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

astreum/_consensus/receipt.py

@@ -1,177 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-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
-    hash: bytes = ZERO32
-    atoms: List[Atom] = field(default_factory=list)
-
-    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
-
-    def atomize(self) -> Tuple[bytes, List[Atom]]:
-        """Generate atoms for this receipt and cache them."""
-        receipt_id, atoms = self.to_atom()
-        self.hash = receipt_id
-        self.atoms = atoms
-        return receipt_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,
-            hash=bytes(receipt_id),
-        )

astreum/_consensus/transaction.py

@@ -1,192 +0,0 @@
-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
-
-
-@dataclass
-class Transaction:
-    amount: int
-    counter: int
-    data: bytes = b""
-    recipient: bytes = b""
-    sender: bytes = b""
-    signature: bytes = b""
-    hash: bytes = ZERO32
-
-    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:
-            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))
-        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,
-        node: Any,
-        transaction_id: bytes,
-    ) -> Transaction:
-        storage_get = node._local_get
-        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]:
-            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_detail_bytes(entry_id: bytes) -> bytes:
-            if entry_id == ZERO32:
-                return b""
-            elem = storage_get(entry_id)
-            if elem is None:
-                return b""
-            detail_atom = storage_get(elem.data)
-            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])
-
-        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,
-            hash=bytes(transaction_id),
-        )
-
-
-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)
-
-    receipt = Receipt(
-        transaction_hash=bytes(transaction_hash),
-        cost=0,
-        logs=b"",
-        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

@@ -1,122 +0,0 @@
-from __future__ import annotations
-
-import time
-from queue import Empty
-from typing import Any, Callable
-
-from ..block import Block
-from ..transaction import apply_transaction
-from ..._storage.atom import bytes_list_to_atoms
-from ..._storage.patricia import PatriciaTrie
-from ..._communication.message import Message, MessageTopic
-from ..._communication.ping import Ping
-
-
-def make_validation_worker(
-    node: Any,
-    *,
-    current_validator: Callable[[Any], bytes],
-) -> Callable[[], None]:
-    """Build the validation worker bound to the given node."""
-
-    def _validation_worker() -> None:
-        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
-
-            # create thread to perform vdf
-
-            new_block = Block()
-            new_block.validator_public_key = validation_public_key
-            new_block.previous_block_hash = node.latest_block_hash
-            try:
-                new_block.previous_block = Block.from_atom(node, new_block.previous_block_hash)
-            except Exception:
-                continue
-            new_block.accounts = PatriciaTrie(root_hash=new_block.previous_block.accounts_hash)
-
-            # we may want to add a timer to process part of the txs only on a slow computer
-            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:
-                    pass
-
-                try:
-                    current_hash = node._validation_transaction_queue.get_nowait()
-                except Empty:
-                    break
-
-            # create an atom list of transactions, save the list head hash as the block's transactions_hash
-            transactions = new_block.transactions or []
-            tx_hashes = [bytes(tx.hash) for tx in transactions if tx.hash]
-            head_hash, _ = bytes_list_to_atoms(tx_hashes)
-            new_block.transactions_hash = head_hash
-
-            receipts = new_block.receipts or []
-            receipt_hashes = [bytes(rcpt.hash) for rcpt in receipts if rcpt.hash]
-            receipts_head, _ = bytes_list_to_atoms(receipt_hashes)
-            new_block.receipts_hash = receipts_head
-
-            # get vdf result, default to 0 for now
-
-            # get timestamp or wait for a the next second from the previous block, rule is the next block must be atleast 1 second after the previous
-            now = time.time()
-            min_allowed = new_block.previous_block.timestamp + 1
-            if now < min_allowed:
-                time.sleep(max(0.0, min_allowed - now))
-                now = time.time()
-            new_block.timestamp = max(int(now), min_allowed)
-
-            # atomize block
-            new_block_hash, _ = new_block.to_atom()
-            # put as own latest block hash
-            node.latest_block_hash = new_block_hash
-
-            # ping peers in the validation route to update there records
-            if node.validation_route and node.outgoing_queue and node.addresses:
-                route_peers = {
-                    peer_key
-                    for bucket in getattr(node.validation_route, "buckets", {}).values()
-                    for peer_key in bucket
-                }
-                if route_peers:
-                    ping_payload = Ping(
-                        is_validator=True,
-                        latest_block=new_block_hash,
-                    ).to_bytes()
-
-                    message_bytes = Message(
-                        topic=MessageTopic.PING,
-                        content=ping_payload,
-                    ).to_bytes()
-
-                    for address, peer_key in node.addresses.items():
-                        if peer_key in route_peers:
-                            try:
-                                node.outgoing_queue.put((message_bytes, address))
-                            except Exception:
-                                pass
-
-            # store the new block and receipts
-
-    return _validation_worker

astreum/_lispeum/__init__.py

@@ -1,16 +0,0 @@
-from .expression import Expr
-from .environment import Env
-from .low_evaluation import low_eval
-from .meter import Meter
-from .parser import parse, ParseError
-from .tokenizer import tokenize
-
-__all__ = [
-    "Env",
-    "Expr",
-    "low_eval",
-    "Meter",
-    "parse",
-    "tokenize",
-    "ParseError",
-]

astreum/_lispeum/environment.py

@@ -1,13 +0,0 @@
-from ast import Expr
-from typing import Dict, Optional
-import uuid
-
-
-class Env:
-    def __init__(
-        self,
-        data: Optional[Dict[str, Expr]] = None,
-        parent_id: Optional[uuid.UUID] = None,
-    ):
-        self.data: Dict[bytes, Expr] = {} if data is None else data
-        self.parent_id = parent_id

astreum/_lispeum/expression.py

@@ -1,37 +0,0 @@
-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)'