fix precompile

Author: lightsing

Cargo.lock

@@ -1,36 +1,19 @@
 use crate::{EvmDatabase, VerificationError};
 use sbv_kv::KeyValueStoreGet;
-use sbv_precompile::PrecompileProvider;
 use sbv_primitives::{
     B256, Bytes,
     chainspec::ChainSpec,
     types::{
-        evm::precompiles::PrecompilesMap,
         reth::{
-            evm::{
-                ConfigureEvm, Database, EthEvm, EthEvmConfig, EvmEnv, EvmFactory,
-                eth::EthEvmContext,
-                execute::Executor,
-                revm::{
-                    Context, Inspector, MainBuilder, MainContext,
-                    context::{
-                        BlockEnv, CfgEnv, TxEnv,
-                        result::{EVMError, HaltReason},
-                    },
-                    inspector::NoOpInspector,
-                },
-            },
+            evm::{ConfigureEvm, EthEvmConfig, execute::Executor},
             execution_types::BlockExecutionOutput,
             primitives::{Block, Receipt, RecoveredBlock},
         },
-        revm::{SpecId, database::CacheDB, precompile::PrecompileSpecId},
+        revm::database::CacheDB,
     },
 };
 use std::sync::Arc;
 
-/// Ethereum-related EVM configuration with [`SbvEthEvmFactory`] as the factory.
-pub type EvmConfig = EthEvmConfig<ChainSpec, SbvEthEvmFactory>;
-
 /// EVM executor that handles the block.
 #[derive(Debug)]
 pub struct EvmExecutor<'a, CodeDb, BlockHashProvider> {
@@ -59,7 +42,7 @@ impl<CodeDb: KeyValueStoreGet<B256, Bytes>, BlockHashProvider: KeyValueStoreGet<
 {
     /// Handle the block with the given witness
     pub fn execute(self) -> Result<BlockExecutionOutput<Receipt>, VerificationError> {
-        let provider = EvmConfig::new_with_evm_factory(self.chain_spec.clone(), SbvEthEvmFactory);
+        let provider = EthEvmConfig::new(self.chain_spec.clone());
 
         let output = cycle_track!(
             provider.executor(CacheDB::new(self.db)).execute(self.block),
@@ -69,53 +52,3 @@ impl<CodeDb: KeyValueStoreGet<B256, Bytes>, BlockHashProvider: KeyValueStoreGet<
         Ok(output)
     }
 }
-
-/// Factory producing [`EthEvm`].
-#[derive(Debug, Default, Clone, Copy)]
-#[non_exhaustive]
-pub struct SbvEthEvmFactory;
-
-impl EvmFactory for SbvEthEvmFactory {
-    type Evm<DB: Database, I: Inspector<EthEvmContext<DB>>> = EthEvm<DB, I, Self::Precompiles>;
-    type Context<DB: Database> = Context<BlockEnv, TxEnv, CfgEnv, DB>;
-    type Tx = TxEnv;
-    type Error<DBError: core::error::Error + Send + Sync + 'static> = EVMError<DBError>;
-    type HaltReason = HaltReason;
-    type Spec = SpecId;
-    type Precompiles = PrecompilesMap;
-
-    fn create_evm<DB: Database>(&self, db: DB, input: EvmEnv) -> Self::Evm<DB, NoOpInspector> {
-        let spec_id = input.cfg_env.spec;
-        EthEvm::new(
-            Context::mainnet()
-                .with_block(input.block_env)
-                .with_cfg(input.cfg_env)
-                .with_db(db)
-                .build_mainnet_with_inspector(NoOpInspector {})
-                .with_precompiles(PrecompileProvider::with_spec(
-                    PrecompileSpecId::from_spec_id(spec_id),
-                )),
-            false,
-        )
-    }
-
-    fn create_evm_with_inspector<DB: Database, I: Inspector<Self::Context<DB>>>(
-        &self,
-        db: DB,
-        input: EvmEnv,
-        inspector: I,
-    ) -> Self::Evm<DB, I> {
-        let spec_id = input.cfg_env.spec;
-        EthEvm::new(
-            Context::mainnet()
-                .with_block(input.block_env)
-                .with_cfg(input.cfg_env)
-                .with_db(db)
-                .build_mainnet_with_inspector(inspector)
-                .with_precompiles(PrecompileProvider::with_spec(
-                    PrecompileSpecId::from_spec_id(spec_id),
-                )),
-            true,
-        )
-    }
-}

crates/core/src/executor/ethereum.rs

@@ -1,9 +1,9 @@
 #[cfg(not(feature = "scroll"))]
 mod ethereum;
 #[cfg(not(feature = "scroll"))]
-pub use ethereum::{EvmConfig, EvmExecutor, SbvEthEvmFactory};
+pub use ethereum::EvmExecutor;
 
 #[cfg(feature = "scroll")]
 mod scroll;
 #[cfg(feature = "scroll")]
-pub use scroll::{EvmConfig, EvmExecutor};
+pub use scroll::EvmExecutor;

crates/core/src/executor/mod.rs

@@ -5,19 +5,15 @@ use sbv_primitives::{
     chainspec::ChainSpec,
     types::{
         reth::{
-            evm::{ConfigureEvm, EthEvmConfig, RethReceiptBuilder},
+            evm::{ConfigureEvm, EthEvmConfig},
             execution_types::BlockExecutionOutput,
-            primitives::{Block, EthPrimitives, Receipt, RecoveredBlock},
+            primitives::{Block, Receipt, RecoveredBlock},
         },
         revm::database::CacheDB,
     },
 };
 use std::sync::Arc;
 
-/// Ethereum-related EVM configuration.
-pub type EvmConfig =
-    EthEvmConfig<ChainSpec, EthPrimitives, RethReceiptBuilder, sbv_precompile::PrecompileProvider>;
-
 /// EVM executor that handles the block.
 #[derive(Debug)]
 pub struct EvmExecutor<'a, CodeDb, BlockHashProvider, CompressionRatios> {
@@ -60,7 +56,7 @@ impl<
             revm::database::{State, states::bundle_state::BundleRetention},
         };
 
-        let provider = EvmConfig::new(self.chain_spec.clone(), Default::default());
+        let provider = EthEvmConfig::scroll(self.chain_spec.clone());
         let factory = provider.block_executor_factory();
 
         let mut db = State::builder()

crates/core/src/executor/scroll.rs

@@ -14,9 +14,7 @@ mod error;
 pub use error::VerificationError;
 
 mod executor;
-#[cfg(not(feature = "scroll"))]
-pub use executor::SbvEthEvmFactory;
-pub use executor::{EvmConfig, EvmExecutor};
+pub use executor::EvmExecutor;
 
 pub mod verifier;
 

crates/core/src/lib.rs

@@ -12,7 +12,6 @@ repository.workspace = true
 sbv-primitives = { workspace = true, features = ["evm-types", "revm-types"] }
 
 openvm-ecc-guest = { workspace = true, optional = true }
-openvm-keccak256 = { workspace = true, optional = true }
 openvm-k256 = { workspace = true, optional = true }
 openvm-sha2 = { workspace = true, optional = true }
 openvm-pairing = { workspace = true, optional = true }
@@ -41,31 +40,22 @@ ethereum-openvm = [
     "openvm-sha256",
 ]
 
-bn128 = [] # marker, won't be used in dependencies
 openvm-bn128 = [
-    "bn128",
     "dep:openvm-ecc-guest",
     "dep:openvm-pairing",
     "openvm-pairing/bn254",
 ]
 
-kzg = [] # marker, won't be used in dependencies
 openvm-kzg = [
-    "kzg",
     "dep:openvm-kzg",
 ]
 
-secp256k1 = [] # marker, won't be used in dependencies
 openvm-secp256k1 = [
-    "secp256k1",
     "dep:openvm-ecc-guest",
-    "dep:openvm-keccak256",
     "dep:openvm-k256",
 ]
 
-sha256 = []
 openvm-sha256 = [
-    "sha256",
     "dep:openvm-sha2"
 ]
 

crates/precompile/Cargo.toml

@@ -37,9 +37,9 @@ const G1_LEN: usize = 2 * FQ_LEN;
 #[inline]
 fn read_fq(input: &[u8]) -> Result<Fp, PrecompileError> {
     if input.len() < FQ_LEN {
-        Err(PrecompileError::Bn128FieldPointNotAMember)
+        Err(PrecompileError::Bn254FieldPointNotAMember)
     } else {
-        Fp::from_be_bytes(&input[..32]).ok_or(PrecompileError::Bn128FieldPointNotAMember)
+        Fp::from_be_bytes(&input[..32]).ok_or(PrecompileError::Bn254FieldPointNotAMember)
     }
 }
 
@@ -62,7 +62,7 @@ fn read_fq2(input: &[u8]) -> Result<Fp2, PrecompileError> {
 
 #[inline]
 fn new_g1_affine_point(px: Fp, py: Fp) -> Result<G1Affine, PrecompileError> {
-    G1Affine::from_xy(px, py).ok_or(PrecompileError::Bn128AffineGFailedToCreate)
+    G1Affine::from_xy(px, py).ok_or(PrecompileError::Bn254AffineGFailedToCreate)
 }
 
 /// Reads a G1 point from the input slice.
@@ -114,7 +114,7 @@ pub(super) fn read_g2_point(input: &[u8]) -> Result<G2Affine, PrecompileError> {
     let ba = read_fq2(&input[0..FQ2_LEN])?;
     let bb = read_fq2(&input[FQ2_LEN..2 * FQ2_LEN])?;
 
-    G2Affine::from_xy(ba, bb).ok_or(PrecompileError::Bn128AffineGFailedToCreate)
+    G2Affine::from_xy(ba, bb).ok_or(PrecompileError::Bn254AffineGFailedToCreate)
 }
 
 /// Reads a scalar from the input slice
@@ -153,22 +153,31 @@ pub(super) fn g1_point_mul(p: G1Affine, fr: Scalar) -> G1Affine {
 /// Note: If the input is empty, this function returns true.
 /// This is different to EIP2537 which disallows the empty input.
 #[inline]
-pub(super) fn pairing_check(pairs: &[(G1Affine, G2Affine)]) -> bool {
-    if pairs.is_empty() {
-        return true;
+pub(super) fn pairing_check(pairs: &[(&[u8], &[u8])]) -> Result<bool, PrecompileError> {
+    let mut g1_points = Vec::with_capacity(pairs.len());
+    let mut g2_points = Vec::with_capacity(pairs.len());
+
+    for (g1_bytes, g2_bytes) in pairs {
+        let g1_is_zero = g1_bytes.iter().all(|i| *i == 0);
+        let g2_is_zero = g2_bytes.iter().all(|i| *i == 0);
+
+        let g1 = read_g1_point(g1_bytes)?;
+        let g2 = read_g2_point(g2_bytes)?;
+
+        let (g1x, g1y) = g1.into_coords();
+        let (g2x, g2y) = g2.into_coords();
+
+        // Skip pairs where either point is at infinity
+        if !g1_is_zero && !g2_is_zero {
+            let g1 = AffinePoint::new(g1x, g1y);
+            let g2 = AffinePoint::new(g2x, g2y);
+            g1_points.push(g1);
+            g2_points.push(g2);
+        }
     }
-    let (g1_points, g2_points): (Vec<_>, Vec<_>) = pairs
-        .iter()
-        .cloned()
-        .map(|(g1, g2)| {
-            let (g1_x, g1_y) = g1.into_coords();
-            let g1 = AffinePoint::new(g1_x, g1_y);
-
-            let (g2_x, g2_y) = g2.into_coords();
-            let g2 = AffinePoint::new(g2_x, g2_y);
-            (g1, g2)
-        })
-        .unzip();
-
-    Bn254::pairing_check(&g1_points, &g2_points).is_ok()
+    if g1_points.is_empty() {
+        return Ok(true);
+    }
+
+    Ok(Bn254::pairing_check(&g1_points, &g2_points).is_ok())
 }