Struct storage_proofs_core::gadgets::por::PoRCircuit

pub struct PoRCircuit<Tree: MerkleTreeTrait> { /* private fields */ }

Proof of retrievability.

Fields

• params - The params for the bls curve.
• value - The value of the leaf.
• auth_path - The authentication path of the leaf in the tree.
• root - The merkle root of the tree.

Implementations

impl<Tree: MerkleTreeTrait> PoRCircuit<Tree>

pub fn new(proof: Tree::Proof, private: bool) -> Self

pub fn synthesize<CS>( cs: CS, value: Root<Fr>, auth_path: AuthPath<Tree::Hasher, Tree::Arity, Tree::SubTreeArity, Tree::TopTreeArity>, root: Root<Fr>, private: bool, ) -> Result<(), SynthesisError>

where CS: ConstraintSystem<Fr>,

Trait Implementations

impl<Tree: MerkleTreeTrait> Circuit<Scalar> for PoRCircuit<Tree>

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

Public Inputs

This circuit expects the following public inputs.

• [0] - packed version of the is_right components of the auth_path.
• [1] - the merkle root of the tree.

This circuit derives the following private inputs from its fields:

• value_num - packed version of value as bits. (might be more than one Fr)

Note: All public inputs must be provided as E::Fr.

impl<Tree: MerkleTreeTrait> CircuitComponent for PoRCircuit<Tree>

type ComponentPrivateInputs = Option<Root<Scalar>>

impl<'a, Tree: 'static + MerkleTreeTrait> CompoundProof<'a, PoR<Tree>, PoRCircuit<Tree>> for PoRCompound<Tree>

fn circuit<'b>( public_inputs: &<PoR<Tree> as ProofScheme<'a>>::PublicInputs, _component_private_inputs: <PoRCircuit<Tree> as CircuitComponent>::ComponentPrivateInputs, proof: &'b <PoR<Tree> as ProofScheme<'a>>::Proof, public_params: &'b <PoR<Tree> as ProofScheme<'a>>::PublicParams, _partition_k: Option<usize>, ) -> Result<PoRCircuit<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( public_params: &<PoR<Tree> as ProofScheme<'a>>::PublicParams, ) -> PoRCircuit<Tree>

fn generate_public_inputs( pub_inputs: &<PoR<Tree> as ProofScheme<'a>>::PublicInputs, pub_params: &<PoR<Tree> as ProofScheme<'a>>::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 setup(sp: &SetupParams<'a, S>) -> Result<PublicParams<'a, S>>

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

fn prove( pub_params: &PublicParams<'a, S>, pub_in: &S::PublicInputs, priv_in: &S::PrivateInputs, groth_params: &Bls12GrothParams, ) -> Result<Vec<Proof<Bls12>>>

prove is equivalent to ProofScheme::prove.

fn prove_with_vanilla( pub_params: &PublicParams<'a, S>, pub_in: &S::PublicInputs, vanilla_proofs: Vec<S::Proof>, groth_params: &Bls12GrothParams, ) -> Result<Vec<Proof<Bls12>>>

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

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

Efficiently verify multiple proofs.

fn circuit_proofs( pub_in: &S::PublicInputs, vanilla_proofs: Vec<S::Proof>, pub_params: &S::PublicParams, groth_params: &Bls12GrothParams, priority: bool, ) -> Result<Vec<Proof<Bls12>>>

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_and_comm_rs: &[u8], proofs: &[Proof<Bls12>], version: AggregateVersion, ) -> Result<AggregateProof<Bls12>>

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

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

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

fn groth_params<R: RngCore>( rng: Option<&mut R>, public_params: &S::PublicParams, ) -> Result<Bls12GrothParams>

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: RngCore>( rng: Option<&mut R>, public_params: &S::PublicParams, ) -> Result<VerifyingKey<Bls12>>

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: RngCore>( rng: Option<&mut R>, public_params: &S::PublicParams, num_proofs_to_aggregate: usize, ) -> Result<ProverSRS<Bls12>>

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: RngCore>( rng: Option<&mut R>, public_params: &S::PublicParams, num_proofs_to_aggregate: usize, ) -> Result<VerifierSRS<Bls12>>

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::PublicInputs, private_inputs: &S::PrivateInputs, ) -> Result<(C, Vec<Fr>)>

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

Like circuit_for_test but returns values for all partitions.