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

astreum/consensus/workers/validation.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+import time
+from queue import Empty
+from typing import Any, Callable
+
+from ..models.account import Account
+from ..models.accounts import Accounts
+from ..models.block import Block
+from ..models.transaction import apply_transaction
+from ..validator import current_validator
+from ...storage.models.atom import bytes_list_to_atoms
+from ...communication.models.message import Message, MessageTopic
+from ...communication.models.ping import Ping
+
+
+def make_validation_worker(
+    node: Any,
+) -> Callable[[], None]:
+    """Build the validation worker bound to the given node."""
+
+    def _validation_worker() -> None:
+        node_logger = node.logger
+        node_logger.info("Validation worker started")
+        stop = node._validation_stop_event
+
+        def _award_validator_reward(block: Block, reward_amount: int) -> None:
+            """Credit the validator account with the provided reward."""
+            if reward_amount <= 0:
+                return
+            accounts = getattr(block, "accounts", None)
+            validator_key = getattr(block, "validator_public_key", None)
+            if accounts is None or not validator_key:
+                node_logger.debug(
+                    "Skipping validator reward; accounts snapshot or key missing"
+                )
+                return
+            try:
+                validator_account = accounts.get_account(
+                    address=validator_key, node=node
+                )
+            except Exception:
+                node_logger.exception("Unable to load validator account for reward")
+                return
+            if validator_account is None:
+                validator_account = Account.create()
+            validator_account.balance += reward_amount
+            accounts.set_account(validator_key, validator_account)
+
+        while not stop.is_set():
+            validation_public_key = getattr(node, "validation_public_key", None)
+            if not validation_public_key:
+                node_logger.debug("Validation public key unavailable; sleeping")
+                time.sleep(0.5)
+                continue
+
+            latest_block_hash = getattr(node, "latest_block_hash", None)
+            if not isinstance(latest_block_hash, (bytes, bytearray)):
+                node_logger.warning("Missing latest_block_hash; retrying")
+                time.sleep(0.5)
+                continue
+
+            node_logger.debug(
+                "Querying current validator for block %s",
+                latest_block_hash.hex()
+                if isinstance(latest_block_hash, (bytes, bytearray))
+                else latest_block_hash,
+            )
+            try:
+                scheduled_validator, _ = current_validator(node, latest_block_hash)
+            except Exception as exc:
+                node_logger.exception("Unable to determine current validator: %s", exc)
+                time.sleep(0.5)
+                continue
+
+            if scheduled_validator != validation_public_key:
+                expected_hex = (
+                    scheduled_validator.hex()
+                    if isinstance(scheduled_validator, (bytes, bytearray))
+                    else scheduled_validator
+                )
+                node_logger.debug("Current validator mismatch; expected %s", expected_hex)
+                time.sleep(0.5)
+                continue
+
+            try:
+                previous_block = Block.from_atom(node, latest_block_hash)
+            except Exception:
+                node_logger.exception("Unable to load previous block for validation")
+                time.sleep(0.5)
+                continue
+
+            try:
+                current_hash = node._validation_transaction_queue.get_nowait()
+                queue_empty = False
+            except Empty:
+                current_hash = None
+                queue_empty = True
+                node_logger.debug(
+                    "No pending validation transactions; generating empty block"
+                )
+
+            try:
+                accounts_snapshot = Accounts(root_hash=previous_block.accounts_hash)
+            except Exception:
+                accounts_snapshot = None
+                node_logger.warning("Unable to initialise accounts snapshot for block")
+
+            new_block = Block(
+                chain_id=getattr(node, "chain", 0),
+                previous_block_hash=latest_block_hash,
+                previous_block=previous_block,
+                number=(previous_block.number or 0) + 1,
+                timestamp=None,
+                accounts_hash=previous_block.accounts_hash,
+                transactions_total_fees=0,
+                transactions_hash=None,
+                receipts_hash=None,
+                delay_difficulty=None,
+                validator_public_key=validation_public_key,
+                nonce=0,
+                signature=None,
+                accounts=accounts_snapshot,
+                transactions=[],
+                receipts=[],
+            )
+            node_logger.debug(
+                "Creating block #%s extending %s",
+                new_block.number,
+                (
+                    node.latest_block_hash.hex()
+                    if isinstance(node.latest_block_hash, (bytes, bytearray))
+                    else node.latest_block_hash
+                ),
+            )
+
+            # we may want to add a timer to process part of the txs only on a slow computer
+            total_fees = 0
+            while current_hash is not None:
+                try:
+                    total_fees += apply_transaction(node, new_block, current_hash)
+                except NotImplementedError:
+                    tx_hex = (
+                        current_hash.hex()
+                        if isinstance(current_hash, (bytes, bytearray))
+                        else current_hash
+                    )
+                    node_logger.warning("Transaction %s unsupported; re-queued", tx_hex)
+                    node._validation_transaction_queue.put(current_hash)
+                    time.sleep(0.5)
+                    break
+                except Exception:
+                    tx_hex = (
+                        current_hash.hex()
+                        if isinstance(current_hash, (bytes, bytearray))
+                        else current_hash
+                    )
+                    node_logger.exception("Failed applying transaction %s", tx_hex)
+
+                try:
+                    current_hash = node._validation_transaction_queue.get_nowait()
+                except Empty:
+                    current_hash = None
+
+            new_block.transactions_total_fees = total_fees
+            reward_amount = total_fees if total_fees > 0 else 1
+            if total_fees == 0 and queue_empty:
+                node_logger.debug("Awarding base validator reward of 1 aster")
+            elif total_fees > 0:
+                node_logger.debug(
+                    "Collected %d aster in transaction fees for this block", total_fees
+                )
+            _award_validator_reward(new_block, reward_amount)
+
+            # 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
+            node_logger.debug("Block includes %d transactions", len(transactions))
+
+            receipts = new_block.receipts or []
+            receipt_atoms = []
+            receipt_hashes = []
+            for rcpt in receipts:
+                receipt_id, atoms = rcpt.to_atom()
+                receipt_atoms.extend(atoms)
+                receipt_hashes.append(bytes(receipt_id))
+            receipts_head, _ = bytes_list_to_atoms(receipt_hashes)
+            new_block.receipts_hash = receipts_head
+            node_logger.debug("Block includes %d receipts", len(receipts))
+
+            account_atoms = []
+            if new_block.accounts is not None:
+                try:
+                    account_atoms = new_block.accounts.update_trie(node)
+                    new_block.accounts_hash = new_block.accounts.root_hash
+                    node_logger.debug(
+                        "Updated trie for %d cached accounts",
+                        len(new_block.accounts._cache),
+                    )
+                except Exception:
+                    node_logger.exception("Failed to update accounts trie for block")
+
+            now = time.time()
+            min_allowed = new_block.previous_block.timestamp + 1
+            new_block.timestamp = max(int(now), min_allowed)
+
+            new_block.delay_difficulty = Block.calculate_delay_difficulty(
+                previous_timestamp=previous_block.timestamp,
+                current_timestamp=new_block.timestamp,
+                previous_difficulty=previous_block.delay_difficulty,
+            )
+            
+            try:
+                new_block.generate_nonce(difficulty=previous_block.delay_difficulty)
+                node_logger.debug(
+                    "Found nonce %s for block #%s at difficulty %s",
+                    new_block.nonce,
+                    new_block.number,
+                    new_block.delay_difficulty,
+                )
+            except Exception:
+                node_logger.exception("Failed while searching for block nonce")
+                time.sleep(0.5)
+                continue
+
+            # atomize block
+            new_block_hash, new_block_atoms = new_block.to_atom()
+            # put as own latest block hash
+            node.latest_block_hash = new_block_hash
+            node.latest_block = new_block
+            node_logger.info(
+                "Validated block #%s with hash %s (%d atoms)",
+                new_block.number,
+                new_block_hash.hex(),
+                len(new_block_atoms),
+            )
+
+            # ping peers in the validation route to update their 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))
+                                node_logger.debug(
+                                    "Queued validator ping to %s (%s)",
+                                    address,
+                                    peer_key.hex()
+                                    if isinstance(peer_key, (bytes, bytearray))
+                                    else peer_key,
+                                )
+                            except Exception:
+                                node_logger.exception(
+                                    "Failed queueing validator ping to %s", address
+                                )
+
+            # upload block atoms
+            for block_atom in new_block_atoms:
+                atom_id = block_atom.object_id()
+                node._hot_storage_set(key=atom_id, value=block_atom)
+
+            # upload receipt atoms
+            for receipt_atom in receipt_atoms:
+                atom_id = receipt_atom.object_id()
+                node._hot_storage_set(key=atom_id, value=receipt_atom)
+
+            # upload account atoms
+            for account_atom in account_atoms:
+                atom_id = account_atom.object_id()
+                node._hot_storage_set(key=atom_id, value=account_atom)
+
+        node_logger.info("Validation worker stopped")
+
+    return _validation_worker

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

@@ -4,13 +4,19 @@ import time
 from queue import Empty
 from typing import Any, Set
 
-from ..fork import Fork
+from ..models.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."""
+    node_logger = node.logger
+    node_logger.debug(
+        "Processing %d peers reporting block %s",
+        len(peer_ids),
+        latest_block_hash.hex() if isinstance(latest_block_hash, (bytes, bytearray)) else latest_block_hash,
+    )
     new_fork = Fork(head=latest_block_hash)
 
     current_fork_heads = {
@@ -22,6 +28,11 @@ def _process_peers_latest_block(
     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):
+            node_logger.warning(
+                "Skipping fork from block %s referencing malicious fork %s",
+                latest_block_hash.hex() if isinstance(latest_block_hash, (bytes, bytearray)) else latest_block_hash,
+                new_fork.validated_upto.hex() if isinstance(new_fork.validated_upto, (bytes, bytearray)) else new_fork.validated_upto,
+            )
             return
         new_fork.root = ref.root
         new_fork.validated_upto = ref.validated_upto
@@ -34,12 +45,20 @@ def _process_peers_latest_block(
                 fork.remove_peer(peer_id)
 
     node.forks[latest_block_hash] = new_fork
+    node_logger.debug(
+        "Fork %s now has %d peers (total forks %d)",
+        latest_block_hash.hex() if isinstance(latest_block_hash, (bytes, bytearray)) else latest_block_hash,
+        len(new_fork.peers),
+        len(node.forks),
+    )
 
 
 def make_verify_worker(node: Any):
     """Build the verify worker bound to the given node."""
 
     def _verify_worker() -> None:
+        node_logger = node.logger
+        node_logger.info("Verify worker started")
         stop = node._validation_stop_event
         while not stop.is_set():
             batch: list[tuple[bytes, Set[Any]]] = []
@@ -51,13 +70,23 @@ def make_verify_worker(node: Any):
                 pass
 
             if not batch:
+                node_logger.debug("Verify queue empty; sleeping")
                 time.sleep(0.1)
                 continue
 
             for latest_b, peers in batch:
                 try:
                     _process_peers_latest_block(node, latest_b, peers)
+                    node_logger.debug(
+                        "Updated forks from block %s for %d peers",
+                        latest_b.hex() if isinstance(latest_b, (bytes, bytearray)) else latest_b,
+                        len(peers),
+                    )
                 except Exception:
-                    pass
+                    latest_hex = (
+                        latest_b.hex() if isinstance(latest_b, (bytes, bytearray)) else latest_b
+                    )
+                    node_logger.exception("Failed processing verification batch for %s", latest_hex)
+        node_logger.info("Verify worker stopped")
 
     return _verify_worker

astreum/machine/__init__.py

@@ -0,0 +1,20 @@
+from .models.expression import Expr
+from .models.environment import Env
+from .evaluations.low_evaluation import low_eval
+from .models.meter import Meter
+from .parser import parse, ParseError
+from .tokenizer import tokenize
+from .evaluations.high_evaluation import high_eval
+from .evaluations.script_evaluation import script_eval
+
+__all__ = [
+    "Env",
+    "Expr",
+    "low_eval",
+    "Meter",
+    "parse",
+    "tokenize",
+    "high_eval",
+    "ParseError",
+    "script_eval",
+]

astreum/{_lispeum → machine/evaluations}/high_evaluation.py

@@ -1,9 +1,9 @@
 from typing import List, Optional, Union
 import uuid
 
-from .environment import Env
-from .expression import Expr, error_expr, ERROR_SYMBOL
-from .meter import Meter
+from ..models.environment import Env
+from ..models.expression import Expr, error_expr, ERROR_SYMBOL
+from ..models.meter import Meter
 
 
 def _is_error(expr: Expr) -> bool:
@@ -37,7 +37,8 @@ def _expr_to_bytes(expr: Expr) -> Optional[bytes]:
     return None
 
 
-def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
+def high_eval(self, expr: Expr, env_id: Optional[uuid.UUID] = None, meter = None) -> Expr:
+    """Evaluate high-level expressions with scoped environments and metering."""
     if meter is None:
         meter = Meter()
 
@@ -51,7 +52,7 @@ def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
             return expr
 
         if isinstance(expr, Expr.Symbol):
-            bound = self.env_get(env_id, expr.value.encode())
+            bound = self.env_get(env_id, expr.value)
             if bound is None:
                 return error_expr("eval", f"unbound symbol '{expr.value}'")
             return bound
@@ -63,7 +64,7 @@ def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
         if len(expr.elements) == 0:
             return expr
         if len(expr.elements) == 1:
-            return self.high_eval(env_id, expr.elements[0], meter)
+            return self.high_eval(expr=expr.elements[0], env_id=env_id, meter=meter)
 
         tail = expr.elements[-1]
 
@@ -75,10 +76,10 @@ def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
             if not isinstance(name_e, Expr.Symbol):
                 return error_expr("eval", "def name must be symbol")
             value_e = expr.elements[-3]
-            value_res = self.high_eval(env_id, value_e, meter)
+            value_res = self.high_eval(expr=value_e, env_id=env_id, meter=meter)
             if _is_error(value_res):
                 return value_res
-            self.env_set(env_id, name_e.value.encode(), value_res)
+            self.env_set(call_env_id, name_e.value, value_res)
             return value_res
         
         # Reference Call
@@ -124,7 +125,7 @@ def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
                 args_exprs = expr.elements[:-1]
                 arg_bytes: List[bytes] = []
                 for a in args_exprs:
-                    v = self.high_eval(env_id, a, meter)
+                    v = self.high_eval(expr=a, env_id=env_id, meter=meter)
                     if _is_error(v):
                         return v
                     vb = to_bytes(v)
@@ -157,7 +158,7 @@ def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
                         return None
 
                     if isinstance(tok, Expr.ListExpr):
-                        rv = self.high_eval(env_id, tok, meter)
+                        rv = self.high_eval(expr=tok, env_id=env_id, meter=meter)
                         if _is_error(rv):
                             return rv
                         rb = to_bytes(rv)
@@ -198,11 +199,11 @@ def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
                 if not isinstance(params_expr, Expr.ListExpr):
                     return error_expr("eval", "fn params must be list")
 
-                params: List[bytes] = []
+                params: List[str] = []
                 for p in params_expr.elements:
                     if not isinstance(p, Expr.Symbol):
                         return error_expr("eval", "fn param must be symbol")
-                    params.append(p.value.encode())
+                    params.append(p.value)
 
                 args_exprs = expr.elements[:-1]
                 if len(args_exprs) != len(params):
@@ -210,7 +211,7 @@ def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
 
                 arg_bytes: List[bytes] = []
                 for a in args_exprs:
-                    v = self.high_eval(env_id, a, meter)
+                    v = self.high_eval(expr=a, env_id=env_id, meter=meter)
                     if _is_error(v):
                         return v
                     if not isinstance(v, Expr.Byte):
@@ -225,12 +226,12 @@ def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
                         self.env_set(child_env, name_b, Expr.Byte(val_b[0]))
 
                     # evaluate HL body, metered from the top
-                    return self.high_eval(child_env, body_expr, meter)
+                    return self.high_eval(expr=body_expr, env_id=child_env, meter=meter)
                 finally:
                     self.environments.pop(child_env, None)
 
         # ---------- default: resolve each element and return list ----------
-        resolved: List[Expr] = [self.high_eval(env_id, e, meter) for e in expr.elements]
+        resolved: List[Expr] = [self.high_eval(expr=e, env_id=env_id, meter=meter) for e in expr.elements]
         return Expr.ListExpr(resolved)
     finally:
         self.environments.pop(call_env_id, None)