Increase the wait duration of kurtosis

* Clean up the process flow for nodes

* Cleanup some of the node tests to use shared nodes

* Commit dev-genesis

.github/workflows/test.yml

@@ -91,10 +91,10 @@ jobs:
         with:
           rustflags: ""
 
-      - name: Add wasm32 target
+      - name: Add wasm32 target and formatting
         run: |
           rustup target add wasm32-unknown-unknown
-          rustup component add rust-src
+          rustup component add rust-src rustfmt clippy
 
       - name: Install Geth on Ubuntu
         if: matrix.os == 'ubuntu-24.04'
@@ -141,6 +141,17 @@ jobs:
           chmod +x resolc
           sudo mv resolc /usr/local/bin
 
+      - name: Install Kurtosis on macOS
+        if: matrix.os == 'macos-14'
+        run: brew install kurtosis-tech/tap/kurtosis-cli
+
+      - name: Install Kurtosis on Ubuntu
+        if: matrix.os == 'ubuntu-24.04'
+        run: |
+          echo "deb [trusted=yes] https://apt.fury.io/kurtosis-tech/ /" | sudo tee /etc/apt/sources.list.d/kurtosis.list
+          sudo apt update
+          sudo apt install kurtosis-cli
+
       - name: Machete
         uses: bnjbvr/cargo-machete@v0.7.1
 
@@ -159,5 +170,22 @@ jobs:
       - name: Check resolc version
         run: resolc --version
 
-      - name: Test cargo workspace
+      - name: Test Formatting
-        run: make test
+        run: make format
+
+      - name: Test Clippy
+        run: make clippy
+
+      - name: Test Machete
+        run: make machete
+
+      - name: Unit Tests
+        if: matrix.os == 'ubuntu-24.04'
+        run: cargo test --workspace -- --nocapture
+
+      # We can't install docker in the MacOS image used in CI and therefore we need to skip the
+      # Kurtosis and lighthouse related tests when running the CI on MacOS.
+      - name: Unit Tests
+        if: matrix.os == 'macos-14'
+        run: |
+          cargo test --workspace -- --nocapture --skip lighthouse_geth::tests::

.gitignore

@@ -13,3 +13,4 @@ resolc-compiler-tests
 workdir
 
 !/schema.json
+!/dev-genesis.json

Cargo.lock

@@ -87,6 +87,7 @@ dependencies = [
  "alloy-transport",
  "alloy-transport-http",
  "alloy-transport-ipc",
+ "alloy-transport-ws",
 ]
 
 [[package]]
@@ -378,6 +379,7 @@ dependencies = [
  "alloy-transport",
  "alloy-transport-http",
  "alloy-transport-ipc",
+ "alloy-transport-ws",
  "async-stream",
  "async-trait",
  "auto_impl",
@@ -454,6 +456,7 @@ dependencies = [
  "alloy-transport",
  "alloy-transport-http",
  "alloy-transport-ipc",
+ "alloy-transport-ws",
  "futures",
  "pin-project",
  "reqwest",
@@ -709,6 +712,24 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "alloy-transport-ws"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e915e1250dc129ad48d264573ccd08e4716fdda564a772fd217875b8459aff9"
+dependencies = [
+ "alloy-pubsub",
+ "alloy-transport",
+ "futures",
+ "http",
+ "rustls",
+ "serde_json",
+ "tokio",
+ "tokio-tungstenite",
+ "tracing",
+ "ws_stream_wasm",
+]
+
 [[package]]
 name = "alloy-trie"
 version = "0.9.0"
@@ -1373,6 +1394,17 @@ dependencies = [
  "syn 2.0.101",
 ]
 
+[[package]]
+name = "async_io_stream"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d7b9decdf35d8908a7e3ef02f64c5e9b1695e230154c0e8de3969142d9b94c"
+dependencies = [
+ "futures",
+ "pharos",
+ "rustc_version 0.4.1",
+]
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -2021,6 +2053,12 @@ dependencies = [
  "parking_lot_core",
 ]
 
+[[package]]
+name = "data-encoding"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
+
 [[package]]
 name = "der"
 version = "0.7.10"
@@ -3956,6 +3994,16 @@ dependencies = [
  "ucd-trie",
 ]
 
+[[package]]
+name = "pharos"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9567389417feee6ce15dd6527a8a1ecac205ef62c2932bcf3d9f6fc5b78b414"
+dependencies = [
+ "futures",
+ "rustc_version 0.4.1",
+]
+
 [[package]]
 name = "pin-project"
 version = "1.1.10"
@@ -4577,6 +4625,8 @@ dependencies = [
  "revive-dt-node-interaction",
  "serde",
  "serde_json",
+ "serde_with",
+ "serde_yaml_ng",
  "sp-core",
  "sp-runtime",
  "temp-dir",
@@ -4768,6 +4818,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "730944ca083c1c233a75c09f199e973ca499344a2b7ba9e755c457e86fb4a321"
 dependencies = [
  "once_cell",
+ "ring",
  "rustls-pki-types",
  "rustls-webpki",
  "subtle",
@@ -5055,6 +5106,12 @@ dependencies = [
  "pest",
 ]
 
+[[package]]
+name = "send_wrapper"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
+
 [[package]]
 name = "serde"
 version = "1.0.219"
@@ -5171,6 +5228,19 @@ dependencies = [
  "syn 2.0.101",
 ]
 
+[[package]]
+name = "serde_yaml_ng"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b4db627b98b36d4203a7b458cf3573730f2bb591b28871d916dfa9efabfd41f"
+dependencies = [
+ "indexmap 2.10.0",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
 [[package]]
 name = "serdect"
 version = "0.2.0"
@@ -6067,6 +6137,22 @@ dependencies = [
  "tokio-util",
 ]
 
+[[package]]
+name = "tokio-tungstenite"
+version = "0.26.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a9daff607c6d2bf6c16fd681ccb7eecc83e4e2cdc1ca067ffaadfca5de7f084"
+dependencies = [
+ "futures-util",
+ "log",
+ "rustls",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tungstenite",
+ "webpki-roots 0.26.11",
+]
+
 [[package]]
 name = "tokio-util"
 version = "0.7.15"
@@ -6281,6 +6367,25 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
+[[package]]
+name = "tungstenite"
+version = "0.26.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4793cb5e56680ecbb1d843515b23b6de9a75eb04b66643e256a396d43be33c13"
+dependencies = [
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "rand 0.9.2",
+ "rustls",
+ "rustls-pki-types",
+ "sha1",
+ "thiserror 2.0.12",
+ "utf-8",
+]
+
 [[package]]
 name = "tuplex"
 version = "0.1.2"
@@ -6368,6 +6473,12 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
+
 [[package]]
 name = "untrusted"
 version = "0.9.0"
@@ -6385,6 +6496,12 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
 [[package]]
 name = "utf8_iter"
 version = "1.0.4"
@@ -6639,6 +6756,24 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "webpki-roots"
+version = "0.26.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
+dependencies = [
+ "webpki-roots 1.0.2",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e8983c3ab33d6fb807cfcdad2491c4ea8cbc8ed839181c7dfd9c67c83e261b2"
+dependencies = [
+ "rustls-pki-types",
+]
+
 [[package]]
 name = "widestring"
 version = "1.2.0"
@@ -6977,6 +7112,25 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
 
+[[package]]
+name = "ws_stream_wasm"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c173014acad22e83f16403ee360115b38846fe754e735c5d9d3803fe70c6abc"
+dependencies = [
+ "async_io_stream",
+ "futures",
+ "js-sys",
+ "log",
+ "pharos",
+ "rustc_version 0.4.1",
+ "send_wrapper",
+ "thiserror 2.0.12",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "wyz"
 version = "0.5.1"

Cargo.toml

@@ -45,7 +45,8 @@ serde_json = { version = "1.0", default-features = false, features = [
     "std",
     "unbounded_depth",
 ] }
-serde_with = { version = "3.14.0" }
+serde_with = { version = "3.14.0", features = ["hex"] }
+serde_yaml_ng = { version = "0.10.0" }
 sha2 = { version = "0.10.9" }
 sp-core = "36.1.0"
 sp-runtime = "41.1.0"
@@ -80,6 +81,7 @@ features = [
     "json-abi",
     "providers",
     "provider-ipc",
+    "provider-ws",
     "provider-debug-api",
     "reqwest",
     "rpc-types",

README.md

@@ -44,6 +44,7 @@ This section describes the required dependencies that this framework requires to
 - ETH-RPC - All communication with Kitchensink is done through the ETH RPC.
 - Solc - This is actually a transitive dependency, while this tool doesn't require solc as it downloads the versions that it requires, resolc requires that Solc is installed and available in the path.
 - Resolc - This is required to compile the contracts to PolkaVM bytecode.
+- Kurtosis - The Kurtosis CLI tool is required for the production Ethereum mainnet-like node configuration with Geth as the execution layer and lighthouse as the consensus layer. Kurtosis also requires docker to be installed since it runs everything inside of docker containers.
 
 All of the above need to be installed and available in the path in order for the tool to work.
 

crates/common/src/types/identifiers.rs

@@ -29,6 +29,8 @@ use strum::{AsRefStr, Display, EnumString, IntoStaticStr};
 pub enum PlatformIdentifier {
     /// The Go-ethereum reference full node EVM implementation with the solc compiler.
     GethEvmSolc,
+    /// The Lighthouse Go-ethereum reference full node EVM implementation with the solc compiler.
+    LighthouseGethEvmSolc,
     /// The kitchensink node with the PolkaVM backend with the resolc compiler.
     KitchensinkPolkavmResolc,
     /// The kitchensink node with the REVM backend with the solc compiler.
@@ -87,6 +89,8 @@ pub enum CompilerIdentifier {
 pub enum NodeIdentifier {
     /// The go-ethereum node implementation.
     Geth,
+    /// The go-ethereum node implementation.
+    LighthouseGeth,
     /// The Kitchensink node implementation.
     Kitchensink,
     /// The revive dev node implementation.

crates/config/src/lib.rs

@@ -79,6 +79,15 @@ impl AsRef<GethConfiguration> for Context {
     }
 }
 
+impl AsRef<KurtosisConfiguration> for Context {
+    fn as_ref(&self) -> &KurtosisConfiguration {
+        match self {
+            Self::ExecuteTests(context) => context.as_ref().as_ref(),
+            Self::ExportJsonSchema => unreachable!(),
+        }
+    }
+}
+
 impl AsRef<KitchensinkConfiguration> for Context {
     fn as_ref(&self) -> &KitchensinkConfiguration {
         match self {
@@ -190,6 +199,10 @@ pub struct TestExecutionContext {
     #[clap(flatten, next_help_heading = "Geth Configuration")]
     pub geth_configuration: GethConfiguration,
 
+    /// Configuration parameters for the lighthouse node.
+    #[clap(flatten, next_help_heading = "Lighthouse Configuration")]
+    pub lighthouse_configuration: KurtosisConfiguration,
+
     /// Configuration parameters for the Kitchensink.
     #[clap(flatten, next_help_heading = "Kitchensink Configuration")]
     pub kitchensink_configuration: KitchensinkConfiguration,
@@ -253,6 +266,12 @@ impl AsRef<GethConfiguration> for TestExecutionContext {
     }
 }
 
+impl AsRef<KurtosisConfiguration> for TestExecutionContext {
+    fn as_ref(&self) -> &KurtosisConfiguration {
+        &self.lighthouse_configuration
+    }
+}
+
 impl AsRef<KitchensinkConfiguration> for TestExecutionContext {
     fn as_ref(&self) -> &KitchensinkConfiguration {
         &self.kitchensink_configuration
@@ -335,12 +354,27 @@ pub struct GethConfiguration {
     #[clap(
         id = "geth.start-timeout-ms",
         long = "geth.start-timeout-ms",
-        default_value = "5000",
+        default_value = "30000",
         value_parser = parse_duration
     )]
     pub start_timeout_ms: Duration,
 }
 
+/// A set of configuration parameters for kurtosis.
+#[derive(Clone, Debug, Parser, Serialize)]
+pub struct KurtosisConfiguration {
+    /// Specifies the path of the kurtosis node to be used by the tool.
+    ///
+    /// If this is not specified, then the tool assumes that it should use the kurtosis binary that's
+    /// provided in the user's $PATH.
+    #[clap(
+        id = "kurtosis.path",
+        long = "kurtosis.path",
+        default_value = "kurtosis"
+    )]
+    pub path: PathBuf,
+}
+
 /// A set of configuration parameters for Kitchensink.
 #[derive(Clone, Debug, Parser, Serialize)]
 pub struct KitchensinkConfiguration {
@@ -359,7 +393,7 @@ pub struct KitchensinkConfiguration {
     #[clap(
         id = "kitchensink.start-timeout-ms",
         long = "kitchensink.start-timeout-ms",
-        default_value = "5000",
+        default_value = "30000",
         value_parser = parse_duration
     )]
     pub start_timeout_ms: Duration,
@@ -387,7 +421,7 @@ pub struct ReviveDevNodeConfiguration {
     #[clap(
         id = "revive-dev-node.start-timeout-ms",
         long = "revive-dev-node.start-timeout-ms",
-        default_value = "5000",
+        default_value = "30000",
         value_parser = parse_duration
     )]
     pub start_timeout_ms: Duration,
@@ -407,7 +441,7 @@ pub struct EthRpcConfiguration {
     #[clap(
         id = "eth-rpc.start-timeout-ms",
         long = "eth-rpc.start-timeout-ms",
-        default_value = "5000",
+        default_value = "30000",
         value_parser = parse_duration
     )]
     pub start_timeout_ms: Duration,
@@ -431,7 +465,7 @@ pub struct GenesisConfiguration {
 impl GenesisConfiguration {
     pub fn genesis(&self) -> anyhow::Result<&Genesis> {
         static DEFAULT_GENESIS: LazyLock<Genesis> = LazyLock::new(|| {
-            let genesis = include_str!("../../../genesis.json");
+            let genesis = include_str!("../../../assets/dev-genesis.json");
             serde_json::from_str(genesis).unwrap()
         });
 
@@ -465,7 +499,7 @@ pub struct WalletConfiguration {
     /// This argument controls which private keys the nodes should have access to and be added to
     /// its wallet signers. With a value of N, private keys (0, N] will be added to the signer set
     /// of the node.
-    #[clap(long = "wallet.additional-keys", default_value_t = 100_000)]
+    #[clap(long = "wallet.additional-keys", default_value_t = 200)]
     additional_keys: usize,
 
     /// The wallet object that will be used.

crates/core/src/driver/mod.rs

@@ -30,7 +30,7 @@ use revive_dt_format::case::Case;
 use revive_dt_format::metadata::{ContractIdent, ContractInstance, ContractPathAndIdent};
 use revive_dt_format::steps::{
     BalanceAssertionStep, Calldata, EtherValue, Expected, ExpectedOutput, FunctionCallStep, Method,
-    StepIdx, StorageEmptyAssertionStep,
+    StepIdx, StepPath, StorageEmptyAssertionStep,
 };
 use revive_dt_format::{metadata::Metadata, steps::Step};
 use revive_dt_node_interaction::EthereumNode;
@@ -83,6 +83,7 @@ impl CaseState {
         &mut self,
         metadata: &Metadata,
         step: &Step,
+        step_path: &StepPath,
         node: &dyn EthereumNode,
     ) -> anyhow::Result<StepOutput> {
         match step {
@@ -110,6 +111,7 @@ impl CaseState {
                     metadata,
                     repetition_step.repeat,
                     &repetition_step.steps,
+                    step_path,
                     node,
                 )
                 .await
@@ -200,13 +202,15 @@ impl CaseState {
         metadata: &Metadata,
         repetitions: usize,
         steps: &[Step],
+        step_path: &StepPath,
         node: &dyn EthereumNode,
     ) -> anyhow::Result<()> {
         let tasks = (0..repetitions).map(|_| {
             let mut state = self.clone();
             async move {
-                for step in steps {
+                for (step_idx, step) in steps.iter().enumerate() {
-                    state.handle_step(metadata, step, node).await?;
+                    let step_path = step_path.append(step_idx);
+                    state.handle_step(metadata, step, &step_path, node).await?;
                 }
                 Ok::<(), anyhow::Error>(())
             }
@@ -842,32 +846,31 @@ impl<'a> CaseDriver<'a> {
             .enumerate()
             .map(|(idx, v)| (StepIdx::new(idx), v))
         {
-            // Run this step concurrently across all platforms; short-circuit on first failure
             let metadata = self.metadata;
-            let step_futs =
+            let step_futures =
                 self.platform_state
                     .iter_mut()
                     .map(|(node, platform_id, case_state)| {
                         let platform_id = *platform_id;
                         let node_ref = *node;
-                        let step_clone = step.clone();
+                        let step = step.clone();
                         let span = info_span!(
                             "Handling Step",
                             %step_idx,
                             platform = %platform_id,
                         );
                         async move {
+                            let step_path = StepPath::from_iterator([step_idx]);
                             case_state
-                                .handle_step(metadata, &step_clone, node_ref)
+                                .handle_step(metadata, &step, &step_path, node_ref)
                                 .await
                                 .map_err(|e| (platform_id, e))
                         }
                         .instrument(span)
                     });
 
-            match try_join_all(step_futs).await {
+            match try_join_all(step_futures).await {
                 Ok(_outputs) => {
-                    // All platforms succeeded for this step
                     steps_executed += 1;
                 }
                 Err((platform_id, error)) => {

crates/core/src/lib.rs

@@ -13,7 +13,9 @@ use anyhow::Context as _;
 use revive_dt_common::types::*;
 use revive_dt_compiler::{SolidityCompiler, revive_resolc::Resolc, solc::Solc};
 use revive_dt_config::*;
-use revive_dt_node::{Node, geth::GethNode, substrate::SubstrateNode};
+use revive_dt_node::{
+    Node, geth::GethNode, lighthouse_geth::LighthouseGethNode, substrate::SubstrateNode,
+};
 use revive_dt_node_interaction::EthereumNode;
 use tracing::info;
 
@@ -104,6 +106,51 @@ impl Platform for GethEvmSolcPlatform {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
+pub struct LighthouseGethEvmSolcPlatform;
+
+impl Platform for LighthouseGethEvmSolcPlatform {
+    fn platform_identifier(&self) -> PlatformIdentifier {
+        PlatformIdentifier::LighthouseGethEvmSolc
+    }
+
+    fn node_identifier(&self) -> NodeIdentifier {
+        NodeIdentifier::LighthouseGeth
+    }
+
+    fn vm_identifier(&self) -> VmIdentifier {
+        VmIdentifier::Evm
+    }
+
+    fn compiler_identifier(&self) -> CompilerIdentifier {
+        CompilerIdentifier::Solc
+    }
+
+    fn new_node(
+        &self,
+        context: Context,
+    ) -> anyhow::Result<JoinHandle<anyhow::Result<Box<dyn EthereumNode + Send + Sync>>>> {
+        let genesis_configuration = AsRef::<GenesisConfiguration>::as_ref(&context);
+        let genesis = genesis_configuration.genesis()?.clone();
+        Ok(thread::spawn(move || {
+            let node = LighthouseGethNode::new(context);
+            let node = spawn_node::<LighthouseGethNode>(node, genesis)?;
+            Ok(Box::new(node) as Box<_>)
+        }))
+    }
+
+    fn new_compiler(
+        &self,
+        context: Context,
+        version: Option<VersionOrRequirement>,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<Box<dyn SolidityCompiler>>>>> {
+        Box::pin(async move {
+            let compiler = Solc::new(context, version).await;
+            compiler.map(|compiler| Box::new(compiler) as Box<dyn SolidityCompiler>)
+        })
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
 pub struct KitchensinkPolkavmResolcPlatform;
 
@@ -316,6 +363,9 @@ impl From<PlatformIdentifier> for Box<dyn Platform> {
     fn from(value: PlatformIdentifier) -> Self {
         match value {
             PlatformIdentifier::GethEvmSolc => Box::new(GethEvmSolcPlatform) as Box<_>,
+            PlatformIdentifier::LighthouseGethEvmSolc => {
+                Box::new(LighthouseGethEvmSolcPlatform) as Box<_>
+            }
             PlatformIdentifier::KitchensinkPolkavmResolc => {
                 Box::new(KitchensinkPolkavmResolcPlatform) as Box<_>
             }
@@ -336,6 +386,9 @@ impl From<PlatformIdentifier> for &dyn Platform {
     fn from(value: PlatformIdentifier) -> Self {
         match value {
             PlatformIdentifier::GethEvmSolc => &GethEvmSolcPlatform as &dyn Platform,
+            PlatformIdentifier::LighthouseGethEvmSolc => {
+                &LighthouseGethEvmSolcPlatform as &dyn Platform
+            }
             PlatformIdentifier::KitchensinkPolkavmResolc => {
                 &KitchensinkPolkavmResolcPlatform as &dyn Platform
             }

crates/format/src/steps.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, fmt::Display};
+use std::{collections::HashMap, fmt::Display, str::FromStr};
 
 use alloy::{
     eips::BlockNumberOrTag,
@@ -46,9 +46,71 @@ pub enum Step {
 
 define_wrapper_type!(
     #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-    pub struct StepIdx(usize) impl Display;
+    pub struct StepIdx(usize) impl Display, FromStr;
 );
 
+define_wrapper_type!(
+    #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+    #[serde(try_from = "String", into = "String")]
+    pub struct StepPath(Vec<StepIdx>);
+);
+
+impl StepPath {
+    pub fn from_iterator(path: impl IntoIterator<Item = impl Into<StepIdx>>) -> Self {
+        Self(path.into_iter().map(|value| value.into()).collect())
+    }
+
+    pub fn increment(&self) -> Self {
+        let mut this = self.clone();
+        if let Some(last) = this.last_mut() {
+            last.0 += 1
+        }
+        this
+    }
+
+    pub fn append(&self, step_idx: impl Into<StepIdx>) -> Self {
+        let mut this = self.clone();
+        this.0.push(step_idx.into());
+        this
+    }
+}
+
+impl Display for StepPath {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0
+            .iter()
+            .map(|idx| idx.to_string())
+            .collect::<Vec<_>>()
+            .join(".")
+            .fmt(f)
+    }
+}
+
+impl FromStr for StepPath {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        s.split(".")
+            .map(StepIdx::from_str)
+            .collect::<anyhow::Result<Vec<_>>>()
+            .map(Self)
+    }
+}
+
+impl From<StepPath> for String {
+    fn from(value: StepPath) -> Self {
+        value.to_string()
+    }
+}
+
+impl TryFrom<String> for StepPath {
+    type Error = anyhow::Error;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        value.parse()
+    }
+}
+
 /// This is an input step which is a transaction description that the framework translates into a
 /// transaction and executes on the nodes.
 #[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq, JsonSchema)]

crates/node/Cargo.toml

@@ -22,6 +22,8 @@ revive-dt-node-interaction = { workspace = true }
 
 serde = { workspace = true }
 serde_json = { workspace = true }
+serde_with = { workspace = true }
+serde_yaml_ng = { workspace = true }
 
 sp-core = { workspace = true }
 sp-runtime = { workspace = true }

crates/node/src/geth.rs

@@ -1,17 +1,17 @@
 //! The go-ethereum node implementation.
 
 use std::{
-    fs::{File, OpenOptions, create_dir_all, remove_dir_all},
+    fs::{File, create_dir_all, remove_dir_all},
-    io::{BufRead, BufReader, Read, Write},
+    io::Read,
     ops::ControlFlow,
     path::PathBuf,
     pin::Pin,
-    process::{Child, Command, Stdio},
+    process::{Command, Stdio},
     sync::{
         Arc,
         atomic::{AtomicU32, Ordering},
     },
-    time::{Duration, Instant},
+    time::Duration,
 };
 
 use alloy::{
@@ -41,7 +41,12 @@ use revive_dt_config::*;
 use revive_dt_format::traits::ResolverApi;
 use revive_dt_node_interaction::EthereumNode;
 
-use crate::{Node, common::FallbackGasFiller, constants::INITIAL_BALANCE};
+use crate::{
+    Node,
+    common::FallbackGasFiller,
+    constants::INITIAL_BALANCE,
+    process::{Process, ProcessReadinessWaitBehavior},
+};
 
 static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 
@@ -61,16 +66,11 @@ pub struct GethNode {
     logs_directory: PathBuf,
     geth: PathBuf,
     id: u32,
-    handle: Option<Child>,
+    handle: Option<Process>,
     start_timeout: Duration,
     wallet: Arc<EthereumWallet>,
     nonce_manager: CachedNonceManager,
     chain_id_filler: ChainIdFiller,
-    /// This vector stores [`File`] objects that we use for logging which we want to flush when the
-    /// node object is dropped. We do not store them in a structured fashion at the moment (in
-    /// separate fields) as the logic that we need to apply to them is all the same regardless of
-    /// what it belongs to, we just want to flush them on [`Drop`] of the node.
-    logs_file_to_flush: Vec<File>,
 }
 
 impl GethNode {
@@ -84,9 +84,6 @@ impl GethNode {
     const READY_MARKER: &str = "IPC endpoint opened";
     const ERROR_MARKER: &str = "Fatal:";
 
-    const GETH_STDOUT_LOG_FILE_NAME: &str = "node_stdout.log";
-    const GETH_STDERR_LOG_FILE_NAME: &str = "node_stderr.log";
-
     const TRANSACTION_INDEXING_ERROR: &str = "transaction indexing is in progress";
     const TRANSACTION_TRACING_ERROR: &str = "historical state not available in path scheme yet";
 
@@ -124,9 +121,6 @@ impl GethNode {
             wallet: wallet.clone(),
             chain_id_filler: Default::default(),
             nonce_manager: Default::default(),
-            // We know that we only need to be storing 2 files so we can specify that when creating
-            // the vector. It's the stdout and stderr of the geth node.
-            logs_file_to_flush: Vec::with_capacity(2),
         }
     }
 
@@ -194,25 +188,12 @@ impl GethNode {
     /// [Instance::init] must be called prior.
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn spawn_process(&mut self) -> anyhow::Result<&mut Self> {
-        // This is the `OpenOptions` that we wish to use for all of the log files that we will be
+        let process = Process::new(
-        // opening in this method. We need to construct it in this way to:
+            None,
-        // 1. Be consistent
+            self.logs_directory.as_path(),
-        // 2. Less verbose and more dry
+            self.geth.as_path(),
-        // 3. Because the builder pattern uses mutable references so we need to get around that.
+            |command, stdout_file, stderr_file| {
-        let open_options = {
+                command
-            let mut options = OpenOptions::new();
-            options.create(true).truncate(true).write(true);
-            options
-        };
-
-        let stdout_logs_file = open_options
-            .clone()
-            .open(self.geth_stdout_log_file_path())
-            .context("Failed to open geth stdout logs file")?;
-        let stderr_logs_file = open_options
-            .open(self.geth_stderr_log_file_path())
-            .context("Failed to open geth stderr logs file")?;
-        self.handle = Command::new(&self.geth)
                     .arg("--dev")
                     .arg("--datadir")
                     .arg(&self.data_directory)
@@ -231,79 +212,37 @@ impl GethNode {
                     .arg("full")
                     .arg("--gcmode")
                     .arg("archive")
-            .stderr(
+                    .stderr(stderr_file)
-                stderr_logs_file
+                    .stdout(stdout_file);
-                    .try_clone()
+            },
-                    .context("Failed to clone geth stderr log file handle")?,
+            ProcessReadinessWaitBehavior::TimeBoundedWaitFunction {
-            )
+                max_wait_duration: self.start_timeout,
-            .stdout(
+                check_function: Box::new(|_, stderr_line| match stderr_line {
-                stdout_logs_file
+                    Some(line) => {
-                    .try_clone()
-                    .context("Failed to clone geth stdout log file handle")?,
-            )
-            .spawn()
-            .context("Failed to spawn geth node process")?
-            .into();
-
-        if let Err(error) = self.wait_ready() {
-            tracing::error!(?error, "Failed to start geth, shutting down gracefully");
-            self.shutdown()
-                .context("Failed to gracefully shutdown after geth start error")?;
-            return Err(error);
-        }
-
-        self.logs_file_to_flush
-            .extend([stderr_logs_file, stdout_logs_file]);
-
-        Ok(self)
-    }
-
-    /// Wait for the g-ethereum node child process getting ready.
-    ///
-    /// [Instance::spawn_process] must be called priorly.
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
-    fn wait_ready(&mut self) -> anyhow::Result<&mut Self> {
-        let start_time = Instant::now();
-
-        let logs_file = OpenOptions::new()
-            .read(true)
-            .write(false)
-            .append(false)
-            .truncate(false)
-            .open(self.geth_stderr_log_file_path())
-            .context("Failed to open geth stderr logs file for readiness check")?;
-
-        let maximum_wait_time = self.start_timeout;
-        let mut stderr = BufReader::new(logs_file).lines();
-        let mut lines = vec![];
-        loop {
-            if let Some(Ok(line)) = stderr.next() {
                         if line.contains(Self::ERROR_MARKER) {
                             anyhow::bail!("Failed to start geth {line}");
+                        } else if line.contains(Self::READY_MARKER) {
+                            Ok(true)
+                        } else {
+                            Ok(false)
                         }
-                if line.contains(Self::READY_MARKER) {
-                    return Ok(self);
                     }
-                lines.push(line);
+                    None => Ok(false),
-            }
+                }),
-            if Instant::now().duration_since(start_time) > maximum_wait_time {
+            },
-                anyhow::bail!(
-                    "Timeout in starting geth: took longer than {}ms. stdout:\n\n{}\n",
-                    self.start_timeout.as_millis(),
-                    lines.join("\n")
         );
-            }
+
+        match process {
+            Ok(process) => self.handle = Some(process),
+            Err(err) => {
+                tracing::error!(?err, "Failed to start geth, shutting down gracefully");
+                self.shutdown()
+                    .context("Failed to gracefully shutdown after geth start error")?;
+                return Err(err);
             }
         }
 
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
+        Ok(self)
-    fn geth_stdout_log_file_path(&self) -> PathBuf {
-        self.logs_directory.join(Self::GETH_STDOUT_LOG_FILE_NAME)
-    }
-
-    #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
-    fn geth_stderr_log_file_path(&self) -> PathBuf {
-        self.logs_directory.join(Self::GETH_STDERR_LOG_FILE_NAME)
     }
 
     async fn provider(
@@ -650,17 +589,7 @@ impl<F: TxFiller<Ethereum>, P: Provider<Ethereum>> ResolverApi for GethNodeResol
 impl Node for GethNode {
     #[instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     fn shutdown(&mut self) -> anyhow::Result<()> {
-        // Terminate the processes in a graceful manner to allow for the output to be flushed.
+        drop(self.handle.take());
-        if let Some(mut child) = self.handle.take() {
-            child
-                .kill()
-                .map_err(|error| anyhow::anyhow!("Failed to kill the geth process: {error:?}"))?;
-        }
-
-        // Flushing the files that we're using for keeping the logs before shutdown.
-        for file in self.logs_file_to_flush.iter_mut() {
-            file.flush()?
-        }
 
         // Remove the node's database so that subsequent runs do not run on the same database. We
         // ignore the error just in case the directory didn't exist in the first place and therefore
@@ -701,6 +630,8 @@ impl Drop for GethNode {
 
 #[cfg(test)]
 mod tests {
+    use std::sync::LazyLock;
+
     use super::*;
 
     fn test_config() -> TestExecutionContext {
@@ -717,9 +648,21 @@ mod tests {
         (context, node)
     }
 
+    fn shared_node() -> &'static GethNode {
+        static NODE: LazyLock<(TestExecutionContext, GethNode)> = LazyLock::new(new_node);
+        &NODE.1
+    }
+
     #[test]
     fn version_works() {
-        let version = GethNode::new(&test_config()).version().unwrap();
+        // Arrange
+        let node = shared_node();
+
+        // Act
+        let version = node.version();
+
+        // Assert
+        let version = version.expect("Failed to get the version");
         assert!(
             version.starts_with("geth version"),
             "expected version string, got: '{version}'"
@@ -729,7 +672,7 @@ mod tests {
     #[tokio::test]
     async fn can_get_chain_id_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let node = shared_node();
 
         // Act
         let chain_id = node.resolver().await.unwrap().chain_id().await;
@@ -742,7 +685,7 @@ mod tests {
     #[tokio::test]
     async fn can_get_gas_limit_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let node = shared_node();
 
         // Act
         let gas_limit = node
@@ -753,14 +696,13 @@ mod tests {
             .await;
 
         // Assert
-        let gas_limit = gas_limit.expect("Failed to get the gas limit");
+        let _ = gas_limit.expect("Failed to get the gas limit");
-        assert_eq!(gas_limit, u32::MAX as u128)
     }
 
     #[tokio::test]
     async fn can_get_coinbase_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let node = shared_node();
 
         // Act
         let coinbase = node
@@ -771,14 +713,13 @@ mod tests {
             .await;
 
         // Assert
-        let coinbase = coinbase.expect("Failed to get the coinbase");
+        let _ = coinbase.expect("Failed to get the coinbase");
-        assert_eq!(coinbase, Address::new([0xFF; 20]))
     }
 
     #[tokio::test]
     async fn can_get_block_difficulty_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let node = shared_node();
 
         // Act
         let block_difficulty = node
@@ -789,14 +730,13 @@ mod tests {
             .await;
 
         // Assert
-        let block_difficulty = block_difficulty.expect("Failed to get the block difficulty");
+        let _ = block_difficulty.expect("Failed to get the block difficulty");
-        assert_eq!(block_difficulty, U256::ZERO)
     }
 
     #[tokio::test]
     async fn can_get_block_hash_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let node = shared_node();
 
         // Act
         let block_hash = node
@@ -813,7 +753,7 @@ mod tests {
     #[tokio::test]
     async fn can_get_block_timestamp_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let node = shared_node();
 
         // Act
         let block_timestamp = node
@@ -830,13 +770,12 @@ mod tests {
     #[tokio::test]
     async fn can_get_block_number_from_node() {
         // Arrange
-        let (_context, node) = new_node();
+        let node = shared_node();
 
         // Act
         let block_number = node.resolver().await.unwrap().last_block_number().await;
 
         // Assert
-        let block_number = block_number.expect("Failed to get the block number");
+        let _ = block_number.expect("Failed to get the block number");
-        assert_eq!(block_number, 0)
     }
 }

crates/node/src/lib.rs

@@ -6,6 +6,8 @@ use revive_dt_node_interaction::EthereumNode;
 pub mod common;
 pub mod constants;
 pub mod geth;
+pub mod lighthouse_geth;
+pub mod process;
 pub mod substrate;
 
 /// An abstract interface for testing nodes.

crates/node/src/process.rs

@@ -0,0 +1,188 @@
+use std::{
+    fs::{File, OpenOptions},
+    io::{BufRead, BufReader, Write},
+    path::Path,
+    process::{Child, Command},
+    time::{Duration, Instant},
+};
+
+use anyhow::{Context, Result, bail};
+
+/// A wrapper around processes which allows for their stdout and stderr to be logged and flushed
+/// when the process is dropped.
+#[derive(Debug)]
+pub struct Process {
+    /// The handle of the child process.
+    child: Child,
+
+    /// The file that stdout is being logged to.
+    stdout_logs_file: File,
+
+    /// The file that stderr is being logged to.
+    stderr_logs_file: File,
+}
+
+impl Process {
+    pub fn new(
+        log_file_prefix: impl Into<Option<&'static str>>,
+        logs_directory: impl AsRef<Path>,
+        binary_path: impl AsRef<Path>,
+        command_building_callback: impl FnOnce(&mut Command, File, File),
+        process_readiness_wait_behavior: ProcessReadinessWaitBehavior,
+    ) -> Result<Self> {
+        let log_file_prefix = log_file_prefix.into();
+
+        let (stdout_file_name, stderr_file_name) = match log_file_prefix {
+            Some(prefix) => (
+                format!("{prefix}_stdout.log"),
+                format!("{prefix}_stderr.log"),
+            ),
+            None => ("stdout.log".to_string(), "stderr.log".to_string()),
+        };
+
+        let stdout_logs_file_path = logs_directory.as_ref().join(stdout_file_name);
+        let stderr_logs_file_path = logs_directory.as_ref().join(stderr_file_name);
+
+        let stdout_logs_file = OpenOptions::new()
+            .write(true)
+            .truncate(true)
+            .create(true)
+            .open(stdout_logs_file_path.as_path())
+            .context("Failed to open the stdout logs file")?;
+        let stderr_logs_file = OpenOptions::new()
+            .write(true)
+            .truncate(true)
+            .create(true)
+            .open(stderr_logs_file_path.as_path())
+            .context("Failed to open the stderr logs file")?;
+
+        let mut command = {
+            let stdout_logs_file = stdout_logs_file
+                .try_clone()
+                .context("Failed to clone the stdout logs file")?;
+            let stderr_logs_file = stderr_logs_file
+                .try_clone()
+                .context("Failed to clone the stderr logs file")?;
+
+            let mut command = Command::new(binary_path.as_ref());
+            command_building_callback(&mut command, stdout_logs_file, stderr_logs_file);
+            command
+        };
+        let mut child = command
+            .spawn()
+            .context("Failed to spawn the built command")?;
+
+        match process_readiness_wait_behavior {
+            ProcessReadinessWaitBehavior::NoStartupWait => {}
+            ProcessReadinessWaitBehavior::WaitDuration(duration) => std::thread::sleep(duration),
+            ProcessReadinessWaitBehavior::TimeBoundedWaitFunction {
+                max_wait_duration,
+                mut check_function,
+            } => {
+                let spawn_time = Instant::now();
+
+                let stdout_logs_file = OpenOptions::new()
+                    .read(true)
+                    .open(stdout_logs_file_path)
+                    .context("Failed to open the stdout logs file")?;
+                let stderr_logs_file = OpenOptions::new()
+                    .read(true)
+                    .open(stderr_logs_file_path)
+                    .context("Failed to open the stderr logs file")?;
+
+                let mut stdout_lines = BufReader::new(stdout_logs_file).lines();
+                let mut stderr_lines = BufReader::new(stderr_logs_file).lines();
+
+                let mut stdout = String::new();
+                let mut stderr = String::new();
+
+                loop {
+                    let stdout_line = stdout_lines.next().and_then(Result::ok);
+                    let stderr_line = stderr_lines.next().and_then(Result::ok);
+
+                    if let Some(stdout_line) = stdout_line.as_ref() {
+                        stdout.push_str(stdout_line);
+                        stdout.push('\n');
+                    }
+                    if let Some(stderr_line) = stderr_line.as_ref() {
+                        stderr.push_str(stderr_line);
+                        stderr.push('\n');
+                    }
+
+                    let check_result =
+                        check_function(stdout_line.as_deref(), stderr_line.as_deref())
+                            .context("Failed to wait for the process to be ready")?;
+
+                    if check_result {
+                        break;
+                    }
+
+                    if Instant::now().duration_since(spawn_time) > max_wait_duration {
+                        bail!(
+                            "Waited for the process to start but it failed to start in time. stderr {stderr} - stdout {stdout}"
+                        )
+                    }
+                }
+            }
+            ProcessReadinessWaitBehavior::WaitForCommandToExit => {
+                if !child
+                    .wait()
+                    .context("Failed waiting for kurtosis run process to finish")?
+                    .success()
+                {
+                    anyhow::bail!("Failed to initialize kurtosis network",);
+                }
+            }
+        }
+
+        Ok(Self {
+            child,
+            stdout_logs_file,
+            stderr_logs_file,
+        })
+    }
+}
+
+impl Drop for Process {
+    fn drop(&mut self) {
+        self.child.kill().expect("Failed to kill the process");
+        self.stdout_logs_file
+            .flush()
+            .expect("Failed to flush the stdout logs file");
+        self.stderr_logs_file
+            .flush()
+            .expect("Failed to flush the stderr logs file");
+    }
+}
+
+pub enum ProcessReadinessWaitBehavior {
+    /// The process does not require any kind of wait after it's been spawned and can be used
+    /// straight away.
+    NoStartupWait,
+
+    /// Waits for the command to exit.
+    WaitForCommandToExit,
+
+    /// The process does require some amount of wait duration after it's been started.
+    WaitDuration(Duration),
+
+    /// The process requires a time bounded wait function which is a function of the lines that
+    /// appear in the log files.
+    TimeBoundedWaitFunction {
+        /// The maximum amount of time to wait for the check function to return true.
+        max_wait_duration: Duration,
+
+        /// The function to use to check if the process spawned is ready to use or not. This
+        /// function should return the following in the following cases:
+        ///
+        /// - `Ok(true)`: Returned when the condition the process is waiting for has been fulfilled
+        ///   and the wait is completed.
+        /// - `Ok(false)`: The process is not ready yet but it might be ready in the future.
+        /// - `Err`: The process is not ready yet and will not be ready in the future as it appears
+        ///   that it has encountered an error when it was being spawned.
+        ///
+        /// The first argument is a line from stdout and the second argument is a line from stderr.
+        #[allow(clippy::type_complexity)]
+        check_function: Box<dyn FnMut(Option<&str>, Option<&str>) -> anyhow::Result<bool>>,
+    },
+}

crates/node/src/substrate.rs

@@ -1,9 +1,8 @@
 use std::{
-    fs::{File, OpenOptions, create_dir_all, remove_dir_all},
+    fs::{create_dir_all, remove_dir_all},
-    io::{BufRead, Write},
+    path::PathBuf,
-    path::{Path, PathBuf},
     pin::Pin,
-    process::{Child, Command, Stdio},
+    process::{Command, Stdio},
     sync::{
         Arc,
         atomic::{AtomicU32, Ordering},
@@ -47,7 +46,12 @@ use revive_dt_config::*;
 use revive_dt_node_interaction::EthereumNode;
 use tracing::instrument;
 
-use crate::{Node, common::FallbackGasFiller, constants::INITIAL_BALANCE};
+use crate::{
+    Node,
+    common::FallbackGasFiller,
+    constants::INITIAL_BALANCE,
+    process::{Process, ProcessReadinessWaitBehavior},
+};
 
 static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 
@@ -63,12 +67,11 @@ pub struct SubstrateNode {
     rpc_url: String,
     base_directory: PathBuf,
     logs_directory: PathBuf,
-    process_substrate: Option<Child>,
+    substrate_process: Option<Process>,
-    process_proxy: Option<Child>,
+    eth_proxy_process: Option<Process>,
     wallet: Arc<EthereumWallet>,
     nonce_manager: CachedNonceManager,
     chain_id_filler: ChainIdFiller,
-    logs_file_to_flush: Vec<File>,
 }
 
 impl SubstrateNode {
@@ -85,12 +88,6 @@ impl SubstrateNode {
     const SUBSTRATE_LOG_ENV: &str = "error,evm=debug,sc_rpc_server=info,runtime::revive=debug";
     const PROXY_LOG_ENV: &str = "info,eth-rpc=debug";
 
-    const SUBSTRATE_STDOUT_LOG_FILE_NAME: &str = "node_stdout.log";
-    const SUBSTRATE_STDERR_LOG_FILE_NAME: &str = "node_stderr.log";
-
-    const PROXY_STDOUT_LOG_FILE_NAME: &str = "proxy_stdout.log";
-    const PROXY_STDERR_LOG_FILE_NAME: &str = "proxy_stderr.log";
-
     pub const KITCHENSINK_EXPORT_CHAINSPEC_COMMAND: &str = "export-chain-spec";
     pub const REVIVE_DEV_NODE_EXPORT_CHAINSPEC_COMMAND: &str = "build-spec";
 
@@ -121,16 +118,16 @@ impl SubstrateNode {
             rpc_url: String::new(),
             base_directory,
             logs_directory,
-            process_substrate: None,
+            substrate_process: None,
-            process_proxy: None,
+            eth_proxy_process: None,
             wallet: wallet.clone(),
             chain_id_filler: Default::default(),
             nonce_manager: Default::default(),
-            logs_file_to_flush: Vec::with_capacity(4),
         }
     }
 
     fn init(&mut self, mut genesis: Genesis) -> anyhow::Result<&mut Self> {
+        let _ = remove_dir_all(self.base_directory.as_path());
         let _ = clear_directory(&self.base_directory);
         let _ = clear_directory(&self.logs_directory);
 
@@ -213,32 +210,16 @@ impl SubstrateNode {
         let substrate_rpc_port = Self::BASE_SUBSTRATE_RPC_PORT + self.id as u16;
         let proxy_rpc_port = Self::BASE_PROXY_RPC_PORT + self.id as u16;
 
-        self.rpc_url = format!("http://127.0.0.1:{proxy_rpc_port}");
-
         let chainspec_path = self.base_directory.join(Self::CHAIN_SPEC_JSON_FILE);
 
-        // This is the `OpenOptions` that we wish to use for all of the log files that we will be
+        self.rpc_url = format!("http://127.0.0.1:{proxy_rpc_port}");
-        // opening in this method. We need to construct it in this way to:
-        // 1. Be consistent
-        // 2. Less verbose and more dry
-        // 3. Because the builder pattern uses mutable references so we need to get around that.
-        let open_options = {
-            let mut options = OpenOptions::new();
-            options.create(true).truncate(true).write(true);
-            options
-        };
 
-        // Start Substrate node
+        let substrate_process = Process::new(
-        let substrate_stdout_logs_file = open_options
+            "node",
-            .clone()
+            self.logs_directory.as_path(),
-            .open(self.substrate_stdout_log_file_path())
+            self.node_binary.as_path(),
-            .context("Failed to open substrate stdout logs file")?;
+            |command, stdout_file, stderr_file| {
-        let substrate_stderr_logs_file = open_options
+                command
-            .clone()
-            .open(self.substrate_stderr_log_file_path())
-            .context("Failed to open substrate stderr logs file")?;
-        let node_binary_path = self.node_binary.as_path();
-        self.process_substrate = Command::new(node_binary_path)
                     .arg("--dev")
                     .arg("--chain")
                     .arg(chainspec_path)
@@ -256,39 +237,33 @@ impl SubstrateNode {
                     .arg("--rpc-max-connections")
                     .arg(u32::MAX.to_string())
                     .env("RUST_LOG", Self::SUBSTRATE_LOG_ENV)
-            .stdout(
+                    .stdout(stdout_file)
-                substrate_stdout_logs_file
+                    .stderr(stderr_file);
-                    .try_clone()
+            },
-                    .context("Failed to clone substrate stdout log file handle")?,
+            ProcessReadinessWaitBehavior::TimeBoundedWaitFunction {
-            )
+                max_wait_duration: Duration::from_secs(30),
-            .stderr(
+                check_function: Box::new(|_, stderr_line| match stderr_line {
-                substrate_stderr_logs_file
+                    Some(line) => Ok(line.contains(Self::SUBSTRATE_READY_MARKER)),
-                    .try_clone()
+                    None => Ok(false),
-                    .context("Failed to clone substrate stderr log file handle")?,
+                }),
-            )
+            },
-            .spawn()
+        );
-            .context("Failed to spawn Substrate node process")?
+        match substrate_process {
-            .into();
+            Ok(process) => self.substrate_process = Some(process),
-
+            Err(err) => {
-        // Give the node a moment to boot
+                tracing::error!(?err, "Failed to start substrate, shutting down gracefully");
-        if let Err(error) = Self::wait_ready(
-            self.substrate_stderr_log_file_path().as_path(),
-            Self::SUBSTRATE_READY_MARKER,
-            Duration::from_secs(60),
-        ) {
                 self.shutdown()
-                .context("Failed to gracefully shutdown after Substrate start error")?;
+                    .context("Failed to gracefully shutdown after substrate start error")?;
-            return Err(error);
+                return Err(err);
-        };
+            }
+        }
 
-        let eth_proxy_stdout_logs_file = open_options
+        let eth_proxy_process = Process::new(
-            .clone()
+            "proxy",
-            .open(self.proxy_stdout_log_file_path())
+            self.logs_directory.as_path(),
-            .context("Failed to open eth-proxy stdout logs file")?;
+            self.eth_proxy_binary.as_path(),
-        let eth_proxy_stderr_logs_file = open_options
+            |command, stdout_file, stderr_file| {
-            .open(self.proxy_stderr_log_file_path())
+                command
-            .context("Failed to open eth-proxy stderr logs file")?;
-        self.process_proxy = Command::new(&self.eth_proxy_binary)
                     .arg("--dev")
                     .arg("--rpc-port")
                     .arg(proxy_rpc_port.to_string())
@@ -297,36 +272,26 @@ impl SubstrateNode {
                     .arg("--rpc-max-connections")
                     .arg(u32::MAX.to_string())
                     .env("RUST_LOG", Self::PROXY_LOG_ENV)
-            .stdout(
+                    .stdout(stdout_file)
-                eth_proxy_stdout_logs_file
+                    .stderr(stderr_file);
-                    .try_clone()
+            },
-                    .context("Failed to clone eth-proxy stdout log file handle")?,
+            ProcessReadinessWaitBehavior::TimeBoundedWaitFunction {
-            )
+                max_wait_duration: Duration::from_secs(30),
-            .stderr(
+                check_function: Box::new(|_, stderr_line| match stderr_line {
-                eth_proxy_stderr_logs_file
+                    Some(line) => Ok(line.contains(Self::ETH_PROXY_READY_MARKER)),
-                    .try_clone()
+                    None => Ok(false),
-                    .context("Failed to clone eth-proxy stderr log file handle")?,
+                }),
-            )
+            },
-            .spawn()
+        );
-            .context("Failed to spawn eth-proxy process")?
+        match eth_proxy_process {
-            .into();
+            Ok(process) => self.eth_proxy_process = Some(process),
-
+            Err(err) => {
-        if let Err(error) = Self::wait_ready(
+                tracing::error!(?err, "Failed to start eth proxy, shutting down gracefully");
-            self.proxy_stderr_log_file_path().as_path(),
-            Self::ETH_PROXY_READY_MARKER,
-            Duration::from_secs(60),
-        ) {
                 self.shutdown()
-                .context("Failed to gracefully shutdown after eth-proxy start error")?;
+                    .context("Failed to gracefully shutdown after eth proxy start error")?;
-            return Err(error);
+                return Err(err);
-        };
+            }
-
+        }
-        self.logs_file_to_flush.extend([
-            substrate_stdout_logs_file,
-            substrate_stderr_logs_file,
-            eth_proxy_stdout_logs_file,
-            eth_proxy_stderr_logs_file,
-        ]);
 
         Ok(())
     }
@@ -356,29 +321,6 @@ impl SubstrateNode {
         account_id.to_ss58check()
     }
 
-    fn wait_ready(logs_file_path: &Path, marker: &str, timeout: Duration) -> anyhow::Result<()> {
-        let start_time = std::time::Instant::now();
-        let logs_file = OpenOptions::new()
-            .read(true)
-            .write(false)
-            .append(false)
-            .truncate(false)
-            .open(logs_file_path)?;
-
-        let mut lines = std::io::BufReader::new(logs_file).lines();
-        loop {
-            if let Some(Ok(line)) = lines.next() {
-                if line.contains(marker) {
-                    return Ok(());
-                }
-            }
-
-            if start_time.elapsed() > timeout {
-                anyhow::bail!("Timeout waiting for process readiness: {marker}");
-            }
-        }
-    }
-
     pub fn eth_rpc_version(&self) -> anyhow::Result<String> {
         let output = Command::new(&self.eth_proxy_binary)
             .arg("--version")
@@ -391,24 +333,6 @@ impl SubstrateNode {
         Ok(String::from_utf8_lossy(&output).trim().to_string())
     }
 
-    fn substrate_stdout_log_file_path(&self) -> PathBuf {
-        self.logs_directory
-            .join(Self::SUBSTRATE_STDOUT_LOG_FILE_NAME)
-    }
-
-    fn substrate_stderr_log_file_path(&self) -> PathBuf {
-        self.logs_directory
-            .join(Self::SUBSTRATE_STDERR_LOG_FILE_NAME)
-    }
-
-    fn proxy_stdout_log_file_path(&self) -> PathBuf {
-        self.logs_directory.join(Self::PROXY_STDOUT_LOG_FILE_NAME)
-    }
-
-    fn proxy_stderr_log_file_path(&self) -> PathBuf {
-        self.logs_directory.join(Self::PROXY_STDERR_LOG_FILE_NAME)
-    }
-
     async fn provider(
         &self,
     ) -> anyhow::Result<
@@ -673,22 +597,8 @@ impl<F: TxFiller<ReviveNetwork>, P: Provider<ReviveNetwork>> ResolverApi
 
 impl Node for SubstrateNode {
     fn shutdown(&mut self) -> anyhow::Result<()> {
-        // Terminate the processes in a graceful manner to allow for the output to be flushed.
+        drop(self.substrate_process.take());
-        if let Some(mut child) = self.process_proxy.take() {
+        drop(self.eth_proxy_process.take());
-            child
-                .kill()
-                .map_err(|error| anyhow::anyhow!("Failed to kill the proxy process: {error:?}"))?;
-        }
-        if let Some(mut child) = self.process_substrate.take() {
-            child.kill().map_err(|error| {
-                anyhow::anyhow!("Failed to kill the Substrate process: {error:?}")
-            })?;
-        }
-
-        // Flushing the files that we're using for keeping the logs before shutdown.
-        for file in self.logs_file_to_flush.iter_mut() {
-            file.flush()?
-        }
 
         // Remove the node's database so that subsequent runs do not run on the same database. We
         // ignore the error just in case the directory didn't exist in the first place and therefore
@@ -1195,19 +1105,19 @@ mod tests {
         (context, node)
     }
 
-    /// A shared node that multiple tests can use. It starts up once.
+    fn shared_state() -> &'static (TestExecutionContext, SubstrateNode) {
+        static STATE: LazyLock<(TestExecutionContext, SubstrateNode)> = LazyLock::new(new_node);
+        &STATE
+    }
+
     fn shared_node() -> &'static SubstrateNode {
-        static NODE: LazyLock<(TestExecutionContext, SubstrateNode)> = LazyLock::new(|| {
+        &shared_state().1
-            let (context, node) = new_node();
-            (context, node)
-        });
-        &NODE.1
     }
 
     #[tokio::test]
     async fn node_mines_simple_transfer_transaction_and_returns_receipt() {
         // Arrange
-        let (context, node) = new_node();
+        let (context, node) = shared_state();
 
         let provider = node.provider().await.expect("Failed to create provider");
 

crates/report/src/common.rs

@@ -4,7 +4,7 @@ use std::{path::PathBuf, sync::Arc};
 
 use revive_dt_common::{define_wrapper_type, types::PlatformIdentifier};
 use revive_dt_compiler::Mode;
-use revive_dt_format::{case::CaseIdx, steps::StepIdx};
+use revive_dt_format::{case::CaseIdx, steps::StepPath};
 use serde::{Deserialize, Serialize};
 
 define_wrapper_type!(
@@ -33,5 +33,5 @@ pub struct ExecutionSpecifier {
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct StepExecutionSpecifier {
     pub execution_specifier: Arc<ExecutionSpecifier>,
-    pub step_idx: StepIdx,
+    pub step_idx: StepPath,
 }