feat(blob-uploader): add arweave sender

.github/workflows/common.yml

@@ -41,7 +41,7 @@ jobs:
     - name: Cache cargo
       uses: Swatinem/rust-cache@v2
       with:
-        workspaces: ". -> target"
+        workspaces: "common/libzkp/impl -> target"
     # - name: Lint
     #   working-directory: 'common'
     #   run: |

.github/workflows/coordinator.yml

@@ -112,7 +112,7 @@ jobs:
     - name: Test coordinator packages
       working-directory: 'coordinator'
       run: |
-        make libzkp
+        # go test -exec "env LD_LIBRARY_PATH=${PWD}/verifier/lib" -v -race -gcflags="-l" -ldflags="-s=false" -coverpkg="scroll-tech/coordinator" -coverprofile=coverage.txt -covermode=atomic ./...
         go test -v -race -gcflags="-l" -ldflags="-s=false" -coverprofile=coverage.txt -covermode=atomic -tags mock_verifier ./...
     - name: Upload coverage reports to Codecov
       uses: codecov/codecov-action@v3

.github/workflows/integration.yml

@@ -38,7 +38,6 @@ jobs:
         make dev_docker
         make -C rollup mock_abi
         make -C common/bytecode all
-        make -C coordinator/internal/logic/libzkp build
     - name: Run integration tests
       run: |
         go test -v -tags="mock_prover mock_verifier" -p 1 -coverprofile=coverage.txt scroll-tech/integration-test/...

Cargo.toml

@@ -1,66 +0,0 @@
-[workspace]
-members = [
-  "crates/libzkp",
-  "crates/l2geth",
-  "crates/libzkp_c",
-  "crates/prover-bin",
-]
-
-resolver = "2"
-
-[workspace.package]
-authors = ["Scroll developers"]
-edition = "2021"
-homepage = "https://scroll.io"
-readme = "README.md"
-repository = "https://github.com/scroll-tech/scroll"
-version = "4.5.8"
-
-[workspace.dependencies]
-scroll-zkvm-prover-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "29c99de", package = "scroll-zkvm-prover" }
-scroll-zkvm-verifier-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "29c99de", package = "scroll-zkvm-verifier" }
-scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "29c99de" }
-
-sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "zkvm/euclid-upgrade", features = ["scroll"] }
-sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "zkvm/euclid-upgrade" }
-
-metrics = "0.23.0"
-metrics-util = "0.17"
-metrics-tracing-context = "0.16.0"
-
-anyhow = "1.0"
-alloy = { version = "0.11", default-features = false }
-alloy-primitives = { version = "0.8", default-features = false }
-# also use this to trigger "serde" feature for primitives
-alloy-serde = { version = "0.8", default-features = false }
-
-rkyv = "0.8"
-serde = { version = "1", default-features = false, features = ["derive"] }
-serde_json = { version = "1.0" }
-serde_derive = "1.0"
-serde_with = "3.11.0"
-itertools = "0.14"
-tiny-keccak = "2.0"
-tracing = "0.1"
-eyre = "0.6"
-bincode_v1 = { version = "1.3", package = "bincode"}
-snark-verifier-sdk = { version = "0.2.0", default-features = false, features = [
-    "loader_halo2",
-    "halo2-axiom",
-    "display",
-] }
-once_cell = "1.20"
-base64 = "0.22"
-
-#TODO: upgrade when Feynman
-vm-zstd = { git = "https://github.com/scroll-tech/rust-zstd-decompressor.git", tag = "v0.1.1" }
-
-[patch.crates-io]
-alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v0.8.18-euclid-upgrade" }
-ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.12.3" }
-tiny-keccak = { git = "https://github.com/scroll-tech/tiny-keccak", branch = "scroll-patch-v2.0.2-euclid-upgrade" }
-
-[profile.maxperf]
-inherits = "release"
-lto = "fat"
-codegen-units = 1

README.md

@@ -28,7 +28,7 @@ We welcome community contributions to this repository. Before you submit any iss
 
 ## Prerequisites
 + Go 1.21
-+ Rust (for version, see [rust-toolchain](./rust-toolchain))
++ Rust (for version, see [rust-toolchain](./common/libzkp/impl/rust-toolchain))
 + Hardhat / Foundry
 + Docker
 

bridge-history-api/go.mod

@@ -10,15 +10,15 @@ require (
 	github.com/go-redis/redis/v8 v8.11.5
 	github.com/pressly/goose/v3 v3.16.0
 	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250626101020-47bc86cd961c
+	github.com/scroll-tech/da-codec v0.1.3-0.20250226072559-f8a8d3898f54
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305084331-57148478e950
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7
 	golang.org/x/sync v0.11.0
 	gorm.io/gorm v1.25.7-0.20240204074919-46816ad31dde
 )
 
-replace github.com/scroll-tech/go-ethereum => github.com/scroll-tech/go-ethereum v1.10.14-0.20250626101020-47bc86cd961c // It's a hotfix for the header hash incompatibility issue, pls change this with caution
+replace github.com/scroll-tech/go-ethereum => github.com/scroll-tech/go-ethereum v1.10.14-0.20250305084331-57148478e950 // It's a hotfix for the header hash incompatibility issue, pls change this with caution
 
 require (
 	dario.cat/mergo v1.0.0 // indirect

bridge-history-api/go.sum

@@ -309,10 +309,10 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6 h1:vb2XLvQwCf+F/ifP6P/lfeiQrHY6+Yb/E3R4KHXLqSE=
-github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250626101020-47bc86cd961c h1:IpEBKM6O+xOK2qZVZztGxcobFXkKMb5hAkBEVzfXjVg=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250626101020-47bc86cd961c/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
+github.com/scroll-tech/da-codec v0.1.3-0.20250226072559-f8a8d3898f54 h1:qVpsVu1J91opTn6HYeuzWcBRVhQmPR8g05i+PlOjlI4=
+github.com/scroll-tech/da-codec v0.1.3-0.20250226072559-f8a8d3898f54/go.mod h1:xECEHZLVzbdUn+tNbRJhRIjLGTOTmnFQuTgUTeVLX58=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305084331-57148478e950 h1:qfOaRflvH1vtnFWloB7BveKlP/VqYgMqLJ6e9TlBJ/8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305084331-57148478e950/go.mod h1:OblWe1+QrZwdpwO0j/LY3BSGuKT3YPUFBDQQgvvfStQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys=

build/dockerfiles/coordinator-api.Dockerfile

@@ -3,13 +3,11 @@ FROM scrolltech/cuda-go-rust-builder:cuda-11.7.1-go-1.21-rust-nightly-2023-12-03
 WORKDIR app
 
 FROM chef as planner
-COPY ./crates ./
-COPY ./Cargo.* ./
-COPY ./rust-toolchain ./
+COPY ./common/libzkp/impl/ .
 RUN cargo chef prepare --recipe-path recipe.json
 
 FROM chef as zkp-builder
-COPY ./rust-toolchain ./
+COPY ./common/libzkp/impl/rust-toolchain ./
 COPY --from=planner /app/recipe.json recipe.json
 # run scripts to get openvm-gpu
 COPY ./build/dockerfiles/coordinator-api/plonky3-gpu /plonky3-gpu
@@ -19,9 +17,8 @@ COPY ./build/dockerfiles/coordinator-api/gitconfig /root/.gitconfig
 COPY ./build/dockerfiles/coordinator-api/config.toml /root/.cargo/config.toml
 RUN cargo chef cook --release --recipe-path recipe.json
 
-COPY ./crates ./
-COPY ./Cargo.* ./
-RUN cargo build --release -p libzkp-c
+COPY ./common/libzkp/impl .
+RUN cargo build --release
 
 
 # Download Go dependencies
@@ -40,9 +37,9 @@ RUN go mod download -x
 # Build coordinator
 FROM base as builder
 COPY . .
-COPY --from=zkp-builder /app/target/release/libzkp.so ./coordinator/internal/logic/libzkp/lib/
-RUN cd ./coordinator && CGO_LDFLAGS="-Wl,--no-as-needed -ldl" make coordinator_api && mv ./build/bin/coordinator_api /bin/coordinator_api
-RUN mv coordinator/internal/logic/libzkp/lib /bin/
+RUN cp -r ./common/libzkp/interface ./coordinator/internal/logic/verifier/lib
+COPY --from=zkp-builder /app/target/release/libzkp.so ./coordinator/internal/logic/verifier/lib/
+RUN cd ./coordinator && CGO_LDFLAGS="-Wl,--no-as-needed -ldl" make coordinator_api_skip_libzkp && mv ./build/bin/coordinator_api /bin/coordinator_api && mv internal/logic/verifier/lib /bin/
 
 # Pull coordinator into a second stage deploy ubuntu container
 FROM nvidia/cuda:11.7.1-runtime-ubuntu22.04

build/dockerfiles/prover.Dockerfile

@@ -18,6 +18,6 @@ RUN cd /src/zkvm-prover && make prover
 
 FROM ubuntu:24.04 AS runtime
 
-COPY --from=builder /src/target/release/prover /usr/local/bin/
+COPY --from=builder /src/zkvm-prover/target/release/prover /usr/local/bin/
 
 ENTRYPOINT ["prover"]

common/libzkp/e2e-test.sh

@@ -20,7 +20,7 @@ function build_test_bins() {
     cd $REPO/coordinator
     make libzkp
     go test -tags="gpu ffi" -timeout 0 -c ./internal/logic/verifier
-    cd $REPO/coordinator/internal/logic/libzkp
+    cd $REPO/common/libzkp
 }
 
 build_test_bins

common/libzkp/impl/Cargo.toml

@@ -1,3 +1,37 @@
+[package]
+name = "zkp"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+crate-type = ["cdylib"]
+
+[patch.crates-io]
+# patched add rkyv support & MSRV 1.77
+alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v0.8.21" }
+ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.12.3" }
+tiny-keccak = { git = "https://github.com/scroll-tech/tiny-keccak", branch = "scroll-patch-v2.0.2-openvm-v1.0.0-rc.1" }
+
+[dependencies]
+euclid_prover = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.4.2", package = "scroll-zkvm-prover" }
+euclid_verifier = { git = "https://github.com/scroll-tech/zkvm-prover.git", tag = "v0.4.2", package = "scroll-zkvm-verifier" }
+
+base64 = "0.13.0"
+env_logger = "0.9.0"
+libc = "0.2"
+log = "0.4"
+once_cell = "1.19"
+serde = "1.0"
+serde_derive = "1.0"
+serde_json = "1.0.66"
+anyhow = "1.0.86"
+
+[profile.test]
+opt-level = 3
+
+[profile.release]
+opt-level = 3
 
 [patch."https://github.com/openvm-org/stark-backend.git"]
 openvm-stark-backend = { git = "ssh://git@github.com/scroll-tech/openvm-stark-gpu.git", branch = "main", features = ["gpu"] }
@@ -29,4 +63,4 @@ p3-poseidon2-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", t
 p3-symmetric = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
 p3-uni-stark = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
 p3-maybe-rayon = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" } # the "parallel" feature is NOT on by default to allow single-threaded benchmarking
-p3-bn254-fr = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-bn254-fr = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }

common/libzkp/impl/Makefile

@@ -0,0 +1,11 @@
+.PHONY: help fmt clippy test test-ci test-all
+
+build:
+	@cargo build --release
+
+fmt:
+	@cargo fmt --all -- --check
+
+clippy:
+	@cargo check --all-features
+	@cargo clippy --release -- -D warnings

common/libzkp/impl/rust-toolchain

@@ -0,0 +1 @@
+nightly-2024-12-06

common/libzkp/impl/src/lib.rs

@@ -0,0 +1,76 @@
+mod utils;
+mod verifier;
+
+use std::path::Path;
+
+use crate::utils::{c_char_to_str, c_char_to_vec};
+use libc::c_char;
+use verifier::{TaskType, VerifierConfig};
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init(config: *const c_char) {
+    let config_str = c_char_to_str(config);
+    let verifier_config = serde_json::from_str::<VerifierConfig>(config_str).unwrap();
+    verifier::init(verifier_config);
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_chunk_proof(
+    proof: *const c_char,
+    fork_name: *const c_char,
+) -> c_char {
+    verify_proof(proof, fork_name, TaskType::Chunk)
+}
+
+fn verify_proof(proof: *const c_char, fork_name: *const c_char, task_type: TaskType) -> c_char {
+    let fork_name_str = c_char_to_str(fork_name);
+    let proof = c_char_to_vec(proof);
+    let verifier = verifier::get_verifier(fork_name_str);
+
+    if let Err(e) = verifier {
+        log::warn!("failed to get verifier, error: {:#}", e);
+        return 0 as c_char;
+    }
+    match verifier.unwrap().verify(task_type, proof) {
+        Err(e) => {
+            log::error!("{:?} verify failed, error: {:#}", task_type, e);
+            false as c_char
+        }
+        Ok(result) => result as c_char,
+    }
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_batch_proof(
+    proof: *const c_char,
+    fork_name: *const c_char,
+) -> c_char {
+    verify_proof(proof, fork_name, TaskType::Batch)
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn verify_bundle_proof(
+    proof: *const c_char,
+    fork_name: *const c_char,
+) -> c_char {
+    verify_proof(proof, fork_name, TaskType::Bundle)
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn dump_vk(fork_name: *const c_char, file: *const c_char) {
+    _dump_vk(fork_name, file);
+}
+
+fn _dump_vk(fork_name: *const c_char, file: *const c_char) {
+    let fork_name_str = c_char_to_str(fork_name);
+    let verifier = verifier::get_verifier(fork_name_str);
+
+    if let Ok(verifier) = verifier {
+        verifier.as_ref().dump_vk(Path::new(c_char_to_str(file)));
+    }
+}

common/libzkp/impl/src/utils.rs

@@ -0,0 +1,27 @@
+use std::{
+    ffi::CStr,
+    os::raw::c_char,
+    panic::{catch_unwind, AssertUnwindSafe},
+};
+
+pub(crate) fn c_char_to_str(c: *const c_char) -> &'static str {
+    let cstr = unsafe { CStr::from_ptr(c) };
+    cstr.to_str().unwrap()
+}
+
+pub(crate) fn c_char_to_vec(c: *const c_char) -> Vec<u8> {
+    let cstr = unsafe { CStr::from_ptr(c) };
+    cstr.to_bytes().to_vec()
+}
+
+pub(crate) fn panic_catch<F: FnOnce() -> R, R>(f: F) -> Result<R, String> {
+    catch_unwind(AssertUnwindSafe(f)).map_err(|err| {
+        if let Some(s) = err.downcast_ref::<String>() {
+            s.to_string()
+        } else if let Some(s) = err.downcast_ref::<&str>() {
+            s.to_string()
+        } else {
+            format!("unable to get panic info {err:?}")
+        }
+    })
+}

common/libzkp/impl/src/verifier.rs

@@ -1,8 +1,8 @@
 #![allow(static_mut_refs)]
 
 mod euclidv2;
+use anyhow::{bail, Result};
 use euclidv2::EuclidV2Verifier;
-use eyre::Result;
 use serde::{Deserialize, Serialize};
 use std::{cell::OnceCell, path::Path, rc::Rc};
 
@@ -13,16 +13,6 @@ pub enum TaskType {
     Bundle,
 }
 
-impl std::fmt::Display for TaskType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Chunk => write!(f, "chunk"),
-            Self::Batch => write!(f, "batch"),
-            Self::Bundle => write!(f, "bundle"),
-        }
-    }
-}
-
 #[derive(Debug, Serialize, Deserialize)]
 pub struct VKDump {
     pub chunk_vk: String,
@@ -71,8 +61,5 @@ pub fn get_verifier(fork_name: &str) -> Result<Rc<Box<dyn ProofVerifier>>> {
             }
         }
     }
-    Err(eyre::eyre!(
-        "failed to get verifier, key not found, {}",
-        fork_name
-    ))
+    bail!("failed to get verifier, key not found, {}", fork_name)
 }

common/libzkp/impl/src/verifier/euclidv2.rs

@@ -1,12 +1,10 @@
 use super::{ProofVerifier, TaskType, VKDump};
 
-use eyre::Result;
+use anyhow::Result;
 
-use crate::{
-    proofs::{AsRootProof, BatchProof, BundleProof, ChunkProof, IntoEvmProof},
-    utils::panic_catch,
-};
-use scroll_zkvm_verifier_euclid::verifier::{BatchVerifier, BundleVerifierEuclidV2, ChunkVerifier};
+use crate::utils::panic_catch;
+use euclid_prover::{BatchProof, BundleProof, ChunkProof};
+use euclid_verifier::verifier::{BatchVerifier, BundleVerifierEuclidV2, ChunkVerifier};
 use std::{fs::File, path::Path};
 
 pub struct EuclidV2Verifier {
@@ -37,29 +35,30 @@ impl ProofVerifier for EuclidV2Verifier {
         panic_catch(|| match task_type {
             TaskType::Chunk => {
                 let proof = serde_json::from_slice::<ChunkProof>(proof.as_slice()).unwrap();
-                self.chunk_verifier.verify_proof(proof.as_root_proof())
+                self.chunk_verifier
+                    .verify_proof(proof.proof.as_root_proof().unwrap())
             }
             TaskType::Batch => {
                 let proof = serde_json::from_slice::<BatchProof>(proof.as_slice()).unwrap();
-                self.batch_verifier.verify_proof(proof.as_root_proof())
+                self.batch_verifier
+                    .verify_proof(proof.proof.as_root_proof().unwrap())
             }
             TaskType::Bundle => {
                 let proof = serde_json::from_slice::<BundleProof>(proof.as_slice()).unwrap();
                 self.bundle_verifier
-                    .verify_proof_evm(&proof.into_evm_proof())
+                    .verify_proof_evm(&proof.proof.as_evm_proof().unwrap())
             }
         })
-        .map_err(|err_str: String| eyre::eyre!("{err_str}"))
+        .map_err(|err_str: String| anyhow::anyhow!(err_str))
     }
 
     fn dump_vk(&self, file: &Path) {
-        use base64::{prelude::BASE64_STANDARD, Engine};
         let f = File::create(file).expect("Failed to open file to dump VK");
 
         let dump = VKDump {
-            chunk_vk: BASE64_STANDARD.encode(self.chunk_verifier.get_app_vk()),
-            batch_vk: BASE64_STANDARD.encode(self.batch_verifier.get_app_vk()),
-            bundle_vk: BASE64_STANDARD.encode(self.bundle_verifier.get_app_vk()),
+            chunk_vk: base64::encode(self.chunk_verifier.get_app_vk()),
+            batch_vk: base64::encode(self.batch_verifier.get_app_vk()),
+            bundle_vk: base64::encode(self.bundle_verifier.get_app_vk()),
         };
         serde_json::to_writer(f, &dump).expect("Failed to dump VK");
     }

common/libzkp/interface/libzkp.h

@@ -0,0 +1,12 @@
+// BatchVerifier is used to:
+// - Verify a batch proof
+// - Verify a bundle proof
+void init(char* config);
+
+char verify_batch_proof(char* proof, char* fork_name);
+
+char verify_bundle_proof(char* proof, char* fork_name);
+
+char verify_chunk_proof(char* proof, char* fork_name);
+
+void dump_vk(char* fork_name, char* file);

common/version/version.go

@@ -5,7 +5,7 @@ import (
 	"runtime/debug"
 )
 
-var tag = "v4.5.25"
+var tag = "v4.5.24"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {
@@ -23,7 +23,7 @@ var commit = func() string {
 	return "000000"
 }()
 
-// ZkVersion is commit-id of cargo.lock/zkvm-prover and openvm, contacted by a "-"
+// ZkVersion is commit-id of common/libzkp/impl/cargo.lock/scroll-prover and halo2, contacted by a "-"
 // The default `000000-000000` is set for integration test, and will be overwritten by coordinator's & prover's actual compilations (see their Makefiles).
 var ZkVersion = "000000-000000"
 

coordinator/.gitignore

@@ -1,4 +1,3 @@
 /build/bin
 .idea
 internal/logic/verifier/lib
-internal/libzkp/lib/libzkp.so

coordinator/Makefile

@@ -2,30 +2,25 @@
 
 IMAGE_VERSION=latest
 REPO_ROOT_DIR=./..
-LIBZKP_PATH=./internal/logic/libzkp/lib/libzkp.so
 
 ifeq (4.3,$(firstword $(sort $(MAKE_VERSION) 4.3)))
-	ZKVM_VERSION=$(shell grep -m 1 "zkvm-prover?" ../Cargo.lock | cut -d "#" -f2 | cut -c-7)
-	OPENVM_VERSION=$(shell grep -m 1 "openvm.git" ../Cargo.lock | cut -d "#" -f2 | cut -c-7)
+	ZKEVM_VERSION=$(shell grep -m 1 "zkevm-circuits" ../common/libzkp/impl/Cargo.lock | cut -d "#" -f2 | cut -c-7)
+	HALO2_VERSION=$(shell grep -m 1 "halo2.git" ../common/libzkp/impl/Cargo.lock | cut -d "#" -f2 | cut -c-7)
 else
-	ZKVM_VERSION=$(shell grep -m 1 "zkvm-prover?" ../Cargo.lock | cut -d "\#" -f2 | cut -c-7)
-	OPENVM_VERSION=$(shell grep -m 1 "openvm.git" ../Cargo.lock | cut -d "\#" -f2 | cut -c-7)
+	ZKEVM_VERSION=$(shell grep -m 1 "zkevm-circuits" ../common/libzkp/impl/Cargo.lock | cut -d "\#" -f2 | cut -c-7)
+	HALO2_VERSION=$(shell grep -m 1 "halo2.git" ../common/libzkp/impl/Cargo.lock | cut -d "\#" -f2 | cut -c-7)
 endif
 
-ZK_VERSION=${ZKVM_VERSION}-${OPENVM_VERSION}
+ZK_VERSION=${ZKEVM_VERSION}-${HALO2_VERSION}
 
 test:
 	go test -v -race -coverprofile=coverage.txt -covermode=atomic -p 1 $(PWD)/...
 
-$(LIBZKP_PATH):
-	$(MAKE) -C ./internal/logic/libzkp build
+libzkp:
+	cd ../common/libzkp/impl && cargo clean && cargo build --release && cp ./target/release/libzkp.so ../interface/
+	rm -rf ./internal/logic/verifier/lib && cp -r ../common/libzkp/interface ./internal/logic/verifier/lib
 
-clean_libzkp:
-	$(MAKE) -C ./internal/logic/libzkp clean
-
-libzkp: clean_libzkp $(LIBZKP_PATH)
-
-coordinator_api: $(LIBZKP_PATH) ## Builds the Coordinator api instance.
+coordinator_api: libzkp ## Builds the Coordinator api instance.
 	go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -o $(PWD)/build/bin/coordinator_api ./cmd/api
 
 coordinator_cron:
@@ -34,8 +29,8 @@ coordinator_cron:
 coordinator_tool:
 	go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -o $(PWD)/build/bin/coordinator_tool ./cmd/tool
 
-#coordinator_api_skip_libzkp:
-#	go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -o $(PWD)/build/bin/coordinator_api ./cmd/api
+coordinator_api_skip_libzkp:
+	go build -ldflags "-X scroll-tech/common/version.ZkVersion=${ZK_VERSION}" -o $(PWD)/build/bin/coordinator_api ./cmd/api
 
 mock_coordinator_api: ## Builds the mocked Coordinator instance.
 	go build -tags="mock_prover mock_verifier" -o $(PWD)/build/bin/coordinator_api ./cmd/api
@@ -43,13 +38,14 @@ mock_coordinator_api: ## Builds the mocked Coordinator instance.
 mock_coordinator_cron: ## Builds the mocked Coordinator instance.
 	go build -tags="mock_prover mock_verifier" -o $(PWD)/build/bin/coordinator_cron ./cmd/cron
 
-test-verifier: $(LIBZKP_PATH)
+test-verifier: libzkp
 	go test -tags ffi -timeout 0 -v ./internal/logic/verifier
 
-test-gpu-verifier: $(LIBZKP_PATH)
+test-gpu-verifier: libzkp
 	go test -tags="gpu ffi" -timeout 0 -v ./internal/logic/verifier
 
 lint: ## Lint the files - used for CI
+	cp -r ../common/libzkp/interface ./internal/logic/verifier/lib
 	GOBIN=$(PWD)/build/bin go run ../build/lint.go
 
 clean: ## Empty out the bin folder

coordinator/go.mod

@@ -9,8 +9,8 @@ require (
 	github.com/google/uuid v1.6.0
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7
+	github.com/scroll-tech/da-codec v0.1.3-0.20250401062930-9f9f53898493
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601
 	github.com/shopspring/decimal v1.3.1
 	github.com/stretchr/testify v1.10.0
 	github.com/urfave/cli/v2 v2.25.7

coordinator/go.sum

@@ -177,10 +177,10 @@ github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU
 github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6 h1:vb2XLvQwCf+F/ifP6P/lfeiQrHY6+Yb/E3R4KHXLqSE=
-github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7 h1:1rN1qocsQlOyk1VCpIEF1J5pfQbLAi1pnMZSLQS37jQ=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
+github.com/scroll-tech/da-codec v0.1.3-0.20250401062930-9f9f53898493 h1:Ioc01J0WEMxuwFvEPGJeBKXdf2KY4Yc3XbFky/IxLlI=
+github.com/scroll-tech/da-codec v0.1.3-0.20250401062930-9f9f53898493/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601 h1:NEsjCG6uSvLRBlsP3+x6PL1kM+Ojs3g8UGotIPgJSz8=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250305151038-478940e79601/go.mod h1:OblWe1+QrZwdpwO0j/LY3BSGuKT3YPUFBDQQgvvfStQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=

coordinator/internal/config/config.go

@@ -28,16 +28,10 @@ type ProverManager struct {
 	BundleCollectionTimeSec int `json:"bundle_collection_time_sec"`
 }
 
-// l2geth client configuration items
-type L2Endpoint struct {
-	Url string `json:"endpoint"`
-}
-
 // L2 loads l2geth configuration items.
 type L2 struct {
 	// l2geth chain_id.
-	ChainID  uint64      `json:"chain_id"`
-	Endpoint *L2Endpoint `json:"l2geth"`
+	ChainID uint64 `json:"chain_id"`
 }
 
 // Auth provides the auth coordinator

coordinator/internal/controller/api/controller.go

@@ -28,17 +28,6 @@ func InitController(cfg *config.Config, chainCfg *params.ChainConfig, db *gorm.D
 
 	log.Info("verifier created", "openVmVerifier", vf.OpenVMVkMap)
 
-	// TODO: enable this when the libzkp has been updated
-	/*l2cfg := cfg.L2.Endpoint
-	if l2cfg == nil {
-		panic("l2geth is not specified")
-	}
-	l2cfgBytes, err := json.Marshal(l2cfg)
-	if err != nil {
-		panic(err)
-	}
-	libzkp.InitL2geth(string(l2cfgBytes))*/
-
 	Auth = NewAuthController(db, cfg, vf)
 	GetTask = NewGetTaskController(cfg, chainCfg, db, reg)
 	SubmitProof = NewSubmitProofController(cfg, chainCfg, db, vf, reg)

coordinator/internal/logic/libzkp/Makefile

@@ -1,17 +0,0 @@
-.PHONY: help fmt clippy test test-ci test-all
-
-build:
-	@cargo build --release -p libzkp-c
-	@mkdir -p lib
-	@cp -f ../../../../target/release/libzkp.so lib/
-
-fmt:
-	@cargo fmt --all -- --check
-
-clean:
-	@cargo clean --release -p libzkp -p libzkp-c -p l2geth
-	@rm -f lib/libzkp.so
-
-clippy:
-	@cargo check --release --all-features
-	@cargo clippy --release -- -D warnings

coordinator/internal/logic/libzkp/lib.go

@@ -1,145 +0,0 @@
-package libzkp
-
-/*
-#cgo LDFLAGS: -lzkp -lm -ldl -L${SRCDIR}/lib -Wl,-rpath=${SRCDIR}/lib
-#cgo gpu LDFLAGS: -lzkp -lm -ldl -lgmp -lstdc++ -lprocps -L/usr/local/cuda/lib64/ -lcudart -L${SRCDIR}/lib/ -Wl,-rpath=${SRCDIR}/lib
-#include <stdlib.h>
-#include "libzkp.h"
-*/
-import "C" //nolint:typecheck
-
-import (
-	"fmt"
-	"os"
-	"unsafe"
-
-	"scroll-tech/common/types/message"
-)
-
-// Helper function to convert Go string to C string and handle cleanup
-func goToCString(s string) *C.char {
-	return C.CString(s)
-}
-
-// Helper function to free C string
-func freeCString(s *C.char) {
-	C.free(unsafe.Pointer(s))
-}
-
-// Initialize the verifier
-func InitVerifier(configJSON string) {
-	cConfig := goToCString(configJSON)
-	defer freeCString(cConfig)
-
-	C.init_verifier(cConfig)
-}
-
-// Initialize the verifier
-func InitL2geth(configJSON string) {
-	cConfig := goToCString(configJSON)
-	defer freeCString(cConfig)
-
-	C.init_l2geth(cConfig)
-}
-
-// Verify a chunk proof
-func VerifyChunkProof(proofData, forkName string) bool {
-	cProof := goToCString(proofData)
-	cForkName := goToCString(forkName)
-	defer freeCString(cProof)
-	defer freeCString(cForkName)
-
-	result := C.verify_chunk_proof(cProof, cForkName)
-	return result != 0
-}
-
-// Verify a batch proof
-func VerifyBatchProof(proofData, forkName string) bool {
-	cProof := goToCString(proofData)
-	cForkName := goToCString(forkName)
-	defer freeCString(cProof)
-	defer freeCString(cForkName)
-
-	result := C.verify_batch_proof(cProof, cForkName)
-	return result != 0
-}
-
-// Verify a bundle proof
-func VerifyBundleProof(proofData, forkName string) bool {
-	cProof := goToCString(proofData)
-	cForkName := goToCString(forkName)
-	defer freeCString(cProof)
-	defer freeCString(cForkName)
-
-	result := C.verify_bundle_proof(cProof, cForkName)
-	return result != 0
-}
-
-// TaskType enum values matching the Rust enum
-const (
-	TaskTypeChunk  = 0
-	TaskTypeBatch  = 1
-	TaskTypeBundle = 2
-)
-
-func fromMessageTaskType(taskType int) int {
-	switch message.ProofType(taskType) {
-	case message.ProofTypeChunk:
-		return TaskTypeChunk
-	case message.ProofTypeBatch:
-		return TaskTypeBatch
-	case message.ProofTypeBundle:
-		return TaskTypeBundle
-	default:
-		panic(fmt.Sprintf("unsupported proof type: %d", taskType))
-	}
-}
-
-// Generate a universal task
-func GenerateUniversalTask(taskType int, taskJSON, forkName string) (bool, string, string, []byte) {
-	return generateUniversalTask(fromMessageTaskType(taskType), taskJSON, forkName)
-}
-
-// Generate wrapped proof
-func GenerateWrappedProof(proofJSON, metadata string, vkData []byte) string {
-	cProofJSON := goToCString(proofJSON)
-	cMetadata := goToCString(metadata)
-	defer freeCString(cProofJSON)
-	defer freeCString(cMetadata)
-
-	// Create a C array from Go slice
-	var cVkData *C.char
-	if len(vkData) > 0 {
-		cVkData = (*C.char)(unsafe.Pointer(&vkData[0]))
-	}
-
-	resultPtr := C.gen_wrapped_proof(cProofJSON, cMetadata, cVkData, C.size_t(len(vkData)))
-	if resultPtr == nil {
-		return ""
-	}
-
-	// Convert result to Go string and free C memory
-	result := C.GoString(resultPtr)
-	C.release_string(resultPtr)
-
-	return result
-}
-
-// Dumps a verification key to a file
-func DumpVk(forkName, filePath string) error {
-	cForkName := goToCString(forkName)
-	cFilePath := goToCString(filePath)
-	defer freeCString(cForkName)
-	defer freeCString(cFilePath)
-
-	// Call the C function to dump the verification key
-	C.dump_vk(cForkName, cFilePath)
-
-	// Check if the file was created successfully
-	// Note: The C function doesn't return an error code, so we check if the file exists
-	if _, err := os.Stat(filePath); os.IsNotExist(err) {
-		return fmt.Errorf("failed to dump verification key: file %s was not created", filePath)
-	}
-
-	return nil
-}

coordinator/internal/logic/libzkp/libzkp.h

@@ -1,48 +0,0 @@
-// Verifier is used to:
-// - Verify a batch proof
-// - Verify a bundle proof
-// - Verify a chunk proof
-
-#ifndef LIBZKP_H
-#define LIBZKP_H
-
-#include <stddef.h> // For size_t
-
-// Initialize the verifier with configuration
-void init_verifier(char* config);
-
-// Initialize the l2geth with configuration
-void init_l2geth(char* config);
-
-// Verify proofs - returns non-zero for success, zero for failure
-char verify_batch_proof(char* proof, char* fork_name);
-char verify_bundle_proof(char* proof, char* fork_name);
-char verify_chunk_proof(char* proof, char* fork_name);
-
-// Dump verification key to file
-void dump_vk(char* fork_name, char* file);
-
-// The result struct to hold data from handling a proving task
-typedef struct {
-    char ok;
-    char* universal_task;
-    char* metadata;
-    char expected_pi_hash[32];
-} HandlingResult;
-
-// Generate a universal task based on task type and input JSON
-// Returns a struct containing task data, metadata, and expected proof hash
-HandlingResult gen_universal_task(int task_type, char* task, char* fork_name);
-
-// Release memory allocated for a HandlingResult returned by gen_universal_task
-void release_task_result(HandlingResult result);
-
-// Generate a wrapped proof from the universal prover output and metadata
-// Returns a JSON string containing the wrapped proof, or NULL on error
-// The caller must call release_string on the returned pointer when done
-char* gen_wrapped_proof(char* proof_json, char* metadata, char* vk, size_t vk_len);
-
-// Release memory allocated for a string returned by gen_wrapped_proof
-void release_string(char* string_ptr);
-
-#endif /* LIBZKP_H */

coordinator/internal/logic/libzkp/mock_universal_task.go

@@ -1,42 +0,0 @@
-//go:build mock_verifier
-
-package libzkp
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"scroll-tech/common/types/message"
-
-	"github.com/scroll-tech/go-ethereum/common"
-)
-
-func generateUniversalTask(taskType int, taskJSON, forkName string) (bool, string, string, []byte) {
-
-	fmt.Printf("call mocked generate universal task %d, taskJson %s\n", taskType, taskJSON)
-	var metadata interface{}
-	switch taskType {
-	case TaskTypeChunk:
-		metadata = struct {
-			ChunkInfo *message.ChunkInfo `json:"chunk_info"`
-		}{ChunkInfo: &message.ChunkInfo{}}
-	case TaskTypeBatch:
-		metadata = struct {
-			BatchInfo *message.OpenVMBatchInfo `json:"batch_info"`
-			BatchHash common.Hash              `json:"batch_hash"`
-		}{BatchInfo: &message.OpenVMBatchInfo{}}
-	case TaskTypeBundle:
-		metadata = struct {
-			BundleInfo   *message.OpenVMBundleInfo `json:"bundle_info"`
-			BundlePIHash common.Hash               `json:"bundle_pi_hash"`
-		}{BundleInfo: &message.OpenVMBundleInfo{}}
-	}
-
-	encodeData, err := json.Marshal(metadata)
-	if err != nil {
-		fmt.Println("mock encoding json fail:", err)
-		return false, "", "", nil
-	}
-
-	return true, "UniversalTask data is not parsed", string(encodeData), []byte{0}
-}

coordinator/internal/logic/libzkp/universal_task.go

@@ -1,36 +0,0 @@
-//go:build !mock_verifier
-
-package libzkp
-
-/*
-#include <stdlib.h>
-#include "libzkp.h"
-*/
-import "C" //nolint:typecheck
-
-func generateUniversalTask(taskType int, taskJSON, forkName string) (bool, string, string, []byte) {
-	cTask := goToCString(taskJSON)
-	cForkName := goToCString(forkName)
-	defer freeCString(cTask)
-	defer freeCString(cForkName)
-
-	result := C.gen_universal_task(C.int(taskType), cTask, cForkName)
-	defer C.release_task_result(result)
-
-	// Check if the operation was successful
-	if result.ok == 0 {
-		return false, "", "", nil
-	}
-
-	// Convert C strings to Go strings
-	universalTask := C.GoString(result.universal_task)
-	metadata := C.GoString(result.metadata)
-
-	// Convert C array to Go slice
-	piHash := make([]byte, 32)
-	for i := 0; i < 32; i++ {
-		piHash[i] = byte(result.expected_pi_hash[i])
-	}
-
-	return true, universalTask, metadata, piHash
-}

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -161,31 +161,19 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		AssignedAt: utils.NowUTC(),
 	}
 
-	taskMsg, err := bp.formatProverTask(ctx.Copy(), &proverTask, batchTask, hardForkName)
-	if err != nil {
-		bp.recoverActiveAttempts(ctx, batchTask)
-		log.Error("format prover task failure", "task_id", batchTask.Hash, "err", err)
-		return nil, ErrCoordinatorInternalFailure
-	}
-	if getTaskParameter.Universal {
-		var metadata []byte
-		taskMsg, metadata, err = bp.applyUniversal(taskMsg)
-		if err != nil {
-			bp.recoverActiveAttempts(ctx, batchTask)
-			log.Error("Generate universal prover task failure", "task_id", batchTask.Hash, "type", "batch")
-			return nil, ErrCoordinatorInternalFailure
-		}
-		proverTask.Metadata = metadata
-	}
-
 	// Store session info.
 	if err = bp.proverTaskOrm.InsertProverTask(ctx.Copy(), &proverTask); err != nil {
 		bp.recoverActiveAttempts(ctx, batchTask)
 		log.Error("insert batch prover task info fail", "task_id", batchTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
 		return nil, ErrCoordinatorInternalFailure
 	}
-	// notice uuid is set as a side effect of InsertProverTask
-	taskMsg.UUID = proverTask.UUID.String()
+
+	taskMsg, err := bp.formatProverTask(ctx.Copy(), &proverTask, batchTask, hardForkName)
+	if err != nil {
+		bp.recoverActiveAttempts(ctx, batchTask)
+		log.Error("format prover task failure", "task_id", batchTask.Hash, "err", err)
+		return nil, ErrCoordinatorInternalFailure
+	}
 
 	bp.batchTaskGetTaskTotal.WithLabelValues(hardForkName).Inc()
 	bp.batchTaskGetTaskProver.With(prometheus.Labels{
@@ -245,6 +233,7 @@ func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 	}
 
 	taskMsg := &coordinatorType.GetTaskSchema{
+		UUID:         task.UUID.String(),
 		TaskID:       task.TaskID,
 		TaskType:     int(message.ProofTypeBatch),
 		TaskData:     string(chunkProofsBytes),
@@ -277,7 +266,7 @@ func (bp *BatchProverTask) getBatchTaskDetail(dbBatch *orm.Batch, chunkInfos []*
 
 	dbBatchCodecVersion := encoding.CodecVersion(dbBatch.CodecVersion)
 	switch dbBatchCodecVersion {
-	case encoding.CodecV3, encoding.CodecV4, encoding.CodecV6, encoding.CodecV7, encoding.CodecV8:
+	case encoding.CodecV3, encoding.CodecV4, encoding.CodecV6, encoding.CodecV7:
 	default:
 		return taskDetail, nil
 	}

coordinator/internal/logic/provertask/bundle_prover_task.go

@@ -159,33 +159,19 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 		AssignedAt: utils.NowUTC(),
 	}
 
-	taskMsg, err := bp.formatProverTask(ctx.Copy(), &proverTask, hardForkName)
-	if err != nil {
-		bp.recoverActiveAttempts(ctx, bundleTask)
-		log.Error("format bundle prover task failure", "task_id", bundleTask.Hash, "err", err)
-		return nil, ErrCoordinatorInternalFailure
-	}
-	if getTaskParameter.Universal {
-		var metadata []byte
-		taskMsg, metadata, err = bp.applyUniversal(taskMsg)
-		if err != nil {
-			bp.recoverActiveAttempts(ctx, bundleTask)
-			log.Error("Generate universal prover task failure", "task_id", bundleTask.Hash, "type", "bundle")
-			return nil, ErrCoordinatorInternalFailure
-		}
-		// bundle proof require snark
-		taskMsg.UseSnark = true
-		proverTask.Metadata = metadata
-	}
-
 	// Store session info.
 	if err = bp.proverTaskOrm.InsertProverTask(ctx.Copy(), &proverTask); err != nil {
 		bp.recoverActiveAttempts(ctx, bundleTask)
 		log.Error("insert bundle prover task info fail", "task_id", bundleTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
 		return nil, ErrCoordinatorInternalFailure
 	}
-	// notice uuid is set as a side effect of InsertProverTask
-	taskMsg.UUID = proverTask.UUID.String()
+
+	taskMsg, err := bp.formatProverTask(ctx.Copy(), &proverTask, hardForkName)
+	if err != nil {
+		bp.recoverActiveAttempts(ctx, bundleTask)
+		log.Error("format bundle prover task failure", "task_id", bundleTask.Hash, "err", err)
+		return nil, ErrCoordinatorInternalFailure
+	}
 
 	bp.bundleTaskGetTaskTotal.WithLabelValues(hardForkName).Inc()
 	bp.bundleTaskGetTaskProver.With(prometheus.Labels{
@@ -251,6 +237,7 @@ func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.Prov
 	}
 
 	taskMsg := &coordinatorType.GetTaskSchema{
+		UUID:         task.UUID.String(),
 		TaskID:       task.TaskID,
 		TaskType:     int(message.ProofTypeBundle),
 		TaskData:     string(batchProofsBytes),

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -157,6 +157,12 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		AssignedAt: utils.NowUTC(),
 	}
 
+	if err = cp.proverTaskOrm.InsertProverTask(ctx.Copy(), &proverTask); err != nil {
+		cp.recoverActiveAttempts(ctx, chunkTask)
+		log.Error("insert chunk prover task fail", "task_id", chunkTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
+		return nil, ErrCoordinatorInternalFailure
+	}
+
 	taskMsg, err := cp.formatProverTask(ctx.Copy(), &proverTask, chunkTask, hardForkName)
 	if err != nil {
 		cp.recoverActiveAttempts(ctx, chunkTask)
@@ -164,25 +170,6 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		return nil, ErrCoordinatorInternalFailure
 	}
 
-	if getTaskParameter.Universal {
-		var metadata []byte
-		taskMsg, metadata, err = cp.applyUniversal(taskMsg)
-		if err != nil {
-			cp.recoverActiveAttempts(ctx, chunkTask)
-			log.Error("Generate universal prover task failure", "task_id", chunkTask.Hash, "type", "chunk")
-			return nil, ErrCoordinatorInternalFailure
-		}
-		proverTask.Metadata = metadata
-	}
-
-	if err = cp.proverTaskOrm.InsertProverTask(ctx.Copy(), &proverTask); err != nil {
-		cp.recoverActiveAttempts(ctx, chunkTask)
-		log.Error("insert chunk prover task fail", "task_id", chunkTask.Hash, "publicKey", taskCtx.PublicKey, "err", err)
-		return nil, ErrCoordinatorInternalFailure
-	}
-	// notice uuid is set as a side effect of InsertProverTask
-	taskMsg.UUID = proverTask.UUID.String()
-
 	cp.chunkTaskGetTaskTotal.WithLabelValues(hardForkName).Inc()
 	cp.chunkTaskGetTaskProver.With(prometheus.Labels{
 		coordinatorType.LabelProverName:      proverTask.ProverName,
@@ -220,6 +207,7 @@ func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.Prove
 	}
 
 	proverTaskSchema := &coordinatorType.GetTaskSchema{
+		UUID:         task.UUID.String(),
 		TaskID:       task.TaskID,
 		TaskType:     int(message.ProofTypeChunk),
 		TaskData:     string(taskDetailBytes),

coordinator/internal/logic/provertask/prover_task.go

@@ -16,7 +16,6 @@ import (
 	"scroll-tech/common/types/message"
 
 	"scroll-tech/coordinator/internal/config"
-	"scroll-tech/coordinator/internal/logic/libzkp"
 	"scroll-tech/coordinator/internal/orm"
 	coordinatorType "scroll-tech/coordinator/internal/types"
 )
@@ -186,16 +185,6 @@ func (b *BaseProverTask) checkParameter(ctx *gin.Context) (*proverTaskContext, e
 	return &ptc, nil
 }
 
-func (b *BaseProverTask) applyUniversal(schema *coordinatorType.GetTaskSchema) (*coordinatorType.GetTaskSchema, []byte, error) {
-	ok, uTaskData, metadata, _ := libzkp.GenerateUniversalTask(schema.TaskType, schema.TaskData, schema.HardForkName)
-	if !ok {
-		return nil, nil, fmt.Errorf("can not generate universal task, see coordinator log for the reason")
-	}
-
-	schema.TaskData = uTaskData
-	return schema, []byte(metadata), nil
-}
-
 func newGetTaskCounterVec(factory promauto.Factory, taskType string) *prometheus.CounterVec {
 	getTaskCounterInitOnce.Do(func() {
 		getTaskCounterVec = factory.NewCounterVec(prometheus.CounterOpts{

coordinator/internal/logic/submitproof/proof_receiver.go

@@ -19,8 +19,6 @@ import (
 	"scroll-tech/common/types/message"
 
 	"scroll-tech/coordinator/internal/config"
-	"scroll-tech/coordinator/internal/logic/libzkp"
-	"scroll-tech/coordinator/internal/logic/provertask"
 	"scroll-tech/coordinator/internal/logic/verifier"
 	"scroll-tech/coordinator/internal/orm"
 	coordinatorType "scroll-tech/coordinator/internal/types"
@@ -71,10 +69,6 @@ type ProofReceiverLogic struct {
 	validateFailureProverTaskStatusNotOk  prometheus.Counter
 	validateFailureProverTaskTimeout      prometheus.Counter
 	validateFailureProverTaskHaveVerifier prometheus.Counter
-
-	ChunkTask  provertask.ProverTask
-	BundleTask provertask.ProverTask
-	BatchTask  provertask.ProverTask
 }
 
 // NewSubmitProofReceiverLogic create a proof receiver logic
@@ -174,15 +168,6 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coor
 	if getHardForkErr != nil {
 		return ErrGetHardForkNameFailed
 	}
-	if proofParameter.Universal {
-		if len(proverTask.Metadata) == 0 {
-			return errors.New("can not re-wrapping proof: no metadata has been recorded in advance")
-		}
-		proofParameter.Proof = libzkp.GenerateWrappedProof(proofParameter.Proof, string(proverTask.Metadata), []byte{})
-		if proofParameter.Proof == "" {
-			return errors.New("can not re-wrapping proof, see coordinator log for reason")
-		}
-	}
 
 	switch message.ProofType(proofParameter.TaskType) {
 	case message.ProofTypeChunk:

coordinator/internal/logic/verifier/verifier.go

@@ -2,23 +2,30 @@
 
 package verifier
 
+/*
+#cgo LDFLAGS: -lzkp -lm -ldl -L${SRCDIR}/lib/ -Wl,-rpath=${SRCDIR}/lib
+#cgo gpu LDFLAGS: -lzkp -lm -ldl -lgmp -lstdc++ -lprocps -L/usr/local/cuda/lib64/ -lcudart -L${SRCDIR}/lib/ -Wl,-rpath=${SRCDIR}/lib
+#include <stdlib.h>
+#include "./lib/libzkp.h"
+*/
+import "C" //nolint:typecheck
+
 import (
 	"encoding/base64"
 	"encoding/json"
 	"io"
 	"os"
 	"path"
-	"path/filepath"
+	"unsafe"
 
 	"github.com/scroll-tech/go-ethereum/log"
 
 	"scroll-tech/common/types/message"
 
 	"scroll-tech/coordinator/internal/config"
-	"scroll-tech/coordinator/internal/logic/libzkp"
 )
 
-// This struct maps to `CircuitConfig` in libzkp/impl/src/verifier.rs
+// This struct maps to `CircuitConfig` in common/libzkp/impl/src/verifier.rs
 // Define a brand new struct here is to eliminate side effects in case fields
 // in `*config.CircuitConfig` being changed
 type rustCircuitConfig struct {
@@ -33,7 +40,7 @@ func newRustCircuitConfig(cfg *config.CircuitConfig) *rustCircuitConfig {
 	}
 }
 
-// This struct maps to `VerifierConfig` in coordinator/internal/logic/libzkp/impl/src/verifier.rs
+// This struct maps to `VerifierConfig` in common/libzkp/impl/src/verifier.rs
 // Define a brand new struct here is to eliminate side effects in case fields
 // in `*config.VerifierConfig` being changed
 type rustVerifierConfig struct {
@@ -60,7 +67,12 @@ func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 		return nil, err
 	}
 
-	libzkp.InitVerifier(string(configBytes))
+	configStr := C.CString(string(configBytes))
+	defer func() {
+		C.free(unsafe.Pointer(configStr))
+	}()
+
+	C.init(configStr)
 
 	v := &Verifier{
 		cfg:         cfg,
@@ -82,7 +94,15 @@ func (v *Verifier) VerifyBatchProof(proof *message.OpenVMBatchProof, forkName st
 	}
 
 	log.Info("Start to verify batch proof", "forkName", forkName)
-	return libzkp.VerifyBatchProof(string(buf), forkName), nil
+	proofStr := C.CString(string(buf))
+	forkNameStr := C.CString(forkName)
+	defer func() {
+		C.free(unsafe.Pointer(proofStr))
+		C.free(unsafe.Pointer(forkNameStr))
+	}()
+
+	verified := C.verify_batch_proof(proofStr, forkNameStr)
+	return verified != 0, nil
 }
 
 // VerifyChunkProof Verify a ZkProof by marshaling it and sending it to the Verifier.
@@ -93,8 +113,15 @@ func (v *Verifier) VerifyChunkProof(proof *message.OpenVMChunkProof, forkName st
 	}
 
 	log.Info("Start to verify chunk proof", "forkName", forkName)
+	proofStr := C.CString(string(buf))
+	forkNameStr := C.CString(forkName)
+	defer func() {
+		C.free(unsafe.Pointer(proofStr))
+		C.free(unsafe.Pointer(forkNameStr))
+	}()
 
-	return libzkp.VerifyChunkProof(string(buf), forkName), nil
+	verified := C.verify_chunk_proof(proofStr, forkNameStr)
+	return verified != 0, nil
 }
 
 // VerifyBundleProof Verify a ZkProof for a bundle of batches, by marshaling it and verifying it via the EVM verifier.
@@ -104,13 +131,20 @@ func (v *Verifier) VerifyBundleProof(proof *message.OpenVMBundleProof, forkName
 		return false, err
 	}
 
+	proofStr := C.CString(string(buf))
+	forkNameStr := C.CString(forkName)
+	defer func() {
+		C.free(unsafe.Pointer(proofStr))
+		C.free(unsafe.Pointer(forkNameStr))
+	}()
+
 	log.Info("Start to verify bundle proof ...")
-	return libzkp.VerifyBundleProof(string(buf), forkName), nil
+	verified := C.verify_bundle_proof(proofStr, forkNameStr)
+	return verified != 0, nil
 }
 
-func (v *Verifier) ReadVK(filePat string) (string, error) {
-
-	f, err := os.Open(filepath.Clean(filePat))
+func (v *Verifier) readVK(filePat string) (string, error) {
+	f, err := os.Open(filePat)
 	if err != nil {
 		return "", err
 	}
@@ -123,12 +157,20 @@ func (v *Verifier) ReadVK(filePat string) (string, error) {
 
 func (v *Verifier) loadOpenVMVks(forkName string) error {
 	tempFile := path.Join(os.TempDir(), "openVmVk.json")
-	err := libzkp.DumpVk(forkName, tempFile)
-	if err != nil {
-		return err
-	}
+	defer func() {
+		if err := os.Remove(tempFile); err != nil {
+			log.Error("failed to remove temp file", "err", err)
+		}
+	}()
 
-	f, err := os.Open(filepath.Clean(tempFile))
+	forkNameCStr := C.CString(forkName)
+	defer C.free(unsafe.Pointer(forkNameCStr))
+	tempFileCStr := C.CString(tempFile)
+	defer C.free(unsafe.Pointer(tempFileCStr))
+
+	C.dump_vk(forkNameCStr, tempFileCStr)
+
+	f, err := os.Open(tempFile)
 	if err != nil {
 		return err
 	}

coordinator/internal/logic/verifier/verifier_test.go

@@ -11,7 +11,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	"scroll-tech/common/types/message"
+	"scroll-tech/common/types"
 
 	"scroll-tech/coordinator/internal/config"
 )
@@ -58,25 +58,25 @@ func TestFFI(t *testing.T) {
 	t.Log("Verified batch proof")
 }
 
-func readBatchProof(filePat string, as *assert.Assertions) *message.OpenVMBatchProof {
+func readBatchProof(filePat string, as *assert.Assertions) *types.OpenVMBatchProof {
 	f, err := os.Open(filePat)
 	as.NoError(err)
 	byt, err := io.ReadAll(f)
 	as.NoError(err)
 
-	proof := &message.OpenVMBatchProof{}
+	proof := &types.OpenVMBatchProof{}
 	as.NoError(json.Unmarshal(byt, proof))
 
 	return proof
 }
 
-func readChunkProof(filePat string, as *assert.Assertions) *message.OpenVMChunkProof {
+func readChunkProof(filePat string, as *assert.Assertions) *types.OpenVMChunkProof {
 	f, err := os.Open(filePat)
 	as.NoError(err)
 	byt, err := io.ReadAll(f)
 	as.NoError(err)
 
-	proof := &message.OpenVMChunkProof{}
+	proof := &types.OpenVMChunkProof{}
 	as.NoError(json.Unmarshal(byt, proof))
 
 	return proof

coordinator/internal/orm/prover_task.go

@@ -37,7 +37,6 @@ type ProverTask struct {
 	FailureType   int16           `json:"failure_type" gorm:"column:failure_type;default:0"`
 	Reward        decimal.Decimal `json:"reward" gorm:"column:reward;default:0;type:decimal(78)"`
 	Proof         []byte          `json:"proof" gorm:"column:proof;default:NULL"`
-	Metadata      []byte          `json:"metadata" gorm:"column:metadata;default:NULL"`
 	AssignedAt    time.Time       `json:"assigned_at" gorm:"assigned_at"`
 
 	// metadata

coordinator/internal/types/get_task.go

@@ -4,8 +4,6 @@ package types
 type GetTaskParameter struct {
 	ProverHeight uint64 `form:"prover_height" json:"prover_height"`
 	TaskTypes    []int  `form:"task_types" json:"task_types"`
-	TaskID       string `form:"task_id,omitempty" json:"task_id,omitempty"`
-	Universal    bool   `form:"universal,omitempty" json:"universal,omitempty"`
 }
 
 // GetTaskSchema the schema data return to prover for get prover task
@@ -13,7 +11,6 @@ type GetTaskSchema struct {
 	UUID         string `json:"uuid"`
 	TaskID       string `json:"task_id"`
 	TaskType     int    `json:"task_type"`
-	UseSnark     bool   `json:"use_snark,omitempty"`
 	TaskData     string `json:"task_data"`
 	HardForkName string `json:"hard_fork_name"`
 }

coordinator/internal/types/submit_proof.go

@@ -7,7 +7,6 @@ type SubmitProofParameter struct {
 	TaskType    int    `form:"task_type" json:"task_type" binding:"required"`
 	Status      int    `form:"status" json:"status"`
 	Proof       string `form:"proof" json:"proof"`
-	Universal   bool   `form:"universal,omitempty" json:"universal,omitempty"`
 	FailureType int    `form:"failure_type" json:"failure_type"`
 	FailureMsg  string `form:"failure_msg" json:"failure_msg"`
 }

coordinator/test/mock_prover.go

@@ -161,7 +161,7 @@ func (r *mockProver) getProverTask(t *testing.T, proofType message.ProofType) (*
 	resp, err := client.R().
 		SetHeader("Content-Type", "application/json").
 		SetHeader("Authorization", fmt.Sprintf("Bearer %s", token)).
-		SetBody(map[string]interface{}{"universal": true, "prover_height": 100, "task_types": []int{int(proofType)}}).
+		SetBody(map[string]interface{}{"prover_height": 100, "task_types": []int{int(proofType)}}).
 		SetResult(&result).
 		Post("http://" + r.coordinatorURL + "/coordinator/v1/get_task")
 	assert.NoError(t, err)
@@ -191,7 +191,7 @@ func (r *mockProver) tryGetProverTask(t *testing.T, proofType message.ProofType)
 	resp, err := client.R().
 		SetHeader("Content-Type", "application/json").
 		SetHeader("Authorization", fmt.Sprintf("Bearer %s", token)).
-		SetBody(map[string]interface{}{"prover_height": 100, "task_type": int(proofType), "universal": true}).
+		SetBody(map[string]interface{}{"prover_height": 100, "task_type": int(proofType)}).
 		SetResult(&result).
 		Post("http://" + r.coordinatorURL + "/coordinator/v1/get_task")
 	assert.NoError(t, err)
@@ -207,33 +207,32 @@ func (r *mockProver) submitProof(t *testing.T, proverTaskSchema *types.GetTaskSc
 	}
 
 	var proof []byte
-	if proofStatus != verifiedFailed {
-		switch message.ProofType(proverTaskSchema.TaskType) {
-		case message.ProofTypeChunk:
-			fallthrough
-		case message.ProofTypeBatch:
-			encodeData, err := json.Marshal(&message.OpenVMProof{})
+	switch message.ProofType(proverTaskSchema.TaskType) {
+	case message.ProofTypeChunk:
+		encodeData, err := json.Marshal(message.OpenVMChunkProof{VmProof: &message.OpenVMProof{}, MetaData: struct {
+			ChunkInfo *message.ChunkInfo `json:"chunk_info"`
+		}{ChunkInfo: &message.ChunkInfo{}}})
+		assert.NoError(t, err)
+		assert.NotEmpty(t, encodeData)
+		proof = encodeData
+	case message.ProofTypeBatch:
+		encodeData, err := json.Marshal(message.OpenVMBatchProof{VmProof: &message.OpenVMProof{}})
+		assert.NoError(t, err)
+		assert.NotEmpty(t, encodeData)
+		proof = encodeData
+	}
+
+	if proofStatus == verifiedFailed {
+		switch proverTaskSchema.TaskType {
+		case int(message.ProofTypeChunk):
+			encodeData, err := json.Marshal(message.OpenVMChunkProof{VmProof: &message.OpenVMProof{Proof: []byte(verifier.InvalidTestProof)}, MetaData: struct {
+				ChunkInfo *message.ChunkInfo `json:"chunk_info"`
+			}{ChunkInfo: &message.ChunkInfo{}}})
 			assert.NoError(t, err)
 			assert.NotEmpty(t, encodeData)
 			proof = encodeData
-		case message.ProofTypeBundle:
-			encodeData, err := json.Marshal(&message.OpenVMEvmProof{})
-			assert.NoError(t, err)
-			assert.NotEmpty(t, encodeData)
-			proof = encodeData
-		}
-	} else {
-		// in "verifiedFailed" status, we purpose the mockprover submit proof but not valid
-		switch message.ProofType(proverTaskSchema.TaskType) {
-		case message.ProofTypeChunk:
-			fallthrough
-		case message.ProofTypeBatch:
-			encodeData, err := json.Marshal(&message.OpenVMProof{Proof: []byte(verifier.InvalidTestProof)})
-			assert.NoError(t, err)
-			assert.NotEmpty(t, encodeData)
-			proof = encodeData
-		case message.ProofTypeBundle:
-			encodeData, err := json.Marshal(&message.OpenVMEvmProof{Proof: []byte(verifier.InvalidTestProof)})
+		case int(message.ProofTypeBatch):
+			encodeData, err := json.Marshal(&message.OpenVMBatchProof{VmProof: &message.OpenVMProof{Proof: []byte(verifier.InvalidTestProof)}})
 			assert.NoError(t, err)
 			assert.NotEmpty(t, encodeData)
 			proof = encodeData
@@ -241,12 +240,11 @@ func (r *mockProver) submitProof(t *testing.T, proverTaskSchema *types.GetTaskSc
 	}
 
 	submitProof := types.SubmitProofParameter{
-		UUID:      proverTaskSchema.UUID,
-		TaskID:    proverTaskSchema.TaskID,
-		TaskType:  proverTaskSchema.TaskType,
-		Status:    int(proofMsgStatus),
-		Proof:     string(proof),
-		Universal: true,
+		UUID:     proverTaskSchema.UUID,
+		TaskID:   proverTaskSchema.TaskID,
+		TaskType: proverTaskSchema.TaskType,
+		Status:   int(proofMsgStatus),
+		Proof:    string(proof),
 	}
 
 	token, authErrCode, errMsg := r.connectToCoordinator(t, []types.ProverType{types.MakeProverType(message.ProofType(proverTaskSchema.TaskType))})

crates/l2geth/Cargo.toml

@@ -1,26 +0,0 @@
-[package]
-name = "l2geth"
-version.workspace = true
-edition.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-[dependencies]
-tokio = {version = "1", features = ["rt-multi-thread"]}
-async-trait = "0.1"
-url = ">=2.5.3"
-
-libzkp = { path = "../libzkp" }
-alloy = { workspace = true, features = ["provider-http", "transport-http", "reqwest", "reqwest-rustls-tls", "json-rpc"] }
-sbv-primitives = { workspace = true, features = ["scroll"] }
-sbv-utils = { workspace = true, features = ["scroll"] }
-
-eyre.workspace = true
-
-base64.workspace = true
-serde.workspace = true
-serde_derive.workspace = true
-serde_json = { workspace = true, features = ["raw_value"]}
-tracing.workspace = true
-
-
-

crates/l2geth/src/lib.rs

@@ -1,19 +0,0 @@
-pub mod rpc_client;
-pub use rpc_client::RpcConfig;
-
-use std::sync::{Arc, OnceLock};
-
-static GLOBAL_L2GETH_CLI: OnceLock<Arc<rpc_client::RpcClientCore>> = OnceLock::new();
-
-pub fn init(config: &str) -> eyre::Result<()> {
-    let cfg: RpcConfig = serde_json::from_str(config)?;
-    GLOBAL_L2GETH_CLI.get_or_init(|| Arc::new(rpc_client::RpcClientCore::create(&cfg).unwrap()));
-    Ok(())
-}
-
-pub fn get_client() -> rpc_client::RpcClient<'static> {
-    GLOBAL_L2GETH_CLI
-        .get()
-        .expect("must has been inited")
-        .get_client()
-}

crates/l2geth/src/rpc_client.rs

@@ -1,241 +0,0 @@
-use alloy::{
-    providers::{Provider, ProviderBuilder, RootProvider},
-    rpc::client::ClientBuilder,
-    transports::layers::RetryBackoffLayer,
-};
-use eyre::Result;
-use libzkp::tasks::ChunkInterpreter;
-use sbv_primitives::types::Network;
-use serde::{Deserialize, Serialize};
-
-fn default_max_retry() -> u32 {
-    10
-}
-fn default_backoff() -> u64 {
-    100
-}
-fn default_cups() -> u64 {
-    100
-}
-fn default_workers() -> usize {
-    4
-}
-fn default_max_concurrency() -> usize {
-    10
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct RpcConfig {
-    #[serde(alias = "endpoint")]
-    pub rpc_url: String,
-    // The threads used in rt, default 4
-    #[serde(default = "default_workers")]
-    pub workers: usize,
-    // The blocking threads to handle rpc tasks, default 10
-    #[serde(default = "default_max_concurrency")]
-    pub max_concurrency: usize,
-    // Retry parameters
-    #[serde(default = "default_max_retry")]
-    pub max_retry: u32,
-    // backoff duration in milliseconds, default 100ms
-    #[serde(default = "default_backoff")]
-    pub backoff: u64,
-    // compute units per second: default 100
-    #[serde(default = "default_cups")]
-    pub cups: u64,
-}
-
-/// An rpc client prover which carrying async runtime,
-/// so it can be run in block mode (i.e. inside dynamic library without a global entry)
-pub struct RpcClientCore {
-    /// rpc prover
-    provider: RootProvider<Network>,
-    rt: tokio::runtime::Runtime,
-}
-
-#[derive(Clone, Copy)]
-pub struct RpcClient<'a> {
-    provider: &'a RootProvider<Network>,
-    handle: &'a tokio::runtime::Handle,
-}
-
-impl RpcClientCore {
-    pub fn create(config: &RpcConfig) -> Result<Self> {
-        let rpc = url::Url::parse(&config.rpc_url)?;
-        tracing::info!("Using RPC: {}", rpc);
-        // note we MUST use multi rt since we have no a main thread for driving
-        // for each call in our method we can acquire a handle of the rt to resolve one or more
-        // async tasks
-        let rt = tokio::runtime::Builder::new_multi_thread()
-            .worker_threads(config.workers)
-            .max_blocking_threads(config.max_concurrency)
-            .enable_all()
-            .build()?;
-
-        let retry_layer = RetryBackoffLayer::new(config.max_retry, config.backoff, config.cups);
-        let client = ClientBuilder::default().layer(retry_layer).http(rpc);
-
-        Ok(Self {
-            provider: ProviderBuilder::<_, _, Network>::default().on_client(client),
-            rt,
-        })
-    }
-
-    pub fn get_client(&self) -> RpcClient {
-        RpcClient {
-            provider: &self.provider,
-            handle: self.rt.handle(),
-        }
-    }
-}
-
-impl ChunkInterpreter for RpcClient<'_> {
-    fn try_fetch_block_witness(
-        &self,
-        block_hash: sbv_primitives::B256,
-        prev_witness: Option<&sbv_primitives::types::BlockWitness>,
-    ) -> Result<sbv_primitives::types::BlockWitness> {
-        async fn fetch_witness_async(
-            provider: &RootProvider<Network>,
-            block_hash: sbv_primitives::B256,
-            prev_witness: Option<&sbv_primitives::types::BlockWitness>,
-        ) -> Result<sbv_primitives::types::BlockWitness> {
-            use alloy::network::primitives::BlockTransactionsKind;
-            use sbv_utils::{rpc::ProviderExt, witness::WitnessBuilder};
-
-            let chain_id = provider.get_chain_id().await?;
-
-            let block = provider
-                .get_block_by_hash(block_hash, BlockTransactionsKind::Full)
-                .await?
-                .ok_or_else(|| eyre::eyre!("Block not found"))?;
-
-            let number = block.header.number;
-            if number == 0 {
-                eyre::bail!("no number in header or use block 0");
-            }
-
-            let prev_state_root = if let Some(witness) = prev_witness {
-                if witness.header.number != number - 1 {
-                    eyre::bail!(
-                        "the ref witness is not the previous block, expected {} get {}",
-                        number - 1,
-                        witness.header.number,
-                    );
-                }
-                witness.header.state_root
-            } else {
-                provider
-                    .scroll_disk_root((number - 1).into())
-                    .await?
-                    .disk_root
-            };
-
-            let witness = WitnessBuilder::new()
-                .block(block)
-                .chain_id(chain_id)
-                .execution_witness(provider.debug_execution_witness(number.into()).await?)
-                .state_root(provider.scroll_disk_root(number.into()).await?.disk_root)?
-                .prev_state_root(prev_state_root)
-                .build()?;
-
-            Ok(witness)
-        }
-
-        tracing::debug!("fetch witness for {block_hash}");
-        self.handle
-            .block_on(fetch_witness_async(self.provider, block_hash, prev_witness))
-    }
-
-    fn try_fetch_storage_node(
-        &self,
-        node_hash: sbv_primitives::B256,
-    ) -> Result<sbv_primitives::Bytes> {
-        async fn fetch_storage_node_async(
-            provider: &RootProvider<Network>,
-            node_hash: sbv_primitives::B256,
-        ) -> Result<sbv_primitives::Bytes> {
-            let ret = provider
-                .client()
-                .request::<_, sbv_primitives::Bytes>("debug_dbGet", (node_hash,))
-                .await?;
-            Ok(ret)
-        }
-
-        tracing::debug!("fetch storage node for {node_hash}");
-        self.handle
-            .block_on(fetch_storage_node_async(self.provider, node_hash))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use alloy::primitives::hex;
-    use sbv_primitives::B256;
-    use std::env;
-
-    fn create_config_from_env() -> RpcConfig {
-        let endpoint =
-            env::var("L2GETH_ENDPOINT").expect("L2GETH_ENDPOINT environment variable must be set");
-
-        let config_json = format!(r#"{{"endpoint": "{}"}}"#, endpoint);
-        serde_json::from_str(&config_json).expect("Failed to parse RPC config")
-    }
-
-    #[test]
-    #[ignore = "Requires L2GETH_ENDPOINT environment variable"]
-    fn test_try_fetch_block_witness() {
-        let config = create_config_from_env();
-        let client_core = RpcClientCore::create(&config).expect("Failed to create RPC client");
-        let client = client_core.get_client();
-
-        // latest - 1 block in 2025.6.15
-        let block_hash = B256::from(
-            hex::const_decode_to_array(
-                b"0x9535a6970bc4db9031749331a214e35ed8c8a3f585f6f456d590a0bc780a1368",
-            )
-            .unwrap(),
-        );
-
-        // This is expected to fail since we're using a dummy hash, but it tests the code path
-        let wit1 = client
-            .try_fetch_block_witness(block_hash, None)
-            .expect("should success");
-
-        // latest block in 2025.6.15
-        let block_hash = B256::from(
-            hex::const_decode_to_array(
-                b"0xd47088cdb6afc68aa082e633bb7da9340d29c73841668afacfb9c1e66e557af0",
-            )
-            .unwrap(),
-        );
-        let wit2 = client
-            .try_fetch_block_witness(block_hash, Some(&wit1))
-            .expect("should success");
-
-        println!("{}", serde_json::to_string_pretty(&wit2).unwrap());
-    }
-
-    #[test]
-    #[ignore = "Requires L2GETH_ENDPOINT environment variable"]
-    fn test_try_fetch_storage_node() {
-        let config = create_config_from_env();
-        let client_core = RpcClientCore::create(&config).expect("Failed to create RPC client");
-        let client = client_core.get_client();
-
-        // the root node (state root) of the block in unittest above
-        let node_hash = B256::from(
-            hex::const_decode_to_array(
-                b"0xb9e67403a2eb35afbb0475fe942918cf9a330a1d7532704c24554506be62b27c",
-            )
-            .unwrap(),
-        );
-
-        // This is expected to fail since we're using a dummy hash, but it tests the code path
-        let node = client
-            .try_fetch_storage_node(node_hash)
-            .expect("should success");
-        println!("{}", serde_json::to_string_pretty(&node).unwrap());
-    }
-}

crates/libzkp/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "libzkp"
-version.workspace = true
-edition.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-[dependencies]
-scroll-zkvm-types.workspace = true
-scroll-zkvm-verifier-euclid.workspace = true
-
-sbv-primitives.workspace = true
-base64.workspace = true
-serde.workspace = true
-serde_derive.workspace = true
-serde_json = { workspace = true, features = ["raw_value"]}
-tracing.workspace = true
-eyre.workspace = true
-
-git-version = "0.3.5"
-serde_stacker = "0.1"
-regex = "1.11"
-c-kzg = { version = "1.0", features = ["serde"] }
-

crates/libzkp/src/lib.rs

@@ -1,121 +0,0 @@
-pub mod proofs;
-pub mod tasks;
-pub mod verifier;
-pub use verifier::{TaskType, VerifierConfig};
-mod utils;
-
-use sbv_primitives::B256;
-use scroll_zkvm_types::util::vec_as_base64;
-use serde::{Deserialize, Serialize};
-use serde_json::value::RawValue;
-use std::path::Path;
-use tasks::chunk_interpreter::{ChunkInterpreter, TryFromWithInterpreter};
-
-/// Turn the coordinator's chunk task into a json string for formal chunk proving
-/// task (with full witnesses)
-pub fn checkout_chunk_task(
-    task_json: &str,
-    interpreter: impl ChunkInterpreter,
-) -> eyre::Result<String> {
-    let chunk_task = serde_json::from_str::<tasks::ChunkTask>(task_json)?;
-    let ret = serde_json::to_string(&tasks::ChunkProvingTask::try_from_with_interpret(
-        chunk_task,
-        interpreter,
-    )?)?;
-    Ok(ret)
-}
-
-/// Generate required staff for proving tasks
-pub fn gen_universal_task(
-    task_type: i32,
-    task_json: &str,
-    fork_name: &str,
-    interpreter: Option<impl ChunkInterpreter>,
-) -> eyre::Result<(B256, String, String)> {
-    use proofs::*;
-    use tasks::*;
-
-    /// Wrapper for metadata
-    #[derive(Clone, Debug, Serialize, Deserialize)]
-    #[serde(untagged)]
-    enum AnyMetaData {
-        Chunk(ChunkProofMetadata),
-        Batch(BatchProofMetadata),
-        Bundle(BundleProofMetadata),
-    }
-
-    let (pi_hash, metadata, u_task) = match task_type {
-        x if x == TaskType::Chunk as i32 => {
-            let task = serde_json::from_str::<ChunkProvingTask>(task_json)?;
-            let (pi_hash, metadata, u_task) =
-                gen_universal_chunk_task(task, fork_name.into(), interpreter)?;
-            (pi_hash, AnyMetaData::Chunk(metadata), u_task)
-        }
-        x if x == TaskType::Batch as i32 => {
-            let task = serde_json::from_str::<BatchProvingTask>(task_json)?;
-            let (pi_hash, metadata, u_task) = gen_universal_batch_task(task, fork_name.into())?;
-            (pi_hash, AnyMetaData::Batch(metadata), u_task)
-        }
-        x if x == TaskType::Bundle as i32 => {
-            let task = serde_json::from_str::<BundleProvingTask>(task_json)?;
-            let (pi_hash, metadata, u_task) = gen_universal_bundle_task(task, fork_name.into())?;
-            (pi_hash, AnyMetaData::Bundle(metadata), u_task)
-        }
-        _ => return Err(eyre::eyre!("unrecognized task type {task_type}")),
-    };
-
-    Ok((
-        pi_hash,
-        serde_json::to_string(&metadata)?,
-        serde_json::to_string(&u_task)?,
-    ))
-}
-
-/// helper to rearrange the proof return by universal prover into corresponding wrapped proof
-pub fn gen_wrapped_proof(proof_json: &str, metadata: &str, vk: &[u8]) -> eyre::Result<String> {
-    #[derive(Serialize)]
-    struct RearrangeWrappedProofJson<'a> {
-        #[serde(borrow)]
-        pub metadata: &'a RawValue,
-        #[serde(borrow)]
-        pub proof: &'a RawValue,
-        #[serde(with = "vec_as_base64", default)]
-        pub vk: Vec<u8>,
-        pub git_version: String,
-    }
-
-    let re_arrange = RearrangeWrappedProofJson {
-        metadata: serde_json::from_str(metadata)?,
-        proof: serde_json::from_str(proof_json)?,
-        vk: vk.to_vec(),
-        git_version: utils::short_git_version(),
-    };
-
-    let ret = serde_json::to_string(&re_arrange)?;
-    Ok(ret)
-}
-
-/// init verifier
-pub fn verifier_init(config: &str) -> eyre::Result<()> {
-    let cfg: VerifierConfig = serde_json::from_str(config)?;
-    verifier::init(cfg);
-    Ok(())
-}
-
-/// verify proof
-pub fn verify_proof(proof: Vec<u8>, fork_name: &str, task_type: TaskType) -> eyre::Result<bool> {
-    let verifier = verifier::get_verifier(fork_name)?;
-
-    let ret = verifier.verify(task_type, proof)?;
-
-    Ok(ret)
-}
-
-/// dump vk
-pub fn dump_vk(fork_name: &str, file: &str) -> eyre::Result<()> {
-    let verifier = verifier::get_verifier(fork_name)?;
-
-    verifier.dump_vk(Path::new(file));
-
-    Ok(())
-}

crates/libzkp/src/proofs.rs

@@ -1,344 +0,0 @@
-use std::path::Path;
-
-use crate::utils::short_git_version;
-use eyre::Result;
-use sbv_primitives::B256;
-use scroll_zkvm_types::{
-    batch::BatchInfo,
-    bundle::BundleInfo,
-    chunk::ChunkInfo,
-    proof::{EvmProof, OpenVmEvmProof, ProofEnum, RootProof},
-    public_inputs::{ForkName, MultiVersionPublicInputs},
-    types_agg::{AggregationInput, ProgramCommitment},
-    util::vec_as_base64,
-};
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
-
-/// A wrapper around the actual inner proof.
-#[derive(Clone, Serialize, Deserialize)]
-pub struct WrappedProof<Metadata> {
-    /// Generic metadata carried by a proof.
-    pub metadata: Metadata,
-    /// The inner proof, either a [`RootProof`] or [`EvmProof`] depending on the
-    /// [`crate::ProverType`].
-    pub proof: ProofEnum,
-    /// Represents the verifying key in serialized form. The purpose of including the verifying key
-    /// along with the proof is to allow a verifier-only mode to identify the source of proof
-    /// generation.
-    ///
-    /// For [`RootProof`] the verifying key is denoted by the digest of the VM's program.
-    ///
-    /// For [`EvmProof`] its the raw bytes of the halo2 circuit's `VerifyingKey`.
-    ///
-    /// We encode the vk in base64 format during JSON serialization.
-    #[serde(with = "vec_as_base64", default)]
-    pub vk: Vec<u8>,
-    /// Represents the git ref for `zkvm-prover` that was used to construct the proof.
-    ///
-    /// This is useful for debugging.
-    pub git_version: String,
-}
-
-pub trait AsRootProof {
-    fn as_root_proof(&self) -> &RootProof;
-}
-
-pub trait AsEvmProof {
-    fn as_evm_proof(&self) -> &EvmProof;
-}
-
-pub trait IntoEvmProof {
-    fn into_evm_proof(self) -> OpenVmEvmProof;
-}
-
-/// Alias for convenience.
-pub type ChunkProof = WrappedProof<ChunkProofMetadata>;
-
-/// Alias for convenience.
-pub type BatchProof = WrappedProof<BatchProofMetadata>;
-
-/// Alias for convenience.
-pub type BundleProof = WrappedProof<BundleProofMetadata>;
-
-impl AsRootProof for ChunkProof {
-    fn as_root_proof(&self) -> &RootProof {
-        self.proof
-            .as_root_proof()
-            .expect("batch proof use root proof")
-    }
-}
-
-impl AsRootProof for BatchProof {
-    fn as_root_proof(&self) -> &RootProof {
-        self.proof
-            .as_root_proof()
-            .expect("batch proof use root proof")
-    }
-}
-
-impl AsEvmProof for BundleProof {
-    fn as_evm_proof(&self) -> &EvmProof {
-        self.proof
-            .as_evm_proof()
-            .expect("bundle proof use evm proof")
-    }
-}
-
-impl IntoEvmProof for BundleProof {
-    fn into_evm_proof(self) -> OpenVmEvmProof {
-        self.proof
-            .as_evm_proof()
-            .expect("bundle proof use evm proof")
-            .clone()
-            .into()
-    }
-}
-
-/// Trait to enable operations in metadata
-pub trait ProofMetadata: Serialize + DeserializeOwned + std::fmt::Debug {
-    type PublicInputs: MultiVersionPublicInputs;
-
-    fn pi_hash_info(&self) -> &Self::PublicInputs;
-
-    fn new_proof<P: Into<ProofEnum>>(self, proof: P, vk: Option<&[u8]>) -> WrappedProof<Self> {
-        WrappedProof {
-            metadata: self,
-            proof: proof.into(),
-            vk: vk.map(Vec::from).unwrap_or_default(),
-            git_version: short_git_version(),
-        }
-    }
-}
-
-pub trait PersistableProof: Sized {
-    /// Read and deserialize the proof.
-    fn from_json<P: AsRef<Path>>(path_proof: P) -> Result<Self>;
-    /// Serialize the proof and dumping at the given path.
-    fn dump<P: AsRef<Path>>(&self, path_proof: P) -> Result<()>;
-}
-
-/// Metadata attached to [`ChunkProof`].
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct ChunkProofMetadata {
-    /// The chunk information describing the list of blocks contained within the chunk.
-    pub chunk_info: ChunkInfo,
-}
-
-impl ProofMetadata for ChunkProofMetadata {
-    type PublicInputs = ChunkInfo;
-
-    fn pi_hash_info(&self) -> &Self::PublicInputs {
-        &self.chunk_info
-    }
-}
-
-/// Metadata attached to [`BatchProof`].
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct BatchProofMetadata {
-    /// The batch information describing the list of chunks.
-    pub batch_info: BatchInfo,
-    /// The [`scroll_zkvm_types::batch::BatchHeader`]'s digest.
-    pub batch_hash: B256,
-}
-
-impl ProofMetadata for BatchProofMetadata {
-    type PublicInputs = BatchInfo;
-
-    fn pi_hash_info(&self) -> &Self::PublicInputs {
-        &self.batch_info
-    }
-}
-
-/// Metadata attached to [`BundleProof`].
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct BundleProofMetadata {
-    /// The bundle information describing the list of batches to be finalised on-chain.
-    pub bundle_info: BundleInfo,
-    /// The public-input digest for the bundle.
-    pub bundle_pi_hash: B256,
-}
-
-impl ProofMetadata for BundleProofMetadata {
-    type PublicInputs = BundleInfo;
-
-    fn pi_hash_info(&self) -> &Self::PublicInputs {
-        &self.bundle_info
-    }
-}
-
-impl<Metadata> From<&WrappedProof<Metadata>> for AggregationInput {
-    fn from(value: &WrappedProof<Metadata>) -> Self {
-        Self {
-            public_values: value.proof.public_values(),
-            commitment: ProgramCommitment::deserialize(&value.vk),
-        }
-    }
-}
-
-impl<Metadata: ProofMetadata> WrappedProof<Metadata> {
-    /// Sanity checks on the wrapped proof:
-    ///
-    /// - pi_hash computed in host does in fact match pi_hash computed in guest
-    pub fn sanity_check(&self, fork_name: ForkName) {
-        let proof_pi = self.proof.public_values();
-
-        let expected_pi = self
-            .metadata
-            .pi_hash_info()
-            .pi_hash_by_fork(fork_name)
-            .0
-            .as_ref()
-            .iter()
-            .map(|&v| v as u32)
-            .collect::<Vec<_>>();
-
-        assert_eq!(
-            expected_pi, proof_pi,
-            "pi mismatch: expected={expected_pi:?}, found={proof_pi:?}"
-        );
-    }
-}
-
-impl<Metadata: ProofMetadata> PersistableProof for WrappedProof<Metadata> {
-    fn from_json<P: AsRef<Path>>(path_proof: P) -> Result<Self> {
-        crate::utils::read_json_deep(path_proof)
-    }
-
-    fn dump<P: AsRef<Path>>(&self, path_proof: P) -> Result<()> {
-        crate::utils::write_json(path_proof, &self)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use base64::{prelude::BASE64_STANDARD, Engine};
-    use sbv_primitives::B256;
-    use scroll_zkvm_types::{
-        bundle::{BundleInfo, BundleInfoV1},
-        proof::EvmProof,
-        public_inputs::PublicInputs,
-    };
-
-    use super::*;
-
-    #[test]
-    fn test_roundtrip() -> eyre::Result<()> {
-        macro_rules! assert_roundtrip {
-            ($fd:expr, $proof:ident) => {
-                let proof_str_expected =
-                    std::fs::read_to_string(std::path::Path::new("./testdata").join($fd))?;
-                let proof = serde_json::from_str::<$proof>(&proof_str_expected)?;
-                let proof_str_got = serde_json::to_string(&proof)?;
-                assert_eq!(proof_str_got, proof_str_expected);
-            };
-        }
-
-        assert_roundtrip!("chunk-proof.json", ChunkProof);
-        assert_roundtrip!("batch-proof.json", BatchProof);
-        assert_roundtrip!("bundle-proof.json", BundleProof);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_dummy_proof() -> eyre::Result<()> {
-        // 1. Metadata
-        let metadata = {
-            let bundle_info: BundleInfoV1 = BundleInfo {
-                chain_id: 12345,
-                num_batches: 12,
-                prev_state_root: B256::repeat_byte(1),
-                prev_batch_hash: B256::repeat_byte(2),
-                post_state_root: B256::repeat_byte(3),
-                batch_hash: B256::repeat_byte(4),
-                withdraw_root: B256::repeat_byte(5),
-                msg_queue_hash: B256::repeat_byte(6),
-            }
-            .into();
-            let bundle_pi_hash = bundle_info.pi_hash();
-            BundleProofMetadata {
-                bundle_info: bundle_info.0,
-                bundle_pi_hash,
-            }
-        };
-
-        // 2. Proof
-        let (proof, proof_base64) = {
-            let proof = std::iter::empty()
-                .chain(std::iter::repeat_n(1, 1))
-                .chain(std::iter::repeat_n(2, 2))
-                .chain(std::iter::repeat_n(3, 3))
-                .chain(std::iter::repeat_n(4, 4))
-                .chain(std::iter::repeat_n(5, 5))
-                .chain(std::iter::repeat_n(6, 6))
-                .chain(std::iter::repeat_n(7, 7))
-                .chain(std::iter::repeat_n(8, 8))
-                .chain(std::iter::repeat_n(9, 9))
-                .collect::<Vec<u8>>();
-            let proof_base64 = BASE64_STANDARD.encode(&proof);
-            (proof, proof_base64)
-        };
-
-        // 3. Instances
-        let (instances, instances_base64) = {
-            // LE: [0x56, 0x34, 0x12, 0x00, 0x00, ..., 0x00]
-            // LE: [0x32, 0x54, 0x76, 0x98, 0x00, ..., 0x00]
-            let instances = std::iter::empty()
-                .chain(std::iter::repeat_n(0x00, 29))
-                .chain(std::iter::once(0x12))
-                .chain(std::iter::once(0x34))
-                .chain(std::iter::once(0x56))
-                .chain(std::iter::repeat_n(0x00, 28))
-                .chain(std::iter::once(0x98))
-                .chain(std::iter::once(0x76))
-                .chain(std::iter::once(0x54))
-                .chain(std::iter::once(0x32))
-                .collect::<Vec<u8>>();
-            let instances_base64 = BASE64_STANDARD.encode(&instances);
-            (instances, instances_base64)
-        };
-
-        // 4. VK
-        let (vk, vk_base64) = {
-            let vk = std::iter::empty()
-                .chain(std::iter::repeat_n(1, 9))
-                .chain(std::iter::repeat_n(2, 8))
-                .chain(std::iter::repeat_n(3, 7))
-                .chain(std::iter::repeat_n(4, 6))
-                .chain(std::iter::repeat_n(5, 5))
-                .chain(std::iter::repeat_n(6, 4))
-                .chain(std::iter::repeat_n(7, 3))
-                .chain(std::iter::repeat_n(8, 2))
-                .chain(std::iter::repeat_n(9, 1))
-                .collect::<Vec<u8>>();
-            let vk_base64 = BASE64_STANDARD.encode(&vk);
-            (vk, vk_base64)
-        };
-
-        let evm_proof = EvmProof { instances, proof };
-        let bundle_proof = metadata.new_proof(evm_proof, Some(vk.as_slice()));
-        let bundle_proof_json = serde_json::to_value(&bundle_proof)?;
-
-        assert_eq!(
-            bundle_proof_json.get("proof").unwrap(),
-            &serde_json::json!({
-                "proof": proof_base64,
-                "instances": instances_base64,
-            }),
-        );
-        assert_eq!(
-            bundle_proof_json.get("vk").unwrap(),
-            &serde_json::Value::String(vk_base64),
-        );
-
-        let bundle_proof_de = serde_json::from_value::<BundleProof>(bundle_proof_json)?;
-
-        assert_eq!(
-            bundle_proof_de.proof.as_evm_proof(),
-            bundle_proof.proof.as_evm_proof()
-        );
-        assert_eq!(bundle_proof_de.vk, bundle_proof.vk);
-
-        Ok(())
-    }
-}

crates/libzkp/src/tasks.rs

@@ -1,76 +0,0 @@
-pub mod batch;
-pub mod bundle;
-pub mod chunk;
-pub mod chunk_interpreter;
-
-pub use batch::BatchProvingTask;
-pub use bundle::BundleProvingTask;
-pub use chunk::{ChunkProvingTask, ChunkTask};
-pub use chunk_interpreter::ChunkInterpreter;
-pub use scroll_zkvm_types::task::ProvingTask;
-
-use crate::proofs::{BatchProofMetadata, BundleProofMetadata, ChunkProofMetadata};
-use chunk_interpreter::{DummyInterpreter, TryFromWithInterpreter};
-use sbv_primitives::B256;
-use scroll_zkvm_types::{
-    chunk::ChunkInfo,
-    public_inputs::{ForkName, MultiVersionPublicInputs},
-};
-
-/// Generate required staff for chunk proving
-pub fn gen_universal_chunk_task(
-    mut task: ChunkProvingTask,
-    fork_name: ForkName,
-    interpreter: Option<impl ChunkInterpreter>,
-) -> eyre::Result<(B256, ChunkProofMetadata, ProvingTask)> {
-    let chunk_info = if let Some(interpreter) = interpreter {
-        ChunkInfo::try_from_with_interpret(&mut task, interpreter)
-    } else {
-        ChunkInfo::try_from_with_interpret(&mut task, DummyInterpreter {})
-    }?;
-    let proving_task = task.try_into()?;
-    let expected_pi_hash = chunk_info.pi_hash_by_fork(fork_name);
-    Ok((
-        expected_pi_hash,
-        ChunkProofMetadata { chunk_info },
-        proving_task,
-    ))
-}
-
-/// Generate required staff for batch proving
-pub fn gen_universal_batch_task(
-    task: BatchProvingTask,
-    fork_name: ForkName,
-) -> eyre::Result<(B256, BatchProofMetadata, ProvingTask)> {
-    let batch_info = task.precheck_and_build_metadata()?;
-    let proving_task = task.try_into()?;
-    let expected_pi_hash = batch_info.pi_hash_by_fork(fork_name);
-
-    Ok((
-        expected_pi_hash,
-        BatchProofMetadata {
-            batch_info,
-            batch_hash: expected_pi_hash,
-        },
-        proving_task,
-    ))
-}
-
-/// Generate required staff for bundle proving
-pub fn gen_universal_bundle_task(
-    task: BundleProvingTask,
-    fork_name: ForkName,
-) -> eyre::Result<(B256, BundleProofMetadata, ProvingTask)> {
-    let bundle_info = task.precheck_and_build_metadata()?;
-    let proving_task = task.try_into()?;
-    let expected_pi_hash = bundle_info.pi_hash_by_fork(fork_name);
-
-    Ok((
-        expected_pi_hash,
-        BundleProofMetadata {
-            bundle_info,
-            bundle_pi_hash: expected_pi_hash,
-        },
-        proving_task,
-    ))
-}

crates/libzkp/src/tasks/batch.rs

@@ -1,253 +0,0 @@
-use crate::proofs::ChunkProof;
-use c_kzg::Bytes48;
-use eyre::Result;
-use sbv_primitives::{B256, U256};
-use scroll_zkvm_types::{
-    batch::{
-        BatchHeader, BatchHeaderV6, BatchHeaderV7, BatchInfo, BatchWitness, EnvelopeV6, EnvelopeV7,
-        PointEvalWitness, ReferenceHeader, N_BLOB_BYTES,
-    },
-    public_inputs::ForkName,
-    task::ProvingTask,
-    utils::{to_rkyv_bytes, RancorError},
-};
-
-mod utils;
-use utils::{base64, point_eval};
-
-/// Define variable batch header type, since BatchHeaderV6 can not
-/// be decoded as V7 we can always has correct deserialization
-/// Notice: V6 header MUST be put above V7 since untagged enum
-/// try to decode each defination in order
-#[derive(Clone, serde::Deserialize, serde::Serialize)]
-#[serde(untagged)]
-pub enum BatchHeaderV {
-    V6(BatchHeaderV6),
-    V7(BatchHeaderV7),
-}
-
-impl From<BatchHeaderV> for ReferenceHeader {
-    fn from(value: BatchHeaderV) -> Self {
-        match value {
-            BatchHeaderV::V6(h) => ReferenceHeader::V6(h),
-            BatchHeaderV::V7(h) => ReferenceHeader::V7(h),
-        }
-    }
-}
-
-impl BatchHeaderV {
-    pub fn batch_hash(&self) -> B256 {
-        match self {
-            BatchHeaderV::V6(h) => h.batch_hash(),
-            BatchHeaderV::V7(h) => h.batch_hash(),
-        }
-    }
-
-    pub fn must_v6_header(&self) -> &BatchHeaderV6 {
-        match self {
-            BatchHeaderV::V6(h) => h,
-            BatchHeaderV::V7(_) => panic!("try to pick v7 header"),
-        }
-    }
-
-    pub fn must_v7_header(&self) -> &BatchHeaderV7 {
-        match self {
-            BatchHeaderV::V7(h) => h,
-            BatchHeaderV::V6(_) => panic!("try to pick v6 header"),
-        }
-    }
-}
-
-/// Defines a proving task for batch proof generation, the format
-/// is compatible with both pre-euclidv2 and euclidv2
-#[derive(Clone, serde::Deserialize, serde::Serialize)]
-pub struct BatchProvingTask {
-    /// Chunk proofs for the contiguous list of chunks within the batch.
-    pub chunk_proofs: Vec<ChunkProof>,
-    /// The [`BatchHeaderV6/V7`], as computed on-chain for this batch.
-    pub batch_header: BatchHeaderV,
-    /// The bytes encoding the batch data that will finally be published on-chain in the form of an
-    /// EIP-4844 blob.
-    #[serde(with = "base64")]
-    pub blob_bytes: Vec<u8>,
-    /// Challenge digest computed using the blob's bytes and versioned hash.
-    pub challenge_digest: Option<U256>,
-    /// KZG commitment for the blob.
-    pub kzg_commitment: Option<Bytes48>,
-    /// KZG proof.
-    pub kzg_proof: Option<Bytes48>,
-    /// fork version specify, for sanity check with batch_header and chunk proof
-    pub fork_name: String,
-}
-
-impl TryFrom<BatchProvingTask> for ProvingTask {
-    type Error = eyre::Error;
-
-    fn try_from(value: BatchProvingTask) -> Result<Self> {
-        let witness = value.build_guest_input();
-
-        Ok(ProvingTask {
-            identifier: value.batch_header.batch_hash().to_string(),
-            fork_name: value.fork_name,
-            aggregated_proofs: value
-                .chunk_proofs
-                .into_iter()
-                .map(|w_proof| w_proof.proof.into_root_proof().expect("expect root proof"))
-                .collect(),
-            serialized_witness: vec![to_rkyv_bytes::<RancorError>(&witness)?.into_vec()],
-            vk: Vec::new(),
-        })
-    }
-}
-
-impl BatchProvingTask {
-    fn build_guest_input(&self) -> BatchWitness {
-        let fork_name = self.fork_name.to_lowercase().as_str().into();
-
-        // calculate point eval needed and compare with task input
-        let (kzg_commitment, kzg_proof, challenge_digest) = {
-            let blob = point_eval::to_blob(&self.blob_bytes);
-            let commitment = point_eval::blob_to_kzg_commitment(&blob);
-            let versioned_hash = point_eval::get_versioned_hash(&commitment);
-            let challenge_digest = match &self.batch_header {
-                BatchHeaderV::V6(_) => {
-                    assert_eq!(
-                        fork_name,
-                        ForkName::EuclidV1,
-                        "hardfork mismatch for da-codec@v6 header: found={fork_name:?}, expected={:?}",
-                        ForkName::EuclidV1,
-                    );
-                    EnvelopeV6::from(self.blob_bytes.as_slice()).challenge_digest(versioned_hash)
-                }
-                BatchHeaderV::V7(_) => {
-                    assert_eq!(
-                        fork_name,
-                        ForkName::EuclidV2,
-                        "hardfork mismatch for da-codec@v7 header: found={fork_name:?}, expected={:?}",
-                        ForkName::EuclidV2,
-                    );
-                    let padded_blob_bytes = {
-                        let mut padded_blob_bytes = self.blob_bytes.to_vec();
-                        padded_blob_bytes.resize(N_BLOB_BYTES, 0);
-                        padded_blob_bytes
-                    };
-                    EnvelopeV7::from(padded_blob_bytes.as_slice()).challenge_digest(versioned_hash)
-                }
-            };
-
-            let (proof, _) = point_eval::get_kzg_proof(&blob, challenge_digest);
-
-            (commitment.to_bytes(), proof.to_bytes(), challenge_digest)
-        };
-
-        if let Some(k) = self.kzg_commitment {
-            assert_eq!(k, kzg_commitment);
-        }
-
-        if let Some(c) = self.challenge_digest {
-            assert_eq!(c, U256::from_be_bytes(challenge_digest.0));
-        }
-
-        if let Some(p) = self.kzg_proof {
-            assert_eq!(p, kzg_proof);
-        }
-
-        let point_eval_witness = PointEvalWitness {
-            kzg_commitment: kzg_commitment.into_inner(),
-            kzg_proof: kzg_proof.into_inner(),
-        };
-
-        let reference_header = self.batch_header.clone().into();
-
-        BatchWitness {
-            fork_name,
-            chunk_proofs: self.chunk_proofs.iter().map(|proof| proof.into()).collect(),
-            chunk_infos: self
-                .chunk_proofs
-                .iter()
-                .map(|p| p.metadata.chunk_info.clone())
-                .collect(),
-            blob_bytes: self.blob_bytes.clone(),
-            reference_header,
-            point_eval_witness,
-        }
-    }
-
-    pub fn precheck_and_build_metadata(&self) -> Result<BatchInfo> {
-        let fork_name = ForkName::from(self.fork_name.as_str());
-        let (parent_state_root, state_root, chain_id, withdraw_root) = (
-            self.chunk_proofs
-                .first()
-                .expect("at least one chunk in batch")
-                .metadata
-                .chunk_info
-                .prev_state_root,
-            self.chunk_proofs
-                .last()
-                .expect("at least one chunk in batch")
-                .metadata
-                .chunk_info
-                .post_state_root,
-            self.chunk_proofs
-                .last()
-                .expect("at least one chunk in batch")
-                .metadata
-                .chunk_info
-                .chain_id,
-            self.chunk_proofs
-                .last()
-                .expect("at least one chunk in batch")
-                .metadata
-                .chunk_info
-                .withdraw_root,
-        );
-        let (parent_batch_hash, prev_msg_queue_hash, post_msg_queue_hash) = match self.batch_header
-        {
-            BatchHeaderV::V6(h) => {
-                assert_eq!(
-                    fork_name,
-                    ForkName::EuclidV1,
-                    "hardfork mismatch for da-codec@v6 header: found={fork_name:?}, expected={:?}",
-                    ForkName::EuclidV1,
-                );
-                (h.parent_batch_hash, Default::default(), Default::default())
-            }
-            BatchHeaderV::V7(h) => {
-                assert_eq!(
-                    fork_name,
-                    ForkName::EuclidV2,
-                    "hardfork mismatch for da-codec@v7 header: found={fork_name:?}, expected={:?}",
-                    ForkName::EuclidV2,
-                );
-                (
-                    h.parent_batch_hash,
-                    self.chunk_proofs
-                        .first()
-                        .expect("at least one chunk in batch")
-                        .metadata
-                        .chunk_info
-                        .prev_msg_queue_hash,
-                    self.chunk_proofs
-                        .last()
-                        .expect("at least one chunk in batch")
-                        .metadata
-                        .chunk_info
-                        .post_msg_queue_hash,
-                )
-            }
-        };
-
-        let batch_hash = self.batch_header.batch_hash();
-
-        Ok(BatchInfo {
-            parent_state_root,
-            parent_batch_hash,
-            state_root,
-            batch_hash,
-            chain_id,
-            withdraw_root,
-            prev_msg_queue_hash,
-            post_msg_queue_hash,
-        })
-    }
-}

crates/libzkp/src/tasks/batch/utils.rs

@@ -1,77 +0,0 @@
-pub mod base64 {
-    use base64::prelude::*;
-    use serde::{Deserialize, Deserializer, Serialize, Serializer};
-
-    pub fn serialize<S: Serializer>(v: &Vec<u8>, s: S) -> Result<S::Ok, S::Error> {
-        let base64 = BASE64_STANDARD.encode(v);
-        String::serialize(&base64, s)
-    }
-
-    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<u8>, D::Error> {
-        let base64 = String::deserialize(d)?;
-        BASE64_STANDARD
-            .decode(base64.as_bytes())
-            .map_err(serde::de::Error::custom)
-    }
-}
-
-pub mod point_eval {
-    use c_kzg;
-    use sbv_primitives::{types::eips::eip4844::BLS_MODULUS, B256 as H256, U256};
-    use scroll_zkvm_types::util::sha256_rv32;
-
-    /// Given the blob-envelope, translate it to a fixed size EIP-4844 blob.
-    ///
-    /// For every 32-bytes chunk in the blob, the most-significant byte is set to 0 while the other
-    /// 31 bytes are copied from the provided blob-envelope.
-    pub fn to_blob(envelope_bytes: &[u8]) -> c_kzg::Blob {
-        let mut blob_bytes = [0u8; c_kzg::BYTES_PER_BLOB];
-
-        assert!(
-            envelope_bytes.len()
-                <= c_kzg::FIELD_ELEMENTS_PER_BLOB * (c_kzg::BYTES_PER_FIELD_ELEMENT - 1),
-            "too many bytes in blob envelope",
-        );
-
-        for (i, &byte) in envelope_bytes.iter().enumerate() {
-            blob_bytes[(i / 31) * 32 + 1 + (i % 31)] = byte;
-        }
-
-        c_kzg::Blob::new(blob_bytes)
-    }
-
-    /// Get the KZG commitment from an EIP-4844 blob.
-    pub fn blob_to_kzg_commitment(blob: &c_kzg::Blob) -> c_kzg::KzgCommitment {
-        c_kzg::KzgCommitment::blob_to_kzg_commitment(blob, c_kzg::ethereum_kzg_settings())
-            .expect("blob to kzg commitment should succeed")
-    }
-
-    /// The version for KZG as per EIP-4844.
-    const VERSIONED_HASH_VERSION_KZG: u8 = 1;
-
-    /// Get the EIP-4844 versioned hash from the KZG commitment.
-    pub fn get_versioned_hash(commitment: &c_kzg::KzgCommitment) -> H256 {
-        let mut hash: [u8; 32] = sha256_rv32(commitment.to_bytes().as_slice()).into();
-        hash[0] = VERSIONED_HASH_VERSION_KZG;
-        H256::new(hash)
-    }
-
-    /// Get x for kzg proof from challenge hash
-    pub fn get_x_from_challenge(challenge: H256) -> U256 {
-        U256::from_be_bytes(challenge.0) % BLS_MODULUS
-    }
-
-    /// Generate KZG proof and evaluation given the blob (polynomial) and a random challenge.
-    pub fn get_kzg_proof(blob: &c_kzg::Blob, challenge: H256) -> (c_kzg::KzgProof, U256) {
-        let challenge = get_x_from_challenge(challenge);
-
-        let (proof, y) = c_kzg::KzgProof::compute_kzg_proof(
-            blob,
-            &c_kzg::Bytes32::new(challenge.to_be_bytes()),
-            c_kzg::ethereum_kzg_settings(),
-        )
-        .expect("kzg proof should succeed");
-
-        (proof, U256::from_be_slice(y.as_slice()))
-    }
-}

crates/libzkp/src/tasks/bundle.rs

@@ -1,125 +0,0 @@
-use crate::proofs::BatchProof;
-use eyre::Result;
-use scroll_zkvm_types::{
-    bundle::{BundleInfo, BundleWitness},
-    task::ProvingTask,
-    utils::{to_rkyv_bytes, RancorError},
-};
-
-/// Message indicating a sanity check failure.
-const BUNDLE_SANITY_MSG: &str = "bundle must have at least one batch";
-
-#[derive(Clone, serde::Deserialize, serde::Serialize)]
-pub struct BundleProvingTask {
-    pub batch_proofs: Vec<BatchProof>,
-    /// for sanity check
-    pub bundle_info: Option<BundleInfo>,
-    /// Fork name specify
-    pub fork_name: String,
-}
-
-impl BundleProvingTask {
-    fn identifier(&self) -> String {
-        assert!(!self.batch_proofs.is_empty(), "{BUNDLE_SANITY_MSG}",);
-
-        let (first, last) = (
-            self.batch_proofs
-                .first()
-                .expect(BUNDLE_SANITY_MSG)
-                .metadata
-                .batch_hash,
-            self.batch_proofs
-                .last()
-                .expect(BUNDLE_SANITY_MSG)
-                .metadata
-                .batch_hash,
-        );
-
-        format!("{first}-{last}")
-    }
-
-    fn build_guest_input(&self) -> BundleWitness {
-        BundleWitness {
-            batch_proofs: self.batch_proofs.iter().map(|proof| proof.into()).collect(),
-            batch_infos: self
-                .batch_proofs
-                .iter()
-                .map(|wrapped_proof| wrapped_proof.metadata.batch_info.clone())
-                .collect(),
-        }
-    }
-
-    pub fn precheck_and_build_metadata(&self) -> Result<BundleInfo> {
-        use eyre::eyre;
-        let err_prefix = format!("metadata_with_prechecks for task_id={}", self.identifier());
-
-        for w in self.batch_proofs.windows(2) {
-            if w[1].metadata.batch_info.chain_id != w[0].metadata.batch_info.chain_id {
-                return Err(eyre!("{err_prefix}: chain_id mismatch"));
-            }
-
-            if w[1].metadata.batch_info.parent_state_root != w[0].metadata.batch_info.state_root {
-                return Err(eyre!("{err_prefix}: state_root not chained"));
-            }
-
-            if w[1].metadata.batch_info.parent_batch_hash != w[0].metadata.batch_info.batch_hash {
-                return Err(eyre!("{err_prefix}: batch_hash not chained"));
-            }
-        }
-
-        let (first_batch, last_batch) = (
-            &self
-                .batch_proofs
-                .first()
-                .expect("at least one batch in bundle")
-                .metadata
-                .batch_info,
-            &self
-                .batch_proofs
-                .last()
-                .expect("at least one batch in bundle")
-                .metadata
-                .batch_info,
-        );
-
-        let chain_id = first_batch.chain_id;
-        let num_batches = u32::try_from(self.batch_proofs.len()).expect("num_batches: u32");
-        let prev_state_root = first_batch.parent_state_root;
-        let prev_batch_hash = first_batch.parent_batch_hash;
-        let post_state_root = last_batch.state_root;
-        let batch_hash = last_batch.batch_hash;
-        let withdraw_root = last_batch.withdraw_root;
-        let msg_queue_hash = last_batch.post_msg_queue_hash;
-
-        Ok(BundleInfo {
-            chain_id,
-            msg_queue_hash,
-            num_batches,
-            prev_state_root,
-            prev_batch_hash,
-            post_state_root,
-            batch_hash,
-            withdraw_root,
-        })
-    }
-}
-
-impl TryFrom<BundleProvingTask> for ProvingTask {
-    type Error = eyre::Error;
-
-    fn try_from(value: BundleProvingTask) -> Result<Self> {
-        let witness = value.build_guest_input();
-
-        Ok(ProvingTask {
-            identifier: value.identifier(),
-            fork_name: value.fork_name,
-            aggregated_proofs: value
-                .batch_proofs
-                .into_iter()
-                .map(|w_proof| w_proof.proof.into_root_proof().expect("expect root proof"))
-                .collect(),
-            serialized_witness: vec![to_rkyv_bytes::<RancorError>(&witness)?.to_vec()],
-            vk: Vec::new(),
-        })
-    }
-}

crates/libzkp/src/tasks/chunk.rs

@@ -1,185 +0,0 @@
-use super::chunk_interpreter::*;
-use eyre::Result;
-use sbv_primitives::{types::BlockWitness, B256};
-use scroll_zkvm_types::{
-    chunk::{execute, ChunkInfo, ChunkWitness},
-    task::ProvingTask,
-    utils::{to_rkyv_bytes, RancorError},
-};
-
-/// The type aligned with coordinator's defination
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct ChunkTask {
-    /// block hashes for a series of block
-    pub block_hashes: Vec<B256>,
-    /// The on-chain L1 msg queue hash before applying L1 msg txs from the chunk.
-    pub prev_msg_queue_hash: B256,
-    /// Fork name specify
-    pub fork_name: String,
-}
-
-impl TryFromWithInterpreter<ChunkTask> for ChunkProvingTask {
-    fn try_from_with_interpret(
-        value: ChunkTask,
-        interpreter: impl ChunkInterpreter,
-    ) -> Result<Self> {
-        let mut block_witnesses = Vec::new();
-        for block_hash in value.block_hashes {
-            let witness =
-                interpreter.try_fetch_block_witness(block_hash, block_witnesses.last())?;
-            block_witnesses.push(witness);
-        }
-
-        Ok(Self {
-            block_witnesses,
-            prev_msg_queue_hash: value.prev_msg_queue_hash,
-            fork_name: value.fork_name,
-        })
-    }
-}
-
-/// Message indicating a sanity check failure.
-const CHUNK_SANITY_MSG: &str = "chunk must have at least one block";
-
-/// Proving task for the [`ChunkCircuit`][scroll_zkvm_chunk_circuit].
-///
-/// The identifier for a chunk proving task is:
-/// - {first_block_number}-{last_block_number}
-#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
-pub struct ChunkProvingTask {
-    /// Witnesses for every block in the chunk.
-    pub block_witnesses: Vec<BlockWitness>,
-    /// The on-chain L1 msg queue hash before applying L1 msg txs from the chunk.
-    pub prev_msg_queue_hash: B256,
-    /// Fork name specify
-    pub fork_name: String,
-}
-
-#[derive(Clone, Debug)]
-pub struct ChunkDetails {
-    pub num_blocks: usize,
-    pub num_txs: usize,
-    pub total_gas_used: u64,
-}
-
-impl TryFrom<ChunkProvingTask> for ProvingTask {
-    type Error = eyre::Error;
-
-    fn try_from(value: ChunkProvingTask) -> Result<Self> {
-        let witness = value.build_guest_input();
-
-        Ok(ProvingTask {
-            identifier: value.identifier(),
-            fork_name: value.fork_name,
-            aggregated_proofs: Vec::new(),
-            serialized_witness: vec![to_rkyv_bytes::<RancorError>(&witness)?.to_vec()],
-            vk: Vec::new(),
-        })
-    }
-}
-
-impl ChunkProvingTask {
-    pub fn stats(&self) -> ChunkDetails {
-        let num_blocks = self.block_witnesses.len();
-        let num_txs = self
-            .block_witnesses
-            .iter()
-            .map(|b| b.transaction.len())
-            .sum::<usize>();
-        let total_gas_used = self
-            .block_witnesses
-            .iter()
-            .map(|b| b.header.gas_used)
-            .sum::<u64>();
-
-        ChunkDetails {
-            num_blocks,
-            num_txs,
-            total_gas_used,
-        }
-    }
-
-    fn identifier(&self) -> String {
-        assert!(!self.block_witnesses.is_empty(), "{CHUNK_SANITY_MSG}",);
-
-        let (first, last) = (
-            self.block_witnesses
-                .first()
-                .expect(CHUNK_SANITY_MSG)
-                .header
-                .number,
-            self.block_witnesses
-                .last()
-                .expect(CHUNK_SANITY_MSG)
-                .header
-                .number,
-        );
-
-        format!("{first}-{last}")
-    }
-
-    fn build_guest_input(&self) -> ChunkWitness {
-        ChunkWitness {
-            blocks: self.block_witnesses.to_vec(),
-            prev_msg_queue_hash: self.prev_msg_queue_hash,
-            fork_name: self.fork_name.to_lowercase().as_str().into(),
-        }
-    }
-
-    fn insert_state(&mut self, node: sbv_primitives::Bytes) {
-        self.block_witnesses[0].states.push(node);
-    }
-}
-
-const MAX_FETCH_NODES_ATTEMPTS: usize = 15;
-
-impl TryFromWithInterpreter<&mut ChunkProvingTask> for ChunkInfo {
-    fn try_from_with_interpret(
-        value: &mut ChunkProvingTask,
-        interpreter: impl ChunkInterpreter,
-    ) -> eyre::Result<Self> {
-        use eyre::eyre;
-
-        let err_prefix = format!(
-            "metadata_with_prechecks for task_id={:?}",
-            value.identifier()
-        );
-
-        if value.block_witnesses.is_empty() {
-            return Err(eyre!(
-                "{err_prefix}: chunk should contain at least one block",
-            ));
-        }
-
-        // resume from node missing error and keep executing process
-        let pattern = r"SparseTrieError\(BlindedNode \{ path: Nibbles\((0x[0-9a-fA-F]+)\), hash: (0x[0-9a-fA-F]+) \}\)";
-        let err_parse_re = regex::Regex::new(pattern)?;
-        let mut attempts = 0;
-        loop {
-            match execute(&value.build_guest_input()) {
-                Ok(chunk_info) => return Ok(chunk_info),
-                Err(e) => {
-                    if let Some(caps) = err_parse_re.captures(&e) {
-                        let hash = caps[2].to_string();
-                        tracing::debug!("missing trie hash {hash}");
-
-                        attempts += 1;
-                        if attempts >= MAX_FETCH_NODES_ATTEMPTS {
-                            return Err(eyre!(
-                            "failed to fetch nodes after {MAX_FETCH_NODES_ATTEMPTS} attempts: {e}"
-                        ));
-                        }
-
-                        let node_hash =
-                            hash.parse::<sbv_primitives::B256>().expect("should be hex");
-                        let node = interpreter.try_fetch_storage_node(node_hash)?;
-                        tracing::warn!("missing node fetched: {node}");
-                        value.insert_state(node);
-                    } else {
-                        return Err(eyre!("{err_prefix}: {e}"));
-                    }
-                }
-            }
-        }
-    }
-}

crates/libzkp/src/tasks/chunk_interpreter.rs

@@ -1,26 +0,0 @@
-use eyre::Result;
-use sbv_primitives::{types::BlockWitness, Bytes, B256};
-
-/// An interpreter which is cirtical in translating chunk data
-/// since we need to grep block witness and storage node data
-/// (in rare case) from external
-pub trait ChunkInterpreter {
-    fn try_fetch_block_witness(
-        &self,
-        _block_hash: B256,
-        _prev_witness: Option<&BlockWitness>,
-    ) -> Result<BlockWitness> {
-        Err(eyre::eyre!("no implement"))
-    }
-    fn try_fetch_storage_node(&self, _node_hash: B256) -> Result<Bytes> {
-        Err(eyre::eyre!("no implement"))
-    }
-}
-
-pub trait TryFromWithInterpreter<T>: Sized {
-    fn try_from_with_interpret(value: T, intepreter: impl ChunkInterpreter) -> Result<Self>;
-}
-
-pub struct DummyInterpreter {}
-
-impl ChunkInterpreter for DummyInterpreter {}

crates/libzkp/src/utils.rs

@@ -1,53 +0,0 @@
-use std::{
-    panic::{catch_unwind, AssertUnwindSafe},
-    path::Path,
-};
-
-use git_version::git_version;
-use serde::{
-    de::{Deserialize, DeserializeOwned},
-    Serialize,
-};
-
-use eyre::Result;
-
-const GIT_VERSION: &str = git_version!(args = ["--abbrev=7", "--always"]);
-
-/// Shortened git commit ref from [`scroll_zkvm_prover`].
-pub(crate) fn short_git_version() -> String {
-    let commit_version = GIT_VERSION.split('-').next_back().unwrap();
-
-    // Check if use commit object as fallback.
-    if commit_version.len() < 8 {
-        commit_version.to_string()
-    } else {
-        commit_version[1..8].to_string()
-    }
-}
-
-/// Wrapper to read JSON that might be deeply nested.
-pub(crate) fn read_json_deep<P: AsRef<Path>, T: DeserializeOwned>(path: P) -> Result<T> {
-    let fd = std::fs::File::open(path)?;
-    let mut deserializer = serde_json::Deserializer::from_reader(fd);
-    deserializer.disable_recursion_limit();
-    let deserializer = serde_stacker::Deserializer::new(&mut deserializer);
-    Ok(Deserialize::deserialize(deserializer)?)
-}
-
-/// Serialize the provided type to JSON format and write to the given path.
-pub(crate) fn write_json<P: AsRef<Path>, T: Serialize>(path: P, value: &T) -> Result<()> {
-    let mut writer = std::fs::File::create(path)?;
-    Ok(serde_json::to_writer(&mut writer, value)?)
-}
-
-pub(crate) fn panic_catch<F: FnOnce() -> R, R>(f: F) -> Result<R, String> {
-    catch_unwind(AssertUnwindSafe(f)).map_err(|err| {
-        if let Some(s) = err.downcast_ref::<String>() {
-            s.to_string()
-        } else if let Some(s) = err.downcast_ref::<&str>() {
-            s.to_string()
-        } else {
-            format!("unable to get panic info {err:?}")
-        }
-    })
-}

crates/libzkp_c/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "libzkp-c"
-version.workspace = true
-edition.workspace = true
-
-[lib]
-name = "zkp"
-crate-type = ["cdylib"]
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-[dependencies]
-libzkp = { path = "../libzkp" }
-l2geth = { path = "../l2geth"}
-tracing.workspace = true

crates/libzkp_c/src/lib.rs

@@ -1,167 +0,0 @@
-mod utils;
-
-use std::ffi::{c_char, CString};
-
-use libzkp::TaskType;
-use utils::{c_char_to_str, c_char_to_vec};
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn init_verifier(config: *const c_char) {
-    let config_str = c_char_to_str(config);
-    libzkp::verifier_init(config_str).unwrap();
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn init_l2geth(config: *const c_char) {
-    let config_str = c_char_to_str(config);
-    l2geth::init(config_str).unwrap();
-}
-
-fn verify_proof(proof: *const c_char, fork_name: *const c_char, task_type: TaskType) -> c_char {
-    let fork_name_str = c_char_to_str(fork_name);
-    let proof = c_char_to_vec(proof);
-
-    match libzkp::verify_proof(proof, fork_name_str, task_type) {
-        Err(e) => {
-            tracing::error!("{:?} verify failed, error: {:#}", task_type, e);
-            false as c_char
-        }
-        Ok(result) => result as c_char,
-    }
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn verify_chunk_proof(
-    proof: *const c_char,
-    fork_name: *const c_char,
-) -> c_char {
-    verify_proof(proof, fork_name, TaskType::Chunk)
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn verify_batch_proof(
-    proof: *const c_char,
-    fork_name: *const c_char,
-) -> c_char {
-    verify_proof(proof, fork_name, TaskType::Batch)
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn verify_bundle_proof(
-    proof: *const c_char,
-    fork_name: *const c_char,
-) -> c_char {
-    verify_proof(proof, fork_name, TaskType::Bundle)
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn dump_vk(fork_name: *const c_char, file: *const c_char) {
-    let fork_name_str = c_char_to_str(fork_name);
-    let file_str = c_char_to_str(file);
-    libzkp::dump_vk(fork_name_str, file_str).unwrap();
-}
-
-// Define a struct to hold handling results
-#[repr(C)]
-pub struct HandlingResult {
-    ok: c_char,
-    universal_task: *mut c_char,
-    metadata: *mut c_char,
-    expected_pi_hash: [c_char; 32],
-}
-
-fn failed_handling_result() -> HandlingResult {
-    HandlingResult {
-        ok: false as c_char,
-        universal_task: std::ptr::null_mut(),
-        metadata: std::ptr::null_mut(),
-        expected_pi_hash: Default::default(),
-    }
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn gen_universal_task(
-    task_type: i32,
-    task: *const c_char,
-    fork_name: *const c_char,
-) -> HandlingResult {
-    let mut interpreter = None;
-    let task_json = if task_type == TaskType::Chunk as i32 {
-        let pre_task_str = c_char_to_str(task);
-        let cli = l2geth::get_client();
-        match libzkp::checkout_chunk_task(pre_task_str, cli) {
-            Ok(str) => {
-                interpreter.replace(cli);
-                str
-            }
-            Err(e) => {
-                tracing::error!("gen_universal_task failed at pre interpret step, error: {e}");
-                return failed_handling_result();
-            }
-        }
-    } else {
-        c_char_to_str(task).to_string()
-    };
-    let ret =
-        libzkp::gen_universal_task(task_type, &task_json, c_char_to_str(fork_name), interpreter);
-
-    if let Ok((pi_hash, task_json, meta_json)) = ret {
-        let expected_pi_hash = pi_hash.0.map(|byte| byte as c_char);
-        HandlingResult {
-            ok: true as c_char,
-            universal_task: CString::new(task_json).unwrap().into_raw(),
-            metadata: CString::new(meta_json).unwrap().into_raw(),
-            expected_pi_hash,
-        }
-    } else {
-        tracing::error!("gen_universal_task failed, error: {:#}", ret.unwrap_err());
-        failed_handling_result()
-    }
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn release_task_result(result: HandlingResult) {
-    if !result.universal_task.is_null() {
-        let _ = CString::from_raw(result.universal_task);
-    }
-    if !result.metadata.is_null() {
-        let _ = CString::from_raw(result.metadata);
-    }
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn gen_wrapped_proof(
-    proof: *const c_char,
-    metadata: *const c_char,
-    vk: *const c_char,
-    vk_len: usize,
-) -> *mut c_char {
-    let proof_str = c_char_to_str(proof);
-    let metadata_str = c_char_to_str(metadata);
-    let vk_data = std::slice::from_raw_parts(vk as *const u8, vk_len);
-
-    match libzkp::gen_wrapped_proof(proof_str, metadata_str, vk_data) {
-        Ok(result) => CString::new(result).unwrap().into_raw(),
-        Err(e) => {
-            tracing::error!("gen_wrapped_proof failed, error: {:#}", e);
-            std::ptr::null_mut()
-        }
-    }
-}
-
-/// # Safety
-#[no_mangle]
-pub unsafe extern "C" fn release_string(ptr: *mut c_char) {
-    if !ptr.is_null() {
-        let _ = CString::from_raw(ptr);
-    }
-}

crates/libzkp_c/src/utils.rs

@@ -1,11 +0,0 @@
-use std::{ffi::CStr, os::raw::c_char};
-
-pub(crate) fn c_char_to_str(c: *const c_char) -> &'static str {
-    let cstr = unsafe { CStr::from_ptr(c) };
-    cstr.to_str().unwrap()
-}
-
-pub(crate) fn c_char_to_vec(c: *const c_char) -> Vec<u8> {
-    let cstr = unsafe { CStr::from_ptr(c) };
-    cstr.to_bytes().to_vec()
-}

crates/prover-bin/Cargo.toml

@@ -1,34 +0,0 @@
-[package]
-name = "prover"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-scroll-zkvm-types.workspace = true
-scroll-zkvm-prover-euclid.workspace = true
-scroll-proving-sdk = { git = "https://github.com/scroll-tech/scroll-proving-sdk.git", branch = "refactor/scroll" }
-serde.workspace = true
-serde_json.workspace = true
-once_cell.workspace =true
-base64.workspace = true
-tiny-keccak = { workspace = true, features = ["sha3", "keccak"] }
-eyre.workspace = true
-
-futures = "0.3.30"
-
-reqwest = { version = "0.12.4", features = ["gzip"] }
-reqwest-middleware = "0.3"
-reqwest-retry = "0.5"
-hex = "0.4.3"
-
-rand = "0.8.5"
-tokio = "1.37.0"
-async-trait = "0.1"
-sled = "0.34.7"
-http = "1.1.0"
-clap = { version = "4.5", features = ["derive"] }
-ctor = "0.2.8"
-url = "2.5.4"
-serde_bytes = "0.11.15"

crates/prover-bin/README.md

@@ -1,11 +0,0 @@
-## Prover
-
-A runnable zkvm prover which can communicate with coordinator, receving proving task and generate proof
-
-## Testing
-
-+ Get the url of the endpoint of coordinator and a rpc endpoint response to the cooresponding chain
-
-+ Build a `config.json` file with previous knowledge from the template in current directory
-
-+ Call `make test_run`

crates/prover-bin/src/zk_circuits_handler.rs

@@ -1,67 +0,0 @@
-//pub mod euclid;
-
-#[allow(non_snake_case)]
-pub mod euclidV2;
-
-use async_trait::async_trait;
-use eyre::Result;
-use scroll_proving_sdk::prover::{proving_service::ProveRequest, ProofType};
-use scroll_zkvm_prover_euclid::ProverConfig;
-use std::path::Path;
-
-#[async_trait]
-pub trait CircuitsHandler: Sync + Send {
-    async fn get_vk(&self, task_type: ProofType) -> Option<Vec<u8>>;
-
-    async fn get_proof_data(&self, prove_request: ProveRequest) -> Result<String>;
-}
-
-#[derive(Clone, Copy)]
-pub(crate) enum Phase {
-    EuclidV2,
-}
-
-impl Phase {
-    pub fn phase_spec_chunk(&self, workspace_path: &Path) -> ProverConfig {
-        let dir_cache = Some(workspace_path.join("cache"));
-        let path_app_exe = workspace_path.join("chunk/app.vmexe");
-        let path_app_config = workspace_path.join("chunk/openvm.toml");
-        let segment_len = Some((1 << 22) - 100);
-        ProverConfig {
-            dir_cache,
-            path_app_config,
-            path_app_exe,
-            segment_len,
-            ..Default::default()
-        }
-    }
-
-    pub fn phase_spec_batch(&self, workspace_path: &Path) -> ProverConfig {
-        let dir_cache = Some(workspace_path.join("cache"));
-        let path_app_exe = workspace_path.join("batch/app.vmexe");
-        let path_app_config = workspace_path.join("batch/openvm.toml");
-        let segment_len = Some((1 << 22) - 100);
-        ProverConfig {
-            dir_cache,
-            path_app_config,
-            path_app_exe,
-            segment_len,
-            ..Default::default()
-        }
-    }
-
-    pub fn phase_spec_bundle(&self, workspace_path: &Path) -> ProverConfig {
-        let dir_cache = Some(workspace_path.join("cache"));
-        let path_app_config = workspace_path.join("bundle/openvm.toml");
-        let segment_len = Some((1 << 22) - 100);
-        match self {
-            Phase::EuclidV2 => ProverConfig {
-                dir_cache,
-                path_app_config,
-                segment_len,
-                path_app_exe: workspace_path.join("bundle/app.vmexe"),
-                ..Default::default()
-            },
-        }
-    }
-}

database/migrate/migrate_test.go

@@ -59,20 +59,20 @@ func testResetDB(t *testing.T) {
 	cur, err := Current(pgDB)
 	assert.NoError(t, err)
 	// total number of tables.
-	assert.Equal(t, int64(28), cur)
+	assert.Equal(t, int64(27), cur)
 }
 
 func testMigrate(t *testing.T) {
 	assert.NoError(t, Migrate(pgDB))
 	cur, err := Current(pgDB)
 	assert.NoError(t, err)
-	assert.Equal(t, int64(28), cur)
+	assert.Equal(t, int64(27), cur)
 }
 
 func testRollback(t *testing.T) {
 	version, err := Current(pgDB)
 	assert.NoError(t, err)
-	assert.Equal(t, int64(28), version)
+	assert.Equal(t, int64(27), version)
 
 	assert.NoError(t, Rollback(pgDB, nil))
 

database/migrate/migrations/00028_add_metadata_to_prover_task.sql

@@ -1,15 +0,0 @@
--- +goose Up
--- +goose StatementBegin
-
-ALTER TABLE prover_task
-ADD COLUMN metadata BYTEA;
-
--- +goose StatementEnd
-
--- +goose Down
--- +goose StatementBegin
-
-ALTER TABLE IF EXISTS prover_task
-DROP COLUMN IF EXISTS metadata;
-
--- +goose StatementEnd

database/migrate/migrations/00028_add_transaction_hash_to_blob_upload.sql

@@ -0,0 +1,19 @@
+-- +goose StatementBegin
+
+ALTER TABLE blob_upload
+ADD COLUMN tx_hash VARCHAR DEFAULT '',
+
+
+CREATE INDEX idx_blob_upload_transaction_hash ON blob_upload(tx_hash);
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+
+DROP INDEX IF EXISTS idx_blob_upload_tx_hash;
+
+ALTER TABLE IF EXISTS blob_upload
+DROP COLUMN IF EXISTS tx_hash;
+
+-- +goose StatementEnd

go.work.sum

@@ -560,7 +560,6 @@ github.com/DATA-DOG/go-sqlmock v1.3.3 h1:CWUqKXe0s8A2z6qCgkP4Kru7wC11YoAnoupUKFD
 github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
 github.com/DataDog/datadog-go v3.2.0+incompatible h1:qSG2N4FghB1He/r2mFrWKCaL7dXCilEuNEeAn20fdD4=
 github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
-github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo=
 github.com/HdrHistogram/hdrhistogram-go v1.1.2/go.mod h1:yDgFjdqOqDEKOvasDdhWNXYg9BVp4O+o5f6V/ehm6Oo=
 github.com/Joker/jade v1.1.3/go.mod h1:T+2WLyt7VH6Lp0TRxQrUYEs64nRc83wkMQrfeIQKduM=
 github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
@@ -671,10 +670,7 @@ github.com/bmizerany/pat v0.0.0-20170815010413-6226ea591a40 h1:y4B3+GPxKlrigF1ha
 github.com/bmizerany/pat v0.0.0-20170815010413-6226ea591a40/go.mod h1:8rLXio+WjiTceGBHIoTvn60HIbs7Hm7bcHjyrSqYB9c=
 github.com/boltdb/bolt v1.3.1 h1:JQmyP4ZBrce+ZQu0dY660FMfatumYDLun9hBCUVIkF4=
 github.com/boltdb/bolt v1.3.1/go.mod h1:clJnj/oiGkjum5o1McbSZDSLxVThjynRyGBgiAx27Ps=
-github.com/btcsuite/btcd/btcec/v2 v2.2.0 h1:fzn1qaOt32TuLjFlkzYSsBC35Q3KUjT1SwPxiMSCF5k=
-github.com/btcsuite/btcd/btcec/v2 v2.2.0/go.mod h1:U7MHm051Al6XmscBQ0BoNydpOTsFAn707034b5nY8zU=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U=
-github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
 github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f h1:bAs4lUbRJpnnkd9VhRV3jjAVU7DJVjMaK+IsvSeZvFo=
 github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d h1:yJzD/yFppdVCf6ApMkVy8cUxV0XrxdP9rVf6D87/Mng=
 github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd h1:R/opQEbFEy9JGkIguV40SvRY1uliPX8ifOvi6ICsFCw=
@@ -689,7 +685,6 @@ github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91
 github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/chzyer/logex v1.1.10 h1:Swpa1K6QvQznwJRcfTfQJmTE72DqScAa40E+fbHEXEE=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
 github.com/chzyer/logex v1.2.0/go.mod h1:9+9sk7u7pGNWYMkh0hdiL++6OeibzJccyQU4p4MedaY=
@@ -720,14 +715,9 @@ github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe/go.mod h1:6pvJx4me5XP
 github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cncf/xds/go v0.0.0-20231128003011-0fa0005c9caa h1:jQCWAUqqlij9Pgj2i/PB79y4KOPYVyFYdROxgaCwdTQ=
 github.com/cncf/xds/go v0.0.0-20231128003011-0fa0005c9caa/go.mod h1:x/1Gn8zydmfq8dk6e9PdstVsDgu9RuyIIJqAaF//0IM=
+github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4=
 github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU=
-github.com/cockroachdb/errors v1.11.3/go.mod h1:m4UIW4CDjx+R5cybPsNrRbreomiFqt8o1h1wUVazSd8=
-github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce/go.mod h1:9/y3cnZ5GKakj/H4y9r9GTjCvAFta7KLgSHPJJYc52M=
-github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs=
-github.com/cockroachdb/pebble v1.1.1/go.mod h1:4exszw1r40423ZsmkG/09AFEG83I0uDgfujJdbL6kYU=
-github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg=
 github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2/go.mod h1:8BT+cPK6xvFOcRlk0R8eg+OTkcqI6baNH4xAkpiYVvQ=
-github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ=
 github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0/go.mod h1:4Zcjuz89kmFXt9morQgcfYZAYZ5n8WHjt81YYWIwtTM=
 github.com/compose-spec/compose-go v1.20.0 h1:h4ZKOst1EF/DwZp7dWkb+wbTVE4nEyT9Lc89to84Ol4=
 github.com/compose-spec/compose-go v1.20.0/go.mod h1:+MdqXV4RA7wdFsahh/Kb8U0pAJqkg7mr4PM9tFKU8RM=
@@ -777,7 +767,6 @@ github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:ma
 github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/crate-crypto/go-ipa v0.0.0-20230601170251-1830d0757c80/go.mod h1:gzbVz57IDJgQ9rLQwfSk696JGWof8ftznEL9GoAv3NI=
-github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs=
 github.com/crate-crypto/go-kzg-4844 v1.0.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc=
 github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c h1:/ovYnF02fwL0kvspmy9AuyKg1JhdTRUgPw4nUxd9oZM=
 github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4=
@@ -791,9 +780,6 @@ github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsP
 github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo=
 github.com/deckarep/golang-set/v2 v2.6.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4=
 github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0=
-github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
-github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc=
-github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs=
 github.com/deepmap/oapi-codegen v1.6.0 h1:w/d1ntwh91XI0b/8ja7+u5SvA4IFfM0UNNLmiDR1gg0=
 github.com/deepmap/oapi-codegen v1.6.0/go.mod h1:ryDa9AgbELGeB+YEXE1dR53yAjHwFvE9iAUlWl9Al3M=
 github.com/deepmap/oapi-codegen v1.8.2 h1:SegyeYGcdi0jLLrpbCMoJxnUUn8GBXHsvr4rbzjuhfU=
@@ -844,7 +830,6 @@ github.com/ethereum/c-kzg-4844/bindings/go v0.0.0-20230126171313-363c7d7593b4 h1
 github.com/ethereum/c-kzg-4844/bindings/go v0.0.0-20230126171313-363c7d7593b4/go.mod h1:y4GA2JbAUama1S4QwYjC2hefgGLU8Ul0GMtL/ADMF1c=
 github.com/ethereum/go-ethereum v1.10.26 h1:i/7d9RBBwiXCEuyduBQzJw/mKmnvzsN14jqBmytw72s=
 github.com/ethereum/go-ethereum v1.10.26/go.mod h1:EYFyF19u3ezGLD4RqOkLq+ZCXzYbLoNDdZlMt7kyKFg=
-github.com/ethereum/go-verkle v0.1.1-0.20240306133620-7d920df305f0/go.mod h1:D9AJLVXSyZQXJQVk8oh1EwjISE+sJTn2duYIZC0dy3w=
 github.com/evanphx/json-patch v4.12.0+incompatible h1:4onqiflcdA9EOZ4RxV643DvftH5pOlLGNtQ5lPWQu84=
 github.com/evanphx/json-patch v4.12.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
 github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
@@ -875,7 +860,6 @@ github.com/getkin/kin-openapi v0.61.0 h1:6awGqF5nG5zkVpMsAih1QH4VgzS8phTxECUWIFo
 github.com/getkin/kin-openapi v0.61.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4=
 github.com/getsentry/sentry-go v0.11.0 h1:qro8uttJGvNAMr5CLcFI9CHR0aDzXl0Vs3Pmw/oTPg8=
 github.com/getsentry/sentry-go v0.11.0/go.mod h1:KBQIxiZAetw62Cj8Ri964vAEWVdgfaUCn30Q3bCvANo=
-github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY=
 github.com/ghemawat/stream v0.0.0-20171120220530-696b145b53b9/go.mod h1:106OIgooyS7OzLDOpUGgm9fA3bQENb/cFSyyBmMoJDs=
 github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
 github.com/glycerine/go-unsnap-stream v0.0.0-20180323001048-9f0cb55181dd h1:r04MMPyLHj/QwZuMJ5+7tJcBr1AQjpiAK/rZWRrQT7o=
@@ -884,6 +868,7 @@ github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31 h1:gclg6gY70GLy
 github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24=
 github.com/go-chi/chi/v5 v5.0.0 h1:DBPx88FjZJH3FsICfDAfIfnb7XxKIYVGG6lOPlhENAg=
 github.com/go-chi/chi/v5 v5.0.0/go.mod h1:BBug9lr0cqtdAhsu6R4AAdvufI0/XBzAQSsUqJpoZOs=
+github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA=
 github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1 h1:QbL/5oDUmRBzO9/Z7Seo6zf912W/a6Sr4Eu0G/3Jho0=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
@@ -937,7 +922,6 @@ github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+Licev
 github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
-github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golangci/lint-1 v0.0.0-20181222135242-d2cdd8c08219 h1:utua3L2IbQJmauC5IXdEA547bcoU5dozgQAfc8Onsg4=
@@ -1192,8 +1176,6 @@ github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515 h1:T+h1c/A9Gawja4Y9mFVWj
 github.com/kr/pty v1.1.1 h1:VkoXIwSboBpnk99O/KFauAEILuNHv5DVFKZMBN/gUgw=
 github.com/kylelemons/go-gypsy v1.0.0 h1:7/wQ7A3UL1bnqRMnZ6T8cwCOArfZCxFmb1iTxaOOo1s=
 github.com/kylelemons/go-gypsy v1.0.0/go.mod h1:chkXM0zjdpXOiqkCW1XcCHDfjfk14PH2KKkQWxfJUcU=
-github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
-github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/labstack/echo/v4 v4.2.1 h1:LF5Iq7t/jrtUuSutNuiEWtB5eiHfZ5gSe2pcu5exjQw=
 github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4FW1e6jwpg=
 github.com/labstack/echo/v4 v4.9.0/go.mod h1:xkCDAdFCIf8jsFQ5NnbK7oqaF/yU1A1X20Ltm0OvSks=
@@ -1304,7 +1286,6 @@ github.com/nats-io/nkeys v0.4.7 h1:RwNJbbIdYCoClSDNY7QVKZlyb/wfT6ugvFCiKy6vDvI=
 github.com/nats-io/nkeys v0.4.7/go.mod h1:kqXRgRDPlGy7nGaEDMuYzmiJCIAAWDK0IMBtDmGD0nc=
 github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
 github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
-github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32/go.mod h1:9wM+0iRr9ahx58uYLpLIr5fm8diHn0JbqRycJi6w0Ms=
 github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86 h1:D6paGObi5Wud7xg83MaEFyjxQB1W5bz5d0IFppr+ymk=
 github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJEU3ofeGjhHklVoIGuVj85JJwZ6kWPaJwCIxgnFmo=
 github.com/neelance/sourcemap v0.0.0-20200213170602-2833bce08e4c h1:bY6ktFuJkt+ZXkX0RChQch2FtHpWQLVS8Qo1YasiIVk=
@@ -1336,6 +1317,7 @@ github.com/philhofer/fwd v1.0.0 h1:UbZqGr5Y38ApvM/V/jEljVxwocdweyH+vmYvRPBnbqQ=
 github.com/philhofer/fwd v1.0.0/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU=
 github.com/pierrec/lz4 v2.0.5+incompatible h1:2xWsjqPFWcplujydGg4WmhC/6fZqK42wMM8aXeqhl0I=
 github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
+github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4=
 github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
 github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4 h1:Qj1ukM4GlMWXNdMBuXcXfz/Kw9s1qm0CLY32QxuSImI=
 github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4/go.mod h1:N6UoU20jOqggOuDwUaBQpluzLNDqif3kq9z2wpdYEfQ=
@@ -1405,14 +1387,8 @@ github.com/scroll-tech/da-codec v0.1.1-0.20241005172014-aca0bef21638 h1:2KIfClLB
 github.com/scroll-tech/da-codec v0.1.1-0.20241005172014-aca0bef21638/go.mod h1:6jxEQvNc7GQKMSUi25PthAUY3WnZL8CN0yWivBgAXi0=
 github.com/scroll-tech/da-codec v0.1.1-0.20241014152913-2703f226fb0b h1:5H6V6ybacXFJ2ti+eFwtf+12Otufod6goxK6/u7Nu1k=
 github.com/scroll-tech/da-codec v0.1.1-0.20241014152913-2703f226fb0b/go.mod h1:48uxaqVgpD8ulH8p+nrBtfeLHZ9tX82bVVdPNkW3rPE=
-github.com/scroll-tech/da-codec v0.1.3-0.20250226072559-f8a8d3898f54/go.mod h1:xECEHZLVzbdUn+tNbRJhRIjLGTOTmnFQuTgUTeVLX58=
 github.com/scroll-tech/da-codec v0.1.3-0.20250227072756-a1482833595f h1:YYbhuUwjowqI4oyXtECRofck7Fyj18e1tcRjuQlZpJE=
 github.com/scroll-tech/da-codec v0.1.3-0.20250227072756-a1482833595f/go.mod h1:xECEHZLVzbdUn+tNbRJhRIjLGTOTmnFQuTgUTeVLX58=
-github.com/scroll-tech/da-codec v0.1.3-0.20250313120912-344f2d5e33e1/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
-github.com/scroll-tech/da-codec v0.1.3-0.20250609113414-f33adf0904bd h1:NUol+dPtZ8LzLYrP7CPq9tRI0jAhxFxrYNmKYrTQgKE=
-github.com/scroll-tech/da-codec v0.1.3-0.20250609113414-f33adf0904bd/go.mod h1:gz5x3CsLy5htNTbv4PWRPBU9nSAujfx1U2XtFcXoFuk=
-github.com/scroll-tech/da-codec v0.1.3-0.20250609154559-8935de62c148 h1:cyK1ifU2fRoMl8YWR9LOsZK4RvJnlG3RODgakj5I8VY=
-github.com/scroll-tech/da-codec v0.1.3-0.20250609154559-8935de62c148/go.mod h1:gz5x3CsLy5htNTbv4PWRPBU9nSAujfx1U2XtFcXoFuk=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240607130425-e2becce6a1a4/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240821074444-b3fa00861e5e/go.mod h1:swB5NSp8pKNDuYsTxfR08bHS6L56i119PBx8fxvV8Cs=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20241010064814-3d88e870ae22/go.mod h1:r9FwtxCtybMkTbWYCyBuevT9TW3zHmOTHqD082Uh+Oo=
@@ -1630,6 +1606,7 @@ golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u0
 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
 golang.org/x/exp v0.0.0-20220426173459-3bcf042a4bf5/go.mod h1:lgLbSvA5ygNOMpwM/9anMpWVlVJ7Z+cHWq/eFuinpGE=
+golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
 golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b h1:+qEpEAPhDZ1o0x3tHzZTQDArnOixOzGD9HUJfcg0mb4=

rollup/cmd/blob_uploader/app/app.go

@@ -70,7 +70,7 @@ func action(ctx *cli.Context) error {
 		log.Crit("failed to create l2 relayer", "config file", cfgFile, "error", err)
 	}
 
-	go utils.Loop(subCtx, 2*time.Second, blobUploader.UploadBlobToS3)
+	go utils.Loop(subCtx, 1*time.Second, blobUploader.UploadBlobToS3)
 
 	// Finish start all blob-uploader functions.
 	log.Info("Start blob-uploader successfully", "version", version.Version)

rollup/conf/config.json

@@ -94,14 +94,12 @@
       "propose_interval_milliseconds": 100,
       "max_block_num_per_chunk": 100,
       "max_l2_gas_per_chunk": 20000000,
-      "chunk_timeout_sec": 300,
-      "max_uncompressed_batch_bytes_size": 4194304
+      "chunk_timeout_sec": 300
     },
     "batch_proposer_config": {
       "propose_interval_milliseconds": 1000,
       "batch_timeout_sec": 300,
-      "max_chunks_per_batch": 45,
-      "max_uncompressed_batch_bytes_size": 4194304
+      "max_chunks_per_batch": 45
     },
     "bundle_proposer_config": {
       "max_batch_num_per_bundle": 20,
@@ -114,6 +112,12 @@
         "region": "us-west-2",
         "access_key": "ACCESSKEY",
         "secret_key": "SECRETKEY"
+      },
+      "arweave_config": {
+        "endpoint": "",
+        "private_key_path": "",
+        "tx_tag": "",
+        "confirmations": ""
       }
     }
   },
@@ -123,4 +127,4 @@
     "maxOpenNum": 200,
     "maxIdleNum": 20
   }
-}
+}

rollup/go.mod

@@ -1,6 +1,6 @@
 module scroll-tech/rollup
 
-go 1.22
+go 1.22.4
 
 require (
 	github.com/agiledragon/gomonkey/v2 v2.12.0
@@ -15,8 +15,8 @@ require (
 	github.com/holiman/uint256 v1.3.2
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/prometheus/client_golang v1.16.0
-	github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7
+	github.com/scroll-tech/da-codec v0.1.3-0.20250519114140-bfa7133d4ad1
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250609212349-f30b2b1832a2
 	github.com/smartystreets/goconvey v1.8.0
 	github.com/spf13/viper v1.19.0
 	github.com/stretchr/testify v1.10.0
@@ -42,17 +42,24 @@ require (
 	github.com/aws/smithy-go v1.22.2 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/bits-and-blooms/bitset v1.20.0 // indirect
-	github.com/btcsuite/btcd v0.20.1-beta // indirect
+	github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd // indirect
+	github.com/btcsuite/btcd/btcec/v2 v2.2.0 // indirect
+	github.com/btcsuite/btcd/btcutil v1.1.5 // indirect
 	github.com/bytedance/sonic v1.10.1 // indirect
-	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
 	github.com/chenzhuoyu/iasm v0.9.0 // indirect
 	github.com/consensys/bavard v0.1.29 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea // indirect
+	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 // indirect
 	github.com/edsrzf/mmap-go v1.0.0 // indirect
 	github.com/ethereum/c-kzg-4844 v1.0.3 // indirect
+	github.com/ethereum/go-ethereum v1.14.7 // indirect
+	github.com/everFinance/ethrpc v1.0.4 // indirect
+	github.com/everFinance/goether v1.1.9 // indirect
+	github.com/everFinance/gojwk v1.0.0 // indirect
 	github.com/fjl/memsize v0.0.2 // indirect
 	github.com/fsnotify/fsnotify v1.7.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
@@ -64,7 +71,7 @@ require (
 	github.com/go-playground/validator/v10 v10.15.5 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/goccy/go-json v0.10.2 // indirect
-	github.com/golang/protobuf v1.5.3 // indirect
+	github.com/golang/protobuf v1.5.4 // indirect
 	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect
 	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
@@ -76,6 +83,7 @@ require (
 	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
 	github.com/huin/goupnp v1.3.0 // indirect
 	github.com/iden3/go-iden3-crypto v0.0.17 // indirect
+	github.com/inconshreveable/log15 v2.16.0+incompatible // indirect
 	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
@@ -84,6 +92,7 @@ require (
 	github.com/klauspost/compress v1.17.9 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.5 // indirect
 	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/linkedin/goavro/v2 v2.13.0 // indirect
 	github.com/magiconair/properties v1.8.7 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
@@ -96,7 +105,9 @@ require (
 	github.com/olekukonko/tablewriter v0.0.5 // indirect
 	github.com/onsi/ginkgo v1.16.5 // indirect
 	github.com/onsi/gomega v1.27.1 // indirect
+	github.com/panjf2000/ants/v2 v2.10.0 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+	github.com/permadao/goar v1.1.1 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/prometheus/client_model v0.4.0 // indirect
@@ -111,6 +122,7 @@ require (
 	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
 	github.com/scroll-tech/zktrie v0.8.4 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
+	github.com/shopspring/decimal v1.4.0 // indirect
 	github.com/smartystreets/assertions v1.13.1 // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/spf13/afero v1.11.0 // indirect
@@ -120,6 +132,9 @@ require (
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/supranational/blst v0.3.13 // indirect
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
+	github.com/tidwall/gjson v1.17.3 // indirect
+	github.com/tidwall/match v1.1.1 // indirect
+	github.com/tidwall/pretty v1.2.0 // indirect
 	github.com/tklauser/go-sysconf v0.3.14 // indirect
 	github.com/tklauser/numcpus v0.9.0 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
@@ -131,13 +146,15 @@ require (
 	go.uber.org/multierr v1.9.0 // indirect
 	golang.org/x/arch v0.5.0 // indirect
 	golang.org/x/crypto v0.32.0 // indirect
-	golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // indirect
+	golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect
 	golang.org/x/net v0.25.0 // indirect
 	golang.org/x/sync v0.11.0 // indirect
 	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/term v0.28.0 // indirect
 	golang.org/x/text v0.21.0 // indirect
 	golang.org/x/time v0.5.0 // indirect
 	google.golang.org/protobuf v1.33.0 // indirect
+	gopkg.in/h2non/gentleman.v2 v2.0.5 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
 	gopkg.in/urfave/cli.v1 v1.20.0 // indirect

rollup/go.sum

@@ -1,3 +1,5 @@
+github.com/DataDog/zstd v1.4.5 h1:EndNeuB0l9syBZhut0wns3gV1hL8zX8LIu6ZiVHWLIQ=
+github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/VictoriaMetrics/fastcache v1.12.2 h1:N0y9ASrJ0F6h0QaC3o6uJb3NIZ9VKLjCM7NQbSmF7WI=
 github.com/VictoriaMetrics/fastcache v1.12.2/go.mod h1:AmC+Nzz1+3G2eCPapF6UcsnkThDcMsQicp4xDukwJYI=
@@ -49,13 +51,29 @@ github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bits-and-blooms/bitset v1.20.0 h1:2F+rfL86jE2d/bmw7OhqUg2Sj/1rURkBn3MdfoPyRVU=
 github.com/bits-and-blooms/bitset v1.20.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
-github.com/btcsuite/btcd v0.20.1-beta h1:Ik4hyJqN8Jfyv3S4AGBOmyouMsYE3EdYODkMbQjwPGw=
 github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ=
+github.com/btcsuite/btcd v0.22.0-beta.0.20220111032746-97732e52810c/go.mod h1:tjmYdS6MLJ5/s0Fj4DbLgSbDHbEqLJrtnHecBFkdz5M=
+github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd h1:js1gPwhcFflTZ7Nzl7WHaOTlTr5hIrR4n1NM4v9n4Kw=
+github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd/go.mod h1:nm3Bko6zh6bWP60UxwoT5LzdGJsQJaPo6HjduXq9p6A=
+github.com/btcsuite/btcd/btcec/v2 v2.1.0/go.mod h1:2VzYrv4Gm4apmbVVsSq5bqf1Ec8v56E48Vt0Y/umPgA=
+github.com/btcsuite/btcd/btcec/v2 v2.1.3/go.mod h1:ctjw4H1kknNJmRN4iP1R7bTQ+v3GJkZBd6mui8ZsAZE=
+github.com/btcsuite/btcd/btcec/v2 v2.2.0 h1:fzn1qaOt32TuLjFlkzYSsBC35Q3KUjT1SwPxiMSCF5k=
+github.com/btcsuite/btcd/btcec/v2 v2.2.0/go.mod h1:U7MHm051Al6XmscBQ0BoNydpOTsFAn707034b5nY8zU=
+github.com/btcsuite/btcd/btcutil v1.0.0/go.mod h1:Uoxwv0pqYWhD//tfTiipkxNfdhG9UrLwaeswfjfdF0A=
+github.com/btcsuite/btcd/btcutil v1.1.0/go.mod h1:5OapHB7A2hBBWLm48mmw4MOHNJCcUBTwmWH/0Jn8VHE=
+github.com/btcsuite/btcd/btcutil v1.1.5 h1:+wER79R5670vs/ZusMTF1yTcRYE5GUsFbdjdisflzM8=
+github.com/btcsuite/btcd/btcutil v1.1.5/go.mod h1:PSZZ4UitpLBWzxGd5VGOrLnmOjtPP/a6HaFo12zMs00=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.0.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 h1:59Kx4K6lzOW5w6nFlA0v5+lk/6sjybR934QNHSJZPTQ=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
 github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA=
 github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg=
 github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg=
 github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY=
+github.com/btcsuite/goleveldb v1.0.0/go.mod h1:QiK9vBlgftBg6rWQIj6wFzbPfRjiykIEhBH4obrXJ/I=
 github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc=
+github.com/btcsuite/snappy-go v1.0.0/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc=
 github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY=
 github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs=
 github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
@@ -65,20 +83,35 @@ github.com/bytedance/sonic v1.10.1/go.mod h1:iZcSUejdk5aukTND/Eu/ivjQuEL0Cu9/rf5
 github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk=
 github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
 github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
 github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d h1:77cEq6EriyTZ0g/qfRdp61a3Uu/AWrgIq2s0ClJV1g0=
 github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d/go.mod h1:8EPpVsBuRksnlj1mLy4AWzRNQYxauNi62uWcE3to6eA=
 github.com/chenzhuoyu/iasm v0.9.0 h1:9fhXjVzq5hUy2gkhhgHl95zG2cEAhw9OSGs8toWWAwo=
 github.com/chenzhuoyu/iasm v0.9.0/go.mod h1:Xjy2NpN3h7aUqeqM+woSuuvxmIe6+DDsiNLIrkAmYog=
+github.com/cockroachdb/errors v1.11.3 h1:5bA+k2Y6r+oz/6Z/RFlNeVCesGARKuC6YymtcDrbC/I=
+github.com/cockroachdb/errors v1.11.3/go.mod h1:m4UIW4CDjx+R5cybPsNrRbreomiFqt8o1h1wUVazSd8=
+github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce h1:giXvy4KSc/6g/esnpM7Geqxka4WSqI1SZc7sMJFd3y4=
+github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce/go.mod h1:9/y3cnZ5GKakj/H4y9r9GTjCvAFta7KLgSHPJJYc52M=
+github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE=
+github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs=
+github.com/cockroachdb/pebble v1.1.1 h1:XnKU22oiCLy2Xn8vp1re67cXg4SAasg/WDt1NtcRFaw=
+github.com/cockroachdb/pebble v1.1.1/go.mod h1:4exszw1r40423ZsmkG/09AFEG83I0uDgfujJdbL6kYU=
+github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30=
+github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg=
+github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo=
+github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ=
 github.com/consensys/bavard v0.1.29 h1:fobxIYksIQ+ZSrTJUuQgu+HIJwclrAPcdXqd7H2hh1k=
 github.com/consensys/bavard v0.1.29/go.mod h1:k/zVjHHC4B+PQy1Pg7fgvG3ALicQw540Crag8qx+dZs=
 github.com/consensys/gnark-crypto v0.16.0 h1:8Dl4eYmUWK9WmlP1Bj6je688gBRJCJbT8Mw4KoTAawo=
 github.com/consensys/gnark-crypto v0.16.0/go.mod h1:Ke3j06ndtPTVvo++PhGNgvm+lgpLvzbcE2MqljY7diU=
 github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM=
 github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c h1:uQYC5Z1mdLRPrZhHjHxufI8+2UG/i25QG92j0Er9p6I=
+github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs=
 github.com/crate-crypto/go-kzg-4844 v1.1.0 h1:EN/u9k2TF6OWSHrCCDBBU6GLNMq88OspHHlMnHfoyU4=
 github.com/crate-crypto/go-kzg-4844 v1.1.0/go.mod h1:JolLjpSff1tCCJKaJx4psrlEdlXuJEC996PL3tTAFks=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -88,11 +121,28 @@ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea h1:j4317fAZh7X6GqbFowYdYdI0L9bwxL07jyPZIdepyZ0=
 github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ=
+github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
+github.com/decred/dcrd/crypto/blake256 v1.1.0 h1:zPMNGQCm0g4QTY27fOCorQW7EryeQ/U0x++OzVrdms8=
+github.com/decred/dcrd/crypto/blake256 v1.1.0/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 h1:NMZiJj8QnKe1LgsbDayM4UoHwbvwDRwnI3hwNaAHRnc=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40=
+github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
 github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
 github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
 github.com/ethereum/c-kzg-4844 v1.0.3 h1:IEnbOHwjixW2cTvKRUlAAUOeleV7nNM/umJR+qy4WDs=
 github.com/ethereum/c-kzg-4844 v1.0.3/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0=
+github.com/ethereum/go-ethereum v1.14.7 h1:EHpv3dE8evQmpVEQ/Ne2ahB06n2mQptdwqaMNhAT29g=
+github.com/ethereum/go-ethereum v1.14.7/go.mod h1:Mq0biU2jbdmKSZoqOj29017ygFrMnB5/Rifwp980W4o=
+github.com/ethereum/go-verkle v0.1.1-0.20240306133620-7d920df305f0 h1:KrE8I4reeVvf7C1tm8elRjj4BdscTYzz/WAbYyf/JI4=
+github.com/ethereum/go-verkle v0.1.1-0.20240306133620-7d920df305f0/go.mod h1:D9AJLVXSyZQXJQVk8oh1EwjISE+sJTn2duYIZC0dy3w=
+github.com/everFinance/ethrpc v1.0.4 h1:Ww+qr8D93Id5QkyG5Mvw58edu5tqy0sL6hDP0IfhYsE=
+github.com/everFinance/ethrpc v1.0.4/go.mod h1:cQipdwW4kM1v8C+q8Z+jDDXwL7a3KngvNk9Yo+lbXpI=
+github.com/everFinance/goether v1.1.9 h1:Y/zz/chv0CmoXz119J3ZK4WbGoHnMjm/IDH5qwKrvVU=
+github.com/everFinance/goether v1.1.9/go.mod h1:QhUIRE3g4CPN4+OGz96pIwguyRH1hZfYo2gAUSY00Qw=
+github.com/everFinance/gojwk v1.0.0 h1:le/oI2NgXlrqg3MHU6ka+V30EWcD7TD6+Ilh+go7924=
+github.com/everFinance/gojwk v1.0.0/go.mod h1:icXSXsIdpAczlpAtSljQlmABkMTRZENr73KHmo0GOGc=
 github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA=
 github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
@@ -105,6 +155,8 @@ github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q
 github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
 github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
 github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww=
+github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps=
+github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY=
 github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
@@ -133,7 +185,11 @@ github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
+github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
 github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
@@ -141,19 +197,20 @@ github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrU
 github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
 github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
-github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk=
 github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
+github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
@@ -177,9 +234,14 @@ github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc=
 github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8=
 github.com/iden3/go-iden3-crypto v0.0.17 h1:NdkceRLJo/pI4UpcjVah4lN/a3yzxRUGXqxbWcYh9mY=
 github.com/iden3/go-iden3-crypto v0.0.17/go.mod h1:dLpM4vEPJ3nDHzhWFXDjzkn1qHoBeOT/3UEhXsEsP3E=
+github.com/inconshreveable/log15 v2.16.0+incompatible h1:6nvMKxtGcpgm7q0KiGs+Vc+xDvUXaBqsPKHWKsinccw=
+github.com/inconshreveable/log15 v2.16.0+incompatible/go.mod h1:cOaXtrgN4ScfRrD9Bre7U1thNq5RtJ8ZoP4iXVGRj6o=
 github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus=
 github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
+github.com/jarcoal/httpmock v1.0.6 h1:e81vOSexXU3mJuJ4l//geOmKIt+Vkxerk1feQBC8D0g=
+github.com/jarcoal/httpmock v1.0.6/go.mod h1:ATjnClrvW/3tijVmpL/va5Z3aAyGvqU3gCT8nX0Txik=
 github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
@@ -201,10 +263,14 @@ github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/leanovate/gopter v0.2.11 h1:vRjThO1EKPb/1NsDXuDrzldR28RLkBflWYcU9CvzWu4=
 github.com/leanovate/gopter v0.2.11/go.mod h1:aK3tzZP/C+p1m3SPRE4SYZFGP7jjkuSI4f7Xvpt0S9c=
 github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
 github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
+github.com/linkedin/goavro/v2 v2.13.0 h1:L8eI8GcuciwUkt41Ej62joSZS4kKaYIUdze+6for9NU=
+github.com/linkedin/goavro/v2 v2.13.0/go.mod h1:KXx+erlq+RPlGSPmLF7xGo6SAbh8sCQ53x064+ioxhk=
 github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY=
 github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
@@ -231,6 +297,8 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32 h1:W6apQkHrMkS0Muv8G/TipAy/FJl/rCYT0+EuS8+Z0z4=
+github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32/go.mod h1:9wM+0iRr9ahx58uYLpLIr5fm8diHn0JbqRycJi6w0Ms=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
 github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
@@ -243,13 +311,18 @@ github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108
 github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
 github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
 github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
+github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/onsi/gomega v1.27.1 h1:rfztXRbg6nv/5f+Raen9RcGoSecHIFgBBLQK3Wdj754=
 github.com/onsi/gomega v1.27.1/go.mod h1:aHX5xOykVYzWOV4WqQy0sy8BQptgukenXpCXfadcIAw=
+github.com/panjf2000/ants/v2 v2.10.0 h1:zhRg1pQUtkyRiOFo2Sbqwjp0GfBNo9cUY2/Grpx1p+8=
+github.com/panjf2000/ants/v2 v2.10.0/go.mod h1:7ZxyxsqE4vvW0M7LSD8aI3cKwgFhBHbxnlN8mDqHa1I=
 github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
 github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
+github.com/permadao/goar v1.1.1 h1:C1Sv/v57SOAb59qn/zH9UXgE9u+3e6bYIqZ8ocrJt1E=
+github.com/permadao/goar v1.1.1/go.mod h1:HgUtU74aB557YRhFav63BI8Z23X9ehT7upia0ZhSL5s=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
@@ -285,14 +358,16 @@ github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6ke
 github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
 github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
 github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
-github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6 h1:vb2XLvQwCf+F/ifP6P/lfeiQrHY6+Yb/E3R4KHXLqSE=
-github.com/scroll-tech/da-codec v0.1.3-0.20250626091118-58b899494da6/go.mod h1:Z6kN5u2khPhiqHyk172kGB7o38bH/nj7Ilrb/46wZGg=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7 h1:1rN1qocsQlOyk1VCpIEF1J5pfQbLAi1pnMZSLQS37jQ=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20250626110859-cc9a1dd82de7/go.mod h1:pDCZ4iGvEGmdIe4aSAGBrb7XSrKEML6/L/wEMmNxOdk=
+github.com/scroll-tech/da-codec v0.1.3-0.20250519114140-bfa7133d4ad1 h1:6aKqJSal+QVdB5HMWMs0JTbAIZ6/iAHJx9qizz0w9dU=
+github.com/scroll-tech/da-codec v0.1.3-0.20250519114140-bfa7133d4ad1/go.mod h1:yhTS9OVC0xQGhg7DN5iV5KZJvnSIlFWAxDdp+6jxQtY=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250609212349-f30b2b1832a2 h1:HT9FZMBg+3EK515jR5t/7T+6eHgcVLSXcbTNuBMvtjU=
+github.com/scroll-tech/go-ethereum v1.10.14-0.20250609212349-f30b2b1832a2/go.mod h1:59TEKiLts8KdJwfdeMCDEyRjm3Dl6M8N5ID7VsrR+i8=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=
 github.com/scroll-tech/zktrie v0.8.4/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
 github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
+github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
+github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/assertions v1.13.1 h1:Ef7KhSmjZcK6AVf9YbJdvPYG9avaF0ZxudX+ThRdWfU=
 github.com/smartystreets/assertions v1.13.1/go.mod h1:cXr/IwVfSo/RbCSPhoAPv73p3hlSdrBH/b3SdnW/LMY=
@@ -319,8 +394,10 @@ github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.5/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
@@ -334,6 +411,15 @@ github.com/supranational/blst v0.3.13 h1:AYeSxdOMacwu7FBmpfloBz5pbFXDmJL33RuwnKt
 github.com/supranational/blst v0.3.13/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
+github.com/tidwall/gjson v1.6.3/go.mod h1:BaHyNc5bjzYkPqgLq7mdVzeiRtULKULXLgZFKsxEHI0=
+github.com/tidwall/gjson v1.17.3 h1:bwWLZU7icoKRG+C+0PNwIKC6FCJO/Q3p2pZvuP0jN94=
+github.com/tidwall/gjson v1.17.3/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/match v1.0.1/go.mod h1:LujAq0jyVjBy028G1WhWfIzbpQfMO8bBZ6Tyb0+pL9E=
+github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
+github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
+github.com/tidwall/pretty v1.0.2/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
+github.com/tidwall/pretty v1.2.0 h1:RWIZEg2iJ8/g6fDDYzMpobmaoGh5OLl4AXtGUGPcqCs=
+github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
 github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU=
 github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY=
 github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPDo=
@@ -364,9 +450,10 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
 golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
-golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
-golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
+golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ=
+golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
@@ -383,6 +470,7 @@ golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
 golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -408,6 +496,8 @@ golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
 golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
+golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
@@ -430,8 +520,6 @@ google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQ
 google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
 google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
 google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
@@ -439,6 +527,8 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/h2non/gentleman.v2 v2.0.5 h1:ckmb6cLxL2DDk7WN7LSdxXDq7jNkOicFg4JZ4ZnDNuE=
+gopkg.in/h2non/gentleman.v2 v2.0.5/go.mod h1:A1c7zwrTgAyyf6AbpvVksYtBayTB4STBUGmdkEtlHeA=
 gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
 gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce h1:+JknDZhAj8YMt7GC73Ei8pv4MzjDUNPHgQWJdtMAaDU=

rollup/internal/config/l2.go

@@ -30,19 +30,17 @@ type L2Config struct {
 
 // ChunkProposerConfig loads chunk_proposer configuration items.
 type ChunkProposerConfig struct {
-	ProposeIntervalMilliseconds   uint64 `json:"propose_interval_milliseconds"`
-	MaxBlockNumPerChunk           uint64 `json:"max_block_num_per_chunk"`
-	MaxL2GasPerChunk              uint64 `json:"max_l2_gas_per_chunk"`
-	ChunkTimeoutSec               uint64 `json:"chunk_timeout_sec"`
-	MaxUncompressedBatchBytesSize uint64 `json:"max_uncompressed_batch_bytes_size"`
+	ProposeIntervalMilliseconds uint64 `json:"propose_interval_milliseconds"`
+	MaxBlockNumPerChunk         uint64 `json:"max_block_num_per_chunk"`
+	MaxL2GasPerChunk            uint64 `json:"max_l2_gas_per_chunk"`
+	ChunkTimeoutSec             uint64 `json:"chunk_timeout_sec"`
 }
 
 // BatchProposerConfig loads batch_proposer configuration items.
 type BatchProposerConfig struct {
-	ProposeIntervalMilliseconds   uint64 `json:"propose_interval_milliseconds"`
-	BatchTimeoutSec               uint64 `json:"batch_timeout_sec"`
-	MaxChunksPerBatch             int    `json:"max_chunks_per_batch"`
-	MaxUncompressedBatchBytesSize uint64 `json:"max_uncompressed_batch_bytes_size"`
+	ProposeIntervalMilliseconds uint64 `json:"propose_interval_milliseconds"`
+	BatchTimeoutSec             uint64 `json:"batch_timeout_sec"`
+	MaxChunksPerBatch           int    `json:"max_chunks_per_batch"`
 }
 
 // BundleProposerConfig loads bundle_proposer configuration items.
@@ -53,8 +51,9 @@ type BundleProposerConfig struct {
 
 // BlobUploaderConfig loads blob_uploader configuration items.
 type BlobUploaderConfig struct {
-	StartBatch  uint64       `json:"start_batch"`
-	AWSS3Config *AWSS3Config `json:"aws_s3_config"`
+	StartBatch    uint64         `json:"start_batch"`
+	AWSS3Config   *AWSS3Config   `json:"aws_s3_config"`
+	ArweaveConfig *ArweaveConfig `json:"arweave_config"`
 }
 
 // AWSS3Config loads s3_uploader configuration items.
@@ -64,3 +63,11 @@ type AWSS3Config struct {
 	AccessKey string `json:"access_key"`
 	SecretKey string `json:"secret_key"`
 }
+
+// ArweaveConfig loads arweave_uploader configuration items.
+type ArweaveConfig struct {
+	Endpoint       string `json:"endpoint"`
+	PrivateKeyPath string `json:"private_key_path"`
+	TxTag          string `json:"tx_tag"`
+	Confirmations  uint64 `json:"confirmations"`
+}

rollup/internal/controller/blob_uploader/arweave_sender.go

@@ -1 +1,171 @@
 package blob_uploader
+
+import (
+	"context"
+	"fmt"
+	"scroll-tech/common/types"
+	"scroll-tech/rollup/internal/config"
+	"scroll-tech/rollup/internal/orm"
+	"time"
+
+	"github.com/permadao/goar"
+	"github.com/permadao/goar/schema"
+	"github.com/scroll-tech/go-ethereum/log"
+	"gorm.io/gorm"
+)
+
+// Arweave Uploader is responsible for uploading data to AWS S3.
+type ArweaveUploader struct {
+	ctx           context.Context
+	wallet        *goar.Wallet
+	client        *goar.Client
+	txTag         string
+	confirmations int
+	blobUploadOrm *orm.BlobUpload
+	batchOrm      *orm.Batch
+
+	onReuploadNeeded func(batch *orm.Batch, platform types.BlobStoragePlatform, speedFactor int64) (string, error)
+}
+
+func NewArweaveUploader(ctx context.Context, cfg *config.ArweaveConfig, db *gorm.DB, onReuploadNeeded func(batch *orm.Batch, platform types.BlobStoragePlatform, speedFactor int64) (string, error)) (*ArweaveUploader, error) {
+	wallet, err := goar.NewWalletFromPath(cfg.PrivateKeyPath, cfg.Endpoint)
+	if err != nil {
+		return nil, fmt.Errorf("failed to new arweave uploader: %w", err)
+	}
+
+	client := goar.NewClient(cfg.Endpoint)
+
+	arweaveUploader := ArweaveUploader{
+		ctx:              ctx,
+		wallet:           wallet,
+		client:           client,
+		txTag:            cfg.TxTag,
+		confirmations:    int(cfg.Confirmations),
+		blobUploadOrm:    orm.NewBlobUpload(db),
+		batchOrm:         orm.NewBatch(db),
+		onReuploadNeeded: onReuploadNeeded,
+	}
+
+	go arweaveUploader.loop(ctx)
+
+	return &arweaveUploader, nil
+}
+
+// UploadData uploads data to arweave
+func (u *ArweaveUploader) UploadData(ctx context.Context, data []byte, objectKey string, speedFactor int64) (*schema.Transaction, error) {
+	var tx schema.Transaction
+	var err error
+	if speedFactor == 0 {
+		tx, err = u.wallet.SendData(
+			data,
+			[]schema.Tag{
+				schema.Tag{
+					Name:  u.txTag,
+					Value: objectKey,
+				},
+			},
+		)
+	} else {
+		tx, err = u.wallet.SendDataSpeedUp(
+			data,
+			[]schema.Tag{
+				schema.Tag{
+					Name:  u.txTag,
+					Value: objectKey,
+				},
+			},
+			speedFactor,
+		)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &tx, nil
+}
+
+// checkPendingBlobUploads checks the confirmation status of pending blob uploads transactions against the latest confirmed block number.
+// If a transaction hasn't been confirmed after a certain number of blocks, it will be resubmitted with an increased gas price.
+func (u *ArweaveUploader) checkPendingBlobUploads(ctx context.Context) {
+	pendingBlobUploads, err := u.blobUploadOrm.GetPendingBlobUploads(ctx, 100)
+	if err != nil {
+		log.Error("failed to load pending blob uploads", "err", err)
+		return
+	}
+
+	for _, blobUpload := range pendingBlobUploads {
+		status, err := u.client.GetTransactionStatus(blobUpload.TxHash)
+		if err != nil {
+			if err == schema.ErrPendingTx {
+				if time.Since(blobUpload.UpdatedAt) > 10*time.Minute {
+					// transaction pending too long, we need to bump the gas price
+					if u.onReuploadNeeded != nil {
+						// get batch from database
+						dbBatch, err := u.batchOrm.GetBatchByIndex(u.ctx, blobUpload.BatchIndex)
+						if err != nil {
+							log.Error("failed to get batch by index %d: %w", blobUpload.BatchIndex, err)
+							continue
+						}
+						if dbBatch.Hash != blobUpload.BatchHash {
+							log.Error("found unmatched batch hash when reupload blob data", "batch index", blobUpload.BatchIndex, "dbBatch hash", dbBatch.Hash, "blobUpload batch hash", blobUpload.BatchHash, "err", err)
+							continue
+						}
+						if _, err := u.onReuploadNeeded(dbBatch, types.BlobStoragePlatformArweave, 50); err != nil {
+							log.Error("failed to reupload blob", "batch index", blobUpload.BatchIndex, "batch hash", blobUpload.BatchHash, "err", err)
+						} else {
+							log.Info("successfully reuploaded blob with higher gas price", "batch index", blobUpload.BatchIndex, "batch hash", blobUpload.BatchHash)
+						}
+					}
+				}
+				log.Debug("got pending arweave transaction, waiting for confirmation")
+			}
+			if err == schema.ErrNotFound || err == schema.ErrInvalidId {
+				// resend transaction if it's dropped
+				if u.onReuploadNeeded != nil {
+					// get batch from database
+					dbBatch, err := u.batchOrm.GetBatchByIndex(u.ctx, blobUpload.BatchIndex)
+					if err != nil {
+						log.Error("failed to get batch by index %d: %w", blobUpload.BatchIndex, err)
+						continue
+					}
+					if dbBatch.Hash != blobUpload.BatchHash {
+						log.Error("found unmatched batch hash when reupload blob data", "batch index", blobUpload.BatchIndex, "dbBatch hash", dbBatch.Hash, "blobUpload batch hash", blobUpload.BatchHash, "err", err)
+						continue
+					}
+					if _, err := u.onReuploadNeeded(dbBatch, types.BlobStoragePlatformArweave, 0); err != nil {
+						log.Error("failed to reupload blob", "batch index", blobUpload.BatchIndex, "batch hash", blobUpload.BatchHash, "err", err)
+					} else {
+						log.Info("successfully reuploaded blob", "batch index", blobUpload.BatchIndex, "batch hash", blobUpload.BatchHash)
+					}
+				}
+			}
+			log.Error("failed to get arweave transaction status", "err", err)
+			return
+		}
+
+		if status.NumberOfConfirmations >= int(u.confirmations) {
+			if err := u.blobUploadOrm.UpdateUploadStatus(u.ctx, blobUpload.TxHash, types.BlobUploadStatusUploaded); err != nil {
+				log.Warn("UpdateUploadStatus failed", "transaction hash", blobUpload.TxHash, "upload status", types.BlobUploadStatusUploaded, "err", err)
+				return
+			}
+
+		}
+
+	}
+}
+
+// Loop is the main event loop
+func (u *ArweaveUploader) loop(ctx context.Context) {
+	checkTick := time.NewTicker(time.Duration(10) * time.Second)
+	defer checkTick.Stop()
+
+	for {
+		select {
+		case <-checkTick.C:
+			u.checkPendingBlobUploads(ctx)
+		case <-ctx.Done():
+			return
+		}
+	}
+}

rollup/internal/controller/blob_uploader/arweave_sender_test.go

@@ -0,0 +1 @@
+package blob_uploader

rollup/internal/controller/blob_uploader/blob_uploader.go

@@ -25,7 +25,8 @@ type BlobUploader struct {
 
 	cfg *config.BlobUploaderConfig
 
-	s3Uploader *S3Uploader
+	s3Uploader      *S3Uploader
+	arweaveUploader *ArweaveUploader
 
 	blobUploadOrm *orm.BlobUpload
 	batchOrm      *orm.Batch
@@ -46,14 +47,42 @@ func NewBlobUploader(ctx context.Context, db *gorm.DB, cfg *config.BlobUploaderC
 		}
 	}
 
+	var arweaveUploader *ArweaveUploader
+	if cfg.ArweaveConfig != nil {
+		// 先创建 blobUploader 实例
+		blobUploader := &BlobUploader{
+			ctx:             ctx,
+			cfg:             cfg,
+			s3Uploader:      s3Uploader,
+			arweaveUploader: nil, // 稍后设置
+			batchOrm:        orm.NewBatch(db),
+			chunkOrm:        orm.NewChunk(db),
+			l2BlockOrm:      orm.NewL2Block(db),
+			blobUploadOrm:   orm.NewBlobUpload(db),
+		}
+
+		arweaveUploader, err = NewArweaveUploader(ctx, cfg.ArweaveConfig, db, func(batch *orm.Batch, platform types.BlobStoragePlatform, speedFactor int64) (string, error) {
+			return blobUploader.uploadBlob(batch, platform, speedFactor)
+		})
+		if err != nil {
+			return nil, fmt.Errorf("new blob uploader failed, err: %w", err)
+		}
+
+		// 设置 arweaveUploader
+		blobUploader.arweaveUploader = arweaveUploader
+		blobUploader.metrics = initBlobUploaderMetrics(reg)
+		return blobUploader, nil
+	}
+
 	blobUploader := &BlobUploader{
-		ctx:           ctx,
-		cfg:           cfg,
-		s3Uploader:    s3Uploader,
-		batchOrm:      orm.NewBatch(db),
-		chunkOrm:      orm.NewChunk(db),
-		l2BlockOrm:    orm.NewL2Block(db),
-		blobUploadOrm: orm.NewBlobUpload(db),
+		ctx:             ctx,
+		cfg:             cfg,
+		s3Uploader:      s3Uploader,
+		arweaveUploader: nil,
+		batchOrm:        orm.NewBatch(db),
+		chunkOrm:        orm.NewChunk(db),
+		l2BlockOrm:      orm.NewL2Block(db),
+		blobUploadOrm:   orm.NewBlobUpload(db),
 	}
 
 	blobUploader.metrics = initBlobUploaderMetrics(reg)
@@ -70,62 +99,102 @@ func (b *BlobUploader) UploadBlobToS3() {
 	// get un-uploaded batches from database in ascending order by their index.
 	dbBatch, err := b.GetFirstUnuploadedBatchByPlatform(b.ctx, b.cfg.StartBatch, types.BlobStoragePlatformS3)
 	if err != nil {
-		log.Error("Failed to fetch unuploaded batch", "err", err)
+		log.Error("s3Uploader: failed to fetch unuploaded batch", "err", err)
 		return
 	}
 
 	// nothing to do if we don't have any pending batches
 	if dbBatch == nil {
-		log.Debug("no pending batches to upload")
+		log.Debug("s3Uploader: no pending batches to upload")
 		return
 	}
 
-	// construct blob
-	codecVersion := encoding.CodecVersion(dbBatch.CodecVersion)
-	blob, err := b.constructBlobCodec(dbBatch)
+	key, err := b.uploadBlob(dbBatch, types.BlobStoragePlatformS3, 0)
 	if err != nil {
-		log.Error("failed to construct constructBlobCodec payload ", "codecVersion", codecVersion, "batch index", dbBatch.Index, "err", err)
+		log.Error("s3Uploader: failed to upload blob data", "batch index", dbBatch.Index, "batch hash", dbBatch.Hash, "err", err)
 		b.metrics.rollupBlobUploaderUploadToS3FailedTotal.Inc()
-		if updateErr := b.blobUploadOrm.InsertOrUpdateBlobUpload(b.ctx, dbBatch.Index, dbBatch.Hash, types.BlobStoragePlatformS3, types.BlobUploadStatusFailed); updateErr != nil {
-			log.Error("failed to update blob upload status to failed", "batch index", dbBatch.Index, "err", updateErr)
-		}
+	}
+
+	b.metrics.rollupBlobUploaderUploadToS3SuccessTotal.Inc()
+	log.Info("s3Uploader: successfully uploaded blob to S3", "batch index", dbBatch.Index, "batch hash", dbBatch.Hash, "versioned blob hash", key)
+}
+
+func (b *BlobUploader) UploadBlobToArweave() {
+	// skip upload if s3 uploader is not configured
+	if b.arweaveUploader == nil {
 		return
 	}
 
+	// get un-uploaded batches from database in ascending order by their index.
+	dbBatch, err := b.GetFirstUnuploadedBatchByPlatform(b.ctx, b.cfg.StartBatch, types.BlobStoragePlatformS3)
+	if err != nil {
+		log.Error("arweaveUploader: failed to fetch unuploaded batch", "err", err)
+		return
+	}
+
+	// nothing to do if we don't have any pending batches
+	if dbBatch == nil {
+		log.Debug("arweaveUploader: no pending batches to upload")
+		return
+	}
+
+	key, err := b.uploadBlob(dbBatch, types.BlobStoragePlatformArweave, 0)
+	if err != nil {
+		log.Error("arweaveUploader: failed to upload blob data", "batch index", dbBatch.Index, "batch hash", dbBatch.Hash, "err", err)
+		b.metrics.rollupBlobUploaderUploadToArweaveFailedTotal.Inc()
+	}
+
+	b.metrics.rollupBlobUploaderUploadToArweaveSuccessTotal.Inc()
+	log.Info("arweaveUploader: successfully uploaded blob to Arweave", "batch index", dbBatch.Index, "versioned blob hash", key)
+}
+
+func (b *BlobUploader) uploadBlob(batch *orm.Batch, platform types.BlobStoragePlatform, speedFactorArweave int64) (string, error) {
+	// construct blob
+	blob, err := b.constructBlobCodec(batch)
+	if err != nil {
+		return "", fmt.Errorf("failed to construct blob, err: %w", err)
+	}
+
 	// calculate versioned blob hash
 	versionedBlobHash, err := utils.CalculateVersionedBlobHash(*blob)
 	if err != nil {
-		log.Error("failed to calculate versioned blob hash", "batch index", dbBatch.Index, "err", err)
-		b.metrics.rollupBlobUploaderUploadToS3FailedTotal.Inc()
-		// update status to failed
-		if updateErr := b.blobUploadOrm.InsertOrUpdateBlobUpload(b.ctx, dbBatch.Index, dbBatch.Hash, types.BlobStoragePlatformS3, types.BlobUploadStatusFailed); updateErr != nil {
-			log.Error("failed to update blob upload status to failed", "batch index", dbBatch.Index, "err", updateErr)
-		}
-		return
+		return "", fmt.Errorf("failed to calculate versioned blob hash, err: %w", err)
 	}
-
-	// upload blob data to s3 bucket
 	key := common.BytesToHash(versionedBlobHash[:]).Hex()
-	err = b.s3Uploader.UploadData(b.ctx, blob[:], key)
-	if err != nil {
-		log.Error("failed to upload blob data to AWS S3", "batch index", dbBatch.Index, "versioned blob hash", key, "err", err)
-		b.metrics.rollupBlobUploaderUploadToS3FailedTotal.Inc()
-		// update status to failed
-		if updateErr := b.blobUploadOrm.InsertOrUpdateBlobUpload(b.ctx, dbBatch.Index, dbBatch.Hash, types.BlobStoragePlatformS3, types.BlobUploadStatusFailed); updateErr != nil {
-			log.Error("failed to update blob upload status to failed", "batch index", dbBatch.Index, "err", updateErr)
+
+	// upload blob data
+	switch platform {
+	case types.BlobStoragePlatformS3:
+		err = b.s3Uploader.UploadData(b.ctx, blob[:], key)
+		if err != nil {
+			if updateErr := b.blobUploadOrm.InsertOrUpdateBlobUpload(b.ctx, batch.Index, batch.Hash, types.BlobStoragePlatformS3, types.BlobUploadStatusFailed, ""); updateErr != nil {
+				return "", fmt.Errorf("failed to update blob upload status to failed, err: %w", updateErr)
+			}
+			return "", fmt.Errorf("failed to upload blob data to S3, err: %w", err)
 		}
-		return
+
+		// update status to uploaded
+		if err = b.blobUploadOrm.InsertOrUpdateBlobUpload(b.ctx, batch.Index, batch.Hash, platform, types.BlobUploadStatusUploaded, ""); err != nil {
+			return "", fmt.Errorf("failed to update blob upload status to uploaded, err: %w", err)
+		}
+	case types.BlobStoragePlatformArweave:
+		tx, err := b.arweaveUploader.UploadData(b.ctx, blob[:], key, speedFactorArweave)
+		if err != nil {
+			if updateErr := b.blobUploadOrm.InsertOrUpdateBlobUpload(b.ctx, batch.Index, batch.Hash, platform, types.BlobUploadStatusFailed, ""); updateErr != nil {
+				return "", fmt.Errorf("failed to update blob upload status to failed, err: %w", updateErr)
+			}
+			return "", fmt.Errorf("failed to upload blob data to Arweave, err: %w", err)
+		}
+
+		// update status to pending with new transaction hash
+		if err = b.blobUploadOrm.InsertOrUpdateBlobUpload(b.ctx, batch.Index, batch.Hash, platform, types.BlobUploadStatusPending, tx.ID); err != nil {
+			return "", fmt.Errorf("failed to update blob upload status to pending, err: %w", err)
+		}
+	default:
+		return "", fmt.Errorf("unsupported blob storage platform, platform: %d", platform)
 	}
 
-	// update status to uploaded
-	if err = b.blobUploadOrm.InsertOrUpdateBlobUpload(b.ctx, dbBatch.Index, dbBatch.Hash, types.BlobStoragePlatformS3, types.BlobUploadStatusUploaded); err != nil {
-		log.Error("failed to update blob upload status to uploaded", "batch index", dbBatch.Index, "err", err)
-		b.metrics.rollupBlobUploaderUploadToS3FailedTotal.Inc()
-		return
-	}
-
-	b.metrics.rollupBlobUploaderUploadToS3SuccessTotal.Inc()
-	log.Info("Successfully uploaded blob to S3", "batch index", dbBatch.Index, "versioned blob hash", key)
+	return key, nil
 }
 
 func (b *BlobUploader) constructBlobCodec(dbBatch *orm.Batch) (*kzg4844.Blob, error) {
@@ -136,12 +205,13 @@ func (b *BlobUploader) constructBlobCodec(dbBatch *orm.Batch) (*kzg4844.Blob, er
 		return nil, fmt.Errorf("failed to get chunks in range: %v", err)
 	}
 
+	// temporarily disable this check because the codec_version field for chunk was added later.
 	// check codec version
-	for _, dbChunk := range dbChunks {
-		if dbBatch.CodecVersion != dbChunk.CodecVersion {
-			return nil, fmt.Errorf("batch codec version is different from chunk codec version, batch index: %d, chunk index: %d, batch codec version: %d, chunk codec version: %d", dbBatch.Index, dbChunk.Index, dbBatch.CodecVersion, dbChunk.CodecVersion)
-		}
-	}
+	// for _, dbChunk := range dbChunks {
+	// 	if dbBatch.CodecVersion != dbChunk.CodecVersion {
+	// 		return nil, fmt.Errorf("batch codec version is different from chunk codec version, batch index: %d, chunk index: %d, batch codec version: %d, chunk codec version: %d", dbBatch.Index, dbChunk.Index, dbBatch.CodecVersion, dbChunk.CodecVersion)
+	// 	}
+	// }
 
 	chunks := make([]*encoding.Chunk, len(dbChunks))
 	var allBlocks []*encoding.Block // collect blocks for CodecV7
@@ -156,6 +226,15 @@ func (b *BlobUploader) constructBlobCodec(dbBatch *orm.Batch) (*kzg4844.Blob, er
 
 	var encodingBatch *encoding.Batch
 	codecVersion := encoding.CodecVersion(dbBatch.CodecVersion)
+
+	// temporarily add this check because the codec_version field for chunk was added later.
+	if codecVersion == encoding.CodecV0 && dbBatch.Index < 73224 {
+		codecVersion = encoding.CodecV1
+	}
+	if codecVersion == encoding.CodecV0 && dbBatch.Index >= 73224 { // for sepolia
+		codecVersion = encoding.CodecV2
+	}
+
 	switch codecVersion {
 	case encoding.CodecV0:
 		return nil, fmt.Errorf("codec version 0 doesn't support blob, batch index: %d", dbBatch.Index)
@@ -211,7 +290,7 @@ func (b *BlobUploader) GetFirstUnuploadedBatchByPlatform(ctx context.Context, st
 		batch, err = b.batchOrm.GetBatchByIndex(ctx, batchIndex)
 		if err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
-				log.Debug("got batch not proposed for blob uploading", "batch_index", batchIndex, "platform", platform.String())
+				log.Debug("got batch not proposed for blob uploading", "batch index", batchIndex, "platform", platform.String())
 				return nil, nil
 			}
 			return nil, err

rollup/internal/controller/blob_uploader/blob_uploader_metrics.go

@@ -10,6 +10,8 @@ import (
 type blobUploaderMetrics struct {
 	rollupBlobUploaderUploadToS3SuccessTotal prometheus.Counter
 	rollupBlobUploaderUploadToS3FailedTotal  prometheus.Counter
+	rollupBlobUploaderUploadToArweaveSuccessTotal prometheus.Counter
+	rollupBlobUploaderUploadToArweaveFailedTotal  prometheus.Counter
 }
 
 var (
@@ -28,6 +30,14 @@ func initBlobUploaderMetrics(reg prometheus.Registerer) *blobUploaderMetrics {
 				Name: "rollup_blob_uploader_upload_to_s3_failed_total",
 				Help: "The total number of upload blob to S3 runs failed total",
 			}),
+			rollupBlobUploaderUploadToArweaveSuccessTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_blob_uploader_upload_to_arweave_success_total",
+				Help: "The total number of upload blob to arweave runs success total",
+			}),
+			rollupBlobUploaderUploadToArweaveFailedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_blob_uploader_upload_to_arweave_failed_total",
+				Help: "The total number of upload blob to arweave runs failed total",
+			}),
 		}
 	})
 	return blobUploaderMetric

rollup/internal/controller/blob_uploader/s3_sender.go

@@ -25,8 +25,6 @@ type S3Uploader struct {
 func NewS3Uploader(cfg *config.AWSS3Config) (*S3Uploader, error) {
 	// load AWS config
 	var opts []func(*awsconfig.LoadOptions) error
-	opts = append(opts, awsconfig.WithRegion(cfg.Region))
-
 	// if AccessKey && SecretKey provided, use it
 	if cfg.AccessKey != "" && cfg.SecretKey != "" {
 		opts = append(opts, awsconfig.WithCredentialsProvider(
@@ -38,6 +36,10 @@ func NewS3Uploader(cfg *config.AWSS3Config) (*S3Uploader, error) {
 		)
 	}
 
+	if cfg.Region != "" {
+		opts = append(opts, awsconfig.WithRegion(cfg.Region))
+	}
+
 	awsCfg, err := awsconfig.LoadDefaultConfig(context.Background(), opts...)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load default config: %w", err)

rollup/internal/controller/relayer/l2_relayer.go

@@ -377,7 +377,7 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 		}
 	}
 
-	var batchesToSubmit []*dbBatchWithChunks
+	var batchesToSubmit []*dbBatchWithChunksAndParent
 	for i, dbBatch := range dbBatches {
 		var dbChunks []*orm.Chunk
 		var dbParentBatch *orm.Batch
@@ -433,9 +433,10 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 		}
 
 		if batchesToSubmitLen < r.cfg.BatchSubmission.MaxBatches {
-			batchesToSubmit = append(batchesToSubmit, &dbBatchWithChunks{
-				Batch:  dbBatch,
-				Chunks: dbChunks,
+			batchesToSubmit = append(batchesToSubmit, &dbBatchWithChunksAndParent{
+				Batch:       dbBatch,
+				Chunks:      dbChunks,
+				ParentBatch: dbParentBatch,
 			})
 		}
 
@@ -465,7 +466,7 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 
 	codecVersion := encoding.CodecVersion(firstBatch.CodecVersion)
 	switch codecVersion {
-	case encoding.CodecV7, encoding.CodecV8:
+	case encoding.CodecV7:
 		calldata, blobs, maxBlockHeight, totalGasUsed, err = r.constructCommitBatchPayloadCodecV7(batchesToSubmit, firstBatch, lastBatch)
 		if err != nil {
 			log.Error("failed to construct constructCommitBatchPayloadCodecV7 payload for V7", "codecVersion", codecVersion, "start index", firstBatch.Index, "end index", lastBatch.Index, "err", err)
@@ -476,7 +477,7 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 		return
 	}
 
-	txHash, blobBaseFee, err := r.commitSender.SendTransaction(r.contextIDFromBatches(codecVersion, batchesToSubmit), &r.cfg.RollupContractAddress, calldata, blobs)
+	txHash, blobBaseFee, err := r.commitSender.SendTransaction(r.contextIDFromBatches(batchesToSubmit), &r.cfg.RollupContractAddress, calldata, blobs)
 	if err != nil {
 		if errors.Is(err, sender.ErrTooManyPendingBlobTxs) {
 			r.metrics.rollupL2RelayerProcessPendingBatchErrTooManyPendingBlobTxsTotal.Inc()
@@ -522,25 +523,28 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 	log.Info("Sent the commitBatches tx to layer1", "batches count", len(batchesToSubmit), "start index", firstBatch.Index, "start hash", firstBatch.Hash, "end index", lastBatch.Index, "end hash", lastBatch.Hash, "tx hash", txHash.String())
 }
 
-func (r *Layer2Relayer) contextIDFromBatches(codecVersion encoding.CodecVersion, batches []*dbBatchWithChunks) string {
-	contextIDs := []string{fmt.Sprintf("v%d", codecVersion)}
+func (r *Layer2Relayer) contextIDFromBatches(batches []*dbBatchWithChunksAndParent) string {
+	contextIDs := []string{"v7"}
+
 	for _, batch := range batches {
 		contextIDs = append(contextIDs, batch.Batch.Hash)
 	}
+
 	return strings.Join(contextIDs, "-")
 }
 
 func (r *Layer2Relayer) batchHashesFromContextID(contextID string) []string {
-	parts := strings.SplitN(contextID, "-", 2)
-	if len(parts) == 2 && strings.HasPrefix(parts[0], "v") {
-		return strings.Split(parts[1], "-")
+	if strings.HasPrefix(contextID, "v7-") {
+		return strings.Split(contextID, "-")[1:]
 	}
+
 	return []string{contextID}
 }
 
-type dbBatchWithChunks struct {
-	Batch  *orm.Batch
-	Chunks []*orm.Chunk
+type dbBatchWithChunksAndParent struct {
+	Batch       *orm.Batch
+	Chunks      []*orm.Chunk
+	ParentBatch *orm.Batch
 }
 
 // ProcessPendingBundles submits proof to layer 1 rollup contract
@@ -689,7 +693,7 @@ func (r *Layer2Relayer) finalizeBundle(bundle *orm.Bundle, withProof bool) error
 
 	var calldata []byte
 	switch encoding.CodecVersion(bundle.CodecVersion) {
-	case encoding.CodecV7, encoding.CodecV8:
+	case encoding.CodecV7:
 		calldata, err = r.constructFinalizeBundlePayloadCodecV7(dbBatch, endChunk, aggProof)
 		if err != nil {
 			return fmt.Errorf("failed to construct finalizeBundle payload codecv7, bundle index: %v, last batch index: %v, err: %w", bundle.Index, dbBatch.Index, err)
@@ -894,7 +898,7 @@ func (r *Layer2Relayer) handleL2RollupRelayerConfirmLoop(ctx context.Context) {
 	}
 }
 
-func (r *Layer2Relayer) constructCommitBatchPayloadCodecV7(batchesToSubmit []*dbBatchWithChunks, firstBatch, lastBatch *orm.Batch) ([]byte, []*kzg4844.Blob, uint64, uint64, error) {
+func (r *Layer2Relayer) constructCommitBatchPayloadCodecV7(batchesToSubmit []*dbBatchWithChunksAndParent, firstBatch, lastBatch *orm.Batch) ([]byte, []*kzg4844.Blob, uint64, uint64, error) {
 	var maxBlockHeight uint64
 	var totalGasUsed uint64
 	blobs := make([]*kzg4844.Blob, 0, len(batchesToSubmit))
@@ -925,7 +929,7 @@ func (r *Layer2Relayer) constructCommitBatchPayloadCodecV7(batchesToSubmit []*db
 
 		encodingBatch := &encoding.Batch{
 			Index:                  b.Batch.Index,
-			ParentBatchHash:        common.HexToHash(b.Batch.ParentBatchHash),
+			ParentBatchHash:        common.HexToHash(b.ParentBatch.Hash),
 			PrevL1MessageQueueHash: common.HexToHash(b.Batch.PrevL1MessageQueueHash),
 			PostL1MessageQueueHash: common.HexToHash(b.Batch.PostL1MessageQueueHash),
 			Blocks:                 batchBlocks,

rollup/internal/controller/watcher/batch_proposer.go

@@ -54,7 +54,7 @@ type BatchProposer struct {
 
 // NewBatchProposer creates a new BatchProposer instance.
 func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, minCodecVersion encoding.CodecVersion, chainCfg *params.ChainConfig, db *gorm.DB, reg prometheus.Registerer) *BatchProposer {
-	log.Info("new batch proposer", "batchTimeoutSec", cfg.BatchTimeoutSec, "maxBlobSize", maxBlobSize, "maxUncompressedBatchBytesSize", cfg.MaxUncompressedBatchBytesSize)
+	log.Info("new batch proposer", "batchTimeoutSec", cfg.BatchTimeoutSec, "maxBlobSize", maxBlobSize)
 
 	p := &BatchProposer{
 		ctx:             ctx,
@@ -294,18 +294,16 @@ func (p *BatchProposer) proposeBatch() error {
 
 		p.recordTimerBatchMetrics(metrics)
 
-		if metrics.L1CommitBlobSize > maxBlobSize || metrics.L1CommitUncompressedBatchBytesSize > p.cfg.MaxUncompressedBatchBytesSize {
+		if metrics.L1CommitBlobSize > maxBlobSize {
 			if i == 0 {
 				// The first chunk exceeds hard limits, which indicates a bug in the chunk-proposer, manual fix is needed.
-				return fmt.Errorf("the first chunk exceeds limits; start block number: %v, end block number: %v, limits: %+v, maxChunkNum: %v, maxBlobSize: %v, maxUncompressedBatchBytesSize: %v",
-					dbChunks[0].StartBlockNumber, dbChunks[0].EndBlockNumber, metrics, maxChunksThisBatch, maxBlobSize, p.cfg.MaxUncompressedBatchBytesSize)
+				return fmt.Errorf("the first chunk exceeds limits; start block number: %v, end block number: %v, limits: %+v, maxChunkNum: %v, maxBlobSize: %v",
+					dbChunks[0].StartBlockNumber, dbChunks[0].EndBlockNumber, metrics, maxChunksThisBatch, maxBlobSize)
 			}
 
 			log.Debug("breaking limit condition in batching",
 				"l1CommitBlobSize", metrics.L1CommitBlobSize,
-				"maxBlobSize", maxBlobSize,
-				"L1CommitUncompressedBatchBytesSize", metrics.L1CommitUncompressedBatchBytesSize,
-				"maxUncompressedBatchBytesSize", p.cfg.MaxUncompressedBatchBytesSize)
+				"maxBlobSize", maxBlobSize)
 
 			lastChunk := batch.Chunks[len(batch.Chunks)-1]
 			batch.Chunks = batch.Chunks[:len(batch.Chunks)-1]

rollup/internal/controller/watcher/batch_proposer_test.go

@@ -72,10 +72,9 @@ func testBatchProposerLimitsCodecV7(t *testing.T) {
 			assert.NoError(t, err)
 
 			cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-				MaxBlockNumPerChunk:           1,
-				MaxL2GasPerChunk:              20000000,
-				ChunkTimeoutSec:               300,
-				MaxUncompressedBatchBytesSize: math.MaxUint64,
+				MaxBlockNumPerChunk: 1,
+				MaxL2GasPerChunk:    20000000,
+				ChunkTimeoutSec:     300,
 			}, encoding.CodecV7, &params.ChainConfig{
 				LondonBlock:    big.NewInt(0),
 				BernoulliBlock: big.NewInt(0),
@@ -89,9 +88,8 @@ func testBatchProposerLimitsCodecV7(t *testing.T) {
 			cp.TryProposeChunk() // chunk2 contains block2
 
 			bp := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
-				MaxChunksPerBatch:             math.MaxInt32,
-				BatchTimeoutSec:               tt.batchTimeoutSec,
-				MaxUncompressedBatchBytesSize: math.MaxUint64,
+				MaxChunksPerBatch: math.MaxInt32,
+				BatchTimeoutSec:   tt.batchTimeoutSec,
 			}, encoding.CodecV7, &params.ChainConfig{
 				LondonBlock:    big.NewInt(0),
 				BernoulliBlock: big.NewInt(0),
@@ -154,10 +152,9 @@ func testBatchProposerBlobSizeLimitCodecV7(t *testing.T) {
 	chainConfig := &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}
 
 	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-		MaxBlockNumPerChunk:           math.MaxUint64,
-		MaxL2GasPerChunk:              math.MaxUint64,
-		ChunkTimeoutSec:               0,
-		MaxUncompressedBatchBytesSize: math.MaxUint64,
+		MaxBlockNumPerChunk: math.MaxUint64,
+		MaxL2GasPerChunk:    math.MaxUint64,
+		ChunkTimeoutSec:     0,
 	}, encoding.CodecV7, chainConfig, db, nil)
 
 	blockHeight := uint64(0)
@@ -175,9 +172,8 @@ func testBatchProposerBlobSizeLimitCodecV7(t *testing.T) {
 	}
 
 	bp := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
-		MaxChunksPerBatch:             math.MaxInt32,
-		BatchTimeoutSec:               math.MaxUint32,
-		MaxUncompressedBatchBytesSize: math.MaxUint64,
+		MaxChunksPerBatch: math.MaxInt32,
+		BatchTimeoutSec:   math.MaxUint32,
 	}, encoding.CodecV7, chainConfig, db, nil)
 
 	for i := 0; i < 2; i++ {
@@ -227,10 +223,9 @@ func testBatchProposerMaxChunkNumPerBatchLimitCodecV7(t *testing.T) {
 	chainConfig := &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}
 
 	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-		MaxBlockNumPerChunk:           math.MaxUint64,
-		MaxL2GasPerChunk:              math.MaxUint64,
-		ChunkTimeoutSec:               0,
-		MaxUncompressedBatchBytesSize: math.MaxUint64,
+		MaxBlockNumPerChunk: math.MaxUint64,
+		MaxL2GasPerChunk:    math.MaxUint64,
+		ChunkTimeoutSec:     0,
 	}, encoding.CodecV7, chainConfig, db, nil)
 
 	block = readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
@@ -243,9 +238,8 @@ func testBatchProposerMaxChunkNumPerBatchLimitCodecV7(t *testing.T) {
 	}
 
 	bp := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
-		MaxChunksPerBatch:             45,
-		BatchTimeoutSec:               math.MaxUint32,
-		MaxUncompressedBatchBytesSize: math.MaxUint64,
+		MaxChunksPerBatch: 45,
+		BatchTimeoutSec:   math.MaxUint32,
 	}, encoding.CodecV7, chainConfig, db, nil)
 	bp.TryProposeBatch()
 
@@ -256,102 +250,3 @@ func testBatchProposerMaxChunkNumPerBatchLimitCodecV7(t *testing.T) {
 
 	assert.Equal(t, expectedChunkNum, dbBatch.EndChunkIndex)
 }
-
-func testBatchProposerUncompressedBatchBytesLimitCodecV8(t *testing.T) {
-	db := setupDB(t)
-	defer database.CloseDB(db)
-
-	// Add genesis batch
-	genesisBlock := &encoding.Block{
-		Header: &gethTypes.Header{
-			Number: big.NewInt(0),
-		},
-	}
-	genesisChunk := &encoding.Chunk{
-		Blocks: []*encoding.Block{genesisBlock},
-	}
-	chunkOrm := orm.NewChunk(db)
-	_, err := chunkOrm.InsertChunk(context.Background(), genesisChunk, encoding.CodecV0, utils.ChunkMetrics{})
-	assert.NoError(t, err)
-
-	genesisBatch := &encoding.Batch{
-		Index:                      0,
-		TotalL1MessagePoppedBefore: 0,
-		ParentBatchHash:            common.Hash{},
-		Chunks:                     []*encoding.Chunk{genesisChunk},
-	}
-	batchOrm := orm.NewBatch(db)
-	_, err = batchOrm.InsertBatch(context.Background(), genesisBatch, encoding.CodecV0, utils.BatchMetrics{})
-	assert.NoError(t, err)
-
-	// Create blocks with large calldata
-	block := readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
-
-	// Create large calldata (3KiB per block)
-	largeCalldata := make([]byte, 3*1024) // 3KiB calldata
-	for i := range largeCalldata {
-		largeCalldata[i] = byte(i % 256)
-	}
-
-	// Modify the block to have a transaction with large calldata
-	block.Transactions[0].Data = "0x" + common.Bytes2Hex(largeCalldata)
-
-	chainConfig := &params.ChainConfig{
-		LondonBlock:    big.NewInt(0),
-		BernoulliBlock: big.NewInt(0),
-		CurieBlock:     big.NewInt(0),
-		DarwinTime:     new(uint64),
-		DarwinV2Time:   new(uint64),
-		EuclidTime:     new(uint64),
-		EuclidV2Time:   new(uint64),
-		FeynmanTime:    new(uint64),
-	}
-
-	// Create chunk proposer with no uncompressed batch bytes limit for chunks
-	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-		MaxBlockNumPerChunk:           1, // One block per chunk
-		MaxL2GasPerChunk:              math.MaxUint64,
-		ChunkTimeoutSec:               math.MaxUint32,
-		MaxUncompressedBatchBytesSize: math.MaxUint64,
-	}, encoding.CodecV8, chainConfig, db, nil)
-
-	// Insert 2 blocks with large calldata and create 2 chunks
-	l2BlockOrm := orm.NewL2Block(db)
-	for i := uint64(1); i <= 2; i++ {
-		blockCopy := *block
-		blockCopy.Header = &gethTypes.Header{}
-		*blockCopy.Header = *block.Header
-		blockCopy.Header.Number = new(big.Int).SetUint64(i)
-		blockCopy.Header.Time = i
-		err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{&blockCopy})
-		assert.NoError(t, err)
-
-		cp.TryProposeChunk() // Each call creates one chunk with one block
-	}
-
-	// Create batch proposer with 4KiB uncompressed batch bytes limit
-	// Each chunk is ~3KiB, so 1 chunk (~3KiB) should fit, but 2 chunks (~6KiB) should exceed limit
-	bp := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
-		MaxChunksPerBatch:             math.MaxInt32,  // No chunk count limit
-		BatchTimeoutSec:               math.MaxUint32, // No timeout limit
-		MaxUncompressedBatchBytesSize: 4 * 1024,       // 4KiB limit
-	}, encoding.CodecV8, chainConfig, db, nil)
-
-	bp.TryProposeBatch()
-
-	// Check that a batch was created
-	batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
-	assert.NoError(t, err)
-	assert.Len(t, batches, 2) // genesis batch + 1 new batch
-
-	// Verify that the batch contains only 1 chunk (not 2) due to uncompressed batch bytes limit
-	newBatch := batches[1] // Skip genesis batch
-	assert.Equal(t, uint64(1), newBatch.StartChunkIndex)
-	assert.Equal(t, uint64(1), newBatch.EndChunkIndex) // Should only include chunk 1
-
-	// Verify that the second chunk is still available for next batch
-	chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), 2, 0)
-	assert.NoError(t, err)
-	assert.Len(t, chunks, 1)                 // Second chunk should still be available
-	assert.Equal(t, "", chunks[0].BatchHash) // Should not be assigned to any batch yet
-}

rollup/internal/controller/watcher/bundle_proposer_test.go

@@ -93,16 +93,14 @@ func testBundleProposerLimitsCodecV7(t *testing.T) {
 			chainConfig := &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}
 
 			cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-				MaxBlockNumPerChunk:           1,
-				MaxL2GasPerChunk:              math.MaxUint64,
-				ChunkTimeoutSec:               math.MaxUint32,
-				MaxUncompressedBatchBytesSize: math.MaxUint64,
+				MaxBlockNumPerChunk: 1,
+				MaxL2GasPerChunk:    math.MaxUint64,
+				ChunkTimeoutSec:     math.MaxUint32,
 			}, encoding.CodecV7, chainConfig, db, nil)
 
 			bap := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
-				MaxChunksPerBatch:             math.MaxInt32,
-				BatchTimeoutSec:               0,
-				MaxUncompressedBatchBytesSize: math.MaxUint64,
+				MaxChunksPerBatch: math.MaxInt32,
+				BatchTimeoutSec:   0,
 			}, encoding.CodecV7, chainConfig, db, nil)
 
 			cp.TryProposeChunk()  // chunk1 contains block1

rollup/internal/controller/watcher/chunk_proposer.go

@@ -295,19 +295,17 @@ func (p *ChunkProposer) proposeChunk() error {
 
 		p.recordTimerChunkMetrics(metrics)
 
-		if metrics.L2Gas > p.cfg.MaxL2GasPerChunk || metrics.L1CommitBlobSize > maxBlobSize || metrics.L1CommitUncompressedBatchBytesSize > p.cfg.MaxUncompressedBatchBytesSize {
+		if metrics.L2Gas > p.cfg.MaxL2GasPerChunk || metrics.L1CommitBlobSize > maxBlobSize {
 			if i == 0 {
 				// The first block exceeds hard limits, which indicates a bug in the sequencer, manual fix is needed.
-				return fmt.Errorf("the first block exceeds limits; block number: %v, limits: %+v, maxBlobSize: %v, maxUncompressedBatchBytesSize: %v", block.Header.Number, metrics, maxBlobSize, p.cfg.MaxUncompressedBatchBytesSize)
+				return fmt.Errorf("the first block exceeds limits; block number: %v, limits: %+v, maxBlobSize: %v", block.Header.Number, metrics, maxBlobSize)
 			}
 
 			log.Debug("breaking limit condition in chunking",
 				"l2Gas", metrics.L2Gas,
 				"maxL2Gas", p.cfg.MaxL2GasPerChunk,
 				"l1CommitBlobSize", metrics.L1CommitBlobSize,
-				"maxBlobSize", maxBlobSize,
-				"L1CommitUncompressedBatchBytesSize", metrics.L1CommitUncompressedBatchBytesSize,
-				"maxUncompressedBatchBytesSize", p.cfg.MaxUncompressedBatchBytesSize)
+				"maxBlobSize", maxBlobSize)
 
 			chunk.Blocks = chunk.Blocks[:len(chunk.Blocks)-1]
 			chunk.PostL1MessageQueueHash = previousPostL1MessageQueueHash

rollup/internal/controller/watcher/chunk_proposer_test.go

@@ -6,7 +6,6 @@ import (
 	"testing"
 
 	"github.com/scroll-tech/da-codec/encoding"
-	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/common/math"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/params"
@@ -85,10 +84,9 @@ func testChunkProposerLimitsCodecV7(t *testing.T) {
 			assert.NoError(t, err)
 
 			cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-				MaxBlockNumPerChunk:           tt.maxBlockNum,
-				MaxL2GasPerChunk:              tt.maxL2Gas,
-				ChunkTimeoutSec:               tt.chunkTimeoutSec,
-				MaxUncompressedBatchBytesSize: math.MaxUint64,
+				MaxBlockNumPerChunk: tt.maxBlockNum,
+				MaxL2GasPerChunk:    tt.maxL2Gas,
+				ChunkTimeoutSec:     tt.chunkTimeoutSec,
 			}, encoding.CodecV7, &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}, db, nil)
 			cp.TryProposeChunk()
 
@@ -130,10 +128,9 @@ func testChunkProposerBlobSizeLimitCodecV7(t *testing.T) {
 	chainConfig := &params.ChainConfig{LondonBlock: big.NewInt(0), BernoulliBlock: big.NewInt(0), CurieBlock: big.NewInt(0), DarwinTime: new(uint64), DarwinV2Time: new(uint64), EuclidTime: new(uint64), EuclidV2Time: new(uint64)}
 
 	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-		MaxBlockNumPerChunk:           255,
-		MaxL2GasPerChunk:              math.MaxUint64,
-		ChunkTimeoutSec:               math.MaxUint32,
-		MaxUncompressedBatchBytesSize: math.MaxUint64,
+		MaxBlockNumPerChunk: 255,
+		MaxL2GasPerChunk:    math.MaxUint64,
+		ChunkTimeoutSec:     math.MaxUint32,
 	}, encoding.CodecV7, chainConfig, db, nil)
 
 	for i := 0; i < 2; i++ {
@@ -156,76 +153,3 @@ func testChunkProposerBlobSizeLimitCodecV7(t *testing.T) {
 		assert.Equal(t, expected, chunk.EndBlockNumber)
 	}
 }
-
-func testChunkProposerUncompressedBatchBytesLimitCodecV8(t *testing.T) {
-	db := setupDB(t)
-	defer database.CloseDB(db)
-
-	// Create a block with very large calldata to test uncompressed batch bytes limit
-	block := readBlockFromJSON(t, "../../../testdata/blockTrace_03.json")
-
-	// Create a transaction with large calldata (around 3KiB)
-	largeCalldata := make([]byte, 3*1024) // 3KiB calldata
-	for i := range largeCalldata {
-		largeCalldata[i] = byte(i % 256)
-	}
-
-	// Modify the block to have a transaction with large calldata
-	block.Transactions[0].Data = "0x" + common.Bytes2Hex(largeCalldata)
-
-	// Insert two identical blocks with large calldata
-	l2BlockOrm := orm.NewL2Block(db)
-	for i := uint64(0); i < 2; i++ {
-		blockCopy := *block
-		blockCopy.Header = &gethTypes.Header{}
-		*blockCopy.Header = *block.Header
-		blockCopy.Header.Number = new(big.Int).SetUint64(i + 1)
-		blockCopy.Header.Time = i + 1
-		err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{&blockCopy})
-		assert.NoError(t, err)
-	}
-
-	// Add genesis chunk
-	chunkOrm := orm.NewChunk(db)
-	_, err := chunkOrm.InsertChunk(context.Background(), &encoding.Chunk{Blocks: []*encoding.Block{{Header: &gethTypes.Header{Number: big.NewInt(0)}}}}, encoding.CodecV0, utils.ChunkMetrics{})
-	assert.NoError(t, err)
-
-	chainConfig := &params.ChainConfig{
-		LondonBlock:    big.NewInt(0),
-		BernoulliBlock: big.NewInt(0),
-		CurieBlock:     big.NewInt(0),
-		DarwinTime:     new(uint64),
-		DarwinV2Time:   new(uint64),
-		EuclidTime:     new(uint64),
-		EuclidV2Time:   new(uint64),
-		FeynmanTime:    new(uint64),
-	}
-
-	// Set max_uncompressed_batch_bytes_size to 4KiB (4 * 1024)
-	// One block (~3KiB) should fit, but two blocks (~6KiB) should exceed the limit
-	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-		MaxBlockNumPerChunk:           math.MaxUint64, // No block number limit
-		MaxL2GasPerChunk:              math.MaxUint64, // No gas limit
-		ChunkTimeoutSec:               math.MaxUint32, // No timeout limit
-		MaxUncompressedBatchBytesSize: 4 * 1024,       // 4KiB limit
-	}, encoding.CodecV8, chainConfig, db, nil)
-
-	// Try to propose chunk
-	cp.TryProposeChunk()
-
-	// Check that a chunk was created
-	chunks, err := chunkOrm.GetChunksGEIndex(context.Background(), 1, 0)
-	assert.NoError(t, err)
-	assert.Len(t, chunks, 1)
-
-	// Verify that the chunk contains only 1 block (not 2) due to uncompressed batch bytes limit
-	chunk := chunks[0]
-	assert.Equal(t, uint64(1), chunk.StartBlockNumber)
-	assert.Equal(t, uint64(1), chunk.EndBlockNumber)
-
-	// Verify that the second block is still available for next chunk
-	blockOrm := orm.NewL2Block(db)
-	blocks, err := blockOrm.GetL2BlocksGEHeight(context.Background(), 2, 0)
-	assert.NoError(t, err)
-	assert.Len(t, blocks, 1) // Second block should still be available
-}

rollup/internal/controller/watcher/watcher_test.go

@@ -103,13 +103,11 @@ func TestFunction(t *testing.T) {
 	// Run chunk proposer test cases.
 	t.Run("TestChunkProposerLimitsCodecV7", testChunkProposerLimitsCodecV7)
 	t.Run("TestChunkProposerBlobSizeLimitCodecV7", testChunkProposerBlobSizeLimitCodecV7)
-	t.Run("TestChunkProposerUncompressedBatchBytesLimitCodecV8", testChunkProposerUncompressedBatchBytesLimitCodecV8)
 
 	// Run batch proposer test cases.
 	t.Run("TestBatchProposerLimitsCodecV7", testBatchProposerLimitsCodecV7)
 	t.Run("TestBatchProposerBlobSizeLimitCodecV7", testBatchProposerBlobSizeLimitCodecV7)
 	t.Run("TestBatchProposerMaxChunkNumPerBatchLimitCodecV7", testBatchProposerMaxChunkNumPerBatchLimitCodecV7)
-	t.Run("TestBatchProposerUncompressedBatchBytesLimitCodecV8", testBatchProposerUncompressedBatchBytesLimitCodecV8)
 
 	// Run bundle proposer test cases.
 	t.Run("TestBundleProposerLimitsCodecV7", testBundleProposerLimitsCodecV7)

rollup/internal/orm/blob_upload.go

@@ -20,6 +20,7 @@ type BlobUpload struct {
 	BatchHash  string `json:"batch_hash" gorm:"column:batch_hash"`
 	Platform   int16  `json:"platform" gorm:"column:platform"`
 	Status     int16  `json:"status" gorm:"column:status"`
+	TxHash     string `json:"tx_hash" gorm:"column:tx_hash;default:NULL"`
 
 	// metadata
 	CreatedAt time.Time      `json:"created_at" gorm:"column:created_at"`
@@ -41,7 +42,8 @@ func (*BlobUpload) TableName() string {
 func (o *BlobUpload) GetNextBatchIndexToUploadByPlatform(ctx context.Context, startBatch uint64, platform types.BlobStoragePlatform) (uint64, error) {
 	db := o.db.WithContext(ctx)
 	db = db.Model(&BlobUpload{})
-	db = db.Where("platform = ? AND status = ?", platform, types.BlobUploadStatusUploaded)
+	db = db.Where("platform = ?", platform, types.BlobUploadStatusUploaded)
+	db = db.Where("status = ? OR status = ?", types.BlobUploadStatusUploaded, types.BatchProofsStatusPending)
 	db = db.Order("batch_index DESC")
 	db = db.Limit(1)
 
@@ -87,8 +89,22 @@ func (o *BlobUpload) GetBlobUploads(ctx context.Context, fields map[string]inter
 	return blobUploads, nil
 }
 
+// GetPendingOrReplacedTransactionsBySenderType retrieves pending or replaced transactions filtered by sender type, ordered by nonce, then gas_fee_cap (gas_price in legacy tx), and limited to a specified count.
+func (o *BlobUpload) GetPendingBlobUploads(ctx context.Context, limit int) ([]BlobUpload, error) {
+	var blobUploads []BlobUpload
+	db := o.db.WithContext(ctx)
+	db = db.Model(&BlobUpload{})
+	db = db.Where("status = ?", types.BatchProofsStatusPending)
+	db = db.Order("batch_index asc")
+	db = db.Limit(limit)
+	if err := db.Find(&blobUploads).Error; err != nil {
+		return nil, fmt.Errorf("failed to get pending blob uploads, error: %w", err)
+	}
+	return blobUploads, nil
+}
+
 // InsertOrUpdateBlobUpload inserts a new blob upload record or updates the existing one.
-func (o *BlobUpload) InsertOrUpdateBlobUpload(ctx context.Context, batchIndex uint64, batchHash string, platform types.BlobStoragePlatform, status types.BlobUploadStatus, dbTX ...*gorm.DB) error {
+func (o *BlobUpload) InsertOrUpdateBlobUpload(ctx context.Context, batchIndex uint64, batchHash string, platform types.BlobStoragePlatform, status types.BlobUploadStatus, txHash string, dbTX ...*gorm.DB) error {
 	db := o.db
 	if len(dbTX) > 0 && dbTX[0] != nil {
 		db = dbTX[0]
@@ -106,18 +122,43 @@ func (o *BlobUpload) InsertOrUpdateBlobUpload(ctx context.Context, batchIndex ui
 			BatchHash:  batchHash,
 			Platform:   int16(platform),
 			Status:     int16(status),
+			TxHash:     txHash,
 		}
 		if err := db.Create(&newRecord).Error; err != nil {
-			return fmt.Errorf("BlobUpload.InsertOrUpdateBlobUpload insert error: %w, batch index: %v, batch_hash: %v, platform: %v", err, batchIndex, batchHash, platform)
+			return fmt.Errorf("BlobUpload.InsertOrUpdateBlobUpload insert error: %w, batch index: %v, batch hash: %v, platform: %v", err, batchIndex, batchHash, platform)
 		}
 		return nil
 	} else if err != nil {
-		return fmt.Errorf("BlobUpload.InsertOrUpdateBlobUpload query error: %w, batch index: %v, batch_hash: %v, platform: %v", err, batchIndex, batchHash, platform)
+		return fmt.Errorf("BlobUpload.InsertOrUpdateBlobUpload query error: %w, batch index: %v, batch hash: %v, platform: %v", err, batchIndex, batchHash, platform)
 	}
 
-	if err := db.Model(&existing).Update("status", int16(status)).Error; err != nil {
-		return fmt.Errorf("BlobUpload.InsertOrUpdateBlobUpload update error: %w, batch index: %v, batch_hash: %v, platform: %v", err, batchIndex, batchHash, platform)
+	updateFields := map[string]interface{}{
+		"status":  int16(status),
+		"tx_hash": txHash,
+	}
+	if err := db.Model(&existing).Where("batch_index = ? AND batch_hash = ? AND platform = ? AND deleted_at IS NULL",
+		batchIndex, batchHash, int16(platform)).Updates(updateFields).Error; err != nil {
+		return fmt.Errorf("BlobUpload.InsertOrUpdateBlobUpload update error: %w, batch index: %v, batch hash: %v, platform: %v", err, batchIndex, batchHash, platform)
 	}
 
 	return nil
 }
+
+// UpdateUploadStatus updates the upload status of a blob upload.
+func (o *BlobUpload) UpdateUploadStatus(ctx context.Context, txHash string, status types.BlobUploadStatus, dbTX ...*gorm.DB) error {
+	db := o.db
+	if len(dbTX) > 0 && dbTX[0] != nil {
+		db = dbTX[0]
+	}
+	db = db.WithContext(ctx)
+	db = db.Model(&BlobUpload{})
+	db = db.Where("tx_hash", txHash)
+
+	updateFields := map[string]interface{}{
+		"status": int16(status),
+	}
+	if err := db.Updates(updateFields).Error; err != nil {
+		return fmt.Errorf("BlobUpload.UpdateUploadStatus error: %w, tx hash: %v, status: %v", err, txHash, status.String())
+	}
+	return nil
+}

rollup/internal/utils/utils.go

@@ -15,8 +15,7 @@ type ChunkMetrics struct {
 	L2Gas               uint64
 	FirstBlockTimestamp uint64
 
-	L1CommitBlobSize                   uint64
-	L1CommitUncompressedBatchBytesSize uint64
+	L1CommitBlobSize uint64
 
 	// timing metrics
 	EstimateBlobSizeTime time.Duration
@@ -42,7 +41,7 @@ func CalculateChunkMetrics(chunk *encoding.Chunk, codecVersion encoding.CodecVer
 	}
 
 	metrics.EstimateBlobSizeTime, err = measureTime(func() error {
-		metrics.L1CommitUncompressedBatchBytesSize, metrics.L1CommitBlobSize, err = codec.EstimateChunkL1CommitBatchSizeAndBlobSize(chunk)
+		_, metrics.L1CommitBlobSize, err = codec.EstimateChunkL1CommitBatchSizeAndBlobSize(chunk)
 		return err
 	})
 	if err != nil {
@@ -57,8 +56,7 @@ type BatchMetrics struct {
 	NumChunks           uint64
 	FirstBlockTimestamp uint64
 
-	L1CommitBlobSize                   uint64
-	L1CommitUncompressedBatchBytesSize uint64
+	L1CommitBlobSize uint64
 
 	// timing metrics
 	EstimateBlobSizeTime time.Duration
@@ -77,7 +75,7 @@ func CalculateBatchMetrics(batch *encoding.Batch, codecVersion encoding.CodecVer
 	}
 
 	metrics.EstimateBlobSizeTime, err = measureTime(func() error {
-		metrics.L1CommitUncompressedBatchBytesSize, metrics.L1CommitBlobSize, err = codec.EstimateBatchL1CommitBatchSizeAndBlobSize(batch)
+		_, metrics.L1CommitBlobSize, err = codec.EstimateBatchL1CommitBatchSizeAndBlobSize(batch)
 		return err
 	})
 	if err != nil {

rollup/proposer-tool-config.json

@@ -4,13 +4,11 @@
       "chunk_proposer_config": {
         "max_block_num_per_chunk": 100,
         "max_l2_gas_per_chunk": 20000000,
-        "chunk_timeout_sec": 72000000000,
-        "max_uncompressed_batch_bytes_size": 4194304
+        "chunk_timeout_sec": 72000000000
       },
       "batch_proposer_config": {
         "batch_timeout_sec": 72000000000,
-        "max_chunks_per_batch": 45,
-        "max_uncompressed_batch_bytes_size": 4194304
+        "max_chunks_per_batch": 45
       },
       "bundle_proposer_config": {
         "max_batch_num_per_bundle": 45,

rollup/proposer-tool-genesis.json

@@ -6,8 +6,7 @@
         "darwinTime": 0,
         "darwinV2Time": 0,
         "euclidTime": 0,
-        "euclidV2Time": 0,
-        "feynmanTime": 0
+        "euclidV2Time": 0
     },
     "nonce": "0x0000000000000033",
     "timestamp": "0x0",

rollup/tests/rollup_test.go

@@ -118,16 +118,14 @@ func testCommitBatchAndFinalizeBundleCodecV7(t *testing.T) {
 	}
 
 	cp := watcher.NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-		MaxBlockNumPerChunk:           100,
-		MaxL2GasPerChunk:              math.MaxUint64,
-		ChunkTimeoutSec:               300,
-		MaxUncompressedBatchBytesSize: math.MaxUint64,
+		MaxBlockNumPerChunk: 100,
+		MaxL2GasPerChunk:    math.MaxUint64,
+		ChunkTimeoutSec:     300,
 	}, encoding.CodecV7, chainConfig, db, nil)
 
 	bap := watcher.NewBatchProposer(context.Background(), &config.BatchProposerConfig{
-		MaxChunksPerBatch:             math.MaxInt32,
-		BatchTimeoutSec:               300,
-		MaxUncompressedBatchBytesSize: math.MaxUint64,
+		MaxChunksPerBatch: math.MaxInt32,
+		BatchTimeoutSec:   300,
 	}, encoding.CodecV7, chainConfig, db, nil)
 
 	bup := watcher.NewBundleProposer(context.Background(), &config.BundleProposerConfig{

rust-toolchain

@@ -1,3 +0,0 @@
-[toolchain]
-channel = "nightly-2025-02-14"
-targets = ["riscv32im-unknown-none-elf", "x86_64-unknown-linux-gnu"]

zkvm-prover/Cargo.toml

@@ -0,0 +1,79 @@
+[package]
+name = "prover"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[patch.crates-io]
+alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v0.8.21" }
+ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.12.3" }
+tiny-keccak = { git = "https://github.com/scroll-tech/tiny-keccak", branch = "scroll-patch-v2.0.2-openvm-v1.0.0-rc.1" }
+
+[dependencies]
+anyhow = "1.0"
+log = "0.4"
+env_logger = "0.11.3"
+serde = { version = "1.0.198", features = ["derive"] }
+serde_json = "1.0.116"
+futures = "0.3.30"
+
+scroll-zkvm-prover-euclid = { git = "https://github.com/scroll-tech/zkvm-prover", tag = "v0.4.2", package = "scroll-zkvm-prover" }
+ethers-core = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
+ethers-providers = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
+scroll-proving-sdk = { git = "https://github.com/scroll-tech/scroll-proving-sdk.git", branch = "main", features = [
+    "openvm",
+] }
+sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "zkvm/euclid-upgrade", features = [
+    "scroll",
+] }
+base64 = "0.13.1"
+reqwest = { version = "0.12.4", features = ["gzip"] }
+reqwest-middleware = "0.3"
+reqwest-retry = "0.5"
+once_cell = "1.19.0"
+hex = "0.4.3"
+tiny-keccak = { version = "2.0.0", features = ["sha3", "keccak"] }
+rand = "0.8.5"
+eth-keystore = "0.5.0"
+rlp = "0.5.2"
+tokio = "1.37.0"
+async-trait = "0.1"
+sled = "0.34.7"
+http = "1.1.0"
+clap = { version = "4.5", features = ["derive"] }
+ctor = "0.2.8"
+url = "2.5.4"
+serde_bytes = "0.11.15"
+
+[patch."https://github.com/openvm-org/stark-backend.git"]
+openvm-stark-backend = { git = "ssh://git@github.com/scroll-tech/openvm-stark-gpu.git", branch = "main", features = ["gpu"] }
+openvm-stark-sdk = { git = "ssh://git@github.com/scroll-tech/openvm-stark-gpu.git", branch = "main", features = ["gpu"] }
+
+[patch."https://github.com/Plonky3/Plonky3.git"]
+p3-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-field = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-commit = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-matrix = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-baby-bear = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", features = [
+    "nightly-features",
+], tag = "v0.2.0" }
+p3-koala-bear = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-util = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-challenger = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-dft = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-fri = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-goldilocks = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-keccak = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-keccak-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-blake3 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-mds = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-merkle-tree = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-monty-31 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-poseidon = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-poseidon2 = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-poseidon2-air = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-symmetric = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-uni-stark = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }
+p3-maybe-rayon = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" } # the "parallel" feature is NOT on by default to allow single-threaded benchmarking
+p3-bn254-fr = { git = "ssh://git@github.com/scroll-tech/plonky3-gpu.git", tag = "v0.2.0" }

zkvm-prover/Makefile

@@ -1,9 +1,9 @@
 .PHONY: prover lint tests_binary
 
 ifeq (4.3,$(firstword $(sort $(MAKE_VERSION) 4.3)))
-    PLONKY3_VERSION=$(shell grep -m 1 "Plonky3.git" ../Cargo.lock | cut -d "#" -f2 | cut -c-7)
+    PLONKY3_VERSION=$(shell grep -m 1 "Plonky3.git" ./Cargo.lock | cut -d "#" -f2 | cut -c-7)
 else
-    PLONKY3_VERSION=$(shell grep -m 1 "Plonky3.git" ../Cargo.lock | cut -d "\#" -f2 | cut -c-7)
+    PLONKY3_VERSION=$(shell grep -m 1 "Plonky3.git" ./Cargo.lock | cut -d "\#" -f2 | cut -c-7)
 endif
 
 ZKVM_VERSION=$(shell ./print_high_zkvm_version.sh)
@@ -40,7 +40,7 @@ prover:
 
 tests_binary:
 	cargo clean && cargo test --release --no-run
-	ls ../target/release/deps/prover* | grep -v "\.d" | xargs -I{} ln -sf {} ./prover.test
+	ls target/release/deps/prover* | grep -v "\.d" | xargs -I{} ln -sf {} ./prover.test
 
 lint:
 	cargo check --all-features

zkvm-prover/config.json.template

@@ -1,31 +0,0 @@
-{
-  "sdk_config": {
-    "prover_name_prefix": "test-prover",
-    "keys_dir": ".work",
-    "coordinator": {
-      "base_url": "<the url of coordinator>",
-      "retry_count": 10,
-      "retry_wait_time_sec": 10,
-      "connection_timeout_sec": 1800
-    },
-    "l2geth": {
-      "endpoint": "<the url of rpc endpoint>"
-    },
-    "prover": {
-      "circuit_type": 2,
-      "supported_proof_types": [
-        1,
-        2,
-        3
-      ],
-      "circuit_version": "v0.13.1"
-    },
-    "db_path": ".work/db"
-  },
-  "circuits": {
-    "euclidV2": {
-      "hard_fork_name": "euclidV2",
-      "workspace_path": ".work"
-    }
-  }
-}

zkvm-prover/print_high_zkvm_version.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 set -ue
 
-higher_zkvm_item=`grep "zkvm-prover" ../Cargo.lock | sort | uniq | awk -F "[#=]" '{print $3" "$4}' | sort -k 1 | tail -n 1`
+higher_zkvm_item=`grep "zkvm-prover" ./Cargo.lock | sort | uniq | awk -F "[#=]" '{print $3" "$4}' | sort -k 1 | tail -n 1`
 
 higher_version=`echo $higher_zkvm_item | awk '{print $1}'`
 

zkvm-prover/rust-toolchain

@@ -0,0 +1 @@
+nightly-2024-12-06

zkvm-prover/src/main.rs

@@ -26,7 +26,7 @@ struct Args {
 }
 
 #[tokio::main]
-async fn main() -> eyre::Result<()> {
+async fn main() -> anyhow::Result<()> {
     init_tracing();
 
     let args = Args::parse();
@@ -39,10 +39,7 @@ async fn main() -> eyre::Result<()> {
     let cfg = LocalProverConfig::from_file(args.config_file)?;
     let sdk_config = cfg.sdk_config.clone();
     let local_prover = LocalProver::new(cfg);
-    let prover = ProverBuilder::new(sdk_config, local_prover)
-        .build()
-        .await
-        .map_err(|e| eyre::eyre!("build prover fail: {e}"))?;
+    let prover = ProverBuilder::new(sdk_config, local_prover).build().await?;
 
     prover.run().await;
 

zkvm-prover/src/prover.rs

@@ -1,7 +1,8 @@
-use crate::zk_circuits_handler::{euclidV2::EuclidV2Handler, CircuitsHandler};
+use crate::zk_circuits_handler::{
+    euclid::EuclidHandler, euclidV2::EuclidV2Handler, CircuitsHandler,
+};
+use anyhow::{anyhow, Result};
 use async_trait::async_trait;
-use base64::{prelude::BASE64_STANDARD, Engine};
-use eyre::Result;
 use scroll_proving_sdk::{
     config::Config as SdkConfig,
     prover::{
@@ -32,7 +33,7 @@ impl LocalProverConfig {
     where
         R: std::io::Read,
     {
-        serde_json::from_reader(reader).map_err(|e| eyre::eyre!(e))
+        serde_json::from_reader(reader).map_err(|e| anyhow!(e))
     }
 
     pub fn from_file(file_name: String) -> Result<Self> {
@@ -68,7 +69,7 @@ impl ProvingService for LocalProver {
                 let vk = handler.get_vk(*proof_type).await;
 
                 if let Some(vk) = vk {
-                    vks.push(BASE64_STANDARD.encode(vk));
+                    vks.push(base64::encode(vk));
                 }
             }
         }
@@ -183,6 +184,9 @@ impl LocalProver {
         let config = self.config.circuits.get(hard_fork_name).unwrap();
 
         match hard_fork_name {
+            "euclid" => Arc::new(Arc::new(Mutex::new(EuclidHandler::new(
+                &config.workspace_path,
+            )))) as Arc<dyn CircuitsHandler>,
             "euclidV2" => Arc::new(Arc::new(Mutex::new(EuclidV2Handler::new(
                 &config.workspace_path,
             )))) as Arc<dyn CircuitsHandler>,