repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 7 values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks4/benches/eip_4844.rs | arkworks4/benches/eip_4844.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg::eip_4844::{
blob_to_kzg_commitment_rust, bytes_to_blob, compute_blob_kzg_proof_rust,
compute_kzg_proof_rust, verify_blob_kzg_proof_batch_rust, verify_blob_kzg_proof_rust,
verify_kzg_proof_rust,
};
use kzg_bench::benches::eip_4844::bench_eip_4844;
use rust_kzg_arkworks4::eip_4844::load_trusted_setup_filename_rust;
use rust_kzg_arkworks4::kzg_proofs::{FFTSettings, KZGSettings};
use rust_kzg_arkworks4::kzg_types::{ArkFp, ArkFr, ArkG1, ArkG1Affine, ArkG1ProjAddAffine, ArkG2};
use rust_kzg_arkworks4::utils::PolyData;
fn bench_eip_4844_(c: &mut Criterion) {
bench_eip_4844::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
c,
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_kzg_proof_rust,
&verify_kzg_proof_rust,
&compute_blob_kzg_proof_rust,
&verify_blob_kzg_proof_rust,
&verify_blob_kzg_proof_batch_rust,
);
}
criterion_group!(benches, bench_eip_4844_,);
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks4/benches/eip_7594.rs | arkworks4/benches/eip_7594.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg::eip_4844::{blob_to_kzg_commitment_rust, bytes_to_blob};
use kzg_bench::benches::eip_7594::bench_eip_7594;
use rust_kzg_arkworks4::{eip_4844::load_trusted_setup_filename_rust, eip_7594::ArkBackend};
fn bench_eip_7594_(c: &mut Criterion) {
bench_eip_7594::<ArkBackend>(
c,
&load_trusted_setup_filename_rust,
&bytes_to_blob,
&blob_to_kzg_commitment_rust,
);
}
criterion_group!(benches, bench_eip_7594_);
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks4/benches/poly.rs | arkworks4/benches/poly.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::poly::bench_new_poly_div;
use rust_kzg_arkworks4::kzg_types::ArkFr;
use rust_kzg_arkworks4::utils::PolyData;
fn bench_new_poly_div_(c: &mut Criterion) {
bench_new_poly_div::<ArkFr, PolyData>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_new_poly_div_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks4/benches/zero_poly.rs | arkworks4/benches/zero_poly.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::zero_poly::bench_zero_poly;
use rust_kzg_arkworks4::kzg_proofs::FFTSettings;
use rust_kzg_arkworks4::kzg_types::ArkFr;
use rust_kzg_arkworks4::utils::PolyData;
fn bench_zero_poly_(c: &mut Criterion) {
bench_zero_poly::<ArkFr, FFTSettings, PolyData>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_zero_poly_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks4/benches/kzg.rs | arkworks4/benches/kzg.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::kzg::{bench_commit_to_poly, bench_compute_proof_single};
use rust_kzg_arkworks4::eip_7594::ArkBackend;
use rust_kzg_arkworks4::kzg_proofs::generate_trusted_setup;
fn bench_commit_to_poly_(c: &mut Criterion) {
bench_commit_to_poly::<ArkBackend>(c, &generate_trusted_setup);
}
fn bench_compute_proof_single_(c: &mut Criterion) {
bench_compute_proof_single::<ArkBackend>(c, &generate_trusted_setup);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_commit_to_poly_, bench_compute_proof_single_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks4/benches/lincomb.rs | arkworks4/benches/lincomb.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::lincomb::bench_g1_lincomb;
use rust_kzg_arkworks4::fft_g1::g1_linear_combination;
use rust_kzg_arkworks4::kzg_types::{ArkFp, ArkFr, ArkG1, ArkG1Affine, ArkG1ProjAddAffine};
fn bench_g1_lincomb_(c: &mut Criterion) {
bench_g1_lincomb::<ArkFr, ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine>(
c,
&g1_linear_combination,
);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_g1_lincomb_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks4/benches/fk_20.rs | arkworks4/benches/fk_20.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::fk20::{bench_fk_multi_da, bench_fk_single_da};
use rust_kzg_arkworks4::eip_7594::ArkBackend;
use rust_kzg_arkworks4::fk20_proofs::{KzgFK20MultiSettings, KzgFK20SingleSettings};
use rust_kzg_arkworks4::kzg_proofs::generate_trusted_setup;
fn bench_fk_single_da_(c: &mut Criterion) {
bench_fk_single_da::<ArkBackend, KzgFK20SingleSettings>(c, &generate_trusted_setup)
}
fn bench_fk_multi_da_(c: &mut Criterion) {
bench_fk_multi_da::<ArkBackend, KzgFK20MultiSettings>(c, &generate_trusted_setup)
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_fk_single_da_, bench_fk_multi_da_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks4/benches/recover.rs | arkworks4/benches/recover.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::recover::bench_recover;
use rust_kzg_arkworks4::kzg_proofs::FFTSettings;
use rust_kzg_arkworks4::kzg_types::ArkFr;
use rust_kzg_arkworks4::utils::PolyData;
fn bench_recover_(c: &mut Criterion) {
bench_recover::<ArkFr, FFTSettings, PolyData, PolyData>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_recover_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks4/benches/fft.rs | arkworks4/benches/fft.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::fft::{bench_fft_fr, bench_fft_g1};
use rust_kzg_arkworks4::kzg_proofs::FFTSettings;
use rust_kzg_arkworks4::kzg_types::{ArkFr, ArkG1};
fn bench_fft_fr_(c: &mut Criterion) {
bench_fft_fr::<ArkFr, FFTSettings>(c);
}
fn bench_fft_g1_(c: &mut Criterion) {
bench_fft_g1::<ArkFr, ArkG1, FFTSettings>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_fft_fr_, bench_fft_g1_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/build.rs | ckzg/build.rs | use std::process::Command;
use std::{env, fs};
fn main() {
let cargo_manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
let out_dir = env::var("OUT_DIR").unwrap();
fs::copy(
format!("{cargo_manifest_dir}/c.patch"),
format!("{out_dir}/c.patch"),
)
.unwrap();
if !Command::new("sh")
.arg(format!("{}/build.sh", cargo_manifest_dir))
.current_dir(out_dir.clone())
.status()
.expect("Failed to build")
.success()
{
panic!("Built script failed");
}
println!("cargo:rustc-link-search={}/lib", out_dir);
println!("cargo:rustc-link-lib=static=ckzg");
println!("cargo:rustc-link-lib=static=blst");
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/src/consts.rs | ckzg/src/consts.rs | use crate::finite::BlstFr;
use kzg::Fr;
#[repr(u8)]
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum KzgRet {
KzgOk = 0,
KzgBadArgs = 1,
KzgError = 2,
KzgMalloc = 3,
}
// will this this one later
#[allow(non_camel_case_types)]
#[repr(u8)]
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum BLST_ERROR {
BLST_SUCCESS = 0,
BLST_BAD_ENCODING,
BLST_POINT_NOT_ON_CURVE,
BLST_POINT_NOT_IN_GROUP,
BLST_AGGR_TYPE_MISMATCH,
BLST_VERIFY_FAIL,
BLST_PK_IS_INFINITY,
BLST_BAD_SCALAR,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
pub struct BlstFp {
pub l: [u64; 6],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
pub struct BlstFp2 {
pub fp: [BlstFp; 2],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct BlstP2 {
pub x: BlstFp2,
pub y: BlstFp2,
pub z: BlstFp2,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct BlstP2Affine {
pub x: BlstFp2,
pub y: BlstFp2,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct BlstP1 {
pub x: BlstFp,
pub y: BlstFp,
pub z: BlstFp,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct BlstP1Affine {
pub x: BlstFp,
pub y: BlstFp,
}
pub const SCALE_FACTOR: u64 = 5;
pub const NUM_ROOTS: usize = 32;
/// The roots of unity. Every root_i equals 1 when raised to the power of (2 ^ i)
pub const SCALE2_ROOT_OF_UNITY: [[u64; 4]; 32] = [
[
0x0000000000000001,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
],
[
0xffffffff00000000,
0x53bda402fffe5bfe,
0x3339d80809a1d805,
0x73eda753299d7d48,
],
[
0x0001000000000000,
0xec03000276030000,
0x8d51ccce760304d0,
0x0000000000000000,
],
[
0x7228fd3397743f7a,
0xb38b21c28713b700,
0x8c0625cd70d77ce2,
0x345766f603fa66e7,
],
[
0x53ea61d87742bcce,
0x17beb312f20b6f76,
0xdd1c0af834cec32c,
0x20b1ce9140267af9,
],
[
0x360c60997369df4e,
0xbf6e88fb4c38fb8a,
0xb4bcd40e22f55448,
0x50e0903a157988ba,
],
[
0x8140d032f0a9ee53,
0x2d967f4be2f95155,
0x14a1e27164d8fdbd,
0x45af6345ec055e4d,
],
[
0x5130c2c1660125be,
0x98d0caac87f5713c,
0xb7c68b4d7fdd60d0,
0x6898111413588742,
],
[
0x4935bd2f817f694b,
0x0a0865a899e8deff,
0x6b368121ac0cf4ad,
0x4f9b4098e2e9f12e,
],
[
0x4541b8ff2ee0434e,
0xd697168a3a6000fe,
0x39feec240d80689f,
0x095166525526a654,
],
[
0x3c28d666a5c2d854,
0xea437f9626fc085e,
0x8f4de02c0f776af3,
0x325db5c3debf77a1,
],
[
0x4a838b5d59cd79e5,
0x55ea6811be9c622d,
0x09f1ca610a08f166,
0x6d031f1b5c49c834,
],
[
0xe206da11a5d36306,
0x0ad1347b378fbf96,
0xfc3e8acfe0f8245f,
0x564c0a11a0f704f4,
],
[
0x6fdd00bfc78c8967,
0x146b58bc434906ac,
0x2ccddea2972e89ed,
0x485d512737b1da3d,
],
[
0x034d2ff22a5ad9e1,
0xae4622f6a9152435,
0xdc86b01c0d477fa6,
0x56624634b500a166,
],
[
0xfbd047e11279bb6e,
0xc8d5f51db3f32699,
0x483405417a0cbe39,
0x3291357ee558b50d,
],
[
0xd7118f85cd96b8ad,
0x67a665ae1fcadc91,
0x88f39a78f1aeb578,
0x2155379d12180caa,
],
[
0x08692405f3b70f10,
0xcd7f2bd6d0711b7d,
0x473a2eef772c33d6,
0x224262332d8acbf4,
],
[
0x6f421a7d8ef674fb,
0xbb97a3bf30ce40fd,
0x652f717ae1c34bb0,
0x2d3056a530794f01,
],
[
0x194e8c62ecb38d9d,
0xad8e16e84419c750,
0xdf625e80d0adef90,
0x520e587a724a6955,
],
[
0xfece7e0e39898d4b,
0x2f69e02d265e09d9,
0xa57a6e07cb98de4a,
0x03e1c54bcb947035,
],
[
0xcd3979122d3ea03a,
0x46b3105f04db5844,
0xc70d0874b0691d4e,
0x47c8b5817018af4f,
],
[
0xc6e7a6ffb08e3363,
0xe08fec7c86389bee,
0xf2d38f10fbb8d1bb,
0x0abe6a5e5abcaa32,
],
[
0x5616c57de0ec9eae,
0xc631ffb2585a72db,
0x5121af06a3b51e3c,
0x73560252aa0655b2,
],
[
0x92cf4deb77bd779c,
0x72cf6a8029b7d7bc,
0x6e0bcd91ee762730,
0x291cf6d68823e687,
],
[
0xce32ef844e11a51e,
0xc0ba12bb3da64ca5,
0x0454dc1edc61a1a3,
0x019fe632fd328739,
],
[
0x531a11a0d2d75182,
0x02c8118402867ddc,
0x116168bffbedc11d,
0x0a0a77a3b1980c0d,
],
[
0xe2d0a7869f0319ed,
0xb94f1101b1d7a628,
0xece8ea224f31d25d,
0x23397a9300f8f98b,
],
[
0xd7b688830a4f2089,
0x6558e9e3f6ac7b41,
0x99e276b571905a7d,
0x52dd465e2f094256,
],
[
0x474650359d8e211b,
0x84d37b826214abc6,
0x8da40c1ef2bb4598,
0x0c83ea7744bf1bee,
],
[
0x694341f608c9dd56,
0xed3a181fabb30adc,
0x1339a815da8b398f,
0x2c6d4e4511657e1e,
],
[
0x63e7cb4906ffc93f,
0xf070bb00e28a193d,
0xad1715b02e5713b5,
0x4b5371495990693f,
],
];
/// Multiply a given root of unity by itself until it results in a 1 and result all multiplication values in a vector
pub fn expand_root_of_unity(root: &BlstFr, width: usize) -> Result<Vec<BlstFr>, String> {
let mut generated_powers = vec![Fr::one(), *root];
while !(generated_powers.last().unwrap().is_one()) {
if generated_powers.len() > width {
return Err(String::from("Root of unity multiplied for too long"));
}
generated_powers.push(generated_powers.last().unwrap().mul(root));
}
Ok(generated_powers)
}
pub fn expand_root_of_unity_mcl(root: &BlstFr) -> Vec<BlstFr> {
let mut root_z = vec![Fr::one(), *root];
let mut i = 1;
while !root_z[i].is_one() {
let next = &root_z[i].mul(root);
root_z.push(*next);
i += 1;
}
root_z
}
pub const G1_NEGATIVE_GENERATOR: BlstP1 = BlstP1 {
x: BlstFp {
l: [
0x5cb38790fd530c16,
0x7817fc679976fff5,
0x154f95c7143ba1c1,
0xf0ae6acdf3d0e747,
0xedce6ecc21dbf440,
0x120177419e0bfb75,
],
},
y: BlstFp {
l: [
0xff526c2af318883a,
0x92899ce4383b0270,
0x89d7738d9fa9d055,
0x12caf35ba344c12a,
0x3cff1b76964b5317,
0x0e44d2ede9774430,
],
},
z: BlstFp {
l: [
0x760900000002fffd,
0xebf4000bc40c0002,
0x5f48985753c758ba,
0x77ce585370525745,
0x5c071a97a256ec6d,
0x15f65ec3fa80e493,
],
},
};
pub const G2_NEGATIVE_GENERATOR: BlstP2 = BlstP2 {
x: BlstFp2 {
fp: [
BlstFp {
l: [
0xf5f28fa202940a10,
0xb3f5fb2687b4961a,
0xa1a893b53e2ae580,
0x9894999d1a3caee9,
0x6f67b7631863366b,
0x058191924350bcd7,
],
},
BlstFp {
l: [
0xa5a9c0759e23f606,
0xaaa0c59dbccd60c3,
0x3bb17e18e2867806,
0x1b1ab6cc8541b367,
0xc2b6ed0ef2158547,
0x11922a097360edf3,
],
},
],
},
y: BlstFp2 {
fp: [
BlstFp {
l: [
0x6d8bf5079fb65e61,
0xc52f05df531d63a5,
0x7f4a4d344ca692c9,
0xa887959b8577c95f,
0x4347fe40525c8734,
0x197d145bbaff0bb5,
],
},
BlstFp {
l: [
0x0c3e036d209afa4e,
0x0601d8f4863f9e23,
0xe0832636bacc0a84,
0xeb2def362a476f84,
0x64044f659f0ee1e9,
0x0ed54f48d5a1caa7,
],
},
],
},
z: BlstFp2 {
fp: [
BlstFp {
l: [
0x760900000002fffd,
0xebf4000bc40c0002,
0x5f48985753c758ba,
0x77ce585370525745,
0x5c071a97a256ec6d,
0x15f65ec3fa80e493,
],
},
BlstFp {
l: [
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
],
},
],
},
};
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/src/finite.rs | ckzg/src/finite.rs | use crate::consts::{
BlstFp, BlstP1, BlstP1Affine, BlstP2, BlstP2Affine, BLST_ERROR, G1_NEGATIVE_GENERATOR,
G2_NEGATIVE_GENERATOR,
};
use kzg::{Fr, G1Mul, G2Mul, G1, G2};
use rand::{thread_rng, RngCore};
extern "C" {
// typedef uint8_t byte;
// typedef uint64_t limb_t;
// typedef struct { limb_t l[256/8/sizeof(limb_t)]; } blst_fr;
// typedef struct { limb_t l[384/8/sizeof(limb_t)]; } blst_fp;
// /* 0 is "real" part, 1 is "imaginary" */
// typedef struct { blst_fp fp[2]; } blst_fp2;
// typedef struct { blst_fp2 fp2[3]; } blst_fp6;
// typedef struct { blst_fp6 fp6[2]; } blst_fp12;
// Fr
fn fr_from_uint64(out: *mut BlstFr, n: u64);
fn fr_from_uint64s(out: *mut BlstFr, vals: *const u64);
fn fr_to_uint64s(out: *mut u64, fr: *const BlstFr);
fn fr_is_zero(p: *const BlstFr) -> bool;
fn fr_is_null(p: *const BlstFr) -> bool;
fn fr_is_one(p: *const BlstFr) -> bool;
fn fr_equal(aa: *const BlstFr, bb: *const BlstFr) -> bool;
fn fr_negate(out: *mut BlstFr, in_: *const BlstFr);
fn fr_pow(out: *mut BlstFr, a: *const BlstFr, n: u64);
fn fr_div(out: *mut BlstFr, a: *const BlstFr, b: *const BlstFr);
fn blst_fr_add(ret: *mut BlstFr, a: *const BlstFr, b: *const BlstFr);
fn blst_fr_sub(ret: *mut BlstFr, a: *const BlstFr, b: *const BlstFr);
fn blst_fr_sqr(ret: *mut BlstFr, a: *const BlstFr);
fn blst_fr_mul(ret: *mut BlstFr, a: *const BlstFr, b: *const BlstFr);
fn blst_fr_eucl_inverse(ret: *mut BlstFr, a: *const BlstFr);
fn blst_fr_inverse(retret: *mut BlstFr, a: *const BlstFr);
// G1
fn blst_p1_generator() -> *const BlstP1;
fn g1_add_or_dbl(out: *mut BlstP1, a: *const BlstP1, b: *const BlstP1);
fn g1_equal(a: *const BlstP1, b: *const BlstP1) -> bool;
fn g1_mul(out: *mut BlstP1, a: *const BlstP1, b: *const BlstFr);
fn g1_dbl(out: *mut BlstP1, a: *const BlstP1);
fn g1_add(out: *mut BlstP1, a: *const BlstP1, b: *const BlstP1);
fn g1_sub(out: *mut BlstP1, a: *const BlstP1, b: *const BlstP1);
fn g1_is_inf(a: *const BlstP1) -> bool;
pub fn blst_p1_from_affine(out: *mut BlstP1, inp: *const BlstP1Affine);
pub fn blst_p1_compress(out: *mut u8, inp: *const BlstP1);
pub fn blst_p1_uncompress(out: *mut BlstP1Affine, byte: *const u8) -> BLST_ERROR;
// G2
fn blst_p2_generator() -> *const BlstP2;
fn g2_mul(out: *mut BlstP2, a: *const BlstP2, b: *const BlstFr);
fn g2_dbl(out: *mut BlstP2, a: *const BlstP2);
fn g2_add_or_dbl(out: *mut BlstP2, a: *const BlstP2, b: *const BlstP2);
fn g2_equal(a: *const BlstP2, b: *const BlstP2) -> bool;
fn g2_sub(out: *mut BlstP2, a: *const BlstP2, b: *const BlstP2);
pub fn blst_p2_from_affine(out: *mut BlstP2, inp: *const BlstP2Affine);
pub fn blst_p2_uncompress(out: *mut BlstP2Affine, byte: *const u8) -> BLST_ERROR;
// Regular functions
pub fn g1_linear_combination(
out: *mut BlstP1,
p: *const BlstP1,
coeffs: *const BlstFr,
len: u64,
);
fn pairings_verify(
a1: *const BlstP1,
a2: *const BlstP2,
b1: *const BlstP1,
b2: *const BlstP2,
) -> bool;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
pub struct BlstFr {
pub l: [u64; 4],
}
impl Fr for BlstFr {
fn null() -> Self {
Self { l: [u64::MAX; 4] }
}
fn zero() -> Self {
Fr::from_u64(0)
}
fn one() -> Self {
Fr::from_u64(1)
}
fn rand() -> Self {
let mut ret = Self::default();
let mut rng = thread_rng();
let a: [u64; 4] = [
rng.next_u64(),
rng.next_u64(),
rng.next_u64(),
rng.next_u64(),
];
unsafe {
fr_from_uint64s(&mut ret, a.as_ptr());
}
ret
}
fn from_u64_arr(u: &[u64; 4]) -> Self {
let mut ret = Self::default();
unsafe {
fr_from_uint64s(&mut ret, u.as_ptr());
}
ret
}
fn from_u64(u: u64) -> Self {
let mut fr = Self::default();
unsafe {
fr_from_uint64(&mut fr, u);
}
fr
}
fn to_u64_arr(&self) -> [u64; 4] {
let mut arr: [u64; 4] = [0; 4];
unsafe {
fr_to_uint64s(arr.as_mut_ptr(), self);
}
arr
}
fn is_one(&self) -> bool {
unsafe { fr_is_one(self) }
}
fn is_zero(&self) -> bool {
unsafe { fr_is_zero(self) }
}
fn is_null(&self) -> bool {
unsafe { fr_is_null(self) }
}
fn sqr(&self) -> Self {
let mut ret = Self::default();
unsafe {
blst_fr_sqr(&mut ret, self);
}
ret
}
fn mul(&self, b: &Self) -> Self {
let mut ret = Self::default();
unsafe {
blst_fr_mul(&mut ret, self, b);
}
ret
}
fn add(&self, b: &Self) -> Self {
let mut sum = Self::default();
unsafe {
blst_fr_add(&mut sum, self, b);
}
sum
}
fn sub(&self, b: &Self) -> Self {
let mut ret = Self::default();
unsafe {
blst_fr_sub(&mut ret, self, b);
}
ret
}
fn eucl_inverse(&self) -> Self {
let mut ret = Self::default();
unsafe {
blst_fr_eucl_inverse(&mut ret, self);
}
ret
}
fn negate(&self) -> Self {
let mut ret = Self::default();
unsafe {
// man rodos, kad tokios nera
fr_negate(&mut ret, self);
}
ret
}
fn inverse(&self) -> Self {
let mut ret = Self::default();
unsafe {
blst_fr_inverse(&mut ret, self);
}
ret
}
fn pow(&self, n: usize) -> Self {
let mut ret = Self::default();
unsafe {
fr_pow(&mut ret, self, n as u64);
}
ret
}
fn div(&self, b: &Self) -> Result<Self, String> {
let mut ret = Self::default();
unsafe {
fr_div(&mut ret, self, b);
}
Ok(ret)
}
fn equals(&self, b: &Self) -> bool {
unsafe { fr_equal(self, b) }
}
}
impl G1 for BlstP1 {
fn identity() -> Self {
Self {
x: BlstFp { l: [0; 6] },
y: BlstFp { l: [0; 6] },
z: BlstFp { l: [0; 6] },
}
}
fn generator() -> Self {
unsafe { *blst_p1_generator() }
}
fn negative_generator() -> Self {
G1_NEGATIVE_GENERATOR
}
fn rand() -> Self {
let mut ret = BlstP1::default();
let random = Fr::rand();
unsafe {
g1_mul(&mut ret, &G1::generator(), &random);
}
ret
}
fn add_or_dbl(&mut self, b: &Self) -> Self {
let mut out = BlstP1::default();
unsafe {
g1_add_or_dbl(&mut out, b, self);
}
out
}
fn is_inf(&self) -> bool {
unsafe { g1_is_inf(self) }
}
fn dbl(&self) -> Self {
let mut ret = BlstP1::default();
unsafe {
g1_dbl(&mut ret, self);
}
ret
}
fn add(&self, b: &Self) -> Self {
let mut ret = BlstP1::default();
unsafe {
g1_add(&mut ret, self, b);
}
ret
}
fn sub(&self, b: &Self) -> Self {
let mut ret = BlstP1::default();
unsafe {
g1_sub(&mut ret, self, b);
}
ret
}
fn equals(&self, b: &Self) -> bool {
unsafe { g1_equal(self, b) }
}
}
impl G1Mul<BlstFr> for BlstP1 {
fn mul(&self, b: &BlstFr) -> Self {
let mut ret = BlstP1::default();
unsafe {
g1_mul(&mut ret, self, b);
}
ret
}
}
impl G2 for BlstP2 {
fn generator() -> Self {
unsafe { *blst_p2_generator() }
}
fn negative_generator() -> Self {
G2_NEGATIVE_GENERATOR
}
fn add_or_dbl(&mut self, b: &Self) -> Self {
let mut ret = BlstP2::default();
unsafe {
g2_add_or_dbl(&mut ret, self, b);
}
ret
}
fn dbl(&self) -> Self {
let mut ret = BlstP2::default();
unsafe {
g2_dbl(&mut ret, self);
}
ret
}
fn sub(&self, b: &Self) -> Self {
let mut ret = BlstP2::default();
unsafe {
g2_sub(&mut ret, self, b);
}
ret
}
fn equals(&self, b: &Self) -> bool {
unsafe { g2_equal(self, b) }
}
}
impl G2Mul<BlstFr> for BlstP2 {
fn mul(&self, b: &BlstFr) -> Self {
let mut ret = BlstP2::default();
unsafe {
g2_mul(&mut ret, self, b);
}
ret
}
}
pub fn linear_combination_g1(out: &mut BlstP1, p: &[BlstP1], coeffs: &[BlstFr], len: usize) {
unsafe {
g1_linear_combination(out, p.as_ptr(), coeffs.as_ptr(), len as u64);
}
}
pub fn verify_pairings(a1: &BlstP1, a2: &BlstP2, b1: &BlstP1, b2: &BlstP2) -> bool {
unsafe { pairings_verify(a1, a2, b1, b2) }
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/src/lib.rs | ckzg/src/lib.rs | pub mod consts;
pub mod eip_4844;
pub mod fftsettings;
pub mod fftsettings4844;
pub mod finite;
pub mod fk20settings;
pub mod kzgsettings;
pub mod kzgsettings4844;
pub mod poly;
#[cfg(feature = "parallel")]
const RUN_PARALLEL: bool = true;
#[cfg(not(feature = "parallel"))]
const RUN_PARALLEL: bool = false;
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/src/eip_4844.rs | ckzg/src/eip_4844.rs | use std::{convert::TryInto, fs::File};
use crate::consts::{BlstP1, KzgRet};
use crate::finite::BlstFr;
use crate::kzgsettings4844::KzgKZGSettings4844;
// use crate::utils::reverse_bit_order;
use kzg::eip_4844::{Blob, KZGCommitment, KZGProof};
use kzg::Fr;
use libc::{fdopen, FILE};
use std::ffi::CStr;
use std::os::unix::io::IntoRawFd;
extern "C" {
fn bytes_to_g1_raw(out: *mut BlstP1, bytes: *const u8);
fn bytes_from_g1_raw(out: *mut u8, g1: *const BlstP1);
fn load_trusted_setup_file(out: *mut KzgKZGSettings4844, inp: *mut FILE) -> KzgRet;
fn verify_aggregate_kzg_proof(
out: *mut bool,
blobs: *const Blob,
expected_kzg_commitments: *const KZGCommitment,
n: usize,
kzg_aggregated_proof: *const KZGProof,
s: *const KzgKZGSettings4844,
) -> KzgRet;
fn blob_to_kzg_commitment(
out: *mut KZGCommitment,
blob: *const Blob,
s: *const KzgKZGSettings4844,
);
fn compute_aggregate_kzg_proof(
out: *mut KZGProof,
blobs: *const Blob,
n: usize,
s: *const KzgKZGSettings4844,
) -> KzgRet;
}
pub fn load_trusted_setup_rust(filepath: &str) -> KzgKZGSettings4844 {
// // https://www.reddit.com/r/rust/comments/8sfjp6/converting_between_file_and_stdfsfile/
let mut v = KzgKZGSettings4844::default();
unsafe {
let rust_file = File::open(filepath).unwrap();
let c_file = fdopen(
rust_file.into_raw_fd(),
CStr::from_bytes_with_nul_unchecked(b"r\0").as_ptr(),
);
load_trusted_setup_file(&mut v, c_file);
v
}
}
pub fn vector_lincomb(vectors: &[Vec<BlstFr>], scalars: &[BlstFr]) -> Vec<BlstFr> {
let mut tmp: BlstFr;
let mut out: Vec<BlstFr> = vec![BlstFr::zero(); vectors[0].len()];
for (v, s) in vectors.iter().zip(scalars.iter()) {
for (i, x) in v.iter().enumerate() {
tmp = x.mul(s);
out[i] = out[i].add(&tmp);
}
}
out
}
pub fn bytes_from_bls_field(fr: &BlstFr) -> [u8; 32usize] {
// probably this and bytes_to_bls_field can be rewritten in blst functions
let v = &fr.to_u64_arr();
// investigate if being little endian changes something
// order of bytes might need to be reversed
let my_u8_vec_bis: Vec<u8> = unsafe { (v[..4].align_to::<u8>().1).to_vec() };
my_u8_vec_bis.try_into().unwrap()
}
pub fn blob_to_kzg_commitment_rust(blob: &[BlstFr], s: &KzgKZGSettings4844) -> BlstP1 {
let mut out = BlstP1::default();
let blob_arr: Blob = Blob {
bytes: blob
.iter()
.flat_map(bytes_from_bls_field)
.collect::<Vec<u8>>()
.try_into()
.unwrap(),
};
unsafe {
let mut kzg_commitment: KZGCommitment = KZGCommitment { bytes: [0; 48] };
blob_to_kzg_commitment(&mut kzg_commitment, &blob_arr, s);
bytes_to_g1_raw(&mut out, kzg_commitment.bytes.as_ptr());
}
out
}
pub fn compute_powers(base: &BlstFr, num_powers: usize) -> Vec<BlstFr> {
let mut powers: Vec<BlstFr> = vec![BlstFr::default(); num_powers];
powers[0] = BlstFr::one();
for i in 1..num_powers {
powers[i] = powers[i - 1].mul(base);
}
powers
}
pub fn compute_aggregate_kzg_proof_rust(blobs: &[Vec<BlstFr>], ts: &KzgKZGSettings4844) -> BlstP1 {
let mut out = BlstP1::default();
let blob_arr: Vec<Blob> = blobs
.iter()
.map(|blob| Blob {
bytes: blob
.iter()
.flat_map(bytes_from_bls_field)
.collect::<Vec<u8>>()
.try_into()
.unwrap(),
})
.collect::<Vec<Blob>>();
unsafe {
let mut kzg_proof: KZGProof = KZGProof { bytes: [0; 48] };
let ret = compute_aggregate_kzg_proof(&mut kzg_proof, blob_arr.as_ptr(), blobs.len(), ts);
assert!(ret == KzgRet::KzgOk);
bytes_to_g1_raw(&mut out, kzg_proof.bytes.as_ptr());
}
out
}
pub fn verify_aggregate_kzg_proof_rust(
blobs: &[Vec<BlstFr>],
expected_kzg_commitments: &[BlstP1],
kzg_aggregated_proof: &BlstP1,
ts: &KzgKZGSettings4844,
) -> bool {
let mut out = false;
let blob_arr: Vec<Blob> = blobs
.iter()
.map(|blob| Blob {
bytes: blob
.iter()
.flat_map(bytes_from_bls_field)
.collect::<Vec<u8>>()
.try_into()
.unwrap(),
})
.collect::<Vec<Blob>>();
let commitments = expected_kzg_commitments
.iter()
.map(|c| {
let mut out: [u8; 48usize] = [0; 48usize];
unsafe {
bytes_from_g1_raw(out.as_mut_ptr(), c);
}
KZGCommitment { bytes: out }
})
.collect::<Vec<KZGCommitment>>();
let proof = {
let mut out: [u8; 48usize] = [0; 48usize];
unsafe {
bytes_from_g1_raw(out.as_mut_ptr(), kzg_aggregated_proof);
}
KZGProof { bytes: out }
};
unsafe {
verify_aggregate_kzg_proof(
&mut out,
blob_arr.as_ptr(),
commitments.as_ptr(),
blobs.len(),
&proof,
ts,
);
}
out
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/src/fk20settings.rs | ckzg/src/fk20settings.rs | use kzg::{FK20MultiSettings, FK20SingleSettings, Poly};
use crate::consts::{BlstP1, BlstP2, KzgRet};
use crate::fftsettings::KzgFFTSettings;
use crate::finite::BlstFr;
use crate::kzgsettings::KzgKZGSettings;
use crate::poly::KzgPoly;
use crate::RUN_PARALLEL;
extern "C" {
// FK20 Single
fn new_fk20_single_settings(
fk: *mut KzgFK20SingleSettings,
n2: u64,
ks: *const KzgKZGSettings,
) -> KzgRet;
fn da_using_fk20_single(
out: *mut BlstP1,
p: *const KzgPoly,
fk: *const KzgFK20SingleSettings,
run_parallel: bool,
) -> KzgRet;
fn fk20_single_da_opt(
out: *mut BlstP1,
p: *const KzgPoly,
fk: *const KzgFK20SingleSettings,
run_parallel: bool,
) -> KzgRet;
fn free_fk20_single_settings(fk: *mut KzgFK20SingleSettings);
// FK20 Multi
fn new_fk20_multi_settings(
fk: *mut KzgFK20MultiSettings,
n2: u64,
chunk_len: u64,
ks: *const KzgKZGSettings,
) -> KzgRet;
fn da_using_fk20_multi(
out: *mut BlstP1,
p: *const KzgPoly,
fk: *const KzgFK20MultiSettings,
run_parallel: bool,
) -> KzgRet;
fn fk20_multi_da_opt(
out: *mut BlstP1,
p: *const KzgPoly,
fk: *const KzgFK20MultiSettings,
run_parallel: bool,
) -> KzgRet;
fn free_fk20_multi_settings(fk: *mut KzgFK20MultiSettings);
}
#[repr(C)]
#[derive(Debug, Clone)]
pub struct KzgFK20SingleSettings {
pub ks: *const KzgKZGSettings,
pub x_ext_fft: *mut BlstP1,
pub x_ext_fft_len: u64,
}
#[repr(C)]
#[derive(Debug, Clone)]
pub struct KzgFK20MultiSettings {
pub ks: *const KzgKZGSettings,
pub chunk_len: u64,
pub x_ext_fft_files: *mut *mut BlstP1,
pub length: u64,
}
impl Default for KzgFK20SingleSettings {
fn default() -> Self {
Self {
ks: &KzgKZGSettings::default(),
x_ext_fft: &mut BlstP1::default(),
x_ext_fft_len: 0,
}
}
}
impl FK20SingleSettings<BlstFr, BlstP1, BlstP2, KzgFFTSettings, KzgPoly, KzgKZGSettings>
for KzgFK20SingleSettings
{
fn new(ks: &KzgKZGSettings, n2: usize) -> Result<Self, String> {
let mut settings = Self::default();
unsafe {
match new_fk20_single_settings(&mut settings, n2 as u64, ks) {
KzgRet::KzgOk => Ok(settings),
e => Err(format!(
"An error has occurred in FK20SingleSettings::new ==> {:?}",
e
)),
}
}
}
fn data_availability(&self, p: &KzgPoly) -> Result<Vec<BlstP1>, String> {
let mut ret = vec![BlstP1::default(); 2 * p.len() as usize];
unsafe {
match da_using_fk20_single(ret.as_mut_ptr(), p, self, RUN_PARALLEL) {
KzgRet::KzgOk => Ok(ret),
e => Err(format!(
"An error has occurred in FK20SingleSettings::data_availability ==> {:?}",
e
)),
}
}
}
fn data_availability_optimized(&self, p: &KzgPoly) -> Result<Vec<BlstP1>, String> {
let mut ret = vec![BlstP1::default(); 2 * p.len() as usize];
unsafe {
match fk20_single_da_opt(ret.as_mut_ptr(), p, self, RUN_PARALLEL) {
KzgRet::KzgOk => Ok(ret),
e => Err(format!("An error has occurred in FK20SingleSettings::data_availability_optimized ==> {:?}", e))
}
}
}
}
impl Drop for KzgFK20SingleSettings {
fn drop(&mut self) {
unsafe {
if self.x_ext_fft_len > 0 {
free_fk20_single_settings(self);
}
}
}
}
impl Default for KzgFK20MultiSettings {
fn default() -> Self {
Self {
ks: &KzgKZGSettings::default(),
chunk_len: 0,
x_ext_fft_files: std::ptr::null_mut(),
length: 0,
}
}
}
impl FK20MultiSettings<BlstFr, BlstP1, BlstP2, KzgFFTSettings, KzgPoly, KzgKZGSettings>
for KzgFK20MultiSettings
{
fn new(ks: &KzgKZGSettings, n2: usize, chunk_len: usize) -> Result<Self, String> {
let mut settings = Self::default();
unsafe {
match new_fk20_multi_settings(&mut settings, n2 as u64, chunk_len as u64, ks) {
KzgRet::KzgOk => Ok(settings),
e => Err(format!(
"An error has occurred in FK20MultiSettings::new ==> {:?}",
e
)),
}
}
}
fn data_availability(&self, p: &KzgPoly) -> Result<Vec<BlstP1>, String> {
let mut ret = vec![BlstP1::default(); 2 * p.len() as usize];
unsafe {
match da_using_fk20_multi(ret.as_mut_ptr(), p, self, RUN_PARALLEL) {
KzgRet::KzgOk => Ok(ret),
e => Err(format!(
"An error has occurred in FK20MultiSettings::data_availability ==> {:?}",
e
)),
}
}
}
fn data_availability_optimized(&self, p: &KzgPoly) -> Result<Vec<BlstP1>, String> {
let mut ret = vec![BlstP1::default(); 2 * p.len() as usize];
unsafe {
match fk20_multi_da_opt(ret.as_mut_ptr(), p, self, RUN_PARALLEL) {
KzgRet::KzgOk => Ok(ret),
e => Err(format!("An error has occurred in FK20MultiSettings::data_availability_optimized ==> {:?}", e))
}
}
}
}
impl Drop for KzgFK20MultiSettings {
fn drop(&mut self) {
unsafe {
if self.length > 0 || self.chunk_len > 0 {
free_fk20_multi_settings(self);
}
}
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/src/poly.rs | ckzg/src/poly.rs | use crate::consts::KzgRet;
use crate::fftsettings::KzgFFTSettings;
use crate::finite::BlstFr;
use crate::RUN_PARALLEL;
use kzg::{Fr, Poly, PolyRecover};
use std::slice;
extern "C" {
fn new_poly(out: *mut KzgPoly, length: u64) -> KzgRet;
fn free_poly(p: *mut KzgPoly);
fn new_poly_div(out: *mut KzgPoly, dividend: *const KzgPoly, divisor: *const KzgPoly)
-> KzgRet;
fn eval_poly(out: *mut BlstFr, p: *const KzgPoly, x: *const BlstFr);
fn poly_inverse(out: *mut KzgPoly, b: *mut KzgPoly) -> KzgRet;
fn poly_mul(
out: *mut KzgPoly,
a: *const KzgPoly,
b: *const KzgPoly,
run_parallel: bool,
) -> KzgRet;
fn poly_long_div(
out: *mut KzgPoly,
dividend: *const KzgPoly,
divisor: *const KzgPoly,
) -> KzgRet;
fn poly_fast_div(
out: *mut KzgPoly,
dividend: *const KzgPoly,
divisor: *const KzgPoly,
) -> KzgRet;
fn recover_poly_from_samples(
reconstructed_data: *mut BlstFr,
samples: *mut BlstFr,
len_samples: u64,
fs: *const KzgFFTSettings,
run_parallel: bool,
) -> KzgRet;
}
#[repr(C)]
#[derive(Debug, Clone)]
pub struct KzgPoly {
pub coeffs: *mut BlstFr,
pub length: u64,
}
impl Default for KzgPoly {
fn default() -> Self {
Self {
coeffs: &mut BlstFr::default(),
length: 0,
}
}
}
impl Poly<BlstFr> for KzgPoly {
fn new(size: usize) -> Result<Self, String> {
let mut poly = Self::default();
unsafe {
match new_poly(&mut poly, size as u64) {
KzgRet::KzgOk => Ok(poly),
e => Err(format!("An error has occurred in Poly::new ==> {:?}", e)),
}
}
}
fn get_coeff_at(&self, i: usize) -> BlstFr {
unsafe { *self.coeffs.add(i) as BlstFr }
}
fn set_coeff_at(&mut self, i: usize, x: &BlstFr) {
unsafe {
*self.coeffs.add(i) = *x;
}
}
fn get_coeffs(&self) -> &[BlstFr] {
unsafe { slice::from_raw_parts(self.coeffs, self.length as usize) }
}
fn len(&self) -> usize {
self.length as usize
}
fn eval(&self, x: &BlstFr) -> BlstFr {
let mut out = BlstFr::default();
unsafe {
eval_poly(&mut out, self, x);
}
out
}
fn scale(&mut self) {
todo!()
}
fn unscale(&mut self) {
todo!()
}
fn inverse(&mut self, new_len: usize) -> Result<Self, String> {
let mut poly = KzgPoly::new(new_len).unwrap();
unsafe {
match poly_inverse(&mut poly, self) {
KzgRet::KzgOk => Ok(poly),
e => Err(format!(
"An error has occurred in Poly::inverse ==> {:?}",
e
)),
}
}
}
fn div(&mut self, x: &Self) -> Result<Self, String> {
let mut poly = Self::default();
unsafe {
match new_poly_div(&mut poly, self, x) {
KzgRet::KzgOk => Ok(poly),
e => Err(format!("An error has occurred in Poly::div ==> {:?}", e)),
}
}
}
fn long_div(&mut self, x: &Self) -> Result<Self, String> {
let mut poly = Self::new(self.len()).unwrap();
unsafe {
match poly_long_div(&mut poly, self, x) {
KzgRet::KzgOk => Ok(poly),
e => Err(format!(
"An error has occurred in Poly::long_div ==> {:?}",
e
)),
}
}
}
fn fast_div(&mut self, x: &Self) -> Result<Self, String> {
let mut poly = Self::new(self.len()).unwrap();
unsafe {
match poly_fast_div(&mut poly, self, x) {
KzgRet::KzgOk => Ok(poly),
e => Err(format!(
"An error has occurred in Poly::fast_div ==> {:?}",
e
)),
}
}
}
fn mul_direct(&mut self, x: &Self, len: usize) -> Result<Self, String> {
let mut poly = Self::new(len).unwrap();
unsafe {
match poly_mul(&mut poly, self, x, RUN_PARALLEL) {
KzgRet::KzgOk => Ok(poly),
e => Err(format!(
"An error has occurred in Poly::mul_direct ==> {:?}",
e
)),
}
}
}
}
impl Drop for KzgPoly {
fn drop(&mut self) {
unsafe {
free_poly(self);
}
}
}
impl PolyRecover<BlstFr, KzgPoly, KzgFFTSettings> for KzgPoly {
fn recover_poly_from_samples(
samples: &[Option<BlstFr>],
fs: &KzgFFTSettings,
) -> Result<KzgPoly, String> {
let mut reconstructed_data = vec![BlstFr::default(); samples.len()];
let mut optionless_samples = Vec::new();
for s in samples {
if s.is_some() {
optionless_samples.push(s.unwrap());
continue;
}
optionless_samples.push(Fr::null());
}
unsafe {
match recover_poly_from_samples(
reconstructed_data.as_mut_ptr(),
optionless_samples.as_mut_ptr(),
samples.len() as u64,
fs,
RUN_PARALLEL,
) {
KzgRet::KzgOk => (),
e => {
return Err(format!(
"An error has occurred in PolyRecover::recover_poly_from_samples ==> {:?}",
e
))
}
}
}
let mut out = KzgPoly::new(reconstructed_data.len()).unwrap();
for (i, data) in reconstructed_data.iter().enumerate() {
out.set_coeff_at(i, data)
}
Ok(out)
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/src/kzgsettings4844.rs | ckzg/src/kzgsettings4844.rs | use kzg::{FFTSettings, KZGSettings};
use crate::consts::{BlstP1, BlstP2};
use crate::fftsettings4844::KzgFFTSettings4844;
use crate::finite::BlstFr;
use crate::poly::KzgPoly;
// use crate::RUN_PARALLEL;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct BlstScalar {
pub b: [u8; 32],
}
#[repr(C)]
#[derive(Debug, Clone)]
pub struct KzgKZGSettings4844 {
pub fs: *const KzgFFTSettings4844,
pub g1_values: *mut BlstP1, // G1
pub g2_values: *mut BlstP2, // G2
}
extern "C" {
fn free_trusted_setup(s: *mut KzgKZGSettings4844);
}
impl Default for KzgKZGSettings4844 {
fn default() -> Self {
Self {
fs: &KzgFFTSettings4844::default(),
g1_values: &mut BlstP1::default(),
g2_values: &mut BlstP2::default(),
}
}
}
impl KZGSettings<BlstFr, BlstP1, BlstP2, KzgFFTSettings4844, KzgPoly> for KzgKZGSettings4844 {
// underscore was added to avoid warnings when new is unused
fn new(
_secret_g1: &[BlstP1],
_secret_g2: &[BlstP2],
_length: usize,
_fs: &KzgFFTSettings4844,
) -> Result<Self, String> {
todo!();
// let mut settings = KzgKZGSettings4844::default();
// unsafe {
// Ok(Self {
// fs,
// g1_values: secret_g1.as_ptr(),
// g2_values: secret_g2.as_ptr(),
// length: length as u64,
// }
// )
// }
}
fn commit_to_poly(&self, _p: &KzgPoly) -> Result<BlstP1, String> {
todo!();
}
fn compute_proof_single(&self, _p: &KzgPoly, _x: &BlstFr) -> Result<BlstP1, String> {
todo!();
}
fn check_proof_single(
&self,
_com: &BlstP1,
_proof: &BlstP1,
_x: &BlstFr,
_value: &BlstFr,
) -> Result<bool, String> {
todo!();
}
fn compute_proof_multi(&self, _p: &KzgPoly, _x: &BlstFr, _n: usize) -> Result<BlstP1, String> {
todo!();
}
fn check_proof_multi(
&self,
_com: &BlstP1,
_proof: &BlstP1,
_x: &BlstFr,
_values: &[BlstFr],
_n: usize,
) -> Result<bool, String> {
todo!();
}
fn get_expanded_roots_of_unity_at(&self, i: usize) -> BlstFr {
unsafe { (*self.fs).get_expanded_roots_of_unity_at(i) }
}
}
impl Drop for KzgKZGSettings4844 {
fn drop(&mut self) {
unsafe {
free_trusted_setup(self);
}
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/src/kzgsettings.rs | ckzg/src/kzgsettings.rs | use kzg::{FFTSettings, Fr, G1Mul, G2Mul, KZGSettings, G1, G2};
use crate::consts::{BlstP1, BlstP2, KzgRet};
use crate::fftsettings::KzgFFTSettings;
use crate::finite::BlstFr;
use crate::poly::KzgPoly;
use crate::RUN_PARALLEL;
extern "C" {
fn new_kzg_settings(
ks: *mut KzgKZGSettings,
secret_g1: *const BlstP1,
secret_g2: *const BlstP2,
length: u64,
fs: *const KzgFFTSettings,
) -> KzgRet;
fn free_kzg_settings(ks: *mut KzgKZGSettings);
fn commit_to_poly(out: *mut BlstP1, p: *const KzgPoly, ks: *const KzgKZGSettings) -> KzgRet;
fn compute_proof_single(
out: *mut BlstP1,
p: *const KzgPoly,
x0: *const BlstFr,
ks: *const KzgKZGSettings,
) -> KzgRet;
fn check_proof_single(
out: *mut bool,
commitment: *const BlstP1,
proof: *const BlstP1,
x: *const BlstFr,
y: *const BlstFr,
ks: *const KzgKZGSettings,
) -> KzgRet;
fn compute_proof_multi(
out: *mut BlstP1,
p: *const KzgPoly,
x0: *const BlstFr,
n: u64,
ks: *const KzgKZGSettings,
) -> KzgRet;
fn check_proof_multi(
out: *mut bool,
commitment: *const BlstP1,
proof: *const BlstP1,
x: *const BlstFr,
ys: *const BlstFr,
n: u64,
ks: *const KzgKZGSettings,
run_parallel: bool,
) -> KzgRet;
// Fr
fn fr_from_scalar(out: *mut BlstFr, a: *const BlstScalar);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct BlstScalar {
pub b: [u8; 32],
}
#[repr(C)]
#[derive(Debug, Clone)]
pub struct KzgKZGSettings {
pub fs: *const KzgFFTSettings,
pub secret_g1: *mut BlstP1, // G1
pub secret_g2: *mut BlstP2, // G2
pub length: u64,
}
impl Default for KzgKZGSettings {
fn default() -> Self {
Self {
fs: &KzgFFTSettings::default(),
secret_g1: &mut BlstP1::default(),
secret_g2: &mut BlstP2::default(),
length: 0,
}
}
}
impl KZGSettings<BlstFr, BlstP1, BlstP2, KzgFFTSettings, KzgPoly> for KzgKZGSettings {
fn new(
secret_g1: &[BlstP1],
secret_g2: &[BlstP2],
length: usize,
fs: &KzgFFTSettings,
) -> Result<Self, String> {
let mut settings = Self::default();
unsafe {
match new_kzg_settings(
&mut settings,
secret_g1.as_ptr(),
secret_g2.as_ptr(),
length as u64,
fs,
) {
KzgRet::KzgOk => Ok(settings),
e => Err(format!(
"An error has occurred in KZGSettings::new ==> {:?}",
e
)),
}
}
}
fn commit_to_poly(&self, p: &KzgPoly) -> Result<BlstP1, String> {
let mut ret = BlstP1::default();
unsafe {
match commit_to_poly(&mut ret, p, self) {
KzgRet::KzgOk => Ok(ret),
e => Err(format!(
"An error has occurred in KZGSettings::commit_to_poly ==> {:?}",
e
)),
}
}
}
fn compute_proof_single(&self, p: &KzgPoly, x: &BlstFr) -> Result<BlstP1, String> {
let mut ret = BlstP1::default();
unsafe {
match compute_proof_single(&mut ret, p, x, self) {
KzgRet::KzgOk => Ok(ret),
e => Err(format!(
"An error has occurred in KZGSettings::compute_proof_single ==> {:?}",
e
)),
}
}
}
fn check_proof_single(
&self,
com: &BlstP1,
proof: &BlstP1,
x: &BlstFr,
value: &BlstFr,
) -> Result<bool, String> {
let mut ret = false;
unsafe {
match check_proof_single(&mut ret, com, proof, x, value, self) {
KzgRet::KzgOk => Ok(ret),
e => Err(format!(
"An error has occurred in KZGSettings::check_proof_single ==> {:?}",
e
)),
}
}
}
fn compute_proof_multi(&self, p: &KzgPoly, x: &BlstFr, n: usize) -> Result<BlstP1, String> {
let mut ret = BlstP1::default();
unsafe {
match compute_proof_multi(&mut ret, p, x, n as u64, self) {
KzgRet::KzgOk => Ok(ret),
e => Err(format!(
"An error has occurred in KZGSettings::compute_proof_multi ==> {:?}",
e
)),
}
}
}
fn check_proof_multi(
&self,
com: &BlstP1,
proof: &BlstP1,
x: &BlstFr,
values: &[BlstFr],
n: usize,
) -> Result<bool, String> {
let mut ret = false;
unsafe {
match check_proof_multi(
&mut ret,
com,
proof,
x,
values.as_ptr(),
n as u64,
self,
RUN_PARALLEL,
) {
KzgRet::KzgOk => Ok(ret),
e => Err(format!(
"An error has occurred in KZGSettings::check_proof_multi ==> {:?}",
e
)),
}
}
}
fn get_expanded_roots_of_unity_at(&self, i: usize) -> BlstFr {
unsafe { (*self.fs).get_expanded_roots_of_unity_at(i) }
}
}
impl Drop for KzgKZGSettings {
fn drop(&mut self) {
unsafe {
if self.length > 0 {
free_kzg_settings(self);
}
}
}
}
pub fn generate_trusted_setup(len: usize, secret: [u8; 32usize]) -> (Vec<BlstP1>, Vec<BlstP2>) {
let mut blst_scalar = BlstScalar { b: [0; 32] };
blst_scalar.b[..secret.len()].clone_from_slice(&secret[..]);
let mut s_pow: BlstFr = Fr::one();
let mut s = BlstFr::default();
unsafe { fr_from_scalar(&mut s, &blst_scalar) };
let mut s1 = vec![BlstP1::default(); 0];
let mut s2 = vec![BlstP2::default(); 0];
for _i in 0..len {
let g1_mul = G1Mul::mul(&G1::generator(), &s_pow);
let g2_mul = G2Mul::mul(&G2::generator(), &s_pow);
s1.push(g1_mul);
s2.push(g2_mul);
s_pow = s_pow.mul(&s);
}
(s1, s2)
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/src/fftsettings4844.rs | ckzg/src/fftsettings4844.rs | use crate::finite::BlstFr;
use kzg::FFTSettings;
use std::slice;
#[repr(C)]
#[derive(Debug, Clone)]
pub struct KzgFFTSettings4844 {
pub max_width: u64,
pub expanded_roots_of_unity: *mut BlstFr,
pub reverse_roots_of_unity: *mut BlstFr,
pub roots_of_unity: *mut BlstFr,
}
extern "C" {}
impl Default for KzgFFTSettings4844 {
fn default() -> Self {
Self {
max_width: 0,
expanded_roots_of_unity: &mut BlstFr::default(),
reverse_roots_of_unity: &mut BlstFr::default(),
roots_of_unity: &mut BlstFr::default(),
}
}
}
impl FFTSettings<BlstFr> for KzgFFTSettings4844 {
// underscore was added to avoid warnings when new is unused
fn new(_scale: usize) -> Result<Self, String> {
todo!();
}
fn get_max_width(&self) -> usize {
self.max_width as usize
}
fn get_expanded_roots_of_unity_at(&self, i: usize) -> BlstFr {
unsafe { *(self.expanded_roots_of_unity.add(i)) as BlstFr }
}
fn get_expanded_roots_of_unity(&self) -> &[BlstFr] {
unsafe { slice::from_raw_parts(self.expanded_roots_of_unity, self.max_width as usize) }
}
fn get_reverse_roots_of_unity_at(&self, i: usize) -> BlstFr {
unsafe { *self.reverse_roots_of_unity.add(i) as BlstFr }
}
fn get_reversed_roots_of_unity(&self) -> &[BlstFr] {
unsafe { slice::from_raw_parts(self.reverse_roots_of_unity, self.max_width as usize) }
}
}
impl Drop for KzgFFTSettings4844 {
fn drop(&mut self) {}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/src/fftsettings.rs | ckzg/src/fftsettings.rs | use crate::consts::{BlstP1, KzgRet};
use crate::finite::BlstFr;
use crate::poly::KzgPoly;
use crate::utils::{log_2, next_pow_of_2};
use crate::RUN_PARALLEL;
use kzg::{FFTFr, FFTSettings, FFTSettingsPoly, Poly, ZeroPoly, DAS, FFTG1, G1};
use std::{cmp::min, slice};
#[repr(C)]
#[derive(Debug, Clone)]
pub struct KzgFFTSettings {
pub max_width: usize,
pub root_of_unity: BlstFr,
pub expanded_roots_of_unity: *mut BlstFr,
pub reverse_roots_of_unity: *mut BlstFr,
}
extern "C" {
fn new_fft_settings(settings: *mut KzgFFTSettings, max_scale: u32) -> KzgRet;
fn free_fft_settings(settings: *mut KzgFFTSettings);
fn fft_fr(
output: *mut BlstFr,
input: *const BlstFr,
inverse: bool,
n: u64,
fs: *const KzgFFTSettings,
run_parallel: bool,
) -> KzgRet;
fn fft_g1(
output: *mut BlstP1,
input: *const BlstP1,
inverse: bool,
n: u64,
fs: *const KzgFFTSettings,
run_parallel: bool,
) -> KzgRet;
fn poly_mul_(
out: *mut KzgPoly,
a: *const KzgPoly,
b: *const KzgPoly,
fs: *mut KzgFFTSettings,
run_parallel: bool,
) -> KzgRet;
fn fft_fr_fast(
output: *mut BlstFr,
input: *const BlstFr,
stride: usize,
roots: *const BlstFr,
roots_stride: usize,
n: usize,
run_parallel: bool,
);
fn fft_fr_slow(
output: *mut BlstFr,
input: *const BlstFr,
stride: usize,
roots: *const BlstFr,
roots_stride: usize,
n: usize,
);
fn fft_g1_fast(
output: *mut BlstP1,
input: *const BlstP1,
stride: usize,
roots: *const BlstFr,
roots_stride: usize,
n: usize,
run_parallel: bool,
);
fn fft_g1_slow(
output: *mut BlstP1,
input: *const BlstP1,
stride: usize,
roots: *const BlstFr,
roots_stride: usize,
n: usize,
);
fn do_zero_poly_mul_partial(
dst: *mut KzgPoly,
indices: *const u64,
len_indices: u64,
stride: u64,
fs: *const KzgFFTSettings,
) -> KzgRet;
//fn pad_p(out: *mut BlstFr, out_len: u64, p: *const KzgPoly) -> KzgRet;
fn reduce_partials(
out: *mut KzgPoly,
len_out: u64,
scratch: *mut BlstFr,
len_scratch: u64,
partials: *const KzgPoly,
partial_count: u64,
fs: *const KzgFFTSettings,
run_parallel: bool,
) -> KzgRet;
fn zero_polynomial_via_multiplication(
zero_eval: *mut BlstFr,
zero_poly: *mut KzgPoly,
length: u64,
missing_indices: *const u64,
len_missing: u64,
fs: *const KzgFFTSettings,
run_parallel: bool,
) -> KzgRet;
fn das_fft_extension(
vals: *mut BlstFr,
n: u64,
fs: *const KzgFFTSettings,
run_parallel: bool,
) -> KzgRet;
}
impl Default for KzgFFTSettings {
fn default() -> Self {
Self {
max_width: 0,
root_of_unity: BlstFr::default(),
expanded_roots_of_unity: &mut BlstFr::default(),
reverse_roots_of_unity: &mut BlstFr::default(),
}
}
}
impl FFTSettings<BlstFr> for KzgFFTSettings {
fn new(scale: usize) -> Result<Self, String> {
let settings = Box::new(KzgFFTSettings::default());
unsafe {
let v = Box::<KzgFFTSettings>::into_raw(settings);
match new_fft_settings(v, scale as u32) {
KzgRet::KzgOk => Ok(*Box::<KzgFFTSettings>::from_raw(v)),
e => Err(format!(
"An error has occurred in FFTSettings::new ==> {:?}",
e
)),
}
}
}
fn get_max_width(&self) -> usize {
self.max_width as usize
}
fn get_expanded_roots_of_unity_at(&self, i: usize) -> BlstFr {
unsafe { *(self.expanded_roots_of_unity.add(i)) as BlstFr }
}
fn get_expanded_roots_of_unity(&self) -> &[BlstFr] {
unsafe { slice::from_raw_parts(self.expanded_roots_of_unity, self.max_width) }
}
fn get_reverse_roots_of_unity_at(&self, i: usize) -> BlstFr {
unsafe { *self.reverse_roots_of_unity.add(i) as BlstFr }
}
fn get_reversed_roots_of_unity(&self) -> &[BlstFr] {
unsafe { slice::from_raw_parts(self.reverse_roots_of_unity, self.max_width) }
}
}
impl Drop for KzgFFTSettings {
fn drop(&mut self) {
unsafe {
if self.max_width > 0 && self.max_width < (1 << 32) {
free_fft_settings(self);
}
}
}
}
impl FFTFr<BlstFr> for KzgFFTSettings {
fn fft_fr(&self, data: &[BlstFr], inverse: bool) -> Result<Vec<BlstFr>, String> {
match _fft_fr(data.as_ptr(), inverse, data.len() as u64, self) {
Ok(fr) => Ok(fr),
Err(e) => Err(format!(
"An error has occurred in FFTFr::fft_fr ==> {:?}",
e
)),
}
}
}
fn _fft_fr(
input: *const BlstFr,
inverse: bool,
n: u64,
fs: *const KzgFFTSettings,
) -> Result<Vec<BlstFr>, KzgRet> {
let mut output = vec![BlstFr::default(); n as usize];
unsafe {
match fft_fr(output.as_mut_ptr(), input, inverse, n, fs, RUN_PARALLEL) {
KzgRet::KzgOk => Ok(output),
e => Err(e),
}
}
}
impl FFTG1<BlstP1> for KzgFFTSettings {
fn fft_g1(&self, data: &[BlstP1], inverse: bool) -> Result<Vec<BlstP1>, String> {
match _fft_g1(data.as_ptr(), inverse, data.len() as u64, self) {
Ok(g) => Ok(g),
Err(e) => Err(format!(
"An error has occurred in FFTG1::fft_g1 ==> {:?}",
e
)),
}
}
}
fn _fft_g1(
input: *const BlstP1,
inverse: bool,
n: u64,
fs: *const KzgFFTSettings,
) -> Result<Vec<BlstP1>, KzgRet> {
let mut output = vec![BlstP1::default(); n as usize];
unsafe {
match fft_g1(output.as_mut_ptr(), input, inverse, n, fs, RUN_PARALLEL) {
KzgRet::KzgOk => Ok(output),
e => Err(e),
}
}
}
impl FFTSettingsPoly<BlstFr, KzgPoly, KzgFFTSettings> for KzgFFTSettings {
fn poly_mul_fft(
a: &KzgPoly,
b: &KzgPoly,
len: usize,
_fs: Option<&KzgFFTSettings>,
) -> Result<KzgPoly, String> {
// Truncate a and b so as not to do excess work for the number of coefficients required
let a_len = min(a.len(), len);
let b_len = min(b.len(), len);
let length = next_pow_of_2(a_len + b_len - 1);
let mut fft = KzgFFTSettings::new(log_2(length)).unwrap();
let mut poly = KzgPoly::new(len).unwrap();
unsafe {
match poly_mul_(&mut poly, a, b, &mut fft, RUN_PARALLEL) {
KzgRet::KzgOk => Ok(poly),
e => Err(format!(
"An error has occurred in FFTSettingsPoly::poly_mul_fft ==> {:?}",
e
)),
}
}
}
}
impl ZeroPoly<BlstFr, KzgPoly> for KzgFFTSettings {
fn do_zero_poly_mul_partial(&self, idxs: &[usize], stride: usize) -> Result<KzgPoly, String> {
let mut poly = KzgPoly::new(idxs.len() + 1).unwrap();
unsafe {
match do_zero_poly_mul_partial(
&mut poly,
idxs.as_ptr() as *const u64,
idxs.len() as u64,
stride as u64,
self,
) {
KzgRet::KzgOk => Ok(poly),
e => Err(format!(
"An error has occurred in ZeroPoly::do_zero_poly_mul_partial ==> {:?}",
e
)),
}
}
}
fn reduce_partials(&self, domain_size: usize, partials: &[KzgPoly]) -> Result<KzgPoly, String> {
let mut poly = KzgPoly::new(domain_size).unwrap();
let scratch_len = domain_size * 3;
let mut scratch = vec![BlstFr::default(); scratch_len];
unsafe {
match reduce_partials(
&mut poly,
domain_size as u64,
scratch.as_mut_ptr(),
scratch_len as u64,
partials.as_ptr(),
partials.len() as u64,
self,
RUN_PARALLEL,
) {
KzgRet::KzgOk => Ok(poly),
e => Err(format!(
"An error has occurred in ZeroPoly:reduce_partials ==> {:?}",
e
)),
}
}
}
fn zero_poly_via_multiplication(
&self,
domain_size: usize,
idxs: &[usize],
) -> Result<(Vec<BlstFr>, KzgPoly), String> {
let mut zero_poly = KzgPoly::new(domain_size).unwrap();
let mut zero_eval = vec![BlstFr::default(); domain_size];
unsafe {
match zero_polynomial_via_multiplication(
zero_eval.as_mut_ptr(),
&mut zero_poly,
domain_size as u64,
idxs.as_ptr() as *const u64,
idxs.len() as u64,
self,
RUN_PARALLEL,
) {
KzgRet::KzgOk => Ok((zero_eval, zero_poly)),
e => Err(format!(
"An error has occurred in ZeroPoly:zero_poly_via_multiplication ==> {:?}",
e
)),
}
}
}
}
impl DAS<BlstFr> for KzgFFTSettings {
fn das_fft_extension(&self, evens: &[BlstFr]) -> Result<Vec<BlstFr>, String> {
let mut values = evens.to_vec();
unsafe {
match das_fft_extension(values.as_mut_ptr(), values.len() as u64, self, RUN_PARALLEL) {
KzgRet::KzgOk => Ok(values),
e => Err(format!(
"An error has occurred in DAS::das_fft_extension ==> {:?}",
e
)),
}
}
}
}
pub fn make_data(n: usize) -> Vec<BlstP1> {
let mut out_val = vec![G1::generator(); n];
let out_ptr: *mut BlstP1 = out_val.as_mut_ptr();
if n == 0 {
return vec![BlstP1::default(); 0];
}
for i in 1..n as isize {
unsafe {
(*out_ptr.offset(i)).add_or_dbl(&*out_ptr.offset(i - 1));
}
}
out_val
}
pub fn bound_fft_fr_fast(
ret: &mut [BlstFr],
data: &[BlstFr],
stride: usize,
roots: &[BlstFr],
roots_stride: usize,
) {
unsafe {
fft_fr_fast(
ret.as_mut_ptr(),
data.as_ptr(),
stride,
roots.as_ptr(),
roots_stride,
4096,
RUN_PARALLEL,
);
}
}
pub fn bound_fft_fr_slow(
ret: &mut [BlstFr],
data: &[BlstFr],
stride: usize,
roots: &[BlstFr],
roots_stride: usize,
) {
unsafe {
fft_fr_slow(
ret.as_mut_ptr(),
data.as_ptr(),
stride,
roots.as_ptr(),
roots_stride,
4096,
);
}
}
pub fn bound_fft_g1_fast(
ret: &mut [BlstP1],
data: &[BlstP1],
stride: usize,
roots: &[BlstFr],
roots_stride: usize,
n: usize,
) {
unsafe {
fft_g1_fast(
ret.as_mut_ptr(),
data.as_ptr(),
stride,
roots.as_ptr(),
roots_stride,
n,
RUN_PARALLEL,
);
}
}
pub fn bound_fft_g1_slow(
ret: &mut [BlstP1],
data: &[BlstP1],
stride: usize,
roots: &[BlstFr],
roots_stride: usize,
n: usize,
) {
unsafe {
fft_g1_slow(
ret.as_mut_ptr(),
data.as_ptr(),
stride,
roots.as_ptr(),
roots_stride,
n,
);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/tests/consts.rs | ckzg/tests/consts.rs | #[cfg(test)]
mod tests {
use ckzg::consts::{expand_root_of_unity, SCALE2_ROOT_OF_UNITY};
use ckzg::fftsettings::KzgFFTSettings;
use ckzg::finite::BlstFr;
use kzg_bench::tests::consts::*;
#[test]
fn test_roots_of_unity_is_the_expected_size() {
roots_of_unity_is_the_expected_size(&SCALE2_ROOT_OF_UNITY);
}
#[test]
fn test_roots_of_unity_out_of_bounds_fails() {
roots_of_unity_out_of_bounds_fails::<BlstFr, KzgFFTSettings>();
}
#[test]
fn test_roots_of_unity_are_plausible() {
roots_of_unity_are_plausible::<BlstFr>(&SCALE2_ROOT_OF_UNITY);
}
#[test]
fn test_expand_roots_is_plausible() {
expand_roots_is_plausible::<BlstFr>(&SCALE2_ROOT_OF_UNITY, &expand_root_of_unity);
}
#[test]
fn test_new_fft_settings_is_plausible() {
new_fft_settings_is_plausible::<BlstFr, KzgFFTSettings>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/tests/das.rs | ckzg/tests/das.rs | #[cfg(test)]
mod tests {
use ckzg::fftsettings::KzgFFTSettings;
use ckzg::finite::BlstFr;
use kzg_bench::tests::das::{das_extension_test_known, das_extension_test_random};
#[test]
fn das_extension_test_known_() {
das_extension_test_known::<BlstFr, KzgFFTSettings>();
}
#[test]
fn das_extension_test_random_() {
das_extension_test_random::<BlstFr, KzgFFTSettings>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/tests/finite.rs | ckzg/tests/finite.rs | #[cfg(test)]
mod tests {
use ckzg::finite::BlstFr;
use kzg_bench::tests::finite::sum_of_two_zeros_is_zero;
#[test]
fn test_sum_of_two_zeros_is_zero() {
sum_of_two_zeros_is_zero::<BlstFr>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/tests/eip_4844.rs | ckzg/tests/eip_4844.rs | #[cfg(test)]
mod tests {
use ckzg::{
consts::{BlstP1, BlstP2},
eip_4844::{
blob_to_kzg_commitment_rust, compute_aggregate_kzg_proof_rust, load_trusted_setup_rust,
verify_aggregate_kzg_proof_rust,
},
fftsettings4844::KzgFFTSettings4844,
finite::BlstFr,
kzgsettings4844::KzgKZGSettings4844,
poly::KzgPoly,
};
use kzg_bench::tests::eip_4844::{
aggregate_proof_for_single_blob_test, eip4844_test, verify_aggregate_kzg_proof_test_empty,
};
#[test]
pub fn eip4844_test_() {
eip4844_test::<BlstFr, BlstP1, BlstP2, KzgPoly, KzgFFTSettings4844, KzgKZGSettings4844>(
&load_trusted_setup_rust,
&blob_to_kzg_commitment_rust,
&compute_aggregate_kzg_proof_rust,
&verify_aggregate_kzg_proof_rust,
);
}
#[test]
pub fn verify_aggregate_kzg_proof_test_empty_() {
verify_aggregate_kzg_proof_test_empty::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings4844,
KzgKZGSettings4844,
>(
&load_trusted_setup_rust,
&compute_aggregate_kzg_proof_rust,
&verify_aggregate_kzg_proof_rust,
);
}
#[test]
pub fn aggregate_proof_for_single_blob_test_() {
aggregate_proof_for_single_blob_test::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings4844,
KzgKZGSettings4844,
>(
&load_trusted_setup_rust,
&blob_to_kzg_commitment_rust,
&compute_aggregate_kzg_proof_rust,
&verify_aggregate_kzg_proof_rust,
);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/tests/kzg_proofs.rs | ckzg/tests/kzg_proofs.rs | #[cfg(test)]
mod tests {
use ckzg::consts::{BlstP1, BlstP2};
use ckzg::fftsettings::KzgFFTSettings;
use ckzg::finite::BlstFr;
use ckzg::kzgsettings::{generate_trusted_setup, KzgKZGSettings};
use ckzg::poly::KzgPoly;
use kzg_bench::tests::kzg_proofs::*;
#[test]
fn test_proof_single() {
proof_single::<BlstFr, BlstP1, BlstP2, KzgPoly, KzgFFTSettings, KzgKZGSettings>(
&generate_trusted_setup,
);
}
#[test]
fn test_commit_to_nil_poly() {
commit_to_nil_poly::<BlstFr, BlstP1, BlstP2, KzgPoly, KzgFFTSettings, KzgKZGSettings>(
&generate_trusted_setup,
);
}
#[test]
fn test_commit_to_too_long_poly() {
commit_to_too_long_poly::<BlstFr, BlstP1, BlstP2, KzgPoly, KzgFFTSettings, KzgKZGSettings>(
&generate_trusted_setup,
);
}
#[test]
fn test_commit_to_too_long_poly_returns_err() {
commit_to_too_long_poly_returns_err::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings,
KzgKZGSettings,
>(&generate_trusted_setup);
}
#[test]
fn test_proof_multi() {
proof_multi::<BlstFr, BlstP1, BlstP2, KzgPoly, KzgFFTSettings, KzgKZGSettings>(
&generate_trusted_setup,
);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/tests/poly.rs | ckzg/tests/poly.rs | #[cfg(test)]
mod tests {
use ckzg::fftsettings::KzgFFTSettings;
use ckzg::finite::BlstFr;
use ckzg::poly::KzgPoly;
use kzg_bench::tests::poly::*;
#[test]
fn test_create_poly_of_length_ten() {
create_poly_of_length_ten::<BlstFr, KzgPoly>();
}
#[test]
fn test_poly_eval_check() {
poly_eval_check::<BlstFr, KzgPoly>();
}
#[test]
fn test_poly_eval_0_check() {
poly_eval_0_check::<BlstFr, KzgPoly>();
}
#[test]
fn test_poly_eval_nil_check() {
poly_eval_nil_check::<BlstFr, KzgPoly>();
}
#[test]
fn test_poly_inverse_simple_0() {
poly_inverse_simple_0::<BlstFr, KzgPoly>();
}
#[test]
fn test_poly_inverse_simple_1() {
poly_inverse_simple_1::<BlstFr, KzgPoly>();
}
#[test]
fn test_poly_test_div() {
poly_test_div::<BlstFr, KzgPoly>();
}
#[test]
fn test_poly_div_by_zero() {
poly_div_by_zero::<BlstFr, KzgPoly>();
}
#[test]
fn test_poly_mul_direct_test() {
poly_mul_direct_test::<BlstFr, KzgPoly>();
}
#[test]
fn test_poly_mul_fft_test() {
poly_mul_fft_test::<BlstFr, KzgPoly, KzgFFTSettings>();
}
#[test]
fn test_poly_mul_random() {
poly_mul_random::<BlstFr, KzgPoly, KzgFFTSettings>();
}
#[test]
fn test_poly_div_random() {
poly_div_random::<BlstFr, KzgPoly>();
}
#[test]
fn test_poly_div_long_test() {
poly_div_long_test::<BlstFr, KzgPoly>();
}
#[test]
fn test_poly_div_fast_test() {
poly_div_fast_test::<BlstFr, KzgPoly>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/tests/zero_poly.rs | ckzg/tests/zero_poly.rs | #[cfg(test)]
mod tests {
use ckzg::fftsettings::KzgFFTSettings;
use ckzg::finite::BlstFr;
use ckzg::poly::KzgPoly;
use kzg_bench::tests::zero_poly::*;
#[test]
fn reduce_partials() {
test_reduce_partials::<BlstFr, KzgFFTSettings, KzgPoly>();
}
#[test]
fn test_reduce_partials_random() {
reduce_partials_random::<BlstFr, KzgFFTSettings, KzgPoly>();
}
#[test]
fn test_check_test_data() {
check_test_data::<BlstFr, KzgFFTSettings, KzgPoly>();
}
#[test]
fn test_zero_poly_random() {
zero_poly_random::<BlstFr, KzgFFTSettings, KzgPoly>();
}
#[test]
fn test_zero_poly_known() {
zero_poly_known::<BlstFr, KzgFFTSettings, KzgPoly>();
}
#[test]
fn test_zero_poly_all_but_one() {
zero_poly_all_but_one::<BlstFr, KzgFFTSettings, KzgPoly>();
}
#[test]
fn test_zero_poly_252() {
zero_poly_252::<BlstFr, KzgFFTSettings, KzgPoly>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/tests/bls12_381.rs | ckzg/tests/bls12_381.rs | #[cfg(test)]
mod tests {
use ckzg::consts::{BlstP1, BlstP2};
use ckzg::finite::{linear_combination_g1, verify_pairings, BlstFr};
use ckzg::utils::log_2_byte;
use kzg_bench::tests::bls12_381::*;
#[test]
fn test_log_2_byte_works() {
log_2_byte_works(&log_2_byte);
}
#[test]
fn test_fr_is_zero_works() {
fr_is_zero_works::<BlstFr>();
}
#[test]
fn test_fr_is_one_works() {
fr_is_one_works::<BlstFr>();
}
#[test]
fn test_fr_is_null_works() {
fr_is_null_works::<BlstFr>();
}
#[test]
fn test_fr_from_uint64_works() {
fr_from_uint64_works::<BlstFr>();
}
#[test]
fn test_fr_equal_works() {
fr_equal_works::<BlstFr>();
}
#[test]
fn test_fr_negate_works() {
fr_negate_works::<BlstFr>();
}
#[test]
fn test_fr_pow_works() {
fr_pow_works::<BlstFr>();
}
#[test]
fn test_fr_div_works() {
fr_div_works::<BlstFr>();
}
#[test]
fn test_fr_div_by_zero() {
fr_div_by_zero::<BlstFr>();
}
#[test]
fn test_fr_uint64s_roundtrip() {
fr_uint64s_roundtrip::<BlstFr>();
}
#[test]
fn test_p1_mul_works() {
p1_mul_works::<BlstFr, BlstP1>();
}
#[test]
fn test_p1_sub_works() {
p1_sub_works::<BlstP1>();
}
#[test]
fn test_p2_add_or_dbl_works() {
p2_add_or_dbl_works::<BlstP2>();
}
#[test]
fn test_p2_mul_works() {
p2_mul_works::<BlstFr, BlstP2>();
}
#[test]
fn test_p2_sub_works() {
p2_sub_works::<BlstP2>();
}
#[test]
fn test_g1_identity_is_infinity() {
g1_identity_is_infinity::<BlstP1>();
}
#[test]
fn test_g1_identity_is_identity() {
g1_identity_is_identity::<BlstP1>();
}
#[test]
fn test_g1_make_linear_combination() {
g1_make_linear_combination::<BlstFr, BlstP1>(&linear_combination_g1);
}
#[test]
fn test_g1_random_linear_combination() {
g1_random_linear_combination::<BlstFr, BlstP1>(&linear_combination_g1);
}
#[test]
fn test_pairings_work() {
pairings_work::<BlstFr, BlstP1, BlstP2>(&verify_pairings);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/tests/fk20_proofs.rs | ckzg/tests/fk20_proofs.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::fk20_proofs::*;
use ckzg::consts::{BlstP1, BlstP2};
use ckzg::fftsettings::KzgFFTSettings;
use ckzg::finite::BlstFr;
use ckzg::fk20settings::{KzgFK20MultiSettings, KzgFK20SingleSettings};
use ckzg::kzgsettings::{generate_trusted_setup, KzgKZGSettings};
use ckzg::poly::KzgPoly;
#[test]
fn test_fk_single() {
fk_single::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings,
KzgKZGSettings,
KzgFK20SingleSettings,
>(&generate_trusted_setup);
}
#[test]
fn test_fk_single_strided() {
fk_single_strided::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings,
KzgKZGSettings,
KzgFK20SingleSettings,
>(&generate_trusted_setup);
}
#[test]
fn test_fk_multi_settings() {
fk_multi_settings::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings,
KzgKZGSettings,
KzgFK20MultiSettings,
>(&generate_trusted_setup);
}
#[test]
fn test_fk_multi_chunk_len_1_512() {
fk_multi_chunk_len_1_512::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings,
KzgKZGSettings,
KzgFK20MultiSettings,
>(&generate_trusted_setup);
}
#[test]
fn test_fk_multi_chunk_len_16_512() {
fk_multi_chunk_len_16_512::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings,
KzgKZGSettings,
KzgFK20MultiSettings,
>(&generate_trusted_setup);
}
#[test]
fn test_fk_multi_chunk_len_16_16() {
fk_multi_chunk_len_16_16::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings,
KzgKZGSettings,
KzgFK20MultiSettings,
>(&generate_trusted_setup);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/tests/fft_g1.rs | ckzg/tests/fft_g1.rs | #[cfg(test)]
mod tests {
use ckzg::consts::BlstP1;
use ckzg::fftsettings::{bound_fft_g1_fast, bound_fft_g1_slow, make_data, KzgFFTSettings};
use ckzg::finite::BlstFr;
use kzg_bench::tests::fft_g1::{compare_sft_fft, roundtrip_fft, stride_fft};
#[test]
fn test_roundtrip_fft() {
roundtrip_fft::<BlstFr, BlstP1, KzgFFTSettings>(&make_data);
}
#[test]
fn test_stride_fft() {
stride_fft::<BlstFr, BlstP1, KzgFFTSettings>(&make_data);
}
#[test]
fn test_compare_sft_fft() {
compare_sft_fft::<BlstFr, BlstP1, KzgFFTSettings>(
&bound_fft_g1_slow,
&bound_fft_g1_fast,
&make_data,
);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/tests/fft_fr.rs | ckzg/tests/fft_fr.rs | #[cfg(test)]
mod tests {
use ckzg::fftsettings::{bound_fft_fr_fast, bound_fft_fr_slow, KzgFFTSettings};
use ckzg::finite::BlstFr;
use kzg_bench::tests::fft_fr::{compare_sft_fft, inverse_fft, roundtrip_fft, stride_fft};
#[test]
fn test_roundtrip_fft() {
roundtrip_fft::<BlstFr, KzgFFTSettings>();
}
#[test]
fn test_inverse_fft() {
inverse_fft::<BlstFr, KzgFFTSettings>();
}
#[test]
fn test_stride_fft() {
stride_fft::<BlstFr, KzgFFTSettings>();
}
#[test]
fn test_compare_sft_fft() {
compare_sft_fft::<BlstFr, KzgFFTSettings>(&bound_fft_fr_slow, &bound_fft_fr_fast);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/tests/recover.rs | ckzg/tests/recover.rs | #[cfg(test)]
mod tests {
use ckzg::fftsettings::KzgFFTSettings;
use ckzg::finite::BlstFr;
use ckzg::poly::KzgPoly;
use kzg_bench::tests::recover::*;
#[test]
fn test_recover_simple() {
recover_simple::<BlstFr, KzgFFTSettings, KzgPoly, KzgPoly>();
}
#[test]
fn test_recover_random() {
recover_random::<BlstFr, KzgFFTSettings, KzgPoly, KzgPoly>();
}
#[test]
fn more_than_half_missing_() {
more_than_half_missing::<BlstFr, KzgFFTSettings, KzgPoly, KzgPoly>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/benches/das.rs | ckzg/benches/das.rs | use ckzg::fftsettings::KzgFFTSettings;
use ckzg::finite::BlstFr;
use criterion::{criterion_group, criterion_main, Criterion};
fn bench_das_extension(c: &mut Criterion) {
kzg_bench::benches::das::bench_das_extension::<BlstFr, KzgFFTSettings>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_das_extension
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/benches/eip_4844.rs | ckzg/benches/eip_4844.rs | use ckzg::{
consts::BlstP1,
consts::BlstP2,
eip_4844::{
blob_to_kzg_commitment_rust, compute_aggregate_kzg_proof_rust, load_trusted_setup_rust,
verify_aggregate_kzg_proof_rust,
},
fftsettings4844::KzgFFTSettings4844,
finite::BlstFr,
kzgsettings4844::KzgKZGSettings4844,
poly::KzgPoly,
};
use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::eip_4844::{
bench_compute_aggregate_kzg_proof, bench_verify_aggregate_kzg_proof,
};
fn bench_compute_aggregate_kzg_proof_1(c: &mut Criterion) {
bench_compute_aggregate_kzg_proof::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings4844,
KzgKZGSettings4844,
>(
c,
&load_trusted_setup_rust,
&compute_aggregate_kzg_proof_rust,
1,
)
}
fn bench_compute_aggregate_kzg_proof_2(c: &mut Criterion) {
bench_compute_aggregate_kzg_proof::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings4844,
KzgKZGSettings4844,
>(
c,
&load_trusted_setup_rust,
&compute_aggregate_kzg_proof_rust,
2,
)
}
fn bench_compute_aggregate_kzg_proof_4(c: &mut Criterion) {
bench_compute_aggregate_kzg_proof::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings4844,
KzgKZGSettings4844,
>(
c,
&load_trusted_setup_rust,
&compute_aggregate_kzg_proof_rust,
4,
)
}
fn bench_compute_aggregate_kzg_proof_8(c: &mut Criterion) {
bench_compute_aggregate_kzg_proof::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings4844,
KzgKZGSettings4844,
>(
c,
&load_trusted_setup_rust,
&compute_aggregate_kzg_proof_rust,
8,
)
}
fn bench_compute_aggregate_kzg_proof_16(c: &mut Criterion) {
bench_compute_aggregate_kzg_proof::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings4844,
KzgKZGSettings4844,
>(
c,
&load_trusted_setup_rust,
&compute_aggregate_kzg_proof_rust,
16,
)
}
fn bench_verify_aggregate_kzg_proof_1(c: &mut Criterion) {
bench_verify_aggregate_kzg_proof::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings4844,
KzgKZGSettings4844,
>(
c,
&load_trusted_setup_rust,
&blob_to_kzg_commitment_rust,
&compute_aggregate_kzg_proof_rust,
&verify_aggregate_kzg_proof_rust,
1,
)
}
fn bench_verify_aggregate_kzg_proof_2(c: &mut Criterion) {
bench_verify_aggregate_kzg_proof::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings4844,
KzgKZGSettings4844,
>(
c,
&load_trusted_setup_rust,
&blob_to_kzg_commitment_rust,
&compute_aggregate_kzg_proof_rust,
&verify_aggregate_kzg_proof_rust,
2,
)
}
fn bench_verify_aggregate_kzg_proof_4(c: &mut Criterion) {
bench_verify_aggregate_kzg_proof::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings4844,
KzgKZGSettings4844,
>(
c,
&load_trusted_setup_rust,
&blob_to_kzg_commitment_rust,
&compute_aggregate_kzg_proof_rust,
&verify_aggregate_kzg_proof_rust,
4,
)
}
fn bench_verify_aggregate_kzg_proof_8(c: &mut Criterion) {
bench_verify_aggregate_kzg_proof::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings4844,
KzgKZGSettings4844,
>(
c,
&load_trusted_setup_rust,
&blob_to_kzg_commitment_rust,
&compute_aggregate_kzg_proof_rust,
&verify_aggregate_kzg_proof_rust,
8,
)
}
fn bench_verify_aggregate_kzg_proof_16(c: &mut Criterion) {
bench_verify_aggregate_kzg_proof::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings4844,
KzgKZGSettings4844,
>(
c,
&load_trusted_setup_rust,
&blob_to_kzg_commitment_rust,
&compute_aggregate_kzg_proof_rust,
&verify_aggregate_kzg_proof_rust,
16,
)
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_compute_aggregate_kzg_proof_1, bench_compute_aggregate_kzg_proof_2,
bench_compute_aggregate_kzg_proof_4, bench_compute_aggregate_kzg_proof_8, bench_compute_aggregate_kzg_proof_16,
bench_verify_aggregate_kzg_proof_1, bench_verify_aggregate_kzg_proof_2,
bench_verify_aggregate_kzg_proof_4, bench_verify_aggregate_kzg_proof_8, bench_verify_aggregate_kzg_proof_16
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/benches/fk20.rs | ckzg/benches/fk20.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::fk20::*;
use ckzg::consts::{BlstP1, BlstP2};
use ckzg::fftsettings::KzgFFTSettings;
use ckzg::finite::BlstFr;
use ckzg::fk20settings::{KzgFK20MultiSettings, KzgFK20SingleSettings};
use ckzg::kzgsettings::{generate_trusted_setup, KzgKZGSettings};
use ckzg::poly::KzgPoly;
fn bench_fk_single_da_(c: &mut Criterion) {
bench_fk_single_da::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings,
KzgKZGSettings,
KzgFK20SingleSettings,
>(c, &generate_trusted_setup);
}
fn bench_fk_multi_da_(c: &mut Criterion) {
bench_fk_multi_da::<
BlstFr,
BlstP1,
BlstP2,
KzgPoly,
KzgFFTSettings,
KzgKZGSettings,
KzgFK20MultiSettings,
>(c, &generate_trusted_setup);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_fk_single_da_, bench_fk_multi_da_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/benches/poly.rs | ckzg/benches/poly.rs | use ckzg::finite::BlstFr;
use ckzg::poly::KzgPoly;
use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::poly::bench_new_poly_div;
fn bench_new_poly_div_(c: &mut Criterion) {
bench_new_poly_div::<BlstFr, KzgPoly>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_new_poly_div_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/benches/zero_poly.rs | ckzg/benches/zero_poly.rs | use ckzg::fftsettings::KzgFFTSettings;
use ckzg::finite::BlstFr;
use ckzg::poly::KzgPoly;
use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::zero_poly::bench_zero_poly;
fn bench_zero_poly_(c: &mut Criterion) {
bench_zero_poly::<BlstFr, KzgFFTSettings, KzgPoly>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_zero_poly_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/benches/kzg.rs | ckzg/benches/kzg.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::kzg::bench_commit_to_poly;
use ckzg::consts::{BlstP1, BlstP2};
use ckzg::fftsettings::KzgFFTSettings;
use ckzg::finite::BlstFr;
use ckzg::kzgsettings::{generate_trusted_setup, KzgKZGSettings};
use ckzg::poly::KzgPoly;
fn bench_commit_to_poly_(c: &mut Criterion) {
bench_commit_to_poly::<BlstFr, BlstP1, BlstP2, KzgPoly, KzgFFTSettings, KzgKZGSettings>(
c,
&generate_trusted_setup,
);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_commit_to_poly_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/benches/recover.rs | ckzg/benches/recover.rs | use ckzg::fftsettings::KzgFFTSettings;
use ckzg::finite::BlstFr;
use ckzg::poly::KzgPoly;
use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::recover::bench_recover;
fn bench_recover_(c: &mut Criterion) {
bench_recover::<BlstFr, KzgFFTSettings, KzgPoly, KzgPoly>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_recover_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/ckzg/benches/fft.rs | ckzg/benches/fft.rs | use ckzg::consts::BlstP1;
use ckzg::fftsettings::KzgFFTSettings;
use ckzg::finite::BlstFr;
use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::fft::{bench_fft_fr, bench_fft_g1};
fn bench_fft_fr_(c: &mut Criterion) {
bench_fft_fr::<BlstFr, KzgFFTSettings>(c);
}
fn bench_fft_g1_(c: &mut Criterion) {
bench_fft_g1::<BlstFr, BlstP1, KzgFFTSettings>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_fft_fr_, bench_fft_g1_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/blst-sppark/build.rs | blst-sppark/build.rs | // Copyright Supranational LLC
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
use std::env;
use std::path::PathBuf;
fn main() {
// account for cross-compilation [by examining environment variable]
let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
// Set CC environment variable to choose alternative C compiler.
// Optimization level depends on whether or not --release is passed
// or implied.
let mut cc = cc::Build::new();
let c_src_dir = PathBuf::from("src");
let files = vec![c_src_dir.join("lib.c")];
let mut cc_opt = None;
match (cfg!(feature = "portable"), cfg!(feature = "force-adx")) {
(true, false) => {
println!("Compiling in portable mode without ISA extensions");
cc_opt = Some("__BLST_PORTABLE__");
}
(false, true) => {
if target_arch.eq("x86_64") {
println!("Enabling ADX support via `force-adx` feature");
cc_opt = Some("__ADX__");
} else {
println!("`force-adx` is ignored for non-x86_64 targets");
}
}
(false, false) =>
{
#[cfg(target_arch = "x86_64")]
if target_arch.eq("x86_64") && std::is_x86_feature_detected!("adx") {
println!("Enabling ADX because it was detected on the host");
cc_opt = Some("__ADX__");
}
}
(true, true) => panic!("Cannot compile with both `portable` and `force-adx` features"),
}
cc.flag_if_supported("-mno-avx") // avoid costly transitions
.flag_if_supported("-fno-builtin")
.flag_if_supported("-Wno-unused-command-line-argument");
if !cfg!(debug_assertions) {
cc.opt_level(2);
}
if let Some(def) = cc_opt {
cc.define(def, None);
}
if let Some(include) = env::var_os("DEP_BLST_C_SRC") {
cc.include(include);
}
cc.files(&files).compile("msm_cuda");
if cfg!(target_os = "windows") && !cfg!(target_env = "msvc") {
return;
}
// Detect if there is CUDA compiler and engage "cuda" feature accordingly
let nvcc = match env::var("NVCC") {
Ok(var) => which::which(var),
Err(_) => which::which("nvcc"),
};
if nvcc.is_ok() {
let mut nvcc = cc::Build::new();
nvcc.cuda(true);
nvcc.flag("-arch=sm_80");
nvcc.flag("-gencode").flag("arch=compute_70,code=sm_70");
nvcc.flag("-t0");
if cfg!(feature = "quiet") {
nvcc.flag("-diag-suppress=177"); // bug in the warning system.
}
#[cfg(not(target_env = "msvc"))]
nvcc.flag("-Xcompiler").flag("-Wno-unused-function");
nvcc.define("TAKE_RESPONSIBILITY_FOR_ERROR_MESSAGE", None);
if let Some(def) = cc_opt {
nvcc.define(def, None);
}
if let Some(include) = env::var_os("DEP_BLST_C_SRC") {
nvcc.include(include);
}
if let Some(include) = env::var_os("DEP_SPPARK_ROOT") {
nvcc.include(include);
}
nvcc.file("cuda/pippenger.cu").compile("blst_cuda_msm");
println!("cargo:rustc-cfg=feature=\"cuda\"");
println!("cargo:rerun-if-changed=cuda");
println!("cargo:rerun-if-env-changed=CXXFLAGS");
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/blst-sppark/src/lib.rs | blst-sppark/src/lib.rs | // Copyright Supranational LLC
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
use blst::*;
use std::ffi::c_void;
pub fn prepare_multi_scalar_mult(points: &[blst_p1_affine]) -> *mut c_void {
#[cfg_attr(feature = "quiet", allow(improper_ctypes))]
extern "C" {
fn prepare_msm(points: *const blst_p1_affine, npoints: usize) -> *mut c_void;
}
let npoints = points.len();
unsafe { prepare_msm(&points[0], npoints) }
}
pub fn multi_scalar_mult_prepared(msm: *mut c_void, scalars: &[blst_fr]) -> blst_p1 {
#[cfg_attr(feature = "quiet", allow(improper_ctypes))]
extern "C" {
fn mult_pippenger_prepared(
msm: *mut c_void,
out: *mut blst_p1,
npoints: usize,
scalars: *const blst_fr,
) -> sppark::Error;
}
let npoints = scalars.len();
let mut ret = blst_p1::default();
let err = unsafe { mult_pippenger_prepared(msm, &mut ret, npoints, &scalars[0]) };
if err.code != 0 {
panic!("{}", String::from(err));
}
ret
}
pub fn multi_scalar_mult(points: &[blst_p1_affine], scalars: &[blst_fr]) -> blst_p1 {
#[cfg_attr(feature = "quiet", allow(improper_ctypes))]
extern "C" {
fn mult_pippenger(
out: *mut blst_p1,
points: *const blst_p1_affine,
npoints: usize,
scalars: *const blst_fr,
) -> sppark::Error;
}
let npoints = points.len();
if npoints != scalars.len() {
panic!("length mismatch")
}
let mut ret = blst_p1::default();
let err = unsafe { mult_pippenger(&mut ret, &points[0], npoints, &scalars[0]) };
if err.code != 0 {
panic!("{}", String::from(err));
}
ret
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/blst-sppark/benches/lincomb.rs | blst-sppark/benches/lincomb.rs | use blst::{blst_fr, blst_p1_affine};
use criterion::{criterion_group, criterion_main, Criterion};
use kzg::Fr;
use kzg::G1;
use rust_kzg_blst::types::fp::FsFp;
use rust_kzg_blst::types::fr::FsFr;
use rust_kzg_blst::types::g1::{FsG1, FsG1Affine};
extern crate alloc;
fn bench_g1_lincomb(c: &mut Criterion) {
const NUM_POINTS: usize = 1usize << 21;
let points = (0..NUM_POINTS)
.into_iter()
.map(|_| FsG1::rand())
.collect::<Vec<_>>();
let scalars = (0..NUM_POINTS)
.into_iter()
.map(|_| FsFr::rand())
.collect::<Vec<_>>();
let affines = kzg::msm::msm_impls::batch_convert::<FsG1, FsFp, FsG1Affine>(&points);
let scalars =
unsafe { alloc::slice::from_raw_parts(scalars.as_ptr() as *const blst_fr, scalars.len()) };
let affines = unsafe {
alloc::slice::from_raw_parts(affines.as_ptr() as *const blst_p1_affine, affines.len())
};
let id = format!("bench_g1_lincomb points: '{}'", NUM_POINTS);
c.bench_function(&id, |b| {
b.iter(|| {
rust_kzg_blst_sppark::multi_scalar_mult(&affines, &scalars);
})
});
let msm = rust_kzg_blst_sppark::prepare_multi_scalar_mult(&affines);
let id = format!("bench_g1_lincomb points (prepared, mont): '{}'", NUM_POINTS);
c.bench_function(&id, |b| {
b.iter(|| {
rust_kzg_blst_sppark::multi_scalar_mult_prepared(msm, &scalars);
})
});
}
criterion_group! {
name = benches;
config = Criterion::default()/*.sample_size(100)*/;
targets = bench_g1_lincomb
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3-sppark-wlc/build.rs | arkworks3-sppark-wlc/build.rs | // Copyright Supranational LLC
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
use std::env;
use std::path::PathBuf;
fn main() {
let curve = "FEATURE_BLS12_377";
// account for cross-compilation [by examining environment variable]
let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
// Set CC environment variable to choose alternative C compiler.
// Optimization level depends on whether or not --release is passed
// or implied.
let mut cc = cc::Build::new();
let c_src_dir = PathBuf::from("src");
let files = vec![c_src_dir.join("lib.c")];
let mut cc_opt = None;
match (cfg!(feature = "portable"), cfg!(feature = "force-adx")) {
(true, false) => {
println!("Compiling in portable mode without ISA extensions");
cc_opt = Some("__BLST_PORTABLE__");
}
(false, true) => {
if target_arch.eq("x86_64") {
println!("Enabling ADX support via `force-adx` feature");
cc_opt = Some("__ADX__");
} else {
println!("`force-adx` is ignored for non-x86_64 targets");
}
}
(false, false) =>
{
#[cfg(target_arch = "x86_64")]
if target_arch.eq("x86_64") && std::is_x86_feature_detected!("adx") {
println!("Enabling ADX because it was detected on the host");
cc_opt = Some("__ADX__");
}
}
(true, true) => panic!("Cannot compile with both `portable` and `force-adx` features"),
}
cc.flag_if_supported("-mno-avx") // avoid costly transitions
.flag_if_supported("-fno-builtin")
.flag_if_supported("-Wno-unused-command-line-argument");
if !cfg!(debug_assertions) {
cc.opt_level(2);
}
if let Some(def) = cc_opt {
cc.define(def, None);
}
if let Some(include) = env::var_os("DEP_BLST_C_SRC") {
cc.include(include);
}
cc.files(&files).compile("blst_msm");
if cfg!(target_os = "windows") && !cfg!(target_env = "msvc") {
return;
}
// Detect if there is CUDA compiler and engage "cuda" feature accordingly
let nvcc = match env::var("NVCC") {
Ok(var) => which::which(var),
Err(_) => which::which("nvcc"),
};
if nvcc.is_ok() {
let mut nvcc = cc::Build::new();
nvcc.cuda(true);
nvcc.flag("-arch=sm_70");
nvcc.flag("-maxrregcount=255");
nvcc.flag("--default-stream=per-thread");
nvcc.flag("-Xcompiler").flag("-Wno-unused-function");
nvcc.define("TAKE_RESPONSIBILITY_FOR_ERROR_MESSAGE", None);
nvcc.define(curve, None);
if let Some(def) = cc_opt {
nvcc.define(def, None);
}
if let Some(include) = env::var_os("DEP_BLST_C_SRC") {
nvcc.include(include);
}
if let Some(include) = env::var_os("DEP_SPPARK_BAL_ROOT") {
nvcc.include(include);
}
nvcc.file("cuda/pippenger_inf.cu").compile("blst_cuda_msm");
println!("cargo:rustc-cfg=feature=\"cuda\"");
println!("cargo:rerun-if-changed=cuda");
println!("cargo:rerun-if-env-changed=CXXFLAGS");
} else {
panic!("nvcc must be in the path. Consider adding /usr/local/cuda/bin.")
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3-sppark-wlc/src/lib.rs | arkworks3-sppark-wlc/src/lib.rs | // Copyright Supranational LLC
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
use ark_bls12_381::{Fr, G1Affine};
use ark_ec::AffineCurve;
use ark_ff::PrimeField;
use ark_std::Zero;
use std::os::raw::c_void;
#[allow(unused_imports)]
use blst::*;
sppark_bal::cuda_error!();
pub mod util;
#[repr(C)]
pub struct MultiScalarMultContext {
pub context: *mut c_void,
}
#[cfg_attr(feature = "quiet", allow(improper_ctypes))]
extern "C" {
fn mult_pippenger_faster_init(
context: *mut MultiScalarMultContext,
points_with_infinity: *const G1Affine,
npoints: usize,
ffi_affine_sz: usize,
) -> cuda::Error;
fn mult_pippenger_faster_inf(
context: *mut MultiScalarMultContext,
out: *mut u64,
npoints: usize,
batch_size: usize,
scalars: *const Fr,
ffi_affine_sz: usize,
) -> cuda::Error;
fn mult_pippenger_faster_free(context: *mut MultiScalarMultContext);
}
pub fn multi_scalar_mult_init<G: AffineCurve>(points: &[G]) -> MultiScalarMultContext {
let mut ret = MultiScalarMultContext {
context: std::ptr::null_mut(),
};
let err = unsafe {
mult_pippenger_faster_init(
&mut ret,
points as *const _ as *const G1Affine,
points.len(),
std::mem::size_of::<G1Affine>(),
)
};
if err.code != 0 {
panic!("{}", String::from(err));
}
ret
}
pub fn multi_scalar_mult_free(context: &mut MultiScalarMultContext) {
unsafe {
mult_pippenger_faster_free(context);
}
}
pub fn multi_scalar_mult<G: AffineCurve>(
context: &mut MultiScalarMultContext,
npoints: usize,
scalars: &[<G::ScalarField as PrimeField>::BigInt],
) -> Vec<G::Projective> {
if scalars.len() % npoints != 0 {
panic!("length mismatch")
}
let batch_size = scalars.len() / npoints;
let mut ret = vec![G::Projective::zero(); batch_size];
let err = unsafe {
let result_ptr = &mut *(&mut ret as *mut Vec<G::Projective> as *mut Vec<u64>);
mult_pippenger_faster_inf(
context,
result_ptr.as_mut_ptr(),
npoints,
batch_size,
scalars as *const _ as *const Fr,
std::mem::size_of::<G1Affine>(),
)
};
if err.code != 0 {
panic!("{}", String::from(err));
}
ret
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3-sppark-wlc/src/util.rs | arkworks3-sppark-wlc/src/util.rs | // Copyright Supranational LLC
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
use rand::SeedableRng;
use rand_chacha::ChaCha20Rng;
use ark_ec::{AffineCurve, ProjectiveCurve};
use ark_std::UniformRand;
use ark_ff::prelude::*;
use ark_std::vec::Vec;
pub fn generate_points_scalars<G: AffineCurve>(
len: usize,
batch_size: usize,
) -> (Vec<G>, Vec<G::ScalarField>) {
let rand_gen: usize = 1 << 11;
let mut rng = ChaCha20Rng::from_entropy();
let mut points = <G::Projective as ProjectiveCurve>::batch_normalization_into_affine(
&(0..rand_gen)
.map(|_| G::Projective::rand(&mut rng))
.collect::<Vec<_>>(),
);
// Sprinkle in some infinity points
// points[3] = G::zero();
while points.len() < len {
points.append(&mut points.clone());
}
let points = &points[0..len];
let scalars = (0..len * batch_size)
.map(|_| G::ScalarField::rand(&mut rng))
.collect::<Vec<_>>();
(points.to_vec(), scalars)
}
#[cfg(feature = "parallel")]
use rayon::prelude::*;
pub struct VariableBaseMSM2;
impl VariableBaseMSM2 {
pub fn multi_scalar_mul<G: AffineCurve>(
bases: &[G],
scalars: &[<G::ScalarField as PrimeField>::BigInt],
) -> G::Projective {
let size = ark_std::cmp::min(bases.len(), scalars.len());
let scalars = &scalars[..size];
let bases = &bases[..size];
let scalars_and_bases_iter = scalars.iter().zip(bases).filter(|(s, _)| !s.is_zero());
// let c = if size < 32 {
// 3
// } else {
// super::ln_without_floats(size) + 2
// };
let c = 21;
let num_bits = <G::ScalarField as PrimeField>::Params::MODULUS_BITS as usize;
let fr_one = G::ScalarField::one().into_repr();
let zero = G::Projective::zero();
let window_starts: Vec<_> = (0..num_bits).step_by(c).collect();
// Each window is of size `c`.
// We divide up the bits 0..num_bits into windows of size `c`, and
// in parallel process each such window.
let window_sums: Vec<_> = ark_std::cfg_into_iter!(window_starts)
.map(|w_start| {
let mut res = zero;
// let mut count = 0;
// We don't need the "zero" bucket, so we only have 2^c - 1 buckets.
let mut buckets = vec![zero; (1 << c) - 1];
// This clone is cheap, because the iterator contains just a
// pointer and an index into the original vectors.
scalars_and_bases_iter.clone().for_each(|(&scalar, base)| {
if scalar == fr_one {
// We only process unit scalars once in the first window.
if w_start == 0 {
res.add_assign_mixed(base);
}
} else {
let mut scalar = scalar;
// We right-shift by w_start, thus getting rid of the
// lower bits.
scalar.divn(w_start as u32);
// We mod the remaining bits by 2^{window size}, thus taking `c` bits.
let scalar = scalar.as_ref()[0] % (1 << c);
// If the scalar is non-zero, we update the corresponding
// bucket.
// (Recall that `buckets` doesn't have a zero bucket.)
// if w_start != 252{
if scalar != 0 {
buckets[(scalar - 1) as usize].add_assign_mixed(base);
}
// }
}
});
// Compute sum_{i in 0..num_buckets} (sum_{j in i..num_buckets} bucket[j])
// This is computed below for b buckets, using 2b curve additions.
//
// We could first normalize `buckets` and then use mixed-addition
// here, but that's slower for the kinds of groups we care about
// (Short Weierstrass curves and Twisted Edwards curves).
// In the case of Short Weierstrass curves,
// mixed addition saves ~4 field multiplications per addition.
// However normalization (with the inversion batched) takes ~6
// field multiplications per element,
// hence batch normalization is a slowdown.
// `running_sum` = sum_{j in i..num_buckets} bucket[j],
// where we iterate backward from i = num_buckets to 0.
let mut running_sum = G::Projective::zero();
buckets.into_iter().rev().for_each(|b| {
running_sum += &b;
res += &running_sum;
});
res
})
.collect();
// We store the sum for the lowest window.
let lowest = *window_sums.first().unwrap();
// let mm = window_sums[1..]
// .iter()
// .rev()
// .fold(zero, |mut total, sum_i| {
// total += sum_i;
// // for _ in 0..c {
// // total.double_in_place();
// // }
// total
// });
// We're traversing windows from high to low.
lowest
+ &window_sums[1..]
.iter()
.rev()
.fold(zero, |mut total, sum_i| {
total += sum_i;
for _ in 0..c {
total.double_in_place();
}
total
})
// if mm == zero{
// panic!("zero!");
// }
// mm
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3-sppark-wlc/tests/msm.rs | arkworks3-sppark-wlc/tests/msm.rs | // Copyright Supranational LLC
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
use ark_bls12_381::G1Affine;
use ark_ec::msm::VariableBaseMSM;
use ark_ec::ProjectiveCurve;
use ark_ff::BigInteger256;
use std::str::FromStr;
use blst_msm::*;
#[test]
fn msm_correctness() {
let test_npow = std::env::var("TEST_NPOW").unwrap_or("19".to_string());
let npoints_npow = i32::from_str(&test_npow).unwrap();
let batches = 4;
let (points, scalars) =
util::generate_points_scalars::<G1Affine>(1usize << npoints_npow, batches);
let mut context = multi_scalar_mult_init(points.as_slice());
let msm_results = multi_scalar_mult(&mut context, points.as_slice(), unsafe {
std::mem::transmute::<&[_], &[BigInteger256]>(scalars.as_slice())
});
for b in 0..batches {
let start = b * points.len();
let end = (b + 1) * points.len();
let arkworks_result = VariableBaseMSM::multi_scalar_mul(points.as_slice(), unsafe {
std::mem::transmute::<&[_], &[BigInteger256]>(&scalars[start..end])
})
.into_affine();
assert_eq!(msm_results[b].into_affine(), arkworks_result);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3-sppark-wlc/benches/msm.rs | arkworks3-sppark-wlc/benches/msm.rs | // Copyright Supranational LLC
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
use criterion::{criterion_group, criterion_main, Criterion};
use ark_bls12_381::G1Affine;
use ark_ff::BigInteger256;
use std::str::FromStr;
use rust_kzg_arkworks3_sppark_wlc::*;
fn criterion_benchmark(c: &mut Criterion) {
let bench_npow = std::env::var("BENCH_NPOW").unwrap_or("20".to_string());
let npoints_npow = i32::from_str(&bench_npow).unwrap();
let batches = 16;
let (points, scalars) =
util::generate_points_scalars::<G1Affine>(1usize << npoints_npow, batches);
let mut context = multi_scalar_mult_init(points.as_slice());
let mut group = c.benchmark_group("CUDA");
group.sample_size(10);
let name = format!("2**{}x{}", npoints_npow, batches);
group.bench_function(name, |b| {
b.iter(|| {
let _ = multi_scalar_mult(&mut context, &points.as_slice(), unsafe {
std::mem::transmute::<&[_], &[BigInteger256]>(scalars.as_slice())
});
})
});
group.finish();
}
criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3-sppark-wlc/sppark/rust/build.rs | arkworks3-sppark-wlc/sppark/rust/build.rs | // Copyright Supranational LLC
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
use std::env;
use std::path::PathBuf;
fn main() {
let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
let mut base_dir = manifest_dir.join("sppark");
if !base_dir.exists() {
// Reach out to .., which is the root of the sppark repo.
// Use an absolute path to avoid issues with relative paths
// being treated as strings by `cc` and getting concatenated
// in ways that reach out of the OUT_DIR.
base_dir = manifest_dir
.parent()
.expect("can't access parent of current directory")
.into();
println!(
"cargo:rerun-if-changed={}",
base_dir.join("ec").to_string_lossy()
);
println!(
"cargo:rerun-if-changed={}",
base_dir.join("ff").to_string_lossy()
);
println!(
"cargo:rerun-if-changed={}",
base_dir.join("msm").to_string_lossy()
);
println!(
"cargo:rerun-if-changed={}",
base_dir.join("util").to_string_lossy()
);
}
// pass DEP_SPPARK_* variables to dependents
println!("cargo:ROOT={}", base_dir.to_string_lossy());
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3-sppark-wlc/sppark/rust/src/lib.rs | arkworks3-sppark-wlc/sppark/rust/src/lib.rs | // Copyright Supranational LLC
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
#[macro_export]
macro_rules! cuda_error {
() => {
// Declare C/C++ counterpart as following:
// extern "C" { fn foobar(...) -> cuda::Error; }
mod cuda {
#[repr(C)]
pub struct Error {
pub code: i32,
str: Option<core::ptr::NonNull<i8>>, // just strdup("string") from C/C++
}
impl Drop for Error {
fn drop(&mut self) {
extern "C" {
fn free(str: Option<core::ptr::NonNull<i8>>);
}
unsafe { free(self.str) };
self.str = None;
}
}
impl From<Error> for String {
fn from(status: Error) -> Self {
let c_str = if let Some(ptr) = status.str {
unsafe { std::ffi::CStr::from_ptr(ptr.as_ptr()) }
} else {
extern "C" {
fn cudaGetErrorString(code: i32) -> *const i8;
}
unsafe { std::ffi::CStr::from_ptr(cudaGetErrorString(status.code)) }
};
String::from(c_str.to_str().unwrap_or("unintelligible"))
}
}
}
};
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/fuzz/src/lib.rs | fuzz/src/lib.rs | use std::{
env,
fs::File,
io::{self, Write},
iter,
path::PathBuf,
sync::OnceLock,
};
use kzg::{
msm::{
msm_impls::{msm, pippenger},
precompute::{precompute, PrecomputationTable},
},
Fr, G1,
};
use rand::{Rng, SeedableRng};
use rand_chacha::ChaCha20Rng;
use rust_kzg_blst::types::{
fp::FsFp,
fr::FsFr,
g1::{FsG1, FsG1Affine, FsG1ProjAddAffine},
};
use sha2::Digest;
static NPOINTS: OnceLock<usize> = OnceLock::new();
pub fn get_npoints() -> usize {
NPOINTS
.get_or_init(|| {
let npow: usize = env::var("NPOW").unwrap_or("12".to_owned()).parse().unwrap();
let npoints: usize = 1usize << npow;
npoints
})
.clone()
}
static SEED: OnceLock<<ChaCha20Rng as SeedableRng>::Seed> = OnceLock::new();
pub fn seed() -> <ChaCha20Rng as SeedableRng>::Seed {
SEED.get_or_init(|| rand::thread_rng().gen()).clone()
}
static BACKENDS: OnceLock<Vec<Backend>> = OnceLock::new();
pub fn cached_backends(points: &[[u8; 48]]) -> &[Backend] {
BACKENDS.get_or_init(|| {
vec![
Backend::blst(points),
#[cfg(feature = "arkworks3")]
Backend::arkworks3(points),
#[cfg(feature = "arkworks4")]
Backend::arkworks4(points),
#[cfg(feature = "arkworks5")]
Backend::arkworks5(points),
#[cfg(feature = "constantine")]
Backend::constantine(points),
#[cfg(feature = "mcl")]
Backend::mcl(points),
#[cfg(feature = "zkcrypto")]
Backend::zkcrypto(points),
]
})
}
pub fn backends(points: &[[u8; 48]]) -> Vec<Backend> {
vec![
Backend::blst(points),
#[cfg(feature = "arkworks3")]
Backend::arkworks3(points),
#[cfg(feature = "arkworks4")]
Backend::arkworks4(points),
#[cfg(feature = "arkworks5")]
Backend::arkworks5(points),
#[cfg(feature = "constantine")]
Backend::constantine(points),
#[cfg(feature = "mcl")]
Backend::mcl(points),
#[cfg(feature = "zkcrypto")]
Backend::zkcrypto(points),
]
}
pub fn compute_expected_value(points: &[[u8; 48]], scalars: &[[u8; 32]]) -> [u8; 48] {
let points = points
.iter()
.map(|bytes| FsG1::from_bytes(bytes))
.collect::<Result<Vec<_>, _>>()
.unwrap();
let scalars = scalars
.iter()
.map(|bytes| FsFr::from_bytes(bytes))
.collect::<Result<Vec<_>, _>>()
.unwrap();
pippenger::<FsFr, FsG1, FsFp, FsG1Affine, FsG1ProjAddAffine>(&points, &scalars).to_bytes()
}
pub enum Backend {
Blst {
points: Vec<FsG1>,
table: Option<PrecomputationTable<FsFr, FsG1, FsFp, FsG1Affine, FsG1ProjAddAffine>>,
},
#[cfg(feature = "arkworks3")]
Arkworks3 {
points: Vec<rust_kzg_arkworks3::kzg_types::ArkG1>,
table: Option<
PrecomputationTable<
rust_kzg_arkworks3::kzg_types::ArkFr,
rust_kzg_arkworks3::kzg_types::ArkG1,
rust_kzg_arkworks3::kzg_types::ArkFp,
rust_kzg_arkworks3::kzg_types::ArkG1Affine,
rust_kzg_arkworks3::kzg_types::ArkG1ProjAddAffine,
>,
>,
},
#[cfg(feature = "arkworks4")]
Arkworks4 {
points: Vec<rust_kzg_arkworks4::kzg_types::ArkG1>,
table: Option<
PrecomputationTable<
rust_kzg_arkworks4::kzg_types::ArkFr,
rust_kzg_arkworks4::kzg_types::ArkG1,
rust_kzg_arkworks4::kzg_types::ArkFp,
rust_kzg_arkworks4::kzg_types::ArkG1Affine,
rust_kzg_arkworks4::kzg_types::ArkG1ProjAddAffine,
>,
>,
},
#[cfg(feature = "arkworks5")]
Arkworks5 {
points: Vec<rust_kzg_arkworks5::kzg_types::ArkG1>,
table: Option<
PrecomputationTable<
rust_kzg_arkworks5::kzg_types::ArkFr,
rust_kzg_arkworks5::kzg_types::ArkG1,
rust_kzg_arkworks5::kzg_types::ArkFp,
rust_kzg_arkworks5::kzg_types::ArkG1Affine,
rust_kzg_arkworks5::kzg_types::ArkG1ProjAddAffine,
>,
>,
},
#[cfg(feature = "constantine")]
Constantine {
points: Vec<rust_kzg_constantine::types::g1::CtG1>,
table: Option<
PrecomputationTable<
rust_kzg_constantine::types::fr::CtFr,
rust_kzg_constantine::types::g1::CtG1,
rust_kzg_constantine::types::fp::CtFp,
rust_kzg_constantine::types::g1::CtG1Affine,
rust_kzg_constantine::types::g1::CtG1ProjAddAffine,
>,
>,
},
#[cfg(feature = "mcl")]
Mcl {
points: Vec<rust_kzg_mcl::types::g1::MclG1>,
table: Option<
PrecomputationTable<
rust_kzg_mcl::types::fr::MclFr,
rust_kzg_mcl::types::g1::MclG1,
rust_kzg_mcl::types::fp::MclFp,
rust_kzg_mcl::types::g1::MclG1Affine,
rust_kzg_mcl::types::g1::MclG1ProjAddAffine,
>,
>,
},
#[cfg(feature = "zkcrypto")]
Zkcrypto {
points: Vec<rust_kzg_zkcrypto::kzg_types::ZG1>,
table: Option<
PrecomputationTable<
rust_kzg_zkcrypto::kzg_types::ZFr,
rust_kzg_zkcrypto::kzg_types::ZG1,
rust_kzg_zkcrypto::kzg_types::ZFp,
rust_kzg_zkcrypto::kzg_types::ZG1Affine,
rust_kzg_zkcrypto::kzg_types::ZG1ProjAddAffine,
>,
>,
},
}
impl Backend {
pub fn blst(points: &[[u8; 48]]) -> Self {
let points = points
.iter()
.map(|p| FsG1::from_bytes(p))
.collect::<Result<Vec<_>, _>>()
.unwrap();
Self::Blst {
table: precompute(&points, &[]).unwrap(),
points,
}
}
#[cfg(feature = "arkworks3")]
pub fn arkworks3(points: &[[u8; 48]]) -> Self {
use rust_kzg_arkworks3::kzg_types::ArkG1;
let points = points
.iter()
.map(|p| ArkG1::from_bytes(p))
.collect::<Result<Vec<_>, _>>()
.unwrap();
Self::Arkworks3 {
table: precompute(&points, &[]).unwrap(),
points,
}
}
#[cfg(feature = "arkworks4")]
pub fn arkworks4(points: &[[u8; 48]]) -> Self {
use rust_kzg_arkworks4::kzg_types::ArkG1;
let points = points
.iter()
.map(|p| ArkG1::from_bytes(p))
.collect::<Result<Vec<_>, _>>()
.unwrap();
Self::Arkworks4 {
table: precompute(&points, &[]).unwrap(),
points,
}
}
#[cfg(feature = "arkworks5")]
pub fn arkworks5(points: &[[u8; 48]]) -> Self {
use rust_kzg_arkworks5::kzg_types::ArkG1;
let points = points
.iter()
.map(|p| ArkG1::from_bytes(p))
.collect::<Result<Vec<_>, _>>()
.unwrap();
Self::Arkworks5 {
table: precompute(&points, &[]).unwrap(),
points,
}
}
#[cfg(feature = "constantine")]
pub fn constantine(points: &[[u8; 48]]) -> Self {
use rust_kzg_constantine::types::g1::CtG1;
let points = points
.iter()
.map(|p| CtG1::from_bytes(p))
.collect::<Result<Vec<_>, _>>()
.unwrap();
Self::Constantine {
table: precompute(&points, &[]).unwrap(),
points,
}
}
#[cfg(feature = "mcl")]
pub fn mcl(points: &[[u8; 48]]) -> Self {
use rust_kzg_mcl::types::g1::MclG1;
let points = points
.iter()
.map(|p| MclG1::from_bytes(p))
.collect::<Result<Vec<_>, _>>()
.unwrap();
Self::Mcl {
table: precompute(&points, &[]).unwrap(),
points,
}
}
#[cfg(feature = "zkcrypto")]
pub fn zkcrypto(points: &[[u8; 48]]) -> Self {
use rust_kzg_zkcrypto::kzg_types::ZG1;
let points = points
.iter()
.map(|p| ZG1::from_bytes(p))
.collect::<Result<Vec<_>, _>>()
.unwrap();
Self::Zkcrypto {
table: precompute(&points, &[]).unwrap(),
points,
}
}
pub fn name(&self) -> String {
match self {
Self::Blst { .. } => "blst".to_owned(),
#[cfg(feature = "arkworks3")]
Self::Arkworks3 { .. } => "arkworks3".to_owned(),
#[cfg(feature = "arkworks4")]
Self::Arkworks4 { .. } => "arkworks4".to_owned(),
#[cfg(feature = "arkworks5")]
Self::Arkworks5 { .. } => "arkworks5".to_owned(),
#[cfg(feature = "constantine")]
Self::Constantine { .. } => "constantine".to_owned(),
#[cfg(feature = "mcl")]
Self::Mcl { .. } => "mcl".to_owned(),
#[cfg(feature = "zkcrypto")]
Self::Zkcrypto { .. } => "zkcrypto".to_owned(),
}
}
pub fn save_case(&self, points: &[[u8; 48]], scalars: &[[u8; 32]]) -> io::Result<()> {
let hash: [u8; 32] = {
let mut hasher = sha2::Sha256::new();
for p in points {
hasher.update(p);
}
for s in scalars {
hasher.update(s);
}
hasher.finalize().into()
};
let failing_case_path =
PathBuf::from(format!("./failing_case_{}.rs", hex::encode(&hash[0..8])));
let mut w = File::create(&failing_case_path).expect("failed to save test case");
let (point_name, scalar_name, fp_name, affine_name, proj_add_affine_name) = match self {
Self::Blst { .. } => ("FsG1", "FsFr", "FsFp", "FsG1Affine", "FsG1ProjAddAffine"),
#[cfg(feature = "arkworks3")]
Self::Arkworks3 { .. } => (
"ArkG1",
"ArkFr",
"ArkFp",
"ArkG1Affine",
"ArkG1ProjAddAffine",
),
#[cfg(feature = "arkworks4")]
Self::Arkworks4 { .. } => (
"ArkG1",
"ArkFr",
"ArkFp",
"ArkG1Affine",
"ArkG1ProjAddAffine",
),
#[cfg(feature = "arkworks5")]
Self::Arkworks5 { .. } => (
"ArkG1",
"ArkFr",
"ArkFp",
"ArkG1Affine",
"ArkG1ProjAddAffine",
),
#[cfg(feature = "constantine")]
Self::Constantine { .. } => ("CtG1", "CtFr", "CtFp", "CtG1Affine", "CtG1ProjAddAffine"),
#[cfg(feature = "mcl")]
Self::Mcl { .. } => (
"MclG1",
"MclFr",
"MclFp",
"MclG1Affine",
"MclG1ProjAddAffine",
),
#[cfg(feature = "zkcrypto")]
Self::Zkcrypto { .. } => ("ZG1", "ZFr", "ZFp", "ZG1Affine", "ZG1ProjAddAffine"),
};
writeln!(w, "#[test]")?;
writeln!(w, "fn failing_fuzz_case() {{")?;
writeln!(
w,
"\tuse kzg::{{msm::{{msm_impls::msm, precompute::precompute}}, Fr, G1Mul, G1}};"
)?;
match self {
Self::Blst { .. } => writeln!(w, "\tuse rust_kzg_blst::types::{{fp::FsFp, fr::FsFr, g1::{{FsG1, FsG1Affine, FsG1ProjAddAffine}}}};")?,
#[cfg(feature = "arkworks3")]
Self::Arkworks3 { .. } => writeln!(w, "\tuse rust_kzg_arkworks3::kzg_types::{{ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine, ArkFr}};")?,
#[cfg(feature = "arkworks4")]
Self::Arkworks4 { .. } => writeln!(w, "\tuse rust_kzg_arkworks4::kzg_types::{{ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine, ArkFr}};")?,
#[cfg(feature = "arkworks5")]
Self::Arkworks5 { .. } => writeln!(w, "\tuse rust_kzg_arkworks5::kzg_types::{{ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine, ArkFr}};")?,
#[cfg(feature = "constantine")]
Self::Constantine { .. } => writeln!(w, "\tuse rust_kzg_constantine::types::{{fp::CtFp, fr::CtFr, g1::{{CtG1, CtG1Affine, CtG1ProjAddAffine}}}};")?,
#[cfg(feature = "mcl")]
Self::Mcl { .. } => writeln!(w, "\tuse rust_kzg_mcl::types::{{fp::MclFp, fr::MclFr, g1::{{MclG1, MclG1Affine, MclG1ProjAddAffine}}}};")?,
#[cfg(feature = "zkcrypto")]
Self::Zkcrypto { .. } => writeln!(w, "\tuse rust_kzg_zkcrypto::kzg_types::{{ZG1, ZFp, ZG1Affine, ZG1ProjAddAffine, ZFr}};")?,
};
writeln!(w)?;
writeln!(w, "\tlet points = vec![")?;
for p in points {
if FsG1::from_bytes(p).unwrap().is_inf() {
writeln!(w, "\t\t{point_name}::zero(),")?;
} else {
let h = hex::encode(p);
writeln!(w, "\t\t{point_name}::from_hex(\"0x{h}\").unwrap(),")?;
}
}
writeln!(w, "\t];")?;
writeln!(w, "")?;
writeln!(w, "\tlet scalars = vec![")?;
for s in scalars {
let scalar = FsFr::from_bytes(s).unwrap();
if scalar.is_zero() {
writeln!(w, "\t\t{scalar_name}::zero(),")?;
} else if scalar.is_one() {
writeln!(w, "\t\t{scalar_name}::one(),")?;
} else if FsFr::from_u64(scalar.to_u64_arr()[0]).to_bytes() == *s {
writeln!(
w,
"\t\t{scalar_name}::from_u64({}),",
scalar.to_u64_arr()[0]
)?;
} else {
let h = hex::encode(s);
writeln!(w, "\t\t{scalar_name}::from_hex(\"0x{h}\").unwrap(),")?;
}
}
writeln!(w, "\t];")?;
writeln!(w, "")?;
writeln!(w, "\tlet mut expected = {}::zero();", point_name)?;
writeln!(w, "")?;
writeln!(w, "\tfor (p, s) in points.iter().zip(scalars.iter()) {{")?;
writeln!(w, "\t\texpected.add_or_dbl_assign(&p.mul(s));")?;
writeln!(w, "\t}}")?;
writeln!(w, "")?;
writeln!(w, "\tlet table = precompute(&points, &[]).unwrap();")?;
writeln!(w, "\tlet received = msm::<{}, {}, {}, {}, {}>(&points, &scalars, points.len(), table.as_ref());",
point_name, fp_name, affine_name, proj_add_affine_name, scalar_name)?;
writeln!(w, "")?;
writeln!(w, "\tassert!(expected.equals(&received));")?;
writeln!(w, "}}")?;
let str = format!(
"│ Failing test case successfully saved to {} │",
failing_case_path.display()
);
let strlen = str.chars().count();
println!(
"\n\n┌{}┐",
iter::repeat('─').take(strlen - 2).collect::<String>()
);
println!("{}", str);
println!(
"└{}┘\n\n",
iter::repeat('─').take(strlen - 2).collect::<String>()
);
Ok(())
}
pub fn multiply(&self, scalars: &[[u8; 32]]) -> [u8; 48] {
match self {
Self::Blst { points, table } => {
let scalars = scalars
.iter()
.map(|b| FsFr::from_bytes(b))
.collect::<Result<Vec<_>, _>>()
.unwrap();
let result = msm::<FsG1, FsFp, FsG1Affine, FsG1ProjAddAffine, FsFr>(
&points,
&scalars,
points.len(),
table.as_ref(),
);
result.to_bytes()
}
#[cfg(feature = "arkworks3")]
Self::Arkworks3 { points, table } => {
use rust_kzg_arkworks3::kzg_types::{
ArkFp, ArkFr, ArkG1, ArkG1Affine, ArkG1ProjAddAffine,
};
let scalars = scalars
.iter()
.map(|b| ArkFr::from_bytes(b))
.collect::<Result<Vec<_>, _>>()
.unwrap();
let result = msm::<ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine, ArkFr>(
&points,
&scalars,
points.len(),
table.as_ref(),
);
result.to_bytes()
}
#[cfg(feature = "arkworks4")]
Self::Arkworks4 { points, table } => {
use rust_kzg_arkworks4::kzg_types::{
ArkFp, ArkFr, ArkG1, ArkG1Affine, ArkG1ProjAddAffine,
};
let scalars = scalars
.iter()
.map(|b| ArkFr::from_bytes(b))
.collect::<Result<Vec<_>, _>>()
.unwrap();
let result = msm::<ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine, ArkFr>(
&points,
&scalars,
points.len(),
table.as_ref(),
);
result.to_bytes()
}
#[cfg(feature = "arkworks5")]
Self::Arkworks5 { points, table } => {
use rust_kzg_arkworks5::kzg_types::{
ArkFp, ArkFr, ArkG1, ArkG1Affine, ArkG1ProjAddAffine,
};
let scalars = scalars
.iter()
.map(|b| ArkFr::from_bytes(b))
.collect::<Result<Vec<_>, _>>()
.unwrap();
let result = msm::<ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine, ArkFr>(
&points,
&scalars,
points.len(),
table.as_ref(),
);
result.to_bytes()
}
#[cfg(feature = "constantine")]
Self::Constantine { points, table } => {
use rust_kzg_constantine::types::{
fp::CtFp,
fr::CtFr,
g1::{CtG1, CtG1Affine, CtG1ProjAddAffine},
};
let scalars = scalars
.iter()
.map(|b| CtFr::from_bytes(b))
.collect::<Result<Vec<_>, _>>()
.unwrap();
let result = msm::<CtG1, CtFp, CtG1Affine, CtG1ProjAddAffine, CtFr>(
&points,
&scalars,
points.len(),
table.as_ref(),
);
result.to_bytes()
}
#[cfg(feature = "mcl")]
Self::Mcl { points, table } => {
use rust_kzg_mcl::types::{
fp::MclFp,
fr::MclFr,
g1::{MclG1, MclG1Affine, MclG1ProjAddAffine},
};
let scalars = scalars
.iter()
.map(|b| MclFr::from_bytes(b))
.collect::<Result<Vec<_>, _>>()
.unwrap();
let result = msm::<MclG1, MclFp, MclG1Affine, MclG1ProjAddAffine, MclFr>(
&points,
&scalars,
points.len(),
table.as_ref(),
);
result.to_bytes()
}
#[cfg(feature = "zkcrypto")]
Self::Zkcrypto { points, table } => {
use rust_kzg_zkcrypto::kzg_types::{ZFp, ZFr, ZG1Affine, ZG1ProjAddAffine, ZG1};
let scalars = scalars
.iter()
.map(|b| ZFr::from_bytes(b))
.collect::<Result<Vec<_>, _>>()
.unwrap();
let result = msm::<ZG1, ZFp, ZG1Affine, ZG1ProjAddAffine, ZFr>(
&points,
&scalars,
points.len(),
table.as_ref(),
);
result.to_bytes()
}
}
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/fuzz/fuzz_targets/fixed_msm_with_zeros.rs | fuzz/fuzz_targets/fixed_msm_with_zeros.rs | #![no_main]
use kzg::{Fr, G1Mul, G1};
use libfuzzer_sys::{
arbitrary::{self, Arbitrary},
fuzz_target,
};
use rand::{seq::SliceRandom, Rng, SeedableRng};
use rand_chacha::ChaCha20Rng;
use rust_kzg_blst::types::{fr::FsFr, g1::FsG1};
use rust_kzg_fuzz::{cached_backends, compute_expected_value, get_npoints, seed};
use std::{
fmt::{self, Debug, Formatter},
sync::OnceLock,
};
static POINTS: OnceLock<Vec<[u8; 48]>> = OnceLock::new();
fn generate_points(seed: <ChaCha20Rng as SeedableRng>::Seed) -> Vec<[u8; 48]> {
let npoints = get_npoints();
let mut rng = ChaCha20Rng::from_seed(seed);
// random amount of infinity points, 50%-100%
let numzero = rng.gen_range((npoints / 2)..npoints);
let mut points = (0..numzero)
.map(|_| FsG1::zero().to_bytes())
.chain((numzero..npoints).map(|_| {
let fr = FsFr::from_bytes_unchecked(&rng.gen::<[u8; 32]>()).unwrap();
let p = FsG1::generator().mul(&fr);
p.to_bytes()
}))
.collect::<Vec<_>>();
points.shuffle(&mut rng);
points
}
struct FuzzInput {
scalars: Vec<[u8; 32]>,
}
impl Debug for FuzzInput {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
f.debug_tuple("FuzzInput")
.field(&"Failing test case was saved to a file in current working directory")
.finish()
}
}
impl<'a> Arbitrary<'a> for FuzzInput {
fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
let npoints = get_npoints();
let mut scalars = Vec::new();
for _ in 0..npoints {
if u.arbitrary()? {
scalars.push(u.arbitrary::<FsFr>()?.to_bytes());
} else {
scalars.push(FsFr::zero().to_bytes());
}
}
Ok(Self { scalars })
}
}
fuzz_target!(|input: FuzzInput| {
let points = POINTS.get_or_init(|| generate_points(seed()));
let backends = cached_backends(&points);
let expected = compute_expected_value(points, &input.scalars);
for backend in backends {
let received = backend.multiply(&input.scalars);
if expected != received {
backend
.save_case(&points, &input.scalars)
.expect("failed to save test case");
}
assert_eq!(expected, received, "backend: {}", backend.name());
}
});
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/fuzz/fuzz_targets/fixed_msm.rs | fuzz/fuzz_targets/fixed_msm.rs | #![no_main]
use kzg::{Fr, G1Mul, G1};
use libfuzzer_sys::{
arbitrary::{self, Arbitrary},
fuzz_target,
};
use rand::{Rng, SeedableRng};
use rand_chacha::ChaCha20Rng;
use rust_kzg_blst::types::{fr::FsFr, g1::FsG1};
use rust_kzg_fuzz::{cached_backends, compute_expected_value, get_npoints, seed};
use std::{
fmt::{self, Debug, Formatter},
sync::OnceLock,
};
static POINTS: OnceLock<Vec<[u8; 48]>> = OnceLock::new();
fn generate_points(seed: <ChaCha20Rng as SeedableRng>::Seed) -> Vec<[u8; 48]> {
let npoints = get_npoints();
let mut rng = ChaCha20Rng::from_seed(seed);
(0..npoints)
.map(|_| {
let fr = FsFr::from_bytes_unchecked(&rng.gen::<[u8; 32]>()).unwrap();
let p = FsG1::generator().mul(&fr);
p.to_bytes()
})
.collect::<Vec<_>>()
}
struct FuzzInput {
scalars: Vec<[u8; 32]>,
}
impl Debug for FuzzInput {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
f.debug_tuple("FuzzInput")
.field(&"Failing test case was saved to a file in current working directory")
.finish()
}
}
impl<'a> Arbitrary<'a> for FuzzInput {
fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
let npoints = get_npoints();
let mut scalars = Vec::new();
for _ in 0..npoints {
scalars.push(u.arbitrary::<FsFr>()?.to_bytes());
}
Ok(Self { scalars })
}
}
fuzz_target!(|input: FuzzInput| {
let points = POINTS.get_or_init(|| generate_points(seed()));
let backends = cached_backends(&points);
let expected = compute_expected_value(points, &input.scalars);
for backend in backends {
let received = backend.multiply(&input.scalars);
if expected != received {
backend
.save_case(&points, &input.scalars)
.expect("failed to save test case");
}
assert_eq!(expected, received, "backend: {}", backend.name());
}
});
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/fuzz/fuzz_targets/variable_msm.rs | fuzz/fuzz_targets/variable_msm.rs | #![no_main]
use kzg::{Fr, G1Affine, G1};
use libfuzzer_sys::{
arbitrary::{self, Arbitrary},
fuzz_target, Corpus,
};
use rust_kzg_blst::types::{fr::FsFr, g1::FsG1Affine};
use rust_kzg_fuzz::{backends, compute_expected_value};
use std::fmt::{self, Debug, Formatter};
struct FuzzInput {
points: Vec<[u8; 48]>,
scalars: Vec<[u8; 32]>,
}
impl Debug for FuzzInput {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
f.debug_tuple("FuzzInput")
.field(&"Failing test case was saved to a file in current working directory")
.finish()
}
}
impl<'a> Arbitrary<'a> for FuzzInput {
fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
let points = u
.arbitrary_iter::<FsG1Affine>()?
.map(|p| p.map(|p| p.to_proj().to_bytes()))
.collect::<Result<Vec<_>, _>>()?;
let scalars = u
.arbitrary_iter::<FsFr>()?
.map(|s| s.map(|s| s.to_bytes()))
.collect::<Result<Vec<_>, _>>()?;
Ok(Self { points, scalars })
}
}
fuzz_target!(|input: FuzzInput| -> Corpus {
if input.points.len() != input.scalars.len() {
return Corpus::Reject;
}
let b = backends(&input.points);
let expected = compute_expected_value(&input.points, &input.scalars);
for backend in b {
let received = backend.multiply(&input.scalars);
if expected != received {
backend
.save_case(&input.points, &input.scalars)
.expect("failed to save test case");
}
assert_eq!(expected, received, "backend: {}", backend.name());
}
Corpus::Keep
});
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/consts.rs | arkworks3/src/consts.rs | pub const SCALE_FACTOR: u64 = 5;
pub const NUM_ROOTS: usize = 32;
#[rustfmt::skip]
pub const SCALE2_ROOT_OF_UNITY: [[u64; 4]; 32] = [
[0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000],
[0xffffffff00000000, 0x53bda402fffe5bfe, 0x3339d80809a1d805, 0x73eda753299d7d48],
[0x0001000000000000, 0xec03000276030000, 0x8d51ccce760304d0, 0x0000000000000000],
[0x7228fd3397743f7a, 0xb38b21c28713b700, 0x8c0625cd70d77ce2, 0x345766f603fa66e7],
[0x53ea61d87742bcce, 0x17beb312f20b6f76, 0xdd1c0af834cec32c, 0x20b1ce9140267af9],
[0x360c60997369df4e, 0xbf6e88fb4c38fb8a, 0xb4bcd40e22f55448, 0x50e0903a157988ba],
[0x8140d032f0a9ee53, 0x2d967f4be2f95155, 0x14a1e27164d8fdbd, 0x45af6345ec055e4d],
[0x5130c2c1660125be, 0x98d0caac87f5713c, 0xb7c68b4d7fdd60d0, 0x6898111413588742],
[0x4935bd2f817f694b, 0x0a0865a899e8deff, 0x6b368121ac0cf4ad, 0x4f9b4098e2e9f12e],
[0x4541b8ff2ee0434e, 0xd697168a3a6000fe, 0x39feec240d80689f, 0x095166525526a654],
[0x3c28d666a5c2d854, 0xea437f9626fc085e, 0x8f4de02c0f776af3, 0x325db5c3debf77a1],
[0x4a838b5d59cd79e5, 0x55ea6811be9c622d, 0x09f1ca610a08f166, 0x6d031f1b5c49c834],
[0xe206da11a5d36306, 0x0ad1347b378fbf96, 0xfc3e8acfe0f8245f, 0x564c0a11a0f704f4],
[0x6fdd00bfc78c8967, 0x146b58bc434906ac, 0x2ccddea2972e89ed, 0x485d512737b1da3d],
[0x034d2ff22a5ad9e1, 0xae4622f6a9152435, 0xdc86b01c0d477fa6, 0x56624634b500a166],
[0xfbd047e11279bb6e, 0xc8d5f51db3f32699, 0x483405417a0cbe39, 0x3291357ee558b50d],
[0xd7118f85cd96b8ad, 0x67a665ae1fcadc91, 0x88f39a78f1aeb578, 0x2155379d12180caa],
[0x08692405f3b70f10, 0xcd7f2bd6d0711b7d, 0x473a2eef772c33d6, 0x224262332d8acbf4],
[0x6f421a7d8ef674fb, 0xbb97a3bf30ce40fd, 0x652f717ae1c34bb0, 0x2d3056a530794f01],
[0x194e8c62ecb38d9d, 0xad8e16e84419c750, 0xdf625e80d0adef90, 0x520e587a724a6955],
[0xfece7e0e39898d4b, 0x2f69e02d265e09d9, 0xa57a6e07cb98de4a, 0x03e1c54bcb947035],
[0xcd3979122d3ea03a, 0x46b3105f04db5844, 0xc70d0874b0691d4e, 0x47c8b5817018af4f],
[0xc6e7a6ffb08e3363, 0xe08fec7c86389bee, 0xf2d38f10fbb8d1bb, 0x0abe6a5e5abcaa32],
[0x5616c57de0ec9eae, 0xc631ffb2585a72db, 0x5121af06a3b51e3c, 0x73560252aa0655b2],
[0x92cf4deb77bd779c, 0x72cf6a8029b7d7bc, 0x6e0bcd91ee762730, 0x291cf6d68823e687],
[0xce32ef844e11a51e, 0xc0ba12bb3da64ca5, 0x0454dc1edc61a1a3, 0x019fe632fd328739],
[0x531a11a0d2d75182, 0x02c8118402867ddc, 0x116168bffbedc11d, 0x0a0a77a3b1980c0d],
[0xe2d0a7869f0319ed, 0xb94f1101b1d7a628, 0xece8ea224f31d25d, 0x23397a9300f8f98b],
[0xd7b688830a4f2089, 0x6558e9e3f6ac7b41, 0x99e276b571905a7d, 0x52dd465e2f094256],
[0x474650359d8e211b, 0x84d37b826214abc6, 0x8da40c1ef2bb4598, 0x0c83ea7744bf1bee],
[0x694341f608c9dd56, 0xed3a181fabb30adc, 0x1339a815da8b398f, 0x2c6d4e4511657e1e],
[0x63e7cb4906ffc93f, 0xf070bb00e28a193d, 0xad1715b02e5713b5, 0x4b5371495990693f],
];
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/das.rs | arkworks3/src/das.rs | use crate::kzg_proofs::FFTSettings;
use crate::kzg_types::ArkFr as BlstFr;
use kzg::{DASExtension, Fr};
use std::cmp::Ordering;
impl FFTSettings {
fn das_fft_extension_stride(&self, ab: &mut [BlstFr], stride: usize) {
match ab.len().cmp(&2_usize) {
Ordering::Less => {}
Ordering::Greater => {
let half = ab.len();
let halfhalf = half / 2;
for i in 0..halfhalf {
let tmp1 = ab[i].add(&ab[halfhalf + i]);
let tmp2 = ab[i].sub(&ab[halfhalf + i]);
ab[halfhalf + i] = tmp2.mul(&self.reverse_roots_of_unity[i * 2 * stride]);
ab[i] = tmp1;
}
#[cfg(feature = "parallel")]
{
if ab.len() > 32 {
let (lo, hi) = ab.split_at_mut(halfhalf);
rayon::join(
|| self.das_fft_extension_stride(hi, stride * 2),
|| self.das_fft_extension_stride(lo, stride * 2),
);
} else {
self.das_fft_extension_stride(&mut ab[..halfhalf], stride * 2);
self.das_fft_extension_stride(&mut ab[halfhalf..], stride * 2);
}
}
#[cfg(not(feature = "parallel"))]
{
self.das_fft_extension_stride(&mut ab[..halfhalf], stride * 2);
self.das_fft_extension_stride(&mut ab[halfhalf..], stride * 2);
}
for i in 0..halfhalf {
let x = ab[i];
let y = ab[halfhalf + i];
let y_times_root = y.mul(&self.roots_of_unity[(1 + 2 * i) * stride]);
ab[i] = x.add(&y_times_root);
ab[halfhalf + i] = x.sub(&y_times_root);
}
}
Ordering::Equal => {
let x = ab[0].add(&ab[1]);
let y = ab[0].sub(&ab[1]);
let tmp = y.mul(&self.roots_of_unity[stride]);
ab[0] = x.add(&tmp);
ab[1] = x.sub(&tmp);
}
}
}
}
impl DASExtension<BlstFr> for FFTSettings {
fn das_fft_extension(&self, vals: &[BlstFr]) -> Result<Vec<BlstFr>, String> {
if vals.is_empty() {
return Err(String::from("vals can not be empty"));
}
if !vals.len().is_power_of_two() {
return Err(String::from("vals lenght has to be power of 2"));
}
if vals.len() * 2 > self.max_width {
return Err(String::from(
"vals lenght * 2 has to equal or less than FFTSetings max width",
));
}
let mut vals = vals.to_vec();
let stride = self.max_width / (vals.len() * 2);
self.das_fft_extension_stride(&mut vals, stride);
let invlen = BlstFr::from_u64(vals.len() as u64);
let invlen = invlen.inverse();
for val in &mut vals {
val.fr *= invlen.fr
}
Ok(vals)
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/lib.rs | arkworks3/src/lib.rs | pub mod consts;
pub mod das;
pub mod eip_4844;
pub mod eip_7594;
pub mod fft;
pub mod fft_g1;
pub mod fk20_proofs;
pub mod kzg_proofs;
pub mod kzg_types;
pub mod poly;
pub mod recover;
pub mod utils;
pub mod zero_poly;
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/eip_4844.rs | arkworks3/src/eip_4844.rs | extern crate alloc;
use crate::kzg_proofs::KZGSettings;
#[cfg(feature = "c_bindings")]
use alloc::boxed::Box;
#[cfg(feature = "c_bindings")]
use core::ptr;
use kzg::eip_4844::load_trusted_setup_rust;
#[cfg(feature = "c_bindings")]
use kzg::{
eip_4844::{
BYTES_PER_G1, FIELD_ELEMENTS_PER_BLOB, TRUSTED_SETUP_NUM_G1_POINTS,
TRUSTED_SETUP_NUM_G2_POINTS,
},
eth::{
self,
c_bindings::{Blob, Bytes32, Bytes48, CKZGSettings, CKzgRet, KZGCommitment, KZGProof},
},
Fr, G1,
};
#[cfg(all(feature = "std", feature = "c_bindings"))]
use libc::FILE;
#[cfg(feature = "std")]
use std::fs::File;
#[cfg(feature = "std")]
use std::io::Read;
#[cfg(feature = "c_bindings")]
use crate::utils::PRECOMPUTATION_TABLES;
#[cfg(feature = "std")]
use kzg::eip_4844::load_trusted_setup_string;
#[cfg(feature = "std")]
pub fn load_trusted_setup_filename_rust(
filepath: &str,
) -> Result<KZGSettings, alloc::string::String> {
let mut file = File::open(filepath).map_err(|_| "Unable to open file".to_string())?;
let mut contents = String::new();
file.read_to_string(&mut contents)
.map_err(|_| "Unable to read file".to_string())?;
let (g1_monomial_bytes, g1_lagrange_bytes, g2_monomial_bytes) =
load_trusted_setup_string(&contents)?;
load_trusted_setup_rust(&g1_monomial_bytes, &g1_lagrange_bytes, &g2_monomial_bytes)
}
#[cfg(feature = "c_bindings")]
macro_rules! handle_ckzg_badargs {
($x: expr) => {
match $x {
Ok(value) => value,
Err(_) => return kzg::eth::c_bindings::CKzgRet::BadArgs,
}
};
}
#[cfg(feature = "c_bindings")]
fn kzg_settings_to_c(rust_settings: &KZGSettings) -> CKZGSettings {
CKZGSettings {
roots_of_unity: Box::leak(
rust_settings
.fs
.roots_of_unity
.iter()
.map(|r| r.to_blst_fr())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
brp_roots_of_unity: Box::leak(
rust_settings
.fs
.brp_roots_of_unity
.iter()
.map(|r| r.to_blst_fr())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
reverse_roots_of_unity: Box::leak(
rust_settings
.fs
.reverse_roots_of_unity
.iter()
.map(|r| r.to_blst_fr())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
g1_values_monomial: Box::leak(
rust_settings
.g1_values_monomial
.iter()
.map(|r| r.to_blst_p1())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
g1_values_lagrange_brp: Box::leak(
rust_settings
.g1_values_lagrange_brp
.iter()
.map(|r| r.to_blst_p1())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
g2_values_monomial: Box::leak(
rust_settings
.g2_values_monomial
.iter()
.map(|r| r.to_blst_p2())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
x_ext_fft_columns: Box::leak(
rust_settings
.x_ext_fft_columns
.iter()
.map(|r| {
Box::leak(
r.iter()
.map(|it| it.to_blst_p1())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr()
})
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
tables: core::ptr::null_mut(),
wbits: 0,
scratch_size: 0,
}
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn blob_to_kzg_commitment(
out: *mut KZGCommitment,
blob: *const Blob,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::blob_to_kzg_commitment_raw;
if TRUSTED_SETUP_NUM_G1_POINTS == 0 {
// FIXME: load_trusted_setup should set this value, but if not, it fails
TRUSTED_SETUP_NUM_G1_POINTS = FIELD_ELEMENTS_PER_BLOB
};
let settings: KZGSettings = handle_ckzg_badargs!(s.try_into());
let tmp = handle_ckzg_badargs!(blob_to_kzg_commitment_raw((*blob).bytes, &settings));
(*out).bytes = tmp.to_bytes();
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn load_trusted_setup(
out: *mut CKZGSettings,
g1_monomial_bytes: *const u8,
num_g1_monomial_bytes: u64,
g1_lagrange_bytes: *const u8,
num_g1_lagrange_bytes: u64,
g2_monomial_bytes: *const u8,
num_g2_monomial_bytes: u64,
_precompute: u64,
) -> CKzgRet {
*out = CKZGSettings {
brp_roots_of_unity: ptr::null_mut(),
roots_of_unity: ptr::null_mut(),
reverse_roots_of_unity: ptr::null_mut(),
g1_values_monomial: ptr::null_mut(),
g1_values_lagrange_brp: ptr::null_mut(),
g2_values_monomial: ptr::null_mut(),
x_ext_fft_columns: ptr::null_mut(),
tables: ptr::null_mut(),
wbits: 0,
scratch_size: 0,
};
let g1_monomial_bytes =
core::slice::from_raw_parts(g1_monomial_bytes, num_g1_monomial_bytes as usize);
let g1_lagrange_bytes =
core::slice::from_raw_parts(g1_lagrange_bytes, num_g1_lagrange_bytes as usize);
let g2_monomial_bytes =
core::slice::from_raw_parts(g2_monomial_bytes, num_g2_monomial_bytes as usize);
TRUSTED_SETUP_NUM_G1_POINTS = num_g1_monomial_bytes as usize / BYTES_PER_G1;
let mut settings = handle_ckzg_badargs!(load_trusted_setup_rust(
g1_monomial_bytes,
g1_lagrange_bytes,
g2_monomial_bytes
));
let c_settings = kzg_settings_to_c(&settings);
PRECOMPUTATION_TABLES.save_precomputation(settings.precomputation.take(), &c_settings);
*out = c_settings;
CKzgRet::Ok
}
/// # Safety
#[cfg(all(feature = "std", feature = "c_bindings"))]
#[no_mangle]
pub unsafe extern "C" fn load_trusted_setup_file(
out: *mut CKZGSettings,
in_: *mut FILE,
) -> CKzgRet {
*out = CKZGSettings {
brp_roots_of_unity: ptr::null_mut(),
roots_of_unity: ptr::null_mut(),
reverse_roots_of_unity: ptr::null_mut(),
g1_values_monomial: ptr::null_mut(),
g1_values_lagrange_brp: ptr::null_mut(),
g2_values_monomial: ptr::null_mut(),
x_ext_fft_columns: ptr::null_mut(),
tables: ptr::null_mut(),
wbits: 0,
scratch_size: 0,
};
let mut buf = vec![0u8; 1024 * 1024];
let len: usize = libc::fread(buf.as_mut_ptr() as *mut libc::c_void, 1, buf.len(), in_);
let s = handle_ckzg_badargs!(String::from_utf8(buf[..len].to_vec()));
let (g1_monomial_bytes, g1_lagrange_bytes, g2_monomial_bytes) =
handle_ckzg_badargs!(load_trusted_setup_string(&s));
TRUSTED_SETUP_NUM_G1_POINTS = g1_monomial_bytes.len() / BYTES_PER_G1;
if TRUSTED_SETUP_NUM_G1_POINTS != FIELD_ELEMENTS_PER_BLOB {
// Helps pass the Java test "shouldThrowExceptionOnIncorrectTrustedSetupFromFile",
// as well as 5 others that pass only if this one passes (likely because Java doesn't
// deallocate its KZGSettings pointer when no exception is thrown).
return CKzgRet::BadArgs;
}
let mut settings = handle_ckzg_badargs!(load_trusted_setup_rust(
&g1_monomial_bytes,
&g1_lagrange_bytes,
&g2_monomial_bytes
));
let c_settings = kzg_settings_to_c(&settings);
PRECOMPUTATION_TABLES.save_precomputation(settings.precomputation.take(), &c_settings);
*out = c_settings;
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn free_trusted_setup(s: *mut CKZGSettings) {
if s.is_null() {
return;
}
PRECOMPUTATION_TABLES.remove_precomputation(&*s);
if !(*s).roots_of_unity.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB + 1,
));
drop(v);
(*s).roots_of_unity = ptr::null_mut();
}
if !(*s).brp_roots_of_unity.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).brp_roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB,
));
drop(v);
(*s).brp_roots_of_unity = ptr::null_mut();
}
if !(*s).reverse_roots_of_unity.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).reverse_roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB + 1,
));
drop(v);
(*s).reverse_roots_of_unity = ptr::null_mut();
}
if !(*s).g1_values_monomial.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).g1_values_monomial,
FIELD_ELEMENTS_PER_BLOB,
));
drop(v);
(*s).g1_values_monomial = ptr::null_mut();
}
if !(*s).g1_values_lagrange_brp.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).g1_values_lagrange_brp,
FIELD_ELEMENTS_PER_BLOB,
));
drop(v);
(*s).g1_values_lagrange_brp = ptr::null_mut();
}
if !(*s).g2_values_monomial.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).g2_values_monomial,
TRUSTED_SETUP_NUM_G2_POINTS,
));
drop(v);
(*s).g2_values_monomial = ptr::null_mut();
}
if !(*s).x_ext_fft_columns.is_null() {
let x_ext_fft_columns = core::slice::from_raw_parts_mut(
(*s).x_ext_fft_columns,
2 * ((eth::FIELD_ELEMENTS_PER_EXT_BLOB / 2) / eth::FIELD_ELEMENTS_PER_CELL),
);
for column in x_ext_fft_columns.iter_mut() {
if !(*column).is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
*column,
eth::FIELD_ELEMENTS_PER_CELL,
));
drop(v);
*column = ptr::null_mut();
}
}
let v = Box::from_raw(x_ext_fft_columns);
drop(v);
(*s).x_ext_fft_columns = ptr::null_mut();
}
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn verify_kzg_proof(
ok: *mut bool,
commitment_bytes: *const Bytes48,
z_bytes: *const Bytes32,
y_bytes: *const Bytes32,
proof_bytes: *const Bytes48,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::verify_kzg_proof_raw;
let settings: KZGSettings = handle_ckzg_badargs!(s.try_into());
let result = handle_ckzg_badargs!(verify_kzg_proof_raw(
(*commitment_bytes).bytes,
(*z_bytes).bytes,
(*y_bytes).bytes,
(*proof_bytes).bytes,
&settings
));
*ok = result;
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn verify_blob_kzg_proof(
ok: *mut bool,
blob: *const Blob,
commitment_bytes: *const Bytes48,
proof_bytes: *const Bytes48,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::verify_blob_kzg_proof_raw;
let settings: KZGSettings = handle_ckzg_badargs!(s.try_into());
let result = handle_ckzg_badargs!(verify_blob_kzg_proof_raw(
(*blob).bytes,
(*commitment_bytes).bytes,
(*proof_bytes).bytes,
&settings,
));
*ok = result;
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn verify_blob_kzg_proof_batch(
ok: *mut bool,
blobs: *const Blob,
commitments_bytes: *const Bytes48,
proofs_bytes: *const Bytes48,
n: usize,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::verify_blob_kzg_proof_batch_raw;
let blobs = core::slice::from_raw_parts(blobs, n)
.iter()
.map(|b| b.bytes)
.collect::<Vec<_>>();
let commitments = core::slice::from_raw_parts(commitments_bytes, n)
.iter()
.map(|b| b.bytes)
.collect::<Vec<_>>();
let proofs = core::slice::from_raw_parts(proofs_bytes, n)
.iter()
.map(|b| b.bytes)
.collect::<Vec<_>>();
*ok = false;
let settings: KZGSettings = handle_ckzg_badargs!(s.try_into());
let result = handle_ckzg_badargs!(verify_blob_kzg_proof_batch_raw(
&blobs,
&commitments,
&proofs,
&settings
));
*ok = result;
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn compute_blob_kzg_proof(
out: *mut KZGProof,
blob: *const Blob,
commitment_bytes: *const Bytes48,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::compute_blob_kzg_proof_raw;
let settings: KZGSettings = handle_ckzg_badargs!(s.try_into());
let proof = handle_ckzg_badargs!(compute_blob_kzg_proof_raw(
(*blob).bytes,
(*commitment_bytes).bytes,
&settings
));
(*out).bytes = proof.to_bytes();
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn compute_kzg_proof(
proof_out: *mut KZGProof,
y_out: *mut Bytes32,
blob: *const Blob,
z_bytes: *const Bytes32,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::compute_kzg_proof_raw;
let settings: KZGSettings = handle_ckzg_badargs!(s.try_into());
let (proof_out_tmp, fry_tmp) = handle_ckzg_badargs!(compute_kzg_proof_raw(
(*blob).bytes,
(*z_bytes).bytes,
&settings
));
(*proof_out).bytes = proof_out_tmp.to_bytes();
(*y_out).bytes = fry_tmp.to_bytes();
CKzgRet::Ok
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/kzg_proofs.rs | arkworks3/src/kzg_proofs.rs | #![allow(non_camel_case_types)]
extern crate alloc;
use crate::kzg_types::{ArkFp, ArkFr, ArkG1, ArkG1Affine, ArkG1ProjAddAffine, ArkG2};
use crate::utils::{blst_poly_into_pc_poly, fft_settings_to_rust, PolyData, PRECOMPUTATION_TABLES};
use alloc::sync::Arc;
use ark_bls12_381::Bls12_381;
use ark_ec::PairingEngine;
use ark_ec::ProjectiveCurve;
use ark_poly::Polynomial;
use ark_std::One;
use kzg::common_utils::log2_pow2;
use kzg::eip_4844::hash_to_bls_field;
use kzg::eth::c_bindings::CKZGSettings;
use kzg::msm::precompute::PrecomputationTable;
use kzg::{eth, FFTSettings as _, Fr, G1Mul, G2Mul, FFTG1, G1, G2};
use std::ops::Neg;
#[derive(Debug, Clone)]
pub struct FFTSettings {
pub max_width: usize,
pub root_of_unity: ArkFr,
pub brp_roots_of_unity: Vec<ArkFr>,
pub reverse_roots_of_unity: Vec<ArkFr>,
pub roots_of_unity: Vec<ArkFr>,
}
pub fn expand_root_of_unity(root: &ArkFr, width: usize) -> Result<Vec<ArkFr>, String> {
let mut generated_powers = vec![ArkFr::one(), *root];
while !(generated_powers.last().unwrap().is_one()) {
if generated_powers.len() > width {
return Err(String::from("Root of unity multiplied for too long"));
}
generated_powers.push(generated_powers.last().unwrap().mul(root));
}
if generated_powers.len() != width + 1 {
return Err(String::from("Root of unity has invalid scale"));
}
Ok(generated_powers)
}
#[allow(clippy::type_complexity)]
#[derive(Debug, Clone, Default)]
pub struct KZGSettings {
pub fs: FFTSettings,
pub g1_values_monomial: Vec<ArkG1>,
pub g1_values_lagrange_brp: Vec<ArkG1>,
pub g2_values_monomial: Vec<ArkG2>,
pub precomputation:
Option<Arc<PrecomputationTable<ArkFr, ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine>>>,
pub x_ext_fft_columns: Vec<Vec<ArkG1>>,
pub cell_size: usize,
}
impl TryFrom<&CKZGSettings> for KZGSettings {
type Error = String;
fn try_from(c_settings: &CKZGSettings) -> Result<KZGSettings, String> {
Ok(KZGSettings {
fs: fft_settings_to_rust(c_settings)?,
g1_values_monomial: unsafe {
core::slice::from_raw_parts(
c_settings.g1_values_monomial,
eth::FIELD_ELEMENTS_PER_BLOB,
)
}
.iter()
.map(|r| ArkG1::from_blst_p1(*r))
.collect::<Vec<_>>(),
g1_values_lagrange_brp: unsafe {
core::slice::from_raw_parts(
c_settings.g1_values_lagrange_brp,
eth::FIELD_ELEMENTS_PER_BLOB,
)
}
.iter()
.map(|r| ArkG1::from_blst_p1(*r))
.collect::<Vec<_>>(),
g2_values_monomial: unsafe {
core::slice::from_raw_parts(
c_settings.g2_values_monomial,
eth::TRUSTED_SETUP_NUM_G2_POINTS,
)
}
.iter()
.map(|r| ArkG2::from_blst_p2(*r))
.collect::<Vec<_>>(),
x_ext_fft_columns: unsafe {
core::slice::from_raw_parts(
c_settings.x_ext_fft_columns,
2 * ((eth::FIELD_ELEMENTS_PER_EXT_BLOB / 2) / eth::FIELD_ELEMENTS_PER_CELL),
)
}
.iter()
.map(|it| {
unsafe { core::slice::from_raw_parts(*it, eth::FIELD_ELEMENTS_PER_CELL) }
.iter()
.map(|it| ArkG1::from_blst_p1(*it))
.collect::<Vec<_>>()
})
.collect::<Vec<_>>(),
#[allow(static_mut_refs)]
precomputation: unsafe { PRECOMPUTATION_TABLES.get_precomputation(c_settings) },
cell_size: eth::FIELD_ELEMENTS_PER_CELL,
})
}
}
pub fn generate_trusted_setup(
n: usize,
secret: [u8; 32usize],
) -> (Vec<ArkG1>, Vec<ArkG1>, Vec<ArkG2>) {
let s = hash_to_bls_field(&secret);
let mut s_pow = Fr::one();
let mut g1_monomial_values = Vec::with_capacity(n);
let mut g2_monomial_values = Vec::with_capacity(n);
for _ in 0..n {
g1_monomial_values.push(ArkG1::generator().mul(&s_pow));
g2_monomial_values.push(ArkG2::generator().mul(&s_pow));
s_pow = s_pow.mul(&s);
}
let s = FFTSettings::new(log2_pow2(n)).unwrap();
let g1_lagrange_values = s.fft_g1(&g1_monomial_values, true).unwrap();
(g1_monomial_values, g1_lagrange_values, g2_monomial_values)
}
pub fn eval_poly(p: &PolyData, x: &ArkFr) -> ArkFr {
let poly = blst_poly_into_pc_poly(&p.coeffs);
ArkFr {
fr: poly.evaluate(&x.fr),
}
}
pub fn pairings_verify(a1: &ArkG1, a2: &ArkG2, b1: &ArkG1, b2: &ArkG2) -> bool {
let ark_a1_neg = a1.0.neg().into_affine();
let ark_b1 = b1.0.into_affine();
let ark_a2 = a2.0.into_affine();
let ark_b2 = b2.0.into_affine();
Bls12_381::product_of_pairings(&[
(ark_a1_neg.into(), ark_a2.into()),
(ark_b1.into(), ark_b2.into()),
])
.is_one()
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/eip_7594.rs | arkworks3/src/eip_7594.rs | extern crate alloc;
use kzg::EcBackend;
use crate::kzg_proofs::FFTSettings;
use crate::kzg_proofs::KZGSettings;
use crate::kzg_types::ArkFp;
use crate::kzg_types::ArkFr;
use crate::kzg_types::ArkG1;
use crate::kzg_types::ArkG1Affine;
use crate::kzg_types::ArkG1ProjAddAffine;
use crate::kzg_types::ArkG2;
use crate::utils::PolyData;
pub struct ArkBackend;
impl EcBackend for ArkBackend {
type Fr = ArkFr;
type G1Fp = ArkFp;
type G1Affine = ArkG1Affine;
type G1 = ArkG1;
type G2 = ArkG2;
type Poly = PolyData;
type FFTSettings = FFTSettings;
type KZGSettings = KZGSettings;
type G1ProjAddAffine = ArkG1ProjAddAffine;
}
#[cfg(feature = "c_bindings")]
kzg::c_bindings_eip7594!(ArkBackend);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/poly.rs | arkworks3/src/poly.rs | use super::kzg_proofs::FFTSettings;
use super::utils::{blst_poly_into_pc_poly, PolyData};
use crate::kzg_types::ArkFr as BlstFr;
use crate::utils::pc_poly_into_blst_poly;
use crate::zero_poly::pad_poly;
use ark_bls12_381::Fr;
use ark_poly::univariate::DensePolynomial;
use ark_poly::UVPolynomial;
use ark_std::{log2, Zero};
use kzg::common_utils::{log2_pow2, next_pow_of_2};
use kzg::{FFTFr, FFTSettings as FFTSettingsT, Fr as FrTrait, Poly};
use std::cmp::min;
pub fn poly_inverse(b: &PolyData, output_len: usize) -> Result<PolyData, String> {
if b.coeffs.is_empty() {
return Err(String::from("b.coeffs is empty"));
}
if BlstFr::is_zero(&b.coeffs[0]) {
return Err(String::from("b.coeffs[0] is zero"));
}
let mut output = PolyData {
coeffs: vec![BlstFr::zero(); output_len],
};
if b.coeffs.len() == 1 {
output.coeffs[0] = b.coeffs[0].inverse();
for i in 1..output_len {
output.coeffs[i] = BlstFr::zero();
}
return Ok(output);
}
let maxd = output_len - 1;
let scale = next_pow_of_2(log2_pow2(2 * output_len - 1));
let fs = FFTSettings::new(scale).unwrap();
let mut tmp0: PolyData;
let mut tmp1: PolyData;
output.coeffs[0] = b.coeffs[0].inverse();
let mut d: usize = 0;
let mut mask: usize = 1 << log2(maxd);
while mask != 0 {
d = 2 * d + usize::from((maxd & mask) != 0);
mask >>= 1;
let len_temp: usize = min(d + 1, b.coeffs.len() + output.coeffs.len() - 1);
tmp0 = poly_mul(b, &output, Some(&fs), len_temp).unwrap();
for i in 0..len_temp {
tmp0.coeffs[i] = tmp0.coeffs[i].negate();
}
let fr_two = BlstFr { fr: Fr::from(2) };
tmp0.coeffs[0] = tmp0.coeffs[0].add(&fr_two);
let len_temp2: usize = d + 1;
tmp1 = poly_mul(&output, &tmp0, Some(&fs), len_temp2).unwrap();
if tmp1.coeffs.len() > output_len {
tmp1.coeffs = tmp1.coeffs[..output_len].to_vec();
}
for i in 0..tmp1.coeffs.len() {
output.coeffs[i] = tmp1.coeffs[i];
}
}
if d + 1 != output_len {
return Err(String::from("d + 1 is not equals to output_len"));
}
Ok(output)
}
pub fn poly_mul_direct(p1: &PolyData, p2: &PolyData, len: usize) -> Result<PolyData, String> {
let p1 = blst_poly_into_pc_poly(&p1.coeffs);
let p2 = blst_poly_into_pc_poly(&p2.coeffs);
if p1.is_zero() || p2.is_zero() {
Ok(pc_poly_into_blst_poly(DensePolynomial::zero()))
} else {
let mut result = vec![Fr::zero(); len];
for (i, self_coeff) in p1.coeffs.iter().enumerate() {
for (j, other_coeff) in p2.coeffs.iter().enumerate() {
if i + j >= len {
break;
}
result[i + j] += &(*self_coeff * other_coeff);
}
}
let p = pc_poly_into_blst_poly(DensePolynomial::from_coefficients_vec(result));
Ok(PolyData {
coeffs: pad_poly(&p, len).unwrap(),
})
}
}
pub fn poly_long_div(p1: &PolyData, p2: &PolyData) -> Result<PolyData, String> {
Ok(pc_poly_into_blst_poly(
&blst_poly_into_pc_poly(&p1.coeffs) / &blst_poly_into_pc_poly(&p2.coeffs),
))
}
pub fn poly_mul(
a: &PolyData,
b: &PolyData,
fs: Option<&FFTSettings>,
len: usize,
) -> Result<PolyData, String> {
if a.coeffs.len() < 64 || b.coeffs.len() < 64 || len < 128 {
poly_mul_direct(a, b, len)
} else {
poly_mul_fft(a, b, fs, len)
}
}
pub fn poly_mul_fft(
a: &PolyData,
b: &PolyData,
fs: Option<&FFTSettings>,
len: usize,
) -> Result<PolyData, String> {
// Truncate a and b so as not to do excess work for the number of coefficients required.
let a_len = min(a.len(), len);
let b_len = min(b.len(), len);
let length = next_pow_of_2(a_len + b_len - 1);
// If the FFT settings are NULL then make a local set, otherwise use the ones passed in.
let fs_p = if let Some(x) = fs {
x.clone()
} else {
let scale = log2_pow2(length);
FFTSettings::new(scale).unwrap()
};
if length > fs_p.max_width {
return Err(String::from(
"length should be equals or less than FFTSettings max width",
));
}
let a = PolyData {
coeffs: a.coeffs[..a_len].to_vec(),
};
let b = PolyData {
coeffs: b.coeffs[..b_len].to_vec(),
};
let a_pad = PolyData {
coeffs: pad_poly(&a, length).unwrap(),
};
let b_pad = PolyData {
coeffs: pad_poly(&b, length).unwrap(),
};
let a_fft;
let b_fft;
#[cfg(feature = "parallel")]
{
if length > 1024 {
let mut a_fft_temp = vec![];
let mut b_fft_temp = vec![];
rayon::join(
|| a_fft_temp = fs_p.fft_fr(&a_pad.coeffs, false).unwrap(),
|| b_fft_temp = fs_p.fft_fr(&b_pad.coeffs, false).unwrap(),
);
a_fft = a_fft_temp;
b_fft = b_fft_temp;
} else {
a_fft = fs_p.fft_fr(&a_pad.coeffs, false).unwrap();
b_fft = fs_p.fft_fr(&b_pad.coeffs, false).unwrap();
}
}
#[cfg(not(feature = "parallel"))]
{
a_fft = fs_p.fft_fr(&a_pad.coeffs, false).unwrap();
b_fft = fs_p.fft_fr(&b_pad.coeffs, false).unwrap();
}
let mut ab_fft = a_pad;
let mut ab = b_pad;
for i in 0..length {
ab_fft.coeffs[i] = a_fft[i].mul(&b_fft[i]);
}
ab.coeffs = fs_p.fft_fr(&ab_fft.coeffs, true).unwrap();
let data_len = min(len, length);
let mut out = PolyData::new(len);
for i in 0..data_len {
out.coeffs[i] = ab.coeffs[i];
}
for i in data_len..len {
out.coeffs[i] = BlstFr::zero();
}
Ok(out)
}
pub fn poly_fast_div(dividend: &PolyData, divisor: &PolyData) -> Result<PolyData, String> {
if divisor.coeffs.is_empty() {
return Err(String::from("divisor coeffs are empty"));
}
if divisor.coeffs[divisor.coeffs.len() - 1].is_zero() {
return Err(String::from("divisor coeffs last member is zero"));
}
let m = dividend.coeffs.len() - 1;
let n = divisor.coeffs.len() - 1;
if n > m {
return Ok(PolyData::new(0));
}
if divisor.coeffs[divisor.coeffs.len() - 1].is_zero() {
return Err(String::from("divisor coeffs last member is zero"));
}
let mut out = PolyData::new(0);
if divisor.len() == 1 {
for i in 0..dividend.len() {
out.coeffs
.push(dividend.coeffs[i].div(&divisor.coeffs[0]).unwrap());
}
return Ok(out);
}
let a_flip = poly_flip(dividend).unwrap();
let b_flip = poly_flip(divisor).unwrap();
let inv_b_flip = poly_inverse(&b_flip, m - n + 1).unwrap();
let q_flip = poly_mul(&a_flip, &inv_b_flip, None, m - n + 1).unwrap();
out = poly_flip(&q_flip).unwrap();
Ok(PolyData {
coeffs: out.coeffs[..m - n + 1].to_vec(),
})
}
pub fn poly_flip(input: &PolyData) -> Result<PolyData, String> {
let mut output = PolyData::new(0);
for i in 0..input.len() {
output.coeffs.push(input.coeffs[input.coeffs.len() - i - 1]);
}
Ok(output)
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/kzg_types.rs | arkworks3/src/kzg_types.rs | use crate::consts::SCALE2_ROOT_OF_UNITY;
use crate::fft_g1::{fft_g1_fast, g1_linear_combination};
use crate::kzg_proofs::{
eval_poly, expand_root_of_unity, pairings_verify, FFTSettings as LFFTSettings,
KZGSettings as LKZGSettings,
};
use crate::poly::{poly_fast_div, poly_inverse, poly_long_div, poly_mul_direct, poly_mul_fft};
use crate::recover::{scale_poly, unscale_poly};
use crate::utils::{
blst_fp_into_pc_fq, blst_fr_into_pc_fr, blst_p1_into_pc_g1projective,
blst_p2_into_pc_g2projective, pc_fr_into_blst_fr, pc_g1projective_into_blst_p1,
pc_g2projective_into_blst_p2, PolyData,
};
use arbitrary::Arbitrary;
use ark_bls12_381::{g1, g2, Fr, G1Affine};
use ark_ec::short_weierstrass_jacobian::GroupAffine;
use ark_ec::ModelParameters;
use ark_ec::{models::short_weierstrass_jacobian::GroupProjective, AffineCurve, ProjectiveCurve};
use ark_ff::PrimeField;
use ark_ff::{biginteger::BigInteger256, BigInteger, Field};
use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
use ark_std::{One, Zero};
#[cfg(feature = "rand")]
use ark_std::UniformRand;
use kzg::common_utils::reverse_bit_order;
use kzg::eip_4844::{BYTES_PER_FIELD_ELEMENT, BYTES_PER_G1, BYTES_PER_G2};
use kzg::eth::c_bindings::{blst_fp, blst_fp2, blst_fr, blst_p1, blst_p2};
use kzg::msm::precompute::{precompute, PrecomputationTable};
use kzg::{
FFTFr, FFTSettings, FFTSettingsPoly, Fr as KzgFr, G1Affine as G1AffineTrait, G1Fp, G1GetFp,
G1LinComb, G1Mul, G1ProjAddAffine, G2Mul, KZGSettings, PairingVerify, Poly, Scalar256, G1, G2,
};
use std::ops::{AddAssign, Neg, Sub};
extern crate alloc;
use alloc::sync::Arc;
fn bytes_be_to_uint64(inp: &[u8]) -> u64 {
u64::from_be_bytes(inp.try_into().expect("Input wasn't 8 elements..."))
}
const BLS12_381_MOD_256: [u64; 4] = [
0xffffffff00000001,
0x53bda402fffe5bfe,
0x3339d80809a1d805,
0x73eda753299d7d48,
];
#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
pub struct ArkFr {
pub fr: Fr,
}
impl ArkFr {
pub fn from_blst_fr(fr: blst_fr) -> Self {
Self {
fr: blst_fr_into_pc_fr(fr),
}
}
pub fn to_blst_fr(&self) -> blst_fr {
pc_fr_into_blst_fr(self.fr)
}
}
fn bigint_check_mod_256(a: &[u64; 4]) -> bool {
let (_, overflow) = a[0].overflowing_sub(BLS12_381_MOD_256[0]);
let (_, overflow) = a[1].overflowing_sub(BLS12_381_MOD_256[1] + overflow as u64);
let (_, overflow) = a[2].overflowing_sub(BLS12_381_MOD_256[2] + overflow as u64);
let (_, overflow) = a[3].overflowing_sub(BLS12_381_MOD_256[3] + overflow as u64);
overflow
}
impl KzgFr for ArkFr {
fn null() -> Self {
Self {
fr: Fr::new(BigInteger256::new([u64::MAX; 4])),
}
}
fn zero() -> Self {
Self { fr: Fr::zero() }
}
fn one() -> Self {
Self::from_u64(1)
}
#[cfg(feature = "rand")]
fn rand() -> Self {
let mut rng = rand::thread_rng();
Self {
fr: Fr::rand(&mut rng),
}
}
fn from_bytes(bytes: &[u8]) -> Result<Self, String> {
bytes
.try_into()
.map_err(|_| {
format!(
"Invalid byte length. Expected {}, got {}",
BYTES_PER_FIELD_ELEMENT,
bytes.len()
)
})
.and_then(|bytes: &[u8; BYTES_PER_FIELD_ELEMENT]| {
let storage: [u64; 4] = [
bytes_be_to_uint64(&bytes[24..32]),
bytes_be_to_uint64(&bytes[16..24]),
bytes_be_to_uint64(&bytes[8..16]),
bytes_be_to_uint64(&bytes[0..8]),
];
let big_int = BigInteger256::new(storage);
if !big_int.is_zero() && !bigint_check_mod_256(&big_int.0) {
return Err("Invalid scalar".to_string());
}
Ok(Self {
fr: Fr::from(big_int),
})
})
}
fn from_bytes_unchecked(bytes: &[u8]) -> Result<Self, String> {
bytes
.try_into()
.map_err(|_| {
format!(
"Invalid byte length. Expected {}, got {}",
BYTES_PER_FIELD_ELEMENT,
bytes.len()
)
})
.map(|bytes: &[u8; BYTES_PER_FIELD_ELEMENT]| Self {
fr: Fr::from_be_bytes_mod_order(bytes),
})
}
fn from_hex(hex: &str) -> Result<Self, String> {
let bytes = hex::decode(&hex[2..]).unwrap();
Self::from_bytes(&bytes)
}
fn from_u64_arr(u: &[u64; 4]) -> Self {
Self {
fr: Fr::from(BigInteger256::new(*u)),
}
}
fn from_u64(val: u64) -> Self {
Self { fr: Fr::from(val) }
}
fn to_bytes(&self) -> [u8; 32] {
let big_int_256: BigInteger256 = Fr::into(self.fr);
<[u8; 32]>::try_from(big_int_256.to_bytes_be()).unwrap()
}
fn to_u64_arr(&self) -> [u64; 4] {
let b: BigInteger256 = Fr::into(self.fr);
b.0
}
fn is_one(&self) -> bool {
self.fr.is_one()
}
fn is_zero(&self) -> bool {
self.fr.is_zero()
}
fn is_null(&self) -> bool {
self.equals(&ArkFr::null())
}
fn sqr(&self) -> Self {
Self {
fr: self.fr.square(),
}
}
fn mul(&self, b: &Self) -> Self {
Self { fr: self.fr * b.fr }
}
fn add(&self, b: &Self) -> Self {
Self { fr: self.fr + b.fr }
}
fn sub(&self, b: &Self) -> Self {
Self { fr: self.fr - b.fr }
}
fn eucl_inverse(&self) -> Self {
// Inverse and eucl inverse work the same way
Self {
fr: self.fr.inverse().unwrap(),
}
}
fn negate(&self) -> Self {
Self { fr: self.fr.neg() }
}
fn inverse(&self) -> Self {
Self {
fr: self.fr.inverse().unwrap(),
}
}
fn pow(&self, n: usize) -> Self {
Self {
fr: self.fr.pow([n as u64]),
}
}
fn div(&self, b: &Self) -> Result<Self, String> {
let div = self.fr / b.fr;
if div.0 .0.is_empty() {
Ok(Self { fr: Fr::zero() })
} else {
Ok(Self { fr: div })
}
}
fn equals(&self, b: &Self) -> bool {
self.fr == b.fr
}
fn to_scalar(&self) -> Scalar256 {
Scalar256::from_u64(self.fr.0 .0)
}
}
impl<'a> Arbitrary<'a> for ArkFr {
fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
let val: [u8; 32] = u.arbitrary()?;
Ok(Self::from_bytes_unchecked(&val).unwrap())
}
}
#[repr(C)]
#[derive(Debug, Default, PartialEq, Eq, Clone, Copy, Hash)]
pub struct ArkG1(pub GroupProjective<g1::Parameters>);
impl ArkG1 {
pub fn from_blst_p1(p1: blst_p1) -> Self {
Self(blst_p1_into_pc_g1projective(&p1))
}
pub fn to_blst_p1(&self) -> blst_p1 {
pc_g1projective_into_blst_p1(self.0)
}
}
impl From<blst_p1> for ArkG1 {
fn from(p1: blst_p1) -> Self {
Self(blst_p1_into_pc_g1projective(&p1))
}
}
impl G1 for ArkG1 {
fn identity() -> Self {
ArkG1::from_blst_p1(blst_p1 {
x: blst_fp {
l: [0, 0, 0, 0, 0, 0],
},
y: blst_fp {
l: [0, 0, 0, 0, 0, 0],
},
z: blst_fp {
l: [0, 0, 0, 0, 0, 0],
},
})
}
fn generator() -> Self {
ArkG1::from_blst_p1(blst_p1 {
x: blst_fp {
l: [
0x5cb38790fd530c16,
0x7817fc679976fff5,
0x154f95c7143ba1c1,
0xf0ae6acdf3d0e747,
0xedce6ecc21dbf440,
0x120177419e0bfb75,
],
},
y: blst_fp {
l: [
0xbaac93d50ce72271,
0x8c22631a7918fd8e,
0xdd595f13570725ce,
0x51ac582950405194,
0x0e1c8c3fad0059c0,
0x0bbc3efc5008a26a,
],
},
z: blst_fp {
l: [
0x760900000002fffd,
0xebf4000bc40c0002,
0x5f48985753c758ba,
0x77ce585370525745,
0x5c071a97a256ec6d,
0x15f65ec3fa80e493,
],
},
})
}
fn negative_generator() -> Self {
ArkG1::from_blst_p1(blst_p1 {
x: blst_fp {
l: [
0x5cb38790fd530c16,
0x7817fc679976fff5,
0x154f95c7143ba1c1,
0xf0ae6acdf3d0e747,
0xedce6ecc21dbf440,
0x120177419e0bfb75,
],
},
y: blst_fp {
l: [
0xff526c2af318883a,
0x92899ce4383b0270,
0x89d7738d9fa9d055,
0x12caf35ba344c12a,
0x3cff1b76964b5317,
0x0e44d2ede9774430,
],
},
z: blst_fp {
l: [
0x760900000002fffd,
0xebf4000bc40c0002,
0x5f48985753c758ba,
0x77ce585370525745,
0x5c071a97a256ec6d,
0x15f65ec3fa80e493,
],
},
})
}
#[cfg(feature = "rand")]
fn rand() -> Self {
let mut rng = rand::thread_rng();
Self(GroupProjective::rand(&mut rng))
}
#[allow(clippy::bind_instead_of_map)]
fn from_bytes(bytes: &[u8]) -> Result<Self, String> {
bytes
.try_into()
.map_err(|_| {
format!(
"Invalid byte length. Expected {}, got {}",
BYTES_PER_G1,
bytes.len()
)
})
.and_then(|bytes: &[u8; BYTES_PER_G1]| {
let mut blst_affine = blst::blst_p1_affine::default();
let result = unsafe { blst::blst_p1_uncompress(&mut blst_affine, bytes.as_ptr()) };
if result != blst::BLST_ERROR::BLST_SUCCESS {
return Err("Failed to deserialize G1".to_owned());
}
let mut blst_point = blst::blst_p1::default();
unsafe { blst::blst_p1_from_affine(&mut blst_point, &blst_affine) };
Ok(ArkG1::from_blst_p1(blst_p1 {
x: blst_fp { l: blst_point.x.l },
y: blst_fp { l: blst_point.y.l },
z: blst_fp { l: blst_point.z.l },
}))
})
}
fn from_hex(hex: &str) -> Result<Self, String> {
let bytes = hex::decode(&hex[2..]).unwrap();
Self::from_bytes(&bytes)
}
fn to_bytes(&self) -> [u8; BYTES_PER_G1] {
let mut out = [0u8; BYTES_PER_G1];
let v = self.to_blst_p1();
unsafe {
blst::blst_p1_compress(
out.as_mut_ptr(),
&blst::blst_p1 {
x: blst::blst_fp { l: v.x.l },
y: blst::blst_fp { l: v.y.l },
z: blst::blst_fp { l: v.z.l },
},
);
}
out
}
fn add_or_dbl(&self, b: &Self) -> Self {
Self(self.0 + b.0)
}
fn is_inf(&self) -> bool {
self.0.is_zero()
}
fn is_valid(&self) -> bool {
let affine = self.0.into_affine();
affine.is_on_curve() && affine.is_in_correct_subgroup_assuming_on_curve()
}
fn dbl(&self) -> Self {
Self(self.0.double())
}
fn add(&self, b: &Self) -> Self {
Self(self.0 + b.0)
}
fn sub(&self, b: &Self) -> Self {
Self(self.0.sub(&b.0))
}
fn equals(&self, b: &Self) -> bool {
self.0.eq(&b.0)
}
fn zero() -> Self {
ArkG1::from_blst_p1(blst_p1 {
x: blst_fp {
l: [
8505329371266088957,
17002214543764226050,
6865905132761471162,
8632934651105793861,
6631298214892334189,
1582556514881692819,
],
},
y: blst_fp {
l: [
8505329371266088957,
17002214543764226050,
6865905132761471162,
8632934651105793861,
6631298214892334189,
1582556514881692819,
],
},
z: blst_fp {
l: [0, 0, 0, 0, 0, 0],
},
})
}
fn add_or_dbl_assign(&mut self, b: &Self) {
self.0 += b.0;
}
fn add_assign(&mut self, b: &Self) {
self.0.add_assign(b.0);
}
fn dbl_assign(&mut self) {
self.0.double_in_place();
}
}
impl G1Mul<ArkFr> for ArkG1 {
fn mul(&self, b: &ArkFr) -> Self {
Self(self.0.mul(b.to_u64_arr()))
}
}
impl G1LinComb<ArkFr, ArkFp, ArkG1Affine, ArkG1ProjAddAffine> for ArkG1 {
fn g1_lincomb(
points: &[Self],
scalars: &[ArkFr],
len: usize,
precomputation: Option<
&PrecomputationTable<ArkFr, Self, ArkFp, ArkG1Affine, ArkG1ProjAddAffine>,
>,
) -> Self {
let mut out = Self::default();
g1_linear_combination(&mut out, points, scalars, len, precomputation);
out
}
}
impl PairingVerify<ArkG1, ArkG2> for ArkG1 {
fn verify(a1: &ArkG1, a2: &ArkG2, b1: &ArkG1, b2: &ArkG2) -> bool {
pairings_verify(a1, a2, b1, b2)
}
}
#[repr(C)]
#[derive(Debug, Default, PartialEq, Eq, Clone)]
pub struct ArkG2(pub GroupProjective<g2::Parameters>);
impl ArkG2 {
pub fn from_blst_p2(p2: blst_p2) -> Self {
Self(blst_p2_into_pc_g2projective(&p2))
}
pub fn to_blst_p2(&self) -> blst_p2 {
pc_g2projective_into_blst_p2(self.0)
}
}
impl G2 for ArkG2 {
fn generator() -> Self {
ArkG2::from_blst_p2(blst_p2 {
x: blst_fp2 {
fp: [
blst_fp {
l: [
0xf5f28fa202940a10,
0xb3f5fb2687b4961a,
0xa1a893b53e2ae580,
0x9894999d1a3caee9,
0x6f67b7631863366b,
0x058191924350bcd7,
],
},
blst_fp {
l: [
0xa5a9c0759e23f606,
0xaaa0c59dbccd60c3,
0x3bb17e18e2867806,
0x1b1ab6cc8541b367,
0xc2b6ed0ef2158547,
0x11922a097360edf3,
],
},
],
},
y: blst_fp2 {
fp: [
blst_fp {
l: [
0x4c730af860494c4a,
0x597cfa1f5e369c5a,
0xe7e6856caa0a635a,
0xbbefb5e96e0d495f,
0x07d3a975f0ef25a2,
0x0083fd8e7e80dae5,
],
},
blst_fp {
l: [
0xadc0fc92df64b05d,
0x18aa270a2b1461dc,
0x86adac6a3be4eba0,
0x79495c4ec93da33a,
0xe7175850a43ccaed,
0x0b2bc2a163de1bf2,
],
},
],
},
z: blst_fp2 {
fp: [
blst_fp {
l: [
0x760900000002fffd,
0xebf4000bc40c0002,
0x5f48985753c758ba,
0x77ce585370525745,
0x5c071a97a256ec6d,
0x15f65ec3fa80e493,
],
},
blst_fp {
l: [
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
],
},
],
},
})
}
fn negative_generator() -> Self {
ArkG2::from_blst_p2(blst_p2 {
x: blst_fp2 {
fp: [
blst_fp {
l: [
0xf5f28fa202940a10,
0xb3f5fb2687b4961a,
0xa1a893b53e2ae580,
0x9894999d1a3caee9,
0x6f67b7631863366b,
0x058191924350bcd7,
],
},
blst_fp {
l: [
0xa5a9c0759e23f606,
0xaaa0c59dbccd60c3,
0x3bb17e18e2867806,
0x1b1ab6cc8541b367,
0xc2b6ed0ef2158547,
0x11922a097360edf3,
],
},
],
},
y: blst_fp2 {
fp: [
blst_fp {
l: [
0x6d8bf5079fb65e61,
0xc52f05df531d63a5,
0x7f4a4d344ca692c9,
0xa887959b8577c95f,
0x4347fe40525c8734,
0x197d145bbaff0bb5,
],
},
blst_fp {
l: [
0x0c3e036d209afa4e,
0x0601d8f4863f9e23,
0xe0832636bacc0a84,
0xeb2def362a476f84,
0x64044f659f0ee1e9,
0x0ed54f48d5a1caa7,
],
},
],
},
z: blst_fp2 {
fp: [
blst_fp {
l: [
0x760900000002fffd,
0xebf4000bc40c0002,
0x5f48985753c758ba,
0x77ce585370525745,
0x5c071a97a256ec6d,
0x15f65ec3fa80e493,
],
},
blst_fp {
l: [
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
],
},
],
},
})
}
#[allow(clippy::bind_instead_of_map)]
fn from_bytes(bytes: &[u8]) -> Result<Self, String> {
bytes
.try_into()
.map_err(|_| {
format!(
"Invalid byte length. Expected {}, got {}",
BYTES_PER_G2,
bytes.len()
)
})
.and_then(|bytes: &[u8; BYTES_PER_G2]| {
let mut blst_affine = blst::blst_p2_affine::default();
let result = unsafe { blst::blst_p2_uncompress(&mut blst_affine, bytes.as_ptr()) };
if result != blst::BLST_ERROR::BLST_SUCCESS {
return Err("Failed to deserialize G1".to_owned());
}
let mut blst_point = blst::blst_p2::default();
unsafe { blst::blst_p2_from_affine(&mut blst_point, &blst_affine) };
Ok(ArkG2::from_blst_p2(blst_p2 {
x: blst_fp2 {
fp: [
blst_fp {
l: blst_point.x.fp[0].l,
},
blst_fp {
l: blst_point.x.fp[1].l,
},
],
},
y: blst_fp2 {
fp: [
blst_fp {
l: blst_point.y.fp[0].l,
},
blst_fp {
l: blst_point.y.fp[1].l,
},
],
},
z: blst_fp2 {
fp: [
blst_fp {
l: blst_point.z.fp[0].l,
},
blst_fp {
l: blst_point.z.fp[1].l,
},
],
},
}))
})
}
fn to_bytes(&self) -> [u8; 96] {
<[u8; 96]>::try_from(self.0.x.c0.0.to_bytes_le()).unwrap()
}
fn add_or_dbl(&mut self, b: &Self) -> Self {
Self(self.0 + b.0)
}
fn dbl(&self) -> Self {
Self(self.0.double())
}
fn sub(&self, b: &Self) -> Self {
Self(self.0 - b.0)
}
fn equals(&self, b: &Self) -> bool {
self.0.eq(&b.0)
}
}
impl G2Mul<ArkFr> for ArkG2 {
fn mul(&self, b: &ArkFr) -> Self {
Self(self.0.mul(b.to_u64_arr()))
}
}
impl Poly<ArkFr> for PolyData {
fn new(size: usize) -> PolyData {
Self {
coeffs: vec![ArkFr::default(); size],
}
}
fn get_coeff_at(&self, i: usize) -> ArkFr {
self.coeffs[i]
}
fn set_coeff_at(&mut self, i: usize, x: &ArkFr) {
self.coeffs[i] = *x;
}
fn get_coeffs(&self) -> &[ArkFr] {
&self.coeffs
}
fn len(&self) -> usize {
self.coeffs.len()
}
fn eval(&self, x: &ArkFr) -> ArkFr {
eval_poly(self, x)
}
fn scale(&mut self) {
scale_poly(self);
}
fn unscale(&mut self) {
unscale_poly(self);
}
fn inverse(&mut self, new_len: usize) -> Result<Self, String> {
poly_inverse(self, new_len)
}
fn div(&mut self, x: &Self) -> Result<Self, String> {
if x.len() >= self.len() || x.len() < 128 {
poly_long_div(self, x)
} else {
poly_fast_div(self, x)
}
}
fn long_div(&mut self, x: &Self) -> Result<Self, String> {
poly_long_div(self, x)
}
fn fast_div(&mut self, x: &Self) -> Result<Self, String> {
poly_fast_div(self, x)
}
fn mul_direct(&mut self, x: &Self, len: usize) -> Result<Self, String> {
poly_mul_direct(self, x, len)
}
}
impl FFTSettingsPoly<ArkFr, PolyData, LFFTSettings> for LFFTSettings {
fn poly_mul_fft(
a: &PolyData,
x: &PolyData,
len: usize,
fs: Option<&LFFTSettings>,
) -> Result<PolyData, String> {
poly_mul_fft(a, x, fs, len)
}
}
impl Default for LFFTSettings {
fn default() -> Self {
Self {
max_width: 0,
root_of_unity: ArkFr::zero(),
brp_roots_of_unity: Vec::new(),
reverse_roots_of_unity: Vec::new(),
roots_of_unity: Vec::new(),
}
}
}
impl FFTSettings<ArkFr> for LFFTSettings {
fn new(scale: usize) -> Result<LFFTSettings, String> {
if scale >= SCALE2_ROOT_OF_UNITY.len() {
return Err(String::from(
"Scale is expected to be within root of unity matrix row size",
));
}
let max_width: usize = 1 << scale;
let root_of_unity = ArkFr::from_u64_arr(&SCALE2_ROOT_OF_UNITY[scale]);
let roots_of_unity = expand_root_of_unity(&root_of_unity, max_width)?;
let mut brp_roots_of_unity = roots_of_unity.clone();
brp_roots_of_unity.pop();
reverse_bit_order(&mut brp_roots_of_unity)?;
let mut reverse_roots_of_unity = roots_of_unity.clone();
reverse_roots_of_unity.reverse();
Ok(LFFTSettings {
max_width,
root_of_unity,
reverse_roots_of_unity,
roots_of_unity,
brp_roots_of_unity,
})
}
fn get_max_width(&self) -> usize {
self.max_width
}
fn get_reverse_roots_of_unity_at(&self, i: usize) -> ArkFr {
self.reverse_roots_of_unity[i]
}
fn get_reversed_roots_of_unity(&self) -> &[ArkFr] {
&self.reverse_roots_of_unity
}
fn get_roots_of_unity_at(&self, i: usize) -> ArkFr {
self.roots_of_unity[i]
}
fn get_roots_of_unity(&self) -> &[ArkFr] {
&self.roots_of_unity
}
fn get_brp_roots_of_unity(&self) -> &[ArkFr] {
&self.brp_roots_of_unity
}
fn get_brp_roots_of_unity_at(&self, i: usize) -> ArkFr {
self.brp_roots_of_unity[i]
}
}
fn toeplitz_part_1(
field_elements_per_ext_blob: usize,
output: &mut [ArkG1],
x: &[ArkG1],
s: &LFFTSettings,
) -> Result<(), String> {
let n = x.len();
let n2 = n * 2;
let mut x_ext = vec![ArkG1::identity(); n2];
x_ext[..n].copy_from_slice(x);
let x_ext = &x_ext[..];
/* Ensure the length is valid */
if x_ext.len() > field_elements_per_ext_blob || !x_ext.len().is_power_of_two() {
return Err("Invalid input size".to_string());
}
let roots_stride = field_elements_per_ext_blob / x_ext.len();
fft_g1_fast(output, x_ext, 1, &s.roots_of_unity, roots_stride);
Ok(())
}
impl
KZGSettings<ArkFr, ArkG1, ArkG2, LFFTSettings, PolyData, ArkFp, ArkG1Affine, ArkG1ProjAddAffine>
for LKZGSettings
{
fn new(
g1_monomial: &[ArkG1],
g1_lagrange_brp: &[ArkG1],
g2_monomial: &[ArkG2],
fft_settings: &LFFTSettings,
cell_size: usize,
) -> Result<Self, String> {
if g1_monomial.len() != g1_lagrange_brp.len() {
return Err("G1 point length mismatch".to_string());
}
let field_elements_per_blob = g1_monomial.len();
let field_elements_per_ext_blob = field_elements_per_blob * 2;
let n = field_elements_per_ext_blob / 2;
let k = n / cell_size;
let k2 = 2 * k;
let mut points = vec![ArkG1::default(); k2];
let mut x = vec![ArkG1::default(); k];
let mut x_ext_fft_columns = vec![vec![ArkG1::default(); cell_size]; k2];
for offset in 0..cell_size {
let start = n - cell_size - 1 - offset;
for (i, p) in x.iter_mut().enumerate().take(k - 1) {
let j = start - i * cell_size;
*p = g1_monomial[j];
}
x[k - 1] = ArkG1::identity();
toeplitz_part_1(field_elements_per_ext_blob, &mut points, &x, fft_settings)?;
for row in 0..k2 {
x_ext_fft_columns[row][offset] = points[row];
}
}
Ok(Self {
g1_values_monomial: g1_monomial.to_vec(),
g1_values_lagrange_brp: g1_lagrange_brp.to_vec(),
g2_values_monomial: g2_monomial.to_vec(),
fs: fft_settings.clone(),
precomputation: {
#[cfg(feature = "sppark")]
{
use ark_bls12_381::G1Affine;
let points = kzg::msm::msm_impls::batch_convert::<ArkG1, ArkFp, ArkG1Affine>(
g1_lagrange_brp,
);
let points = unsafe {
alloc::slice::from_raw_parts(
points.as_ptr() as *const G1Affine,
points.len(),
)
};
let prepared = rust_kzg_arkworks3_sppark::prepare_multi_scalar_mult(points);
Some(Arc::new(PrecomputationTable::from_ptr(prepared)))
}
#[cfg(feature = "sppark_wlc")]
{
let affines = kzg::msm::msm_impls::batch_convert::<ArkG1, ArkFp, ArkG1Affine>(
&g1_lagrange_brp,
);
let affines = unsafe {
alloc::slice::from_raw_parts(
affines.as_ptr() as *const G1Affine,
g1_lagrange_brp.len(),
)
};
Some(Arc::new(PrecomputationTable::from_ptr(
rust_kzg_arkworks3_sppark_wlc::multi_scalar_mult_init(affines).context,
)))
}
#[cfg(not(any(feature = "sppark", feature = "sppark_wlc")))]
{
precompute(g1_lagrange_brp, &x_ext_fft_columns)
.ok()
.flatten()
.map(Arc::new)
}
},
x_ext_fft_columns,
cell_size,
})
}
fn commit_to_poly(&self, p: &PolyData) -> Result<ArkG1, String> {
if p.coeffs.len() > self.g1_values_monomial.len() {
return Err(String::from("Polynomial is longer than secret g1"));
}
let mut out = ArkG1::default();
g1_linear_combination(
&mut out,
&self.g1_values_monomial,
&p.coeffs,
p.coeffs.len(),
None,
);
Ok(out)
}
fn compute_proof_single(&self, p: &PolyData, x: &ArkFr) -> Result<ArkG1, String> {
if p.coeffs.is_empty() {
return Err(String::from("Polynomial must not be empty"));
}
// `-(x0^n)`, where `n` is `1`
let divisor_0 = x.negate();
// Calculate `q = p / (x^n - x0^n)` for our reduced case (see `compute_proof_multi` for
// generic implementation)
let mut out_coeffs = Vec::from(&p.coeffs[1..]);
for i in (1..out_coeffs.len()).rev() {
let tmp = out_coeffs[i].mul(&divisor_0);
out_coeffs[i - 1] = out_coeffs[i - 1].sub(&tmp);
}
let q = PolyData { coeffs: out_coeffs };
let ret = self.commit_to_poly(&q)?;
Ok(ret)
// Ok(compute_single(p, x, self))
}
fn check_proof_single(
&self,
com: &ArkG1,
proof: &ArkG1,
x: &ArkFr,
y: &ArkFr,
) -> Result<bool, String> {
let x_g2: ArkG2 = ArkG2::generator().mul(x);
let s_minus_x: ArkG2 = self.g2_values_monomial[1].sub(&x_g2);
let y_g1 = ArkG1::generator().mul(y);
let commitment_minus_y: ArkG1 = com.sub(&y_g1);
Ok(pairings_verify(
&commitment_minus_y,
&ArkG2::generator(),
proof,
&s_minus_x,
))
}
fn compute_proof_multi(&self, p: &PolyData, x: &ArkFr, n: usize) -> Result<ArkG1, String> {
if p.coeffs.is_empty() {
return Err(String::from("Polynomial must not be empty"));
}
if !n.is_power_of_two() {
return Err(String::from("n must be a power of two"));
}
// Construct x^n - x0^n = (x - x0.w^0)(x - x0.w^1)...(x - x0.w^(n-1))
let mut divisor = PolyData {
coeffs: Vec::with_capacity(n + 1),
};
// -(x0^n)
let x_pow_n = x.pow(n);
divisor.coeffs.push(x_pow_n.negate());
// Zeros
for _ in 1..n {
divisor.coeffs.push(ArkFr { fr: Fr::zero() });
}
// x^n
divisor.coeffs.push(ArkFr { fr: Fr::one() });
let mut new_polina = p.clone();
// Calculate q = p / (x^n - x0^n)
// let q = p.div(&divisor).unwrap();
let q = new_polina.div(&divisor)?;
let ret = self.commit_to_poly(&q)?;
Ok(ret)
}
fn check_proof_multi(
&self,
com: &ArkG1,
proof: &ArkG1,
x: &ArkFr,
ys: &[ArkFr],
n: usize,
) -> Result<bool, String> {
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | true |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/zero_poly.rs | arkworks3/src/zero_poly.rs | use super::kzg_proofs::FFTSettings;
use super::utils::{blst_poly_into_pc_poly, pc_poly_into_blst_poly, PolyData};
use crate::kzg_types::ArkFr as BlstFr;
use kzg::common_utils::next_pow_of_2;
use kzg::{FFTFr, Fr as FrTrait, ZeroPoly};
use std::cmp::{min, Ordering};
use std::ops::Neg;
pub(crate) fn pad_poly(poly: &PolyData, new_length: usize) -> Result<Vec<BlstFr>, String> {
if new_length <= poly.coeffs.len() {
return Ok(poly.coeffs.clone());
}
let mut out = poly.coeffs.to_vec();
for _i in poly.coeffs.len()..new_length {
out.push(BlstFr::zero())
}
Ok(out)
}
impl ZeroPoly<BlstFr, PolyData> for FFTSettings {
fn do_zero_poly_mul_partial(
&self,
indices: &[usize],
stride: usize,
) -> Result<PolyData, String> {
if indices.is_empty() {
return Err(String::from("idx array must be non-zero"));
}
let blstpoly = PolyData {
coeffs: vec![BlstFr::one(); indices.len() + 1],
};
let mut poly = blst_poly_into_pc_poly(&blstpoly.coeffs);
poly.coeffs[0] = (self.roots_of_unity[indices[0] * stride]).fr.neg();
for (i, indice) in indices.iter().enumerate().skip(1) {
let neg_di = (self.roots_of_unity[indice * stride]).fr.neg();
poly.coeffs[i] = neg_di + poly.coeffs[i - 1];
let mut j = i - 1;
while j > 0 {
let temp = poly.coeffs[j] * neg_di;
poly.coeffs[j] = temp + poly.coeffs[j - 1];
j -= 1;
}
poly.coeffs[0] *= neg_di;
}
Ok(pc_poly_into_blst_poly(poly))
}
fn reduce_partials(&self, len_out: usize, partials: &[PolyData]) -> Result<PolyData, String> {
let mut out_degree: usize = 0;
for partial in partials {
out_degree += partial.coeffs.len() - 1;
}
if out_degree + 1 > len_out {
return Err(String::from("Expected domain size to be a power of 2"));
}
let mut p_partial = pad_poly(&partials[0], len_out).unwrap();
let mut mul_eval_ps = self.fft_fr(&p_partial, false).unwrap();
for partial in partials.iter().skip(1) {
p_partial = pad_poly(partial, len_out)?;
let p_eval = self.fft_fr(&p_partial, false).unwrap();
for j in 0..len_out {
mul_eval_ps[j].fr *= p_eval[j].fr;
}
}
let coeffs = self.fft_fr(&mul_eval_ps, true)?;
let out = PolyData {
coeffs: coeffs[..(out_degree + 1)].to_vec(),
};
Ok(out)
}
fn zero_poly_via_multiplication(
&self,
length: usize,
missing_indices: &[usize],
) -> Result<(Vec<BlstFr>, PolyData), String> {
let zero_eval: Vec<BlstFr>;
let mut zero_poly: PolyData;
if missing_indices.is_empty() {
zero_eval = Vec::new();
zero_poly = PolyData { coeffs: Vec::new() };
return Ok((zero_eval, zero_poly));
}
if missing_indices.len() >= length {
return Err(String::from("Missing idxs greater than domain size"));
} else if length > self.max_width {
return Err(String::from(
"Domain size greater than fft_settings.max_width",
));
} else if !length.is_power_of_two() {
return Err(String::from("Domain size must be a power of 2"));
}
let degree_of_partial = 256;
let missing_per_partial = degree_of_partial - 1;
let domain_stride = self.max_width / length;
let mut partial_count =
(missing_per_partial + missing_indices.len() - 1) / missing_per_partial;
let domain_ceiling = min(next_pow_of_2(partial_count * degree_of_partial), length);
if missing_indices.len() <= missing_per_partial {
zero_poly = self.do_zero_poly_mul_partial(missing_indices, domain_stride)?;
} else {
let mut work = vec![BlstFr::zero(); next_pow_of_2(partial_count * degree_of_partial)];
let mut partial_lens = Vec::new();
let mut offset = 0;
let mut out_offset = 0;
let max = missing_indices.len();
for _i in 0..partial_count {
let end = min(offset + missing_per_partial, max);
let mut partial =
self.do_zero_poly_mul_partial(&missing_indices[offset..end], domain_stride)?;
partial.coeffs = pad_poly(&partial, degree_of_partial)?;
work.splice(
out_offset..(out_offset + degree_of_partial),
partial.coeffs.to_vec(),
);
partial_lens.push(degree_of_partial);
offset += missing_per_partial;
out_offset += degree_of_partial;
}
partial_lens[partial_count - 1] =
1 + missing_indices.len() - (partial_count - 1) * missing_per_partial;
let reduction_factor = 4;
while partial_count > 1 {
let reduced_count = 1 + (partial_count - 1) / reduction_factor;
let partial_size = next_pow_of_2(partial_lens[0]);
for i in 0..reduced_count {
let start = i * reduction_factor;
let out_end = min((start + reduction_factor) * partial_size, domain_ceiling);
let reduced_len = min(out_end - start * partial_size, length);
let partials_num = min(reduction_factor, partial_count - start);
let mut partial_vec = Vec::new();
for j in 0..partials_num {
let k = (start + j) * partial_size;
partial_vec.push(PolyData {
coeffs: work[k..(k + partial_lens[i + j])].to_vec(),
});
}
if partials_num > 1 {
let mut reduced_poly = self.reduce_partials(reduced_len, &partial_vec)?;
partial_lens[i] = reduced_poly.coeffs.len();
reduced_poly.coeffs = pad_poly(&reduced_poly, partial_size * partials_num)?;
work.splice(
(start * partial_size)
..(start * partial_size + reduced_poly.coeffs.len()),
reduced_poly.coeffs,
);
} else {
partial_lens[i] = partial_lens[start];
}
}
partial_count = reduced_count;
}
zero_poly = PolyData { coeffs: work };
}
match zero_poly.coeffs.len().cmp(&length) {
Ordering::Less => zero_poly.coeffs = pad_poly(&zero_poly, length)?,
Ordering::Greater => zero_poly.coeffs = zero_poly.coeffs[..length].to_vec(),
Ordering::Equal => {}
}
zero_eval = self.fft_fr(&zero_poly.coeffs, false)?;
Ok((zero_eval, zero_poly))
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/fk20_proofs.rs | arkworks3/src/fk20_proofs.rs | use crate::kzg_proofs::{FFTSettings, KZGSettings as LKZGSettings};
use crate::kzg_types::{ArkFp, ArkFr as BlstFr, ArkG1, ArkG1Affine, ArkG1ProjAddAffine, ArkG2};
use crate::utils::PolyData;
use kzg::common_utils::reverse_bit_order;
use kzg::{FFTFr, FK20MultiSettings, FK20SingleSettings, Fr, G1Mul, Poly, FFTG1, G1};
#[cfg(feature = "parallel")]
use rayon::prelude::*;
#[repr(C)]
#[derive(Debug, Clone, Default)]
pub struct KzgFK20SingleSettings {
pub ks: LKZGSettings,
pub x_ext_fft: Vec<ArkG1>,
pub x_ext_fft_len: usize,
}
#[repr(C)]
#[derive(Debug, Clone, Default)]
pub struct KzgFK20MultiSettings {
pub ks: LKZGSettings,
pub chunk_len: usize,
pub x_ext_fft_files: Vec<Vec<ArkG1>>,
pub length: usize,
}
impl
FK20SingleSettings<
BlstFr,
ArkG1,
ArkG2,
FFTSettings,
PolyData,
LKZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
> for KzgFK20SingleSettings
{
fn new(ks: &LKZGSettings, n2: usize) -> Result<Self, String> {
let n = n2 / 2;
if n2 > ks.fs.max_width {
return Err(String::from(
"n2 must be equal or less than kzg settings max width",
));
}
if !n2.is_power_of_two() {
return Err(String::from("n2 must be power of 2"));
}
if n2 < 2 {
return Err(String::from("n2 must be equal or greater than 2"));
}
let mut x = Vec::new();
for i in 0..(n - 1) {
x.push(ks.g1_values_monomial[n - 2 - i])
}
x.push(ArkG1::identity());
let new_ks = LKZGSettings {
fs: ks.fs.clone(),
..LKZGSettings::default()
};
Ok(KzgFK20SingleSettings {
ks: new_ks,
x_ext_fft: toeplitz_part_1(&x, &ks.fs).unwrap(),
x_ext_fft_len: n2,
})
}
fn data_availability(&self, p: &PolyData) -> Result<Vec<ArkG1>, String> {
let n = p.len();
let n2 = n * 2;
if n2 > self.ks.fs.max_width {
return Err(String::from(
"n2 must be equal or less than kzg settings max width",
));
}
if !n.is_power_of_two() {
return Err(String::from("n2 must be power of 2"));
}
let mut out = fk20_single_da_opt(p, self).unwrap();
reverse_bit_order(&mut out)?;
Ok(out)
}
fn data_availability_optimized(&self, p: &PolyData) -> Result<Vec<ArkG1>, String> {
fk20_single_da_opt(p, self)
}
}
impl
FK20MultiSettings<
BlstFr,
ArkG1,
ArkG2,
FFTSettings,
PolyData,
LKZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
> for KzgFK20MultiSettings
{
fn new(ks: &LKZGSettings, n2: usize, chunk_len: usize) -> Result<Self, String> {
if n2 > ks.fs.max_width {
return Err(String::from(
"n2 must be equal or less than kzg settings max width",
));
}
if !n2.is_power_of_two() {
return Err(String::from("n2 must be power of 2"));
}
if n2 < 2 {
return Err(String::from("n2 must be equal or greater than 2"));
}
if chunk_len > n2 / 2 {
return Err(String::from("chunk_len must be equal or less than n2/2"));
}
if !chunk_len.is_power_of_two() {
return Err(String::from("chunk_len must be power of 2"));
}
if chunk_len == 0 {
return Err(String::from("chunk_len must be greater than 0"));
}
let n = n2 / 2;
let k = n / chunk_len;
let mut x_ext_fft_files = Vec::new();
for offset in 0..chunk_len {
let mut x = vec![ArkG1::default(); k];
let start = if n >= chunk_len + 1 + offset {
n - chunk_len - 1 - offset
} else {
0
};
let mut j = start;
for i in x.iter_mut().take(k - 1) {
i.0 = ks.g1_values_monomial[j].0;
if j >= chunk_len {
j -= chunk_len;
} else {
j = 0;
}
}
x[k - 1] = ArkG1::identity();
x_ext_fft_files.push(toeplitz_part_1(&x, &ks.fs).unwrap());
}
let new_ks = LKZGSettings {
fs: ks.fs.clone(),
..LKZGSettings::default()
};
Ok(KzgFK20MultiSettings {
ks: new_ks,
x_ext_fft_files,
chunk_len,
length: n, //unsure if this is right
})
}
fn data_availability(&self, p: &PolyData) -> Result<Vec<ArkG1>, String> {
let n = p.len();
let n2 = n * 2;
if n2 > self.ks.fs.max_width {
return Err(String::from(
"n2 must be equal or less than kzg settings max width",
));
}
if !n.is_power_of_two() {
return Err(String::from("n2 must be power of 2"));
}
let mut out = fk20_multi_da_opt(p, self).unwrap();
reverse_bit_order(&mut out)?;
Ok(out)
}
fn data_availability_optimized(&self, p: &PolyData) -> Result<Vec<ArkG1>, String> {
fk20_multi_da_opt(p, self)
}
}
fn fk20_single_da_opt(p: &PolyData, fk: &KzgFK20SingleSettings) -> Result<Vec<ArkG1>, String> {
let n = p.len();
let n2 = n * 2;
if n2 > fk.ks.fs.max_width {
return Err(String::from(
"n2 must be equal or less than kzg settings max width",
));
}
if !n.is_power_of_two() {
return Err(String::from("n2 must be power of 2"));
}
let outlen = 2 * p.len();
let toeplitz_coeffs = toeplitz_coeffs_step(p, outlen).unwrap();
let h_ext_fft = toeplitz_part_2(&toeplitz_coeffs, &fk.x_ext_fft, &fk.ks.fs).unwrap();
let h = toeplitz_part_3(&h_ext_fft, &fk.ks.fs).unwrap();
fk.ks.fs.fft_g1(&h, false)
}
fn fk20_multi_da_opt(p: &PolyData, fk: &KzgFK20MultiSettings) -> Result<Vec<ArkG1>, String> {
let n = p.len();
let n2 = n * 2;
if n2 > fk.ks.fs.max_width {
return Err(String::from(
"n2 must be equal or less than kzg settings max width",
));
}
if !n.is_power_of_two() {
return Err(String::from("n2 must be power of 2"));
}
let n = n2 / 2;
let k = n / fk.chunk_len;
let k2 = k * 2;
let mut h_ext_fft = Vec::new();
for _i in 0..k2 {
h_ext_fft.push(ArkG1::identity());
}
let mut toeplitz_coeffs = PolyData::new(n2 / fk.chunk_len);
for i in 0..fk.chunk_len {
toeplitz_coeffs =
toeplitz_coeffs_stride(p, i, fk.chunk_len, toeplitz_coeffs.len()).unwrap();
let h_ext_fft_file =
toeplitz_part_2(&toeplitz_coeffs, &fk.x_ext_fft_files[i], &fk.ks.fs).unwrap();
for j in 0..k2 {
h_ext_fft[j] = h_ext_fft[j].add_or_dbl(&h_ext_fft_file[j]);
}
}
// Calculate `h`
let mut h = toeplitz_part_3(&h_ext_fft, &fk.ks.fs).unwrap();
// Overwrite the second half of `h` with zero
for i in h.iter_mut().take(k2).skip(k) {
i.0 = ArkG1::identity().0;
}
fk.ks.fs.fft_g1(&h, false)
}
fn toeplitz_coeffs_step(p: &PolyData, outlen: usize) -> Result<PolyData, String> {
toeplitz_coeffs_stride(p, 0, 1, outlen)
}
fn toeplitz_coeffs_stride(
poly: &PolyData,
offset: usize,
stride: usize,
outlen: usize,
) -> Result<PolyData, String> {
let n = poly.len();
if stride == 0 {
return Err(String::from("stride must be greater than 0"));
}
let k = n / stride;
let k2 = k * 2;
if outlen < k2 {
return Err(String::from("outlen must be equal or greater than k2"));
}
let mut out = PolyData::new(outlen);
out.set_coeff_at(0, &poly.coeffs[n - 1 - offset]);
let mut i = 1;
while i <= (k + 1) && i < k2 {
out.set_coeff_at(i, &BlstFr::zero());
i += 1;
}
let mut j = 2 * stride - offset - 1;
for i in (k + 2)..k2 {
out.set_coeff_at(i, &poly.coeffs[j]);
j += stride;
}
Ok(out)
}
fn toeplitz_part_1(x: &[ArkG1], fs: &FFTSettings) -> Result<Vec<ArkG1>, String> {
let n = x.len();
let n2 = n * 2;
let mut x_ext = Vec::new();
for i in x.iter().take(n) {
x_ext.push(*i);
}
for _i in n..n2 {
x_ext.push(ArkG1::identity());
}
fs.fft_g1(&x_ext, false)
}
fn toeplitz_part_2(
toeplitz_coeffs: &PolyData,
x_ext_fft: &[ArkG1],
fs: &FFTSettings,
) -> Result<Vec<ArkG1>, String> {
let toeplitz_coeffs_fft = fs.fft_fr(&toeplitz_coeffs.coeffs, false).unwrap();
#[cfg(feature = "parallel")]
{
let out: Vec<_> = (0..toeplitz_coeffs.len())
.into_par_iter()
.map(|i| x_ext_fft[i].mul(&toeplitz_coeffs_fft[i]))
.collect();
Ok(out)
}
#[cfg(not(feature = "parallel"))]
{
let mut out = Vec::new();
for i in 0..toeplitz_coeffs.len() {
out.push(x_ext_fft[i].mul(&toeplitz_coeffs_fft[i]));
}
Ok(out)
}
}
fn toeplitz_part_3(h_ext_fft: &[ArkG1], fs: &FFTSettings) -> Result<Vec<ArkG1>, String> {
let n = h_ext_fft.len() / 2;
let mut out = fs.fft_g1(h_ext_fft, true).unwrap();
// Zero the second half of h
for i in out.iter_mut().take(h_ext_fft.len()).skip(n) {
i.0 = ArkG1::identity().0;
}
Ok(out)
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/utils.rs | arkworks3/src/utils.rs | extern crate alloc;
use kzg::{
eip_4844::PrecomputationTableManager,
eth::{
self,
c_bindings::{blst_fp, blst_fp2, blst_fr, blst_p1, blst_p2, CKZGSettings},
},
};
use crate::kzg_types::{ArkFp, ArkFr, ArkG1, ArkG1Affine};
use crate::{kzg_proofs::FFTSettings as LFFTSettings, kzg_types::ArkG1ProjAddAffine};
use ark_bls12_381::{g1, g2, Fq, Fq2};
use ark_ec::models::short_weierstrass_jacobian::GroupProjective;
use ark_ff::{BigInteger256, BigInteger384, Fp2};
use ark_poly::univariate::DensePolynomial as DensePoly;
use ark_poly::UVPolynomial;
#[derive(Debug, PartialEq, Eq)]
pub struct Error;
#[derive(Debug, Clone, Eq, PartialEq, Default)]
pub struct PolyData {
pub coeffs: Vec<ArkFr>,
}
// FIXME: Store just dense poly here
pub(crate) fn fft_settings_to_rust(
c_settings: *const CKZGSettings,
) -> Result<LFFTSettings, String> {
let settings = unsafe { &*c_settings };
let roots_of_unity = unsafe {
core::slice::from_raw_parts(
settings.roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB + 1,
)
.iter()
.map(|r| ArkFr::from_blst_fr(*r))
.collect::<Vec<ArkFr>>()
};
let brp_roots_of_unity = unsafe {
core::slice::from_raw_parts(
settings.brp_roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB,
)
.iter()
.map(|r| ArkFr::from_blst_fr(*r))
.collect::<Vec<ArkFr>>()
};
let reverse_roots_of_unity = unsafe {
core::slice::from_raw_parts(
settings.reverse_roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB + 1,
)
.iter()
.map(|r| ArkFr::from_blst_fr(*r))
.collect::<Vec<ArkFr>>()
};
Ok(LFFTSettings {
max_width: eth::FIELD_ELEMENTS_PER_EXT_BLOB,
root_of_unity: roots_of_unity[1],
roots_of_unity,
brp_roots_of_unity,
reverse_roots_of_unity,
})
}
pub(crate) static mut PRECOMPUTATION_TABLES: PrecomputationTableManager<
ArkFr,
ArkG1,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
> = PrecomputationTableManager::new();
pub fn pc_poly_into_blst_poly(poly: DensePoly<ark_bls12_381::Fr>) -> PolyData {
let mut bls_pol: Vec<ArkFr> = { Vec::new() };
for x in poly.coeffs {
bls_pol.push(ArkFr { fr: x });
}
PolyData { coeffs: bls_pol }
}
pub fn blst_poly_into_pc_poly(pd: &[ArkFr]) -> DensePoly<ark_bls12_381::Fr> {
let mut poly: Vec<ark_bls12_381::Fr> = vec![ark_bls12_381::Fr::default(); pd.len()];
for i in 0..pd.len() {
poly[i] = pd[i].fr;
}
DensePoly::from_coefficients_vec(poly)
}
pub const fn pc_fq_into_blst_fp(fq: Fq) -> blst_fp {
blst_fp { l: fq.0 .0 }
}
pub const fn blst_fr_into_pc_fr(fr: blst_fr) -> ark_bls12_381::Fr {
let big_int = BigInteger256::new(fr.l);
ark_bls12_381::Fr::new(big_int)
}
pub const fn pc_fr_into_blst_fr(fr: ark_bls12_381::Fr) -> blst_fr {
blst_fr { l: fr.0 .0 }
}
pub const fn blst_fp_into_pc_fq(fp: &blst_fp) -> Fq {
let big_int = BigInteger384::new(fp.l);
Fq::new(big_int)
}
pub fn blst_fp2_into_pc_fq2(fp: &blst_fp2) -> Fq2 {
Fp2::new(blst_fp_into_pc_fq(&fp.fp[0]), blst_fp_into_pc_fq(&fp.fp[1]))
}
pub fn blst_p1_into_pc_g1projective(p1: &blst_p1) -> GroupProjective<g1::Parameters> {
GroupProjective::new(
blst_fp_into_pc_fq(&p1.x),
blst_fp_into_pc_fq(&p1.y),
blst_fp_into_pc_fq(&p1.z),
)
}
pub const fn pc_g1projective_into_blst_p1(p1: GroupProjective<g1::Parameters>) -> blst_p1 {
blst_p1 {
x: blst_fp { l: p1.x.0 .0 },
y: blst_fp { l: p1.y.0 .0 },
z: blst_fp { l: p1.z.0 .0 },
}
}
pub fn blst_p2_into_pc_g2projective(p2: &blst_p2) -> GroupProjective<g2::Parameters> {
GroupProjective::new(
blst_fp2_into_pc_fq2(&p2.x),
blst_fp2_into_pc_fq2(&p2.y),
blst_fp2_into_pc_fq2(&p2.z),
)
}
pub const fn pc_g2projective_into_blst_p2(p2: GroupProjective<g2::Parameters>) -> blst_p2 {
blst_p2 {
x: blst_fp2 {
fp: [blst_fp { l: p2.x.c0.0 .0 }, blst_fp { l: p2.x.c1.0 .0 }],
},
y: blst_fp2 {
fp: [blst_fp { l: p2.y.c0.0 .0 }, blst_fp { l: p2.y.c1.0 .0 }],
},
z: blst_fp2 {
fp: [blst_fp { l: p2.z.c0.0 .0 }, blst_fp { l: p2.z.c1.0 .0 }],
},
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/fft_g1.rs | arkworks3/src/fft_g1.rs | use crate::kzg_proofs::FFTSettings;
use crate::kzg_types::{ArkFp, ArkFr, ArkG1, ArkG1Affine, ArkG1ProjAddAffine};
use kzg::cfg_into_iter;
#[cfg(feature = "parallel")]
use rayon::prelude::*;
use ark_ec::ProjectiveCurve;
use ark_ff::PrimeField;
use kzg::msm::precompute::PrecomputationTable;
use kzg::{Fr as KzgFr, G1Mul};
use kzg::{FFTG1, G1};
use std::ops::MulAssign;
extern crate alloc;
#[allow(unused_variables)]
pub fn g1_linear_combination(
out: &mut ArkG1,
points: &[ArkG1],
scalars: &[ArkFr],
len: usize,
precomputation: Option<
&PrecomputationTable<ArkFr, ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine>,
>,
) {
#[cfg(feature = "sppark")]
{
use ark_bls12_381::{Fr, G1Affine};
use ark_ec::msm::VariableBaseMSM;
use ark_ff::BigInteger256;
use kzg::{G1Mul, G1};
if len < 8 {
*out = ArkG1::default();
for i in 0..len {
let tmp = points[i].mul(&scalars[i]);
out.add_or_dbl_assign(&tmp);
}
return;
}
let scalars =
unsafe { alloc::slice::from_raw_parts(scalars.as_ptr() as *const BigInteger256, len) };
let point = if let Some(precomputation) = precomputation {
rust_kzg_arkworks3_sppark::multi_scalar_mult_prepared::<G1Affine>(
precomputation.table,
scalars,
)
} else {
let affines = kzg::msm::msm_impls::batch_convert::<ArkG1, ArkFp, ArkG1Affine>(&points);
let affines =
unsafe { alloc::slice::from_raw_parts(affines.as_ptr() as *const G1Affine, len) };
rust_kzg_arkworks3_sppark::multi_scalar_mult::<G1Affine>(&affines[0..len], scalars)
};
*out = ArkG1(point);
}
#[cfg(feature = "sppark_wlc")]
{
use ark_bls12_381::{Fr, G1Affine};
use ark_ff::BigInteger256;
use kzg::{G1Mul, G1};
use rust_kzg_arkworks3_sppark_wlc::MultiScalarMultContext;
if len < 8 {
*out = ArkG1::default();
for i in 0..len {
let tmp = points[i].mul(&scalars[i]);
out.add_or_dbl_assign(&tmp);
}
return;
}
let ark_scalars = cfg_into_iter!(&scalars[0..len])
.map(|scalar| scalar.fr.into_repr())
.collect::<Vec<_>>();
let mut context = if let Some(context) = precomputation {
let table = context.table;
MultiScalarMultContext { context: table }
} else {
let affines = kzg::msm::msm_impls::batch_convert::<ArkG1, ArkFp, ArkG1Affine>(&points);
let affines =
unsafe { alloc::slice::from_raw_parts(affines.as_ptr() as *const G1Affine, len) };
rust_kzg_arkworks3_sppark_wlc::multi_scalar_mult_init(affines)
};
let msm_results = rust_kzg_arkworks3_sppark_wlc::multi_scalar_mult::<G1Affine>(
&mut context,
len,
unsafe { std::mem::transmute::<&[_], &[BigInteger256]>(&ark_scalars) },
);
*out = ArkG1(msm_results[0]);
if precomputation.is_none() {
rust_kzg_arkworks3_sppark_wlc::multi_scalar_mult_free(&mut context);
}
}
#[cfg(not(any(feature = "sppark", feature = "sppark_wlc")))]
{
use ark_ec::msm::VariableBaseMSM;
let ark_points = cfg_into_iter!(&points[0..len])
.map(|point| point.0.into_affine())
.collect::<Vec<_>>();
let ark_scalars = cfg_into_iter!(&scalars[0..len])
.map(|scalar| scalar.fr.into_repr())
.collect::<Vec<_>>();
*out = ArkG1(VariableBaseMSM::multi_scalar_mul(
ark_points.as_slice(),
ark_scalars.as_slice(),
));
}
}
pub fn make_data(data: usize) -> Vec<ArkG1> {
let mut vec = Vec::new();
if data != 0 {
vec.push(ArkG1::generator());
for i in 1..data as u64 {
let res = vec[(i - 1) as usize].add_or_dbl(&ArkG1::generator());
vec.push(res);
}
}
vec
}
impl FFTG1<ArkG1> for FFTSettings {
fn fft_g1(&self, data: &[ArkG1], inverse: bool) -> Result<Vec<ArkG1>, String> {
if data.len() > self.max_width {
return Err(String::from("data length is longer than allowed max width"));
}
if !data.len().is_power_of_two() {
return Err(String::from("data length is not power of 2"));
}
let stride: usize = self.max_width / data.len();
let mut ret = vec![ArkG1::default(); data.len()];
let roots = if inverse {
&self.reverse_roots_of_unity
} else {
&self.roots_of_unity
};
fft_g1_fast(&mut ret, data, 1, roots, stride);
if inverse {
let inv_fr_len = ArkFr::from_u64(data.len() as u64).inverse();
ret[..data.len()]
.iter_mut()
.for_each(|f| f.0.mul_assign(inv_fr_len.fr));
}
Ok(ret)
}
}
pub fn fft_g1_slow(
ret: &mut [ArkG1],
data: &[ArkG1],
stride: usize,
roots: &[ArkFr],
roots_stride: usize,
) {
for i in 0..data.len() {
ret[i] = data[0].mul(&roots[0]);
for j in 1..data.len() {
let jv = data[j * stride];
let r = roots[((i * j) % data.len()) * roots_stride];
let v = jv.mul(&r);
ret[i] = ret[i].add_or_dbl(&v);
}
}
}
pub fn fft_g1_fast(
ret: &mut [ArkG1],
data: &[ArkG1],
stride: usize,
roots: &[ArkFr],
roots_stride: usize,
) {
let half = ret.len() / 2;
if half > 0 {
#[cfg(feature = "parallel")]
{
let (lo, hi) = ret.split_at_mut(half);
rayon::join(
|| fft_g1_fast(hi, &data[stride..], stride * 2, roots, roots_stride * 2),
|| fft_g1_fast(lo, data, stride * 2, roots, roots_stride * 2),
);
}
#[cfg(not(feature = "parallel"))]
{
fft_g1_fast(&mut ret[..half], data, stride * 2, roots, roots_stride * 2);
fft_g1_fast(
&mut ret[half..],
&data[stride..],
stride * 2,
roots,
roots_stride * 2,
);
}
for i in 0..half {
let y_times_root = ret[i + half].mul(&roots[i * roots_stride]);
ret[i + half] = ret[i].sub(&y_times_root);
ret[i] = ret[i].add_or_dbl(&y_times_root);
}
} else {
ret[0] = data[0];
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/recover.rs | arkworks3/src/recover.rs | use crate::consts::SCALE_FACTOR;
use crate::kzg_proofs::FFTSettings;
use crate::kzg_types::ArkFr as BlstFr;
use crate::utils::PolyData;
use kzg::{FFTFr, Fr, Poly, PolyRecover, ZeroPoly};
#[cfg(feature = "parallel")]
use kzg::common_utils::next_pow_of_2;
#[cfg(feature = "parallel")]
static mut INVERSE_FACTORS: Vec<BlstFr> = Vec::new();
#[cfg(feature = "parallel")]
static mut UNSCALE_FACTOR_POWERS: Vec<BlstFr> = Vec::new();
#[allow(clippy::needless_range_loop)]
pub fn scale_poly(p: &mut PolyData) {
let scale_factor = BlstFr::from_u64(SCALE_FACTOR);
let inv_factor = scale_factor.inverse();
#[allow(static_mut_refs)]
#[cfg(feature = "parallel")]
{
let optim = next_pow_of_2(p.len() - 1);
if optim <= 1024 {
unsafe {
if INVERSE_FACTORS.len() < p.len() {
if INVERSE_FACTORS.is_empty() {
INVERSE_FACTORS.push(BlstFr::one());
}
for i in (INVERSE_FACTORS.len())..p.len() {
INVERSE_FACTORS.push(INVERSE_FACTORS[i - 1].mul(&inv_factor));
}
}
for i in 1..p.len() {
p.coeffs[i] = p.coeffs[i].mul(&INVERSE_FACTORS[i]);
}
}
} else {
let mut factor_power = BlstFr::one();
for i in 1..p.len() {
factor_power = factor_power.mul(&inv_factor);
p.set_coeff_at(i, &p.get_coeff_at(i).mul(&factor_power));
}
}
}
#[cfg(not(feature = "parallel"))]
{
let mut factor_power = BlstFr::one();
for i in 1..p.len() {
factor_power = factor_power.mul(&inv_factor);
p.set_coeff_at(i, &p.get_coeff_at(i).mul(&factor_power));
}
}
}
#[allow(clippy::needless_range_loop)]
pub fn unscale_poly(p: &mut PolyData) {
let scale_factor = BlstFr::from_u64(SCALE_FACTOR);
#[allow(static_mut_refs)]
#[cfg(feature = "parallel")]
{
unsafe {
if UNSCALE_FACTOR_POWERS.len() < p.len() {
if UNSCALE_FACTOR_POWERS.is_empty() {
UNSCALE_FACTOR_POWERS.push(BlstFr::one());
}
for i in (UNSCALE_FACTOR_POWERS.len())..p.len() {
UNSCALE_FACTOR_POWERS.push(UNSCALE_FACTOR_POWERS[i - 1].mul(&scale_factor));
}
}
for i in 1..p.len() {
p.coeffs[i] = p.coeffs[i].mul(&UNSCALE_FACTOR_POWERS[i]);
}
}
}
#[cfg(not(feature = "parallel"))]
{
let mut factor_power = BlstFr::one();
for i in 1..p.len() {
factor_power = factor_power.mul(&scale_factor);
p.set_coeff_at(i, &p.get_coeff_at(i).mul(&factor_power));
}
}
}
impl PolyRecover<BlstFr, PolyData, FFTSettings> for PolyData {
fn recover_poly_coeffs_from_samples(
samples: &[Option<BlstFr>],
fs: &FFTSettings,
) -> Result<Self, String> {
if !samples.len().is_power_of_two() {
return Err(String::from("samples lenght has to be power of 2"));
}
let mut missing = Vec::new();
for (i, sample) in samples.iter().enumerate() {
if sample.is_none() {
missing.push(i);
}
}
if missing.len() > samples.len() / 2 {
return Err(String::from(
"Impossible to recover, too many shards are missing",
));
}
// Calculate `Z_r,I`
let (zero_eval, mut zero_poly) =
fs.zero_poly_via_multiplication(samples.len(), missing.as_slice())?;
// Check all is well
for (i, item) in zero_eval.iter().enumerate().take(samples.len()) {
if samples[i].is_none() != item.is_zero() {
return Err(String::from("sample and item are both zero"));
}
}
// Construct E * Z_r,I: the loop makes the evaluation polynomial
let mut poly_evaluations_with_zero = vec![BlstFr::zero(); samples.len()];
for i in 0..samples.len() {
if samples[i].is_none() {
poly_evaluations_with_zero[i] = BlstFr::zero();
} else {
poly_evaluations_with_zero[i] = samples[i].unwrap().mul(&zero_eval[i]);
}
}
// Now inverse FFT so that poly_with_zero is (E * Z_r,I)(x) = (D * Z_r,I)(x)
let mut poly_with_zero = PolyData {
coeffs: fs
.fft_fr(poly_evaluations_with_zero.as_slice(), true)
.unwrap(),
};
#[cfg(feature = "parallel")]
let optim = next_pow_of_2(poly_with_zero.len() - 1);
#[cfg(feature = "parallel")]
{
if optim > 1024 {
rayon::join(
|| scale_poly(&mut poly_with_zero),
|| scale_poly(&mut zero_poly),
);
} else {
scale_poly(&mut poly_with_zero);
scale_poly(&mut zero_poly);
}
}
#[cfg(not(feature = "parallel"))]
{
scale_poly(&mut poly_with_zero);
scale_poly(&mut zero_poly);
}
// Q1 = (D * Z_r,I)(k * x)
let scaled_poly_with_zero = poly_with_zero; // Renaming
// Q2 = Z_r,I(k * x)
let scaled_zero_poly = zero_poly.coeffs; // Renaming
let eval_scaled_poly_with_zero;
let eval_scaled_zero_poly;
#[cfg(feature = "parallel")]
{
if optim > 1024 {
let mut eval_scaled_poly_with_zero_temp = vec![];
let mut eval_scaled_zero_poly_temp = vec![];
rayon::join(
|| {
eval_scaled_poly_with_zero_temp =
fs.fft_fr(&scaled_poly_with_zero.coeffs, false).unwrap()
},
|| eval_scaled_zero_poly_temp = fs.fft_fr(&scaled_zero_poly, false).unwrap(),
);
eval_scaled_poly_with_zero = eval_scaled_poly_with_zero_temp;
eval_scaled_zero_poly = eval_scaled_zero_poly_temp;
} else {
eval_scaled_poly_with_zero =
fs.fft_fr(&scaled_poly_with_zero.coeffs, false).unwrap();
eval_scaled_zero_poly = fs.fft_fr(&scaled_zero_poly, false).unwrap();
}
}
#[cfg(not(feature = "parallel"))]
{
eval_scaled_poly_with_zero = fs.fft_fr(&scaled_poly_with_zero.coeffs, false).unwrap();
eval_scaled_zero_poly = fs.fft_fr(&scaled_zero_poly, false).unwrap();
}
let mut eval_scaled_reconstructed_poly = eval_scaled_poly_with_zero.clone();
for i in 0..samples.len() {
eval_scaled_reconstructed_poly[i] = eval_scaled_poly_with_zero[i]
.div(&eval_scaled_zero_poly[i])
.unwrap();
}
// The result of the division is D(k * x):
let mut scaled_reconstructed_poly = PolyData {
coeffs: fs.fft_fr(&eval_scaled_reconstructed_poly, true).unwrap(),
};
// k * x -> x
unscale_poly(&mut scaled_reconstructed_poly);
// Finally we have D(x) which evaluates to our original data at the powers of roots of unity
Ok(scaled_reconstructed_poly)
}
fn recover_poly_from_samples(
samples: &[Option<BlstFr>],
fs: &FFTSettings,
) -> Result<Self, String> {
let reconstructed_poly = Self::recover_poly_coeffs_from_samples(samples, fs)?;
// The evaluation polynomial for D(x) is the reconstructed data:
let out = PolyData {
coeffs: fs.fft_fr(&reconstructed_poly.coeffs, false).unwrap(),
};
// Check all is well
for (i, sample) in samples.iter().enumerate() {
if !sample.is_none() && !out.get_coeff_at(i).equals(&sample.unwrap()) {
return Err(String::from(
"sample is zero and out coeff at i is not equals to sample",
));
}
}
Ok(out)
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/src/fft.rs | arkworks3/src/fft.rs | use crate::kzg_proofs::FFTSettings as LFFTSettings;
use crate::kzg_types::ArkFr as BlstFr;
use kzg::{FFTFr, Fr as FFr};
impl LFFTSettings {
/// Fast Fourier Transform for finite field elements, `output` must be zeroes
pub(crate) fn fft_fr_output(
&self,
data: &[BlstFr],
inverse: bool,
output: &mut [BlstFr],
) -> Result<(), String> {
if data.len() > self.max_width {
return Err(String::from(
"Supplied list is longer than the available max width",
));
}
if data.len() != output.len() {
return Err(format!(
"Output length {} doesn't match data length {}",
data.len(),
output.len()
));
}
if !data.len().is_power_of_two() {
return Err(String::from("A list with power-of-two length expected"));
}
// In case more roots are provided with fft_settings, use a larger stride
let stride = self.max_width / data.len();
// Inverse is same as regular, but all constants are reversed and results are divided by n
// This is a property of the DFT matrix
let roots = if inverse {
&self.reverse_roots_of_unity
} else {
&self.roots_of_unity
};
fft_fr_fast(output, data, 1, roots, stride);
if inverse {
let inv_fr_len = BlstFr::from_u64(data.len() as u64).inverse();
output.iter_mut().for_each(|f| *f = f.mul(&inv_fr_len));
}
Ok(())
}
}
impl FFTFr<BlstFr> for LFFTSettings {
fn fft_fr(&self, data: &[BlstFr], inverse: bool) -> Result<Vec<BlstFr>, String> {
let mut ret = vec![BlstFr::default(); data.len()];
self.fft_fr_output(data, inverse, &mut ret)?;
Ok(ret)
}
}
pub fn fft_fr_fast(
ret: &mut [BlstFr],
data: &[BlstFr],
stride: usize,
roots: &[BlstFr],
roots_stride: usize,
) {
let half: usize = ret.len() / 2;
if half > 0 {
#[cfg(not(feature = "parallel"))]
{
fft_fr_fast(&mut ret[..half], data, stride * 2, roots, roots_stride * 2);
fft_fr_fast(
&mut ret[half..],
&data[stride..],
stride * 2,
roots,
roots_stride * 2,
);
}
#[cfg(feature = "parallel")]
{
if half > 256 {
let (lo, hi) = ret.split_at_mut(half);
rayon::join(
|| fft_fr_fast(lo, data, stride * 2, roots, roots_stride * 2),
|| fft_fr_fast(hi, &data[stride..], stride * 2, roots, roots_stride * 2),
);
} else {
fft_fr_fast(&mut ret[..half], data, stride * 2, roots, roots_stride * 2);
fft_fr_fast(
&mut ret[half..],
&data[stride..],
stride * 2,
roots,
roots_stride * 2,
);
}
}
for i in 0..half {
let y_times_root = ret[i + half].mul(&roots[i * roots_stride]);
ret[i + half] = ret[i].sub(&y_times_root);
ret[i] = ret[i].add(&y_times_root);
}
} else {
ret[0] = data[0];
}
}
pub fn fft_fr_slow(
ret: &mut [BlstFr],
data: &[BlstFr],
stride: usize,
roots: &[BlstFr],
roots_stride: usize,
) {
let mut v;
let mut jv;
let mut r;
for i in 0..data.len() {
ret[i] = data[0].mul(&roots[0]);
for j in 1..data.len() {
jv = data[j * stride];
r = roots[((i * j) % data.len()) * roots_stride];
v = jv.mul(&r);
ret[i] = ret[i].add(&v);
}
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/consts.rs | arkworks3/tests/consts.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::consts::{
expand_roots_is_plausible, new_fft_settings_is_plausible, roots_of_unity_are_plausible,
roots_of_unity_is_the_expected_size, roots_of_unity_out_of_bounds_fails,
};
use rust_kzg_arkworks3::consts::SCALE2_ROOT_OF_UNITY;
use rust_kzg_arkworks3::kzg_proofs::expand_root_of_unity;
use rust_kzg_arkworks3::kzg_proofs::FFTSettings;
use rust_kzg_arkworks3::kzg_types::ArkFr;
#[test]
fn roots_of_unity_out_of_bounds_fails_() {
roots_of_unity_out_of_bounds_fails::<ArkFr, FFTSettings>();
}
#[test]
fn roots_of_unity_are_plausible_() {
roots_of_unity_are_plausible::<ArkFr>(&SCALE2_ROOT_OF_UNITY);
}
#[test]
fn expand_roots_is_plausible_() {
expand_roots_is_plausible::<ArkFr>(&SCALE2_ROOT_OF_UNITY, &expand_root_of_unity);
}
#[test]
fn new_fft_settings_is_plausible_() {
new_fft_settings_is_plausible::<ArkFr, FFTSettings>();
}
#[test]
fn roots_of_unity_is_the_expected_size_() {
roots_of_unity_is_the_expected_size(&SCALE2_ROOT_OF_UNITY);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/das.rs | arkworks3/tests/das.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::das::{das_extension_test_known, das_extension_test_random};
use rust_kzg_arkworks3::kzg_proofs::FFTSettings;
use rust_kzg_arkworks3::kzg_types::ArkFr;
#[test]
fn das_extension_test_known_() {
das_extension_test_known::<ArkFr, FFTSettings>();
}
#[test]
fn das_extension_test_random_() {
das_extension_test_random::<ArkFr, FFTSettings>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/eip_4844.rs | arkworks3/tests/eip_4844.rs | #[cfg(test)]
mod tests {
use kzg::eip_4844::{
blob_to_kzg_commitment_rust, blob_to_polynomial, bytes_to_blob,
compute_blob_kzg_proof_rust, compute_challenge_rust, compute_kzg_proof_rust,
compute_powers, evaluate_polynomial_in_evaluation_form, verify_blob_kzg_proof_batch_rust,
verify_blob_kzg_proof_rust, verify_kzg_proof_rust,
};
use kzg::Fr;
use kzg_bench::tests::eip_4844::{
blob_to_kzg_commitment_test, bytes_to_bls_field_test,
compute_and_verify_blob_kzg_proof_fails_with_incorrect_proof_test,
compute_and_verify_blob_kzg_proof_test,
compute_and_verify_kzg_proof_fails_with_incorrect_proof_test,
compute_and_verify_kzg_proof_round_trip_test,
compute_and_verify_kzg_proof_within_domain_test, compute_kzg_proof_test,
compute_powers_test, test_vectors_blob_to_kzg_commitment,
test_vectors_compute_blob_kzg_proof, test_vectors_compute_challenge,
test_vectors_compute_kzg_proof, test_vectors_verify_blob_kzg_proof,
test_vectors_verify_blob_kzg_proof_batch, test_vectors_verify_kzg_proof,
verify_kzg_proof_batch_fails_with_incorrect_proof_test, verify_kzg_proof_batch_test,
};
use rust_kzg_arkworks3::consts::SCALE2_ROOT_OF_UNITY;
use rust_kzg_arkworks3::eip_4844::load_trusted_setup_filename_rust;
use rust_kzg_arkworks3::kzg_proofs::{expand_root_of_unity, FFTSettings, KZGSettings};
use rust_kzg_arkworks3::kzg_types::{
ArkFp, ArkFr, ArkG1, ArkG1Affine, ArkG1ProjAddAffine, ArkG2,
};
use rust_kzg_arkworks3::utils::PolyData;
#[test]
pub fn bytes_to_bls_field_test_() {
bytes_to_bls_field_test::<ArkFr>();
}
#[test]
pub fn compute_powers_test_() {
compute_powers_test::<ArkFr>(&compute_powers);
}
#[test]
pub fn blob_to_kzg_commitment_test_() {
blob_to_kzg_commitment_test::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
);
}
#[test]
pub fn compute_kzg_proof_test_() {
compute_kzg_proof_test::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&compute_kzg_proof_rust,
&blob_to_polynomial,
&evaluate_polynomial_in_evaluation_form,
);
}
#[test]
pub fn compute_and_verify_kzg_proof_round_trip_test_() {
compute_and_verify_kzg_proof_round_trip_test::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_kzg_proof_rust,
&blob_to_polynomial,
&evaluate_polynomial_in_evaluation_form,
&verify_kzg_proof_rust,
);
}
#[test]
pub fn compute_and_verify_kzg_proof_within_domain_test_() {
compute_and_verify_kzg_proof_within_domain_test::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_kzg_proof_rust,
&blob_to_polynomial,
&evaluate_polynomial_in_evaluation_form,
&verify_kzg_proof_rust,
);
}
#[test]
pub fn compute_and_verify_kzg_proof_fails_with_incorrect_proof_test_() {
compute_and_verify_kzg_proof_fails_with_incorrect_proof_test::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_kzg_proof_rust,
&blob_to_polynomial,
&evaluate_polynomial_in_evaluation_form,
&verify_kzg_proof_rust,
);
}
#[test]
pub fn compute_and_verify_blob_kzg_proof_test_() {
compute_and_verify_blob_kzg_proof_test::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_blob_kzg_proof_rust,
&verify_blob_kzg_proof_rust,
);
}
#[test]
pub fn compute_and_verify_blob_kzg_proof_fails_with_incorrect_proof_test_() {
compute_and_verify_blob_kzg_proof_fails_with_incorrect_proof_test::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_blob_kzg_proof_rust,
&verify_blob_kzg_proof_rust,
);
}
#[test]
pub fn verify_kzg_proof_batch_test_() {
verify_kzg_proof_batch_test::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_blob_kzg_proof_rust,
&verify_blob_kzg_proof_batch_rust,
);
}
#[test]
pub fn verify_kzg_proof_batch_fails_with_incorrect_proof_test_() {
verify_kzg_proof_batch_fails_with_incorrect_proof_test::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_blob_kzg_proof_rust,
&verify_blob_kzg_proof_batch_rust,
);
}
#[test]
pub fn test_vectors_blob_to_kzg_commitment_() {
test_vectors_blob_to_kzg_commitment::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
);
}
#[test]
pub fn test_vectors_compute_kzg_proof_() {
test_vectors_compute_kzg_proof::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&compute_kzg_proof_rust,
&bytes_to_blob,
);
}
#[test]
pub fn test_vectors_compute_blob_kzg_proof_() {
test_vectors_compute_blob_kzg_proof::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&bytes_to_blob,
&compute_blob_kzg_proof_rust,
);
}
#[test]
pub fn test_vectors_verify_kzg_proof_() {
test_vectors_verify_kzg_proof::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(&load_trusted_setup_filename_rust, &verify_kzg_proof_rust);
}
#[test]
pub fn test_vectors_verify_blob_kzg_proof_() {
test_vectors_verify_blob_kzg_proof::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&bytes_to_blob,
&verify_blob_kzg_proof_rust,
);
}
#[test]
pub fn test_vectors_verify_blob_kzg_proof_batch_() {
test_vectors_verify_blob_kzg_proof_batch::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
&load_trusted_setup_filename_rust,
&bytes_to_blob,
&verify_blob_kzg_proof_batch_rust,
);
}
#[test]
pub fn test_vectors_compute_challenge_() {
test_vectors_compute_challenge::<ArkFr, ArkG1>(&bytes_to_blob, &compute_challenge_rust);
}
#[test]
pub fn expand_root_of_unity_too_long() {
let out = expand_root_of_unity(&ArkFr::from_u64_arr(&SCALE2_ROOT_OF_UNITY[1]), 1);
assert!(out.is_err());
}
#[test]
pub fn expand_root_of_unity_too_short() {
let out = expand_root_of_unity(&ArkFr::from_u64_arr(&SCALE2_ROOT_OF_UNITY[1]), 3);
assert!(out.is_err());
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/kzg_proofs.rs | arkworks3/tests/kzg_proofs.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::kzg_proofs::{
commit_to_nil_poly, commit_to_too_long_poly_returns_err, proof_multi, proof_single,
trusted_setup_in_correct_form,
};
use rust_kzg_arkworks3::eip_7594::ArkBackend;
use rust_kzg_arkworks3::kzg_proofs::generate_trusted_setup;
#[test]
pub fn test_trusted_setup_in_correct_form() {
trusted_setup_in_correct_form::<ArkBackend>(&generate_trusted_setup);
}
#[test]
fn proof_single_() {
proof_single::<ArkBackend>(&generate_trusted_setup);
}
#[test]
fn commit_to_nil_poly_() {
commit_to_nil_poly::<ArkBackend>(&generate_trusted_setup);
}
#[test]
fn commit_to_too_long_poly_() {
commit_to_too_long_poly_returns_err::<ArkBackend>(&generate_trusted_setup);
}
#[test]
fn proof_multi_() {
proof_multi::<ArkBackend>(&generate_trusted_setup);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/eip_7594.rs | arkworks3/tests/eip_7594.rs | #[cfg(test)]
mod tests {
use kzg::eip_4844::bytes_to_blob;
use kzg_bench::tests::eip_7594::{
test_vectors_compute_cells, test_vectors_compute_cells_and_kzg_proofs,
test_vectors_compute_verify_cell_kzg_proof_batch_challenge,
test_vectors_recover_cells_and_kzg_proofs, test_vectors_verify_cell_kzg_proof_batch,
};
use rust_kzg_arkworks3::{eip_4844::load_trusted_setup_filename_rust, eip_7594::ArkBackend};
#[test]
pub fn test_vectors_compute_cells_() {
test_vectors_compute_cells::<ArkBackend>(&load_trusted_setup_filename_rust, &bytes_to_blob);
}
#[test]
pub fn test_vectors_compute_cells_and_kzg_proofs_() {
test_vectors_compute_cells_and_kzg_proofs::<ArkBackend>(
&load_trusted_setup_filename_rust,
&bytes_to_blob,
);
}
#[test]
pub fn test_vectors_recover_cells_and_kzg_proofs_() {
test_vectors_recover_cells_and_kzg_proofs::<ArkBackend>(&load_trusted_setup_filename_rust);
}
#[test]
pub fn test_vectors_verify_cell_kzg_proof_batch_() {
test_vectors_verify_cell_kzg_proof_batch::<ArkBackend>(&load_trusted_setup_filename_rust);
}
#[test]
pub fn test_vectors_compute_verify_cell_kzg_proof_batch_challenge_() {
test_vectors_compute_verify_cell_kzg_proof_batch_challenge::<ArkBackend>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/msm.rs | arkworks3/tests/msm.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::msm::msm_slice::{
test_msm_slice_window_size_1, test_msm_slice_window_size_16, test_msm_slice_window_size_2,
test_msm_slice_window_size_3,
};
#[test]
pub fn test_msm_slice_window_size_1_() {
test_msm_slice_window_size_1()
}
#[test]
fn test_msm_slice_window_size_2_() {
test_msm_slice_window_size_2();
}
#[test]
fn test_msm_slice_window_size_3_() {
test_msm_slice_window_size_3();
}
#[test]
fn test_msm_slice_window_size_16_() {
test_msm_slice_window_size_16();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/poly.rs | arkworks3/tests/poly.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::poly::{
create_poly_of_length_ten, poly_div_by_zero, poly_div_fast_test, poly_div_long_test,
poly_div_random, poly_eval_0_check, poly_eval_check, poly_eval_nil_check,
poly_inverse_simple_0, poly_inverse_simple_1, poly_mul_direct_test, poly_mul_fft_test,
poly_mul_random, poly_test_div,
};
use rust_kzg_arkworks3::kzg_proofs::FFTSettings;
use rust_kzg_arkworks3::kzg_types::ArkFr;
use rust_kzg_arkworks3::utils::PolyData;
#[test]
fn create_poly_of_length_ten_() {
create_poly_of_length_ten::<ArkFr, PolyData>();
}
#[test]
fn poly_eval_check_() {
poly_eval_check::<ArkFr, PolyData>();
}
#[test]
fn poly_eval_0_check_() {
poly_eval_0_check::<ArkFr, PolyData>();
}
#[test]
fn poly_eval_nil_check_() {
poly_eval_nil_check::<ArkFr, PolyData>();
}
#[test]
fn poly_inverse_simple_0_() {
poly_inverse_simple_0::<ArkFr, PolyData>();
}
#[test]
fn poly_inverse_simple_1_() {
poly_inverse_simple_1::<ArkFr, PolyData>();
}
#[test]
fn poly_test_div_() {
poly_test_div::<ArkFr, PolyData>();
}
#[test]
#[should_panic]
fn poly_div_by_zero_() {
poly_div_by_zero::<ArkFr, PolyData>();
}
#[test]
fn poly_mul_direct_test_() {
poly_mul_direct_test::<ArkFr, PolyData>();
}
#[test]
fn poly_mul_fft_test_() {
poly_mul_fft_test::<ArkFr, PolyData, FFTSettings>();
}
#[test]
fn poly_mul_random_() {
poly_mul_random::<ArkFr, PolyData, FFTSettings>();
}
#[test]
fn poly_div_random_() {
poly_div_random::<ArkFr, PolyData>();
}
#[test]
fn poly_div_long_test_() {
poly_div_long_test::<ArkFr, PolyData>()
}
#[test]
fn poly_div_fast_test_() {
poly_div_fast_test::<ArkFr, PolyData>()
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/zero_poly.rs | arkworks3/tests/zero_poly.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::zero_poly::{
check_test_data, reduce_partials_random, test_reduce_partials, zero_poly_252,
zero_poly_all_but_one, zero_poly_known, zero_poly_random,
};
use rust_kzg_arkworks3::kzg_proofs::FFTSettings;
use rust_kzg_arkworks3::kzg_types::ArkFr;
use rust_kzg_arkworks3::utils::PolyData;
#[test]
fn test_reduce_partials_() {
test_reduce_partials::<ArkFr, FFTSettings, PolyData>();
}
#[test]
fn reduce_partials_random_() {
reduce_partials_random::<ArkFr, FFTSettings, PolyData>();
}
#[test]
fn check_test_data_() {
check_test_data::<ArkFr, FFTSettings, PolyData>();
}
#[test]
fn zero_poly_known_() {
zero_poly_known::<ArkFr, FFTSettings, PolyData>();
}
#[test]
fn zero_poly_random_() {
zero_poly_random::<ArkFr, FFTSettings, PolyData>();
}
#[test]
fn zero_poly_all_but_one_() {
zero_poly_all_but_one::<ArkFr, FFTSettings, PolyData>();
}
#[test]
fn zero_poly_252_() {
zero_poly_252::<ArkFr, FFTSettings, PolyData>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/bls12_381.rs | arkworks3/tests/bls12_381.rs | #[cfg(test)]
mod tests {
use kzg::common_utils::log_2_byte;
use kzg_bench::tests::bls12_381::*;
use rust_kzg_arkworks3::fft_g1::g1_linear_combination;
use rust_kzg_arkworks3::kzg_proofs::pairings_verify;
use rust_kzg_arkworks3::kzg_types::{
ArkFp, ArkFr, ArkG1, ArkG1Affine, ArkG1ProjAddAffine, ArkG2,
};
#[test]
pub fn log_2_byte_works_() {
log_2_byte_works(&log_2_byte);
}
#[test]
pub fn fr_is_zero_works_() {
fr_is_zero_works::<ArkFr>();
}
#[test]
pub fn fr_is_one_works_() {
fr_is_one_works::<ArkFr>();
}
#[test]
pub fn fr_from_uint64_works_() {
fr_from_uint64_works::<ArkFr>();
}
#[test]
pub fn fr_equal_works_() {
fr_equal_works::<ArkFr>();
}
#[test]
pub fn fr_negate_works_() {
fr_negate_works::<ArkFr>();
}
#[test]
pub fn fr_pow_works_() {
fr_pow_works::<ArkFr>();
}
#[test]
pub fn fr_div_works_() {
fr_div_works::<ArkFr>();
}
#[test]
#[should_panic]
pub fn fr_div_by_zero_() {
fr_div_by_zero::<ArkFr>();
}
#[test]
pub fn fr_uint64s_roundtrip_() {
fr_uint64s_roundtrip::<ArkFr>();
}
#[test]
pub fn p1_mul_works_() {
p1_mul_works::<ArkFr, ArkG1>();
}
#[test]
pub fn p1_sub_works_() {
p1_sub_works::<ArkG1>();
}
#[test]
pub fn p2_add_or_dbl_works_() {
p2_add_or_dbl_works::<ArkG2>();
}
#[test]
pub fn p2_mul_works_() {
p2_mul_works::<ArkFr, ArkG2>();
}
#[test]
pub fn p2_sub_works_() {
p2_sub_works::<ArkG2>();
}
#[test]
pub fn g1_identity_is_infinity_() {
g1_identity_is_infinity::<ArkG1>();
}
#[test]
pub fn g1_identity_is_identity_() {
g1_identity_is_identity::<ArkG1>();
}
#[test]
pub fn g1_make_linear_combination_() {
g1_make_linear_combination::<ArkFr, ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine>(
&g1_linear_combination,
);
}
#[test]
pub fn g1_random_linear_combination_() {
g1_random_linear_combination::<ArkFr, ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine>(
&g1_linear_combination,
);
}
#[test]
pub fn g1_linear_combination_infinity_points_() {
g1_linear_combination_infinity_points::<ArkFr, ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine>(
&g1_linear_combination,
);
}
#[test]
fn g1_small_linear_combination_() {
g1_small_linear_combination::<ArkFr, ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine>(
&g1_linear_combination,
)
}
#[test]
pub fn pairings_work_() {
pairings_work::<ArkFr, ArkG1, ArkG2>(&pairings_verify);
}
#[test]
pub fn fr_is_null_works_() {
fr_is_null_works::<ArkFr>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/fk20_proofs.rs | arkworks3/tests/fk20_proofs.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::fk20_proofs::*;
use rust_kzg_arkworks3::eip_7594::ArkBackend;
use rust_kzg_arkworks3::fk20_proofs::{KzgFK20MultiSettings, KzgFK20SingleSettings};
use rust_kzg_arkworks3::kzg_proofs::generate_trusted_setup;
#[test]
fn test_fk_single() {
fk_single::<ArkBackend, KzgFK20SingleSettings>(&generate_trusted_setup);
}
#[test]
fn test_fk_single_strided() {
fk_single_strided::<ArkBackend, KzgFK20SingleSettings>(&generate_trusted_setup);
}
#[test]
fn test_fk_multi_settings() {
fk_multi_settings::<ArkBackend, KzgFK20MultiSettings>(&generate_trusted_setup);
}
#[test]
fn test_fk_multi_chunk_len_1_512() {
fk_multi_chunk_len_1_512::<ArkBackend, KzgFK20MultiSettings>(&generate_trusted_setup);
}
#[test]
fn test_fk_multi_chunk_len_16_512() {
fk_multi_chunk_len_16_512::<ArkBackend, KzgFK20MultiSettings>(&generate_trusted_setup);
}
#[test]
fn test_fk_multi_chunk_len_16_16() {
fk_multi_chunk_len_16_16::<ArkBackend, KzgFK20MultiSettings>(&generate_trusted_setup);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/bucket_msm.rs | arkworks3/tests/bucket_msm.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::msm::bucket_msm::{
test_process_point_and_slices_deal_three_points,
test_process_point_and_slices_glv_deal_two_points,
};
use rust_kzg_arkworks3::kzg_types::{ArkFp, ArkG1, ArkG1Affine, ArkG1ProjAddAffine};
#[test]
pub fn test_process_point_and_slices_deal_three_points_() {
test_process_point_and_slices_deal_three_points::<
ArkG1,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>();
}
#[test]
fn test_process_point_and_slices_glv_deal_two_points_() {
test_process_point_and_slices_glv_deal_two_points::<
ArkG1,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/fft_g1.rs | arkworks3/tests/fft_g1.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::fft_g1::{compare_sft_fft, roundtrip_fft, stride_fft};
use rust_kzg_arkworks3::fft_g1::{fft_g1_fast, fft_g1_slow, make_data};
use rust_kzg_arkworks3::kzg_proofs::FFTSettings;
use rust_kzg_arkworks3::kzg_types::{ArkFr, ArkG1};
#[test]
fn roundtrip_fft_() {
roundtrip_fft::<ArkFr, ArkG1, FFTSettings>(&make_data);
}
#[test]
fn stride_fft_() {
stride_fft::<ArkFr, ArkG1, FFTSettings>(&make_data);
}
#[test]
fn compare_sft_fft_() {
compare_sft_fft::<ArkFr, ArkG1, FFTSettings>(&fft_g1_slow, &fft_g1_fast, &make_data);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/fft_fr.rs | arkworks3/tests/fft_fr.rs | mod batch_adder;
#[cfg(test)]
mod tests {
use kzg_bench::tests::fft_fr::{compare_sft_fft, inverse_fft, roundtrip_fft, stride_fft};
use rust_kzg_arkworks3::fft::{fft_fr_fast, fft_fr_slow};
use rust_kzg_arkworks3::kzg_proofs::FFTSettings;
use rust_kzg_arkworks3::kzg_types::ArkFr;
#[test]
fn compare_sft_fft_() {
compare_sft_fft::<ArkFr, FFTSettings>(&fft_fr_slow, &fft_fr_fast);
}
#[test]
fn roundtrip_fft_() {
roundtrip_fft::<ArkFr, FFTSettings>();
}
#[test]
fn inverse_fft_() {
inverse_fft::<ArkFr, FFTSettings>();
}
#[test]
fn stride_fft_() {
stride_fft::<ArkFr, FFTSettings>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/batch_adder.rs | arkworks3/tests/batch_adder.rs | #[cfg(test)]
mod tests {
use kzg_bench::tests::msm::batch_adder::{
test_batch_add, test_batch_add_indexed, test_batch_add_indexed_single_bucket,
test_batch_add_step_n, test_phase_one_p_add_p, test_phase_one_p_add_q,
test_phase_one_p_add_q_twice, test_phase_one_zero_or_neg, test_phase_two_p_add_neg,
test_phase_two_p_add_p, test_phase_two_p_add_q, test_phase_two_zero_add_p,
};
use rust_kzg_arkworks3::kzg_types::{ArkFp, ArkG1, ArkG1Affine};
#[test]
fn test_phase_one_zero_or_neg_() {
test_phase_one_zero_or_neg::<ArkG1, ArkFp, ArkG1Affine>();
}
#[test]
fn test_phase_one_p_add_p_() {
test_phase_one_p_add_p::<ArkG1, ArkFp, ArkG1Affine>();
}
#[test]
fn test_phase_one_p_add_q_() {
test_phase_one_p_add_q::<ArkG1, ArkFp, ArkG1Affine>();
}
#[test]
fn test_phase_one_p_add_q_twice_() {
test_phase_one_p_add_q_twice::<ArkG1, ArkFp, ArkG1Affine>();
}
#[test]
fn test_phase_two_zero_add_p_() {
test_phase_two_zero_add_p::<ArkG1, ArkFp, ArkG1Affine>();
}
#[test]
fn test_phase_two_p_add_neg_() {
test_phase_two_p_add_neg::<ArkG1, ArkFp, ArkG1Affine>();
}
#[test]
fn test_phase_two_p_add_q_() {
test_phase_two_p_add_q::<ArkG1, ArkFp, ArkG1Affine>();
}
#[test]
pub fn test_phase_two_p_add_p_() {
test_phase_two_p_add_p::<ArkG1, ArkFp, ArkG1Affine>();
}
#[test]
fn test_batch_add_() {
test_batch_add::<ArkG1, ArkFp, ArkG1Affine>();
}
#[test]
fn test_batch_add_step_n_() {
test_batch_add_step_n::<ArkG1, ArkFp, ArkG1Affine>();
}
#[test]
fn test_batch_add_indexed_() {
test_batch_add_indexed::<ArkG1, ArkFp, ArkG1Affine>();
}
#[test]
fn test_batch_add_indexed_single_bucket_() {
test_batch_add_indexed_single_bucket::<ArkG1, ArkFp, ArkG1Affine>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/tests/recover.rs | arkworks3/tests/recover.rs | #[cfg(test)]
mod recover_tests {
use kzg_bench::tests::recover::*;
use rust_kzg_arkworks3::kzg_proofs::FFTSettings;
use rust_kzg_arkworks3::kzg_types::ArkFr as Fr;
use rust_kzg_arkworks3::utils::PolyData;
#[test]
fn recover_simple_() {
recover_simple::<Fr, FFTSettings, PolyData, PolyData>();
}
//Could be not working because of zero poly.
#[test]
fn recover_random_() {
recover_random::<Fr, FFTSettings, PolyData, PolyData>();
}
#[test]
fn more_than_half_missing_() {
more_than_half_missing::<Fr, FFTSettings, PolyData, PolyData>();
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/benches/das.rs | arkworks3/benches/das.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::das::bench_das_extension;
use rust_kzg_arkworks3::kzg_proofs::FFTSettings;
use rust_kzg_arkworks3::kzg_types::ArkFr;
fn bench_das_extension_(c: &mut Criterion) {
bench_das_extension::<ArkFr, FFTSettings>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_das_extension_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/benches/eip_4844.rs | arkworks3/benches/eip_4844.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg::eip_4844::{
blob_to_kzg_commitment_rust, bytes_to_blob, compute_blob_kzg_proof_rust,
compute_kzg_proof_rust, verify_blob_kzg_proof_batch_rust, verify_blob_kzg_proof_rust,
verify_kzg_proof_rust,
};
use kzg_bench::benches::eip_4844::bench_eip_4844;
use rust_kzg_arkworks3::eip_4844::load_trusted_setup_filename_rust;
use rust_kzg_arkworks3::kzg_proofs::{FFTSettings, KZGSettings};
use rust_kzg_arkworks3::kzg_types::{ArkFp, ArkFr, ArkG1, ArkG1Affine, ArkG1ProjAddAffine, ArkG2};
use rust_kzg_arkworks3::utils::PolyData;
fn bench_eip_4844_(c: &mut Criterion) {
bench_eip_4844::<
ArkFr,
ArkG1,
ArkG2,
PolyData,
FFTSettings,
KZGSettings,
ArkFp,
ArkG1Affine,
ArkG1ProjAddAffine,
>(
c,
&load_trusted_setup_filename_rust,
&blob_to_kzg_commitment_rust,
&bytes_to_blob,
&compute_kzg_proof_rust,
&verify_kzg_proof_rust,
&compute_blob_kzg_proof_rust,
&verify_blob_kzg_proof_rust,
&verify_blob_kzg_proof_batch_rust,
);
}
criterion_group!(benches, bench_eip_4844_,);
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/benches/eip_7594.rs | arkworks3/benches/eip_7594.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg::eip_4844::{blob_to_kzg_commitment_rust, bytes_to_blob};
use kzg_bench::benches::eip_7594::bench_eip_7594;
use rust_kzg_arkworks3::{eip_4844::load_trusted_setup_filename_rust, eip_7594::ArkBackend};
fn bench_eip_7594_(c: &mut Criterion) {
bench_eip_7594::<ArkBackend>(
c,
&load_trusted_setup_filename_rust,
&bytes_to_blob,
&blob_to_kzg_commitment_rust,
);
}
criterion_group!(benches, bench_eip_7594_);
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/benches/poly.rs | arkworks3/benches/poly.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::poly::bench_new_poly_div;
use rust_kzg_arkworks3::kzg_types::ArkFr;
use rust_kzg_arkworks3::utils::PolyData;
fn bench_new_poly_div_(c: &mut Criterion) {
bench_new_poly_div::<ArkFr, PolyData>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_new_poly_div_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/benches/zero_poly.rs | arkworks3/benches/zero_poly.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::zero_poly::bench_zero_poly;
use rust_kzg_arkworks3::kzg_proofs::FFTSettings;
use rust_kzg_arkworks3::kzg_types::ArkFr;
use rust_kzg_arkworks3::utils::PolyData;
fn bench_zero_poly_(c: &mut Criterion) {
bench_zero_poly::<ArkFr, FFTSettings, PolyData>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_zero_poly_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/benches/kzg.rs | arkworks3/benches/kzg.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::kzg::{bench_commit_to_poly, bench_compute_proof_single};
use rust_kzg_arkworks3::eip_7594::ArkBackend;
use rust_kzg_arkworks3::kzg_proofs::generate_trusted_setup;
fn bench_commit_to_poly_(c: &mut Criterion) {
bench_commit_to_poly::<ArkBackend>(c, &generate_trusted_setup);
}
fn bench_compute_proof_single_(c: &mut Criterion) {
bench_compute_proof_single::<ArkBackend>(c, &generate_trusted_setup);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_commit_to_poly_, bench_compute_proof_single_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/benches/lincomb.rs | arkworks3/benches/lincomb.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::lincomb::bench_g1_lincomb;
use rust_kzg_arkworks3::fft_g1::g1_linear_combination;
use rust_kzg_arkworks3::kzg_types::{ArkFp, ArkFr, ArkG1, ArkG1Affine, ArkG1ProjAddAffine};
fn bench_g1_lincomb_(c: &mut Criterion) {
bench_g1_lincomb::<ArkFr, ArkG1, ArkFp, ArkG1Affine, ArkG1ProjAddAffine>(
c,
&g1_linear_combination,
);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_g1_lincomb_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/benches/fk_20.rs | arkworks3/benches/fk_20.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::fk20::{bench_fk_multi_da, bench_fk_single_da};
use rust_kzg_arkworks3::eip_7594::ArkBackend;
use rust_kzg_arkworks3::fk20_proofs::{KzgFK20MultiSettings, KzgFK20SingleSettings};
use rust_kzg_arkworks3::kzg_proofs::generate_trusted_setup;
fn bench_fk_single_da_(c: &mut Criterion) {
bench_fk_single_da::<ArkBackend, KzgFK20SingleSettings>(c, &generate_trusted_setup)
}
fn bench_fk_multi_da_(c: &mut Criterion) {
bench_fk_multi_da::<ArkBackend, KzgFK20MultiSettings>(c, &generate_trusted_setup)
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_fk_single_da_, bench_fk_multi_da_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/benches/recover.rs | arkworks3/benches/recover.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::recover::bench_recover;
use rust_kzg_arkworks3::kzg_proofs::FFTSettings;
use rust_kzg_arkworks3::kzg_types::ArkFr;
use rust_kzg_arkworks3::utils::PolyData;
fn bench_recover_(c: &mut Criterion) {
bench_recover::<ArkFr, FFTSettings, PolyData, PolyData>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_recover_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/arkworks3/benches/fft.rs | arkworks3/benches/fft.rs | use criterion::{criterion_group, criterion_main, Criterion};
use kzg_bench::benches::fft::{bench_fft_fr, bench_fft_g1};
use rust_kzg_arkworks3::kzg_proofs::FFTSettings;
use rust_kzg_arkworks3::kzg_types::{ArkFr, ArkG1};
fn bench_fft_fr_(c: &mut Criterion) {
bench_fft_fr::<ArkFr, FFTSettings>(c);
}
fn bench_fft_g1_(c: &mut Criterion) {
bench_fft_g1::<ArkFr, ArkG1, FFTSettings>(c);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = bench_fft_fr_, bench_fft_g1_
}
criterion_main!(benches);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/constantine/src/consts.rs | constantine/src/consts.rs | //blst_fp = bls12_381_fp, CtG1 = CtG1, blst_p1 = bls12_381_g1_jac, blst_fr = bls12_381_fr
use constantine_sys::{bls12_381_fp, bls12_381_fp2, bls12_381_g1_jac, bls12_381_g2_jac};
use crate::types::g1::CtG1;
use crate::types::g2::CtG2;
pub const G1_IDENTITY: CtG1 = CtG1::from_xyz(
bls12_381_fp { limbs: [0; 6] },
bls12_381_fp { limbs: [0; 6] },
bls12_381_fp { limbs: [0; 6] },
);
pub const SCALE_FACTOR: u64 = 5;
pub const NUM_ROOTS: usize = 32;
/// The roots of unity. Every root_i equals 1 when raised to the power of (2 ^ i)
#[rustfmt::skip]
pub const SCALE2_ROOT_OF_UNITY: [[u64; 4]; 32] = [
[0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000],
[0xffffffff00000000, 0x53bda402fffe5bfe, 0x3339d80809a1d805, 0x73eda753299d7d48],
[0x0001000000000000, 0xec03000276030000, 0x8d51ccce760304d0, 0x0000000000000000],
[0x7228fd3397743f7a, 0xb38b21c28713b700, 0x8c0625cd70d77ce2, 0x345766f603fa66e7],
[0x53ea61d87742bcce, 0x17beb312f20b6f76, 0xdd1c0af834cec32c, 0x20b1ce9140267af9],
[0x360c60997369df4e, 0xbf6e88fb4c38fb8a, 0xb4bcd40e22f55448, 0x50e0903a157988ba],
[0x8140d032f0a9ee53, 0x2d967f4be2f95155, 0x14a1e27164d8fdbd, 0x45af6345ec055e4d],
[0x5130c2c1660125be, 0x98d0caac87f5713c, 0xb7c68b4d7fdd60d0, 0x6898111413588742],
[0x4935bd2f817f694b, 0x0a0865a899e8deff, 0x6b368121ac0cf4ad, 0x4f9b4098e2e9f12e],
[0x4541b8ff2ee0434e, 0xd697168a3a6000fe, 0x39feec240d80689f, 0x095166525526a654],
[0x3c28d666a5c2d854, 0xea437f9626fc085e, 0x8f4de02c0f776af3, 0x325db5c3debf77a1],
[0x4a838b5d59cd79e5, 0x55ea6811be9c622d, 0x09f1ca610a08f166, 0x6d031f1b5c49c834],
[0xe206da11a5d36306, 0x0ad1347b378fbf96, 0xfc3e8acfe0f8245f, 0x564c0a11a0f704f4],
[0x6fdd00bfc78c8967, 0x146b58bc434906ac, 0x2ccddea2972e89ed, 0x485d512737b1da3d],
[0x034d2ff22a5ad9e1, 0xae4622f6a9152435, 0xdc86b01c0d477fa6, 0x56624634b500a166],
[0xfbd047e11279bb6e, 0xc8d5f51db3f32699, 0x483405417a0cbe39, 0x3291357ee558b50d],
[0xd7118f85cd96b8ad, 0x67a665ae1fcadc91, 0x88f39a78f1aeb578, 0x2155379d12180caa],
[0x08692405f3b70f10, 0xcd7f2bd6d0711b7d, 0x473a2eef772c33d6, 0x224262332d8acbf4],
[0x6f421a7d8ef674fb, 0xbb97a3bf30ce40fd, 0x652f717ae1c34bb0, 0x2d3056a530794f01],
[0x194e8c62ecb38d9d, 0xad8e16e84419c750, 0xdf625e80d0adef90, 0x520e587a724a6955],
[0xfece7e0e39898d4b, 0x2f69e02d265e09d9, 0xa57a6e07cb98de4a, 0x03e1c54bcb947035],
[0xcd3979122d3ea03a, 0x46b3105f04db5844, 0xc70d0874b0691d4e, 0x47c8b5817018af4f],
[0xc6e7a6ffb08e3363, 0xe08fec7c86389bee, 0xf2d38f10fbb8d1bb, 0x0abe6a5e5abcaa32],
[0x5616c57de0ec9eae, 0xc631ffb2585a72db, 0x5121af06a3b51e3c, 0x73560252aa0655b2],
[0x92cf4deb77bd779c, 0x72cf6a8029b7d7bc, 0x6e0bcd91ee762730, 0x291cf6d68823e687],
[0xce32ef844e11a51e, 0xc0ba12bb3da64ca5, 0x0454dc1edc61a1a3, 0x019fe632fd328739],
[0x531a11a0d2d75182, 0x02c8118402867ddc, 0x116168bffbedc11d, 0x0a0a77a3b1980c0d],
[0xe2d0a7869f0319ed, 0xb94f1101b1d7a628, 0xece8ea224f31d25d, 0x23397a9300f8f98b],
[0xd7b688830a4f2089, 0x6558e9e3f6ac7b41, 0x99e276b571905a7d, 0x52dd465e2f094256],
[0x474650359d8e211b, 0x84d37b826214abc6, 0x8da40c1ef2bb4598, 0x0c83ea7744bf1bee],
[0x694341f608c9dd56, 0xed3a181fabb30adc, 0x1339a815da8b398f, 0x2c6d4e4511657e1e],
[0x63e7cb4906ffc93f, 0xf070bb00e28a193d, 0xad1715b02e5713b5, 0x4b5371495990693f]
];
// pub const G1_GENERATOR_AFFINE: bls12_381_g1_aff = bls12_381_g1_aff {
// x: bls12_381_fp {
// limbs: [
// 0x17f1d3a73197d794,
// 0x2695638c4fa9ac0f,
// 0xc3688c4f9774b905,
// 0xa14e3a3f171bac58,
// 0x6c55e83ff97a1aef,
// 0xfb3af00adb22c6bb,
// ],
// },
// y: bls12_381_fp {
// limbs: [
// 0xbaac93d50ce72271,
// 0x8c22631a7918fd8e,
// 0xdd595f13570725ce,
// 0x51ac582950405194,
// 0x0e1c8c3fad0059c0,
// 0x0bbc3efc5008a26a,
// ],
// },
// });
pub const G1_GENERATOR: CtG1 = CtG1(bls12_381_g1_jac {
x: bls12_381_fp {
limbs: [
0x5cb38790fd530c16,
0x7817fc679976fff5,
0x154f95c7143ba1c1,
0xf0ae6acdf3d0e747,
0xedce6ecc21dbf440,
0x120177419e0bfb75,
],
},
y: bls12_381_fp {
limbs: [
0xbaac93d50ce72271,
0x8c22631a7918fd8e,
0xdd595f13570725ce,
0x51ac582950405194,
0x0e1c8c3fad0059c0,
0x0bbc3efc5008a26a,
],
},
z: bls12_381_fp {
limbs: [
0x760900000002fffd,
0xebf4000bc40c0002,
0x5f48985753c758ba,
0x77ce585370525745,
0x5c071a97a256ec6d,
0x15f65ec3fa80e493,
],
},
});
pub const G1_NEGATIVE_GENERATOR: CtG1 = CtG1(bls12_381_g1_jac {
x: bls12_381_fp {
limbs: [
0x5cb38790fd530c16,
0x7817fc679976fff5,
0x154f95c7143ba1c1,
0xf0ae6acdf3d0e747,
0xedce6ecc21dbf440,
0x120177419e0bfb75,
],
},
y: bls12_381_fp {
limbs: [
0xff526c2af318883a,
0x92899ce4383b0270,
0x89d7738d9fa9d055,
0x12caf35ba344c12a,
0x3cff1b76964b5317,
0x0e44d2ede9774430,
],
},
z: bls12_381_fp {
limbs: [
0x760900000002fffd,
0xebf4000bc40c0002,
0x5f48985753c758ba,
0x77ce585370525745,
0x5c071a97a256ec6d,
0x15f65ec3fa80e493,
],
},
});
pub const G2_GENERATOR: CtG2 = CtG2(bls12_381_g2_jac {
x: bls12_381_fp2 {
c: [
bls12_381_fp {
limbs: [
0xf5f28fa202940a10,
0xb3f5fb2687b4961a,
0xa1a893b53e2ae580,
0x9894999d1a3caee9,
0x6f67b7631863366b,
0x058191924350bcd7,
],
},
bls12_381_fp {
limbs: [
0xa5a9c0759e23f606,
0xaaa0c59dbccd60c3,
0x3bb17e18e2867806,
0x1b1ab6cc8541b367,
0xc2b6ed0ef2158547,
0x11922a097360edf3,
],
},
],
},
y: bls12_381_fp2 {
c: [
bls12_381_fp {
limbs: [
0x4c730af860494c4a,
0x597cfa1f5e369c5a,
0xe7e6856caa0a635a,
0xbbefb5e96e0d495f,
0x07d3a975f0ef25a2,
0x0083fd8e7e80dae5,
],
},
bls12_381_fp {
limbs: [
0xadc0fc92df64b05d,
0x18aa270a2b1461dc,
0x86adac6a3be4eba0,
0x79495c4ec93da33a,
0xe7175850a43ccaed,
0x0b2bc2a163de1bf2,
],
},
],
},
z: bls12_381_fp2 {
c: [
bls12_381_fp {
limbs: [
0x760900000002fffd,
0xebf4000bc40c0002,
0x5f48985753c758ba,
0x77ce585370525745,
0x5c071a97a256ec6d,
0x15f65ec3fa80e493,
],
},
bls12_381_fp {
limbs: [
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
],
},
],
},
});
pub const G2_NEGATIVE_GENERATOR: CtG2 = CtG2(bls12_381_g2_jac {
x: bls12_381_fp2 {
c: [
bls12_381_fp {
limbs: [
0xf5f28fa202940a10,
0xb3f5fb2687b4961a,
0xa1a893b53e2ae580,
0x9894999d1a3caee9,
0x6f67b7631863366b,
0x058191924350bcd7,
],
},
bls12_381_fp {
limbs: [
0xa5a9c0759e23f606,
0xaaa0c59dbccd60c3,
0x3bb17e18e2867806,
0x1b1ab6cc8541b367,
0xc2b6ed0ef2158547,
0x11922a097360edf3,
],
},
],
},
y: bls12_381_fp2 {
c: [
bls12_381_fp {
limbs: [
0x6d8bf5079fb65e61,
0xc52f05df531d63a5,
0x7f4a4d344ca692c9,
0xa887959b8577c95f,
0x4347fe40525c8734,
0x197d145bbaff0bb5,
],
},
bls12_381_fp {
limbs: [
0x0c3e036d209afa4e,
0x0601d8f4863f9e23,
0xe0832636bacc0a84,
0xeb2def362a476f84,
0x64044f659f0ee1e9,
0x0ed54f48d5a1caa7,
],
},
],
},
z: bls12_381_fp2 {
c: [
bls12_381_fp {
limbs: [
0x760900000002fffd,
0xebf4000bc40c0002,
0x5f48985753c758ba,
0x77ce585370525745,
0x5c071a97a256ec6d,
0x15f65ec3fa80e493,
],
},
bls12_381_fp {
limbs: [
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
0x0000000000000000,
],
},
],
},
});
pub const TRUSTED_SETUP_GENERATOR: [u8; 32usize] = [
0xa4, 0x73, 0x31, 0x95, 0x28, 0xc8, 0xb6, 0xea, 0x4d, 0x08, 0xcc, 0x53, 0x18, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/constantine/src/lib.rs | constantine/src/lib.rs | #![cfg_attr(not(feature = "std"), no_std)]
pub mod consts;
pub mod data_availability_sampling;
pub mod eip_4844;
pub mod eip_7594;
pub mod fft_fr;
pub mod fft_g1;
pub mod fk20_proofs;
pub mod kzg_proofs;
pub mod mixed_kzg;
pub mod recovery;
pub mod types;
pub mod utils;
pub mod zero_poly;
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/constantine/src/eip_4844.rs | constantine/src/eip_4844.rs | extern crate alloc;
#[cfg(feature = "c_bindings")]
use alloc::{boxed::Box, string::String, vec::Vec};
#[cfg(feature = "c_bindings")]
use core::ptr;
#[cfg(feature = "c_bindings")]
use kzg::{
eip_4844::{
BYTES_PER_G1, FIELD_ELEMENTS_PER_BLOB, TRUSTED_SETUP_NUM_G1_POINTS,
TRUSTED_SETUP_NUM_G2_POINTS,
},
eth,
eth::c_bindings::{Blob, Bytes32, Bytes48, CKZGSettings, CKzgRet, KZGCommitment, KZGProof},
Fr, G1,
};
#[cfg(all(feature = "std", feature = "c_bindings"))]
use libc::FILE;
#[cfg(feature = "std")]
use std::fs::File;
#[cfg(feature = "std")]
use std::io::Read;
#[cfg(feature = "std")]
use kzg::eip_4844::load_trusted_setup_string;
use kzg::eip_4844::load_trusted_setup_rust;
#[cfg(feature = "c_bindings")]
use crate::types::{
fp::CtFp,
fr::CtFr,
g1::{CtG1, CtG1Affine},
kzg_settings::CtKZGSettings,
};
#[cfg(feature = "c_bindings")]
use crate::utils::PRECOMPUTATION_TABLES;
#[cfg(feature = "std")]
pub fn load_trusted_setup_filename_rust(
filepath: &str,
) -> Result<crate::types::kzg_settings::CtKZGSettings, alloc::string::String> {
let mut file = File::open(filepath).map_err(|_| "Unable to open file".to_string())?;
let mut contents = String::new();
file.read_to_string(&mut contents)
.map_err(|_| "Unable to read file".to_string())?;
let (g1_monomial_bytes, g1_lagrange_bytes, g2_monomial_bytes) =
load_trusted_setup_string(&contents)?;
load_trusted_setup_rust(&g1_monomial_bytes, &g1_lagrange_bytes, &g2_monomial_bytes)
}
#[cfg(feature = "c_bindings")]
fn kzg_settings_to_c(rust_settings: &CtKZGSettings) -> CKZGSettings {
CKZGSettings {
roots_of_unity: Box::leak(
rust_settings
.fs
.roots_of_unity
.iter()
.map(|r| r.to_blst_fr())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
brp_roots_of_unity: Box::leak(
rust_settings
.fs
.brp_roots_of_unity
.iter()
.map(|r| r.to_blst_fr())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
reverse_roots_of_unity: Box::leak(
rust_settings
.fs
.reverse_roots_of_unity
.iter()
.map(|r| r.to_blst_fr())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
g1_values_monomial: Box::leak(
rust_settings
.g1_values_monomial
.iter()
.map(|r| r.to_blst_p1())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
g1_values_lagrange_brp: Box::leak(
rust_settings
.g1_values_lagrange_brp
.iter()
.map(|r| r.to_blst_p1())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
g2_values_monomial: Box::leak(
rust_settings
.g2_values_monomial
.iter()
.map(|r| r.to_blst_p2())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
x_ext_fft_columns: Box::leak(
rust_settings
.x_ext_fft_columns
.iter()
.map(|r| {
Box::leak(
r.iter()
.map(|it| it.to_blst_p1())
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr()
})
.collect::<Vec<_>>()
.into_boxed_slice(),
)
.as_mut_ptr(),
tables: core::ptr::null_mut(),
wbits: 0,
scratch_size: 0,
}
}
#[cfg(feature = "c_bindings")]
macro_rules! handle_ckzg_badargs {
($x: expr) => {
match $x {
Ok(value) => value,
Err(_) => return kzg::eth::c_bindings::CKzgRet::BadArgs,
}
};
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn blob_to_kzg_commitment(
out: *mut KZGCommitment,
blob: *const Blob,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::blob_to_kzg_commitment_raw;
if TRUSTED_SETUP_NUM_G1_POINTS == 0 {
// FIXME: load_trusted_setup should set this value, but if not, it fails
TRUSTED_SETUP_NUM_G1_POINTS = FIELD_ELEMENTS_PER_BLOB
};
let settings: CtKZGSettings = handle_ckzg_badargs!(s.try_into());
let tmp = handle_ckzg_badargs!(blob_to_kzg_commitment_raw((*blob).bytes, &settings));
(*out).bytes = tmp.to_bytes();
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn load_trusted_setup(
out: *mut CKZGSettings,
g1_monomial_bytes: *const u8,
num_g1_monomial_bytes: u64,
g1_lagrange_bytes: *const u8,
num_g1_lagrange_bytes: u64,
g2_monomial_bytes: *const u8,
num_g2_monomial_bytes: u64,
_precompute: u64,
) -> CKzgRet {
*out = CKZGSettings {
brp_roots_of_unity: ptr::null_mut(),
roots_of_unity: ptr::null_mut(),
reverse_roots_of_unity: ptr::null_mut(),
g1_values_monomial: ptr::null_mut(),
g1_values_lagrange_brp: ptr::null_mut(),
g2_values_monomial: ptr::null_mut(),
x_ext_fft_columns: ptr::null_mut(),
tables: ptr::null_mut(),
wbits: 0,
scratch_size: 0,
};
let g1_monomial_bytes =
core::slice::from_raw_parts(g1_monomial_bytes, num_g1_monomial_bytes as usize);
let g1_lagrange_bytes =
core::slice::from_raw_parts(g1_lagrange_bytes, num_g1_lagrange_bytes as usize);
let g2_monomial_bytes =
core::slice::from_raw_parts(g2_monomial_bytes, num_g2_monomial_bytes as usize);
TRUSTED_SETUP_NUM_G1_POINTS = num_g1_monomial_bytes as usize / BYTES_PER_G1;
let mut settings = handle_ckzg_badargs!(load_trusted_setup_rust(
g1_monomial_bytes,
g1_lagrange_bytes,
g2_monomial_bytes
));
let c_settings = kzg_settings_to_c(&settings);
PRECOMPUTATION_TABLES.save_precomputation(settings.precomputation.take(), &c_settings);
*out = c_settings;
CKzgRet::Ok
}
/// # Safety
#[cfg(all(feature = "std", feature = "c_bindings"))]
#[no_mangle]
pub unsafe extern "C" fn load_trusted_setup_file(
out: *mut CKZGSettings,
in_: *mut FILE,
) -> CKzgRet {
*out = CKZGSettings {
brp_roots_of_unity: ptr::null_mut(),
roots_of_unity: ptr::null_mut(),
reverse_roots_of_unity: ptr::null_mut(),
g1_values_monomial: ptr::null_mut(),
g1_values_lagrange_brp: ptr::null_mut(),
g2_values_monomial: ptr::null_mut(),
x_ext_fft_columns: ptr::null_mut(),
tables: ptr::null_mut(),
wbits: 0,
scratch_size: 0,
};
let mut buf = vec![0u8; 1024 * 1024];
let len: usize = libc::fread(buf.as_mut_ptr() as *mut libc::c_void, 1, buf.len(), in_);
let s = handle_ckzg_badargs!(String::from_utf8(buf[..len].to_vec()));
let (g1_monomial_bytes, g1_lagrange_bytes, g2_monomial_bytes) =
handle_ckzg_badargs!(load_trusted_setup_string(&s));
TRUSTED_SETUP_NUM_G1_POINTS = g1_monomial_bytes.len() / BYTES_PER_G1;
if TRUSTED_SETUP_NUM_G1_POINTS != FIELD_ELEMENTS_PER_BLOB {
// Helps pass the Java test "shouldThrowExceptionOnIncorrectTrustedSetupFromFile",
// as well as 5 others that pass only if this one passes (likely because Java doesn't
// deallocate its KZGSettings pointer when no exception is thrown).
return CKzgRet::BadArgs;
}
let mut settings = handle_ckzg_badargs!(load_trusted_setup_rust(
&g1_monomial_bytes,
&g1_lagrange_bytes,
&g2_monomial_bytes
));
let c_settings = kzg_settings_to_c(&settings);
PRECOMPUTATION_TABLES.save_precomputation(settings.precomputation.take(), &c_settings);
*out = c_settings;
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn compute_blob_kzg_proof(
out: *mut KZGProof,
blob: *const Blob,
commitment_bytes: *const Bytes48,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::compute_blob_kzg_proof_raw;
let settings: CtKZGSettings = handle_ckzg_badargs!(s.try_into());
let proof = handle_ckzg_badargs!(compute_blob_kzg_proof_raw(
(*blob).bytes,
(*commitment_bytes).bytes,
&settings
));
(*out).bytes = proof.to_bytes();
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn free_trusted_setup(s: *mut CKZGSettings) {
if s.is_null() {
return;
}
PRECOMPUTATION_TABLES.remove_precomputation(&*s);
if !(*s).roots_of_unity.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB + 1,
));
drop(v);
(*s).roots_of_unity = ptr::null_mut();
}
if !(*s).brp_roots_of_unity.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).brp_roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB,
));
drop(v);
(*s).brp_roots_of_unity = ptr::null_mut();
}
if !(*s).reverse_roots_of_unity.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).reverse_roots_of_unity,
eth::FIELD_ELEMENTS_PER_EXT_BLOB + 1,
));
drop(v);
(*s).reverse_roots_of_unity = ptr::null_mut();
}
if !(*s).g1_values_monomial.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).g1_values_monomial,
FIELD_ELEMENTS_PER_BLOB,
));
drop(v);
(*s).g1_values_monomial = ptr::null_mut();
}
if !(*s).g1_values_lagrange_brp.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).g1_values_lagrange_brp,
FIELD_ELEMENTS_PER_BLOB,
));
drop(v);
(*s).g1_values_lagrange_brp = ptr::null_mut();
}
if !(*s).g2_values_monomial.is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
(*s).g2_values_monomial,
TRUSTED_SETUP_NUM_G2_POINTS,
));
drop(v);
(*s).g2_values_monomial = ptr::null_mut();
}
if !(*s).x_ext_fft_columns.is_null() {
let x_ext_fft_columns = core::slice::from_raw_parts_mut(
(*s).x_ext_fft_columns,
2 * ((eth::FIELD_ELEMENTS_PER_EXT_BLOB / 2) / eth::FIELD_ELEMENTS_PER_CELL),
);
for column in x_ext_fft_columns.iter_mut() {
if !(*column).is_null() {
let v = Box::from_raw(core::slice::from_raw_parts_mut(
*column,
eth::FIELD_ELEMENTS_PER_CELL,
));
drop(v);
*column = ptr::null_mut();
}
}
let v = Box::from_raw(x_ext_fft_columns);
drop(v);
(*s).x_ext_fft_columns = ptr::null_mut();
}
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn verify_kzg_proof(
ok: *mut bool,
commitment_bytes: *const Bytes48,
z_bytes: *const Bytes32,
y_bytes: *const Bytes32,
proof_bytes: *const Bytes48,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::verify_kzg_proof_raw;
let settings: CtKZGSettings = handle_ckzg_badargs!(s.try_into());
let result = handle_ckzg_badargs!(verify_kzg_proof_raw(
(*commitment_bytes).bytes,
(*z_bytes).bytes,
(*y_bytes).bytes,
(*proof_bytes).bytes,
&settings
));
*ok = result;
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn verify_blob_kzg_proof(
ok: *mut bool,
blob: *const Blob,
commitment_bytes: *const Bytes48,
proof_bytes: *const Bytes48,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::verify_blob_kzg_proof_raw;
let settings: CtKZGSettings = handle_ckzg_badargs!(s.try_into());
let result = handle_ckzg_badargs!(verify_blob_kzg_proof_raw(
(*blob).bytes,
(*commitment_bytes).bytes,
(*proof_bytes).bytes,
&settings,
));
*ok = result;
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn verify_blob_kzg_proof_batch(
ok: *mut bool,
blobs: *const Blob,
commitments_bytes: *const Bytes48,
proofs_bytes: *const Bytes48,
n: usize,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::verify_blob_kzg_proof_batch_raw;
let blobs = core::slice::from_raw_parts(blobs, n)
.iter()
.map(|v| v.bytes)
.collect::<Vec<_>>();
let commitments = core::slice::from_raw_parts(commitments_bytes, n)
.iter()
.map(|c| c.bytes)
.collect::<Vec<_>>();
let proofs = core::slice::from_raw_parts(proofs_bytes, n)
.iter()
.map(|p| p.bytes)
.collect::<Vec<_>>();
*ok = false;
let settings: CtKZGSettings = handle_ckzg_badargs!(s.try_into());
*ok = handle_ckzg_badargs!(verify_blob_kzg_proof_batch_raw(
&blobs,
&commitments,
&proofs,
&settings
));
CKzgRet::Ok
}
/// # Safety
#[cfg(feature = "c_bindings")]
#[no_mangle]
pub unsafe extern "C" fn compute_kzg_proof(
proof_out: *mut KZGProof,
y_out: *mut Bytes32,
blob: *const Blob,
z_bytes: *const Bytes32,
s: &CKZGSettings,
) -> CKzgRet {
use kzg::eip_4844::compute_kzg_proof_raw;
let settings: CtKZGSettings = handle_ckzg_badargs!(s.try_into());
let (proof_out_tmp, fry_tmp) = handle_ckzg_badargs!(compute_kzg_proof_raw(
(*blob).bytes,
(*z_bytes).bytes,
&settings
));
(*proof_out).bytes = proof_out_tmp.to_bytes();
(*y_out).bytes = fry_tmp.to_bytes();
CKzgRet::Ok
}
#[cfg(test)]
mod tests {
#[cfg(feature = "c_bindings")]
#[test]
fn kzg_settings_to_rust_check_conversion() {
use kzg_bench::tests::utils::get_trusted_setup_path;
use crate::types::kzg_settings::CtKZGSettings;
use super::{kzg_settings_to_c, load_trusted_setup_filename_rust};
let settings = load_trusted_setup_filename_rust(get_trusted_setup_path().as_str());
assert!(settings.is_ok());
let settings = settings.unwrap();
let converted_settings: CtKZGSettings = (&kzg_settings_to_c(&settings)).try_into().unwrap();
assert_eq!(
settings.fs.root_of_unity,
converted_settings.fs.root_of_unity
);
assert_eq!(
settings.fs.roots_of_unity,
converted_settings.fs.roots_of_unity
);
assert_eq!(
settings.fs.brp_roots_of_unity,
converted_settings.fs.brp_roots_of_unity
);
assert_eq!(
settings.fs.reverse_roots_of_unity,
converted_settings.fs.reverse_roots_of_unity
);
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/constantine/src/kzg_proofs.rs | constantine/src/kzg_proofs.rs | extern crate alloc;
use crate::types::fp::CtFp;
use crate::types::g1::CtG1;
use crate::types::{fr::CtFr, g1::CtG1Affine};
use crate::utils::{ptr_transmute, ptr_transmute_mut};
#[cfg(feature = "constantine_msm")]
use constantine_sys as constantine;
#[cfg(feature = "constantine_msm")]
use kzg::G1Affine;
#[cfg(not(feature = "constantine_msm"))]
use kzg::msm::msm_impls::msm;
#[cfg(not(feature = "constantine_msm"))]
use crate::types::g1::CtG1ProjAddAffine;
use kzg::msm::precompute::PrecomputationTable;
use crate::types::g2::CtG2;
use kzg::PairingVerify;
impl PairingVerify<CtG1, CtG2> for CtG1 {
fn verify(a1: &CtG1, a2: &CtG2, b1: &CtG1, b2: &CtG2) -> bool {
pairings_verify(a1, a2, b1, b2)
}
}
pub fn g1_linear_combination(
out: &mut CtG1,
points: &[CtG1],
scalars: &[CtFr],
len: usize,
_precomputation: Option<&PrecomputationTable<CtFr, CtG1, CtFp, CtG1Affine, CtG1ProjAddAffine>>,
) {
#[cfg(feature = "constantine_msm")]
{
if len == 0 {
*out = CtG1::default();
return;
}
#[cfg(feature = "parallel")]
let pool = unsafe {
constantine::ctt_threadpool_new(constantine_sys::ctt_cpu_get_num_threads_os())
};
#[cfg(not(feature = "parallel"))]
let pool = unsafe { constantine::ctt_threadpool_new(1) };
unsafe {
let points_affine_vec = CtG1Affine::into_affines(points);
let points_transmuted: &[constantine::bls12_381_g1_aff] =
core::mem::transmute(points_affine_vec.as_slice());
let frs_transmuted: &[constantine::bls12_381_fr] = core::mem::transmute(scalars);
constantine::ctt_bls12_381_g1_jac_multi_scalar_mul_fr_coefs_vartime_parallel(
pool,
&mut out.0,
frs_transmuted.as_ptr(),
points_transmuted.as_ptr(),
len,
);
}
unsafe {
constantine::ctt_threadpool_shutdown(pool);
}
}
#[cfg(not(feature = "constantine_msm"))]
{
*out = msm::<CtG1, CtFp, CtG1Affine, CtG1ProjAddAffine, CtFr>(
points,
scalars,
len,
_precomputation,
);
}
}
pub fn pairings_verify(a1: &CtG1, a2: &CtG2, b1: &CtG1, b2: &CtG2) -> bool {
// FIXME: Remove usage of BLST version, though not sure if there's a constantine version of multi miller loop
let mut aa1 = blst::blst_p1_affine::default();
let mut bb1 = blst::blst_p1_affine::default();
let mut aa2 = blst::blst_p2_affine::default();
let mut bb2 = blst::blst_p2_affine::default();
// As an optimisation, we want to invert one of the pairings,
// so we negate one of the points.
let mut a1neg: CtG1 = *a1;
unsafe {
blst::blst_p1_cneg(ptr_transmute_mut(&mut a1neg.0), true);
blst::blst_p1_to_affine(&mut aa1, ptr_transmute(&a1neg.0));
blst::blst_p1_to_affine(&mut bb1, ptr_transmute(&b1.0));
blst::blst_p2_to_affine(&mut aa2, ptr_transmute(&a2.0));
blst::blst_p2_to_affine(&mut bb2, ptr_transmute(&b2.0));
let dst = [0u8; 3];
let mut pairing_blst = blst::Pairing::new(false, &dst);
pairing_blst.raw_aggregate(&aa2, &aa1);
pairing_blst.raw_aggregate(&bb2, &bb1);
let gt_point = pairing_blst.as_fp12().final_exp();
blst::blst_fp12_is_one(>_point)
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/constantine/src/eip_7594.rs | constantine/src/eip_7594.rs | extern crate alloc;
use kzg::EcBackend;
use crate::types::fft_settings::CtFFTSettings;
use crate::types::fp::CtFp;
use crate::types::fr::CtFr;
use crate::types::g1::CtG1;
use crate::types::g1::CtG1Affine;
use crate::types::g1::CtG1ProjAddAffine;
use crate::types::g2::CtG2;
use crate::types::kzg_settings::CtKZGSettings;
use crate::types::poly::CtPoly;
pub struct CtBackend;
impl EcBackend for CtBackend {
type Fr = CtFr;
type G1Fp = CtFp;
type G1Affine = CtG1Affine;
type G1ProjAddAffine = CtG1ProjAddAffine;
type G1 = CtG1;
type G2 = CtG2;
type Poly = CtPoly;
type FFTSettings = CtFFTSettings;
type KZGSettings = CtKZGSettings;
}
#[cfg(feature = "c_bindings")]
kzg::c_bindings_eip7594!(CtBackend);
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/constantine/src/zero_poly.rs | constantine/src/zero_poly.rs | extern crate alloc;
use alloc::string::String;
use alloc::vec;
use alloc::vec::Vec;
use core::cmp::{min, Ordering};
use kzg::{common_utils::next_pow_of_2, FFTFr, Fr, ZeroPoly};
use crate::types::fft_settings::CtFFTSettings;
use crate::types::fr::CtFr;
use crate::types::poly::CtPoly;
#[cfg(feature = "parallel")]
use rayon::prelude::*;
use smallvec::{smallvec, SmallVec};
// Can be tuned & optimized (must be a power of 2)
const DEGREE_OF_PARTIAL: usize = 256;
// Can be tuned & optimized (but must be a power of 2)
const REDUCTION_FACTOR: usize = 4;
/// Pad given poly it with zeros to new length
pub fn pad_poly(mut poly: Vec<CtFr>, new_length: usize) -> Result<Vec<CtFr>, String> {
if new_length < poly.len() {
return Err(String::from(
"new_length must be longer or equal to poly length",
));
}
poly.resize(new_length, CtFr::zero());
Ok(poly)
}
/// Pad given poly coefficients it with zeros to new length
pub fn pad_poly_coeffs<const N: usize, T>(
mut coeffs: SmallVec<[T; N]>,
new_length: usize,
) -> Result<SmallVec<[T; N]>, String>
where
T: Default + Clone,
{
if new_length < coeffs.len() {
return Err(String::from(
"new_length must be longer or equal to coeffs length",
));
}
coeffs.resize(new_length, T::default());
Ok(coeffs)
}
impl CtFFTSettings {
fn do_zero_poly_mul_partial(
&self,
idxs: &[usize],
stride: usize,
) -> Result<SmallVec<[CtFr; DEGREE_OF_PARTIAL]>, String> {
if idxs.is_empty() {
return Err(String::from("idx array must not be empty"));
}
// Makes use of long multiplication in terms of (x - w_0)(x - w_1)..
let mut coeffs = SmallVec::<[CtFr; DEGREE_OF_PARTIAL]>::new();
// For the first member, store -w_0 as constant term
coeffs.push(self.roots_of_unity[idxs[0] * stride].negate());
for (i, idx) in idxs.iter().copied().enumerate().skip(1) {
// For member (x - w_i) take coefficient as -(w_i + w_{i-1} + ...)
let neg_di = self.roots_of_unity[idx * stride].negate();
coeffs.push(neg_di.add(&coeffs[i - 1]));
// Multiply all previous members by (x - w_i)
// It equals multiplying by - w_i and adding x^(i - 1) coefficient (implied multiplication by x)
for j in (1..i).rev() {
coeffs[j] = coeffs[j].mul(&neg_di).add(&coeffs[j - 1]);
}
// Multiply x^0 member by - w_i
coeffs[0] = coeffs[0].mul(&neg_di);
}
coeffs.resize(idxs.len() + 1, CtFr::one());
Ok(coeffs)
}
fn reduce_partials(
&self,
domain_size: usize,
partial_coeffs: SmallVec<[SmallVec<[CtFr; DEGREE_OF_PARTIAL]>; REDUCTION_FACTOR]>,
) -> Result<SmallVec<[CtFr; DEGREE_OF_PARTIAL]>, String> {
if !domain_size.is_power_of_two() {
return Err(String::from("Expected domain size to be a power of 2"));
}
if partial_coeffs.is_empty() {
return Err(String::from("partials must not be empty"));
}
// Calculate the resulting polynomial degree
// E.g. (a * x^n + ...) (b * x^m + ...) has a degree of x^(n+m)
let out_degree = partial_coeffs
.iter()
.map(|partial| {
// TODO: Not guaranteed by function signature that this doesn't underflow
partial.len() - 1
})
.sum::<usize>();
if out_degree + 1 > domain_size {
return Err(String::from(
"Out degree is longer than possible polynomial size in domain",
));
}
let mut partial_coeffs = partial_coeffs.into_iter();
// Pad all partial polynomials to same length, compute their FFT and multiply them together
let mut padded_partial = pad_poly_coeffs(
partial_coeffs
.next()
.expect("Not empty, checked above; qed"),
domain_size,
)?;
let mut eval_result: SmallVec<[CtFr; DEGREE_OF_PARTIAL]> =
smallvec![CtFr::zero(); domain_size];
self.fft_fr_output(&padded_partial, false, &mut eval_result)?;
for partial in partial_coeffs {
padded_partial = pad_poly_coeffs(partial, domain_size)?;
let mut evaluated_partial: SmallVec<[CtFr; DEGREE_OF_PARTIAL]> =
smallvec![CtFr::zero(); domain_size];
self.fft_fr_output(&padded_partial, false, &mut evaluated_partial)?;
eval_result
.iter_mut()
.zip(evaluated_partial.iter())
.for_each(|(eval_result, evaluated_partial)| {
*eval_result = eval_result.mul(evaluated_partial);
});
}
let mut coeffs = smallvec![CtFr::zero(); domain_size];
// Apply an inverse FFT to produce a new poly. Limit its size to out_degree + 1
self.fft_fr_output(&eval_result, true, &mut coeffs)?;
coeffs.truncate(out_degree + 1);
Ok(coeffs)
}
}
impl ZeroPoly<CtFr, CtPoly> for CtFFTSettings {
fn do_zero_poly_mul_partial(&self, idxs: &[usize], stride: usize) -> Result<CtPoly, String> {
self.do_zero_poly_mul_partial(idxs, stride)
.map(|coeffs| CtPoly {
coeffs: coeffs.into_vec(),
})
}
fn reduce_partials(&self, domain_size: usize, partials: &[CtPoly]) -> Result<CtPoly, String> {
self.reduce_partials(
domain_size,
partials
.iter()
.map(|partial| SmallVec::from_slice(&partial.coeffs))
.collect(),
)
.map(|coeffs| CtPoly {
coeffs: coeffs.into_vec(),
})
}
fn zero_poly_via_multiplication(
&self,
domain_size: usize,
missing_idxs: &[usize],
) -> Result<(Vec<CtFr>, CtPoly), String> {
let zero_eval: Vec<CtFr>;
let mut zero_poly: CtPoly;
if missing_idxs.is_empty() {
zero_eval = Vec::new();
zero_poly = CtPoly { coeffs: Vec::new() };
return Ok((zero_eval, zero_poly));
}
if missing_idxs.len() >= domain_size {
return Err(String::from("Missing idxs greater than domain size"));
} else if domain_size > self.max_width {
return Err(String::from(
"Domain size greater than fft_settings.max_width",
));
} else if !domain_size.is_power_of_two() {
return Err(String::from("Domain size must be a power of 2"));
}
let missing_per_partial = DEGREE_OF_PARTIAL - 1; // Number of missing idxs needed per partial
let domain_stride = self.max_width / domain_size;
let mut partial_count = 1 + (missing_idxs.len() - 1) / missing_per_partial; // TODO: explain why -1 is used here
let next_pow: usize = next_pow_of_2(partial_count * DEGREE_OF_PARTIAL);
let domain_ceiling = min(next_pow, domain_size);
// Calculate zero poly
if missing_idxs.len() <= missing_per_partial {
// When all idxs fit into a single multiplication
zero_poly = CtPoly {
coeffs: self
.do_zero_poly_mul_partial(missing_idxs, domain_stride)?
.into_vec(),
};
} else {
// Otherwise, construct a set of partial polynomials
// Save all constructed polynomials in a shared 'work' vector
let mut work = vec![CtFr::zero(); next_pow];
let mut partial_lens = vec![DEGREE_OF_PARTIAL; partial_count];
#[cfg(not(feature = "parallel"))]
let iter = missing_idxs
.chunks(missing_per_partial)
.zip(work.chunks_exact_mut(DEGREE_OF_PARTIAL));
#[cfg(feature = "parallel")]
let iter = missing_idxs
.par_chunks(missing_per_partial)
.zip(work.par_chunks_exact_mut(DEGREE_OF_PARTIAL));
// Insert all generated partial polynomials at degree_of_partial intervals in work vector
iter.for_each(|(missing_idxs, work)| {
let partial_coeffs = self
.do_zero_poly_mul_partial(missing_idxs, domain_stride)
.expect("`missing_idxs` is guaranteed to not be empty; qed");
let partial_coeffs = pad_poly_coeffs(partial_coeffs, DEGREE_OF_PARTIAL).expect(
"`partial.coeffs.len()` (same as `missing_idxs.len() + 1`) is \
guaranteed to be at most `degree_of_partial`; qed",
);
work[..DEGREE_OF_PARTIAL].copy_from_slice(&partial_coeffs);
});
// Adjust last length to match its actual length
partial_lens[partial_count - 1] =
1 + missing_idxs.len() - (partial_count - 1) * missing_per_partial;
// Reduce all vectors into one by reducing them w/ varying size multiplications
while partial_count > 1 {
let reduced_count = 1 + (partial_count - 1) / REDUCTION_FACTOR;
let partial_size = next_pow_of_2(partial_lens[0]);
// Step over polynomial space and produce larger multiplied polynomials
for i in 0..reduced_count {
let start = i * REDUCTION_FACTOR;
let out_end = min((start + REDUCTION_FACTOR) * partial_size, domain_ceiling);
let reduced_len = min(out_end - start * partial_size, domain_size);
let partials_num = min(REDUCTION_FACTOR, partial_count - start);
// Calculate partial views from lens and offsets
// Also update offsets to match current iteration
let partial_offset = start * partial_size;
let mut partial_coeffs = SmallVec::new();
for (partial_offset, partial_len) in (partial_offset..)
.step_by(partial_size)
.zip(partial_lens.iter().skip(i).copied())
.take(partials_num)
{
// We know the capacity required in `reduce_partials()` call below to avoid
// re-allocation
let mut coeffs = SmallVec::with_capacity(reduced_len);
coeffs.extend_from_slice(&work[partial_offset..][..partial_len]);
partial_coeffs.push(coeffs);
}
if partials_num > 1 {
let mut reduced_coeffs =
self.reduce_partials(reduced_len, partial_coeffs)?;
// Update partial length to match its length after reduction
partial_lens[i] = reduced_coeffs.len();
reduced_coeffs =
pad_poly_coeffs(reduced_coeffs, partial_size * partials_num)?;
work[partial_offset..][..reduced_coeffs.len()]
.copy_from_slice(&reduced_coeffs);
} else {
// Instead of keeping track of remaining polynomials, reuse i'th partial for start'th one
partial_lens[i] = partial_lens[start];
}
}
// Number of steps done equals the number of polynomials that we still need to reduce together
partial_count = reduced_count;
}
zero_poly = CtPoly { coeffs: work };
}
// Pad resulting poly to expected
match zero_poly.coeffs.len().cmp(&domain_size) {
Ordering::Less => {
zero_poly.coeffs = pad_poly(zero_poly.coeffs, domain_size)?;
}
Ordering::Equal => {}
Ordering::Greater => {
zero_poly.coeffs.truncate(domain_size);
}
}
// Evaluate calculated poly
zero_eval = self.fft_fr(&zero_poly.coeffs, false)?;
Ok((zero_eval, zero_poly))
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
grandinetech/rust-kzg | https://github.com/grandinetech/rust-kzg/blob/d47acbdf587753f466a5e6842395e03930ae1f96/constantine/src/data_availability_sampling.rs | constantine/src/data_availability_sampling.rs | //blst_fp = bls12_381_fp, CtG1 = CtG1, blst_p1 = bls12_381_g1_jacbls12_381_g1_jac
extern crate alloc;
use alloc::string::String;
use alloc::vec::Vec;
use core::cmp::Ordering;
use kzg::{DASExtension, Fr};
use crate::types::fft_settings::CtFFTSettings;
use crate::types::fr::CtFr;
// TODO: explain algo
impl CtFFTSettings {
pub fn das_fft_extension_stride(&self, evens: &mut [CtFr], stride: usize) {
match evens.len().cmp(&2) {
Ordering::Less => {
return;
}
Ordering::Equal => {
let x = evens[0].add(&evens[1]);
let y = evens[0].sub(&evens[1]);
let y_times_root = y.mul(&self.roots_of_unity[stride]);
evens[0] = x.add(&y_times_root);
evens[1] = x.sub(&y_times_root);
return;
}
Ordering::Greater => {}
}
let half: usize = evens.len() / 2;
for i in 0..half {
let tmp1 = evens[i].add(&evens[half + i]);
let tmp2 = evens[i].sub(&evens[half + i]);
evens[half + i] = tmp2.mul(&self.reverse_roots_of_unity[i * 2 * stride]);
evens[i] = tmp1;
}
#[cfg(feature = "parallel")]
{
if evens.len() > 32 {
let (lo, hi) = evens.split_at_mut(half);
rayon::join(
|| self.das_fft_extension_stride(hi, stride * 2),
|| self.das_fft_extension_stride(lo, stride * 2),
);
} else {
// Recurse
self.das_fft_extension_stride(&mut evens[..half], stride * 2);
self.das_fft_extension_stride(&mut evens[half..], stride * 2);
}
}
#[cfg(not(feature = "parallel"))]
{
// Recurse
self.das_fft_extension_stride(&mut evens[..half], stride * 2);
self.das_fft_extension_stride(&mut evens[half..], stride * 2);
}
for i in 0..half {
let x = evens[i];
let y = evens[half + i];
let y_times_root: CtFr = y.mul(&self.roots_of_unity[(1 + 2 * i) * stride]);
evens[i] = x.add(&y_times_root);
evens[half + i] = x.sub(&y_times_root);
}
}
}
impl DASExtension<CtFr> for CtFFTSettings {
/// Polynomial extension for data availability sampling. Given values of even indices, produce values of odd indices.
/// FFTSettings must hold at least 2 times the roots of provided evens.
/// The resulting odd indices make the right half of the coefficients of the inverse FFT of the combined indices zero.
fn das_fft_extension(&self, evens: &[CtFr]) -> Result<Vec<CtFr>, String> {
if evens.is_empty() {
return Err(String::from("A non-zero list ab expected"));
} else if !evens.len().is_power_of_two() {
return Err(String::from("A list with power-of-two length expected"));
} else if evens.len() * 2 > self.max_width {
return Err(String::from(
"Supplied list is longer than the available max width",
));
}
// In case more roots are provided with fft_settings, use a larger stride
let stride = self.max_width / (evens.len() * 2);
let mut odds = evens.to_vec();
self.das_fft_extension_stride(&mut odds, stride);
// TODO: explain why each odd member is multiplied by euclidean inverse of length
let mut inv_len = CtFr::from_u64(odds.len() as u64);
inv_len = inv_len.eucl_inverse();
let odds = odds.iter().map(|f| f.mul(&inv_len)).collect();
Ok(odds)
}
}
| rust | Apache-2.0 | d47acbdf587753f466a5e6842395e03930ae1f96 | 2026-01-04T20:22:26.256259Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.