Struct snarkvm_algorithms::polycommit::kzg10::UniversalParams

pub struct UniversalParams<E: PairingEngine> {
    pub powers: Arc<RwLock<PowersOfG<E>>>,
    pub h: E::G2Affine,
    pub beta_h: E::G2Affine,
    pub supported_degree_bounds: Vec<usize>,
    pub inverse_neg_powers_of_beta_h: BTreeMap<usize, E::G2Affine>,
    pub prepared_h: <E::G2Affine as PairingCurve>::Prepared,
    pub prepared_beta_h: <E::G2Affine as PairingCurve>::Prepared,
}

UniversalParams are the universal parameters for the KZG10 scheme.

Fields

powers: Arc<RwLock<PowersOfG<E>>>

Group elements of the form { \beta^i G }, where i ranges from 0 to degree, and group elements of the form { \beta^i \gamma G }, where i ranges from 0 to degree. This struct provides an abstraction over the powers which are located on-disk to reduce memory usage.

h: E::G2Affine

The generator of G2.

beta_h: E::G2Affine

\beta times the above generator of G2.

supported_degree_bounds: Vec<usize>

Supported degree bounds.

inverse_neg_powers_of_beta_h: BTreeMap<usize, E::G2Affine>

Group elements of the form { \beta^{max_degree -i} G2 }, where i is the supported degree bound. This one is used for deriving the verifying key.

prepared_h: <E::G2Affine as PairingCurve>::Prepared

The generator of G2, prepared for use in pairings.

prepared_beta_h: <E::G2Affine as PairingCurve>::Prepared

\beta times the above generator of G2, prepared for use in pairings.

Implementations

impl<E: PairingEngine> UniversalParams<E>

pub fn lagrange_basis(
    &self,
    domain: EvaluationDomain<E::Fr>
) -> Result<Vec<E::G1Affine>>

pub fn power_of_beta_g(&self, which_power: usize) -> Result<E::G1Affine>

pub fn powers_of_beta_g(
    &self,
    lower: usize,
    upper: usize
) -> Result<Vec<E::G1Affine>>

pub fn get_powers_times_gamma_g(&self) -> BTreeMap<usize, E::G1Affine>

pub fn download_up_to(&self, degree: usize) -> Result<()>

impl<E: PairingEngine> UniversalParams<E>

pub fn max_degree(&self) -> usize

pub fn supported_degree_bounds(&self) -> &[usize]

pub fn increase_degree(&self, degree: usize) -> Result<()>

Trait Implementations

impl<E: PairingEngine> CanonicalDeserialize for UniversalParams<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 UniversalParams<E>

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

fn serialized_size(&self, mode: 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 UniversalParams<E> where
    E::G2Affine: Clone,
    E::G2Affine: Clone,
    E::G2Affine: Clone,
    E::G2Affine: Clone,
    E::G2Affine: Clone, 

fn clone(&self) -> UniversalParams<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 UniversalParams<E> where
    E::G2Affine: Debug,
    E::G2Affine: Debug,
    E::G2Affine: Debug,
    E::G2Affine: Debug,
    E::G2Affine: Debug, 

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

Formats the value using the given formatter.

impl<E: PairingEngine> FromBytes for UniversalParams<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>

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

impl<E: PairingEngine> ToBytes for UniversalParams<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>

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

impl<E: PairingEngine> Valid for UniversalParams<E>

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

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