wip

Author: GCdePaula

.gitignore

@@ -3,4 +3,7 @@ sequencer.db
 sequencer.db-shm
 sequencer.db-wal
 benchmarks/results/
+/benchmarks/.deps/
+/examples/canonical-app/out/
 /out/
+/.DS_Store

Cargo.lock

@@ -155,11 +155,18 @@ Success response:
 ## Local Test Prerequisites
 
 - Some `sequencer` tests spin up `Anvil`; install Foundry locally if you want the full test suite:
+- Self-contained benchmarks also spawn `Anvil` from a preloaded rollups state dump.
 
 ```bash
 foundryup
 ```
 
+- Prepare local benchmark + guest build dependencies:
+
+```bash
+just setup
+```
+
 - Enable the Anvil-backed reader tests explicitly:
 
 ```bash

README.md

@@ -22,6 +22,7 @@ instance they are targeting.
 From repository root:
 
 ```bash
+just setup
 just --justfile benchmarks/justfile bench-unit
 just --justfile benchmarks/justfile bench-ack-self
 just --justfile benchmarks/justfile bench-e2e-self
@@ -63,10 +64,12 @@ cargo run -p benchmarks --bin compare_latest --release -- --results-dir benchmar
 
 ## Notes
 
+- Self-contained variants launch `anvil --load-state` from the preloaded rollups dump under `benchmarks/.deps/`; run `just setup` first.
+- Self-contained variants therefore require Foundry's `anvil` binary to be installed locally.
 - Networked benches fail by default if any tx is rejected. Pass `--allow-rejections` to inspect mixed traffic.
 - `e2e_latency` drains existing WS backlog before timing so stale history does not pollute the measurement window.
 - `bench-sweep mode=e2e` carries `from_offset` forward across rounds to avoid re-reading old WS history.
 - `--stop-on-first-non-200` now does exactly what it says: it stops on the first HTTP non-`200`, not on client-side transport failures.
 - If sweep hits `Too many open files`, increase the shell limit (`ulimit -n 4096`) or use a smaller concurrency list.
-- Self-contained variants automatically build a temp DB, spawn a sequencer, and persist logs/results under `benchmarks/results`.
+- Self-contained variants automatically build a temp DB, spawn `anvil`, start the sequencer, and persist logs/results under `benchmarks/results`.
 - For non-self-contained runs, start a sequencer instance first and make sure the benchmark domain matches the sequencer domain.

benchmarks/README.md

@@ -1,9 +1,23 @@
 set shell := ["bash", "-euo", "pipefail", "-c"]
 set working-directory := ".."
 
+anvil_dump_name := "rollups-contracts-2.2.0-anvil-v1.4.3"
+anvil_dump_dir := "benchmarks/.deps/" + anvil_dump_name
+anvil_dump_tar := "benchmarks/.deps/" + anvil_dump_name + ".tar.gz"
+anvil_dump_url := "https://github.com/cartesi/rollups-contracts/releases/download/v2.2.0/rollups-contracts-2.2.0-anvil-v1.4.3.tar.gz"
+root_anvil_dump_tar := "rollups-contracts-2.2.0-anvil-v1.4.3.tar.gz"
+
 default:
     @just --justfile benchmarks/justfile --list
 
+setup:
+    mkdir -p benchmarks/.deps
+    if [[ ! -f {{anvil_dump_tar}} ]]; then if [[ -f {{root_anvil_dump_tar}} ]]; then cp {{root_anvil_dump_tar}} {{anvil_dump_tar}}; else wget {{anvil_dump_url}} -O {{anvil_dump_tar}}; fi; fi
+    if [[ ! -f {{anvil_dump_dir}}/state.json ]]; then rm -rf {{anvil_dump_dir}}; mkdir -p {{anvil_dump_dir}}; tar -xzf {{anvil_dump_tar}} -C {{anvil_dump_dir}}; fi
+
+clean:
+    rm -rf benchmarks/.deps
+
 bench-unit count="10000" max_fee="0":
     cargo run -p benchmarks --bin unit_hot_path --release -- --count {{count}} --max-fee {{max_fee}}
 

benchmarks/justfile

@@ -1,6 +1,7 @@
 // (c) Cartesi and individual authors (see AUTHORS)
 // SPDX-License-Identifier: Apache-2.0 (see LICENSE)
 
+use alloy_primitives::Address;
 use serde::{Deserialize, Serialize};
 use std::fs::{self, OpenOptions};
 use std::path::{Path, PathBuf};
@@ -18,10 +19,13 @@ use crate::{BenchResult, self_contained_domain};
 pub const DEFAULT_SEQUENCER_BIN: &str = "target/release/sequencer";
 pub const DEFAULT_MEMORY_SAMPLE_INTERVAL_MS: u64 = 500;
 pub const DEFAULT_SEQUENCER_LOGS_DIR: &str = "benchmarks/results";
+pub const DEFAULT_ANVIL_STATE_DIR: &str = "benchmarks/.deps/rollups-contracts-2.2.0-anvil-v1.4.3";
 
 const DEFAULT_SEQUENCER_START_TIMEOUT: Duration = Duration::from_secs(10);
 const DEFAULT_SEQUENCER_SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(3);
 const DEFAULT_SEQUENCER_RUST_LOG: &str = "info";
+const DEFAULT_ANVIL_START_TIMEOUT: Duration = Duration::from_secs(10);
+const DEFAULT_ANVIL_SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(3);
 
 #[derive(Debug, Clone)]
 pub struct ManagedSequencerConfig {
@@ -30,6 +34,7 @@ pub struct ManagedSequencerConfig {
 }
 
 pub struct ManagedSequencer {
+    anvil: ManagedAnvil,
     child: Child,
     shutdown_timeout: Duration,
     temp_dir: Option<TempDir>,
@@ -41,6 +46,7 @@ impl ManagedSequencer {
     pub async fn spawn(config: ManagedSequencerConfig) -> BenchResult<Self> {
         let (endpoint, http_addr) = build_local_endpoint()?;
         let domain = self_contained_domain();
+        let anvil = ManagedAnvil::spawn(config.log_prefix).await?;
 
         let dir = tempfile::tempdir()?;
         let db_path = dir_path_join(dir.path(), "sequencer.db");
@@ -62,6 +68,10 @@ impl ManagedSequencer {
             .arg(http_addr)
             .arg("--db-path")
             .arg(path_as_str(db_path.as_path())?)
+            .arg("--eth-rpc-url")
+            .arg(anvil.endpoint.as_str())
+            .arg("--input-box-address")
+            .arg(anvil.input_box_address.to_string())
             .arg("--domain-chain-id")
             .arg(domain.chain_id.to_string())
             .arg("--domain-verifying-contract")
@@ -85,6 +95,7 @@ impl ManagedSequencer {
         .await?;
 
         Ok(Self {
+            anvil,
             child,
             shutdown_timeout: DEFAULT_SEQUENCER_SHUTDOWN_TIMEOUT,
             temp_dir,
@@ -103,6 +114,86 @@ impl ManagedSequencer {
 
     pub async fn shutdown(mut self) -> BenchResult<()> {
         let _ = self.temp_dir.take();
+        send_graceful_terminate(&mut self.child).await;
+        let sequencer_result: BenchResult<()> =
+            match tokio::time::timeout(self.shutdown_timeout, self.child.wait()).await {
+                Ok(wait_result) => {
+                    let _ = wait_result?;
+                    Ok(())
+                }
+                Err(_) => {
+                    self.child.start_kill()?;
+                    let _ = self.child.wait().await;
+                    Ok(())
+                }
+            };
+        let anvil_result = self.anvil.shutdown().await;
+        sequencer_result?;
+        anvil_result
+    }
+}
+
+struct ManagedAnvil {
+    child: Child,
+    shutdown_timeout: Duration,
+    endpoint: String,
+    input_box_address: Address,
+}
+
+impl ManagedAnvil {
+    async fn spawn(log_prefix: &str) -> BenchResult<Self> {
+        let state_dir = PathBuf::from(DEFAULT_ANVIL_STATE_DIR);
+        let state_path = dir_path_join(state_dir.as_path(), "state.json");
+        let deployment_path = dir_path_join(state_dir.as_path(), "deployments/31337/InputBox.json");
+
+        ensure_exists(
+            state_path.as_path(),
+            format!("missing {}; run `just setup` first", state_path.display()),
+        )?;
+        ensure_exists(
+            deployment_path.as_path(),
+            format!(
+                "missing {}; run `just setup` first",
+                deployment_path.display()
+            ),
+        )?;
+
+        let input_box_address = read_input_box_address(deployment_path.as_path())?;
+        let (endpoint, http_addr) = build_local_endpoint()?;
+        let log_path = default_anvil_log_path(log_prefix);
+        if let Some(parent) = log_path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        let stdout_log = OpenOptions::new()
+            .create(true)
+            .truncate(true)
+            .write(true)
+            .open(log_path.as_path())?;
+        let stderr_log = stdout_log.try_clone()?;
+
+        let mut child = Command::new("anvil")
+            .arg("--host")
+            .arg("127.0.0.1")
+            .arg("--port")
+            .arg(http_addr.rsplit(':').next().expect("port"))
+            .arg("--load-state")
+            .arg(path_as_str(state_path.as_path())?)
+            .stdout(Stdio::from(stdout_log))
+            .stderr(Stdio::from(stderr_log))
+            .spawn()
+            .map_err(|err| io_other(format!("failed to spawn anvil: {err}")))?;
+
+        wait_for_rpc_readiness(endpoint.as_str(), &mut child, DEFAULT_ANVIL_START_TIMEOUT).await?;
+
+        Ok(Self {
+            child,
+            shutdown_timeout: DEFAULT_ANVIL_SHUTDOWN_TIMEOUT,
+            endpoint,
+            input_box_address,
+        })
+    }
+
+    async fn shutdown(mut self) -> BenchResult<()> {
         send_graceful_terminate(&mut self.child).await;
         match tokio::time::timeout(self.shutdown_timeout, self.child.wait()).await {
             Ok(wait_result) => {
@@ -237,6 +328,16 @@ pub fn default_sequencer_log_path(prefix: &str) -> PathBuf {
     PathBuf::from(format!("{DEFAULT_SEQUENCER_LOGS_DIR}/{prefix}-{ts}.log"))
 }
 
+fn default_anvil_log_path(prefix: &str) -> PathBuf {
+    let ts = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|value| value.as_millis())
+        .unwrap_or(0);
+    PathBuf::from(format!(
+        "{DEFAULT_SEQUENCER_LOGS_DIR}/{prefix}-anvil-{ts}.log"
+    ))
+}
+
 async fn wait_for_readiness(
     endpoint: &str,
     child: &mut Child,
@@ -263,6 +364,29 @@ async fn wait_for_readiness(
     }
 }
 
+async fn wait_for_rpc_readiness(
+    endpoint: &str,
+    child: &mut Child,
+    timeout: Duration,
+) -> BenchResult<()> {
+    let deadline = tokio::time::Instant::now() + timeout;
+    loop {
+        if let Some(status) = child.try_wait()? {
+            return Err(io_other(format!("anvil exited before readiness: status={status}")).into());
+        }
+        if rpc_endpoint_is_ready(endpoint).await {
+            return Ok(());
+        }
+        if tokio::time::Instant::now() >= deadline {
+            return Err(io_other(format!(
+                "timed out waiting for anvil readiness at {endpoint}"
+            ))
+            .into());
+        }
+        tokio::time::sleep(Duration::from_millis(100)).await;
+    }
+}
+
 async fn http_endpoint_is_ready(endpoint: &str) -> bool {
     let Some(host_port) = endpoint.strip_prefix("http://") else {
         return false;
@@ -288,6 +412,35 @@ async fn http_endpoint_is_ready(endpoint: &str) -> bool {
     }
 }
 
+async fn rpc_endpoint_is_ready(endpoint: &str) -> bool {
+    let Some(host_port) = endpoint.strip_prefix("http://") else {
+        return false;
+    };
+    let mut stream =
+        match tokio::time::timeout(Duration::from_millis(300), TcpStream::connect(host_port)).await
+        {
+            Ok(Ok(value)) => value,
+            _ => return false,
+        };
+
+    let body = r#"{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}"#;
+    let request = format!(
+        "POST / HTTP/1.1\r\nHost: {host_port}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
+        body.len()
+    );
+    if stream.write_all(request.as_bytes()).await.is_err() {
+        return false;
+    }
+    let mut head = [0_u8; 128];
+    match tokio::time::timeout(Duration::from_millis(300), stream.read(&mut head)).await {
+        Ok(Ok(read)) if read > 0 => std::str::from_utf8(&head[..read])
+            .ok()
+            .map(|text| text.contains("200 OK"))
+            .unwrap_or(false),
+        _ => false,
+    }
+}
+
 async fn send_graceful_terminate(child: &mut Child) {
     let Some(pid) = child.id() else {
         return;
@@ -322,23 +475,55 @@ fn dir_path_join(base: &Path, file: &str) -> PathBuf {
     path
 }
 
+fn ensure_exists(path: &Path, missing_message: String) -> BenchResult<()> {
+    if path.exists() {
+        Ok(())
+    } else {
+        Err(io_other(missing_message).into())
+    }
+}
+
 fn path_as_str(path: &Path) -> BenchResult<&str> {
     path.to_str()
         .ok_or_else(|| io_other(format!("path is not valid UTF-8: {}", path.display())).into())
 }
 
+fn read_input_box_address(path: &Path) -> BenchResult<Address> {
+    #[derive(Deserialize)]
+    struct DeploymentInfo {
+        address: String,
+    }
+
+    let deployment: DeploymentInfo = serde_json::from_str(&fs::read_to_string(path)?)
+        .map_err(|err| io_other(format!("failed to parse {}: {err}", path.display())))?;
+    deployment.address.parse().map_err(|err| {
+        io_other(format!(
+            "invalid InputBox address in {}: {err}",
+            path.display()
+        ))
+        .into()
+    })
+}
+
 fn io_other(message: impl Into<String>) -> std::io::Error {
     std::io::Error::other(message.into())
 }
 
 #[cfg(test)]
 mod tests {
-    use super::default_sequencer_log_path;
+    use super::{default_anvil_log_path, default_sequencer_log_path};
 
     #[test]
     fn default_log_path_uses_results_dir() {
         let value = default_sequencer_log_path("ack-latency");
         assert!(value.to_string_lossy().contains("benchmarks/results/"));
         assert!(value.to_string_lossy().contains("ack-latency"));
     }
+
+    #[test]
+    fn default_anvil_log_path_uses_results_dir() {
+        let value = default_anvil_log_path("ack-latency");
+        assert!(value.to_string_lossy().contains("benchmarks/results/"));
+        assert!(value.to_string_lossy().contains("ack-latency-anvil"));
+    }
 }