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

astreum/_consensus/transaction.py

@@ -3,43 +3,11 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, List, Optional, Tuple
 
-from .._storage.atom import Atom, ZERO32
-from .receipt import Receipt, STATUS_SUCCESS
-
-
-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
-    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
-
+from .._storage.atom import Atom, AtomKind, ZERO32
+from ..utils.integer import bytes_to_int, int_to_bytes
+from .account import Account
+from .genesis import TREASURY_ADDRESS
+from .receipt import STATUS_FAILED, Receipt, STATUS_SUCCESS
 
 @dataclass
 class Transaction:
@@ -57,31 +25,46 @@ class Transaction:
         acc: List[Atom] = []
 
         def emit(payload: bytes) -> None:
-            atom = Atom.from_data(data=payload)
+            atom = Atom.from_data(data=payload, kind=AtomKind.BYTES)
             body_child_ids.append(atom.object_id())
             acc.append(atom)
 
-        emit(_int_to_be_bytes(self.amount))
-        emit(_int_to_be_bytes(self.counter))
+        emit(int_to_bytes(self.amount))
+        emit(int_to_bytes(self.counter))
         emit(bytes(self.data))
         emit(bytes(self.recipient))
         emit(bytes(self.sender))
 
-        body_id, body_atoms = _make_list(body_child_ids)
+        # Build the linked list of body entry references.
+        body_atoms: List[Atom] = []
+        body_head = ZERO32
+        for child_id in reversed(body_child_ids):
+            node = Atom.from_data(data=child_id, next_hash=body_head, kind=AtomKind.BYTES)
+            body_head = node.object_id()
+            body_atoms.append(node)
+        body_atoms.reverse()
         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))
+        body_list_atom = Atom.from_data(data=body_head, kind=AtomKind.LIST)
+        acc.append(body_list_atom)
+        body_list_id = body_list_atom.object_id()
 
-        top_list_id, top_atoms = _make_list(
-            [type_atom.object_id(), body_id, signature_atom.object_id()]
+        signature_atom = Atom.from_data(
+            data=bytes(self.signature),
+            next_hash=body_list_id,
+            kind=AtomKind.BYTES,
+        )
+        type_atom = Atom.from_data(
+            data=b"transaction",
+            next_hash=signature_atom.object_id(),
+            kind=AtomKind.SYMBOL,
         )
 
-        atoms: List[Atom] = acc
-        atoms.append(type_atom)
-        atoms.append(signature_atom)
-        atoms.extend(top_atoms)
-        return top_list_id, atoms
+        acc.append(signature_atom)
+        acc.append(type_atom)
+
+        self.hash = type_atom.object_id()
+        return self.hash, acc
 
     @classmethod
     def from_atom(
@@ -89,83 +72,86 @@ class Transaction:
         node: Any,
         transaction_id: bytes,
     ) -> Transaction:
-        storage_get = node._local_get
+        storage_get = getattr(node, "storage_get", None)
         if not callable(storage_get):
             raise NotImplementedError("node does not expose a storage getter")
 
-        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]:
+        def _atom_kind(atom: Optional[Atom]) -> Optional[AtomKind]:
+            kind_value = getattr(atom, "kind", None)
+            if isinstance(kind_value, AtomKind):
+                return kind_value
+            if isinstance(kind_value, int):
+                try:
+                    return AtomKind(kind_value)
+                except ValueError:
+                    return None
+            return None
+
+        def _require_atom(
+            atom_id: Optional[bytes],
+            context: str,
+            expected_kind: Optional[AtomKind] = None,
+        ) -> Atom:
+            if not atom_id or atom_id == ZERO32:
+                raise ValueError(f"missing {context}")
+            atom = storage_get(atom_id)
+            if atom is None:
+                raise ValueError(f"missing {context}")
+            if expected_kind is not None:
+                kind = _atom_kind(atom)
+                if kind is not expected_kind:
+                    raise ValueError(f"malformed {context}")
+            return atom
+
+        def _read_list(head_id: Optional[bytes], context: str) -> List[bytes]:
             entries: List[bytes] = []
-            current = start if start != ZERO32 else b""
+            current = head_id if head_id and head_id != ZERO32 else None
             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""
+                node = storage_get(current)
+                if node is None:
+                    raise ValueError(f"missing list node while decoding {context}")
+                node_kind = _atom_kind(node)
+                if node_kind is not AtomKind.BYTES:
+                    raise ValueError(f"invalid list node while decoding {context}")
+                if len(node.data) != len(ZERO32):
+                    raise ValueError(f"malformed list entry while decoding {context}")
+                entries.append(node.data)
+                nxt = node.next
+                current = nxt if nxt and nxt != ZERO32 else None
             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_detail_bytes(entry_id: bytes) -> bytes:
-            if entry_id == ZERO32:
-                return b""
-            elem = storage_get(entry_id)
-            if elem is None:
+        def _read_detail_bytes(entry_id: Optional[bytes]) -> bytes:
+            if not entry_id or entry_id == ZERO32:
                 return b""
-            detail_atom = storage_get(elem.data)
+            detail_atom = storage_get(entry_id)
             return detail_atom.data if detail_atom is not None else b""
 
-        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])
+        type_atom = _require_atom(transaction_id, "transaction type atom", AtomKind.SYMBOL)
+        if type_atom.data != b"transaction":
+            raise ValueError("not a transaction (type atom payload)")
+
+        signature_atom = _require_atom(type_atom.next, "transaction signature atom", AtomKind.BYTES)
+        body_list_atom = _require_atom(signature_atom.next, "transaction body list atom", AtomKind.LIST)
+        if body_list_atom.next and body_list_atom.next != ZERO32:
+            raise ValueError("malformed transaction (body list tail)")
+
+        body_entry_ids = _read_list(body_list_atom.data, "transaction body")
+        if len(body_entry_ids) < 5:
+            body_entry_ids.extend([ZERO32] * (5 - len(body_entry_ids)))
 
-        signature_atom = storage_get(signature_atom_id)
-        signature_bytes = signature_atom.data if signature_atom is not None else b""
+        amount_bytes = _read_detail_bytes(body_entry_ids[0])
+        counter_bytes = _read_detail_bytes(body_entry_ids[1])
+        data_bytes = _read_detail_bytes(body_entry_ids[2])
+        recipient_bytes = _read_detail_bytes(body_entry_ids[3])
+        sender_bytes = _read_detail_bytes(body_entry_ids[4])
 
         return cls(
-            amount=_be_bytes_to_int(amount_bytes),
-            counter=_be_bytes_to_int(counter_bytes),
+            amount=bytes_to_int(amount_bytes),
+            counter=bytes_to_int(counter_bytes),
             data=data_bytes,
             recipient=recipient_bytes,
             sender=sender_bytes,
-            signature=signature_bytes,
+            signature=signature_atom.data,
             hash=bytes(transaction_id),
         )
 
@@ -174,9 +160,50 @@ def apply_transaction(node: Any, block: object, transaction_hash: bytes) -> None
     """Apply transaction to the candidate block. Override downstream."""
     transaction = Transaction.from_atom(node, transaction_hash)
 
-    if block.transactions is None:
-        block.transactions = []
-    block.transactions.append(transaction)
+    accounts = block.accounts
+
+    sender_account = accounts.get_account(address=transaction.sender, node=node)
+
+    if sender_account is None:
+        return
+    
+    tx_cost = 1 + transaction.amount
+
+    if sender_account.balance < tx_cost:
+        low_sender_balance_receipt = Receipt(
+            transaction_hash=transaction_hash,
+            cost=0,
+            logs=b"low sender balance",
+            status=STATUS_FAILED
+        )
+        low_sender_balance_receipt.atomize()
+        block.receipts.append(receipt)
+        block.transactions.append(transaction)
+        return
+
+    recipient_account = accounts.get_account(address=transaction.recipient, node=node)
+
+    if recipient_account is None:
+        recipient_account = Account.create()
+
+    if transaction.recipient == TREASURY_ADDRESS:
+        stake_trie = recipient_account.data
+        existing_stake = stake_trie.get(node, transaction.sender)
+        current_stake = bytes_to_int(existing_stake)
+        new_stake = current_stake + transaction.amount
+        stake_trie.put(node, transaction.sender, int_to_bytes(new_stake))
+        recipient_account.data_hash = stake_trie.root_hash or ZERO32
+        recipient_account.balance += transaction.amount
+    else:
+        recipient_account.balance += transaction.amount
+
+    sender_account.balance -= tx_cost
+
+    block.accounts.set_account(address=sender_account)
+
+    block.accounts.set_account(address=recipient_account)
+
+    block.transactions.append(transaction_hash)
 
     receipt = Receipt(
         transaction_hash=bytes(transaction_hash),
@@ -185,8 +212,4 @@ def apply_transaction(node: Any, block: object, transaction_hash: bytes) -> None
         status=STATUS_SUCCESS,
     )
     receipt.atomize()
-    if block.receipts is None:
-        block.receipts = []
     block.receipts.append(receipt)
-
-    # Downstream implementations can extend this to apply state changes.

astreum/_consensus/workers/validation.py

@@ -88,7 +88,7 @@ def make_validation_worker(
             new_block.timestamp = max(int(now), min_allowed)
 
             # atomize block
-            new_block_hash, _ = new_block.to_atom()
+            new_block_hash, new_block_atoms = new_block.to_atom()
             # put as own latest block hash
             node.latest_block_hash = new_block_hash
 
@@ -117,6 +117,9 @@ def make_validation_worker(
                             except Exception:
                                 pass
 
-            # store the new block and receipts
+            # upload block atoms
+            
+            # upload receipt atoms
+            # upload account atoms
 
     return _validation_worker

astreum/_consensus/workers/verify.py

@@ -17,7 +17,7 @@ def _process_peers_latest_block(
         fk.head for fk in node.forks.values() if fk.head != latest_block_hash
     }
 
-    new_fork.validate(storage_get=node._local_get, stop_heads=current_fork_heads)
+    new_fork.validate(storage_get=node.storage_get, stop_heads=current_fork_heads)
 
     if new_fork.validated_upto and new_fork.validated_upto in node.forks:
         ref = node.forks[new_fork.validated_upto]

astreum/_lispeum/expression.py

@@ -1,37 +1,190 @@
-from typing import List, Optional
-
-
-class Expr:
-    class ListExpr:
-        def __init__(self, elements: List['Expr']):
-            self.elements = elements
-        
-        def __repr__(self):
-            if not self.elements:
-                return "()"
-            inner = " ".join(str(e) for e in self.elements)
-            return f"({inner} list)"
-        
-    class Symbol:
-        def __init__(self, value: str):
-            self.value = value
-
-        def __repr__(self):
-            return f"({self.value} symbol)"
-        
-    class Bytes:
-        def __init__(self, value: bytes):
-            self.value = value
-
-        def __repr__(self):
-            return f"({self.value} bytes)"
-        
-    class Error:
-        def __init__(self, topic: str, origin: Optional['Expr'] = None):
-            self.topic = topic
-            self.origin  = origin
-
-        def __repr__(self):
-            if self.origin is None:
-                return f'({self.topic} error)'
-            return f'({self.origin} {self.topic} error)'
+from typing import Any, List, Optional, Tuple
+
+from .._storage.atom import Atom, AtomKind
+
+ZERO32 = b"\x00" * 32
+ERROR_SYMBOL = "error"
+
+
+class Expr:
+    class ListExpr:
+        def __init__(self, elements: List['Expr']):
+            self.elements = elements
+        
+        def __repr__(self):
+            if not self.elements:
+                return "()"
+            inner = " ".join(str(e) for e in self.elements)
+            return f"({inner})"
+
+        def to_atoms(self):
+            return Expr.to_atoms(self)
+        
+    class Symbol:
+        def __init__(self, value: str):
+            self.value = value
+
+        def __repr__(self):
+            return f"{self.value}"
+
+        def to_atoms(self):
+            return Expr.to_atoms(self)
+        
+    class Bytes:
+        def __init__(self, value: bytes):
+            self.value = value
+
+        def __repr__(self):
+            int_value = int.from_bytes(self.value, "big") if self.value else 0
+            return f"{int_value}"
+
+        def to_atoms(self):
+            return Expr.to_atoms(self)
+    @classmethod
+    def from_atoms(cls, node: Any, root_hash: bytes) -> "Expr":
+        """Rebuild an expression tree from stored atoms."""
+        if not isinstance(root_hash, (bytes, bytearray)):
+            raise TypeError("root hash must be bytes-like")
+
+        storage_get = getattr(node, "storage_get", None)
+        if not callable(storage_get):
+            raise TypeError("node must provide a callable 'storage_get'")
+
+        expr_id = bytes(root_hash)
+
+        def _require(atom_id: Optional[bytes], context: str):
+            if not atom_id:
+                raise ValueError(f"missing atom id while decoding {context}")
+            atom = storage_get(atom_id)
+            if atom is None:
+                raise ValueError(f"missing atom data while decoding {context}")
+            return atom
+
+        def _atom_kind(atom: Any) -> Optional[AtomKind]:
+            kind_value = getattr(atom, "kind", None)
+            if isinstance(kind_value, AtomKind):
+                return kind_value
+            if isinstance(kind_value, int):
+                try:
+                    return AtomKind(kind_value)
+                except ValueError:
+                    return None
+            return None
+
+        type_atom = _require(expr_id, "expression atom")
+
+        kind_enum = _atom_kind(type_atom)
+        if kind_enum is None:
+            raise ValueError("expression atom missing kind")
+
+        if kind_enum is AtomKind.SYMBOL:
+            try:
+                return cls.Symbol(type_atom.data.decode("utf-8"))
+            except UnicodeDecodeError as exc:
+                raise ValueError("symbol atom is not valid utf-8") from exc
+
+        if kind_enum is AtomKind.BYTES:
+            return cls.Bytes(type_atom.data)
+
+        if kind_enum is AtomKind.LIST:
+            # Empty list sentinel: zero-length payload and no next pointer.
+            if len(type_atom.data) == 0 and type_atom.next == ZERO32:
+                return cls.ListExpr([])
+
+            elements: List[Expr] = []
+            current_atom = type_atom
+            idx = 0
+            while True:
+                child_hash = current_atom.data
+                if not child_hash:
+                    raise ValueError("list element missing child hash")
+                if len(child_hash) != len(ZERO32):
+                    raise ValueError("list element hash has unexpected length")
+                child_expr = cls.from_atoms(node, child_hash)
+                elements.append(child_expr)
+                next_id = current_atom.next
+                if not next_id or next_id == ZERO32:
+                    break
+                next_atom = _require(next_id, f"list element {idx}")
+                next_kind = _atom_kind(next_atom)
+                if next_kind is not AtomKind.LIST:
+                    raise ValueError("list chain contains non-list atom")
+                current_atom = next_atom
+                idx += 1
+            return cls.ListExpr(elements)
+
+        raise ValueError(f"unknown expression kind: {kind_enum}")
+
+    @staticmethod
+    def to_atoms(e: "Expr") -> Tuple[bytes, List[Atom]]:
+        def symbol(value: str) -> Tuple[bytes, List[Atom]]:
+            atom = Atom.from_data(data=value.encode("utf-8"), kind=AtomKind.SYMBOL)
+            return atom.object_id(), [atom]
+
+        def bytes_value(data: bytes) -> Tuple[bytes, List[Atom]]:
+            atom = Atom.from_data(data=data, kind=AtomKind.BYTES)
+            return atom.object_id(), [atom]
+
+        def lst(items: List["Expr"]) -> Tuple[bytes, List[Atom]]:
+            acc: List[Atom] = []
+            child_hashes: List[bytes] = []
+            for it in items:
+                h, atoms = Expr.to_atoms(it)
+                acc.extend(atoms)
+                child_hashes.append(h)
+            next_hash = ZERO32
+            elem_atoms: List[Atom] = []
+            for h in reversed(child_hashes):
+                a = Atom.from_data(h, next_hash, kind=AtomKind.LIST)
+                next_hash = a.object_id()
+                elem_atoms.append(a)
+            elem_atoms.reverse()
+            if elem_atoms:
+                head = elem_atoms[0].object_id()
+            else:
+                empty_atom = Atom.from_data(data=b"", next_hash=ZERO32, kind=AtomKind.LIST)
+                elem_atoms = [empty_atom]
+                head = empty_atom.object_id()
+            return head, acc + elem_atoms
+
+        if isinstance(e, Expr.Symbol):
+            return symbol(e.value)
+        if isinstance(e, Expr.Bytes):
+            return bytes_value(e.value)
+        if isinstance(e, Expr.ListExpr):
+            return lst(e.elements)
+        raise TypeError("unknown Expr variant")
+
+def _expr_generate_id(expr) -> bytes:
+    expr_id, _ = Expr.to_atoms(expr)
+    return expr_id
+
+
+def _expr_cached_id(expr) -> bytes:
+    cached = getattr(expr, "_cached_id", None)
+    if cached is None:
+        cached = _expr_generate_id(expr)
+        setattr(expr, "_cached_id", cached)
+    return cached
+
+
+for _expr_cls in (Expr.ListExpr, Expr.Symbol, Expr.Bytes):
+    _expr_cls.generate_id = _expr_generate_id  # type: ignore[attr-defined]
+    _expr_cls.id = property(_expr_cached_id)  # type: ignore[attr-defined]
+
+
+def error_expr(topic: str, message: str) -> Expr.ListExpr:
+    """Encode an error as (error <topic-bytes> <message-bytes>)."""
+    try:
+        topic_bytes = topic.encode("utf-8")
+    except UnicodeEncodeError as exc:
+        raise ValueError("error topic must be valid utf-8") from exc
+    try:
+        message_bytes = message.encode("utf-8")
+    except UnicodeEncodeError as exc:
+        raise ValueError("error message must be valid utf-8") from exc
+    return Expr.ListExpr([
+        Expr.Symbol(ERROR_SYMBOL),
+        Expr.Bytes(topic_bytes),
+        Expr.Bytes(message_bytes),
+    ])