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

astreum/consensus/workers/verify.py

@@ -11,8 +11,7 @@ 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(
+    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,
@@ -28,7 +27,7 @@ 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(
+            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,
@@ -45,7 +44,7 @@ def _process_peers_latest_block(
                 fork.remove_peer(peer_id)
 
     node.forks[latest_block_hash] = new_fork
-    node_logger.debug(
+    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),
@@ -57,8 +56,7 @@ 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")
+        node.logger.info("Verify worker started")
         stop = node._validation_stop_event
         while not stop.is_set():
             batch: list[tuple[bytes, Set[Any]]] = []
@@ -70,14 +68,14 @@ def make_verify_worker(node: Any):
                 pass
 
             if not batch:
-                node_logger.debug("Verify queue empty; sleeping")
+                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(
+                    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),
@@ -86,7 +84,7 @@ def make_verify_worker(node: Any):
                     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")
+                    node.logger.exception("Failed processing verification batch for %s", latest_hex)
+        node.logger.info("Verify worker stopped")
 
     return _verify_worker

astreum/crypto/chacha20poly1305.py

@@ -0,0 +1,74 @@
+import os
+from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305
+
+def encrypt(key: bytes, nonce: bytes, plaintext: bytes, aad: bytes = b"") -> bytes:
+    """
+    Encrypt data using the ChaCha20-Poly1305 AEAD construction.
+
+    This function provides both confidentiality and integrity. The returned
+    value contains the ciphertext with the Poly1305 authentication tag
+    appended. The same key, nonce, and associated authenticated data (AAD)
+    must be provided during decryption.
+
+    Parameters
+    ----------
+    key : bytes
+        A 32-byte (256-bit) secret key.
+    nonce : bytes
+        A 12-byte nonce. Must be unique per key; nonce reuse with the same key
+        breaks security.
+    plaintext : bytes
+        The data to be encrypted.
+    aad : bytes, optional
+        Associated authenticated data that is not encrypted but is included
+        in authentication (e.g. headers or metadata). Defaults to empty.
+
+    Returns
+    -------
+    bytes
+        The encrypted output consisting of ciphertext followed by the
+        authentication tag.
+
+    Raises
+    ------
+    ValueError
+        If the key or nonce length is invalid.
+    """
+    aead = ChaCha20Poly1305(key)
+    return aead.encrypt(nonce, plaintext, aad)
+
+
+def decrypt(key: bytes, nonce: bytes, ciphertext: bytes, aad: bytes = b"") -> bytes:
+    """
+    Decrypt data encrypted with ChaCha20-Poly1305 and verify its authenticity.
+
+    This function verifies the Poly1305 authentication tag before returning
+    the plaintext. If the ciphertext, nonce, key, or associated authenticated
+    data (AAD) has been altered, decryption fails.
+
+    Parameters
+    ----------
+    key : bytes
+        The same 32-byte (256-bit) secret key used for encryption.
+    nonce : bytes
+        The same 12-byte nonce used for encryption.
+    ciphertext : bytes
+        The encrypted data including the appended authentication tag.
+    aad : bytes, optional
+        The associated authenticated data used during encryption. Must match
+        exactly. Defaults to empty.
+
+    Returns
+    -------
+    bytes
+        The original decrypted plaintext.
+
+    Raises
+    ------
+    cryptography.exceptions.InvalidTag
+        If authentication fails due to tampering or incorrect inputs.
+    ValueError
+        If the key or nonce length is invalid.
+    """
+    aead = ChaCha20Poly1305(key)
+    return aead.decrypt(nonce, ciphertext, aad)

astreum/machine/evaluations/high_evaluation.py

@@ -1,237 +1,237 @@
-from typing import List, Optional, Union
-import uuid
-
-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:
-    return (
-        isinstance(expr, Expr.ListExpr)
-        and bool(expr.elements)
-        and isinstance(expr.elements[0], Expr.Symbol)
-        and expr.elements[0].value == ERROR_SYMBOL
-    )
-
-
-def _hex_symbol_to_bytes(value: Optional[str]) -> Optional[bytes]:
-    if not value:
-        return None
-    data = value.strip()
-    if data.startswith(("0x", "0X")):
-        data = data[2:]
-    if len(data) % 2:
-        data = "0" + data
-    try:
-        return bytes.fromhex(data)
-    except ValueError:
-        return None
-
-
-def _expr_to_bytes(expr: Expr) -> Optional[bytes]:
-    if isinstance(expr, Expr.Bytes):
-        return expr.value
-    if isinstance(expr, Expr.Symbol):
-        return _hex_symbol_to_bytes(expr.value)
-    return None
-
-
-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()
-
-    call_env_id = uuid.uuid4()
-    self.environments[call_env_id] = Env(parent_id=env_id)
-    env_id = call_env_id
-
-    try:
-        # ---------- atoms ----------
-        if _is_error(expr):
-            return expr
-
-        if isinstance(expr, Expr.Symbol):
-            bound = self.env_get(env_id, expr.value)
-            if bound is None:
-                return error_expr("eval", f"unbound symbol '{expr.value}'")
-            return bound
-
-        if not isinstance(expr, Expr.ListExpr):
-            return expr  # Expr.Byte or other literals passthrough
-
-        # ---------- empty / single ----------
-        if len(expr.elements) == 0:
-            return expr
-        if len(expr.elements) == 1:
-            return self.high_eval(expr=expr.elements[0], env_id=env_id, meter=meter)
-
-        tail = expr.elements[-1]
-
-        # ---------- (value name def) ----------
-        if isinstance(tail, Expr.Symbol) and tail.value == "def":
-            if len(expr.elements) < 3:
-                return error_expr("eval", "def expects (value name def)")
-            name_e = expr.elements[-2]
-            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(expr=value_e, env_id=env_id, meter=meter)
-            if _is_error(value_res):
-                return value_res
-            self.env_set(call_env_id, name_e.value, value_res)
-            return value_res
-        
-        # Reference Call
-        # (atom_id ref)
-        if isinstance(tail, Expr.Symbol) and tail.value == "ref":
-            if len(expr.elements) != 2:
-                return error_expr("eval", "ref expects (atom_id ref)")
-            key_bytes = _expr_to_bytes(expr.elements[0])
-            if not key_bytes:
-                return error_expr("eval", "ref expects (atom_id ref)")
-            stored_list = self.get_expr_list_from_storage(key_bytes)
-            if stored_list is None:
-                return error_expr("eval", "ref target not found")
-            return stored_list
-
-        # Low Level Call
-        # (arg1 arg2 ... ((body) sk))
-        if isinstance(tail, Expr.ListExpr):
-            inner = tail.elements
-            if len(inner) >= 2 and isinstance(inner[-1], Expr.Symbol) and inner[-1].value == "sk":
-                body_expr = inner[-2]
-                if not isinstance(body_expr, Expr.ListExpr):
-                    return error_expr("eval", "sk body must be list")
-
-                # helper: turn an Expr into a contiguous bytes buffer
-                def to_bytes(v: Expr) -> Union[bytes, Expr]:
-                    if isinstance(v, Expr.Byte):
-                        return bytes([v.value & 0xFF])
-                    if isinstance(v, Expr.ListExpr):
-                        # expect a list of Expr.Byte
-                        out: bytearray = bytearray()
-                        for el in v.elements:
-                            if isinstance(el, Expr.Byte):
-                                out.append(el.value & 0xFF)
-                            else:
-                                return error_expr("eval", "byte list must contain only Byte elements")
-                        return bytes(out)
-                    if _is_error(v):
-                        return v
-                    return error_expr("eval", "argument must resolve to Byte or (Byte ...)")
-
-                # resolve ALL preceding args into bytes (can be Byte or List[Byte])
-                args_exprs = expr.elements[:-1]
-                arg_bytes: List[bytes] = []
-                for a in args_exprs:
-                    v = self.high_eval(expr=a, env_id=env_id, meter=meter)
-                    if _is_error(v):
-                        return v
-                    vb = to_bytes(v)
-                    if not isinstance(vb, bytes):
-                        if _is_error(vb):
-                            return vb
-                        return error_expr("eval", "unexpected expression while coercing to bytes")
-                    arg_bytes.append(vb)
-
-                # build low-level code with $0-based placeholders ($0 = first arg)
-                code: List[bytes] = []
-
-                def emit(tok: Expr) -> Union[None, Expr]:
-                    if isinstance(tok, Expr.Symbol):
-                        name = tok.value
-                        if name.startswith("$"):
-                            idx_s = name[1:]
-                            if not idx_s.isdigit():
-                                return error_expr("eval", "invalid sk placeholder")
-                            idx = int(idx_s)  # $0 is first
-                            if idx < 0 or idx >= len(arg_bytes):
-                                return error_expr("eval", "arity mismatch in sk placeholder")
-                            code.append(arg_bytes[idx])
-                            return None
-                        code.append(name.encode())
-                        return None
-
-                    if isinstance(tok, Expr.Byte):
-                        code.append(bytes([tok.value & 0xFF]))
-                        return None
-
-                    if isinstance(tok, Expr.ListExpr):
-                        rv = self.high_eval(expr=tok, env_id=env_id, meter=meter)
-                        if _is_error(rv):
-                            return rv
-                        rb = to_bytes(rv)
-                        if not isinstance(rb, bytes):
-                            if _is_error(rb):
-                                return rb
-                            return error_expr("eval", "unexpected expression while coercing list token to bytes")
-                        code.append(rb)
-                        return None
-
-                    if _is_error(tok):
-                        return tok
-
-                    return error_expr("eval", "invalid token in sk body")
-
-                for t in body_expr.elements:
-                    err = emit(t)
-                    if err is not None and _is_error(err):
-                        return err
-
-                # Execute low-level code built from sk-body using the caller's meter
-                res = self.low_eval(code, meter=meter)
-                return res
-
-        # High Level Call
-        # (arg1 arg2 ... ((body) (params) fn))
-        if isinstance(tail, Expr.ListExpr):
-            fn_form = tail
-            if (len(fn_form.elements) >= 3
-                and isinstance(fn_form.elements[-1], Expr.Symbol)
-                and fn_form.elements[-1].value == "fn"):
-
-                body_expr   = fn_form.elements[-3]
-                params_expr = fn_form.elements[-2]
-
-                if not isinstance(body_expr, Expr.ListExpr):
-                    return error_expr("eval", "fn body must be list")
-                if not isinstance(params_expr, Expr.ListExpr):
-                    return error_expr("eval", "fn params must be list")
-
-                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)
-
-                args_exprs = expr.elements[:-1]
-                if len(args_exprs) != len(params):
-                    return error_expr("eval", "arity mismatch")
-
-                arg_bytes: List[bytes] = []
-                for a in args_exprs:
-                    v = self.high_eval(expr=a, env_id=env_id, meter=meter)
-                    if _is_error(v):
-                        return v
-                    if not isinstance(v, Expr.Byte):
-                        return error_expr("eval", "argument must resolve to Byte")
-                    arg_bytes.append(bytes([v.value & 0xFF]))
-
-                # child env, bind params -> Expr.Byte
-                child_env = uuid.uuid4()
-                self.environments[child_env] = Env(parent_id=env_id)
-                try:
-                    for name_b, val_b in zip(params, arg_bytes):
-                        self.env_set(child_env, name_b, Expr.Byte(val_b[0]))
-
-                    # evaluate HL body, metered from the top
-                    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(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)
+from typing import List, Optional, Union
+import uuid
+
+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:
+    return (
+        isinstance(expr, Expr.ListExpr)
+        and bool(expr.elements)
+        and isinstance(expr.elements[0], Expr.Symbol)
+        and expr.elements[0].value == ERROR_SYMBOL
+    )
+
+
+def _hex_symbol_to_bytes(value: Optional[str]) -> Optional[bytes]:
+    if not value:
+        return None
+    data = value.strip()
+    if data.startswith(("0x", "0X")):
+        data = data[2:]
+    if len(data) % 2:
+        data = "0" + data
+    try:
+        return bytes.fromhex(data)
+    except ValueError:
+        return None
+
+
+def _expr_to_bytes(expr: Expr) -> Optional[bytes]:
+    if isinstance(expr, Expr.Bytes):
+        return expr.value
+    if isinstance(expr, Expr.Symbol):
+        return _hex_symbol_to_bytes(expr.value)
+    return None
+
+
+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()
+
+    call_env_id = uuid.uuid4()
+    self.environments[call_env_id] = Env(parent_id=env_id)
+    env_id = call_env_id
+
+    try:
+        # ---------- atoms ----------
+        if _is_error(expr):
+            return expr
+
+        if isinstance(expr, Expr.Symbol):
+            bound = self.env_get(env_id, expr.value)
+            if bound is None:
+                return error_expr("eval", f"unbound symbol '{expr.value}'")
+            return bound
+
+        if not isinstance(expr, Expr.ListExpr):
+            return expr  # Expr.Bytes or other literals passthrough
+
+        # ---------- empty / single ----------
+        if len(expr.elements) == 0:
+            return expr
+        if len(expr.elements) == 1:
+            return self.high_eval(expr=expr.elements[0], env_id=env_id, meter=meter)
+
+        tail = expr.elements[-1]
+
+        # ---------- (value name def) ----------
+        if isinstance(tail, Expr.Symbol) and tail.value == "def":
+            if len(expr.elements) < 3:
+                return error_expr("eval", "def expects (value name def)")
+            name_e = expr.elements[-2]
+            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(expr=value_e, env_id=env_id, meter=meter)
+            if _is_error(value_res):
+                return value_res
+            self.env_set(call_env_id, name_e.value, value_res)
+            return value_res
+        
+        # Reference Call
+        # (atom_id ref)
+        if isinstance(tail, Expr.Symbol) and tail.value == "ref":
+            if len(expr.elements) != 2:
+                return error_expr("eval", "ref expects (atom_id ref)")
+            key_bytes = _expr_to_bytes(expr.elements[0])
+            if not key_bytes:
+                return error_expr("eval", "ref expects (atom_id ref)")
+            stored_list = self.get_expr_list_from_storage(key_bytes)
+            if stored_list is None:
+                return error_expr("eval", "ref target not found")
+            return stored_list
+
+        # Low Level Call
+        # (arg1 arg2 ... ((body) sk))
+        if isinstance(tail, Expr.ListExpr):
+            inner = tail.elements
+            if len(inner) >= 2 and isinstance(inner[-1], Expr.Symbol) and inner[-1].value == "sk":
+                body_expr = inner[-2]
+                if not isinstance(body_expr, Expr.ListExpr):
+                    return error_expr("eval", "sk body must be list")
+
+                # helper: turn an Expr into a contiguous bytes buffer
+                def to_bytes(v: Expr) -> Union[bytes, Expr]:
+                    if isinstance(v, Expr.Bytes):
+                        return v.value
+                    if isinstance(v, Expr.ListExpr):
+                        # expect a list of Expr.Bytes
+                        out: bytearray = bytearray()
+                        for el in v.elements:
+                            if isinstance(el, Expr.Bytes):
+                                out.extend(el.value)
+                            else:
+                                return error_expr("eval", "byte list must contain only Bytes elements")
+                        return bytes(out)
+                    if _is_error(v):
+                        return v
+                    return error_expr("eval", "argument must resolve to Bytes or (Bytes ...)")
+
+                # resolve ALL preceding args into bytes (can be Bytes or List[Bytes])
+                args_exprs = expr.elements[:-1]
+                arg_bytes: List[bytes] = []
+                for a in args_exprs:
+                    v = self.high_eval(expr=a, env_id=env_id, meter=meter)
+                    if _is_error(v):
+                        return v
+                    vb = to_bytes(v)
+                    if not isinstance(vb, bytes):
+                        if _is_error(vb):
+                            return vb
+                        return error_expr("eval", "unexpected expression while coercing to bytes")
+                    arg_bytes.append(vb)
+
+                # build low-level code with $0-based placeholders ($0 = first arg)
+                code: List[bytes] = []
+
+                def emit(tok: Expr) -> Union[None, Expr]:
+                    if isinstance(tok, Expr.Symbol):
+                        name = tok.value
+                        if name.startswith("$"):
+                            idx_s = name[1:]
+                            if not idx_s.isdigit():
+                                return error_expr("eval", "invalid sk placeholder")
+                            idx = int(idx_s)  # $0 is first
+                            if idx < 0 or idx >= len(arg_bytes):
+                                return error_expr("eval", "arity mismatch in sk placeholder")
+                            code.append(arg_bytes[idx])
+                            return None
+                        code.append(name.encode())
+                        return None
+
+                    if isinstance(tok, Expr.Bytes):
+                        code.append(tok.value)
+                        return None
+
+                    if isinstance(tok, Expr.ListExpr):
+                        rv = self.high_eval(expr=tok, env_id=env_id, meter=meter)
+                        if _is_error(rv):
+                            return rv
+                        rb = to_bytes(rv)
+                        if not isinstance(rb, bytes):
+                            if _is_error(rb):
+                                return rb
+                            return error_expr("eval", "unexpected expression while coercing list token to bytes")
+                        code.append(rb)
+                        return None
+
+                    if _is_error(tok):
+                        return tok
+
+                    return error_expr("eval", "invalid token in sk body")
+
+                for t in body_expr.elements:
+                    err = emit(t)
+                    if err is not None and _is_error(err):
+                        return err
+
+                # Execute low-level code built from sk-body using the caller's meter
+                res = self.low_eval(code, meter=meter)
+                return res
+
+        # High Level Call
+        # (arg1 arg2 ... ((body) (params) fn))
+        if isinstance(tail, Expr.ListExpr):
+            fn_form = tail
+            if (len(fn_form.elements) >= 3
+                and isinstance(fn_form.elements[-1], Expr.Symbol)
+                and fn_form.elements[-1].value == "fn"):
+
+                body_expr   = fn_form.elements[-3]
+                params_expr = fn_form.elements[-2]
+
+                if not isinstance(body_expr, Expr.ListExpr):
+                    return error_expr("eval", "fn body must be list")
+                if not isinstance(params_expr, Expr.ListExpr):
+                    return error_expr("eval", "fn params must be list")
+
+                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)
+
+                args_exprs = expr.elements[:-1]
+                if len(args_exprs) != len(params):
+                    return error_expr("eval", "arity mismatch")
+
+                arg_bytes: List[bytes] = []
+                for a in args_exprs:
+                    v = self.high_eval(expr=a, env_id=env_id, meter=meter)
+                    if _is_error(v):
+                        return v
+                    if not isinstance(v, Expr.Bytes):
+                        return error_expr("eval", "argument must resolve to Bytes")
+                    arg_bytes.append(v.value)
+
+                # child env, bind params -> Expr.Bytes
+                child_env = uuid.uuid4()
+                self.environments[child_env] = Env(parent_id=env_id)
+                try:
+                    for name_b, val_b in zip(params, arg_bytes):
+                        self.env_set(child_env, name_b, Expr.Bytes(val_b))
+
+                    # evaluate HL body, metered from the top
+                    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(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)