Struct snarkvm_algorithms::polycommit::sonic_pc::CommitterKey

pub struct CommitterKey<E: PairingEngine> {
    pub powers_of_beta_g: Vec<E::G1Affine>,
    pub lagrange_bases_at_beta_g: BTreeMap<usize, Vec<E::G1Affine>>,
    pub powers_of_beta_times_gamma_g: Vec<E::G1Affine>,
    pub shifted_powers_of_beta_g: Option<Vec<E::G1Affine>>,
    pub shifted_powers_of_beta_times_gamma_g: Option<BTreeMap<usize, Vec<E::G1Affine>>>,
    pub enforced_degree_bounds: Option<Vec<usize>>,
}

CommitterKey is used to commit to, and create evaluation proofs for, a given polynomial.

Fields

powers_of_beta_g: Vec<E::G1Affine>

The key used to commit to polynomials.

lagrange_bases_at_beta_g: BTreeMap<usize, Vec<E::G1Affine>>

The key used to commit to polynomials in Lagrange basis.

powers_of_beta_times_gamma_g: Vec<E::G1Affine>

The key used to commit to hiding polynomials.

shifted_powers_of_beta_g: Option<Vec<E::G1Affine>>

The powers used to commit to shifted polynomials. This is None if self does not support enforcing any degree bounds.

shifted_powers_of_beta_times_gamma_g: Option<BTreeMap<usize, Vec<E::G1Affine>>>

The powers used to commit to shifted hiding polynomials. This is None if self does not support enforcing any degree bounds.

enforced_degree_bounds: Option<Vec<usize>>

The degree bounds that are supported by self. Sorted in ascending order from smallest bound to largest bound. This is None if self does not support enforcing any degree bounds.

Trait Implementations

impl<E: PairingEngine> CanonicalDeserialize for CommitterKey<E>

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

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: PairingEngine> CanonicalSerialize for CommitterKey<E>

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

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 + PairingEngine> Clone for CommitterKey<E>where E::G1Affine: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug + PairingEngine> Debug for CommitterKey<E>where E::G1Affine: Debug,

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

Formats the value using the given formatter.

impl<E: Default + PairingEngine> Default for CommitterKey<E>where E::G1Affine: Default,

fn default() -> CommitterKey<E>

Returns the “default value” for a type.

impl<E: PairingEngine> FromBytes for CommitterKey<E>

fn read_le<R: Read>(reader: R) -> Result<Self>

Reads Self from reader as little-endian bytes.

fn from_bytes_le(bytes: &[u8]) -> Result<Self, Error>where Self: Sized,

Returns Self from a byte array in little-endian order.

impl<E: Hash + PairingEngine> Hash for CommitterKey<E>where E::G1Affine: Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<E: PartialEq + PairingEngine> PartialEq<CommitterKey<E>> for CommitterKey<E>where E::G1Affine: PartialEq,

fn eq(&self, other: &CommitterKey<E>) -> 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<E: PairingEngine> ToBytes for CommitterKey<E>

fn write_le<W: Write>(&self, writer: W) -> Result<()>

Writes self into writer as little-endian bytes.

fn to_bytes_le(&self) -> Result<Vec<u8, Global>, Error>where Self: Sized,

Returns self as a byte array in little-endian order.

impl<E: PairingEngine> Valid for CommitterKey<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 + PairingEngine> Eq for CommitterKey<E>where E::G1Affine: Eq,

impl<E: PairingEngine> StructuralEq for CommitterKey<E>

impl<E: PairingEngine> StructuralPartialEq for CommitterKey<E>