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

astreum/consensus/models/receipt.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import Any, List, Optional, Tuple
+
+from ...storage.models.atom import Atom, AtomKind, 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")
+
+
+class Receipt:
+    def __init__(
+        self,
+        transaction_hash: bytes,
+        cost: int,
+        status: int,
+        logs_hash: bytes = ZERO32,
+    ) -> None:
+        self.transaction_hash = bytes(transaction_hash)
+        self.cost = int(cost)
+        self.logs_hash = bytes(logs_hash)
+        self.status = int(status)
+        self.atom_hash = ZERO32
+        self.atoms: List[Atom] = []
+
+    def to_atom(self) -> Tuple[bytes, List[Atom]]:
+        if self.status not in (STATUS_SUCCESS, STATUS_FAILED):
+            raise ValueError("unsupported receipt status")
+
+        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_hash), AtomKind.LIST),
+        ]
+
+        detail_atoms: List[Atom] = []
+        next_hash = ZERO32
+        for payload, kind in reversed(detail_specs):
+            atom = Atom(data=payload, next_id=next_hash, kind=kind)
+            detail_atoms.append(atom)
+            next_hash = atom.object_id()
+        detail_atoms.reverse()
+
+        type_atom = Atom(data=b"receipt", next_id=next_hash, kind=AtomKind.SYMBOL)
+
+        atoms = detail_atoms + [type_atom]
+        receipt_id = type_atom.object_id()
+        return receipt_id, atoms
+
+    @classmethod
+    def from_atom(cls, node: Any, receipt_id: bytes) -> Receipt:
+        atom_chain = node.get_atom_list_from_storage(receipt_id)
+        if atom_chain is None or len(atom_chain) != 5:
+            raise ValueError("malformed receipt atom chain")
+
+        type_atom, tx_atom, status_atom, cost_atom, logs_atom = atom_chain
+        if type_atom.kind is not AtomKind.SYMBOL or type_atom.data != b"receipt":
+            raise ValueError("not a receipt (type atom)")
+        if tx_atom.kind is not AtomKind.LIST:
+            raise ValueError("receipt transaction hash must be list-kind")
+        if status_atom.kind is not AtomKind.BYTES or cost_atom.kind is not AtomKind.BYTES or logs_atom.kind is not AtomKind.LIST:
+            raise ValueError("receipt detail atoms must be bytes-kind")
+
+        transaction_hash_bytes = tx_atom.data
+        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")
+
+        receipt = cls(
+            transaction_hash=transaction_hash_bytes,
+            cost=_be_bytes_to_int(cost_bytes),
+            logs_hash=logs_bytes,
+            status=status_value,
+        )
+        receipt.atom_hash = bytes(receipt_id)
+        receipt.atoms = atom_chain
+        return receipt

astreum/{_consensus → consensus/models}/transaction.py

@@ -3,14 +3,15 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, List, Optional, Tuple
 
-from .._storage.atom import Atom, AtomKind, ZERO32
-from ..utils.integer import bytes_to_int, int_to_bytes
+from ...storage.models.atom import Atom, AtomKind, ZERO32
+from ...utils.integer import bytes_to_int, int_to_bytes
 from .account import Account
-from .genesis import TREASURY_ADDRESS
+from ..genesis import TREASURY_ADDRESS
 from .receipt import STATUS_FAILED, Receipt, STATUS_SUCCESS
 
 @dataclass
 class Transaction:
+    chain_id: int
     amount: int
     counter: int
     data: bytes = b""
@@ -21,42 +22,40 @@ class Transaction:
 
     def to_atom(self) -> Tuple[bytes, List[Atom]]:
         """Serialise the transaction, returning (object_id, atoms)."""
-        body_child_ids: List[bytes] = []
+        detail_payloads: List[bytes] = []
         acc: List[Atom] = []
 
         def emit(payload: bytes) -> None:
-            atom = Atom.from_data(data=payload, kind=AtomKind.BYTES)
-            body_child_ids.append(atom.object_id())
-            acc.append(atom)
+            detail_payloads.append(payload)
 
+        emit(int_to_bytes(self.chain_id))
         emit(int_to_bytes(self.amount))
         emit(int_to_bytes(self.counter))
         emit(bytes(self.data))
         emit(bytes(self.recipient))
         emit(bytes(self.sender))
 
-        # Build the linked list of body entry references.
-        body_atoms: List[Atom] = []
         body_head = ZERO32
-        for child_id in reversed(body_child_ids):
-            node = Atom.from_data(data=child_id, next_hash=body_head, kind=AtomKind.BYTES)
-            body_head = node.object_id()
-            body_atoms.append(node)
-        body_atoms.reverse()
-        acc.extend(body_atoms)
-
-        body_list_atom = Atom.from_data(data=body_head, kind=AtomKind.LIST)
+        detail_atoms: List[Atom] = []
+        for payload in reversed(detail_payloads):
+            atom = Atom(data=payload, next_id=body_head, kind=AtomKind.BYTES)
+            detail_atoms.append(atom)
+            body_head = atom.object_id()
+        detail_atoms.reverse()
+        acc.extend(detail_atoms)
+
+        body_list_atom = Atom(data=body_head, kind=AtomKind.LIST)
         acc.append(body_list_atom)
         body_list_id = body_list_atom.object_id()
 
-        signature_atom = Atom.from_data(
+        signature_atom = Atom(
             data=bytes(self.signature),
-            next_hash=body_list_id,
+            next_id=body_list_id,
             kind=AtomKind.BYTES,
         )
-        type_atom = Atom.from_data(
+        type_atom = Atom(
             data=b"transaction",
-            next_hash=signature_atom.object_id(),
+            next_id=signature_atom.object_id(),
             kind=AtomKind.SYMBOL,
         )
 
@@ -103,49 +102,38 @@ class Transaction:
                     raise ValueError(f"malformed {context}")
             return atom
 
-        def _read_list(head_id: Optional[bytes], context: str) -> List[bytes]:
-            entries: List[bytes] = []
-            current = head_id if head_id and head_id != ZERO32 else None
-            while current:
-                node = storage_get(current)
-                if node is None:
-                    raise ValueError(f"missing list node while decoding {context}")
-                node_kind = _atom_kind(node)
-                if node_kind is not AtomKind.BYTES:
-                    raise ValueError(f"invalid list node while decoding {context}")
-                if len(node.data) != len(ZERO32):
-                    raise ValueError(f"malformed list entry while decoding {context}")
-                entries.append(node.data)
-                nxt = node.next
-                current = nxt if nxt and nxt != ZERO32 else None
-            return entries
-
-        def _read_detail_bytes(entry_id: Optional[bytes]) -> bytes:
-            if not entry_id or entry_id == ZERO32:
-                return b""
-            detail_atom = storage_get(entry_id)
-            return detail_atom.data if detail_atom is not None else b""
-
         type_atom = _require_atom(transaction_id, "transaction type atom", AtomKind.SYMBOL)
         if type_atom.data != b"transaction":
             raise ValueError("not a transaction (type atom payload)")
 
-        signature_atom = _require_atom(type_atom.next, "transaction signature atom", AtomKind.BYTES)
-        body_list_atom = _require_atom(signature_atom.next, "transaction body list atom", AtomKind.LIST)
-        if body_list_atom.next and body_list_atom.next != ZERO32:
+        signature_atom = _require_atom(type_atom.next_id, "transaction signature atom", AtomKind.BYTES)
+        body_list_atom = _require_atom(signature_atom.next_id, "transaction body list atom", AtomKind.LIST)
+        if body_list_atom.next_id and body_list_atom.next_id != ZERO32:
             raise ValueError("malformed transaction (body list tail)")
 
-        body_entry_ids = _read_list(body_list_atom.data, "transaction body")
-        if len(body_entry_ids) < 5:
-            body_entry_ids.extend([ZERO32] * (5 - len(body_entry_ids)))
-
-        amount_bytes = _read_detail_bytes(body_entry_ids[0])
-        counter_bytes = _read_detail_bytes(body_entry_ids[1])
-        data_bytes = _read_detail_bytes(body_entry_ids[2])
-        recipient_bytes = _read_detail_bytes(body_entry_ids[3])
-        sender_bytes = _read_detail_bytes(body_entry_ids[4])
+        detail_atoms = node.get_atom_list_from_storage(body_list_atom.data)
+        if detail_atoms is None:
+            raise ValueError("missing transaction body list nodes")
+        if len(detail_atoms) != 6:
+            raise ValueError("transaction body must contain exactly 6 detail entries")
+
+        detail_values: List[bytes] = []
+        for detail_atom in detail_atoms:
+            if detail_atom.kind is not AtomKind.BYTES:
+                raise ValueError("transaction detail atoms must be bytes")
+            detail_values.append(detail_atom.data)
+
+        (
+            chain_id_bytes,
+            amount_bytes,
+            counter_bytes,
+            data_bytes,
+            recipient_bytes,
+            sender_bytes,
+        ) = detail_values
 
         return cls(
+            chain_id=bytes_to_int(chain_id_bytes),
             amount=bytes_to_int(amount_bytes),
             counter=bytes_to_int(counter_bytes),
             data=data_bytes,
@@ -156,33 +144,41 @@ class Transaction:
         )
 
 
-def apply_transaction(node: Any, block: object, transaction_hash: bytes) -> None:
-    """Apply transaction to the candidate block. Override downstream."""
+def apply_transaction(node: Any, block: object, transaction_hash: bytes) -> int:
+    """Apply transaction to the candidate block and return the collected fee."""
     transaction = Transaction.from_atom(node, transaction_hash)
 
-    accounts = block.accounts
+    block_chain = getattr(block, "chain_id", None)
+    if block_chain is not None and transaction.chain_id != block_chain:
+        return 0
 
-    sender_account = accounts.get_account(address=transaction.sender, node=node)
+    accounts = getattr(block, "accounts", None)
+    if accounts is None:
+        raise ValueError("block missing accounts snapshot for transaction application")
 
+    sender_account = accounts.get_account(address=transaction.sender, node=node)
     if sender_account is None:
-        return
-    
-    tx_cost = 1 + transaction.amount
+        return 0
+
+    tx_fee = 1
+    tx_cost = tx_fee + transaction.amount
 
     if sender_account.balance < tx_cost:
         low_sender_balance_receipt = Receipt(
-            transaction_hash=transaction_hash,
+            transaction_hash=bytes(transaction_hash),
             cost=0,
-            logs=b"low sender balance",
-            status=STATUS_FAILED
+            status=STATUS_FAILED,
         )
-        low_sender_balance_receipt.atomize()
-        block.receipts.append(receipt)
+        low_sender_balance_receipt.to_atom()
+        if block.receipts is None:
+            block.receipts = []
+        block.receipts.append(low_sender_balance_receipt)
+        if block.transactions is None:
+            block.transactions = []
         block.transactions.append(transaction)
-        return
+        return 0
 
     recipient_account = accounts.get_account(address=transaction.recipient, node=node)
-
     if recipient_account is None:
         recipient_account = Account.create()
 
@@ -198,18 +194,20 @@ def apply_transaction(node: Any, block: object, transaction_hash: bytes) -> None
         recipient_account.balance += transaction.amount
 
     sender_account.balance -= tx_cost
+    accounts.set_account(transaction.sender, sender_account)
+    accounts.set_account(transaction.recipient, recipient_account)
 
-    block.accounts.set_account(address=sender_account)
-
-    block.accounts.set_account(address=recipient_account)
-
-    block.transactions.append(transaction_hash)
+    if block.transactions is None:
+        block.transactions = []
+    block.transactions.append(transaction)
 
     receipt = Receipt(
         transaction_hash=bytes(transaction_hash),
-        cost=0,
-        logs=b"",
+        cost=tx_fee,
         status=STATUS_SUCCESS,
     )
-    receipt.atomize()
+    receipt.to_atom()
+    if block.receipts is None:
+        block.receipts = []
     block.receipts.append(receipt)
+    return tx_fee

astreum/{_consensus → consensus}/setup.py

@@ -4,22 +4,18 @@ import threading
 from queue import Queue
 from typing import Any, Optional
 
+from .validator import current_validator  # re-exported for compatibility
 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:
-    """Return the current validator identifier. Override downstream."""
-    raise NotImplementedError("current_validator must be implemented by the host node")
-
-
 def consensus_setup(node: Any, config: Optional[dict] = None) -> None:
     config = config or {}
+    node.logger.info("Setting up node consensus")
 
     # Shared state
     node.validation_lock = getattr(node, "validation_lock", threading.RLock())
@@ -29,12 +25,22 @@ def consensus_setup(node: Any, config: Optional[dict] = None) -> None:
     # - forks:  Dict[head, Fork]
     node.chains = getattr(node, "chains", {})
     node.forks = getattr(node, "forks", {})
+    node.logger.info(
+        "Consensus maps initialized (chains=%s, forks=%s)",
+        len(node.chains),
+        len(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
+    
+    node.latest_block_hash = getattr(node, "latest_block_hash", None)
+    node.latest_block = getattr(node, "latest_block", None)
+    node.logger.info(
+        "Consensus latest_block_hash preset: %s",
+        node.latest_block_hash.hex() if isinstance(node.latest_block_hash, bytes) else node.latest_block_hash,
+    )
 
     # Pending transactions queue (hash-only entries)
     node._validation_transaction_queue = getattr(
@@ -57,9 +63,7 @@ def consensus_setup(node: Any, config: Optional[dict] = None) -> None:
     node.enqueue_transaction_hash = enqueue_transaction_hash
 
     verify_worker = make_verify_worker(node)
-    validation_worker = make_validation_worker(
-        node, current_validator=current_validator
-    )
+    validation_worker = make_validation_worker(node)
 
     # Start workers as daemons
     discovery_worker = make_discovery_worker(node)
@@ -73,43 +77,7 @@ def consensus_setup(node: Any, config: Optional[dict] = None) -> None:
         target=validation_worker, daemon=True, name="consensus-validation"
     )
     node.consensus_discovery_thread.start()
+    node.logger.info("Started consensus discovery thread (%s)", node.consensus_discovery_thread.name)
     node.consensus_verify_thread.start()
-
-    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()
+    node.logger.info("Started consensus verify thread (%s)", node.consensus_verify_thread.name)
+    node.logger.info("Consensus setup ready")

astreum/consensus/start.py

@@ -0,0 +1,67 @@
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+from astreum.consensus.genesis import create_genesis_block
+
+
+def process_blocks_and_transactions(self, validator_secret_key: Ed25519PrivateKey):
+    """Initialize validator keys, ensure genesis exists, then start validation thread."""
+    self.logger.info(
+        "Initializing block and transaction processing for chain %s",
+        self.config["chain"],
+    )
+
+    self.validation_secret_key = validator_secret_key
+    validator_public_key_obj = self.validation_secret_key.public_key()
+    validator_public_key_bytes = validator_public_key_obj.public_bytes(
+        encoding=serialization.Encoding.Raw,
+        format=serialization.PublicFormat.Raw,
+    )
+    self.validation_public_key = validator_public_key_bytes
+    self.logger.debug(
+        "Derived validator public key %s", validator_public_key_bytes.hex()
+    )
+
+    if self.latest_block_hash is None:
+        genesis_block = create_genesis_block(
+            self,
+            validator_public_key=validator_public_key_bytes,
+            chain_id=self.config["chain_id"],
+        )
+        account_atoms = genesis_block.accounts.update_trie(self) if genesis_block.accounts else []
+
+        genesis_hash, genesis_atoms = genesis_block.to_atom()
+        self.logger.debug(
+            "Genesis block created with %s atoms (%s account atoms)",
+            len(genesis_atoms),
+            len(account_atoms),
+        )
+
+        for atom in account_atoms + genesis_atoms:
+            try:
+                self._hot_storage_set(key=atom.object_id(), value=atom)
+            except Exception as exc:
+                self.logger.warning(
+                    "Unable to persist genesis atom %s: %s",
+                    atom.object_id(),
+                    exc,
+                )
+
+        self.latest_block_hash = genesis_hash
+        self.latest_block = genesis_block
+        self.logger.info("Genesis block stored with hash %s", genesis_hash.hex())
+    else:
+        self.logger.debug(
+            "latest_block_hash already set to %s; skipping genesis creation",
+            self.latest_block_hash.hex()
+            if isinstance(self.latest_block_hash, (bytes, bytearray))
+            else self.latest_block_hash,
+        )
+
+    self.logger.info(
+        "Starting consensus validation thread (%s)",
+        self.consensus_validation_thread.name,
+    )
+    self.consensus_validation_thread.start()
+
+    # ping all peers to announce validation capability

astreum/consensus/validator.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import random
+from typing import Any, Dict, Optional, Tuple
+
+from .genesis import TREASURY_ADDRESS
+from .models.account import Account
+from .models.accounts import Accounts
+from .models.block import Block
+from ..storage.models.atom import ZERO32
+from ..utils.integer import bytes_to_int, int_to_bytes
+
+
+def current_validator(
+    node: Any,
+    block_hash: bytes,
+    target_time: Optional[int] = None,
+) -> Tuple[bytes, Accounts]:
+    """
+    Determine the validator for the requested target_time, halving stakes each second
+    between the referenced block and the target time. Returns the validator key and
+    the updated accounts snapshot reflecting stake and balance adjustments.
+    """
+
+    block = Block.from_atom(node, block_hash)
+
+    if block.timestamp is None:
+        raise ValueError("block timestamp missing")
+
+    block_timestamp = block.timestamp
+    target_timestamp = int(target_time) if target_time is not None else block_timestamp + 1
+    if target_timestamp <= block_timestamp:
+        target_timestamp = block_timestamp + 1
+
+    accounts_hash = getattr(block, "accounts_hash", None)
+    if not accounts_hash:
+        raise ValueError("block missing accounts hash")
+    accounts = Accounts(root_hash=accounts_hash)
+
+    treasury_account = accounts.get_account(TREASURY_ADDRESS, node)
+    if treasury_account is None:
+        raise ValueError("treasury account missing from accounts trie")
+
+    stake_trie = treasury_account.data
+
+    stakes: Dict[bytes, int] = {}
+    for account_key, stake_amount in stake_trie.get_all(node).items():
+        if not account_key:
+            continue
+        stakes[account_key] = bytes_to_int(stake_amount)
+
+    if not stakes:
+        raise ValueError("no validator stakes found in treasury trie")
+
+    seed_source = block_hash or getattr(block, "previous_block_hash", ZERO32)
+    seed_value = int.from_bytes(bytes(seed_source), "big", signed=False)
+    rng = random.Random(seed_value)
+
+    def pick_validator() -> bytes:
+        positive_weights = [(key, weight) for key, weight in stakes.items() if weight > 0]
+        if not positive_weights:
+            raise ValueError("no validators with positive stake")
+        total_weight = sum(weight for _, weight in positive_weights)
+        choice = rng.randrange(total_weight)
+        cumulative = 0
+        for key, weight in sorted(positive_weights, key=lambda item: item[0]):
+            cumulative += weight
+            if choice < cumulative:
+                return key
+        return positive_weights[-1][0]
+
+    def halve_stake(validator_key: bytes) -> None:
+        current_amount = stakes.get(validator_key, 0)
+        if current_amount <= 0:
+            raise ValueError("validator stake must be positive")
+        new_amount = current_amount // 2
+        returned_amount = current_amount - new_amount
+        stakes[validator_key] = new_amount
+        stake_trie.put(node, validator_key, int_to_bytes(new_amount))
+        treasury_account.data_hash = stake_trie.root_hash or ZERO32
+
+        validator_account = accounts.get_account(validator_key, node)
+        if validator_account is None:
+            validator_account = Account.create()
+        validator_account.balance += returned_amount
+        accounts.set_account(validator_key, validator_account)
+        accounts.set_account(TREASURY_ADDRESS, treasury_account)
+
+    iteration_target = block_timestamp + 1
+    while True:
+        selected_validator = pick_validator()
+        halve_stake(selected_validator)
+        if iteration_target == target_timestamp:
+            return selected_validator, accounts
+        iteration_target += 1

astreum/{_consensus → consensus}/workers/discovery.py

@@ -13,6 +13,7 @@ def make_discovery_worker(node: Any):
     """
 
     def _discovery_worker() -> None:
+        node.logger.info("Discovery worker started")
         stop = node._validation_stop_event
         while not stop.is_set():
             try:
@@ -33,6 +34,16 @@ def make_discovery_worker(node: Any):
                         for hb in latest_keys
                     }
 
+                    if not pairs:
+                        node.logger.debug("No peers reported latest blocks; skipping queue update")
+                        continue
+
+                    node.logger.debug(
+                        "Discovery grouped %d block hashes from %d peers",
+                        len(grouped),
+                        len(pairs),
+                    )
+
                     try:
                         while True:
                             node._validation_verify_queue.get_nowait()
@@ -40,9 +51,16 @@ def make_discovery_worker(node: Any):
                         pass
                     for latest_b, peer_set in grouped.items():
                         node._validation_verify_queue.put((latest_b, peer_set))
+                        node.logger.debug(
+                            "Queued %d peers for validation of block %s",
+                            len(peer_set),
+                            latest_b.hex(),
+                        )
             except Exception:
-                pass
+                node.logger.exception("Discovery worker iteration failed")
             finally:
                 time.sleep(0.5)
 
+        node.logger.info("Discovery worker stopped")
+
     return _discovery_worker