Struct storage_proofs::circuit::por::PoRCircuit

pub struct PoRCircuit<'a, E: JubjubEngine, H: Hasher> { /* fields omitted */ }

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.

Methods

impl<'a, E: JubjubEngine, H: Hasher> PoRCircuit<'a, E, H>

pub fn synthesize<CS>(
    cs: CS,
    params: &E::Params,
    value: Option<E::Fr>,
    auth_path: Vec<Option<(E::Fr, bool)>>,
    root: Root<E>,
    private: bool
) -> Result<(), SynthesisError> where
    E: JubjubEngine,
    CS: ConstraintSystem<E>, 

Trait Implementations

impl<'a, E: JubjubEngine, H: Hasher> CircuitComponent for PoRCircuit<'a, E, H>

type ComponentPrivateInputs = Option<Root<E>>

impl<'a, H> CompoundProof<'a, Bls12, MerklePoR<H>, PoRCircuit<'a, Bls12, H>> for PoRCompound<H> where
    H: 'a + Hasher, 

fn circuit<'b>(
    public_inputs: &<MerklePoR<H> as ProofScheme<'a>>::PublicInputs,
    _component_private_inputs: <PoRCircuit<'a, Bls12, H> as CircuitComponent>::ComponentPrivateInputs,
    proof: &'b <MerklePoR<H> as ProofScheme<'a>>::Proof,
    public_params: &'b <MerklePoR<H> as ProofScheme<'a>>::PublicParams,
    engine_params: &'a JubjubBls12
) -> PoRCircuit<'a, Bls12, H>

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: &<MerklePoR<H> as ProofScheme<'a>>::PublicParams,
    params: &'a JubjubBls12
) -> PoRCircuit<'a, Bls12, H>

fn generate_public_inputs(
    pub_inputs: &<MerklePoR<H> as ProofScheme<'a>>::PublicInputs,
    pub_params: &<MerklePoR<H> as ProofScheme<'a>>::PublicParams,
    _k: Option<usize>
) -> 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<'b>(sp: &SetupParams<'a, 'b, E, S>) -> Result<PublicParams<'a, E, S>> where
    E::Params: Sync, 

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

fn prove<'b>(
    pub_params: &'b PublicParams<'a, E, S>,
    pub_in: &'b S::PublicInputs,
    priv_in: &'b S::PrivateInputs,
    groth_params: &'b Parameters<E>
) -> Result<MultiProof<'b, E>> where
    E::Params: Sync, 

prove is equivalent to ProofScheme::prove.

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

fn circuit_proof<'b>(
    pub_in: &S::PublicInputs,
    vanilla_proof: &S::Proof,
    pub_params: &'b S::PublicParams,
    params: &'a E::Params,
    groth_params: &Parameters<E>
) -> Result<Proof<E>>

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 groth_params(
    public_params: &S::PublicParams,
    engine_params: &'a E::Params
) -> Result<Parameters<E>>

fn verifying_key(
    public_params: &S::PublicParams,
    engine_params: &'a E::Params
) -> Result<VerifyingKey<E>>

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

impl<'a, E: JubjubEngine, H: Hasher> Circuit<E> for PoRCircuit<'a, E, H>

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

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.