Struct VerifyingKey

pub struct VerifyingKey<E: Pairing> {
    pub domain_size: usize,
    pub num_inputs: usize,
    pub sigma_comms: Vec<Commitment<E>>,
    pub selector_comms: Vec<Commitment<E>>,
    pub k: Vec<E::ScalarField>,
    pub open_key: OpenKey<E>,
    pub is_merged: bool,
    pub plookup_vk: Option<PlookupVerifyingKey<E>>,
}

Preprocessed verifier parameters used to verify Plonk proofs for a certain circuit.

Fields

domain_size: usize

The size of the evaluation domain. Should be a power of two.

num_inputs: usize

The number of public inputs.

sigma_comms: Vec<Commitment<E>>

The permutation polynomial commitments. The commitments are not hiding.

selector_comms: Vec<Commitment<E>>

The selector polynomial commitments. The commitments are not hiding.

k: Vec<E::ScalarField>

The constants K0, …, K_num_wire_types that ensure wire subsets are disjoint.

open_key: OpenKey<E>

KZG PCS opening key.

is_merged: bool

A flag indicating whether the key is a merged key.

plookup_vk: Option<PlookupVerifyingKey<E>>

Plookup verifying key, None if not support lookup.

Implementations

impl<E, F, P> VerifyingKey<E>

where E: Pairing<BaseField = F, G1Affine = Affine<P>>, F: SWToTEConParam, P: SWCurveConfig<BaseField = F>,

pub fn convert_te_coordinates_to_scalars(&self) -> Vec<F>

Convert the group elements to a list of scalars that represent the Twisted Edwards coordinates.

impl<E: Pairing> VerifyingKey<E>

pub fn dummy(num_inputs: usize, domain_size: usize) -> Self

Create a dummy TurboPlonk verification key for a circuit with num_inputs public inputs and domain size domain_size.

Trait Implementations

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,

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

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 VerifyingKey<E>

where E::ScalarField: Clone,

fn clone(&self) -> VerifyingKey<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 VerifyingKey<E>

where E::ScalarField: Debug,

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

Formats the value using the given formatter.

impl<E, F, P1, P2> From<VerifyingKey<E>> for Vec<E::BaseField>

where E: Pairing<G1Affine = Affine<P1>, G2Affine = Affine<P2>, TargetField = Fp2<F>>, F: Fp2Config<Fp = E::BaseField>, P1: SWCurveConfig<BaseField = E::BaseField, ScalarField = E::ScalarField>, P2: SWCurveConfig<BaseField = E::TargetField, ScalarField = E::ScalarField>,

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

Converts to this type from the input type.

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

where E::ScalarField: 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>

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 VerifyingKey<E>

where E::ScalarField: Eq,

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