astreum 0.2.37__tar.gz → 0.2.39__tar.gz

{astreum-0.2.37/src/astreum.egg-info → astreum-0.2.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.37
+Version: 0.2.39
 Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
 Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
 Project-URL: Homepage, https://github.com/astreum/lib

{astreum-0.2.37 → astreum-0.2.39}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "astreum"
-version = "0.2.37"
+version = "0.2.39"
 authors = [
   { name="Roy R. O. Okello", email="roy@stelar.xyz" },
 ]

{astreum-0.2.37 → astreum-0.2.39}/src/astreum/_communication/setup.py

@@ -1,7 +1,8 @@
 import socket, threading
 from queue import Queue
 from typing import Tuple, Optional
-from cryptography.hazmat.primitives.asymmetric import ed25519
+from cryptography.hazmat.primitives.asymmetric import ed25519
+from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric.x25519 import (
     X25519PrivateKey,
     X25519PublicKey,
@@ -67,10 +68,18 @@ def communication_setup(node: "Node", config: dict):
 
     # key loading
     node.relay_secret_key      = load_x25519(config.get('relay_secret_key'))
-    node.validation_secret_key = load_ed25519(config.get('validation_secret_key'))
-
-    # derive pubs + routes
-    node.relay_public_key      = node.relay_secret_key.public_key()
+    node.validation_secret_key = load_ed25519(config.get('validation_secret_key'))
+
+    # derive pubs + routes
+    node.relay_public_key      = node.relay_secret_key.public_key()
+    node.validation_public_key = (
+        node.validation_secret_key.public_key().public_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw,
+        )
+        if node.validation_secret_key
+        else None
+    )
     node.peer_route, node.validation_route = make_routes(
         node.relay_public_key,
         node.validation_secret_key

{astreum-0.2.37/src/astreum/_validation → astreum-0.2.39/src/astreum/_consensus}/__init__.py

@@ -1,12 +1,14 @@
 from .block import Block
 from .chain import Chain
 from .fork import Fork
-from .setup import validation_setup
-
-
+from .transaction import Transaction
+from .setup import consensus_setup
+
+
 __all__ = [
     "Block",
     "Chain",
     "Fork",
-    "validation_setup",
+    "Transaction",
+    "consensus_setup",
 ]

{astreum-0.2.37/src/astreum/_validation → astreum-0.2.39/src/astreum/_consensus}/setup.py

@@ -2,16 +2,27 @@ from __future__ import annotations
 
 import threading
 import time
-from queue import Queue, Empty
+from queue import Empty, Queue
 from typing import Any, Dict, Optional, Tuple
 
 from .block import Block
 from .chain import Chain
 from .fork import Fork
+from .transaction import Transaction
 from .._storage.atom import ZERO32, Atom
 
 
-def validation_setup(node: Any) -> None:
+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 apply_transaction(node: Any, block: object, transaction_hash: bytes) -> None:
+    """Apply transaction to the candidate block. Override downstream."""
+    pass
+
+
+def consensus_setup(node: Any) -> None:
     # Shared state
     node.validation_lock = getattr(node, "validation_lock", threading.RLock())
 
@@ -21,6 +32,10 @@ def validation_setup(node: Any) -> None:
     node.chains = getattr(node, "chains", {})
     node.forks = getattr(node, "forks", {})
 
+    # Pending transactions queue (hash-only entries)
+    node._validation_transaction_queue = getattr(
+        node, "_validation_transaction_queue", Queue()
+    )
     # Single work queue of grouped items: (latest_block_hash, set(peer_ids))
     node._validation_verify_queue = getattr(
         node, "_validation_verify_queue", Queue()
@@ -29,6 +44,14 @@ def validation_setup(node: Any) -> None:
         node, "_validation_stop_event", threading.Event()
     )
 
+    def enqueue_transaction_hash(tx_hash: bytes) -> None:
+        """Schedule a transaction hash for validation processing."""
+        if not isinstance(tx_hash, (bytes, bytearray)):
+            raise TypeError("transaction hash must be bytes-like")
+        node._validation_transaction_queue.put(bytes(tx_hash))
+
+    node.enqueue_transaction_hash = enqueue_transaction_hash
+
     def _process_peers_latest_block(latest_block_hash: bytes, peer_ids: set[Any]) -> None:
         """Assign a peer to a fork for its latest block without merging forks.
 
@@ -130,6 +153,46 @@ def validation_setup(node: Any) -> None:
                 except Exception:
                     pass
 
+    def _validation_worker() -> None:
+        """Consume pending transactions when scheduled to validate."""
+        stop = node._validation_stop_event
+        while not stop.is_set():
+            validation_public_key = getattr(node, "validation_public_key", None)
+            if not validation_public_key:
+                time.sleep(0.5)
+                continue
+
+            scheduled_validator = current_validator(node)
+
+            if scheduled_validator != validation_public_key:
+                time.sleep(0.5)
+                continue
+
+            try:
+                current_hash = node._validation_transaction_queue.get_nowait()
+            except Empty:
+                time.sleep(0.1)
+                continue
+
+            new_block = Block()
+            new_block.validator_public_key = getattr(node, "validation_public_key", None)
+            
+            while True:
+                try:
+                    apply_transaction(node, new_block, current_hash)
+                except NotImplementedError:
+                    node._validation_transaction_queue.put(current_hash)
+                    time.sleep(0.5)
+                    break
+                except Exception:
+                    # Skip problematic transaction; leave block as-is.
+                    pass
+
+                try:
+                    current_hash = node._validation_transaction_queue.get_nowait()
+                except Empty:
+                    break
+
     # Start workers as daemons
     node.validation_discovery_thread = threading.Thread(
         target=_discovery_worker, daemon=True, name="validation-discovery"
@@ -137,5 +200,10 @@ def validation_setup(node: Any) -> None:
     node.validation_verify_thread = threading.Thread(
         target=_verify_worker, daemon=True, name="validation-verify"
     )
+    node.validation_worker_thread = threading.Thread(
+        target=_validation_worker, daemon=True, name="validation-worker"
+    )
     node.validation_discovery_thread.start()
     node.validation_verify_thread.start()
+    if getattr(node, "validation_secret_key", None):
+        node.validation_worker_thread.start()

astreum-0.2.39/src/astreum/_consensus/transaction.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, List, Optional, Tuple
+
+from .._storage.atom import Atom, ZERO32
+
+
+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")
+
+
+def _make_typed_bytes(payload: bytes) -> Tuple[bytes, List[Atom]]:
+    value_atom = Atom.from_data(data=payload)
+    type_atom = Atom.from_data(data=b"byte", next_hash=value_atom.object_id())
+    return type_atom.object_id(), [value_atom, type_atom]
+
+
+def _make_list(child_ids: List[bytes]) -> Tuple[bytes, List[Atom]]:
+    atoms: List[Atom] = []
+    next_hash = ZERO32
+    chain: List[Atom] = []
+    for child_id in reversed(child_ids):
+        elem = Atom.from_data(data=child_id, next_hash=next_hash)
+        next_hash = elem.object_id()
+        chain.append(elem)
+
+    chain.reverse()
+    list_value = Atom.from_data(data=len(child_ids).to_bytes(8, "little"), next_hash=next_hash)
+    list_type = Atom.from_data(data=b"list", next_hash=list_value.object_id())
+    atoms.extend(chain)
+    atoms.append(list_value)
+    atoms.append(list_type)
+    return list_type.object_id(), atoms
+
+
+@dataclass
+class Transaction:
+    amount: int
+    counter: int
+    data: bytes = b""
+    recipient: bytes = b""
+    sender: bytes = b""
+    signature: bytes = b""
+
+    def to_atom(self) -> Tuple[bytes, List[Atom]]:
+        """Serialise the transaction, returning (object_id, atoms)."""
+        body_child_ids: List[bytes] = []
+        acc: List[Atom] = []
+
+        def emit(payload: bytes) -> None:
+            oid, atoms = _make_typed_bytes(payload)
+            body_child_ids.append(oid)
+            acc.extend(atoms)
+
+        emit(_int_to_be_bytes(self.amount))
+        emit(_int_to_be_bytes(self.counter))
+        emit(bytes(self.data))
+        emit(bytes(self.recipient))
+        emit(bytes(self.sender))
+
+        body_id, body_atoms = _make_list(body_child_ids)
+        acc.extend(body_atoms)
+
+        type_atom = Atom.from_data(data=b"transaction", next_hash=body_id)
+        signature_atom = Atom.from_data(data=bytes(self.signature))
+
+        top_list_id, top_atoms = _make_list(
+            [type_atom.object_id(), body_id, signature_atom.object_id()]
+        )
+
+        atoms: List[Atom] = acc
+        atoms.append(type_atom)
+        atoms.append(signature_atom)
+        atoms.extend(top_atoms)
+        return top_list_id, atoms
+
+    @classmethod
+    def from_atom(
+        cls,
+        storage_get: Callable[[bytes], Optional[Atom]],
+        transaction_id: bytes,
+    ) -> Transaction:
+        top_type_atom = storage_get(transaction_id)
+        if top_type_atom is None or top_type_atom.data != b"list":
+            raise ValueError("not a transaction (outer list missing)")
+
+        top_value_atom = storage_get(top_type_atom.next)
+        if top_value_atom is None:
+            raise ValueError("malformed transaction (outer value missing)")
+
+        head = top_value_atom.next
+        first_elem = storage_get(head)
+        if first_elem is None:
+            raise ValueError("malformed transaction (type element missing)")
+
+        type_atom_id = first_elem.data
+        type_atom = storage_get(type_atom_id)
+        if type_atom is None or type_atom.data != b"transaction":
+            raise ValueError("not a transaction (type mismatch)")
+
+        def read_list_entries(start: bytes) -> List[bytes]:
+            entries: List[bytes] = []
+            current = start if start != ZERO32 else b""
+            while current:
+                elem = storage_get(current)
+                if elem is None:
+                    break
+                entries.append(elem.data)
+                nxt = elem.next
+                current = nxt if nxt != ZERO32 else b""
+            return entries
+
+        remainder_entries = read_list_entries(first_elem.next)
+        if len(remainder_entries) < 2:
+            raise ValueError("malformed transaction (body/signature missing)")
+
+        body_id, signature_atom_id = remainder_entries[0], remainder_entries[1]
+
+        body_type_atom = storage_get(body_id)
+        if body_type_atom is None or body_type_atom.data != b"list":
+            raise ValueError("malformed transaction body (type)")
+
+        body_value_atom = storage_get(body_type_atom.next)
+        if body_value_atom is None:
+            raise ValueError("malformed transaction body (value)")
+
+        body_entries = read_list_entries(body_value_atom.next)
+        if len(body_entries) < 5:
+            body_entries.extend([ZERO32] * (5 - len(body_entries)))
+
+        def read_typed_bytes(entry_id: bytes) -> bytes:
+            if not entry_id or entry_id == ZERO32:
+                return b""
+            elem = storage_get(entry_id)
+            if elem is None:
+                return b""
+            type_atom = storage_get(elem.data)
+            if type_atom is None or type_atom.data != b"byte":
+                return b""
+            value_atom = storage_get(type_atom.next)
+            return value_atom.data if value_atom is not None else b""
+
+        amount_bytes = read_typed_bytes(body_entries[0])
+        counter_bytes = read_typed_bytes(body_entries[1])
+        data_bytes = read_typed_bytes(body_entries[2])
+        recipient_bytes = read_typed_bytes(body_entries[3])
+        sender_bytes = read_typed_bytes(body_entries[4])
+
+        signature_atom = storage_get(signature_atom_id)
+        signature_bytes = signature_atom.data if signature_atom is not None else b""
+
+        return cls(
+            amount=_be_bytes_to_int(amount_bytes),
+            counter=_be_bytes_to_int(counter_bytes),
+            data=data_bytes,
+            recipient=recipient_bytes,
+            sender=sender_bytes,
+            signature=signature_bytes,
+        )

{astreum-0.2.37 → astreum-0.2.39}/src/astreum/_node.py

@@ -25,9 +25,9 @@ class Node:
             communication_setup(node=self, config=config)
         except Exception:
             pass
-        try:
-            from astreum._validation import validation_setup  # type: ignore
-            validation_setup(node=self)
+        try:
+            from astreum._consensus import consensus_setup  # type: ignore
+            consensus_setup(node=self)
         except Exception:
             pass
 

{astreum-0.2.37 → astreum-0.2.39/src/astreum.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.37
+Version: 0.2.39
 Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
 Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
 Project-URL: Homepage, https://github.com/astreum/lib

{astreum-0.2.37 → astreum-0.2.39}/src/astreum.egg-info/SOURCES.txt

@@ -14,6 +14,13 @@ src/astreum/_communication/__init__.py
 src/astreum/_communication/peer.py
 src/astreum/_communication/route.py
 src/astreum/_communication/setup.py
+src/astreum/_consensus/__init__.py
+src/astreum/_consensus/block.py
+src/astreum/_consensus/chain.py
+src/astreum/_consensus/fork.py
+src/astreum/_consensus/genesis.py
+src/astreum/_consensus/setup.py
+src/astreum/_consensus/transaction.py
 src/astreum/_lispeum/__init__.py
 src/astreum/_lispeum/environment.py
 src/astreum/_lispeum/expression.py
@@ -24,12 +31,6 @@ src/astreum/_lispeum/parser.py
 src/astreum/_lispeum/tokenizer.py
 src/astreum/_storage/__init__.py
 src/astreum/_storage/atom.py
-src/astreum/_validation/__init__.py
-src/astreum/_validation/block.py
-src/astreum/_validation/chain.py
-src/astreum/_validation/fork.py
-src/astreum/_validation/genesis.py
-src/astreum/_validation/setup.py
 src/astreum/crypto/__init__.py
 src/astreum/crypto/ed25519.py
 src/astreum/crypto/quadratic_form.py