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

astreum/communication/util.py

@@ -40,3 +40,10 @@ def address_str_to_host_and_port(address: str) -> Tuple[str, int]:
         raise ValueError(f"port out of range: {port}")
 
     return host, port
+
+
+def xor_distance(a: bytes, b: bytes) -> int:
+    """Return the unsigned integer XOR distance between two equal-length identifiers."""
+    if len(a) != len(b):
+        raise ValueError("xor distance requires operands of equal length")
+    return int.from_bytes(bytes(x ^ y for x, y in zip(a, b)), "big", signed=False)

astreum/consensus/start.py

@@ -6,10 +6,9 @@ from astreum.consensus.genesis import create_genesis_block
 
 def process_blocks_and_transactions(self, validator_secret_key: Ed25519PrivateKey):
     """Initialize validator keys, ensure genesis exists, then start validation thread."""
-    node_logger = self.logger
-    node_logger.info(
+    self.logger.info(
         "Initializing block and transaction processing for chain %s",
-        getattr(self, "chain", "unknown"),
+        self.config["chain"],
     )
 
     self.validation_secret_key = validator_secret_key
@@ -19,7 +18,7 @@ def process_blocks_and_transactions(self, validator_secret_key: Ed25519PrivateKe
         format=serialization.PublicFormat.Raw,
     )
     self.validation_public_key = validator_public_key_bytes
-    node_logger.debug(
+    self.logger.debug(
         "Derived validator public key %s", validator_public_key_bytes.hex()
     )
 
@@ -27,12 +26,12 @@ def process_blocks_and_transactions(self, validator_secret_key: Ed25519PrivateKe
         genesis_block = create_genesis_block(
             self,
             validator_public_key=validator_public_key_bytes,
-            chain_id=self.chain,
+            chain_id=self.config["chain_id"],
         )
         account_atoms = genesis_block.accounts.update_trie(self) if genesis_block.accounts else []
 
         genesis_hash, genesis_atoms = genesis_block.to_atom()
-        node_logger.debug(
+        self.logger.debug(
             "Genesis block created with %s atoms (%s account atoms)",
             len(genesis_atoms),
             len(account_atoms),
@@ -42,7 +41,7 @@ def process_blocks_and_transactions(self, validator_secret_key: Ed25519PrivateKe
             try:
                 self._hot_storage_set(key=atom.object_id(), value=atom)
             except Exception as exc:
-                node_logger.warning(
+                self.logger.warning(
                     "Unable to persist genesis atom %s: %s",
                     atom.object_id(),
                     exc,
@@ -50,16 +49,16 @@ def process_blocks_and_transactions(self, validator_secret_key: Ed25519PrivateKe
 
         self.latest_block_hash = genesis_hash
         self.latest_block = genesis_block
-        node_logger.info("Genesis block stored with hash %s", genesis_hash.hex())
+        self.logger.info("Genesis block stored with hash %s", genesis_hash.hex())
     else:
-        node_logger.debug(
+        self.logger.debug(
             "latest_block_hash already set to %s; skipping genesis creation",
             self.latest_block_hash.hex()
             if isinstance(self.latest_block_hash, (bytes, bytearray))
             else self.latest_block_hash,
         )
 
-    node_logger.info(
+    self.logger.info(
         "Starting consensus validation thread (%s)",
         self.consensus_validation_thread.name,
     )

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)
@@ -74,6 +78,8 @@ def current_validator(
         if current_amount <= 0:
             raise ValueError("validator stake must be positive")
         new_amount = current_amount // 2
+        if new_amount < 1:
+            new_amount = 1
         returned_amount = current_amount - new_amount
         stakes[validator_key] = new_amount
         stake_trie.put(node, validator_key, int_to_bytes(new_amount))
@@ -86,10 +92,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/consensus/workers/discovery.py

@@ -13,8 +13,7 @@ def make_discovery_worker(node: Any):
     """
 
     def _discovery_worker() -> None:
-        node_logger = node.logger
-        node_logger.info("Discovery worker started")
+        node.logger.info("Discovery worker started")
         stop = node._validation_stop_event
         while not stop.is_set():
             try:
@@ -36,10 +35,10 @@ def make_discovery_worker(node: Any):
                     }
 
                     if not pairs:
-                        node_logger.debug("No peers reported latest blocks; skipping queue update")
+                        node.logger.debug("No peers reported latest blocks; skipping queue update")
                         continue
 
-                    node_logger.debug(
+                    node.logger.debug(
                         "Discovery grouped %d block hashes from %d peers",
                         len(grouped),
                         len(pairs),
@@ -52,16 +51,16 @@ def make_discovery_worker(node: Any):
                         pass
                     for latest_b, peer_set in grouped.items():
                         node._validation_verify_queue.put((latest_b, peer_set))
-                        node_logger.debug(
+                        node.logger.debug(
                             "Queued %d peers for validation of block %s",
                             len(peer_set),
                             latest_b.hex(),
                         )
             except Exception:
-                node_logger.exception("Discovery worker iteration failed")
+                node.logger.exception("Discovery worker iteration failed")
             finally:
                 time.sleep(0.5)
 
-        node_logger.info("Discovery worker stopped")
+        node.logger.info("Discovery worker stopped")
 
     return _discovery_worker