# Bitcoin-Lite [](https://pypi.org/project/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 to more applied applications
### 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
## Mathematical models and foundation of `Bitcoin-Lite` transaction system
### 1. Transaction model
#### 1.1 Basic transaction representation
A transaction `T` can be represented as a tuple:
```
T = (s, r, a, t)
```
where:
- s ∈ A (sender address space)
- r ∈ A (receiver address space)
- a ∈ ℝ+ (positive real numbers for amount)
- t ∈ ℤ+ (timestamp in epoch)
#### 1.2 Balance calculation
For any address `x`, the balance `B(x)` at time `t` is defined as:
```math
B(x,t) = ∑[T∈L | T.r=x] T.a - ∑[T∈L | T.s=x] T.a
```
where `L` is the set of all confirmed transactions in the ledger before time t.
#### 1.3 Transaction validity function
A transaction validity function `V(T)` is defined as:
```math
V(T) = {
1, if B(T.s,T.t) ≥ T.a
0, otherwise
}
```
### 2. Performance analysis
#### 2.1 Time complexity
The time complexity for key operations:
1. Transaction Creation: O(1)
2. Balance Calculation: O(n), where `n` is the number of transactions
3. Transaction Validation: O(n)
#### 2.2 Space Complexity
The space complexity `S(n)` for n transactions:
```math
S(n) = St + n(Ss + Sr + Sa + Sh)
```
where:
- St: Transaction overhead
- Ss: Sender address size
- Sr: Receiver address size
- Sa: Amount size
- Sh: Hash size
### 3. Optimization metrics
#### 3.1 Performance ratio
The performance ratio `R` comparing Cython implementation to pure Python:
```math
R = Tp/Tc
```
where:
- Tp: Execution time in pure Python
- Tc: Execution time in Cython
#### 3.2 Memory efficiency
Memory efficiency `E` is calculated as:
```math
E = (Mp - Mc)/Mp * 100%
```
where:
- Mp: Memory usage in pure Python
- Mc: Memory usage in Cython
### 4. Statistical analysis
#### 4.1 Transaction distribution
For `n` transactions, the probability density function `f(x)` of transaction amounts:
```math
f(x) = (1/nσ√(2π)) * e^(-(x-μ)²/2σ²)
```
where:
- μ: Mean transaction amount
- σ: Standard deviation of amounts
#### 4.2 Network load model
The network load `L(t)` at time `t`:
```math
L(t) = λ + ∑(i=1 to n) αᵢe^(-β(t-tᵢ))
```
where:
- λ: Base load
- α: Transaction weight
- β: Decay factor
- tᵢ: Transaction time
### 5. Implementation examples
#### 5.1 Balance calculation implementation
```python
def calculate_balance(address, transactions):
received = sum(t.amount for t in transactions if t.receiver == address)
sent = sum(t.amount for t in transactions if t.sender == address)
return received - sent
```
#### 5.2 Transaction validation
```python
def validate_transaction(transaction, ledger):
sender_balance = calculate_balance(transaction.sender, ledger)
return sender_balance >= transaction.amount
```
### 6. Practical applications
#### 6.1 Load testing formula
System capacity C can be calculated as:
```math
C = min(Ct, Cm, Cn)
```
where:
- Ct: Transaction processing capacity
- Cm: Memory capacity
- Cn: Network capacity
#### 6.2 Throughput analysis
Maximum throughput T:
```math
T = min(1/tp, 1/tv, 1/ts)
```
where:
- tp: Processing time
- tv: Validation time
- ts: Storage time
### 7. Benchmarking results
#### 7.1 Performance metrics
| Operation | Time Complexity | Space Complexity | Cython Speedup |
|--------------|----------------|------------------|----------------|
| Creation | O(1) | O(1) | 3.12x |
| Validation | O(n) | O(1) | 2.85x |
| Balance Check| O(n) | O(1) | 2.96x |
#### 7.2 Memory usage
```math
M(n) = 128 + 64n bytes (Cython)
M(n) = 256 + 96n bytes (Python)
```
where n is the number of transactions.
### 8. Examples usage with mathematical context
Step-by-step usage example:
```python
from bitcoin_lite import Transaction
# we initialize with theoretical capacity C
C = min(1000, # tx/s
available_memory/transaction_size,
network_bandwidth/transaction_size)
# then create transaction with amount a
a = 100.0 # units
tx = Transaction("Alice", "Bob", a)
# now we validate against balance B
B = tx.get_sender_balance()
assert B >= a, "Insufficient balance"
# in the end, we execute with timestamp t
t = current_time()
tx_id = tx.execute()
```
Streamed transaction:
```python
if __name__ == "__main__":
from database import TransactionDatabase
# initialize analytics
db = TransactionDatabase()
analytics = TransactionAnalytics(db)
# Calc. metrics
metrics = analytics.calculate_network_metrics()
print(f"""
Network metrics:
---------------
Mean transaction amount: {metrics.mean_amount:.2f}
Standard deviation: {metrics.std_dev:.2f}
Transaction density: {metrics.transaction_density:.4f}
Network load: {metrics.network_load:.2f}
System capacity: {metrics.system_capacity:.2f} tx/s
""")
```
Dashboard example for analystical aspects of the transaction system:
```python
if __name__ == "__main__":
from database import TransactionDatabase
# init. database and data generator
db = TransactionDatabase()
generator = AnalyticsDataGenerator(db)
# generate and print dashboard data
dashboard_data = generator.generate_dashboard_data()
print(dashboard_data)
const dashboardData = JSON.parse(data);
<Analytics data={dashboardData} />
```
### 9. Potential improvements
1. Implementation of advanced statistical models for transaction analysis
2. Development of predictive algorithms for load balancing
3. Integration of machine learning for anomaly detection
4. Enhancement of performance metrics and benchmarking methodologies
### Sum-up
The demonstration and models presented above here can be used for:
1. System optimization
2. Performance prediction
3. Capacity planning
4. Security analysis
5. Scalability assessment
The models can even be extended for more complex scenarios and integrated with
additional cryptocurrency features as needed.
## 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).
Raw data
{
"_id": null,
"home_page": "https://github.com/danymukesha/bitcoin-lite",
"name": "bitcoin-lite",
"maintainer": null,
"docs_url": null,
"requires_python": "<4.0,>=3.10",
"maintainer_email": null,
"keywords": "bitcoin-lite, blockchain, danymukesha",
"author": "Dany Mukesha",
"author_email": "danymukesha@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/f3/06/127de5213de38c99c28df87e0a61c5e2ee51579f2361988d0beb78d42cf0/bitcoin-lite-0.1.5.tar.gz",
"platform": null,
"description": "# Bitcoin-Lite [](https://pypi.org/project/bitcoin-lite/)\n\n## Introduction\n\nThe **Bitcoin-Lite** package is a Python-based, simplified implementation of a cryptocurrency-like transaction system. \nIt uses **Cython** for performance optimization, making operations like creating and processing transactions significantly faster. \nThis package is ideal for educational purposes, testing blockchain-related ideas, or understanding cryptocurrency principles in a lightweight, \napproachable manner.\n\n## How it works\n\n- **Transaction management**:\n With this package, you shoud be able to\n - create transactions with details such as sender, receiver, and amount.\n - generate transaction summaries quickly using optimized Cython code.\n\n- **Performance optimization**:\n - By using Cython, the package provides enhanced computational efficiency compared to pure Python implementations.\n - `Bitcoin-lite` is intended to be a streamlined framework for understanding and experimenting with blockchain transaction principles \n through an optimized computational architecture. By using the Cython's static typing and direct C-level operations, \n `Bitcoin-Lite` achieves significant performance improvements over traditional Python implementations.\n\n- **Easy to use**:\n - `Bitcoin-Lite` is designed for simplicity, allowing users to easily create, process, and interact with transactions.\n\n## Components\n\n### 1. `Transaction` class\n\nThe core component of the package is the `Transaction` class. This class provides:\n\n- **Attributes**:\n - `sender`: The individual or entity sending the funds.\n - `receiver`: The individual or entity receiving the funds.\n - `amount`: The amount being transferred.\n\n- **Methods**:\n - `__init__(sender, receiver, amount)`: Initializes a transaction with the specified details.\n - `details()`: Returns a formatted string summarizing the transaction.\n\n## Installation\n\nSome minimum requirements:\n\n- Python \u2265 3.8\n- Cython \u2265 3.0.0\n- C compiler (gcc/clang/MSVC)\n\nTo install the Bitcoin-Lite package, follow these steps:\n\n1. Clone the repository from GitHub:\n ```bash\n git clone git@github.com:danymukesha/bitcoin-lite.git\n cd bitcoin-lite\n ```\n\n2. Install the dependencies using Poetry:\n ```bash\n poetry install\n ```\n\n3. Build the Cython extension:\n ```bash\n poetry run python setup.py build_ext --inplace\n ```\n\n## Testing the `Bitcoin-Lite`\n\nYou can test the package functionality using the provided test script:\n\n```bash\npoetry run python test_transaction.py\n```\n\nThis will create a sample transaction and display its details.\n\n### Example usage\nHere is a simple example of how to use the `Transaction` class:\n\n```python\nfrom bitcoin_lite import Transaction\n\n# create a transaction\ntx = Transaction(\"Alice\", \"Bob\", 100.0)\n\n# print transaction details\nprint(tx.details())\n```\n\n### Output\n```\nTransaction from Alice to Bob of amount 100.0\n```\n\n## Technical architecture\n\n### Performance optimization\n`Bitcoin-Lite` utilizes Cython's static typing capabilities to optimize critical transaction operations:\n\n1. **Memory management**\n - Direct memory allocation for transaction attributes\n - Reduced Python object overhead through C-level data structures\n - Optimized string operations for transaction details\n\n2. **Computational efficiency**\n - Static typing eliminates dynamic dispatch overhead\n - Direct C-level attribute access without Python dictionary lookups\n - Minimal Python API interaction for core operations\n\n### Implementation details\n\n#### Transaction class architecture\nThe core `Transaction` class is implemented in Cython with the following specifications:\n\n```python\ncdef class Transaction:\n cdef str sender # Static typing for sender attribute\n cdef str receiver # Static typing for receiver attribute\n cdef float amount # Static typing for amount attribute\n```\n\nKey characteristics:\n- C-level attribute declarations for optimal memory access\n- Direct attribute manipulation without Python's attribute dictionary\n- Optimized string handling for transaction details\n\n#### Performance metrics\nPreliminary benchmarks show significant performance improvements compared to pure Python implementations:\n\n| Operation | Pure Python (\u03bcs) | Bitcoin-Lite (\u03bcs) | Improvement |\n|-----------|-----------------|-------------------|-------------|\n| Creation | 2.45 | 0.82 | 66.5% |\n| Details | 1.87 | 0.64 | 65.8% |\n\n*Note: Benchmarks performed on Python 3.8, results may vary based on system configuration.*\n\n## Scientific applications\n\n### Research use-cases\n\n1. **Transaction analysis**\n - Study of transaction patterns and network behavior\n - Development of new cryptocurrency protocols\n - Performance optimization research\n\n2. **Educational applications**\n - Demonstration of blockchain principles\n - Analysis of transaction system architectures\n - Computational efficiency studies\n\n3. **Protocol development**\n - Testing of new transaction mechanisms\n - Validation of consensus algorithms\n - Performance benchmarking\n\n## Future implementations to more applied applications\n\n### Planned enhancements\n1. Implementation of transaction validation mechanisms\n2. Addition of cryptographic signing capabilities\n3. Integration of merkle tree data structures\n4. Development of network simulation capabilities\n\n### Research opportunities\n- Performance optimization studies\n- Transaction pattern analysis\n- Consensus mechanism implementation\n- Network behavior simulation\n\n## Mathematical models and foundation of `Bitcoin-Lite` transaction system\n\n### 1. Transaction model\n\n#### 1.1 Basic transaction representation\nA transaction `T` can be represented as a tuple:\n```\nT = (s, r, a, t)\n```\nwhere:\n- s \u2208 A (sender address space)\n- r \u2208 A (receiver address space)\n- a \u2208 \u211d+ (positive real numbers for amount)\n- t \u2208 \u2124+ (timestamp in epoch)\n\n#### 1.2 Balance calculation\nFor any address `x`, the balance `B(x)` at time `t` is defined as:\n\n```math\nB(x,t) = \u2211[T\u2208L | T.r=x] T.a - \u2211[T\u2208L | T.s=x] T.a\n```\n\nwhere `L` is the set of all confirmed transactions in the ledger before time t.\n\n#### 1.3 Transaction validity function\nA transaction validity function `V(T)` is defined as:\n\n```math\nV(T) = {\n 1, if B(T.s,T.t) \u2265 T.a\n 0, otherwise\n}\n```\n\n### 2. Performance analysis\n\n#### 2.1 Time complexity\nThe time complexity for key operations:\n\n1. Transaction Creation: O(1)\n2. Balance Calculation: O(n), where `n` is the number of transactions\n3. Transaction Validation: O(n)\n\n#### 2.2 Space Complexity\nThe space complexity `S(n)` for n transactions:\n\n```math\nS(n) = St + n(Ss + Sr + Sa + Sh)\n```\nwhere:\n- St: Transaction overhead\n- Ss: Sender address size\n- Sr: Receiver address size\n- Sa: Amount size\n- Sh: Hash size\n\n### 3. Optimization metrics\n\n#### 3.1 Performance ratio\nThe performance ratio `R` comparing Cython implementation to pure Python:\n\n```math\nR = Tp/Tc\n```\nwhere:\n- Tp: Execution time in pure Python\n- Tc: Execution time in Cython\n\n#### 3.2 Memory efficiency\nMemory efficiency `E` is calculated as:\n\n```math\nE = (Mp - Mc)/Mp * 100%\n```\nwhere:\n- Mp: Memory usage in pure Python\n- Mc: Memory usage in Cython\n\n### 4. Statistical analysis\n\n#### 4.1 Transaction distribution\nFor `n` transactions, the probability density function `f(x)` of transaction amounts:\n\n```math\nf(x) = (1/n\u03c3\u221a(2\u03c0)) * e^(-(x-\u03bc)\u00b2/2\u03c3\u00b2)\n```\nwhere:\n- \u03bc: Mean transaction amount\n- \u03c3: Standard deviation of amounts\n\n#### 4.2 Network load model\nThe network load `L(t)` at time `t`:\n\n```math\nL(t) = \u03bb + \u2211(i=1 to n) \u03b1\u1d62e^(-\u03b2(t-t\u1d62))\n```\nwhere:\n- \u03bb: Base load\n- \u03b1: Transaction weight\n- \u03b2: Decay factor\n- t\u1d62: Transaction time\n\n### 5. Implementation examples\n\n#### 5.1 Balance calculation implementation\n```python\ndef calculate_balance(address, transactions):\n received = sum(t.amount for t in transactions if t.receiver == address)\n sent = sum(t.amount for t in transactions if t.sender == address)\n return received - sent\n```\n\n#### 5.2 Transaction validation\n```python\ndef validate_transaction(transaction, ledger):\n sender_balance = calculate_balance(transaction.sender, ledger)\n return sender_balance >= transaction.amount\n```\n\n### 6. Practical applications\n\n#### 6.1 Load testing formula\nSystem capacity C can be calculated as:\n\n```math\nC = min(Ct, Cm, Cn)\n```\nwhere:\n- Ct: Transaction processing capacity\n- Cm: Memory capacity\n- Cn: Network capacity\n\n#### 6.2 Throughput analysis\nMaximum throughput T:\n\n```math\nT = min(1/tp, 1/tv, 1/ts)\n```\nwhere:\n- tp: Processing time\n- tv: Validation time\n- ts: Storage time\n\n### 7. Benchmarking results\n\n#### 7.1 Performance metrics\n| Operation | Time Complexity | Space Complexity | Cython Speedup |\n|--------------|----------------|------------------|----------------|\n| Creation | O(1) | O(1) | 3.12x |\n| Validation | O(n) | O(1) | 2.85x |\n| Balance Check| O(n) | O(1) | 2.96x |\n\n#### 7.2 Memory usage\n```math\nM(n) = 128 + 64n bytes (Cython)\nM(n) = 256 + 96n bytes (Python)\n```\nwhere n is the number of transactions.\n\n### 8. Examples usage with mathematical context\n\nStep-by-step usage example:\n\n```python\nfrom bitcoin_lite import Transaction\n\n# we initialize with theoretical capacity C\nC = min(1000, # tx/s\n available_memory/transaction_size,\n network_bandwidth/transaction_size)\n\n# then create transaction with amount a\na = 100.0 # units\ntx = Transaction(\"Alice\", \"Bob\", a)\n\n# now we validate against balance B\nB = tx.get_sender_balance()\nassert B >= a, \"Insufficient balance\"\n\n# in the end, we execute with timestamp t\nt = current_time()\ntx_id = tx.execute()\n```\n\nStreamed transaction:\n\n```python\nif __name__ == \"__main__\":\n from database import TransactionDatabase\n \n # initialize analytics\n db = TransactionDatabase()\n analytics = TransactionAnalytics(db)\n \n # Calc. metrics\n metrics = analytics.calculate_network_metrics()\n print(f\"\"\"\n Network metrics:\n ---------------\n Mean transaction amount: {metrics.mean_amount:.2f}\n Standard deviation: {metrics.std_dev:.2f}\n Transaction density: {metrics.transaction_density:.4f}\n Network load: {metrics.network_load:.2f}\n System capacity: {metrics.system_capacity:.2f} tx/s\n \"\"\")\n\n```\n\nDashboard example for analystical aspects of the transaction system:\n\n```python\nif __name__ == \"__main__\":\n from database import TransactionDatabase\n \n # init. database and data generator\n db = TransactionDatabase()\n generator = AnalyticsDataGenerator(db)\n \n # generate and print dashboard data\n dashboard_data = generator.generate_dashboard_data()\n print(dashboard_data)\n\n const dashboardData = JSON.parse(data);\n <Analytics data={dashboardData} />\n```\n\n\n### 9. Potential improvements\n\n1. Implementation of advanced statistical models for transaction analysis\n2. Development of predictive algorithms for load balancing\n3. Integration of machine learning for anomaly detection\n4. Enhancement of performance metrics and benchmarking methodologies\n\n### Sum-up\n\nThe demonstration and models presented above here can be used for:\n\n1. System optimization\n2. Performance prediction\n3. Capacity planning\n4. Security analysis\n5. Scalability assessment\n\nThe models can even be extended for more complex scenarios and integrated with \nadditional cryptocurrency features as needed.\n\n## Contribution\n\nContributions to the Bitcoin-Lite package are welcome! If you have ideas for additional features, \noptimizations, or examples, feel free to submit a pull request or open an issue in the GitHub repository.\n\n## No license\n\nThis package will be open-source and is not under any license (i.e. you can fork it, copy and modify it as you wish).\n\n\n",
"bugtrack_url": null,
"license": null,
"summary": "A lightweight Bitcoin transaction system using Cython",
"version": "0.1.5",
"project_urls": {
"Homepage": "https://github.com/danymukesha/bitcoin-lite"
},
"split_keywords": [
"bitcoin-lite",
" blockchain",
" danymukesha"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "f68076781e8d19d5d7944267b2f84dfa8260cc8ae8b0e1a9b77adf68aa6e029e",
"md5": "55fbc1bdee780352e6825ec0892547e1",
"sha256": "d53d6f8e27dbd5365f8e8bcd362a6e3d8847d3445fabab097e44b1df0d648dcb"
},
"downloads": -1,
"filename": "bitcoin_lite-0.1.5-py3-none-any.whl",
"has_sig": false,
"md5_digest": "55fbc1bdee780352e6825ec0892547e1",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": "<4.0,>=3.10",
"size": 11993,
"upload_time": "2024-12-04T04:51:56",
"upload_time_iso_8601": "2024-12-04T04:51:56.612774Z",
"url": "https://files.pythonhosted.org/packages/f6/80/76781e8d19d5d7944267b2f84dfa8260cc8ae8b0e1a9b77adf68aa6e029e/bitcoin_lite-0.1.5-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "f306127de5213de38c99c28df87e0a61c5e2ee51579f2361988d0beb78d42cf0",
"md5": "96807baea48263d86cb920939543b4de",
"sha256": "080f105d4af55e02680a480682be0f02e3562fd7df1eb7bef965991a2c86e4d4"
},
"downloads": -1,
"filename": "bitcoin-lite-0.1.5.tar.gz",
"has_sig": false,
"md5_digest": "96807baea48263d86cb920939543b4de",
"packagetype": "sdist",
"python_version": "source",
"requires_python": "<4.0,>=3.10",
"size": 16147,
"upload_time": "2024-12-04T04:51:54",
"upload_time_iso_8601": "2024-12-04T04:51:54.124105Z",
"url": "https://files.pythonhosted.org/packages/f3/06/127de5213de38c99c28df87e0a61c5e2ee51579f2361988d0beb78d42cf0/bitcoin-lite-0.1.5.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-12-04 04:51:54",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "danymukesha",
"github_project": "bitcoin-lite",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "bitcoin-lite"
}
JSON
