Struct storage_proofs::zigzag_drgporep::ZigZagDrgPoRep

pub struct ZigZagDrgPoRep<'a, H: 'a + Hasher> { /* fields omitted */ }

ZigZagDrgPorep is a layered PoRep which replicates layer by layer. Between layers, the graph is 'reversed' in such a way that the dependencies expand with each iteration. This reversal is not a straightforward inversion -- so we coin the term 'zigzag' to describe the transformation. Each graph can be divided into base and expansion components. The 'base' component is an ordinary DRG. The expansion component attempts to add a target (expansion_degree) number of connections between nodes in a reversible way. Expansion connections are therefore simply inverted at each layer. Because of how DRG-sampled parents are calculated on demand, the base components are not. Instead, a same-degree DRG with connections in the opposite direction (and using the same random seed) is used when calculating parents on demand. For the algorithm to have the desired properties, it is important that the expansion components are directly inverted at each layer. However, it is fortunately not necessary that the base DRG components also have this property.

Trait Implementations

impl<'a, H: 'static + Hasher> CompoundProof<'a, Bls12, ZigZagDrgPoRep<'a, H>, ZigZagCircuit<'a, Bls12, H>> for ZigZagCompound

fn generate_public_inputs(
    pub_in: &<ZigZagDrgPoRep<H> as ProofScheme>::PublicInputs,
    pub_params: &<ZigZagDrgPoRep<H> as ProofScheme>::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 <ZigZagDrgPoRep<H> as ProofScheme>::PublicInputs,
    _component_private_inputs: <ZigZagCircuit<'a, Bls12, H> as CircuitComponent>::ComponentPrivateInputs,
    vanilla_proof: &'b <ZigZagDrgPoRep<H> as ProofScheme>::Proof,
    public_params: &'b <ZigZagDrgPoRep<H> as ProofScheme>::PublicParams,
    engine_params: &'a <Bls12 as JubjubEngine>::Params
) -> ZigZagCircuit<'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: &<ZigZagDrgPoRep<H> as ProofScheme>::PublicParams,
    params: &'a <Bls12 as JubjubEngine>::Params
) -> ZigZagCircuit<'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: 'static + Hasher> Layers for ZigZagDrgPoRep<'a, H>

type Hasher = <ZigZagBucketGraph<H> as ZigZag>::BaseHasher

type Graph = ZigZagBucketGraph<Self::Hasher>

fn transform(graph: &Self::Graph) -> Self::Graph

Transform a layer's public parameters, returning new public parameters corresponding to the next layer. Warning: This method will likely need to be extended for other implementations but because it is not clear what parameters they will need, only the ones needed for zizag are currently present (same applies to [invert_transform]).

fn invert_transform(graph: &Self::Graph) -> Self::Graph

Transform a layer's public parameters, returning new public parameters corresponding to the previous layer.

fn prove_layers<'a>(
    graph: &Self::Graph,
    sloth_iter: usize,
    pub_inputs: &PublicInputs<<Self::Hasher as Hasher>::Domain>,
    tau: &[Tau<<Self::Hasher as Hasher>::Domain>],
    aux: &'a [MerkleTree<<Self::Hasher as Hasher>::Domain, <Self::Hasher as Hasher>::Function>],
    layer_challenges: &LayerChallenges,
    layers: usize,
    total_layers: usize,
    partition_count: usize
) -> Result<Vec<Vec<EncodingProof<Self::Hasher>>>>

fn extract_and_invert_transform_layers<'a>(
    graph: &Self::Graph,
    sloth_iter: usize,
    layer_challenges: &LayerChallenges,
    replica_id: &<Self::Hasher as Hasher>::Domain,
    data: &'a mut [u8]
) -> Result<()>

fn transform_and_replicate_layers(
    graph: &Self::Graph,
    sloth_iter: usize,
    layer_challenges: &LayerChallenges,
    replica_id: &<Self::Hasher as Hasher>::Domain,
    data: &mut [u8]
) -> Result<(Vec<Tau<<Self::Hasher as Hasher>::Domain>>, Vec<MerkleTree<<Self::Hasher as Hasher>::Domain, <Self::Hasher as Hasher>::Function>>)>

fn generate_data_tree(
    graph: &Self::Graph,
    data: &[u8],
    _layer: usize
) -> MerkleTree<<Self::Hasher as Hasher>::Domain, <Self::Hasher as Hasher>::Function>

impl<'a, H: Debug + 'a + Hasher> Debug for ZigZagDrgPoRep<'a, H>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.