chore(client + ci): precompile annotation checks (#390)

* chore: kzg_eval precompile

* feat: bump to revm_precompile 0.16.1

* wip

* chore: precompile

* works

* add

* addgs

* ci.yaml

* remove unnecessary tests

* ci

* add

* range elf

* add

Author: ratankaliani

.github/workflows/ci.yaml

@@ -0,0 +1,37 @@
+name: Cargo Tests
+
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+
+jobs:
+  tests:
+    runs-on:
+      - runs-on
+      - runner=64cpu-linux-x64
+      - run-id=${{ github.run_id }} 
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    - run: rustup toolchain install stable --profile minimal
+    - uses: Swatinem/rust-cache@v2
+    - name: Check
+      run: cargo check --release    
+    - name: Build
+      run: cargo build --release
+    - name: Test
+      run: cargo test --release
+      env:
+        L2_NODE_RPC: ${{ secrets.L2_NODE_RPC }}
+        L1_RPC: ${{ secrets.L1_RPC }}
+        L1_BEACON_RPC: ${{ secrets.L1_BEACON_RPC }}
+        L2_RPC: ${{ secrets.L2_RPC }}
+        REPO_OWNER: ${{ github.repository_owner }}
+        REPO_NAME: ${{ github.event.repository.name }}
+        PR_NUMBER: ${{ github.event.pull_request.number }}
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        POST_TO_GITHUB: ${{ github.event_name == 'pull_request' }}

.github/workflows/compile.yaml

@@ -22,25 +22,11 @@ jobs:
       - name: Setup CI
         uses: ./.github/actions/setup
 
-      - name: OP Sepolia cost estimator on recent block range
+      - name: Run cost estimator on recent block range
         run: |
           RUST_LOG=info cargo run --bin cost-estimator --release -- --rolling
         env:
           L2_NODE_RPC: ${{ secrets.L2_NODE_RPC }}
           L1_RPC: ${{ secrets.L1_RPC }}
           L1_BEACON_RPC: ${{ secrets.L1_BEACON_RPC }}
           L2_RPC: ${{ secrets.L2_RPC }}
-
-      - name: Run multi script
-        run: |
-          cargo test --test "multi" --release
-        env:
-          L2_NODE_RPC: ${{ secrets.L2_NODE_RPC }}
-          L1_RPC: ${{ secrets.L1_RPC }}
-          L1_BEACON_RPC: ${{ secrets.L1_BEACON_RPC }}
-          L2_RPC: ${{ secrets.L2_RPC }}
-          REPO_OWNER: ${{ github.repository_owner }}
-          REPO_NAME: ${{ github.event.repository.name }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          POST_TO_GITHUB: ${{ github.event_name == 'pull_request' }}

.github/workflows/integration-tests.yml

@@ -102,7 +102,7 @@ maili-registry = { version = "0.2.6", default-features = false }
 maili-genesis = { version = "0.2.6", default-features = false }
 
 # Revm
-revm = { version = "19.4.0", default-features = false, features = ["kzg-rs"] }
+revm = { version = "19.5.0", default-features = false, features = ["kzg-rs"] }
 
 # SP1
 sp1-lib = { version = "4.1.0", features = ["verify"] }

Cargo.lock

@@ -35,20 +35,30 @@ macro_rules! create_annotated_precompile {
     };
 }
 
-pub(crate) const ANNOTATED_BN_ADD: PrecompileWithAddress =
-    create_annotated_precompile!(bn128::add::ISTANBUL, "bn-add");
-pub(crate) const ANNOTATED_BN_MUL: PrecompileWithAddress =
-    create_annotated_precompile!(bn128::mul::ISTANBUL, "bn-mul");
-pub(crate) const ANNOTATED_BN_PAIR: PrecompileWithAddress =
-    create_annotated_precompile!(bn128::pair::ISTANBUL, "bn-pair");
-pub(crate) const ANNOTATED_KZG_EVAL: PrecompileWithAddress = create_annotated_precompile!(
-    revm::precompile::kzg_point_evaluation::POINT_EVALUATION,
-    "kzg-eval"
-);
-pub(crate) const ANNOTATED_EC_RECOVER: PrecompileWithAddress =
-    create_annotated_precompile!(revm::precompile::secp256k1::ECRECOVER, "ec-recover");
-pub(crate) const ANNOTATED_P256_VERIFY: PrecompileWithAddress =
-    create_annotated_precompile!(revm::precompile::secp256r1::P256VERIFY, "p256-verify");
+/// Tuples of the original and annotated precompiles.
+// TODO: Add kzg_point_evaluation once it has standard precompile support in revm-precompile 0.17.0.
+const PRECOMPILES: &[(PrecompileWithAddress, PrecompileWithAddress)] = &[
+    (
+        bn128::add::ISTANBUL,
+        create_annotated_precompile!(bn128::add::ISTANBUL, "bn-add"),
+    ),
+    (
+        bn128::mul::ISTANBUL,
+        create_annotated_precompile!(bn128::mul::ISTANBUL, "bn-mul"),
+    ),
+    (
+        bn128::pair::ISTANBUL,
+        create_annotated_precompile!(bn128::pair::ISTANBUL, "bn-pair"),
+    ),
+    (
+        revm::precompile::secp256k1::ECRECOVER,
+        create_annotated_precompile!(revm::precompile::secp256k1::ECRECOVER, "ec-recover"),
+    ),
+    (
+        revm::precompile::secp256r1::P256VERIFY,
+        create_annotated_precompile!(revm::precompile::secp256r1::P256VERIFY, "p256-verify"),
+    ),
+];
 
 // Source: https://github.com/anton-rs/kona/blob/main/bin/client/src/fault/handler/mod.rs#L20-L42
 pub fn zkvm_handle_register<F, H>(handler: &mut EvmHandler<'_, (), &mut State<&mut TrieDB<F, H>>>)
@@ -62,19 +72,25 @@ where
         let mut ctx_precompiles = spec_to_generic!(spec_id, {
             revm::optimism::load_precompiles::<SPEC, (), &mut State<&mut TrieDB<F, H>>>()
         });
-
-        // Extend with ZKVM-accelerated precompiles and annotated precompiles that track the
-        // cycle count.
-        let override_precompiles = [
-            ANNOTATED_BN_ADD,
-            ANNOTATED_BN_MUL,
-            ANNOTATED_BN_PAIR,
-            ANNOTATED_KZG_EVAL,
-            ANNOTATED_EC_RECOVER,
-            ANNOTATED_P256_VERIFY,
-        ];
-        ctx_precompiles.extend(override_precompiles);
-
+        // Add the annotated precompiles.
+        ctx_precompiles.extend(PRECOMPILES.iter().map(|p| p.1.clone()).take(1));
         ctx_precompiles
     });
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_precompile_standard() {
+        // Check each precompile which was annotated is a standard precompile.
+        for precompile in PRECOMPILES {
+            assert!(
+                matches!(precompile.0 .1, Precompile::Standard(_)),
+                "{:?} is not a standard precompile",
+                precompile.0
+            );
+        }
+    }
+}

Cargo.toml

@@ -994,73 +994,3 @@ impl OPSuccinctDataFetcher {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::fetcher::OPSuccinctDataFetcher;
-    use crate::fetcher::RunContext;
-
-    #[tokio::test]
-    #[cfg(test)]
-    async fn test_get_l1_head() {
-        use alloy_eips::BlockId;
-
-        dotenv::dotenv().ok();
-        let fetcher = OPSuccinctDataFetcher::new_with_rollup_config(RunContext::Dev)
-            .await
-            .unwrap();
-        let latest_l2_block = fetcher.get_l2_header(BlockId::latest()).await.unwrap();
-
-        // Get the L2 block number from 1 hour ago.
-        let l2_end_block = latest_l2_block.number
-            - ((60 * 60) / fetcher.rollup_config.as_ref().unwrap().block_time);
-
-        let _ = fetcher.get_l1_head(l2_end_block).await.unwrap();
-    }
-
-    #[tokio::test]
-    #[cfg(test)]
-    async fn test_l2_safe_head_progression() {
-        use alloy_eips::BlockId;
-        use futures::StreamExt;
-        use maili_rpc::SafeHeadResponse;
-
-        use crate::fetcher::RPCMode;
-
-        dotenv::dotenv().ok();
-        let fetcher = OPSuccinctDataFetcher::new(RunContext::Dev);
-        let mut l2_safe_heads = Vec::new();
-
-        let latest_l1_block = fetcher.get_l1_header(BlockId::latest()).await.unwrap();
-        let latest_l1_block_number = latest_l1_block.number;
-        let l1_block_number_hex = format!("0x{:x}", latest_l1_block_number);
-        let _ = fetcher
-            .fetch_rpc_data_with_mode::<SafeHeadResponse>(
-                RPCMode::L2Node,
-                "optimism_safeHeadAtL1Block",
-                vec![l1_block_number_hex.into()],
-            )
-            .await
-            .unwrap();
-
-        let latest_l2_block = fetcher.get_l2_header(BlockId::latest()).await.unwrap();
-
-        let safe_heads =
-            futures::stream::iter(latest_l2_block.number - 500..=latest_l2_block.number)
-                .map(|block_num| {
-                    let l1_block_number_hex = format!("0x{:x}", block_num);
-                    fetcher.fetch_rpc_data_with_mode::<SafeHeadResponse>(
-                        RPCMode::L2Node,
-                        "optimism_safeHeadAtL1Block",
-                        vec![l1_block_number_hex.into()],
-                    )
-                })
-                .buffered(100)
-                .collect::<Vec<_>>()
-                .await;
-
-        for result in safe_heads.into_iter().flatten() {
-            l2_safe_heads.push(result.safe_head.number);
-        }
-    }
-}