astreum 0.2.37__py3-none-any.whl → 0.2.39__py3-none-any.whl

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/{_validation → _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/{_validation → _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/_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/_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.dist-info → astreum-0.2.39.dist-info}/METADATA

@@ -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.dist-info → astreum-0.2.39.dist-info}/RECORD

@@ -1,11 +1,18 @@
 astreum/__init__.py,sha256=9tzA27B_eG5wRF1SAWJIV7xTmCcR1QFc123b_cvFOa4,345
-astreum/_node.py,sha256=RCGi99yliygs9aduNItlhfGREn7emLxFr7aAWQ1uafc,2220
+astreum/_node.py,sha256=3fpfULVs3MrPBR-ymlvPyuZMi8lv0a8JBnxPb2oFOTU,2214
 astreum/format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
 astreum/node.py,sha256=SuVm1b0QWl1FpDUaLRH1fiFYnXCrPs6qYeUQlPDae8w,38358
 astreum/_communication/__init__.py,sha256=I6TVFC1KXtwwdCjKUkGjOhsLWfC7cECubjzqmm-SwRs,161
 astreum/_communication/peer.py,sha256=DT2vJOzeLyyOj7vTDQ1u1lF5Vc7Epj0Hhie-YfDrzfA,425
 astreum/_communication/route.py,sha256=enWT_1260LJq-L-zK-jtacQ8LbZGquNO9yj-9IglSXE,1232
-astreum/_communication/setup.py,sha256=IzT23T1LNpseJ2m3G1J4g6oXKdywT14g-Saffi2NSqA,3544
+astreum/_communication/setup.py,sha256=6KH144iaHNec9g4cvC8fcLIBY0dvx5OCjV5WVYKNcZo,3865
+astreum/_consensus/__init__.py,sha256=EDwIjOABPYv1c8jL0ib1hd8CuNCovTVrdcwxIy_qhaU,241
+astreum/_consensus/block.py,sha256=4ImViawnG0bhN-TiCk3F0byTlPm9U0l6PdSL53u3bsc,11171
+astreum/_consensus/chain.py,sha256=lOFbz5z0AOeMLchQ2YPRSbIZIdQlnHqDyMJvgdwJ-Iw,2532
+astreum/_consensus/fork.py,sha256=ZGTOVEhSiYJvvLvlC6FV8Zqe62uLTM-cSS3yKrKrLvA,3602
+astreum/_consensus/genesis.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/_consensus/setup.py,sha256=ao9Vcuv8vUUn5yDAFBpjA_ffsmAv0pBeED0eYn997r0,8215
+astreum/_consensus/transaction.py,sha256=LhMGQgXR4RxcEGu6m4aYsKAVhSX_bNt17jMtWaagnHc,5992
 astreum/_lispeum/__init__.py,sha256=LAy2Z-gBBQlByBHRGUKaaQrOB7QzFEEyGRtInmwTpfU,304
 astreum/_lispeum/environment.py,sha256=pJ0rjp9GoQxHhDiPIVei0jP7dZ_Pznso2O_tpp94-Ik,328
 astreum/_lispeum/expression.py,sha256=io8tbCer_1TJee77yRbcNI5q-DPFGa8xZiC80tGvRRQ,1063
@@ -16,12 +23,6 @@ astreum/_lispeum/parser.py,sha256=WOW3sSZWkIzPEy3fYTyl0lrtkMxHL9zRrNSYztPDemQ,22
 astreum/_lispeum/tokenizer.py,sha256=P68uIj4aPKzjuCJ85jfzRi67QztpuXIOC1vvLQueBI4,552
 astreum/_storage/__init__.py,sha256=EmKZNAZmo3UVE3ekOOuckwFnBVjpa0Sy8Oxg72Lgdxc,53
 astreum/_storage/atom.py,sha256=w0O_jw74nGhO0hgxFHk0RmkCIgHXHweBEOVULi7_dhQ,3652
-astreum/_validation/__init__.py,sha256=E2-CITedO5bIHsYG2zMr3vwmV9asF3aRWh2V3bwJShY,189
-astreum/_validation/block.py,sha256=4ImViawnG0bhN-TiCk3F0byTlPm9U0l6PdSL53u3bsc,11171
-astreum/_validation/chain.py,sha256=lOFbz5z0AOeMLchQ2YPRSbIZIdQlnHqDyMJvgdwJ-Iw,2532
-astreum/_validation/fork.py,sha256=ZGTOVEhSiYJvvLvlC6FV8Zqe62uLTM-cSS3yKrKrLvA,3602
-astreum/_validation/genesis.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/_validation/setup.py,sha256=VSuCtLBZ3ieHHlJl3EkI5n4mEjRpgJ9hfKGxeGSrAVo,5592
 astreum/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/crypto/ed25519.py,sha256=FRnvlN0kZlxn4j-sJKl-C9tqiz_0z4LZyXLj3KIj1TQ,1760
 astreum/crypto/quadratic_form.py,sha256=pJgbORey2NTWbQNhdyvrjy_6yjORudQ67jBz2ScHptg,4037
@@ -47,8 +48,8 @@ astreum/relay/setup.py,sha256=ynvGaJdlDtw_f5LLiow2Wo7IRzUjvgk8eSr1Sv4_zTg,2090
 astreum/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/storage/object.py,sha256=knFlvw_tpcC4twSu1DGNpHX31wlANN8E5dgEqIfU--Q,2041
 astreum/storage/setup.py,sha256=1-9ztEFI_BvRDvAA0lAn4mFya8iq65THTArlj--M3Hg,626
-astreum-0.2.37.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.37.dist-info/METADATA,sha256=6VjD2A-MyBa-ahLWr_pJN69GO4lBjcFgv4So48JCsvo,6181
-astreum-0.2.37.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.37.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.37.dist-info/RECORD,,
+astreum-0.2.39.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.2.39.dist-info/METADATA,sha256=htQXaHM7_zULw39odLaHu6wtU-W_sa5IXt0GlxEejGU,6181
+astreum-0.2.39.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.2.39.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.2.39.dist-info/RECORD,,