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

astreum/_consensus/block.py

@@ -1,311 +0,0 @@
-
-from typing import Any, Callable, List, Optional, Tuple, TYPE_CHECKING
-
-from .._storage.atom import Atom, AtomKind, 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
-
-
-def _int_to_be_bytes(n: Optional[int]) -> bytes:
-    if n is None:
-        return b""
-    n = int(n)
-    if n == 0:
-        return b"\x00"
-    size = (n.bit_length() + 7) // 8
-    return n.to_bytes(size, "big")
-
-
-def _be_bytes_to_int(b: Optional[bytes]) -> int:
-    if not b:
-        return 0
-    return int.from_bytes(b, "big")
-
-
-class Block:
-    """Validation Block representation using Atom storage.
-
-    Top-level encoding:
-      block_id = type_atom.object_id()
-      chain: type_atom --next--> signature_atom --next--> body_list_atom --next--> ZERO32
-      where: type_atom        = Atom(kind=AtomKind.SYMBOL, data=b"block")
-             signature_atom   = Atom(kind=AtomKind.BYTES, data=<signature-bytes>)
-             body_list_atom   = Atom(kind=AtomKind.LIST,  data=<body_head_id>)
-
-    Details order in body_list:
-      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_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
-        embedded again as a field to avoid circular references.
-      - "signature" is a field on the class but is not required for validation
-        navigation; include it in the instance but it is not encoded in atoms
-        unless explicitly provided via details extension in the future.
-    """
-
-    # essential identifiers
-    hash: 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_hash: Optional[bytes]
-    receipts_hash: Optional[bytes]
-    delay_difficulty: Optional[int]
-    delay_output: Optional[bytes]
-    validator_public_key: Optional[bytes]
-
-    # additional
-    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_hash = ZERO32
-        self.previous_block = None
-        self.number = None
-        self.timestamp = None
-        self.accounts_hash = None
-        self.transactions_total_fees = 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 direct byte atoms, in defined order
-        details_ids: List[bytes] = []
-        block_atoms: List[Atom] = []
-
-        def _emit(detail_bytes: bytes) -> None:
-            atom = Atom.from_data(data=detail_bytes, kind=AtomKind.BYTES)
-            details_ids.append(atom.object_id())
-            block_atoms.append(atom)
-
-        # 0: previous_block_hash
-        _emit(self.previous_block_hash)
-        # 1: number
-        _emit(_int_to_be_bytes(self.number))
-        # 2: timestamp
-        _emit(_int_to_be_bytes(self.timestamp))
-        # 3: accounts_hash
-        _emit(self.accounts_hash or b"")
-        # 4: transactions_total_fees
-        _emit(_int_to_be_bytes(self.transactions_total_fees))
-        # 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))
-        # 8: delay_output
-        _emit(self.delay_output or b"")
-        # 9: validator_public_key
-        _emit(self.validator_public_key or b"")
-
-        # Build body list chain (head points to the first detail atom id)
-        body_atoms: List[Atom] = []
-        body_head = ZERO32
-        for child_id in reversed(details_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()
-
-        block_atoms.extend(body_atoms)
-
-        body_list_atom = Atom.from_data(data=body_head, kind=AtomKind.LIST)
-        self.body_hash = body_list_atom.object_id()
-
-        # Signature atom links to body list atom; type atom links to signature atom
-        sig_atom = Atom.from_data(data=self.signature, next_hash=self.body_hash, kind=AtomKind.BYTES)
-        type_atom = Atom.from_data(data=b"block", next_hash=sig_atom.object_id(), kind=AtomKind.SYMBOL)
-
-        block_atoms.append(body_list_atom)
-        block_atoms.append(sig_atom)
-        block_atoms.append(type_atom)
-
-        self.hash = type_atom.object_id()
-        return self.hash, block_atoms
-
-    @classmethod
-    def from_atom(cls, source: Any, block_id: bytes) -> "Block":
-        storage_get: Optional[Callable[[bytes], Optional[Atom]]]
-        if callable(source):
-            storage_get = source
-        else:
-            storage_get = getattr(source, "storage_get", None)
-        if not callable(storage_get):
-            raise TypeError(
-                "Block.from_atom requires a node with 'storage_get' or a callable storage getter"
-            )
-
-        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 = head_id
-            if not current or current == ZERO32:
-                return entries
-            while current and current != ZERO32:
-                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"list element must be bytes while decoding {context}")
-                if len(node.data) != len(ZERO32):
-                    raise ValueError(f"list element payload has unexpected length while decoding {context}")
-                entries.append(node.data)
-                current = node.next
-            return entries
-
-        type_atom = _require_atom(block_id, "block type atom", AtomKind.SYMBOL)
-        if type_atom.data != b"block":
-            raise ValueError("not a block (type atom payload)")
-
-        sig_atom = _require_atom(type_atom.next, "block signature atom", AtomKind.BYTES)
-        body_list_id = sig_atom.next
-        body_list_atom = _require_atom(body_list_id, "block body list atom", AtomKind.LIST)
-        if body_list_atom.next and body_list_atom.next != ZERO32:
-            raise ValueError("malformed block (body list tail)")
-
-        body_child_ids = _read_list(body_list_atom.data, "block body")
-
-        details: List[bytes] = []
-        for idx, child_id in enumerate(body_child_ids):
-            if idx >= 10:
-                break
-            if not child_id or child_id == ZERO32:
-                details.append(b"")
-                continue
-            detail_atom = storage_get(child_id)
-            details.append(detail_atom.data if detail_atom is not None else b"")
-
-        if len(details) < 10:
-            details.extend([b""] * (10 - len(details)))
-
-        b = cls()
-        b.hash = block_id
-        b.body_hash = body_list_id
-
-        get = lambda i: details[i] if i < len(details) else b""
-        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_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
-
-        b.signature = sig_atom.data if sig_atom is not None else None
-
-        return b
-
-    def validate(self, storage_get: Callable[[bytes], Optional[Atom]]) -> bool:
-        """Validate this block against storage.
-
-        Checks:
-        - Signature: signature must verify over the body list id using the
-          validator's public key.
-        - Timestamp monotonicity: if previous block exists (not ZERO32), this
-          block's timestamp must be >= previous.timestamp + 1.
-        """
-        # Unverifiable if critical fields are missing
-        if not self.body_hash:
-            return False
-        if not self.signature:
-            return False
-        if not self.validator_public_key:
-            return False
-        if self.timestamp is None:
-            return False
-
-        # 1) Signature check over body hash
-        try:
-            pub = Ed25519PublicKey.from_public_bytes(bytes(self.validator_public_key))
-            pub.verify(self.signature, self.body_hash)
-        except InvalidSignature as e:
-            raise ValueError("invalid signature") from e
-
-        # 2) Timestamp monotonicity against previous block
-        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, 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")
-
-        return True

astreum/_consensus/genesis.py

@@ -1,72 +0,0 @@
-
-from __future__ import annotations
-
-from typing import Any, List
-
-from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
-
-from .account import Account
-from .block import Block
-from .._storage.atom import ZERO32
-from .._storage.patricia import PatriciaTrie
-from ..utils.integer import int_to_bytes
-
-TREASURY_ADDRESS = b"\x01" * 32
-BURN_ADDRESS = b"\x00" * 32
-def create_genesis_block(node: Any, validator_public_key: bytes, validator_secret_key: bytes) -> Block:
-    validator_pk = bytes(validator_public_key)
-
-    if len(validator_pk) != 32:
-        raise ValueError("validator_public_key must be 32 bytes")
-
-    # 1. Stake trie with single validator stake of 1 (encoded on 32 bytes).
-    stake_trie = PatriciaTrie()
-    stake_amount = int_to_bytes(1)
-    stake_trie.put(storage_node=node, key=validator_pk, value=stake_amount)
-    stake_root = stake_trie.root_hash
-
-    # 2. Account trie with treasury, burn, and validator accounts.
-    accounts_trie = PatriciaTrie()
-
-    treasury_account = Account.create(balance=1, data=stake_root, counter=0)
-    accounts_trie.put(storage_node=node, key=TREASURY_ADDRESS, value=treasury_account.hash)
-
-    burn_account = Account.create(balance=0, data=b"", counter=0)
-    accounts_trie.put(storage_node=node, key=BURN_ADDRESS, value=burn_account.hash)
-
-    validator_account = Account.create(balance=0, data=b"", counter=0)
-    accounts_trie.put(storage_node=node, key=validator_pk, value=validator_account.hash)
-
-    accounts_root = accounts_trie.root_hash
-    if accounts_root is None:
-        raise ValueError("genesis accounts trie is empty")
-
-    # 3. Assemble block metadata.
-    block = Block()
-    block.previous_block_hash = ZERO32
-    block.number = 0
-    block.timestamp = 0
-    block.accounts_hash = accounts_root
-    block.accounts = accounts_trie
-    block.transactions_total_fees = 0
-    block.transactions_hash = ZERO32
-    block.receipts_hash = ZERO32
-    block.delay_difficulty = 0
-    block.delay_output = b""
-    block.validator_public_key = validator_pk
-    block.transactions = []
-    block.receipts = []
-
-    # 4. Sign the block body with the validator secret key.
-    block.signature = b""
-    block.to_atom()
-
-    if block.body_hash is None:
-        raise ValueError("failed to materialise genesis block body")
-
-    secret = Ed25519PrivateKey.from_private_bytes(validator_secret_key)
-    block.signature = secret.sign(block.body_hash)
-    block_hash, _ = block.to_atom()
-
-    block.hash = block_hash
-    return block

astreum/_consensus/receipt.py

@@ -1,136 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Callable, List, Optional, Tuple
-
-from .._storage.atom import Atom, AtomKind, 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")
-
-
-@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")
-
-        detail_specs = [
-            (bytes(self.transaction_hash), AtomKind.LIST),
-            (_int_to_be_bytes(self.status), AtomKind.BYTES),
-            (_int_to_be_bytes(self.cost), AtomKind.BYTES),
-            (bytes(self.logs), AtomKind.BYTES),
-        ]
-
-        detail_atoms: List[Atom] = []
-        next_hash = ZERO32
-        for payload, kind in reversed(detail_specs):
-            atom = Atom.from_data(data=payload, next_hash=next_hash, kind=kind)
-            detail_atoms.append(atom)
-            next_hash = atom.object_id()
-        detail_atoms.reverse()
-
-        type_atom = Atom.from_data(
-            data=b"receipt",
-            next_hash=next_hash,
-            kind=AtomKind.SYMBOL,
-        )
-
-        self.hash = type_atom.object_id()
-        atoms = detail_atoms + [type_atom]
-        return self.hash, 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."""
-        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
-
-        type_atom = storage_get(receipt_id)
-        if type_atom is None:
-            raise ValueError("missing receipt type atom")
-        if _atom_kind(type_atom) is not AtomKind.SYMBOL:
-            raise ValueError("malformed receipt (type kind)")
-        if type_atom.data != b"receipt":
-            raise ValueError("not a receipt (type payload)")
-
-        details: List[Atom] = []
-        current = type_atom.next
-        while current and current != ZERO32 and len(details) < 4:
-            atom = storage_get(current)
-            if atom is None:
-                raise ValueError("missing receipt detail atom")
-            details.append(atom)
-            current = atom.next
-
-        if current and current != ZERO32:
-            raise ValueError("too many receipt fields")
-        if len(details) != 4:
-            raise ValueError("incomplete receipt fields")
-
-        tx_atom, status_atom, cost_atom, logs_atom = details
-
-        if _atom_kind(tx_atom) is not AtomKind.LIST:
-            raise ValueError("receipt transaction hash must be list-kind")
-        if any(_atom_kind(atom) is not AtomKind.BYTES for atom in [status_atom, cost_atom, logs_atom]):
-            raise ValueError("receipt detail atoms must be bytes-kind")
-
-        transaction_hash_bytes = tx_atom.data or ZERO32
-        status_bytes = status_atom.data
-        cost_bytes = cost_atom.data
-        logs_bytes = logs_atom.data
-
-        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/workers/validation.py

@@ -1,125 +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_atoms = 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
-
-            # upload block atoms
-            
-            # upload receipt atoms
-            # upload account atoms
-
-    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