Risc0 - experiment results

[ryleung-magicblock]

Here, I'll note the findings from the Risc0 experiment

Key Takeaways:

• At least for some workloads, the proving runtime grows sublinearly, though more tests will be needed to better characterize this
• At the moment though, the perf characteristics do not seem to rule out replaying certain individual txs or even batches of txs for use in fraud proofs for example
• This is especially true using GPU proving, which seems to give a nearly order-of-magnitude improvement in proving times
• However, CUDA support is still very unpolished and not ready for production right now, and has medium-to-poor documentation, requires manual building and installation of risc0 crates, hotfixes to the risc0 code, etc.
• Probably not practical to rely on compiling smart contract source to the Risc0 environment - some crates, including the Solana SDK (due to getrandom dependency) do not compile for the target, and there's the problem of how to prove the compiled program corresponds to the SBPF binary, syscalls, etc.
• Will probably need to wait for transpiler, or better, native SBPF zk support

The Test:
Host code:

// These constants represent the RISC-V ELF and the image ID generated by risc0-build.
// The ELF is used for proving and the ID is used for verification.
use methods::{
    GUEST_CODE_FOR_ZK_PROOF_ELF, GUEST_CODE_FOR_ZK_PROOF_ID
};
use risc0_zkvm::{default_prover, ExecutorEnv};
use core::GreetingAccount;
use std::time::Instant;


fn main() {
    // Initialize tracing. In order to view logs, run `RUST_LOG=info cargo run`
    tracing_subscriber::fmt()
        .with_env_filter(tracing_subscriber::filter::EnvFilter::from_default_env())
        .init();

    let input = (0..1000).map(|i|
        GreetingAccount {
        counter: i
    }).collect::<Vec<_>>();

    let env = ExecutorEnv::builder()
        .write(&input).unwrap()
        .build()
        .unwrap();

    // Obtain the default prover.
    let prover = default_prover();

    let now = Instant::now();
    // Proof information by proving the specified ELF binary.
    // This struct contains the receipt along with statistics about execution of the guest
    let prove_info = prover
        .prove(env, GUEST_CODE_FOR_ZK_PROOF_ELF)
        .unwrap();

    let elapsed = now.elapsed();
    // extract the receipt.
    let receipt = prove_info.receipt;

    // The receipt was verified at the end of proving, but the below code is an
    // example of how someone else could verify this receipt.
    /*receipt
        .verify(GUEST_CODE_FOR_ZK_PROOF_ID)
        .unwrap();*/


    let output: Vec<GreetingAccount> = receipt.journal.decode().unwrap();

    println!("Proving took {} ms", elapsed.as_millis());
     // Print, notice, after committing to a journal, the private input became public
     println!("Hello, world! I generated a proof of guest execution! {:?} is a public output from journal and the original input was {:?}", output, input);
}

Guest code:

use risc0_zkvm::guest::env;
use core::GreetingAccount;

// Program entrypoint's implementation
fn process_instruction(
    //program_id: &Pubkey, // Public key of the account the hello world program was loaded into
    greeting_accounts: &mut [GreetingAccount], // The account to say hello to
    //_instruction_data: &[u8], // Ignored, all helloworld instructions are hellos
) {
    for account in greeting_accounts {
        account.counter += 1;
    }
}

fn main() {
    // read and deserialize the input (uses serde)
    let mut greeting_account: Vec<GreetingAccount> = env::read();
    process_instruction(&mut greeting_account);

    // serialize and write the public output to the journal (uses serde)
    env::commit(&greeting_account);
}

Shared struct def:

use serde::{Deserialize, Serialize};

/// Define the type of state stored in accounts
#[derive(Debug, Deserialize, Serialize)]
pub struct GreetingAccount {
    /// number of greetings
    pub counter: u32,
}

Sample output:

Proving took 4209 ms
Hello, world! I generated a proof of guest execution! [GreetingAccount { counter: 1 }] is a public output from journal and the original input was [GreetingAccount { counter: 0 }]

Results:
For one element, on a run on an 11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz, proving took 4209 ms, for 10, 4222 ms, for 100, 8912 ms and for 1000, 17243 ms

Using CUDA, for one element, on a run on an NVIDIA GeForce RTX 3080 (laptop), proving took 2624 ms, for 10, 2589 ms, for 100, 2676 ms and for 1000, 2894 ms