astreum 0.2.41__py3-none-any.whl → 0.3.1__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/models/transaction.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, List, Optional, Tuple
+
+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 .receipt import STATUS_FAILED, Receipt, STATUS_SUCCESS
+
+@dataclass
+class Transaction:
+    chain_id: int
+    amount: int
+    counter: int
+    data: bytes = b""
+    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)."""
+        detail_payloads: List[bytes] = []
+        acc: List[Atom] = []
+
+        def emit(payload: bytes) -> None:
+            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))
+
+        body_head = ZERO32
+        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(
+            data=bytes(self.signature),
+            next_id=body_list_id,
+            kind=AtomKind.BYTES,
+        )
+        type_atom = Atom(
+            data=b"transaction",
+            next_id=signature_atom.object_id(),
+            kind=AtomKind.SYMBOL,
+        )
+
+        acc.append(signature_atom)
+        acc.append(type_atom)
+
+        self.hash = type_atom.object_id()
+        return self.hash, acc
+
+    @classmethod
+    def from_atom(
+        cls,
+        node: Any,
+        transaction_id: bytes,
+    ) -> Transaction:
+        storage_get = getattr(node, "storage_get", None)
+        if not callable(storage_get):
+            raise NotImplementedError("node does not expose a storage getter")
+
+        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
+
+        def _require_atom(
+            atom_id: Optional[bytes],
+            context: str,
+            expected_kind: Optional[AtomKind] = None,
+        ) -> Atom:
+            if not atom_id or atom_id == ZERO32:
+                raise ValueError(f"missing {context}")
+            atom = storage_get(atom_id)
+            if atom is None:
+                raise ValueError(f"missing {context}")
+            if expected_kind is not None:
+                kind = _atom_kind(atom)
+                if kind is not expected_kind:
+                    raise ValueError(f"malformed {context}")
+            return atom
+
+        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_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)")
+
+        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,
+            recipient=recipient_bytes,
+            sender=sender_bytes,
+            signature=signature_atom.data,
+            hash=bytes(transaction_id),
+        )
+
+
+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)
+
+    block_chain = getattr(block, "chain_id", None)
+    if block_chain is not None and transaction.chain_id != block_chain:
+        return 0
+
+    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 0
+
+    tx_fee = 1
+    tx_cost = tx_fee + transaction.amount
+
+    if sender_account.balance < tx_cost:
+        low_sender_balance_receipt = Receipt(
+            transaction_hash=bytes(transaction_hash),
+            cost=0,
+            status=STATUS_FAILED,
+        )
+        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 0
+
+    recipient_account = accounts.get_account(address=transaction.recipient, node=node)
+    if recipient_account is None:
+        recipient_account = Account.create()
+
+    if transaction.recipient == TREASURY_ADDRESS:
+        stake_trie = recipient_account.data
+        existing_stake = stake_trie.get(node, transaction.sender)
+        current_stake = bytes_to_int(existing_stake)
+        new_stake = current_stake + transaction.amount
+        stake_trie.put(node, transaction.sender, int_to_bytes(new_stake))
+        recipient_account.data_hash = stake_trie.root_hash or ZERO32
+        recipient_account.balance += transaction.amount
+    else:
+        recipient_account.balance += transaction.amount
+
+    sender_account.balance -= tx_cost
+    accounts.set_account(transaction.sender, sender_account)
+    accounts.set_account(transaction.recipient, recipient_account)
+
+    if block.transactions is None:
+        block.transactions = []
+    block.transactions.append(transaction)
+
+    receipt = Receipt(
+        transaction_hash=bytes(transaction_hash),
+        cost=tx_fee,
+        status=STATUS_SUCCESS,
+    )
+    receipt.to_atom()
+    if block.receipts is None:
+        block.receipts = []
+    block.receipts.append(receipt)
+    return tx_fee

astreum/{_consensus → consensus}/setup.py

@@ -2,21 +2,21 @@ from __future__ import annotations
 
 import threading
 from queue import Queue
-from typing import Any
+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 ..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")
 
-
-def consensus_setup(node: Any) -> None:
     # Shared state
     node.validation_lock = getattr(node, "validation_lock", threading.RLock())
 
@@ -25,6 +25,22 @@ def consensus_setup(node: Any) -> 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),
+    )
+
+    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_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(
@@ -47,9 +63,7 @@ def consensus_setup(node: Any) -> 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)
@@ -63,6 +77,7 @@ def consensus_setup(node: Any) -> 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()
-    if getattr(node, "validation_secret_key", None):
-        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,68 @@
+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."""
+    node_logger = self.logger
+    node_logger.info(
+        "Initializing block and transaction processing for chain %s",
+        getattr(self, "chain", "unknown"),
+    )
+
+    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
+    node_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.chain,
+        )
+        account_atoms = genesis_block.accounts.update_trie(self) if genesis_block.accounts else []
+
+        genesis_hash, genesis_atoms = genesis_block.to_atom()
+        node_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:
+                node_logger.warning(
+                    "Unable to persist genesis atom %s: %s",
+                    atom.object_id(),
+                    exc,
+                )
+
+        self.latest_block_hash = genesis_hash
+        self.latest_block = genesis_block
+        node_logger.info("Genesis block stored with hash %s", genesis_hash.hex())
+    else:
+        node_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,
+        )
+
+    node_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,8 @@ def make_discovery_worker(node: Any):
     """
 
     def _discovery_worker() -> None:
+        node_logger = node.logger
+        node_logger.info("Discovery worker started")
         stop = node._validation_stop_event
         while not stop.is_set():
             try:
@@ -33,6 +35,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 +52,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