Struct storage_proofs_porep::stacked::StackedCircuit

pub struct StackedCircuit<'a, Tree: 'static + MerkleTreeTrait, G: 'static + Hasher> { /* fields omitted */ }

Stacked DRG based Proof of Replication.

Fields

• params - parameters for the curve

Implementations

impl<'a, Tree: 'static + MerkleTreeTrait, G: 'static + Hasher> StackedCircuit<'a, Tree, G>

pub fn synthesize<CS>(
    cs: CS,
    public_params: <StackedDrg<'a, Tree, G> as ProofScheme<'a>>::PublicParams,
    replica_id: Option<<Tree::Hasher as Hasher>::Domain>,
    comm_d: Option<G::Domain>,
    comm_r: Option<<Tree::Hasher as Hasher>::Domain>,
    comm_r_last: Option<<Tree::Hasher as Hasher>::Domain>,
    comm_c: Option<<Tree::Hasher as Hasher>::Domain>,
    proofs: Vec<Proof<Tree, G>>
) -> Result<(), SynthesisError> where
    CS: ConstraintSystem<Bls12>, 

Trait Implementations

impl<'a, Tree: MerkleTreeTrait, G: Hasher> Circuit<Bls12> for StackedCircuit<'a, Tree, G>

fn synthesize<CS: ConstraintSystem<Bls12>>(
    self,
    cs: &mut CS
) -> Result<(), SynthesisError>

Synthesize the circuit into a rank-1 quadratic constraint system.

impl<'a, Tree: MerkleTreeTrait, G: Hasher> CircuitComponent for StackedCircuit<'a, Tree, G>

type ComponentPrivateInputs = ()

impl<'a, Tree: MerkleTreeTrait, G: Hasher> Clone for StackedCircuit<'a, Tree, G>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, Tree: 'static + MerkleTreeTrait, G: 'static + Hasher> CompoundProof<'a, StackedDrg<'a, Tree, G>, StackedCircuit<'a, Tree, G>> for StackedCompound<Tree, G>

fn generate_public_inputs(
    pub_in: &<StackedDrg<'_, Tree, G> as ProofScheme<'_>>::PublicInputs,
    pub_params: &<StackedDrg<'_, Tree, G> as ProofScheme<'_>>::PublicParams,
    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<'b>(
    public_inputs: &'b <StackedDrg<'_, Tree, G> as ProofScheme<'_>>::PublicInputs,
    _component_private_inputs: <StackedCircuit<'a, Tree, G> as CircuitComponent>::ComponentPrivateInputs,
    vanilla_proof: &'b <StackedDrg<'_, Tree, G> as ProofScheme<'_>>::Proof,
    public_params: &'b <StackedDrg<'_, Tree, G> as ProofScheme<'_>>::PublicParams,
    _partition_k: Option<usize>
) -> Result<StackedCircuit<'a, Tree, G>>

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(
    public_params: &<StackedDrg<'_, Tree, G> as ProofScheme<'_>>::PublicParams
) -> StackedCircuit<'a, Tree, G>

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

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

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.

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>

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>

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.

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.

fn aggregate_proofs(
    prover_srs: &ProverSRS<Bls12>,
    hashed_seeds: &[u8],
    proofs: &[Proof<Bls12>]
) -> Result<AggregateProof<Bls12>, Error>

Given a prover_srs key, a list of groth16 proofs, and an ordered list of seeds (used to derive the PoRep challenges) hashed using FIXME, aggregate them all into an AggregateProof type.

fn verify_aggregate_proofs(
    ip_verifier_srs: &VerifierSRS<Bls12>,
    pvk: &PreparedVerifyingKey<Bls12>,
    hashed_seeds: &[u8],
    public_inputs: &[Vec<Fr, Global>],
    aggregate_proof: &AggregateProof<Bls12>
) -> Result<bool, Error>

Verifies the aggregate proof, with respect to the flattened input list.

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.

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.

fn srs_key<R>(
    rng: Option<&mut R>,
    public_params: &<S as ProofScheme<'a>>::PublicParams,
    num_proofs_to_aggregate: usize
) -> Result<ProverSRS<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.

fn srs_verifier_key<R>(
    rng: Option<&mut R>,
    public_params: &<S as ProofScheme<'a>>::PublicParams,
    num_proofs_to_aggregate: usize
) -> Result<VerifierSRS<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.

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>

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.