astreum 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

astreum/node/validation/block/__init__.py

@@ -0,0 +1,12 @@
+"""
+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/create.py

@@ -0,0 +1,98 @@
+"""
+Block creation functionality for the Astreum blockchain.
+"""
+
+import time
+from typing import Dict, List, Optional, Tuple, Set
+
+from .model import Block
+from ..account import Account
+from ...models import Transaction
+from ...utils import hash_data
+
+def create_block(
+    number: int,
+    validator: bytes,
+    previous: bytes,
+    transactions: List[Transaction],
+    timestamp: Optional[int] = None,
+    vdf: Optional[bytes] = None,
+    signature: Optional[bytes] = None,
+    proof: Optional[bytes] = None,
+    receipts: Optional[List] = None,
+    data: Optional[bytes] = None,
+    delay: Optional[int] = None,
+    difficulty: Optional[int] = None,
+    accounts: Optional[Dict] = None,
+    chain: Optional[bytes] = None
+) -> Block:
+    """
+    Create a new block.
+    
+    Args:
+        number: Block number
+        validator: Address of block validator
+        previous: Hash of previous block
+        transactions: List of transactions to include
+        timestamp: Block timestamp (defaults to current time)
+        vdf: VDF proof
+        signature: Block signature
+        proof: Additional proof data
+        receipts: Transaction receipts
+        data: Additional block data
+        delay: Block delay
+        difficulty: Block difficulty
+        accounts: Accounts state
+        chain: Chain identifier
+        
+    Returns:
+        New Block object
+    """
+    # Use current time if timestamp not provided
+    if timestamp is None:
+        timestamp = int(time.time())
+    
+    # Create and return a new Block object
+    return Block(
+        number=number,
+        validator=validator,
+        previous=previous,
+        transactions=transactions,
+        timestamp=timestamp,
+        vdf=vdf,
+        signature=signature,
+        proof=proof,
+        receipts=receipts,
+        data=data,
+        delay=delay,
+        difficulty=difficulty,
+        accounts=accounts,
+        chain=chain
+    )
+
+def create_genesis_block(validator_address: bytes) -> Block:
+    """
+    Create the genesis block.
+    
+    Args:
+        validator_address: Address of the genesis block validator
+        
+    Returns:
+        Genesis Block object
+    """
+    return create_block(
+        number=0,
+        validator=validator_address,
+        previous=None,
+        transactions=[],
+        timestamp=int(time.time()),
+        vdf=None,
+        signature=None,
+        proof=None,
+        receipts=[],
+        data=None,
+        delay=0,
+        difficulty=1,
+        accounts={},
+        chain=hash_data(b"genesis")
+    )

astreum/node/validation/block/model.py

@@ -0,0 +1,81 @@
+"""
+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

@@ -0,0 +1,196 @@
+# 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/constants.py

@@ -0,0 +1,15 @@
+"""
+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

@@ -0,0 +1,229 @@
+"""
+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]