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

astreum/node/validation/block.py

@@ -0,0 +1,30 @@
+class Block:
+    @classmethod
+    def from_bytes(cls, validator) -> '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.
+    """
+        decoded = bytes_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 bytes_format.encode([
+            self.balance,
+            self.code,
+            self.counter,
+            self.data
+        ])
+
+class Chain:
+    def __init__(self, latest_block: Block):
+        self.latest_block = latest_block

astreum/node/validation/transaction.py

@@ -0,0 +1,146 @@
+from typing import Optional
+import time
+from .account import Account, get_account_from_storage
+import astreum.utils.bytes_format as bytes_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 = bytes_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 bytes_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-0.1.15.dist-info → astreum-0.1.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: astreum
-Version: 0.1.15
+Version: 0.1.17
 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
@@ -14,6 +14,7 @@ License-File: LICENSE
 Requires-Dist: pycryptodomex==3.21.0
 Requires-Dist: cryptography==44.0.2
 Requires-Dist: blake3==1.0.4
+Dynamic: license-file
 
 # lib
 

{astreum-0.1.15.dist-info → astreum-0.1.17.dist-info}/RECORD

@@ -23,31 +23,36 @@ astreum/machine/environment.py,sha256=K0084U6B7wwjrDZ9b2_7cEcbBzsB7UOy_Zpbrr7B3G
 astreum/machine/error.py,sha256=MvqBaZZt33rNELNhUJ2lER3TE3aS8WVqsWF2hz2AwoA,38
 astreum/node/__init__.py,sha256=K7F21c7V9vlJuTWoSw9arsLA8RF5KNR5I6QS3Frl_Ys,19481
 astreum/node/utils.py,sha256=amGhNYHVMjvAO-9vBRAcim-S5LlLSRudqooBN-XPdm4,702
-astreum/node/relay/__init__.py,sha256=0zvbchIbLUPqGA7QXJbXokKupcIq6Iu3X3VUpxejIQc,14981
+astreum/node/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/node/crypto/ed25519.py,sha256=FRnvlN0kZlxn4j-sJKl-C9tqiz_0z4LZyXLj3KIj1TQ,1760
+astreum/node/crypto/x25519.py,sha256=i29v4BmwKRcbz9E7NKqFDQyxzFtJUqN0St9jd7GS1uA,1137
+astreum/node/relay/__init__.py,sha256=A6br8QSGLW7qmKYBJNIC4bEf5QMzLBFaa_FH3MaOJrs,15069
 astreum/node/relay/bucket.py,sha256=pcmollbbM-xeHlmDxLZnzvf0Ut-9v9RoN6SijYiQuu8,2893
 astreum/node/relay/envelope.py,sha256=sDKsIvJruQKLWgWs92sx1mCjMHF7yQVoLguPygw2Pz8,10037
 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=gZf18ZhaJffckmuQbc92MwfxepBLwINdORuM6EeyJBc,23879
+astreum/node/storage/merkle.py,sha256=sC7gfxPDUBgv3iiFs5PyxPgYbC4CoE-If5TQvkuoTGU,10295
+astreum/node/storage/patricia.py,sha256=zP4whShdB7yOFcEPLE1-1PIFfx_LdK8DyMSadnF0KT0,11588
 astreum/node/storage/storage.py,sha256=czJDhRK2rQxjOo88fhZ6j10f55RW8hWp1qq7c4yur6Y,10086
-astreum/node/storage/trie.py,sha256=DrYNEgTS6j7WL-LtVzzCIDjSmjphjV-jL1bGXBlcyfQ,4930
 astreum/node/storage/utils.py,sha256=CxKH9GbW31aVYs2Hwg1SirCykSnH_3_JisEayDrpOvY,5169
 astreum/node/validation/__init__.py,sha256=D9Gmc5x5V5xgXtM32axuDMSzgKiDCz7MiUShNnuFKYc,1636
-astreum/node/validation/account.py,sha256=gFoJHoSAZs7BKGaewNaLiziivKINTCh8MBpOoN-YajA,27951
+astreum/node/validation/account.py,sha256=mKbJSi3sfQ5K9a4zwgdyPGqT3gXHekI55yDDVpzcolo,3650
+astreum/node/validation/block.py,sha256=ff4ZvMtIBuoY232SHxtRiwU3J-ku_hQOiqssHhIqbXY,934
 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/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/node/validation/_block/__init__.py,sha256=n2HaMG_5cpa7y5xko-c7vbHz8rL-1wAGthmr8boNrCs,216
+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.15.dist-info/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.1.15.dist-info/METADATA,sha256=dkXfuFNHZTgGlPpIHmcYC8hReofWF52gD_4_6JcCQSA,3290
-astreum-0.1.15.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-astreum-0.1.15.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.1.15.dist-info/RECORD,,
+astreum-0.1.17.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.1.17.dist-info/METADATA,sha256=0cJVTCBktTFF2gwVAFuxDeIvojUr3pA7SeCbNCP4VuE,3312
+astreum-0.1.17.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+astreum-0.1.17.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.1.17.dist-info/RECORD,,

{astreum-0.1.15.dist-info → astreum-0.1.17.dist-info}/WHEEL

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

astreum/node/storage/trie.py

@@ -1,146 +0,0 @@
-from astreum.utils.bytes_format import encode, decode
-from astreum.utils.hash import hash_data
-from typing import Optional, List
-from ..storage import Storage
-
-
-class Trie:
-    def __init__(self, root: TrieNode, storage: Storage):
-        self.root = root
-        self.storage = storage
-
-    def insert(self, key: bytes, data: bytes):
-        self.root = self._insert(self.root, key, data)
-
-    def _insert(self, node: TrieNode, key: bytes, data: bytes) -> TrieNode:
-        if node is None:
-            return TrieNode(key, data)
-        if key < node.key:
-            node.children = self._insert(node.children, key, data)
-        elif key > node.key:
-            node.children = self._insert(node.children, key, data)
-        else:
-            node.data = data
-        return node
-
-    def lookup(self, key: bytes) -> bytes:
-        """
-        Look up a key in the trie.
-        
-        Args:
-            key: The key to look up
-            
-        Returns:
-            The data associated with the key, or None if not found
-        """
-        return self._lookup(self.root, key)
-
-    def _lookup(self, node: Optional[TrieNode], key: bytes) -> bytes:
-        """
-        Recursive helper for looking up a key in the trie.
-        
-        Args:
-            node: The current node being examined
-            key: The key to look up
-            
-        Returns:
-            The data associated with the key, or None if not found
-        """
-        if node is None:
-            return None
-            
-        # If we found an exact match, return the data
-        if node.key == key:
-            return node.data
-            
-        # Make sure node has a storage reference
-        if node.storage is None:
-            node.storage = self.storage
-            
-        # Use child_lookup to find the most promising child
-        child_node = node.child_lookup(key)
-        if child_node is None:
-            return None
-            
-        # Create and traverse to the child node
-        child_node = TrieNode.from_bytes(child_data, self.storage)
-        return self._lookup(child_node, key)
-
-class TrieNode:
-    """
-    A node in a trie.
-
-    Attributes:
-        key: The key of the node
-        data: The data stored in the node
-        children: The children of the node
-        storage: Reference to storage service (not serialized)
-    """
-    def __init__(self, key: bytes, data: bytes = None, children: bytes = None, storage = None):
-        """
-        Initialize a new TrieNode.
-        
-        Args:
-            key: The key of the node
-            data: The data stored in the node
-            children: a byte string of children hashes each are 32 bytes long
-            storage: Storage instance for retrieving child nodes (not serialized)
-        """
-        self.key = key
-        self.data = data
-        self.children = children
-        self.storage = storage
-
-    def to_bytes(self) -> bytes:
-        """Serialize the node data (excluding storage reference)"""
-        return encode([self.key, self.data, self.children])
-
-    @classmethod
-    def from_bytes(cls, data: bytes, storage = None) -> 'TrieNode':
-        """
-        Deserialize node data and optionally attach a storage reference.
-        
-        Args:
-            data: The serialized node data
-            storage: Optional storage instance to attach to the node
-        
-        Returns:
-            A new TrieNode instance
-        """
-        key, data, children = decode(data)
-        return TrieNode(key, data, children, storage)
-
-    def hash(self) -> bytes:
-        return hash_data(self.to_bytes())
-
-    def child_lookup(self, key: bytes) -> Optional[TrieNode]:
-        """
-        Does a binary lookup of the keys in the children of this node.
-        Uses storage to look up children and finds a starting match for the key.
-        """
-        if self.children is None or self.storage is None:
-            return None
-        
-        # Parse children bytes into a list of 32-byte hashes
-        children_hashes = []
-        for i in range(0, len(self.children), 32):
-            if i + 32 <= len(self.children):
-                children_hashes.append(self.children[i:i+32])
-        
-        # Look up each child in storage and compare keys
-        for child_hash in children_hashes:
-            # Get child node data from storage
-            child_data = self.storage.get(child_hash)
-            if child_data is None:
-                continue  # Skip if not found in storage
-            
-            # Deserialize the child node
-            child_node = TrieNode.from_bytes(child_data, self.storage)
-            
-            # Check if this child's key is a prefix of the lookup key
-            # or if the lookup key is a prefix of this child's key
-            min_len = min(len(child_node.key), len(key))
-            if child_node.key[:min_len] == key[:min_len]:
-                return child_node
-        
-        return None