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

astreum/_communication/util.py

@@ -0,0 +1,42 @@
+from typing import Tuple
+
+
+def address_str_to_host_and_port(address: str) -> Tuple[str, int]:
+    """Parse `host:port` (or `[ipv6]:port`) into a tuple."""
+    addr = address.strip()
+    if not addr:
+        raise ValueError("address cannot be empty")
+
+    host: str
+    port_str: str
+
+    if addr.startswith('['):
+        end = addr.find(']')
+        if end == -1:
+            raise ValueError("missing closing ']' in IPv6 address")
+        host = addr[1:end]
+        remainder = addr[end + 1 :]
+        if not remainder.startswith(':'):
+            raise ValueError("missing port separator after IPv6 address")
+        port_str = remainder[1:]
+    else:
+        if ':' not in addr:
+            raise ValueError("address must contain ':' separating host and port")
+        host, port_str = addr.rsplit(':', 1)
+
+    host = host.strip()
+    if not host:
+        raise ValueError("host cannot be empty")
+    port_str = port_str.strip()
+    if not port_str:
+        raise ValueError("port cannot be empty")
+
+    try:
+        port = int(port_str, 10)
+    except ValueError as exc:
+        raise ValueError(f"invalid port number: {port_str}") from exc
+
+    if not (0 < port < 65536):
+        raise ValueError(f"port out of range: {port}")
+
+    return host, port

astreum/_consensus/__init__.py

@@ -1,6 +1,7 @@
 from .block import Block
 from .chain import Chain
 from .fork import Fork
+from .receipt import Receipt
 from .transaction import Transaction
 from .setup import consensus_setup
 
@@ -9,6 +10,7 @@ __all__ = [
     "Block",
     "Chain",
     "Fork",
+    "Receipt",
     "Transaction",
     "consensus_setup",
 ]

astreum/_consensus/block.py

@@ -1,7 +1,12 @@
-
-from typing import Callable, List, Optional, Tuple
+
+from typing import Callable, List, Optional, Tuple, TYPE_CHECKING
 
 from .._storage.atom import Atom, ZERO32
+
+if TYPE_CHECKING:
+    from .._storage.patricia import PatriciaTrie
+    from .transaction import Transaction
+    from .receipt import Receipt
 from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
 from cryptography.exceptions import InvalidSignature
 
@@ -22,16 +27,6 @@ def _be_bytes_to_int(b: Optional[bytes]) -> int:
     return int.from_bytes(b, "big")
 
 
-def _make_typed_bytes(data: bytes) -> Tuple[bytes, List[Atom]]:
-    """Create a typed 'byte' atom for the given payload.
-
-    Returns (object_id, atoms_in_dependency_order).
-    """
-    val = Atom.from_data(data=data)
-    typ = Atom.from_data(data=b"byte", next_hash=val.object_id())
-    return typ.object_id(), [val, typ]
-
-
 def _make_list(child_ids: List[bytes]) -> Tuple[bytes, List[Atom]]:
     """Create a typed 'list' atom for child object ids.
 
@@ -65,15 +60,16 @@ class Block:
              signature_atom = Atom(data=<signature-bytes>)
 
     Details order in body_list:
-      0: previous_block                      (bytes)
+      0: previous_block_hash                 (bytes)
       1: number                              (int → big-endian bytes)
       2: timestamp                           (int → big-endian bytes)
       3: accounts_hash                       (bytes)
       4: transactions_total_fees             (int → big-endian bytes)
-      5: transactions_root_hash              (bytes)
-      6: delay_difficulty                    (int → big-endian bytes)
-      7: delay_output                        (bytes)
-      8: validator_public_key                (bytes)
+      5: transactions_hash                   (bytes)
+      6: receipts_hash                       (bytes)
+      7: delay_difficulty                    (int → big-endian bytes)
+      8: delay_output                        (bytes)
+      9: validator_public_key                (bytes)
 
     Notes:
       - "body tree" is represented here by the body_list id (self.body_hash), not
@@ -85,14 +81,16 @@ class Block:
 
     # essential identifiers
     hash: bytes
-    previous_block: bytes
+    previous_block_hash: bytes
+    previous_block: Optional["Block"]
 
     # block details
     number: Optional[int]
     timestamp: Optional[int]
     accounts_hash: Optional[bytes]
     transactions_total_fees: Optional[int]
-    transactions_root_hash: Optional[bytes]
+    transactions_hash: Optional[bytes]
+    receipts_hash: Optional[bytes]
     delay_difficulty: Optional[int]
     delay_output: Optional[bytes]
     validator_public_key: Optional[bytes]
@@ -101,33 +99,48 @@ class Block:
     body_hash: Optional[bytes]
     signature: Optional[bytes]
 
+    # structures
+    accounts: Optional["PatriciaTrie"]
+    transactions: Optional[List["Transaction"]]
+    receipts: Optional[List["Receipt"]]
+    
+    
+
     def __init__(self) -> None:
         # defaults for safety
         self.hash = b""
-        self.previous_block = ZERO32
+        self.previous_block_hash = ZERO32
+        self.previous_block = None
         self.number = None
         self.timestamp = None
         self.accounts_hash = None
         self.transactions_total_fees = None
-        self.transactions_root_hash = None
+        self.transactions_hash = None
+        self.receipts_hash = None
         self.delay_difficulty = None
         self.delay_output = None
         self.validator_public_key = None
         self.body_hash = None
         self.signature = None
+        self.accounts = None
+        self.transactions = None
+        self.receipts = None
 
     def to_atom(self) -> Tuple[bytes, List[Atom]]:
-        # Build body details as typed bytes, in defined order
+        # Build body details as direct byte atoms, in defined order
         details_ids: List[bytes] = []
         atoms_acc: List[Atom] = []
 
         def _emit(detail_bytes: bytes) -> None:
-            oid, ats = _make_typed_bytes(detail_bytes)
-            details_ids.append(oid)
-            atoms_acc.extend(ats)
-
-        # 0: previous_block
-        _emit(self.previous_block or ZERO32)
+            atom = Atom.from_data(data=detail_bytes)
+            details_ids.append(atom.object_id())
+            atoms_acc.append(atom)
+
+        # 0: previous_block_hash
+        prev_hash = self.previous_block_hash or (self.previous_block.hash if self.previous_block else b"")
+        prev_hash = prev_hash or ZERO32
+        self.previous_block_hash = prev_hash
+        _emit(prev_hash)
         # 1: number
         _emit(_int_to_be_bytes(self.number))
         # 2: timestamp
@@ -136,13 +149,15 @@ class Block:
         _emit(self.accounts_hash or b"")
         # 4: transactions_total_fees
         _emit(_int_to_be_bytes(self.transactions_total_fees))
-        # 5: transactions_root_hash
-        _emit(self.transactions_root_hash or b"")
-        # 6: delay_difficulty
+        # 5: transactions_hash
+        _emit(self.transactions_hash or b"")
+        # 6: receipts_hash
+        _emit(self.receipts_hash or b"")
+        # 7: delay_difficulty
         _emit(_int_to_be_bytes(self.delay_difficulty))
-        # 7: delay_output
+        # 8: delay_output
         _emit(self.delay_output or b"")
-        # 8: validator_public_key
+        # 9: validator_public_key
         _emit(self.validator_public_key or b"")
 
         # Build body list
@@ -206,23 +221,20 @@ class Block:
             raise ValueError("malformed body (value)")
         cur_elem_id = body_val.next
 
-        def _read_typed_bytes(elem_id: bytes) -> bytes:
+        def _read_detail_bytes(elem_id: bytes) -> bytes:
             elem = storage_get(elem_id)
             if elem is None:
                 return b""
             child_id = elem.data
-            typ = storage_get(child_id)
-            if typ is None or typ.data != b"byte":
-                return b""
-            val = storage_get(typ.next)
-            return val.data if val is not None else b""
+            detail = storage_get(child_id)
+            return detail.data if detail is not None else b""
 
         details: List[bytes] = []
-        # We read up to 9 fields if present
-        for _ in range(9):
+        # We read up to 10 fields if present
+        for _ in range(10):
             if not cur_elem_id:
                 break
-            b = _read_typed_bytes(cur_elem_id)
+            b = _read_detail_bytes(cur_elem_id)
             details.append(b)
             nxt = storage_get(cur_elem_id)
             cur_elem_id = nxt.next if nxt is not None else b""
@@ -233,21 +245,23 @@ class Block:
 
         # Map details back per the defined order
         get = lambda i: details[i] if i < len(details) else b""
-        b.previous_block = get(0) or ZERO32
+        b.previous_block_hash = get(0) or ZERO32
+        b.previous_block = None
         b.number = _be_bytes_to_int(get(1))
         b.timestamp = _be_bytes_to_int(get(2))
         b.accounts_hash = get(3) or None
         b.transactions_total_fees = _be_bytes_to_int(get(4))
-        b.transactions_root_hash = get(5) or None
-        b.delay_difficulty = _be_bytes_to_int(get(6))
-        b.delay_output = get(7) or None
-        b.validator_public_key = get(8) or None
+        b.transactions_hash = get(5) or None
+        b.receipts_hash = get(6) or None
+        b.delay_difficulty = _be_bytes_to_int(get(7))
+        b.delay_output = get(8) or None
+        b.validator_public_key = get(9) or None
 
-        # 4) Parse signature if present (supports raw or typed 'byte' atom)
+        # 4) Parse signature if present (supports raw or typed 'bytes' atom)
         if sig_atom_id is not None:
             sa = storage_get(sig_atom_id)
             if sa is not None:
-                if sa.data == b"byte":
+                if sa.data == b"bytes":
                     sval = storage_get(sa.next)
                     b.signature = sval.data if sval is not None else b""
                 else:
@@ -282,13 +296,24 @@ class Block:
             raise ValueError("invalid signature") from e
 
         # 2) Timestamp monotonicity against previous block
-        if self.previous_block and self.previous_block != ZERO32:
+        prev_ts: Optional[int] = None
+        prev_hash = self.previous_block_hash or ZERO32
+
+        if self.previous_block is not None:
+            prev_ts = int(self.previous_block.timestamp or 0)
+            prev_hash = self.previous_block.hash or prev_hash or ZERO32
+
+        if prev_hash and prev_hash != ZERO32 and prev_ts is None:
             # If previous block cannot be loaded, treat as unverifiable, not malicious
             try:
-                prev = Block.from_atom(storage_get, self.previous_block)
+                prev = Block.from_atom(storage_get, prev_hash)
             except Exception:
                 return False
             prev_ts = int(prev.timestamp or 0)
+
+        if prev_hash and prev_hash != ZERO32:
+            if prev_ts is None:
+                return False
             cur_ts = int(self.timestamp or 0)
             if cur_ts < prev_ts + 1:
                 raise ValueError("timestamp must be at least prev+1")

astreum/_consensus/chain.py

@@ -54,10 +54,13 @@ class Chain:
                 self.malicious_block_hash = getattr(blk, "hash", None)
                 raise
 
-            if blk.previous_block == ZERO32:
+            prev_hash = blk.previous_block_hash if hasattr(blk, "previous_block_hash") else ZERO32
+            if prev_hash == ZERO32:
                 break
             # Move to previous block using cache-aware loader
-            blk = load_block(blk.previous_block)
+            prev_blk = load_block(prev_hash)
+            blk.previous_block = prev_blk  # cache the object for any downstream use
+            blk = prev_blk
 
         self.validated_upto_block = blk
         return blk

astreum/_consensus/fork.py

@@ -92,7 +92,9 @@ class Fork:
                 self.validated_upto = blk.hash
                 return True
             
-            nxt = load_block(blk.previous_block)
+            prev_hash = blk.previous_block_hash if hasattr(blk, "previous_block_hash") else ZERO32
+            nxt = load_block(prev_hash)
             if nxt is None:
                 return False
+            blk.previous_block = nxt  # cache for future use
             blk = nxt

astreum/_consensus/receipt.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, List, Optional, Tuple
+
+from .._storage.atom import Atom, 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")
+
+
+def _make_list(child_ids: List[bytes]) -> Tuple[bytes, List[Atom]]:
+    atoms: List[Atom] = []
+    next_hash = ZERO32
+    elements: 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()
+        elements.append(elem)
+    elements.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(elements)
+    atoms.append(list_value)
+    atoms.append(list_type)
+    return list_type.object_id(), atoms
+
+
+def _read_list_entries(
+    storage_get: Callable[[bytes], Optional[Atom]], start: bytes
+) -> List[bytes]:
+    entries: List[bytes] = []
+    current = start if start and 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 and nxt != ZERO32 else b""
+    return entries
+
+
+def _read_payload_bytes(
+    storage_get: Callable[[bytes], Optional[Atom]], object_id: bytes
+) -> bytes:
+    if not object_id or object_id == ZERO32:
+        return b""
+    atom = storage_get(object_id)
+    if atom is None:
+        return b""
+    if atom.data == b"bytes":
+        value_atom = storage_get(atom.next)
+        return value_atom.data if value_atom is not None else b""
+    return atom.data
+
+
+@dataclass
+class Receipt:
+    transaction_hash: bytes = ZERO32
+    cost: int = 0
+    logs: bytes = b""
+    status: int = 0
+
+    def to_atom(self) -> Tuple[bytes, List[Atom]]:
+        """Serialise the receipt into Atom storage."""
+        if self.status not in (STATUS_SUCCESS, STATUS_FAILED):
+            raise ValueError("unsupported receipt status")
+
+        atoms: List[Atom] = []
+
+        tx_atom = Atom.from_data(data=bytes(self.transaction_hash))
+        status_atom = Atom.from_data(data=_int_to_be_bytes(self.status))
+        cost_atom = Atom.from_data(data=_int_to_be_bytes(self.cost))
+        logs_atom = Atom.from_data(data=bytes(self.logs))
+
+        atoms.extend([tx_atom, status_atom, cost_atom, logs_atom])
+
+        body_child_ids = [
+            tx_atom.object_id(),
+            status_atom.object_id(),
+            cost_atom.object_id(),
+            logs_atom.object_id(),
+        ]
+        body_id, body_atoms = _make_list(body_child_ids)
+        atoms.extend(body_atoms)
+
+        type_atom = Atom.from_data(data=b"receipt", next_hash=body_id)
+        atoms.append(type_atom)
+
+        top_list_id, top_atoms = _make_list([type_atom.object_id(), body_id])
+        atoms.extend(top_atoms)
+
+        return top_list_id, atoms
+
+    @classmethod
+    def from_atom(
+        cls,
+        storage_get: Callable[[bytes], Optional[Atom]],
+        receipt_id: bytes,
+    ) -> Receipt:
+        """Materialise a Receipt from Atom storage."""
+        top_type_atom = storage_get(receipt_id)
+        if top_type_atom is None or top_type_atom.data != b"list":
+            raise ValueError("not a receipt (outer list missing)")
+
+        top_value_atom = storage_get(top_type_atom.next)
+        if top_value_atom is None:
+            raise ValueError("malformed receipt (outer value missing)")
+
+        head = top_value_atom.next
+        first_elem = storage_get(head) if head else None
+        if first_elem is None:
+            raise ValueError("malformed receipt (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"receipt":
+            raise ValueError("not a receipt (type mismatch)")
+
+        remainder_entries = _read_list_entries(storage_get, first_elem.next)
+        if not remainder_entries:
+            raise ValueError("malformed receipt (body missing)")
+        body_id = remainder_entries[0]
+
+        body_type_atom = storage_get(body_id)
+        if body_type_atom is None or body_type_atom.data != b"list":
+            raise ValueError("malformed receipt body (type)")
+
+        body_value_atom = storage_get(body_type_atom.next)
+        if body_value_atom is None:
+            raise ValueError("malformed receipt body (value)")
+
+        body_entries = _read_list_entries(storage_get, body_value_atom.next)
+        if len(body_entries) < 4:
+            body_entries.extend([ZERO32] * (4 - len(body_entries)))
+
+        transaction_hash_bytes = _read_payload_bytes(storage_get, body_entries[0])
+        status_bytes = _read_payload_bytes(storage_get, body_entries[1])
+        cost_bytes = _read_payload_bytes(storage_get, body_entries[2])
+        logs_bytes = _read_payload_bytes(storage_get, body_entries[3])
+        status_value = _be_bytes_to_int(status_bytes)
+        if status_value not in (STATUS_SUCCESS, STATUS_FAILED):
+            raise ValueError("unsupported receipt status")
+
+        return cls(
+            transaction_hash=transaction_hash_bytes or ZERO32,
+            cost=_be_bytes_to_int(cost_bytes),
+            logs=logs_bytes,
+            status=status_value,
+        )

astreum/_consensus/setup.py

@@ -8,7 +8,7 @@ from typing import Any, Dict, Optional, Tuple
 from .block import Block
 from .chain import Chain
 from .fork import Fork
-from .transaction import Transaction
+from .transaction import Transaction, apply_transaction
 from .._storage.atom import ZERO32, Atom
 
 
@@ -17,11 +17,6 @@ def current_validator(node: Any) -> bytes:
     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())
@@ -194,16 +189,17 @@ def consensus_setup(node: Any) -> None:
                     break
 
     # Start workers as daemons
-    node.validation_discovery_thread = threading.Thread(
-        target=_discovery_worker, daemon=True, name="validation-discovery"
+    node.consensus_discovery_thread = threading.Thread(
+        target=_discovery_worker, daemon=True, name="consensus-discovery"
     )
-    node.validation_verify_thread = threading.Thread(
-        target=_verify_worker, daemon=True, name="validation-verify"
+    node.consensus_verify_thread = threading.Thread(
+        target=_verify_worker, daemon=True, name="consensus-verify"
     )
-    node.validation_worker_thread = threading.Thread(
-        target=_validation_worker, daemon=True, name="validation-worker"
+    node.consensus_validation_thread = threading.Thread(
+        target=_validation_worker, daemon=True, name="consensus-validation"
     )
-    node.validation_discovery_thread.start()
-    node.validation_verify_thread.start()
+    node.consensus_discovery_thread.start()
+    node.consensus_verify_thread.start()
     if getattr(node, "validation_secret_key", None):
-        node.validation_worker_thread.start()
+        node.consensus_validation_thread.start()
+

astreum/_consensus/transaction.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Callable, List, Optional, Tuple
+from typing import Any, Callable, List, Optional, Tuple
 
 from .._storage.atom import Atom, ZERO32
 
@@ -22,12 +22,6 @@ def _be_bytes_to_int(data: Optional[bytes]) -> int:
     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
@@ -61,9 +55,9 @@ class Transaction:
         acc: List[Atom] = []
 
         def emit(payload: bytes) -> None:
-            oid, atoms = _make_typed_bytes(payload)
-            body_child_ids.append(oid)
-            acc.extend(atoms)
+            atom = Atom.from_data(data=payload)
+            body_child_ids.append(atom.object_id())
+            acc.append(atom)
 
         emit(_int_to_be_bytes(self.amount))
         emit(_int_to_be_bytes(self.counter))
@@ -141,23 +135,20 @@ class Transaction:
         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:
+        def read_detail_bytes(entry_id: bytes) -> bytes:
+            if 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""
+            detail_atom = storage_get(elem.data)
+            return detail_atom.data if detail_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])
+        amount_bytes = read_detail_bytes(body_entries[0])
+        counter_bytes = read_detail_bytes(body_entries[1])
+        data_bytes = read_detail_bytes(body_entries[2])
+        recipient_bytes = read_detail_bytes(body_entries[3])
+        sender_bytes = read_detail_bytes(body_entries[4])
 
         signature_atom = storage_get(signature_atom_id)
         signature_bytes = signature_atom.data if signature_atom is not None else b""
@@ -170,3 +161,8 @@ class Transaction:
             sender=sender_bytes,
             signature=signature_bytes,
         )
+
+
+def apply_transaction(node: Any, block: object, transaction_hash: bytes) -> None:
+    """Apply transaction to the candidate block. Override downstream."""
+    pass