Struct storage_proofs::circuit::vdf_post::VDFPoStCircuit

pub struct VDFPoStCircuit<'a, E: JubjubEngine> {
    pub params: &'a E::Params,
    pub challenge_seed: Option<E::Fr>,
    pub vdf_key: Option<E::Fr>,
    pub vdf_ys: Vec<Option<E::Fr>>,
    pub vdf_xs: Vec<Option<E::Fr>>,
    pub vdf_sloth_rounds: usize,
    pub challenges_vec: Vec<Vec<Option<usize>>>,
    pub challenged_sectors_vec: Vec<Vec<Option<usize>>>,
    pub challenged_leafs_vec: Vec<Vec<Option<E::Fr>>>,
    pub commitments_vec: Vec<Vec<Option<E::Fr>>>,
    pub root_commitment: Option<E::Fr>,
    pub paths_vec: Vec<Vec<Vec<Option<(E::Fr, bool)>>>>,
}

This is the VDF-PoSt circuit.

Fields

params: &'a E::Params

Paramters for the engine.

challenge_seed: Option<E::Fr>

vdf_key: Option<E::Fr>

vdf_ys: Vec<Option<E::Fr>>

vdf_xs: Vec<Option<E::Fr>>

vdf_sloth_rounds: usize

challenges_vec: Vec<Vec<Option<usize>>>

challenged_sectors_vec: Vec<Vec<Option<usize>>>

challenged_leafs_vec: Vec<Vec<Option<E::Fr>>>

commitments_vec: Vec<Vec<Option<E::Fr>>>

root_commitment: Option<E::Fr>

paths_vec: Vec<Vec<Vec<Option<(E::Fr, bool)>>>>

Methods

impl<'a, E: JubjubEngine> VDFPoStCircuit<'a, E>

pub fn synthesize<CS: ConstraintSystem<E>>(
    cs: &mut CS,
    params: &E::Params,
    challenge_seed: Option<E::Fr>,
    vdf_key: Option<E::Fr>,
    vdf_ys: Vec<Option<E::Fr>>,
    vdf_xs: Vec<Option<E::Fr>>,
    vdf_sloth_rounds: usize,
    challenges_vec: Vec<Vec<Option<usize>>>,
    challenged_sectors_vec: Vec<Vec<Option<usize>>>,
    challenged_leafs_vec: Vec<Vec<Option<E::Fr>>>,
    root_commitment: Option<E::Fr>,
    commitments_vec: Vec<Vec<Option<E::Fr>>>,
    paths_vec: Vec<Vec<Vec<Option<(E::Fr, bool)>>>>
) -> Result<(), SynthesisError>

Trait Implementations

impl<'a, E: JubjubEngine> CircuitComponent for VDFPoStCircuit<'a, E>

type ComponentPrivateInputs = ComponentPrivateInputs

impl<'a, H, V> CompoundProof<'a, Bls12, VDFPoSt<H, V>, VDFPoStCircuit<'a, Bls12>> for VDFPostCompound where
    H: 'static + Hasher,
    V: Vdf<H::Domain>,
    <V as Vdf<H::Domain>>::PublicParams: Send + Sync,
    <V as Vdf<H::Domain>>::Proof: Send + Sync,
    V: Sync + Send, 

fn generate_public_inputs(
    pub_in: &<VDFPoSt<H, V> as ProofScheme<'a>>::PublicInputs,
    _pub_params: &<VDFPoSt<H, V> as ProofScheme<'a>>::PublicParams,
    _partition_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(
    pub_in: &<VDFPoSt<H, V> as ProofScheme<'a>>::PublicInputs,
    _component_private_inputs: <VDFPoStCircuit<'a, Bls12> as CircuitComponent>::ComponentPrivateInputs,
    vanilla_proof: &<VDFPoSt<H, V> as ProofScheme<'a>>::Proof,
    pub_params: &<VDFPoSt<H, V> as ProofScheme<'a>>::PublicParams,
    engine_params: &'a <Bls12 as JubjubEngine>::Params
) -> VDFPoStCircuit<'a, Bls12>

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(
    pub_params: &<VDFPoSt<H, V> as ProofScheme>::PublicParams,
    engine_params: &'a <Bls12 as JubjubEngine>::Params
) -> VDFPoStCircuit<'a, Bls12>

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: Debug + JubjubEngine> Debug for VDFPoStCircuit<'a, E> where
    E::Params: Debug,
    E::Fr: Debug,
    E::Fr: Debug,
    E::Fr: Debug,
    E::Fr: Debug,
    E::Fr: Debug,
    E::Fr: Debug,
    E::Fr: Debug,
    E::Fr: Debug, 

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

Formats the value using the given formatter.

impl<'a, E: JubjubEngine> Circuit<E> for VDFPoStCircuit<'a, E>

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

Synthesize the circuit into a rank-1 quadratic constraint system