Struct storage_proofs_post::rational::RationalPoStCompound

pub struct RationalPoStCompound<Tree> where
    Tree: MerkleTreeTrait,  { /* fields omitted */ }

Trait Implementations

impl<C: Circuit<Bls12>, P: ParameterSetMetadata, Tree: MerkleTreeTrait> CacheableParameters<C, P> for RationalPoStCompound<Tree>

fn cache_prefix() -> String

pub fn cache_meta(pub_params: &P) -> CacheEntryMetadata

pub fn cache_identifier(pub_params: &P) -> String

pub fn get_param_metadata(
    _circuit: C,
    pub_params: &P
) -> Result<CacheEntryMetadata, Error>

pub fn get_groth_params<R>(
    rng: Option<&mut R>,
    circuit: C,
    pub_params: &P
) -> Result<MappedParameters<Bls12>, Error> where
    R: RngCore, 

If the rng option argument is set, parameters will be generated using it. This is used for testing only, or where parameters are otherwise unavailable (e.g. benches). If rng is not set, an error will result if parameters are not present.

pub fn get_verifying_key<R>(
    rng: Option<&mut R>,
    circuit: C,
    pub_params: &P
) -> Result<VerifyingKey<Bls12>, Error> where
    R: RngCore, 

If the rng option argument is set, parameters will be generated using it. This is used for testing only, or where parameters are otherwise unavailable (e.g. benches). If rng is not set, an error will result if parameters are not present.

impl<'a, Tree: 'static + MerkleTreeTrait> CompoundProof<'a, RationalPoSt<'a, Tree>, RationalPoStCircuit<Tree>> for RationalPoStCompound<Tree> where
    Tree: 'static + MerkleTreeTrait, 

fn generate_public_inputs(
    pub_in: &<RationalPoSt<'a, Tree> as ProofScheme<'a>>::PublicInputs,
    pub_params: &<RationalPoSt<'a, Tree> as ProofScheme<'a>>::PublicParams,
    _partition_k: Option<usize>
) -> Result<Vec<Fr>>

generate_public_inputs generates public inputs suitable for use as input during verification of a proof generated from this CompoundProof’s bellperson::Circuit (C). These inputs correspond to those allocated when C is synthesized.

fn circuit(
    pub_in: &<RationalPoSt<'a, Tree> as ProofScheme<'a>>::PublicInputs,
    _priv_in: <RationalPoStCircuit<Tree> as CircuitComponent>::ComponentPrivateInputs,
    vanilla_proof: &<RationalPoSt<'a, Tree> as ProofScheme<'a>>::Proof,
    _pub_params: &<RationalPoSt<'a, Tree> as ProofScheme<'a>>::PublicParams,
    _partition_k: Option<usize>
) -> Result<RationalPoStCircuit<Tree>>

circuit constructs an instance of this CompoundProof’s bellperson::Circuit. circuit takes PublicInputs, PublicParams, and Proof from this CompoundProof’s proof::ProofScheme (S) and uses them to initialize Circuit fields which will be used to construct public and private inputs during circuit synthesis.

fn blank_circuit(
    pub_params: &<RationalPoSt<'a, Tree> as ProofScheme<'a>>::PublicParams
) -> RationalPoStCircuit<Tree>

pub fn setup(sp: &SetupParams<'a, S>) -> Result<PublicParams<'a, S>, Error>

pub fn partition_count(public_params: &PublicParams<'a, S>) -> usize

pub fn prove(
    pub_params: &PublicParams<'a, S>,
    pub_in: &<S as ProofScheme<'a>>::PublicInputs,
    priv_in: &<S as ProofScheme<'a>>::PrivateInputs,
    groth_params: &'b MappedParameters<Bls12>
) -> Result<MultiProof<'b>, Error>

prove is equivalent to ProofScheme::prove.

pub fn prove_with_vanilla(
    pub_params: &PublicParams<'a, S>,
    pub_in: &<S as ProofScheme<'a>>::PublicInputs,
    vanilla_proofs: Vec<<S as ProofScheme<'a>>::Proof, Global>,
    groth_params: &'b MappedParameters<Bls12>
) -> Result<MultiProof<'b>, Error>

pub fn verify(
    public_params: &PublicParams<'a, S>,
    public_inputs: &<S as ProofScheme<'a>>::PublicInputs,
    multi_proof: &MultiProof<'b>,
    requirements: &<S as ProofScheme<'a>>::Requirements
) -> Result<bool, Error>

pub fn batch_verify(
    public_params: &PublicParams<'a, S>,
    public_inputs: &[<S as ProofScheme<'a>>::PublicInputs],
    multi_proofs: &[MultiProof<'b>],
    requirements: &<S as ProofScheme<'a>>::Requirements
) -> Result<bool, Error>

Efficiently verify multiple proofs.

pub fn circuit_proofs(
    pub_in: &<S as ProofScheme<'a>>::PublicInputs,
    vanilla_proofs: Vec<<S as ProofScheme<'a>>::Proof, Global>,
    pub_params: &<S as ProofScheme<'a>>::PublicParams,
    groth_params: &MappedParameters<Bls12>,
    priority: bool
) -> Result<Vec<Proof<Bls12>, Global>, Error>

circuit_proof creates and synthesizes a circuit from concrete params/inputs, then generates a groth proof from it. It returns a groth proof. circuit_proof is used internally and should neither be called nor implemented outside of default trait methods.

pub fn groth_params<R>(
    rng: Option<&mut R>,
    public_params: &<S as ProofScheme<'a>>::PublicParams
) -> Result<MappedParameters<Bls12>, Error> where
    R: RngCore, 

If the rng option argument is set, parameters will be generated using it. This is used for testing only, or where parameters are otherwise unavailable (e.g. benches). If rng is not set, an error will result if parameters are not present.

pub fn verifying_key<R>(
    rng: Option<&mut R>,
    public_params: &<S as ProofScheme<'a>>::PublicParams
) -> Result<VerifyingKey<Bls12>, Error> where
    R: RngCore, 

If the rng option argument is set, parameters will be generated using it. This is used for testing only, or where parameters are otherwise unavailable (e.g. benches). If rng is not set, an error will result if parameters are not present.

pub fn circuit_for_test(
    public_parameters: &PublicParams<'a, S>,
    public_inputs: &<S as ProofScheme<'a>>::PublicInputs,
    private_inputs: &<S as ProofScheme<'a>>::PrivateInputs
) -> Result<(C, Vec<Fr, Global>), Error>

pub fn circuit_for_test_all(
    public_parameters: &PublicParams<'a, S>,
    public_inputs: &<S as ProofScheme<'a>>::PublicInputs,
    private_inputs: &<S as ProofScheme<'a>>::PrivateInputs
) -> Result<Vec<(C, Vec<Fr, Global>), Global>, Error>

Like circuit_for_test but returns values for all partitions.