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

astreum/machine/evaluations/low_evaluation.py

@@ -64,21 +64,21 @@ def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
             pc += 1
 
             # ---------- ADD ----------
-            if tok == b"add":
-                if len(stack) < 2:
-                    return error_expr("low_eval", "underflow")
-                b_b = stack.pop()
-                a_b = stack.pop()
-                a_i = tc_to_int(a_b)
-                b_i = tc_to_int(b_b)
-                res_i = a_i + b_i
-                width = max(len(a_b), len(b_b), min_tc_width(res_i))
-                res_b = int_to_tc(res_i, width)
-                # charge for both operands' byte widths
-                if not meter.charge_bytes(len(a_b) + len(b_b)):
-                    return error_expr("low_eval", "meter limit")
-                stack.append(res_b)
-                continue
+            # if tok == b"add":
+            #     if len(stack) < 2:
+            #         return error_expr("low_eval", "underflow")
+            #     b_b = stack.pop()
+            #     a_b = stack.pop()
+            #     a_i = tc_to_int(a_b)
+            #     b_i = tc_to_int(b_b)
+            #     res_i = a_i + b_i
+            #     width = max(len(a_b), len(b_b), min_tc_width(res_i))
+            #     res_b = int_to_tc(res_i, width)
+            #     # charge for both operands' byte widths
+            #     if not meter.charge_bytes(len(a_b) + len(b_b)):
+            #         return error_expr("low_eval", "meter limit")
+            #     stack.append(res_b)
+            #     continue
 
             # ---------- NAND ----------
             
@@ -153,7 +153,7 @@ def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
                 if not meter.charge_bytes(len(slice_bytes)):
                     return error_expr("low_eval", "meter limit")
 
-                new_atom = Atom(data=slice_bytes, kind=atom.kind)
+                new_atom = Atom(data=slice_bytes, kind=atom.kind)
                 new_id = new_atom.object_id()
                 try:
                     self._hot_storage_set(key=new_id, value=new_atom)
@@ -205,7 +205,7 @@ def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
                 if not meter.charge_bytes(len(joined)):
                     return error_expr("low_eval", "meter limit")
 
-                new_atom = Atom(data=joined, kind=AtomKind.BYTES)
+                new_atom = Atom(data=joined, kind=AtomKind.BYTES)
                 new_id = new_atom.object_id()
 
                 try:
@@ -236,7 +236,7 @@ def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
                 if not meter.charge_bytes(len(data_b)):
                     return error_expr("low_eval", "meter limit")
 
-                new_atom = Atom(data=data_b, kind=kind)
+                new_atom = Atom(data=data_b, kind=kind)
                 new_id = new_atom.object_id()
 
                 try:

astreum/node.py

@@ -7,6 +7,12 @@ import uuid
 from typing import Dict
 
 from astreum.communication.start import connect_to_network_and_verify
+from astreum.communication.models.peer import (
+    add_peer as peers_add_peer,
+    replace_peer as peers_replace_peer,
+    get_peer as peers_get_peer,
+    remove_peer as peers_remove_peer,
+)
 from astreum.consensus.start import process_blocks_and_transactions
 from astreum.machine import Expr, high_eval, low_eval, script_eval
 from astreum.machine.models.environment import Env, env_get, env_set
@@ -17,35 +23,41 @@ from astreum.storage.actions.get import (
     _cold_storage_get,
     _network_get,
     storage_get,
+    local_get,
 )
 from astreum.storage.actions.set import (
     _hot_storage_set,
     _cold_storage_set,
     _network_set,
 )
+from astreum.storage.requests import add_atom_req, has_atom_req, pop_atom_req
 from astreum.storage.setup import storage_setup
+from astreum.utils.config import config_setup
 from astreum.utils.logging import logging_setup
 
 
 class Node:
     def __init__(self, config: dict = {}):
-        self.config = config
-        self.logger = logging_setup(config)
+        self.config = config_setup(config=config)
+        
+        self.logger = logging_setup(self.config)
 
         self.logger.info("Starting Astreum Node")
 
         # Chain Configuration
-        chain_str = config.get("chain", "test")
-        self.chain = 1 if chain_str == "main" else 0
-        self.logger.info(f"Chain configured as: {chain_str} ({self.chain})")
+        self.logger.info(f"Chain configured as: {self.config["chain"]} ({self.config["chain_id"]})")
 
         # Storage Setup
-        storage_setup(self, config=config)
+        storage_setup(self, config=self.config)
 
         # Machine Setup
         self.environments: Dict[uuid.UUID, Env] = {}
         self.machine_environments_lock = threading.RLock()
-
+        self.is_connected = False
+        self.latest_block_hash = None
+        self.latest_block = None
+        self.nonce_time_ms = 0  # rolling measurement of last nonce search duration
+        
     connect = connect_to_network_and_verify
     validate = process_blocks_and_transactions
 
@@ -68,6 +80,16 @@ class Node:
     _network_set = _network_set
 
     storage_get = storage_get
+    local_get = local_get
 
     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
+    pop_atom_req = pop_atom_req
+
+    add_peer = peers_add_peer
+    replace_peer = peers_replace_peer
+    get_peer = peers_get_peer
+    remove_peer = peers_remove_peer

astreum/storage/actions/get.py

@@ -1,69 +1,183 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Optional
-
-from ..models.atom import Atom
-
-
-def _hot_storage_get(self, key: bytes) -> Optional[Atom]:
-    """Retrieve an atom from in-memory cache while tracking hit statistics."""
-    node_logger = self.logger
-    atom = self.hot_storage.get(key)
-    if atom is not None:
-        self.hot_storage_hits[key] = self.hot_storage_hits.get(key, 0) + 1
-        node_logger.debug("Hot storage hit for %s", key.hex())
-    else:
-        node_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."""
-    node_logger = self.logger
-    node_logger.debug("Attempting network fetch for %s", key.hex())
-    # locate storage provider
-    # query storage provider
-    node_logger.warning("Network fetch for %s is not implemented", key.hex())
-    return None
-
-
-def storage_get(self, key: bytes) -> Optional[Atom]:
-    """Retrieve an Atom by checking local storage first, then the network."""
-    node_logger = self.logger
-    node_logger.debug("Fetching atom %s", key.hex())
-    atom = self._hot_storage_get(key)
-    if atom is not None:
-        node_logger.debug("Returning atom %s from hot storage", key.hex())
-        return atom
-    atom = self._cold_storage_get(key)
-    if atom is not None:
-        node_logger.debug("Returning atom %s from cold storage", key.hex())
-        return atom
-    node_logger.debug("Falling back to network fetch for %s", key.hex())
-    return self._network_get(key)
-
-
-def _cold_storage_get(self, key: bytes) -> Optional[Atom]:
-    """Read an atom from the cold storage directory if configured."""
-    node_logger = self.logger
-    if not self.cold_storage_path:
-        node_logger.debug("Cold storage disabled; cannot fetch %s", key.hex())
-        return None
-    filename = f"{key.hex().upper()}.bin"
-    file_path = Path(self.cold_storage_path) / filename
-    try:
-        data = file_path.read_bytes()
-    except FileNotFoundError:
-        node_logger.debug("Cold storage miss for %s", key.hex())
-        return None
-    except OSError as exc:
-        node_logger.warning("Error reading cold storage file %s: %s", file_path, exc)
-        return None
-    try:
-        atom = Atom.from_bytes(data)
-        node_logger.debug("Loaded atom %s from cold storage", key.hex())
-        return atom
-    except ValueError as exc:
-        node_logger.warning("Cold storage data corrupted for %s: %s", file_path, exc)
-        return None
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+from ..models.atom import Atom
+
+
+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 ...communication.models.message import Message, MessageTopic
+    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:
+        self.outgoing_queue.put((message.to_bytes(), closest_peer.address))
+        self.logger.debug(
+            "Queued 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_payload = self.storage_index.get(key)
+    if provider_payload is not None:
+        try:
+            from ...communication.handlers.object_response import decode_object_provider
+            from ...communication.handlers.object_request import (
+                ObjectRequest,
+                ObjectRequestType,
+            )
+            from ...communication.models.message import Message, MessageTopic
+            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,
+            )
+            message.encrypt(shared_key_bytes)
+            self.add_atom_req(key)
+            self.outgoing_queue.put((message.to_bytes(), (provider_address, provider_port)))
+            self.logger.debug(
+                "Requested atom %s from indexed provider %s:%s",
+                key.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.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

astreum/storage/actions/set.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
+import socket
 from pathlib import Path
 
+from cryptography.hazmat.primitives import serialization
+
 from ..models.atom import Atom
 
 
@@ -9,11 +12,12 @@ def _hot_storage_set(self, key: bytes, value: Atom) -> bool:
     """Store atom in hot storage without exceeding the configured limit."""
     node_logger = self.logger
     projected = self.hot_storage_size + value.size
-    if projected > self.hot_storage_limit:
+    hot_limit = self.config["hot_storage_default_limit"]
+    if projected > hot_limit:
         node_logger.warning(
             "Hot storage limit reached (%s > %s); skipping atom %s",
             projected,
-            self.hot_storage_limit,
+            hot_limit,
             key.hex(),
         )
         return False
@@ -34,20 +38,21 @@ def _cold_storage_set(self, atom: Atom) -> None:
     node_logger = self.logger
     atom_id = atom.object_id()
     atom_hex = atom_id.hex()
-    if not self.cold_storage_path:
+    if not self.config["cold_storage_path"]:
         node_logger.debug("Cold storage disabled; skipping atom %s", atom_hex)
         return
     atom_bytes = atom.to_bytes()
     projected = self.cold_storage_size + len(atom_bytes)
-    if self.cold_storage_limit and projected > self.cold_storage_limit:
+    cold_limit = self.config["cold_storage_limit"]
+    if cold_limit and projected > cold_limit:
         node_logger.warning(
             "Cold storage limit reached (%s > %s); skipping atom %s",
             projected,
-            self.cold_storage_limit,
+            cold_limit,
             atom_hex,
         )
         return
-    directory = Path(self.cold_storage_path)
+    directory = Path(self.config["cold_storage_path"])
     if not directory.exists():
         node_logger.warning(
             "Cold storage path %s missing; skipping atom %s",
@@ -76,6 +81,10 @@ def _network_set(self, atom: Atom) -> None:
     atom_id = atom.object_id()
     atom_hex = atom_id.hex()
     try:
+        from ...communication.handlers.object_request import (
+            ObjectRequest,
+            ObjectRequestType,
+        )
         from ...communication.models.message import Message, MessageTopic
     except Exception as exc:
         node_logger.warning(
@@ -85,16 +94,6 @@ def _network_set(self, atom: Atom) -> None:
         )
         return
 
-    try:
-        closest_peer = self.peer_route.closest_peer_for_hash(atom_id)
-    except Exception as exc:
-        node_logger.warning("Peer lookup failed for atom %s: %s", atom_hex, exc)
-        return
-    if closest_peer is None or closest_peer.address is None:
-        node_logger.debug("No peer available to advertise atom %s", atom_hex)
-        return
-    target_addr = closest_peer.address
-
     try:
         provider_ip, provider_port = self.incoming_socket.getsockname()[:2]
     except Exception as exc:
@@ -105,15 +104,62 @@ def _network_set(self, atom: Atom) -> None:
         )
         return
 
-    provider_str = f"{provider_ip}:{int(provider_port)}"
     try:
-        provider_bytes = provider_str.encode("utf-8")
+        provider_ip_bytes = socket.inet_aton(provider_ip)
+        provider_port_bytes = int(provider_port).to_bytes(2, "big", signed=False)
+        provider_key_bytes = self.relay_public_key_bytes
     except Exception as exc:
         node_logger.warning("Unable to encode provider info for %s: %s", atom_hex, exc)
         return
 
-    payload = atom_id + provider_bytes
-    message = Message(topic=MessageTopic.STORAGE_REQUEST, content=payload)
+    provider_payload = provider_key_bytes + provider_ip_bytes + provider_port_bytes
+
+    try:
+        closest_peer = self.peer_route.closest_peer_for_hash(atom_id)
+    except Exception as exc:
+        node_logger.warning("Peer lookup failed for atom %s: %s", atom_hex, exc)
+        return
+
+    is_self_closest = False
+    if closest_peer is None or closest_peer.address is None:
+        is_self_closest = True
+    else:
+        try:
+            from ...communication.util import xor_distance
+        except Exception as exc:
+            node_logger.warning("Failed to import xor_distance for atom %s: %s", atom_hex, exc)
+            is_self_closest = True
+        else:
+            try:
+                self_distance = xor_distance(atom_id, self.relay_public_key_bytes)
+                peer_distance = xor_distance(atom_id, closest_peer.public_key_bytes)
+            except Exception as exc:
+                node_logger.warning("Failed computing distance for atom %s: %s", atom_hex, exc)
+                is_self_closest = True
+            else:
+                is_self_closest = self_distance <= peer_distance
+
+    if is_self_closest:
+        node_logger.debug("Self is closest; indexing provider for atom %s", atom_hex)
+        self.storage_index[atom_id] = provider_payload
+        return
+
+    target_addr = closest_peer.address
+
+    obj_req = ObjectRequest(
+        type=ObjectRequestType.OBJECT_PUT,
+        data=provider_payload,
+        atom_id=atom_id,
+    )
+    
+    message_body = obj_req.to_bytes()
+
+    message = Message(
+        topic=MessageTopic.OBJECT_REQUEST,
+        content=message_body,
+        sender=self.relay_public_key,
+    )
+    message.encrypt(closest_peer.shared_key_bytes)
     try:
         self.outgoing_queue.put((message.to_bytes(), target_addr))
         node_logger.debug(

astreum/storage/requests.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from threading import RLock
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .. import Node
+
+
+def add_atom_req(node: "Node", atom_id: bytes) -> None:
+    """Mark an atom request as pending."""
+    with node.atom_requests_lock:
+        node.atom_requests.add(atom_id)
+
+
+def has_atom_req(node: "Node", atom_id: bytes) -> bool:
+    """Return True if the atom request is currently tracked."""
+    with node.atom_requests_lock:
+        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."""
+    with node.atom_requests_lock:
+        if atom_id in node.atom_requests:
+            node.atom_requests.remove(atom_id)
+            return True
+        return False

astreum/storage/setup.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from pathlib import Path
 from typing import Any
 
 
@@ -13,32 +12,11 @@ def storage_setup(node: Any, config: dict) -> None:
     node.hot_storage_hits = {}
     node.storage_index = {}
     node.hot_storage_size = 0
-    hot_storage_default_limit = 1 << 30  # 1 GiB
-    hot_storage_limit_value = config.get("hot_storage_limit", hot_storage_default_limit)
-    try:
-        node.hot_storage_limit = int(hot_storage_limit_value)
-    except (TypeError, ValueError):
-        node.hot_storage_limit = hot_storage_default_limit
-
     node.cold_storage_size = 0
-    cold_storage_default_limit = 10 << 30  # 10 GiB
-    cold_storage_limit_value = config.get("cold_storage_limit", cold_storage_default_limit)
-    try:
-        node.cold_storage_limit = int(cold_storage_limit_value)
-    except (TypeError, ValueError):
-        node.cold_storage_limit = cold_storage_default_limit
-
-    cold_storage_path = config.get("cold_storage_path")
-    if cold_storage_path:
-        try:
-            Path(cold_storage_path).mkdir(parents=True, exist_ok=True)
-        except OSError:
-            cold_storage_path = None
-    node.cold_storage_path = cold_storage_path
 
     node.logger.info(
         "Storage ready (hot_limit=%s bytes, cold_limit=%s bytes, cold_path=%s)",
-        node.hot_storage_limit,
-        node.cold_storage_limit,
-        node.cold_storage_path or "disabled",
+        config["hot_storage_default_limit"],
+        config["cold_storage_limit"],
+        config["cold_storage_path"] or "disabled",
     )