feat(l2): add ethrex_batchNumber to RPC (#4349)

**Motivation**

<!-- Why does this pull request exist? What are its goals? -->
We lack a way to get the latest batch sealed, something similar to
`eth_blockNumber`.

**Description**

<!-- A clear and concise general description of the changes this PR
introduces -->
Add a new RPC method `ethrex_batchNumber` that returns the last sealed
batch.

How to test:
1. Start an L2 node:
    ```
    COMPILE_CONTRACTS=true cargo run --release -- l2 --dev
    ```
3. Wait about 1 minute until a batch is sealed.
4. Request the last batch number:
    ```
curl localhost:1729 -H 'content-type: application/json' -d '{"jsonrpc":
"2.0", "id": "1", "method": "ethrex_batchNumber"}'
    ```
Should return something like `{"id":"1","jsonrpc":"2.0","result":"0x2"}`

<!-- Link to issues: Resolves #111, Resolves #222 -->

---------

Co-authored-by: Copilot <[email protected]>

Author: ManuelBilbao

crates/l2/networking/rpc/l2/batch.rs

@@ -100,3 +100,27 @@ impl RpcHandler for GetBatchByBatchNumberRequest {
         serde_json::to_value(&rpc_batch).map_err(|error| RpcErr::Internal(error.to_string()))
     }
 }
+
+pub struct BatchNumberRequest {}
+
+impl RpcHandler for BatchNumberRequest {
+    fn parse(params: &Option<Vec<Value>>) -> Result<Self, RpcErr> {
+        if params.as_ref().is_some_and(|params| !params.is_empty()) {
+            return Err(ethrex_rpc::RpcErr::BadParams(
+                "Expected 0 params".to_owned(),
+            ))?;
+        };
+
+        Ok(BatchNumberRequest {})
+    }
+
+    async fn handle(&self, context: RpcApiContext) -> Result<Value, RpcErr> {
+        debug!("Requested last batch number");
+        let Some(batch_number) = context.rollup_store.get_batch_number().await? else {
+            return Ok(Value::Null);
+        };
+
+        serde_json::to_value(format!("{batch_number:#x}"))
+            .map_err(|error| RpcErr::Internal(error.to_string()))
+    }
+}

crates/l2/networking/rpc/rpc.rs

@@ -1,4 +1,4 @@
-use crate::l2::batch::GetBatchByBatchNumberRequest;
+use crate::l2::batch::{BatchNumberRequest, GetBatchByBatchNumberRequest};
 use crate::l2::l1_message::GetL1MessageProof;
 use crate::utils::{RpcErr, RpcNamespace, resolve_namespace};
 use axum::extract::State;
@@ -211,6 +211,7 @@ pub async fn map_l2_requests(req: &RpcRequest, context: RpcApiContext) -> Result
     match req.method.as_str() {
         "ethrex_sendTransaction" => SponsoredTx::call(req, context).await,
         "ethrex_getMessageProof" => GetL1MessageProof::call(req, context).await,
+        "ethrex_batchNumber" => BatchNumberRequest::call(req, context).await,
         "ethrex_getBatchByNumber" => GetBatchByBatchNumberRequest::call(req, context).await,
         unknown_ethrex_l2_method => {
             Err(ethrex_rpc::RpcErr::MethodNotFound(unknown_ethrex_l2_method.to_owned()).into())

crates/l2/storage/src/api.rs

@@ -60,6 +60,8 @@ pub trait StoreEngineRollup: Debug + Send + Sync {
 
     async fn seal_batch(&self, batch: Batch) -> Result<(), RollupStoreError>;
 
+    async fn get_last_batch_number(&self) -> Result<Option<u64>, RollupStoreError>;
+
     async fn get_verify_tx_by_batch(
         &self,
         batch_number: u64,

crates/l2/storage/src/store.rs

@@ -150,6 +150,10 @@ impl Store {
             .await
     }
 
+    pub async fn get_batch_number(&self) -> Result<Option<u64>, RollupStoreError> {
+        self.engine.get_last_batch_number().await
+    }
+
     pub async fn get_batch(&self, batch_number: u64) -> Result<Option<Batch>, RollupStoreError> {
         let Some(blocks) = self.get_block_numbers_by_batch(batch_number).await? else {
             return Ok(None);

crates/l2/storage/src/store_db/in_memory.rs

@@ -347,6 +347,10 @@ impl StoreEngineRollup for Store {
         inner.batch_proofs.remove(&(proof_type, batch_number));
         Ok(())
     }
+
+    async fn get_last_batch_number(&self) -> Result<Option<u64>, RollupStoreError> {
+        Ok(self.inner()?.state_roots.keys().max().cloned())
+    }
 }
 
 impl Debug for Store {

crates/l2/storage/src/store_db/sql.rs

@@ -483,7 +483,7 @@ impl StoreEngineRollup for SQLStore {
         messages_inc: u64,
     ) -> Result<(), RollupStoreError> {
         self.execute(
-            "UPDATE operation_count SET transactions = transactions + ?1, privileged_transactions = privileged_transactions + ?2, messages = messages + ?3", 
+            "UPDATE operation_count SET transactions = transactions + ?1, privileged_transactions = privileged_transactions + ?2, messages = messages + ?3",
             (transaction_inc, privileged_transactions_inc, messages_inc)).await?;
         Ok(())
     }
@@ -798,6 +798,14 @@ impl StoreEngineRollup for SQLStore {
         }
         self.execute_in_tx(queries, None).await
     }
+
+    async fn get_last_batch_number(&self) -> Result<Option<u64>, RollupStoreError> {
+        let mut rows = self.query("SELECT MAX(batch) FROM state_roots", ()).await?;
+        rows.next()
+            .await?
+            .map(|row| read_from_row_int(&row, 0))
+            .transpose()
+    }
 }
 
 #[cfg(test)]