Struct storage_proofs_porep::stacked::StackedDrg

pub struct StackedDrg<'a, Tree: MerkleTreeTrait, G: Hasher> { /* private fields */ }

Implementations

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

pub fn generate_labels_for_encoding(
    graph: &StackedBucketGraph<Tree::Hasher>,
    layer_challenges: &LayerChallenges,
    replica_id: &<Tree::Hasher as Hasher>::Domain,
    config: StoreConfig
) -> Result<(Labels<Tree>, Vec<LayerState>)>

Generates the layers as needed for encoding.

pub fn generate_labels_for_decoding(
    graph: &StackedBucketGraph<Tree::Hasher>,
    layer_challenges: &LayerChallenges,
    replica_id: &<Tree::Hasher as Hasher>::Domain,
    config: StoreConfig
) -> Result<LabelsCache<Tree>>

Generates the layers, as needed for decoding.

pub fn build_binary_tree<K: Hasher>(
    tree_data: &[u8],
    config: StoreConfig
) -> Result<BinaryMerkleTree<K>>

pub fn use_gpu_column_builder() -> bool

pub fn use_gpu_tree_builder() -> bool

pub fn generate_tree_r_last<TreeArity>(
    data: &mut Data<'_>,
    nodes_count: usize,
    tree_count: usize,
    tree_r_last_config: StoreConfig,
    replica_path: PathBuf,
    source: &DiskStore<<Tree::Hasher as Hasher>::Domain>,
    callback: Option<fn(source: &DiskStore<<Tree::Hasher as Hasher>::Domain>, data: Option<&mut Data<'_>>, start: usize, end: usize) -> Result<TreeRElementData<Tree>>>
) -> Result<LCTree<Tree::Hasher, Tree::Arity, Tree::SubTreeArity, Tree::TopTreeArity>> where
    TreeArity: PoseidonArity, 

pub fn replicate_phase1(
    pp: &'a PublicParams<Tree>,
    replica_id: &<Tree::Hasher as Hasher>::Domain,
    config: StoreConfig
) -> Result<Labels<Tree>>

Phase1 of replication.

pub fn replicate_phase2(
    pp: &'a PublicParams<Tree>,
    label_configs: Labels<Tree>,
    data: Data<'a>,
    data_tree: BinaryMerkleTree<G>,
    config: StoreConfig,
    replica_path: PathBuf
) -> Result<(<Self as PoRep<'a, Tree::Hasher, G>>::Tau, <Self as PoRep<'a, Tree::Hasher, G>>::ProverAux)>

Phase2 of replication.

pub fn fake_replicate_phase2<R: AsRef<Path>, S: AsRef<Path>>(
    tree_c_root: <Tree::Hasher as Hasher>::Domain,
    replica_path: R,
    cache_path: S,
    sector_size: usize
) -> Result<(<Tree::Hasher as Hasher>::Domain, PersistentAux<<Tree::Hasher as Hasher>::Domain>)>

pub fn fake_comm_r<R: AsRef<Path>>(
    tree_c_root: <Tree::Hasher as Hasher>::Domain,
    existing_p_aux_path: R
) -> Result<(<Tree::Hasher as Hasher>::Domain, PersistentAux<<Tree::Hasher as Hasher>::Domain>)>

Trait Implementations

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_and_comm_rs: &[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 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<Scalar, 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<Scalar, 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<Scalar, Global>), Global>, Error>

Like circuit_for_test but returns values for all partitions.

impl<'a, Tree: Debug + MerkleTreeTrait, G: Debug + Hasher> Debug for StackedDrg<'a, Tree, G>

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

Formats the value using the given formatter.

impl<'a, 'c, Tree: 'static + MerkleTreeTrait, G: 'static + Hasher> PoRep<'a, <Tree as MerkleTreeTrait>::Hasher, G> for StackedDrg<'a, Tree, G>

type Tau = Tau<<Tree::Hasher as Hasher>::Domain, <G as Hasher>::Domain>

type ProverAux = (PersistentAux<<Tree::Hasher as Hasher>::Domain>, TemporaryAux<Tree, G>)

fn replicate(
    pp: &'a PublicParams<Tree>,
    replica_id: &<Tree::Hasher as Hasher>::Domain,
    data: Data<'a>,
    data_tree: Option<BinaryMerkleTree<G>>,
    config: StoreConfig,
    replica_path: PathBuf
) -> Result<(Self::Tau, Self::ProverAux)>

fn extract_all<'b>(
    pp: &'b PublicParams<Tree>,
    replica_id: &'b <Tree::Hasher as Hasher>::Domain,
    data: &'b mut [u8],
    config: Option<StoreConfig>
) -> Result<()>

fn extract(
    _pp: &PublicParams<Tree>,
    _replica_id: &<Tree::Hasher as Hasher>::Domain,
    _data: &mut [u8],
    _node: usize,
    _config: Option<StoreConfig>
) -> Result<()>

impl<'a, 'c, Tree: 'static + MerkleTreeTrait, G: 'static + Hasher> ProofScheme<'a> for StackedDrg<'c, Tree, G>

type PublicParams = PublicParams<Tree>

type SetupParams = SetupParams

type PublicInputs = PublicInputs<<Tree::Hasher as Hasher>::Domain, <G as Hasher>::Domain>

type PrivateInputs = PrivateInputs<Tree, G>

type Proof = Vec<Proof<Tree, G>>

type Requirements = ChallengeRequirements

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 prove_all_partitions<'b>(
    pub_params: &'b Self::PublicParams,
    pub_inputs: &'b Self::PublicInputs,
    priv_inputs: &'b Self::PrivateInputs,
    partition_count: usize
) -> Result<Vec<Self::Proof>>

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

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

fn satisfies_requirements(
    public_params: &PublicParams<Tree>,
    requirements: &ChallengeRequirements,
    partitions: usize
) -> bool

fn verify(
    _pub_params: &Self::PublicParams,
    _pub_inputs: &Self::PublicInputs,
    _proof: &Self::Proof
) -> Result<bool, Error>

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.