feat (kzg): v36 rust-kzg diff - Don't merge

Cargo.toml

@@ -22,3 +22,6 @@ debug = true
 [profile.ethtests]
 inherits = "test"
 opt-level = 3
+
+[patch.crates-io]
+blst = { git = "https://github.com/CeciliaZ030/blst.git", branch = "v0.3.12-serialize" }

README.md

@@ -52,7 +52,7 @@ cd revm
 cargo build --release
 ```
 
-**_Note:_** `clang` is required for building revm with `c-kzg` or `secp256k1` feature flags as they depend on `C` libraries. If you don't have it installed, you can install it with `apt install clang`.
+**_Note:_** `clang` is required for building revm with ~~`c-kzg`~~ or `secp256k1` feature flags as they depend on `C` libraries. If you don't have it installed, you can install it with `apt install clang`.
 
 # Running eth tests
 

crates/interpreter/Cargo.toml

@@ -52,7 +52,6 @@ hashbrown = ["revm-primitives/hashbrown"]
 serde = ["dep:serde", "revm-primitives/serde"]
 arbitrary = ["std", "revm-primitives/arbitrary"]
 asm-keccak = ["revm-primitives/asm-keccak"]
-portable = ["revm-primitives/portable"]
 parse = ["dep:paste", "dep:phf"]
 
 taiko = ["revm-primitives/taiko"]

crates/precompile/CHANGELOG.md

@@ -125,8 +125,8 @@ Full git log:
 date 28.09.2023
 
  Summary:
- * Cancun EIP-4844 precompile. It is behind `c-kzg` that is enabled by default
-    the reason is that c-kzg fails to build on wasm and some docker images.
+ * Cancun EIP-4844 precompile. It is behind `kzg` that is enabled by default
+    ~~the reason is that c-kzg fails to build on wasm and some docker images.~~
  * no_std support
  * small fixes to return out of gas for modepx and pairing precompiles.
 

crates/precompile/Cargo.toml

@@ -25,41 +25,39 @@ revm-primitives = { path = "../primitives", version = "4.0.0", default-features
 bn = { package = "substrate-bn", version = "0.6", default-features = false }
 once_cell = { version = "1.19", default-features = false, features = ["alloc"] }
 ripemd = { version = "0.1", default-features = false }
-sha2 = { version = "0.10", default-features = false }
+# sha2 = { version = "0.10", default-features = false }
+sha2 = { git = "https://github.com/sp1-patches/RustCrypto-hashes", branch = "patch-v0.10.8" }
+
 # modexp precompile
 aurora-engine-modexp = { version = "1.1", default-features = false }
 
 # Optional KZG point evaluation precompile
-c-kzg = { git = "https://github.com/brechtpd/c-kzg-4844", branch = "for-alpha7", default-features = false, optional = true, features = [
-    "preload-kzg-settings",
-    "no-threads",
-]}
+rust-kzg-zkcrypto = { git = "https://github.com/CeciliaZ030/rust-kzg.git", branch = "sp1-patch", default-features = false, optional = true }
+kzg = { git = "https://github.com/CeciliaZ030/rust-kzg.git", branch = "sp1-patch",default-features = false, optional = true }
+
 
 # ecRecover precompile
 k256 = { version = "0.13.3", default-features = false, features = ["ecdsa"] }
-secp256k1 = { version = "0.29", default-features = false, features = [
-    "alloc",
-    "recovery",
-    "rand",
+secp256k1 = { version = "0.29", default-features = false, optional = true, features = [
     "global-context",
-], optional = true }
+    "recovery",
+] }
 
 # BLS12-381 precompiles
-blst = { version = "0.3.11", optional = true }
+blst = { version = "0.3.12", optional = true }
 
 [dev-dependencies]
 criterion = { version = "0.5" }
 rand = { version = "0.8", features = ["std"] }
 
 [features]
-default = ["std", "c-kzg", "secp256k1", "portable", "blst"]
+default = ["std", "c-kzg", "secp256k1", "blst"]
 std = [
     "revm-primitives/std",
     "k256/std",
     "once_cell/std",
     "ripemd/std",
     "sha2/std",
-    "c-kzg?/std",
     "secp256k1?/std",
 ]
 hashbrown = ["revm-primitives/hashbrown"]
@@ -78,8 +76,8 @@ negate-taiko-default-handler = [
 # These libraries may not work on all no_std platforms as they depend on C.
 
 # Enables the KZG point evaluation precompile.
-c-kzg = ["dep:c-kzg", "revm-primitives/c-kzg"]
-portable = ["revm-primitives/portable", "c-kzg?/portable"]
+c-kzg = ["dep:kzg", "dep:rust-kzg-zkcrypto", "revm-primitives/c-kzg"]
+
 
 # Use `secp256k1` as a faster alternative to `k256`.
 # The problem that `secp256k1` has is it fails to build for `wasm` target on Windows and Mac as it is c lib.

crates/precompile/src/kzg_point_evaluation.rs

@@ -1,6 +1,9 @@
+use core::mem::MaybeUninit;
+
 use crate::{Address, Error, Precompile, PrecompileResult, PrecompileWithAddress};
-use c_kzg::{Bytes32, Bytes48, KzgProof, KzgSettings};
+use kzg::eip_4844::{Bytes32, Bytes48, C_KZG_RET_OK};
 use revm_primitives::{hex_literal::hex, Bytes, Env};
+use rust_kzg_zkcrypto::eip_4844::verify_kzg_proof;
 use sha2::{Digest, Sha256};
 
 pub const POINT_EVALUATION: PrecompileWithAddress =
@@ -48,9 +51,21 @@ pub fn run(input: &Bytes, gas_limit: u64, env: &Env) -> PrecompileResult {
     let z = as_bytes32(&input[32..64]);
     let y = as_bytes32(&input[64..96]);
     let proof = as_bytes48(&input[144..192]);
-    if !verify_kzg_proof(commitment, z, y, proof, env.cfg.kzg_settings.get()) {
-        return Err(Error::BlobVerifyKzgProofFailed);
-    }
+    let mut verified: MaybeUninit<bool> = MaybeUninit::uninit();
+
+    unsafe {
+        if verify_kzg_proof(
+            verified.as_mut_ptr(),
+            commitment,
+            z,
+            y,
+            proof,
+            env.cfg.kzg_settings.get(),
+        ) != C_KZG_RET_OK
+        {
+            return Err(Error::BlobVerifyKzgProofFailed);
+        }
+    };
     #[cfg(feature = "sp1-cycle-tracker")]
     println!("cycle-tracker-end: kzg");
 
@@ -66,17 +81,6 @@ pub fn kzg_to_versioned_hash(commitment: &[u8]) -> [u8; 32] {
     hash
 }
 
-#[inline]
-pub fn verify_kzg_proof(
-    commitment: &Bytes48,
-    z: &Bytes32,
-    y: &Bytes32,
-    proof: &Bytes48,
-    kzg_settings: &KzgSettings,
-) -> bool {
-    KzgProof::verify_kzg_proof(commitment, z, y, proof, kzg_settings).unwrap_or(false)
-}
-
 #[inline]
 #[track_caller]
 pub fn as_array<const N: usize>(bytes: &[u8]) -> &[u8; N] {
@@ -85,14 +89,14 @@ pub fn as_array<const N: usize>(bytes: &[u8]) -> &[u8; N] {
 
 #[inline]
 #[track_caller]
-pub fn as_bytes32(bytes: &[u8]) -> &Bytes32 {
+pub fn as_bytes32(bytes: &[u8]) -> *const Bytes32 {
     // SAFETY: `#[repr(C)] Bytes32([u8; 32])`
     unsafe { &*as_array::<32>(bytes).as_ptr().cast() }
 }
 
 #[inline]
 #[track_caller]
-pub fn as_bytes48(bytes: &[u8]) -> &Bytes48 {
+pub fn as_bytes48(bytes: &[u8]) -> *const Bytes48 {
     // SAFETY: `#[repr(C)] Bytes48([u8; 48])`
     unsafe { &*as_array::<48>(bytes).as_ptr().cast() }
 }

crates/precompile/src/lib.rs

@@ -135,7 +135,7 @@ impl Precompiles {
 
     /// Returns precompiles for Cancun spec.
     ///
-    /// If the `c-kzg` feature is not enabled KZG Point Evaluation precompile will not be included,
+    /// If the `kzg` feature is not enabled KZG Point Evaluation precompile will not be included,
     /// effectively making this the same as Berlin.
     pub fn cancun() -> &'static Self {
         static INSTANCE: OnceBox<Precompiles> = OnceBox::new();

crates/primitives/CHANGELOG.md

@@ -288,4 +288,4 @@ Changelog:
 # v1.0.0
 date: 29.01.2023
 
-Interpreter was extracted from main revm crate at the revm v3.0.0 version.
+Interpreter was extracted from main revm crate at the revm v3.0.0 version.

crates/primitives/Cargo.toml

@@ -30,11 +30,10 @@ auto_impl = "1.2"
 bitvec = { version = "1", default-features = false, features = ["alloc"] }
 bitflags = { version = "2.5.0", default-features = false }
 
-# For setting the CfgEnv KZGSettings. Enabled by c-kzg flag.
-c-kzg = { git = "https://github.com/brechtpd/c-kzg-4844", branch = "for-alpha7", default-features = false, optional = true, features = [
-    "preload-kzg-settings",
-    "no-threads",
-]}
+rust-kzg-zkcrypto = { git = "https://github.com/CeciliaZ030/rust-kzg.git", branch = "sp1-patch", default-features = false, optional = true }
+kzg = { git = "https://github.com/CeciliaZ030/rust-kzg.git", branch = "sp1-patch",  optional = true }
+
+
 once_cell = { version = "1.19", default-features = false, optional = true }
 
 # utility
@@ -53,7 +52,7 @@ serde = { version = "1.0", default-features = false, features = [
 hex = { version = "0.4", default-features = false }
 
 [features]
-default = ["std", "c-kzg", "portable"]
+default = ["std", "c-kzg"]
 std = [
     "serde?/std",
     "alloy-primitives/std",
@@ -69,11 +68,9 @@ serde = [
     "hashbrown/serde",
     "bitvec/serde",
     "bitflags/serde",
-    "c-kzg?/serde",
 ]
 arbitrary = ["std", "alloy-primitives/arbitrary", "bitflags/arbitrary"]
 asm-keccak = ["alloy-primitives/asm-keccak"]
-portable = ["c-kzg?/portable"]
 
 optimism = []
 taiko = []
@@ -100,4 +97,4 @@ optional_beneficiary_reward = []
 rand = ["alloy-primitives/rand"]
 
 # See comments in `revm-precompile`
-c-kzg = ["dep:c-kzg", "dep:once_cell", "dep:derive_more"]
+c-kzg = ["dep:kzg", "dep:rust-kzg-zkcrypto", "dep:once_cell", "dep:derive_more"]

crates/primitives/src/kzg.rs

@@ -1,9 +1,9 @@
 mod env_settings;
 mod trusted_setup_points;
 
-pub use c_kzg::KzgSettings;
 pub use env_settings::EnvKzgSettings;
+pub use kzg::eip_4844::CKZGSettings as KZGSettings;
 pub use trusted_setup_points::{
-    parse_kzg_trusted_setup, G1Points, G2Points, KzgErrors, BYTES_PER_G1_POINT, BYTES_PER_G2_POINT,
-    G1_POINTS, G2_POINTS, NUM_G1_POINTS, NUM_G2_POINTS,
+    parse_kzg_trusted_setup, G1Points, G2Points, KzgErrors, BYTES_PER_G1, BYTES_PER_G2,
+    NUM_G1_POINTS, NUM_G2_POINTS, G2_POINTS, G1_POINTS,
 };

crates/primitives/src/kzg/env_settings.rs

@@ -1,23 +1,33 @@
+
 use super::{
     trusted_setup_points::{G1_POINTS, G2_POINTS},
-    KzgSettings,
+    trusted_setup_points::KzgErrors, G1Points, G2Points, KZGSettings
+};
+use core::{
+    fmt,
+    hash::{Hash, Hasher},
+    mem::MaybeUninit,
+};
+use kzg::eip_4844::{
+    load_trusted_setup_rust, BYTES_PER_G1, BYTES_PER_G2, C_KZG_RET_OK, FIELD_ELEMENTS_PER_BLOB,
+    TRUSTED_SETUP_NUM_G2_POINTS,
 };
-use core::hash::{Hash, Hasher};
-use once_cell::race::OnceBox;
+use once_cell::{race::OnceBox, unsync::OnceCell};
+use rust_kzg_zkcrypto::eip_4844::load_trusted_setup;
 use std::{boxed::Box, sync::Arc};
 
 /// KZG Settings that allow us to specify a custom trusted setup.
 /// or use hardcoded default settings.
-#[derive(Debug, Clone, Default, Eq)]
+#[derive(Debug, Clone, Default)]
 pub enum EnvKzgSettings {
     /// Default mainnet trusted setup
     #[default]
     Default,
     /// Custom trusted setup.
-    Custom(Arc<c_kzg::KzgSettings>),
+    Custom(Arc<KZGSettings>),
 }
 
-// Implement PartialEq and Hash manually because `c_kzg::KzgSettings` does not implement them
+// Implement PartialEq and Hash manually because `KZGSettings` does not implement them
 impl PartialEq for EnvKzgSettings {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
@@ -28,6 +38,8 @@ impl PartialEq for EnvKzgSettings {
     }
 }
 
+impl Eq for EnvKzgSettings {}
+
 impl Hash for EnvKzgSettings {
     fn hash<H: Hasher>(&self, state: &mut H) {
         core::mem::discriminant(self).hash(state);
@@ -42,18 +54,35 @@ impl EnvKzgSettings {
     /// Return set KZG settings.
     ///
     /// In will initialize the default settings if it is not already loaded.
-    pub fn get(&self) -> &KzgSettings {
+    pub fn get(&self) -> &KZGSettings {
         match self {
             Self::Default => {
-                static DEFAULT: OnceBox<KzgSettings> = OnceBox::new();
+                static DEFAULT: OnceBox<KZGSettings> = OnceBox::new();
                 DEFAULT.get_or_init(|| {
-                    let settings =
-                        KzgSettings::load_trusted_setup(G1_POINTS.as_ref(), G2_POINTS.as_ref())
-                            .expect("failed to load default trusted setup");
-                    Box::new(settings)
+                    let mut kzg_settings = MaybeUninit::<KZGSettings>::uninit();
+                    unsafe {
+                        if load_trusted_setup(
+                            kzg_settings.as_mut_ptr(),
+                            G1_POINTS.as_ptr().cast(),
+                            G1_POINTS.len(),
+                            G2_POINTS.as_ptr().cast(),
+                            G2_POINTS.len(),
+                        ) != C_KZG_RET_OK
+                        {
+                            panic!("Failed to load default trusted setup");
+                        }
+                        Box::new(kzg_settings.assume_init())
+                    }
                 })
             }
             Self::Custom(settings) => settings,
         }
     }
 }
+
+
+#[test]
+fn test_load_trusted_setup() {
+    let kzg_env = EnvKzgSettings::default();
+    let settings = kzg_env.get();
+}

crates/primitives/src/kzg/trusted_setup_points.rs

@@ -2,33 +2,35 @@ use core::fmt;
 use derive_more::{AsMut, AsRef, Deref, DerefMut};
 use std::boxed::Box;
 
-pub use c_kzg::{BYTES_PER_G1_POINT, BYTES_PER_G2_POINT};
+pub use kzg::eip_4844::{
+    BYTES_PER_G1, BYTES_PER_G2, FIELD_ELEMENTS_PER_BLOB, TRUSTED_SETUP_NUM_G2_POINTS,
+};
 
 /// 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;
+pub const NUM_G2_POINTS: usize = TRUSTED_SETUP_NUM_G2_POINTS;
 
 /// A newtype over list of G1 point from kzg trusted setup.
 #[derive(Debug, Clone, PartialEq, AsRef, AsMut, Deref, DerefMut)]
 #[repr(transparent)]
-pub struct G1Points(pub [[u8; BYTES_PER_G1_POINT]; NUM_G1_POINTS]);
+pub struct G1Points(pub [[u8; BYTES_PER_G1]; NUM_G1_POINTS]);
 
 impl Default for G1Points {
     fn default() -> Self {
-        Self([[0; BYTES_PER_G1_POINT]; NUM_G1_POINTS])
+        Self([[0; BYTES_PER_G1]; NUM_G1_POINTS])
     }
 }
 
 /// A newtype over list of G2 point from kzg trusted setup.
 #[derive(Debug, Clone, Eq, PartialEq, AsRef, AsMut, Deref, DerefMut)]
 #[repr(transparent)]
-pub struct G2Points(pub [[u8; BYTES_PER_G2_POINT]; NUM_G2_POINTS]);
+pub struct G2Points(pub [[u8; BYTES_PER_G2]; NUM_G2_POINTS]);
 
 impl Default for G2Points {
     fn default() -> Self {
-        Self([[0; BYTES_PER_G2_POINT]; NUM_G2_POINTS])
+        Self([[0; BYTES_PER_G2]; NUM_G2_POINTS])
     }
 }
 
@@ -49,7 +51,7 @@ pub const G2_POINTS: &G2Points = {
 /// Parses the contents of a KZG trusted setup file into a list of G1 and G2 points.
 ///
 /// These can then be used to create a KZG settings object with
-/// [`KzgSettings::load_trusted_setup`](c_kzg::KzgSettings::load_trusted_setup).
+/// [`KzgSettings::load_trusted_setup`](KZGSettings::load_trusted_setup).
 pub fn parse_kzg_trusted_setup(
     trusted_setup: &str,
 ) -> Result<(Box<G1Points>, Box<G2Points>), KzgErrors> {