astreum 0.2.25__py3-none-any.whl → 0.2.27__py3-none-any.whl

astreum/models/block.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from threading import Thread
 from typing import List, Dict, Any, Optional, Union
 
-from astreum.crypto.wesolowski import vdf_generate
+from astreum.crypto.wesolowski import vdf_generate, vdf_verify
 from astreum.models.account import Account
 from astreum.models.accounts import Accounts
 from astreum.models.patricia import PatriciaTrie
@@ -86,51 +86,46 @@ class Block:
             return int.from_bytes(leaf_bytes, "big")
         return leaf_bytes
 
-    def verify_block_signature(self) -> bool:
-        """Verify the block's Ed25519 signature against its body root."""
-        pub = ed25519.Ed25519PublicKey.from_public_bytes(
-            self.get_field("validator_pk")
-        )
-        try:
-            pub.verify(self.get_signature(), self.get_body_hash())
-            return True
-        except Exception:
-            return False
-
     @classmethod
     def genesis(cls, validator_addr: bytes) -> "Block":
-        # 1 . validator-stakes sub-trie
+        # 1. validator-stakes sub-trie
         stake_trie = PatriciaTrie()
         stake_trie.put(validator_addr, (1).to_bytes(32, "big"))
         stake_root = stake_trie.root_hash
 
-        # 2 . build the two Account bodies
-        validator_acct = Account.create(balance=0, data=b"",        nonce=0)
+        # 2. three Account bodies
+        validator_acct = Account.create(balance=0, data=b"", nonce=0)
         treasury_acct  = Account.create(balance=1, data=stake_root, nonce=0)
+        burn_acct = Account.create(balance=0, data=b"", nonce=0)
 
-        # 3 . global Accounts structure
+        # 3. global Accounts structure
         accts = Accounts()
         accts.set_account(validator_addr, validator_acct)
         accts.set_account(b"\x11" * 32, treasury_acct)
+        accts.set_account(b"\x00" * 32, burn_acct)
         accounts_hash = accts.root_hash
 
-        # 4 . constant body fields for genesis
+        # 4. constant body fields for genesis
         body_kwargs = dict(
+            block_hash              = b"",
             number                  = 0,
             prev_block_hash         = b"\x00" * 32,
             timestamp               = 0,
+            block_time              = 0,
             accounts_hash           = accounts_hash,
+            accounts                = accts,
             transactions_total_fees = 0,
-            transaction_limit       = 0,
+            transaction_limit       = 1,
             transactions_root_hash  = b"\x00" * 32,
-            delay_difficulty        = 0,
+            transactions_count      = 0,
+            delay_difficulty        = 1,
             delay_output            = b"",
             delay_proof             = b"",
             validator_pk            = validator_addr,
             signature               = b"",
         )
 
-        # 5 . build and return the block
+        # 5. build and return the block
         return cls.create(**body_kwargs)
 
     @classmethod
@@ -139,10 +134,9 @@ class Block:
         previous_block: "Block",
         transactions: List[Transaction],
         *,
-        validator_sk,                     # private key for signing
+        validator_sk,
         natural_rate: float = 0.618,
     ) -> "Block":
-        TREASURY = b"\x11" * 32
         BURN     = b"\x00" * 32
 
         blk = cls(
@@ -345,3 +339,94 @@ class Block:
         self.total_fees += fee
         self.tx_hashes.append(tx.hash)
         self.transactions_count += 1
+
+    def validate_block(self, remote_get_fn) -> bool:
+        NAT = 0.618
+        _i2b = lambda i: i.to_bytes((i.bit_length() + 7) // 8 or 1, "big")
+
+        # ---------- 1.  block-hash & signature -----------------------------
+        blk_mt = MerkleTree(node_get=remote_get_fn, root_hash=self.hash)
+        body_root = blk_mt.get(0); sig = blk_mt.get(1)
+        ed25519.verify_signature(public_key=self.validator_pk, message=body_root, signature=sig)
+
+        # ---------- 2.  rebuild body_root from fields ----------------------
+        f_names = (
+            "accounts_hash","block_time","delay_difficulty","delay_output","delay_proof",
+            "number","prev_block_hash","timestamp","transaction_limit",
+            "transactions_count","transactions_root_hash","transactions_total_fees",
+            "validator_pk",
+        )
+        leaves = [
+            v if isinstance(v := self.get_field(n), bytes) else _i2b(v)
+            for n in sorted(f_names)
+        ]
+        if MerkleTree.from_leaves(leaves).root_hash != body_root:
+            raise ValueError("body root mismatch")
+
+        # ---------- 3.  previous block header & VDF ------------------------
+        prev_mt = MerkleTree(node_get=remote_get_fn, root_hash=self.prev_block_hash)
+        prev_body_root, prev_sig = prev_mt.get(0), prev_mt.get(1)
+        prev_body_mt  = MerkleTree(node_get=remote_get_fn, root_hash=prev_body_root)
+        prev_blk      = Block(block_hash=self.prev_block_hash,
+                            body_tree=prev_body_mt, signature=prev_sig)
+        prev_out   = prev_blk.get_field("delay_output")
+        prev_diff  = prev_blk.get_field("delay_difficulty")
+        prev_bt    = prev_blk.get_field("block_time")
+        prev_limit = prev_blk.get_field("transaction_limit")
+        prev_cnt   = prev_blk.get_field("transactions_count")
+
+        if not vdf_verify(prev_out, self.delay_output, self.delay_proof,
+                        T=self.delay_difficulty, D=-4):
+            raise ValueError("bad VDF proof")
+
+        # ---------- 4.  replay all txs -------------------------------------
+        accs = Accounts(root_hash=prev_blk.get_field("accounts_hash"),
+                        node_get=remote_get_fn)
+        tx_mt = MerkleTree(node_get=remote_get_fn,
+                        root_hash=self.transactions_root_hash)
+        if tx_mt.leaf_count() != self.transactions_count:
+            raise ValueError("transactions_count mismatch")
+
+        dummy = Block(block_hash=b"", accounts=accs,
+                    accounts_hash=accs.root_hash,
+                    transaction_limit=prev_limit)
+        for i in range(self.transactions_count):
+            h  = tx_mt.get(i)
+            tm = MerkleTree(node_get=remote_get_fn, root_hash=h)
+            tx = Transaction(h, tree=tm, node_get=remote_get_fn)
+            dummy.apply_tx(tx)
+
+        # fee split identical to build()
+        burn = dummy.total_fees // 2
+        rew  = dummy.total_fees - burn
+        if burn:
+            dummy.accounts.set_account(
+                b"\x00"*32,
+                Account.create(burn, b"", 0)
+            )
+        if rew:
+            v_acct = dummy.accounts.get_account(self.validator_pk) or Account.create(0,b"",0)
+            dummy.accounts.set_account(
+                self.validator_pk,
+                Account.create(v_acct.balance()+rew, v_acct.data(), v_acct.nonce())
+            )
+
+        if dummy.accounts.root_hash != self.accounts_hash:
+            raise ValueError("accounts_hash mismatch")
+
+        # ---------- 5.  natural-rate rules --------------------------------
+        grow_thr   = prev_limit * NAT
+        shrink_thr = prev_cnt * NAT
+        expect_lim = prev_cnt if prev_cnt > grow_thr \
+            else max(1, int(prev_limit * NAT)) if prev_cnt < shrink_thr \
+            else prev_limit
+        if self.transaction_limit != expect_lim:
+            raise ValueError("tx-limit rule")
+
+        expect_diff = max(1, int(prev_diff / NAT)) if prev_bt <= 1 \
+                    else max(1, int(prev_diff * NAT))
+        if self.delay_difficulty != expect_diff:
+            raise ValueError("difficulty rule")
+
+        return True
+

astreum/models/merkle.py

@@ -41,11 +41,11 @@ class MerkleNode:
 class MerkleTree:
     def __init__(
         self,
-        node_get: Callable[[bytes], Optional[bytes]],
+        global_get_fn: Callable[[bytes], Optional[bytes]],
         root_hash: Optional[bytes] = None,
         height: Optional[int] = None,
     ) -> None:
-        self._node_get = node_get
+        self._global_get_fn = global_get_fn
         self.nodes: Dict[bytes, MerkleNode] = {}
         self.root_hash = root_hash
         self._height: Optional[int] = height
@@ -54,13 +54,13 @@ class MerkleTree:
     def from_leaves(
         cls,
         leaves: List[bytes],
-        node_get: Callable[[bytes], Optional[bytes]] | None = None,
+        global_get_fn: Callable[[bytes], Optional[bytes]] | None = None,
     ) -> "MerkleTree":
         if not leaves:
             raise ValueError("must supply at least one leaf")
 
-        node_get = node_get or (lambda _h: None)
-        tree = cls(node_get=node_get)
+        global_get_fn = global_get_fn or (lambda _h: None)
+        tree = cls(global_get_fn=global_get_fn)
 
         # Step 1 – create leaf nodes list[bytes]
         level_hashes: List[bytes] = []
@@ -97,7 +97,7 @@ class MerkleTree:
             return None
         node = self.nodes.get(h)
         if node is None:
-            raw = self._node_get(h)
+            raw = self._global_get_fn(h)
             if raw is None:
                 return None
             node = MerkleNode.from_bytes(raw)

astreum/models/message.py

@@ -0,0 +1,64 @@
+from enum import IntEnum
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PublicKey
+
+class MessageTopic(IntEnum):
+    PING = 0
+    OBJECT_REQUEST = 1
+    OBJECT_RESPONSE = 2
+    ROUTE_REQUEST = 3
+    ROUTE_RESPONSE = 4
+
+class Message:
+    handshake: bool
+    sender: X25519PublicKey
+
+    topic: MessageTopic
+    content: bytes
+
+    def to_bytes(self):
+        if self.handshake:
+            # handshake byte (1) + raw public key bytes
+            return bytes([1]) + self.sender.public_bytes(
+                encoding=serialization.Encoding.Raw,
+                format=serialization.PublicFormat.Raw
+            )
+        else:
+            # normal message: 0 + topic + content
+            return bytes([0, self.topic.value]) + self.content
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> "Message":
+        if len(data) < 1:
+            raise ValueError("Cannot parse Message: no data")
+        flag = data[0]
+        # create empty instance
+        msg = cls.__new__(cls)
+
+        if flag == 1:
+            # handshake message: the rest is the peer’s public key
+            key_bytes = data[1:]
+            try:
+                sender = X25519PublicKey.from_public_bytes(key_bytes)
+            except ValueError:
+                raise ValueError("Invalid public key bytes")
+            msg.handshake = True
+            msg.sender = sender
+            msg.topic = None
+            msg.content = b''
+        elif flag == 0:
+            # normal message: next byte is topic, rest is content
+            if len(data) < 2:
+                raise ValueError("Cannot parse Message: missing topic byte")
+            topic_val = data[1]
+            try:
+                topic = MessageTopic(topic_val)
+            except ValueError:
+                raise ValueError(f"Unknown MessageTopic: {topic_val}")
+            msg.handshake = False
+            msg.sender = None
+            msg.topic = topic
+            msg.content = data[2:]
+        else:
+            raise ValueError(f"Invalid handshake flag: {flag}")
+
+        return msg

astreum/models/transaction.py

@@ -27,14 +27,14 @@ class Transaction:
         tx_hash: bytes,
         *,
         tree: Optional[MerkleTree] = None,
-        get_node_fn: Optional[Callable[[bytes], Optional[bytes]]] = None,
+        global_get_fn: Optional[Callable[[bytes], Optional[bytes]]] = None,
     ) -> None:
         self._hash = tx_hash
         self._tree = tree
         self._field_cache: Dict[str, Union[int, bytes]] = {}
 
-        if self._tree and get_node_fn:
-            self._tree.set_external_node_fetcher(get_node_fn)
+        if self._tree and global_get_fn:
+            self._tree.global_get_fn = global_get_fn
 
     @classmethod
     def create(

astreum/node.py

@@ -15,6 +15,7 @@ from .crypto import ed25519, x25519
 from enum import IntEnum
 import blake3
 import struct
+from .models.message import Message, MessageTopic
 
 class ObjectRequestType(IntEnum):
     OBJECT_GET = 0
@@ -61,106 +62,11 @@ class ObjectResponse:
         type_val, data_val, hash_val = decode(data)
         return cls(type=ObjectResponseType(type_val[0]), data=data_val, hash=hash_val)
 
-class MessageTopic(IntEnum):
-    PING = 0
-    OBJECT_REQUEST = 1
-    OBJECT_RESPONSE = 2
-    ROUTE_REQUEST = 3
-    ROUTE_RESPONSE = 4
-
-class Message:
-    body: bytes
-    topic: MessageTopic
-    
-    def to_bytes(self):
-        return encode([self.body, [self.topic.value]])
-
-    @classmethod
-    def from_bytes(cls, data: bytes):
-        body, topic = decode(data)
-        return cls(body=body, topic=MessageTopic(topic[0]))
-
-class Envelope:
-    encrypted: bool
-    message: Message
-    nonce: int
-    sender: X25519PublicKey
-    timestamp: datetime
-
-    def __init__(self, message: Message, sender: X25519PublicKey, encrypted: bool = False, nonce: int = 0, timestamp: Union[int, datetime, None] = None, difficulty: int = 1):
-        self.encrypted = encrypted
-        encrypted_bytes = b'\x01' if self.encrypted else b'\x00'
-
-        self.message = message
-        message_bytes = message.to_bytes()
-
-        self.sender = sender
-        self.sender_bytes = sender.public_bytes()
-
-        self.nonce = nonce
-    
-        if timestamp is None:
-            self.timestamp = datetime.now(timezone.utc)
-            timestamp_int = int(self.timestamp.timestamp())
-        elif isinstance(timestamp, int):
-            self.timestamp = datetime.fromtimestamp(timestamp, timezone.utc)
-            timestamp_int = timestamp
-        elif isinstance(timestamp, datetime):
-            self.timestamp = timestamp
-            timestamp_int = int(timestamp.timestamp())
-        else:
-            raise TypeError("Timestamp must be an int (Unix timestamp), datetime object, or None")
-
-        def count_leading_zero_bits(data: bytes) -> int:
-            count = 0
-            for b in data:
-                if b == 0:
-                    count += 8
-                else:
-                    count += 8 - b.bit_length()
-                    break
-            return count
-
-        while True:
-            envelope_bytes = encode([
-                encrypted_bytes,
-                message_bytes,
-                self.nonce,
-                self.sender_bytes,
-                timestamp_int
-            ])
-            envelope_hash = blake3.blake3(envelope_bytes).digest()
-            if count_leading_zero_bits(envelope_hash) >= difficulty:
-                self.hash = envelope_hash
-                break
-            self.nonce += 1
-
-    def to_bytes(self):
-        encrypted_bytes = b'\x01' if self.encrypted else b'\x00'
-        
-        return encode([
-            encrypted_bytes,
-            self.message.to_bytes(),
-            self.nonce,
-            self.sender.public_bytes(),
-            int(self.timestamp.timestamp())
-        ])
-
-    @classmethod
-    def from_bytes(cls, data: bytes):
-        encrypted_bytes, message_bytes, nonce, sender_bytes, timestamp_int = decode(data)
-        return cls(
-            encrypted=(encrypted_bytes == b'\x01'),
-            message=Message.from_bytes(message_bytes),
-            nonce=nonce,
-            sender=X25519PublicKey.from_public_bytes(sender_bytes),
-            timestamp=datetime.fromtimestamp(timestamp_int, timezone.utc)
-        )
-
 class Peer:
-    def __init__(self, node_secret_key: X25519PrivateKey, peer_public_key: X25519PublicKey, address: Tuple[str, int]):
-        self.shared_key = x25519.generate_shared_key(node_secret_key, peer_public_key)
-        self.address = address
+    shared_key: bytes
+    timestamp: datetime
+    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)
 
 class Route:
@@ -419,6 +325,7 @@ class Node:
         self.peer_manager_thread.start()
 
         self.peers = Dict[X25519PublicKey, Peer]
+        self.addresses = Dict[Tuple[str, int], X25519PublicKey]
 
         if 'bootstrap' in config:
             for addr in config['bootstrap']:
@@ -451,9 +358,8 @@ class Node:
         # find the nearest peer route node to the hash and send an object request
         closest_peer = self._get_closest_local_peer(hash)
         if closest_peer:
-            object_request_message = Message(topic=MessageTopic.OBJECT_REQUEST, body=hash)
-            object_request_envelope = Envelope(message=object_request_message, sender=self.relay_public_key)
-            self.outgoing_queue.put((object_request_envelope.to_bytes(), self.peers[closest_peer].address))
+            object_request_message = Message(topic=MessageTopic.OBJECT_REQUEST, content=hash)
+            self.outgoing_queue.put((object_request_message.to_bytes(), self.peers[closest_peer].address))
 
         # wait for upto self.storage_get_relay_timeout seconds for the object to be stored/until local_object_get returns something
         start_time = time.time()
@@ -481,30 +387,31 @@ class Node:
         while True:
             try:
                 data, addr = self.incoming_queue.get()
-                envelope = Envelope.from_bytes(data)
-                match envelope.message.topic:
+                message = Message.from_bytes(data)
+                match message.topic:
                     case MessageTopic.PING:
-                        if envelope.sender in self.peers:
-                            self.peers[envelope.sender].timestamp = datetime.now(timezone.utc)
+                        peer_pub_key = self.addresses.get(addr)
+                        if peer_pub_key in self.peers:
+                            self.peers[peer_pub_key].timestamp = datetime.now(timezone.utc)
                             continue
 
-                        is_validator_flag = decode(envelope.message.body)
+                        is_validator_flag = decode(message.body)
 
-                        if envelope.sender not in self.peers:
+                        if peer_pub_key not in self.peers:
                             self._send_ping(addr)
 
-                        peer = Peer(self.relay_secret_key, envelope.sender, addr)
+                        peer = Peer(my_sec_key=self.relay_secret_key, peer_pub_key=peer_pub_key)
                         self.peers[peer.sender] = peer
-                        self.peer_route.add_peer(envelope.sender)
+                        self.peer_route.add_peer(peer_pub_key)
                         if is_validator_flag == [1]:
-                            self.validation_route.add_peer(envelope.sender)
+                            self.validation_route.add_peer(peer_pub_key)
 
                         if peer.timestamp < datetime.now(timezone.utc) - timedelta(minutes=5.0):
                             self._send_ping(addr)
                     
                     case MessageTopic.OBJECT_REQUEST:
                         try:
-                            object_request = ObjectRequest.from_bytes(envelope.message.body)
+                            object_request = ObjectRequest.from_bytes(message.body)
 
                             match object_request.type:
                                 # --------------  OBJECT_GET  --------------
@@ -519,9 +426,8 @@ class Node:
                                             data=local_data,
                                             hash=object_hash
                                         )
-                                        msg  = Message(topic=MessageTopic.OBJECT_RESPONSE, body=resp.to_bytes())
-                                        env  = Envelope(message=msg, sender=self.relay_public_key)
-                                        self.outgoing_queue.put((env.to_bytes(), addr))
+                                        obj_res_msg  = Message(topic=MessageTopic.OBJECT_RESPONSE, body=resp.to_bytes())
+                                        self.outgoing_queue.put((obj_res_msg.to_bytes(), addr))
                                         return  # done
 
                                     # 2. If we know a provider, tell the requester.
@@ -534,9 +440,8 @@ class Node:
                                             data=provider_bytes,
                                             hash=object_hash
                                         )
-                                        msg = Message(topic=MessageTopic.OBJECT_RESPONSE, body=resp.to_bytes())
-                                        env = Envelope(message=msg, sender=self.relay_public_key)
-                                        self.outgoing_queue.put((env.to_bytes(), addr))
+                                        obj_res_msg = Message(topic=MessageTopic.OBJECT_RESPONSE, body=resp.to_bytes())
+                                        self.outgoing_queue.put((obj_res_msg.to_bytes(), addr))
                                         return  # done
 
                                     # 3. Otherwise, direct the requester to a peer nearer to the hash.
@@ -555,14 +460,13 @@ class Node:
                                             data=peer_info,
                                             hash=object_hash
                                         )
-                                        msg = Message(topic=MessageTopic.OBJECT_RESPONSE, body=resp.to_bytes())
-                                        env = Envelope(message=msg, sender=self.relay_public_key)
-                                        self.outgoing_queue.put((env.to_bytes(), addr))
+                                        obj_res_msg = Message(topic=MessageTopic.OBJECT_RESPONSE, body=resp.to_bytes())
+                                        self.outgoing_queue.put((obj_res_msg.to_bytes(), addr))
 
                                 # --------------  OBJECT_PUT  --------------
                                 case ObjectRequestType.OBJECT_PUT:
                                     # Ensure the hash is present / correct.
-                                    obj_hash = object_request.hash or blake30.blake3(object_request.data).digest()
+                                    obj_hash = object_request.hash or blake3.blake3(object_request.data).digest()
 
                                     nearest = self._get_closest_local_peer(obj_hash)
                                     # If a strictly nearer peer exists, forward the PUT.
@@ -572,13 +476,13 @@ class Node:
                                             data=object_request.data,
                                             hash=obj_hash
                                         )
-                                        fwd_msg = Message(topic=MessageTopic.OBJECT_REQUEST, body=fwd_req.to_bytes())
-                                        fwd_env = Envelope(message=fwd_msg, sender=self.relay_public_key)
-                                        self.outgoing_queue.put((fwd_env.to_bytes(), nearest[1].address))
+                                        obj_req_msg = Message(topic=MessageTopic.OBJECT_REQUEST, body=fwd_req.to_bytes())
+                                        self.outgoing_queue.put((obj_req_msg.to_bytes(), nearest[1].address))
                                     else:
                                         # We are closest → remember who can provide the object.
+                                        peer_pub_key = self.addresses.get(addr)
                                         provider_record = encode([
-                                            envelope.sender.public_bytes(),
+                                           peer_pub_key.public_bytes(),
                                             encode_ip_address(*addr)
                                         ])
                                         if not hasattr(self, "storage_index") or not isinstance(self.storage_index, dict):
@@ -590,13 +494,13 @@ class Node:
 
                     case MessageTopic.OBJECT_RESPONSE:
                         try:
-                            object_response = ObjectResponse.from_bytes(envelope.message.body)
+                            object_response = ObjectResponse.from_bytes(message.body)
                             if object_response.hash not in self.object_request_queue:
                                 continue
                             
                             match object_response.type:
                                 case ObjectResponseType.OBJECT_FOUND:
-                                    if object_response.hash != blake30.blake3(object_response.data).digest():
+                                    if object_response.hash != blake3.blake3(object_response.data).digest():
                                         continue
                                     self.object_request_queue.remove(object_response.hash)
                                     self._local_object_put(object_response.hash, object_response.data)
@@ -604,9 +508,8 @@ class Node:
                                 case ObjectResponseType.OBJECT_PROVIDER:
                                     _provider_public_key, provider_address = decode(object_response.data)
                                     provider_ip, provider_port = decode_ip_address(provider_address)
-                                    object_request_message = Message(topic=MessageTopic.OBJECT_REQUEST, body=object_hash)
-                                    object_request_envelope = Envelope(message=object_request_message, sender=self.relay_public_key)
-                                    self.outgoing_queue.put((object_request_envelope.to_bytes(), (provider_ip, provider_port)))
+                                    obj_req_msg = Message(topic=MessageTopic.OBJECT_REQUEST, body=object_hash)
+                                    self.outgoing_queue.put((obj_req_msg.to_bytes(), (provider_ip, provider_port)))
 
                                 case ObjectResponseType.OBJECT_NEAREST_PEER:
                                     # -- decode the peer info sent back
@@ -630,23 +533,10 @@ class Node:
                                     if self._is_closer_than_local_peers(
                                         object_response.hash, nearest_peer_public_key
                                     ):
-                                        nearest_peer_ip, nearest_peer_port = decode_ip_address(
-                                            nearest_peer_address
-                                        )
-                                        object_request_message = Message(
-                                            topic=MessageTopic.OBJECT_REQUEST,
-                                            body=object_response.hash,
-                                        )
-                                        object_request_envelope = Envelope(
-                                            message=object_request_message,
-                                            sender=self.relay_public_key,
-                                        )
-                                        self.outgoing_queue.put(
-                                            (
-                                                object_request_envelope.to_bytes(),
-                                                (nearest_peer_ip, nearest_peer_port),
-                                            )
-                                        )
+                                        nearest_peer_ip, nearest_peer_port = decode_ip_address(nearest_peer_address)
+                                        obj_req_msg = Message(topic=MessageTopic.OBJECT_REQUEST, content=object_response.hash)
+                                        self.outgoing_queue.put((obj_req_msg.to_bytes(), (nearest_peer_ip, nearest_peer_port),)
+                                    )
 
           
                         except Exception as e:
@@ -678,9 +568,8 @@ class Node:
 
     def _send_ping(self, addr: Tuple[str, int]):
         is_validator_flag = encode([1] if self.validation_secret_key else [0])
-        ping_message = Message(topic=MessageTopic.PING, body=is_validator_flag)
-        ping_envelope = Envelope(message=ping_message, sender=self.relay_public_key)
-        self.outgoing_queue.put((ping_envelope.to_bytes(), addr))
+        ping_message = Message(topic=MessageTopic.PING, content=is_validator_flag)
+        self.outgoing_queue.put((ping_message.to_bytes(), addr))
 
     def _get_closest_local_peer(self, hash: bytes) -> Optional[Tuple[X25519PublicKey, Peer]]:
         # Find the globally closest peer using XOR distance

{astreum-0.2.25.dist-info → astreum-0.2.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.25
+Version: 0.2.27
 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.25.dist-info → astreum-0.2.27.dist-info}/RECORD

@@ -1,6 +1,6 @@
 astreum/__init__.py,sha256=y2Ok3EY_FstcmlVASr80lGR_0w-dH-SXDCCQFmL6uwA,28
 astreum/format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
-astreum/node.py,sha256=dPloCXuDyIn3-KDqxlgl3jxsonJlFMLi_quwJRsoLC8,46259
+astreum/node.py,sha256=DZyFQLQcdcNw-Vl3JrJzNbDKAiEqSbNQhyOLeGWGXz4,41967
 astreum/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/crypto/ed25519.py,sha256=FRnvlN0kZlxn4j-sJKl-C9tqiz_0z4LZyXLj3KIj1TQ,1760
 astreum/crypto/quadratic_form.py,sha256=pJgbORey2NTWbQNhdyvrjy_6yjORudQ67jBz2ScHptg,4037
@@ -12,12 +12,13 @@ astreum/lispeum/tokenizer.py,sha256=J-I7MEd0r2ZoVqxvRPlu-Afe2ZdM0tKXXhf1R4SxYTo,
 astreum/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/models/account.py,sha256=sHujGSwtV13rvOGJ5LZXuMrJ4F9XUdvyuWKz-zJ9lkE,2986
 astreum/models/accounts.py,sha256=aFSEWlq6zRf65-KGAdNGqEJyNVY3fpKhx8y1vU6sgSc,1164
-astreum/models/block.py,sha256=4slG6z6pZUyxQUu2on4c8nT24ztzJuQBZRje9KyRTXE,13840
-astreum/models/merkle.py,sha256=merV3rx2iRfzvglV6gNusrJf7OMbcVV854T-DUWCC64,6733
+astreum/models/block.py,sha256=-5j7uO0woVtNi0h52__e7AxpDQSVhzKUhr6Qc-2xZsE,17870
+astreum/models/merkle.py,sha256=lvWJa9nmrBL0n_2h_uNqpB_9a5s5Hn1FceRLx0IZIVQ,6778
+astreum/models/message.py,sha256=vv8yx-ndVYjCmPM4gXRVMToCTlKY_mflPu0uKsb9iiE,2117
 astreum/models/patricia.py,sha256=ohmXrcaz7Ae561tyC4u4iPOkQPkKr8N0IWJek4upFIg,13392
-astreum/models/transaction.py,sha256=yBarvRK2ybMAHHEQPZpubGO7gms4U9k093xQGNQHQ4Q,3043
-astreum-0.2.25.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.25.dist-info/METADATA,sha256=BqaRK8hea6p3iMUkin5gqzivjdOz16_alamM9jFkteQ,5478
-astreum-0.2.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.25.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.25.dist-info/RECORD,,
+astreum/models/transaction.py,sha256=MkLL5YX18kIf9-O4LBaZ4eWjkXDAaYIrDcDehbDZoqg,3038
+astreum-0.2.27.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.2.27.dist-info/METADATA,sha256=nMaxqfSmJtxic-_mIXivDbg2WszmnGkDnniiX1hqDH4,5478
+astreum-0.2.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.2.27.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.2.27.dist-info/RECORD,,