sp1-sdk 6.0.0-beta.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

use std::{
    future::{Future, IntoFuture},
    pin::Pin,
};

use super::{EnvProver, EnvProvingKey};
use crate::{prover::BaseProveRequest, ProveRequest, Prover, SP1ProofWithPublicValues};
use anyhow::Result;

/// A prover request for the [`EnvProver`].
pub struct EnvProveRequest<'a> {
    pub(crate) base: BaseProveRequest<'a, EnvProver>,
}

impl<'a> ProveRequest<'a, EnvProver> for EnvProveRequest<'a> {
    fn base(&mut self) -> &mut BaseProveRequest<'a, EnvProver> {
        &mut self.base
    }
}

impl<'a> IntoFuture for EnvProveRequest<'a> {
    type Output = Result<SP1ProofWithPublicValues>;

    type IntoFuture = Pin<Box<dyn Future<Output = Self::Output> + Send + 'a>>;

    fn into_future(self) -> Self::IntoFuture {
        let BaseProveRequest { prover, pk, stdin, mode, context_builder } = self.base;

        match prover {
            EnvProver::Cpu(prover) => match pk {
                EnvProvingKey::Cpu { pk, .. } => {
                    let mut req = prover.prove(pk, stdin);
                    req.base.mode = mode;
                    req.base.context_builder = context_builder;

                    Box::pin(async move { Ok(req.into_future().await?) })
                }
                _ => panic!("Invalid proving key type for CPU prover"),
            },
            EnvProver::Cuda(prover) => match self.base.pk {
                EnvProvingKey::Cuda { pk, .. } => {
                    let mut req = prover.prove(pk, stdin);
                    req.base.mode = mode;
                    req.base.context_builder = context_builder;

                    Box::pin(async move { Ok(req.into_future().await?) })
                }
                _ => panic!("Invalid proving key type for CUDA prover"),
            },
            EnvProver::Mock(prover) => match self.base.pk {
                EnvProvingKey::Mock { pk, .. } => {
                    let mut req = prover.prove(pk, stdin);
                    req.base.mode = mode;
                    req.base.context_builder = context_builder;

                    Box::pin(async move { req.await })
                }
                _ => panic!("Invalid proving key type for Mock prover"),
            },
            #[cfg(feature = "network")]
            EnvProver::Network(prover) => match self.base.pk {
                EnvProvingKey::Network { pk, .. } => {
                    let mut req = prover.prove(pk, stdin);
                    req.base.mode = mode;
                    req.base.context_builder = context_builder;

                    req.into_future()
                }
                _ => panic!("Invalid proving key type for Network prover"),
            },
        }
    }
}