astreum 0.2.41__py3-none-any.whl → 0.2.42__py3-none-any.whl

astreum/_consensus/account.py

@@ -1,170 +1,95 @@
-from __future__ import annotations
-
+from __future__ import annotations
+
 from dataclasses import dataclass, field
-from typing import Any, Callable, List, Optional, Tuple
+from typing import Any, 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
+from .._storage.patricia import PatriciaTrie
+from ..utils.integer import bytes_to_int, int_to_bytes
 
 
 @dataclass
 class Account:
-    _balance: int
-    _data: bytes
-    _nonce: int
+    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)
 
-    @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,
+    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, 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)")
+    def from_atom(cls, node: Any, account_id: bytes) -> "Account":
+        storage_get = node._local_get
 
-        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)
+        type_atom = storage_get(account_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)")
+        def _read_atom(atom_id: Optional[bytes]) -> Optional[Atom]:
+            if not atom_id or atom_id == ZERO32:
+                return None
+            return storage_get(atom_id)
 
-        body_value = storage_get(body_list.next)
-        if body_value is None:
-            raise ValueError("malformed account body (value)")
+        balance_atom = _read_atom(type_atom.next)
+        if balance_atom is None:
+            raise ValueError("malformed account (balance missing)")
 
-        field_ids = _read_list_entries(storage_get, body_value.next)
-        if len(field_ids) < 3:
-            field_ids.extend([ZERO32] * (3 - len(field_ids)))
+        code_atom = _read_atom(balance_atom.next)
+        if code_atom is None:
+            raise ValueError("malformed account (code missing)")
 
-        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""
+        counter_atom = _read_atom(code_atom.next)
+        if counter_atom is None:
+            raise ValueError("malformed account (counter missing)")
 
-        balance_bytes = _read_field(field_ids[0])
-        data_bytes = _read_field(field_ids[1])
-        nonce_bytes = _read_field(field_ids[2])
+        data_atom = _read_atom(counter_atom.next)
+        if data_atom is None:
+            raise ValueError("malformed account (data missing)")
 
         account = cls.create(
-            balance=_be_bytes_to_int(balance_bytes),
-            data=data_bytes,
-            nonce=_be_bytes_to_int(nonce_bytes),
+            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 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)
+        # 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/_consensus/accounts.py

@@ -1,9 +1,7 @@
-from __future__ import annotations
 from __future__ import annotations
 
-from typing import Any, Dict, Iterable, Optional, Tuple
+from typing import Any, Dict, Optional
 
-from .._storage.atom import Atom
 from .._storage.patricia import PatriciaTrie
 from .account import Account
 
@@ -15,53 +13,26 @@ class Accounts:
     ) -> 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]
-
+    def get_account(self, address: bytes, node: Optional[Any] = None) -> Optional[Account]:
         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 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(storage_node, account_id)
+        account = Account.from_atom(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()}

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/_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/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/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.dist-info → astreum-0.2.42.dist-info}/METADATA

@@ -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.dist-info → astreum-0.2.42.dist-info}/RECORD

@@ -10,15 +10,15 @@ astreum/_communication/route.py,sha256=fbVXY0xF3O-k7dY9TuCsr6_XxD3m7Cb9ugVacQZ6G
 astreum/_communication/setup.py,sha256=TzXpc8dajV31BJhHQMMcb5UdaFrxb1xlYSj58vc_5mg,9072
 astreum/_communication/util.py,sha256=bJ3td3naDzmCelAJQpLwiDMoRBkijQl9YLROjsWyOrI,1256
 astreum/_consensus/__init__.py,sha256=gOCpvnIeO17CGjUGr0odaKNvGEggmDRXfT5IuyrYtcM,376
-astreum/_consensus/account.py,sha256=d95h5c8kvmLD4CCyGRvaTJRQK7AESKrqDG8bCdbZOKg,5614
-astreum/_consensus/accounts.py,sha256=NaLKDafsfq9SgFMtrYQpvAO7o0XbEwAIRhFl0dkY_Dk,2277
+astreum/_consensus/account.py,sha256=XCBWRapmFMrLCzz0wLtuuIaDRyNN9IKyOGc4dEl8W0s,3294
+astreum/_consensus/accounts.py,sha256=zGq2BCMJPtD_lzcj4jqMzB2Foc3ptxXSPhc9zypB1T0,1106
 astreum/_consensus/block.py,sha256=v6U2y8br9PVKGn0Q8fLVOtEODlXayPtEd_Wqprem_TU,12358
 astreum/_consensus/chain.py,sha256=WwUeLrdg7uj--ZsUxse6xFlzO2QeQQggyKSL49KhfU0,2768
 astreum/_consensus/fork.py,sha256=dK5DtT9hWCj_rQs6MS1c1bcGBbkgVTBPIOudYbqS9vw,3825
-astreum/_consensus/genesis.py,sha256=Xe9LA58cBz_IoutSJrtjeGDuFo0W-MVrWMkSdEwAVog,4760
+astreum/_consensus/genesis.py,sha256=oED7AHw0fPJgMu0OmhbbikJcbItw_bxVBVU8RlB2rJM,4766
 astreum/_consensus/receipt.py,sha256=GPLspqVJHnyBr1cKmBoClsJyeEUecYmg3_acz4L4rRo,6031
 astreum/_consensus/setup.py,sha256=agwqfOemdLqE0Z1zrPV2XHVmZ9sAxp8Bh4k6e2u-t8w,2385
-astreum/_consensus/transaction.py,sha256=LK4oDe9EepOfzLxeXc19fEFDBoxY-aj_v-nsuRyET8g,6490
+astreum/_consensus/transaction.py,sha256=VRp06ExbjAebiPcTZEX7PH-zwjzy4CLcf5kclyooL1k,7475
 astreum/_consensus/workers/__init__.py,sha256=bS5FjbevbIR5FHbVGnT4Jli17VIld_5auemRw4CaHFU,278
 astreum/_consensus/workers/discovery.py,sha256=X1yjKGjLSApMJ9mgWbnc7N21ALD09khDf-in-M45Mis,1683
 astreum/_consensus/workers/validation.py,sha256=WcHLOs2NLMTrJpErghBXWeW2aqtX3-xGPo-HcySdEZ8,4814
@@ -40,14 +40,15 @@ astreum/crypto/quadratic_form.py,sha256=pJgbORey2NTWbQNhdyvrjy_6yjORudQ67jBz2ScH
 astreum/crypto/wesolowski.py,sha256=SUgGXW3Id07dJtWzDcs4dluIhjqbRWQ8YWjn_mK78AQ,4092
 astreum/crypto/x25519.py,sha256=i29v4BmwKRcbz9E7NKqFDQyxzFtJUqN0St9jd7GS1uA,1137
 astreum/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/models/block.py,sha256=7qKUhOpL26NiiLDq_ff7mJCNrbxWb_9jPTtMtjemy3Y,18126
+astreum/models/block.py,sha256=_dgas0zW9OLFV7C1Bo-laxa102klqpJrCAG3DnwQ51U,18092
 astreum/models/merkle.py,sha256=lvWJa9nmrBL0n_2h_uNqpB_9a5s5Hn1FceRLx0IZIVQ,6778
 astreum/models/patricia.py,sha256=ohmXrcaz7Ae561tyC4u4iPOkQPkKr8N0IWJek4upFIg,13392
 astreum/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/storage/object.py,sha256=knFlvw_tpcC4twSu1DGNpHX31wlANN8E5dgEqIfU--Q,2041
 astreum/storage/setup.py,sha256=1-9ztEFI_BvRDvAA0lAn4mFya8iq65THTArlj--M3Hg,626
-astreum-0.2.41.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.41.dist-info/METADATA,sha256=03v5FuUofHssnDaviuCFvqWB1p3hz6lqvhM1t9HFhas,6181
-astreum-0.2.41.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.41.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.41.dist-info/RECORD,,
+astreum/utils/integer.py,sha256=iQt-klWOYVghu_NOT341MmHbOle4FDT3by4PNKNXscg,736
+astreum-0.2.42.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.2.42.dist-info/METADATA,sha256=xb_Bi75R1izIliHmHZQiJ93TxWPn6l9Z9EiN4IqVTAc,6181
+astreum-0.2.42.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.2.42.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.2.42.dist-info/RECORD,,