feat/anvil integration tests (#430)

* (WIP) add test runner for scenario files

* fix gas estimate in uniV3.toml scenario

* add timeout to send_transaction calls in setup&spam

* add tracing_subscriber logging to scenario tests

* track contents of scenarios/ in build.rs; re-runs on changes

* apply required tx types to tx-type-specific scenarios

* chore: clippy

* suppress snake_case warnings for macro-generated tests

* chore: clippy

* chore: update changelog

* chore: fix comment

Author: zeroXbrock

crates/cli/build.rs

@@ -0,0 +1,62 @@
+use std::{
+    env, fs,
+    path::{Path, PathBuf},
+};
+
+fn main() {
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+
+    // Same as your collect_scenario_files: go up twice to project root,
+    // then into "scenarios".
+    let project_root = manifest_dir.parent().unwrap().parent().unwrap();
+    let scenarios_dir = project_root.join("scenarios");
+
+    let mut files = Vec::new();
+    let mut dirs = Vec::new();
+    collect_files(&scenarios_dir, &mut files, &mut dirs);
+
+    // Tell Cargo to rerun build.rs if scenarios/ directory or any subdirectory changes
+    // (this detects new/deleted files)
+    for dir in &dirs {
+        println!("cargo:rerun-if-changed={}", dir.display());
+    }
+    // Also watch each individual file (detects modifications)
+    for path in &files {
+        println!("cargo:rerun-if-changed={}", path.display());
+    }
+
+    let mut out = String::from("scenario_tests! {\n");
+
+    for path in files {
+        // Store paths relative to project_root so runtime resolution is identical
+        // to your current helper.
+        let rel = path.strip_prefix(project_root).unwrap();
+        let rel_str = rel.to_string_lossy();
+
+        // Turn "scenarios/foo/bar.toml" into a legal test name
+        let test_name: String = rel_str
+            .chars()
+            .map(|c| if c.is_ascii_alphanumeric() { c } else { '_' })
+            .collect();
+
+        out.push_str(&format!("    {} => {:?},\n", test_name, rel_str));
+    }
+
+    out.push_str("}\n");
+
+    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
+    fs::write(out_dir.join("generated_scenario_tests.rs"), out).unwrap();
+}
+
+fn collect_files(dir: &Path, acc: &mut Vec<PathBuf>, dirs: &mut Vec<PathBuf>) {
+    dirs.push(dir.to_path_buf());
+    for entry in fs::read_dir(dir).unwrap() {
+        let entry = entry.unwrap();
+        let path = entry.path();
+        if path.is_dir() {
+            collect_files(&path, acc, dirs);
+        } else {
+            acc.push(path);
+        }
+    }
+}

crates/cli/src/commands/common.rs

@@ -220,6 +220,17 @@ Required if --auth-rpc-url is set.",
     message_version: EngineMessageVersion,
 }
 
+impl Default for AuthCliArgs {
+    fn default() -> Self {
+        Self {
+            auth_rpc_url: None,
+            jwt_secret: None,
+            use_op: false,
+            message_version: EngineMessageVersion::V4,
+        }
+    }
+}
+
 #[derive(Copy, Debug, Clone, clap::ValueEnum)]
 enum EngineMessageVersion {
     V1,

crates/cli/src/commands/spam.rs

@@ -818,3 +818,167 @@ pub async fn spam<D: DbOps + Clone + Send + Sync + 'static>(
     let mut test_scenario = args.init_scenario(db).await?;
     spam_inner(db, &mut test_scenario, args, run_context).await
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::commands::common::AuthCliArgs;
+    use crate::commands::SetupCommandArgs;
+
+    use super::*;
+    use alloy::node_bindings::{Anvil, AnvilInstance, WEI_IN_ETHER};
+    use contender_sqlite::SqliteDb;
+    use std::{
+        collections::HashMap,
+        path::{Path, PathBuf},
+    };
+
+    fn create_send_args(sf: &Path, anvil: &AnvilInstance) -> ScenarioSendTxsCliArgs {
+        // map scenario files to custom tx types if needed
+        // this might be replaced with a more robust solution in the future
+        // e.g. mapping the entire ScenarioSendTxsCliArgs structure instead of just tx types
+        let custom_tx_types = HashMap::<&str, TxTypeCli>::from_iter([
+            ("blobs.toml", TxTypeCli::Eip4844),
+            ("setCode.toml", TxTypeCli::Eip7702),
+        ]);
+
+        // use last components of the path after "scenarios/" as a scenario ID
+        // this supports nested directories under "scenarios/"
+        let relative_path = sf
+            .components()
+            .rev()
+            .take_while(|component| component.as_os_str() != "scenarios")
+            .collect::<Vec<_>>()
+            .into_iter()
+            .rev()
+            .collect::<PathBuf>();
+
+        ScenarioSendTxsCliArgs {
+            testfile: Some(sf.to_str().unwrap().to_owned()),
+            rpc_args: SendTxsCliArgsInner {
+                rpc_url: anvil.endpoint_url(),
+                seed: None,
+                private_keys: None,
+                min_balance: WEI_IN_ETHER * U256::from(10),
+                tx_type: custom_tx_types
+                    .get(relative_path.as_os_str().to_str().unwrap())
+                    .cloned()
+                    .unwrap_or(TxTypeCli::Eip1559),
+                bundle_type: crate::commands::common::BundleTypeCli::L1,
+                auth_args: AuthCliArgs::default(),
+                call_forkchoice: false,
+                env: None,
+                override_senders: false,
+                gas_price: None,
+                accounts_per_agent: None,
+            },
+        }
+    }
+
+    async fn run_scenario(
+        sf: &Path,
+        anvil: &AnvilInstance,
+        db: &SqliteDb,
+        rand_seed: &RandSeed,
+    ) -> Result<()> {
+        // special case: skip bundle scenario (anvil doesn't support it)
+        if sf.ends_with("bundles.toml") {
+            println!("Skipping bundle scenario (anvil doesn't support bundles)");
+            return Ok(());
+        }
+
+        // initialize a logger
+        let _ = tracing_subscriber::fmt()
+            .with_env_filter("contender_core=debug,info")
+            .with_test_writer() // captures output properly in tests
+            .try_init(); // try_init() won't panic if already initialized
+
+        // initialize scenario
+        let scenario = SpamScenario::Testfile(sf.to_str().unwrap().to_owned());
+        let send_args = create_send_args(sf, anvil);
+
+        // run setup
+        crate::commands::setup(
+            db,
+            SetupCommandArgs {
+                scenario: scenario.clone(),
+                eth_json_rpc_args: send_args.rpc_args.clone(),
+                seed: rand_seed.clone(),
+            },
+        )
+        .await?;
+
+        // do a quick spam run
+        let res = spam(
+            db,
+            &SpamCommandArgs {
+                scenario,
+                spam_args: SpamCliArgs {
+                    eth_json_rpc_args: send_args,
+                    spam_args: SendSpamCliArgs {
+                        builder_url: None,
+                        txs_per_second: Some(50),
+                        txs_per_block: None,
+                        duration: 4,
+                        pending_timeout: 10,
+                        run_forever: false,
+                    },
+                    ignore_receipts: false,
+                    optimistic_nonces: true,
+                    gen_report: false,
+                    redeploy: true,
+                    skip_setup: false,
+                    rpc_batch_size: 0,
+                    spam_timeout: Duration::from_secs(5),
+                },
+                seed: rand_seed.clone(),
+            },
+            SpamCampaignContext {
+                campaign_id: None,
+                campaign_name: None,
+                stage_name: None,
+                scenario_name: None,
+            },
+        )
+        .await?;
+
+        println!("spam run successful. run id: {:?}", res);
+        Ok(())
+    }
+
+    /// Spin up a fresh anvil instance, DB, & seed, then run the scenario file given at `path`.
+    async fn run_scenario_file(path: &Path) -> Result<()> {
+        let anvil = Anvil::new().block_time(1).spawn();
+        let db = SqliteDb::new_memory();
+        db.create_tables()?;
+        let rand_seed = RandSeed::new();
+
+        run_scenario(path, &anvil, &db, &rand_seed).await
+    }
+
+    /// Generates individual spam test for each scenario given in the macro input.
+    /// NOTE: paths are relative to the project root. See `build.rs` for usage.
+    macro_rules! scenario_tests {
+        ($($name:ident => $relative_path:expr),* $(,)?) => {
+            $(
+                #[tokio::test]
+                async fn $name() -> std::result::Result<(), CliError> {
+                    let project_root = Path::new(env!("CARGO_MANIFEST_DIR"))
+                        .parent()
+                        .unwrap()
+                        .parent()
+                        .unwrap();
+                    let path: PathBuf = project_root.join($relative_path);
+                    run_scenario_file(&path).await?;
+                    Ok(())
+                }
+            )*
+        };
+    }
+
+    #[allow(non_snake_case)]
+    mod generated_scenario_tests {
+        use super::*;
+        // Generate tests for all scenario files identified by build.rs
+        include!(concat!(env!("OUT_DIR"), "/generated_scenario_tests.rs"));
+    }
+}

crates/core/CHANGELOG.md

@@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+
+- added timeout for send_transaction calls ([#430](https://github.com/flashbots/contender/pull/430/files))
+
 ## [0.7.3](https://github.com/flashbots/contender/releases/tag/v0.7.3) - 2026-01-20
 
 - transactions that revert onchain now store error as "execution reverted" DB, rather than NULL ([#418](https://github.com/flashbots/contender/pull/418/files))

crates/core/src/test_scenario.rs

@@ -610,7 +610,9 @@ where
 
         let res = wallet_client
             .send_transaction(WithOtherFields::new(tx))
-            .await?;
+            .await?
+            .with_timeout(Some(Duration::from_secs(30)));
+
         // watch pending transaction
         let receipt = res.get_receipt().await.expect("failed to get receipt");
         debug!(
@@ -664,6 +666,7 @@ where
                     .wallet(signer)
                     .network::<AnyNetwork>()
                     .connect_http(rpc_url.to_owned());
+                debug!("connecting wallet to rpc at {}", rpc_url);
 
                 let tx_label = tx_req
                     .name
@@ -698,8 +701,12 @@ where
                 );
 
                 // wallet will assign nonce before sending
-                let res = wallet.send_transaction(tx.into()).await?;
+                let res = wallet
+                    .send_transaction(tx.into())
+                    .await?
+                    .with_timeout(Some(Duration::from_secs(30)));
 
+                debug!("sent setup tx {:?}: {}", tx_req.kind, res.tx_hash());
                 // get receipt using provider (not wallet) to allow any receipt type (support non-eth chains)
                 let receipt = res.get_receipt().await?;
                 debug!(
@@ -1315,7 +1322,7 @@ where
         });
 
         format!(
-            "running setup: from={} to={} {}",
+            "running setup: from={} to={} gas={:?} {}",
             tx_req
                 .tx
                 .from
@@ -1327,6 +1334,7 @@ where
             } else {
                 to_address.map(|a| a.encode_hex()).unwrap_or_default()
             },
+            tx_req.tx.gas,
             if let Some(kind) = &tx_req.kind {
                 format!("kind={kind}")
             } else {

scenarios/uniV3.toml

@@ -71,16 +71,17 @@ args = [
     "3000",         # 0.3% fee tier
 ]
 
+# Token approvals for position manager are not needed, because we're using
+# tokens that auto-approve on `transferFrom`
+
 ## Initialize pools
 
 [[setup]]
 kind = "unicheat_init_pool_token1_token2"
 to = "{unicheatV3}"
 signature = "function initPool(address tokenA, address tokenB, uint24 fee)"
 args = ["{testToken}", "{testToken2}", "3000"]
-
-# Token approvals for position manager are not needed, because we're using
-# tokens that auto-approve on `transferFrom`
+gas_limit = 1000000
 
 ## Send all tokens to Unicheat
 
@@ -109,6 +110,7 @@ args = [
     "100000000000000000000",
     "100000000000000000000",
 ]
+gas_limit = 1000000
 
 ### Spam Steps
 ### (sends trades via UnicheatV3 contract so senders don't have to manage their own token balances)