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

astreum/_node/validation/transaction.py

@@ -1,146 +0,0 @@
-from typing import Optional
-import time
-from .account import Account, get_account_from_storage
-import astreum.format as format
-
-class Transaction:
-    def __init__(
-        self,
-        sender: Account,
-        recipient: Account,
-        amount: int,
-        data: bytes = None,
-        counter: int = 0
-    ):
-        self.sender = sender
-        self.recipient = recipient
-        self.amount = amount
-        self.data = data
-        self.counter = counter
-        self.timestamp = time.time()
-        self.signature = None
-
-    @classmethod
-    def from_bytes(cls, data: bytes, resolve_accounts: bool = False, accounts=None, storage=None) -> 'Transaction':
-        """
-        Deserialize a Transaction from its byte representation.
-        
-        Expected format: [sender_hash, recipient_hash, amount, data, counter, timestamp, signature]
-        
-        Args:
-            data: Serialized transaction data
-            resolve_accounts: If True, attempts to resolve account objects from storage
-            accounts: Accounts instance (required if resolve_accounts is True)
-            storage: Storage instance (required if resolve_accounts is True)
-            
-        Returns:
-            Transaction object
-        """
-        decoded = format.decode(data)
-        sender_public_key, recipient_public_key, amount, tx_data, counter, timestamp, signature = decoded
-        
-        sender_account = None
-        recipient_account = None
-        
-        if resolve_accounts:
-            if accounts is None or storage is None:
-                raise ValueError("Both accounts and storage must be provided when resolve_accounts is True")
-            sender_account = get_account_from_storage(sender_public_key, accounts, storage)
-            recipient_account = get_account_from_storage(recipient_public_key, accounts, storage)
-        else:
-            # Create minimal Account objects with just the public keys
-            sender_account = Account(sender_public_key, 0, b'', 0, b'')
-            recipient_account = Account(recipient_public_key, 0, b'', 0, b'')
-        
-        transaction = cls(sender_account, recipient_account, amount, tx_data, counter)
-        transaction.timestamp = timestamp
-        transaction.signature = signature
-        return transaction
-
-    def to_bytes(self) -> bytes:
-        """
-        Serialize the Transaction into bytes.
-        
-        Format: [sender_hash, recipient_hash, amount, data, counter, timestamp, signature]
-        """
-        return format.encode([
-            self.sender.public_key,
-            self.recipient.public_key,
-            self.amount,
-            self.data,
-            self.counter,
-            self.timestamp,
-            self.signature
-        ])
-
-
-def get_tx_from_storage(hash: bytes) -> Optional[Transaction]:
-    """Resolves storage objects to get a transaction.
-    
-    Args:
-        hash: Hash of the transaction and merkle root of the transaction
-        
-    Returns:
-        Transaction object if found, None otherwise
-    """
-    return None
-
-
-def put_tx_to_storage(transaction: Transaction):
-    """Puts a transaction into storage.
-    
-    Args:
-        transaction: Transaction object to put into storage
-        
-    Returns:
-        None
-    """
-    return None
-
-
-def get_tx_hash(transaction: Transaction) -> bytes:
-    """Get the hash of a transaction.
-    
-    Args:
-        transaction: Transaction object to get hash for
-        
-    Returns:
-        Merkle root of the transaction body hash and signature
-    """
-    return hash_data(get_tx_body_hash(transaction) + hash_data(transaction.signature))
-
-def get_tx_body_hash(transaction: Transaction) -> bytes:
-    """Get the hash of the transaction body.
-    
-    Args:
-        transaction: Transaction object to get hash for
-        
-    Returns:
-        Hash of the transaction body
-    """
-    return hash_data(transaction)
-
-def sign_tx(transaction: Transaction, private_key: bytes) -> Transaction:
-    """Sign a transaction.
-    
-    Args:
-        transaction: Transaction object to sign
-        private_key: Private key to sign with
-        
-    Returns:
-        Signed transaction
-    """
-    transaction.signature = hash_data(get_tx_body_hash(transaction) + private_key)
-    return transaction
-
-
-def verify_tx(transaction: Transaction) -> bool:
-    """Verify a transaction.
-    
-    Args:
-        transaction: Transaction object to verify,with sender public key
-        
-    Returns:
-        True if the transaction is valid, False otherwise
-    """
-    return True

astreum/_node/validation/vdf.py

@@ -1,80 +0,0 @@
-"""
-Verifiable Delay Function (VDF) implementation for Astreum.
-
-This module provides functionality for computing and verifying VDFs,
-which are used in the consensus mechanism to create artificial time delays.
-"""
-
-import time
-import hashlib
-from typing import Optional
-from .constants import VDF_DIFFICULTY
-
-
-def compute_vdf(input_data: bytes, difficulty: Optional[int] = None) -> bytes:
-    """
-    Compute VDF output for given input data.
-    
-    Args:
-        input_data: Input data for VDF
-        difficulty: VDF difficulty level (if None, uses default)
-        
-    Returns:
-        VDF output
-    """
-    if difficulty is None:
-        difficulty = VDF_DIFFICULTY
-        
-    # Simple VDF implementation
-    # In a real implementation, this would be a proper VDF algorithm
-    # like Wesolowski VDF or Pietrzak VDF
-    
-    # For this implementation, we'll use a simple hash-based time delay
-    result = input_data
-    for _ in range(difficulty):
-        result = hashlib.sha256(result).digest()
-        
-    return result
-
-
-def verify_vdf(input_data: bytes, output: bytes, difficulty: Optional[int] = None) -> bool:
-    """
-    Verify VDF computation.
-    
-    Args:
-        input_data: Input data for VDF
-        output: Purported VDF output
-        difficulty: VDF difficulty level (if None, uses default)
-        
-    Returns:
-        True if output is valid, False otherwise
-    """
-    if difficulty is None:
-        difficulty = VDF_DIFFICULTY
-        
-    # Compute expected output and compare
-    expected = compute_vdf(input_data, difficulty)
-    return expected == output
-
-
-def validate_block_vdf(block_number: int, previous_hash: bytes, vdf_proof: bytes) -> bool:
-    """
-    Validate the VDF proof for a block.
-    
-    Args:
-        block_number: Block number
-        previous_hash: Hash of previous block
-        vdf_proof: VDF proof to validate
-        
-    Returns:
-        True if VDF proof is valid, False otherwise
-    """
-    # Skip VDF validation for genesis block
-    if block_number == 0:
-        return True
-        
-    # Compute expected input for the VDF
-    vdf_input = previous_hash
-    
-    # Verify the VDF
-    return verify_vdf(vdf_input, vdf_proof)

astreum/lispeum/expression.py

@@ -1,95 +0,0 @@
-from typing import List, Union
-
-class Expr:
-    class ListExpr:
-        def __init__(self, elements: List['Expr']):
-            self.elements = elements
-
-        def __eq__(self, other):
-            if not isinstance(other, Expr.ListExpr):
-                return NotImplemented
-            return self.elements == other.elements
-
-        def __ne__(self, other):
-            return not self.__eq__(other)
-
-        @property
-        def value(self):
-            inner = " ".join(str(e) for e in self.elements)
-            return f"({inner})"
-
-
-        def __repr__(self):
-            if not self.elements:
-                return "()"
-            
-            inner = " ".join(str(e) for e in self.elements)
-            return f"({inner})"
-        
-        def __iter__(self):
-            return iter(self.elements)
-        
-        def __getitem__(self, index: Union[int, slice]):
-            return self.elements[index]
-
-        def __len__(self):
-            return len(self.elements)
-
-    class Symbol:
-        def __init__(self, value: str):
-            self.value = value
-
-        def __repr__(self):
-            return self.value
-
-    class Integer:
-        def __init__(self, value: int):
-            self.value = value
-
-        def __repr__(self):
-            return str(self.value)
-
-    class String:
-        def __init__(self, value: str):
-            self.value = value
-
-        def __repr__(self):
-            return f'"{self.value}"'
-        
-    class Boolean:
-        def __init__(self, value: bool):
-            self.value = value
-
-        def __repr__(self):
-            return "true" if self.value else "false"
-
-    class Function:
-        def __init__(self, params: List[str], body: 'Expr'):
-            self.params = params
-            self.body = body
-
-        def __repr__(self):
-            params_str = " ".join(self.params)
-            body_str = str(self.body)
-            return f"(fn ({params_str}) {body_str})"
-        
-    class Error:
-        """
-        Represents an error with a freeform category and message.
-        - `category`: A string identifying the type of error (e.g., 'SyntaxError').
-        - `message`: A human-readable description of the error.
-        - `details`: Optional, additional information about the error.
-        """
-        def __init__(self, category: str, message: str, details: str = None):
-            if not category:
-                raise ValueError("Error category must be provided.")
-            if not message:
-                raise ValueError("Error message must be provided.")
-            self.category = category
-            self.message = message
-            self.details = details
-
-        def __repr__(self):
-            if self.details:
-                return f'({self.category} "{self.message}" {self.details})'
-            return f'({self.category} "{self.message}")'

astreum/lispeum/special/definition.py

@@ -1,27 +0,0 @@
-from astreum.lispeum.expression import Expr
-from astreum.machine.environment import Environment
-
-
-def handle_definition(machine, args: Expr.ListExpr, env: Environment) -> Expr:
-        if len(args) != 2:
-            return Expr.Error(
-                category="SyntaxError",
-                message="def expects exactly two arguments: a symbol and an expression"
-            )
-        
-        if not isinstance(args[0], Expr.Symbol):
-            return Expr.Error(
-                category="TypeError",
-                message="First argument to def must be a symbol"
-            )
-    
-        var_name = args[0].value
-
-        result = machine.evaluate_expression(args[1], env)
-
-        if isinstance(result, Expr.Error):
-            return result
-
-        env.set(var_name, result)
-    
-        return result

astreum/lispeum/special/list/all.py

@@ -1,32 +0,0 @@
-from astreum.lispeum.expression import Expr
-from astreum.machine.environment import Environment
-
-def handle_list_all(machine, list: Expr.ListExpr, predicate: Expr.Function, env: Environment) -> Expr:
-    if not isinstance(list, Expr.ListExpr):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("First argument must be a list")
-        ])
-    
-    if not isinstance(predicate, Expr.Function):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("Second argument must be a function")
-        ])
-    
-    for elem in list.elements:
-        new_env = Environment(parent=env)
-        new_env.set(predicate.params[0], elem)
-        
-        result, _ = machine.evaluate_expression(predicate, new_env)
-
-        if result == Expr.Boolean(False):
-            return Expr.ListExpr([
-                Expr.Boolean(False),
-                Expr.ListExpr([])
-            ])
-    
-    return Expr.ListExpr([
-        Expr.Boolean(True),
-        Expr.ListExpr([])
-    ])

astreum/lispeum/special/list/any.py

@@ -1,32 +0,0 @@
-from astreum.lispeum.expression import Expr
-from astreum.machine.environment import Environment
-
-def handle_list_any(machine, list: Expr.ListExpr, predicate: Expr.Function, env: Environment) -> Expr:
-    if not isinstance(list, Expr.ListExpr):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("First argument must be a list")
-        ])
-    
-    if not isinstance(predicate, Expr.Function):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("Second argument must be a function")
-        ])
-    
-    for elem in list.elements:
-        new_env = Environment(parent=env)
-        new_env.set(predicate.params[0], elem)
-        
-        result, _ = machine.evaluate_expression(predicate, new_env)
-
-        if result == Expr.Boolean(True):
-            return Expr.ListExpr([
-                Expr.Boolean(True),
-                Expr.ListExpr([])
-            ])
-    
-    return Expr.ListExpr([
-        Expr.Boolean(False),
-        Expr.ListExpr([])
-    ])

astreum/lispeum/special/list/fold.py

@@ -1,29 +0,0 @@
-from astreum.lispeum.expression import Expr
-from astreum.machine.environment import Environment
-
-
-def handle_list_fold(machine, list: Expr.ListExpr, initial: Expr, func: Expr.Function, env: Environment) -> Expr:
-    if not isinstance(list, Expr.ListExpr):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("First argument must be a list")
-        ])
-    
-    if not isinstance(func, Expr.Function):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("Third argument must be a function")
-        ])
-    
-    result = initial
-    for elem in list.elements:
-        new_env = Environment(parent=env)
-        new_env.set(func.params[0], result)
-        new_env.set(func.params[1], elem)
-        
-        result = machine.evaluate_expression(func, new_env)
-    
-    return Expr.ListExpr([
-        result,
-        Expr.ListExpr([])
-    ])

astreum/lispeum/special/list/get.py

@@ -1,20 +0,0 @@
-
-
-from astreum.lispeum.expression import Expr
-from astreum.machine.environment import Environment
-
-
-def handle_list_get(machine, list: Expr.ListExpr, index: Expr.Integer, env: Environment) -> Expr:
-    if not isinstance(list, Expr.ListExpr):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("First argument must be a list")
-        ])
-    
-    if index.value < 0 or index.value >= len(list.elements):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("Index out of bounds")
-        ])
-    
-    return machine.evaluate_expression(list.elements[index])

astreum/lispeum/special/list/insert.py

@@ -1,23 +0,0 @@
-from astreum.lispeum.expression import Expr
-
-
-def handle_list_insert(list: Expr.ListExpr, index: Expr.Integer, value: Expr) -> Expr:
-    if not isinstance(list, Expr.ListExpr):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("First argument must be a list")
-        ])
-    
-    if index.value < 0 or index.value > len(list.elements):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("Index out of bounds")
-        ])
-    
-    new_elements = list.elements[:index.value] + [value] + list.elements[index.value:]
-    
-    return Expr.ListExpr([
-        Expr.ListExpr(new_elements),
-        Expr.ListExpr([])
-    ])
-    

astreum/lispeum/special/list/map.py

@@ -1,30 +0,0 @@
-from astreum.lispeum.expression import Expr
-from astreum.machine.environment import Environment
-
-
-def handle_list_map(machine, list: Expr.ListExpr, func: Expr.Function, env: Environment) -> Expr:
-    if not isinstance(list, Expr.ListExpr):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("First argument must be a list")
-        ])
-    
-    if not isinstance(func, Expr.Function):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("Second argument must be a function")
-        ])
-    
-    mapped_elements = []
-    for elem in list.elements:
-        new_env = Environment(parent=env)
-        new_env.set(func.params[0], elem)
-        
-        mapped_elem = machine.evaluate_expression(func.body, new_env)
-        
-        mapped_elements.append(mapped_elem)
-    
-    return Expr.ListExpr([
-        Expr.ListExpr(mapped_elements),
-        Expr.ListExpr([])
-    ])

astreum/lispeum/special/list/position.py

@@ -1,33 +0,0 @@
-from astreum.lispeum.expression import Expr
-from astreum.machine.environment import Environment
-
-
-def handle_list_position(machine, list: Expr.ListExpr, predicate: Expr.Function, env: Environment) -> Expr:
-    if not isinstance(list, Expr.ListExpr):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("First argument must be a list")
-        ])
-    
-    if not isinstance(predicate, Expr.Function):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("Second argument must be a function")
-        ])
-    
-    for idx, elem in enumerate(list.elements):
-        new_env = Environment(parent=env)
-        new_env.set(predicate.params[0], elem)
-        
-        result, _ = machine.evaluate_expression(predicate, new_env)
-
-        if result == Expr.Boolean(True):
-            return Expr.ListExpr([
-                Expr.Integer(idx),
-                Expr.ListExpr([])
-            ])
-    
-    return Expr.ListExpr([
-        Expr.ListExpr([]),
-        Expr.ListExpr([])
-    ])

astreum/lispeum/special/list/remove.py

@@ -1,22 +0,0 @@
-from astreum.lispeum.expression import Expr
-
-
-def handle_list_remove(list: Expr.ListExpr, index: Expr.Integer) -> Expr:
-    if not isinstance(list, Expr.ListExpr):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("First argument must be a list")
-        ])
-    
-    if index.value < 0 or index.value >= len(list.elements):
-        return Expr.ListExpr([
-            Expr.ListExpr([]),
-            Expr.String("Index out of bounds")
-        ])
-    
-    new_elements = list.elements[:index.value] + list.elements[index.value + 1:]
-    
-    return Expr.ListExpr([
-        Expr.ListExpr(new_elements),
-        Expr.ListExpr([])
-    ])