fmt

* Add different output formats

* Add the mode to the output

.github/workflows/test.yml

@@ -15,6 +15,7 @@ concurrency:
 
 env:
   CARGO_TERM_COLOR: always
+  POLKADOT_VERSION: polkadot-stable2506-2
 
 jobs:
   cache-polkadot:
@@ -65,6 +66,37 @@ jobs:
         run: |
           cd polkadot-sdk
           cargo install --path substrate/frame/revive/rpc --bin eth-rpc
+      
+      - name: Cache downloaded Polkadot binaries
+        id: cache-polkadot
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/polkadot-cache/polkadot
+            ~/polkadot-cache/polkadot-execute-worker
+            ~/polkadot-cache/polkadot-prepare-worker
+            ~/polkadot-cache/polkadot-parachain
+          key: polkadot-downloaded-${{ matrix.os }}-${{ env.POLKADOT_VERSION }}
+
+      - name: Download Polkadot binaries on macOS
+        if: matrix.os == 'macos-14' && steps.cache-polkadot.outputs.cache-hit != 'true'
+        run: |
+          mkdir -p ~/polkadot-cache
+          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-aarch64-apple-darwin -o ~/polkadot-cache/polkadot
+          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-execute-worker-aarch64-apple-darwin -o ~/polkadot-cache/polkadot-execute-worker
+          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-prepare-worker-aarch64-apple-darwin -o ~/polkadot-cache/polkadot-prepare-worker
+          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-parachain-aarch64-apple-darwin -o ~/polkadot-cache/polkadot-parachain
+          chmod +x ~/polkadot-cache/*
+
+      - name: Download Polkadot binaries on Ubuntu
+        if: matrix.os == 'ubuntu-24.04' && steps.cache-polkadot.outputs.cache-hit != 'true'
+        run: |
+          mkdir -p ~/polkadot-cache
+          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot -o ~/polkadot-cache/polkadot
+          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-execute-worker -o ~/polkadot-cache/polkadot-execute-worker
+          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-prepare-worker -o ~/polkadot-cache/polkadot-prepare-worker
+          curl -sL https://github.com/paritytech/polkadot-sdk/releases/download/${{ env.POLKADOT_VERSION }}/polkadot-parachain -o ~/polkadot-cache/polkadot-parachain
+          chmod +x ~/polkadot-cache/*
 
   ci:
     name: CI on ${{ matrix.os }}
@@ -86,6 +118,24 @@ jobs:
             ~/.cargo/bin/eth-rpc
           key: polkadot-binaries-${{ matrix.os }}-${{ hashFiles('polkadot-sdk/.git') }}
 
+      - name: Restore downloaded Polkadot binaries from cache
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/polkadot-cache/polkadot
+            ~/polkadot-cache/polkadot-execute-worker
+            ~/polkadot-cache/polkadot-prepare-worker
+            ~/polkadot-cache/polkadot-parachain
+          key: polkadot-downloaded-${{ matrix.os }}-${{ env.POLKADOT_VERSION }}
+
+      - name: Install Polkadot binaries
+        run: |
+          sudo cp ~/polkadot-cache/polkadot /usr/local/bin/
+          sudo cp ~/polkadot-cache/polkadot-execute-worker /usr/local/bin/
+          sudo cp ~/polkadot-cache/polkadot-prepare-worker /usr/local/bin/
+          sudo cp ~/polkadot-cache/polkadot-parachain /usr/local/bin/
+          sudo chmod +x /usr/local/bin/polkadot*
+
       - name: Setup Rust toolchain
         uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
@@ -170,6 +220,18 @@ jobs:
       - name: Check resolc version
         run: resolc --version
 
+      - name: Check polkadot version
+        run: polkadot --version
+      
+      - name: Check polkadot-parachain version
+        run: polkadot-parachain --version
+
+      - name: Check polkadot-execute-worker version
+        run: polkadot-execute-worker --version
+      
+      - name: Check polkadot-prepare-worker version
+        run: polkadot-prepare-worker --version
+
       - name: Test Formatting
         run: make format
 

Cargo.toml

@@ -22,7 +22,9 @@ revive-dt-node-pool = { version = "0.1.0", path = "crates/node-pool" }
 revive-dt-report = { version = "0.1.0", path = "crates/report" }
 revive-dt-solc-binaries = { version = "0.1.0", path = "crates/solc-binaries" }
 
+ansi_term = "0.12.1"
 anyhow = "1.0"
+async-stream = { version = "0.3.6" }
 bson = { version = "2.15.0" }
 cacache = { version = "13.1.0" }
 clap = { version = "4", features = ["derive"] }
@@ -73,6 +75,8 @@ revive-solc-json-interface = { git = "https://github.com/paritytech/revive", rev
 revive-common = { git = "https://github.com/paritytech/revive", rev = "3389865af7c3ff6f29a586d82157e8bc573c1a8e" }
 revive-differential = { git = "https://github.com/paritytech/revive", rev = "3389865af7c3ff6f29a586d82157e8bc573c1a8e" }
 
+zombienet-sdk = { git = "https://github.com/paritytech/zombienet-sdk.git", rev = "891f6554354ce466abd496366dbf8b4f82141241" }
+
 [workspace.dependencies.alloy]
 version = "1.0.37"
 default-features = false

crates/common/src/types/identifiers.rs

@@ -39,6 +39,10 @@ pub enum PlatformIdentifier {
     ReviveDevNodePolkavmResolc,
     /// The revive dev node with the REVM backend with the solc compiler.
     ReviveDevNodeRevmSolc,
+    /// A zombienet based Substrate/Polkadot node with the PolkaVM backend with the resolc compiler.
+    ZombienetPolkavmResolc,
+    /// A zombienet based Substrate/Polkadot node with the REVM backend with the solc compiler.
+    ZombienetRevmSolc,
 }
 
 /// An enum of the platform identifiers of all of the platforms supported by this framework.
@@ -95,6 +99,8 @@ pub enum NodeIdentifier {
     Kitchensink,
     /// The revive dev node implementation.
     ReviveDevNode,
+    /// A zombienet spawned nodes
+    Zombienet,
 }
 
 /// An enum representing the identifiers of the supported VMs.

crates/compiler/tests/assets/array_one_element/main.sol

@@ -7,7 +7,10 @@ pragma solidity >=0.6.9;
 import "./callable.sol";
 
 contract Main {
-    function main(uint[1] calldata p1, Callable callable) public returns(uint) {
+    function main(
+        uint[1] calldata p1,
+        Callable callable
+    ) public pure returns (uint) {
         return callable.f(p1);
     }
 }

crates/config/src/lib.rs

@@ -107,6 +107,16 @@ impl AsRef<KurtosisConfiguration> for Context {
     }
 }
 
+impl AsRef<PolkadotParachainConfiguration> for Context {
+    fn as_ref(&self) -> &PolkadotParachainConfiguration {
+        match self {
+            Self::Test(context) => context.as_ref().as_ref(),
+            Self::Benchmark(context) => context.as_ref().as_ref(),
+            Self::ExportJsonSchema => unreachable!(),
+        }
+    }
+}
+
 impl AsRef<KitchensinkConfiguration> for Context {
     fn as_ref(&self) -> &KitchensinkConfiguration {
         match self {
@@ -192,6 +202,18 @@ impl AsRef<ReportConfiguration> for Context {
 
 #[derive(Clone, Debug, Parser, Serialize)]
 pub struct TestExecutionContext {
+    /// The set of platforms that the differential tests should run on.
+    #[arg(
+        short = 'p',
+        long = "platform",
+        default_values = ["geth-evm-solc", "revive-dev-node-polkavm-resolc"]
+    )]
+    pub platforms: Vec<PlatformIdentifier>,
+
+    /// The output format to use for the tool's output.
+    #[arg(short, long, default_value_t = OutputFormat::CargoTestLike)]
+    pub output_format: OutputFormat,
+
     /// The working directory that the program will use for all of the temporary artifacts needed at
     /// runtime.
     ///
@@ -205,14 +227,6 @@ pub struct TestExecutionContext {
     )]
     pub working_directory: WorkingDirectoryConfiguration,
 
-    /// The set of platforms that the differential tests should run on.
-    #[arg(
-        short = 'p',
-        long = "platform",
-        default_values = ["geth-evm-solc", "revive-dev-node-polkavm-resolc"]
-    )]
-    pub platforms: Vec<PlatformIdentifier>,
-
     /// Configuration parameters for the corpus files to use.
     #[clap(flatten, next_help_heading = "Corpus Configuration")]
     pub corpus_configuration: CorpusConfiguration,
@@ -225,6 +239,10 @@ pub struct TestExecutionContext {
     #[clap(flatten, next_help_heading = "Resolc Configuration")]
     pub resolc_configuration: ResolcConfiguration,
 
+    /// Configuration parameters for the Polkadot Parachain.
+    #[clap(flatten, next_help_heading = "Polkadot Parachain Configuration")]
+    pub polkadot_parachain_configuration: PolkadotParachainConfiguration,
+
     /// Configuration parameters for the geth node.
     #[clap(flatten, next_help_heading = "Geth Configuration")]
     pub geth_configuration: GethConfiguration,
@@ -318,6 +336,10 @@ pub struct BenchmarkingContext {
     #[clap(flatten, next_help_heading = "Kitchensink Configuration")]
     pub kitchensink_configuration: KitchensinkConfiguration,
 
+    /// Configuration parameters for the Polkadot Parachain.
+    #[clap(flatten, next_help_heading = "Polkadot Parachain Configuration")]
+    pub polkadot_parachain_configuration: PolkadotParachainConfiguration,
+
     /// Configuration parameters for the Revive Dev Node.
     #[clap(flatten, next_help_heading = "Revive Dev Node Configuration")]
     pub revive_dev_node_configuration: ReviveDevNodeConfiguration,
@@ -379,6 +401,12 @@ impl AsRef<GethConfiguration> for TestExecutionContext {
     }
 }
 
+impl AsRef<PolkadotParachainConfiguration> for TestExecutionContext {
+    fn as_ref(&self) -> &PolkadotParachainConfiguration {
+        &self.polkadot_parachain_configuration
+    }
+}
+
 impl AsRef<KurtosisConfiguration> for TestExecutionContext {
     fn as_ref(&self) -> &KurtosisConfiguration {
         &self.lighthouse_configuration
@@ -475,6 +503,12 @@ impl AsRef<KurtosisConfiguration> for BenchmarkingContext {
     }
 }
 
+impl AsRef<PolkadotParachainConfiguration> for BenchmarkingContext {
+    fn as_ref(&self) -> &PolkadotParachainConfiguration {
+        &self.polkadot_parachain_configuration
+    }
+}
+
 impl AsRef<KitchensinkConfiguration> for BenchmarkingContext {
     fn as_ref(&self) -> &KitchensinkConfiguration {
         &self.kitchensink_configuration
@@ -545,6 +579,30 @@ pub struct ResolcConfiguration {
     pub path: PathBuf,
 }
 
+/// A set of configuration parameters for Polkadot Parachain.
+#[derive(Clone, Debug, Parser, Serialize)]
+pub struct PolkadotParachainConfiguration {
+    /// Specifies the path of the polkadot-parachain node to be used by the tool.
+    ///
+    /// If this is not specified, then the tool assumes that it should use the polkadot-parachain binary
+    /// that's provided in the user's $PATH.
+    #[clap(
+        id = "polkadot-parachain.path",
+        long = "polkadot-parachain.path",
+        default_value = "polkadot-parachain"
+    )]
+    pub path: PathBuf,
+
+    /// The amount of time to wait upon startup before considering that the node timed out.
+    #[clap(
+        id = "polkadot-parachain.start-timeout-ms",
+        long = "polkadot-parachain.start-timeout-ms",
+        default_value = "5000",
+        value_parser = parse_duration
+    )]
+    pub start_timeout_ms: Duration,
+}
+
 /// A set of configuration parameters for Geth.
 #[derive(Clone, Debug, Parser, Serialize)]
 pub struct GethConfiguration {
@@ -626,6 +684,14 @@ pub struct ReviveDevNodeConfiguration {
         value_parser = parse_duration
     )]
     pub start_timeout_ms: Duration,
+
+    /// The consensus to use for the spawned revive-dev-node.
+    #[clap(
+        id = "revive-dev-node.consensus",
+        long = "revive-dev-node.consensus",
+        default_value = "instant-seal"
+    )]
+    pub consensus: String,
 }
 
 /// A set of configuration parameters for the ETH RPC.
@@ -893,4 +959,32 @@ pub enum TestingPlatform {
     Geth,
     /// The kitchensink runtime provides the PolkaVM (PVM) based node implementation.
     Kitchensink,
+    /// A polkadot/Substrate based network
+    Zombienet,
+}
+
+/// The output format to use for the test execution output.
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    Serialize,
+    ValueEnum,
+    EnumString,
+    Display,
+    AsRefStr,
+    IntoStaticStr,
+)]
+#[strum(serialize_all = "kebab-case")]
+pub enum OutputFormat {
+    /// The legacy format that was used in the past for the output.
+    Legacy,
+
+    /// An output format that looks heavily resembles the output from `cargo test`.
+    CargoTestLike,
 }

crates/core/Cargo.toml

@@ -21,6 +21,7 @@ revive-dt-node = { workspace = true }
 revive-dt-node-interaction = { workspace = true }
 revive-dt-report = { workspace = true }
 
+ansi_term = { workspace = true }
 alloy = { workspace = true }
 anyhow = { workspace = true }
 bson = { workspace = true }

crates/core/src/differential_benchmarks/driver.rs

@@ -22,6 +22,7 @@ use alloy::{
     },
 };
 use anyhow::{Context as _, Result, bail};
+use futures::TryFutureExt;
 use indexmap::IndexMap;
 use revive_dt_common::{
     futures::{PollingWaitBehavior, poll},
@@ -35,7 +36,7 @@ use revive_dt_format::{
     },
     traits::{ResolutionContext, ResolverApi},
 };
-use tokio::sync::{Mutex, mpsc::UnboundedSender};
+use tokio::sync::{Mutex, OnceCell, mpsc::UnboundedSender};
 use tracing::{Instrument, Span, debug, error, field::display, info, info_span, instrument};
 
 use crate::{
@@ -123,13 +124,7 @@ where
                 &self.platform_information.reporter,
             )
             .await
-            .inspect_err(|err| {
-                error!(
-                    ?err,
-                    platform_identifier = %self.platform_information.platform.platform_identifier(),
-                    "Pre-linking compilation failed"
-                )
-            })
+            .inspect_err(|err| error!(?err, "Pre-linking compilation failed"))
             .context("Failed to produce the pre-linking compiled contracts")?;
 
         let mut deployed_libraries = None::<HashMap<_, _>>;
@@ -137,13 +132,7 @@ where
             .test_definition
             .metadata
             .contract_sources()
-            .inspect_err(|err| {
-                error!(
-                    ?err,
-                    platform_identifier = %self.platform_information.platform.platform_identifier(),
-                    "Failed to retrieve contract sources from metadata"
-                )
-            })
+            .inspect_err(|err| error!(?err, "Failed to retrieve contract sources from metadata"))
             .context("Failed to get the contract instances from the metadata file")?;
         for library_instance in self
             .test_definition
@@ -191,20 +180,19 @@ where
                 TransactionRequest::default().from(deployer_address),
                 code,
             );
-            let receipt = self.execute_transaction(tx).await.inspect_err(|err| {
-                error!(
-                    ?err,
-                    %library_instance,
-                    platform_identifier = %self.platform_information.platform.platform_identifier(),
-                    "Failed to deploy the library"
-                )
-            })?;
+            let receipt = self
+                .execute_transaction(tx)
+                .and_then(|(_, receipt_fut)| receipt_fut)
+                .await
+                .inspect_err(|err| {
+                    error!(
+                        ?err,
+                        %library_instance,
+                        "Failed to deploy the library"
+                    )
+                })?;
 
-            debug!(
-                ?library_instance,
-                platform_identifier = %self.platform_information.platform.platform_identifier(),
-                "Deployed library"
-            );
+            debug!(?library_instance, "Deployed library");
 
             let library_address = receipt
                 .contract_address
@@ -227,13 +215,7 @@ where
                 &self.platform_information.reporter,
             )
             .await
-            .inspect_err(|err| {
-                error!(
-                    ?err,
-                    platform_identifier = %self.platform_information.platform.platform_identifier(),
-                    "Post-linking compilation failed"
-                )
-            })
+            .inspect_err(|err| error!(?err, "Post-linking compilation failed"))
             .context("Failed to compile the post-link contracts")?;
 
         self.execution_state = ExecutionState::new(
@@ -269,7 +251,6 @@ where
         skip_all,
         fields(
             driver_id = self.driver_id,
-            platform_identifier = %self.platform_information.platform.platform_identifier(),
             %step_path,
         ),
         err(Debug),
@@ -305,15 +286,11 @@ where
             .handle_function_call_contract_deployment(step)
             .await
             .context("Failed to deploy contracts for the function call step")?;
-        let execution_receipt = self
+        let transaction_hash = self
             .handle_function_call_execution(step, deployment_receipts)
             .await
             .context("Failed to handle the function call execution")?;
-        let tracing_result = self
-            .handle_function_call_call_frame_tracing(execution_receipt.transaction_hash)
-            .await
-            .context("Failed to handle the function call call frame tracing")?;
-        self.handle_function_call_variable_assignment(step, &tracing_result)
+        self.handle_function_call_variable_assignment(step, transaction_hash)
             .await
             .context("Failed to handle function call variable assignment")?;
         Ok(1)
@@ -367,18 +344,19 @@ where
         &mut self,
         step: &FunctionCallStep,
         mut deployment_receipts: HashMap<ContractInstance, TransactionReceipt>,
-    ) -> Result<TransactionReceipt> {
+    ) -> Result<TxHash> {
         match step.method {
             // This step was already executed when `handle_step` was called. We just need to
             // lookup the transaction receipt in this case and continue on.
             Method::Deployer => deployment_receipts
                 .remove(&step.instance)
-                .context("Failed to find deployment receipt for constructor call"),
+                .context("Failed to find deployment receipt for constructor call")
+                .map(|receipt| receipt.transaction_hash),
             Method::Fallback | Method::FunctionName(_) => {
                 let tx = step
                     .as_transaction(self.resolver.as_ref(), self.default_resolution_context())
                     .await?;
-                self.execute_transaction(tx).await
+                Ok(self.execute_transaction(tx).await?.0)
             }
         }
     }
@@ -417,15 +395,19 @@ where
     async fn handle_function_call_variable_assignment(
         &mut self,
         step: &FunctionCallStep,
-        tracing_result: &CallFrame,
+        tx_hash: TxHash,
     ) -> Result<()> {
         let Some(ref assignments) = step.variable_assignments else {
             return Ok(());
         };
 
         // Handling the return data variable assignments.
+        let callframe = OnceCell::new();
         for (variable_name, output_word) in assignments.return_data.iter().zip(
-            tracing_result
+            callframe
+                .get_or_try_init(|| self.handle_function_call_call_frame_tracing(tx_hash))
+                .await
+                .context("Failed to get the callframe trace for transaction")?
                 .output
                 .as_ref()
                 .unwrap_or_default()
@@ -547,7 +529,6 @@ where
         skip_all,
         fields(
             driver_id = self.driver_id,
-            platform_identifier = %self.platform_information.platform.platform_identifier(),
             %contract_instance,
             %deployer
         ),
@@ -590,7 +571,6 @@ where
     skip_all,
         fields(
             driver_id = self.driver_id,
-            platform_identifier = %self.platform_information.platform.platform_identifier(),
             %contract_instance,
             %deployer
         ),
@@ -660,7 +640,11 @@ where
             TransactionBuilder::<Ethereum>::with_deploy_code(tx, code)
         };
 
-        let receipt = match self.execute_transaction(tx).await {
+        let receipt = match self
+            .execute_transaction(tx)
+            .and_then(|(_, receipt_fut)| receipt_fut)
+            .await
+        {
             Ok(receipt) => receipt,
             Err(error) => {
                 tracing::error!(?error, "Contract deployment transaction failed.");
@@ -734,7 +718,7 @@ where
     async fn execute_transaction(
         &self,
         transaction: TransactionRequest,
-    ) -> anyhow::Result<TransactionReceipt> {
+    ) -> anyhow::Result<(TxHash, impl Future<Output = Result<TransactionReceipt>>)> {
         let node = self.platform_information.node;
         let transaction_hash = node
             .submit_transaction(transaction)
@@ -747,24 +731,28 @@ where
             .send(WatcherEvent::SubmittedTransaction { transaction_hash })
             .context("Failed to send the transaction hash to the watcher")?;
 
-        info!("Starting to poll for transaction receipt");
-        poll(
-            Duration::from_secs(30 * 60),
-            PollingWaitBehavior::Constant(Duration::from_secs(1)),
-            || {
-                async move {
-                    match node.get_receipt(transaction_hash).await {
-                        Ok(receipt) => {
-                            info!("Polling succeeded, receipt found");
-                            Ok(ControlFlow::Break(receipt))
+        Ok((transaction_hash, async move {
+            info!("Starting to poll for transaction receipt");
+            poll(
+                Duration::from_secs(30 * 60),
+                PollingWaitBehavior::Constant(Duration::from_secs(1)),
+                || {
+                    async move {
+                        match node.get_receipt(transaction_hash).await {
+                            Ok(receipt) => {
+                                info!("Polling succeeded, receipt found");
+                                Ok(ControlFlow::Break(receipt))
+                            }
+                            Err(_) => Ok(ControlFlow::Continue(())),
                         }
-                        Err(_) => Ok(ControlFlow::Continue(())),
                     }
-                }
-                .instrument(info_span!("Polling for receipt"))
-            },
-        )
-        .await
+                    .instrument(info_span!("Polling for receipt"))
+                },
+            )
+            .instrument(info_span!("Polling for receipt", %transaction_hash))
+            .await
+            .inspect(|_| info!("Found the transaction receipt"))
+        }))
     }
     // endregion:Transaction Execution
 }

crates/core/src/differential_benchmarks/entry_point.rs

@@ -8,7 +8,7 @@ use revive_dt_common::types::PrivateKeyAllocator;
 use revive_dt_core::Platform;
 use revive_dt_format::steps::{Step, StepIdx, StepPath};
 use tokio::sync::Mutex;
-use tracing::{error, info, info_span, instrument, warn};
+use tracing::{Instrument, error, info, info_span, instrument, warn};
 
 use revive_dt_config::{BenchmarkingContext, Context};
 use revive_dt_report::Reporter;
@@ -159,12 +159,15 @@ pub async fn handle_differential_benchmarks(
 
             futures::future::try_join(
                 watcher.run(),
-                driver.execute_all().inspect(|_| {
-                    info!("All transactions submitted - driver completed execution");
-                    watcher_tx
-                        .send(WatcherEvent::AllTransactionsSubmitted)
-                        .unwrap()
-                }),
+                driver
+                    .execute_all()
+                    .instrument(info_span!("Executing Benchmarks", %platform_identifier))
+                    .inspect(|_| {
+                        info!("All transactions submitted - driver completed execution");
+                        watcher_tx
+                            .send(WatcherEvent::AllTransactionsSubmitted)
+                            .unwrap()
+                    }),
             )
             .await
             .context("Failed to run the driver and executor")

crates/core/src/differential_benchmarks/watcher.rs

@@ -104,6 +104,10 @@ impl Watcher {
             async move {
                 let mut mined_blocks_information = Vec::new();
 
+                // region:TEMPORARY
+                eprintln!("Watcher information for {}", self.platform_identifier);
+                eprintln!("block_number,block_timestamp,mined_gas,block_gas_limit,tx_count");
+                // endregion:TEMPORARY
                 while let Some(block) = blocks_information_stream.next().await {
                     // If the block number is equal to or less than the last block before the
                     // repetition then we ignore it and continue on to the next block.
@@ -118,8 +122,9 @@ impl Watcher {
                     }
 
                     info!(
-                        remaining_transactions = watch_for_transaction_hashes.read().await.len(),
+                        block_number = block.block_number,
                         block_tx_count = block.transaction_hashes.len(),
+                        remaining_transactions = watch_for_transaction_hashes.read().await.len(),
                         "Observed a block"
                     );
 
@@ -131,6 +136,20 @@ impl Watcher {
                         watch_for_transaction_hashes.remove(tx_hash);
                     }
 
+                    // region:TEMPORARY
+                    // TODO: The following core is TEMPORARY and will be removed once we have proper
+                    // reporting in place and then it can be removed. This serves as as way of doing
+                    // some very simple reporting for the time being.
+                    eprintln!(
+                        "\"{}\",\"{}\",\"{}\",\"{}\",\"{}\"",
+                        block.block_number,
+                        block.block_timestamp,
+                        block.mined_gas,
+                        block.block_gas_limit,
+                        block.transaction_hashes.len()
+                    );
+                    // endregion:TEMPORARY
+
                     mined_blocks_information.push(block);
                 }
 
@@ -139,41 +158,10 @@ impl Watcher {
             }
         };
 
-        let (_, mined_blocks_information) =
+        let (_, _) =
             futures::future::join(watcher_event_watching_task, block_information_watching_task)
                 .await;
 
-        // region:TEMPORARY
-        {
-            // TODO: The following core is TEMPORARY and will be removed once we have proper
-            // reporting in place and then it can be removed. This serves as as way of doing some
-            // very simple reporting for the time being.
-            use std::io::Write;
-
-            let mut stderr = std::io::stderr().lock();
-            writeln!(
-                stderr,
-                "Watcher information for {}",
-                self.platform_identifier
-            )?;
-            writeln!(
-                stderr,
-                "block_number,block_timestamp,mined_gas,block_gas_limit,tx_count"
-            )?;
-            for block in mined_blocks_information {
-                writeln!(
-                    stderr,
-                    "{},{},{},{},{}",
-                    block.block_number,
-                    block.block_timestamp,
-                    block.mined_gas,
-                    block.block_gas_limit,
-                    block.transaction_hashes.len()
-                )?
-            }
-        }
-        // endregion:TEMPORARY
-
         Ok(())
     }
 }

crates/core/src/differential_tests/driver.rs

@@ -31,7 +31,7 @@ use revive_dt_format::{
     traits::ResolutionContext,
 };
 use tokio::sync::Mutex;
-use tracing::{debug, error, info, instrument};
+use tracing::{error, info, instrument};
 
 use crate::{
     differential_tests::ExecutionState,
@@ -109,7 +109,6 @@ impl<'a> Driver<'a, StepsIterator> {
     // endregion:Constructors
 
     // region:Execution
-    #[instrument(level = "info", skip_all)]
     pub async fn execute_all(mut self) -> Result<usize> {
         let platform_drivers = std::mem::take(&mut self.platform_drivers);
         let results = futures::future::try_join_all(
@@ -218,8 +217,6 @@ where
             .flatten()
             .flat_map(|(_, map)| map.values())
         {
-            debug!(%library_instance, "Deploying Library Instance");
-
             let ContractPathAndIdent {
                 contract_source_path: library_source_path,
                 contract_ident: library_ident,
@@ -268,12 +265,6 @@ where
                     )
                 })?;
 
-            debug!(
-                ?library_instance,
-                platform_identifier = %platform_information.platform.platform_identifier(),
-                "Deployed library"
-            );
-
             let library_address = receipt
                 .contract_address
                 .expect("Failed to deploy the library");
@@ -312,7 +303,6 @@ where
     // endregion:Constructors & Initialization
 
     // region:Step Handling
-    #[instrument(level = "info", skip_all)]
     pub async fn execute_all(mut self) -> Result<usize> {
         while let Some(result) = self.execute_next_step().await {
             result?
@@ -320,14 +310,6 @@ where
         Ok(self.steps_executed)
     }
 
-    #[instrument(
-        level = "info",
-        skip_all,
-        fields(
-            platform_identifier = %self.platform_information.platform.platform_identifier(),
-            node_id = self.platform_information.node.id(),
-        ),
-    )]
     pub async fn execute_next_step(&mut self) -> Option<Result<()>> {
         let (step_path, step) = self.steps_iterator.next()?;
         info!(%step_path, "Executing Step");
@@ -344,6 +326,7 @@ where
         skip_all,
         fields(
             platform_identifier = %self.platform_information.platform.platform_identifier(),
+            node_id = self.platform_information.node.id(),
             %step_path,
         ),
         err(Debug),
@@ -402,6 +385,7 @@ where
         Ok(1)
     }
 
+    #[instrument(level = "debug", skip_all)]
     async fn handle_function_call_contract_deployment(
         &mut self,
         step: &FunctionCallStep,
@@ -447,6 +431,7 @@ where
         Ok(receipts)
     }
 
+    #[instrument(level = "debug", skip_all)]
     async fn handle_function_call_execution(
         &mut self,
         step: &FunctionCallStep,
@@ -470,14 +455,12 @@ where
                     }
                 };
 
-                match self.platform_information.node.execute_transaction(tx).await {
-                    Ok(receipt) => Ok(receipt),
-                    Err(err) => Err(err),
-                }
+                self.platform_information.node.execute_transaction(tx).await
             }
         }
     }
 
+    #[instrument(level = "debug", skip_all)]
     async fn handle_function_call_call_frame_tracing(
         &mut self,
         tx_hash: TxHash,
@@ -509,6 +492,7 @@ where
             })
     }
 
+    #[instrument(level = "debug", skip_all)]
     async fn handle_function_call_variable_assignment(
         &mut self,
         step: &FunctionCallStep,
@@ -541,6 +525,7 @@ where
         Ok(())
     }
 
+    #[instrument(level = "debug", skip_all)]
     async fn handle_function_call_assertions(
         &mut self,
         step: &FunctionCallStep,
@@ -583,6 +568,7 @@ where
             .await
     }
 
+    #[instrument(level = "debug", skip_all)]
     async fn handle_function_call_assertion_item(
         &self,
         receipt: &TransactionReceipt,
@@ -865,7 +851,6 @@ where
         level = "info",
         skip_all,
         fields(
-            platform_identifier = %self.platform_information.platform.platform_identifier(),
             %contract_instance,
             %deployer
         ),
@@ -907,7 +892,6 @@ where
     level = "info",
     skip_all,
         fields(
-            platform_identifier = %self.platform_information.platform.platform_identifier(),
             %contract_instance,
             %deployer
         ),

crates/core/src/differential_tests/entry_point.rs

@@ -1,20 +1,21 @@
 //! The main entry point into differential testing.
 
 use std::{
-    collections::BTreeMap,
+    collections::{BTreeMap, BTreeSet},
     io::{BufWriter, Write, stderr},
     sync::Arc,
-    time::Instant,
+    time::{Duration, Instant},
 };
 
+use ansi_term::{ANSIStrings, Color};
 use anyhow::Context as _;
 use futures::{FutureExt, StreamExt};
 use revive_dt_common::types::PrivateKeyAllocator;
 use revive_dt_core::Platform;
-use tokio::sync::Mutex;
+use tokio::sync::{Mutex, RwLock, Semaphore};
 use tracing::{Instrument, error, info, info_span, instrument};
 
-use revive_dt_config::{Context, TestExecutionContext};
+use revive_dt_config::{Context, OutputFormat, TestExecutionContext};
 use revive_dt_report::{Reporter, ReporterEvent, TestCaseStatus};
 
 use crate::{
@@ -101,20 +102,40 @@ pub async fn handle_differential_tests(
     )));
 
     // Creating the driver and executing all of the steps.
-    let driver_task = futures::future::join_all(test_definitions.iter().map(|test_definition| {
-        let private_key_allocator = private_key_allocator.clone();
-        let cached_compiler = cached_compiler.clone();
-        let mode = test_definition.mode.clone();
-        let span = info_span!(
-            "Executing Test Case",
-            metadata_file_path = %test_definition.metadata_file_path.display(),
-            case_idx = %test_definition.case_idx,
-            mode = %mode
-        );
-        async move {
-            let driver =
-                match Driver::new_root(test_definition, private_key_allocator, &cached_compiler)
-                    .await
+    let semaphore = context
+        .concurrency_configuration
+        .concurrency_limit()
+        .map(Semaphore::new)
+        .map(Arc::new);
+    let running_task_list = Arc::new(RwLock::new(BTreeSet::<usize>::new()));
+    let driver_task = futures::future::join_all(test_definitions.iter().enumerate().map(
+        |(test_id, test_definition)| {
+            let running_task_list = running_task_list.clone();
+            let semaphore = semaphore.clone();
+
+            let private_key_allocator = private_key_allocator.clone();
+            let cached_compiler = cached_compiler.clone();
+            let mode = test_definition.mode.clone();
+            let span = info_span!(
+                "Executing Test Case",
+                test_id,
+                metadata_file_path = %test_definition.metadata_file_path.display(),
+                case_idx = %test_definition.case_idx,
+                mode = %mode,
+            );
+            async move {
+                let permit = match semaphore.as_ref() {
+                    Some(semaphore) => Some(semaphore.acquire().await.expect("Can't fail")),
+                    None => None,
+                };
+
+                running_task_list.write().await.insert(test_id);
+                let driver = match Driver::new_root(
+                    test_definition,
+                    private_key_allocator,
+                    &cached_compiler,
+                )
+                .await
                 {
                     Ok(driver) => driver,
                     Err(error) => {
@@ -123,35 +144,52 @@ pub async fn handle_differential_tests(
                             .report_test_failed_event(format!("{error:#}"))
                             .expect("Can't fail");
                         error!("Test Case Failed");
+                        drop(permit);
+                        running_task_list.write().await.remove(&test_id);
                         return;
                     }
                 };
-            info!("Created the driver for the test case");
+                info!("Created the driver for the test case");
 
-            match driver.execute_all().await {
-                Ok(steps_executed) => test_definition
-                    .reporter
-                    .report_test_succeeded_event(steps_executed)
-                    .expect("Can't fail"),
-                Err(error) => {
-                    test_definition
+                match driver.execute_all().await {
+                    Ok(steps_executed) => test_definition
                         .reporter
-                        .report_test_failed_event(format!("{error:#}"))
-                        .expect("Can't fail");
-                    error!("Test Case Failed");
-                }
-            };
-            info!("Finished the execution of the test case")
-        }
-        .instrument(span)
-    }))
+                        .report_test_succeeded_event(steps_executed)
+                        .expect("Can't fail"),
+                    Err(error) => {
+                        test_definition
+                            .reporter
+                            .report_test_failed_event(format!("{error:#}"))
+                            .expect("Can't fail");
+                        error!("Test Case Failed");
+                    }
+                };
+                info!("Finished the execution of the test case");
+                drop(permit);
+                running_task_list.write().await.remove(&test_id);
+            }
+            .instrument(span)
+        },
+    ))
     .inspect(|_| {
         info!("Finished executing all test cases");
         reporter_clone
             .report_completion_event()
             .expect("Can't fail")
     });
-    let cli_reporting_task = start_cli_reporting_task(reporter);
+    let cli_reporting_task = start_cli_reporting_task(context.output_format, reporter);
+
+    tokio::task::spawn(async move {
+        loop {
+            let remaining_tasks = running_task_list.read().await;
+            info!(
+                count = remaining_tasks.len(),
+                ?remaining_tasks,
+                "Remaining Tests"
+            );
+            tokio::time::sleep(Duration::from_secs(10)).await
+        }
+    });
 
     futures::future::join(driver_task, cli_reporting_task).await;
 
@@ -159,21 +197,15 @@ pub async fn handle_differential_tests(
 }
 
 #[allow(irrefutable_let_patterns, clippy::uninlined_format_args)]
-async fn start_cli_reporting_task(reporter: Reporter) {
+async fn start_cli_reporting_task(output_format: OutputFormat, reporter: Reporter) {
     let mut aggregator_events_rx = reporter.subscribe().await.expect("Can't fail");
     drop(reporter);
 
     let start = Instant::now();
 
-    const GREEN: &str = "\x1B[32m";
-    const RED: &str = "\x1B[31m";
-    const GREY: &str = "\x1B[90m";
-    const COLOR_RESET: &str = "\x1B[0m";
-    const BOLD: &str = "\x1B[1m";
-    const BOLD_RESET: &str = "\x1B[22m";
-
-    let mut number_of_successes = 0;
-    let mut number_of_failures = 0;
+    let mut global_success_count = 0;
+    let mut global_failure_count = 0;
+    let mut global_ignore_count = 0;
 
     let mut buf = BufWriter::new(stderr());
     while let Ok(event) = aggregator_events_rx.recv().await {
@@ -186,55 +218,125 @@ async fn start_cli_reporting_task(reporter: Reporter) {
             continue;
         };
 
-        let _ = writeln!(buf, "{} - {}", mode, metadata_file_path.display());
-        for (case_idx, case_status) in case_status.into_iter() {
-            let _ = write!(buf, "\tCase Index {case_idx:>3}: ");
-            let _ = match case_status {
-                TestCaseStatus::Succeeded { steps_executed } => {
-                    number_of_successes += 1;
-                    writeln!(
-                        buf,
-                        "{}{}Case Succeeded{} - Steps Executed: {}{}",
-                        GREEN, BOLD, BOLD_RESET, steps_executed, COLOR_RESET
-                    )
+        match output_format {
+            OutputFormat::Legacy => {
+                let _ = writeln!(buf, "{} - {}", mode, metadata_file_path.display());
+                for (case_idx, case_status) in case_status.into_iter() {
+                    let _ = write!(buf, "\tCase Index {case_idx:>3}: ");
+                    let _ = match case_status {
+                        TestCaseStatus::Succeeded { steps_executed } => {
+                            global_success_count += 1;
+                            writeln!(
+                                buf,
+                                "{}",
+                                ANSIStrings(&[
+                                    Color::Green.bold().paint("Case Succeeded"),
+                                    Color::Green
+                                        .paint(format!(" - Steps Executed: {steps_executed}")),
+                                ])
+                            )
+                        }
+                        TestCaseStatus::Failed { reason } => {
+                            global_failure_count += 1;
+                            writeln!(
+                                buf,
+                                "{}",
+                                ANSIStrings(&[
+                                    Color::Red.bold().paint("Case Failed"),
+                                    Color::Red.paint(format!(" - Reason: {}", reason.trim())),
+                                ])
+                            )
+                        }
+                        TestCaseStatus::Ignored { reason, .. } => {
+                            global_ignore_count += 1;
+                            writeln!(
+                                buf,
+                                "{}",
+                                ANSIStrings(&[
+                                    Color::Yellow.bold().paint("Case Ignored"),
+                                    Color::Yellow.paint(format!(" - Reason: {}", reason.trim())),
+                                ])
+                            )
+                        }
+                    };
                 }
-                TestCaseStatus::Failed { reason } => {
-                    number_of_failures += 1;
-                    writeln!(
-                        buf,
-                        "{}{}Case Failed{} - Reason: {}{}",
-                        RED,
-                        BOLD,
-                        BOLD_RESET,
-                        reason.trim(),
-                        COLOR_RESET,
-                    )
-                }
-                TestCaseStatus::Ignored { reason, .. } => writeln!(
+                let _ = writeln!(buf);
+            }
+            OutputFormat::CargoTestLike => {
+                writeln!(
                     buf,
-                    "{}{}Case Ignored{} - Reason: {}{}",
-                    GREY,
-                    BOLD,
-                    BOLD_RESET,
-                    reason.trim(),
-                    COLOR_RESET,
-                ),
-            };
+                    "\t{} {} - {}\n",
+                    Color::Green.paint("Running"),
+                    metadata_file_path.display(),
+                    mode
+                )
+                .unwrap();
+
+                let mut success_count = 0;
+                let mut failure_count = 0;
+                let mut ignored_count = 0;
+                writeln!(buf, "running {} tests", case_status.len()).unwrap();
+                for (case_idx, case_result) in case_status.iter() {
+                    let status = match case_result {
+                        TestCaseStatus::Succeeded { .. } => {
+                            success_count += 1;
+                            global_success_count += 1;
+                            Color::Green.paint("ok")
+                        }
+                        TestCaseStatus::Failed { reason } => {
+                            failure_count += 1;
+                            global_failure_count += 1;
+                            Color::Red.paint(format!("FAILED, {reason}"))
+                        }
+                        TestCaseStatus::Ignored { reason, .. } => {
+                            ignored_count += 1;
+                            global_ignore_count += 1;
+                            Color::Yellow.paint(format!("ignored, {reason:?}"))
+                        }
+                    };
+                    writeln!(buf, "test case_idx_{} ... {}", case_idx, status).unwrap();
+                }
+                writeln!(buf).unwrap();
+
+                let status = if failure_count > 0 {
+                    Color::Red.paint("FAILED")
+                } else {
+                    Color::Green.paint("ok")
+                };
+                writeln!(
+                    buf,
+                    "test result: {}. {} passed; {} failed; {} ignored",
+                    status, success_count, failure_count, ignored_count,
+                )
+                .unwrap();
+                writeln!(buf).unwrap()
+            }
         }
-        let _ = writeln!(buf);
     }
 
     // Summary at the end.
-    let _ = writeln!(
-        buf,
-        "{} cases: {}{}{} cases succeeded, {}{}{} cases failed in {} seconds",
-        number_of_successes + number_of_failures,
-        GREEN,
-        number_of_successes,
-        COLOR_RESET,
-        RED,
-        number_of_failures,
-        COLOR_RESET,
-        start.elapsed().as_secs()
-    );
+    match output_format {
+        OutputFormat::Legacy => {
+            writeln!(
+                buf,
+                "{} cases: {} cases succeeded, {} cases failed in {} seconds",
+                global_success_count + global_failure_count + global_ignore_count,
+                Color::Green.paint(global_success_count.to_string()),
+                Color::Red.paint(global_failure_count.to_string()),
+                start.elapsed().as_secs()
+            )
+            .unwrap();
+        }
+        OutputFormat::CargoTestLike => {
+            writeln!(
+                buf,
+                "run finished. {} passed; {} failed; {} ignored; finished in {}s",
+                global_success_count,
+                global_failure_count,
+                global_ignore_count,
+                start.elapsed().as_secs()
+            )
+            .unwrap();
+        }
+    }
 }

crates/core/src/helpers/cached_compiler.rs

@@ -201,7 +201,7 @@ async fn compile_contracts(
     // Puts a limit on how many compilations we can perform at any given instance which helps us
     // with some of the errors we've been seeing with high concurrency on MacOS (we have not tried
     // it on Linux so we don't know if these issues also persist there or not.)
-    static SPAWN_GATE: LazyLock<Semaphore> = LazyLock::new(|| Semaphore::new(100));
+    static SPAWN_GATE: LazyLock<Semaphore> = LazyLock::new(|| Semaphore::new(5));
     let _permit = SPAWN_GATE.acquire().await?;
 
     let all_sources_in_dir = FilesWithExtensionIterator::new(metadata_directory.as_ref())

crates/core/src/lib.rs

@@ -16,7 +16,7 @@ use revive_dt_config::*;
 use revive_dt_node::{
     Node, node_implementations::geth::GethNode,
     node_implementations::lighthouse_geth::LighthouseGethNode,
-    node_implementations::substrate::SubstrateNode,
+    node_implementations::substrate::SubstrateNode, node_implementations::zombienet::ZombienetNode,
 };
 use revive_dt_node_interaction::EthereumNode;
 use tracing::info;
@@ -184,6 +184,7 @@ impl Platform for KitchensinkPolkavmResolcPlatform {
             let node = SubstrateNode::new(
                 kitchensink_path,
                 SubstrateNode::KITCHENSINK_EXPORT_CHAINSPEC_COMMAND,
+                None,
                 context,
             );
             let node = spawn_node(node, genesis)?;
@@ -236,6 +237,7 @@ impl Platform for KitchensinkRevmSolcPlatform {
             let node = SubstrateNode::new(
                 kitchensink_path,
                 SubstrateNode::KITCHENSINK_EXPORT_CHAINSPEC_COMMAND,
+                None,
                 context,
             );
             let node = spawn_node(node, genesis)?;
@@ -280,14 +282,17 @@ impl Platform for ReviveDevNodePolkavmResolcPlatform {
         context: Context,
     ) -> anyhow::Result<JoinHandle<anyhow::Result<Box<dyn EthereumNode + Send + Sync>>>> {
         let genesis_configuration = AsRef::<GenesisConfiguration>::as_ref(&context);
-        let revive_dev_node_path = AsRef::<ReviveDevNodeConfiguration>::as_ref(&context)
-            .path
-            .clone();
+        let revive_dev_node_configuration = AsRef::<ReviveDevNodeConfiguration>::as_ref(&context);
+
+        let revive_dev_node_path = revive_dev_node_configuration.path.clone();
+        let revive_dev_node_consensus = revive_dev_node_configuration.consensus.clone();
+
         let genesis = genesis_configuration.genesis()?.clone();
         Ok(thread::spawn(move || {
             let node = SubstrateNode::new(
                 revive_dev_node_path,
                 SubstrateNode::REVIVE_DEV_NODE_EXPORT_CHAINSPEC_COMMAND,
+                Some(revive_dev_node_consensus),
                 context,
             );
             let node = spawn_node(node, genesis)?;
@@ -332,14 +337,17 @@ impl Platform for ReviveDevNodeRevmSolcPlatform {
         context: Context,
     ) -> anyhow::Result<JoinHandle<anyhow::Result<Box<dyn EthereumNode + Send + Sync>>>> {
         let genesis_configuration = AsRef::<GenesisConfiguration>::as_ref(&context);
-        let revive_dev_node_path = AsRef::<ReviveDevNodeConfiguration>::as_ref(&context)
-            .path
-            .clone();
+        let revive_dev_node_configuration = AsRef::<ReviveDevNodeConfiguration>::as_ref(&context);
+
+        let revive_dev_node_path = revive_dev_node_configuration.path.clone();
+        let revive_dev_node_consensus = revive_dev_node_configuration.consensus.clone();
+
         let genesis = genesis_configuration.genesis()?.clone();
         Ok(thread::spawn(move || {
             let node = SubstrateNode::new(
                 revive_dev_node_path,
                 SubstrateNode::REVIVE_DEV_NODE_EXPORT_CHAINSPEC_COMMAND,
+                Some(revive_dev_node_consensus),
                 context,
             );
             let node = spawn_node(node, genesis)?;
@@ -359,6 +367,102 @@ impl Platform for ReviveDevNodeRevmSolcPlatform {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
+pub struct ZombienetPolkavmResolcPlatform;
+
+impl Platform for ZombienetPolkavmResolcPlatform {
+    fn platform_identifier(&self) -> PlatformIdentifier {
+        PlatformIdentifier::ZombienetPolkavmResolc
+    }
+
+    fn node_identifier(&self) -> NodeIdentifier {
+        NodeIdentifier::Zombienet
+    }
+
+    fn vm_identifier(&self) -> VmIdentifier {
+        VmIdentifier::PolkaVM
+    }
+
+    fn compiler_identifier(&self) -> CompilerIdentifier {
+        CompilerIdentifier::Resolc
+    }
+
+    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 polkadot_parachain_path = AsRef::<PolkadotParachainConfiguration>::as_ref(&context)
+            .path
+            .clone();
+        let genesis = genesis_configuration.genesis()?.clone();
+        Ok(thread::spawn(move || {
+            let node = ZombienetNode::new(polkadot_parachain_path, context);
+            let node = spawn_node(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 = Resolc::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 ZombienetRevmSolcPlatform;
+
+impl Platform for ZombienetRevmSolcPlatform {
+    fn platform_identifier(&self) -> PlatformIdentifier {
+        PlatformIdentifier::ZombienetRevmSolc
+    }
+
+    fn node_identifier(&self) -> NodeIdentifier {
+        NodeIdentifier::Zombienet
+    }
+
+    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 polkadot_parachain_path = AsRef::<PolkadotParachainConfiguration>::as_ref(&context)
+            .path
+            .clone();
+        let genesis = genesis_configuration.genesis()?.clone();
+        Ok(thread::spawn(move || {
+            let node = ZombienetNode::new(polkadot_parachain_path, context);
+            let node = spawn_node(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>)
+        })
+    }
+}
+
 impl From<PlatformIdentifier> for Box<dyn Platform> {
     fn from(value: PlatformIdentifier) -> Self {
         match value {
@@ -378,6 +482,10 @@ impl From<PlatformIdentifier> for Box<dyn Platform> {
             PlatformIdentifier::ReviveDevNodeRevmSolc => {
                 Box::new(ReviveDevNodeRevmSolcPlatform) as Box<_>
             }
+            PlatformIdentifier::ZombienetPolkavmResolc => {
+                Box::new(ZombienetPolkavmResolcPlatform) as Box<_>
+            }
+            PlatformIdentifier::ZombienetRevmSolc => Box::new(ZombienetRevmSolcPlatform) as Box<_>,
         }
     }
 }
@@ -401,6 +509,10 @@ impl From<PlatformIdentifier> for &dyn Platform {
             PlatformIdentifier::ReviveDevNodeRevmSolc => {
                 &ReviveDevNodeRevmSolcPlatform as &dyn Platform
             }
+            PlatformIdentifier::ZombienetPolkavmResolc => {
+                &ZombienetPolkavmResolcPlatform as &dyn Platform
+            }
+            PlatformIdentifier::ZombienetRevmSolc => &ZombienetRevmSolcPlatform as &dyn Platform,
         }
     }
 }

crates/node/Cargo.toml

@@ -11,6 +11,7 @@ rust-version.workspace = true
 [dependencies]
 anyhow = { workspace = true }
 alloy = { workspace = true }
+async-stream = { workspace = true }
 futures = { workspace = true }
 tracing = { workspace = true }
 tower = { workspace = true }
@@ -29,6 +30,7 @@ serde_yaml_ng = { workspace = true }
 
 sp-core = { workspace = true }
 sp-runtime = { workspace = true }
+zombienet-sdk = { workspace = true }
 
 [dev-dependencies]
 temp-dir = { workspace = true }

crates/node/src/node_implementations/common/chainspec.rs

@@ -0,0 +1,193 @@
+use alloy::{
+    genesis::{Genesis, GenesisAccount},
+    network::{Ethereum, NetworkWallet},
+    primitives::{Address, U256},
+};
+use anyhow::{Context, Result};
+use serde_json::{Value as JsonValue, json};
+use sp_core::crypto::Ss58Codec;
+use sp_runtime::AccountId32;
+use std::{fs::File, path::Path, process::Command};
+
+pub fn export_and_patch_chainspec_json(
+    binary_path: &Path,
+    export_command: &str,
+    chain_arg: &str,
+    output_path: &Path,
+    genesis: &mut Genesis,
+    wallet: &impl NetworkWallet<Ethereum>,
+    initial_balance: u128,
+) -> Result<()> {
+    // Note: we do not pipe the logs of this process to a separate file since this is just a
+    // once-off export of the default chain spec and not part of the long-running node process.
+    let output = Command::new(binary_path)
+        .arg(export_command)
+        .arg("--chain")
+        .arg(chain_arg)
+        .env_remove("RUST_LOG")
+        .output()
+        .context("Failed to export the chain-spec")?;
+
+    if !output.status.success() {
+        anyhow::bail!(
+            "Export chain-spec failed: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    let content =
+        String::from_utf8(output.stdout).context("Failed to decode chain-spec output as UTF-8")?;
+    let mut chainspec_json: JsonValue =
+        serde_json::from_str(&content).context("Failed to parse chain spec JSON")?;
+
+    let existing_chainspec_balances =
+        chainspec_json["genesis"]["runtimeGenesis"]["patch"]["balances"]["balances"]
+            .as_array()
+            .cloned()
+            .unwrap_or_default();
+
+    let mut merged_balances: Vec<(String, u128)> = existing_chainspec_balances
+        .into_iter()
+        .filter_map(|val| {
+            if let Some(arr) = val.as_array() {
+                if arr.len() == 2 {
+                    let account = arr[0].as_str()?.to_string();
+                    let balance = arr[1].as_f64()? as u128;
+                    return Some((account, balance));
+                }
+            }
+            None
+        })
+        .collect();
+
+    for signer_address in wallet.signer_addresses() {
+        genesis
+            .alloc
+            .entry(signer_address)
+            .or_insert(GenesisAccount::default().with_balance(U256::from(initial_balance)));
+    }
+
+    let mut eth_balances =
+        crate::node_implementations::common::chainspec::extract_balance_from_genesis_file(genesis)
+            .context("Failed to extract balances from EVM genesis JSON")?;
+
+    merged_balances.append(&mut eth_balances);
+
+    chainspec_json["genesis"]["runtimeGenesis"]["patch"]["balances"]["balances"] =
+        json!(merged_balances);
+
+    serde_json::to_writer_pretty(
+        File::create(output_path).context("Failed to create chainspec file")?,
+        &chainspec_json,
+    )
+    .context("Failed to write chainspec JSON")?;
+
+    Ok(())
+}
+
+pub fn extract_balance_from_genesis_file(genesis: &Genesis) -> anyhow::Result<Vec<(String, u128)>> {
+    genesis
+        .alloc
+        .iter()
+        .try_fold(Vec::new(), |mut vec, (address, acc)| {
+            let substrate_address = eth_to_polkadot_address(address);
+            let balance = acc.balance.try_into()?;
+            vec.push((substrate_address, balance));
+            Ok(vec)
+        })
+}
+
+pub fn eth_to_polkadot_address(address: &Address) -> String {
+    let eth_bytes = address.0.0;
+
+    let mut padded = [0xEEu8; 32];
+    padded[..20].copy_from_slice(&eth_bytes);
+
+    let account_id = AccountId32::from(padded);
+    account_id.to_ss58check()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_genesis_alloc() {
+        // Create test genesis file
+        let genesis_json = r#"
+        {
+          "alloc": {
+            "0x90F8bf6A479f320ead074411a4B0e7944Ea8c9C1": { "balance": "1000000000000000000" },
+            "0x0000000000000000000000000000000000000000": { "balance": "0xDE0B6B3A7640000" },
+            "0xffffffffffffffffffffffffffffffffffffffff": { "balance": "123456789" }
+          }
+        }
+        "#;
+
+        let result =
+            extract_balance_from_genesis_file(&serde_json::from_str(genesis_json).unwrap())
+                .unwrap();
+
+        let result_map: std::collections::HashMap<_, _> = result.into_iter().collect();
+
+        assert_eq!(
+            result_map.get("5FLneRcWAfk3X3tg6PuGyLNGAquPAZez5gpqvyuf3yUK8VaV"),
+            Some(&1_000_000_000_000_000_000u128)
+        );
+
+        assert_eq!(
+            result_map.get("5C4hrfjw9DjXZTzV3MwzrrAr9P1MLDHajjSidz9bR544LEq1"),
+            Some(&1_000_000_000_000_000_000u128)
+        );
+
+        assert_eq!(
+            result_map.get("5HrN7fHLXWcFiXPwwtq2EkSGns9eMmoUQnbVKweNz3VVr6N4"),
+            Some(&123_456_789u128)
+        );
+    }
+
+    #[test]
+    fn test_eth_to_polkadot_address() {
+        let cases = vec![
+            (
+                "0x90F8bf6A479f320ead074411a4B0e7944Ea8c9C1",
+                "5FLneRcWAfk3X3tg6PuGyLNGAquPAZez5gpqvyuf3yUK8VaV",
+            ),
+            (
+                "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1",
+                "5FLneRcWAfk3X3tg6PuGyLNGAquPAZez5gpqvyuf3yUK8VaV",
+            ),
+            (
+                "0x0000000000000000000000000000000000000000",
+                "5C4hrfjw9DjXZTzV3MwzrrAr9P1MLDHajjSidz9bR544LEq1",
+            ),
+            (
+                "0xffffffffffffffffffffffffffffffffffffffff",
+                "5HrN7fHLXWcFiXPwwtq2EkSGns9eMmoUQnbVKweNz3VVr6N4",
+            ),
+        ];
+
+        for (eth_addr, expected_ss58) in cases {
+            let result = eth_to_polkadot_address(&eth_addr.parse().unwrap());
+            assert_eq!(
+                result, expected_ss58,
+                "Mismatch for Ethereum address {eth_addr}"
+            );
+        }
+    }
+
+    #[test]
+    fn print_eth_to_polkadot_mappings() {
+        let eth_addresses = vec![
+            "0x90F8bf6A479f320ead074411a4B0e7944Ea8c9C1",
+            "0xffffffffffffffffffffffffffffffffffffffff",
+            "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1",
+        ];
+
+        for eth_addr in eth_addresses {
+            let ss58 = eth_to_polkadot_address(&eth_addr.parse().unwrap());
+
+            println!("Ethereum: {eth_addr} -> Polkadot SS58: {ss58}");
+        }
+    }
+}

crates/node/src/node_implementations/common/mod.rs

@@ -0,0 +1,3 @@
+pub(crate) mod chainspec;
+pub(crate) mod process;
+pub(crate) mod revive;

crates/node/src/node_implementations/common/process.rs

@@ -0,0 +1,60 @@
+use anyhow::Result;
+use std::{
+    process::{Command, Stdio},
+    {path::Path, time::Duration},
+};
+
+use crate::helpers::{Process, ProcessReadinessWaitBehavior};
+
+const PROXY_LOG_ENV: &str = "info,eth-rpc=debug";
+
+pub fn spawn_eth_rpc_process(
+    logs_directory: &Path,
+    eth_proxy_binary: &Path,
+    node_rpc_url: &str,
+    eth_rpc_port: u16,
+    extra_args: &[&str],
+    ready_marker: &str,
+) -> anyhow::Result<Process> {
+    let ready_marker = ready_marker.to_owned();
+    Process::new(
+        "proxy",
+        logs_directory,
+        eth_proxy_binary,
+        |command, stdout_file, stderr_file| {
+            command
+                .arg("--node-rpc-url")
+                .arg(node_rpc_url)
+                .arg("--rpc-cors")
+                .arg("all")
+                .arg("--rpc-max-connections")
+                .arg(u32::MAX.to_string())
+                .arg("--rpc-port")
+                .arg(eth_rpc_port.to_string())
+                .env("RUST_LOG", PROXY_LOG_ENV);
+            for arg in extra_args {
+                command.arg(arg);
+            }
+            command.stdout(stdout_file).stderr(stderr_file);
+        },
+        ProcessReadinessWaitBehavior::TimeBoundedWaitFunction {
+            max_wait_duration: Duration::from_secs(30),
+            check_function: Box::new(move |_, stderr_line| match stderr_line {
+                Some(line) => Ok(line.contains(&ready_marker)),
+                None => Ok(false),
+            }),
+        },
+    )
+}
+
+pub fn command_version(command_binary: &Path) -> Result<String> {
+    let output = Command::new(command_binary)
+        .arg("--version")
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::null())
+        .spawn()?
+        .wait_with_output()?
+        .stdout;
+    Ok(String::from_utf8_lossy(&output).trim().to_string())
+}

crates/node/src/node_implementations/common/revive.rs

@@ -0,0 +1,434 @@
+use alloy::{
+    consensus::{BlockHeader, TxEnvelope},
+    network::{
+        Ethereum, Network, TransactionBuilder, TransactionBuilderError, UnbuiltTransactionError,
+    },
+    primitives::{Address, B64, B256, BlockNumber, Bloom, Bytes, U256},
+    rpc::types::eth::{Block, Header, Transaction},
+};
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ReviveNetwork;
+
+impl Network for ReviveNetwork {
+    type TxType = <Ethereum as Network>::TxType;
+
+    type TxEnvelope = <Ethereum as Network>::TxEnvelope;
+
+    type UnsignedTx = <Ethereum as Network>::UnsignedTx;
+
+    type ReceiptEnvelope = <Ethereum as Network>::ReceiptEnvelope;
+
+    type Header = ReviveHeader;
+
+    type TransactionRequest = <Ethereum as Network>::TransactionRequest;
+
+    type TransactionResponse = <Ethereum as Network>::TransactionResponse;
+
+    type ReceiptResponse = <Ethereum as Network>::ReceiptResponse;
+
+    type HeaderResponse = Header<ReviveHeader>;
+
+    type BlockResponse = Block<Transaction<TxEnvelope>, Header<ReviveHeader>>;
+}
+
+impl TransactionBuilder<ReviveNetwork> for <Ethereum as Network>::TransactionRequest {
+    fn chain_id(&self) -> Option<alloy::primitives::ChainId> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::chain_id(self)
+    }
+
+    fn set_chain_id(&mut self, chain_id: alloy::primitives::ChainId) {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_chain_id(
+            self, chain_id,
+        )
+    }
+
+    fn nonce(&self) -> Option<u64> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::nonce(self)
+    }
+
+    fn set_nonce(&mut self, nonce: u64) {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_nonce(
+            self, nonce,
+        )
+    }
+
+    fn take_nonce(&mut self) -> Option<u64> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::take_nonce(
+            self,
+        )
+    }
+
+    fn input(&self) -> Option<&alloy::primitives::Bytes> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::input(self)
+    }
+
+    fn set_input<T: Into<alloy::primitives::Bytes>>(&mut self, input: T) {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_input(
+            self, input,
+        )
+    }
+
+    fn from(&self) -> Option<Address> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::from(self)
+    }
+
+    fn set_from(&mut self, from: Address) {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_from(
+            self, from,
+        )
+    }
+
+    fn kind(&self) -> Option<alloy::primitives::TxKind> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::kind(self)
+    }
+
+    fn clear_kind(&mut self) {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::clear_kind(
+            self,
+        )
+    }
+
+    fn set_kind(&mut self, kind: alloy::primitives::TxKind) {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_kind(
+            self, kind,
+        )
+    }
+
+    fn value(&self) -> Option<alloy::primitives::U256> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::value(self)
+    }
+
+    fn set_value(&mut self, value: alloy::primitives::U256) {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_value(
+            self, value,
+        )
+    }
+
+    fn gas_price(&self) -> Option<u128> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::gas_price(self)
+    }
+
+    fn set_gas_price(&mut self, gas_price: u128) {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_gas_price(
+            self, gas_price,
+        )
+    }
+
+    fn max_fee_per_gas(&self) -> Option<u128> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::max_fee_per_gas(
+            self,
+        )
+    }
+
+    fn set_max_fee_per_gas(&mut self, max_fee_per_gas: u128) {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_max_fee_per_gas(
+            self, max_fee_per_gas
+        )
+    }
+
+    fn max_priority_fee_per_gas(&self) -> Option<u128> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::max_priority_fee_per_gas(
+            self,
+        )
+    }
+
+    fn set_max_priority_fee_per_gas(&mut self, max_priority_fee_per_gas: u128) {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_max_priority_fee_per_gas(
+            self, max_priority_fee_per_gas
+        )
+    }
+
+    fn gas_limit(&self) -> Option<u64> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::gas_limit(self)
+    }
+
+    fn set_gas_limit(&mut self, gas_limit: u64) {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_gas_limit(
+            self, gas_limit,
+        )
+    }
+
+    fn access_list(&self) -> Option<&alloy::rpc::types::AccessList> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::access_list(
+            self,
+        )
+    }
+
+    fn set_access_list(&mut self, access_list: alloy::rpc::types::AccessList) {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_access_list(
+            self,
+            access_list,
+        )
+    }
+
+    fn complete_type(
+        &self,
+        ty: <ReviveNetwork as Network>::TxType,
+    ) -> Result<(), Vec<&'static str>> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::complete_type(
+            self, ty,
+        )
+    }
+
+    fn can_submit(&self) -> bool {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::can_submit(
+            self,
+        )
+    }
+
+    fn can_build(&self) -> bool {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::can_build(self)
+    }
+
+    fn output_tx_type(&self) -> <ReviveNetwork as Network>::TxType {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::output_tx_type(
+            self,
+        )
+    }
+
+    fn output_tx_type_checked(&self) -> Option<<ReviveNetwork as Network>::TxType> {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::output_tx_type_checked(
+            self,
+        )
+    }
+
+    fn prep_for_submission(&mut self) {
+        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::prep_for_submission(
+            self,
+        )
+    }
+
+    fn build_unsigned(
+        self,
+    ) -> alloy::network::BuildResult<<ReviveNetwork as Network>::UnsignedTx, ReviveNetwork> {
+        let result = <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::build_unsigned(
+            self,
+        );
+        match result {
+            Ok(unsigned_tx) => Ok(unsigned_tx),
+            Err(UnbuiltTransactionError { request, error }) => {
+                Err(UnbuiltTransactionError::<ReviveNetwork> {
+                    request,
+                    error: match error {
+                        TransactionBuilderError::InvalidTransactionRequest(tx_type, items) => {
+                            TransactionBuilderError::InvalidTransactionRequest(tx_type, items)
+                        }
+                        TransactionBuilderError::UnsupportedSignatureType => {
+                            TransactionBuilderError::UnsupportedSignatureType
+                        }
+                        TransactionBuilderError::Signer(error) => {
+                            TransactionBuilderError::Signer(error)
+                        }
+                        TransactionBuilderError::Custom(error) => {
+                            TransactionBuilderError::Custom(error)
+                        }
+                    },
+                })
+            }
+        }
+    }
+
+    async fn build<W: alloy::network::NetworkWallet<ReviveNetwork>>(
+        self,
+        wallet: &W,
+    ) -> Result<<ReviveNetwork as Network>::TxEnvelope, TransactionBuilderError<ReviveNetwork>>
+    {
+        Ok(wallet.sign_request(self).await?)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ReviveHeader {
+    /// The Keccak 256-bit hash of the parent
+    /// block’s header, in its entirety; formally Hp.
+    pub parent_hash: B256,
+    /// The Keccak 256-bit hash of the ommers list portion of this block; formally Ho.
+    #[serde(rename = "sha3Uncles", alias = "ommersHash")]
+    pub ommers_hash: B256,
+    /// The 160-bit address to which all fees collected from the successful mining of this block
+    /// be transferred; formally Hc.
+    #[serde(rename = "miner", alias = "beneficiary")]
+    pub beneficiary: Address,
+    /// The Keccak 256-bit hash of the root node of the state trie, after all transactions are
+    /// executed and finalisations applied; formally Hr.
+    pub state_root: B256,
+    /// The Keccak 256-bit hash of the root node of the trie structure populated with each
+    /// transaction in the transactions list portion of the block; formally Ht.
+    pub transactions_root: B256,
+    /// The Keccak 256-bit hash of the root node of the trie structure populated with the receipts
+    /// of each transaction in the transactions list portion of the block; formally He.
+    pub receipts_root: B256,
+    /// The Bloom filter composed from indexable information (logger address and log topics)
+    /// contained in each log entry from the receipt of each transaction in the transactions list;
+    /// formally Hb.
+    pub logs_bloom: Bloom,
+    /// A scalar value corresponding to the difficulty level of this block. This can be calculated
+    /// from the previous block’s difficulty level and the timestamp; formally Hd.
+    pub difficulty: U256,
+    /// A scalar value equal to the number of ancestor blocks. The genesis block has a number of
+    /// zero; formally Hi.
+    #[serde(with = "alloy::serde::quantity")]
+    pub number: BlockNumber,
+    /// A scalar value equal to the current limit of gas expenditure per block; formally Hl.
+    // This is the main difference over the Ethereum network implementation. We use u128 here and
+    // not u64.
+    #[serde(with = "alloy::serde::quantity")]
+    pub gas_limit: u128,
+    /// A scalar value equal to the total gas used in transactions in this block; formally Hg.
+    #[serde(with = "alloy::serde::quantity")]
+    pub gas_used: u64,
+    /// A scalar value equal to the reasonable output of Unix’s time() at this block’s inception;
+    /// formally Hs.
+    #[serde(with = "alloy::serde::quantity")]
+    pub timestamp: u64,
+    /// An arbitrary byte array containing data relevant to this block. This must be 32 bytes or
+    /// fewer; formally Hx.
+    pub extra_data: Bytes,
+    /// A 256-bit hash which, combined with the
+    /// nonce, proves that a sufficient amount of computation has been carried out on this block;
+    /// formally Hm.
+    pub mix_hash: B256,
+    /// A 64-bit value which, combined with the mixhash, proves that a sufficient amount of
+    /// computation has been carried out on this block; formally Hn.
+    pub nonce: B64,
+    /// A scalar representing EIP1559 base fee which can move up or down each block according
+    /// to a formula which is a function of gas used in parent block and gas target
+    /// (block gas limit divided by elasticity multiplier) of parent block.
+    /// The algorithm results in the base fee per gas increasing when blocks are
+    /// above the gas target, and decreasing when blocks are below the gas target. The base fee per
+    /// gas is burned.
+    #[serde(
+        default,
+        with = "alloy::serde::quantity::opt",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub base_fee_per_gas: Option<u64>,
+    /// The Keccak 256-bit hash of the withdrawals list portion of this block.
+    /// <https://eips.ethereum.org/EIPS/eip-4895>
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub withdrawals_root: Option<B256>,
+    /// The total amount of blob gas consumed by the transactions within the block, added in
+    /// EIP-4844.
+    #[serde(
+        default,
+        with = "alloy::serde::quantity::opt",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub blob_gas_used: Option<u64>,
+    /// A running total of blob gas consumed in excess of the target, prior to the block. Blocks
+    /// with above-target blob gas consumption increase this value, blocks with below-target blob
+    /// gas consumption decrease it (bounded at 0). This was added in EIP-4844.
+    #[serde(
+        default,
+        with = "alloy::serde::quantity::opt",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub excess_blob_gas: Option<u64>,
+    /// The hash of the parent beacon block's root is included in execution blocks, as proposed by
+    /// EIP-4788.
+    ///
+    /// This enables trust-minimized access to consensus state, supporting staking pools, bridges,
+    /// and more.
+    ///
+    /// The beacon roots contract handles root storage, enhancing Ethereum's functionalities.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parent_beacon_block_root: Option<B256>,
+    /// The Keccak 256-bit hash of the an RLP encoded list with each
+    /// [EIP-7685] request in the block body.
+    ///
+    /// [EIP-7685]: https://eips.ethereum.org/EIPS/eip-7685
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub requests_hash: Option<B256>,
+}
+
+impl BlockHeader for ReviveHeader {
+    fn parent_hash(&self) -> B256 {
+        self.parent_hash
+    }
+
+    fn ommers_hash(&self) -> B256 {
+        self.ommers_hash
+    }
+
+    fn beneficiary(&self) -> Address {
+        self.beneficiary
+    }
+
+    fn state_root(&self) -> B256 {
+        self.state_root
+    }
+
+    fn transactions_root(&self) -> B256 {
+        self.transactions_root
+    }
+
+    fn receipts_root(&self) -> B256 {
+        self.receipts_root
+    }
+
+    fn withdrawals_root(&self) -> Option<B256> {
+        self.withdrawals_root
+    }
+
+    fn logs_bloom(&self) -> Bloom {
+        self.logs_bloom
+    }
+
+    fn difficulty(&self) -> U256 {
+        self.difficulty
+    }
+
+    fn number(&self) -> BlockNumber {
+        self.number
+    }
+
+    // There's sadly nothing that we can do about this. We're required to implement this trait on
+    // any type that represents a header and the gas limit type used here is a u64.
+    fn gas_limit(&self) -> u64 {
+        self.gas_limit.try_into().unwrap_or(u64::MAX)
+    }
+
+    fn gas_used(&self) -> u64 {
+        self.gas_used
+    }
+
+    fn timestamp(&self) -> u64 {
+        self.timestamp
+    }
+
+    fn mix_hash(&self) -> Option<B256> {
+        Some(self.mix_hash)
+    }
+
+    fn nonce(&self) -> Option<B64> {
+        Some(self.nonce)
+    }
+
+    fn base_fee_per_gas(&self) -> Option<u64> {
+        self.base_fee_per_gas
+    }
+
+    fn blob_gas_used(&self) -> Option<u64> {
+        self.blob_gas_used
+    }
+
+    fn excess_blob_gas(&self) -> Option<u64> {
+        self.excess_blob_gas
+    }
+
+    fn parent_beacon_block_root(&self) -> Option<B256> {
+        self.parent_beacon_block_root
+    }
+
+    fn requests_hash(&self) -> Option<B256> {
+        self.requests_hash
+    }
+
+    fn extra_data(&self) -> &Bytes {
+        &self.extra_data
+    }
+}

crates/node/src/node_implementations/lighthouse_geth.rs

@@ -17,7 +17,7 @@ use std::{
     pin::Pin,
     process::{Command, Stdio},
     sync::{
-        Arc, LazyLock,
+        Arc,
         atomic::{AtomicU32, Ordering},
     },
     time::{Duration, SystemTime, UNIX_EPOCH},
@@ -47,7 +47,7 @@ use futures::{Stream, StreamExt};
 use revive_common::EVMVersion;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_with::serde_as;
-use tokio::sync::{OnceCell, Semaphore};
+use tokio::sync::OnceCell;
 use tracing::{Instrument, info, instrument};
 
 use revive_dt_common::{
@@ -105,7 +105,6 @@ pub struct LighthouseGethNode {
 
     persistent_http_provider: OnceCell<ConcreteProvider<Ethereum, Arc<EthereumWallet>>>,
     persistent_ws_provider: OnceCell<ConcreteProvider<Ethereum, Arc<EthereumWallet>>>,
-    http_provider_requests_semaphore: LazyLock<Semaphore>,
 }
 
 impl LighthouseGethNode {
@@ -176,7 +175,6 @@ impl LighthouseGethNode {
             nonce_manager: Default::default(),
             persistent_http_provider: OnceCell::const_new(),
             persistent_ws_provider: OnceCell::const_new(),
-            http_provider_requests_semaphore: LazyLock::new(|| Semaphore::const_new(500)),
         }
     }
 
@@ -566,8 +564,6 @@ impl EthereumNode for LighthouseGethNode {
         transaction: TransactionRequest,
     ) -> Pin<Box<dyn Future<Output = anyhow::Result<TxHash>> + '_>> {
         Box::pin(async move {
-            let _permit = self.http_provider_requests_semaphore.acquire().await;
-
             let provider = self
                 .http_provider()
                 .await
@@ -1135,6 +1131,7 @@ mod tests {
     }
 
     #[tokio::test]
+    #[ignore = "Ignored since they take a long time to run"]
     async fn node_mines_simple_transfer_transaction_and_returns_receipt() {
         // Arrange
         let (context, node) = new_node();

crates/node/src/node_implementations/mod.rs

@@ -1,3 +1,6 @@
+mod common;
+
 pub mod geth;
 pub mod lighthouse_geth;
 pub mod substrate;
+pub mod zombienet;

crates/node/src/node_implementations/substrate.rs

@@ -2,7 +2,6 @@ use std::{
     fs::{create_dir_all, remove_dir_all},
     path::PathBuf,
     pin::Pin,
-    process::{Command, Stdio},
     sync::{
         Arc,
         atomic::{AtomicU32, Ordering},
@@ -11,17 +10,10 @@ use std::{
 };
 
 use alloy::{
-    consensus::{BlockHeader, TxEnvelope},
     eips::BlockNumberOrTag,
-    genesis::{Genesis, GenesisAccount},
-    network::{
-        Ethereum, EthereumWallet, Network, NetworkWallet, TransactionBuilder,
-        TransactionBuilderError, UnbuiltTransactionError,
-    },
-    primitives::{
-        Address, B64, B256, BlockHash, BlockNumber, BlockTimestamp, Bloom, Bytes, StorageKey,
-        TxHash, U256,
-    },
+    genesis::Genesis,
+    network::EthereumWallet,
+    primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, StorageKey, TxHash, U256},
     providers::{
         Provider,
         ext::DebugApi,
@@ -29,23 +21,18 @@ use alloy::{
     },
     rpc::types::{
         EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest,
-        eth::{Block, Header, Transaction},
         trace::geth::{
             DiffMode, GethDebugTracingOptions, GethTrace, PreStateConfig, PreStateFrame,
         },
     },
 };
 use anyhow::Context as _;
-use futures::{Stream, StreamExt};
+use async_stream::stream;
+use futures::Stream;
 use revive_common::EVMVersion;
 use revive_dt_common::fs::clear_directory;
-use revive_dt_format::traits::ResolverApi;
-use serde::{Deserialize, Serialize};
-use serde_json::{Value as JsonValue, json};
-use sp_core::crypto::Ss58Codec;
-use sp_runtime::AccountId32;
-
 use revive_dt_config::*;
+use revive_dt_format::traits::ResolverApi;
 use revive_dt_node_interaction::{EthereumNode, MinedBlockInformation};
 use tokio::sync::OnceCell;
 use tracing::instrument;
@@ -54,7 +41,15 @@ use crate::{
     Node,
     constants::{CHAIN_ID, INITIAL_BALANCE},
     helpers::{Process, ProcessReadinessWaitBehavior},
-    provider_utils::{ConcreteProvider, FallbackGasFiller, construct_concurrency_limited_provider},
+    node_implementations::common::{
+        chainspec::export_and_patch_chainspec_json,
+        process::{command_version, spawn_eth_rpc_process},
+        revive::ReviveNetwork,
+    },
+    provider_utils::{
+        ConcreteProvider, FallbackGasFiller, construct_concurrency_limited_provider,
+        execute_transaction,
+    },
 };
 
 static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
@@ -77,10 +72,11 @@ pub struct SubstrateNode {
     wallet: Arc<EthereumWallet>,
     nonce_manager: CachedNonceManager,
     provider: OnceCell<ConcreteProvider<ReviveNetwork, Arc<EthereumWallet>>>,
+    consensus: Option<String>,
 }
 
 impl SubstrateNode {
-    const BASE_DIRECTORY: &str = "Substrate";
+    const BASE_DIRECTORY: &str = "substrate";
     const LOGS_DIRECTORY: &str = "logs";
     const DATA_DIRECTORY: &str = "chains";
 
@@ -91,7 +87,6 @@ impl SubstrateNode {
     const BASE_PROXY_RPC_PORT: u16 = 8545;
 
     const SUBSTRATE_LOG_ENV: &str = "error,evm=debug,sc_rpc_server=info,runtime::revive=debug";
-    const PROXY_LOG_ENV: &str = "info,eth-rpc=debug";
 
     pub const KITCHENSINK_EXPORT_CHAINSPEC_COMMAND: &str = "export-chain-spec";
     pub const REVIVE_DEV_NODE_EXPORT_CHAINSPEC_COMMAND: &str = "build-spec";
@@ -99,6 +94,7 @@ impl SubstrateNode {
     pub fn new(
         node_path: PathBuf,
         export_chainspec_command: &str,
+        consensus: Option<String>,
         context: impl AsRef<WorkingDirectoryConfiguration>
         + AsRef<EthRpcConfiguration>
         + AsRef<WalletConfiguration>,
@@ -128,6 +124,7 @@ impl SubstrateNode {
             wallet: wallet.clone(),
             nonce_manager: Default::default(),
             provider: Default::default(),
+            consensus,
         }
     }
 
@@ -143,72 +140,16 @@ impl SubstrateNode {
 
         let template_chainspec_path = self.base_directory.join(Self::CHAIN_SPEC_JSON_FILE);
 
-        // Note: we do not pipe the logs of this process to a separate file since this is just a
-        // once-off export of the default chain spec and not part of the long-running node process.
-        let output = Command::new(&self.node_binary)
-            .arg(self.export_chainspec_command.as_str())
-            .arg("--chain")
-            .arg("dev")
-            .env_remove("RUST_LOG")
-            .output()
-            .context("Failed to export the chain-spec")?;
+        export_and_patch_chainspec_json(
+            &self.node_binary,
+            self.export_chainspec_command.as_str(),
+            "dev",
+            &template_chainspec_path,
+            &mut genesis,
+            &self.wallet,
+            INITIAL_BALANCE,
+        )?;
 
-        if !output.status.success() {
-            anyhow::bail!(
-                "Substrate-node export-chain-spec failed: {}",
-                String::from_utf8_lossy(&output.stderr)
-            );
-        }
-
-        let content = String::from_utf8(output.stdout)
-            .context("Failed to decode Substrate export-chain-spec output as UTF-8")?;
-        let mut chainspec_json: JsonValue =
-            serde_json::from_str(&content).context("Failed to parse Substrate chain spec JSON")?;
-
-        let existing_chainspec_balances =
-            chainspec_json["genesis"]["runtimeGenesis"]["patch"]["balances"]["balances"]
-                .as_array()
-                .cloned()
-                .unwrap_or_default();
-
-        let mut merged_balances: Vec<(String, u128)> = existing_chainspec_balances
-            .into_iter()
-            .filter_map(|val| {
-                if let Some(arr) = val.as_array() {
-                    if arr.len() == 2 {
-                        let account = arr[0].as_str()?.to_string();
-                        let balance = arr[1].as_f64()? as u128;
-                        return Some((account, balance));
-                    }
-                }
-                None
-            })
-            .collect();
-        let mut eth_balances = {
-            for signer_address in
-                <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
-            {
-                // Note, the use of the entry API here means that we only modify the entries for any
-                // account that is not in the `alloc` field of the genesis state.
-                genesis
-                    .alloc
-                    .entry(signer_address)
-                    .or_insert(GenesisAccount::default().with_balance(U256::from(INITIAL_BALANCE)));
-            }
-            self.extract_balance_from_genesis_file(&genesis)
-                .context("Failed to extract balances from EVM genesis JSON")?
-        };
-        merged_balances.append(&mut eth_balances);
-
-        chainspec_json["genesis"]["runtimeGenesis"]["patch"]["balances"]["balances"] =
-            json!(merged_balances);
-
-        serde_json::to_writer_pretty(
-            std::fs::File::create(&template_chainspec_path)
-                .context("Failed to create substrate template chainspec file")?,
-            &chainspec_json,
-        )
-        .context("Failed to write substrate template chainspec JSON")?;
         Ok(self)
     }
 
@@ -225,7 +166,7 @@ impl SubstrateNode {
             self.logs_directory.as_path(),
             self.node_binary.as_path(),
             |command, stdout_file, stderr_file| {
-                command
+                let cmd = command
                     .arg("--dev")
                     .arg("--chain")
                     .arg(chainspec_path)
@@ -242,9 +183,16 @@ impl SubstrateNode {
                     .arg("all")
                     .arg("--rpc-max-connections")
                     .arg(u32::MAX.to_string())
+                    .arg("--pool-limit")
+                    .arg(u32::MAX.to_string())
+                    .arg("--pool-kbytes")
+                    .arg(u32::MAX.to_string())
                     .env("RUST_LOG", Self::SUBSTRATE_LOG_ENV)
                     .stdout(stdout_file)
                     .stderr(stderr_file);
+                if let Some(consensus) = self.consensus.as_ref() {
+                    cmd.arg("--consensus").arg(consensus.clone());
+                }
             },
             ProcessReadinessWaitBehavior::TimeBoundedWaitFunction {
                 max_wait_duration: Duration::from_secs(30),
@@ -263,32 +211,15 @@ impl SubstrateNode {
                 return Err(err);
             }
         }
-
-        let eth_proxy_process = Process::new(
-            "proxy",
+        let eth_proxy_process = spawn_eth_rpc_process(
             self.logs_directory.as_path(),
             self.eth_proxy_binary.as_path(),
-            |command, stdout_file, stderr_file| {
-                command
-                    .arg("--dev")
-                    .arg("--rpc-port")
-                    .arg(proxy_rpc_port.to_string())
-                    .arg("--node-rpc-url")
-                    .arg(format!("ws://127.0.0.1:{substrate_rpc_port}"))
-                    .arg("--rpc-max-connections")
-                    .arg(u32::MAX.to_string())
-                    .env("RUST_LOG", Self::PROXY_LOG_ENV)
-                    .stdout(stdout_file)
-                    .stderr(stderr_file);
-            },
-            ProcessReadinessWaitBehavior::TimeBoundedWaitFunction {
-                max_wait_duration: Duration::from_secs(30),
-                check_function: Box::new(|_, stderr_line| match stderr_line {
-                    Some(line) => Ok(line.contains(Self::ETH_PROXY_READY_MARKER)),
-                    None => Ok(false),
-                }),
-            },
+            &format!("ws://127.0.0.1:{substrate_rpc_port}"),
+            proxy_rpc_port,
+            &["--dev"], // extra args
+            Self::ETH_PROXY_READY_MARKER,
         );
+
         match eth_proxy_process {
             Ok(process) => self.eth_proxy_process = Some(process),
             Err(err) => {
@@ -302,41 +233,8 @@ impl SubstrateNode {
         Ok(())
     }
 
-    fn extract_balance_from_genesis_file(
-        &self,
-        genesis: &Genesis,
-    ) -> anyhow::Result<Vec<(String, u128)>> {
-        genesis
-            .alloc
-            .iter()
-            .try_fold(Vec::new(), |mut vec, (address, acc)| {
-                let substrate_address = Self::eth_to_substrate_address(address);
-                let balance = acc.balance.try_into()?;
-                vec.push((substrate_address, balance));
-                Ok(vec)
-            })
-    }
-
-    fn eth_to_substrate_address(address: &Address) -> String {
-        let eth_bytes = address.0.0;
-
-        let mut padded = [0xEEu8; 32];
-        padded[..20].copy_from_slice(&eth_bytes);
-
-        let account_id = AccountId32::from(padded);
-        account_id.to_ss58check()
-    }
-
     pub fn eth_rpc_version(&self) -> anyhow::Result<String> {
-        let output = Command::new(&self.eth_proxy_binary)
-            .arg("--version")
-            .stdin(Stdio::null())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::null())
-            .spawn()?
-            .wait_with_output()?
-            .stdout;
-        Ok(String::from_utf8_lossy(&output).trim().to_string())
+        command_version(&self.eth_proxy_binary)
     }
 
     async fn provider(
@@ -346,7 +244,7 @@ impl SubstrateNode {
             .get_or_try_init(|| async move {
                 construct_concurrency_limited_provider::<ReviveNetwork, _>(
                     self.rpc_url.as_str(),
-                    FallbackGasFiller::new(250_000_000, 5_000_000_000, 1_000_000_000),
+                    FallbackGasFiller::new(u64::MAX, 5_000_000_000, 1_000_000_000),
                     ChainIdFiller::new(Some(CHAIN_ID)),
                     NonceFiller::new(self.nonce_manager.clone()),
                     self.wallet.clone(),
@@ -408,23 +306,12 @@ impl EthereumNode for SubstrateNode {
         &self,
         transaction: TransactionRequest,
     ) -> Pin<Box<dyn Future<Output = anyhow::Result<TransactionReceipt>> + '_>> {
-        static SEMAPHORE: std::sync::LazyLock<tokio::sync::Semaphore> =
-            std::sync::LazyLock::new(|| tokio::sync::Semaphore::new(500));
-
         Box::pin(async move {
-            let _permit = SEMAPHORE.acquire().await?;
-
-            let receipt = self
+            let provider = self
                 .provider()
                 .await
-                .context("Failed to create provider for transaction submission")?
-                .send_transaction(transaction)
-                .await
-                .context("Failed to submit transaction to substrate proxy")?
-                .get_receipt()
-                .await
-                .context("Failed to fetch transaction receipt from substrate proxy")?;
-            Ok(receipt)
+                .context("Failed to create the provider")?;
+            execute_transaction(provider, transaction).await
         })
     }
 
@@ -516,37 +403,46 @@ impl EthereumNode for SubstrateNode {
                 + '_,
         >,
     > {
+        fn create_stream(
+            provider: ConcreteProvider<ReviveNetwork, Arc<EthereumWallet>>,
+        ) -> impl Stream<Item = MinedBlockInformation> {
+            stream! {
+                let mut block_number = provider.get_block_number().await.expect("Failed to get the block number");
+                loop {
+                    tokio::time::sleep(Duration::from_secs(1)).await;
+
+                    let Ok(Some(block)) = provider.get_block_by_number(BlockNumberOrTag::Number(block_number)).await
+                    else {
+                        continue;
+                    };
+
+                    block_number += 1;
+                    yield MinedBlockInformation {
+                        block_number: block.number(),
+                        block_timestamp: block.header.timestamp,
+                        mined_gas: block.header.gas_used as _,
+                        block_gas_limit: block.header.gas_limit,
+                        transaction_hashes: block
+                            .transactions
+                            .into_hashes()
+                            .as_hashes()
+                            .expect("Must be hashes")
+                            .to_vec(),
+                    };
+                };
+            }
+        }
+
         Box::pin(async move {
             let provider = self
                 .provider()
                 .await
-                .context("Failed to create the provider for block subscription")?;
-            let mut block_subscription = provider
-                .watch_full_blocks()
-                .await
-                .context("Failed to create the blocks stream")?;
-            block_subscription.set_channel_size(0xFFFF);
-            block_subscription.set_poll_interval(Duration::from_secs(1));
-            let block_stream = block_subscription.into_stream();
+                .context("Failed to create the provider for a block subscription")?;
 
-            let mined_block_information_stream = block_stream.filter_map(|block| async {
-                let block = block.ok()?;
-                Some(MinedBlockInformation {
-                    block_number: block.number(),
-                    block_timestamp: block.header.timestamp,
-                    mined_gas: block.header.gas_used as _,
-                    block_gas_limit: block.header.gas_limit,
-                    transaction_hashes: block
-                        .transactions
-                        .into_hashes()
-                        .as_hashes()
-                        .expect("Must be hashes")
-                        .to_vec(),
-                })
-            });
+            let stream = Box::pin(create_stream(provider))
+                as Pin<Box<dyn Stream<Item = MinedBlockInformation>>>;
 
-            Ok(Box::pin(mined_block_information_stream)
-                as Pin<Box<dyn Stream<Item = MinedBlockInformation>>>)
+            Ok(stream)
         })
     }
 }
@@ -697,17 +593,7 @@ impl Node for SubstrateNode {
     }
 
     fn version(&self) -> anyhow::Result<String> {
-        let output = Command::new(&self.node_binary)
-            .arg("--version")
-            .stdin(Stdio::null())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::null())
-            .spawn()
-            .context("Failed to spawn substrate --version")?
-            .wait_with_output()
-            .context("Failed to wait for substrate --version")?
-            .stdout;
-        Ok(String::from_utf8_lossy(&output).into())
+        command_version(&self.node_binary)
     }
 }
 
@@ -717,430 +603,6 @@ impl Drop for SubstrateNode {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct ReviveNetwork;
-
-impl Network for ReviveNetwork {
-    type TxType = <Ethereum as Network>::TxType;
-
-    type TxEnvelope = <Ethereum as Network>::TxEnvelope;
-
-    type UnsignedTx = <Ethereum as Network>::UnsignedTx;
-
-    type ReceiptEnvelope = <Ethereum as Network>::ReceiptEnvelope;
-
-    type Header = ReviveHeader;
-
-    type TransactionRequest = <Ethereum as Network>::TransactionRequest;
-
-    type TransactionResponse = <Ethereum as Network>::TransactionResponse;
-
-    type ReceiptResponse = <Ethereum as Network>::ReceiptResponse;
-
-    type HeaderResponse = Header<ReviveHeader>;
-
-    type BlockResponse = Block<Transaction<TxEnvelope>, Header<ReviveHeader>>;
-}
-
-impl TransactionBuilder<ReviveNetwork> for <Ethereum as Network>::TransactionRequest {
-    fn chain_id(&self) -> Option<alloy::primitives::ChainId> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::chain_id(self)
-    }
-
-    fn set_chain_id(&mut self, chain_id: alloy::primitives::ChainId) {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_chain_id(
-            self, chain_id,
-        )
-    }
-
-    fn nonce(&self) -> Option<u64> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::nonce(self)
-    }
-
-    fn set_nonce(&mut self, nonce: u64) {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_nonce(
-            self, nonce,
-        )
-    }
-
-    fn take_nonce(&mut self) -> Option<u64> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::take_nonce(
-            self,
-        )
-    }
-
-    fn input(&self) -> Option<&alloy::primitives::Bytes> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::input(self)
-    }
-
-    fn set_input<T: Into<alloy::primitives::Bytes>>(&mut self, input: T) {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_input(
-            self, input,
-        )
-    }
-
-    fn from(&self) -> Option<Address> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::from(self)
-    }
-
-    fn set_from(&mut self, from: Address) {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_from(
-            self, from,
-        )
-    }
-
-    fn kind(&self) -> Option<alloy::primitives::TxKind> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::kind(self)
-    }
-
-    fn clear_kind(&mut self) {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::clear_kind(
-            self,
-        )
-    }
-
-    fn set_kind(&mut self, kind: alloy::primitives::TxKind) {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_kind(
-            self, kind,
-        )
-    }
-
-    fn value(&self) -> Option<alloy::primitives::U256> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::value(self)
-    }
-
-    fn set_value(&mut self, value: alloy::primitives::U256) {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_value(
-            self, value,
-        )
-    }
-
-    fn gas_price(&self) -> Option<u128> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::gas_price(self)
-    }
-
-    fn set_gas_price(&mut self, gas_price: u128) {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_gas_price(
-            self, gas_price,
-        )
-    }
-
-    fn max_fee_per_gas(&self) -> Option<u128> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::max_fee_per_gas(
-            self,
-        )
-    }
-
-    fn set_max_fee_per_gas(&mut self, max_fee_per_gas: u128) {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_max_fee_per_gas(
-            self, max_fee_per_gas
-        )
-    }
-
-    fn max_priority_fee_per_gas(&self) -> Option<u128> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::max_priority_fee_per_gas(
-            self,
-        )
-    }
-
-    fn set_max_priority_fee_per_gas(&mut self, max_priority_fee_per_gas: u128) {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_max_priority_fee_per_gas(
-            self, max_priority_fee_per_gas
-        )
-    }
-
-    fn gas_limit(&self) -> Option<u64> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::gas_limit(self)
-    }
-
-    fn set_gas_limit(&mut self, gas_limit: u64) {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_gas_limit(
-            self, gas_limit,
-        )
-    }
-
-    fn access_list(&self) -> Option<&alloy::rpc::types::AccessList> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::access_list(
-            self,
-        )
-    }
-
-    fn set_access_list(&mut self, access_list: alloy::rpc::types::AccessList) {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::set_access_list(
-            self,
-            access_list,
-        )
-    }
-
-    fn complete_type(
-        &self,
-        ty: <ReviveNetwork as Network>::TxType,
-    ) -> Result<(), Vec<&'static str>> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::complete_type(
-            self, ty,
-        )
-    }
-
-    fn can_submit(&self) -> bool {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::can_submit(
-            self,
-        )
-    }
-
-    fn can_build(&self) -> bool {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::can_build(self)
-    }
-
-    fn output_tx_type(&self) -> <ReviveNetwork as Network>::TxType {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::output_tx_type(
-            self,
-        )
-    }
-
-    fn output_tx_type_checked(&self) -> Option<<ReviveNetwork as Network>::TxType> {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::output_tx_type_checked(
-            self,
-        )
-    }
-
-    fn prep_for_submission(&mut self) {
-        <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::prep_for_submission(
-            self,
-        )
-    }
-
-    fn build_unsigned(
-        self,
-    ) -> alloy::network::BuildResult<<ReviveNetwork as Network>::UnsignedTx, ReviveNetwork> {
-        let result = <<Ethereum as Network>::TransactionRequest as TransactionBuilder<Ethereum>>::build_unsigned(
-            self,
-        );
-        match result {
-            Ok(unsigned_tx) => Ok(unsigned_tx),
-            Err(UnbuiltTransactionError { request, error }) => {
-                Err(UnbuiltTransactionError::<ReviveNetwork> {
-                    request,
-                    error: match error {
-                        TransactionBuilderError::InvalidTransactionRequest(tx_type, items) => {
-                            TransactionBuilderError::InvalidTransactionRequest(tx_type, items)
-                        }
-                        TransactionBuilderError::UnsupportedSignatureType => {
-                            TransactionBuilderError::UnsupportedSignatureType
-                        }
-                        TransactionBuilderError::Signer(error) => {
-                            TransactionBuilderError::Signer(error)
-                        }
-                        TransactionBuilderError::Custom(error) => {
-                            TransactionBuilderError::Custom(error)
-                        }
-                    },
-                })
-            }
-        }
-    }
-
-    async fn build<W: alloy::network::NetworkWallet<ReviveNetwork>>(
-        self,
-        wallet: &W,
-    ) -> Result<<ReviveNetwork as Network>::TxEnvelope, TransactionBuilderError<ReviveNetwork>>
-    {
-        Ok(wallet.sign_request(self).await?)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ReviveHeader {
-    /// The Keccak 256-bit hash of the parent
-    /// block’s header, in its entirety; formally Hp.
-    pub parent_hash: B256,
-    /// The Keccak 256-bit hash of the ommers list portion of this block; formally Ho.
-    #[serde(rename = "sha3Uncles", alias = "ommersHash")]
-    pub ommers_hash: B256,
-    /// The 160-bit address to which all fees collected from the successful mining of this block
-    /// be transferred; formally Hc.
-    #[serde(rename = "miner", alias = "beneficiary")]
-    pub beneficiary: Address,
-    /// The Keccak 256-bit hash of the root node of the state trie, after all transactions are
-    /// executed and finalisations applied; formally Hr.
-    pub state_root: B256,
-    /// The Keccak 256-bit hash of the root node of the trie structure populated with each
-    /// transaction in the transactions list portion of the block; formally Ht.
-    pub transactions_root: B256,
-    /// The Keccak 256-bit hash of the root node of the trie structure populated with the receipts
-    /// of each transaction in the transactions list portion of the block; formally He.
-    pub receipts_root: B256,
-    /// The Bloom filter composed from indexable information (logger address and log topics)
-    /// contained in each log entry from the receipt of each transaction in the transactions list;
-    /// formally Hb.
-    pub logs_bloom: Bloom,
-    /// A scalar value corresponding to the difficulty level of this block. This can be calculated
-    /// from the previous block’s difficulty level and the timestamp; formally Hd.
-    pub difficulty: U256,
-    /// A scalar value equal to the number of ancestor blocks. The genesis block has a number of
-    /// zero; formally Hi.
-    #[serde(with = "alloy::serde::quantity")]
-    pub number: BlockNumber,
-    /// A scalar value equal to the current limit of gas expenditure per block; formally Hl.
-    // This is the main difference over the Ethereum network implementation. We use u128 here and
-    // not u64.
-    #[serde(with = "alloy::serde::quantity")]
-    pub gas_limit: u128,
-    /// A scalar value equal to the total gas used in transactions in this block; formally Hg.
-    #[serde(with = "alloy::serde::quantity")]
-    pub gas_used: u64,
-    /// A scalar value equal to the reasonable output of Unix’s time() at this block’s inception;
-    /// formally Hs.
-    #[serde(with = "alloy::serde::quantity")]
-    pub timestamp: u64,
-    /// An arbitrary byte array containing data relevant to this block. This must be 32 bytes or
-    /// fewer; formally Hx.
-    pub extra_data: Bytes,
-    /// A 256-bit hash which, combined with the
-    /// nonce, proves that a sufficient amount of computation has been carried out on this block;
-    /// formally Hm.
-    pub mix_hash: B256,
-    /// A 64-bit value which, combined with the mixhash, proves that a sufficient amount of
-    /// computation has been carried out on this block; formally Hn.
-    pub nonce: B64,
-    /// A scalar representing EIP1559 base fee which can move up or down each block according
-    /// to a formula which is a function of gas used in parent block and gas target
-    /// (block gas limit divided by elasticity multiplier) of parent block.
-    /// The algorithm results in the base fee per gas increasing when blocks are
-    /// above the gas target, and decreasing when blocks are below the gas target. The base fee per
-    /// gas is burned.
-    #[serde(
-        default,
-        with = "alloy::serde::quantity::opt",
-        skip_serializing_if = "Option::is_none"
-    )]
-    pub base_fee_per_gas: Option<u64>,
-    /// The Keccak 256-bit hash of the withdrawals list portion of this block.
-    /// <https://eips.ethereum.org/EIPS/eip-4895>
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub withdrawals_root: Option<B256>,
-    /// The total amount of blob gas consumed by the transactions within the block, added in
-    /// EIP-4844.
-    #[serde(
-        default,
-        with = "alloy::serde::quantity::opt",
-        skip_serializing_if = "Option::is_none"
-    )]
-    pub blob_gas_used: Option<u64>,
-    /// A running total of blob gas consumed in excess of the target, prior to the block. Blocks
-    /// with above-target blob gas consumption increase this value, blocks with below-target blob
-    /// gas consumption decrease it (bounded at 0). This was added in EIP-4844.
-    #[serde(
-        default,
-        with = "alloy::serde::quantity::opt",
-        skip_serializing_if = "Option::is_none"
-    )]
-    pub excess_blob_gas: Option<u64>,
-    /// The hash of the parent beacon block's root is included in execution blocks, as proposed by
-    /// EIP-4788.
-    ///
-    /// This enables trust-minimized access to consensus state, supporting staking pools, bridges,
-    /// and more.
-    ///
-    /// The beacon roots contract handles root storage, enhancing Ethereum's functionalities.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub parent_beacon_block_root: Option<B256>,
-    /// The Keccak 256-bit hash of the an RLP encoded list with each
-    /// [EIP-7685] request in the block body.
-    ///
-    /// [EIP-7685]: https://eips.ethereum.org/EIPS/eip-7685
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub requests_hash: Option<B256>,
-}
-
-impl BlockHeader for ReviveHeader {
-    fn parent_hash(&self) -> B256 {
-        self.parent_hash
-    }
-
-    fn ommers_hash(&self) -> B256 {
-        self.ommers_hash
-    }
-
-    fn beneficiary(&self) -> Address {
-        self.beneficiary
-    }
-
-    fn state_root(&self) -> B256 {
-        self.state_root
-    }
-
-    fn transactions_root(&self) -> B256 {
-        self.transactions_root
-    }
-
-    fn receipts_root(&self) -> B256 {
-        self.receipts_root
-    }
-
-    fn withdrawals_root(&self) -> Option<B256> {
-        self.withdrawals_root
-    }
-
-    fn logs_bloom(&self) -> Bloom {
-        self.logs_bloom
-    }
-
-    fn difficulty(&self) -> U256 {
-        self.difficulty
-    }
-
-    fn number(&self) -> BlockNumber {
-        self.number
-    }
-
-    // There's sadly nothing that we can do about this. We're required to implement this trait on
-    // any type that represents a header and the gas limit type used here is a u64.
-    fn gas_limit(&self) -> u64 {
-        self.gas_limit.try_into().unwrap_or(u64::MAX)
-    }
-
-    fn gas_used(&self) -> u64 {
-        self.gas_used
-    }
-
-    fn timestamp(&self) -> u64 {
-        self.timestamp
-    }
-
-    fn mix_hash(&self) -> Option<B256> {
-        Some(self.mix_hash)
-    }
-
-    fn nonce(&self) -> Option<B64> {
-        Some(self.nonce)
-    }
-
-    fn base_fee_per_gas(&self) -> Option<u64> {
-        self.base_fee_per_gas
-    }
-
-    fn blob_gas_used(&self) -> Option<u64> {
-        self.blob_gas_used
-    }
-
-    fn excess_blob_gas(&self) -> Option<u64> {
-        self.excess_blob_gas
-    }
-
-    fn parent_beacon_block_root(&self) -> Option<B256> {
-        self.parent_beacon_block_root
-    }
-
-    fn requests_hash(&self) -> Option<B256> {
-        self.requests_hash
-    }
-
-    fn extra_data(&self) -> &Bytes {
-        &self.extra_data
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use alloy::rpc::types::TransactionRequest;
@@ -1149,7 +611,7 @@ mod tests {
     use std::fs;
 
     use super::*;
-    use crate::Node;
+    use crate::node_implementations::common::chainspec::eth_to_polkadot_address;
 
     fn test_config() -> TestExecutionContext {
         TestExecutionContext::default()
@@ -1178,6 +640,7 @@ mod tests {
         let mut node = SubstrateNode::new(
             context.kitchensink_configuration.path.clone(),
             SubstrateNode::KITCHENSINK_EXPORT_CHAINSPEC_COMMAND,
+            None,
             &context,
         );
         node.init(context.genesis_configuration.genesis().unwrap().clone())
@@ -1243,6 +706,7 @@ mod tests {
         let mut dummy_node = SubstrateNode::new(
             context.kitchensink_configuration.path.clone(),
             SubstrateNode::KITCHENSINK_EXPORT_CHAINSPEC_COMMAND,
+            None,
             &context,
         );
 
@@ -1260,12 +724,10 @@ mod tests {
         let contents = fs::read_to_string(&final_chainspec_path).expect("Failed to read chainspec");
 
         // Validate that the Substrate addresses derived from the Ethereum addresses are in the file
-        let first_eth_addr = SubstrateNode::eth_to_substrate_address(
-            &"90F8bf6A479f320ead074411a4B0e7944Ea8c9C1".parse().unwrap(),
-        );
-        let second_eth_addr = SubstrateNode::eth_to_substrate_address(
-            &"Ab8483F64d9C6d1EcF9b849Ae677dD3315835cb2".parse().unwrap(),
-        );
+        let first_eth_addr =
+            eth_to_polkadot_address(&"90F8bf6A479f320ead074411a4B0e7944Ea8c9C1".parse().unwrap());
+        let second_eth_addr =
+            eth_to_polkadot_address(&"Ab8483F64d9C6d1EcF9b849Ae677dD3315835cb2".parse().unwrap());
 
         assert!(
             contents.contains(&first_eth_addr),
@@ -1277,96 +739,6 @@ mod tests {
         );
     }
 
-    #[test]
-    #[ignore = "Ignored since they take a long time to run"]
-    fn test_parse_genesis_alloc() {
-        // Create test genesis file
-        let genesis_json = r#"
-        {
-          "alloc": {
-            "0x90F8bf6A479f320ead074411a4B0e7944Ea8c9C1": { "balance": "1000000000000000000" },
-            "0x0000000000000000000000000000000000000000": { "balance": "0xDE0B6B3A7640000" },
-            "0xffffffffffffffffffffffffffffffffffffffff": { "balance": "123456789" }
-          }
-        }
-        "#;
-
-        let context = test_config();
-        let node = SubstrateNode::new(
-            context.kitchensink_configuration.path.clone(),
-            SubstrateNode::KITCHENSINK_EXPORT_CHAINSPEC_COMMAND,
-            &context,
-        );
-
-        let result = node
-            .extract_balance_from_genesis_file(&serde_json::from_str(genesis_json).unwrap())
-            .unwrap();
-
-        let result_map: std::collections::HashMap<_, _> = result.into_iter().collect();
-
-        assert_eq!(
-            result_map.get("5FLneRcWAfk3X3tg6PuGyLNGAquPAZez5gpqvyuf3yUK8VaV"),
-            Some(&1_000_000_000_000_000_000u128)
-        );
-
-        assert_eq!(
-            result_map.get("5C4hrfjw9DjXZTzV3MwzrrAr9P1MLDHajjSidz9bR544LEq1"),
-            Some(&1_000_000_000_000_000_000u128)
-        );
-
-        assert_eq!(
-            result_map.get("5HrN7fHLXWcFiXPwwtq2EkSGns9eMmoUQnbVKweNz3VVr6N4"),
-            Some(&123_456_789u128)
-        );
-    }
-
-    #[test]
-    #[ignore = "Ignored since they take a long time to run"]
-    fn print_eth_to_substrate_mappings() {
-        let eth_addresses = vec![
-            "0x90F8bf6A479f320ead074411a4B0e7944Ea8c9C1",
-            "0xffffffffffffffffffffffffffffffffffffffff",
-            "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1",
-        ];
-
-        for eth_addr in eth_addresses {
-            let ss58 = SubstrateNode::eth_to_substrate_address(&eth_addr.parse().unwrap());
-
-            println!("Ethereum: {eth_addr} -> Substrate SS58: {ss58}");
-        }
-    }
-
-    #[test]
-    #[ignore = "Ignored since they take a long time to run"]
-    fn test_eth_to_substrate_address() {
-        let cases = vec![
-            (
-                "0x90F8bf6A479f320ead074411a4B0e7944Ea8c9C1",
-                "5FLneRcWAfk3X3tg6PuGyLNGAquPAZez5gpqvyuf3yUK8VaV",
-            ),
-            (
-                "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1",
-                "5FLneRcWAfk3X3tg6PuGyLNGAquPAZez5gpqvyuf3yUK8VaV",
-            ),
-            (
-                "0x0000000000000000000000000000000000000000",
-                "5C4hrfjw9DjXZTzV3MwzrrAr9P1MLDHajjSidz9bR544LEq1",
-            ),
-            (
-                "0xffffffffffffffffffffffffffffffffffffffff",
-                "5HrN7fHLXWcFiXPwwtq2EkSGns9eMmoUQnbVKweNz3VVr6N4",
-            ),
-        ];
-
-        for (eth_addr, expected_ss58) in cases {
-            let result = SubstrateNode::eth_to_substrate_address(&eth_addr.parse().unwrap());
-            assert_eq!(
-                result, expected_ss58,
-                "Mismatch for Ethereum address {eth_addr}"
-            );
-        }
-    }
-
     #[test]
     #[ignore = "Ignored since they take a long time to run"]
     fn version_works() {

crates/node/src/node_implementations/zombienet.rs

@@ -0,0 +1,951 @@
+//! # ZombieNode Implementation
+//!
+//! ## Required Binaries
+//! This module requires the following binaries to be compiled and available in your PATH:
+//!
+//! 1. **polkadot-parachain**:
+//!    ```bash
+//!    git clone https://github.com/paritytech/polkadot-sdk.git
+//!    cd polkadot-sdk
+//!    cargo build --release --locked -p polkadot-parachain-bin --bin polkadot-parachain
+//!    ```
+//!
+//! 2. **eth-rpc** (Revive EVM RPC server):
+//!    ```bash
+//!    git clone https://github.com/paritytech/polkadot-sdk.git
+//!    cd polkadot-sdk
+//!    cargo build --locked --profile production -p pallet-revive-eth-rpc --bin eth-rpc
+//!    ```
+//!
+//! 3. **polkadot** (for the relay chain):
+//!    ```bash
+//!    # In polkadot-sdk directory
+//!    cargo build --locked --profile testnet --features fast-runtime --bin polkadot --bin polkadot-prepare-worker --bin polkadot-execute-worker
+//!    ```
+//!
+//! Make sure to add the build output directories to your PATH or provide
+//! the full paths in your configuration.
+
+use std::{
+    fs::{create_dir_all, remove_dir_all},
+    path::PathBuf,
+    pin::Pin,
+    sync::{
+        Arc,
+        atomic::{AtomicU32, Ordering},
+    },
+    time::Duration,
+};
+
+use alloy::{
+    eips::BlockNumberOrTag,
+    genesis::Genesis,
+    network::EthereumWallet,
+    primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, StorageKey, TxHash, U256},
+    providers::{
+        Provider,
+        ext::DebugApi,
+        fillers::{CachedNonceManager, ChainIdFiller, FillProvider, NonceFiller, TxFiller},
+    },
+    rpc::types::{
+        EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest,
+        trace::geth::{DiffMode, GethDebugTracingOptions, PreStateConfig, PreStateFrame},
+    },
+};
+
+use anyhow::Context as _;
+use async_stream::stream;
+use futures::Stream;
+use revive_common::EVMVersion;
+use revive_dt_common::fs::clear_directory;
+use revive_dt_config::*;
+use revive_dt_format::traits::ResolverApi;
+use revive_dt_node_interaction::{EthereumNode, MinedBlockInformation};
+use tokio::sync::OnceCell;
+use tracing::instrument;
+use zombienet_sdk::{LocalFileSystem, NetworkConfigBuilder, NetworkConfigExt};
+
+use crate::{
+    Node,
+    constants::INITIAL_BALANCE,
+    helpers::Process,
+    node_implementations::common::{
+        chainspec::export_and_patch_chainspec_json,
+        process::{command_version, spawn_eth_rpc_process},
+        revive::ReviveNetwork,
+    },
+    provider_utils::{
+        ConcreteProvider, FallbackGasFiller, construct_concurrency_limited_provider,
+        execute_transaction,
+    },
+};
+
+static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
+
+/// A Zombienet network where collator is `polkadot-parachain` node with `eth-rpc` [`ZombieNode`]
+/// abstracts away the details of managing the zombienet network and provides an interface to
+/// interact with the parachain's Ethereum RPC.
+#[derive(Debug, Default)]
+pub struct ZombienetNode {
+    /* Node Identifier */
+    id: u32,
+    connection_string: String,
+    node_rpc_port: Option<u16>,
+
+    /* Directory Paths */
+    base_directory: PathBuf,
+    logs_directory: PathBuf,
+
+    /* Binary Paths & Timeouts */
+    eth_proxy_binary: PathBuf,
+    polkadot_parachain_path: PathBuf,
+
+    /* Spawned Processes */
+    eth_rpc_process: Option<Process>,
+
+    /* Zombienet Network */
+    network_config: Option<zombienet_sdk::NetworkConfig>,
+    network: Option<zombienet_sdk::Network<LocalFileSystem>>,
+
+    /* Provider Related Fields */
+    wallet: Arc<EthereumWallet>,
+    nonce_manager: CachedNonceManager,
+
+    provider: OnceCell<ConcreteProvider<ReviveNetwork, Arc<EthereumWallet>>>,
+}
+
+impl ZombienetNode {
+    const BASE_DIRECTORY: &str = "zombienet";
+    const DATA_DIRECTORY: &str = "data";
+    const LOGS_DIRECTORY: &str = "logs";
+
+    const NODE_BASE_RPC_PORT: u16 = 9946;
+    const PARACHAIN_ID: u32 = 100;
+    const ETH_RPC_BASE_PORT: u16 = 8545;
+
+    const ETH_RPC_READY_MARKER: &str = "Running JSON-RPC server";
+
+    const EXPORT_CHAINSPEC_COMMAND: &str = "build-spec";
+    const CHAIN_SPEC_JSON_FILE: &str = "template_chainspec.json";
+
+    pub fn new(
+        polkadot_parachain_path: PathBuf,
+        context: impl AsRef<WorkingDirectoryConfiguration>
+        + AsRef<EthRpcConfiguration>
+        + AsRef<WalletConfiguration>,
+    ) -> Self {
+        let eth_proxy_binary = AsRef::<EthRpcConfiguration>::as_ref(&context)
+            .path
+            .to_owned();
+        let working_directory_path = AsRef::<WorkingDirectoryConfiguration>::as_ref(&context);
+        let id = NODE_COUNT.fetch_add(1, Ordering::SeqCst);
+        let base_directory = working_directory_path
+            .join(Self::BASE_DIRECTORY)
+            .join(id.to_string());
+        let base_directory = base_directory.canonicalize().unwrap_or(base_directory);
+        let logs_directory = base_directory.join(Self::LOGS_DIRECTORY);
+        let wallet = AsRef::<WalletConfiguration>::as_ref(&context).wallet();
+
+        Self {
+            id,
+            base_directory,
+            logs_directory,
+            wallet,
+            polkadot_parachain_path,
+            eth_proxy_binary,
+            nonce_manager: CachedNonceManager::default(),
+            network_config: None,
+            network: None,
+            eth_rpc_process: None,
+            connection_string: String::new(),
+            node_rpc_port: None,
+            provider: Default::default(),
+        }
+    }
+
+    fn init(&mut self, mut genesis: Genesis) -> anyhow::Result<&mut Self> {
+        let _ = clear_directory(&self.base_directory);
+        let _ = clear_directory(&self.logs_directory);
+
+        create_dir_all(&self.base_directory)
+            .context("Failed to create base directory for zombie node")?;
+        create_dir_all(&self.logs_directory)
+            .context("Failed to create logs directory for zombie node")?;
+
+        let template_chainspec_path = self.base_directory.join(Self::CHAIN_SPEC_JSON_FILE);
+        export_and_patch_chainspec_json(
+            &self.polkadot_parachain_path,
+            Self::EXPORT_CHAINSPEC_COMMAND,
+            "asset-hub-westend-local",
+            &template_chainspec_path,
+            &mut genesis,
+            &self.wallet,
+            INITIAL_BALANCE,
+        )?;
+
+        let polkadot_parachain_path = self
+            .polkadot_parachain_path
+            .to_str()
+            .context("Invalid polkadot parachain path")?;
+
+        let node_rpc_port = Self::NODE_BASE_RPC_PORT + self.id as u16;
+
+        let network_config = NetworkConfigBuilder::new()
+            .with_relaychain(|relay_chain| {
+                relay_chain
+                    .with_chain("westend-local")
+                    .with_default_command("polkadot")
+                    .with_node(|node| node.with_name("alice"))
+                    .with_node(|node| node.with_name("bob"))
+            })
+            .with_global_settings(|global_settings| {
+                // global_settings.with_base_dir(&self.base_directory)
+                global_settings
+            })
+            .with_parachain(|parachain| {
+                parachain
+                    .with_id(Self::PARACHAIN_ID)
+                    .with_chain_spec_path(template_chainspec_path.to_path_buf())
+                    .with_chain("asset-hub-westend-local")
+                    .with_collator(|node_config| {
+                        node_config
+                            .with_name("Collator")
+                            .with_command(polkadot_parachain_path)
+                            .with_rpc_port(node_rpc_port)
+                            .with_args(vec![
+                                ("--pool-limit", u32::MAX.to_string().as_str()).into(),
+                                ("--pool-kbytes", u32::MAX.to_string().as_str()).into(),
+                            ])
+                    })
+            })
+            .build()
+            .map_err(|err| anyhow::anyhow!("Failed to build zombienet network config: {err:?}"))?;
+
+        self.node_rpc_port = Some(node_rpc_port);
+        self.network_config = Some(network_config);
+
+        Ok(self)
+    }
+
+    fn spawn_process(&mut self) -> anyhow::Result<()> {
+        let network_config = self
+            .network_config
+            .clone()
+            .context("Node not initialized, call init() first")?;
+
+        // TODO: Look into the possibility of removing this in the future, perhaps by reintroducing
+        // the blocking runtime abstraction and making it available to the entire program so that we
+        // don't need to be spawning multiple different runtimes.
+        let rt = tokio::runtime::Runtime::new().unwrap();
+        let network = rt.block_on(async {
+            network_config
+                .spawn_native()
+                .await
+                .map_err(|e| anyhow::anyhow!("Failed to spawn zombienet network: {e:?}"))
+        })?;
+
+        tracing::debug!("Zombienet network is up");
+
+        let node_url = format!("ws://localhost:{}", self.node_rpc_port.unwrap());
+        let eth_rpc_port = Self::ETH_RPC_BASE_PORT + self.id as u16;
+
+        let eth_rpc_process = spawn_eth_rpc_process(
+            self.logs_directory.as_path(),
+            self.eth_proxy_binary.as_path(),
+            &node_url,
+            eth_rpc_port,
+            &[], // extra args
+            Self::ETH_RPC_READY_MARKER,
+        );
+
+        match eth_rpc_process {
+            Ok(process) => self.eth_rpc_process = Some(process),
+            Err(err) => {
+                tracing::error!(?err, "Failed to start eth proxy, shutting down gracefully");
+                self.shutdown()
+                    .context("Failed to gracefully shutdown after eth proxy start error")?;
+                return Err(err);
+            }
+        }
+
+        tracing::debug!("eth-rpc is up");
+
+        self.connection_string = format!("http://localhost:{}", eth_rpc_port);
+        self.network = Some(network);
+
+        Ok(())
+    }
+
+    pub fn eth_rpc_version(&self) -> anyhow::Result<String> {
+        command_version(&self.eth_proxy_binary)
+    }
+
+    async fn provider(
+        &self,
+    ) -> anyhow::Result<ConcreteProvider<ReviveNetwork, Arc<EthereumWallet>>> {
+        self.provider
+            .get_or_try_init(|| async move {
+                construct_concurrency_limited_provider::<ReviveNetwork, _>(
+                    self.connection_string.as_str(),
+                    FallbackGasFiller::new(u64::MAX, 5_000_000_000, 1_000_000_000),
+                    ChainIdFiller::default(), // TODO: use CHAIN_ID constant
+                    NonceFiller::new(self.nonce_manager.clone()),
+                    self.wallet.clone(),
+                )
+                .await
+                .context("Failed to construct the provider")
+            })
+            .await
+            .cloned()
+    }
+}
+
+impl EthereumNode for ZombienetNode {
+    fn pre_transactions(&mut self) -> Pin<Box<dyn Future<Output = anyhow::Result<()>> + '_>> {
+        Box::pin(async move { Ok(()) })
+    }
+
+    fn id(&self) -> usize {
+        self.id as _
+    }
+
+    fn connection_string(&self) -> &str {
+        &self.connection_string
+    }
+
+    fn submit_transaction(
+        &self,
+        transaction: TransactionRequest,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<TxHash>> + '_>> {
+        Box::pin(async move {
+            let provider = self
+                .provider()
+                .await
+                .context("Failed to create the provider for transaction submission")?;
+            let pending_transaction = provider
+                .send_transaction(transaction)
+                .await
+                .context("Failed to submit the transaction through the provider")?;
+            Ok(*pending_transaction.tx_hash())
+        })
+    }
+
+    fn get_receipt(
+        &self,
+        tx_hash: TxHash,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<TransactionReceipt>> + '_>> {
+        Box::pin(async move {
+            self.provider()
+                .await
+                .context("Failed to create provider for getting the receipt")?
+                .get_transaction_receipt(tx_hash)
+                .await
+                .context("Failed to get the receipt of the transaction")?
+                .context("Failed to get the receipt of the transaction")
+        })
+    }
+
+    fn execute_transaction(
+        &self,
+        transaction: alloy::rpc::types::TransactionRequest,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<TransactionReceipt>> + '_>> {
+        Box::pin(async move {
+            let provider = self
+                .provider()
+                .await
+                .context("Failed to create the provider")?;
+            execute_transaction(provider, transaction).await
+        })
+    }
+
+    fn trace_transaction(
+        &self,
+        tx_hash: TxHash,
+        trace_options: GethDebugTracingOptions,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<alloy::rpc::types::trace::geth::GethTrace>> + '_>>
+    {
+        Box::pin(async move {
+            self.provider()
+                .await
+                .context("Failed to create provider for debug tracing")?
+                .debug_trace_transaction(tx_hash, trace_options)
+                .await
+                .context("Failed to obtain debug trace from proxy")
+        })
+    }
+
+    fn state_diff(
+        &self,
+        tx_hash: TxHash,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<DiffMode>> + '_>> {
+        Box::pin(async move {
+            let trace_options = GethDebugTracingOptions::prestate_tracer(PreStateConfig {
+                diff_mode: Some(true),
+                disable_code: None,
+                disable_storage: None,
+            });
+            match self
+                .trace_transaction(tx_hash, trace_options)
+                .await?
+                .try_into_pre_state_frame()?
+            {
+                PreStateFrame::Diff(diff) => Ok(diff),
+                _ => anyhow::bail!("expected a diff mode trace"),
+            }
+        })
+    }
+
+    fn balance_of(
+        &self,
+        address: Address,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<U256>> + '_>> {
+        Box::pin(async move {
+            self.provider()
+                .await
+                .context("Failed to get the zombie provider")?
+                .get_balance(address)
+                .await
+                .map_err(Into::into)
+        })
+    }
+
+    fn latest_state_proof(
+        &self,
+        address: Address,
+        keys: Vec<StorageKey>,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<EIP1186AccountProofResponse>> + '_>> {
+        Box::pin(async move {
+            self.provider()
+                .await
+                .context("Failed to get the zombie provider")?
+                .get_proof(address, keys)
+                .latest()
+                .await
+                .map_err(Into::into)
+        })
+    }
+
+    fn resolver(
+        &self,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<Arc<dyn ResolverApi + '_>>> + '_>> {
+        Box::pin(async move {
+            let id = self.id;
+            let provider = self.provider().await?;
+
+            Ok(Arc::new(ZombieNodeResolver { id, provider }) as Arc<dyn ResolverApi>)
+        })
+    }
+
+    fn evm_version(&self) -> EVMVersion {
+        EVMVersion::Cancun
+    }
+
+    fn subscribe_to_full_blocks_information(
+        &self,
+    ) -> Pin<
+        Box<
+            dyn Future<Output = anyhow::Result<Pin<Box<dyn Stream<Item = MinedBlockInformation>>>>>
+                + '_,
+        >,
+    > {
+        fn create_stream(
+            provider: ConcreteProvider<ReviveNetwork, Arc<EthereumWallet>>,
+        ) -> impl Stream<Item = MinedBlockInformation> {
+            stream! {
+                let mut block_number = provider.get_block_number().await.expect("Failed to get the block number");
+                loop {
+                    tokio::time::sleep(Duration::from_secs(1)).await;
+
+                    let Ok(Some(block)) = provider.get_block_by_number(BlockNumberOrTag::Number(block_number)).await
+                    else {
+                        continue;
+                    };
+
+                    block_number += 1;
+                    yield MinedBlockInformation {
+                        block_number: block.number(),
+                        block_timestamp: block.header.timestamp,
+                        mined_gas: block.header.gas_used as _,
+                        block_gas_limit: block.header.gas_limit,
+                        transaction_hashes: block
+                            .transactions
+                            .into_hashes()
+                            .as_hashes()
+                            .expect("Must be hashes")
+                            .to_vec(),
+                    };
+                };
+            }
+        }
+
+        Box::pin(async move {
+            let provider = self
+                .provider()
+                .await
+                .context("Failed to create the provider for a block subscription")?;
+
+            let stream = Box::pin(create_stream(provider))
+                as Pin<Box<dyn Stream<Item = MinedBlockInformation>>>;
+
+            Ok(stream)
+        })
+    }
+}
+
+pub struct ZombieNodeResolver<F: TxFiller<ReviveNetwork>, P: Provider<ReviveNetwork>> {
+    id: u32,
+    provider: FillProvider<F, P, ReviveNetwork>,
+}
+
+impl<F: TxFiller<ReviveNetwork>, P: Provider<ReviveNetwork>> ResolverApi
+    for ZombieNodeResolver<F, P>
+{
+    #[instrument(level = "info", skip_all, fields(zombie_node_id = self.id))]
+    fn chain_id(
+        &self,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<alloy::primitives::ChainId>> + '_>> {
+        Box::pin(async move { self.provider.get_chain_id().await.map_err(Into::into) })
+    }
+
+    #[instrument(level = "info", skip_all, fields(zombie_node_id = self.id))]
+    fn transaction_gas_price(
+        &self,
+        tx_hash: TxHash,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<u128>> + '_>> {
+        Box::pin(async move {
+            self.provider
+                .get_transaction_receipt(tx_hash)
+                .await?
+                .context("Failed to get the transaction receipt")
+                .map(|receipt| receipt.effective_gas_price)
+        })
+    }
+
+    #[instrument(level = "info", skip_all, fields(zombie_node_id = self.id))]
+    fn block_gas_limit(
+        &self,
+        number: BlockNumberOrTag,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<u128>> + '_>> {
+        Box::pin(async move {
+            self.provider
+                .get_block_by_number(number)
+                .await
+                .context("Failed to get the block")?
+                .context("Failed to get the block, perhaps the chain has no blocks?")
+                .map(|block| block.header.gas_limit as _)
+        })
+    }
+
+    #[instrument(level = "info", skip_all, fields(zombie_node_id = self.id))]
+    fn block_coinbase(
+        &self,
+        number: BlockNumberOrTag,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<Address>> + '_>> {
+        Box::pin(async move {
+            self.provider
+                .get_block_by_number(number)
+                .await
+                .context("Failed to get the zombie block")?
+                .context("Failed to get the zombie block, perhaps the chain has no blocks?")
+                .map(|block| block.header.beneficiary)
+        })
+    }
+
+    #[instrument(level = "info", skip_all, fields(zombie_node_id = self.id))]
+    fn block_difficulty(
+        &self,
+        number: BlockNumberOrTag,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<U256>> + '_>> {
+        Box::pin(async move {
+            self.provider
+                .get_block_by_number(number)
+                .await
+                .context("Failed to get the zombie block")?
+                .context("Failed to get the zombie block, perhaps the chain has no blocks?")
+                .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
+        })
+    }
+
+    #[instrument(level = "info", skip_all, fields(zombie_node_id = self.id))]
+    fn block_base_fee(
+        &self,
+        number: BlockNumberOrTag,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<u64>> + '_>> {
+        Box::pin(async move {
+            self.provider
+                .get_block_by_number(number)
+                .await
+                .context("Failed to get the zombie block")?
+                .context("Failed to get the zombie block, perhaps the chain has no blocks?")
+                .and_then(|block| {
+                    block
+                        .header
+                        .base_fee_per_gas
+                        .context("Failed to get the base fee per gas")
+                })
+        })
+    }
+
+    #[instrument(level = "info", skip_all, fields(zombie_node_id = self.id))]
+    fn block_hash(
+        &self,
+        number: BlockNumberOrTag,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<BlockHash>> + '_>> {
+        Box::pin(async move {
+            self.provider
+                .get_block_by_number(number)
+                .await
+                .context("Failed to get the zombie block")?
+                .context("Failed to get the zombie block, perhaps the chain has no blocks?")
+                .map(|block| block.header.hash)
+        })
+    }
+
+    #[instrument(level = "info", skip_all, fields(zombie_node_id = self.id))]
+    fn block_timestamp(
+        &self,
+        number: BlockNumberOrTag,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<BlockTimestamp>> + '_>> {
+        Box::pin(async move {
+            self.provider
+                .get_block_by_number(number)
+                .await
+                .context("Failed to get the zombie block")?
+                .context("Failed to get the zombie block, perhaps the chain has no blocks?")
+                .map(|block| block.header.timestamp)
+        })
+    }
+
+    #[instrument(level = "info", skip_all, fields(zombie_node_id = self.id))]
+    fn last_block_number(&self) -> Pin<Box<dyn Future<Output = anyhow::Result<BlockNumber>> + '_>> {
+        Box::pin(async move { self.provider.get_block_number().await.map_err(Into::into) })
+    }
+}
+
+impl Node for ZombienetNode {
+    fn shutdown(&mut self) -> anyhow::Result<()> {
+        // Kill the eth_rpc process
+        drop(self.eth_rpc_process.take());
+
+        // Destroy the network
+        if let Some(network) = self.network.take() {
+            // Handle network cleanup here
+            tokio::task::spawn_blocking(move || {
+                let rt = tokio::runtime::Runtime::new().unwrap();
+                rt.block_on(async {
+                    if let Err(e) = network.destroy().await {
+                        tracing::warn!("Failed to destroy zombienet network: {e:?}");
+                    }
+                })
+            });
+        }
+
+        // Remove the database directory
+        if let Err(e) = remove_dir_all(self.base_directory.join(Self::DATA_DIRECTORY)) {
+            tracing::warn!("Failed to remove database directory: {e:?}");
+        }
+
+        Ok(())
+    }
+
+    fn spawn(&mut self, genesis: Genesis) -> anyhow::Result<()> {
+        self.init(genesis)?.spawn_process()
+    }
+
+    fn version(&self) -> anyhow::Result<String> {
+        command_version(&self.polkadot_parachain_path)
+    }
+}
+
+impl Drop for ZombienetNode {
+    fn drop(&mut self) {
+        let _ = self.shutdown();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use alloy::rpc::types::TransactionRequest;
+
+    use crate::node_implementations::{
+        common::chainspec::eth_to_polkadot_address, zombienet::tests::utils::shared_node,
+    };
+
+    use super::*;
+
+    mod utils {
+        use super::*;
+
+        use std::sync::Arc;
+        use tokio::sync::OnceCell;
+
+        pub fn test_config() -> TestExecutionContext {
+            TestExecutionContext::default()
+        }
+
+        pub async fn new_node() -> (TestExecutionContext, ZombienetNode) {
+            let context = test_config();
+            let mut node = ZombienetNode::new(
+                context.polkadot_parachain_configuration.path.clone(),
+                &context,
+            );
+            let genesis = context.genesis_configuration.genesis().unwrap().clone();
+            node.init(genesis).unwrap();
+
+            // Run spawn_process in a blocking thread
+            let node = tokio::task::spawn_blocking(move || {
+                node.spawn_process().unwrap();
+                node
+            })
+            .await
+            .expect("Failed to spawn process");
+
+            (context, node)
+        }
+
+        pub async fn shared_state() -> &'static (TestExecutionContext, Arc<ZombienetNode>) {
+            static NODE: OnceCell<(TestExecutionContext, Arc<ZombienetNode>)> =
+                OnceCell::const_new();
+
+            NODE.get_or_init(|| async {
+                let (context, node) = new_node().await;
+                (context, Arc::new(node))
+            })
+            .await
+        }
+
+        pub async fn shared_node() -> &'static Arc<ZombienetNode> {
+            &shared_state().await.1
+        }
+    }
+    use utils::{new_node, test_config};
+
+    #[tokio::test]
+    #[ignore = "Ignored for the time being"]
+    async fn test_transfer_transaction_should_return_receipt() {
+        let (ctx, node) = new_node().await;
+
+        let provider = node.provider().await.expect("Failed to create provider");
+        let account_address = ctx.wallet_configuration.wallet().default_signer().address();
+        let transaction = TransactionRequest::default()
+            .to(account_address)
+            .value(U256::from(100_000_000_000_000u128));
+
+        let receipt = provider.send_transaction(transaction).await;
+        let _ = receipt
+            .expect("Failed to send the transfer transaction")
+            .get_receipt()
+            .await
+            .expect("Failed to get the receipt for the transfer");
+    }
+
+    #[tokio::test]
+    async fn test_init_generates_chainspec_with_balances() {
+        let genesis_content = r#"
+        {
+            "alloc": {
+                "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1": {
+                    "balance": "1000000000000000000"
+                },
+                "Ab8483F64d9C6d1EcF9b849Ae677dD3315835cb2": {
+                    "balance": "2000000000000000000"
+                }
+            }
+        }
+        "#;
+
+        let context = test_config();
+        let mut node = ZombienetNode::new(
+            context.polkadot_parachain_configuration.path.clone(),
+            &context,
+        );
+
+        // Call `init()`
+        node.init(serde_json::from_str(genesis_content).unwrap())
+            .expect("init failed");
+
+        // Check that the patched chainspec file was generated
+        let final_chainspec_path = node
+            .base_directory
+            .join(ZombienetNode::CHAIN_SPEC_JSON_FILE);
+        assert!(final_chainspec_path.exists(), "Chainspec file should exist");
+
+        let contents =
+            std::fs::read_to_string(&final_chainspec_path).expect("Failed to read chainspec");
+
+        // Validate that the Polkadot addresses derived from the Ethereum addresses are in the file
+        let first_eth_addr =
+            eth_to_polkadot_address(&"90F8bf6A479f320ead074411a4B0e7944Ea8c9C1".parse().unwrap());
+        let second_eth_addr =
+            eth_to_polkadot_address(&"Ab8483F64d9C6d1EcF9b849Ae677dD3315835cb2".parse().unwrap());
+
+        assert!(
+            contents.contains(&first_eth_addr),
+            "Chainspec should contain Polkadot address for first Ethereum account"
+        );
+        assert!(
+            contents.contains(&second_eth_addr),
+            "Chainspec should contain Polkadot address for second Ethereum account"
+        );
+    }
+
+    #[test]
+    fn eth_rpc_version_works() {
+        // Arrange
+        let context = test_config();
+        let node = ZombienetNode::new(
+            context.polkadot_parachain_configuration.path.clone(),
+            &context,
+        );
+
+        // Act
+        let version = node.eth_rpc_version().unwrap();
+
+        // Assert
+        assert!(
+            version.starts_with("pallet-revive-eth-rpc"),
+            "Expected eth-rpc version string, got: {version}"
+        );
+    }
+
+    #[test]
+    fn version_works() {
+        // Arrange
+        let context = test_config();
+        let node = ZombienetNode::new(
+            context.polkadot_parachain_configuration.path.clone(),
+            &context,
+        );
+
+        // Act
+        let version = node.version().unwrap();
+
+        // Assert
+        assert!(
+            version.starts_with("polkadot-parachain"),
+            "Expected Polkadot-parachain version string, got: {version}"
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "Ignored since they take a long time to run"]
+    async fn get_chain_id_from_node_should_succeed() {
+        // Arrange
+        let node = shared_node().await;
+
+        // Act
+        let chain_id = node
+            .resolver()
+            .await
+            .expect("Failed to create resolver")
+            .chain_id()
+            .await
+            .expect("Failed to get chain id");
+
+        // Assert
+        assert!(chain_id > 0, "Chain ID should be greater than zero");
+    }
+
+    #[tokio::test]
+    #[ignore = "Ignored since they take a long time to run"]
+    async fn can_get_gas_limit_from_node() {
+        // Arrange
+        let node = shared_node().await;
+
+        // Act
+        let gas_limit = node
+            .resolver()
+            .await
+            .unwrap()
+            .block_gas_limit(BlockNumberOrTag::Latest)
+            .await;
+
+        // Assert
+        let _ = gas_limit.expect("Failed to get the gas limit");
+    }
+
+    #[tokio::test]
+    #[ignore = "Ignored since they take a long time to run"]
+    async fn can_get_coinbase_from_node() {
+        // Arrange
+        let node = shared_node().await;
+
+        // Act
+        let coinbase = node
+            .resolver()
+            .await
+            .unwrap()
+            .block_coinbase(BlockNumberOrTag::Latest)
+            .await;
+
+        // Assert
+        let _ = coinbase.expect("Failed to get the coinbase");
+    }
+
+    #[tokio::test]
+    #[ignore = "Ignored since they take a long time to run"]
+    async fn can_get_block_difficulty_from_node() {
+        // Arrange
+        let node = shared_node().await;
+
+        // Act
+        let block_difficulty = node
+            .resolver()
+            .await
+            .unwrap()
+            .block_difficulty(BlockNumberOrTag::Latest)
+            .await;
+
+        // Assert
+        let _ = block_difficulty.expect("Failed to get the block difficulty");
+    }
+
+    #[tokio::test]
+    #[ignore = "Ignored since they take a long time to run"]
+    async fn can_get_block_hash_from_node() {
+        // Arrange
+        let node = shared_node().await;
+
+        // Act
+        let block_hash = node
+            .resolver()
+            .await
+            .unwrap()
+            .block_hash(BlockNumberOrTag::Latest)
+            .await;
+
+        // Assert
+        let _ = block_hash.expect("Failed to get the block hash");
+    }
+
+    #[tokio::test]
+    #[ignore = "Ignored since they take a long time to run"]
+    async fn can_get_block_timestamp_from_node() {
+        // Arrange
+        let node = shared_node().await;
+
+        // Act
+        let block_timestamp = node
+            .resolver()
+            .await
+            .unwrap()
+            .block_timestamp(BlockNumberOrTag::Latest)
+            .await;
+
+        // Assert
+        let _ = block_timestamp.expect("Failed to get the block timestamp");
+    }
+
+    #[tokio::test]
+    #[ignore = "Ignored since they take a long time to run"]
+    async fn can_get_block_number_from_node() {
+        // Arrange
+        let node = shared_node().await;
+
+        // Act
+        let block_number = node.resolver().await.unwrap().last_block_number().await;
+
+        // Assert
+        let _ = block_number.expect("Failed to get the block number");
+    }
+}

crates/node/src/provider_utils/fallback_gas_filler.rs

@@ -7,6 +7,10 @@ use alloy::{
     transports::TransportResult,
 };
 
+// Percentage padding applied to estimated gas (e.g. 120 = 20% padding)
+const GAS_ESTIMATE_PADDING_NUMERATOR: u64 = 120;
+const GAS_ESTIMATE_PADDING_DENOMINATOR: u64 = 100;
+
 #[derive(Clone, Debug)]
 pub struct FallbackGasFiller {
     inner: GasFiller,
@@ -56,8 +60,6 @@ where
         provider: &P,
         tx: &<N as Network>::TransactionRequest,
     ) -> TransportResult<Self::Fillable> {
-        // Try to fetch GasFiller’s “fillable” (gas_price, base_fee, estimate_gas, …)
-        // If it errors (i.e. tx would revert under eth_estimateGas), swallow it.
         match self.inner.prepare(provider, tx).await {
             Ok(fill) => Ok(Some(fill)),
             Err(_) => Ok(None),
@@ -70,8 +72,17 @@ where
         mut tx: alloy::providers::SendableTx<N>,
     ) -> TransportResult<SendableTx<N>> {
         if let Some(fill) = fillable {
-            // our inner GasFiller succeeded — use it
-            self.inner.fill(fill, tx).await
+            let mut tx = self.inner.fill(fill, tx).await?;
+            if let Some(builder) = tx.as_mut_builder() {
+                if let Some(estimated) = builder.gas_limit() {
+                    let padded = estimated
+                        .checked_mul(GAS_ESTIMATE_PADDING_NUMERATOR)
+                        .and_then(|v| v.checked_div(GAS_ESTIMATE_PADDING_DENOMINATOR))
+                        .unwrap_or(u64::MAX);
+                    builder.set_gas_limit(padded);
+                }
+            }
+            Ok(tx)
         } else {
             if let Some(builder) = tx.as_mut_builder() {
                 builder.set_gas_limit(self.default_gas_limit);

crates/node/src/provider_utils/mod.rs

@@ -1,7 +1,7 @@
 mod concurrency_limiter;
-mod fallback_gas_provider;
+mod fallback_gas_filler;
 mod provider;
 
 pub use concurrency_limiter::*;
-pub use fallback_gas_provider::*;
+pub use fallback_gas_filler::*;
 pub use provider::*;

crates/node/src/provider_utils/provider.rs

@@ -1,14 +1,16 @@
-use std::sync::LazyLock;
+use std::{ops::ControlFlow, sync::LazyLock, time::Duration};
 
 use alloy::{
-    network::{Network, NetworkWallet, TransactionBuilder4844},
+    network::{Ethereum, Network, NetworkWallet, TransactionBuilder4844},
     providers::{
-        Identity, ProviderBuilder, RootProvider,
+        Identity, PendingTransactionBuilder, Provider, ProviderBuilder, RootProvider,
         fillers::{ChainIdFiller, FillProvider, JoinFill, NonceFiller, TxFiller, WalletFiller},
     },
     rpc::client::ClientBuilder,
 };
 use anyhow::{Context, Result};
+use revive_dt_common::futures::{PollingWaitBehavior, poll};
+use tracing::{Instrument, debug, info, info_span};
 
 use crate::provider_utils::{ConcurrencyLimiterLayer, FallbackGasFiller};
 
@@ -42,7 +44,7 @@ where
     // requests at any point of time and no more than that. This is done in an effort to stabilize
     // the framework from some of the interment issues that we've been seeing related to RPC calls.
     static GLOBAL_CONCURRENCY_LIMITER_LAYER: LazyLock<ConcurrencyLimiterLayer> =
-        LazyLock::new(|| ConcurrencyLimiterLayer::new(10));
+        LazyLock::new(|| ConcurrencyLimiterLayer::new(500));
 
     let client = ClientBuilder::default()
         .layer(GLOBAL_CONCURRENCY_LIMITER_LAYER.clone())
@@ -61,3 +63,70 @@ where
 
     Ok(provider)
 }
+
+pub async fn execute_transaction<N, W>(
+    provider: ConcreteProvider<N, W>,
+    transaction: N::TransactionRequest,
+) -> Result<N::ReceiptResponse>
+where
+    N: Network<
+            TransactionRequest: TransactionBuilder4844,
+            TxEnvelope = <Ethereum as Network>::TxEnvelope,
+        >,
+    W: NetworkWallet<N>,
+    Identity: TxFiller<N>,
+    FallbackGasFiller: TxFiller<N>,
+    ChainIdFiller: TxFiller<N>,
+    NonceFiller: TxFiller<N>,
+    WalletFiller<W>: TxFiller<N>,
+{
+    let sendable_transaction = provider
+        .fill(transaction)
+        .await
+        .context("Failed to fill transaction")?;
+
+    let transaction_envelope = sendable_transaction
+        .try_into_envelope()
+        .context("Failed to convert transaction into an envelope")?;
+    let tx_hash = *transaction_envelope.tx_hash();
+
+    let mut pending_transaction = match provider.send_tx_envelope(transaction_envelope).await {
+        Ok(pending_transaction) => pending_transaction,
+        Err(error) => {
+            let error_string = error.to_string();
+
+            if error_string.contains("Transaction Already Imported") {
+                PendingTransactionBuilder::<N>::new(provider.root().clone(), tx_hash)
+            } else {
+                return Err(error).context(format!("Failed to submit transaction {tx_hash}"));
+            }
+        }
+    };
+    debug!(%tx_hash, "Submitted Transaction");
+
+    pending_transaction.set_timeout(Some(Duration::from_secs(120)));
+    let tx_hash = pending_transaction.watch().await.context(format!(
+        "Transaction inclusion watching timeout for {tx_hash}"
+    ))?;
+
+    poll(
+        Duration::from_secs(60),
+        PollingWaitBehavior::Constant(Duration::from_secs(3)),
+        || {
+            let provider = provider.clone();
+
+            async move {
+                match provider.get_transaction_receipt(tx_hash).await {
+                    Ok(Some(receipt)) => {
+                        info!("Found the transaction receipt");
+                        Ok(ControlFlow::Break(receipt))
+                    }
+                    _ => Ok(ControlFlow::Continue(())),
+                }
+            }
+        },
+    )
+    .instrument(info_span!("Polling for receipt", %tx_hash))
+    .await
+    .context(format!("Polling for receipt failed for {tx_hash}"))
+}

run_tests.sh

@@ -76,8 +76,6 @@ cat > "$CORPUS_FILE" << EOF
 {
   "name": "MatterLabs Solidity Simple, Complex, and Semantic Tests",
   "paths": [
-    "$(realpath "$TEST_REPO_DIR/fixtures/solidity/translated_semantic_tests")",
-    "$(realpath "$TEST_REPO_DIR/fixtures/solidity/complex")",
     "$(realpath "$TEST_REPO_DIR/fixtures/solidity/simple")"
   ]
 }
@@ -96,15 +94,15 @@ echo ""
 cargo build --release;
 RUST_LOG="info,alloy_pubsub::service=error" ./target/release/retester test \
     --platform geth-evm-solc \
-    --platform revive-dev-node-revm-solc \
     --corpus "$CORPUS_FILE" \
     --working-directory "$WORKDIR" \
-    --concurrency.number-of-nodes 5 \
+    --concurrency.number-of-nodes 10 \
+    --concurrency.number-of-threads 5 \
+    --concurrency.ignore-concurrency-limit \
     --wallet.additional-keys 100000 \
     --kitchensink.path "$SUBSTRATE_NODE_BIN" \
     --revive-dev-node.path "$REVIVE_DEV_NODE_BIN" \
     --eth-rpc.path "$ETH_RPC_BIN" \
-    > logs.log \
-    2> output.log
+    > logs.log 
 
 echo -e "${GREEN}=== Test run completed! ===${NC}"