# Bitcoin-Lite 

## Introduction

The **Bitcoin-Lite** package is a Python-based, simplified implementation of a cryptocurrency-like transaction system. 
It uses **Cython** for performance optimization, making operations like creating and processing transactions significantly faster. 
This package is ideal for educational purposes, testing blockchain-related ideas, or understanding cryptocurrency principles in a lightweight, 
approachable manner.

## How it works

- **Transaction management**:
  With this package, you shoud be able to
  - create transactions with details such as sender, receiver, and amount.
  - generate transaction summaries quickly using optimized Cython code.

- **Performance optimization**:
  - By using Cython, the package provides enhanced computational efficiency compared to pure Python implementations.
  - `Bitcoin-lite` is intended to be a streamlined framework for understanding and experimenting with blockchain transaction principles 
  through an optimized computational architecture. By using the Cython's static typing and direct C-level operations, 
  `Bitcoin-Lite` achieves significant performance improvements over traditional Python implementations.

- **Easy to use**:
  - `Bitcoin-Lite` is designed for simplicity, allowing users to easily create, process, and interact with transactions.

## Components

### 1. `Transaction` class

The core component of the package is the `Transaction` class. This class provides:

- **Attributes**:
  - `sender`: The individual or entity sending the funds.
  - `receiver`: The individual or entity receiving the funds.
  - `amount`: The amount being transferred.

- **Methods**:
  - `__init__(sender, receiver, amount)`: Initializes a transaction with the specified details.
  - `details()`: Returns a formatted string summarizing the transaction.

## Installation

Some minimum requirements:

- Python ≥ 3.8
- Cython ≥ 3.0.0
- C compiler (gcc/clang/MSVC)

To install the Bitcoin-Lite package, follow these steps:

1. Clone the repository from GitHub:
   ```bash
   git clone git@github.com:danymukesha/bitcoin-lite.git
   cd bitcoin-lite
   ```

2. Install the dependencies using Poetry:
   ```bash
   poetry install
   ```

3. Build the Cython extension:
   ```bash
   poetry run python setup.py build_ext --inplace
   ```

## Testing the `Bitcoin-Lite`

You can test the package functionality using the provided test script:

```bash
poetry run python test_transaction.py
```

This will create a sample transaction and display its details.

### Example usage
Here is a simple example of how to use the `Transaction` class:

```python
from bitcoin_lite import Transaction

# create a transaction
tx = Transaction("Alice", "Bob", 100.0)

# print transaction details
print(tx.details())
```

### Output
```
Transaction from Alice to Bob of amount 100.0
```

## Technical architecture

### Performance optimization
`Bitcoin-Lite` utilizes Cython's static typing capabilities to optimize critical transaction operations:

1. **Memory management**
   - Direct memory allocation for transaction attributes
   - Reduced Python object overhead through C-level data structures
   - Optimized string operations for transaction details

2. **Computational Efficiency**
   - Static typing eliminates dynamic dispatch overhead
   - Direct C-level attribute access without Python dictionary lookups
   - Minimal Python API interaction for core operations

### Implementation Details

#### Transaction Class Architecture
The core `Transaction` class is implemented in Cython with the following specifications:

```python
cdef class Transaction:
    cdef str sender      # Static typing for sender attribute
    cdef str receiver    # Static typing for receiver attribute
    cdef float amount    # Static typing for amount attribute
```

Key characteristics:
- C-level attribute declarations for optimal memory access
- Direct attribute manipulation without Python's attribute dictionary
- Optimized string handling for transaction details

#### Performance Metrics
Preliminary benchmarks show significant performance improvements compared to pure Python implementations:

| Operation | Pure Python (μs) | Bitcoin-Lite (μs) | Improvement |
|-----------|-----------------|-------------------|-------------|
| Creation  | 2.45           | 0.82              | 66.5%       |
| Details   | 1.87           | 0.64              | 65.8%       |

*Note: Benchmarks performed on Python 3.8, results may vary based on system configuration.*

## Scientific applications

### Research use-cases

1. **Transaction analysis**
   - Study of transaction patterns and network behavior
   - Development of new cryptocurrency protocols
   - Performance optimization research

2. **Educational applications**
   - Demonstration of blockchain principles
   - Analysis of transaction system architectures
   - Computational efficiency studies

3. **Protocol development**
   - Testing of new transaction mechanisms
   - Validation of consensus algorithms
   - Performance benchmarking

## Future implementations

### Planned enhancements
1. Implementation of transaction validation mechanisms
2. Addition of cryptographic signing capabilities
3. Integration of merkle tree data structures
4. Development of network simulation capabilities

### Research opportunities
- Performance optimization studies
- Transaction pattern analysis
- Consensus mechanism implementation
- Network behavior simulation

## Contribution

Contributions to the Bitcoin-Lite package are welcome! If you have ideas for additional features, 
optimizations, or examples, feel free to submit a pull request or open an issue in the GitHub repository.

## No license

This package will be open-source and is not under any license (i.e. you can fork it, copy and modify it as you wish).
