astreum 0.2.44__py3-none-any.whl → 0.2.46__py3-none-any.whl

astreum/_consensus/genesis.py

@@ -1,77 +1,18 @@
-
+
 from __future__ import annotations
 
-from typing import Any, Iterable, List, Optional, Tuple
+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 Atom, ZERO32
-from .._storage.patricia import PatriciaTrie, PatriciaNode
+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 _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)
 
@@ -80,30 +21,21 @@ def create_genesis_block(node: Any, validator_public_key: bytes, validator_secre
 
     # 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
+    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)
-    treasury_account_id, treasury_atoms = treasury_account.to_atom()
-    _store_atoms(node, treasury_atoms)
-    accounts_trie.put(node, TREASURY_ADDRESS, treasury_account_id)
+    accounts_trie.put(storage_node=node, key=TREASURY_ADDRESS, value=treasury_account.hash)
 
     burn_account = Account.create(balance=0, data=b"", counter=0)
-    burn_account_id, burn_atoms = burn_account.to_atom()
-    _store_atoms(node, burn_atoms)
-    accounts_trie.put(node, BURN_ADDRESS, burn_account_id)
+    accounts_trie.put(storage_node=node, key=BURN_ADDRESS, value=burn_account.hash)
 
     validator_account = Account.create(balance=0, data=b"", counter=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_trie.put(storage_node=node, key=validator_pk, value=validator_account.hash)
 
     accounts_root = accounts_trie.root_hash
     if accounts_root is None:
@@ -134,8 +66,7 @@ def create_genesis_block(node: Any, validator_public_key: bytes, validator_secre
 
     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.to_atom()
 
     block.hash = block_hash
     return block

astreum/_consensus/setup.py

@@ -2,13 +2,15 @@ from __future__ import annotations
 
 import threading
 from queue import Queue
-from typing import Any
+from typing import Any, Optional
 
 from .workers import (
     make_discovery_worker,
     make_validation_worker,
     make_verify_worker,
 )
+from .genesis import create_genesis_block
+from ..utils.bytes import hex_to_bytes
 
 
 def current_validator(node: Any) -> bytes:
@@ -16,7 +18,9 @@ def current_validator(node: Any) -> bytes:
     raise NotImplementedError("current_validator must be implemented by the host node")
 
 
-def consensus_setup(node: Any) -> None:
+def consensus_setup(node: Any, config: Optional[dict] = None) -> None:
+    config = config or {}
+
     # Shared state
     node.validation_lock = getattr(node, "validation_lock", threading.RLock())
 
@@ -26,6 +30,12 @@ def consensus_setup(node: Any) -> None:
     node.chains = getattr(node, "chains", {})
     node.forks = getattr(node, "forks", {})
 
+    node.latest_block_hash = None
+    latest_block_hex = config.get("latest_block_hash")
+    if latest_block_hex is not None:
+        node.latest_block_hash = hex_to_bytes(latest_block_hex, expected_length=32)
+    node.latest_block = None
+
     # Pending transactions queue (hash-only entries)
     node._validation_transaction_queue = getattr(
         node, "_validation_transaction_queue", Queue()
@@ -64,5 +74,42 @@ def consensus_setup(node: Any) -> None:
     )
     node.consensus_discovery_thread.start()
     node.consensus_verify_thread.start()
-    if getattr(node, "validation_secret_key", None):
+
+    validator_secret_hex = config.get("validation_secret_key")
+    if validator_secret_hex:
+        validator_secret_bytes = hex_to_bytes(validator_secret_hex, expected_length=32)
+        try:
+            from cryptography.hazmat.primitives import serialization
+            from cryptography.hazmat.primitives.asymmetric import ed25519
+
+            validator_private = ed25519.Ed25519PrivateKey.from_private_bytes(
+                validator_secret_bytes
+            )
+        except Exception as exc:
+            raise ValueError("invalid validation_secret_key") from exc
+
+        validator_public_bytes = validator_private.public_key().public_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw,
+        )
+
+        node.validation_secret_key = validator_private
+        node.validation_public_key = validator_public_bytes
+
+        if node.latest_block_hash is None:
+            genesis_block = create_genesis_block(
+                node,
+                validator_public_key=validator_public_bytes,
+                validator_secret_key=validator_secret_bytes,
+            )
+            genesis_hash, genesis_atoms = genesis_block.to_atom()
+            if hasattr(node, "_local_set"):
+                for atom in genesis_atoms:
+                    try:
+                        node._local_set(atom.object_id(), atom)
+                    except Exception:
+                        pass
+            node.latest_block_hash = genesis_hash
+            node.latest_block = genesis_block
+
         node.consensus_validation_thread.start()

astreum/_lispeum/parser.py

@@ -1,5 +1,5 @@
-from typing import List, Tuple
-from src.astreum._lispeum import Expr
+from typing import List, Tuple
+from . import Expr
 
 class ParseError(Exception):
     pass
@@ -27,30 +27,30 @@ def _parse_one(tokens: List[str], pos: int = 0) -> Tuple[Expr, int]:
     if tok == ')':
         raise ParseError("unexpected ')'")
 
-    # try integer → Bytes (variable-length two's complement)
-    try:
-        n = int(tok)
-        # encode as minimal-width signed two's complement, big-endian
-        def int_to_min_tc(v: int) -> bytes:
-            """Return the minimal-width signed two's complement big-endian
-            byte encoding of integer v. Width expands just enough so that
-            decoding with signed=True yields the same value and sign.
-            Example: 0 -> b"\x00", 127 -> b"\x7f", 128 -> b"\x00\x80".
-            """
-            if v == 0:
-                return b"\x00"
-            w = 1
-            while True:
-                try:
-                    return v.to_bytes(w, "big", signed=True)
-                except OverflowError:
-                    w += 1
-
-        return Expr.Bytes(int_to_min_tc(n)), pos + 1
-    except ValueError:
-        return Expr.Symbol(tok), pos + 1
+    # try integer → Bytes (variable-length two's complement)
+    try:
+        n = int(tok)
+        # encode as minimal-width signed two's complement, big-endian
+        def int_to_min_tc(v: int) -> bytes:
+            """Return the minimal-width signed two's complement big-endian
+            byte encoding of integer v. Width expands just enough so that
+            decoding with signed=True yields the same value and sign.
+            Example: 0 -> b"\x00", 127 -> b"\x7f", 128 -> b"\x00\x80".
+            """
+            if v == 0:
+                return b"\x00"
+            w = 1
+            while True:
+                try:
+                    return v.to_bytes(w, "big", signed=True)
+                except OverflowError:
+                    w += 1
+
+        return Expr.Bytes(int_to_min_tc(n)), pos + 1
+    except ValueError:
+        return Expr.Symbol(tok), pos + 1
 
 def parse(tokens: List[str]) -> Tuple[Expr, List[str]]:
     """Parse tokens into an Expr and return (expr, remaining_tokens)."""
     expr, next_pos = _parse_one(tokens, 0)
-    return expr, tokens[next_pos:]
+    return expr, tokens[next_pos:]

astreum/_node.py

@@ -3,8 +3,8 @@ from typing import Dict, Optional
 import uuid
 import threading
 
-from src.astreum._storage.atom import Atom
-from src.astreum._lispeum import Env, Expr, low_eval, parse, tokenize, ParseError
+from ._storage.atom import Atom
+from ._lispeum import Env, Expr, low_eval, parse, tokenize, ParseError
 
 def bytes_touched(*vals: bytes) -> int:
     """For metering: how many bytes were manipulated (max of operands)."""
@@ -13,9 +13,9 @@ def bytes_touched(*vals: bytes) -> int:
 class Node:
     def __init__(self, config: dict):
         # Storage Setup
-        self.in_memory_storage: Dict[bytes, Atom] = {}
-        self.in_memory_storage_lock = threading.RLock()
-        self.storage_index: Dict[bytes, str] = {}
+        self.in_memory_storage: Dict[bytes, Atom] = {}
+        self.in_memory_storage_lock = threading.RLock()
+        self.storage_index: Dict[bytes, str] = {}
         # Lispeum Setup
         self.environments: Dict[uuid.UUID, Env] = {}
         self.machine_environments_lock = threading.RLock()
@@ -28,9 +28,11 @@ class Node:
             pass
         try:
             from astreum._consensus import consensus_setup  # type: ignore
-            consensus_setup(node=self)
+            consensus_setup(node=self, config=config)
         except Exception:
             pass
+        
+
 
     # ---- Env helpers ----
     def env_get(self, env_id: uuid.UUID, key: bytes) -> Optional[Expr]:
@@ -73,30 +75,30 @@ class Node:
     def _network_set(self, atom: Atom) -> None:
         """Advertise an atom to the closest known peer so they can fetch it from us."""
         try:
-            from src.astreum._communication.message import Message, MessageTopic
+            from ._communication.message import Message, MessageTopic
         except Exception:
             return
 
         atom_id = atom.object_id()
-        try:
-            closest_peer = self.peer_route.closest_peer_for_hash(atom_id)
-        except Exception:
-            return
-        if closest_peer is None or closest_peer.address is None:
-            return
-        target_addr = closest_peer.address
+        try:
+            closest_peer = self.peer_route.closest_peer_for_hash(atom_id)
+        except Exception:
+            return
+        if closest_peer is None or closest_peer.address is None:
+            return
+        target_addr = closest_peer.address
+
+        try:
+            provider_ip, provider_port = self.incoming_socket.getsockname()[:2]
+        except Exception:
+            return
+
+        provider_str = f"{provider_ip}:{int(provider_port)}"
+        try:
+            provider_bytes = provider_str.encode("utf-8")
+        except Exception:
+            return
 
-        try:
-            provider_ip, provider_port = self.incoming_socket.getsockname()[:2]
-        except Exception:
-            return
-
-        provider_str = f"{provider_ip}:{int(provider_port)}"
-        try:
-            provider_bytes = provider_str.encode("utf-8")
-        except Exception:
-            return
-
-        payload = atom_id + provider_bytes
+        payload = atom_id + provider_bytes
         message = Message(topic=MessageTopic.STORAGE_REQUEST, content=payload)
         self.outgoing_queue.put((message.to_bytes(), target_addr))

astreum/utils/bytes.py

@@ -0,0 +1,24 @@
+from typing import Optional
+
+
+def hex_to_bytes(value: str, *, expected_length: Optional[int] = None) -> bytes:
+    """Convert a 0x-prefixed hex string into raw bytes."""
+    if not isinstance(value, str):
+        raise TypeError("hex value must be provided as a string")
+
+    if not value.startswith(("0x", "0X")):
+        raise ValueError("hex value must start with '0x'")
+
+    hex_digits = value[2:]
+    if len(hex_digits) % 2:
+        raise ValueError("hex value must have an even number of digits")
+
+    try:
+        result = bytes.fromhex(hex_digits)
+    except ValueError as exc:
+        raise ValueError("hex value contains non-hexadecimal characters") from exc
+
+    if expected_length is not None and len(result) != expected_length:
+        raise ValueError(f"hex value must decode to exactly {expected_length} bytes")
+
+    return result

{astreum-0.2.44.dist-info → astreum-0.2.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.44
+Version: 0.2.46
 Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
 Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
 Project-URL: Homepage, https://github.com/astreum/lib

{astreum-0.2.44.dist-info → astreum-0.2.46.dist-info}/RECORD

@@ -1,5 +1,5 @@
 astreum/__init__.py,sha256=9tzA27B_eG5wRF1SAWJIV7xTmCcR1QFc123b_cvFOa4,345
-astreum/_node.py,sha256=AUpLjqbHno-Oh2X47nEfoU4I9i_Aj5vjXM1mHQH0gfM,3780
+astreum/_node.py,sha256=dTwXjnCJZHjUw8dPmH7neaL1-M4rso77Aogo0935vsY,3796
 astreum/format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
 astreum/node.py,sha256=MmlK3jaANTMB3ZAxR8IaSc82OS9meJmVawYIVURADbg,39689
 astreum/_communication/__init__.py,sha256=XJui0yOcfAur4HKt-8sSRlwB-MSU1rchkuOAY-nKDOE,207
@@ -15,9 +15,9 @@ astreum/_consensus/accounts.py,sha256=zGq2BCMJPtD_lzcj4jqMzB2Foc3ptxXSPhc9zypB1T
 astreum/_consensus/block.py,sha256=HybdVcV1D9f1wUE9XeFRnCGF9HH8YI1bgo-y1h-RS5o,12342
 astreum/_consensus/chain.py,sha256=WwUeLrdg7uj--ZsUxse6xFlzO2QeQQggyKSL49KhfU0,2768
 astreum/_consensus/fork.py,sha256=dK5DtT9hWCj_rQs6MS1c1bcGBbkgVTBPIOudYbqS9vw,3825
-astreum/_consensus/genesis.py,sha256=oED7AHw0fPJgMu0OmhbbikJcbItw_bxVBVU8RlB2rJM,4766
+astreum/_consensus/genesis.py,sha256=YOzEEcpH5lQUdRNz1P8cfeddh-IJzjTbOiVKrEPHXPg,2506
 astreum/_consensus/receipt.py,sha256=GPLspqVJHnyBr1cKmBoClsJyeEUecYmg3_acz4L4rRo,6031
-astreum/_consensus/setup.py,sha256=agwqfOemdLqE0Z1zrPV2XHVmZ9sAxp8Bh4k6e2u-t8w,2385
+astreum/_consensus/setup.py,sha256=KHW2KzHRgCMLWaJNV2utosKdk7nxjI5aF9ie7jctgcU,4257
 astreum/_consensus/transaction.py,sha256=q9r0nQzB_67dV-9cIThCzpiJkTojP--8QENPOKxN5yw,7481
 astreum/_consensus/workers/__init__.py,sha256=bS5FjbevbIR5FHbVGnT4Jli17VIld_5auemRw4CaHFU,278
 astreum/_consensus/workers/discovery.py,sha256=X1yjKGjLSApMJ9mgWbnc7N21ALD09khDf-in-M45Mis,1683
@@ -29,7 +29,7 @@ astreum/_lispeum/expression.py,sha256=io8tbCer_1TJee77yRbcNI5q-DPFGa8xZiC80tGvRR
 astreum/_lispeum/high_evaluation.py,sha256=7MwIeVZMPumYvKXn6Lkn-GrZhRNB6MjnUUWdiYT7Ei0,7952
 astreum/_lispeum/low_evaluation.py,sha256=HgyCSAmL5K5SKq3Xw_BtbTZZUJbMg4-bVZW-A12glQ0,4373
 astreum/_lispeum/meter.py,sha256=5q2PFW7_jmgKVM1-vwE4RRjMfPEthUA4iu1CwR-Axws,505
-astreum/_lispeum/parser.py,sha256=WOW3sSZWkIzPEy3fYTyl0lrtkMxHL9zRrNSYztPDemQ,2271
+astreum/_lispeum/parser.py,sha256=rpxznlILbGruCS8wS_SQajYs7MlNPoMPbQ48XEjLeRo,2277
 astreum/_lispeum/tokenizer.py,sha256=P68uIj4aPKzjuCJ85jfzRi67QztpuXIOC1vvLQueBI4,552
 astreum/_storage/__init__.py,sha256=EmKZNAZmo3UVE3ekOOuckwFnBVjpa0Sy8Oxg72Lgdxc,53
 astreum/_storage/atom.py,sha256=YFjvfMhniInch13iaKGpw4CCxxgyWonniryb-Rfse4A,4177
@@ -46,9 +46,10 @@ astreum/models/patricia.py,sha256=ohmXrcaz7Ae561tyC4u4iPOkQPkKr8N0IWJek4upFIg,13
 astreum/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/storage/object.py,sha256=knFlvw_tpcC4twSu1DGNpHX31wlANN8E5dgEqIfU--Q,2041
 astreum/storage/setup.py,sha256=1-9ztEFI_BvRDvAA0lAn4mFya8iq65THTArlj--M3Hg,626
+astreum/utils/bytes.py,sha256=9QTWC2JCdwWLB5R2mPtmjPro0IUzE58DL3uEul4AheE,846
 astreum/utils/integer.py,sha256=iQt-klWOYVghu_NOT341MmHbOle4FDT3by4PNKNXscg,736
-astreum-0.2.44.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.44.dist-info/METADATA,sha256=BfQ0S0XtFjxl4evYAAWk9buUhQAVAq7L37patJVYDDU,6181
-astreum-0.2.44.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.44.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.44.dist-info/RECORD,,
+astreum-0.2.46.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.2.46.dist-info/METADATA,sha256=o454zFl45Clnos8EwXm0PCSivnHw8fkoOC3C2mCFXYo,6181
+astreum-0.2.46.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.2.46.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.2.46.dist-info/RECORD,,