sp1-prover 4.1.6

SP1 is a performant, 100% open-source, contributor-friendly zkVM.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

#![allow(clippy::print_stdout)]

use clap::Parser;
use p3_baby_bear::BabyBear;
use p3_util::log2_ceil_usize;
use sp1_core_executor::{Executor, Program, RiscvAirId, SP1Context};
use sp1_core_machine::{
    io::SP1Stdin, riscv::RiscvAir, shape::CoreShapeConfig, utils::setup_logger,
};
use sp1_stark::SP1CoreOpts;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    #[arg(short, long, value_delimiter = ' ')]
    list: Vec<String>,
    #[arg(short, long, value_delimiter = ' ')]
    shard_size: usize,
}

fn test_shape_fixing(
    elf: &[u8],
    stdin: &SP1Stdin,
    opts: SP1CoreOpts,
    context: SP1Context,
    shape_config: &CoreShapeConfig<BabyBear>,
) {
    // Setup the program.
    let mut program = Program::from(elf).unwrap();
    shape_config.fix_preprocessed_shape(&mut program).unwrap();

    // Setup the executor.
    let mut executor = Executor::with_context(program, opts, context);
    executor.maximal_shapes = Some(
        shape_config.maximal_core_shapes(log2_ceil_usize(opts.shard_size)).into_iter().collect(),
    );
    executor.write_vecs(&stdin.buffer);
    for (proof, vkey) in stdin.proofs.iter() {
        executor.write_proof(proof.clone(), vkey.clone());
    }

    // Collect the maximal shapes.
    let mut finished = false;
    while !finished {
        let (records, f) = executor.execute_record(true).unwrap();
        finished = f;
        for mut record in records {
            let _ = record.defer();
            let heights = RiscvAir::<BabyBear>::core_heights(&record);
            println!("heights: {:?}", heights);

            shape_config.fix_shape(&mut record).unwrap();

            if record.contains_cpu()
                && record.shape.unwrap().height(&RiscvAirId::Cpu).unwrap() > opts.shard_size
            {
                panic!("something went wrong")
            }
        }
    }
}

fn main() {
    // Setup logger.
    setup_logger();

    // Parse arguments.
    let args = Args::parse();

    // Setup the options.
    let config = CoreShapeConfig::<BabyBear>::default();
    let mut opts = SP1CoreOpts { shard_batch_size: 1, ..Default::default() };
    opts.shard_size = 1 << args.shard_size;

    // For each program, collect the maximal shapes.
    let program_list = args.list;
    for s3_path in program_list {
        // Download program and stdin files from S3.
        tracing::info!("download elf and input for {}", s3_path);

        // Download program.bin.
        let status = std::process::Command::new("aws")
            .args([
                "s3",
                "cp",
                &format!("s3://sp1-testing-suite/{}/program.bin", s3_path),
                "program.bin",
            ])
            .status()
            .expect("Failed to execute aws s3 cp command for program.bin");
        if !status.success() {
            panic!("Failed to download program.bin from S3");
        }

        // Download stdin.bin.
        let status = std::process::Command::new("aws")
            .args([
                "s3",
                "cp",
                &format!("s3://sp1-testing-suite/{}/stdin.bin", s3_path),
                "stdin.bin",
            ])
            .status()
            .expect("Failed to execute aws s3 cp command for stdin.bin");
        if !status.success() {
            panic!("Failed to download stdin.bin from S3");
        }

        // Read the program and stdin.
        let elf = std::fs::read("program.bin").expect("failed to read program");
        let stdin = std::fs::read("stdin.bin").expect("failed to read stdin");
        let stdin: SP1Stdin = bincode::deserialize(&stdin).expect("failed to deserialize stdin");

        // Collect the maximal shapes for each shard size.
        let elf = elf.clone();
        let stdin = stdin.clone();
        let new_context = SP1Context::default();
        test_shape_fixing(&elf, &stdin, opts, new_context, &config);

        std::fs::remove_file("program.bin").expect("failed to remove program.bin");
        std::fs::remove_file("stdin.bin").expect("failed to remove stdin.bin");
    }
}