astreum 0.1.18__py3-none-any.whl → 0.1.20__py3-none-any.whl

astreum/node/storage/__init__.py

@@ -1,13 +0,0 @@
-"""
-Storage utilities for the Astreum node.
-"""
-
-from .merkle import MerkleTree, MerkleProof, MerkleNode
-from .merkle import find_first, find_all, map, binary_search
-from .storage import Storage
-
-__all__ = [
-    "MerkleTree", "MerkleProof", "MerkleNode", 
-    "find_first", "find_all", "map", "binary_search",
-    "Storage"
-]

astreum/node/storage/merkle.py

@@ -1,7 +1,71 @@
 import blake3
 from .storage import Storage
-import astreum.utils.bytes_format as bytes_format bytes_format.decode, bytes_format.encode
+from astreum.utils import bytes_format
 
+class MerkleNode:
+    def __init__(self, leaf: bool, data: bytes):
+        """
+        Initialize a Merkle node.
+        
+        For a leaf node, `data` is the actual content to be stored.
+        For an internal node, `data` should be the concatenation of the two child hashes.
+        
+        :param leaf: A boolean flag indicating whether this node is a leaf node (True) or an internal node (False).
+        :param data: The node's data. For leaves, the stored data; for internal nodes, concatenated child hashes.
+        """
+        self.leaf = leaf
+        self.data = data
+        self._hash = None  # Cached hash value to avoid recomputation.
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> 'MerkleNode':
+        """
+        Deserialize a MerkleNode from its byte representation.
+        
+        The input bytes are expected to be in the Astreum format, containing a leaf flag and node data.
+        
+        :param data: The serialized node data.
+        :return: A new MerkleNode instance.
+        """
+        leaf_flag, node_data = bytes_format.decode(data)
+        return cls(True if leaf_flag == 1 else False, node_data)
+
+    @classmethod
+    def from_storage(cls, storage: Storage, hash_value: bytes) -> 'MerkleNode' or None:
+        """
+        Retrieve and deserialize a MerkleNode from storage using its hash.
+        
+        :param storage: The Storage instance used to retrieve the node.
+        :param hash_value: The hash key under which the node is stored.
+        :return: A MerkleNode instance if found, otherwise None.
+        """
+        node_bytes = storage.get(hash_value)
+        if node_bytes is None:
+            return None
+        return cls.from_bytes(node_bytes)
+
+    def to_bytes(self) -> bytes:
+        """
+        Serialize the MerkleNode into bytes using the Astreum format.
+        
+        The format encodes a list containing the leaf flag and the node data.
+        
+        :return: The serialized bytes representing the node.
+        """
+        return bytes_format.encode([1 if self.leaf else 0, self.data])
+
+    def hash(self) -> bytes:
+        """
+        Compute (or retrieve a cached) hash of the node using the Blake3 algorithm.
+        
+        For leaf nodes, the hash is computed over the actual data.
+        For internal nodes, the hash is computed over the concatenated child hashes.
+        
+        :return: The Blake3 digest of the node's data.
+        """
+        if self._hash is None:
+            self._hash = blake3.blake3(self.data).digest()
+        return self._hash
 
 
 class MerkleTree:
@@ -158,67 +222,3 @@ class MerkleTree:
             return new_node_hash
 
 
-class MerkleNode:
-    def __init__(self, leaf: bool, data: bytes):
-        """
-        Initialize a Merkle node.
-        
-        For a leaf node, `data` is the actual content to be stored.
-        For an internal node, `data` should be the concatenation of the two child hashes.
-        
-        :param leaf: A boolean flag indicating whether this node is a leaf node (True) or an internal node (False).
-        :param data: The node's data. For leaves, the stored data; for internal nodes, concatenated child hashes.
-        """
-        self.leaf = leaf
-        self.data = data
-        self._hash = None  # Cached hash value to avoid recomputation.
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> 'MerkleNode':
-        """
-        Deserialize a MerkleNode from its byte representation.
-        
-        The input bytes are expected to be in the Astreum format, containing a leaf flag and node data.
-        
-        :param data: The serialized node data.
-        :return: A new MerkleNode instance.
-        """
-        leaf_flag, node_data = bytes_format.decode(data)
-        return cls(True if leaf_flag == 1 else False, node_data)
-
-    @classmethod
-    def from_storage(cls, storage: Storage, hash_value: bytes) -> 'MerkleNode' or None:
-        """
-        Retrieve and deserialize a MerkleNode from storage using its hash.
-        
-        :param storage: The Storage instance used to retrieve the node.
-        :param hash_value: The hash key under which the node is stored.
-        :return: A MerkleNode instance if found, otherwise None.
-        """
-        node_bytes = storage.get(hash_value)
-        if node_bytes is None:
-            return None
-        return cls.from_bytes(node_bytes)
-
-    def to_bytes(self) -> bytes:
-        """
-        Serialize the MerkleNode into bytes using the Astreum format.
-        
-        The format encodes a list containing the leaf flag and the node data.
-        
-        :return: The serialized bytes representing the node.
-        """
-        return bytes_format.encode([1 if self.leaf else 0, self.data])
-
-    def hash(self) -> bytes:
-        """
-        Compute (or retrieve a cached) hash of the node using the Blake3 algorithm.
-        
-        For leaf nodes, the hash is computed over the actual data.
-        For internal nodes, the hash is computed over the concatenated child hashes.
-        
-        :return: The Blake3 digest of the node's data.
-        """
-        if self._hash is None:
-            self._hash = blake3.blake3(self.data).digest()
-        return self._hash

astreum/node/validation/__init__.py

@@ -1,84 +0,0 @@
-"""
-Validation module for the Astreum blockchain.
-
-This module provides functions for validating blocks and transactions,
-computing and verifying VDFs, and selecting validators.
-"""
-
-# Export validation functions
-from .block import (
-    validate_block,
-    create_block,
-    create_genesis_block,
-    select_validator,
-    select_validator_for_slot
-)
-
-# Export VDF functions
-from .vdf import (
-    compute_vdf,
-    verify_vdf,
-    validate_block_vdf
-)
-
-# Export account functions
-from .account import (
-    Account,
-    get_validator_stake,
-    is_validator
-)
-
-# Export constants
-from .constants import (
-    VALIDATION_ADDRESS,
-    BURN_ADDRESS,
-    MIN_STAKE_AMOUNT,
-    SLOT_DURATION,
-    VDF_DIFFICULTY
-)
-
-# Export blockchain state functions
-from .state import (
-    add_block_to_state,
-    validate_and_apply_block,
-    create_account_state,
-    get_validator_for_slot,
-    select_best_chain,
-    compare_chains,
-    get_validator_set
-)
-
-__all__ = [
-    # Block validation
-    'validate_block',
-    'create_block',
-    'create_genesis_block',
-    'select_validator',
-    'select_validator_for_slot',
-    
-    # VDF functions
-    'compute_vdf',
-    'verify_vdf',
-    'validate_block_vdf',
-    
-    # Account functions
-    'Account',
-    'get_validator_stake',
-    'is_validator',
-    
-    # Constants
-    'VALIDATION_ADDRESS',
-    'BURN_ADDRESS',
-    'MIN_STAKE_AMOUNT',
-    'SLOT_DURATION',
-    'VDF_DIFFICULTY',
-    
-    # Blockchain state
-    'add_block_to_state',
-    'validate_and_apply_block',
-    'create_account_state',
-    'get_validator_for_slot',
-    'select_best_chain',
-    'compare_chains',
-    'get_validator_set'
-]

astreum/node/validation/_block/__init__.py

@@ -1,12 +0,0 @@
-"""
-Block validation module for the Astreum blockchain.
-"""
-
-from .model import Block
-from .create import create_block, create_genesis_block
-
-__all__ = [
-    'Block',
-    'create_block',
-    'create_genesis_block',
-]

astreum/node/validation/block.py

@@ -1,29 +1,20 @@
 class Block:
+
+    def __init__(self):
+        pass
+    
     @classmethod
-    def from_bytes(cls, validator) -> 'Block':
+    def from_bytes(cls) -> 'Block':
         """
-        Deserialize an Account from its byte representation.
-        
-        Expected format: [balance, code, counter, data]
-        
-        The public_key (and optional secret_key) must be provided separately.
+        Deserialize a block from its byte representation.
     """
-        decoded = bytes_format.decode(data)
-        balance, code, counter, account_data = decoded
-        return cls(public_key, balance, code, counter, account_data, secret_key=secret_key)
-    
+        return cls()
+
     def to_bytes(self) -> bytes:
         """
-        Serialize the Account into bytes.
-        
-        Format: [balance, code, counter, data]
+        Serialize the block into bytes.
         """
-        return bytes_format.encode([
-            self.balance,
-            self.code,
-            self.counter,
-            self.data
-        ])
+        return b""
 
 class Chain:
     def __init__(self, latest_block: Block):

{astreum-0.1.18.dist-info → astreum-0.1.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.1.18
+Version: 0.1.20
 Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
 Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
 Project-URL: Homepage, https://github.com/astreum/lib

{astreum-0.1.18.dist-info → astreum-0.1.20.dist-info}/RECORD

@@ -21,7 +21,7 @@ astreum/lispeum/special/number/addition.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 astreum/machine/__init__.py,sha256=GOdZl1tS9uIJHbq5WVcplifMDPDLQroX7CVew-K2YbA,15262
 astreum/machine/environment.py,sha256=K0084U6B7wwjrDZ9b2_7cEcbBzsB7UOy_Zpbrr7B3GY,834
 astreum/machine/error.py,sha256=MvqBaZZt33rNELNhUJ2lER3TE3aS8WVqsWF2hz2AwoA,38
-astreum/node/__init__.py,sha256=zY4rD4knr8zPOmXX3eL-VENCQ-SGDccUQlTLEzzQaAA,20073
+astreum/node/__init__.py,sha256=7yz1YHo0DCUgUQvJf75qdUo_ocl5-XZRU-Vc2NhcvJs,18639
 astreum/node/utils.py,sha256=amGhNYHVMjvAO-9vBRAcim-S5LlLSRudqooBN-XPdm4,702
 astreum/node/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/node/crypto/ed25519.py,sha256=FRnvlN0kZlxn4j-sJKl-C9tqiz_0z4LZyXLj3KIj1TQ,1760
@@ -32,27 +32,26 @@ astreum/node/relay/envelope.py,sha256=sDKsIvJruQKLWgWs92sx1mCjMHF7yQVoLguPygw2Pz
 astreum/node/relay/message.py,sha256=uezmGjNaQK4fZmYQLCHd2YpiosaaFb8DOa3H58HS1jA,2887
 astreum/node/relay/peer.py,sha256=DlvTR9j0BZQ1dW-p_9UGgfLvQqwNdpNLMSCYEW4FhyI,5899
 astreum/node/relay/route.py,sha256=fyOSsAe1mfsCVeN6LtQ_OEUEb1FiC5dobZBEJKNGU9U,5814
-astreum/node/storage/__init__.py,sha256=eJL7ILUGKSKDhXZqkn3Rk5TUza39vIcwPwAW_AaIHTk,326
-astreum/node/storage/merkle.py,sha256=sC7gfxPDUBgv3iiFs5PyxPgYbC4CoE-If5TQvkuoTGU,10295
+astreum/node/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/node/storage/merkle.py,sha256=_rt6-jTE9jOGMpj0Ze8kegObfHJ4h-7QJdHJm_a_Di8,10243
 astreum/node/storage/patricia.py,sha256=zP4whShdB7yOFcEPLE1-1PIFfx_LdK8DyMSadnF0KT0,11588
 astreum/node/storage/storage.py,sha256=czJDhRK2rQxjOo88fhZ6j10f55RW8hWp1qq7c4yur6Y,10086
 astreum/node/storage/utils.py,sha256=CxKH9GbW31aVYs2Hwg1SirCykSnH_3_JisEayDrpOvY,5169
-astreum/node/validation/__init__.py,sha256=D9Gmc5x5V5xgXtM32axuDMSzgKiDCz7MiUShNnuFKYc,1636
+astreum/node/validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/node/validation/account.py,sha256=mKbJSi3sfQ5K9a4zwgdyPGqT3gXHekI55yDDVpzcolo,3650
-astreum/node/validation/block.py,sha256=ff4ZvMtIBuoY232SHxtRiwU3J-ku_hQOiqssHhIqbXY,934
+astreum/node/validation/block.py,sha256=KRvlpLZOmgJ3WJaSHsbk7ryh2Z1NsC2z-RWKWh1quBE,444
 astreum/node/validation/constants.py,sha256=ImIdLZFtMKx1iWg60YssEKl2tdDqZQnIa2JaJE6CX0o,422
 astreum/node/validation/stake.py,sha256=Z9EPM-X9c92fpsZIYsdVpvgz4DhxQViPM-RDktWUZq8,7141
-astreum/node/validation/state.py,sha256=QMXY7h4da-o79wMjJW93ixtepyhgcbJEf101yVuZurg,7661
 astreum/node/validation/transaction.py,sha256=Lovx1CWIxL45glFU-LBDxI1argBLxSmDAcg1TteaOlY,4701
 astreum/node/validation/vdf.py,sha256=HDdnqn9O_LicfE7SNCmncawKoR-ojLyjlpn74OvRNOU,2194
-astreum/node/validation/_block/__init__.py,sha256=n2HaMG_5cpa7y5xko-c7vbHz8rL-1wAGthmr8boNrCs,216
+astreum/node/validation/_block/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/node/validation/_block/create.py,sha256=apD9h92b9Y146zeppSzKNk_NJPgyBy7FhxoEkypQQNk,2515
 astreum/node/validation/_block/model.py,sha256=d7x3_tX2MPLnGODL_5_vNjQfLdYa405blc-zL9o8HFA,2589
 astreum/node/validation/_block/validate.py,sha256=niLexCNhEwUJLclyrdNZSvHcVa_J6jlu7J3FiWY7XBU,6232
 astreum/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/utils/bytes_format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
-astreum-0.1.18.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.1.18.dist-info/METADATA,sha256=k1Eptg-mbsR5Ddo2ky6JCIgkKlXO0WqovKe5zKDSZ3c,3312
-astreum-0.1.18.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-astreum-0.1.18.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.1.18.dist-info/RECORD,,
+astreum-0.1.20.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.1.20.dist-info/METADATA,sha256=Br2J_FPsK6l8w7Af-CpsOcOn1yXDX7FV7BePSOXYJCQ,3312
+astreum-0.1.20.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
+astreum-0.1.20.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.1.20.dist-info/RECORD,,

{astreum-0.1.18.dist-info → astreum-0.1.20.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

astreum/node/validation/state.py

@@ -1,230 +0,0 @@
-"""
-Blockchain state management.
-
-This module manages the blockchain state, including accounts, blocks, and
-transactions.
-"""
-
-import time
-from typing import Dict, List, Optional, Set, Any
-from dataclasses import dataclass, field
-from ..utils import hash_data
-from ..models import Block, Transaction, Account as ModelAccount
-from .account import Account
-from .constants import VALIDATION_ADDRESS, BURN_ADDRESS, MIN_STAKE_AMOUNT
-
-
-class BlockchainState:
-    """
-    Manages the state of the blockchain.
-    
-    This class tracks the current state of accounts, blocks, and transactions,
-    and provides methods to update the state with new blocks and transactions.
-    """
-    
-    def __init__(self, config: Optional[dict] = None):
-        """
-        Initialize blockchain state.
-        
-        Args:
-            config: Optional configuration
-        """
-        self.config = config or {}
-        
-        # Dictionaries to track blockchain state
-        self.accounts = {}  # address -> Account
-        self.blocks = {}  # hash -> Block
-        self.transactions = {}  # hash -> Transaction
-        
-        # Track the latest block
-        self.latest_block = None
-        
-        # Pending transactions
-        self.pending_transactions = set()  # Set of transaction hashes
-        
-        # State of validators and stakes
-        self.validators = {}  # address -> stake amount
-        
-        # Initialize the genesis block if not provided
-        if not self.latest_block:
-            self._initialize_genesis()
-    
-    def _initialize_genesis(self):
-        """Initialize the genesis block and state."""
-        # In a full implementation, this would initialize the genesis
-        # block and state from configuration
-        print("Initializing genesis block and state")
-    
-    def add_block(self, block: Block) -> bool:
-        """
-        Add a block to the blockchain state.
-        
-        Args:
-            block: Block to add
-            
-        Returns:
-            True if block was added successfully, False otherwise
-        """
-        # Convert block to validation format directly
-        validation_block = {
-            'number': block.number,
-            'timestamp': block.time,
-            'producer': block.validator.public_key if block.validator else b'',
-            'previous': block.previous.get_hash() if block.previous else b'',
-            'transactions': self._extract_transactions(block),
-            'vdf_proof': block.signature[:8],  # Use part of signature as VDF proof for demo
-            'signature': block.signature
-        }
-        
-        # Check for duplicate (already processed) blocks
-        block_hash = block.get_hash()
-        if block_hash in self.blocks:
-            print(f"Block {block_hash.hex()} already in blockchain")
-            return True
-        
-        # Convert block's accounts to validation accounts
-        account_dict = {}
-        # Here we would deserialize the accounts data from the block
-        # In a real implementation, this would reconstruct accounts from serialized data
-        
-        # For now, we'll just log that we would process the block
-        print(f"Processing block at height {block.number}")
-        
-        # Add the block to our state
-        self.blocks[block_hash] = block
-        
-        # Update latest block if this is a new latest block
-        if not self.latest_block or block.number > self.latest_block.number:
-            self.latest_block = block
-        
-        # Process transactions in the block
-        # This would update account states, apply transaction effects, etc.
-        
-        return True
-    
-    def _extract_transactions(self, block: Block) -> List[dict]:
-        """
-        Extract transactions from a block.
-        
-        Args:
-            block: The model Block instance
-            
-        Returns:
-            List of transactions in validation format
-        """
-        transactions = []
-        # Parse transaction data from the block
-        # In a real implementation, this would deserialize the transactions field
-        # For now, we'll return an empty list as a placeholder
-        return transactions
-    
-    def add_transaction(self, transaction: Transaction) -> bool:
-        """
-        Add a transaction to the pending set.
-        
-        Args:
-            transaction: Transaction to add
-            
-        Returns:
-            True if transaction was added successfully, False otherwise
-        """
-        # Convert transaction to validation format directly
-        validation_tx = {
-            'sender': transaction.sender.public_key if transaction.sender else b'',
-            'recipient': transaction.receipient.public_key if transaction.receipient else b'',
-            'amount': transaction.amount,
-            'counter': transaction.counter,
-            'data': transaction.data,
-            'signature': transaction.signature
-        }
-        
-        # Generate a transaction hash
-        tx_hash = hash_data(str(validation_tx).encode())
-        
-        # Check for duplicate transactions
-        if tx_hash in self.transactions or tx_hash in self.pending_transactions:
-            print(f"Transaction {tx_hash.hex()} already processed or pending")
-            return False
-        
-        # Validate the transaction
-        # In a real implementation, this would check signature, sender balance, etc.
-        
-        # Add to pending transactions
-        self.pending_transactions.add(tx_hash)
-        
-        return True
-    
-    def is_staking_transaction(self, tx: Transaction) -> bool:
-        """
-        Check if a transaction is a staking transaction.
-        
-        Args:
-            tx: The model Transaction instance
-            
-        Returns:
-            True if this is a staking transaction, False otherwise
-        """
-        # A transaction is a staking transaction if it's sending to the validation address
-        if tx.receipient and hasattr(tx.receipient, 'public_key'):
-            return tx.receipient.public_key == VALIDATION_ADDRESS
-        return False
-    
-    def get_account(self, address: bytes) -> Optional[Account]:
-        """
-        Get an account by address.
-        
-        Args:
-            address: Account address
-            
-        Returns:
-            Account if found, None otherwise
-        """
-        return self.accounts.get(address)
-    
-    def get_validator_stake(self, address: bytes) -> int:
-        """
-        Get the stake of a validator.
-        
-        Args:
-            address: Validator address
-            
-        Returns:
-            Stake amount (0 if not a validator)
-        """
-        return self.validators.get(address, 0)
-    
-    def is_validator(self, address: bytes) -> bool:
-        """
-        Check if an address is a validator.
-        
-        Args:
-            address: Address to check
-            
-        Returns:
-            True if address is a validator, False otherwise
-        """
-        return self.get_validator_stake(address) >= MIN_STAKE_AMOUNT
-    
-    def get_pending_transactions(self) -> List[Transaction]:
-        """
-        Get all pending transactions.
-        
-        Returns:
-            List of pending transactions
-        """
-        # In a real implementation, this would return the actual transaction objects
-        # For now, we'll just return an empty list
-        return []
-
-
-def create_blockchain(config: Optional[dict] = None) -> BlockchainState:
-    """
-    Create a new blockchain state.
-    
-    Args:
-        config: Optional configuration
-        
-    Returns:
-        New BlockchainState instance
-    """
-    return BlockchainState(config)