Struct UnivariateUniversalParams

pub struct UnivariateUniversalParams<E: Pairing> {
    pub powers_of_g: Vec<E::G1Affine>,
    pub h: E::G2Affine,
    pub beta_h: E::G2Affine,
    pub powers_of_h: Vec<E::G2Affine>,
}

UniversalParams are the universal parameters for the KZG10 scheme.

Fields

powers_of_g: Vec<E::G1Affine>

Group elements of the form { \beta^i G }, where i ranges from 0 to degree.

h: E::G2Affine

TODO: remove h and beta_h The generator of G2.

beta_h: E::G2Affine

\beta times the above generator of G2.

powers_of_h: Vec<E::G2Affine>

powers of \beta time the generator h of G2

Implementations

impl<E: Pairing> UnivariateUniversalParams<E>

pub fn max_degree(&self) -> usize

Returns the maximum supported degree

Trait Implementations

impl<E: Pairing> CanonicalDeserialize for UnivariateUniversalParams<E>

fn deserialize_with_mode<R: Read>( reader: R, compress: Compress, validate: Validate, ) -> Result<Self, SerializationError>

The general deserialize method that takes in customization flags.

fn deserialize_compressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_compressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

impl<E: Pairing> CanonicalSerialize for UnivariateUniversalParams<E>

fn serialize_with_mode<W: Write>( &self, writer: W, compress: Compress, ) -> Result<(), SerializationError>

The general serialize method that takes in customization flags.

fn serialized_size(&self, compress: Compress) -> usize

fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn compressed_size(&self) -> usize

fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn uncompressed_size(&self) -> usize

impl<E: Clone + Pairing> Clone for UnivariateUniversalParams<E>

where E::G1Affine: Clone, E::G2Affine: Clone,

fn clone(&self) -> UnivariateUniversalParams<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug + Pairing> Debug for UnivariateUniversalParams<E>

where E::G1Affine: Debug, E::G2Affine: Debug,

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

Formats the value using the given formatter.

impl<E: Default + Pairing> Default for UnivariateUniversalParams<E>

where E::G1Affine: Default, E::G2Affine: Default,

fn default() -> UnivariateUniversalParams<E>

Returns the “default value” for a type.

impl<E: PartialEq + Pairing> PartialEq for UnivariateUniversalParams<E>

where E::G1Affine: PartialEq, E::G2Affine: PartialEq,

fn eq(&self, other: &UnivariateUniversalParams<E>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<E: Pairing> StructuredReferenceString for UnivariateUniversalParams<E>

fn extract_prover_param(&self, supported_degree: usize) -> Self::ProverParam

Extract the prover parameters from the public parameters.

fn extract_verifier_param(&self, supported_degree: usize) -> Self::VerifierParam

Extract the verifier parameters from the public parameters.

fn trim_with_verifier_degree( &self, prover_supported_degree: usize, verifier_supported_degree: usize, ) -> Result<(Self::ProverParam, Self::VerifierParam), PCSError>

Trim the universal parameters to specialize the public parameters for univariate polynomials to the given supported_degree, and returns committer key and verifier key. supported_degree should be in range 1..params.len()

fn trim( &self, supported_degree: usize, ) -> Result<(Self::ProverParam, Self::VerifierParam), PCSError>

Trim the universal parameters to specialize the public parameters for univariate polynomials to the given supported_degree, and returns committer key and verifier key. supported_degree should be in range 1..params.len()

type ProverParam = UnivariateProverParam<E>

Prover parameters

type VerifierParam = UnivariateVerifierParam<E>

Verifier parameters

fn load_srs_from_file( _supported_degree: usize, _file: Option<&str>, ) -> Result<Self, PCSError>

Load public parameter in production environment. These parameters are loaded from files with serialized pp bytes, and the actual setup is usually carried out via MPC and should be implemented else where. We only load them into memory here.

impl<E: Pairing> Valid for UnivariateUniversalParams<E>

fn check(&self) -> Result<(), SerializationError>

fn batch_check<'a>( batch: impl Iterator<Item = &'a Self> + Send, ) -> Result<(), SerializationError>

where Self: 'a,

impl<E: Eq + Pairing> Eq for UnivariateUniversalParams<E>

where E::G1Affine: Eq, E::G2Affine: Eq,

impl<E: Pairing> StructuralPartialEq for UnivariateUniversalParams<E>