astreum 0.3.46__py3-none-any.whl → 0.3.48__py3-none-any.whl

astreum/communication/handlers/object_request.py

@@ -1,9 +1,16 @@
 import logging
 import socket
 from enum import IntEnum
-from typing import TYPE_CHECKING, Tuple
+from typing import Optional, TYPE_CHECKING, Tuple
 
-from .object_response import ObjectResponse, ObjectResponseType
+from .object_response import (
+    ObjectResponse,
+    ObjectResponseType,
+    OBJECT_FOUND_ATOM_PAYLOAD,
+    OBJECT_FOUND_LIST_PAYLOAD,
+    encode_object_found_atom_payload,
+    encode_object_found_list_payload,
+)
 from ..outgoing_queue import enqueue_outgoing
 from ..models.message import Message, MessageTopic
 from ..util import xor_distance
@@ -19,22 +26,34 @@ class ObjectRequestType(IntEnum):
     OBJECT_PUT = 1
 
 
-class ObjectRequest:
-    type: ObjectRequestType
-    data: bytes
-    atom_id: bytes
-
-    def __init__(self, type: ObjectRequestType, data: bytes, atom_id: bytes = None):
-        self.type = type
-        self.data = data
-        self.atom_id = atom_id
-
-    def to_bytes(self):
-        return bytes([self.type.value]) + self.atom_id + self.data
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> "ObjectRequest":
-        # need at least 1 byte for type + 32 bytes for hash
+class ObjectRequest:
+    type: ObjectRequestType
+    data: bytes
+    atom_id: bytes
+    payload_type: Optional[int]
+
+    def __init__(
+        self,
+        type: ObjectRequestType,
+        data: bytes = b"",
+        atom_id: bytes = None,
+        payload_type: Optional[int] = None,
+    ):
+        self.type = type
+        self.data = data
+        self.atom_id = atom_id
+        self.payload_type = payload_type
+
+    def to_bytes(self):
+        if self.type == ObjectRequestType.OBJECT_GET and self.payload_type is not None:
+            payload = bytes([self.payload_type]) + self.data
+        else:
+            payload = self.data
+        return bytes([self.type.value]) + self.atom_id + payload
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> "ObjectRequest":
+        # need at least 1 byte for type + 32 bytes for hash
         if len(data) < 1 + 32:
             raise ValueError(f"Too short for ObjectRequest ({len(data)} bytes)")
 
@@ -44,9 +63,16 @@ class ObjectRequest:
         except ValueError:
             raise ValueError(f"Unknown ObjectRequestType: {type_val!r}")
 
-        atom_id_bytes = data[1:33]
-        payload    = data[33:]
-        return cls(req_type, payload, atom_id_bytes)
+        atom_id_bytes = data[1:33]
+        payload = data[33:]
+        if req_type == ObjectRequestType.OBJECT_GET:
+            if payload:
+                payload_type = payload[0]
+                payload = payload[1:]
+            else:
+                payload_type = None
+            return cls(req_type, payload, atom_id_bytes, payload_type=payload_type)
+        return cls(req_type, payload, atom_id_bytes)
 
 
 def encode_peer_contact_bytes(peer: "Peer") -> bytes:
@@ -75,31 +101,63 @@ def handle_object_request(node: "Node", peer: "Peer", message: Message) -> None:
         return
 
     match object_request.type:
-        case ObjectRequestType.OBJECT_GET:
-            atom_id = object_request.atom_id
-            node.logger.debug("Handling OBJECT_GET for %s from %s", atom_id.hex(), peer.address)
-
-            local_atom = node.local_get(atom_id)
-            if local_atom is not None:
-                node.logger.debug("Object %s found locally; returning to %s", atom_id.hex(), peer.address)
-                resp = ObjectResponse(
-                    type=ObjectResponseType.OBJECT_FOUND,
-                    data=local_atom.to_bytes(),
-                    atom_id=atom_id
-                )
-                obj_res_msg  = Message(
-                    topic=MessageTopic.OBJECT_RESPONSE,
-                    body=resp.to_bytes(),
-                    sender=node.relay_public_key,
-                )
-                obj_res_msg.encrypt(peer.shared_key_bytes)
-                enqueue_outgoing(
-                    node,
-                    peer.address,
-                    message=obj_res_msg,
-                    difficulty=peer.difficulty,
+        case ObjectRequestType.OBJECT_GET:
+            atom_id = object_request.atom_id
+            node.logger.debug("Handling OBJECT_GET for %s from %s", atom_id.hex(), peer.address)
+            payload_type = object_request.payload_type
+            if payload_type is None:
+                payload_type = OBJECT_FOUND_ATOM_PAYLOAD
+
+            if payload_type == OBJECT_FOUND_ATOM_PAYLOAD:
+                local_atom = node.get_atom_from_local_storage(atom_id=atom_id)
+                if local_atom is not None:
+                    node.logger.debug("Object %s found locally; returning to %s", atom_id.hex(), peer.address)
+                    resp = ObjectResponse(
+                        type=ObjectResponseType.OBJECT_FOUND,
+                        data=encode_object_found_atom_payload(local_atom),
+                        atom_id=atom_id
+                    )
+                    obj_res_msg  = Message(
+                        topic=MessageTopic.OBJECT_RESPONSE,
+                        body=resp.to_bytes(),
+                        sender=node.relay_public_key,
+                    )
+                    obj_res_msg.encrypt(peer.shared_key_bytes)
+                    enqueue_outgoing(
+                        node,
+                        peer.address,
+                        message=obj_res_msg,
+                        difficulty=peer.difficulty,
+                    )
+                    return
+            elif payload_type == OBJECT_FOUND_LIST_PAYLOAD:
+                local_atoms = node.get_atom_list_from_local_storage(root_hash=atom_id)
+                if local_atoms is not None:
+                    node.logger.debug("Object list %s found locally; returning to %s", atom_id.hex(), peer.address)
+                    resp = ObjectResponse(
+                        type=ObjectResponseType.OBJECT_FOUND,
+                        data=encode_object_found_list_payload(local_atoms),
+                        atom_id=atom_id
+                    )
+                    obj_res_msg  = Message(
+                        topic=MessageTopic.OBJECT_RESPONSE,
+                        body=resp.to_bytes(),
+                        sender=node.relay_public_key,
+                    )
+                    obj_res_msg.encrypt(peer.shared_key_bytes)
+                    enqueue_outgoing(
+                        node,
+                        peer.address,
+                        message=obj_res_msg,
+                        difficulty=peer.difficulty,
+                    )
+                    return
+            else:
+                node.logger.warning(
+                    "Unknown OBJECT_GET payload type %s for %s",
+                    payload_type,
+                    atom_id.hex(),
                 )
-                return
 
             if atom_id in node.storage_index:
                 provider_id = node.storage_index[atom_id]

astreum/communication/handlers/object_response.py

@@ -1,10 +1,11 @@
 import socket
 from enum import IntEnum
-from typing import Tuple, TYPE_CHECKING
+from typing import List, Tuple, TYPE_CHECKING
 
 from ..outgoing_queue import enqueue_outgoing
 from ..models.message import Message, MessageTopic
 from ...storage.models.atom import Atom
+from ...storage.requests import get_atom_req_payload
 
 if TYPE_CHECKING:
     from .. import Node
@@ -17,6 +18,10 @@ class ObjectResponseType(IntEnum):
     OBJECT_NEAREST_PEER = 2
 
 
+OBJECT_FOUND_ATOM_PAYLOAD = 1
+OBJECT_FOUND_LIST_PAYLOAD = 2
+
+
 class ObjectResponse:
     type: ObjectResponseType
     data: bytes
@@ -47,6 +52,37 @@ class ObjectResponse:
         return cls(resp_type, payload, atom_id)
 
 
+def encode_object_found_atom_payload(atom: Atom) -> bytes:
+    return bytes([OBJECT_FOUND_ATOM_PAYLOAD]) + atom.to_bytes()
+
+
+def encode_object_found_list_payload(atoms: List[Atom]) -> bytes:
+    parts = [bytes([OBJECT_FOUND_LIST_PAYLOAD])]
+    for atom in atoms:
+        atom_bytes = atom.to_bytes()
+        parts.append(len(atom_bytes).to_bytes(4, "big", signed=False))
+        parts.append(atom_bytes)
+    return b"".join(parts)
+
+
+def decode_object_found_list_payload(payload: bytes) -> List[Atom]:
+    atoms: List[Atom] = []
+    offset = 0
+    while offset < len(payload):
+        if len(payload) - offset < 4:
+            raise ValueError("truncated atom length")
+        atom_len = int.from_bytes(payload[offset : offset + 4], "big", signed=False)
+        offset += 4
+        if atom_len <= 0:
+            raise ValueError("invalid atom length")
+        end = offset + atom_len
+        if end > len(payload):
+            raise ValueError("truncated atom payload")
+        atoms.append(Atom.from_bytes(payload[offset:end]))
+        offset = end
+    return atoms
+
+
 def decode_object_provider(payload: bytes) -> Tuple[bytes, str, int]:
     expected_len = 32 + 4 + 2
     if len(payload) < expected_len:
@@ -77,17 +113,78 @@ def handle_object_response(node: "Node", peer: "Peer", message: Message) -> None
 
     match object_response.type:
         case ObjectResponseType.OBJECT_FOUND:
-            atom = Atom.from_bytes(object_response.data)
-            atom_id = atom.object_id()
-            if object_response.atom_id == atom_id:
-                node.pop_atom_req(atom_id)
-                node._hot_storage_set(atom_id, atom)
-            else:
+            payload = object_response.data
+            if not payload:
                 node.logger.warning(
-                    "OBJECT_FOUND atom ID mismatch (expected=%s got=%s)",
+                    "OBJECT_FOUND payload for %s missing content",
                     object_response.atom_id.hex(),
-                    atom_id.hex(),
                 )
+                return
+
+            payload_type = payload[0]
+            body = payload[1:]
+
+            if payload_type == OBJECT_FOUND_ATOM_PAYLOAD:
+                try:
+                    atom = Atom.from_bytes(body)
+                except Exception as exc:
+                    node.logger.warning(
+                        "Invalid OBJECT_FOUND atom payload for %s: %s",
+                        object_response.atom_id.hex(),
+                        exc,
+                    )
+                    return
+
+                atom_id = atom.object_id()
+                if object_response.atom_id != atom_id:
+                    node.logger.warning(
+                        "OBJECT_FOUND atom ID mismatch (expected=%s got=%s)",
+                        object_response.atom_id.hex(),
+                        atom_id.hex(),
+                    )
+                    return
+
+                node.pop_atom_req(atom_id)
+                node._hot_storage_set(atom_id, atom)
+                return
+
+            if payload_type == OBJECT_FOUND_LIST_PAYLOAD:
+                try:
+                    atoms = decode_object_found_list_payload(body)
+                except Exception as exc:
+                    node.logger.warning(
+                        "Invalid OBJECT_FOUND list payload for %s: %s",
+                        object_response.atom_id.hex(),
+                        exc,
+                    )
+                    return
+
+                if not atoms:
+                    node.logger.warning(
+                        "OBJECT_FOUND list payload for %s contained no atoms",
+                        object_response.atom_id.hex(),
+                    )
+                    return
+
+                root_id = atoms[0].object_id()
+                if object_response.atom_id != root_id:
+                    node.logger.warning(
+                        "OBJECT_FOUND list root ID mismatch (expected=%s got=%s)",
+                        object_response.atom_id.hex(),
+                        root_id.hex(),
+                    )
+                    return
+
+                node.pop_atom_req(root_id)
+                for atom in atoms:
+                    node._hot_storage_set(atom.object_id(), atom)
+                return
+
+            node.logger.warning(
+                "Unknown OBJECT_FOUND payload type %s for %s",
+                payload_type,
+                object_response.atom_id.hex(),
+            )
 
         case ObjectResponseType.OBJECT_PROVIDER:
             try:
@@ -98,10 +195,15 @@ def handle_object_response(node: "Node", peer: "Peer", message: Message) -> None
 
             from .object_request import ObjectRequest, ObjectRequestType
 
+            payload_type = get_atom_req_payload(node, object_response.atom_id)
+            if payload_type is None:
+                payload_type = OBJECT_FOUND_ATOM_PAYLOAD
+
             obj_req = ObjectRequest(
                 type=ObjectRequestType.OBJECT_GET,
                 data=b"",
                 atom_id=object_response.atom_id,
+                payload_type=payload_type,
             )
             obj_req_bytes = obj_req.to_bytes()
             obj_req_msg = Message(

astreum/communication/setup.py

@@ -206,7 +206,7 @@ def communication_setup(node: "Node", config: dict):
 
     # connection state & atom request tracking
     node.is_connected = False
-    node.atom_requests = set()
+    node.atom_requests = {}
     node.atom_requests_lock = threading.RLock()
 
     # sockets + queues + threads

astreum/machine/evaluations/low_evaluation.py

@@ -143,7 +143,7 @@ def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
                 if idx < 0 or length < 0:
                     return error_expr("low_eval", "bad slice")
 
-                atom = self.storage_get(key=id_b)
+                atom = self.get_atom(atom_id=id_b)
                 if atom is None:
                     return error_expr("low_eval", "unknown atom")
 
@@ -173,7 +173,7 @@ def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
                 if not meter.charge_bytes(len(id1_b) + len(id2_b)):
                     return error_expr("low_eval", "meter limit")
                 
-                atom = self.storage_get(key=id_b)
+                atom = self.get_atom(atom_id=id_b)
                 if atom is None:
                     return error_expr("low_eval", "unknown atom")
 
@@ -195,8 +195,8 @@ def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
                 id2_b = stack.pop()
                 id1_b = stack.pop()
 
-                atom1 = self.storage_get(key=id1_b)
-                atom2 = self.storage_get(key=id2_b)
+                atom1 = self.get_atom(atom_id=id1_b)
+                atom2 = self.get_atom(atom_id=id2_b)
                 if atom1 is None or atom2 is None:
                     return error_expr("low_eval", "unknown atom")
 
@@ -263,7 +263,7 @@ def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
                 if length > 32:
                     return error_expr("low_eval", "load too wide")
 
-                atom = self.storage_get(key=id_b)
+                atom = self.get_atom(atom_id=id_b)
                 if atom is None:
                     return error_expr("low_eval", "unknown atom")
 

astreum/machine/models/expression.py

@@ -46,16 +46,16 @@ class Expr:
         if not isinstance(root_hash, (bytes, bytearray)):
             raise TypeError("root hash must be bytes-like")
 
-        storage_get = getattr(node, "storage_get", None)
-        if not callable(storage_get):
-            raise TypeError("node must provide a callable 'storage_get'")
+        get_atom = getattr(node, "get_atom", None)
+        if not callable(get_atom):
+            raise TypeError("node must provide a callable 'get_atom'")
 
         expr_id = bytes(root_hash)
 
         def _require(atom_id: Optional[bytes], context: str):
             if not atom_id:
                 raise ValueError(f"missing atom id while decoding {context}")
-            atom = storage_get(atom_id)
+            atom = get_atom(atom_id)
             if atom is None:
                 raise ValueError(f"missing atom data while decoding {context}")
             return atom
@@ -197,7 +197,7 @@ def error_expr(topic: str, message: str) -> Expr.ListExpr:
 
 def get_expr_list_from_storage(self, key: bytes) -> Optional["ListExpr"]:
         """Load a list expression from storage using the given atom list root hash."""
-        atoms = self.get_atom_list_from_storage(root_hash=key)
+        atoms = self.get_atom_list(key)
         if atoms is None:
             return None
         

astreum/node.py

@@ -20,14 +20,15 @@ from astreum.verification.node import verify_blockchain
 from astreum.machine import Expr, high_eval, low_eval, script_eval
 from astreum.machine.models.environment import Env, env_get, env_set
 from astreum.machine.models.expression import get_expr_list_from_storage
-from astreum.storage.models.atom import get_atom_list_from_storage
-from astreum.storage.actions.get import (
-    _hot_storage_get,
-    _cold_storage_get,
-    _network_get,
-    storage_get,
-    local_get,
-)
+from astreum.storage.actions.get import (
+    _hot_storage_get,
+    _cold_storage_get,
+    _network_get,
+    get_atom_from_local_storage,
+    get_atom,
+    get_atom_list_from_local_storage,
+    get_atom_list,
+)
 from astreum.storage.actions.set import (
     _hot_storage_set,
     _cold_storage_set,
@@ -86,11 +87,12 @@ class Node:
     _cold_storage_set = _cold_storage_set
     _network_set = _network_set
 
-    storage_get = storage_get
-    local_get = local_get
+    get_atom_from_local_storage = get_atom_from_local_storage
+    get_atom = get_atom
+    get_atom_list_from_local_storage = get_atom_list_from_local_storage
+    get_atom_list = get_atom_list
 
     get_expr_list_from_storage = get_expr_list_from_storage
-    get_atom_list_from_storage = get_atom_list_from_storage
 
     add_atom_req = add_atom_req
     has_atom_req = has_atom_req

astreum/storage/actions/get.py

@@ -1,127 +1,91 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Optional
-
-from ..models.atom import Atom
-from ..providers import provider_payload_for_id
-
-
-def _hot_storage_get(self, key: bytes) -> Optional[Atom]:
-    """Retrieve an atom from in-memory cache while tracking hit statistics."""
-    atom = self.hot_storage.get(key)
-    if atom is not None:
-        self.hot_storage_hits[key] = self.hot_storage_hits.get(key, 0) + 1
-        self.logger.debug("Hot storage hit for %s", key.hex())
-    else:
-        self.logger.debug("Hot storage miss for %s", key.hex())
-    return atom
-
-
-def _network_get(self, key: bytes) -> Optional[Atom]:
-    """Attempt to fetch an atom from network peers when local storage misses."""
-    if not getattr(self, "is_connected", False):
-        self.logger.debug("Network fetch skipped for %s; node not connected", key.hex())
-        return None
-    self.logger.debug("Attempting network fetch for %s", key.hex())
-    try:
-        from ...communication.handlers.object_request import (
-            ObjectRequest,
-            ObjectRequestType,
+from __future__ import annotations
+
+from pathlib import Path
+from time import sleep
+from typing import List, Optional, Union
+
+from ..models.atom import Atom, ZERO32
+from ..providers import provider_payload_for_id
+
+
+def _hot_storage_get(self, key: bytes) -> Optional[Atom]:
+    """Retrieve an atom from in-memory cache while tracking hit statistics."""
+    atom = self.hot_storage.get(key)
+    if atom is not None:
+        self.hot_storage_hits[key] = self.hot_storage_hits.get(key, 0) + 1
+        self.logger.debug("Hot storage hit for %s", key.hex())
+    else:
+        self.logger.debug("Hot storage miss for %s", key.hex())
+    return atom
+
+
+def _network_get(self, atom_id: bytes, payload_type: int) -> Optional[Union[Atom, List[Atom]]]:
+    """Attempt to fetch an atom from network peers when local storage misses."""
+    from ...communication.handlers.object_response import (
+        OBJECT_FOUND_ATOM_PAYLOAD,
+        OBJECT_FOUND_LIST_PAYLOAD,
+    )
+
+    def _wait_for_atom(atom_id: bytes, interval: float, retries: int) -> Optional[Atom]:
+        if interval <= 0 or retries <= 0:
+            return self.get_atom_from_local_storage(atom_id=atom_id)
+        for _ in range(retries):
+            atom = self.get_atom_from_local_storage(atom_id=atom_id)
+            if atom is not None:
+                return atom
+            sleep(interval)
+        return self.get_atom_from_local_storage(atom_id=atom_id)
+
+    def _wait_for_list(root_hash: bytes, interval: float, retries: int) -> Optional[List[Atom]]:
+        if interval <= 0 or retries <= 0:
+            return self.get_atom_list_from_local_storage(root_hash=root_hash)
+        for _ in range(retries):
+            atoms = self.get_atom_list_from_local_storage(root_hash=root_hash)
+            if atoms is not None:
+                return atoms
+            sleep(interval)
+        return self.get_atom_list_from_local_storage(root_hash=root_hash)
+
+    def _wait_for_payload() -> Optional[Union[Atom, List[Atom]]]:
+        wait_interval = self.config["atom_fetch_interval"]
+        wait_retries = self.config["atom_fetch_retries"]
+        if payload_type == OBJECT_FOUND_ATOM_PAYLOAD:
+            return _wait_for_atom(atom_id, wait_interval, wait_retries)
+        if payload_type == OBJECT_FOUND_LIST_PAYLOAD:
+            return _wait_for_list(atom_id, wait_interval, wait_retries)
+        self.logger.warning(
+            "Unknown payload type %s for %s",
+            payload_type,
+            atom_id.hex(),
         )
-        from ...communication.models.message import Message, MessageTopic
-        from ...communication.outgoing_queue import enqueue_outgoing
-    except Exception as exc:
-        self.logger.warning(
-            "Communication module unavailable; cannot fetch %s: %s",
-            key.hex(),
-            exc,
-        )
-        return None
-
-    try:
-        closest_peer = self.peer_route.closest_peer_for_hash(key)
-    except Exception as exc:
-        self.logger.warning("Peer lookup failed for %s: %s", key.hex(), exc)
-        return None
-
-    if closest_peer is None or closest_peer.address is None:
-        self.logger.debug("No peer available to fetch %s", key.hex())
-        return None
-
-    obj_req = ObjectRequest(
-        type=ObjectRequestType.OBJECT_GET,
-        data=b"",
-        atom_id=key,
-    )
-    try:
-        message = Message(
-            topic=MessageTopic.OBJECT_REQUEST,
-            content=obj_req.to_bytes(),
-            sender=self.relay_public_key,
-        )
-    except Exception as exc:
-        self.logger.warning("Failed to build object request for %s: %s", key.hex(), exc)
-        return None
-
-    # encrypt the outbound request for the target peer
-    message.encrypt(closest_peer.shared_key_bytes)
-
-    try:
-        self.add_atom_req(key)
-    except Exception as exc:
-        self.logger.warning("Failed to track object request for %s: %s", key.hex(), exc)
-
-    try:
-        queued = enqueue_outgoing(
-            self,
-            closest_peer.address,
-            message=message,
-            difficulty=closest_peer.difficulty,
+        return None
+
+    if payload_type == OBJECT_FOUND_ATOM_PAYLOAD:
+        local_atom = self.get_atom_from_local_storage(atom_id=atom_id)
+        if local_atom is not None:
+            return local_atom
+    elif payload_type == OBJECT_FOUND_LIST_PAYLOAD:
+        local_atoms = self.get_atom_list_from_local_storage(root_hash=atom_id)
+        if local_atoms is not None:
+            return local_atoms
+    else:
+        self.logger.warning(
+            "Unknown payload type %s for %s",
+            payload_type,
+            atom_id.hex(),
         )
-        if queued:
-            self.logger.debug(
-                "Queued OBJECT_GET for %s to peer %s",
-                key.hex(),
-                closest_peer.address,
-            )
-        else:
-            self.logger.debug(
-                "Dropped OBJECT_GET for %s to peer %s",
-                key.hex(),
-                closest_peer.address,
-            )
-    except Exception as exc:
-        self.logger.warning(
-            "Failed to queue OBJECT_GET for %s to %s: %s",
-            key.hex(),
-            closest_peer.address,
-            exc,
-        )
-    return None
-
-
-def storage_get(self, key: bytes) -> Optional[Atom]:
-    """Retrieve an Atom by checking local storage first, then the network."""
-    self.logger.debug("Fetching atom %s", key.hex())
-    atom = self._hot_storage_get(key)
-    if atom is not None:
-        self.logger.debug("Returning atom %s from hot storage", key.hex())
-        return atom
-    atom = self._cold_storage_get(key)
-    if atom is not None:
-        self.logger.debug("Returning atom %s from cold storage", key.hex())
-        return atom
-    
-    if not self.is_connected:
-        return None
-    
-    provider_id = self.storage_index.get(key)
-    if provider_id is not None:
-        provider_payload = provider_payload_for_id(self, provider_id)
-        if provider_payload is not None:
-            try:
-                from ...communication.handlers.object_response import decode_object_provider
+
+    if not getattr(self, "is_connected", False):
+        self.logger.debug("Network fetch skipped for %s; node not connected", atom_id.hex())
+        return None
+    self.logger.debug("Attempting network fetch for %s", atom_id.hex())
+    
+    provider_id = self.storage_index.get(atom_id)
+    if provider_id is not None:
+        provider_payload = provider_payload_for_id(self, provider_id)
+        if provider_payload is not None:
+            try:
+                from ...communication.handlers.object_response import decode_object_provider
                 from ...communication.handlers.object_request import (
                     ObjectRequest,
                     ObjectRequestType,
@@ -129,23 +93,24 @@ def storage_get(self, key: bytes) -> Optional[Atom]:
                 from ...communication.models.message import Message, MessageTopic
                 from ...communication.outgoing_queue import enqueue_outgoing
                 from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PublicKey
-
-                provider_key, provider_address, provider_port = decode_object_provider(provider_payload)
-                provider_public_key = X25519PublicKey.from_public_bytes(provider_key)
-                shared_key_bytes = self.relay_secret_key.exchange(provider_public_key)
-
-                obj_req = ObjectRequest(
-                    type=ObjectRequestType.OBJECT_GET,
-                    data=b"",
-                    atom_id=key,
-                )
-                message = Message(
-                    topic=MessageTopic.OBJECT_REQUEST,
-                    content=obj_req.to_bytes(),
-                    sender=self.relay_public_key,
-                )
+
+                provider_key, provider_address, provider_port = decode_object_provider(provider_payload)
+                provider_public_key = X25519PublicKey.from_public_bytes(provider_key)
+                shared_key_bytes = self.relay_secret_key.exchange(provider_public_key)
+
+                obj_req = ObjectRequest(
+                    type=ObjectRequestType.OBJECT_GET,
+                    data=b"",
+                    atom_id=atom_id,
+                    payload_type=payload_type,
+                )
+                message = Message(
+                    topic=MessageTopic.OBJECT_REQUEST,
+                    content=obj_req.to_bytes(),
+                    sender=self.relay_public_key,
+                )
                 message.encrypt(shared_key_bytes)
-                self.add_atom_req(key)
+                self.add_atom_req(atom_id, payload_type)
                 queued = enqueue_outgoing(
                     self,
                     (provider_address, provider_port),
@@ -155,60 +120,166 @@ def storage_get(self, key: bytes) -> Optional[Atom]:
                 if queued:
                     self.logger.debug(
                         "Requested atom %s from indexed provider %s:%s",
-                        key.hex(),
+                        atom_id.hex(),
                         provider_address,
                         provider_port,
                     )
                 else:
                     self.logger.debug(
                         "Dropped request for atom %s to indexed provider %s:%s",
-                        key.hex(),
+                        atom_id.hex(),
                         provider_address,
                         provider_port,
                     )
-            except Exception as exc:
-                self.logger.warning("Failed indexed fetch for %s: %s", key.hex(), exc)
-            return None
-        self.logger.warning("Unknown provider id %s for %s", provider_id, key.hex())
-
-    self.logger.debug("Falling back to network fetch for %s", key.hex())
-    return self._network_get(key)
-
-
-def local_get(self, key: bytes) -> Optional[Atom]:
-    """Retrieve an Atom by checking only local hot and cold storage."""
-    self.logger.debug("Fetching atom %s (local only)", key.hex())
-    atom = self._hot_storage_get(key)
-    if atom is not None:
-        self.logger.debug("Returning atom %s from hot storage", key.hex())
-        return atom
-    atom = self._cold_storage_get(key)
-    if atom is not None:
-        self.logger.debug("Returning atom %s from cold storage", key.hex())
-        return atom
-    self.logger.debug("Local storage miss for %s", key.hex())
-    return None
-
-
-def _cold_storage_get(self, key: bytes) -> Optional[Atom]:
-    """Read an atom from the cold storage directory if configured."""
-    if not self.config["cold_storage_path"]:
-        self.logger.debug("Cold storage disabled; cannot fetch %s", key.hex())
-        return None
-    filename = f"{key.hex().upper()}.bin"
-    file_path = Path(self.config["cold_storage_path"]) / filename
-    try:
-        data = file_path.read_bytes()
-    except FileNotFoundError:
-        self.logger.debug("Cold storage miss for %s", key.hex())
-        return None
-    except OSError as exc:
-        self.logger.warning("Error reading cold storage file %s: %s", file_path, exc)
-        return None
-    try:
-        atom = Atom.from_bytes(data)
-        self.logger.debug("Loaded atom %s from cold storage", key.hex())
-        return atom
-    except ValueError as exc:
-        self.logger.warning("Cold storage data corrupted for %s: %s", file_path, exc)
-        return None
+            except Exception as exc:
+                self.logger.warning("Failed indexed fetch for %s: %s", atom_id.hex(), exc)
+            return _wait_for_payload()
+        self.logger.warning("Unknown provider id %s for %s", provider_id, atom_id.hex())
+
+    self.logger.debug("Falling back to network fetch for %s", atom_id.hex())
+
+    from ...communication.handlers.object_request import (
+        ObjectRequest,
+        ObjectRequestType,
+    )
+    from ...communication.models.message import Message, MessageTopic
+    from ...communication.outgoing_queue import enqueue_outgoing
+
+    try:
+        closest_peer = self.peer_route.closest_peer_for_hash(atom_id)
+    except Exception as exc:
+        self.logger.warning("Peer lookup failed for %s: %s", atom_id.hex(), exc)
+        return _wait_for_payload()
+
+    if closest_peer is None or closest_peer.address is None:
+        self.logger.debug("No peer available to fetch %s", atom_id.hex())
+        return None
+
+    obj_req = ObjectRequest(
+        type=ObjectRequestType.OBJECT_GET,
+        data=b"",
+        atom_id=atom_id,
+        payload_type=payload_type,
+    )
+    try:
+        message = Message(
+            topic=MessageTopic.OBJECT_REQUEST,
+            content=obj_req.to_bytes(),
+            sender=self.relay_public_key,
+        )
+    except Exception as exc:
+        self.logger.warning("Failed to build object request for %s: %s", atom_id.hex(), exc)
+        return None
+
+    # encrypt the outbound request for the target peer
+    message.encrypt(closest_peer.shared_key_bytes)
+
+    try:
+        self.add_atom_req(atom_id, payload_type)
+    except Exception as exc:
+        self.logger.warning("Failed to track object request for %s: %s", atom_id.hex(), exc)
+
+    try:
+        queued = enqueue_outgoing(
+            self,
+            closest_peer.address,
+            message=message,
+            difficulty=closest_peer.difficulty,
+        )
+        if queued:
+            self.logger.debug(
+                "Queued OBJECT_GET for %s to peer %s",
+                atom_id.hex(),
+                closest_peer.address,
+            )
+        else:
+            self.logger.debug(
+                "Dropped OBJECT_GET for %s to peer %s",
+                atom_id.hex(),
+                closest_peer.address,
+            )
+    except Exception as exc:
+        self.logger.warning(
+            "Failed to queue OBJECT_GET for %s to %s: %s",
+            atom_id.hex(),
+            closest_peer.address,
+            exc,
+        )
+    return _wait_for_payload()
+
+def get_atom_from_local_storage(self, atom_id: bytes) -> Optional[Atom]:
+    """Retrieve an Atom by checking only local hot and cold storage."""
+    self.logger.debug("Fetching atom %s (local only)", atom_id.hex())
+    atom = self._hot_storage_get(atom_id)
+    if atom is not None:
+        self.logger.debug("Returning atom %s from hot storage", atom_id.hex())
+        return atom
+    atom = self._cold_storage_get(atom_id)
+    if atom is not None:
+        self.logger.debug("Returning atom %s from cold storage", atom_id.hex())
+        return atom
+    self.logger.debug("Local storage miss for %s", atom_id.hex())
+    return None
+
+
+def get_atom(self, atom_id: bytes) -> Optional[Atom]:
+    """Retrieve an atom locally first, then request it from the network."""
+    atom = self.get_atom_from_local_storage(atom_id=atom_id)
+    if atom is not None:
+        return atom
+    from ...communication.handlers.object_response import OBJECT_FOUND_ATOM_PAYLOAD
+
+    result = self._network_get(atom_id, OBJECT_FOUND_ATOM_PAYLOAD)
+    if isinstance(result, Atom):
+        return result
+    return None
+
+
+def get_atom_list_from_local_storage(self, root_hash: bytes) -> Optional[List[Atom]]:
+    """Follow a local-only atom list chain, returning atoms or None on gaps."""
+    next_id = root_hash
+    atoms: List[Atom] = []
+    while next_id != ZERO32:
+        atom = self.get_atom_from_local_storage(atom_id=next_id)
+        if atom is None:
+            return None
+        atoms.append(atom)
+        next_id = atom.next_id
+    return atoms
+
+
+def get_atom_list(self, root_hash: bytes) -> Optional[List[Atom]]:
+    """Retrieve an atom list locally first, then request it from the network."""
+    atoms = self.get_atom_list_from_local_storage(root_hash=root_hash)
+    if atoms is not None:
+        return atoms
+    from ...communication.handlers.object_response import OBJECT_FOUND_LIST_PAYLOAD
+
+    result = self._network_get(root_hash, OBJECT_FOUND_LIST_PAYLOAD)
+    if isinstance(result, list):
+        return result
+    return None
+
+
+def _cold_storage_get(self, key: bytes) -> Optional[Atom]:
+    """Read an atom from the cold storage directory if configured."""
+    if not self.config["cold_storage_path"]:
+        self.logger.debug("Cold storage disabled; cannot fetch %s", key.hex())
+        return None
+    filename = f"{key.hex().upper()}.bin"
+    file_path = Path(self.config["cold_storage_path"]) / filename
+    try:
+        data = file_path.read_bytes()
+    except FileNotFoundError:
+        self.logger.debug("Cold storage miss for %s", key.hex())
+        return None
+    except OSError as exc:
+        self.logger.warning("Error reading cold storage file %s: %s", file_path, exc)
+        return None
+    try:
+        atom = Atom.from_bytes(data)
+        self.logger.debug("Loaded atom %s from cold storage", key.hex())
+        return atom
+    except ValueError as exc:
+        self.logger.warning("Cold storage data corrupted for %s: %s", file_path, exc)
+        return None

astreum/storage/models/atom.py

@@ -91,17 +91,3 @@ def bytes_list_to_atoms(values: List[bytes]) -> Tuple[bytes, List[Atom]]:
 
     atoms.reverse()
     return (next_hash if values else ZERO32), atoms
-
-
-def get_atom_list_from_storage(self, root_hash: bytes) -> Optional[List["Atom"]]:
-    """Follow the list chain starting at root_hash, returning atoms or None on gaps."""
-    next_id: bytes = root_hash
-    atom_list: List["Atom"] = []
-    while next_id != ZERO32:
-        elem = self.storage_get(key=next_id)
-        if elem:
-            atom_list.append(elem)
-            next_id = elem.next_id
-        else:
-            return None
-    return atom_list

astreum/storage/models/trie.py

@@ -99,7 +99,7 @@ class TrieNode:
         if head_hash == ZERO32:
             raise ValueError("empty atom chain for Patricia node")
 
-        atom_chain = node.get_atom_list_from_storage(head_hash)
+        atom_chain = node.get_atom_list(head_hash)
         if atom_chain is None or len(atom_chain) != 5:
             raise ValueError("malformed Patricia atom chain")
 
@@ -177,7 +177,7 @@ class Trie:
         if cached is not None:
             return cached
 
-        if storage_node.storage_get(h) is None:
+        if storage_node.get_atom(atom_id=h) is None:
             return None
 
         pat_node = TrieNode.from_atoms(storage_node, h)

astreum/storage/requests.py

@@ -1,16 +1,16 @@
 from __future__ import annotations
 
 from threading import RLock
-from typing import TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from .. import Node
 
 
-def add_atom_req(node: "Node", atom_id: bytes) -> None:
-    """Mark an atom request as pending."""
+def add_atom_req(node: "Node", atom_id: bytes, payload_type: Optional[int] = None) -> None:
+    """Mark an atom request as pending with an optional payload type."""
     with node.atom_requests_lock:
-        node.atom_requests.add(atom_id)
+        node.atom_requests[atom_id] = payload_type
 
 
 def has_atom_req(node: "Node", atom_id: bytes) -> bool:
@@ -19,10 +19,13 @@ def has_atom_req(node: "Node", atom_id: bytes) -> bool:
         return atom_id in node.atom_requests
 
 
-def pop_atom_req(node: "Node", atom_id: bytes) -> bool:
-    """Remove the pending request if present. Returns True when removed."""
+def pop_atom_req(node: "Node", atom_id: bytes) -> Optional[int]:
+    """Remove the pending request if present and return its payload type."""
     with node.atom_requests_lock:
-        if atom_id in node.atom_requests:
-            node.atom_requests.remove(atom_id)
-            return True
-        return False
+        return node.atom_requests.pop(atom_id, None)
+
+
+def get_atom_req_payload(node: "Node", atom_id: bytes) -> Optional[int]:
+    """Return the payload type for a pending request without removing it."""
+    with node.atom_requests_lock:
+        return node.atom_requests.get(atom_id)

astreum/storage/setup.py

@@ -11,13 +11,17 @@ def storage_setup(node: Any, config: dict) -> None:
     node.hot_storage = {}
     node.hot_storage_hits = {}
     node.storage_index = {}
-    node.storage_providers = []
-    node.hot_storage_size = 0
-    node.cold_storage_size = 0
-
-    node.logger.info(
-        "Storage ready (hot_limit=%s bytes, cold_limit=%s bytes, cold_path=%s)",
-        config["hot_storage_limit"],
-        config["cold_storage_limit"],
-        config["cold_storage_path"] or "disabled",
-    )
+    node.storage_providers = []
+    node.hot_storage_size = 0
+    node.cold_storage_size = 0
+    node.atom_fetch_interval = config["atom_fetch_interval"]
+    node.atom_fetch_retries = config["atom_fetch_retries"]
+
+    node.logger.info(
+        "Storage ready (hot_limit=%s bytes, cold_limit=%s bytes, cold_path=%s, atom_fetch_interval=%s, atom_fetch_retries=%s)",
+        config["hot_storage_limit"],
+        config["cold_storage_limit"],
+        config["cold_storage_path"] or "disabled",
+        config["atom_fetch_interval"],
+        config["atom_fetch_retries"],
+    )

astreum/utils/config.py

@@ -11,6 +11,8 @@ DEFAULT_PEER_TIMEOUT_SECONDS = 15 * 60  # 15 minutes
 DEFAULT_PEER_TIMEOUT_INTERVAL_SECONDS = 10  # 10 seconds
 DEFAULT_BOOTSTRAP_RETRY_INTERVAL_SECONDS = 30  # 30 seconds
 DEFAULT_STORAGE_INDEX_INTERVAL_SECONDS = 600  # 10 minutes
+DEFAULT_ATOM_FETCH_INTERVAL_SECONDS = 0.25
+DEFAULT_ATOM_FETCH_RETRIES = 8
 DEFAULT_INCOMING_QUEUE_SIZE_LIMIT_BYTES = 64 * 1024 * 1024  # 64 MiB
 DEFAULT_INCOMING_QUEUE_TIMEOUT_SECONDS = 1.0
 DEFAULT_OUTGOING_QUEUE_SIZE_LIMIT_BYTES = 64 * 1024 * 1024  # 64 MiB
@@ -189,6 +191,32 @@ def config_setup(config: Dict = {}):
         raise ValueError("storage_index_interval must be a positive integer")
     config["storage_index_interval"] = storage_index_interval
 
+    atom_fetch_interval_raw = config.get(
+        "atom_fetch_interval", DEFAULT_ATOM_FETCH_INTERVAL_SECONDS
+    )
+    try:
+        atom_fetch_interval = float(atom_fetch_interval_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"atom_fetch_interval must be a number: {atom_fetch_interval_raw!r}"
+        ) from exc
+    if atom_fetch_interval < 0:
+        raise ValueError("atom_fetch_interval must be a non-negative number")
+    config["atom_fetch_interval"] = atom_fetch_interval
+
+    atom_fetch_retries_raw = config.get(
+        "atom_fetch_retries", DEFAULT_ATOM_FETCH_RETRIES
+    )
+    try:
+        atom_fetch_retries = int(atom_fetch_retries_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"atom_fetch_retries must be an integer: {atom_fetch_retries_raw!r}"
+        ) from exc
+    if atom_fetch_retries < 0:
+        raise ValueError("atom_fetch_retries must be a non-negative integer")
+    config["atom_fetch_retries"] = atom_fetch_retries
+
     outgoing_queue_limit_raw = config.get(
         "outgoing_queue_size_limit", DEFAULT_OUTGOING_QUEUE_SIZE_LIMIT_BYTES
     )

astreum/validation/models/account.py

@@ -35,7 +35,7 @@ class Account:
     @classmethod
     def from_atom(cls, node: Any, root_id: bytes) -> "Account":
 
-        account_atoms = node.get_atom_list_from_storage(root_hash=root_id)
+        account_atoms = node.get_atom_list(root_id)
 
         if account_atoms is None or len(account_atoms) != 5:
             raise ValueError("malformed account atom list")

astreum/validation/models/block.py

@@ -204,7 +204,7 @@ class Block:
     @classmethod
     def from_atom(cls, node: Any, block_id: bytes) -> "Block":
 
-        block_header = node.get_atom_list_from_storage(block_id)
+        block_header = node.get_atom_list(block_id)
         if block_header is None or len(block_header) != 4:
             raise ValueError("malformed block atom chain")
         type_atom, version_atom, sig_atom, body_list_atom = block_header
@@ -223,7 +223,7 @@ class Block:
         if body_list_atom.next_id != ZERO32:
             raise ValueError("malformed block (body list tail)")
 
-        detail_atoms = node.get_atom_list_from_storage(body_list_atom.data)
+        detail_atoms = node.get_atom_list(body_list_atom.data)
         if detail_atoms is None:
             raise ValueError("missing block body list nodes")
 
@@ -304,7 +304,7 @@ class Block:
         def _load_hash_list(head: bytes) -> Optional[List[bytes]]:
             if head == ZERO32:
                 return []
-            atoms = node.get_atom_list_from_storage(head)
+            atoms = node.get_atom_list(head)
             if atoms is None:
                 _log_warning("Block verify missing list atoms head=%s block=%s", _hex(head), _hex(self.atom_hash))
                 return None

astreum/validation/models/receipt.py

@@ -73,7 +73,7 @@ class Receipt:
 
     @classmethod
     def from_atom(cls, node: Any, receipt_id: bytes) -> Receipt:
-        atom_chain = node.get_atom_list_from_storage(receipt_id)
+        atom_chain = node.get_atom_list(receipt_id)
         if atom_chain is None or len(atom_chain) != 6:
             raise ValueError("malformed receipt atom chain")
 

astreum/validation/models/transaction.py

@@ -78,9 +78,9 @@ class Transaction:
         node: Any,
         transaction_id: bytes,
     ) -> Transaction:
-        storage_get = getattr(node, "storage_get", None)
-        if not callable(storage_get):
-            raise NotImplementedError("node does not expose a storage getter")
+        get_atom = getattr(node, "get_atom", None)
+        if not callable(get_atom):
+            raise NotImplementedError("node does not expose an atom getter")
 
         def _atom_kind(atom: Optional[Atom]) -> Optional[AtomKind]:
             kind_value = getattr(atom, "kind", None)
@@ -100,7 +100,7 @@ class Transaction:
         ) -> Atom:
             if not atom_id or atom_id == ZERO32:
                 raise ValueError(f"missing {context}")
-            atom = storage_get(atom_id)
+            atom = get_atom(atom_id)
             if atom is None:
                 raise ValueError(f"missing {context}")
             if expected_kind is not None:
@@ -127,7 +127,7 @@ class Transaction:
         if body_list_atom.next_id and body_list_atom.next_id != ZERO32:
             raise ValueError("malformed transaction (body list tail)")
 
-        detail_atoms = node.get_atom_list_from_storage(body_list_atom.data)
+        detail_atoms = node.get_atom_list(body_list_atom.data)
         if detail_atoms is None:
             raise ValueError("missing transaction body list nodes")
         if len(detail_atoms) != 6:
@@ -167,7 +167,7 @@ class Transaction:
         transaction_id: bytes,
     ) -> Optional[List[Atom]]:
         """Load the transaction atom chain from storage, returning the atoms or None."""
-        atoms = node.get_atom_list_from_storage(transaction_id)
+        atoms = node.get_atom_list(transaction_id)
         if atoms is None or len(atoms) < 4:
             return None
         type_atom = atoms[0]
@@ -178,7 +178,7 @@ class Transaction:
             return None
 
         body_list_atom = atoms[-1]
-        detail_atoms = node.get_atom_list_from_storage(body_list_atom.data)
+        detail_atoms = node.get_atom_list(body_list_atom.data)
         if detail_atoms is None:
             return None
         atoms.extend(detail_atoms)

{astreum-0.3.46.dist-info → astreum-0.3.48.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.3.46
+Version: 0.3.48
 Summary: Python library to interact with the Astreum blockchain and its virtual machine.
 Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
 Project-URL: Homepage, https://github.com/astreum/lib-py
@@ -33,6 +33,8 @@ When initializing an `astreum.Node`, pass a dictionary with any of the options b
 | `hot_storage_limit`         | int        | `1073741824`   | Maximum bytes kept in the hot cache before new atoms are skipped (1 GiB).                                                                                                         |
 | `cold_storage_limit`        | int        | `10737418240`  | Cold storage write threshold (10 GiB by default); set to `0` to skip the limit.                                                                                                   |
 | `cold_storage_path`         | string     | `None`         | Directory where persisted atoms live; Astreum creates it on startup and skips cold storage when unset.                                                                            |
+| `atom_fetch_interval`       | float      | `0.25`         | Poll interval (seconds) while waiting for missing atoms in `get_atom_list_from_storage`; `0` disables waiting.                                                                    |
+| `atom_fetch_retries`        | int        | `8`            | Number of poll attempts for missing atoms; max wait is roughly `interval * retries`, `0` disables waiting.                                                                        |
 | `logging_retention_days`    | int        | `90`           | Number of days to keep rotated log files (daily gzip).                                                                                                                           |
 | `chain_id`                  | int        | `0`            | Chain identifier used for validation (0 = test, 1 = main).                                                                                                                        |
 | `verbose`                   | bool       | `False`        | When **True**, also mirror JSON logs to stdout with a human-readable format.                                                                                                     |

{astreum-0.3.46.dist-info → astreum-0.3.48.dist-info}/RECORD

@@ -1,5 +1,5 @@
 astreum/__init__.py,sha256=ibzwB_Rq3mBCgzFBVx7ssHo7-MFxpiayn5cHMIZ3Gd4,351
-astreum/node.py,sha256=vqcS5gFXyy2l1WW6gdGSElo6h3QeyizfwJFpIGlZTAs,3104
+astreum/node.py,sha256=6K6XeAd6h9b9LYtXE9MeJ2med0eOMZbEU5I1_RoLt30,3174
 astreum/communication/__init__.py,sha256=E0-UtzXwyX6svdbL52fI3tnUY8ILmQJ6rqw3qX2YZi0,357
 astreum/communication/difficulty.py,sha256=XUw3xfppecVy_kBsaOXBCcxICz4d3qwKvu8L4rXNtyY,886
 astreum/communication/disconnect.py,sha256=m5rwR_TJxBk4KWAUtF-qcikssVj2u-6zse1TTYZquj4,1613
@@ -7,12 +7,12 @@ astreum/communication/incoming_queue.py,sha256=ccKmjSmkMt8Kvi7XS8Mr-iI-swJSWxjmL
 astreum/communication/message_pow.py,sha256=diDxc2aXjTxBQw5GWK5b-8Gybxa8AWSAcGmxF-tODnI,1103
 astreum/communication/node.py,sha256=GrcPRffWEv74W_gezYRnKVvGHBblmGEsn5Wvtw8pxC8,1700
 astreum/communication/outgoing_queue.py,sha256=CDA-A9vrkNmK-Gm4wS5htnhQhFaLaejW8dKNTsFDSNo,3818
-astreum/communication/setup.py,sha256=Rc6jjA9_HD68ED5NI29MFfEaN9ZcTBLs6ng__25PVRE,11915
+astreum/communication/setup.py,sha256=I1uZDxb5qyPVZ6XNi_tngtgF1CXGV4otxdNoUeRoKHs,11911
 astreum/communication/util.py,sha256=tDF6TNP-u7Q7K96JhnuWHEwfq4pASoYYcF5MakBicrg,1942
 astreum/communication/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/communication/handlers/handshake.py,sha256=XGeHslDhDn0zJS-DvvcxHwrPzmIhTMpunKOjGc8F2pg,3525
-astreum/communication/handlers/object_request.py,sha256=dpRZ-CAZ6ahEKErKXXE__k8OaPYIkWpDLVveI9SU3GQ,8376
-astreum/communication/handlers/object_response.py,sha256=p4ixSMsnsGfeHudIrvbuc8Nx5aa5orLFtgll0p9wtvc,4092
+astreum/communication/handlers/object_request.py,sha256=Wik_jEA9GiwuIaliUYThGvCLojiC2CbdGu0DfULAUa4,10791
+astreum/communication/handlers/object_response.py,sha256=nDHn81GAWMFe6iOhw4NyR0ZQxGxfr0ehZ7HcISWdtZA,7671
 astreum/communication/handlers/ping.py,sha256=bbB8JQfLR0oYgdharx0xarsn7YIaCdxlZb-AdmLw99g,1345
 astreum/communication/handlers/route_request.py,sha256=lZgapJH0RfLgp9c14H864BU3K3t03WHRGLcgpeu7SEg,2584
 astreum/communication/handlers/route_response.py,sha256=ktEft9XevZYVp6rZNCrbFIZ-HZTlYZLIUZcdRR4vkU8,1857
@@ -36,22 +36,22 @@ astreum/machine/parser.py,sha256=Z_Y0Sax0rPh8JcIo19-iNDQoc5GTdGQkmfFyLpCB4bw,175
 astreum/machine/tokenizer.py,sha256=6wPqR_D3h5BEvR78XKtD45ouy77RZBbz4Yh4jHSmN4o,2394
 astreum/machine/evaluations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/machine/evaluations/high_evaluation.py,sha256=cqYudR9WAdVz9dURDyuQhZsuhWbmjbdw9x3UxDEYpPI,9971
-astreum/machine/evaluations/low_evaluation.py,sha256=_93r6DKkCwnaOKmVGSp8JBlUPZpKrA1GECqVnwLb9es,10370
+astreum/machine/evaluations/low_evaluation.py,sha256=t3xfZCKrvRMBTmc4PUp8tywr2uIOScgQnWaR6eMG3wE,10370
 astreum/machine/evaluations/script_evaluation.py,sha256=eWouYUwTYzaqUyXqEe-lAJFIluW0gMeCDdXqle88oWw,864
 astreum/machine/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/machine/models/environment.py,sha256=WjP6GRX_8e0-BAhzRLvQ6fYtKQEVR0LZi7DZNZS0TSE,1019
-astreum/machine/models/expression.py,sha256=yYr9ktk-NWPL4EXwHz7ePvr9eNvfSBQe3yzRUz06yas,7675
+astreum/machine/models/expression.py,sha256=KjN6TxikqpRK_vwx5f4N4RNZCqoKYBdR6rGBBJp2-Bk,7637
 astreum/machine/models/meter.py,sha256=5q2PFW7_jmgKVM1-vwE4RRjMfPEthUA4iu1CwR-Axws,505
 astreum/storage/__init__.py,sha256=Flk6WXT2xGFHWWJiZHK3O5OpjoLTOFMqqIiJTtD58kY,111
 astreum/storage/providers.py,sha256=-nOEfoecraTBhPA3ERgz8UwEOJ9DKD-wnHtaSoR6WjU,740
-astreum/storage/requests.py,sha256=q_rxG_k7POth93HmsUTCLSyNw-4EdFqqNExhIwm7Q0g,818
-astreum/storage/setup.py,sha256=lG6_-zDx_UvqUcEh8o287Zp9szovYHVwBK4x_Np1BXQ,659
-astreum/storage/actions/get.py,sha256=xuM5Q2oqEIKu0myC0-ayCBdSAD1ouc9LwdCiIvs5xv4,8099
+astreum/storage/requests.py,sha256=5D9F2uWdwqhvfPM3TWrtCMopseFyPV6WKNKbxT5uLlY,1067
+astreum/storage/setup.py,sha256=t6EtAan9N7wrTEcU927z-sM5L5mboMnKk218fwfTRy8,893
+astreum/storage/actions/get.py,sha256=2yA00Odjefzf2v5Qpwl6H0LSG8sb7KLmfbxkA9Fnivo,11088
 astreum/storage/actions/set.py,sha256=TGD1JS9zRLO7AVDTWwP2st7DWabfB51trVAghUrja4A,6386
-astreum/storage/models/atom.py,sha256=FY_bgtoju59Yo7TL1DTFTr9_pRMNBuH6-u59D6bz2fc,3163
-astreum/storage/models/trie.py,sha256=Bn3ssPGI7YGS4iUH5ESvpG1NE6Ljx2Xo7wkEpQhjKUY,17587
+astreum/storage/models/atom.py,sha256=fAIXW7bMzsyioZL4UOyu_Rpjvw2amWNQNbyTE3m56sk,2707
+astreum/storage/models/trie.py,sha256=kZelNuMTGKnG21Rt4Fo72bp4d1P_5W8zAH7hWk4zN1k,17577
 astreum/utils/bytes.py,sha256=9QTWC2JCdwWLB5R2mPtmjPro0IUzE58DL3uEul4AheE,846
-astreum/utils/config.py,sha256=tcIBLPvwhxwca0SqbMe4fmXIG38OEPrBC4-Ovg2C9ts,10158
+astreum/utils/config.py,sha256=b2ei_LtPxnQs__dJvBnNfjQiQjnLOJM0-EGrO_1PEYw,11256
 astreum/utils/integer.py,sha256=iQt-klWOYVghu_NOT341MmHbOle4FDT3by4PNKNXscg,736
 astreum/utils/logging.py,sha256=YbFtt_h6_3mpnOomffGW0DnI1Y1cwl_vb6Zsu1_W_Xg,6692
 astreum/validation/__init__.py,sha256=cRlrwE3MqtBrda9ZxLmtCEOY3P5oJnXpjE4YDNHCnpI,322
@@ -60,20 +60,20 @@ astreum/validation/genesis.py,sha256=7JSZEa5-AdaWn2sCO0G2bh8-4OG-mio585U1lJ9ZjWk
 astreum/validation/node.py,sha256=AuY186eqlmXMIbFnQrDO8tn6gmuaj-sI6l1htIwoxnA,6935
 astreum/validation/validator.py,sha256=MmxkOMWQeUg4peIt5FHz1A1Fv-RvbGNCa49sDj8b7QM,3873
 astreum/validation/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-astreum/validation/models/account.py,sha256=3QcT59QUZynysLSbiywidFYVzYJ3LR6qia7JwXOwn4I,2690
+astreum/validation/models/account.py,sha256=WRRaNHqQuoc0hBrDmPF2gZvQCl5557QX1FOYDOmpkqE,2666
 astreum/validation/models/accounts.py,sha256=iUMs6LvmMea-gxd6-ujkFjqhWmuW1cl9XTWGXQkpLys,2388
-astreum/validation/models/block.py,sha256=KeQLAWOmrcAuqs9vxmGilTC-XGhUrh27VOErZ0G-7Oc,21120
+astreum/validation/models/block.py,sha256=SfjKO3mez67vHHxOdpsJn1WihKlBou0RsBzl7KiOnqI,21081
 astreum/validation/models/fork.py,sha256=R9yBKThlvAzqGf4nAe5yVyFDX7tIX5TfnH_KDEZ7Azg,20630
-astreum/validation/models/receipt.py,sha256=84foS48tOWpHYqzsR4OM34ZPzxpr_DiKShBPz684SRs,3896
-astreum/validation/models/transaction.py,sha256=HIcqWm9iFHz-w9aCYprbP0rx8skcmw36G_8x_gkuuL4,8878
+astreum/validation/models/receipt.py,sha256=IRDrAEApdMIuBnRUuvueZ0X45Fq2iEvl40sbW3u1mso,3883
+astreum/validation/models/transaction.py,sha256=TKylwk3AqWW6pcXFAowR7A4BT43nQxPRQ-NseE3ELtQ,8825
 astreum/validation/workers/__init__.py,sha256=GH8G4j7ONbtcoqBiX1d1I16Ikiu3fjGM6pUSQXqDtiw,228
 astreum/validation/workers/validation.py,sha256=60L5KiX6e5-5KN4NLAF9jclfyRqDX_ju4qOTx92PnY4,15349
 astreum/verification/__init__.py,sha256=Ec7_CTXbHYtiw1KK3oJx0s96loSnVX0i863_FLHv_es,130
 astreum/verification/discover.py,sha256=ubMdNTE8gzDQ9B8NzycrHpKVHfnqaBQgNkEHywoVjws,2449
 astreum/verification/node.py,sha256=xYhVRhRW_wKIdFiWzrC5A-xeHy1P6cRJwG5MWRA8KTM,2005
 astreum/verification/worker.py,sha256=BM8feAJ0IVKyHYzdC3YRZwEItOxUhQdmtu2RtksIMvI,6460
-astreum-0.3.46.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.3.46.dist-info/METADATA,sha256=HH9jPPWkYUzF74hWJMFtDZlSPW4Sc9yzpW4p6iAtQ8w,10503
-astreum-0.3.46.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.3.46.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.3.46.dist-info/RECORD,,
+astreum-0.3.48.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.3.48.dist-info/METADATA,sha256=pR6MmP4QXroddMYtP9BHnOaVA1C_glrH5fY42waippM,10987
+astreum-0.3.48.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.3.48.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.3.48.dist-info/RECORD,,