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

astreum/_communication/util.py

@@ -0,0 +1,42 @@
+from typing import Tuple
+
+
+def address_str_to_host_and_port(address: str) -> Tuple[str, int]:
+    """Parse `host:port` (or `[ipv6]:port`) into a tuple."""
+    addr = address.strip()
+    if not addr:
+        raise ValueError("address cannot be empty")
+
+    host: str
+    port_str: str
+
+    if addr.startswith('['):
+        end = addr.find(']')
+        if end == -1:
+            raise ValueError("missing closing ']' in IPv6 address")
+        host = addr[1:end]
+        remainder = addr[end + 1 :]
+        if not remainder.startswith(':'):
+            raise ValueError("missing port separator after IPv6 address")
+        port_str = remainder[1:]
+    else:
+        if ':' not in addr:
+            raise ValueError("address must contain ':' separating host and port")
+        host, port_str = addr.rsplit(':', 1)
+
+    host = host.strip()
+    if not host:
+        raise ValueError("host cannot be empty")
+    port_str = port_str.strip()
+    if not port_str:
+        raise ValueError("port cannot be empty")
+
+    try:
+        port = int(port_str, 10)
+    except ValueError as exc:
+        raise ValueError(f"invalid port number: {port_str}") from exc
+
+    if not (0 < port < 65536):
+        raise ValueError(f"port out of range: {port}")
+
+    return host, port

astreum/_consensus/__init__.py

@@ -1,6 +1,9 @@
+from .account import Account
+from .accounts import Accounts
 from .block import Block
 from .chain import Chain
 from .fork import Fork
+from .receipt import Receipt
 from .transaction import Transaction
 from .setup import consensus_setup
 
@@ -9,6 +12,9 @@ __all__ = [
     "Block",
     "Chain",
     "Fork",
+    "Receipt",
     "Transaction",
+    "Account",
+    "Accounts",
     "consensus_setup",
 ]

astreum/_consensus/account.py

@@ -0,0 +1,170 @@
+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/_consensus/accounts.py

@@ -0,0 +1,67 @@
+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()}

astreum/_consensus/block.py

@@ -1,7 +1,12 @@
-
-from typing import Callable, List, Optional, Tuple
+
+from typing import Any, Callable, List, Optional, Tuple, TYPE_CHECKING
 
 from .._storage.atom import Atom, ZERO32
+
+if TYPE_CHECKING:
+    from .._storage.patricia import PatriciaTrie
+    from .transaction import Transaction
+    from .receipt import Receipt
 from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
 from cryptography.exceptions import InvalidSignature
 
@@ -22,16 +27,6 @@ def _be_bytes_to_int(b: Optional[bytes]) -> int:
     return int.from_bytes(b, "big")
 
 
-def _make_typed_bytes(data: bytes) -> Tuple[bytes, List[Atom]]:
-    """Create a typed 'byte' atom for the given payload.
-
-    Returns (object_id, atoms_in_dependency_order).
-    """
-    val = Atom.from_data(data=data)
-    typ = Atom.from_data(data=b"byte", next_hash=val.object_id())
-    return typ.object_id(), [val, typ]
-
-
 def _make_list(child_ids: List[bytes]) -> Tuple[bytes, List[Atom]]:
     """Create a typed 'list' atom for child object ids.
 
@@ -65,15 +60,16 @@ class Block:
              signature_atom = Atom(data=<signature-bytes>)
 
     Details order in body_list:
-      0: previous_block                      (bytes)
+      0: previous_block_hash                 (bytes)
       1: number                              (int → big-endian bytes)
       2: timestamp                           (int → big-endian bytes)
       3: accounts_hash                       (bytes)
       4: transactions_total_fees             (int → big-endian bytes)
-      5: transactions_root_hash              (bytes)
-      6: delay_difficulty                    (int → big-endian bytes)
-      7: delay_output                        (bytes)
-      8: validator_public_key                (bytes)
+      5: transactions_hash                   (bytes)
+      6: receipts_hash                       (bytes)
+      7: delay_difficulty                    (int → big-endian bytes)
+      8: delay_output                        (bytes)
+      9: validator_public_key                (bytes)
 
     Notes:
       - "body tree" is represented here by the body_list id (self.body_hash), not
@@ -85,14 +81,16 @@ class Block:
 
     # essential identifiers
     hash: bytes
-    previous_block: bytes
+    previous_block_hash: bytes
+    previous_block: Optional["Block"]
 
     # block details
     number: Optional[int]
     timestamp: Optional[int]
     accounts_hash: Optional[bytes]
     transactions_total_fees: Optional[int]
-    transactions_root_hash: Optional[bytes]
+    transactions_hash: Optional[bytes]
+    receipts_hash: Optional[bytes]
     delay_difficulty: Optional[int]
     delay_output: Optional[bytes]
     validator_public_key: Optional[bytes]
@@ -101,33 +99,48 @@ class Block:
     body_hash: Optional[bytes]
     signature: Optional[bytes]
 
+    # structures
+    accounts: Optional["PatriciaTrie"]
+    transactions: Optional[List["Transaction"]]
+    receipts: Optional[List["Receipt"]]
+    
+    
+
     def __init__(self) -> None:
         # defaults for safety
         self.hash = b""
-        self.previous_block = ZERO32
+        self.previous_block_hash = ZERO32
+        self.previous_block = None
         self.number = None
         self.timestamp = None
         self.accounts_hash = None
         self.transactions_total_fees = None
-        self.transactions_root_hash = None
+        self.transactions_hash = None
+        self.receipts_hash = None
         self.delay_difficulty = None
         self.delay_output = None
         self.validator_public_key = None
         self.body_hash = None
         self.signature = None
+        self.accounts = None
+        self.transactions = None
+        self.receipts = None
 
     def to_atom(self) -> Tuple[bytes, List[Atom]]:
-        # Build body details as typed bytes, in defined order
+        # Build body details as direct byte atoms, in defined order
         details_ids: List[bytes] = []
         atoms_acc: List[Atom] = []
 
         def _emit(detail_bytes: bytes) -> None:
-            oid, ats = _make_typed_bytes(detail_bytes)
-            details_ids.append(oid)
-            atoms_acc.extend(ats)
-
-        # 0: previous_block
-        _emit(self.previous_block or ZERO32)
+            atom = Atom.from_data(data=detail_bytes)
+            details_ids.append(atom.object_id())
+            atoms_acc.append(atom)
+
+        # 0: previous_block_hash
+        prev_hash = self.previous_block_hash or (self.previous_block.hash if self.previous_block else b"")
+        prev_hash = prev_hash or ZERO32
+        self.previous_block_hash = prev_hash
+        _emit(prev_hash)
         # 1: number
         _emit(_int_to_be_bytes(self.number))
         # 2: timestamp
@@ -136,13 +149,15 @@ class Block:
         _emit(self.accounts_hash or b"")
         # 4: transactions_total_fees
         _emit(_int_to_be_bytes(self.transactions_total_fees))
-        # 5: transactions_root_hash
-        _emit(self.transactions_root_hash or b"")
-        # 6: delay_difficulty
+        # 5: transactions_hash
+        _emit(self.transactions_hash or b"")
+        # 6: receipts_hash
+        _emit(self.receipts_hash or b"")
+        # 7: delay_difficulty
         _emit(_int_to_be_bytes(self.delay_difficulty))
-        # 7: delay_output
+        # 8: delay_output
         _emit(self.delay_output or b"")
-        # 8: validator_public_key
+        # 9: validator_public_key
         _emit(self.validator_public_key or b"")
 
         # Build body list
@@ -166,7 +181,14 @@ class Block:
         return self.hash, atoms_acc
 
     @classmethod
-    def from_atom(cls, storage_get: Callable[[bytes], Optional[Atom]], block_id: bytes) -> "Block":
+    def from_atom(cls, source: Any, block_id: bytes) -> "Block":
+        storage_get: Optional[Callable[[bytes], Optional[Atom]]]
+        if callable(source):
+            storage_get = source
+        else:
+            storage_get = getattr(source, "_local_get", None)
+        if not callable(storage_get):
+            raise TypeError("Block.from_atom requires a node with '_local_get' or a callable storage getter")
         # 1) Expect main list
         main_typ = storage_get(block_id)
         if main_typ is None or main_typ.data != b"list":
@@ -206,23 +228,20 @@ class Block:
             raise ValueError("malformed body (value)")
         cur_elem_id = body_val.next
 
-        def _read_typed_bytes(elem_id: bytes) -> bytes:
+        def _read_detail_bytes(elem_id: bytes) -> bytes:
             elem = storage_get(elem_id)
             if elem is None:
                 return b""
             child_id = elem.data
-            typ = storage_get(child_id)
-            if typ is None or typ.data != b"byte":
-                return b""
-            val = storage_get(typ.next)
-            return val.data if val is not None else b""
+            detail = storage_get(child_id)
+            return detail.data if detail is not None else b""
 
         details: List[bytes] = []
-        # We read up to 9 fields if present
-        for _ in range(9):
+        # We read up to 10 fields if present
+        for _ in range(10):
             if not cur_elem_id:
                 break
-            b = _read_typed_bytes(cur_elem_id)
+            b = _read_detail_bytes(cur_elem_id)
             details.append(b)
             nxt = storage_get(cur_elem_id)
             cur_elem_id = nxt.next if nxt is not None else b""
@@ -233,21 +252,23 @@ class Block:
 
         # Map details back per the defined order
         get = lambda i: details[i] if i < len(details) else b""
-        b.previous_block = get(0) or ZERO32
+        b.previous_block_hash = get(0) or ZERO32
+        b.previous_block = None
         b.number = _be_bytes_to_int(get(1))
         b.timestamp = _be_bytes_to_int(get(2))
         b.accounts_hash = get(3) or None
         b.transactions_total_fees = _be_bytes_to_int(get(4))
-        b.transactions_root_hash = get(5) or None
-        b.delay_difficulty = _be_bytes_to_int(get(6))
-        b.delay_output = get(7) or None
-        b.validator_public_key = get(8) or None
+        b.transactions_hash = get(5) or None
+        b.receipts_hash = get(6) or None
+        b.delay_difficulty = _be_bytes_to_int(get(7))
+        b.delay_output = get(8) or None
+        b.validator_public_key = get(9) or None
 
-        # 4) Parse signature if present (supports raw or typed 'byte' atom)
+        # 4) Parse signature if present (supports raw or typed 'bytes' atom)
         if sig_atom_id is not None:
             sa = storage_get(sig_atom_id)
             if sa is not None:
-                if sa.data == b"byte":
+                if sa.data == b"bytes":
                     sval = storage_get(sa.next)
                     b.signature = sval.data if sval is not None else b""
                 else:
@@ -282,13 +303,24 @@ class Block:
             raise ValueError("invalid signature") from e
 
         # 2) Timestamp monotonicity against previous block
-        if self.previous_block and self.previous_block != ZERO32:
+        prev_ts: Optional[int] = None
+        prev_hash = self.previous_block_hash or ZERO32
+
+        if self.previous_block is not None:
+            prev_ts = int(self.previous_block.timestamp or 0)
+            prev_hash = self.previous_block.hash or prev_hash or ZERO32
+
+        if prev_hash and prev_hash != ZERO32 and prev_ts is None:
             # If previous block cannot be loaded, treat as unverifiable, not malicious
             try:
-                prev = Block.from_atom(storage_get, self.previous_block)
+                prev = Block.from_atom(storage_get, prev_hash)
             except Exception:
                 return False
             prev_ts = int(prev.timestamp or 0)
+
+        if prev_hash and prev_hash != ZERO32:
+            if prev_ts is None:
+                return False
             cur_ts = int(self.timestamp or 0)
             if cur_ts < prev_ts + 1:
                 raise ValueError("timestamp must be at least prev+1")

astreum/_consensus/chain.py

@@ -1,63 +1,66 @@
 # chain.py
-from typing import Callable, Dict, Optional
-from .block import Block
-from .._storage.atom import ZERO32, Atom
-
-class Chain:
-    def __init__(self, head_block: Block):
-        self.head_block = head_block
-        self.validated_upto_block = None
-        # Root (genesis) hash for this chain; set by validation setup when known
-        self.root: Optional[bytes] = None
-        # Fork position: the head hash of the default/current fork for this chain
-        self.fork_position: Optional[bytes] = getattr(head_block, "hash", None)
-        # Mark the first malicious block encountered during validation; None means not found
-        self.malicious_block_hash: Optional[bytes] = None
-
-    def validate(self, storage_get: Callable[[bytes], Atom]) -> Block:
-        """Validate the chain from head to genesis and return the root block.
-
-        Incorporates per-block validation (signature on body and timestamp
-        monotonicity). Uses a simple cache to avoid duplicate Atom fetches and
-        duplicate block decoding during the backward walk.
-        """
-        # Atom and Block caches for this validation pass
-        atom_cache: Dict[bytes, Optional[Atom]] = {}
-        block_cache: Dict[bytes, Block] = {}
-
-        def get_cached(k: bytes) -> Optional[Atom]:
-            if k in atom_cache:
-                return atom_cache[k]
-            a = storage_get(k)
-            atom_cache[k] = a
-            return a
-
-        def load_block(bid: bytes) -> Block:
-            if bid in block_cache:
-                return block_cache[bid]
-            b = Block.from_atom(get_cached, bid)  # type: ignore[arg-type]
-            block_cache[bid] = b
-            return b
-
-        blk = self.head_block
-        # Ensure head is in cache if it has a hash
-        if getattr(blk, "hash", None):
-            block_cache[blk.hash] = blk  # type: ignore[attr-defined]
-
-        # Walk back, validating each block
-        while True:
-            # Validate current block (signature over body, timestamp rule)
-            try:
-                blk.validate(get_cached)  # may decode previous but uses cached atoms
-            except Exception:
-                # record first failure point then propagate
-                self.malicious_block_hash = getattr(blk, "hash", None)
-                raise
-
-            if blk.previous_block == ZERO32:
-                break
-            # Move to previous block using cache-aware loader
-            blk = load_block(blk.previous_block)
-
-        self.validated_upto_block = blk
-        return blk
+from typing import Callable, Dict, Optional
+from .block import Block
+from .._storage.atom import ZERO32, Atom
+
+class Chain:
+    def __init__(self, head_block: Block):
+        self.head_block = head_block
+        self.validated_upto_block = None
+        # Root (genesis) hash for this chain; set by validation setup when known
+        self.root: Optional[bytes] = None
+        # Fork position: the head hash of the default/current fork for this chain
+        self.fork_position: Optional[bytes] = getattr(head_block, "hash", None)
+        # Mark the first malicious block encountered during validation; None means not found
+        self.malicious_block_hash: Optional[bytes] = None
+
+    def validate(self, storage_get: Callable[[bytes], Atom]) -> Block:
+        """Validate the chain from head to genesis and return the root block.
+
+        Incorporates per-block validation (signature on body and timestamp
+        monotonicity). Uses a simple cache to avoid duplicate Atom fetches and
+        duplicate block decoding during the backward walk.
+        """
+        # Atom and Block caches for this validation pass
+        atom_cache: Dict[bytes, Optional[Atom]] = {}
+        block_cache: Dict[bytes, Block] = {}
+
+        def get_cached(k: bytes) -> Optional[Atom]:
+            if k in atom_cache:
+                return atom_cache[k]
+            a = storage_get(k)
+            atom_cache[k] = a
+            return a
+
+        def load_block(bid: bytes) -> Block:
+            if bid in block_cache:
+                return block_cache[bid]
+            b = Block.from_atom(get_cached, bid)
+            block_cache[bid] = b
+            return b
+
+        blk = self.head_block
+        # Ensure head is in cache if it has a hash
+        if getattr(blk, "hash", None):
+            block_cache[blk.hash] = blk  # type: ignore[attr-defined]
+
+        # Walk back, validating each block
+        while True:
+            # Validate current block (signature over body, timestamp rule)
+            try:
+                blk.validate(get_cached)  # may decode previous but uses cached atoms
+            except Exception:
+                # record first failure point then propagate
+                self.malicious_block_hash = getattr(blk, "hash", None)
+                raise
+
+            prev_hash = blk.previous_block_hash if hasattr(blk, "previous_block_hash") else ZERO32
+            if prev_hash == ZERO32:
+                break
+            # Move to previous block using cache-aware loader
+            prev_blk = load_block(prev_hash)
+            blk.previous_block = prev_blk  # cache the object for any downstream use
+            blk = prev_blk
+
+        self.validated_upto_block = blk
+        return blk