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

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/_communication/peer.py

@@ -1,11 +1,23 @@
-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)
+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/_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/_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/_consensus/account.py

@@ -1,170 +1,95 @@
-from __future__ import annotations
-
+from __future__ import annotations
+
 from dataclasses import dataclass, field
-from typing import Any, Callable, List, Optional, Tuple
+from typing import Any, List, Optional, Tuple
 
 from .._storage.atom import Atom, ZERO32
-
-
-def _int_to_be_bytes(value: int) -> bytes:
-    value = int(value)
-    if value < 0:
-        raise ValueError("account integers must be non-negative")
-    if value == 0:
-        return b"\x00"
-    size = (value.bit_length() + 7) // 8
-    return value.to_bytes(size, "big")
-
-
-def _be_bytes_to_int(data: Optional[bytes]) -> int:
-    if not data:
-        return 0
-    return int.from_bytes(data, "big")
-
-
-def _make_list(child_ids: List[bytes]) -> Tuple[bytes, List[Atom]]:
-    next_hash = ZERO32
-    elements: 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()
-        elements.append(elem)
-    elements.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 = elements + [value_atom, type_atom]
-    return type_atom.object_id(), atoms
-
-
-def _resolve_storage_get(source: Any) -> Callable[[bytes], Optional[Atom]]:
-    if callable(source):
-        return source
-    getter = getattr(source, "_local_get", None)
-    if callable(getter):
-        return getter
-    raise TypeError("Account.from_atom needs a callable storage getter or node with '_local_get'")
-
-
-def _read_list_entries(
-    storage_get: Callable[[bytes], Optional[Atom]],
-    start: bytes,
-) -> List[bytes]:
-    entries: List[bytes] = []
-    current = start if start and start != ZERO32 else b""
-    while current:
-        elem = storage_get(current)
-        if elem is None:
-            break
-        entries.append(elem.data)
-        nxt = elem.next
-        current = nxt if nxt and nxt != ZERO32 else b""
-    return entries
+from .._storage.patricia import PatriciaTrie
+from ..utils.integer import bytes_to_int, int_to_bytes
 
 
 @dataclass
 class Account:
-    _balance: int
-    _data: bytes
-    _nonce: int
+    balance: int
+    code: bytes
+    counter: int
+    data_hash: bytes
+    data: PatriciaTrie
     hash: bytes = ZERO32
+    body_hash: bytes = ZERO32
     atoms: List[Atom] = field(default_factory=list)
 
-    @staticmethod
-    def _encode(balance: int, data: bytes, nonce: int) -> Tuple[bytes, List[Atom]]:
-        balance_atom = Atom.from_data(data=_int_to_be_bytes(balance))
-        data_atom = Atom.from_data(data=bytes(data))
-        nonce_atom = Atom.from_data(data=_int_to_be_bytes(nonce))
-
-        field_atoms = [balance_atom, data_atom, nonce_atom]
-        field_ids = [a.object_id() for a in field_atoms]
-
-        body_id, body_atoms = _make_list(field_ids)
-        type_atom = Atom.from_data(data=b"account", next_hash=body_id)
-        top_id, top_atoms = _make_list([type_atom.object_id(), body_id])
-
-        atoms = field_atoms + body_atoms + [type_atom] + top_atoms
-        return top_id, atoms
-
     @classmethod
-    def create(cls, balance: int, data: bytes, nonce: int) -> "Account":
-        account_hash, atoms = cls._encode(balance, data, nonce)
-        return cls(
-            _balance=int(balance),
-            _data=bytes(data),
-            _nonce=int(nonce),
-            hash=account_hash,
-            atoms=atoms,
+    def create(cls, balance: int = 0, data_hash: bytes = ZERO32, code: bytes = ZERO32, counter: int = 0) -> "Account":
+        account = cls(
+            balance=int(balance),
+            code=bytes(code),
+            counter=int(counter),
+            data_hash=bytes(data_hash),
+            data=PatriciaTrie(root_hash=bytes(data_hash)),
         )
+        account.to_atom()
+        return account
 
     @classmethod
-    def from_atom(cls, source: Any, account_id: bytes) -> "Account":
-        storage_get = _resolve_storage_get(source)
-
-        outer_list = storage_get(account_id)
-        if outer_list is None or outer_list.data != b"list":
-            raise ValueError("not an account (outer list missing)")
-
-        outer_value = storage_get(outer_list.next)
-        if outer_value is None:
-            raise ValueError("malformed account (outer value missing)")
+    def from_atom(cls, node: Any, account_id: bytes) -> "Account":
+        storage_get = node.storage_get
 
-        entries = _read_list_entries(storage_get, outer_value.next)
-        if len(entries) < 2:
-            raise ValueError("malformed account (type/body missing)")
-
-        type_atom_id, body_id = entries[0], entries[1]
-        type_atom = storage_get(type_atom_id)
+        type_atom = storage_get(account_id)
         if type_atom is None or type_atom.data != b"account":
             raise ValueError("not an account (type mismatch)")
 
-        body_list = storage_get(body_id)
-        if body_list is None or body_list.data != b"list":
-            raise ValueError("malformed account body (type)")
+        def _read_atom(atom_id: Optional[bytes]) -> Optional[Atom]:
+            if not atom_id or atom_id == ZERO32:
+                return None
+            return storage_get(atom_id)
 
-        body_value = storage_get(body_list.next)
-        if body_value is None:
-            raise ValueError("malformed account body (value)")
+        balance_atom = _read_atom(type_atom.next)
+        if balance_atom is None:
+            raise ValueError("malformed account (balance missing)")
 
-        field_ids = _read_list_entries(storage_get, body_value.next)
-        if len(field_ids) < 3:
-            field_ids.extend([ZERO32] * (3 - len(field_ids)))
+        code_atom = _read_atom(balance_atom.next)
+        if code_atom is None:
+            raise ValueError("malformed account (code missing)")
 
-        def _read_field(field_id: bytes) -> bytes:
-            if not field_id or field_id == ZERO32:
-                return b""
-            atom = storage_get(field_id)
-            return atom.data if atom is not None else b""
+        counter_atom = _read_atom(code_atom.next)
+        if counter_atom is None:
+            raise ValueError("malformed account (counter missing)")
 
-        balance_bytes = _read_field(field_ids[0])
-        data_bytes = _read_field(field_ids[1])
-        nonce_bytes = _read_field(field_ids[2])
+        data_atom = _read_atom(counter_atom.next)
+        if data_atom is None:
+            raise ValueError("malformed account (data missing)")
 
         account = cls.create(
-            balance=_be_bytes_to_int(balance_bytes),
-            data=data_bytes,
-            nonce=_be_bytes_to_int(nonce_bytes),
+            balance=bytes_to_int(balance_atom.data),
+            data_hash=data_atom.data,
+            counter=bytes_to_int(counter_atom.data),
+            code=code_atom.data,
         )
         if account.hash != account_id:
             raise ValueError("account hash mismatch while decoding")
         return account
 
-    def balance(self) -> int:
-        return self._balance
-
-    def data(self) -> bytes:
-        return self._data
-
-    def nonce(self) -> int:
-        return self._nonce
-
-    def body_hash(self) -> bytes:
-        return self.hash
-
     def to_atom(self) -> Tuple[bytes, List[Atom]]:
-        account_hash, atoms = self._encode(self._balance, self._data, self._nonce)
+        # Build a single forward chain: account -> balance -> code -> counter -> data.
+        data_atom = Atom.from_data(data=bytes(self.data_hash))
+        counter_atom = Atom.from_data(
+            data=int_to_bytes(self.counter),
+            next_hash=data_atom.object_id(),
+        )
+        code_atom = Atom.from_data(
+            data=bytes(self.code),
+            next_hash=counter_atom.object_id(),
+        )
+        balance_atom = Atom.from_data(
+            data=int_to_bytes(self.balance),
+            next_hash=code_atom.object_id(),
+        )
+        type_atom = Atom.from_data(data=b"account", next_hash=balance_atom.object_id())
+
+        atoms = [data_atom, counter_atom, code_atom, balance_atom, type_atom]
+        account_hash = type_atom.object_id()
         self.hash = account_hash
+        self.body_hash = account_hash
         self.atoms = atoms
         return account_hash, list(atoms)

astreum/_consensus/accounts.py

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