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

astreum/_consensus/accounts.py

@@ -1,67 +0,0 @@
-from __future__ import annotations
-from __future__ import annotations
-
-from typing import Any, Dict, Iterable, Optional, Tuple
-
-from .._storage.atom import Atom
-from .._storage.patricia import PatriciaTrie
-from .account import Account
-
-
-class Accounts:
-    def __init__(
-        self,
-        root_hash: Optional[bytes] = None,
-    ) -> None:
-        self._trie = PatriciaTrie(root_hash=root_hash)
-        self._cache: Dict[bytes, Account] = {}
-        self._staged: Dict[bytes, Account] = {}
-        self._staged_hashes: Dict[bytes, bytes] = {}
-        self._staged_atoms: Dict[bytes, Iterable[Atom]] = {}
-        self._node: Optional[Any] = None
-
-    @property
-    def root_hash(self) -> Optional[bytes]:
-        return self._trie.root_hash
-
-    def _resolve_node(self, node: Optional[Any]) -> Any:
-        if node is not None:
-            if self._node is None:
-                self._node = node
-            return node
-        if self._node is None:
-            raise ValueError("Accounts requires a node reference for trie access")
-        return self._node
-
-    def get_account(self, address: bytes, *, node: Optional[Any] = None) -> Optional[Account]:
-        if address in self._staged:
-            return self._staged[address]
-
-        cached = self._cache.get(address)
-        if cached is not None:
-            return cached
-
-        storage_node = self._resolve_node(node)
-        account_id: Optional[bytes] = self._trie.get(storage_node, address)
-        if account_id is None:
-            return None
-
-        account = Account.from_atom(storage_node, account_id)
-        self._cache[address] = account
-        return account
-
-    def set_account(self, address: bytes, account: Account) -> None:
-        account_hash, atoms = account.to_atom()
-        self._staged[address] = account
-        self._staged_hashes[address] = account_hash
-        self._staged_atoms[address] = tuple(atoms)
-        self._cache[address] = account
-
-    def staged_items(self) -> Iterable[Tuple[bytes, Account]]:
-        return self._staged.items()
-
-    def staged_hashes(self) -> Dict[bytes, bytes]:
-        return dict(self._staged_hashes)
-
-    def staged_atoms(self) -> Dict[bytes, Iterable[Atom]]:
-        return {addr: tuple(atoms) for addr, atoms in self._staged_atoms.items()}

astreum/_consensus/block.py

@@ -1,328 +0,0 @@
-
-from typing import Any, 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
-
-
-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")
-
-
-def _make_list(child_ids: List[bytes]) -> Tuple[bytes, List[Atom]]:
-    """Create a typed 'list' atom for child object ids.
-
-    Encodes elements as a linked chain of element-atoms with data=child_id and
-    next pointing to the next element's object id. The list value atom contains
-    the element count and points to the head of the element chain. The type atom
-    identifies the structure as a list.
-    """
-    acc: List[Atom] = []
-    next_hash = ZERO32
-    elem_atoms: List[Atom] = []
-    # Build element chain in reverse, then flip to maintain forward order
-    for h in reversed(child_ids):
-        a = Atom.from_data(data=h, next_hash=next_hash)
-        next_hash = a.object_id()
-        elem_atoms.append(a)
-    elem_atoms.reverse()
-    head = next_hash
-    val = Atom.from_data(data=(len(child_ids)).to_bytes(8, "little"), next_hash=head)
-    typ = Atom.from_data(data=b"list", next_hash=val.object_id())
-    return typ.object_id(), acc + elem_atoms + [val, typ]
-
-
-class Block:
-    """Validation Block representation using Atom storage.
-
-    Top-level encoding:
-      block_id = list([ type_atom, body_list, signature_atom ])
-      where: type_atom      = Atom(data=b"block", next=body_list_id)
-             body_list      = list([...details...])
-             signature_atom = Atom(data=<signature-bytes>)
-
-    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] = []
-        atoms_acc: List[Atom] = []
-
-        def _emit(detail_bytes: bytes) -> None:
-            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
-        _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
-        body_id, body_atoms = _make_list(details_ids)
-        atoms_acc.extend(body_atoms)
-        self.body_hash = body_id
-
-        # Type atom points to body list
-        type_atom = Atom.from_data(data=b"block", next_hash=body_id)
-
-        # Signature atom (raw byte payload)
-        sig_atom = Atom.from_data(data=self.signature or b"", next_hash=ZERO32)
-
-        # Main block list: [type_atom, body_list, signature]
-        main_id, main_atoms = _make_list([type_atom.object_id(), body_id, sig_atom.object_id()])
-        atoms_acc.append(type_atom)
-        atoms_acc.append(sig_atom)
-        atoms_acc.extend(main_atoms)
-
-        self.hash = main_id
-        return self.hash, atoms_acc
-
-    @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, "_local_get", None)
-        if not callable(storage_get):
-            raise TypeError("Block.from_atom requires a node with '_local_get' or a callable storage getter")
-        # 1) Expect main list
-        main_typ = storage_get(block_id)
-        if main_typ is None or main_typ.data != b"list":
-            raise ValueError("not a block (main list missing)")
-        main_val = storage_get(main_typ.next)
-        if main_val is None:
-            raise ValueError("malformed block list (missing value)")
-        # length is little-endian u64 per storage format
-        if len(main_val.data) < 1:
-            raise ValueError("malformed block list (length)")
-        head = main_val.next
-
-        # read first 2 elements: [type_atom_id, body_list_id]
-        first_elem = storage_get(head)
-        if first_elem is None:
-            raise ValueError("malformed block list (head element)")
-        type_atom_id = first_elem.data
-        second_elem = storage_get(first_elem.next)
-        if second_elem is None:
-            raise ValueError("malformed block list (second element)")
-        body_list_id = second_elem.data
-        # optional 3rd element: signature atom id
-        third_elem = storage_get(second_elem.next) if second_elem.next else None
-        sig_atom_id: Optional[bytes] = third_elem.data if third_elem is not None else None
-
-        # 2) Validate type atom and linkage to body
-        type_atom = storage_get(type_atom_id)
-        if type_atom is None or type_atom.data != b"block" or type_atom.next != body_list_id:
-            raise ValueError("not a block (type atom)")
-
-        # 3) Parse body list of details
-        body_typ = storage_get(body_list_id)
-        if body_typ is None or body_typ.data != b"list":
-            raise ValueError("malformed body (type)")
-        body_val = storage_get(body_typ.next)
-        if body_val is None:
-            raise ValueError("malformed body (value)")
-        cur_elem_id = body_val.next
-
-        def _read_detail_bytes(elem_id: bytes) -> bytes:
-            elem = storage_get(elem_id)
-            if elem is None:
-                return b""
-            child_id = elem.data
-            detail = storage_get(child_id)
-            return detail.data if detail is not None else b""
-
-        details: List[bytes] = []
-        # We read up to 10 fields if present
-        for _ in range(10):
-            if not cur_elem_id:
-                break
-            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""
-
-        b = cls()
-        b.hash = block_id
-        b.body_hash = body_list_id
-
-        # Map details back per the defined order
-        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
-
-        # 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"bytes":
-                    sval = storage_get(sa.next)
-                    b.signature = sval.data if sval is not None else b""
-                else:
-                    b.signature = sa.data
-
-        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,141 +0,0 @@
-
-from __future__ import annotations
-
-from typing import Any, Iterable, List, Optional, Tuple
-
-from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
-
-from .account import Account
-from .block import Block
-from .._storage.atom import Atom, ZERO32
-from .._storage.patricia import PatriciaTrie, PatriciaNode
-
-TREASURY_ADDRESS = b"\x01" * 32
-BURN_ADDRESS = b"\x00" * 32
-
-
-def _int_to_be_bytes(value: int) -> bytes:
-    if value < 0:
-        raise ValueError("integer fields in genesis must be non-negative")
-    if value == 0:
-        return b"\x00"
-    length = (value.bit_length() + 7) // 8
-    return value.to_bytes(length, "big")
-
-
-def _make_list(child_ids: List[bytes]) -> Tuple[bytes, 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()
-
-    value_atom = Atom.from_data(
-        data=len(child_ids).to_bytes(8, "little"),
-        next_hash=next_hash,
-    )
-    type_atom = Atom.from_data(data=b"list", next_hash=value_atom.object_id())
-    atoms = chain + [value_atom, type_atom]
-    return type_atom.object_id(), atoms
-
-
-def _store_atoms(node: Any, atoms: Iterable[Atom]) -> None:
-    setter = getattr(node, "_local_set", None)
-    if not callable(setter):
-        raise TypeError("node must expose '_local_set(object_id, atom)'")
-    for atom in atoms:
-        setter(atom.object_id(), atom)
-
-
-def _persist_trie(trie: PatriciaTrie, node: Any) -> None:
-    for patricia_node in trie.nodes.values():
-        _, atoms = patricia_node.to_atoms()
-        _store_atoms(node, atoms)
-
-
-if not hasattr(PatriciaNode, "to_bytes"):
-    def _patricia_node_to_bytes(self: PatriciaNode) -> bytes:  # type: ignore[no-redef]
-        fields = [
-            bytes([self.key_len]) + self.key,
-            self.child_0 or ZERO32,
-            self.child_1 or ZERO32,
-            self.value or b"",
-        ]
-        encoded: List[bytes] = []
-        for field in fields:
-            encoded.append(len(field).to_bytes(4, "big"))
-            encoded.append(field)
-        return b"".join(encoded)
-
-    PatriciaNode.to_bytes = _patricia_node_to_bytes  # type: ignore[attr-defined]
-
-
-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 = (1).to_bytes(32, "big")
-    stake_trie.put(node, validator_pk, stake_amount)
-    _persist_trie(stake_trie, node)
-    stake_root = stake_trie.root_hash or ZERO32
-
-    # 2. Account trie with treasury, burn, and validator accounts.
-    accounts_trie = PatriciaTrie()
-
-    treasury_account = Account.create(balance=1, data=stake_root, nonce=0)
-    treasury_account_id, treasury_atoms = treasury_account.to_atom()
-    _store_atoms(node, treasury_atoms)
-    accounts_trie.put(node, TREASURY_ADDRESS, treasury_account_id)
-
-    burn_account = Account.create(balance=0, data=b"", nonce=0)
-    burn_account_id, burn_atoms = burn_account.to_atom()
-    _store_atoms(node, burn_atoms)
-    accounts_trie.put(node, BURN_ADDRESS, burn_account_id)
-
-    validator_account = Account.create(balance=0, data=b"", nonce=0)
-    validator_account_id, validator_atoms = validator_account.to_atom()
-    _store_atoms(node, validator_atoms)
-    accounts_trie.put(node, validator_pk, validator_account_id)
-
-    _persist_trie(accounts_trie, node)
-
-    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_atoms = block.to_atom()
-    _store_atoms(node, block_atoms)
-
-    block.hash = block_hash
-    return block