// program/src/main.rs
#![no_main]
sp1_zkvm::entrypoint!(main);

use sp1_zkvm::lib::syscall_keccak256;
use sp1_zkvm::io::{read, commit};

pub fn main() {
    // Inputs: n (u32), seed (u64) - passed from host via stdin
    let n: u32 = read();
    let seed: u64 = read();

    // Simulate heavy compute: Fibonacci + Hashing (mimics price sig verification)
    let mut a: u64 = 0;
    let mut b: u64 = 1;
    let mut result = seed;

    for i in 0..n {
        // Fibonacci step
        let c = a.wrapping_add(b);
        a = b;
        b = c;

        // Mix in Keccak every 1000 iters to stress precompile (syscall 0x101)
        if i % 1000 == 0 {
            let mut input = [0u8; 32];
            input[..8].copy_from_slice(&a.to_le_bytes());
            input[8..16].copy_from_slice(&b.to_le_bytes());
            input[16..24].copy_from_slice(&result.to_le_bytes());

            // SP1 Syscall: Keccak256
            // unsafe { syscall_keccak256(input.as_ptr(), 32, result.as_mut_ptr()) }; 
            // Note: In v4+, use the safe wrapper:
            result = u64::from_le_bytes(sp1_zkvm::lib::keccak256(&input)[..8].try_into().unwrap());
        }
    }

    // Commit public outputs (sent to verifier contract)
    commit(&a); // fib(n)
    commit(&b); // fib(n+1)
    commit(&result); // mixed hash state
}

// script/bench.rs
use sp1_sdk::{ProverClient, SP1Stdin, SP1ProvingKey, SP1VerifyingKey, HashableKey};
use std::time::Instant;
use clap::Parser;

#[derive(Parser)]
struct Args {
    #[arg(long, default_value = "10_000_000")]
    cycles: u32,
    #[arg(long, default_value = "network")] // "local" or "network"
    mode: String,
}

fn main() {
    let args = Args::parse();
    let client = ProverClient::from_env(); // Reads SP1_PROVER=network/local

    // 1. Setup Keys (Cached in ~/.sp1/cache after first run)
    let (pk, vk) = client.setup(include_bytes!("../../program/elf/riscv32im-succinct-zkvm-elf"));
    println!("PK: {:?}, VK: {:?}", pk.hash(), vk.hash());

    // 2. Prepare Inputs
    let mut stdin = SP1Stdin::new();
    stdin.write(&args.cycles);
    stdin.write(&0xDEADBEEF_CAFE_BABE_u64);

    // 3. Execute (Dry run - traces only, no proof)
    let start = Instant::now();
    let (_, report) = client.execute(include_bytes!("../../program/elf/riscv32im-succinct-zkvm-elf"), stdin.clone()).run().unwrap();
    println!("Execution: {:?} | Cycles: {}", start.elapsed(), report.total_instruction_count());

    // 4. Prove
    let prove_start = Instant::now();
    let proof = match args.mode.as_str() {
        "local" => client.prove(&pk, stdin).groth16().run().unwrap(), // Local Groth16
        "network" => client.prove(&pk, stdin).groth16().network().run().unwrap(), // SP1 Network
        _ => panic!("Invalid mode"),
    };
    println!("Proving Time: {:?}", prove_start.elapsed());
    println!("Proof Size: {} bytes", proof.bytes().len());

    // 5. Verify Locally (Host side sanity check)
    client.verify(&proof, &vk).unwrap();
    println!("Local Verification: OK");

    // 6. Output for Solidity
    println!("Solidity Calldata: 0x{}", hex::encode(proof.bytes()));
    println!("Public Values: 0x{}", hex::encode(proof.public_values));
}

# In your project root (where Cargo.toml is)
cargo install sp1-cli --locked
sp1 build --program program # Compiles guest ELF
sp1 generate-verifier --program program --output contracts/src/SP1Verifier.sol

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

import { Groth16Verifier } from "./Groth16Verifier.sol"; // Generated dependency

contract SP1Verifier is Groth16Verifier {
    // SP1 v4.0 Verifying Key Hash (Embedded at deployment)
    // Generated by `sp1 generate-verifier`
    bytes32 public immutable SP1_VK_HASH = 0x1234...; 

    // Main entry point called by your App Contract
    function verifyProof(
        bytes calldata proof, 
        bytes calldata pubInputs
    ) external view returns (bool) {
        // 1. Verify Groth16 Proof against embedded VK
        // This calls the bn254 precompiles (pairing check)
        bool valid = Groth16Verifier.verifyProof(proof, pubInputs, SP1_VK_HASH);

        // 2. SP1 Specific: Verify the proof commits to the correct VM image (ELF hash)
        // This is handled inside Groth16Verifier logic via public inputs structure.
        // SP1 Public Inputs Layout: [sp1_vk_hash, committed_values_digest, ...]

        return valid;
    }
}

// contracts/src/ZKPriceOracle.sol
pragma solidity ^0.8.20;

import { SP1Verifier } from "./SP1Verifier.sol";
import { IOracleConsumer } from "./IOracleConsumer.sol";

contract ZKPriceOracle {
    SP1Verifier public immutable verifier;
    address public immutable admin;

    // State: Last verified prices
    uint256 public lastCexPrice;  // 8 decimals
    uint256 public lastDexPrice;  // 8 decimals
    uint256 public lastTimestamp;
    bool public lastResult;       // true if CEX > DEX

    event PriceVerified(uint256 indexed cex, uint256 indexed dex, bool cexGtDex, uint256 timestamp);

    constructor(address _verifier) {
        verifier = SP1Verifier(_verifier);
        admin = msg.sender;
    }

    // Called by Keeper/Relayer/MEV Bot
    function updatePrice(
        bytes calldata proof, 
        bytes calldata pubInputs
    ) external {
        // 1. Verify ZK Proof
        require(verifier.verifyProof(proof, pubInputs), "INVALID_PROOF");

        // 2. Decode Public Inputs (SP1 Layout: [fib_n, fib_n1, hash_state] -> We map to [cex, dex, nonce])
        // NOTE: In real app, define a struct ABI encoding in guest and decode here.
        (uint256 cexPrice, uint256 dexPrice, uint256 nonce) = abi.decode(pubInputs, (uint256, uint256, uint256));

        // 3. Replay Protection (Nonce)
        require(nonce > lastTimestamp, "STALE_PROOF"); // Using timestamp as nonce

        // 4. Update State
        lastCexPrice = cexPrice;
        lastDexPrice = dexPrice;
        lastTimestamp = nonce;
        lastResult = (cexPrice > dexPrice);

        emit PriceVerified(cexPrice, dexPrice, lastResult, nonce);
    }

    // Helper for consumers
    function getLastSpread() external view returns (int256) {
        return int256(lastCexPrice) - int256(lastDexPrice);
    }
}