astreum 0.2.19__tar.gz → 0.2.21__tar.gz

{astreum-0.2.19/src/astreum.egg-info → astreum-0.2.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.19
+Version: 0.2.21
 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.19 → astreum-0.2.21}/pyproject.toml

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

astreum-0.2.21/src/astreum/models/accounts.py

@@ -0,0 +1,80 @@
+"""Account‐state management built on a PatriciaTrie.
+
+Only the *initial skeleton* is provided here per current request:
+  • __init__: wrap an existing trie root (or start empty).
+  • get_account: look up an Account object, using a cache so multiple
+    balance/nonce updates in one block operate on the same instance.
+
+Additional mutation helpers (set_account, change_balance, etc.) will be
+added next, once confirmed.
+"""
+from __future__ import annotations
+
+from typing import Dict, Optional, Callable
+
+from .patricia import PatriciaTrie
+from .account import Account
+
+
+class Accounts:
+    """Light wrapper around a PatriciaTrie (address → body_hash) plus
+    an in‑memory cache of Account objects currently being worked on.
+    """
+
+    # ------------------------------------------------------------
+    # construction
+    # ------------------------------------------------------------
+    def __init__(
+        self,
+        root_hash: Optional[bytes] = None,
+        *,
+        get_node_fn: Optional[Callable[[bytes], Optional[bytes]]] = None,
+    ) -> None:
+        """Wrap an existing state trie *or* start empty (root_hash=None).
+
+        `get_node_fn` (optional) is a callback that retrieves raw node bytes
+        when the underlying PatriciaTrie encounters an unknown hash – useful
+        for disk or network-backed light clients.
+        """
+        self._remote_get = get_node_fn
+        # Instantiate the trie; we pass the external fetcher straight in.
+        # PatriciaTrie is expected to accept `node_get` and `root_hash`.
+        self._trie = PatriciaTrie(node_get=get_node_fn, root_hash=root_hash)
+
+        # Working‑set cache: address → Account instance
+        self._cache: Dict[bytes, Account] = {}
+
+    # ------------------------------------------------------------
+    # public introspection
+    # ------------------------------------------------------------
+    @property
+    def root_hash(self) -> Optional[bytes]:
+        """Current trie root (updates automatically after puts)."""
+        return self._trie.root_hash
+
+    # ------------------------------------------------------------
+    # account access – read‑only for now
+    # ------------------------------------------------------------
+    def get_account(self, address: bytes) -> Optional[Account]:
+        """Return an *Account* for `address`, or *None* if it doesn't exist.
+
+        • First check the in‑memory cache (so repeat reads/updates reuse the
+          same object).
+        • Otherwise look up `body_hash` in the PatriciaTrie.
+        • If found, create a lightweight `Account` wrapper, cache it, and
+          return it.  The Account is initialised with the same external
+          node‑fetcher so its own Merkle lookups can go remote if needed.
+        """
+        # cache hit → hot path
+        if address in self._cache:
+            return self._cache[address]
+
+        # trie lookup (raw body_hash)
+        body_hash: Optional[bytes] = self._trie.get(address)
+        if body_hash is None:
+            return None
+
+        # wrap in Account and cache
+        acc = Account(body_hash, get_node_fn=self._remote_get)
+        self._cache[address] = acc
+        return acc

{astreum-0.2.19 → astreum-0.2.21}/src/astreum/models/patricia.py

@@ -195,9 +195,12 @@ class PatriciaTrie:
 
             # 4.3 – matched entire key → update value
             if key_pos == total_bits:
-                self._invalidate_hash(node)
+                old_hash = node.hash()
                 node.value = value
+                self._invalidate_hash(node)
                 new_hash = node.hash()
+                if new_hash != old_hash:
+                    self.nodes.pop(old_hash, None)
                 self.nodes[new_hash] = node
                 self._bubble(stack, new_hash)
                 return
@@ -233,12 +236,12 @@ class PatriciaTrie:
         value: bytes,
         stack: List[Tuple[PatriciaNode, bytes, int]],
     ) -> None:
-        # key_pos points to routing bit; leaf stores the rest after that bit
         tail_len = len(key) * 8 - (key_pos + 1)
         tail_bits, tail_len = self._bit_slice(key, key_pos + 1, tail_len)
         leaf = self._make_node(tail_bits, tail_len, value, None, None)
 
-        # attach to parent
+        old_parent_hash = parent.hash()
+        
         if dir_bit:
             parent.child_1 = leaf.hash()
         else:
@@ -246,9 +249,12 @@ class PatriciaTrie:
 
         self._invalidate_hash(parent)
         new_parent_hash = parent.hash()
+        if new_parent_hash != old_parent_hash:
+            self.nodes.pop(old_parent_hash, None)
         self.nodes[new_parent_hash] = parent
         self._bubble(stack, new_parent_hash)
 
+
     def _split_and_insert(
         self,
         node: PatriciaNode,
@@ -277,10 +283,14 @@ class PatriciaTrie:
             lcp + 1,                       # start *after* divergence bit
             node.key_len - lcp - 1         # may be zero
         )
+        old_node_hash = node.hash()
+
         node.key = old_suffix_bits
         node.key_len = old_suffix_len
         self._invalidate_hash(node)
         new_node_hash = node.hash()
+        if new_node_hash != old_node_hash:
+            self.nodes.pop(old_node_hash, None)
         self.nodes[new_node_hash] = node
 
         # ➍—new leaf for the key being inserted (unchanged)
@@ -341,15 +351,21 @@ class PatriciaTrie:
         """
         while stack:
             parent, old_hash, dir_bit = stack.pop()
+
             if dir_bit == 0:
                 parent.child_0 = new_hash
             else:
                 parent.child_1 = new_hash
+
             self._invalidate_hash(parent)
             new_hash = parent.hash()
+            if new_hash != old_hash:
+                self.nodes.pop(old_hash, None)
             self.nodes[new_hash] = parent
+            
         self.root_hash = new_hash
 
+
     def _bit_slice(
         self,
         buf: bytes,

{astreum-0.2.19 → astreum-0.2.21/src/astreum.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.19
+Version: 0.2.21
 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.19 → astreum-0.2.21}/src/astreum.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ src/astreum/lispeum/parser.py
 src/astreum/lispeum/tokenizer.py
 src/astreum/models/__init__.py
 src/astreum/models/account.py
+src/astreum/models/accounts.py
 src/astreum/models/block.py
 src/astreum/models/merkle.py
 src/astreum/models/patricia.py