astreum 0.2.41__tar.gz → 0.2.42__tar.gz

{astreum-0.2.41/src/astreum.egg-info → astreum-0.2.42}/PKG-INFO

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

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

astreum-0.2.42/src/astreum/_consensus/account.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, List, Optional, Tuple
+
+from .._storage.atom import Atom, ZERO32
+from .._storage.patricia import PatriciaTrie
+from ..utils.integer import bytes_to_int, int_to_bytes
+
+
+@dataclass
+class Account:
+    balance: int
+    code: bytes
+    counter: int
+    data_hash: bytes
+    data: PatriciaTrie
+    hash: bytes = ZERO32
+    body_hash: bytes = ZERO32
+    atoms: List[Atom] = field(default_factory=list)
+
+    @classmethod
+    def create(cls, balance: int = 0, data_hash: bytes = ZERO32, code: bytes = ZERO32, counter: int = 0) -> "Account":
+        account = cls(
+            balance=int(balance),
+            code=bytes(code),
+            counter=int(counter),
+            data_hash=bytes(data_hash),
+            data=PatriciaTrie(root_hash=bytes(data_hash)),
+        )
+        account.to_atom()
+        return account
+
+    @classmethod
+    def from_atom(cls, node: Any, account_id: bytes) -> "Account":
+        storage_get = node._local_get
+
+        type_atom = storage_get(account_id)
+        if type_atom is None or type_atom.data != b"account":
+            raise ValueError("not an account (type mismatch)")
+
+        def _read_atom(atom_id: Optional[bytes]) -> Optional[Atom]:
+            if not atom_id or atom_id == ZERO32:
+                return None
+            return storage_get(atom_id)
+
+        balance_atom = _read_atom(type_atom.next)
+        if balance_atom is None:
+            raise ValueError("malformed account (balance missing)")
+
+        code_atom = _read_atom(balance_atom.next)
+        if code_atom is None:
+            raise ValueError("malformed account (code missing)")
+
+        counter_atom = _read_atom(code_atom.next)
+        if counter_atom is None:
+            raise ValueError("malformed account (counter missing)")
+
+        data_atom = _read_atom(counter_atom.next)
+        if data_atom is None:
+            raise ValueError("malformed account (data missing)")
+
+        account = cls.create(
+            balance=bytes_to_int(balance_atom.data),
+            data_hash=data_atom.data,
+            counter=bytes_to_int(counter_atom.data),
+            code=code_atom.data,
+        )
+        if account.hash != account_id:
+            raise ValueError("account hash mismatch while decoding")
+        return account
+
+    def to_atom(self) -> Tuple[bytes, List[Atom]]:
+        # Build a single forward chain: account -> balance -> code -> counter -> data.
+        data_atom = Atom.from_data(data=bytes(self.data_hash))
+        counter_atom = Atom.from_data(
+            data=int_to_bytes(self.counter),
+            next_hash=data_atom.object_id(),
+        )
+        code_atom = Atom.from_data(
+            data=bytes(self.code),
+            next_hash=counter_atom.object_id(),
+        )
+        balance_atom = Atom.from_data(
+            data=int_to_bytes(self.balance),
+            next_hash=code_atom.object_id(),
+        )
+        type_atom = Atom.from_data(data=b"account", next_hash=balance_atom.object_id())
+
+        atoms = [data_atom, counter_atom, code_atom, balance_atom, type_atom]
+        account_hash = type_atom.object_id()
+        self.hash = account_hash
+        self.body_hash = account_hash
+        self.atoms = atoms
+        return account_hash, list(atoms)

astreum-0.2.42/src/astreum/_consensus/accounts.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from .._storage.patricia import PatriciaTrie
+from .account import Account
+
+
+class Accounts:
+    def __init__(
+        self,
+        root_hash: Optional[bytes] = None,
+    ) -> None:
+        self._trie = PatriciaTrie(root_hash=root_hash)
+        self._cache: Dict[bytes, Account] = {}
+
+    @property
+    def root_hash(self) -> Optional[bytes]:
+        return self._trie.root_hash
+
+    def get_account(self, address: bytes, node: Optional[Any] = None) -> Optional[Account]:
+        cached = self._cache.get(address)
+        if cached is not None:
+            return cached
+
+        if node is None:
+            raise ValueError("Accounts requires a node reference for trie access")
+
+        account_id: Optional[bytes] = self._trie.get(node, address)
+        if account_id is None:
+            return None
+
+        account = Account.from_atom(node, account_id)
+        self._cache[address] = account
+        return account
+
+    def set_account(self, address: bytes, account: Account) -> None:
+        self._cache[address] = account

{astreum-0.2.41 → astreum-0.2.42}/src/astreum/_consensus/genesis.py

@@ -88,17 +88,17 @@ def create_genesis_block(node: Any, validator_public_key: bytes, validator_secre
     # 2. Account trie with treasury, burn, and validator accounts.
     accounts_trie = PatriciaTrie()
 
-    treasury_account = Account.create(balance=1, data=stake_root, nonce=0)
+    treasury_account = Account.create(balance=1, data=stake_root, counter=0)
     treasury_account_id, treasury_atoms = treasury_account.to_atom()
     _store_atoms(node, treasury_atoms)
     accounts_trie.put(node, TREASURY_ADDRESS, treasury_account_id)
 
-    burn_account = Account.create(balance=0, data=b"", nonce=0)
+    burn_account = Account.create(balance=0, data=b"", counter=0)
     burn_account_id, burn_atoms = burn_account.to_atom()
     _store_atoms(node, burn_atoms)
     accounts_trie.put(node, BURN_ADDRESS, burn_account_id)
 
-    validator_account = Account.create(balance=0, data=b"", nonce=0)
+    validator_account = Account.create(balance=0, data=b"", counter=0)
     validator_account_id, validator_atoms = validator_account.to_atom()
     _store_atoms(node, validator_atoms)
     accounts_trie.put(node, validator_pk, validator_account_id)

{astreum-0.2.41 → astreum-0.2.42}/src/astreum/_consensus/transaction.py

@@ -1,26 +1,13 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, List, Optional, Tuple
+from typing import Any, List, Tuple
 
 from .._storage.atom import Atom, ZERO32
-from .receipt import Receipt, STATUS_SUCCESS
-
-
-def _int_to_be_bytes(value: Optional[int]) -> bytes:
-    if value is None:
-        return b""
-    value = int(value)
-    if value == 0:
-        return b"\x00"
-    size = (value.bit_length() + 7) // 8
-    return value.to_bytes(size, "big")
-
-
-def _be_bytes_to_int(data: Optional[bytes]) -> int:
-    if not data:
-        return 0
-    return int.from_bytes(data, "big")
+from ..utils.integer import bytes_to_int, int_to_bytes
+from .account import Account
+from .genesis import TREASURY_ADDRESS
+from .receipt import STATUS_FAILED, Receipt, STATUS_SUCCESS
 
 
 def _make_list(child_ids: List[bytes]) -> Tuple[bytes, List[Atom]]:
@@ -61,8 +48,8 @@ class Transaction:
             body_child_ids.append(atom.object_id())
             acc.append(atom)
 
-        emit(_int_to_be_bytes(self.amount))
-        emit(_int_to_be_bytes(self.counter))
+        emit(int_to_bytes(self.amount))
+        emit(int_to_bytes(self.counter))
         emit(bytes(self.data))
         emit(bytes(self.recipient))
         emit(bytes(self.sender))
@@ -160,8 +147,8 @@ class Transaction:
         signature_bytes = signature_atom.data if signature_atom is not None else b""
 
         return cls(
-            amount=_be_bytes_to_int(amount_bytes),
-            counter=_be_bytes_to_int(counter_bytes),
+            amount=bytes_to_int(amount_bytes),
+            counter=bytes_to_int(counter_bytes),
             data=data_bytes,
             recipient=recipient_bytes,
             sender=sender_bytes,
@@ -174,8 +161,49 @@ def apply_transaction(node: Any, block: object, transaction_hash: bytes) -> None
     """Apply transaction to the candidate block. Override downstream."""
     transaction = Transaction.from_atom(node, transaction_hash)
 
-    if block.transactions is None:
-        block.transactions = []
+    accounts = block.accounts
+
+    sender_account = accounts.get_account(address=transaction.sender, node=node)
+
+    if sender_account is None:
+        return
+    
+    tx_cost = 1 + transaction.amount
+
+    if sender_account.balance < tx_cost:
+        low_sender_balance_receipt = Receipt(
+            transaction_hash=transaction_hash,
+            cost=0,
+            logs=b"low sender balance",
+            status=STATUS_FAILED
+        )
+        low_sender_balance_receipt.atomize()
+        block.receipts.append(receipt)
+        block.transactions.append(transaction)
+        return
+
+    recipient_account = accounts.get_account(address=transaction.recipient, node=node)
+
+    if recipient_account is None:
+        recipient_account = Account.create()
+
+    if transaction.recipient == TREASURY_ADDRESS:
+        stake_trie = recipient_account.data
+        existing_stake = stake_trie.get(node, transaction.sender)
+        current_stake = bytes_to_int(existing_stake)
+        new_stake = current_stake + transaction.amount
+        stake_trie.put(node, transaction.sender, int_to_bytes(new_stake))
+        recipient_account.data_hash = stake_trie.root_hash or ZERO32
+        recipient_account.balance += transaction.amount
+    else:
+        recipient_account.balance += transaction.amount
+
+    sender_account.balance -= tx_cost
+
+    block.accounts.set_account(address=sender_account)
+
+    block.accounts.set_account(address=recipient_account)
+
     block.transactions.append(transaction)
 
     receipt = Receipt(
@@ -185,8 +213,4 @@ def apply_transaction(node: Any, block: object, transaction_hash: bytes) -> None
         status=STATUS_SUCCESS,
     )
     receipt.atomize()
-    if block.receipts is None:
-        block.receipts = []
     block.receipts.append(receipt)
-
-    # Downstream implementations can extend this to apply state changes.

{astreum-0.2.41 → astreum-0.2.42}/src/astreum/models/block.py

@@ -103,9 +103,9 @@ class Block:
         stake_root = stake_trie.root_hash
 
         # 2. three Account bodies
-        validator_acct = Account.create(balance=0, data=b"", nonce=0)
-        treasury_acct  = Account.create(balance=1, data=stake_root, nonce=0)
-        burn_acct = Account.create(balance=0, data=b"", nonce=0)
+        validator_acct = Account.create(balance=0, data=b"", counter=0)
+        treasury_acct  = Account.create(balance=1, data=stake_root, counter=0)
+        burn_acct = Account.create(balance=0, data=b"", counter=0)
 
         # 3. global Accounts structure
         accts = Accounts()
@@ -190,7 +190,7 @@ class Block:
 
         def _credit(addr: bytes, amt: int):
             acc = blk.accounts.get_account(addr) or Account.create(0, b"", 0)
-            blk.accounts.set_account(addr, Account.create(acc.balance() + amt, acc.data(), acc.nonce()))
+            blk.accounts.set_account(addr, Account.create(acc.balance + amt, acc.data, acc.counter))
 
         if burn_amt:
             _credit(BURN, burn_amt)
@@ -280,17 +280,17 @@ class Block:
 
         sender_acct = self.accounts.get_account(sender_pk)
         if (sender_acct is None
-            or sender_acct.nonce() != nonce
-            or sender_acct.balance() < amount + fee):
+            or sender_acct.counter != nonce
+            or sender_acct.balance < amount + fee):
             raise ValueError("invalid or unaffordable transaction")
 
         # --- debit sender --------------------------------------------------
         self.accounts.set_account(
             sender_pk,
             Account.create(
-                balance=sender_acct.balance() - amount - fee,
-                data=sender_acct.data(),
-                nonce=sender_acct.nonce() + 1,
+                balance=sender_acct.balance - amount - fee,
+                data=sender_acct.data,
+                counter=sender_acct.counter + 1,
             )
         )
 
@@ -298,14 +298,14 @@ class Block:
         if recip_pk == TREASURY:
             treasury = self.accounts.get_account(TREASURY)
 
-            trie = PatriciaTrie(node_get=None, root_hash=treasury.data())
+            trie = PatriciaTrie(node_get=None, root_hash=treasury.data)
             stake_bytes = trie.get(sender_pk) or b""
             current_stake = int.from_bytes(stake_bytes, "big") if stake_bytes else 0
 
             if amount > 0:
                 # stake **deposit**
                 trie.put(sender_pk, (current_stake + amount).to_bytes(32, "big"))
-                new_treas_bal = treasury.balance() + amount
+                new_treas_bal = treasury.balance + amount
             else:
                 # stake **withdrawal**
                 if current_stake == 0:
@@ -315,13 +315,13 @@ class Block:
                 self.accounts.set_account(
                     sender_pk,
                     Account.create(
-                        balance=sender_after.balance() + current_stake,
-                        data=sender_after.data(),
-                        nonce=sender_after.nonce(),
+                        balance=sender_after.balance + current_stake,
+                        data=sender_after.data,
+                        counter=sender_after.counter,
                     )
                 )
                 trie.delete(sender_pk)
-                new_treas_bal = treasury.balance()  # treasury balance unchanged
+                new_treas_bal = treasury.balance  # treasury balance unchanged
 
             # write back treasury with new trie root
             self.accounts.set_account(
@@ -329,7 +329,7 @@ class Block:
                 Account.create(
                     balance=new_treas_bal,
                     data=trie.root_hash,
-                    nonce=treasury.nonce(),
+                    counter=treasury.counter,
                 )
             )
 
@@ -338,9 +338,9 @@ class Block:
             self.accounts.set_account(
                 recip_pk,
                 Account.create(
-                    balance=recip_acct.balance() + amount,
-                    data=recip_acct.data(),
-                    nonce=recip_acct.nonce(),
+                    balance=recip_acct.balance + amount,
+                    data=recip_acct.data,
+                    counter=recip_acct.counter,
                 )
             )
 
@@ -417,7 +417,7 @@ class Block:
             v_acct = dummy.accounts.get_account(self.validator_pk) or Account.create(0,b"",0)
             dummy.accounts.set_account(
                 self.validator_pk,
-                Account.create(v_acct.balance()+rew, v_acct.data(), v_acct.nonce())
+                Account.create(v_acct.balance+rew, v_acct.data, v_acct.counter)
             )
 
         if dummy.accounts.root_hash != self.accounts_hash:

astreum-0.2.42/src/astreum/utils/integer.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Optional, Union
+
+ByteLike = Union[bytes, bytearray, memoryview]
+
+
+def int_to_bytes(value: Optional[int]) -> bytes:
+    """Convert an integer to a little-endian byte string with minimal length."""
+    if value is None:
+        return b""
+    value = int(value)
+    if value == 0:
+        return b"\x00"
+    length = (value.bit_length() + 7) // 8
+    return value.to_bytes(length, "little", signed=False)
+
+
+def bytes_to_int(data: Optional[ByteLike]) -> int:
+    """Convert a little-endian byte string to an integer."""
+    if not data:
+        return 0
+    if isinstance(data, memoryview):
+        data = data.tobytes()
+    return int.from_bytes(bytes(data), "little", signed=False)

{astreum-0.2.41 → astreum-0.2.42/src/astreum.egg-info}/PKG-INFO

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

@@ -53,4 +53,5 @@ src/astreum/models/merkle.py
 src/astreum/models/patricia.py
 src/astreum/storage/__init__.py
 src/astreum/storage/object.py
-src/astreum/storage/setup.py
+src/astreum/storage/setup.py
+src/astreum/utils/integer.py

astreum-0.2.41/src/astreum/_consensus/account.py

@@ -1,170 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Callable, List, Optional, Tuple
-
-from .._storage.atom import Atom, ZERO32
-
-
-def _int_to_be_bytes(value: int) -> bytes:
-    value = int(value)
-    if value < 0:
-        raise ValueError("account integers must be non-negative")
-    if value == 0:
-        return b"\x00"
-    size = (value.bit_length() + 7) // 8
-    return value.to_bytes(size, "big")
-
-
-def _be_bytes_to_int(data: Optional[bytes]) -> int:
-    if not data:
-        return 0
-    return int.from_bytes(data, "big")
-
-
-def _make_list(child_ids: List[bytes]) -> Tuple[bytes, List[Atom]]:
-    next_hash = ZERO32
-    elements: List[Atom] = []
-    for child_id in reversed(child_ids):
-        elem = Atom.from_data(data=child_id, next_hash=next_hash)
-        next_hash = elem.object_id()
-        elements.append(elem)
-    elements.reverse()
-    value_atom = Atom.from_data(
-        data=len(child_ids).to_bytes(8, "little"),
-        next_hash=next_hash,
-    )
-    type_atom = Atom.from_data(data=b"list", next_hash=value_atom.object_id())
-    atoms = elements + [value_atom, type_atom]
-    return type_atom.object_id(), atoms
-
-
-def _resolve_storage_get(source: Any) -> Callable[[bytes], Optional[Atom]]:
-    if callable(source):
-        return source
-    getter = getattr(source, "_local_get", None)
-    if callable(getter):
-        return getter
-    raise TypeError("Account.from_atom needs a callable storage getter or node with '_local_get'")
-
-
-def _read_list_entries(
-    storage_get: Callable[[bytes], Optional[Atom]],
-    start: bytes,
-) -> List[bytes]:
-    entries: List[bytes] = []
-    current = start if start and start != ZERO32 else b""
-    while current:
-        elem = storage_get(current)
-        if elem is None:
-            break
-        entries.append(elem.data)
-        nxt = elem.next
-        current = nxt if nxt and nxt != ZERO32 else b""
-    return entries
-
-
-@dataclass
-class Account:
-    _balance: int
-    _data: bytes
-    _nonce: int
-    hash: bytes = ZERO32
-    atoms: List[Atom] = field(default_factory=list)
-
-    @staticmethod
-    def _encode(balance: int, data: bytes, nonce: int) -> Tuple[bytes, List[Atom]]:
-        balance_atom = Atom.from_data(data=_int_to_be_bytes(balance))
-        data_atom = Atom.from_data(data=bytes(data))
-        nonce_atom = Atom.from_data(data=_int_to_be_bytes(nonce))
-
-        field_atoms = [balance_atom, data_atom, nonce_atom]
-        field_ids = [a.object_id() for a in field_atoms]
-
-        body_id, body_atoms = _make_list(field_ids)
-        type_atom = Atom.from_data(data=b"account", next_hash=body_id)
-        top_id, top_atoms = _make_list([type_atom.object_id(), body_id])
-
-        atoms = field_atoms + body_atoms + [type_atom] + top_atoms
-        return top_id, atoms
-
-    @classmethod
-    def create(cls, balance: int, data: bytes, nonce: int) -> "Account":
-        account_hash, atoms = cls._encode(balance, data, nonce)
-        return cls(
-            _balance=int(balance),
-            _data=bytes(data),
-            _nonce=int(nonce),
-            hash=account_hash,
-            atoms=atoms,
-        )
-
-    @classmethod
-    def from_atom(cls, source: Any, account_id: bytes) -> "Account":
-        storage_get = _resolve_storage_get(source)
-
-        outer_list = storage_get(account_id)
-        if outer_list is None or outer_list.data != b"list":
-            raise ValueError("not an account (outer list missing)")
-
-        outer_value = storage_get(outer_list.next)
-        if outer_value is None:
-            raise ValueError("malformed account (outer value missing)")
-
-        entries = _read_list_entries(storage_get, outer_value.next)
-        if len(entries) < 2:
-            raise ValueError("malformed account (type/body missing)")
-
-        type_atom_id, body_id = entries[0], entries[1]
-        type_atom = storage_get(type_atom_id)
-        if type_atom is None or type_atom.data != b"account":
-            raise ValueError("not an account (type mismatch)")
-
-        body_list = storage_get(body_id)
-        if body_list is None or body_list.data != b"list":
-            raise ValueError("malformed account body (type)")
-
-        body_value = storage_get(body_list.next)
-        if body_value is None:
-            raise ValueError("malformed account body (value)")
-
-        field_ids = _read_list_entries(storage_get, body_value.next)
-        if len(field_ids) < 3:
-            field_ids.extend([ZERO32] * (3 - len(field_ids)))
-
-        def _read_field(field_id: bytes) -> bytes:
-            if not field_id or field_id == ZERO32:
-                return b""
-            atom = storage_get(field_id)
-            return atom.data if atom is not None else b""
-
-        balance_bytes = _read_field(field_ids[0])
-        data_bytes = _read_field(field_ids[1])
-        nonce_bytes = _read_field(field_ids[2])
-
-        account = cls.create(
-            balance=_be_bytes_to_int(balance_bytes),
-            data=data_bytes,
-            nonce=_be_bytes_to_int(nonce_bytes),
-        )
-        if account.hash != account_id:
-            raise ValueError("account hash mismatch while decoding")
-        return account
-
-    def balance(self) -> int:
-        return self._balance
-
-    def data(self) -> bytes:
-        return self._data
-
-    def nonce(self) -> int:
-        return self._nonce
-
-    def body_hash(self) -> bytes:
-        return self.hash
-
-    def to_atom(self) -> Tuple[bytes, List[Atom]]:
-        account_hash, atoms = self._encode(self._balance, self._data, self._nonce)
-        self.hash = account_hash
-        self.atoms = atoms
-        return account_hash, list(atoms)

astreum-0.2.41/src/astreum/_consensus/accounts.py

@@ -1,67 +0,0 @@
-from __future__ import annotations
-from __future__ import annotations
-
-from typing import Any, Dict, Iterable, Optional, Tuple
-
-from .._storage.atom import Atom
-from .._storage.patricia import PatriciaTrie
-from .account import Account
-
-
-class Accounts:
-    def __init__(
-        self,
-        root_hash: Optional[bytes] = None,
-    ) -> None:
-        self._trie = PatriciaTrie(root_hash=root_hash)
-        self._cache: Dict[bytes, Account] = {}
-        self._staged: Dict[bytes, Account] = {}
-        self._staged_hashes: Dict[bytes, bytes] = {}
-        self._staged_atoms: Dict[bytes, Iterable[Atom]] = {}
-        self._node: Optional[Any] = None
-
-    @property
-    def root_hash(self) -> Optional[bytes]:
-        return self._trie.root_hash
-
-    def _resolve_node(self, node: Optional[Any]) -> Any:
-        if node is not None:
-            if self._node is None:
-                self._node = node
-            return node
-        if self._node is None:
-            raise ValueError("Accounts requires a node reference for trie access")
-        return self._node
-
-    def get_account(self, address: bytes, *, node: Optional[Any] = None) -> Optional[Account]:
-        if address in self._staged:
-            return self._staged[address]
-
-        cached = self._cache.get(address)
-        if cached is not None:
-            return cached
-
-        storage_node = self._resolve_node(node)
-        account_id: Optional[bytes] = self._trie.get(storage_node, address)
-        if account_id is None:
-            return None
-
-        account = Account.from_atom(storage_node, account_id)
-        self._cache[address] = account
-        return account
-
-    def set_account(self, address: bytes, account: Account) -> None:
-        account_hash, atoms = account.to_atom()
-        self._staged[address] = account
-        self._staged_hashes[address] = account_hash
-        self._staged_atoms[address] = tuple(atoms)
-        self._cache[address] = account
-
-    def staged_items(self) -> Iterable[Tuple[bytes, Account]]:
-        return self._staged.items()
-
-    def staged_hashes(self) -> Dict[bytes, bytes]:
-        return dict(self._staged_hashes)
-
-    def staged_atoms(self) -> Dict[bytes, Iterable[Atom]]:
-        return {addr: tuple(atoms) for addr, atoms in self._staged_atoms.items()}