refactor: bulk rename combined prover to batch prover (#286)

* refactor: bulk rename combined prover to batch prover

* chore: cargo fmt

Author: damiannolan

Cargo.lock

@@ -4,8 +4,8 @@ members = [
     "crates/ev-prover",
     "crates/ev-state-queries",
     "crates/ev-zkevm-types",
-    "crates/sp1/ev-combined/program",
-    "crates/sp1/ev-combined/script",
+    "crates/sp1/ev-batch-exec/program",
+    "crates/sp1/ev-batch-exec/script",
     "crates/sp1/ev-exec/program",
     "crates/sp1/ev-exec/script",
     "crates/sp1/ev-hyperlane/program",

Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [features]
-combined = []
+batch_mode = []
 
 [dependencies]
 alloy = { workspace = true }

crates/ev-prover/Cargo.toml

@@ -2,8 +2,8 @@
 The `ev-prover` service is a simple gRPC service designed to serve ZK proofs to clients.
 It encapsulates the SP1 programs maintained under `sp1`, and uses the `sp1_sdk::ProverClient` in order to interface with them.
 
-## Running the ev-prover service in `combined` mode for a private or public testnet
-The combined mode aggregates a range of blocks and proves them in one go, using a single GPU instance. This mode is better than default
+## Running the ev-prover service in `batch_mode` mode for a private or public testnet
+The batch mode aggregates a range of blocks and proves them in one go, using a single GPU instance. This mode is better than default
 when using the succinct prover network, because in default mode the base fee will accumulate and cause huge costs.
 
 ### Setup
@@ -26,7 +26,7 @@ Run the following commands from the root of the repository.
 
 1. Install the binary to Cargo binary directory ~/.cargo/bin
     ```shell
-    cargo install --path ./crates/ev-prover --features combined
+    cargo install --path ./crates/ev-prover --features batch_mode
     ```
 
 2. Initialize a new `ev-prover` home directory and configuration file with defaults:
@@ -40,10 +40,10 @@ Run the following commands from the root of the repository.
     RUST_LOG="ev_prover=debug" ev-prover start
     ```
 
-The service will join the tasks in `src/prover/programs/combined.rs` and `src/prover/programs/message.rs`.
+The service will join the tasks in `src/prover/programs/batch.rs` and `src/prover/programs/message.rs`.
 
 ## Running the ev-prover service using the `ev-exec` and `ev-range-exec` circuits
-The default mode, without the `combined` feature enabled, will prove every single blocks and recursively verify block proofs in a
+The default mode, without the `batch_mode` feature enabled, will prove every single blocks and recursively verify block proofs in a
 range circuit. This is ideal for minimum latency, but expensive when running on Succinct's prover network / when paying for every prover instance
 launch. 
 

crates/ev-prover/README.md

@@ -4,6 +4,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     build_program_with_args("../sp1/ev-exec/program", Default::default());
     build_program_with_args("../sp1/ev-range-exec/program", Default::default());
     build_program_with_args("../sp1/ev-hyperlane/program", Default::default());
-    build_program_with_args("../sp1/ev-combined/program", Default::default());
+    build_program_with_args("../sp1/ev-batch-exec/program", Default::default());
     Ok(())
 }

crates/ev-prover/build.rs

@@ -20,7 +20,7 @@ use crate::proto::celestia::prover::v1::{
     GetBlockProofRequest, GetBlockProofsInRangeRequest, GetLatestBlockProofRequest, GetLatestMembershipProofRequest,
     GetMembershipProofRequest, GetRangeProofsRequest,
 };
-use crate::prover::programs::combined::EV_COMBINED_ELF;
+use crate::prover::programs::batch::BATCH_ELF;
 use crate::prover::programs::message::EV_HYPERLANE_ELF;
 use crate::server::start_server;
 use storage::proofs::{ProofStorage, RocksDbProofStorage};
@@ -86,7 +86,7 @@ pub async fn create_zkism() -> Result<()> {
 
     info!("setting up ELF for state proofs");
     let prover = ProverClient::builder().cpu().build();
-    let (_, vk) = prover.setup(EV_COMBINED_ELF);
+    let (_, vk) = prover.setup(BATCH_ELF);
     let state_transition_vkey = vk.bytes32_raw().to_vec();
 
     info!("setting up ELF for membership proofs");

crates/ev-prover/src/command/mod.rs

@@ -19,7 +19,7 @@ use celestia_types::{
     Blob,
 };
 use ev_types::v1::SignedData;
-use ev_zkevm_types::programs::block::{BlockExecInput, BlockRangeExecOutput, EvCombinedInput};
+use ev_zkevm_types::programs::block::{BatchExecInput, BlockExecInput, BlockRangeExecOutput};
 use prost::Message;
 use reth_chainspec::ChainSpec;
 use rsp_client_executor::io::EthClientExecutorInput;
@@ -33,7 +33,7 @@ use crate::prover::ProgramProver;
 use crate::prover::{prover_from_env, SP1Prover};
 
 /// The ELF (executable and linkable format) file for the Succinct RISC-V zkVM.
-pub const EV_COMBINED_ELF: &[u8] = include_elf!("ev-combined-program");
+pub const BATCH_ELF: &[u8] = include_elf!("ev-batch-program");
 
 /// ProverStatus of the latest Celestia state relevant to the prover loop.
 ///
@@ -105,23 +105,23 @@ impl AppContext {
 }
 
 #[derive(Clone)]
-pub struct CombinedProverConfig {
+pub struct BatchProverConfig {
     pub pk: Arc<SP1ProvingKey>,
     pub vk: Arc<SP1VerifyingKey>,
     pub proof_mode: SP1ProofMode,
 }
 
-impl CombinedProverConfig {
+impl BatchProverConfig {
     pub fn new(pk: SP1ProvingKey, vk: SP1VerifyingKey, mode: SP1ProofMode) -> Self {
-        CombinedProverConfig {
+        BatchProverConfig {
             pk: Arc::new(pk),
             vk: Arc::new(vk),
             proof_mode: mode,
         }
     }
 }
 
-impl ProverConfig for CombinedProverConfig {
+impl ProverConfig for BatchProverConfig {
     fn pk(&self) -> Arc<SP1ProvingKey> {
         Arc::clone(&self.pk)
     }
@@ -135,17 +135,17 @@ impl ProverConfig for CombinedProverConfig {
     }
 }
 
-pub struct EvCombinedProver {
+pub struct BatchExecProver {
     app: AppContext,
     range_tx: mpsc::Sender<MessageProofRequest>,
-    config: CombinedProverConfig,
+    config: BatchProverConfig,
     prover: Arc<SP1Prover>,
 }
 
 #[async_trait]
-impl ProgramProver for EvCombinedProver {
-    type Config = CombinedProverConfig;
-    type Input = EvCombinedInput;
+impl ProgramProver for BatchExecProver {
+    type Config = BatchProverConfig;
+    type Input = BatchExecInput;
     type Output = BlockRangeExecOutput;
 
     fn cfg(&self) -> &Self::Config {
@@ -169,11 +169,11 @@ impl ProgramProver for EvCombinedProver {
     }
 }
 
-impl EvCombinedProver {
+impl BatchExecProver {
     /// Creates a new prover instance.
     pub fn new(app: AppContext, range_tx: mpsc::Sender<MessageProofRequest>) -> Result<Self> {
         let prover = prover_from_env();
-        let config = EvCombinedProver::default_config(prover.as_ref());
+        let config = BatchExecProver::default_config(prover.as_ref());
 
         Ok(Self {
             app,
@@ -184,9 +184,9 @@ impl EvCombinedProver {
     }
 
     /// Returns the prover config.
-    pub fn default_config(prover: &SP1Prover) -> CombinedProverConfig {
-        let (pk, vk) = prover.setup(EV_COMBINED_ELF);
-        CombinedProverConfig::new(pk, vk, SP1ProofMode::Groth16)
+    pub fn default_config(prover: &SP1Prover) -> BatchProverConfig {
+        let (pk, vk) = prover.setup(BATCH_ELF);
+        BatchProverConfig::new(pk, vk, SP1ProofMode::Groth16)
     }
 
     /// Starts the batched prover loop.
@@ -340,7 +340,7 @@ impl EvCombinedProver {
         start_height: u64,
         status: &ProverStatus,
         batch_size: u64,
-    ) -> Result<EvCombinedInput> {
+    ) -> Result<BatchExecInput> {
         let mut current_height = status.trusted_height;
         let mut current_root = status.trusted_root;
 
@@ -365,7 +365,7 @@ impl EvCombinedProver {
 
         // let mut stdin = SP1Stdin::new();
         // stdin.write(&);
-        Ok(EvCombinedInput { blocks: block_inputs })
+        Ok(BatchExecInput { blocks: block_inputs })
     }
 
     /// Builds a single block prover input for the given height.

…v-prover/src/prover/programs/combined.rs …s/ev-prover/src/prover/programs/batch.rscrates/ev-prover/src/prover/programs/combined.rs renamed to crates/ev-prover/src/prover/programs/batch.rs crates/ev-prover/src/prover/programs/combined.rs renamed to crates/ev-prover/src/prover/programs/batch.rs

@@ -1,4 +1,4 @@
+pub mod batch;
 pub mod block;
-pub mod combined;
 pub mod message;
 pub mod range;

crates/ev-prover/src/prover/programs/mod.rs

@@ -31,7 +31,7 @@ use crate::prover::programs::message::HyperlaneMessageProver;
 use crate::prover::service::ProverService;
 use crate::prover::{MessageProofRequest, MessageProofSync};
 
-#[cfg(not(feature = "combined"))]
+#[cfg(not(feature = "batch_mode"))]
 use crate::prover::{
     programs::{
         block::{AppContext, BlockExecProver},
@@ -42,37 +42,37 @@ use crate::prover::{
 
 use crate::prover::programs::message::AppContext as MessageAppContext;
 use storage::proofs::ProofStorage;
-#[cfg(feature = "combined")]
+#[cfg(feature = "batch_mode")]
 use {
-    crate::prover::programs::combined::{AppContext as CombinedAppContext, EvCombinedProver},
+    crate::prover::programs::batch::{AppContext as BatchAppContext, BatchExecProver},
     std::time::Duration,
 };
 
 struct Server {
     pub message_prover: Arc<HyperlaneMessageProver>,
-    #[cfg(not(feature = "combined"))]
+    #[cfg(not(feature = "batch_mode"))]
     pub block_prover: Arc<BlockExecProver>,
-    #[cfg(not(feature = "combined"))]
+    #[cfg(not(feature = "batch_mode"))]
     pub block_range_prover: Arc<BlockRangeExecProver>,
-    #[cfg(feature = "combined")]
-    pub combined_prover: Arc<EvCombinedProver>,
+    #[cfg(feature = "batch_mode")]
+    pub batch_prover: Arc<BatchExecProver>,
 }
 
 impl Server {
     pub fn new(
         message_prover: Arc<HyperlaneMessageProver>,
-        #[cfg(not(feature = "combined"))] block_prover: Arc<BlockExecProver>,
-        #[cfg(not(feature = "combined"))] block_range_prover: Arc<BlockRangeExecProver>,
-        #[cfg(feature = "combined")] combined_prover: Arc<EvCombinedProver>,
+        #[cfg(not(feature = "batch_mode"))] block_prover: Arc<BlockExecProver>,
+        #[cfg(not(feature = "batch_mode"))] block_range_prover: Arc<BlockRangeExecProver>,
+        #[cfg(feature = "batch_mode")] batch_prover: Arc<BatchExecProver>,
     ) -> Self {
         Self {
             message_prover,
-            #[cfg(not(feature = "combined"))]
+            #[cfg(not(feature = "batch_mode"))]
             block_prover,
-            #[cfg(not(feature = "combined"))]
+            #[cfg(not(feature = "batch_mode"))]
             block_range_prover,
-            #[cfg(feature = "combined")]
-            combined_prover,
+            #[cfg(feature = "batch_mode")]
+            batch_prover: batch_prover,
         }
     }
     pub async fn start_message_prover(
@@ -88,7 +88,7 @@ impl Server {
             }
         }))
     }
-    #[cfg(not(feature = "combined"))]
+    #[cfg(not(feature = "batch_mode"))]
     pub async fn start_block_prover(&self) -> Result<JoinHandle<()>> {
         let block_prover = Arc::clone(&self.block_prover);
         Ok(tokio::spawn(async move {
@@ -97,7 +97,7 @@ impl Server {
             }
         }))
     }
-    #[cfg(not(feature = "combined"))]
+    #[cfg(not(feature = "batch_mode"))]
     pub async fn start_block_range_prover(
         self,
         client: CelestiaIsmClient,
@@ -129,12 +129,12 @@ impl Server {
             }
         }))
     }
-    #[cfg(feature = "combined")]
-    pub async fn start_combined_prover(&self, message_sync: Arc<MessageProofSync>) -> Result<JoinHandle<()>> {
-        let combined_prover = Arc::clone(&self.combined_prover);
+    #[cfg(feature = "batch_mode")]
+    pub async fn start_batch_prover(&self, message_sync: Arc<MessageProofSync>) -> Result<JoinHandle<()>> {
+        let batch_prover = Arc::clone(&self.batch_prover);
         Ok(tokio::spawn(async move {
-            if let Err(e) = combined_prover.run(message_sync).await {
-                error!("Combined prover task failed: {e:?}");
+            if let Err(e) = batch_prover.run(message_sync).await {
+                error!("Batch prover task failed: {e:?}");
             }
         }))
     }
@@ -162,7 +162,7 @@ pub async fn start_server(config: Config) -> Result<()> {
     let config = ClientConfig::from_env()?;
     let ism_client = Arc::new(CelestiaIsmClient::new(config).await?);
 
-    #[cfg(not(feature = "combined"))]
+    #[cfg(not(feature = "batch_mode"))]
     let wrapper_task = Some({
         let storage_clone: Arc<dyn ProofStorage> = storage.clone();
         let client_config = ClientConfig::from_env()?;
@@ -265,7 +265,7 @@ pub async fn start_server(config: Config) -> Result<()> {
         })
     });
 
-    #[cfg(feature = "combined")]
+    #[cfg(feature = "batch_mode")]
     let wrapper_task = Some({
         let storage_clone: Arc<dyn ProofStorage> = storage.clone();
         let message_sync = MessageProofSync::shared();
@@ -274,18 +274,18 @@ pub async fn start_server(config: Config) -> Result<()> {
         tokio::spawn(async move {
             loop {
                 let (tx_range, rx_range) = mpsc::channel::<MessageProofRequest>(256);
-                let combined_context =
-                    match CombinedAppContext::from_config(&config_clone, Arc::clone(&ism_client_clone)).await {
+                let batch_context =
+                    match BatchAppContext::from_config(&config_clone, Arc::clone(&ism_client_clone)).await {
                         Ok(context) => context,
                         Err(e) => {
-                            error!("Failed to create combined context: {e:?}");
+                            error!("Failed to create batch context: {e:?}");
                             continue;
                         }
                     };
-                let combined_prover = match EvCombinedProver::new(combined_context, tx_range) {
+                let batch_prover = match BatchExecProver::new(batch_context, tx_range) {
                     Ok(prover) => prover,
                     Err(e) => {
-                        error!("Failed to create combined prover: {e:?}");
+                        error!("Failed to create batch prover: {e:?}");
                         continue;
                     }
                 };
@@ -297,12 +297,12 @@ pub async fn start_server(config: Config) -> Result<()> {
                             continue;
                         }
                     };
-                let server = Arc::new(Server::new(Arc::new(message_prover), Arc::new(combined_prover)));
+                let server = Arc::new(Server::new(Arc::new(message_prover), Arc::new(batch_prover)));
 
-                let mut combined_handle = match server.start_combined_prover(Arc::clone(&message_sync)).await {
+                let mut batch_handle = match server.start_batch_prover(Arc::clone(&message_sync)).await {
                     Ok(handle) => handle,
                     Err(e) => {
-                        error!("Failed to start combined prover: {e:?}");
+                        error!("Failed to start batch prover: {e:?}");
                         continue;
                     }
                 };
@@ -318,13 +318,13 @@ pub async fn start_server(config: Config) -> Result<()> {
                 };
 
                 tokio::select! {
-                    r = &mut combined_handle => {
-                        error!("combined prover stopped: {:?}", r);
+                    r = &mut batch_handle => {
+                        error!("batch prover stopped: {:?}", r);
                         message_handle.abort();
                     }
                     r = &mut message_handle => {
                         error!("message prover stopped: {:?}", r);
-                        combined_handle.abort();
+                        batch_handle.abort();
                     }
                 }
                 tokio::time::sleep(Duration::from_secs(1)).await;

crates/ev-prover/src/server/mod.rs

@@ -91,7 +91,7 @@ pub struct BlockRangeExecInput {
 }
 
 #[derive(Serialize, Deserialize, Debug)]
-pub struct EvCombinedInput {
+pub struct BatchExecInput {
     pub blocks: Vec<BlockExecInput>,
 }