Update the CI action fixing incorrect matrix usage

.github/actions/run-differential-tests/action.yml

@@ -33,14 +33,6 @@ inputs:
     description: "The identifier of the platform to run the tests on (e.g., geth-evm-solc, revive-dev-node-revm-solc)"
     required: true
     type: string
-  polkadot-omnichain-node-chain-spec-path:
-    description: "The path of the chain-spec of the chain we're spawning'. This is only required if the polkadot-omni-node is one of the selected platforms."
-    required: false
-    type: string
-  polkadot-omnichain-node-parachain-id:
-    description: "The id of the parachain to spawn with the polkadot-omni-node. This is only required if the polkadot-omni-node is one of the selected platforms."
-    type: number
-    required: false
 
 runs:
   using: "composite"
@@ -76,26 +68,10 @@ runs:
         tar -zxf cache.tar.gz -C ./workdir > /dev/null 2>&1
     - name: Building the dependencies from the Polkadot SDK
       shell: bash
-      run: |
+      run: ${{ inputs['cargo-command'] }} build --locked --profile release -p pallet-revive-eth-rpc -p revive-dev-node --manifest-path ${{ inputs['polkadot-sdk-path'] }}/Cargo.toml
-        ${{ inputs['cargo-command'] }} build --locked --profile release -p pallet-revive-eth-rpc -p revive-dev-node --manifest-path ${{ inputs['polkadot-sdk-path'] }}/Cargo.toml
-        ${{ inputs['cargo-command'] }} build --locked --profile release --bin polkadot-omni-node --manifest-path ${{ inputs['polkadot-sdk-path'] }}/Cargo.toml
     - name: Running the Differential Tests
       shell: bash
       run: |
-        OMNI_ARGS=()
-        if [[ -n "${{ inputs['polkadot-omnichain-node-parachain-id'] }}" ]]; then
-          OMNI_ARGS+=(
-            --polkadot-omni-node.parachain-id
-            "${{ inputs['polkadot-omnichain-node-parachain-id'] }}"
-          )
-        fi
-        if [[ -n "${{ inputs['polkadot-omnichain-node-chain-spec-path'] }}" ]]; then
-          OMNI_ARGS+=(
-            --polkadot-omni-node.chain-spec-path
-            "${{ inputs['polkadot-omnichain-node-chain-spec-path'] }}"
-          )
-        fi
-
         ${{ inputs['cargo-command'] }} run --locked --manifest-path revive-differential-tests/Cargo.toml -- test \
           --test ./revive-differential-tests/resolc-compiler-tests/fixtures/solidity/simple \
           --test ./revive-differential-tests/resolc-compiler-tests/fixtures/solidity/complex \
@@ -108,9 +84,7 @@ runs:
           --revive-dev-node.consensus manual-seal-200 \
           --revive-dev-node.path ${{ inputs['polkadot-sdk-path'] }}/target/release/revive-dev-node \
           --eth-rpc.path ${{ inputs['polkadot-sdk-path'] }}/target/release/eth-rpc \
-          --polkadot-omni-node.path ${{ inputs['polkadot-sdk-path'] }}/target/release/polkadot-omni-node \
+          --resolc.path ./resolc
-          --resolc.path ./resolc \
-          "${OMNI_ARGS[@]}"
     - name: Creating a markdown report of the test execution
       shell: bash
       if: ${{ always() }}

crates/common/src/types/identifiers.rs

@@ -39,12 +39,6 @@ pub enum PlatformIdentifier {
     ZombienetPolkavmResolc,
     /// A zombienet based Substrate/Polkadot node with the REVM backend with the solc compiler.
     ZombienetRevmSolc,
-    /// A polkadot-omni-chain based node with a custom runtime with the PolkaVM backend and the
-    /// resolc compiler.
-    PolkadotOmniNodePolkavmResolc,
-    /// A polkadot-omni-chain based node with a custom runtime with the REVM backend and the solc
-    /// compiler.
-    PolkadotOmniNodeRevmSolc,
 }
 
 /// An enum of the platform identifiers of all of the platforms supported by this framework.
@@ -101,8 +95,6 @@ pub enum NodeIdentifier {
     ReviveDevNode,
     /// A zombienet spawned nodes
     Zombienet,
-    /// The polkadot-omni-node.
-    PolkadotOmniNode,
 }
 
 /// An enum representing the identifiers of the supported VMs.

crates/compiler/src/revive_resolc.rs

@@ -208,18 +208,14 @@ impl SolidityCompiler for Resolc {
                 anyhow::bail!("Compilation failed with an error: {message}");
             }
 
-            let parsed: SolcStandardJsonOutput = {
+            let parsed = serde_json::from_slice::<SolcStandardJsonOutput>(&stdout)
-                let mut deserializer = serde_json::Deserializer::from_slice(&stdout);
+                .map_err(|e| {
-                deserializer.disable_recursion_limit();
+                    anyhow::anyhow!(
-                serde::de::Deserialize::deserialize(&mut deserializer)
+                        "failed to parse resolc JSON output: {e}\nstderr: {}",
-                    .map_err(|e| {
+                        String::from_utf8_lossy(&stderr)
-                        anyhow::anyhow!(
+                    )
-                            "failed to parse resolc JSON output: {e}\nstderr: {}",
+                })
-                            String::from_utf8_lossy(&stderr)
+                .context("Failed to parse resolc standard JSON output")?;
-                        )
-                    })
-                    .context("Failed to parse resolc standard JSON output")?
-            };
 
             tracing::debug!(
                 output = %serde_json::to_string(&parsed).unwrap(),

crates/config/src/lib.rs

@@ -143,17 +143,6 @@ impl AsRef<ReviveDevNodeConfiguration> for Context {
     }
 }
 
-impl AsRef<PolkadotOmnichainNodeConfiguration> for Context {
-    fn as_ref(&self) -> &PolkadotOmnichainNodeConfiguration {
-        match self {
-            Self::Test(context) => context.as_ref().as_ref(),
-            Self::Benchmark(context) => context.as_ref().as_ref(),
-            Self::ExportGenesis(context) => context.as_ref().as_ref(),
-            Self::ExportJsonSchema => unreachable!(),
-        }
-    }
-}
-
 impl AsRef<EthRpcConfiguration> for Context {
     fn as_ref(&self) -> &EthRpcConfiguration {
         match self {
@@ -239,7 +228,6 @@ pub struct TestExecutionContext {
     #[arg(
         short = 'p',
         long = "platform",
-        id = "platforms",
         default_values = ["geth-evm-solc", "revive-dev-node-polkavm-resolc"]
     )]
     pub platforms: Vec<PlatformIdentifier>,
@@ -289,10 +277,6 @@ pub struct TestExecutionContext {
     #[clap(flatten, next_help_heading = "Revive Dev Node Configuration")]
     pub revive_dev_node_configuration: ReviveDevNodeConfiguration,
 
-    /// Configuration parameters for the Polkadot Omnichain Node.
-    #[clap(flatten, next_help_heading = "Polkadot Omnichain Node Configuration")]
-    pub polkadot_omnichain_node_configuration: PolkadotOmnichainNodeConfiguration,
-
     /// Configuration parameters for the Eth Rpc.
     #[clap(flatten, next_help_heading = "Eth RPC Configuration")]
     pub eth_rpc_configuration: EthRpcConfiguration,
@@ -436,10 +420,6 @@ pub struct BenchmarkingContext {
     #[clap(flatten, next_help_heading = "Revive Dev Node Configuration")]
     pub revive_dev_node_configuration: ReviveDevNodeConfiguration,
 
-    /// Configuration parameters for the Polkadot Omnichain Node.
-    #[clap(flatten, next_help_heading = "Polkadot Omnichain Node Configuration")]
-    pub polkadot_omnichain_node_configuration: PolkadotOmnichainNodeConfiguration,
-
     /// Configuration parameters for the Eth Rpc.
     #[clap(flatten, next_help_heading = "Eth RPC Configuration")]
     pub eth_rpc_configuration: EthRpcConfiguration,
@@ -518,10 +498,6 @@ pub struct ExportGenesisContext {
     #[clap(flatten, next_help_heading = "Revive Dev Node Configuration")]
     pub revive_dev_node_configuration: ReviveDevNodeConfiguration,
 
-    /// Configuration parameters for the Polkadot Omnichain Node.
-    #[clap(flatten, next_help_heading = "Polkadot Omnichain Node Configuration")]
-    pub polkadot_omnichain_node_configuration: PolkadotOmnichainNodeConfiguration,
-
     /// Configuration parameters for the wallet.
     #[clap(flatten, next_help_heading = "Wallet Configuration")]
     pub wallet_configuration: WalletConfiguration,
@@ -581,12 +557,6 @@ impl AsRef<ReviveDevNodeConfiguration> for TestExecutionContext {
     }
 }
 
-impl AsRef<PolkadotOmnichainNodeConfiguration> for TestExecutionContext {
-    fn as_ref(&self) -> &PolkadotOmnichainNodeConfiguration {
-        &self.polkadot_omnichain_node_configuration
-    }
-}
-
 impl AsRef<EthRpcConfiguration> for TestExecutionContext {
     fn as_ref(&self) -> &EthRpcConfiguration {
         &self.eth_rpc_configuration
@@ -683,12 +653,6 @@ impl AsRef<ReviveDevNodeConfiguration> for BenchmarkingContext {
     }
 }
 
-impl AsRef<PolkadotOmnichainNodeConfiguration> for BenchmarkingContext {
-    fn as_ref(&self) -> &PolkadotOmnichainNodeConfiguration {
-        &self.polkadot_omnichain_node_configuration
-    }
-}
-
 impl AsRef<EthRpcConfiguration> for BenchmarkingContext {
     fn as_ref(&self) -> &EthRpcConfiguration {
         &self.eth_rpc_configuration
@@ -749,12 +713,6 @@ impl AsRef<ReviveDevNodeConfiguration> for ExportGenesisContext {
     }
 }
 
-impl AsRef<PolkadotOmnichainNodeConfiguration> for ExportGenesisContext {
-    fn as_ref(&self) -> &PolkadotOmnichainNodeConfiguration {
-        &self.polkadot_omnichain_node_configuration
-    }
-}
-
 impl AsRef<WalletConfiguration> for ExportGenesisContext {
     fn as_ref(&self) -> &WalletConfiguration {
         &self.wallet_configuration
@@ -911,54 +869,6 @@ pub struct ReviveDevNodeConfiguration {
     pub existing_rpc_url: Vec<String>,
 }
 
-/// A set of configuration parameters for the polkadot-omni-node.
-#[derive(Clone, Debug, Parser, Serialize, Deserialize)]
-pub struct PolkadotOmnichainNodeConfiguration {
-    /// Specifies the path of the polkadot-omni-node to be used by the tool.
-    ///
-    /// If this is not specified, then the tool assumes that it should use the polkadot-omni-node
-    /// binary that's provided in the user's $PATH.
-    #[clap(
-        id = "polkadot-omni-node.path",
-        long = "polkadot-omni-node.path",
-        default_value = "polkadot-omni-node"
-    )]
-    pub path: PathBuf,
-
-    /// The amount of time to wait upon startup before considering that the node timed out.
-    #[clap(
-        id = "polkadot-omni-node.start-timeout-ms",
-        long = "polkadot-omni-node.start-timeout-ms",
-        default_value = "90000",
-        value_parser = parse_duration
-    )]
-    pub start_timeout_ms: Duration,
-
-    /// Defines how often blocks will be sealed by the node in milliseconds.
-    #[clap(
-        id = "polkadot-omni-node.block-time-ms",
-        long = "polkadot-omni-node.block-time-ms",
-        default_value = "200",
-        value_parser = parse_duration
-    )]
-    pub block_time: Duration,
-
-    /// The path of the chainspec of the chain that we're spawning
-    #[clap(
-        id = "polkadot-omni-node.chain-spec-path",
-        long = "polkadot-omni-node.chain-spec-path"
-    )]
-    pub chain_spec_path: Option<PathBuf>,
-
-    /// The ID of the parachain that the polkadot-omni-node will spawn. This argument is required if
-    /// the polkadot-omni-node is one of the selected platforms for running the tests or benchmarks.
-    #[clap(
-        id = "polkadot-omni-node.parachain-id",
-        long = "polkadot-omni-node.parachain-id"
-    )]
-    pub parachain_id: Option<usize>,
-}
-
 /// A set of configuration parameters for the ETH RPC.
 #[derive(Clone, Debug, Parser, Serialize, Deserialize)]
 pub struct EthRpcConfiguration {

crates/core/src/lib.rs

@@ -14,12 +14,9 @@ use revive_dt_common::types::*;
 use revive_dt_compiler::{SolidityCompiler, revive_resolc::Resolc, solc::Solc};
 use revive_dt_config::*;
 use revive_dt_node::{
-    Node,
+    Node, node_implementations::geth::GethNode,
-    node_implementations::{
+    node_implementations::lighthouse_geth::LighthouseGethNode,
-        geth::GethNode, lighthouse_geth::LighthouseGethNode,
+    node_implementations::substrate::SubstrateNode, node_implementations::zombienet::ZombienetNode,
-        polkadot_omni_node::PolkadotOmnichainNode, substrate::SubstrateNode,
-        zombienet::ZombienetNode,
-    },
 };
 use revive_dt_node_interaction::EthereumNode;
 use tracing::info;
@@ -435,126 +432,6 @@ impl Platform for ZombienetRevmSolcPlatform {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
-pub struct PolkadotOmniNodePolkavmResolcPlatform;
-
-impl Platform for PolkadotOmniNodePolkavmResolcPlatform {
-    fn platform_identifier(&self) -> PlatformIdentifier {
-        PlatformIdentifier::PolkadotOmniNodePolkavmResolc
-    }
-
-    fn node_identifier(&self) -> NodeIdentifier {
-        NodeIdentifier::PolkadotOmniNode
-    }
-
-    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 genesis = genesis_configuration.genesis()?.clone();
-        Ok(thread::spawn(move || {
-            let use_fallback_gas_filler = matches!(context, Context::Test(..));
-            let node = PolkadotOmnichainNode::new(context, use_fallback_gas_filler);
-            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>)
-        })
-    }
-
-    fn export_genesis(&self, context: Context) -> anyhow::Result<serde_json::Value> {
-        let polkadot_omnichain_node_configuration =
-            AsRef::<PolkadotOmnichainNodeConfiguration>::as_ref(&context);
-        let wallet = AsRef::<WalletConfiguration>::as_ref(&context).wallet();
-
-        PolkadotOmnichainNode::node_genesis(
-            &wallet,
-            polkadot_omnichain_node_configuration
-                .chain_spec_path
-                .as_ref()
-                .context("No WASM runtime path found in the polkadot-omni-node configuration")?,
-        )
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
-pub struct PolkadotOmniNodeRevmSolcPlatform;
-
-impl Platform for PolkadotOmniNodeRevmSolcPlatform {
-    fn platform_identifier(&self) -> PlatformIdentifier {
-        PlatformIdentifier::PolkadotOmniNodeRevmSolc
-    }
-
-    fn node_identifier(&self) -> NodeIdentifier {
-        NodeIdentifier::PolkadotOmniNode
-    }
-
-    fn vm_identifier(&self) -> VmIdentifier {
-        VmIdentifier::Evm
-    }
-
-    fn compiler_identifier(&self) -> CompilerIdentifier {
-        CompilerIdentifier::Solc
-    }
-
-    fn new_node(
-        &self,
-        context: Context,
-    ) -> anyhow::Result<JoinHandle<anyhow::Result<Box<dyn EthereumNode + Send + Sync>>>> {
-        let genesis_configuration = AsRef::<GenesisConfiguration>::as_ref(&context);
-        let genesis = genesis_configuration.genesis()?.clone();
-        Ok(thread::spawn(move || {
-            let use_fallback_gas_filler = matches!(context, Context::Test(..));
-            let node = PolkadotOmnichainNode::new(context, use_fallback_gas_filler);
-            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>)
-        })
-    }
-
-    fn export_genesis(&self, context: Context) -> anyhow::Result<serde_json::Value> {
-        let polkadot_omnichain_node_configuration =
-            AsRef::<PolkadotOmnichainNodeConfiguration>::as_ref(&context);
-        let wallet = AsRef::<WalletConfiguration>::as_ref(&context).wallet();
-
-        PolkadotOmnichainNode::node_genesis(
-            &wallet,
-            polkadot_omnichain_node_configuration
-                .chain_spec_path
-                .as_ref()
-                .context("No WASM runtime path found in the polkadot-omni-node configuration")?,
-        )
-    }
-}
-
 impl From<PlatformIdentifier> for Box<dyn Platform> {
     fn from(value: PlatformIdentifier) -> Self {
         match value {
@@ -572,12 +449,6 @@ impl From<PlatformIdentifier> for Box<dyn Platform> {
                 Box::new(ZombienetPolkavmResolcPlatform) as Box<_>
             }
             PlatformIdentifier::ZombienetRevmSolc => Box::new(ZombienetRevmSolcPlatform) as Box<_>,
-            PlatformIdentifier::PolkadotOmniNodePolkavmResolc => {
-                Box::new(PolkadotOmniNodePolkavmResolcPlatform) as Box<_>
-            }
-            PlatformIdentifier::PolkadotOmniNodeRevmSolc => {
-                Box::new(PolkadotOmniNodeRevmSolcPlatform) as Box<_>
-            }
         }
     }
 }
@@ -599,12 +470,6 @@ impl From<PlatformIdentifier> for &dyn Platform {
                 &ZombienetPolkavmResolcPlatform as &dyn Platform
             }
             PlatformIdentifier::ZombienetRevmSolc => &ZombienetRevmSolcPlatform as &dyn Platform,
-            PlatformIdentifier::PolkadotOmniNodePolkavmResolc => {
-                &PolkadotOmniNodePolkavmResolcPlatform as &dyn Platform
-            }
-            PlatformIdentifier::PolkadotOmniNodeRevmSolc => {
-                &PolkadotOmniNodeRevmSolcPlatform as &dyn Platform
-            }
         }
     }
 }

crates/core/src/main.rs

@@ -4,6 +4,7 @@ mod helpers;
 
 use anyhow::{Context as _, bail};
 use clap::Parser;
+use revive_dt_common::types::ParsedTestSpecifier;
 use revive_dt_report::{ReportAggregator, TestCaseStatus};
 use schemars::schema_for;
 use tracing::{info, level_filters::LevelFilter};
@@ -63,15 +64,40 @@ fn main() -> anyhow::Result<()> {
                 )
                 .await?;
 
-                let contains_failure = report
+                // Error out if there are any failing tests.
+                let failures = report
                     .execution_information
-                    .values()
+                    .into_iter()
-                    .flat_map(|values| values.case_reports.values())
+                    .flat_map(|(metadata_file_path, metadata_file_report)| {
-                    .flat_map(|values| values.mode_execution_reports.values())
+                        metadata_file_report.case_reports.into_iter().flat_map(
-                    .any(|report| matches!(report.status, Some(TestCaseStatus::Failed { .. })));
+                            move |(case_idx, case_report)| {
+                                let metadata_file_path = metadata_file_path.clone();
+                                case_report.mode_execution_reports.into_iter().filter_map(
+                                    move |(mode, execution_report)| {
+                                        if let Some(TestCaseStatus::Failed { reason }) =
+                                            execution_report.status
+                                        {
+                                            let parsed_test_specifier =
+                                                ParsedTestSpecifier::CaseWithMode {
+                                                    metadata_file_path: metadata_file_path
+                                                        .clone()
+                                                        .into_inner(),
+                                                    case_idx: case_idx.into_inner(),
+                                                    mode,
+                                                };
+                                            Some((parsed_test_specifier, reason))
+                                        } else {
+                                            None
+                                        }
+                                    },
+                                )
+                            },
+                        )
+                    })
+                    .collect::<Vec<_>>();
 
-                if contains_failure {
+                if !failures.is_empty() {
-                    bail!("Some tests failed")
+                    bail!("Some tests failed: {failures:#?}")
                 }
 
                 Ok(())
@@ -91,15 +117,40 @@ fn main() -> anyhow::Result<()> {
                 )
                 .await?;
 
-                let contains_failure = report
+                // Error out if there are any failing tests.
+                let failures = report
                     .execution_information
-                    .values()
+                    .into_iter()
-                    .flat_map(|values| values.case_reports.values())
+                    .flat_map(|(metadata_file_path, metadata_file_report)| {
-                    .flat_map(|values| values.mode_execution_reports.values())
+                        metadata_file_report.case_reports.into_iter().flat_map(
-                    .any(|report| matches!(report.status, Some(TestCaseStatus::Failed { .. })));
+                            move |(case_idx, case_report)| {
+                                let metadata_file_path = metadata_file_path.clone();
+                                case_report.mode_execution_reports.into_iter().filter_map(
+                                    move |(mode, execution_report)| {
+                                        if let Some(TestCaseStatus::Failed { reason }) =
+                                            execution_report.status
+                                        {
+                                            let parsed_test_specifier =
+                                                ParsedTestSpecifier::CaseWithMode {
+                                                    metadata_file_path: metadata_file_path
+                                                        .clone()
+                                                        .into_inner(),
+                                                    case_idx: case_idx.into_inner(),
+                                                    mode,
+                                                };
+                                            Some((parsed_test_specifier, reason))
+                                        } else {
+                                            None
+                                        }
+                                    },
+                                )
+                            },
+                        )
+                    })
+                    .collect::<Vec<_>>();
 
-                if contains_failure {
+                if !failures.is_empty() {
-                    bail!("Some benchmarks failed")
+                    bail!("Some tests failed: {failures:#?}")
                 }
 
                 Ok(())

crates/node/src/node_implementations/geth.rs

@@ -250,7 +250,7 @@ impl GethNode {
                 construct_concurrency_limited_provider::<Ethereum, _>(
                     self.connection_string.as_str(),
                     FallbackGasFiller::default()
-                        .with_fallback_mechanism(self.use_fallback_gas_filler),
+                        .with_use_fallback_gas_filler(self.use_fallback_gas_filler),
                     ChainIdFiller::new(Some(CHAIN_ID)),
                     NonceFiller::new(self.nonce_manager.clone()),
                     self.wallet.clone(),

crates/node/src/node_implementations/lighthouse_geth.rs

@@ -379,7 +379,7 @@ impl LighthouseGethNode {
                 construct_concurrency_limited_provider::<Ethereum, _>(
                     self.ws_connection_string.as_str(),
                     FallbackGasFiller::default()
-                        .with_fallback_mechanism(self.use_fallback_gas_filler),
+                        .with_use_fallback_gas_filler(self.use_fallback_gas_filler),
                     ChainIdFiller::new(Some(CHAIN_ID)),
                     NonceFiller::new(self.nonce_manager.clone()),
                     self.wallet.clone(),

crates/node/src/node_implementations/mod.rs

@@ -1,5 +1,4 @@
 pub mod geth;
 pub mod lighthouse_geth;
-pub mod polkadot_omni_node;
 pub mod substrate;
 pub mod zombienet;

crates/node/src/node_implementations/polkadot_omni_node.rs

@@ -1,790 +0,0 @@
-use std::{
-    fs::{File, create_dir_all, remove_dir_all},
-    path::{Path, PathBuf},
-    pin::Pin,
-    process::{Command, Stdio},
-    sync::{
-        Arc,
-        atomic::{AtomicU32, Ordering},
-    },
-    time::Duration,
-};
-
-use alloy::{
-    eips::BlockNumberOrTag,
-    genesis::Genesis,
-    network::{Ethereum, EthereumWallet, NetworkWallet},
-    primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, StorageKey, TxHash, U256},
-    providers::{
-        Provider,
-        ext::DebugApi,
-        fillers::{CachedNonceManager, ChainIdFiller, NonceFiller},
-    },
-    rpc::types::{
-        EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest,
-        trace::geth::{
-            DiffMode, GethDebugTracingOptions, GethTrace, PreStateConfig, PreStateFrame,
-        },
-    },
-};
-use anyhow::Context as _;
-use futures::{FutureExt, Stream, StreamExt};
-use revive_common::EVMVersion;
-use revive_dt_common::fs::clear_directory;
-use revive_dt_format::traits::ResolverApi;
-use serde_json::json;
-use sp_core::crypto::Ss58Codec;
-use sp_runtime::AccountId32;
-
-use revive_dt_config::*;
-use revive_dt_node_interaction::EthereumNode;
-use revive_dt_report::{
-    EthereumMinedBlockInformation, MinedBlockInformation, SubstrateMinedBlockInformation,
-};
-use subxt::{OnlineClient, SubstrateConfig};
-use tokio::sync::OnceCell;
-use tracing::{instrument, trace};
-
-use crate::{
-    Node,
-    constants::INITIAL_BALANCE,
-    helpers::{Process, ProcessReadinessWaitBehavior},
-    provider_utils::{
-        ConcreteProvider, FallbackGasFiller, construct_concurrency_limited_provider,
-        execute_transaction,
-    },
-};
-
-static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
-
-/// The number of blocks that should be cached by the polkadot-omni-node and the eth-rpc.
-const NUMBER_OF_CACHED_BLOCKS: u32 = 100_000;
-
-/// A node implementation for the polkadot-omni-node.
-#[derive(Debug)]
-
-pub struct PolkadotOmnichainNode {
-    /// The id of the node.
-    id: u32,
-
-    /// The path of the polkadot-omni-chain node binary.
-    polkadot_omnichain_node_binary_path: PathBuf,
-    /// The path of the eth-rpc binary.
-    eth_rpc_binary_path: PathBuf,
-    /// The path of the runtime's WASM that this node will be spawned with.
-    chain_spec_path: Option<PathBuf>,
-    /// The path of the base directory which contains all of the stored data for this node.
-    base_directory_path: PathBuf,
-    /// The path of the logs directory which contains all of the stored logs.
-    logs_directory_path: PathBuf,
-
-    /// Defines the amount of time to wait before considering that the node start has timed out.
-    node_start_timeout: Duration,
-
-    /// The id of the parachain that this node will be spawning.
-    parachain_id: Option<usize>,
-    /// The block time.
-    block_time: Duration,
-
-    /// The node's process.
-    polkadot_omnichain_node_process: Option<Process>,
-    /// The eth-rpc's process.
-    eth_rpc_process: Option<Process>,
-
-    /// The URL of the eth-rpc.
-    rpc_url: String,
-    /// The wallet object that's used to sign any transaction submitted through this node.
-    wallet: Arc<EthereumWallet>,
-    /// The nonce manager used to populate nonces for all transactions submitted through this node.
-    nonce_manager: CachedNonceManager,
-    /// The provider used for all RPC interactions with the RPC of this node.
-    provider: OnceCell<ConcreteProvider<Ethereum, Arc<EthereumWallet>>>,
-
-    /// A boolean that controls if the fallback gas filler should be used or not.
-    use_fallback_gas_filler: bool,
-}
-
-impl PolkadotOmnichainNode {
-    const BASE_DIRECTORY: &str = "polkadot-omni-node";
-    const LOGS_DIRECTORY: &str = "logs";
-
-    const POLKADOT_OMNICHAIN_NODE_READY_MARKER: &str = "Running JSON-RPC server";
-    const ETH_RPC_READY_MARKER: &str = "Running JSON-RPC server";
-    const CHAIN_SPEC_JSON_FILE: &str = "template_chainspec.json";
-    const BASE_POLKADOT_OMNICHAIN_NODE_RPC_PORT: u16 = 9944;
-    const BASE_ETH_RPC_PORT: u16 = 8545;
-
-    const POLKADOT_OMNICHAIN_NODE_LOG_ENV: &str =
-        "error,evm=debug,sc_rpc_server=info,runtime::revive=debug";
-    const RPC_LOG_ENV: &str = "info,eth-rpc=debug";
-
-    pub fn new(
-        context: impl AsRef<WorkingDirectoryConfiguration>
-        + AsRef<EthRpcConfiguration>
-        + AsRef<WalletConfiguration>
-        + AsRef<PolkadotOmnichainNodeConfiguration>,
-        use_fallback_gas_filler: bool,
-    ) -> Self {
-        let polkadot_omnichain_node_configuration =
-            AsRef::<PolkadotOmnichainNodeConfiguration>::as_ref(&context);
-        let working_directory_path =
-            AsRef::<WorkingDirectoryConfiguration>::as_ref(&context).as_path();
-        let eth_rpc_path = AsRef::<EthRpcConfiguration>::as_ref(&context)
-            .path
-            .as_path();
-        let wallet = AsRef::<WalletConfiguration>::as_ref(&context).wallet();
-
-        let id = NODE_COUNT.fetch_add(1, Ordering::SeqCst);
-        let base_directory = working_directory_path
-            .join(Self::BASE_DIRECTORY)
-            .join(id.to_string());
-        let logs_directory = base_directory.join(Self::LOGS_DIRECTORY);
-
-        Self {
-            id,
-            polkadot_omnichain_node_binary_path: polkadot_omnichain_node_configuration
-                .path
-                .to_path_buf(),
-            eth_rpc_binary_path: eth_rpc_path.to_path_buf(),
-            chain_spec_path: polkadot_omnichain_node_configuration
-                .chain_spec_path
-                .clone(),
-            base_directory_path: base_directory,
-            logs_directory_path: logs_directory,
-            parachain_id: polkadot_omnichain_node_configuration.parachain_id,
-            block_time: polkadot_omnichain_node_configuration.block_time,
-            polkadot_omnichain_node_process: Default::default(),
-            eth_rpc_process: Default::default(),
-            rpc_url: Default::default(),
-            wallet,
-            nonce_manager: Default::default(),
-            provider: Default::default(),
-            use_fallback_gas_filler,
-            node_start_timeout: polkadot_omnichain_node_configuration.start_timeout_ms,
-        }
-    }
-
-    fn init(&mut self, _: Genesis) -> anyhow::Result<&mut Self> {
-        trace!("Removing the various directories");
-        let _ = remove_dir_all(self.base_directory_path.as_path());
-        let _ = clear_directory(&self.base_directory_path);
-        let _ = clear_directory(&self.logs_directory_path);
-
-        trace!("Creating the various directories");
-        create_dir_all(&self.base_directory_path)
-            .context("Failed to create base directory for polkadot-omni-node node")?;
-        create_dir_all(&self.logs_directory_path)
-            .context("Failed to create logs directory for polkadot-omni-node node")?;
-
-        let template_chainspec_path = self.base_directory_path.join(Self::CHAIN_SPEC_JSON_FILE);
-
-        let chainspec_json = Self::node_genesis(
-            &self.wallet,
-            self.chain_spec_path
-                .as_ref()
-                .context("No runtime path provided")?,
-        )
-        .context("Failed to prepare the chainspec command")?;
-
-        serde_json::to_writer_pretty(
-            std::fs::File::create(&template_chainspec_path)
-                .context("Failed to create polkadot-omni-node template chainspec file")?,
-            &chainspec_json,
-        )
-        .context("Failed to write polkadot-omni-node template chainspec JSON")?;
-
-        Ok(self)
-    }
-
-    fn spawn_process(&mut self) -> anyhow::Result<()> {
-        // Error out if the runtime's path or the parachain id are not set which means that the
-        // arguments we require were not provided.
-        self.chain_spec_path
-            .as_ref()
-            .context("No WASM path provided for the runtime")?;
-        self.parachain_id
-            .as_ref()
-            .context("No argument provided for the parachain-id")?;
-
-        let polkadot_omnichain_node_rpc_port =
-            Self::BASE_POLKADOT_OMNICHAIN_NODE_RPC_PORT + self.id as u16;
-        let eth_rpc_port = Self::BASE_ETH_RPC_PORT + self.id as u16;
-
-        let chainspec_path = self.base_directory_path.join(Self::CHAIN_SPEC_JSON_FILE);
-
-        self.rpc_url = format!("http://127.0.0.1:{eth_rpc_port}");
-
-        let polkadot_omnichain_node_process = Process::new(
-            "node",
-            self.logs_directory_path.as_path(),
-            self.polkadot_omnichain_node_binary_path.as_path(),
-            |command, stdout_file, stderr_file| {
-                command
-                    .arg("--log")
-                    .arg(Self::POLKADOT_OMNICHAIN_NODE_LOG_ENV)
-                    .arg("--dev-block-time")
-                    .arg(self.block_time.as_millis().to_string())
-                    .arg("--rpc-port")
-                    .arg(polkadot_omnichain_node_rpc_port.to_string())
-                    .arg("--base-path")
-                    .arg(self.base_directory_path.as_path())
-                    .arg("--no-prometheus")
-                    .arg("--no-hardware-benchmarks")
-                    .arg("--authoring")
-                    .arg("slot-based")
-                    .arg("--chain")
-                    .arg(chainspec_path)
-                    .arg("--name")
-                    .arg(format!("polkadot-omni-node-{}", self.id))
-                    .arg("--rpc-methods")
-                    .arg("unsafe")
-                    .arg("--rpc-cors")
-                    .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())
-                    .arg("--state-pruning")
-                    .arg(NUMBER_OF_CACHED_BLOCKS.to_string())
-                    .env("RUST_LOG", Self::POLKADOT_OMNICHAIN_NODE_LOG_ENV)
-                    .stdout(stdout_file)
-                    .stderr(stderr_file);
-            },
-            ProcessReadinessWaitBehavior::TimeBoundedWaitFunction {
-                max_wait_duration: self.node_start_timeout,
-                check_function: Box::new(|_, stderr_line| match stderr_line {
-                    Some(line) => Ok(line.contains(Self::POLKADOT_OMNICHAIN_NODE_READY_MARKER)),
-                    None => Ok(false),
-                }),
-            },
-        );
-
-        match polkadot_omnichain_node_process {
-            Ok(process) => self.polkadot_omnichain_node_process = Some(process),
-            Err(err) => {
-                tracing::error!(
-                    ?err,
-                    "Failed to start polkadot-omni-node, shutting down gracefully"
-                );
-                self.shutdown().context(
-                    "Failed to gracefully shutdown after polkadot-omni-node start error",
-                )?;
-                return Err(err);
-            }
-        }
-
-        let eth_rpc_process = Process::new(
-            "eth-rpc",
-            self.logs_directory_path.as_path(),
-            self.eth_rpc_binary_path.as_path(),
-            |command, stdout_file, stderr_file| {
-                command
-                    .arg("--dev")
-                    .arg("--rpc-port")
-                    .arg(eth_rpc_port.to_string())
-                    .arg("--node-rpc-url")
-                    .arg(format!("ws://127.0.0.1:{polkadot_omnichain_node_rpc_port}"))
-                    .arg("--rpc-max-connections")
-                    .arg(u32::MAX.to_string())
-                    .arg("--index-last-n-blocks")
-                    .arg(NUMBER_OF_CACHED_BLOCKS.to_string())
-                    .arg("--cache-size")
-                    .arg(NUMBER_OF_CACHED_BLOCKS.to_string())
-                    .env("RUST_LOG", Self::RPC_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_RPC_READY_MARKER)),
-                    None => Ok(false),
-                }),
-            },
-        );
-        match eth_rpc_process {
-            Ok(process) => self.eth_rpc_process = Some(process),
-            Err(err) => {
-                tracing::error!(?err, "Failed to start eth-rpc, shutting down gracefully");
-                self.shutdown()
-                    .context("Failed to gracefully shutdown after eth-rpc start error")?;
-                return Err(err);
-            }
-        }
-
-        Ok(())
-    }
-
-    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_rpc_binary_path)
-            .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())
-    }
-
-    async fn provider(&self) -> anyhow::Result<ConcreteProvider<Ethereum, Arc<EthereumWallet>>> {
-        self.provider
-            .get_or_try_init(|| async move {
-                construct_concurrency_limited_provider::<Ethereum, _>(
-                    self.rpc_url.as_str(),
-                    FallbackGasFiller::default()
-                        .with_fallback_mechanism(self.use_fallback_gas_filler),
-                    ChainIdFiller::default(),
-                    NonceFiller::new(self.nonce_manager.clone()),
-                    self.wallet.clone(),
-                )
-                .await
-                .context("Failed to construct the provider")
-            })
-            .await
-            .cloned()
-    }
-
-    pub fn node_genesis(
-        wallet: &EthereumWallet,
-        chain_spec_path: &Path,
-    ) -> anyhow::Result<serde_json::Value> {
-        let unmodified_chainspec_file =
-            File::open(chain_spec_path).context("Failed to open the unmodified chainspec file")?;
-        let mut chainspec_json =
-            serde_json::from_reader::<_, serde_json::Value>(&unmodified_chainspec_file)
-                .context("Failed to read the unmodified chainspec JSON")?;
-
-        let existing_chainspec_balances =
-            chainspec_json["genesis"]["runtimeGenesis"]["patch"]["balances"]["balances"]
-                .as_array_mut()
-                .expect("Can't fail");
-
-        for address in NetworkWallet::<Ethereum>::signer_addresses(wallet) {
-            let substrate_address = Self::eth_to_substrate_address(&address);
-            let balance = INITIAL_BALANCE;
-            existing_chainspec_balances.push(json!((substrate_address, balance)));
-        }
-
-        Ok(chainspec_json)
-    }
-}
-
-impl EthereumNode for PolkadotOmnichainNode {
-    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.rpc_url
-    }
-
-    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: 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<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 eth-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 eth-rpc 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 eth-rpc 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(PolkadotOmnichainNodeResolver { 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>>>>>
-                + '_,
-        >,
-    > {
-        #[subxt::subxt(runtime_metadata_path = "../../assets/revive_metadata.scale")]
-        pub mod revive {}
-
-        Box::pin(async move {
-            let polkadot_omnichain_node_rpc_port =
-                Self::BASE_POLKADOT_OMNICHAIN_NODE_RPC_PORT + self.id as u16;
-            let polkadot_omnichain_node_rpc_url =
-                format!("ws://127.0.0.1:{polkadot_omnichain_node_rpc_port}");
-            let api = OnlineClient::<SubstrateConfig>::from_url(polkadot_omnichain_node_rpc_url)
-                .await
-                .context("Failed to create subxt rpc client")?;
-            let provider = self.provider().await.context("Failed to create provider")?;
-
-            let block_stream = api
-                .blocks()
-                .subscribe_all()
-                .await
-                .context("Failed to subscribe to blocks")?;
-
-            let mined_block_information_stream = block_stream.filter_map(move |block| {
-                let api = api.clone();
-                let provider = provider.clone();
-
-                async move {
-                    let substrate_block = block.ok()?;
-                    let revive_block = provider
-                        .get_block_by_number(
-                            BlockNumberOrTag::Number(substrate_block.number() as _),
-                        )
-                        .await
-                        .expect("TODO: Remove")
-                        .expect("TODO: Remove");
-
-                    let used = api
-                        .storage()
-                        .at(substrate_block.reference())
-                        .fetch_or_default(&revive::storage().system().block_weight())
-                        .await
-                        .expect("TODO: Remove");
-
-                    let block_ref_time = (used.normal.ref_time as u128)
-                        + (used.operational.ref_time as u128)
-                        + (used.mandatory.ref_time as u128);
-                    let block_proof_size = (used.normal.proof_size as u128)
-                        + (used.operational.proof_size as u128)
-                        + (used.mandatory.proof_size as u128);
-
-                    let limits = api
-                        .constants()
-                        .at(&revive::constants().system().block_weights())
-                        .expect("TODO: Remove");
-
-                    let max_ref_time = limits.max_block.ref_time;
-                    let max_proof_size = limits.max_block.proof_size;
-
-                    Some(MinedBlockInformation {
-                        ethereum_block_information: EthereumMinedBlockInformation {
-                            block_number: revive_block.number(),
-                            block_timestamp: revive_block.header.timestamp,
-                            mined_gas: revive_block.header.gas_used as _,
-                            block_gas_limit: revive_block.header.gas_limit as _,
-                            transaction_hashes: revive_block
-                                .transactions
-                                .into_hashes()
-                                .as_hashes()
-                                .expect("Must be hashes")
-                                .to_vec(),
-                        },
-                        substrate_block_information: Some(SubstrateMinedBlockInformation {
-                            ref_time: block_ref_time,
-                            max_ref_time,
-                            proof_size: block_proof_size,
-                            max_proof_size,
-                        }),
-                        tx_counts: Default::default(),
-                    })
-                }
-            });
-
-            Ok(Box::pin(mined_block_information_stream)
-                as Pin<Box<dyn Stream<Item = MinedBlockInformation>>>)
-        })
-    }
-
-    fn provider(
-        &self,
-    ) -> Pin<Box<dyn Future<Output = anyhow::Result<alloy::providers::DynProvider<Ethereum>>> + '_>>
-    {
-        Box::pin(
-            self.provider()
-                .map(|provider| provider.map(|provider| provider.erased())),
-        )
-    }
-}
-
-pub struct PolkadotOmnichainNodeResolver {
-    id: u32,
-    provider: ConcreteProvider<Ethereum, Arc<EthereumWallet>>,
-}
-
-impl ResolverApi for PolkadotOmnichainNodeResolver {
-    #[instrument(level = "info", skip_all, fields(polkadot_omnichain_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(polkadot_omnichain_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(polkadot_omnichain_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 eth-rpc block")?
-                .context("Failed to get the eth-rpc block, perhaps the chain has no blocks?")
-                .map(|block| block.header.gas_limit as _)
-        })
-    }
-
-    #[instrument(level = "info", skip_all, fields(polkadot_omnichain_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 eth-rpc block")?
-                .context("Failed to get the eth-rpc block, perhaps the chain has no blocks?")
-                .map(|block| block.header.beneficiary)
-        })
-    }
-
-    #[instrument(level = "info", skip_all, fields(polkadot_omnichain_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 eth-rpc block")?
-                .context("Failed to get the eth-rpc block, perhaps the chain has no blocks?")
-                .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
-        })
-    }
-
-    #[instrument(level = "info", skip_all, fields(polkadot_omnichain_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 eth-rpc block")?
-                .context("Failed to get the eth-rpc 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(polkadot_omnichain_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 eth-rpc block")?
-                .context("Failed to get the eth-rpc block, perhaps the chain has no blocks?")
-                .map(|block| block.header.hash)
-        })
-    }
-
-    #[instrument(level = "info", skip_all, fields(polkadot_omnichain_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 eth-rpc block")?
-                .context("Failed to get the eth-rpc block, perhaps the chain has no blocks?")
-                .map(|block| block.header.timestamp)
-        })
-    }
-
-    #[instrument(level = "info", skip_all, fields(polkadot_omnichain_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 PolkadotOmnichainNode {
-    fn shutdown(&mut self) -> anyhow::Result<()> {
-        drop(self.polkadot_omnichain_node_process.take());
-        drop(self.eth_rpc_process.take());
-
-        // Remove the node's database so that subsequent runs do not run on the same database. We
-        // ignore the error just in case the directory didn't exist in the first place and therefore
-        // there's nothing to be deleted.
-        let _ = remove_dir_all(self.base_directory_path.join("data"));
-
-        Ok(())
-    }
-
-    fn spawn(&mut self, genesis: Genesis) -> anyhow::Result<()> {
-        self.init(genesis)?.spawn_process()
-    }
-
-    fn version(&self) -> anyhow::Result<String> {
-        let output = Command::new(&self.polkadot_omnichain_node_binary_path)
-            .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())
-    }
-}
-
-impl Drop for PolkadotOmnichainNode {
-    fn drop(&mut self) {
-        self.shutdown().expect("Failed to shutdown")
-    }
-}

crates/node/src/node_implementations/substrate.rs

@@ -47,7 +47,7 @@ use tracing::{instrument, trace};
 
 use crate::{
     Node,
-    constants::INITIAL_BALANCE,
+    constants::{CHAIN_ID, INITIAL_BALANCE},
     helpers::{Process, ProcessReadinessWaitBehavior},
     provider_utils::{
         ConcreteProvider, FallbackGasFiller, construct_concurrency_limited_provider,
@@ -327,9 +327,13 @@ impl SubstrateNode {
             .get_or_try_init(|| async move {
                 construct_concurrency_limited_provider::<Ethereum, _>(
                     self.rpc_url.as_str(),
-                    FallbackGasFiller::default()
+                    FallbackGasFiller::new(
-                        .with_fallback_mechanism(self.use_fallback_gas_filler),
+                        u64::MAX,
-                    ChainIdFiller::default(),
+                        50_000_000_000,
+                        1_000_000_000,
+                        self.use_fallback_gas_filler,
+                    ),
+                    ChainIdFiller::new(Some(CHAIN_ID)),
                     NonceFiller::new(self.nonce_manager.clone()),
                     self.wallet.clone(),
                 )

crates/node/src/node_implementations/zombienet.rs

@@ -334,8 +334,12 @@ impl ZombienetNode {
             .get_or_try_init(|| async move {
                 construct_concurrency_limited_provider::<Ethereum, _>(
                     self.connection_string.as_str(),
-                    FallbackGasFiller::default()
+                    FallbackGasFiller::new(
-                        .with_fallback_mechanism(self.use_fallback_gas_filler),
+                        u64::MAX,
+                        5_000_000_000,
+                        1_000_000_000,
+                        self.use_fallback_gas_filler,
+                    ),
                     ChainIdFiller::default(), // TODO: use CHAIN_ID constant
                     NonceFiller::new(self.nonce_manager.clone()),
                     self.wallet.clone(),

crates/node/src/provider_utils/fallback_gas_filler.rs

@@ -1,71 +1,65 @@
-use std::{borrow::Cow, fmt::Display};
-
 use alloy::{
-    eips::BlockNumberOrTag,
     network::{Network, TransactionBuilder},
     providers::{
         Provider, SendableTx,
-        ext::DebugApi,
+        fillers::{GasFiller, TxFiller},
-        fillers::{GasFillable, GasFiller, TxFiller},
     },
-    rpc::types::trace::geth::{
+    transports::{TransportError, TransportResult},
-        GethDebugBuiltInTracerType, GethDebugTracerType, GethDebugTracingCallOptions,
-        GethDebugTracingOptions,
-    },
-    transports::{RpcError, TransportResult},
 };
 
-/// An implementation of [`GasFiller`] with a fallback mechanism for reverting  transactions.
+// Percentage padding applied to estimated gas (e.g. 120 = 20% padding)
-///
+const GAS_ESTIMATE_PADDING_NUMERATOR: u64 = 120;
-/// This struct provides a fallback mechanism for alloy's [`GasFiller`] which  kicks in when a
+const GAS_ESTIMATE_PADDING_DENOMINATOR: u64 = 100;
-/// transaction's dry run fails due to it reverting allowing us to get gas estimates even for
-/// failing transactions. In this codebase, this  is very important since the MatterLabs tests
-/// expect some transactions in the test suite revert. Since we're expected to run a number of
-/// assertions on these reverting transactions we must commit them to the ledger.
-///
-/// Therefore, this struct does the following:
-///
-/// 1. It first attempts to estimate the gas through the mechanism implemented in the [`GasFiller`].
-/// 2. If it fails, then we perform a debug trace of the transaction to find  out how much gas the
-///    transaction needs until it reverts.
-/// 3. We fill in these values (either the success or failure case) into the transaction.
-///
-/// The fallback mechanism of this filler can be completely disabled if we don't want it to be used.
-/// In that case, this gas filler will act in an identical  way to alloy's [`GasFiller`].
-///
-/// We then fill in these values into the transaction.
-///
-/// The previous implementation of this fallback gas filler relied on making use of default values
-/// for the gas limit in order to be able to submit the reverting transactions to the network. But,
-/// it introduced a number of issues that we weren't anticipating at the time when it was built.
-#[derive(Clone, Copy, Debug)]
-pub struct FallbackGasFiller {
-    /// The inner [`GasFiller`] which we pass all of the calls to in the happy path.
-    inner: GasFiller,
 
-    /// A [`bool`] that controls if the fallback mechanism is enabled or not.
+#[derive(Clone, Debug)]
-    enable_fallback_mechanism: bool,
+pub struct FallbackGasFiller {
+    inner: GasFiller,
+    default_gas_limit: u64,
+    default_max_fee_per_gas: u128,
+    default_priority_fee: u128,
+    use_fallback_gas_filler: bool,
 }
 
 impl FallbackGasFiller {
-    pub fn new() -> Self {
+    pub fn new(
+        default_gas_limit: u64,
+        default_max_fee_per_gas: u128,
+        default_priority_fee: u128,
+        use_fallback_gas_filler: bool,
+    ) -> Self {
         Self {
-            inner: Default::default(),
+            inner: GasFiller,
-            enable_fallback_mechanism: true,
+            default_gas_limit,
+            default_max_fee_per_gas,
+            default_priority_fee,
+            use_fallback_gas_filler,
         }
     }
 
-    pub fn with_fallback_mechanism(mut self, enable: bool) -> Self {
+    pub fn with_default_gas_limit(mut self, default_gas_limit: u64) -> Self {
-        self.enable_fallback_mechanism = enable;
+        self.default_gas_limit = default_gas_limit;
         self
     }
 
-    pub fn with_fallback_mechanism_enabled(self) -> Self {
+    pub fn with_default_max_fee_per_gas(mut self, default_max_fee_per_gas: u128) -> Self {
-        self.with_fallback_mechanism(true)
+        self.default_max_fee_per_gas = default_max_fee_per_gas;
+        self
     }
 
-    pub fn with_fallback_mechanism_disabled(self) -> Self {
+    pub fn with_default_priority_fee(mut self, default_priority_fee: u128) -> Self {
-        self.with_fallback_mechanism(false)
+        self.default_priority_fee = default_priority_fee;
+        self
+    }
+
+    pub fn with_use_fallback_gas_filler(mut self, use_fallback_gas_filler: bool) -> Self {
+        self.use_fallback_gas_filler = use_fallback_gas_filler;
+        self
+    }
+}
+
+impl Default for FallbackGasFiller {
+    fn default() -> Self {
+        FallbackGasFiller::new(25_000_000, 1_000_000_000, 1_000_000_000, true)
     }
 }
 
@@ -73,89 +67,32 @@ impl<N> TxFiller<N> for FallbackGasFiller
 where
     N: Network,
 {
-    type Fillable = <GasFiller as TxFiller<N>>::Fillable;
+    type Fillable = Option<<GasFiller as TxFiller<N>>::Fillable>;
 
     fn status(
         &self,
         tx: &<N as Network>::TransactionRequest,
     ) -> alloy::providers::fillers::FillerControlFlow {
-        TxFiller::<N>::status(&self.inner, tx)
+        <GasFiller as TxFiller<N>>::status(&self.inner, tx)
     }
 
-    fn fill_sync(&self, _: &mut SendableTx<N>) {}
+    fn fill_sync(&self, _: &mut alloy::providers::SendableTx<N>) {}
 
     async fn prepare<P: Provider<N>>(
         &self,
         provider: &P,
         tx: &<N as Network>::TransactionRequest,
     ) -> TransportResult<Self::Fillable> {
-        match (
+        match self.inner.prepare(provider, tx).await {
-            self.inner.prepare(provider, tx).await,
+            Ok(fill) => Ok(Some(fill)),
-            self.enable_fallback_mechanism,
+            Err(err) => {
-        ) {
+                tracing::debug!(error = ?err, "Gas Provider Estimation Failed, using fallback");
-            // Return the same thing if either this calls succeeds, or if the call falls and the
-            // fallback mechanism is disabled.
-            (rtn @ Ok(..), ..) | (rtn @ Err(..), false) => rtn,
-            (Err(..), true) => {
-                // Perform a trace of the transaction.
-                let trace = provider
-                    .debug_trace_call(
-                        tx.clone(),
-                        BlockNumberOrTag::Latest.into(),
-                        GethDebugTracingCallOptions {
-                            tracing_options: GethDebugTracingOptions {
-                                tracer: Some(GethDebugTracerType::BuiltInTracer(
-                                    GethDebugBuiltInTracerType::CallTracer,
-                                )),
-                                ..Default::default()
-                            },
-                            state_overrides: Default::default(),
-                            block_overrides: Default::default(),
-                        },
-                    )
-                    .await?
-                    .try_into_call_frame()
-                    .map_err(|err| {
-                        RpcError::LocalUsageError(
-                            FallbackGasFillerError::new(format!(
-                                "Expected a callframe trace, but got: {err:?}"
-                            ))
-                            .boxed(),
-                        )
-                    })?;
 
-                let gas_used = u64::try_from(trace.gas_used).map_err(|_| {
+                if !self.use_fallback_gas_filler {
-                    RpcError::LocalUsageError(
+                    Err(err)
-                        FallbackGasFillerError::new(
-                            "Transaction trace returned a value of gas used that exceeds u64",
-                        )
-                        .boxed(),
-                    )
-                })?;
-                let gas_limit = gas_used.saturating_mul(120) / 100;
-
-                if let Some(gas_price) = tx.gas_price() {
-                    return Ok(GasFillable::Legacy {
-                        gas_limit,
-                        gas_price,
-                    });
-                }
-
-                let estimate = if let (Some(max_fee_per_gas), Some(max_priority_fee_per_gas)) =
-                    (tx.max_fee_per_gas(), tx.max_priority_fee_per_gas())
-                {
-                    alloy::eips::eip1559::Eip1559Estimation {
-                        max_fee_per_gas,
-                        max_priority_fee_per_gas,
-                    }
                 } else {
-                    provider.estimate_eip1559_fees().await?
+                    Ok(None)
-                };
+                }
-
-                Ok(GasFillable::Eip1559 {
-                    gas_limit,
-                    estimate,
-                })
             }
         }
     }
@@ -163,35 +100,31 @@ where
     async fn fill(
         &self,
         fillable: Self::Fillable,
-        tx: SendableTx<N>,
+        mut tx: alloy::providers::SendableTx<N>,
     ) -> TransportResult<SendableTx<N>> {
-        self.inner.fill(fillable, tx).await
+        if let Some(fill) = fillable {
+            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 self.use_fallback_gas_filler {
+            if let Some(builder) = tx.as_mut_builder() {
+                builder.set_gas_limit(self.default_gas_limit);
+                builder.set_max_fee_per_gas(self.default_max_fee_per_gas);
+                builder.set_max_priority_fee_per_gas(self.default_priority_fee);
+            }
+            Ok(tx)
+        } else {
+            Err(TransportError::UnsupportedFeature(
+                "Fallback gas filler is disabled and we're attempting to do a gas estimate on a failing transaction",
+            ))
+        }
     }
 }
-
-impl Default for FallbackGasFiller {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-struct FallbackGasFillerError(Cow<'static, str>);
-
-impl FallbackGasFillerError {
-    pub fn new(string: impl Into<Cow<'static, str>>) -> Self {
-        Self(string.into())
-    }
-
-    pub fn boxed(self) -> Box<Self> {
-        Box::new(self)
-    }
-}
-
-impl Display for FallbackGasFillerError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        Display::fmt(&self.0, f)
-    }
-}
-
-impl std::error::Error for FallbackGasFillerError {}