astreum 0.2.17__py3-none-any.whl → 0.2.19__py3-none-any.whl

astreum/models/account.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from typing import Optional, Callable
+
+from .merkle import MerkleTree
+
+_FIELD_ORDER = ["balance", "data", "nonce"]
+_INT_FIELDS = {"balance", "nonce"}
+
+def _int_to_min_bytes(i: int) -> bytes:
+    length = (i.bit_length() + 7) // 8 or 1
+    return i.to_bytes(length, "big")
+
+class Account:
+    def __init__(
+        self,
+        body_hash: bytes,
+        *,
+        body_tree: Optional[MerkleTree] = None,
+        get_node_fn: Optional[Callable[[bytes], Optional[bytes]]] = None,
+    ) -> None:
+        self._body_hash = body_hash
+        self._body_tree = body_tree
+        self._balance: Optional[int] = None
+        self._data: Optional[bytes] = None
+        self._nonce: Optional[int] = None
+
+        if self._body_tree and get_node_fn:
+            self._body_tree._node_get = get_node_fn
+
+    @classmethod
+    def create(
+        cls,
+        balance: int,
+        data: bytes,
+        nonce: int,
+    ) -> Account:
+        """Build an Account body from explicit fields in alphabetical order."""
+        # prepare values dict
+        values = {"balance": balance, "data": data, "nonce": nonce}
+
+        # build leaves in alphabetical order
+        leaves: list[bytes] = []
+        for name in _FIELD_ORDER:
+            v = values[name]
+            if name in _INT_FIELDS:
+                leaves.append(_int_to_min_bytes(v))  # type: ignore[arg-type]
+            else:
+                leaves.append(v)
+
+        tree = MerkleTree.from_leaves(leaves)
+        return cls(tree.root_hash, body_tree=tree)
+
+    def body_hash(self) -> bytes:
+        """Return the Merkle root of the account body."""
+        return self._body_hash
+
+    def _require_tree(self) -> MerkleTree:
+        if not self._body_tree:
+            raise ValueError("Body tree unavailable for this Account")
+        return self._body_tree
+
+    def balance(self) -> int:
+        """Fetch & cache the `balance` field (leaf 0)."""
+        if self._balance is not None:
+            return self._balance
+        raw = self._require_tree().get(0)
+        if raw is None:
+            raise ValueError("Merkle leaf 0 (balance) missing")
+        self._balance = int.from_bytes(raw, "big")
+        return self._balance
+
+    def data(self) -> bytes:
+        """Fetch & cache the `data` field (leaf 1)."""
+        if self._data is not None:
+            return self._data
+        raw = self._require_tree().get(1)
+        if raw is None:
+            raise ValueError("Merkle leaf 1 (data) missing")
+        self._data = raw
+        return self._data
+
+    def nonce(self) -> int:
+        """Fetch & cache the `nonce` field (leaf 2)."""
+        if self._nonce is not None:
+            return self._nonce
+        raw = self._require_tree().get(2)
+        if raw is None:
+            raise ValueError("Merkle leaf 2 (nonce) missing")
+        self._nonce = int.from_bytes(raw, "big")
+        return self._nonce

astreum/models/merkle.py

@@ -2,18 +2,10 @@ from __future__ import annotations
 
 from typing import Callable, Dict, List, Optional, Tuple
 
-import blake3  # type: ignore
+import blake3
 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],
@@ -25,9 +17,6 @@ class MerkleNode:
         self.value = value
         self._hash: Optional[bytes] = None
 
-    # ------------------------------------------------------------------
-    # serialisation helpers
-    # ------------------------------------------------------------------
     def to_bytes(self) -> bytes:
         return encode([self.left, self.right, self.value])
 
@@ -36,11 +25,8 @@ class 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
+        if self.value is not None:
             return blake3.blake3(self.value).digest()
         left = self.left or b""
         right = self.right or b""
@@ -52,21 +38,7 @@ class MerkleNode:
         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]],
@@ -84,11 +56,6 @@ class MerkleTree:
         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")
 
@@ -125,9 +92,6 @@ class MerkleTree:
         tree._height = height
         return tree
 
-    # ------------------------------------------------------------------
-    # internal helpers
-    # ------------------------------------------------------------------
     def _fetch(self, h: bytes | None) -> Optional[MerkleNode]:
         if h is None:
             return None
@@ -141,11 +105,10 @@ class MerkleTree:
         return node
 
     def _invalidate(self, node: MerkleNode) -> None:
-        node._hash = None  # type: ignore[attr-defined]
+        node._hash = None
 
     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:
@@ -186,11 +149,7 @@ class MerkleTree:
         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.
-        """
+        # 1 . input validation
         if index < 0:
             raise IndexError("negative index")
         if self.root_hash is None:
@@ -198,6 +157,7 @@ class MerkleTree:
         if index >= self._capacity():
             raise IndexError("index beyond tree capacity")
 
+        # 2 . walk down to the target leaf
         node_hash = self.root_hash
         stack: List[Tuple[MerkleNode, bytes, bool]] = []
         for bit in self._path_bits(index):
@@ -207,28 +167,39 @@ class MerkleTree:
             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")
+                raise IndexError("path leads into non-existent branch")
             stack.append((node, node.hash(), went_right))
             node_hash = child_hash
 
+        # 3 . update the leaf
         leaf = self._fetch(node_hash)
         if leaf is None or leaf.value is None:
             raise IndexError("target leaf missing")
+
+        old_hash = leaf.hash()
         leaf.value = value
         self._invalidate(leaf)
         new_hash = leaf.hash()
+        
+        if new_hash != old_hash:
+            self.nodes.pop(old_hash, None)
         self.nodes[new_hash] = leaf
-
-        # bubble updated hashes
+        
+        # 4 . bubble the change up
         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.nodes.pop(old_hash, None)
+            self.nodes[new_hash] = parent
+            
+        # 5 . finalise the new root
         self.root_hash = new_hash
 
+

astreum/models/transaction.py

@@ -1,78 +1,106 @@
-from ..format import encode, decode
+from __future__ import annotations
+
+from typing import Dict, List, Optional, Union, Any, Callable
+
+from .merkle import MerkleTree
 from ..crypto import ed25519
-import blake3
+
+_FIELD_ORDER: List[str] = [
+    "amount",
+    "balance",
+    "fee",
+    "nonce",
+    "recipient_pk",
+    "sender_pk",
+]
+
+_INT_FIELDS = {"amount", "balance", "fee", "nonce"}
+
+def _int_to_min_bytes(i: int) -> bytes:
+    length = (i.bit_length() + 7) // 8 or 1
+    return i.to_bytes(length, "big")
 
 class Transaction:
+    # init
     def __init__(
         self,
-        sender_pk: bytes,
-        recipient_pk: bytes,
+        tx_hash: bytes,
+        *,
+        tree: Optional[MerkleTree] = None,
+        get_node_fn: Optional[Callable[[bytes], Optional[bytes]]] = None,
+    ) -> None:
+        self._hash = tx_hash
+        self._tree = tree
+        self._field_cache: Dict[str, Union[int, bytes]] = {}
+
+        if self._tree and get_node_fn:
+            self._tree.set_external_node_fetcher(get_node_fn)
+
+    @classmethod
+    def create(
+        cls,
+        *,
         amount: int,
+        balance: 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
+        recipient_pk: bytes,
+        sender_pk: bytes,
+    ) -> "Transaction":
+        vals: Dict[str, Any] = locals().copy()
+        leaves = [
+            vals[name] if isinstance(vals[name], bytes) else _int_to_min_bytes(vals[name])
+            for name in _FIELD_ORDER
+        ]
+
+        tree = MerkleTree.from_leaves(leaves)
+        return cls(tx_hash=tree.root_hash, tree=tree)
+
+    @property
+    def hash(self) -> bytes:
+        return self._hash
+
+    def _require_tree(self) -> MerkleTree:
+        if not self._tree:
+            raise ValueError("Merkle tree unavailable for this Transaction")
+        return self._tree
+
+    def _field(self, idx: int, name: str) -> Union[int, bytes]:
+        if name in self._field_cache:
+            return self._field_cache[name]
+
+        raw = self._require_tree().get(idx)
+        if raw is None:
+            raise ValueError(f"Leaf {idx} (‘{name}’) missing from Merkle tree")
+
+        value = int.from_bytes(raw, "big") if name in _INT_FIELDS else raw
+        self._field_cache[name] = value
+        return value
+
+    def get_amount(self) -> int:
+        return self._field(0, "amount")
+    
+    def get_balance(self) -> int:
+        return self._field(1, "balance")
+    
+    def get_fee(self) -> int:
+        return self._field(2, "fee")
+    
+    def get_nonce(self) -> int:
+        return self._field(3, "nonce")
+    
+    def get_recipient_pk(self) -> bytes:
+        return self._field(4, "recipient_pk")
+    
+    def get_sender_pk(self) -> bytes:
+        return self._field(5, "sender_pk")
+    
+    def sign(self, priv: ed25519.Ed25519PrivateKey) -> bytes:
+        return priv.sign(self.hash)
+
+    def verify_signature(self, sig: bytes, sender_pk: bytes) -> bool:
         try:
-            pub = ed25519.Ed25519PublicKey.from_public_bytes(self.sender_pk)
-            pub.verify(self.signature, self.tx_body_hash)
+            ed25519.Ed25519PublicKey.from_public_bytes(sender_pk).verify(sig, self.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 __hash__(self) -> int:
-        return int.from_bytes(self.tx_hash, 'big')

{astreum-0.2.17.dist-info → astreum-0.2.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.17
+Version: 0.2.19
 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

{astreum-0.2.17.dist-info → astreum-0.2.19.dist-info}/RECORD

@@ -10,12 +10,13 @@ astreum/lispeum/__init__.py,sha256=K-NDzIjtIsXzC9X7lnYvlvIaVxjFcY7WNsgLIE3DH3U,5
 astreum/lispeum/parser.py,sha256=jQRzZYvBuSg8t_bxsbt1-WcHaR_LPveHNX7Qlxhaw-M,1165
 astreum/lispeum/tokenizer.py,sha256=J-I7MEd0r2ZoVqxvRPlu-Afe2ZdM0tKXXhf1R4SxYTo,1429
 astreum/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/models/account.py,sha256=sHujGSwtV13rvOGJ5LZXuMrJ4F9XUdvyuWKz-zJ9lkE,2986
 astreum/models/block.py,sha256=YIY3qLneFM7OooY29khLDEs3NIEA7y8VhlXitflkxTo,4564
-astreum/models/merkle.py,sha256=E850dITZmuQS2LmQt2yA_luy0a3QjHgSbL2ibQAmYJc,8627
+astreum/models/merkle.py,sha256=merV3rx2iRfzvglV6gNusrJf7OMbcVV854T-DUWCC64,6733
 astreum/models/patricia.py,sha256=WtfwVufZazFTOjVDnSDI0I3ghetm3GBzAwqNQevOlJ8,12974
-astreum/models/transaction.py,sha256=ReCmLf9j1WLm2VUTtZh4cAVEyJodk17bVPp3t-UyNnI,2427
-astreum-0.2.17.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.17.dist-info/METADATA,sha256=7BooYG3o3YQyZ2Y0hOsAtD-5ykT5nvfWnT3koADQ4gM,5478
-astreum-0.2.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.17.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.17.dist-info/RECORD,,
+astreum/models/transaction.py,sha256=yBarvRK2ybMAHHEQPZpubGO7gms4U9k093xQGNQHQ4Q,3043
+astreum-0.2.19.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.2.19.dist-info/METADATA,sha256=tnkbLG0OS3__mZJ9T7giW36HKeJxEseV4CxQeF_YBW0,5478
+astreum-0.2.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.2.19.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.2.19.dist-info/RECORD,,