astreum 0.3.10__tar.gz → 0.3.14__tar.gz

{astreum-0.3.10/src/astreum.egg-info → astreum-0.3.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.3.10
+Version: 0.3.14
 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

{astreum-0.3.10 → astreum-0.3.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "astreum"
-version = "0.3.10"
+version = "0.3.14"
 authors = [
   { name="Roy R. O. Okello", email="roy@stelar.xyz" },
 ]

astreum-0.3.14/src/astreum/communication/handlers/handshake.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Sequence
+
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PublicKey
+
+from ..models.peer import Peer
+from ..models.message import Message
+
+if TYPE_CHECKING:
+    from .... import Node
+
+
+def handle_handshake(node: "Node", addr: Sequence[object], message: Message) -> bool:
+    """Handle incoming handshake messages.
+
+    Returns True if the outer loop should `continue`, False otherwise.
+    """
+    sender_public_key_bytes = message.sender_bytes
+    try:
+        sender_key = X25519PublicKey.from_public_bytes(sender_public_key_bytes)
+    except Exception as exc:
+        node.logger.warning("Error extracting sender key bytes: %s", exc)
+        return True
+
+    try:
+        host = addr[0]
+        port = int.from_bytes(message.content[:2], "big", signed=False)
+    except Exception:
+        return True
+    peer_address = (host, port)
+
+    existing_peer = node.get_peer(sender_public_key_bytes)
+    if existing_peer is not None:
+        existing_peer.address = peer_address
+        return False
+
+    try:
+        peer = Peer(
+            node_secret_key=node.relay_secret_key,
+            peer_public_key=sender_key,
+            address=peer_address,
+        )
+    except Exception:
+        return True
+
+    node.add_peer(sender_public_key_bytes, peer)
+    node.peer_route.add_peer(sender_public_key_bytes, peer)
+
+    node.logger.info(
+        "Handshake accepted from %s:%s; peer added",
+        peer_address[0],
+        peer_address[1],
+    )
+    response = Message(
+        handshake=True,
+        sender=node.relay_public_key,
+        content=int(node.config["incoming_port"]).to_bytes(2, "big", signed=False),
+    )
+    node.outgoing_queue.put((response.to_bytes(), peer_address))
+    return True

astreum-0.3.14/src/astreum/communication/processors/peer.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import time
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .. import Node
+
+
+def manage_peer(node: "Node") -> None:
+    """Continuously evict peers whose timestamps exceed the configured timeout."""
+    node.logger.info(
+        "Peer manager started (timeout=%3ds, interval=%3ds)",
+        node.config["peer_timeout"],
+        node.config["peer_timeout_interval"],
+    )
+    while True:
+        timeout_seconds = node.config["peer_timeout"]
+        interval_seconds = node.config["peer_timeout_interval"]
+        try:
+            peers = getattr(node, "peers", None)
+            peer_route = getattr(node, "peer_route", None)
+            if not isinstance(peers, dict) or peer_route is None:
+                time.sleep(interval_seconds)
+                continue
+
+            cutoff = datetime.now(timezone.utc) - timedelta(seconds=timeout_seconds)
+            stale_keys = []
+            with node.peers_lock:
+                for peer_key, peer in list(peers.items()):
+                    if peer.timestamp < cutoff:
+                        stale_keys.append(peer_key)
+
+            removed_count = 0
+            for peer_key in stale_keys:
+                removed = node.remove_peer(peer_key)
+                if removed is None:
+                    continue
+                removed_count += 1
+                try:
+                    peer_route.remove_peer(peer_key)
+                except Exception:
+                    node.logger.debug(
+                        "Unable to remove peer %s from route",
+                        peer_key.hex(),
+                    )
+                node.logger.debug(
+                    "Evicted stale peer %s last seen at %s",
+                    peer_key.hex(),
+                    getattr(removed, "timestamp", None),
+                )
+
+            if removed_count:
+                node.logger.info("Peer manager removed %s stale peer(s)", removed_count)
+        except Exception:
+            node.logger.exception("Peer manager iteration failed")
+
+        time.sleep(interval_seconds)

{astreum-0.3.10 → astreum-0.3.14}/src/astreum/communication/setup.py

@@ -18,6 +18,7 @@ from .processors.incoming import (
     populate_incoming_messages,
 )
 from .processors.outgoing import process_outgoing_messages
+from .processors.peer import manage_peer
 from .util import address_str_to_host_and_port
 from ..utils.bytes import hex_to_bytes
 
@@ -122,13 +123,14 @@ def communication_setup(node: "Node", config: dict):
     # other workers & maps
     # track atom requests we initiated; guarded by atom_requests_lock on the node
     node.peer_manager_thread  = threading.Thread(
-        target=node._relay_peer_manager,
+        target=manage_peer,
+        args=(node,),
         daemon=True
     )
     node.peer_manager_thread.start()
 
     with node.peers_lock:
-        node.peers, node.addresses = {}, {} # peers: Dict[bytes,Peer], addresses: Dict[(str,int),bytes]
+        node.peers = {} # Dict[bytes,Peer]
 
     latest_block_hex = config.get("latest_block_hash")
     if latest_block_hex:

{astreum-0.3.10 → astreum-0.3.14}/src/astreum/consensus/validator.py

@@ -11,15 +11,19 @@ from ..storage.models.atom import ZERO32
 from ..utils.integer import bytes_to_int, int_to_bytes
 
 
+SLOT_DURATION_SECONDS = 2
+
+
 def current_validator(
     node: Any,
     block_hash: bytes,
     target_time: Optional[int] = None,
 ) -> Tuple[bytes, Accounts]:
     """
-    Determine the validator for the requested target_time, halving stakes each second
-    between the referenced block and the target time. Returns the validator key and
-    the updated accounts snapshot reflecting stake and balance adjustments.
+    Determine the validator for the requested target_time, halving stakes once per
+    slot (currently 2 seconds) between the referenced block and the target time.
+    Returns the validator key and the updated accounts snapshot reflecting stake and
+    balance adjustments.
     """
 
     block = Block.from_atom(node, block_hash)
@@ -86,10 +90,13 @@ def current_validator(
         accounts.set_account(validator_key, validator_account)
         accounts.set_account(TREASURY_ADDRESS, treasury_account)
 
-    iteration_target = block_timestamp + 1
-    while True:
+    delta = target_timestamp - block_timestamp
+    slots_to_process = max(1, (delta + SLOT_DURATION_SECONDS - 1) // SLOT_DURATION_SECONDS)
+
+    selected_validator = pick_validator()
+    halve_stake(selected_validator)
+    for _ in range(1, slots_to_process):
         selected_validator = pick_validator()
         halve_stake(selected_validator)
-        if iteration_target == target_timestamp:
-            return selected_validator, accounts
-        iteration_target += 1
+
+    return selected_validator, accounts

{astreum-0.3.10 → astreum-0.3.14}/src/astreum/consensus/workers/validation.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import math
 import time
 from queue import Empty
 from typing import Any, Callable
@@ -203,7 +204,9 @@ def make_validation_worker(
 
             now = time.time()
             min_allowed = new_block.previous_block.timestamp + 1
-            new_block.timestamp = max(int(now), min_allowed)
+            nonce_time_seconds = node.nonce_time_ms / 1000.0
+            expected_blocktime = now + nonce_time_seconds
+            new_block.timestamp = max(int(math.ceil(expected_blocktime)), min_allowed)
 
             new_block.delay_difficulty = Block.calculate_delay_difficulty(
                 previous_timestamp=previous_block.timestamp,
@@ -212,7 +215,10 @@ def make_validation_worker(
             )
             
             try:
+                nonce_started = time.perf_counter()
                 new_block.generate_nonce(difficulty=previous_block.delay_difficulty)
+                elapsed_ms = int((time.perf_counter() - nonce_started) * 1000)
+                setattr(node, "nonce_time_ms", elapsed_ms)
                 node.logger.debug(
                     "Found nonce %s for block #%s at difficulty %s",
                     new_block.nonce,
@@ -223,18 +229,39 @@ def make_validation_worker(
                 node.logger.exception("Failed while searching for block nonce")
                 time.sleep(0.5)
                 continue
+            
+            # wait until the block timestamp is reached before propagating
+            now = time.time()
+            if now > new_block.timestamp:
+                node.logger.warning(
+                    "Skipping block #%s propagation; timestamp %s already elapsed (now=%s)",
+                    new_block.number,
+                    new_block.timestamp,
+                    now,
+                )
+                continue
 
+            spread_delay = new_block.timestamp - now
+            if spread_delay > 0:
+                node.logger.debug(
+                    "Delaying distribution for %.3fs to reach block timestamp %s",
+                    spread_delay,
+                    new_block.timestamp,
+                )
+                time.sleep(spread_delay)
+                
             # atomize block
             new_block_hash, new_block_atoms = new_block.to_atom()
             # put as own latest block hash
             node.latest_block_hash = new_block_hash
             node.latest_block = new_block
             node.logger.info(
-                "Validated block #%s with hash %s (%d atoms)",
+                "Created block #%s with hash %s (%d atoms)",
                 new_block.number,
                 new_block_hash.hex(),
                 len(new_block_atoms),
             )
+            
 
             # ping peers in the validation route to update their records
             if node.validation_route and node.outgoing_queue and node.peers:

{astreum-0.3.10 → astreum-0.3.14}/src/astreum/node.py

@@ -56,7 +56,8 @@ class Node:
         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
 

{astreum-0.3.10 → astreum-0.3.14}/src/astreum/utils/config.py

@@ -1,9 +1,11 @@
-
+
 from pathlib import Path
 from typing import Dict
 
 DEFAULT_HOT_STORAGE_LIMIT = 1 << 30  # 1 GiB
 DEFAULT_COLD_STORAGE_LIMIT = 10 << 30  # 10 GiB
+DEFAULT_PEER_TIMEOUT_SECONDS = 15 * 60  # 15 minutes
+DEFAULT_PEER_TIMEOUT_INTERVAL_SECONDS = 10  # 10 seconds
 
 
 def config_setup(config: Dict = {}):
@@ -45,4 +47,30 @@ def config_setup(config: Dict = {}):
     else:
         config["cold_storage_path"] = None
 
+    peer_timeout_raw = config.get("peer_timeout", DEFAULT_PEER_TIMEOUT_SECONDS)
+    try:
+        peer_timeout = int(peer_timeout_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"peer_timeout must be an integer: {peer_timeout_raw!r}"
+        ) from exc
+
+    if peer_timeout <= 0:
+        raise ValueError("peer_timeout must be a positive integer")
+
+    config["peer_timeout"] = peer_timeout
+
+    interval_raw = config.get("peer_timeout_interval", DEFAULT_PEER_TIMEOUT_INTERVAL_SECONDS)
+    try:
+        interval = int(interval_raw)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"peer_timeout_interval must be an integer: {interval_raw!r}"
+        ) from exc
+
+    if interval <= 0:
+        raise ValueError("peer_timeout_interval must be a positive integer")
+
+    config["peer_timeout_interval"] = interval
+
     return config

{astreum-0.3.10 → astreum-0.3.14/src/astreum.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.3.10
+Version: 0.3.14
 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

{astreum-0.3.10 → astreum-0.3.14}/src/astreum.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ src/astreum/communication/models/route.py
 src/astreum/communication/processors/__init__.py
 src/astreum/communication/processors/incoming.py
 src/astreum/communication/processors/outgoing.py
+src/astreum/communication/processors/peer.py
 src/astreum/consensus/__init__.py
 src/astreum/consensus/genesis.py
 src/astreum/consensus/setup.py

astreum-0.3.10/src/astreum/communication/handlers/handshake.py

@@ -1,89 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Sequence
-
-from cryptography.hazmat.primitives import serialization
-from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PublicKey
-
-from ..models.peer import Peer
-from ..models.message import Message
-
-if TYPE_CHECKING:
-    from .... import Node
-
-
-def handle_handshake(node: "Node", addr: Sequence[object], message: Message) -> bool:
-    """Handle incoming handshake messages.
-
-    Returns True if the outer loop should `continue`, False otherwise.
-    """
-    sender_public_key_bytes = message.sender_bytes
-    try:
-        sender_key = X25519PublicKey.from_public_bytes(sender_public_key_bytes)
-    except Exception as exc:
-        node.logger.warning("Error extracting sender key bytes: %s", exc)
-        return True
-
-    try:
-        host = addr[0]
-        port = int.from_bytes(message.content[:2], "big", signed=False)
-    except Exception:
-        return True
-    peer_address = (host, port)
-
-    old_key_bytes = node.addresses.get(peer_address)
-    node.addresses[peer_address] = sender_public_key_bytes
-
-    if old_key_bytes is None:
-        try:
-            peer = Peer(
-                node_secret_key=node.relay_secret_key,
-                peer_public_key=sender_key,
-                address=peer_address,
-            )
-        except Exception:
-            return True
-
-        node.add_peer(sender_public_key_bytes, peer)
-        node.peer_route.add_peer(sender_public_key_bytes, peer)
-
-        node.logger.info(
-            "Handshake accepted from %s:%s; peer added",
-            peer_address[0],
-            peer_address[1],
-        )
-        response = Message(
-            handshake=True,
-            sender=node.relay_public_key,
-            content=int(node.config["incoming_port"]).to_bytes(2, "big", signed=False),
-        )
-        node.outgoing_queue.put((response.to_bytes(), peer_address))
-        return True
-
-    if old_key_bytes == sender_public_key_bytes:
-        peer = node.get_peer(sender_public_key_bytes)
-        if peer is not None:
-            peer.address = peer_address
-        return False
-
-    try:
-        node.peer_route.remove_peer(old_key_bytes)
-    except Exception:
-        pass
-    try:
-        peer = Peer(
-            node_secret_key=node.relay_secret_key,
-            peer_public_key=sender_key,
-            address=peer_address,
-        )
-    except Exception:
-        return True
-
-    node.replace_peer(old_key_bytes, sender_public_key_bytes, peer)
-    node.peer_route.add_peer(sender_public_key_bytes, peer)
-    node.logger.info(
-        "Peer at %s:%s replaced due to key change",
-        peer_address[0],
-        peer_address[1],
-    )
-    return False