astreum 0.2.12__tar.gz → 0.2.14__tar.gz

{astreum-0.2.12/src/astreum.egg-info → astreum-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.12
+Version: 0.2.14
 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
@@ -118,6 +118,6 @@ except ParseError as e:
 ## Testing
 
 ```bash
-
+source venv/bin/activate
 python3 -m unittest discover -s tests
 ```

{astreum-0.2.12 → astreum-0.2.14}/README.md

@@ -100,6 +100,6 @@ except ParseError as e:
 ## Testing
 
 ```bash
-
+source venv/bin/activate
 python3 -m unittest discover -s tests
 ```

{astreum-0.2.12 → astreum-0.2.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "astreum"
-version = "0.2.12"
+version = "0.2.14"
 authors = [
   { name="Roy R. O. Okello", email="roy@stelar.xyz" },
 ]

astreum-0.2.14/src/astreum/models/block.py

@@ -0,0 +1,98 @@
+from ..format import encode, decode
+from ..crypto import ed25519
+import blake3
+
+class Block:
+    def __init__(
+        self,
+        number: int,
+        prev_block_hash: bytes,
+        timestamp: int,
+        accounts_hash: bytes,
+        transactions_total_fees: int,
+        transaction_limit: int,
+        transactions_root_hash: bytes,
+        vdf_difficulty: int,
+        vdf_output: bytes,
+        vdf_proof: bytes,
+        validator_pk: bytes,
+        signature: bytes,
+    ) -> None:
+        self.accounts_hash = accounts_hash
+        self.number = int(number)
+        self.prev_block_hash = prev_block_hash
+        self.timestamp = int(timestamp)
+        self.transactions_total_fees = int(transactions_total_fees)
+        self.transaction_limit = int(transaction_limit)
+        self.transactions_root_hash = transactions_root_hash
+        self.validator_pk = validator_pk
+        self.vdf_difficulty = int(vdf_difficulty)
+        self.vdf_output = vdf_output
+        self.vdf_proof = vdf_proof
+        self.signature = signature
+        self.body_hash = self._compute_body_hash()
+
+    def _body_fields_without_sig(self) -> list:
+        return [
+            self.accounts_hash,
+            self.number,
+            self.prev_block_hash,
+            self.timestamp,
+            self.transactions_total_fees,
+            self.transaction_limit,
+            self.transactions_root_hash,
+            self.validator_pk,
+            self.vdf_difficulty,
+            self.vdf_output,
+            self.vdf_proof,
+        ]
+
+    def _compute_body_hash(self) -> bytes:
+        return blake3.blake3(encode(self._body_fields_without_sig())).digest()
+    
+    def to_bytes(self) -> bytes:
+        return encode(self._body_fields_without_sig() + [self.signature])
+
+    @classmethod
+    def from_bytes(cls, blob: bytes) -> "Block":
+        (
+            accounts_hash,
+            number,
+            prev_block_hash,
+            timestamp,
+            transactions_total_fees,
+            transaction_limit,
+            transactions_root_hash,
+            validator_pk,
+            vdf_difficulty,
+            vdf_output,
+            vdf_proof,
+            signature
+        ) = decode(blob)
+        return cls(
+            number=int(number),
+            prev_block_hash=prev_block_hash,
+            timestamp=int(timestamp),
+            accounts_hash=accounts_hash,
+            transactions_total_fees=int(transactions_total_fees),
+            transaction_limit=int(transaction_limit),
+            transactions_root_hash=transactions_root_hash,
+            vdf_difficulty=int(vdf_difficulty),
+            vdf_output=vdf_output,
+            vdf_proof=vdf_proof,
+            validator_pk=validator_pk,
+            signature=signature,
+        )
+
+    @property
+    def hash(self) -> bytes:
+        return blake3.blake3(self.body_hash + self.signature).digest()
+
+    def verify_block_signature(self) -> bool:
+        try:
+            pub = ed25519.Ed25519PublicKey.from_public_bytes(self.validator_pk)
+            pub.verify(self.signature, self.body_hash)
+            return True
+        except Exception:
+            return False
+  

astreum-0.2.14/src/astreum/models/merkle.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+from typing import Callable, Dict, List, Optional, Tuple
+
+import blake3  # type: ignore
+from ..format import encode, decode
+
+class MerkleNode:
+    """A node in a binary Merkle tree.
+
+    *Leaf*  : ``value`` is **not** ``None``.
+    *Interior*: ``value`` is ``None``.
+    """
+
+    __slots__ = ("left", "right", "value", "_hash")
+
+    def __init__(
+        self,
+        left: Optional[bytes],
+        right: Optional[bytes],
+        value: Optional[bytes],
+    ) -> None:
+        self.left = left
+        self.right = right
+        self.value = value
+        self._hash: Optional[bytes] = None
+
+    # ------------------------------------------------------------------
+    # serialisation helpers
+    # ------------------------------------------------------------------
+    def to_bytes(self) -> bytes:
+        return encode([self.left, self.right, self.value])
+
+    @classmethod
+    def from_bytes(cls, blob: bytes) -> "MerkleNode":
+        left, right, value = decode(blob)
+        return cls(left, right, value)
+
+    # ------------------------------------------------------------------
+    # content hash (blake3)
+    # ------------------------------------------------------------------
+    def _compute_hash(self) -> bytes:
+        if self.value is not None:  # leaf
+            return blake3.blake3(self.value).digest()
+        left = self.left or b""
+        right = self.right or b""
+        return blake3.blake3(left + right).digest()
+
+    def hash(self) -> bytes:
+        if self._hash is None:
+            self._hash = self._compute_hash()
+        return self._hash
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Merkle tree – fixed‑height, no dynamic growth
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+class MerkleTree:
+    """Binary Merkle tree addressed by *leaf position* (0‑based).
+
+    * The number of levels is fixed once the tree is built (``_height``).
+    * ``put`` can **only update** existing leaves; it never adds capacity.
+    """
+
+    # ------------------------------------------------------------------
+    # construction helpers
+    # ------------------------------------------------------------------
+    def __init__(
+        self,
+        node_get: Callable[[bytes], Optional[bytes]],
+        root_hash: Optional[bytes] = None,
+        height: Optional[int] = None,
+    ) -> None:
+        self._node_get = node_get
+        self.nodes: Dict[bytes, MerkleNode] = {}
+        self.root_hash = root_hash
+        self._height: Optional[int] = height
+
+    @classmethod
+    def from_leaves(
+        cls,
+        leaves: List[bytes],
+        node_get: Callable[[bytes], Optional[bytes]] | None = None,
+    ) -> "MerkleTree":
+        """Build a complete tree from *leaves* (left‑to‑right order).
+
+        Missing right siblings in the top levels are allowed; they are encoded
+        as interior nodes with a single child.
+        """
+        if not leaves:
+            raise ValueError("must supply at least one leaf")
+
+        node_get = node_get or (lambda _h: None)
+        tree = cls(node_get=node_get)
+
+        # Step 1 – create leaf nodes list[bytes]
+        level_hashes: List[bytes] = []
+        for val in leaves:
+            leaf = MerkleNode(None, None, val)
+            h = leaf.hash()
+            tree.nodes[h] = leaf
+            level_hashes.append(h)
+
+        height = 1  # current level (leaves)
+
+        # Step 2 – build upper levels until single root remains
+        while len(level_hashes) > 1:
+            next_level: List[bytes] = []
+            it = iter(level_hashes)
+            for left_hash in it:
+                try:
+                    right_hash = next(it)
+                except StopIteration:
+                    right_hash = None
+                parent = MerkleNode(left_hash, right_hash, None)
+                ph = parent.hash()
+                tree.nodes[ph] = parent
+                next_level.append(ph)
+            level_hashes = next_level
+            height += 1
+
+        tree.root_hash = level_hashes[0]
+        tree._height = height
+        return tree
+
+    # ------------------------------------------------------------------
+    # internal helpers
+    # ------------------------------------------------------------------
+    def _fetch(self, h: bytes | None) -> Optional[MerkleNode]:
+        if h is None:
+            return None
+        node = self.nodes.get(h)
+        if node is None:
+            raw = self._node_get(h)
+            if raw is None:
+                return None
+            node = MerkleNode.from_bytes(raw)
+            self.nodes[h] = node
+        return node
+
+    def _invalidate(self, node: MerkleNode) -> None:
+        node._hash = None  # type: ignore[attr-defined]
+
+    def _ensure_height(self) -> None:
+        if self._height is None:
+            # Recompute by traversing leftmost branch
+            h = 0
+            nh = self.root_hash
+            while nh is not None:
+                node = self._fetch(nh)
+                nh = node.left if node and node.value is None else None
+                h += 1
+            self._height = h or 1
+
+    def _capacity(self) -> int:
+        self._ensure_height()
+        assert self._height is not None
+        return 1 << (self._height - 1)
+
+    def _path_bits(self, index: int) -> List[int]:
+        self._ensure_height()
+        assert self._height is not None
+        bits = []
+        for shift in range(self._height - 2, -1, -1):
+            bits.append((index >> shift) & 1)
+        return bits
+
+    # ------------------------------------------------------------------
+    # get / put
+    # ------------------------------------------------------------------
+    def get(self, index: int) -> Optional[bytes]:
+        if index < 0 or self.root_hash is None or index >= self._capacity():
+            return None
+
+        node_hash = self.root_hash
+        for bit in self._path_bits(index):
+            node = self._fetch(node_hash)
+            if node is None:
+                return None
+            node_hash = node.right if bit else node.left
+            if node_hash is None:
+                return None
+        leaf = self._fetch(node_hash)
+        return leaf.value if leaf else None
+
+    def put(self, index: int, value: bytes) -> None:
+        """Overwrite *value* at existing leaf *index*.
+
+        Raises ``IndexError`` if *index* is outside current capacity **or** if
+        the path to that leaf is missing in the stored structure.
+        """
+        if index < 0:
+            raise IndexError("negative index")
+        if self.root_hash is None:
+            raise IndexError("tree is empty – build it first with from_leaves()")
+        if index >= self._capacity():
+            raise IndexError("index beyond tree capacity")
+
+        node_hash = self.root_hash
+        stack: List[Tuple[MerkleNode, bytes, bool]] = []
+        for bit in self._path_bits(index):
+            node = self._fetch(node_hash)
+            if node is None:
+                raise IndexError("missing node along path")
+            went_right = bool(bit)
+            child_hash = node.right if went_right else node.left
+            if child_hash is None:
+                raise IndexError("path leads into non‑existent branch")
+            stack.append((node, node.hash(), went_right))
+            node_hash = child_hash
+
+        leaf = self._fetch(node_hash)
+        if leaf is None or leaf.value is None:
+            raise IndexError("target leaf missing")
+        leaf.value = value
+        self._invalidate(leaf)
+        new_hash = leaf.hash()
+
+        # bubble updated hashes
+        for parent, old_hash, went_right in reversed(stack):
+            if went_right:
+                parent.right = new_hash
+            else:
+                parent.left = new_hash
+            self._invalidate(parent)
+            new_hash = parent.hash()
+            if new_hash != old_hash:
+                del self.nodes[old_hash]
+                self.nodes[new_hash] = parent
+        self.root_hash = new_hash
+

astreum-0.2.14/src/astreum/models/transaction.py

@@ -0,0 +1,83 @@
+from ..format import encode, decode
+from ..crypto import ed25519
+import blake3
+
+class Transaction:
+    def __init__(
+        self,
+        sender_pk: bytes,
+        recipient_pk: bytes,
+        amount: int,
+        fee: int,
+        nonce: int,
+        signature: bytes | None = None,
+    ) -> None:
+        self.sender_pk = sender_pk
+        self.recipient_pk = recipient_pk
+        self.amount = amount
+        self.fee = fee
+        self.nonce = nonce
+        self.signature = signature
+
+        if self.amount < 0 or self.fee < 0:
+            raise ValueError("amount and fee must be non-negative")
+        
+        if self.fee % 2 != 0:
+            raise ValueError("fee must be divisible by two")
+
+        self.tx_body_hash: bytes = blake3.blake3(self._body_bytes()).digest()
+        
+        if self.signature is not None:
+            self.tx_hash = blake3.blake3(self.tx_body_hash + self.signature).digest()
+        else:
+            self.tx_hash = None
+
+    def sign(self, priv_key: ed25519.Ed25519PrivateKey) -> None:
+        if self.signature is not None:
+            raise ValueError("transaction already signed")
+        sig = priv_key.sign(self.tx_body_hash)
+        self.signature = sig
+        self.tx_hash = blake3.blake3(self.tx_body_hash + sig).digest()
+
+    def verify_signature(self) -> bool:
+        if self.signature is None:
+            return False
+        try:
+            pub = ed25519.Ed25519PublicKey.from_public_bytes(self.sender_pk)
+            pub.verify(self.signature, self.tx_body_hash)
+            return True
+        except Exception:
+            return False
+
+    def to_bytes(self) -> bytes:
+        sig = self.signature or b""
+        return encode([
+            self.sender_pk,
+            self.recipient_pk,
+            self.amount,
+            self.fee,
+            self.nonce,
+            sig,
+        ])
+
+    @classmethod
+    def from_bytes(cls, blob: bytes) -> 'Transaction':
+        sender, recipient, amount, fee, nonce, sig = decode(blob)
+        return cls(sender, recipient, int(amount), int(fee), int(nonce), sig)
+
+    def _body_bytes(self) -> bytes:
+        return encode([
+            self.sender_pk,
+            self.recipient_pk,
+            self.amount,
+            self.fee,
+            self.nonce,
+        ])
+
+    def __eq__(self, other: "Transaction") -> bool:
+        if not isinstance(other, Transaction):
+            return NotImplemented
+        return self.tx_hash == other.tx_hash
+
+    def __hash__(self) -> int:
+        return int.from_bytes(self.tx_hash, 'big')

{astreum-0.2.12 → astreum-0.2.14}/src/astreum/node.py

@@ -6,6 +6,8 @@ from pathlib import Path
 from typing import Tuple, Dict, Union, Optional, List
 from datetime import datetime, timedelta, timezone
 import uuid
+
+from .models.transaction import Transaction
 from .format import encode, decode
 from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
 from cryptography.hazmat.primitives import serialization
@@ -324,181 +326,6 @@ class Env:
         )
 
 
-class Transaction:
-    def __init__(
-        self,
-        sender_pk: bytes,
-        recipient_pk: bytes,
-        amount: int,
-        fee: int,
-        nonce: int,
-        signature: bytes | None = None,
-    ) -> None:
-        self.sender_pk = sender_pk
-        self.recipient_pk = recipient_pk
-        self.amount = amount
-        self.fee = fee
-        self.nonce = nonce
-        self.signature = signature
-
-        if self.amount < 0 or self.fee < 0:
-            raise ValueError("amount and fee must be non-negative")
-        
-        if self.fee % 2 != 0:
-            raise ValueError("fee must be divisible by two")
-
-        self.tx_body_hash: bytes = blake3.blake3(self._body_bytes()).digest()
-        
-        if self.signature is not None:
-            self.tx_hash = blake3.blake3(self.tx_body_hash + self.signature).digest()
-        else:
-            self.tx_hash = None
-
-    def sign(self, priv_key: ed25519.Ed25519PrivateKey) -> None:
-        if self.signature is not None:
-            raise ValueError("transaction already signed")
-        sig = priv_key.sign(self.tx_body_hash)
-        self.signature = sig
-        self.tx_hash = blake3.blake3(self.tx_body_hash + sig).digest()
-
-    def verify_signature(self) -> bool:
-        if self.signature is None:
-            return False
-        try:
-            pub = ed25519.Ed25519PublicKey.from_public_bytes(self.sender_pk)
-            pub.verify(self.signature, self.tx_body_hash)
-            return True
-        except Exception:
-            return False
-
-    def to_bytes(self) -> bytes:
-        sig = self.signature or b""
-        return encode([
-            self.sender_pk,
-            self.recipient_pk,
-            self.amount,
-            self.fee,
-            self.nonce,
-            sig,
-        ])
-
-    @classmethod
-    def from_bytes(cls, blob: bytes) -> 'Transaction':
-        sender, recipient, amount, fee, nonce, sig = decode(blob)
-        return cls(sender, recipient, int(amount), int(fee), int(nonce), sig)
-
-    def _body_bytes(self) -> bytes:
-        return encode([
-            self.sender_pk,
-            self.recipient_pk,
-            self.amount,
-            self.fee,
-            self.nonce,
-        ])
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, Transaction):
-            return NotImplemented
-        return self.tx_hash == other.tx_hash
-
-    def __hash__(self) -> int:
-        return int.from_bytes(self.tx_hash, 'big')
-
-class Block:
-    def __init__(
-        self,
-        *,
-        number: int,
-        prev_block_hash: bytes,
-        timestamp: int,
-        accounts_hash: bytes,
-        total_astre_burned: int,
-        tx_limit: int,
-        tx_root: bytes,
-        vdf_difficulty: int,
-        vdf_output: bytes,
-        vdf_proof: bytes,
-        validator_pk: bytes,
-        signature: bytes,
-    ) -> None:
-        self.accounts_hash = accounts_hash
-        self.number = int(number)
-        self.prev_block_hash = prev_block_hash
-        self.timestamp = int(timestamp)
-        self.total_astre_burned = int(total_astre_burned)
-        self.tx_limit = int(tx_limit)
-        self.tx_root = tx_root
-        self.validator_pk = validator_pk
-        self.vdf_difficulty = int(vdf_difficulty)
-        self.vdf_output = vdf_output
-        self.vdf_proof = vdf_proof
-        self.signature = signature
-        self.body_hash = self._compute_body_hash()
-
-    def _body_fields_without_sig(self) -> list:
-        return [
-            self.accounts_hash,
-            self.number,
-            self.prev_block_hash,
-            self.timestamp,
-            self.total_astre_burned,
-            self.tx_limit,
-            self.tx_root,
-            self.validator_pk,
-            self.vdf_difficulty,
-            self.vdf_output,
-            self.vdf_proof,
-        ]
-
-    def _compute_body_hash(self) -> bytes:
-        return blake3.blake3(encode(self._body_fields_without_sig())).digest()
-    
-    def to_bytes(self) -> bytes:
-        return encode(self._body_fields_without_sig() + [self.signature])
-
-    @classmethod
-    def from_bytes(cls, blob: bytes) -> "Block":
-        (
-            accounts_hash,
-            number,
-            prev_block_hash,
-            timestamp,
-            total_astre_burned,
-            tx_limit,
-            tx_root,
-            validator_pk,
-            vdf_difficulty,
-            vdf_output,
-            vdf_proof,
-            signature
-        ) = decode(blob)
-        return cls(
-            number=int(number),
-            prev_block_hash=prev_block_hash,
-            timestamp=int(timestamp),
-            accounts_hash=accounts_hash,
-            total_astre_burned=int(total_astre_burned),
-            tx_limit=int(tx_limit),
-            tx_root=tx_root,
-            vdf_difficulty=int(vdf_difficulty),
-            vdf_output=vdf_output,
-            vdf_proof=vdf_proof,
-            validator_pk=validator_pk,
-            signature=signature,
-        )
-
-    @property
-    def hash(self) -> bytes:
-        return blake3.blake3(self.body_hash + self.signature).digest()
-
-    def verify_block_signature(self) -> bool:
-        try:
-            pub = ed25519.Ed25519PublicKey.from_public_bytes(self.validator_pk)
-            pub.verify(self.signature, self.body_hash)
-            return True
-        except Exception:
-            return False
-  
 class Node:
     def __init__(self, config: dict = {}):
         self._machine_setup()

{astreum-0.2.12 → astreum-0.2.14/src/astreum.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.12
+Version: 0.2.14
 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
@@ -118,6 +118,6 @@ except ParseError as e:
 ## Testing
 
 ```bash
-
+source venv/bin/activate
 python3 -m unittest discover -s tests
 ```

{astreum-0.2.12 → astreum-0.2.14}/src/astreum.egg-info/SOURCES.txt

@@ -21,6 +21,9 @@ src/astreum/crypto/x25519.py
 src/astreum/lispeum/__init__.py
 src/astreum/lispeum/parser.py
 src/astreum/lispeum/tokenizer.py
-src/astreum/utils/__init__.py
-src/astreum/utils/patricia.py
+src/astreum/models/__init__.py
+src/astreum/models/block.py
+src/astreum/models/merkle.py
+src/astreum/models/patricia.py
+src/astreum/models/transaction.py
 tests/test_node_machine.py