Struct storage_proofs::drgporep::DrgPoRep

pub struct DrgPoRep<'a, H, G> where
    H: 'a + Hasher,
    G: 'a + Graph<H>,  { /* fields omitted */ }

Trait Implementations

impl<'a, H, G> CompoundProof<'a, Bls12, DrgPoRep<'a, H, G>, DrgPoRepCircuit<'a, Bls12, H>> for DrgPoRepCompound<H, G> where
    H: 'a + Hasher,
    G: 'a + Graph<H> + ParameterSetMetadata + Sync + Send, 

fn generate_public_inputs(
    pub_in: &<DrgPoRep<'a, H, G> as ProofScheme<'a>>::PublicInputs,
    pub_params: &<DrgPoRep<'a, H, G> 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 circuit<'b>(
    public_inputs: &'b <DrgPoRep<'a, H, G> as ProofScheme<'a>>::PublicInputs,
    component_private_inputs: <DrgPoRepCircuit<'a, Bls12, H> as CircuitComponent>::ComponentPrivateInputs,
    proof: &'b <DrgPoRep<'a, H, G> as ProofScheme<'a>>::Proof,
    public_params: &'b <DrgPoRep<'a, H, G> as ProofScheme<'a>>::PublicParams,
    engine_params: &'a <Bls12 as JubjubEngine>::Params
) -> DrgPoRepCircuit<'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: &<DrgPoRep<'a, H, G> as ProofScheme<'a>>::PublicParams,
    params: &'a <Bls12 as JubjubEngine>::Params
) -> DrgPoRepCircuit<'a, Bls12, H>

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, H, G> PoRep<'a, H> for DrgPoRep<'a, H, G> where
    H: 'a + Hasher,
    G: 'a + Graph<H> + ParameterSetMetadata + Sync + Send, 

type Tau = Tau<H::Domain>

type ProverAux = ProverAux<H>

fn replicate(
    pp: &Self::PublicParams,
    replica_id: &H::Domain,
    data: &mut [u8],
    data_tree: Option<MerkleTree<H::Domain, H::Function>>
) -> Result<(Tau<H::Domain>, ProverAux<H>)>

fn extract_all<'b>(
    pp: &'b Self::PublicParams,
    replica_id: &'b H::Domain,
    data: &'b [u8]
) -> Result<Vec<u8>>

fn extract(
    pp: &Self::PublicParams,
    replica_id: &H::Domain,
    data: &[u8],
    node: usize
) -> Result<Vec<u8>>

impl<'a, H, G> ProofScheme<'a> for DrgPoRep<'a, H, G> where
    H: 'a + Hasher,
    G: 'a + Graph<H> + ParameterSetMetadata, 

type PublicParams = PublicParams<H, G>

type SetupParams = SetupParams

type PublicInputs = PublicInputs<H::Domain>

type PrivateInputs = PrivateInputs<'a, H>

type Proof = Proof<H>

type Requirements = NoRequirements

fn setup(sp: &Self::SetupParams) -> Result<Self::PublicParams>

setup is used to generate public parameters from setup parameters in order to specialize a ProofScheme to the specific parameters required by a consumer.

fn prove<'b>(
    pub_params: &'b Self::PublicParams,
    pub_inputs: &'b Self::PublicInputs,
    priv_inputs: &'b Self::PrivateInputs
) -> Result<Self::Proof>

prove generates and returns a proof from public parameters, public inputs, and private inputs.

fn verify(
    pub_params: &Self::PublicParams,
    pub_inputs: &Self::PublicInputs,
    proof: &Self::Proof
) -> Result<bool>

verify returns true if the supplied proof is valid for the given public parameter and public inputs. Note that verify does not have access to private inputs. Remember that proof is untrusted, and any data it provides MUST be validated as corresponding to the supplied public parameters and inputs.

fn prove_all_partitions<'b>(
    pub_params: &'b Self::PublicParams,
    pub_in: &'b Self::PublicInputs,
    priv_in: &'b Self::PrivateInputs,
    partition_count: usize
) -> Result<Vec<Self::Proof>>

fn verify_all_partitions(
    pub_params: &Self::PublicParams,
    pub_in: &Self::PublicInputs,
    proofs: &[Self::Proof]
) -> Result<bool>

fn with_partition(
    pub_in: Self::PublicInputs,
    _k: Option<usize>
) -> Self::PublicInputs

fn satisfies_requirements(
    _pub_params: &Self::PublicParams,
    _requirements: &Self::Requirements,
    _partitions: usize
) -> bool

impl<'a, H: Default, G: Default> Default for DrgPoRep<'a, H, G> where
    H: 'a + Hasher,
    G: 'a + Graph<H>, 

fn default() -> DrgPoRep<'a, H, G>

Returns the "default value" for a type.