Struct KZG

pub struct KZG { /* private fields */ }

Main interesting struct of the rust-kzg-bn254 crate. [Kzg] is a struct that holds the SRS points in monomial form, and provides methods for committing to a blob, (either via a Blob itself, or a PolynomialCoeffForm or PolynomialEvalForm), and generating and verifying proofs.

The Blob and PolynomialCoeffForm/PolynomialEvalForm structs are mostly https://en.wikipedia.org/wiki/Passive_data_structure with constructor and few helper methods.

Implementations

impl KZG

pub fn new() -> Self

pub fn calculate_and_store_roots_of_unity( &mut self, length_of_data_after_padding: u64, ) -> Result<(), KzgError>

Calculates the roots of unities and assigns it to the struct

Arguments

• length_of_data_after_padding - Length of the blob data after padding in bytes.

Returns

• Result<(), KzgError>

Details

• Generates roots of unity needed for FFT operations

Example

use rust_kzg_bn254_prover::kzg::KZG;
use rust_kzg_bn254_primitives::blob::Blob;
use ark_std::One;
use ark_bn254::Fr;

let mut kzg = KZG::new();
let input_blob = Blob::from_raw_data(b"test blob data");
kzg.calculate_and_store_roots_of_unity(input_blob.len().try_into().unwrap()).unwrap();

pub fn get_roots_of_unities(&self) -> Vec<Fr>

pub fn get_nth_root_of_unity(&self, i: usize) -> Option<&Fr>

helper function to get the

pub fn commit_eval_form( &self, polynomial: &PolynomialEvalForm, srs: &SRS, ) -> Result<G1Affine, KzgError>

Commit the polynomial with the srs values loaded into [Kzg].

pub fn commit_coeff_form( &self, polynomial: &PolynomialCoeffForm, srs: &SRS, ) -> Result<G1Affine, KzgError>

Commit the polynomial with the srs values loaded into [Kzg].

pub fn commit_blob(&self, blob: &Blob, srs: &SRS) -> Result<G1Affine, KzgError>

commit to a Blob, by transforming it into a PolynomialEvalForm and then calling [Kzg::commit_eval_form].

pub fn compute_proof_with_known_z_fr_index( &self, polynomial: &PolynomialEvalForm, index: u64, srs: &SRS, ) -> Result<G1Affine, KzgError>

pub fn compute_proof( &self, polynomial: &PolynomialEvalForm, z_fr: &Fr, srs: &SRS, ) -> Result<G1Affine, KzgError>

Compute a kzg proof from a polynomial in evaluation form. We don’t currently support proofs for polynomials in coefficient form, but one can take the FFT of the polynomial in coefficient form to get the polynomial in evaluation form. This is available via the method PolynomialCoeffForm::to_eval_form. TODO(anupsv): Accept bytes instead of Fr element. Ref: https://github.com/Layr-Labs/rust-kzg-bn254/issues/29

pub fn compute_quotient_eval_on_domain( &self, z_fr: &Fr, eval_fr: &[Fr], value_fr: &Fr, ) -> Fr

refer to DA for more context

pub fn g1_ifft( &self, length: usize, srs: &SRS, ) -> Result<Vec<G1Affine>, KzgError>

function to compute the inverse FFT

pub fn compute_blob_proof( &self, blob: &Blob, commitment: &G1Affine, srs: &SRS, ) -> Result<G1Affine, KzgError>

TODO(anupsv): Match 4844 specs w.r.t to the inputs. Ref: https://github.com/Layr-Labs/rust-kzg-bn254/issues/30

Trait Implementations

impl Clone for KZG

fn clone(&self) -> KZG

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for KZG

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

Formats the value using the given formatter.

impl Default for KZG

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for KZG

fn eq(&self, other: &KZG) -> 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 StructuralPartialEq for KZG