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

astreum/_consensus/genesis.py

@@ -1,77 +1,18 @@
-
+
 from __future__ import annotations
 
-from typing import Any, Iterable, List, Optional, Tuple
+from typing import Any, List
 
 from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
 
 from .account import Account
 from .block import Block
-from .._storage.atom import Atom, ZERO32
-from .._storage.patricia import PatriciaTrie, PatriciaNode
+from .._storage.atom import ZERO32
+from .._storage.patricia import PatriciaTrie
+from ..utils.integer import int_to_bytes
 
 TREASURY_ADDRESS = b"\x01" * 32
 BURN_ADDRESS = b"\x00" * 32
-
-
-def _int_to_be_bytes(value: int) -> bytes:
-    if value < 0:
-        raise ValueError("integer fields in genesis must be non-negative")
-    if value == 0:
-        return b"\x00"
-    length = (value.bit_length() + 7) // 8
-    return value.to_bytes(length, "big")
-
-
-def _make_list(child_ids: List[bytes]) -> Tuple[bytes, List[Atom]]:
-    next_hash = ZERO32
-    chain: 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()
-        chain.append(elem)
-    chain.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 = chain + [value_atom, type_atom]
-    return type_atom.object_id(), atoms
-
-
-def _store_atoms(node: Any, atoms: Iterable[Atom]) -> None:
-    setter = getattr(node, "_local_set", None)
-    if not callable(setter):
-        raise TypeError("node must expose '_local_set(object_id, atom)'")
-    for atom in atoms:
-        setter(atom.object_id(), atom)
-
-
-def _persist_trie(trie: PatriciaTrie, node: Any) -> None:
-    for patricia_node in trie.nodes.values():
-        _, atoms = patricia_node.to_atoms()
-        _store_atoms(node, atoms)
-
-
-if not hasattr(PatriciaNode, "to_bytes"):
-    def _patricia_node_to_bytes(self: PatriciaNode) -> bytes:  # type: ignore[no-redef]
-        fields = [
-            bytes([self.key_len]) + self.key,
-            self.child_0 or ZERO32,
-            self.child_1 or ZERO32,
-            self.value or b"",
-        ]
-        encoded: List[bytes] = []
-        for field in fields:
-            encoded.append(len(field).to_bytes(4, "big"))
-            encoded.append(field)
-        return b"".join(encoded)
-
-    PatriciaNode.to_bytes = _patricia_node_to_bytes  # type: ignore[attr-defined]
-
-
 def create_genesis_block(node: Any, validator_public_key: bytes, validator_secret_key: bytes) -> Block:
     validator_pk = bytes(validator_public_key)
 
@@ -80,30 +21,21 @@ def create_genesis_block(node: Any, validator_public_key: bytes, validator_secre
 
     # 1. Stake trie with single validator stake of 1 (encoded on 32 bytes).
     stake_trie = PatriciaTrie()
-    stake_amount = (1).to_bytes(32, "big")
-    stake_trie.put(node, validator_pk, stake_amount)
-    _persist_trie(stake_trie, node)
-    stake_root = stake_trie.root_hash or ZERO32
+    stake_amount = int_to_bytes(1)
+    stake_trie.put(storage_node=node, key=validator_pk, value=stake_amount)
+    stake_root = stake_trie.root_hash
 
     # 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_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_id, burn_atoms = burn_account.to_atom()
-    _store_atoms(node, burn_atoms)
-    accounts_trie.put(node, BURN_ADDRESS, burn_account_id)
+    treasury_account = Account.create(balance=1, data=stake_root, counter=0)
+    accounts_trie.put(storage_node=node, key=TREASURY_ADDRESS, value=treasury_account.hash)
 
-    validator_account = Account.create(balance=0, data=b"", nonce=0)
-    validator_account_id, validator_atoms = validator_account.to_atom()
-    _store_atoms(node, validator_atoms)
-    accounts_trie.put(node, validator_pk, validator_account_id)
+    burn_account = Account.create(balance=0, data=b"", counter=0)
+    accounts_trie.put(storage_node=node, key=BURN_ADDRESS, value=burn_account.hash)
 
-    _persist_trie(accounts_trie, node)
+    validator_account = Account.create(balance=0, data=b"", counter=0)
+    accounts_trie.put(storage_node=node, key=validator_pk, value=validator_account.hash)
 
     accounts_root = accounts_trie.root_hash
     if accounts_root is None:
@@ -134,8 +66,7 @@ def create_genesis_block(node: Any, validator_public_key: bytes, validator_secre
 
     secret = Ed25519PrivateKey.from_private_bytes(validator_secret_key)
     block.signature = secret.sign(block.body_hash)
-    block_hash, block_atoms = block.to_atom()
-    _store_atoms(node, block_atoms)
+    block_hash, _ = block.to_atom()
 
     block.hash = block_hash
     return block

astreum/_consensus/receipt.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Callable, List, Optional, Tuple
 
-from .._storage.atom import Atom, ZERO32
+from .._storage.atom import Atom, AtomKind, ZERO32
 
 STATUS_SUCCESS = 0
 STATUS_FAILED = 1
@@ -25,52 +25,6 @@ def _be_bytes_to_int(data: Optional[bytes]) -> int:
     return int.from_bytes(data, "big")
 
 
-def _make_list(child_ids: List[bytes]) -> Tuple[bytes, List[Atom]]:
-    atoms: 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()
-    list_value = Atom.from_data(data=len(child_ids).to_bytes(8, "little"), next_hash=next_hash)
-    list_type = Atom.from_data(data=b"list", next_hash=list_value.object_id())
-    atoms.extend(elements)
-    atoms.append(list_value)
-    atoms.append(list_type)
-    return list_type.object_id(), atoms
-
-
-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
-
-
-def _read_payload_bytes(
-    storage_get: Callable[[bytes], Optional[Atom]], object_id: bytes
-) -> bytes:
-    if not object_id or object_id == ZERO32:
-        return b""
-    atom = storage_get(object_id)
-    if atom is None:
-        return b""
-    if atom.data == b"bytes":
-        value_atom = storage_get(atom.next)
-        return value_atom.data if value_atom is not None else b""
-    return atom.data
-
-
 @dataclass
 class Receipt:
     transaction_hash: bytes = ZERO32
@@ -85,31 +39,30 @@ class Receipt:
         if self.status not in (STATUS_SUCCESS, STATUS_FAILED):
             raise ValueError("unsupported receipt status")
 
-        atoms: List[Atom] = []
-
-        tx_atom = Atom.from_data(data=bytes(self.transaction_hash))
-        status_atom = Atom.from_data(data=_int_to_be_bytes(self.status))
-        cost_atom = Atom.from_data(data=_int_to_be_bytes(self.cost))
-        logs_atom = Atom.from_data(data=bytes(self.logs))
-
-        atoms.extend([tx_atom, status_atom, cost_atom, logs_atom])
-
-        body_child_ids = [
-            tx_atom.object_id(),
-            status_atom.object_id(),
-            cost_atom.object_id(),
-            logs_atom.object_id(),
+        detail_specs = [
+            (bytes(self.transaction_hash), AtomKind.LIST),
+            (_int_to_be_bytes(self.status), AtomKind.BYTES),
+            (_int_to_be_bytes(self.cost), AtomKind.BYTES),
+            (bytes(self.logs), AtomKind.BYTES),
         ]
-        body_id, body_atoms = _make_list(body_child_ids)
-        atoms.extend(body_atoms)
-
-        type_atom = Atom.from_data(data=b"receipt", next_hash=body_id)
-        atoms.append(type_atom)
 
-        top_list_id, top_atoms = _make_list([type_atom.object_id(), body_id])
-        atoms.extend(top_atoms)
+        detail_atoms: List[Atom] = []
+        next_hash = ZERO32
+        for payload, kind in reversed(detail_specs):
+            atom = Atom.from_data(data=payload, next_hash=next_hash, kind=kind)
+            detail_atoms.append(atom)
+            next_hash = atom.object_id()
+        detail_atoms.reverse()
+
+        type_atom = Atom.from_data(
+            data=b"receipt",
+            next_hash=next_hash,
+            kind=AtomKind.SYMBOL,
+        )
 
-        return top_list_id, atoms
+        self.hash = type_atom.object_id()
+        atoms = detail_atoms + [type_atom]
+        return self.hash, atoms
 
     def atomize(self) -> Tuple[bytes, List[Atom]]:
         """Generate atoms for this receipt and cache them."""
@@ -125,45 +78,51 @@ class Receipt:
         receipt_id: bytes,
     ) -> Receipt:
         """Materialise a Receipt from Atom storage."""
-        top_type_atom = storage_get(receipt_id)
-        if top_type_atom is None or top_type_atom.data != b"list":
-            raise ValueError("not a receipt (outer list missing)")
-
-        top_value_atom = storage_get(top_type_atom.next)
-        if top_value_atom is None:
-            raise ValueError("malformed receipt (outer value missing)")
-
-        head = top_value_atom.next
-        first_elem = storage_get(head) if head else None
-        if first_elem is None:
-            raise ValueError("malformed receipt (type element missing)")
-
-        type_atom_id = first_elem.data
-        type_atom = storage_get(type_atom_id)
-        if type_atom is None or type_atom.data != b"receipt":
-            raise ValueError("not a receipt (type mismatch)")
-
-        remainder_entries = _read_list_entries(storage_get, first_elem.next)
-        if not remainder_entries:
-            raise ValueError("malformed receipt (body missing)")
-        body_id = remainder_entries[0]
-
-        body_type_atom = storage_get(body_id)
-        if body_type_atom is None or body_type_atom.data != b"list":
-            raise ValueError("malformed receipt body (type)")
-
-        body_value_atom = storage_get(body_type_atom.next)
-        if body_value_atom is None:
-            raise ValueError("malformed receipt body (value)")
-
-        body_entries = _read_list_entries(storage_get, body_value_atom.next)
-        if len(body_entries) < 4:
-            body_entries.extend([ZERO32] * (4 - len(body_entries)))
-
-        transaction_hash_bytes = _read_payload_bytes(storage_get, body_entries[0])
-        status_bytes = _read_payload_bytes(storage_get, body_entries[1])
-        cost_bytes = _read_payload_bytes(storage_get, body_entries[2])
-        logs_bytes = _read_payload_bytes(storage_get, body_entries[3])
+        def _atom_kind(atom: Optional[Atom]) -> Optional[AtomKind]:
+            kind_value = getattr(atom, "kind", None)
+            if isinstance(kind_value, AtomKind):
+                return kind_value
+            if isinstance(kind_value, int):
+                try:
+                    return AtomKind(kind_value)
+                except ValueError:
+                    return None
+            return None
+
+        type_atom = storage_get(receipt_id)
+        if type_atom is None:
+            raise ValueError("missing receipt type atom")
+        if _atom_kind(type_atom) is not AtomKind.SYMBOL:
+            raise ValueError("malformed receipt (type kind)")
+        if type_atom.data != b"receipt":
+            raise ValueError("not a receipt (type payload)")
+
+        details: List[Atom] = []
+        current = type_atom.next
+        while current and current != ZERO32 and len(details) < 4:
+            atom = storage_get(current)
+            if atom is None:
+                raise ValueError("missing receipt detail atom")
+            details.append(atom)
+            current = atom.next
+
+        if current and current != ZERO32:
+            raise ValueError("too many receipt fields")
+        if len(details) != 4:
+            raise ValueError("incomplete receipt fields")
+
+        tx_atom, status_atom, cost_atom, logs_atom = details
+
+        if _atom_kind(tx_atom) is not AtomKind.LIST:
+            raise ValueError("receipt transaction hash must be list-kind")
+        if any(_atom_kind(atom) is not AtomKind.BYTES for atom in [status_atom, cost_atom, logs_atom]):
+            raise ValueError("receipt detail atoms must be bytes-kind")
+
+        transaction_hash_bytes = tx_atom.data or ZERO32
+        status_bytes = status_atom.data
+        cost_bytes = cost_atom.data
+        logs_bytes = logs_atom.data
+
         status_value = _be_bytes_to_int(status_bytes)
         if status_value not in (STATUS_SUCCESS, STATUS_FAILED):
             raise ValueError("unsupported receipt status")

astreum/_consensus/setup.py

@@ -2,13 +2,15 @@ from __future__ import annotations
 
 import threading
 from queue import Queue
-from typing import Any
+from typing import Any, Optional
 
 from .workers import (
     make_discovery_worker,
     make_validation_worker,
     make_verify_worker,
 )
+from .genesis import create_genesis_block
+from ..utils.bytes import hex_to_bytes
 
 
 def current_validator(node: Any) -> bytes:
@@ -16,7 +18,9 @@ def current_validator(node: Any) -> bytes:
     raise NotImplementedError("current_validator must be implemented by the host node")
 
 
-def consensus_setup(node: Any) -> None:
+def consensus_setup(node: Any, config: Optional[dict] = None) -> None:
+    config = config or {}
+
     # Shared state
     node.validation_lock = getattr(node, "validation_lock", threading.RLock())
 
@@ -26,6 +30,12 @@ def consensus_setup(node: Any) -> None:
     node.chains = getattr(node, "chains", {})
     node.forks = getattr(node, "forks", {})
 
+    node.latest_block_hash = None
+    latest_block_hex = config.get("latest_block_hash")
+    if latest_block_hex is not None:
+        node.latest_block_hash = hex_to_bytes(latest_block_hex, expected_length=32)
+    node.latest_block = None
+
     # Pending transactions queue (hash-only entries)
     node._validation_transaction_queue = getattr(
         node, "_validation_transaction_queue", Queue()
@@ -64,5 +74,42 @@ def consensus_setup(node: Any) -> None:
     )
     node.consensus_discovery_thread.start()
     node.consensus_verify_thread.start()
-    if getattr(node, "validation_secret_key", None):
+
+    validator_secret_hex = config.get("validation_secret_key")
+    if validator_secret_hex:
+        validator_secret_bytes = hex_to_bytes(validator_secret_hex, expected_length=32)
+        try:
+            from cryptography.hazmat.primitives import serialization
+            from cryptography.hazmat.primitives.asymmetric import ed25519
+
+            validator_private = ed25519.Ed25519PrivateKey.from_private_bytes(
+                validator_secret_bytes
+            )
+        except Exception as exc:
+            raise ValueError("invalid validation_secret_key") from exc
+
+        validator_public_bytes = validator_private.public_key().public_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw,
+        )
+
+        node.validation_secret_key = validator_private
+        node.validation_public_key = validator_public_bytes
+
+        if node.latest_block_hash is None:
+            genesis_block = create_genesis_block(
+                node,
+                validator_public_key=validator_public_bytes,
+                validator_secret_key=validator_secret_bytes,
+            )
+            genesis_hash, genesis_atoms = genesis_block.to_atom()
+            if hasattr(node, "_local_set"):
+                for atom in genesis_atoms:
+                    try:
+                        node._local_set(atom.object_id(), atom)
+                    except Exception:
+                        pass
+            node.latest_block_hash = genesis_hash
+            node.latest_block = genesis_block
+
         node.consensus_validation_thread.start()