From Single VM to
Decentralized Network

//! Sketch of a DePIN node wrapping the real zkvm-isa/zkvm-stark prover.
//! Not implemented -- libp2p is not a dependency of this repo today.

use clap::Parser;
use libp2p::{identity, swarm::{NetworkBehaviour, SwarmEvent}, Multiaddr, PeerId, Swarm};
use zkvm_isa::{execute, Program};
use zkvm_stark::{prove_program, verify_program};

#[derive(Parser, Debug)]
struct Args {
    #[arg(long)] start: bool,
    #[arg(long)] gpu: bool,
    #[arg(long, default_value = "testnet")] network: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args = Args::parse();
    let id_keys = identity::Keypair::generate_secp256k1();
    let peer_id = PeerId::from(id_keys.public());

    // ... swarm setup would go here; omitted, this is a sketch ...

    loop {
        // on receiving a task: execute the real interpreter, then prove_program()
        // exactly as zkvm-cli's `prove` command already does today.
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// Sketch only. The real, tested contract this would extend is
/// contracts/src/ProofOrchestrator.sol in the actual repo -- it already
/// does task/reward lifecycle for a single attester. This sketch is what
/// "many competing provers claim one task" would need to add.
contract MultiProverOrchestrator {
    struct Task {
        bytes32 id;
        string circuitHash;
        bytes inputs;
        address requester;
        uint256 reward;
        bool fulfilled;
        bytes proof;
        address prover;
    }

    mapping(bytes32 => Task) public tasks;
    uint256 public taskCount;

    event TaskSubmitted(bytes32 indexed taskId, address indexed requester);
    event TaskClaimed(bytes32 indexed taskId, address indexed prover);
    event TaskFulfilled(bytes32 indexed taskId, bool success);

    function submitTask(string memory _circuitHash, bytes memory _inputs)
        external payable returns (bytes32)
    {
        taskCount++;
        bytes32 taskId = keccak256(abi.encodePacked(block.timestamp, taskCount, msg.sender));
        tasks[taskId] = Task({
            id: taskId, circuitHash: _circuitHash, inputs: _inputs,
            requester: msg.sender, reward: msg.value, fulfilled: false,
            proof: new bytes(0), prover: address(0)
        });
        emit TaskSubmitted(taskId, msg.sender);
        return taskId;
    }

    function claimTask(bytes32 _taskId) external {
        Task storage task = tasks[_taskId];
        require(!task.fulfilled, "Task already fulfilled");
        require(task.prover == address(0), "Task already claimed");
        task.prover = msg.sender;
        emit TaskClaimed(_taskId, msg.sender);
    }

    function submitProof(bytes32 _taskId, bytes memory _proof) external {
        Task storage task = tasks[_taskId];
        require(msg.sender == task.prover, "Not the prover");
        require(!task.fulfilled, "Task already fulfilled");

        bool isValid = verifyProof(task.circuitHash, _proof, task.inputs);
        if (isValid) {
            task.fulfilled = true;
            task.proof = _proof;
            (bool sent, ) = payable(task.prover).call{value: task.reward}("");
            require(sent, "Failed to send reward");
            emit TaskFulfilled(_taskId, true);
        } else {
            revert("Invalid proof");
        }
    }

    /// Honest placeholder: reverts rather than silently accepting every proof.
    /// A real implementation needs to port FRI/Merkle/field-arithmetic
    /// verification into Solidity -- see docs/ONCHAIN_VERIFIER.md in the
    /// real repo for exactly what that requires and why it's a genuine
    /// research-and-engineering undertaking, not a TODO.
    function verifyProof(
        string memory,
        bytes memory,
        bytes memory
    ) internal pure returns (bool) {
        revert("verifyProof: not implemented -- see docs/ONCHAIN_VERIFIER.md");
    }
}

import requests
import time

class ZkVMHost:
    def __init__(self, orchestrator_url: str = "http://localhost:8080"):
        self.orchestrator_url = orchestrator_url

    def submit_task(self, circuit: str, inputs: dict, reward: float = 0.01) -> str:
        payload = {"circuit": circuit, "inputs": inputs, "reward": reward}
        response = requests.post(f"{self.orchestrator_url}/submit", json=payload)
        return response.json()["taskId"]

    def wait_for_proof(self, task_id: str, timeout: int = 60) -> dict:
        start = time.time()
        while time.time() - start < timeout:
            data = requests.get(f"{self.orchestrator_url}/status/{task_id}").json()
            if data["status"] == "fulfilled":
                return data
            time.sleep(1)
        raise TimeoutError("Proof generation timed out")

# What actually exists today: real anvil + Foundry, real CLI
$ anvil
$ cd contracts && forge test
$ cargo run --release -p zkvm-cli -- demo

# What this sketch imagines for a multi-node network (unbuilt):
$ docker run -p 3030:3030 zkvm/host-node:latest --start --gpu --network testnet
$ docker run -p 3031:3030 zkvm/host-node:latest --start --network testnet