sp1-core 1.1.1

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

mod air;
pub mod columns;
mod execute;
mod trace;

use p3_keccak_air::KeccakAir;
use serde::{Deserialize, Serialize};

use crate::runtime::{MemoryReadRecord, MemoryWriteRecord};

pub(crate) const STATE_SIZE: usize = 25;

// The permutation state is 25 u64's.  Our word size is 32 bits, so it is 50 words.
const STATE_NUM_WORDS: usize = STATE_SIZE * 2;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KeccakPermuteEvent {
    pub lookup_id: u128,
    pub shard: u32,
    pub channel: u8,
    pub clk: u32,
    pub pre_state: [u64; STATE_SIZE],
    pub post_state: [u64; STATE_SIZE],
    pub state_read_records: Vec<MemoryReadRecord>,
    pub state_write_records: Vec<MemoryWriteRecord>,
    pub state_addr: u32,
}

pub struct KeccakPermuteChip {
    p3_keccak: KeccakAir,
}

impl KeccakPermuteChip {
    pub const fn new() -> Self {
        Self {
            p3_keccak: KeccakAir {},
        }
    }
}

#[cfg(test)]
pub mod permute_tests {
    use crate::runtime::SyscallCode;
    use crate::stark::CpuProver;
    use crate::utils::{run_test, SP1CoreOpts};
    use crate::{
        runtime::{Instruction, Opcode, Program, Runtime},
        utils::{self, tests::KECCAK_PERMUTE_ELF},
    };

    pub fn keccak_permute_program() -> Program {
        let digest_ptr = 100;
        let mut instructions = vec![Instruction::new(Opcode::ADD, 29, 0, 1, false, true)];
        for i in 0..(25 * 8) {
            instructions.extend(vec![
                Instruction::new(Opcode::ADD, 30, 0, digest_ptr + i * 4, false, true),
                Instruction::new(Opcode::SW, 29, 30, 0, false, true),
            ]);
        }
        instructions.extend(vec![
            Instruction::new(
                Opcode::ADD,
                5,
                0,
                SyscallCode::KECCAK_PERMUTE as u32,
                false,
                true,
            ),
            Instruction::new(Opcode::ADD, 10, 0, digest_ptr, false, true),
            Instruction::new(Opcode::ECALL, 5, 10, 11, false, false),
        ]);

        Program::new(instructions, 0, 0)
    }

    #[test]
    pub fn test_keccak_permute_program_execute() {
        utils::setup_logger();
        let program = keccak_permute_program();
        let mut runtime = Runtime::new(program, SP1CoreOpts::default());
        runtime.run().unwrap();
    }

    #[test]
    fn test_keccak_permute_prove_babybear() {
        utils::setup_logger();

        let program = keccak_permute_program();
        run_test::<CpuProver<_, _>>(program).unwrap();
    }

    #[test]
    fn test_keccak_permute_program_prove() {
        utils::setup_logger();
        let program = Program::from(KECCAK_PERMUTE_ELF);
        run_test::<CpuProver<_, _>>(program).unwrap();
    }
}