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

astreum/_consensus/fork.py

@@ -1,98 +1,100 @@
-from __future__ import annotations
-
+from __future__ import annotations
+
 from typing import Optional, Set, Any, Callable, Dict
-from .block import Block
-from .._storage.atom import ZERO32, Atom
-
-
-class Fork:
-    """A branch head within a Chain (same root).
-
-    - head:       current tip block id (bytes)
-    - peers:      identifiers (e.g., peer pubkey objects) following this head
-    - root:       genesis block id for this chain (optional)
-    - validated_upto: earliest verified ancestor (optional)
-    - chain_fork_position: the chain's fork anchor relevant to this fork
-    """
-
-    def __init__(
-        self,
-        head: bytes,
-    ) -> None:
-        self.head: bytes = head
-        self.peers: Set[Any] = set()
-        self.root: Optional[bytes] = None
-        self.validated_upto: Optional[bytes] = None
-        self.chain_fork_position: Optional[bytes] = None
-        # Mark the first block found malicious during validation; None means not found
-        self.malicious_block_hash: Optional[bytes] = None
-
-    def add_peer(self, peer_id: Any) -> None:
-        self.peers.add(peer_id)
-
-    def remove_peer(self, peer_id: Any) -> None:
-        self.peers.discard(peer_id)
-
-    def validate(
-        self,
-        storage_get: Callable[[bytes], Optional[object]],
-        stop_heads: Optional[Set[bytes]] = None,
-    ) -> bool:
-        """Validate only up to the chain fork position, not genesis.
-
-        Returns True if self.head descends from self.chain_fork_position (or if
-        chain_fork_position is None/equals head), and updates validated_upto to
-        that anchor. If stop_heads is provided, returns True early if ancestry
-        reaches any of those heads, setting validated_upto to the matched head.
-        Returns False if ancestry cannot be confirmed.
-        """
-        if self.chain_fork_position is None or self.chain_fork_position == self.head:
-            self.validated_upto = self.head
-            return True
-        # Caches to avoid double fetching/decoding
-        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)  # type: ignore[call-arg]
-            atom_cache[k] = a  # may be None if missing
-            return a
-
-        def load_block(bid: bytes) -> Optional[Block]:
-            if bid in block_cache:
-                return block_cache[bid]
-            try:
-                b = Block.from_atom(get_cached, bid)  # type: ignore[arg-type]
-            except Exception:
-                return None
-            block_cache[bid] = b
-            return b
-
-        blk = load_block(self.head)
-        if blk is None:
-            # Missing head data: unverifiable, not malicious
-            return False
-        # Walk up to fork anchor, validating each block signature + timestamp
-        while True:
-            try:
-                blk.validate(get_cached)  # type: ignore[arg-type]
-            except Exception:
-                # mark the first failure point
-                self.malicious_block_hash = blk.hash
-                return False
-
-            # Early-exit if we met another known fork head
-            if stop_heads and blk.hash in stop_heads:
-                self.validated_upto = blk.hash
-                return True
-
-            if blk.hash == self.chain_fork_position:
-                self.validated_upto = blk.hash
-                return True
-            
-            nxt = load_block(blk.previous_block)
-            if nxt is None:
-                return False
-            blk = nxt
+from .block import Block
+from .._storage.atom import ZERO32, Atom
+
+
+class Fork:
+    """A branch head within a Chain (same root).
+
+    - head:       current tip block id (bytes)
+    - peers:      identifiers (e.g., peer pubkey objects) following this head
+    - root:       genesis block id for this chain (optional)
+    - validated_upto: earliest verified ancestor (optional)
+    - chain_fork_position: the chain's fork anchor relevant to this fork
+    """
+
+    def __init__(
+        self,
+        head: bytes,
+    ) -> None:
+        self.head: bytes = head
+        self.peers: Set[Any] = set()
+        self.root: Optional[bytes] = None
+        self.validated_upto: Optional[bytes] = None
+        self.chain_fork_position: Optional[bytes] = None
+        # Mark the first block found malicious during validation; None means not found
+        self.malicious_block_hash: Optional[bytes] = None
+
+    def add_peer(self, peer_id: Any) -> None:
+        self.peers.add(peer_id)
+
+    def remove_peer(self, peer_id: Any) -> None:
+        self.peers.discard(peer_id)
+
+    def validate(
+        self,
+        storage_get: Callable[[bytes], Optional[object]],
+        stop_heads: Optional[Set[bytes]] = None,
+    ) -> bool:
+        """Validate only up to the chain fork position, not genesis.
+
+        Returns True if self.head descends from self.chain_fork_position (or if
+        chain_fork_position is None/equals head), and updates validated_upto to
+        that anchor. If stop_heads is provided, returns True early if ancestry
+        reaches any of those heads, setting validated_upto to the matched head.
+        Returns False if ancestry cannot be confirmed.
+        """
+        if self.chain_fork_position is None or self.chain_fork_position == self.head:
+            self.validated_upto = self.head
+            return True
+        # Caches to avoid double fetching/decoding
+        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)  # type: ignore[call-arg]
+            atom_cache[k] = a  # may be None if missing
+            return a
+
+        def load_block(bid: bytes) -> Optional[Block]:
+            if bid in block_cache:
+                return block_cache[bid]
+            try:
+                b = Block.from_atom(get_cached, bid)
+            except Exception:
+                return None
+            block_cache[bid] = b
+            return b
+
+        blk = load_block(self.head)
+        if blk is None:
+            # Missing head data: unverifiable, not malicious
+            return False
+        # Walk up to fork anchor, validating each block signature + timestamp
+        while True:
+            try:
+                blk.validate(get_cached)  # type: ignore[arg-type]
+            except Exception:
+                # mark the first failure point
+                self.malicious_block_hash = blk.hash
+                return False
+
+            # Early-exit if we met another known fork head
+            if stop_heads and blk.hash in stop_heads:
+                self.validated_upto = blk.hash
+                return True
+
+            if blk.hash == self.chain_fork_position:
+                self.validated_upto = blk.hash
+                return True
+            
+            prev_hash = blk.previous_block_hash if hasattr(blk, "previous_block_hash") else ZERO32
+            nxt = load_block(prev_hash)
+            if nxt is None:
+                return False
+            blk.previous_block = nxt  # cache for future use
+            blk = nxt

astreum/_consensus/genesis.py

@@ -0,0 +1,141 @@
+
+from __future__ import annotations
+
+from typing import Any, Iterable, List, Optional, Tuple
+
+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
+
+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)
+
+    if len(validator_pk) != 32:
+        raise ValueError("validator_public_key must be 32 bytes")
+
+    # 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
+
+    # 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)
+
+    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)
+
+    _persist_trie(accounts_trie, node)
+
+    accounts_root = accounts_trie.root_hash
+    if accounts_root is None:
+        raise ValueError("genesis accounts trie is empty")
+
+    # 3. Assemble block metadata.
+    block = Block()
+    block.previous_block_hash = ZERO32
+    block.number = 0
+    block.timestamp = 0
+    block.accounts_hash = accounts_root
+    block.accounts = accounts_trie
+    block.transactions_total_fees = 0
+    block.transactions_hash = ZERO32
+    block.receipts_hash = ZERO32
+    block.delay_difficulty = 0
+    block.delay_output = b""
+    block.validator_public_key = validator_pk
+    block.transactions = []
+    block.receipts = []
+
+    # 4. Sign the block body with the validator secret key.
+    block.signature = b""
+    block.to_atom()
+
+    if block.body_hash is None:
+        raise ValueError("failed to materialise genesis block body")
+
+    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_hash
+    return block

astreum/_consensus/receipt.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable, List, Optional, Tuple
+
+from .._storage.atom import Atom, ZERO32
+
+STATUS_SUCCESS = 0
+STATUS_FAILED = 1
+
+
+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")
+
+
+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
+    cost: int = 0
+    logs: bytes = b""
+    status: int = 0
+    hash: bytes = ZERO32
+    atoms: List[Atom] = field(default_factory=list)
+
+    def to_atom(self) -> Tuple[bytes, List[Atom]]:
+        """Serialise the receipt into Atom storage."""
+        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(),
+        ]
+        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)
+
+        return top_list_id, atoms
+
+    def atomize(self) -> Tuple[bytes, List[Atom]]:
+        """Generate atoms for this receipt and cache them."""
+        receipt_id, atoms = self.to_atom()
+        self.hash = receipt_id
+        self.atoms = atoms
+        return receipt_id, atoms
+
+    @classmethod
+    def from_atom(
+        cls,
+        storage_get: Callable[[bytes], Optional[Atom]],
+        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])
+        status_value = _be_bytes_to_int(status_bytes)
+        if status_value not in (STATUS_SUCCESS, STATUS_FAILED):
+            raise ValueError("unsupported receipt status")
+
+        return cls(
+            transaction_hash=transaction_hash_bytes or ZERO32,
+            cost=_be_bytes_to_int(cost_bytes),
+            logs=logs_bytes,
+            status=status_value,
+            hash=bytes(receipt_id),
+        )