astreum 0.2.43__py3-none-any.whl → 0.2.44__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/workers/validation.py

@@ -88,7 +88,7 @@ def make_validation_worker(
             new_block.timestamp = max(int(now), min_allowed)
 
             # atomize block
-            new_block_hash, _ = new_block.to_atom()
+            new_block_hash, new_block_atoms = new_block.to_atom()
             # put as own latest block hash
             node.latest_block_hash = new_block_hash
 
@@ -117,6 +117,9 @@ def make_validation_worker(
                             except Exception:
                                 pass
 
-            # store the new block and receipts
+            # upload block atoms
+            
+            # upload receipt atoms
+            # upload account atoms
 
     return _validation_worker

astreum/_node.py

@@ -13,8 +13,9 @@ def bytes_touched(*vals: bytes) -> int:
 class Node:
     def __init__(self, config: dict):
         # Storage Setup
-        self.in_memory_storage: Dict[bytes, Atom] = {}
-        self.in_memory_storage_lock = threading.RLock()
+        self.in_memory_storage: Dict[bytes, Atom] = {}
+        self.in_memory_storage_lock = threading.RLock()
+        self.storage_index: Dict[bytes, str] = {}
         # Lispeum Setup
         self.environments: Dict[uuid.UUID, Env] = {}
         self.machine_environments_lock = threading.RLock()
@@ -68,3 +69,34 @@ class Node:
         if atom is not None:
             return atom
         return self._network_get(key)
+
+    def _network_set(self, atom: Atom) -> None:
+        """Advertise an atom to the closest known peer so they can fetch it from us."""
+        try:
+            from src.astreum._communication.message import Message, MessageTopic
+        except Exception:
+            return
+
+        atom_id = atom.object_id()
+        try:
+            closest_peer = self.peer_route.closest_peer_for_hash(atom_id)
+        except Exception:
+            return
+        if closest_peer is None or closest_peer.address is None:
+            return
+        target_addr = closest_peer.address
+
+        try:
+            provider_ip, provider_port = self.incoming_socket.getsockname()[:2]
+        except Exception:
+            return
+
+        provider_str = f"{provider_ip}:{int(provider_port)}"
+        try:
+            provider_bytes = provider_str.encode("utf-8")
+        except Exception:
+            return
+
+        payload = atom_id + provider_bytes
+        message = Message(topic=MessageTopic.STORAGE_REQUEST, content=payload)
+        self.outgoing_queue.put((message.to_bytes(), target_addr))

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

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

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

@@ -1,13 +1,13 @@
 astreum/__init__.py,sha256=9tzA27B_eG5wRF1SAWJIV7xTmCcR1QFc123b_cvFOa4,345
-astreum/_node.py,sha256=Nyb4NZWWDjfCcIgljWIDAGyX5QTMr1lwBirnWzg13hQ,2642
+astreum/_node.py,sha256=AUpLjqbHno-Oh2X47nEfoU4I9i_Aj5vjXM1mHQH0gfM,3780
 astreum/format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
 astreum/node.py,sha256=MmlK3jaANTMB3ZAxR8IaSc82OS9meJmVawYIVURADbg,39689
 astreum/_communication/__init__.py,sha256=XJui0yOcfAur4HKt-8sSRlwB-MSU1rchkuOAY-nKDOE,207
-astreum/_communication/message.py,sha256=zNjUnt1roJRHMEoiLkcA7VK_TsHXok8PYEF7KTCqKnQ,3303
-astreum/_communication/peer.py,sha256=DT2vJOzeLyyOj7vTDQ1u1lF5Vc7Epj0Hhie-YfDrzfA,425
+astreum/_communication/message.py,sha256=Wl1IITj7eY9_q0IOT4J7c5gsjS1bF51CH7GcSSuu5OM,3327
+astreum/_communication/peer.py,sha256=CbqkyCwhFCiC2spd1-KjNdeVGNjjt2ECVs8uHot-ETI,875
 astreum/_communication/ping.py,sha256=u_DQTZJsbMdYiDDqjdZDsLaN5na2m9WZjVeEM3zq9_Y,955
-astreum/_communication/route.py,sha256=fbVXY0xF3O-k7dY9TuCsr6_XxD3m7Cb9ugVacQZ6GSk,2490
-astreum/_communication/setup.py,sha256=TzXpc8dajV31BJhHQMMcb5UdaFrxb1xlYSj58vc_5mg,9072
+astreum/_communication/route.py,sha256=Dqw8utefBeesZ311Nyizb7PO-g5dl26AoIUavttojHA,4037
+astreum/_communication/setup.py,sha256=EN2GyVfGlVtkSHMhZWwJN33y-Ycfdvq9tjr38Myrmqg,11739
 astreum/_communication/util.py,sha256=bJ3td3naDzmCelAJQpLwiDMoRBkijQl9YLROjsWyOrI,1256
 astreum/_consensus/__init__.py,sha256=gOCpvnIeO17CGjUGr0odaKNvGEggmDRXfT5IuyrYtcM,376
 astreum/_consensus/account.py,sha256=ClMB1e07ky5Wf7BwR4yhEjTSaWK2wiCmpvzio9AsZAY,3295
@@ -21,7 +21,7 @@ astreum/_consensus/setup.py,sha256=agwqfOemdLqE0Z1zrPV2XHVmZ9sAxp8Bh4k6e2u-t8w,2
 astreum/_consensus/transaction.py,sha256=q9r0nQzB_67dV-9cIThCzpiJkTojP--8QENPOKxN5yw,7481
 astreum/_consensus/workers/__init__.py,sha256=bS5FjbevbIR5FHbVGnT4Jli17VIld_5auemRw4CaHFU,278
 astreum/_consensus/workers/discovery.py,sha256=X1yjKGjLSApMJ9mgWbnc7N21ALD09khDf-in-M45Mis,1683
-astreum/_consensus/workers/validation.py,sha256=WcHLOs2NLMTrJpErghBXWeW2aqtX3-xGPo-HcySdEZ8,4814
+astreum/_consensus/workers/validation.py,sha256=ftlwTDocwrvCk_BAicrOJgm3deZHgwjN_gn5r-gWE_0,4900
 astreum/_consensus/workers/verify.py,sha256=wNkfh5qMARew79B-yyGL2UiExaSoGpOIq0fXUkDzpdw,1925
 astreum/_lispeum/__init__.py,sha256=LAy2Z-gBBQlByBHRGUKaaQrOB7QzFEEyGRtInmwTpfU,304
 astreum/_lispeum/environment.py,sha256=pJ0rjp9GoQxHhDiPIVei0jP7dZ_Pznso2O_tpp94-Ik,328
@@ -47,8 +47,8 @@ astreum/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/storage/object.py,sha256=knFlvw_tpcC4twSu1DGNpHX31wlANN8E5dgEqIfU--Q,2041
 astreum/storage/setup.py,sha256=1-9ztEFI_BvRDvAA0lAn4mFya8iq65THTArlj--M3Hg,626
 astreum/utils/integer.py,sha256=iQt-klWOYVghu_NOT341MmHbOle4FDT3by4PNKNXscg,736
-astreum-0.2.43.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.43.dist-info/METADATA,sha256=IjEYvHsaHI08xcD8hrZ5Pn9EZmwEPTNErSTqmv18t7Q,6181
-astreum-0.2.43.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.43.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.43.dist-info/RECORD,,
+astreum-0.2.44.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.2.44.dist-info/METADATA,sha256=BfQ0S0XtFjxl4evYAAWk9buUhQAVAq7L37patJVYDDU,6181
+astreum-0.2.44.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.2.44.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.2.44.dist-info/RECORD,,