orchestrator.py

#!/usr/bin/env python3
"""
Autonet Multi-Node Orchestrator

Deploys contracts to a local Hardhat node, spawns N nodes of each type,
and validates that the protocol produces coordinated behavior:

- Proposers create tasks with hidden ground truth
- Solvers discover, train on, and submit solutions
- Coordinators verify solutions and vote via Yuma consensus
- Aggregators combine verified updates and publish new models
- Rewards flow correctly through the system

Usage:
    # Start hardhat node first: npx hardhat node
    python orchestrator.py [--proposers N] [--solvers M] [--coordinators K] [--rounds R]
"""

import argparse
import json
import logging
import os
import subprocess
import sys
import time
import threading
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Any
from pathlib import Path

# Add project root to path
PROJECT_ROOT = Path(__file__).parent
sys.path.insert(0, str(PROJECT_ROOT))

from nodes.common.blockchain import BlockchainInterface
from nodes.common.contracts import ContractRegistry
from nodes.common.blob_store import BlobStore
from nodes.common.config import AutonetConfig, load_config
from nodes.common.governance import GovernanceBridge, compute_service_id

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(name)s] %(levelname)s: %(message)s",
    datefmt="%H:%M:%S",
)
logger = logging.getLogger("orchestrator")


# =============================================================================
# Metrics Collection
# =============================================================================

@dataclass
class NodeMetrics:
    """Metrics for a single node."""
    node_id: str
    role: str
    address: str
    tasks_proposed: int = 0
    tasks_completed: int = 0
    solutions_committed: int = 0
    votes_submitted: int = 0
    aggregations_done: int = 0
    forced_errors_caught: int = 0
    rewards_earned: int = 0
    errors: int = 0
    cycles: int = 0


@dataclass
class NetworkMetrics:
    """Aggregate metrics across all nodes."""
    nodes: Dict[str, NodeMetrics] = field(default_factory=dict)
    total_tasks_proposed: int = 0
    total_solutions_committed: int = 0
    total_votes_submitted: int = 0
    total_consensus_reached: int = 0
    total_rewards_distributed: int = 0
    total_aggregations: int = 0
    start_time: float = 0.0

    def summary(self) -> str:
        elapsed = time.time() - self.start_time if self.start_time else 0
        lines = [
            "",
            "=" * 70,
            "NETWORK METRICS SUMMARY",
            "=" * 70,
            f"  Elapsed time:            {elapsed:.1f}s",
            f"  Tasks proposed:          {self.total_tasks_proposed}",
            f"  Solutions committed:     {self.total_solutions_committed}",
            f"  Votes submitted:         {self.total_votes_submitted}",
            f"  Consensus reached:       {self.total_consensus_reached}",
            f"  Rewards distributed:     {self.total_rewards_distributed}",
            f"  Aggregations:            {self.total_aggregations}",
            "",
            "  Per-node breakdown:",
        ]
        for nid, m in sorted(self.nodes.items()):
            lines.append(
                f"    [{m.role:12s}] {m.address[:10]}... "
                f"proposed={m.tasks_proposed} solved={m.tasks_completed} "
                f"voted={m.votes_submitted} aggregated={m.aggregations_done} "
                f"errors={m.errors} cycles={m.cycles}"
            )
        lines.append("=" * 70)
        return "\n".join(lines)


# =============================================================================
# Contract Deployment
# =============================================================================

def deploy_contracts(project_root: Path) -> Dict[str, str]:
    """Deploy all contracts via Hardhat and return addresses."""
    logger.info("Deploying contracts via Hardhat...")
    result = subprocess.run(
        "npx hardhat run scripts/deploy.js --network localhost",
        cwd=str(project_root),
        capture_output=True,
        text=True,
        timeout=120,
        shell=True,
    )

    if result.returncode != 0:
        logger.error(f"Deployment failed:\n{result.stderr}")
        raise RuntimeError("Contract deployment failed")

    logger.info("Deployment output:\n" + result.stdout)

    # Load addresses from the file that deploy.js creates
    addresses_file = project_root / "deployment-addresses.json"
    if not addresses_file.exists():
        raise RuntimeError("deployment-addresses.json not found after deploy")

    with open(addresses_file) as f:
        addresses = json.load(f)

    logger.info(f"Contracts deployed: {list(addresses.keys())}")
    return addresses


# =============================================================================
# Hardhat Account Management
# =============================================================================

# Hardhat default accounts (deterministic from mnemonic)
# "test test test test test test test test test test test junk"
HARDHAT_ACCOUNTS = [
    {
        "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
        "private_key": "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
    },
    {
        "address": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
        "private_key": "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d",
    },
    {
        "address": "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
        "private_key": "0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a",
    },
    {
        "address": "0x90F79bf6EB2c4f870365E785982E1f101E93b906",
        "private_key": "0x7c852118294e51e653712a81e05800f419141751be58f605c371e15141b007a6",
    },
    {
        "address": "0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65",
        "private_key": "0x47e179ec197488593b187f80a00eb0da91f1b9d0b13f8733639f19c30a34926a",
    },
    {
        "address": "0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc",
        "private_key": "0x8b3a350cf5c34c9194ca85829a2df0ec3153be0318b5e2d3348e872092edffba",
    },
    {
        "address": "0x976EA74026E726554dB657fA54763abd0C3a0aa9",
        "private_key": "0x92db14e403b83dfe3df233f83dfa3a0d7096f21ca9b0d6d6b8d88b2b4ec1564e",
    },
    {
        "address": "0x14dC79964da2C08b23698B3D3cc7Ca32193d9955",
        "private_key": "0x4bbbf85ce3377467afe5d46f804f221813b2bb87f24d81f60f1fcdbf7cbf4356",
    },
    {
        "address": "0x23618e81E3f5cdF7f54C3d65f7FBc0aBf5B21E8f",
        "private_key": "0xdbda1821b80551c9d65939329250298aa3472ba22feea921c0cf5d620ea67b97",
    },
    {
        "address": "0xa0Ee7A142d267C1f36714E4a8F75612F20a79720",
        "private_key": "0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6",
    },
    {
        "address": "0xBcd4042DE499D14e55001CcbB24a551F3b954096",
        "private_key": "0xf214f2b2cd398c806f84e317254e0f0b801d0643303237d97a22a48e01628897",
    },
    {
        "address": "0x71bE63f3384f5fb98995898A86B02Fb2426c5788",
        "private_key": "0x701b615bbdfb9de65240bc28bd21bbc0d996645a3dd57e7b12bc2bdf6f192c82",
    },
    {
        "address": "0xFABB0ac9d68B0B445fB7357272Ff202C5651694a",
        "private_key": "0xa267530f49f8280200edf313ee7af6b827f2a8bce2897751d06a843f644967b1",
    },
    {
        "address": "0x1CBd3b2770909D4e10f157cABC84C7264073C9Ec",
        "private_key": "0x47c99abed3324a2707c28affff1267e45918ec8c3f20b8aa892e8b065d2942dd",
    },
    {
        "address": "0xdF3e18d64BC6A983f673Ab319CCaE4f1a57C7097",
        "private_key": "0xc526ee95bf44d8fc405a158bb884d9d1238d99f0612e9f33d006bb0789009aaa",
    },
    {
        "address": "0xcd3B766CCDd6AE721141F452C550Ca635964ce71",
        "private_key": "0x8166f546bab6da521a8369cab06c5d2b9e46670292d85c875ee9ec20e84ffb61",
    },
    {
        "address": "0x2546BcD3c84621e976D8185a91A922aE77ECEc30",
        "private_key": "0xea6c44ac03bff858b476bba40716402b03e41b8e97e276d1baec7c37d42484a0",
    },
    {
        "address": "0xbDA5747bFD65F08deb54cb465eB87D40e51B197E",
        "private_key": "0x689af8efa8c651a91ad287602527f3af2fe9f6501a7ac4b061667b5a93e037fd",
    },
    {
        "address": "0xdD2FD4581271e230360230F9337D5c0430Bf44C0",
        "private_key": "0xde9be858da4a475276426320d5e9262ecfc3ba460bfac56360bfa6c4c28b4ee0",
    },
    {
        "address": "0x8626f6940E2eb28930eFb4CeF49B2d1F2C9C1199",
        "private_key": "0xdf57089febbacf7ba0bc227dafbffa9fc08a93fdc68e1e42411a14efcf23656e",
    },
]


# =============================================================================
# Node Runner (Thread-based)
# =============================================================================

class NodeRunner:
    """Runs a node in a thread with metrics collection."""

    def __init__(
        self,
        node_class,
        node_id: str,
        role: str,
        account: dict,
        contract_addresses: Dict[str, str],
        store: BlobStore,
        metrics: NetworkMetrics,
        rpb_address: str = "",
        max_cycles: int = 10,
        cycle_delay: float = 2.0,
        extra_kwargs: Optional[Dict[str, Any]] = None,
        config: Optional[AutonetConfig] = None,
    ):
        self.node_class = node_class
        self.node_id = node_id
        self.role = role
        self.account = account
        self.contract_addresses = contract_addresses
        self.store = store
        self.metrics = metrics
        self.rpb_address = rpb_address
        self.max_cycles = max_cycles
        self.cycle_delay = cycle_delay
        self.extra_kwargs = extra_kwargs or {}
        self.config = config
        self.thread: Optional[threading.Thread] = None
        self.node = None
        self.error: Optional[str] = None

        # Create per-node metrics
        self.node_metrics = NodeMetrics(
            node_id=node_id,
            role=role,
            address=account["address"],
        )
        metrics.nodes[node_id] = self.node_metrics

    def start(self):
        """Start the node in a background thread."""
        self.thread = threading.Thread(
            target=self._run, name=f"node-{self.node_id}", daemon=True
        )
        self.thread.start()

    def _run(self):
        """Main node execution."""
        try:
            # Create blockchain interface for this node
            blockchain = BlockchainInterface(
                rpc_url="http://127.0.0.1:8545",
                private_key=self.account["private_key"],
                chain_id=31337,  # Hardhat chain ID
            )

            if not blockchain.is_connected():
                self.error = "Failed to connect to blockchain"
                logger.error(f"[{self.node_id}] {self.error}")
                return

            # Create contract registry
            registry = ContractRegistry(
                blockchain=blockchain,
                addresses=self.contract_addresses,
            )

            # Create the node (pass config if available)
            kwargs = dict(self.extra_kwargs)
            if self.config is not None:
                kwargs["config"] = self.config
            self.node = self.node_class(
                registry=registry,
                store=self.store,
                node_id=self.node_id,
                rpb_address=self.rpb_address,
                **kwargs,
            )

            logger.info(f"[{self.node_id}] {self.role} node starting with address {self.account['address'][:10]}...")

            # Run the node loop
            self.node.run(max_cycles=self.max_cycles, cycle_delay=self.cycle_delay)

            # Collect final metrics
            if hasattr(self.node, "metrics"):
                m = self.node.metrics
                self.node_metrics.tasks_proposed = getattr(m, "tasks_proposed", 0)
                self.node_metrics.tasks_completed = getattr(m, "tasks_completed", 0)
                self.node_metrics.solutions_committed = getattr(m, "solutions_committed", 0)
                self.node_metrics.votes_submitted = getattr(m, "votes_submitted", 0)
                self.node_metrics.aggregations_done = getattr(m, "aggregations_done", 0)
                self.node_metrics.forced_errors_caught = getattr(m, "forced_errors_caught", 0)
                self.node_metrics.errors = getattr(m, "errors", 0)
                self.node_metrics.cycles = getattr(m, "cycles", 0)

        except Exception as e:
            self.error = str(e)
            self.node_metrics.errors += 1
            logger.error(f"[{self.node_id}] {self.role} node failed: {e}", exc_info=True)

    def is_alive(self) -> bool:
        return self.thread is not None and self.thread.is_alive()


# =============================================================================
# RPB Setup (Project.sol was removed — RPB is the project)
# =============================================================================


def distribute_tokens(
    deployer_blockchain: BlockchainInterface,
    registry: ContractRegistry,
    accounts: List[dict],
) -> None:
    """Distribute ATN tokens to all node accounts."""
    from web3 import Web3

    logger.info(f"Distributing tokens to {len(accounts)} node accounts...")
    for acc in accounts:
        result = registry.send(
            "ATNToken", "transfer",
            acc["address"],
            Web3.to_wei(50000, "ether"),
        )
        if result.success:
            logger.debug(f"  Sent 50000 ATN to {acc['address'][:10]}...")
        else:
            logger.warning(f"  Failed to send ATN to {acc['address'][:10]}: {result.error}")


# =============================================================================
# Validation
# =============================================================================

def validate_coordination(metrics: NetworkMetrics) -> bool:
    """
    Validate that the network showed expected coordination behavior.

    Criteria:
    1. At least 1 task was proposed
    2. At least 1 solution was committed
    3. At least 2 coordinator votes were submitted (MIN_COORDINATORS)
    4. Consensus was reached at least once
    5. No catastrophic errors (>50% of nodes failed)
    """
    logger.info("\nValidating coordination...")

    checks = []

    # Check 1: Tasks proposed
    proposed = sum(m.tasks_proposed for m in metrics.nodes.values())
    checks.append(("Tasks proposed > 0", proposed > 0, proposed))

    # Check 2: Solutions committed
    committed = sum(m.solutions_committed for m in metrics.nodes.values())
    checks.append(("Solutions committed > 0", committed > 0, committed))

    # Check 3: Votes submitted
    voted = sum(m.votes_submitted for m in metrics.nodes.values())
    checks.append(("Votes submitted >= 2", voted >= 2, voted))

    # Check 4: Consensus reached
    checks.append(("Consensus reached > 0", metrics.total_consensus_reached > 0, metrics.total_consensus_reached))

    # Check 5: Rewards distributed
    checks.append(("Rewards distributed > 0", metrics.total_rewards_distributed > 0, metrics.total_rewards_distributed))

    # Check 6: Low error rate
    total_nodes = len(metrics.nodes)
    failed_nodes = sum(1 for m in metrics.nodes.values() if m.errors > 0)
    error_rate = failed_nodes / max(total_nodes, 1)
    checks.append(("Error rate < 50%", error_rate < 0.5, f"{error_rate:.0%}"))

    # Print results
    all_passed = True
    for name, passed, value in checks:
        status = "PASS" if passed else "FAIL"
        logger.info(f"  [{status}] {name} (value: {value})")
        if not passed:
            all_passed = False

    return all_passed


# =============================================================================
# Main Orchestrator
# =============================================================================

# =============================================================================
# Governance Helpers (epoch management, service registration)
# =============================================================================


def _setup_governance(registry: ContractRegistry, config: AutonetConfig):
    """
    Register the training service and start the first epoch.

    Only runs if the AutonetEconomy contract is deployed. Otherwise
    skips gracefully (simulation mode without economic layer).
    """
    if not registry.get("AutonetEconomy"):
        logger.info("AutonetEconomy not deployed, skipping governance setup")
        return

    rpb_contract = registry.get("RPB")
    rpb_addr = rpb_contract.address if rpb_contract else ""
    service_id = compute_service_id(rpb_addr)

    # Register service
    if rpb_contract:
        try:
            import subprocess
            codebase_hash = subprocess.check_output(
                ["git", "rev-parse", "HEAD"],
                cwd=str(PROJECT_ROOT),
                timeout=5,
            ).decode().strip()
        except Exception:
            codebase_hash = "simulation"

        result = registry.register_service(
            service_id, rpb_contract.address, codebase_hash
        )
        if result.success:
            logger.info(f"Registered training service: {service_id[:8].hex()}...")

        # Activate service
        result = registry.activate_service(service_id)
        if result.success:
            logger.info(f"Activated training service")

    # Start first epoch with a budget
    epoch_budget = 10_000 * 10**18  # 10k ATN
    result = registry.start_epoch(epoch_budget)
    if result.success:
        epoch = registry.get_current_epoch()
        logger.info(f"Started epoch {epoch} with budget {epoch_budget // 10**18} ATN")


def _finalize_governance(registry: ContractRegistry):
    """Finalize the current epoch after all nodes stop."""
    if not registry.get("AutonetEconomy"):
        return

    try:
        epoch = registry.get_current_epoch()
        result = registry.finalize_epoch()
        if result.success:
            stats = registry.get_epoch_stats(epoch)
            if stats:
                logger.info(
                    f"Epoch {epoch} finalized: "
                    f"totalUsage={stats['totalUsage']}, "
                    f"budget={stats['budget'] // 10**18} ATN"
                )
            else:
                logger.info(f"Epoch {epoch} finalized")
    except Exception as e:
        logger.warning(f"Epoch finalization skipped: {e}")


def run_orchestrator(
    num_proposers: int = 2,
    num_solvers: int = 3,
    num_coordinators: int = 3,
    num_aggregators: int = 1,
    num_inference: int = 0,
    num_rounds: int = 5,
    cycle_delay: float = 3.0,
    task_mode: str = "ground_truth",
):
    """
    Run the full multi-node orchestration.

    1. Deploy contracts
    2. Setup project and distribute tokens
    3. Spawn all nodes
    4. Run for N rounds
    5. Collect metrics and validate

    Args:
        task_mode: "ground_truth" (legacy commit-reveal) or
                   "consensus_truth" (MM-Zero consensus-as-truth)
    """
    # Load shared config
    config = load_config()

    logger.info("=" * 70)
    logger.info("AUTONET MULTI-NODE ORCHESTRATOR")
    logger.info("=" * 70)
    logger.info(f"Configuration: {num_proposers}P / {num_solvers}S / {num_coordinators}C / {num_aggregators}A")
    logger.info(f"Rounds: {num_rounds}, Cycle delay: {cycle_delay}s, Task mode: {task_mode}")
    logger.info(f"Model: {config.model.architecture}, Device: {config.resolve_device()}, Task type: {config.training.task_type}")

    total_nodes = num_proposers + num_solvers + num_coordinators + num_aggregators
    if total_nodes + 1 > len(HARDHAT_ACCOUNTS):
        raise RuntimeError(
            f"Need {total_nodes + 1} accounts but only have {len(HARDHAT_ACCOUNTS)}"
        )

    # Step 1: Deploy contracts
    logger.info("\n--- STEP 1: Deploying contracts ---")
    addresses = deploy_contracts(PROJECT_ROOT)

    # Step 2: Setup deployer connection
    logger.info("\n--- STEP 2: Setting up deployer ---")
    deployer = HARDHAT_ACCOUNTS[0]
    deployer_blockchain = BlockchainInterface(
        rpc_url="http://127.0.0.1:8545",
        private_key=deployer["private_key"],
        chain_id=31337,
    )

    if not deployer_blockchain.is_connected():
        raise RuntimeError("Cannot connect to Hardhat node. Is it running?")

    deployer_registry = ContractRegistry(
        blockchain=deployer_blockchain,
        addresses=addresses,
    )

    # Step 3: Distribute tokens
    logger.info("\n--- STEP 3: Distributing tokens ---")
    node_accounts = HARDHAT_ACCOUNTS[1:total_nodes + 1]
    distribute_tokens(deployer_blockchain, deployer_registry, node_accounts)

    # Step 4: Create shared blob store (all threads share one directory)
    import tempfile
    blob_dir = tempfile.mkdtemp(prefix="autonet-blobs-")
    store = BlobStore(data_dir=blob_dir)
    logger.info(f"Blob store initialized at {blob_dir}")

    # Step 5: Spawn nodes
    logger.info("\n--- STEP 4: Spawning nodes ---")
    metrics = NetworkMetrics(start_time=time.time())
    runners: List[NodeRunner] = []

    account_idx = 0

    # Import node classes
    from nodes.proposer.main import ProposerNode
    from nodes.solver.main import SolverNode
    from nodes.coordinator.main import CoordinatorNode
    from nodes.aggregator.main import AggregatorNode
    from nodes.inference.main import InferenceNode

    # Proposers - need to run long enough to see SolutionCommitted events and reveal ground truth
    for i in range(num_proposers):
        runner = NodeRunner(
            node_class=ProposerNode,
            node_id=f"proposer-{i}",
            role="proposer",
            account=node_accounts[account_idx],
            contract_addresses=addresses,
            store=store,
            metrics=metrics,
            rpb_address="",
            max_cycles=num_rounds * 10,
            cycle_delay=cycle_delay,
            extra_kwargs={"task_mode": task_mode},
            config=config,
        )
        runners.append(runner)
        account_idx += 1

    # Solvers - need to train, commit, wait for ground truth reveal, then reveal solutions
    for i in range(num_solvers):
        runner = NodeRunner(
            node_class=SolverNode,
            node_id=f"solver-{i}",
            role="solver",
            account=node_accounts[account_idx],
            contract_addresses=addresses,
            store=store,
            metrics=metrics,
            rpb_address="",
            max_cycles=num_rounds * 10,
            cycle_delay=cycle_delay,
            extra_kwargs={"task_mode": task_mode},
            config=config,
        )
        runners.append(runner)
        account_idx += 1

    # Coordinators - need to run long enough to see solution reveals (after both reveals happen)
    for i in range(num_coordinators):
        runner = NodeRunner(
            node_class=CoordinatorNode,
            node_id=f"coordinator-{i}",
            role="coordinator",
            account=node_accounts[account_idx],
            contract_addresses=addresses,
            store=store,
            metrics=metrics,
            rpb_address="",
            max_cycles=num_rounds * 20,
            cycle_delay=cycle_delay,
            extra_kwargs={"task_mode": task_mode},
            config=config,
        )
        runners.append(runner)
        account_idx += 1

    # Aggregators - need to run long enough to collect rewards and aggregate
    for i in range(num_aggregators):
        runner = NodeRunner(
            node_class=AggregatorNode,
            node_id=f"aggregator-{i}",
            role="aggregator",
            account=node_accounts[account_idx],
            contract_addresses=addresses,
            store=store,
            metrics=metrics,
            rpb_address="",
            max_cycles=num_rounds * 10,
            cycle_delay=cycle_delay * 1.5,
            extra_kwargs={"task_mode": task_mode},
            config=config,
        )
        runners.append(runner)
        account_idx += 1

    # Inference nodes - run long to catch model publications and serve requests
    for i in range(num_inference):
        runner = NodeRunner(
            node_class=InferenceNode,
            node_id=f"inference-{i}",
            role="inference",
            account=node_accounts[account_idx],
            contract_addresses=addresses,
            store=store,
            metrics=metrics,
            rpb_address="",
            max_cycles=num_rounds * 15,
            cycle_delay=cycle_delay,
            config=config,
        )
        runners.append(runner)
        account_idx += 1

    # Step 5b: Register training service and start epoch (if economy available)
    _setup_governance(deployer_registry, config=config)

    # Start all nodes
    logger.info(f"Starting {len(runners)} nodes...")
    for runner in runners:
        runner.start()
        time.sleep(0.5)  # Stagger startup slightly

    # Step 6: Monitor until all nodes finish
    logger.info("\n--- STEP 5: Running simulation ---")
    start_time = time.time()
    max_runtime = num_rounds * cycle_delay * 5 + 60  # generous timeout

    while any(r.is_alive() for r in runners):
        elapsed = time.time() - start_time
        alive = sum(1 for r in runners if r.is_alive())
        logger.info(f"[{elapsed:.0f}s] {alive}/{len(runners)} nodes still running...")

        if elapsed > max_runtime:
            logger.warning("Timeout reached, stopping remaining nodes...")
            for r in runners:
                if r.node:
                    r.node.stop()
            break

        time.sleep(5)

    # Wait for threads to finish
    for runner in runners:
        if runner.thread:
            runner.thread.join(timeout=10)

    # Step 6b: Finalize epoch after nodes finish (if economy available)
    _finalize_governance(deployer_registry)

    # Step 7: Collect and display metrics
    logger.info("\n--- STEP 6: Results ---")

    # Update aggregate metrics
    for m in metrics.nodes.values():
        metrics.total_tasks_proposed += m.tasks_proposed
        metrics.total_solutions_committed += m.solutions_committed
        metrics.total_votes_submitted += m.votes_submitted
        metrics.total_aggregations += m.aggregations_done

    # Count on-chain consensus and rewards events
    consensus_events = deployer_registry.get_events(
        "ResultsRewards", "YumaConsensusReached", from_block=0, to_block="latest"
    )
    rewards_events = deployer_registry.get_events(
        "ResultsRewards", "RewardsDistributed", from_block=0, to_block="latest"
    )
    metrics.total_consensus_reached = len(consensus_events)
    metrics.total_rewards_distributed = len(rewards_events)

    logger.info(metrics.summary())

    # Step 8: Validate
    logger.info("\n--- STEP 7: Validation ---")
    passed = validate_coordination(metrics)

    if passed:
        logger.info("\n*** COORDINATION VALIDATED SUCCESSFULLY ***")
    else:
        logger.warning("\n*** COORDINATION VALIDATION FAILED ***")

    # Report any node errors
    errors = [(r.node_id, r.error) for r in runners if r.error]
    if errors:
        logger.info("\nNode errors:")
        for nid, err in errors:
            logger.info(f"  {nid}: {err}")

    return passed


# =============================================================================
# CLI Entry Point
# =============================================================================

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Autonet Multi-Node Orchestrator")
    parser.add_argument("--proposers", type=int, default=2, help="Number of proposer nodes")
    parser.add_argument("--solvers", type=int, default=3, help="Number of solver nodes")
    parser.add_argument("--coordinators", type=int, default=3, help="Number of coordinator nodes")
    parser.add_argument("--aggregators", type=int, default=1, help="Number of aggregator nodes")
    parser.add_argument("--inference", type=int, default=0, help="Number of inference nodes")
    parser.add_argument("--rounds", type=int, default=5, help="Number of training rounds")
    parser.add_argument("--delay", type=float, default=3.0, help="Cycle delay in seconds")
    parser.add_argument("--verbose", action="store_true", help="Enable debug logging")
    parser.add_argument(
        "--task-mode",
        choices=["ground_truth", "consensus_truth"],
        default="ground_truth",
        help="Task verification mode: ground_truth (legacy) or consensus_truth (MM-Zero)",
    )

    args = parser.parse_args()

    if args.verbose:
        logging.getLogger().setLevel(logging.DEBUG)

    success = run_orchestrator(
        num_proposers=args.proposers,
        num_solvers=args.solvers,
        num_coordinators=args.coordinators,
        num_aggregators=args.aggregators,
        num_inference=args.inference,
        num_rounds=args.rounds,
        cycle_delay=args.delay,
        task_mode=args.task_mode,
    )

    sys.exit(0 if success else 1)