astreum 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

astreum/_node/validation/_block/model.py

@@ -1,81 +0,0 @@
-"""
-Block model for the Astreum blockchain.
-"""
-
-import time
-import threading
-from typing import Dict, List, Optional, Tuple, Set
-from dataclasses import dataclass, field
-
-from ...node.storage.merkle import MerkleTree
-from ...utils import hash_data
-
-class Block:
-    def __init__(self, number, validator, previous, transactions, timestamp, vdf, signature, proof, receipts, data, delay, difficulty, accounts=None, chain=None):
-        self.accounts = accounts
-        self.chain = chain
-        self.data = data
-        self.delay = delay
-        self.difficulty = difficulty
-        self.number = number
-        self.validator = validator
-        self.vdf = vdf
-        self.previous = previous
-        self.transactions = transactions
-        self.timestamp = timestamp
-        self.signature = signature
-        self.proof = proof
-        self.receipts = receipts
-
-    def get_details_hash(self):
-        detail_fields = [
-            'accounts',
-            'chain',
-            'data',
-            'delay',
-            'difficulty',
-            'number',
-            'previous',
-            'proof',
-            'receipts',
-            'timestamp',
-            'transactions',
-            'validator',
-            'vdf',
-        ]
-
-        # Prepare serialized entries in the exact order of detail_fields
-        serialized_entries = []
-        for field in detail_fields:
-            value = getattr(self, field, None)  # Use None if attribute doesn't exist
-            
-            # Convert value to bytes directly based on type
-            if isinstance(value, (bytes, bytearray)):
-                # Already bytes, use as is
-                entry = value
-            elif isinstance(value, (int, float)):
-                # Convert numbers to bytes
-                entry = str(value).encode('utf-8')
-            elif isinstance(value, str):
-                # Convert strings to bytes
-                entry = value.encode('utf-8')
-            elif value is None:
-                # Handle None values
-                entry = b''
-            else:
-                # For complex types, use their string representation
-                entry = str(value).encode('utf-8')
-                
-            serialized_entries.append(entry)
-        
-        # Use MerkleTree from storage module
-        merkle_tree = MerkleTree()
-        merkle_tree.add(serialized_entries)
-        
-        return merkle_tree.get_root_hash()
-
-
-    def get_hash(self):
-        merkle_tree = MerkleTree()
-        merkle_tree.add([self.get_details_hash(), self.signature])
-        return merkle_tree.get_root_hash()

astreum/_node/validation/_block/validate.py

@@ -1,196 +0,0 @@
-# Cached verified blocks
-verified_blocks = set()
-
-def validate_block(block: Block, accounts: Dict[bytes, Account], 
-                 known_blocks: Dict[bytes, Block]) -> bool:
-    """
-    Validate a block.
-    
-    Args:
-        block: Block to validate
-        accounts: Dictionary of accounts
-        known_blocks: Dictionary of known blocks
-        
-    Returns:
-        True if block is valid, False otherwise
-    """
-    # Skip validation if already verified
-    block_hash = block.get_hash()
-    if block_hash in verified_blocks:
-        return True
-        
-    # Check block structure
-    if not _validate_block_structure(block):
-        return False
-        
-    # Check if previous block exists, except for genesis block
-    if block.number > 0 and block.previous not in known_blocks:
-        return False
-        
-    # Check if validator is a validator
-    if not _is_valid_producer(block, accounts):
-        return False
-        
-    # Validate VDF proof
-    if not _validate_vdf_proof(block):
-        return False
-        
-    # Validate transactions
-    if not _validate_transactions(block, accounts):
-        return False
-        
-    # All checks passed, mark as verified
-    verified_blocks.add(block_hash)
-    return True
-
-def _validate_block_structure(block: Block) -> bool:
-    """
-    Validate basic block structure.
-    
-    Args:
-        block: Block to validate
-        
-    Returns:
-        True if structure is valid, False otherwise
-    """
-    # Check for required fields
-    if (block.number is None or block.time is None or 
-        not hasattr(block, 'validator') or not block.validator):
-        return False
-        
-    # Check that genesis block has no previous
-    if block.number == 0 and block.previous is not None:
-        return False
-        
-    # Check that non-genesis block has previous
-    if block.number > 0 and block.previous is None:
-        return False
-        
-    # Check timestamp is reasonable
-    current_time = int(time.time())
-    if block.time > current_time + 60:  # Allow 1 minute clock drift
-        return False
-        
-    return True
-
-def _is_valid_producer(block: Block, accounts: Dict[bytes, Account]) -> bool:
-    """
-    Check if block validator is a valid validator.
-    
-    Args:
-        block: Block to validate
-        accounts: Dictionary of accounts
-        
-    Returns:
-        True if validator is valid, False otherwise
-    """
-    # Anyone can produce the genesis block
-    if block.number == 0:
-        return True
-        
-    # Check if validator is a validator with stake
-    if not block.validator or not hasattr(block.validator, 'public_key'):
-        return False
-        
-    validator_address = block.validator.public_key
-    stake = get_validator_stake(accounts, validator_address)
-    return stake >= MIN_STAKE_AMOUNT
-
-def _validate_vdf_proof(block: Block) -> bool:
-    """
-    Validate the VDF proof in the block.
-    
-    Args:
-        block: Block to validate
-        
-    Returns:
-        True if VDF proof is valid, False otherwise
-    """
-    # Skip VDF validation for genesis block
-    if block.number == 0:
-        return True
-        
-    # In a real implementation, this would verify the VDF proof
-    # For our purposes, we'll assume all blocks have valid VDF proofs
-    if not block.vdf_proof:
-        return False
-        
-    return validate_block_vdf(block.number, block.previous, block.vdf_proof)
-
-def _validate_transactions(block: Block, accounts: Dict[bytes, Account]) -> bool:
-    """
-    Validate transactions in a block.
-    
-    Args:
-        block: Block to validate
-        accounts: Dictionary of accounts
-        
-    Returns:
-        True if all transactions are valid, False otherwise
-    """
-    # In a real implementation, this would verify each transaction
-    # For our purposes, we'll assume all transactions in a block are valid
-    return True
-
-def select_validator(accounts: Dict[bytes, Account], random_seed: bytes) -> Optional[bytes]:
-    """
-    Select a validator based on stake using a random seed.
-    
-    Args:
-        accounts: Dictionary of accounts
-        random_seed: Random seed for selection
-        
-    Returns:
-        Selected validator address or None if no validators
-    """
-    # Get validators (accounts with stake)
-    validators = {addr: acc for addr, acc in accounts.items() 
-                 if get_validator_stake(accounts, addr) >= MIN_STAKE_AMOUNT}
-    
-    # Calculate total stake
-    total_stake = sum(get_validator_stake(accounts, addr) for addr in validators)
-    
-    if total_stake <= 0:
-        return None
-        
-    # Convert random seed to a number between 0 and total_stake
-    seed_hash = hash_data(random_seed)
-    random_value = int.from_bytes(seed_hash, byteorder='big') % total_stake
-    
-    # Build cumulative stake mapping
-    cumulative_stake = 0
-    stake_map = {}
-    
-    # Sort validators by address for determinism
-    for addr in sorted(validators.keys()):
-        cumulative_stake += get_validator_stake(accounts, addr)
-        stake_map[addr] = cumulative_stake
-        
-    # Find the validator whose cumulative stake covers the random value
-    for addr, cum_stake in stake_map.items():
-        if random_value < cum_stake:
-            return addr
-            
-    # If no validator found (should not happen), return the last one
-    if stake_map:
-        return list(stake_map.keys())[-1]
-    return None
-
-def select_validator_for_slot(accounts: Dict[bytes, Account], slot: int, 
-                             previous_vdf: bytes) -> Optional[bytes]:
-    """
-    Select validator for a specific slot.
-    
-    Args:
-        accounts: Dictionary of accounts
-        slot: Slot number
-        previous_vdf: VDF output from previous block
-        
-    Returns:
-        Selected validator address or None if no validators
-    """
-    # Generate random seed based on slot and previous VDF
-    seed = hash_data(previous_vdf + slot.to_bytes(8, byteorder='big'))
-    
-    # Select validator based on stake
-    return select_validator(accounts, seed)

astreum/_node/validation/account.py

@@ -1,99 +0,0 @@
-from typing import Optional
-from ..storage.patricia import PatriciaTrie
-
-import astreum.format as format
-class Account:
-    def __init__(self, public_key: bytes, balance: int, code: bytes, counter: int, data: bytes, secret_key: Optional[bytes] = None):
-        """
-        Initialize an Account.
-
-        :param public_key: The public key used as the account identifier (used as trie key).
-        :param balance: The account balance.
-        :param code: The associated code (for example, smart contract code).
-        :param counter: A transaction counter (nonce).
-        :param data: Additional account data.
-        :param secret_key: (Optional) The account’s secret key.
-        """
-        self.public_key = public_key
-        self.secret_key = secret_key  # Optional private key.
-        self.balance = balance
-        self.code = code
-        self.counter = counter
-        self.data = data
-
-    @classmethod
-    def from_bytes(cls, public_key: bytes, data: bytes, secret_key: Optional[bytes] = None) -> 'Account':
-        """
-        Deserialize an Account from its byte representation.
-        
-        Expected format: [balance, code, counter, data]
-        
-        The public_key (and optional secret_key) must be provided separately.
-    """
-        decoded = format.decode(data)
-        balance, code, counter, account_data = decoded
-        return cls(public_key, balance, code, counter, account_data, secret_key=secret_key)
-    
-    def to_bytes(self) -> bytes:
-        """
-        Serialize the Account into bytes.
-        
-        Format: [balance, code, counter, data]
-        """
-        return format.encode([
-            self.balance,
-            self.code,
-            self.counter,
-            self.data
-        ])
-
-
-class Accounts(PatriciaTrie):
-    """
-    Accounts is a PatriciaTrie storing Account objects.
-    
-    The trie key is the account’s public key (bytes), while the value is the account data
-    (serialized with balance, code, counter, and data only).
-    
-    You can instantiate Accounts with a storage instance and, if available, a root hash
-    representing an existing trie.
-    """
-    def get_account(self, public_key: bytes) -> Optional[Account]:
-        """
-        Retrieve an account using its public key.
-
-        :param public_key: The public key (bytes) of the account.
-        :return: The Account instance if found, else None.
-        """
-        raw = self.get(public_key)
-        if raw is None:
-            return None
-        return Account.from_bytes(public_key, raw)
-
-    def put_account(self, account: Account) -> None:
-        """
-        Insert or update an account in the trie.
-
-        :param account: The Account instance to store.
-        """
-        self.put(account.public_key, account.to_bytes())
-
-def get_account_from_storage(public_key: bytes, accounts: Accounts, storage: Storage) -> Optional[Account]:
-    # 1. get account details hash
-    # 2. resolve storage objects to get account details
-    # 3. return account
-    return None
-
-# Example of instantiation:
-#
-# Assuming you have an instance of Storage (e.g., from your storage module), you can create
-# an Accounts instance either as an empty trie or using an existing root hash:
-#
-#   storage = Storage()
-#
-#   # To instantiate an empty Accounts trie:
-#   accounts = Accounts(storage)
-#
-#   # To instantiate with an existing trie root hash:
-#   existing_root_hash = b'...'  # This would be loaded from persistent storage.
-#   accounts = Accounts(storage, root_hash=existing_root_hash)

astreum/_node/validation/block.py

@@ -1,21 +0,0 @@
-class Block:
-
-    def __init__(self):
-        pass
-    
-    @classmethod
-    def from_bytes(cls) -> 'Block':
-        """
-        Deserialize a block from its byte representation.
-    """
-        return cls()
-
-    def to_bytes(self) -> bytes:
-        """
-        Serialize the block into bytes.
-        """
-        return b""
-
-class Chain:
-    def __init__(self, latest_block: Block):
-        self.latest_block = latest_block

astreum/_node/validation/constants.py

@@ -1,15 +0,0 @@
-"""
-Constants for the validation module.
-"""
-
-import time
-from ..utils import hash_data
-
-# Special addresses
-VALIDATION_ADDRESS = b'\xFF' * 32  # Address for staking (all F's)
-BURN_ADDRESS = b'\x00' * 32  # Address for burning tokens (all 0's)
-
-# Validation parameters
-MIN_STAKE_AMOUNT = 1  # Minimum stake amount in Aster
-SLOT_DURATION = 1  # Duration of each slot in seconds
-VDF_DIFFICULTY = 1  # Default VDF difficulty

astreum/_node/validation/stake.py

@@ -1,229 +0,0 @@
-"""
-Stake management for validators.
-"""
-
-import time
-import random
-import json
-from typing import Dict, List, Optional, Tuple
-
-from ...crypto import hash_data
-from ..models import Transaction, TransactionType
-from ..storage import Storage, MerkleNode
-from .constants import SLOT_DURATION, MIN_STAKE_AMOUNT, VALIDATION_ADDRESS
-from .account import Account
-
-
-def get_validator_stake(storage: Storage, stake_root: bytes, validator_address: bytes) -> int:
-    """
-    Get the stake amount for a specific validator.
-    
-    Args:
-        storage: Storage instance
-        stake_root: Root hash of the stake Merkle tree
-        validator_address: Address of the validator to check
-        
-    Returns:
-        Stake amount for the validator, or 0 if not a validator
-    """
-    from ..storage.merkle import find_first
-    
-    # Find the validator node containing the stake information
-    def match_validator(node_data: bytes) -> bool:
-        try:
-            stake_data = json.loads(node_data.decode('utf-8'))
-            return stake_data.get('address') == validator_address.hex()
-        except:
-            return False
-    
-    validator_node = find_first(storage, stake_root, match_validator)
-    
-    if validator_node:
-        try:
-            stake_data = json.loads(validator_node.decode('utf-8'))
-            return stake_data.get('stake', 0)
-        except:
-            return 0
-    
-    return 0
-
-
-def is_validator(storage: Storage, stake_root: bytes, address: bytes) -> bool:
-    """
-    Check if an address is registered as a validator.
-    
-    Args:
-        storage: Storage instance
-        stake_root: Root hash of the stake Merkle tree
-        address: Address to check
-        
-    Returns:
-        True if the address is a validator, False otherwise
-    """
-    stake = get_validator_stake(storage, stake_root, address)
-    return stake >= MIN_STAKE_AMOUNT
-
-
-def get_all_validators(storage: Storage, stake_root: bytes) -> Dict[bytes, int]:
-    """
-    Get all validators and their stakes.
-    
-    Args:
-        storage: Storage instance
-        stake_root: Root hash of the stake Merkle tree
-        
-    Returns:
-        Dictionary mapping validator addresses to their stakes
-    """
-    from ..storage.merkle import find_all
-    
-    validators = {}
-    
-    # Find all validator nodes containing stake information
-    def match_all_validators(node_data: bytes) -> bool:
-        return True  # Match all nodes
-    
-    validator_nodes = find_all(storage, stake_root, match_all_validators)
-    
-    for node_data in validator_nodes:
-        try:
-            stake_data = json.loads(node_data.decode('utf-8'))
-            address = bytes.fromhex(stake_data.get('address', ''))
-            stake = stake_data.get('stake', 0)
-            
-            if stake >= MIN_STAKE_AMOUNT:
-                validators[address] = stake
-        except:
-            continue
-    
-    return validators
-
-
-def process_stake_transaction(
-    storage: Storage, 
-    stake_root: bytes, 
-    validator_address: bytes, 
-    amount: int
-) -> bytes:
-    """
-    Process a staking transaction and update the stake tree.
-    
-    Args:
-        storage: Storage instance
-        stake_root: Current root hash of the stake Merkle tree
-        validator_address: Address of the validator staking tokens
-        amount: Amount being staked
-        
-    Returns:
-        New root hash of the stake Merkle tree after the update
-    """
-    from ..storage.merkle import find_first, MerkleTree
-    
-    # Find the validator node if it exists
-    def match_validator(node_data: bytes) -> bool:
-        try:
-            stake_data = json.loads(node_data.decode('utf-8'))
-            return stake_data.get('address') == validator_address.hex()
-        except:
-            return False
-    
-    validator_node = find_first(storage, stake_root, match_validator)
-    
-    # Create or update the validator stake
-    if validator_node:
-        # Update existing validator
-        try:
-            stake_data = json.loads(validator_node.decode('utf-8'))
-            current_stake = stake_data.get('stake', 0)
-            stake_data['stake'] = current_stake + amount
-            updated_node = json.dumps(stake_data).encode('utf-8')
-            
-            # Replace the node in the tree
-            merkle_tree = MerkleTree(storage)
-            merkle_tree.root_hash = stake_root
-            new_root = merkle_tree.add(updated_node)
-        except Exception as e:
-            print(f"Error updating validator stake: {e}")
-            return stake_root
-    else:
-        # Create new validator
-        stake_data = {
-            'address': validator_address.hex(),
-            'stake': amount,
-            'last_update': int(time.time())
-        }
-        new_node = json.dumps(stake_data).encode('utf-8')
-        
-        # Add the node to the tree
-        merkle_tree = MerkleTree(storage)
-        if stake_root:
-            merkle_tree.root_hash = stake_root
-            new_root = merkle_tree.add(new_node)
-        else:
-            new_root = merkle_tree.add([new_node])
-    
-    return new_root
-
-
-class SlotManager:
-    """
-    Manager for tracking slots and selecting validators.
-    """
-    
-    def __init__(self, storage: Storage, stake_root: bytes = None):
-        """
-        Initialize slot manager.
-        
-        Args:
-            storage: Storage instance
-            stake_root: Root hash of the stake Merkle tree
-        """
-        self.storage = storage
-        self.stake_root = stake_root
-        
-    def get_current_slot(self) -> int:
-        """
-        Get the current slot based on current time.
-        
-        Returns:
-            Current slot number
-        """
-        return int(time.time() // SLOT_DURATION)
-        
-    def select_validator_for_slot(self, slot: int, previous_vdf: bytes) -> Optional[bytes]:
-        """
-        Select a validator for the given slot.
-        
-        Args:
-            slot: Slot number
-            previous_vdf: VDF output from previous block
-            
-        Returns:
-            Selected validator address, or None if no validators available
-        """
-        # Get all validators
-        validators = get_all_validators(self.storage, self.stake_root)
-        
-        if not validators:
-            return None
-            
-        # Generate random seed based on slot and previous VDF
-        seed = hash_data(previous_vdf + slot.to_bytes(8, byteorder='big'))
-        
-        # Select validator based on stake and random seed
-        total_stake = sum(validators.values())
-        if total_stake == 0:
-            return None
-            
-        # Convert seed to a random number between 0 and 1
-        random_value = int.from_bytes(seed, byteorder='big') / (2**(len(seed) * 8) - 1)
-        
-        # Select validator based on stake weight
-        cumulative_prob = 0
-        for validator, stake in validators.items():
-            cumulative_prob += stake / total_stake
-            if random_value <= cumulative_prob:
-                return validator
-                
-        # Should never reach here unless there's a rounding error
-        return list(validators.keys())[0]