astreum 0.3.9__py3-none-any.whl → 0.3.46__py3-none-any.whl

astreum/consensus/models/block.py

@@ -1,364 +0,0 @@
-
-from typing import Any, Callable, List, Optional, Tuple, TYPE_CHECKING
-
-from ...storage.models.atom import Atom, AtomKind, ZERO32, hash_bytes
-
-if TYPE_CHECKING:
-    from ...storage.models.trie import Trie
-    from .transaction import Transaction
-    from .receipt import Receipt
-from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
-from cryptography.exceptions import InvalidSignature
-
-
-def _int_to_be_bytes(n: Optional[int]) -> bytes:
-    if n is None:
-        return b""
-    n = int(n)
-    if n == 0:
-        return b"\x00"
-    size = (n.bit_length() + 7) // 8
-    return n.to_bytes(size, "big")
-
-
-def _be_bytes_to_int(b: Optional[bytes]) -> int:
-    if not b:
-        return 0
-    return int.from_bytes(b, "big")
-
-
-class Block:
-    """Validation Block representation using Atom storage.
-
-    Top-level encoding:
-      block_id = type_atom.object_id()
-      chain: type_atom --next--> signature_atom --next--> body_list_atom --next--> ZERO32
-      where: type_atom        = Atom(kind=AtomKind.SYMBOL, data=b"block")
-             signature_atom   = Atom(kind=AtomKind.BYTES, data=<signature-bytes>)
-             body_list_atom   = Atom(kind=AtomKind.LIST,  data=<body_head_id>)
-
-    Details order in body_list:
-      0: chain                               (byte)
-      1: previous_block_hash                 (bytes)
-      2: number                              (int -> big-endian bytes)
-      3: timestamp                           (int -> big-endian bytes)
-      4: accounts_hash                       (bytes)
-      5: transactions_total_fees             (int -> big-endian bytes)
-      6: transactions_hash                   (bytes)
-      7: receipts_hash                       (bytes)
-      8: delay_difficulty                    (int -> big-endian bytes)
-      9: validator_public_key               (bytes)
-      10: nonce                              (int -> big-endian bytes)
-
-    Notes:
-      - "body tree" is represented here by the body_list id (self.body_hash), not
-        embedded again as a field to avoid circular references.
-      - "signature" is a field on the class but is not required for validation
-        navigation; include it in the instance but it is not encoded in atoms
-        unless explicitly provided via details extension in the future.
-    """
-
-    # essential identifiers
-    atom_hash: Optional[bytes]
-    chain_id: int
-    previous_block_hash: bytes
-    previous_block: Optional["Block"]
-
-    # block details
-    number: int
-    timestamp: Optional[int]
-    accounts_hash: Optional[bytes]
-    transactions_total_fees: Optional[int]
-    transactions_hash: Optional[bytes]
-    receipts_hash: Optional[bytes]
-    delay_difficulty: Optional[int]
-    validator_public_key: Optional[bytes]
-    nonce: Optional[int]
-
-    # additional
-    body_hash: Optional[bytes]
-    signature: Optional[bytes]
-
-    # structures
-    accounts: Optional["Trie"]
-    transactions: Optional[List["Transaction"]]
-    receipts: Optional[List["Receipt"]]
-    
-    def __init__(
-        self,
-        *,
-        chain_id: int,
-        previous_block_hash: bytes,
-        previous_block: Optional["Block"],
-        number: int,
-        timestamp: Optional[int],
-        accounts_hash: Optional[bytes],
-        transactions_total_fees: Optional[int],
-        transactions_hash: Optional[bytes],
-        receipts_hash: Optional[bytes],
-        delay_difficulty: Optional[int],
-        validator_public_key: Optional[bytes],
-        nonce: Optional[int] = None,
-        signature: Optional[bytes] = None,
-        atom_hash: Optional[bytes] = None,
-        body_hash: Optional[bytes] = None,
-        accounts: Optional["Trie"] = None,
-        transactions: Optional[List["Transaction"]] = None,
-        receipts: Optional[List["Receipt"]] = None,
-    ) -> None:
-        self.atom_hash = atom_hash
-        self.chain_id = chain_id
-        self.previous_block_hash = previous_block_hash
-        self.previous_block = previous_block
-        self.number = number
-        self.timestamp = timestamp
-        self.accounts_hash = accounts_hash
-        self.transactions_total_fees = transactions_total_fees
-        self.transactions_hash = transactions_hash
-        self.receipts_hash = receipts_hash
-        self.delay_difficulty = delay_difficulty
-        self.validator_public_key = validator_public_key
-        self.nonce = nonce
-        self.body_hash = body_hash
-        self.signature = signature
-        self.accounts = accounts
-        self.transactions = transactions
-        self.receipts = receipts
-
-    def to_atom(self) -> Tuple[bytes, List[Atom]]:
-        # Build body details as direct byte atoms, in defined order
-        detail_payloads: List[bytes] = []
-        block_atoms: List[Atom] = []
-
-        def _emit(detail_bytes: bytes) -> None:
-            detail_payloads.append(detail_bytes)
-
-        # 0: chain
-        _emit(_int_to_be_bytes(self.chain_id))
-        # 1: previous_block_hash
-        _emit(self.previous_block_hash)
-        # 2: number
-        _emit(_int_to_be_bytes(self.number))
-        # 3: timestamp
-        _emit(_int_to_be_bytes(self.timestamp))
-        # 4: accounts_hash
-        _emit(self.accounts_hash or b"")
-        # 5: transactions_total_fees
-        _emit(_int_to_be_bytes(self.transactions_total_fees))
-        # 6: transactions_hash
-        _emit(self.transactions_hash or b"")
-        # 7: receipts_hash
-        _emit(self.receipts_hash or b"")
-        # 8: delay_difficulty
-        _emit(_int_to_be_bytes(self.delay_difficulty))
-        # 9: validator_public_key
-        _emit(self.validator_public_key or b"")
-        # 10: nonce
-        _emit(_int_to_be_bytes(self.nonce))
-
-        # Build body list chain directly from detail atoms
-        body_head = ZERO32
-        detail_atoms: List[Atom] = []
-        for payload in reversed(detail_payloads):
-            atom = Atom(data=payload, next_id=body_head, kind=AtomKind.BYTES)
-            detail_atoms.append(atom)
-            body_head = atom.object_id()
-        detail_atoms.reverse()
-
-        block_atoms.extend(detail_atoms)
-
-        body_list_atom = Atom(data=body_head, kind=AtomKind.LIST)
-        self.body_hash = body_list_atom.object_id()
-
-        # Signature atom links to body list atom; type atom links to signature atom
-        sig_atom = Atom(
-            data=bytes(self.signature or b""),
-            next_id=self.body_hash,
-            kind=AtomKind.BYTES,
-        )
-        type_atom = Atom(data=b"block", next_id=sig_atom.object_id(), kind=AtomKind.SYMBOL)
-
-        block_atoms.append(body_list_atom)
-        block_atoms.append(sig_atom)
-        block_atoms.append(type_atom)
-
-        self.atom_hash = type_atom.object_id()
-        return self.atom_hash, block_atoms
-
-    @classmethod
-    def from_atom(cls, node: Any, block_id: bytes) -> "Block":
-
-        block_header = node.get_atom_list_from_storage(block_id)
-        if block_header is None or len(block_header) != 3:
-            raise ValueError("malformed block atom chain")
-        type_atom, sig_atom, body_list_atom = block_header
-
-        if type_atom.kind is not AtomKind.SYMBOL or type_atom.data != b"block":
-            raise ValueError("not a block (type atom payload)")
-        if sig_atom.kind is not AtomKind.BYTES:
-            raise ValueError("malformed block (signature atom kind)")
-        if body_list_atom.kind is not AtomKind.LIST:
-            raise ValueError("malformed block (body list atom kind)")
-        if body_list_atom.next_id != ZERO32:
-            raise ValueError("malformed block (body list tail)")
-
-        detail_atoms = node.get_atom_list_from_storage(body_list_atom.data)
-        if detail_atoms is None:
-            raise ValueError("missing block body list nodes")
-
-        if len(detail_atoms) != 11:
-            raise ValueError("block body must contain exactly 11 detail entries")
-
-        detail_values: List[bytes] = []
-        for detail_atom in detail_atoms:
-            if detail_atom.kind is not AtomKind.BYTES:
-                raise ValueError("block body detail atoms must be bytes")
-            detail_values.append(detail_atom.data)
-
-        (
-            chain_bytes,
-            prev_bytes,
-            number_bytes,
-            timestamp_bytes,
-            accounts_bytes,
-            fees_bytes,
-            transactions_bytes,
-            receipts_bytes,
-            delay_diff_bytes,
-            validator_bytes,
-            nonce_bytes,
-        ) = detail_values
-
-        return cls(
-            chain_id=_be_bytes_to_int(chain_bytes),
-            previous_block_hash=prev_bytes or ZERO32,
-            previous_block=None,
-            number=_be_bytes_to_int(number_bytes),
-            timestamp=_be_bytes_to_int(timestamp_bytes),
-            accounts_hash=accounts_bytes or None,
-            transactions_total_fees=_be_bytes_to_int(fees_bytes),
-            transactions_hash=transactions_bytes or None,
-            receipts_hash=receipts_bytes or None,
-            delay_difficulty=_be_bytes_to_int(delay_diff_bytes),
-            validator_public_key=validator_bytes or None,
-            nonce=_be_bytes_to_int(nonce_bytes),
-            signature=sig_atom.data if sig_atom is not None else None,
-            atom_hash=block_id,
-            body_hash=body_list_atom.object_id(),
-        )
-
-    def validate(self, storage_get: Callable[[bytes], Optional[Atom]]) -> bool:
-        """Validate this block against storage.
-
-        Checks:
-        - Signature: signature must verify over the body list id using the
-          validator's public key.
-        - Timestamp monotonicity: if previous block exists (not ZERO32), this
-          block's timestamp must be >= previous.timestamp + 1.
-        """
-        # Unverifiable if critical fields are missing
-        if not self.body_hash:
-            return False
-        if not self.signature:
-            return False
-        if not self.validator_public_key:
-            return False
-        if self.timestamp is None:
-            return False
-
-        # 1) Signature check over body hash
-        try:
-            pub = Ed25519PublicKey.from_public_bytes(bytes(self.validator_public_key))
-            pub.verify(self.signature, self.body_hash)
-        except InvalidSignature as e:
-            raise ValueError("invalid signature") from e
-
-        # 2) Timestamp monotonicity against previous block
-        prev_ts: Optional[int] = None
-        prev_hash = self.previous_block_hash or ZERO32
-
-        if self.previous_block is not None:
-            prev_ts = int(self.previous_block.timestamp or 0)
-            prev_hash = self.previous_block.atom_hash or prev_hash or ZERO32
-
-        if prev_hash and prev_hash != ZERO32 and prev_ts is None:
-            # If previous block cannot be loaded, treat as unverifiable, not malicious
-            try:
-                prev = Block.from_atom(storage_get, prev_hash)
-            except Exception:
-                return False
-            prev_ts = int(prev.timestamp or 0)
-
-        if prev_hash and prev_hash != ZERO32:
-            if prev_ts is None:
-                return False
-            cur_ts = int(self.timestamp or 0)
-            if cur_ts < prev_ts + 1:
-                raise ValueError("timestamp must be at least prev+1")
-
-        return True
-
-    @staticmethod
-    def _leading_zero_bits(buf: bytes) -> int:
-        """Return the number of leading zero bits in the provided buffer."""
-        zeros = 0
-        for byte in buf:
-            if byte == 0:
-                zeros += 8
-                continue
-            zeros += 8 - int(byte).bit_length()
-            break
-        return zeros
-
-    @staticmethod
-    def calculate_delay_difficulty(
-        *,
-        previous_timestamp: Optional[int],
-        current_timestamp: Optional[int],
-        previous_difficulty: Optional[int],
-        target_spacing: int = 2,
-    ) -> int:
-        """
-        Adjust the delay difficulty based on how quickly the previous block was produced.
-
-        The previous block difficulty is increased if the spacing is below the target,
-        decreased if above, and returned unchanged when the target spacing is met.
-        """
-        base_difficulty = max(1, int(previous_difficulty or 1))
-        if previous_timestamp is None or current_timestamp is None:
-            return base_difficulty
-
-        spacing = max(0, int(current_timestamp) - int(previous_timestamp))
-        if spacing <= 1:
-            adjusted = base_difficulty * 1.618
-        elif spacing == target_spacing:
-            adjusted = float(base_difficulty)
-        elif spacing > target_spacing:
-            adjusted = base_difficulty * 0.618
-        else:
-            adjusted = float(base_difficulty)
-
-        return max(1, int(round(adjusted)))
-
-    def generate_nonce(
-        self,
-        *,
-        difficulty: int,
-    ) -> int:
-        """
-        Find a nonce that yields a block hash with the required leading zero bits.
-
-        The search starts from the current nonce and iterates until the target
-        difficulty is met.
-        """
-        target = max(1, int(difficulty))
-        start = int(self.nonce or 0)
-        nonce = start
-        while True:
-            self.nonce = nonce
-            block_hash, _ = self.to_atom()
-            leading_zeros = self._leading_zero_bits(block_hash)
-            if leading_zeros >= target:
-                self.atom_hash = block_hash
-                return nonce
-            nonce += 1

astreum/consensus/models/chain.py

@@ -1,66 +0,0 @@
-# chain.py
-from typing import Callable, Dict, Optional
-from .block import Block
-from ...storage.models.atom import ZERO32, Atom
-
-class Chain:
-    def __init__(self, head_block: Block):
-        self.head_block = head_block
-        self.validated_upto_block = None
-        # Root (genesis) hash for this chain; set by validation setup when known
-        self.root: Optional[bytes] = None
-        # Fork position: the head hash of the default/current fork for this chain
-        self.fork_position: Optional[bytes] = getattr(head_block, "atom_hash", None)
-        # Mark the first malicious block encountered during validation; None means not found
-        self.malicious_block_hash: Optional[bytes] = None
-
-    def validate(self, storage_get: Callable[[bytes], Atom]) -> Block:
-        """Validate the chain from head to genesis and return the root block.
-
-        Incorporates per-block validation (signature on body and timestamp
-        monotonicity). Uses a simple cache to avoid duplicate Atom fetches and
-        duplicate block decoding during the backward walk.
-        """
-        # Atom and Block caches for this validation pass
-        atom_cache: Dict[bytes, Optional[Atom]] = {}
-        block_cache: Dict[bytes, Block] = {}
-
-        def get_cached(k: bytes) -> Optional[Atom]:
-            if k in atom_cache:
-                return atom_cache[k]
-            a = storage_get(k)
-            atom_cache[k] = a
-            return a
-
-        def load_block(bid: bytes) -> Block:
-            if bid in block_cache:
-                return block_cache[bid]
-            b = Block.from_atom(get_cached, bid)
-            block_cache[bid] = b
-            return b
-
-        blk = self.head_block
-        # Ensure head is in cache if it has a hash
-        if getattr(blk, "atom_hash", None):
-            block_cache[blk.atom_hash] = blk  # type: ignore[attr-defined]
-
-        # Walk back, validating each block
-        while True:
-            # Validate current block (signature over body, timestamp rule)
-            try:
-                blk.validate(get_cached)  # may decode previous but uses cached atoms
-            except Exception:
-                # record first failure point then propagate
-                self.malicious_block_hash = getattr(blk, "atom_hash", None)
-                raise
-
-            prev_hash = blk.previous_block_hash if hasattr(blk, "previous_block_hash") else ZERO32
-            if prev_hash == ZERO32:
-                break
-            # Move to previous block using cache-aware loader
-            prev_blk = load_block(prev_hash)
-            blk.previous_block = prev_blk  # cache the object for any downstream use
-            blk = prev_blk
-
-        self.validated_upto_block = blk
-        return blk

astreum/consensus/models/fork.py

@@ -1,100 +0,0 @@
-from __future__ import annotations
-
-from typing import Optional, Set, Any, Callable, Dict
-from .block import Block
-from ...storage.models.atom import ZERO32, Atom
-
-
-class Fork:
-    """A branch head within a Chain (same root).
-
-    - head:       current tip block id (bytes)
-    - peers:      identifiers (e.g., peer pubkey objects) following this head
-    - root:       genesis block id for this chain (optional)
-    - validated_upto: earliest verified ancestor (optional)
-    - chain_fork_position: the chain's fork anchor relevant to this fork
-    """
-
-    def __init__(
-        self,
-        head: bytes,
-    ) -> None:
-        self.head: bytes = head
-        self.peers: Set[Any] = set()
-        self.root: Optional[bytes] = None
-        self.validated_upto: Optional[bytes] = None
-        self.chain_fork_position: Optional[bytes] = None
-        # Mark the first block found malicious during validation; None means not found
-        self.malicious_block_hash: Optional[bytes] = None
-
-    def add_peer(self, peer_id: Any) -> None:
-        self.peers.add(peer_id)
-
-    def remove_peer(self, peer_id: Any) -> None:
-        self.peers.discard(peer_id)
-
-    def validate(
-        self,
-        storage_get: Callable[[bytes], Optional[object]],
-        stop_heads: Optional[Set[bytes]] = None,
-    ) -> bool:
-        """Validate only up to the chain fork position, not genesis.
-
-        Returns True if self.head descends from self.chain_fork_position (or if
-        chain_fork_position is None/equals head), and updates validated_upto to
-        that anchor. If stop_heads is provided, returns True early if ancestry
-        reaches any of those heads, setting validated_upto to the matched head.
-        Returns False if ancestry cannot be confirmed.
-        """
-        if self.chain_fork_position is None or self.chain_fork_position == self.head:
-            self.validated_upto = self.head
-            return True
-        # Caches to avoid double fetching/decoding
-        atom_cache: Dict[bytes, Optional[Atom]] = {}
-        block_cache: Dict[bytes, Block] = {}
-
-        def get_cached(k: bytes) -> Optional[Atom]:
-            if k in atom_cache:
-                return atom_cache[k]
-            a = storage_get(k)  # type: ignore[call-arg]
-            atom_cache[k] = a  # may be None if missing
-            return a
-
-        def load_block(bid: bytes) -> Optional[Block]:
-            if bid in block_cache:
-                return block_cache[bid]
-            try:
-                b = Block.from_atom(get_cached, bid)
-            except Exception:
-                return None
-            block_cache[bid] = b
-            return b
-
-        blk = load_block(self.head)
-        if blk is None:
-            # Missing head data: unverifiable, not malicious
-            return False
-        # Walk up to fork anchor, validating each block signature + timestamp
-        while True:
-            try:
-                blk.validate(get_cached)  # type: ignore[arg-type]
-            except Exception:
-                # mark the first failure point
-                self.malicious_block_hash = blk.atom_hash
-                return False
-
-            # Early-exit if we met another known fork head
-            if stop_heads and blk.atom_hash in stop_heads:
-                self.validated_upto = blk.atom_hash
-                return True
-
-            if blk.atom_hash == self.chain_fork_position:
-                self.validated_upto = blk.atom_hash
-                return True
-            
-            prev_hash = blk.previous_block_hash if hasattr(blk, "previous_block_hash") else ZERO32
-            nxt = load_block(prev_hash)
-            if nxt is None:
-                return False
-            blk.previous_block = nxt  # cache for future use
-            blk = nxt

astreum/consensus/setup.py

@@ -1,83 +0,0 @@
-from __future__ import annotations
-
-import threading
-from queue import Queue
-from typing import Any, Optional
-
-from .validator import current_validator  # re-exported for compatibility
-from .workers import (
-    make_discovery_worker,
-    make_validation_worker,
-    make_verify_worker,
-)
-from ..utils.bytes import hex_to_bytes
-
-
-def consensus_setup(node: Any, config: Optional[dict] = None) -> None:
-    config = config or {}
-    node.logger.info("Setting up node consensus")
-
-    # Shared state
-    node.validation_lock = getattr(node, "validation_lock", threading.RLock())
-
-    # Public maps per your spec
-    # - chains: Dict[root, Chain]
-    # - forks:  Dict[head, Fork]
-    node.chains = getattr(node, "chains", {})
-    node.forks = getattr(node, "forks", {})
-    node.logger.info(
-        "Consensus maps initialized (chains=%s, forks=%s)",
-        len(node.chains),
-        len(node.forks),
-    )
-
-    latest_block_hex = config.get("latest_block_hash")
-    if latest_block_hex is not None:
-        node.latest_block_hash = hex_to_bytes(latest_block_hex, expected_length=32)
-    
-    node.latest_block_hash = getattr(node, "latest_block_hash", None)
-    node.latest_block = getattr(node, "latest_block", None)
-    node.logger.info(
-        "Consensus latest_block_hash preset: %s",
-        node.latest_block_hash.hex() if isinstance(node.latest_block_hash, bytes) else node.latest_block_hash,
-    )
-
-    # Pending transactions queue (hash-only entries)
-    node._validation_transaction_queue = getattr(
-        node, "_validation_transaction_queue", Queue()
-    )
-    # Single work queue of grouped items: (latest_block_hash, set(peer_ids))
-    node._validation_verify_queue = getattr(
-        node, "_validation_verify_queue", Queue()
-    )
-    node._validation_stop_event = getattr(
-        node, "_validation_stop_event", threading.Event()
-    )
-
-    def enqueue_transaction_hash(tx_hash: bytes) -> None:
-        """Schedule a transaction hash for validation processing."""
-        if not isinstance(tx_hash, (bytes, bytearray)):
-            raise TypeError("transaction hash must be bytes-like")
-        node._validation_transaction_queue.put(bytes(tx_hash))
-
-    node.enqueue_transaction_hash = enqueue_transaction_hash
-
-    verify_worker = make_verify_worker(node)
-    validation_worker = make_validation_worker(node)
-
-    # Start workers as daemons
-    discovery_worker = make_discovery_worker(node)
-    node.consensus_discovery_thread = threading.Thread(
-        target=discovery_worker, daemon=True, name="consensus-discovery"
-    )
-    node.consensus_verify_thread = threading.Thread(
-        target=verify_worker, daemon=True, name="consensus-verify"
-    )
-    node.consensus_validation_thread = threading.Thread(
-        target=validation_worker, daemon=True, name="consensus-validation"
-    )
-    node.consensus_discovery_thread.start()
-    node.logger.info("Started consensus discovery thread (%s)", node.consensus_discovery_thread.name)
-    node.consensus_verify_thread.start()
-    node.logger.info("Started consensus verify thread (%s)", node.consensus_verify_thread.name)
-    node.logger.info("Consensus setup ready")

astreum/consensus/start.py

@@ -1,67 +0,0 @@
-from cryptography.hazmat.primitives import serialization
-from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
-
-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."""
-    self.logger.info(
-        "Initializing block and transaction processing for chain %s",
-        self.config["chain"],
-    )
-
-    self.validation_secret_key = validator_secret_key
-    validator_public_key_obj = self.validation_secret_key.public_key()
-    validator_public_key_bytes = validator_public_key_obj.public_bytes(
-        encoding=serialization.Encoding.Raw,
-        format=serialization.PublicFormat.Raw,
-    )
-    self.validation_public_key = validator_public_key_bytes
-    self.logger.debug(
-        "Derived validator public key %s", validator_public_key_bytes.hex()
-    )
-
-    if self.latest_block_hash is None:
-        genesis_block = create_genesis_block(
-            self,
-            validator_public_key=validator_public_key_bytes,
-            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()
-        self.logger.debug(
-            "Genesis block created with %s atoms (%s account atoms)",
-            len(genesis_atoms),
-            len(account_atoms),
-        )
-
-        for atom in account_atoms + genesis_atoms:
-            try:
-                self._hot_storage_set(key=atom.object_id(), value=atom)
-            except Exception as exc:
-                self.logger.warning(
-                    "Unable to persist genesis atom %s: %s",
-                    atom.object_id(),
-                    exc,
-                )
-
-        self.latest_block_hash = genesis_hash
-        self.latest_block = genesis_block
-        self.logger.info("Genesis block stored with hash %s", genesis_hash.hex())
-    else:
-        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,
-        )
-
-    self.logger.info(
-        "Starting consensus validation thread (%s)",
-        self.consensus_validation_thread.name,
-    )
-    self.consensus_validation_thread.start()
-
-    # ping all peers to announce validation capability

astreum/consensus/workers/__init__.py

@@ -1,9 +0,0 @@
-"""
-Worker thread factories for the consensus subsystem.
-"""
-
-from .discovery import make_discovery_worker
-from .validation import make_validation_worker
-from .verify import make_verify_worker
-
-__all__ = ["make_discovery_worker", "make_verify_worker", "make_validation_worker"]