astreum 0.2.43__tar.gz → 0.2.45__tar.gz

{astreum-0.2.43/src/astreum.egg-info → astreum-0.2.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.43
+Version: 0.2.45
 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.43 → astreum-0.2.45}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "astreum"
-version = "0.2.43"
+version = "0.2.45"
 authors = [
   { name="Roy R. O. Okello", email="roy@stelar.xyz" },
 ]

{astreum-0.2.43 → astreum-0.2.45}/src/astreum/_communication/message.py

@@ -10,6 +10,7 @@ class MessageTopic(IntEnum):
     ROUTE_REQUEST = 3
     ROUTE_RESPONSE = 4
     TRANSACTION = 5
+    STORAGE_REQUEST = 6
     
 
 class Message:

astreum-0.2.45/src/astreum/_communication/peer.py

@@ -0,0 +1,23 @@
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
+from cryptography.hazmat.primitives import serialization
+from datetime import datetime, timezone
+from typing import Optional, Tuple
+
+class Peer:
+    shared_key: bytes
+    timestamp: datetime
+    latest_block: bytes
+    address: Optional[Tuple[str, int]]
+    public_key: X25519PublicKey
+    public_key_bytes: bytes
+
+    def __init__(self, my_sec_key: X25519PrivateKey, peer_pub_key: X25519PublicKey):
+        self.shared_key = my_sec_key.exchange(peer_pub_key)
+        self.timestamp = datetime.now(timezone.utc)
+        self.latest_block = b""
+        self.address = None
+        self.public_key = peer_pub_key
+        self.public_key_bytes = peer_pub_key.public_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw,
+        )

{astreum-0.2.43 → astreum-0.2.45}/src/astreum/_communication/route.py

@@ -1,6 +1,7 @@
-from typing import Dict, List, Union
+from typing import Dict, List, Optional, Union
 from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PublicKey
+from .peer import Peer
 
 PeerKey = Union[X25519PublicKey, bytes, bytearray]
 
@@ -15,7 +16,7 @@ class Route:
         self.buckets: Dict[int, List[bytes]] = {
             i: [] for i in range(len(self.relay_public_key_bytes) * 8)
         }
-        self.peers = {}
+        self.peers: Dict[bytes, Peer] = {}
 
     @staticmethod
     def _matching_leading_bits(a: bytes, b: bytes) -> int:
@@ -38,13 +39,21 @@ class Route:
             return key_bytes
         raise TypeError("peer_public_key must be raw bytes or X25519PublicKey")
 
-    def add_peer(self, peer_public_key: PeerKey):
+    @staticmethod
+    def _xor_distance(a: bytes, b: bytes) -> int:
+        if len(a) != len(b):
+            raise ValueError("xor distance requires equal-length operands")
+        return int.from_bytes(bytes(x ^ y for x, y in zip(a, b)), "big", signed=False)
+
+    def add_peer(self, peer_public_key: PeerKey, peer: Optional[Peer] = None):
         peer_public_key_bytes = self._normalize_peer_key(peer_public_key)
         bucket_idx = self._matching_leading_bits(self.relay_public_key_bytes, peer_public_key_bytes)
         if len(self.buckets[bucket_idx]) < self.bucket_size:
             bucket = self.buckets[bucket_idx]
             if peer_public_key_bytes not in bucket:
                 bucket.append(peer_public_key_bytes)
+        if peer is not None:
+            self.peers[peer_public_key_bytes] = peer
 
     def remove_peer(self, peer_public_key: PeerKey):
         peer_public_key_bytes = self._normalize_peer_key(peer_public_key)
@@ -56,3 +65,31 @@ class Route:
             bucket.remove(peer_public_key_bytes)
         except ValueError:
             pass
+        self.peers.pop(peer_public_key_bytes, None)
+
+    def closest_peer_for_hash(self, target_hash: bytes) -> Optional[Peer]:
+        """Return the peer with the minimal XOR distance to ``target_hash``."""
+        if not isinstance(target_hash, (bytes, bytearray)):
+            raise TypeError("target_hash must be bytes-like")
+
+        target = bytes(target_hash)
+        if len(target) != len(self.relay_public_key_bytes):
+            raise ValueError("target_hash must match peer key length (32 bytes)")
+
+        closest_key: Optional[bytes] = None
+        closest_distance: Optional[int] = None
+
+        for bucket in self.buckets.values():
+            for peer_key in bucket:
+                try:
+                    distance = self._xor_distance(target, peer_key)
+                except ValueError:
+                    continue
+                if closest_distance is None or distance < closest_distance:
+                    closest_distance = distance
+                    closest_key = peer_key
+
+        if closest_key is None:
+            return None
+        peer = self.peers.get(closest_key)
+        return peer

{astreum-0.2.43 → astreum-0.2.45}/src/astreum/_communication/setup.py

@@ -95,9 +95,10 @@ def process_incoming_messages(node: "Node") -> None:
                     peer = Peer(node.relay_secret_key, sender_key)
                 except Exception:
                     continue
-                
+                peer.address = address_key
+
                 node.peers[sender_public_key_bytes] = peer
-                node.peer_route.add_peer(sender_public_key_bytes)
+                node.peer_route.add_peer(sender_public_key_bytes, peer)
 
                 response = Message(handshake=True, sender=node.relay_public_key)
                 node.outgoing_queue.put((response.to_bytes(), address_key))
@@ -105,17 +106,25 @@ def process_incoming_messages(node: "Node") -> None:
             
             elif old_key_bytes == sender_public_key_bytes:
                 # existing mapping with same key -> nothing to change
-                pass
+                peer = node.peers.get(sender_public_key_bytes)
+                if peer is not None:
+                    peer.address = address_key
             
             else:
                 # address reused with a different key -> replace peer
                 node.peers.pop(old_key_bytes, None)
+                try:
+                    node.peer_route.remove_peer(old_key_bytes)
+                except Exception:
+                    pass
                 try:
                     peer = Peer(node.relay_secret_key, sender_key)
                 except Exception:
                     continue
-                
+                peer.address = address_key
+
                 node.peers[sender_public_key_bytes] = peer
+                node.peer_route.add_peer(sender_public_key_bytes, peer)
 
         match message.topic:
             case MessageTopic.PING:
@@ -164,6 +173,65 @@ def process_incoming_messages(node: "Node") -> None:
                 if node.validation_secret_key is None:
                     continue
                 node._validation_transaction_queue.put(message.content)
+
+            case MessageTopic.STORAGE_REQUEST:
+                payload = message.content
+                if len(payload) < 32:
+                    continue
+
+                atom_id = payload[:32]
+                provider_bytes = payload[32:]
+                if not provider_bytes:
+                    continue
+
+                try:
+                    provider_str = provider_bytes.decode("utf-8")
+                except UnicodeDecodeError:
+                    continue
+
+                try:
+                    host, port = addr[0], int(addr[1])
+                except Exception:
+                    continue
+                address_key = (host, port)
+                sender_key_bytes = node.addresses.get(address_key)
+                if sender_key_bytes is None:
+                    continue
+
+                try:
+                    local_key_bytes = node.relay_public_key.public_bytes(
+                        encoding=serialization.Encoding.Raw,
+                        format=serialization.PublicFormat.Raw,
+                    )
+                except Exception:
+                    continue
+
+                def xor_distance(target: bytes, key: bytes) -> int:
+                    return int.from_bytes(
+                        bytes(a ^ b for a, b in zip(target, key)),
+                        byteorder="big",
+                        signed=False,
+                    )
+
+                self_distance = xor_distance(atom_id, local_key_bytes)
+
+                try:
+                    closest_peer = node.peer_route.closest_peer_for_hash(atom_id)
+                except Exception:
+                    closest_peer = None
+
+                if (
+                    closest_peer is not None
+                    and closest_peer.public_key_bytes != sender_key_bytes
+                ):
+                    closest_distance = xor_distance(atom_id, closest_peer.public_key_bytes)
+                    if closest_distance < self_distance:
+                        target_addr = closest_peer.address
+                        if target_addr is not None and target_addr != addr:
+                            node.outgoing_queue.put((message.to_bytes(), target_addr))
+                            continue
+
+                node.storage_index[atom_id] = provider_str.strip()
             
             case _:
                 continue

astreum-0.2.45/src/astreum/_consensus/genesis.py

@@ -0,0 +1,72 @@
+
+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-0.2.43 → astreum-0.2.45}/src/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-0.2.43 → astreum-0.2.45}/src/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-0.2.43 → astreum-0.2.45}/src/astreum/_node.py

@@ -15,21 +15,24 @@ class Node:
         # Storage Setup
         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()
         self.low_eval = low_eval
         # Communication and Validation Setup (import lazily to avoid heavy deps during parsing tests)
-        try:
-            from astreum._communication import communication_setup  # type: ignore
-            communication_setup(node=self, config=config)
-        except Exception:
-            pass
-        try:
-            from astreum._consensus import consensus_setup  # type: ignore
-            consensus_setup(node=self)
-        except Exception:
-            pass
+        try:
+            from astreum._communication import communication_setup  # type: ignore
+            communication_setup(node=self, config=config)
+        except Exception:
+            pass
+        try:
+            from astreum._consensus import consensus_setup  # type: ignore
+            consensus_setup(node=self, config=config)
+        except Exception:
+            pass
+        
+
 
     # ---- Env helpers ----
     def env_get(self, env_id: uuid.UUID, key: bytes) -> Optional[Expr]:
@@ -68,3 +71,34 @@ class Node:
         if atom is not None:
             return atom
         return self._network_get(key)
+
+    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
+        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:
+            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
+        message = Message(topic=MessageTopic.STORAGE_REQUEST, content=payload)
+        self.outgoing_queue.put((message.to_bytes(), target_addr))

astreum-0.2.45/src/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.43 → astreum-0.2.45/src/astreum.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.43
+Version: 0.2.45
 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.43 → astreum-0.2.45}/src/astreum.egg-info/SOURCES.txt

@@ -54,4 +54,5 @@ src/astreum/models/patricia.py
 src/astreum/storage/__init__.py
 src/astreum/storage/object.py
 src/astreum/storage/setup.py
+src/astreum/utils/bytes.py
 src/astreum/utils/integer.py

astreum-0.2.43/src/astreum/_communication/peer.py

@@ -1,11 +0,0 @@
-from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
-from datetime import datetime, timezone
-
-class Peer:
-    shared_key: bytes
-    timestamp: datetime
-    latest_block: bytes
-
-    def __init__(self, my_sec_key: X25519PrivateKey, peer_pub_key: X25519PublicKey):
-        self.shared_key = my_sec_key.exchange(peer_pub_key)
-        self.timestamp = datetime.now(timezone.utc)

astreum-0.2.43/src/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, 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)
-
-    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)
-
-    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_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