chore(deps): c-kzg 2.0

Cargo.toml

@@ -96,7 +96,7 @@ tree_hash = "0.9.1"
 tree_hash_derive = "0.9.1"
 
 # crypto
-c-kzg = { version = "1.0", default-features = false }
+c-kzg = { version = "2.0", default-features = false }
 elliptic-curve = { version = "0.13", default-features = false }
 k256 = { version = "0.13", default-features = false, features = ["ecdsa"] }
 sha2 = { version = "0.10", default-features = false }

crates/eips/src/eip4844/builder.rs

@@ -383,8 +383,8 @@ impl<T: SidecarCoder> SidecarBuilder<T> {
         for blob in &self.inner.blobs {
             // SAFETY: same size
             let blob = unsafe { core::mem::transmute::<&Blob, &c_kzg::Blob>(blob) };
-            let commitment = KzgCommitment::blob_to_kzg_commitment(blob, settings)?;
-            let proof = KzgProof::compute_blob_kzg_proof(blob, &commitment.to_bytes(), settings)?;
+            let commitment = settings.blob_to_kzg_commitment(blob)?;
+            let proof = settings.compute_blob_kzg_proof(blob, &commitment.to_bytes())?;
 
             // SAFETY: same size
             unsafe {

crates/eips/src/eip4844/env_settings.rs

@@ -45,8 +45,10 @@ impl EnvKzgSettings {
         match self {
             Self::Default => {
                 let load = || {
-                    KzgSettings::load_trusted_setup(&G1_POINTS.0, &G2_POINTS.0)
-                        .expect("failed to load default trusted setup")
+                    // FIXME
+                    // KzgSettings::load_trusted_setup(&G1_POINTS.0, &G2_POINTS.0)
+                    //     .expect("failed to load default trusted setup")
+                    todo!()
                 };
                 #[cfg(feature = "std")]
                 {
@@ -71,7 +73,9 @@ impl EnvKzgSettings {
     pub fn load_from_trusted_setup_file(
         trusted_setup_file: &std::path::Path,
     ) -> Result<Self, c_kzg::Error> {
-        let settings = KzgSettings::load_trusted_setup_file(trusted_setup_file)?;
+        // FIXME: Precompute value??
+        let precompute = 0;
+        let settings = KzgSettings::load_trusted_setup_file(trusted_setup_file, precompute)?;
         Ok(Self::Custom(Arc::new(settings)))
     }
 }

crates/eips/src/eip4844/sidecar.rs

@@ -143,7 +143,8 @@ impl BlobTransactionSidecarItem {
         let proof = c_kzg::Bytes48::from_bytes(self.kzg_proof.as_slice())
             .map_err(BlobTransactionValidationError::KZGError)?;
 
-        let result = c_kzg::KzgProof::verify_blob_kzg_proof(&blob, &commitment, &proof, settings)
+        let result = settings
+            .verify_blob_kzg_proof(&blob, &commitment, &proof)
             .map_err(BlobTransactionValidationError::KZGError)?;
 
         result.then_some(()).ok_or(BlobTransactionValidationError::InvalidProof)
@@ -269,14 +270,13 @@ impl BlobTransactionSidecar {
 
         // SAFETY: ALL types have the same size
         let res = unsafe {
-            c_kzg::KzgProof::verify_blob_kzg_proof_batch(
+            proof_settings.verify_blob_kzg_proof_batch(
                 // blobs
                 core::mem::transmute::<&[Blob], &[c_kzg::Blob]>(self.blobs.as_slice()),
                 // commitments
                 core::mem::transmute::<&[Bytes48], &[c_kzg::Bytes48]>(self.commitments.as_slice()),
                 // proofs
                 core::mem::transmute::<&[Bytes48], &[c_kzg::Bytes48]>(self.proofs.as_slice()),
-                proof_settings,
             )
         }
         .map_err(BlobTransactionValidationError::KZGError)?;
@@ -346,16 +346,17 @@ impl BlobTransactionSidecar {
         let commitments = blobs
             .iter()
             .map(|blob| {
-                KzgCommitment::blob_to_kzg_commitment(&blob.clone(), kzg_settings.get())
-                    .map(|blob| blob.to_bytes())
+                kzg_settings.get().blob_to_kzg_commitment(&blob.clone()).map(|blob| blob.to_bytes())
             })
             .collect::<Result<Vec<_>, _>>()?;
 
         let proofs = blobs
             .iter()
             .zip(commitments.iter())
             .map(|(blob, commitment)| {
-                KzgProof::compute_blob_kzg_proof(blob, commitment, kzg_settings.get())
+                kzg_settings
+                    .get()
+                    .compute_blob_kzg_proof(blob, commitment)
                     .map(|blob| blob.to_bytes())
             })
             .collect::<Result<Vec<_>, _>>()?;

crates/eips/src/eip4844/trusted_setup_points.rs

@@ -3,10 +3,12 @@ use alloy_primitives::hex;
 use core::fmt;
 use derive_more::{AsMut, AsRef, Deref, DerefMut};
 
-pub use c_kzg::{BYTES_PER_G1_POINT, BYTES_PER_G2_POINT};
+pub use c_kzg::{BYTES_PER_COMMITMENT as BYTES_PER_G1_POINT, FIELD_ELEMENTS_PER_BLOB};
+
+pub const BYTES_PER_G2_POINT: usize = 96;
 
 /// Number of G1 Points.
-pub const NUM_G1_POINTS: usize = 4096;
+pub const NUM_G1_POINTS: usize = FIELD_ELEMENTS_PER_BLOB;
 
 /// Number of G2 Points.
 pub const NUM_G2_POINTS: usize = 65;