Struct VerifierKey 

pub struct VerifierKey<E: Pairing> {
    pub g: E::G1Affine,
    pub gamma_g: E::G1Affine,
    pub h: E::G2Affine,
    pub beta_h: Vec<E::G2Affine>,
    pub prepared_h: E::G2Prepared,
    pub prepared_beta_h: Vec<E::G2Prepared>,
    pub num_vars: usize,
    pub supported_degree: usize,
    pub max_degree: usize,
}

VerifierKey is used to check evaluation proofs for a given commitment.

Fields

g: E::G1Affine

The generator of G1.

gamma_g: E::G1Affine

The generator of G1 that is used for making a commitment hiding.

h: E::G2Affine

The generator of G2.

beta_h: Vec<E::G2Affine>

\beta_i times the above generator of G2 where i ranges from 0 to num_vars-1

prepared_h: E::G2Prepared

The generator of G2, prepared for use in pairings.

prepared_beta_h: Vec<E::G2Prepared>

\beta_i times the above generator of G2 where i ranges from 0 to num_vars-1, prepared for use in pairings

num_vars: usize

The number of variables self is initialized for

supported_degree: usize

The maximum degree supported by the trimmed parameters that self is a part of.

max_degree: usize

The maximum degree supported by the UniversalParams self was derived from.

Trait Implementations

impl<E: Pairing> CanonicalDeserialize for VerifierKey<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,

Reads Self from reader using the compressed form if applicable. Performs validation if applicable.

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

where R: Read,

Reads Self from reader using the compressed form if applicable, without validating the deserialized value.

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

where R: Read,

Reads Self from reader using the uncompressed form. Performs validation if applicable.

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

where R: Read,

Reads Self from reader using the uncompressed form, without validating the deserialized value.

impl<E: Pairing> CanonicalSerialize for VerifierKey<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

Returns the size in bytes of the serialized version of self with the given compression mode.

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

where W: Write,

Serializes self into writer using the compressed form if applicable.

fn compressed_size(&self) -> usize

Returns the size in bytes of the compressed serialized version of self.

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

where W: Write,

Serializes self into writer using the uncompressed form.

fn uncompressed_size(&self) -> usize

Returns the size in bytes of the uncompressed serialized version of self.

impl<E: Pairing> Clone for VerifierKey<E>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Pairing> Debug for VerifierKey<E>

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

Formats the value using the given formatter.

impl<E: Pairing> Default for VerifierKey<E>

fn default() -> Self

Returns the “default value” for a type.

impl<E: Pairing> PCPreparedVerifierKey<VerifierKey<E>> for PreparedVerifierKey<E>

fn prepare(vk: &VerifierKey<E>) -> Self

prepare PreparedVerifierKey from VerifierKey

impl<E: Pairing> PCVerifierKey for VerifierKey<E>

fn max_degree(&self) -> usize

Outputs the maximum degree supported by the universal parameters Self was derived from.

fn supported_degree(&self) -> usize

Outputs the maximum degree supported by the verifier key.

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

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

Checks whether self is valid. If self is valid, returns Ok(()). Otherwise, returns an error describing the failure. This method is called by deserialize_with_mode if validate is Validate::Yes.

const TRIVIAL_CHECK: bool = false

Whether the check method is trivial (i.e. always returns Ok(())). If this is true, the batch_check method will skip all checks and return Ok(()). This should be set to true for types where check is trivial, e.g. integers, field elements, etc. This is false by default. This is primarily an optimization to skip unnecessary checks in batch_check.

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

where Self: 'a,

Checks whether all items in batch are valid. If all items are valid, returns Ok(()). Otherwise, returns an error describing the first failure.