Struct VerifyingKey 

pub struct VerifyingKey<E: Pairing> {
    pub alpha_g1: E::G1Affine,
    pub beta_g2: E::G2Affine,
    pub gamma_g2: E::G2Affine,
    pub delta_g2: E::G2Affine,
    pub gamma_abc_g1: Vec<E::G1Affine>,
}

A verification key in the Groth16 SNARK.

Fields

alpha_g1: E::G1Affine

The alpha * G, where G is the generator of E::G1.

beta_g2: E::G2Affine

The alpha * H, where H is the generator of E::G2.

gamma_g2: E::G2Affine

The gamma * H, where H is the generator of E::G2.

delta_g2: E::G2Affine

The delta * H, where H is the generator of E::G2.

gamma_abc_g1: Vec<E::G1Affine>

The gamma^{-1} * (beta * a_i + alpha * b_i + c_i) * H, where H is the generator of E::G1.

Trait Implementations

impl<E> Absorb for VerifyingKey<E>

where E: Pairing, E::G1Affine: Absorb, E::G2Affine: Absorb,

fn to_sponge_bytes(&self, dest: &mut Vec<u8>)

Converts the object into a list of bytes that can be absorbed by a CryptographicSponge. Append the list to dest.

fn to_sponge_field_elements<F: PrimeField>(&self, dest: &mut Vec<F>)

Converts the object into field elements that can be absorbed by a CryptographicSponge. Append the list to dest

fn to_sponge_bytes_as_vec(&self) -> Vec<u8>

Converts the object into a list of bytes that can be absorbed by a CryptographicSponge. Return the list as Vec.

fn to_sponge_field_elements_as_vec<F>(&self) -> Vec<F>

where F: PrimeField,

Converts the object into field elements that can be absorbed by a CryptographicSponge. Return the list as Vec

fn batch_to_sponge_bytes(batch: &[Self], dest: &mut Vec<u8>)

where Self: Sized,

Specifies the conversion into a list of bytes for a batch. Append the list to dest.

fn batch_to_sponge_bytes_as_vec(batch: &[Self]) -> Vec<u8>

where Self: Sized,

Specifies the conversion into a list of bytes for a batch. Return the list as Vec.

fn batch_to_sponge_field_elements<F>(batch: &[Self], dest: &mut Vec<F>)

where F: PrimeField, Self: Sized,

Specifies the conversion into a list of field elements for a batch. Append the list to dest.

fn batch_to_sponge_field_elements_as_vec<F>(batch: &[Self]) -> Vec<F>

where F: PrimeField, Self: Sized,

Specifies the conversion into a list of field elements for a batch. Return the list as Vec.

impl<E: Pairing> CanonicalDeserialize for VerifyingKey<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 VerifyingKey<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: Clone + Pairing> Clone for VerifyingKey<E>

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<E: Pairing> From<PreparedVerifyingKey<E>> for VerifyingKey<E>

fn from(other: PreparedVerifyingKey<E>) -> Self

Converts to this type from the input type.

impl<E: Pairing> From<VerifyingKey<E>> for PreparedVerifyingKey<E>

fn from(other: VerifyingKey<E>) -> Self

Converts to this type from the input type.

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

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

fn eq(&self, other: &VerifyingKey<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> Valid for VerifyingKey<E>

const TRIVIAL_CHECK: bool

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 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.

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.

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