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

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

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Callable, List, Optional, Tuple
 
 from .._storage.atom import Atom, ZERO32
@@ -77,6 +77,8 @@ class Receipt:
     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."""
@@ -109,6 +111,13 @@ class Receipt:
 
         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,
@@ -164,4 +173,5 @@ class Receipt:
             cost=_be_bytes_to_int(cost_bytes),
             logs=logs_bytes,
             status=status_value,
+            hash=bytes(receipt_id),
         )

astreum/_consensus/setup.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
 import threading
-import time
-from queue import Empty, Queue
-from typing import Any, Dict, Optional, Tuple
+from queue import Queue
+from typing import Any
 
-from .block import Block
-from .chain import Chain
-from .fork import Fork
-from .transaction import Transaction, apply_transaction
-from .._storage.atom import ZERO32, Atom
+from .workers import (
+    make_discovery_worker,
+    make_validation_worker,
+    make_verify_worker,
+)
 
 
 def current_validator(node: Any) -> bytes:
@@ -47,159 +46,23 @@ def consensus_setup(node: Any) -> None:
 
     node.enqueue_transaction_hash = enqueue_transaction_hash
 
-    def _process_peers_latest_block(latest_block_hash: bytes, peer_ids: set[Any]) -> None:
-        """Assign a peer to a fork for its latest block without merging forks.
-
-        Flow:
-        - Create a new Fork for `latest_block_hash` and validate it, using
-          stop_heads composed of current fork heads to short-circuit when
-          ancestry meets an existing fork head.
-        - If a matching fork head is found and is not malicious, copy its
-          structural fields (root, validated_upto, chain_fork_position) onto
-          the new fork.
-        - Add all peers in `peer_ids` to the new fork and remove each from any
-          previous fork they followed.
-        - Persist the new fork under `node.forks[latest_block_hash]`.
-        """
-        new_fork = Fork(head=latest_block_hash)
-
-        current_fork_heads = {fk.head for fk in node.forks.values() if fk.head != latest_block_hash}
-
-        new_fork.validate(storage_get=node._local_get, stop_heads=current_fork_heads)
-
-        # update new_fork with details of the fork with head of validated_upto
-        if new_fork.validated_upto and new_fork.validated_upto in node.forks:
-            ref = node.forks[new_fork.validated_upto]
-            # if the matched fork is malicious, disregard this new fork entirely
-            if getattr(ref, "malicious_block_hash", None):
-                return
-            # copy structural fields exactly
-            new_fork.root = ref.root
-            new_fork.validated_upto = ref.validated_upto
-            new_fork.chain_fork_position = ref.chain_fork_position
-
-        # add peers to new fork and remove them from any old forks
-        for peer_id in peer_ids:
-            new_fork.add_peer(peer_id)
-            # Remove this peer from all other forks
-            for h, fk in list(node.forks.items()):
-                if h != latest_block_hash:
-                    fk.remove_peer(peer_id)
-
-        # persist the fork
-        node.forks[latest_block_hash] = new_fork
-
-
-    # Discovery worker: watches peers and enqueues head changes
-    def _discovery_worker():
-        stop = node._validation_stop_event
-        while not stop.is_set():
-            try:
-                peers = getattr(node, "peers", None)
-                if isinstance(peers, dict):
-                    # Snapshot as (peer_id, latest_block_hash) pairs
-                    pairs = [
-                        (peer_id, bytes(latest))
-                        for peer_id, peer in list(peers.items())
-                        if isinstance((latest := getattr(peer, "latest_block", None)), (bytes, bytearray)) and latest
-                    ]
-                    # Group peers by latest block hash
-                    latest_keys = {hb for _, hb in pairs}
-                    grouped: Dict[bytes, set[Any]] = {
-                        hb: {pid for pid, phb in pairs if phb == hb}
-                        for hb in latest_keys
-                    }
-
-                    # Replace queue contents with current groups
-                    try:
-                        while True:
-                            node._validation_verify_queue.get_nowait()
-                    except Empty:
-                        pass
-                    for latest_b, peer_set in grouped.items():
-                        node._validation_verify_queue.put((latest_b, peer_set))
-            except Exception:
-                pass
-            finally:
-                time.sleep(0.5)
-
-    # Verification worker: computes root/height and applies peer→fork assignment
-    def _verify_worker():
-        stop = node._validation_stop_event
-        while not stop.is_set():
-            # Take a snapshot of all currently queued groups
-            batch: list[tuple[bytes, set[Any]]] = []
-            try:
-                while True:
-                    item = node._validation_verify_queue.get_nowait()
-                    batch.append(item)
-            except Empty:
-                pass
-
-            if not batch:
-                time.sleep(0.1)
-                continue
-
-            # Process the snapshot; new items enqueued during processing
-            # will be handled in the next iteration
-            for latest_b, peers in batch:
-                try:
-                    _process_peers_latest_block(latest_b, peers)
-                except Exception:
-                    pass
-
-    def _validation_worker() -> None:
-        """Consume pending transactions when scheduled to validate."""
-        stop = node._validation_stop_event
-        while not stop.is_set():
-            validation_public_key = getattr(node, "validation_public_key", None)
-            if not validation_public_key:
-                time.sleep(0.5)
-                continue
-
-            scheduled_validator = current_validator(node)
-
-            if scheduled_validator != validation_public_key:
-                time.sleep(0.5)
-                continue
-
-            try:
-                current_hash = node._validation_transaction_queue.get_nowait()
-            except Empty:
-                time.sleep(0.1)
-                continue
-
-            new_block = Block()
-            new_block.validator_public_key = getattr(node, "validation_public_key", None)
-            
-            while True:
-                try:
-                    apply_transaction(node, new_block, current_hash)
-                except NotImplementedError:
-                    node._validation_transaction_queue.put(current_hash)
-                    time.sleep(0.5)
-                    break
-                except Exception:
-                    # Skip problematic transaction; leave block as-is.
-                    pass
-
-                try:
-                    current_hash = node._validation_transaction_queue.get_nowait()
-                except Empty:
-                    break
+    verify_worker = make_verify_worker(node)
+    validation_worker = make_validation_worker(
+        node, current_validator=current_validator
+    )
 
     # Start workers as daemons
+    discovery_worker = make_discovery_worker(node)
     node.consensus_discovery_thread = threading.Thread(
-        target=_discovery_worker, daemon=True, name="consensus-discovery"
+        target=discovery_worker, daemon=True, name="consensus-discovery"
     )
     node.consensus_verify_thread = threading.Thread(
-        target=_verify_worker, daemon=True, name="consensus-verify"
+        target=verify_worker, daemon=True, name="consensus-verify"
     )
     node.consensus_validation_thread = threading.Thread(
-        target=_validation_worker, daemon=True, name="consensus-validation"
+        target=validation_worker, daemon=True, name="consensus-validation"
     )
     node.consensus_discovery_thread.start()
     node.consensus_verify_thread.start()
     if getattr(node, "validation_secret_key", None):
         node.consensus_validation_thread.start()
-

astreum/_consensus/transaction.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Callable, List, Optional, Tuple
+from typing import Any, List, Optional, Tuple
 
 from .._storage.atom import Atom, ZERO32
+from .receipt import Receipt, STATUS_SUCCESS
 
 
 def _int_to_be_bytes(value: Optional[int]) -> bytes:
@@ -48,6 +49,7 @@ class Transaction:
     recipient: bytes = b""
     sender: bytes = b""
     signature: bytes = b""
+    hash: bytes = ZERO32
 
     def to_atom(self) -> Tuple[bytes, List[Atom]]:
         """Serialise the transaction, returning (object_id, atoms)."""
@@ -84,9 +86,13 @@ class Transaction:
     @classmethod
     def from_atom(
         cls,
-        storage_get: Callable[[bytes], Optional[Atom]],
+        node: Any,
         transaction_id: bytes,
     ) -> Transaction:
+        storage_get = node._local_get
+        if not callable(storage_get):
+            raise NotImplementedError("node does not expose a storage getter")
+
         top_type_atom = storage_get(transaction_id)
         if top_type_atom is None or top_type_atom.data != b"list":
             raise ValueError("not a transaction (outer list missing)")
@@ -160,9 +166,27 @@ class Transaction:
             recipient=recipient_bytes,
             sender=sender_bytes,
             signature=signature_bytes,
+            hash=bytes(transaction_id),
         )
 
 
 def apply_transaction(node: Any, block: object, transaction_hash: bytes) -> None:
     """Apply transaction to the candidate block. Override downstream."""
-    pass
+    transaction = Transaction.from_atom(node, transaction_hash)
+
+    if block.transactions is None:
+        block.transactions = []
+    block.transactions.append(transaction)
+
+    receipt = Receipt(
+        transaction_hash=bytes(transaction_hash),
+        cost=0,
+        logs=b"",
+        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/_consensus/workers/__init__.py

@@ -0,0 +1,9 @@
+"""
+Worker thread factories for the consensus subsystem.
+"""
+
+from .discovery import make_discovery_worker
+from .validation import make_validation_worker
+from .verify import make_verify_worker
+
+__all__ = ["make_discovery_worker", "make_verify_worker", "make_validation_worker"]

astreum/_consensus/workers/discovery.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import time
+from queue import Empty
+from typing import Any, Dict, Set, Tuple
+
+
+def make_discovery_worker(node: Any):
+    """
+    Build the discovery worker bound to the given node.
+
+    The returned callable mirrors the previous inline worker in ``setup.py``.
+    """
+
+    def _discovery_worker() -> None:
+        stop = node._validation_stop_event
+        while not stop.is_set():
+            try:
+                peers = getattr(node, "peers", None)
+                if isinstance(peers, dict):
+                    pairs: list[Tuple[Any, bytes]] = [
+                        (peer_id, bytes(latest))
+                        for peer_id, peer in list(peers.items())
+                        if isinstance(
+                            (latest := getattr(peer, "latest_block", None)),
+                            (bytes, bytearray),
+                        )
+                        and latest
+                    ]
+                    latest_keys: Set[bytes] = {hb for _, hb in pairs}
+                    grouped: Dict[bytes, set[Any]] = {
+                        hb: {pid for pid, phb in pairs if phb == hb}
+                        for hb in latest_keys
+                    }
+
+                    try:
+                        while True:
+                            node._validation_verify_queue.get_nowait()
+                    except Empty:
+                        pass
+                    for latest_b, peer_set in grouped.items():
+                        node._validation_verify_queue.put((latest_b, peer_set))
+            except Exception:
+                pass
+            finally:
+                time.sleep(0.5)
+
+    return _discovery_worker

astreum/_consensus/workers/validation.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import time
+from queue import Empty
+from typing import Any, Callable
+
+from ..block import Block
+from ..transaction import apply_transaction
+from ..._storage.atom import bytes_list_to_atoms
+from ..._storage.patricia import PatriciaTrie
+from ..._communication.message import Message, MessageTopic
+from ..._communication.ping import Ping
+
+
+def make_validation_worker(
+    node: Any,
+    *,
+    current_validator: Callable[[Any], bytes],
+) -> Callable[[], None]:
+    """Build the validation worker bound to the given node."""
+
+    def _validation_worker() -> None:
+        stop = node._validation_stop_event
+        while not stop.is_set():
+            validation_public_key = getattr(node, "validation_public_key", None)
+            if not validation_public_key:
+                time.sleep(0.5)
+                continue
+
+            scheduled_validator = current_validator(node)
+
+            if scheduled_validator != validation_public_key:
+                time.sleep(0.5)
+                continue
+
+            try:
+                current_hash = node._validation_transaction_queue.get_nowait()
+            except Empty:
+                time.sleep(0.1)
+                continue
+
+            # create thread to perform vdf
+
+            new_block = Block()
+            new_block.validator_public_key = validation_public_key
+            new_block.previous_block_hash = node.latest_block_hash
+            try:
+                new_block.previous_block = Block.from_atom(node, new_block.previous_block_hash)
+            except Exception:
+                continue
+            new_block.accounts = PatriciaTrie(root_hash=new_block.previous_block.accounts_hash)
+
+            # we may want to add a timer to process part of the txs only on a slow computer
+            while True:
+                try:
+                    apply_transaction(node, new_block, current_hash)
+                except NotImplementedError:
+                    node._validation_transaction_queue.put(current_hash)
+                    time.sleep(0.5)
+                    break
+                except Exception:
+                    pass
+
+                try:
+                    current_hash = node._validation_transaction_queue.get_nowait()
+                except Empty:
+                    break
+
+            # create an atom list of transactions, save the list head hash as the block's transactions_hash
+            transactions = new_block.transactions or []
+            tx_hashes = [bytes(tx.hash) for tx in transactions if tx.hash]
+            head_hash, _ = bytes_list_to_atoms(tx_hashes)
+            new_block.transactions_hash = head_hash
+
+            receipts = new_block.receipts or []
+            receipt_hashes = [bytes(rcpt.hash) for rcpt in receipts if rcpt.hash]
+            receipts_head, _ = bytes_list_to_atoms(receipt_hashes)
+            new_block.receipts_hash = receipts_head
+
+            # get vdf result, default to 0 for now
+
+            # get timestamp or wait for a the next second from the previous block, rule is the next block must be atleast 1 second after the previous
+            now = time.time()
+            min_allowed = new_block.previous_block.timestamp + 1
+            if now < min_allowed:
+                time.sleep(max(0.0, min_allowed - now))
+                now = time.time()
+            new_block.timestamp = max(int(now), min_allowed)
+
+            # atomize block
+            new_block_hash, _ = new_block.to_atom()
+            # put as own latest block hash
+            node.latest_block_hash = new_block_hash
+
+            # ping peers in the validation route to update there records
+            if node.validation_route and node.outgoing_queue and node.addresses:
+                route_peers = {
+                    peer_key
+                    for bucket in getattr(node.validation_route, "buckets", {}).values()
+                    for peer_key in bucket
+                }
+                if route_peers:
+                    ping_payload = Ping(
+                        is_validator=True,
+                        latest_block=new_block_hash,
+                    ).to_bytes()
+
+                    message_bytes = Message(
+                        topic=MessageTopic.PING,
+                        content=ping_payload,
+                    ).to_bytes()
+
+                    for address, peer_key in node.addresses.items():
+                        if peer_key in route_peers:
+                            try:
+                                node.outgoing_queue.put((message_bytes, address))
+                            except Exception:
+                                pass
+
+            # store the new block and receipts
+
+    return _validation_worker

astreum/_consensus/workers/verify.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import time
+from queue import Empty
+from typing import Any, Set
+
+from ..fork import Fork
+
+
+def _process_peers_latest_block(
+    node: Any, latest_block_hash: bytes, peer_ids: Set[Any]
+) -> None:
+    """Assign peers to the fork that matches their reported head."""
+    new_fork = Fork(head=latest_block_hash)
+
+    current_fork_heads = {
+        fk.head for fk in node.forks.values() if fk.head != latest_block_hash
+    }
+
+    new_fork.validate(storage_get=node._local_get, stop_heads=current_fork_heads)
+
+    if new_fork.validated_upto and new_fork.validated_upto in node.forks:
+        ref = node.forks[new_fork.validated_upto]
+        if getattr(ref, "malicious_block_hash", None):
+            return
+        new_fork.root = ref.root
+        new_fork.validated_upto = ref.validated_upto
+        new_fork.chain_fork_position = ref.chain_fork_position
+
+    for peer_id in peer_ids:
+        new_fork.add_peer(peer_id)
+        for head, fork in list(node.forks.items()):
+            if head != latest_block_hash:
+                fork.remove_peer(peer_id)
+
+    node.forks[latest_block_hash] = new_fork
+
+
+def make_verify_worker(node: Any):
+    """Build the verify worker bound to the given node."""
+
+    def _verify_worker() -> None:
+        stop = node._validation_stop_event
+        while not stop.is_set():
+            batch: list[tuple[bytes, Set[Any]]] = []
+            try:
+                while True:
+                    latest_b, peers = node._validation_verify_queue.get_nowait()
+                    batch.append((latest_b, peers))
+            except Empty:
+                pass
+
+            if not batch:
+                time.sleep(0.1)
+                continue
+
+            for latest_b, peers in batch:
+                try:
+                    _process_peers_latest_block(node, latest_b, peers)
+                except Exception:
+                    pass
+
+    return _verify_worker