sp1-prover 6.1.0

The SP1 prover implementation
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

use std::sync::Arc;

use sp1_core_executor::{ExecutionReport, Program, SP1Context, SP1CoreOpts};
use sp1_core_machine::io::SP1Stdin;

use sp1_hypercube::SP1VerifyingKey;
use sp1_primitives::io::SP1PublicValues;
use sp1_verifier::SP1Proof;
use tracing::instrument;

use crate::{
    verify::{SP1Verifier, VerifierRecursionVks},
    worker::{execute_with_options, SP1ExecutorConfig},
    SP1CoreProofData,
};

struct SP1NodeCoreInner {
    verifier: SP1Verifier,
    opts: SP1CoreOpts,
}

pub struct SP1NodeCore {
    inner: Arc<SP1NodeCoreInner>,
}

impl Clone for SP1NodeCore {
    fn clone(&self) -> Self {
        Self { inner: self.inner.clone() }
    }
}

impl SP1NodeCore {
    pub fn new(verifier: SP1Verifier, opts: SP1CoreOpts) -> Self {
        Self { inner: Arc::new(SP1NodeCoreInner { verifier, opts }) }
    }

    #[instrument(name = "execute_program", skip_all)]
    pub async fn execute(
        &self,
        elf: &[u8],
        stdin: SP1Stdin,
        context: SP1Context<'static>,
    ) -> anyhow::Result<(SP1PublicValues, [u8; 32], ExecutionReport)> {
        let program = Program::from(elf)
            .map_err(|e| anyhow::anyhow!("failed to dissassemble program: {}", e))?;
        let program = Arc::new(program);
        let (public_values, public_value_digest, report) = execute_with_options(
            program,
            stdin,
            context,
            self.inner.opts.clone(),
            SP1ExecutorConfig::default(),
        )
        .await?;
        Ok((public_values, public_value_digest, report))
    }

    pub fn verify(&self, vk: &SP1VerifyingKey, proof: &SP1Proof) -> anyhow::Result<()> {
        // Verify the underlying proof.
        match proof {
            SP1Proof::Core(proof) => {
                let core_proof = SP1CoreProofData(proof.clone());
                self.inner.verifier.verify(&core_proof, vk)?;
            }
            SP1Proof::Compressed(proof) => {
                self.inner.verifier.verify_compressed(proof, vk)?;
            }
            SP1Proof::Plonk(proof) => {
                self.inner.verifier.verify_plonk_bn254(proof, vk)?;
            }
            SP1Proof::Groth16(proof) => {
                self.inner.verifier.verify_groth16_bn254(proof, vk)?;
            }
        }

        Ok(())
    }

    pub fn recursion_vks(&self) -> VerifierRecursionVks {
        self.inner.verifier.recursion_vks.clone()
    }

    pub fn vk_verification(&self) -> bool {
        self.inner.verifier.vk_verification()
    }

    pub fn allowed_vk_height(&self) -> usize {
        let num_shapes = self.inner.verifier.recursion_vks.num_keys();
        num_shapes.next_power_of_two().ilog2() as usize
    }

    #[cfg(test)]
    pub(crate) fn wrap_vk(
        &self,
    ) -> &sp1_hypercube::MachineVerifyingKey<sp1_primitives::SP1OuterGlobalContext> {
        &self.inner.verifier.wrap_vk
    }
}