Struct poly_commitment::kzg::PairingSRS

pub struct PairingSRS<Pair: Pairing> {
    pub full_srs: SRS<Pair::G1Affine>,
    pub verifier_srs: SRS<Pair::G2Affine>,
}

Define a structured reference string (i.e. SRS) for the KZG protocol. The SRS consists of powers of an element g^x for some toxic waste x.

The SRS is formed using what we call a “trusted setup”. For now, the setup is created using the method create_trusted_setup.

Fields

full_srs: SRS<Pair::G1Affine>

The full SRS is the one used by the prover. Can be seen as the “proving key”/“secret key”

verifier_srs: SRS<Pair::G2Affine>

SRS to be used by the verifier. Can be seen as the “verification key”/“public key”.

Implementations

impl<F: PrimeField, G: CommitmentCurve<ScalarField = F>, G2: CommitmentCurve<ScalarField = F>, Pair: Pairing<G1Affine = G, G2Affine = G2>> PairingSRS<Pair>

pub fn create_trusted_setup(toxic_waste: F, depth: usize) -> Self

Create a trusted setup for the KZG protocol. The setup is created using a toxic waste toxic_waste and a depth depth.

Trait Implementations

impl<Pair: Pairing> Clone for PairingSRS<Pair>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Pair: Debug + Pairing> Debug for PairingSRS<Pair>where Pair::G1Affine: Debug, Pair::G2Affine: Debug,

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

Formats the value using the given formatter.

impl<Pair: Pairing> Default for PairingSRS<Pair>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, Pair: Pairing> Deserialize<'de> for PairingSRS<Pair>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Pair: PartialEq + Pairing> PartialEq<PairingSRS<Pair>> for PairingSRS<Pair>where Pair::G1Affine: PartialEq, Pair::G2Affine: PartialEq,

fn eq(&self, other: &PairingSRS<Pair>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F: PrimeField, G: CommitmentCurve<ScalarField = F>, G2: CommitmentCurve<ScalarField = F>, Pair: Pairing<G1Affine = G, G2Affine = G2>> SRS<G> for PairingSRS<Pair>

fn max_poly_size(&self) -> usize

The maximum polynomial degree that can be committed to

fn get_lagrange_basis(&self, domain: D<G::ScalarField>) -> &Vec<PolyComm<G>>

Compute commitments to the lagrange basis corresponding to the given domain and cache them in the SRS

fn get_lagrange_basis_from_domain_size( &self, domain_size: usize ) -> &Vec<PolyComm<G>>

Same as get_lagrange_basis but only using the domain size.

fn blinding_commitment(&self) -> G

Get the group element used for blinding commitments

fn mask_custom( &self, com: PolyComm<G>, blinders: &PolyComm<G::ScalarField> ) -> Result<BlindedCommitment<G>, CommitmentError>

Same as SRS::mask except that you can pass the blinders manually. A BlindedCommitment object is returned instead of a PolyComm object to keep the blinding factors and the commitment together. The blinded commitment is saved in the commitment field of the output. The output is wrapped into a Result to handle the case the blinders are not the same length than the number of chunks commitments have.

fn mask( &self, comm: PolyComm<G>, rng: &mut impl RngCore + CryptoRng ) -> BlindedCommitment<G>

Turns a non-hiding polynomial commitment into a hidding polynomial commitment. Transforms each given <a, G> into (<a, G> + wH, w) with a random w per commitment. A BlindedCommitment object is returned instead of a PolyComm object to keep the blinding factors and the commitment together. The blinded commitment is saved in the commitment field of the output.

fn commit( &self, plnm: &DensePolynomial<F>, num_chunks: usize, rng: &mut impl RngCore + CryptoRng ) -> BlindedCommitment<G>

Commits a polynomial, potentially splitting the result in multiple commitments. It is analogous to SRS::commit_evaluations but for polynomials. A BlindedCommitment object is returned instead of a PolyComm object to keep the blinding factors and the commitment together. The blinded commitment is saved in the commitment field of the output.

fn commit_non_hiding( &self, plnm: &DensePolynomial<G::ScalarField>, num_chunks: usize ) -> PolyComm<G>

This function commits a polynomial using the SRS’ basis of size n.

fn commit_custom( &self, plnm: &DensePolynomial<G::ScalarField>, num_chunks: usize, blinders: &PolyComm<G::ScalarField> ) -> Result<BlindedCommitment<G>, CommitmentError>

Commit to a polynomial, with custom blinding factors. It is a combination of SRS::commit and SRS::mask_custom. It is analogous to SRS::commit_evaluations_custom but for polynomials. A BlindedCommitment object is returned instead of a PolyComm object to keep the blinding factors and the commitment together. The blinded commitment is saved in the commitment field of the output. The output is wrapped into a Result to handle the case the blinders are not the same length than the number of chunks commitments have.

fn commit_evaluations_non_hiding( &self, domain: D<G::ScalarField>, plnm: &Evaluations<G::ScalarField, D<G::ScalarField>> ) -> PolyComm<G>

Commit to evaluations, without blinding factors. It is analogous to SRS::commit_non_hiding but for evaluations.

fn commit_evaluations( &self, domain: D<G::ScalarField>, plnm: &Evaluations<G::ScalarField, D<G::ScalarField>>, rng: &mut impl RngCore + CryptoRng ) -> BlindedCommitment<G>

Commit to evaluations with blinding factors, generated using the random number generator rng. It is analogous to SRS::commit but for evaluations. A BlindedCommitment object is returned instead of a PolyComm object to keep the blinding factors and the commitment together. The blinded commitment is saved in the commitment field of the output.

fn commit_evaluations_custom( &self, domain: D<G::ScalarField>, plnm: &Evaluations<G::ScalarField, D<G::ScalarField>>, blinders: &PolyComm<G::ScalarField> ) -> Result<BlindedCommitment<G>, CommitmentError>

Commit to evaluations with custom blinding factors. It is a combination of SRS::commit_evaluations and SRS::mask_custom. It is analogous to SRS::commit_custom but for evaluations. A BlindedCommitment object is returned instead of a PolyComm object to keep the blinding factors and the commitment together. The blinded commitment is saved in the commitment field of the output. The output is wrapped into a Result to handle the case the blinders are not the same length than the number of chunks commitments have.

fn create(depth: usize) -> Self

Create an SRS of size depth.

fn size(&self) -> usize

impl<Pair: Pairing> Serialize for PairingSRS<Pair>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Pair: Pairing> StructuralPartialEq for PairingSRS<Pair>