Struct proof_system::proof_spec::ProofSpec

pub struct ProofSpec<E: Pairing> {
    pub statements: Statements<E>,
    pub meta_statements: MetaStatements,
    pub setup_params: Vec<SetupParams<E>>,
    pub context: Option<Vec<u8>>,
    pub aggregate_groth16: Option<Vec<BTreeSet<usize>>>,
    pub aggregate_legogroth16: Option<Vec<BTreeSet<usize>>>,
    pub snark_aggregation_srs: Option<SnarkpackSRS<E>>,
}

Describes the relations that need to proven. This is created independently by the prover and verifier and must be agreed upon and be same before creating a Proof. Represented as collection of Statements and MetaStatements. Also contains other instructions like which proofs to aggregate.

Fields

statements: Statements<E>

meta_statements: MetaStatements

setup_params: Vec<SetupParams<E>>

context: Option<Vec<u8>>

context is any arbitrary data that needs to be hashed into the proof and it must be kept same while creating and verifying the proof. Eg of context are the purpose of the proof or the verifier’s identity or some verifier-specific identity of the holder or all of the above combined.

aggregate_groth16: Option<Vec<BTreeSet<usize>>>

Statement indices for which Groth16 proof should be aggregated. Each BTreeSet represents one group of statements whose proof will be aggregated into 1 aggregate proof. The number of aggregate proofs is the length of the vector

aggregate_legogroth16: Option<Vec<BTreeSet<usize>>>

Same as aggregate_groth16 above but aggregates LegoGroth16 proof instead of Groth16.

snark_aggregation_srs: Option<SnarkpackSRS<E>>

Implementations

impl<E: Pairing> ProofSpec<E>

pub fn new( statements: Statements<E>, meta_statements: MetaStatements, setup_params: Vec<SetupParams<E>>, context: Option<Vec<u8>> ) -> Self

Create a new ProofSpec

pub fn new_with_aggregation( statements: Statements<E>, meta_statements: MetaStatements, setup_params: Vec<SetupParams<E>>, context: Option<Vec<u8>>, aggregate_groth16: Option<Vec<BTreeSet<usize>>>, aggregate_legogroth16: Option<Vec<BTreeSet<usize>>>, snark_aggregation_srs: Option<SnarkpackSRS<E>> ) -> Self

Same as Self::new but specifies which proofs should be aggregated.

pub fn add_statement(&mut self, statement: Statement<E>) -> usize

pub fn add_meta_statement(&mut self, meta_statement: MetaStatement) -> usize

pub fn validate(&self) -> Result<(), ProofSystemError>

Sanity check to ensure the proof spec is valid. This should never error as these are used by same entity creating them.

pub fn derive_commitment_keys( &self ) -> Result<(StatementDerivedParams<Vec<E::G1Affine>>, StatementDerivedParams<Vec<E::G1Affine>>, StatementDerivedParams<(Vec<E::G1Affine>, Vec<E::G1Affine>)>, StatementDerivedParams<Vec<E::G1Affine>>, StatementDerivedParams<[E::G1Affine; 2]>, StatementDerivedParams<[E::G1Affine; 2]>, StatementDerivedParams<[E::G1Affine; 2]>), ProofSystemError>

Derive commitment keys for Schnorr protocol from public params. This is done to avoid creating them if the same public params are used in multiple statements and is effectively a pre-processing step done for optimization.

pub fn derive_prepared_parameters( &self ) -> Result<(StatementDerivedParams<LegoPreparedVerifyingKey<E>>, StatementDerivedParams<PreparedEncryptionGens<E>>, StatementDerivedParams<PreparedEncryptionKey<E>>, StatementDerivedParams<SaverPreparedVerifyingKey<E>>, StatementDerivedParams<PreparedBBSPlusSigParams<E>>, StatementDerivedParams<PreparedBBSPlusPk<E>>, StatementDerivedParams<PreparedAccumParams<E>>, StatementDerivedParams<PreparedAccumPk<E>>, StatementDerivedParams<KBPreparedAccumParams<E>>, StatementDerivedParams<KBPreparedAccumPk<E>>, StatementDerivedParams<PreparedPSSigParams<E>>, StatementDerivedParams<PreparedPSPk<E>>, StatementDerivedParams<PreparedBBSSigParams23<E>>, StatementDerivedParams<SmcParamsWithPairingAndCommitmentKey<E>>), ProofSystemError>

Derive prepared keys for performing pairings. This is done to avoid preparing the same parameters again and is effectively a pre-processing step done for optimization.

Trait Implementations

impl<E: Pairing> CanonicalDeserialize for ProofSpec<E>

fn deserialize_with_mode<R: Read>( reader: R, compress: Compress, validate: Validate ) -> Result<Self, SerializationError>

The general deserialize method that takes in customization flags.

fn deserialize_compressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_compressed_unchecked<R>( reader: R ) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed_unchecked<R>( reader: R ) -> Result<Self, SerializationError>

where R: Read,

impl<E: Pairing> CanonicalSerialize for ProofSpec<E>

fn serialize_with_mode<W: Write>( &self, writer: W, compress: Compress ) -> Result<(), SerializationError>

The general serialize method that takes in customization flags.

fn serialized_size(&self, compress: Compress) -> usize

fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn compressed_size(&self) -> usize

fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn uncompressed_size(&self) -> usize

impl<E: Clone + Pairing> Clone for ProofSpec<E>

fn clone(&self) -> ProofSpec<E>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E: Debug + Pairing> Debug for ProofSpec<E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E: Pairing> Default for ProofSpec<E>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, E: Pairing> Deserialize<'de> for ProofSpec<E>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<E: PartialEq + Pairing> PartialEq for ProofSpec<E>

fn eq(&self, other: &ProofSpec<E>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<E: Pairing> Serialize for ProofSpec<E>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<E: Pairing> Valid for ProofSpec<E>

fn check(&self) -> Result<(), SerializationError>

fn batch_check<'a>( batch: impl Iterator<Item = &'a Self> + Send ) -> Result<(), SerializationError>

where Self: 'a,

impl<E: Pairing> StructuralPartialEq for ProofSpec<E>