Allow for the resolution of gas price

* Set the gc mode to archive in geth

* Add a maximum to the exponential backoff wait duration

* Edit the formatting of the CLI case reporter

Cargo.lock

@@ -4030,6 +4030,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "semver 1.0.26",
+ "tokio",
 ]
 
 [[package]]

crates/common/Cargo.toml

@@ -11,3 +11,4 @@ rust-version.workspace = true
 [dependencies]
 anyhow = { workspace = true }
 semver = { workspace = true }
+tokio = { workspace = true, default-features = false, features = ["time"] }

crates/common/src/futures/mod.rs

@@ -0,0 +1,3 @@
+mod poll;
+
+pub use poll::*;

crates/common/src/futures/poll.rs

@@ -0,0 +1,69 @@
+use std::ops::ControlFlow;
+use std::time::Duration;
+
+use anyhow::{Result, anyhow};
+
+const EXPONENTIAL_BACKOFF_MAX_WAIT_DURATION: Duration = Duration::from_secs(60);
+
+/// A function that polls for a fallible future for some period of time and errors if it fails to
+/// get a result after polling.
+///
+/// Given a future that returns a [`Result<ControlFlow<O, ()>>`], this function calls the future
+/// repeatedly (with some wait period) until the future returns a [`ControlFlow::Break`] or until it
+/// returns an [`Err`] in which case the function stops polling and returns the error.
+///
+/// If the future keeps returning [`ControlFlow::Continue`] and fails to return a [`Break`] within
+/// the permitted polling duration then this function returns an [`Err`]
+///
+/// [`Break`]: ControlFlow::Break
+/// [`Continue`]: ControlFlow::Continue
+pub async fn poll<F, O>(
+    polling_duration: Duration,
+    polling_wait_behavior: PollingWaitBehavior,
+    mut future: impl FnMut() -> F,
+) -> Result<O>
+where
+    F: Future<Output = Result<ControlFlow<O, ()>>>,
+{
+    let mut retries = 0;
+    let mut total_wait_duration = Duration::ZERO;
+    let max_allowed_wait_duration = polling_duration;
+
+    loop {
+        if total_wait_duration >= max_allowed_wait_duration {
+            break Err(anyhow!(
+                "Polling failed after {} retries and a total of {:?} of wait time",
+                retries,
+                total_wait_duration
+            ));
+        }
+
+        match future().await? {
+            ControlFlow::Continue(()) => {
+                let next_wait_duration = match polling_wait_behavior {
+                    PollingWaitBehavior::Constant(duration) => duration,
+                    PollingWaitBehavior::ExponentialBackoff => {
+                        Duration::from_secs(2u64.pow(retries))
+                            .min(EXPONENTIAL_BACKOFF_MAX_WAIT_DURATION)
+                    }
+                };
+                let next_wait_duration =
+                    next_wait_duration.min(max_allowed_wait_duration - total_wait_duration);
+                total_wait_duration += next_wait_duration;
+                retries += 1;
+
+                tokio::time::sleep(next_wait_duration).await;
+            }
+            ControlFlow::Break(output) => {
+                break Ok(output);
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+pub enum PollingWaitBehavior {
+    Constant(Duration),
+    #[default]
+    ExponentialBackoff,
+}

crates/common/src/lib.rs

@@ -2,6 +2,7 @@
 //! the workspace can benefit from.
 
 pub mod fs;
+pub mod futures;
 pub mod iterators;
 pub mod macros;
 pub mod types;

crates/core/src/driver/mod.rs

@@ -4,11 +4,10 @@ use std::collections::HashMap;
 use std::marker::PhantomData;
 use std::path::PathBuf;
 
-use alloy::eips::BlockNumberOrTag;
 use alloy::hex;
 use alloy::json_abi::JsonAbi;
 use alloy::network::{Ethereum, TransactionBuilder};
-use alloy::primitives::{BlockNumber, U256};
+use alloy::primitives::U256;
 use alloy::rpc::types::TransactionReceipt;
 use alloy::rpc::types::trace::geth::{
     CallFrame, GethDebugBuiltInTracerType, GethDebugTracerType, GethDebugTracingOptions, GethTrace,
@@ -23,7 +22,7 @@ use alloy::{
 };
 use anyhow::Context;
 use indexmap::IndexMap;
-use revive_dt_format::traits::ResolverApi;
+use revive_dt_format::traits::{ResolutionContext, ResolverApi};
 use semver::Version;
 
 use revive_dt_format::case::{Case, CaseIdx};
@@ -88,13 +87,7 @@ where
             .handle_input_call_frame_tracing(&execution_receipt, node)
             .await?;
         self.handle_input_variable_assignment(input, &tracing_result)?;
-        let resolver = BlockPinnedResolver::<'_, T> {
-            node,
-            block_number: execution_receipt
-                .block_number
-                .context("Transaction was not included in a block")?,
-        };
-        self.handle_input_expectations(input, &execution_receipt, &resolver, &tracing_result)
+        self.handle_input_expectations(input, &execution_receipt, node, &tracing_result)
             .await?;
         self.handle_input_diff(case_idx, execution_receipt, node)
             .await
@@ -171,7 +164,7 @@ where
                 .context("Failed to find deployment receipt"),
             Method::Fallback | Method::FunctionName(_) => {
                 let tx = match input
-                    .legacy_transaction(&self.deployed_contracts, &self.variables, node)
+                    .legacy_transaction(node, self.default_resolution_context())
                     .await
                 {
                     Ok(tx) => {
@@ -317,8 +310,10 @@ where
             }
         }
 
-        let deployed_contracts = &mut self.deployed_contracts;
-        let variables = &mut self.variables;
+        let resolution_context = self
+            .default_resolution_context()
+            .with_block_number(execution_receipt.block_number.as_ref())
+            .with_transaction_hash(&execution_receipt.transaction_hash);
 
         // Handling the receipt state assertion.
         let expected = !expectation.exception;
@@ -341,7 +336,7 @@ where
             let expected = expected_calldata;
             let actual = &tracing_result.output.as_ref().unwrap_or_default();
             if !expected
-                .is_equivalent(actual, deployed_contracts, &*variables, resolver)
+                .is_equivalent(actual, resolver, resolution_context)
                 .await?
             {
                 tracing::error!(
@@ -376,7 +371,7 @@ where
                 if let Some(ref expected_address) = expected_event.address {
                     let expected = Address::from_slice(
                         Calldata::new_compound([expected_address])
-                            .calldata(deployed_contracts, &*variables, resolver)
+                            .calldata(resolver, resolution_context)
                             .await?
                             .get(12..32)
                             .expect("Can't fail"),
@@ -404,7 +399,7 @@ where
                 {
                     let expected = Calldata::new_compound([expected]);
                     if !expected
-                        .is_equivalent(&actual.0, deployed_contracts, &*variables, resolver)
+                        .is_equivalent(&actual.0, resolver, resolution_context)
                         .await?
                     {
                         tracing::error!(
@@ -424,7 +419,7 @@ where
                 let expected = &expected_event.values;
                 let actual = &actual_event.data().data;
                 if !expected
-                    .is_equivalent(&actual.0, deployed_contracts, &*variables, resolver)
+                    .is_equivalent(&actual.0, resolver, resolution_context)
                     .await?
                 {
                     tracing::error!(
@@ -530,7 +525,7 @@ where
 
         if let Some(calldata) = calldata {
             let calldata = calldata
-                .calldata(&self.deployed_contracts, None, node)
+                .calldata(node, self.default_resolution_context())
                 .await?;
             code.extend(calldata);
         }
@@ -571,6 +566,12 @@ where
 
         Ok((address, abi, Some(receipt)))
     }
+
+    fn default_resolution_context(&self) -> ResolutionContext<'_> {
+        ResolutionContext::default()
+            .with_deployed_contracts(&self.deployed_contracts)
+            .with_variables(&self.variables)
+    }
 }
 
 pub struct CaseDriver<'a, Leader: Platform, Follower: Platform> {
@@ -685,67 +686,3 @@ where
         Ok(inputs_executed)
     }
 }
-
-pub struct BlockPinnedResolver<'a, T: Platform> {
-    block_number: BlockNumber,
-    node: &'a T::Blockchain,
-}
-
-impl<'a, T: Platform> ResolverApi for BlockPinnedResolver<'a, T> {
-    async fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
-        self.node.chain_id().await
-    }
-
-    async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
-        self.node
-            .block_gas_limit(self.resolve_block_number_or_tag(number))
-            .await
-    }
-
-    async fn block_coinbase(&self, number: BlockNumberOrTag) -> anyhow::Result<Address> {
-        self.node
-            .block_coinbase(self.resolve_block_number_or_tag(number))
-            .await
-    }
-
-    async fn block_difficulty(&self, number: BlockNumberOrTag) -> anyhow::Result<U256> {
-        self.node
-            .block_difficulty(self.resolve_block_number_or_tag(number))
-            .await
-    }
-
-    async fn block_hash(
-        &self,
-        number: BlockNumberOrTag,
-    ) -> anyhow::Result<alloy::primitives::BlockHash> {
-        self.node
-            .block_hash(self.resolve_block_number_or_tag(number))
-            .await
-    }
-
-    async fn block_timestamp(
-        &self,
-        number: BlockNumberOrTag,
-    ) -> anyhow::Result<alloy::primitives::BlockTimestamp> {
-        self.node
-            .block_timestamp(self.resolve_block_number_or_tag(number))
-            .await
-    }
-
-    async fn last_block_number(&self) -> anyhow::Result<alloy::primitives::BlockNumber> {
-        Ok(self.block_number)
-    }
-}
-
-impl<'a, T: Platform> BlockPinnedResolver<'a, T> {
-    fn resolve_block_number_or_tag(&self, number: BlockNumberOrTag) -> BlockNumberOrTag {
-        match number {
-            BlockNumberOrTag::Latest => BlockNumberOrTag::Number(self.block_number),
-            n @ BlockNumberOrTag::Finalized
-            | n @ BlockNumberOrTag::Safe
-            | n @ BlockNumberOrTag::Earliest
-            | n @ BlockNumberOrTag::Pending
-            | n @ BlockNumberOrTag::Number(_) => n,
-        }
-    }
-}

crates/core/src/main.rs

@@ -248,10 +248,10 @@ where
                         })
                         .collect::<Vec<_>>();
                     case_status.sort_by(|a, b| a.0.cmp(&b.0));
-                    for (_, case_name, case_status) in case_status.into_iter() {
+                    for (case_idx, case_name, case_status) in case_status.into_iter() {
                         if case_status {
                             eprintln!(
-                                "{GREEN}  Case Succeeded:{RESET} {}",
+                                "  {GREEN}Case Succeeded:{RESET} {} - Case Idx: {case_idx}",
                                 case_name
                                     .as_ref()
                                     .map(|string| string.as_str())
@@ -259,7 +259,7 @@ where
                             )
                         } else {
                             eprintln!(
-                                "{RED}  Case Failed:{RESET} {}",
+                                "  {RED}Case Failed:{RESET} {} - Case Idx: {case_idx}",
                                 case_name
                                     .as_ref()
                                     .map(|string| string.as_str())

crates/format/src/input.rs

@@ -3,7 +3,6 @@ use std::collections::HashMap;
 use alloy::{
     eips::BlockNumberOrTag,
     hex::ToHexExt,
-    json_abi::JsonAbi,
     network::TransactionBuilder,
     primitives::{Address, Bytes, U256},
     rpc::types::TransactionRequest,
@@ -15,8 +14,8 @@ use serde::{Deserialize, Serialize};
 
 use revive_dt_common::macros::define_wrapper_type;
 
-use crate::metadata::ContractInstance;
 use crate::traits::ResolverApi;
+use crate::{metadata::ContractInstance, traits::ResolutionContext};
 
 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
 pub struct Input {
@@ -187,37 +186,21 @@ impl Input {
         ContractInstance::new("Test")
     }
 
-    fn instance_to_address(
+    pub async fn encoded_input(
         &self,
-        instance: &ContractInstance,
-        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-    ) -> anyhow::Result<Address> {
-        deployed_contracts
-            .get(instance)
-            .map(|(a, _)| *a)
-            .ok_or_else(|| anyhow::anyhow!("instance {instance:?} not deployed"))
-    }
-
-    pub async fn encoded_input<'a>(
-        &'a self,
-        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
         resolver: &impl ResolverApi,
+        context: ResolutionContext<'_>,
     ) -> anyhow::Result<Bytes> {
         match self.method {
             Method::Deployer | Method::Fallback => {
-                let calldata = self
-                    .calldata
-                    .calldata(deployed_contracts, variables, resolver)
-                    .await?;
+                let calldata = self.calldata.calldata(resolver, context).await?;
 
                 Ok(calldata.into())
             }
             Method::FunctionName(ref function_name) => {
-                let Some(abi) = deployed_contracts.get(&self.instance).map(|(_, a)| a) else {
+                let Some(abi) = context.deployed_contract_abi(&self.instance) else {
                     tracing::error!(
                         contract_name = self.instance.as_ref(),
-                        available_abis = ?deployed_contracts.keys().collect::<Vec<_>>(),
                         "Attempted to lookup ABI of contract but it wasn't found"
                     );
                     anyhow::bail!("ABI for instance '{}' not found", self.instance.as_ref());
@@ -256,7 +239,7 @@ impl Input {
                 let mut calldata = Vec::<u8>::with_capacity(4 + self.calldata.size_requirement());
                 calldata.extend(function.selector().0);
                 self.calldata
-                    .calldata_into_slice(&mut calldata, deployed_contracts, variables, resolver)
+                    .calldata_into_slice(&mut calldata, resolver, context)
                     .await?;
 
                 Ok(calldata.into())
@@ -265,15 +248,12 @@ impl Input {
     }
 
     /// Parse this input into a legacy transaction.
-    pub async fn legacy_transaction<'a>(
-        &'a self,
-        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
+    pub async fn legacy_transaction(
+        &self,
         resolver: &impl ResolverApi,
+        context: ResolutionContext<'_>,
     ) -> anyhow::Result<TransactionRequest> {
-        let input_data = self
-            .encoded_input(deployed_contracts, variables, resolver)
-            .await?;
+        let input_data = self.encoded_input(resolver, context).await?;
         let transaction_request = TransactionRequest::default().from(self.caller).value(
             self.value
                 .map(|value| value.into_inner())
@@ -282,7 +262,10 @@ impl Input {
         match self.method {
             Method::Deployer => Ok(transaction_request.with_deploy_code(input_data)),
             _ => Ok(transaction_request
-                .to(self.instance_to_address(&self.instance, deployed_contracts)?)
+                .to(context
+                    .deployed_contract_address(&self.instance)
+                    .context("Failed to get the contract address")
+                    .copied()?)
                 .input(input_data.into())),
         }
     }
@@ -351,24 +334,22 @@ impl Calldata {
         }
     }
 
-    pub async fn calldata<'a>(
-        &'a self,
-        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
+    pub async fn calldata(
+        &self,
         resolver: &impl ResolverApi,
+        context: ResolutionContext<'_>,
     ) -> anyhow::Result<Vec<u8>> {
         let mut buffer = Vec::<u8>::with_capacity(self.size_requirement());
-        self.calldata_into_slice(&mut buffer, deployed_contracts, variables, resolver)
+        self.calldata_into_slice(&mut buffer, resolver, context)
             .await?;
         Ok(buffer)
     }
 
-    pub async fn calldata_into_slice<'a>(
-        &'a self,
+    pub async fn calldata_into_slice(
+        &self,
         buffer: &mut Vec<u8>,
-        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
         resolver: &impl ResolverApi,
+        context: ResolutionContext<'_>,
     ) -> anyhow::Result<()> {
         match self {
             Calldata::Single(bytes) => {
@@ -376,10 +357,7 @@ impl Calldata {
             }
             Calldata::Compound(items) => {
                 for (arg_idx, arg) in items.iter().enumerate() {
-                    match arg
-                        .resolve(deployed_contracts, variables.clone(), resolver)
-                        .await
-                    {
+                    match arg.resolve(resolver, context).await {
                         Ok(resolved) => {
                             buffer.extend(resolved.to_be_bytes::<32>());
                         }
@@ -402,12 +380,11 @@ impl Calldata {
     }
 
     /// Checks if this [`Calldata`] is equivalent to the passed calldata bytes.
-    pub async fn is_equivalent<'a>(
-        &'a self,
+    pub async fn is_equivalent(
+        &self,
         other: &[u8],
-        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
         resolver: &impl ResolverApi,
+        context: ResolutionContext<'_>,
     ) -> anyhow::Result<bool> {
         match self {
             Calldata::Single(calldata) => Ok(calldata == other),
@@ -429,9 +406,7 @@ impl Calldata {
                         std::borrow::Cow::Borrowed(other)
                     };
 
-                    let this = this
-                        .resolve(deployed_contracts, variables.clone(), resolver)
-                        .await?;
+                    let this = this.resolve(resolver, context).await?;
                     let other = U256::from_be_slice(&other);
                     if this != other {
                         return Ok(false);
@@ -444,17 +419,16 @@ impl Calldata {
 }
 
 impl CalldataItem {
-    async fn resolve<'a>(
-        &'a self,
-        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
+    async fn resolve(
+        &self,
         resolver: &impl ResolverApi,
+        context: ResolutionContext<'_>,
     ) -> anyhow::Result<U256> {
         let mut stack = Vec::<CalldataToken<U256>>::new();
 
         for token in self
             .calldata_tokens()
-            .map(|token| token.resolve(deployed_contracts, variables.clone(), resolver))
+            .map(|token| token.resolve(resolver, context))
         {
             let token = token.await?;
             let new_token = match token {
@@ -509,7 +483,7 @@ impl CalldataItem {
         }
     }
 
-    fn calldata_tokens<'a>(&'a self) -> impl Iterator<Item = CalldataToken<&'a str>> + 'a {
+    fn calldata_tokens(&self) -> impl Iterator<Item = CalldataToken<&str>> {
         self.0.split(' ').map(|item| match item {
             "+" => CalldataToken::Operation(Operation::Addition),
             "-" => CalldataToken::Operation(Operation::Subtraction),
@@ -533,9 +507,11 @@ impl<T> CalldataToken<T> {
     const GAS_LIMIT_VARIABLE: &str = "$GAS_LIMIT";
     const COINBASE_VARIABLE: &str = "$COINBASE";
     const DIFFICULTY_VARIABLE: &str = "$DIFFICULTY";
+    const BLOCK_BASE_FEE_VARIABLE: &str = "$BASE_FEE";
     const BLOCK_HASH_VARIABLE_PREFIX: &str = "$BLOCK_HASH";
     const BLOCK_NUMBER_VARIABLE: &str = "$BLOCK_NUMBER";
     const BLOCK_TIMESTAMP_VARIABLE: &str = "$BLOCK_TIMESTAMP";
+    const TRANSACTION_GAS_PRICE: &str = "$TRANSACTION_GAS_PRICE";
     const VARIABLE_PREFIX: &str = "$VARIABLE:";
 
     fn into_item(self) -> Option<T> {
@@ -555,24 +531,21 @@ impl<T: AsRef<str>> CalldataToken<T> {
     /// This piece of code is taken from the matter-labs-tester repository which is licensed under
     /// MIT or Apache. The original source code can be found here:
     /// https://github.com/matter-labs/era-compiler-tester/blob/0ed598a27f6eceee7008deab3ff2311075a2ec69/compiler_tester/src/test/case/input/value.rs#L43-L146
-    async fn resolve<'a>(
+    async fn resolve(
         self,
-        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        variables: impl Into<Option<&'a HashMap<String, U256>>> + Clone,
         resolver: &impl ResolverApi,
+        context: ResolutionContext<'_>,
     ) -> anyhow::Result<CalldataToken<U256>> {
         match self {
             Self::Item(item) => {
                 let item = item.as_ref();
                 let value = if let Some(instance) = item.strip_suffix(Self::ADDRESS_VARIABLE_SUFFIX)
                 {
-                    Ok(U256::from_be_slice(
-                        deployed_contracts
-                            .get(&ContractInstance::new(instance))
-                            .map(|(a, _)| *a)
-                            .ok_or_else(|| anyhow::anyhow!("Instance `{}` not found", instance))?
-                            .as_ref(),
-                    ))
+                    context
+                        .deployed_contract_address(&ContractInstance::new(instance))
+                        .ok_or_else(|| anyhow::anyhow!("Instance `{}` not found", instance))
+                        .map(AsRef::as_ref)
+                        .map(U256::from_be_slice)
                 } else if let Some(value) = item.strip_prefix(Self::NEGATIVE_VALUE_PREFIX) {
                     let value = U256::from_str_radix(value, 10).map_err(|error| {
                         anyhow::anyhow!("Invalid decimal literal after `-`: {}", error)
@@ -585,22 +558,36 @@ impl<T: AsRef<str>> CalldataToken<T> {
                         .ok_or_else(|| anyhow::anyhow!("`-0` is invalid literal"))?;
                     Ok(U256::MAX.checked_sub(value).expect("Always valid"))
                 } else if let Some(value) = item.strip_prefix(Self::HEX_LITERAL_PREFIX) {
-                    Ok(U256::from_str_radix(value, 16).map_err(|error| {
-                        anyhow::anyhow!("Invalid hexadecimal literal: {}", error)
-                    })?)
+                    U256::from_str_radix(value, 16)
+                        .map_err(|error| anyhow::anyhow!("Invalid hexadecimal literal: {}", error))
                 } else if item == Self::CHAIN_VARIABLE {
-                    let chain_id = resolver.chain_id().await?;
-                    Ok(U256::from(chain_id))
+                    resolver.chain_id().await.map(U256::from)
+                } else if item == Self::TRANSACTION_GAS_PRICE {
+                    context
+                        .transaction_hash()
+                        .context("No transaction hash provided to get the transaction gas price")
+                        .map(|tx_hash| resolver.transaction_gas_price(tx_hash))?
+                        .await
+                        .map(U256::from)
                 } else if item == Self::GAS_LIMIT_VARIABLE {
-                    let gas_limit = resolver.block_gas_limit(BlockNumberOrTag::Latest).await?;
-                    Ok(U256::from(gas_limit))
+                    resolver
+                        .block_gas_limit(context.resolve_block_number(BlockNumberOrTag::Latest))
+                        .await
+                        .map(U256::from)
                 } else if item == Self::COINBASE_VARIABLE {
-                    let coinbase = resolver.block_coinbase(BlockNumberOrTag::Latest).await?;
-                    Ok(U256::from_be_slice(coinbase.as_ref()))
+                    resolver
+                        .block_coinbase(context.resolve_block_number(BlockNumberOrTag::Latest))
+                        .await
+                        .map(|address| U256::from_be_slice(address.as_ref()))
                 } else if item == Self::DIFFICULTY_VARIABLE {
-                    let block_difficulty =
-                        resolver.block_difficulty(BlockNumberOrTag::Latest).await?;
-                    Ok(block_difficulty)
+                    resolver
+                        .block_difficulty(context.resolve_block_number(BlockNumberOrTag::Latest))
+                        .await
+                } else if item == Self::BLOCK_BASE_FEE_VARIABLE {
+                    resolver
+                        .block_base_fee(context.resolve_block_number(BlockNumberOrTag::Latest))
+                        .await
+                        .map(U256::from)
                 } else if item.starts_with(Self::BLOCK_HASH_VARIABLE_PREFIX) {
                     let offset: u64 = item
                         .split(':')
@@ -608,31 +595,34 @@ impl<T: AsRef<str>> CalldataToken<T> {
                         .and_then(|value| value.parse().ok())
                         .unwrap_or_default();
 
-                    let current_block_number = resolver.last_block_number().await?;
+                    let current_block_number = match context.tip_block_number() {
+                        Some(block_number) => *block_number,
+                        None => resolver.last_block_number().await?,
+                    };
                     let desired_block_number = current_block_number - offset;
 
                     let block_hash = resolver.block_hash(desired_block_number.into()).await?;
 
                     Ok(U256::from_be_bytes(block_hash.0))
                 } else if item == Self::BLOCK_NUMBER_VARIABLE {
-                    let current_block_number = resolver.last_block_number().await?;
+                    let current_block_number = match context.tip_block_number() {
+                        Some(block_number) => *block_number,
+                        None => resolver.last_block_number().await?,
+                    };
                     Ok(U256::from(current_block_number))
                 } else if item == Self::BLOCK_TIMESTAMP_VARIABLE {
-                    let timestamp = resolver.block_timestamp(BlockNumberOrTag::Latest).await?;
-                    Ok(U256::from(timestamp))
+                    resolver
+                        .block_timestamp(BlockNumberOrTag::Latest)
+                        .await
+                        .map(U256::from)
                 } else if let Some(variable_name) = item.strip_prefix(Self::VARIABLE_PREFIX) {
-                    let Some(variables) = variables.into() else {
-                        anyhow::bail!(
-                            "Variable resolution required but no variables were passed in"
-                        );
-                    };
-                    let Some(variable) = variables.get(variable_name) else {
-                        anyhow::bail!("No variable found with the name {}", variable_name)
-                    };
-                    Ok(*variable)
+                    context
+                        .variable(variable_name)
+                        .context("Variable lookup failed")
+                        .copied()
                 } else {
-                    Ok(U256::from_str_radix(item, 10)
-                        .map_err(|error| anyhow::anyhow!("Invalid decimal literal: {}", error))?)
+                    U256::from_str_radix(item, 10)
+                        .map_err(|error| anyhow::anyhow!("Invalid decimal literal: {}", error))
                 };
                 value.map(CalldataToken::Item)
             }
@@ -671,50 +661,49 @@ impl<'de> Deserialize<'de> for EtherValue {
 mod tests {
 
     use super::*;
-    use alloy::json_abi::JsonAbi;
-    use alloy_primitives::address;
+    use alloy::{eips::BlockNumberOrTag, json_abi::JsonAbi};
+    use alloy_primitives::{BlockHash, BlockNumber, BlockTimestamp, ChainId, TxHash, address};
     use alloy_sol_types::SolValue;
     use std::collections::HashMap;
 
     struct MockResolver;
 
     impl ResolverApi for MockResolver {
-        async fn chain_id(&self) -> anyhow::Result<alloy_primitives::ChainId> {
+        async fn chain_id(&self) -> anyhow::Result<ChainId> {
             Ok(0x123)
         }
 
-        async fn block_gas_limit(&self, _: alloy::eips::BlockNumberOrTag) -> anyhow::Result<u128> {
+        async fn block_gas_limit(&self, _: BlockNumberOrTag) -> anyhow::Result<u128> {
             Ok(0x1234)
         }
 
-        async fn block_coinbase(
-            &self,
-            _: alloy::eips::BlockNumberOrTag,
-        ) -> anyhow::Result<Address> {
+        async fn block_coinbase(&self, _: BlockNumberOrTag) -> anyhow::Result<Address> {
             Ok(Address::ZERO)
         }
 
-        async fn block_difficulty(&self, _: alloy::eips::BlockNumberOrTag) -> anyhow::Result<U256> {
+        async fn block_difficulty(&self, _: BlockNumberOrTag) -> anyhow::Result<U256> {
             Ok(U256::from(0x12345u128))
         }
 
-        async fn block_hash(
-            &self,
-            _: alloy::eips::BlockNumberOrTag,
-        ) -> anyhow::Result<alloy_primitives::BlockHash> {
+        async fn block_base_fee(&self, _: BlockNumberOrTag) -> anyhow::Result<u64> {
+            Ok(0x100)
+        }
+
+        async fn block_hash(&self, _: BlockNumberOrTag) -> anyhow::Result<BlockHash> {
             Ok([0xEE; 32].into())
         }
 
-        async fn block_timestamp(
-            &self,
-            _: alloy::eips::BlockNumberOrTag,
-        ) -> anyhow::Result<alloy_primitives::BlockTimestamp> {
+        async fn block_timestamp(&self, _: BlockNumberOrTag) -> anyhow::Result<BlockTimestamp> {
             Ok(0x123456)
         }
 
-        async fn last_block_number(&self) -> anyhow::Result<alloy_primitives::BlockNumber> {
+        async fn last_block_number(&self) -> anyhow::Result<BlockNumber> {
             Ok(0x1234567)
         }
+
+        async fn transaction_gas_price(&self, _: &TxHash) -> anyhow::Result<u128> {
+            Ok(0x200)
+        }
     }
 
     #[tokio::test]
@@ -753,10 +742,9 @@ mod tests {
             (Address::ZERO, parsed_abi),
         );
 
-        let encoded = input
-            .encoded_input(&contracts, None, &MockResolver)
-            .await
-            .unwrap();
+        let resolver = MockResolver;
+        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
+        let encoded = input.encoded_input(&resolver, context).await.unwrap();
         assert!(encoded.0.starts_with(&selector));
 
         type T = (u64,);
@@ -798,10 +786,9 @@ mod tests {
             (Address::ZERO, parsed_abi),
         );
 
-        let encoded = input
-            .encoded_input(&contracts, None, &MockResolver)
-            .await
-            .unwrap();
+        let resolver = MockResolver;
+        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
+        let encoded = input.encoded_input(&resolver, context).await.unwrap();
         assert!(encoded.0.starts_with(&selector));
 
         type T = (alloy_primitives::Address,);
@@ -846,10 +833,9 @@ mod tests {
             (Address::ZERO, parsed_abi),
         );
 
-        let encoded = input
-            .encoded_input(&contracts, None, &MockResolver)
-            .await
-            .unwrap();
+        let resolver = MockResolver;
+        let context = ResolutionContext::new_from_parts(&contracts, None, None, None);
+        let encoded = input.encoded_input(&resolver, context).await.unwrap();
         assert!(encoded.0.starts_with(&selector));
 
         type T = (alloy_primitives::Address,);
@@ -865,9 +851,8 @@ mod tests {
         deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
         resolver: &impl ResolverApi,
     ) -> anyhow::Result<U256> {
-        CalldataItem::new(input)
-            .resolve(deployed_contracts, None, resolver)
-            .await
+        let context = ResolutionContext::new_from_parts(deployed_contracts, None, None, None);
+        CalldataItem::new(input).resolve(resolver, context).await
     }
 
     #[tokio::test]
@@ -945,6 +930,26 @@ mod tests {
         )
     }
 
+    #[tokio::test]
+    async fn resolver_can_resolve_block_base_fee_variable() {
+        // Arrange
+        let input = "$BASE_FEE";
+
+        // Act
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver).await;
+
+        // Assert
+        let resolved = resolved.expect("Failed to resolve argument");
+        assert_eq!(
+            resolved,
+            MockResolver
+                .block_base_fee(Default::default())
+                .await
+                .map(U256::from)
+                .unwrap()
+        )
+    }
+
     #[tokio::test]
     async fn resolver_can_resolve_block_hash_variable() {
         // Arrange

crates/format/src/traits.rs

@@ -1,13 +1,22 @@
+use std::collections::HashMap;
+
 use alloy::eips::BlockNumberOrTag;
+use alloy::json_abi::JsonAbi;
 use alloy::primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId, U256};
+use alloy_primitives::TxHash;
 use anyhow::Result;
 
+use crate::metadata::ContractInstance;
+
 /// A trait of the interface are required to implement to be used by the resolution logic that this
 /// crate implements to go from string calldata and into the bytes calldata.
 pub trait ResolverApi {
     /// Returns the ID of the chain that the node is on.
     fn chain_id(&self) -> impl Future<Output = Result<ChainId>>;
 
+    /// Returns the gas price for the specified transaction.
+    fn transaction_gas_price(&self, tx_hash: &TxHash) -> impl Future<Output = Result<u128>>;
+
     // TODO: This is currently a u128 due to Kitchensink needing more than 64 bits for its gas limit
     // when we implement the changes to the gas we need to adjust this to be a u64.
     /// Returns the gas limit of the specified block.
@@ -19,6 +28,9 @@ pub trait ResolverApi {
     /// Returns the difficulty of the specified block.
     fn block_difficulty(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<U256>>;
 
+    /// Returns the base fee of the specified block.
+    fn block_base_fee(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<u64>>;
+
     /// Returns the hash of the specified block.
     fn block_hash(&self, number: BlockNumberOrTag) -> impl Future<Output = Result<BlockHash>>;
 
@@ -31,3 +43,108 @@ pub trait ResolverApi {
     /// Returns the number of the last block.
     fn last_block_number(&self) -> impl Future<Output = Result<BlockNumber>>;
 }
+
+#[derive(Clone, Copy, Debug, Default)]
+/// Contextual information required by the code that's performing the resolution.
+pub struct ResolutionContext<'a> {
+    /// When provided the contracts provided here will be used for resolutions.
+    deployed_contracts: Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>,
+
+    /// When provided the variables in here will be used for performing resolutions.
+    variables: Option<&'a HashMap<String, U256>>,
+
+    /// When provided this block number will be treated as the tip of the chain.
+    block_number: Option<&'a BlockNumber>,
+
+    /// When provided the resolver will use this transaction hash for all of its resolutions.
+    transaction_hash: Option<&'a TxHash>,
+}
+
+impl<'a> ResolutionContext<'a> {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn new_from_parts(
+        deployed_contracts: impl Into<Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>>,
+        variables: impl Into<Option<&'a HashMap<String, U256>>>,
+        block_number: impl Into<Option<&'a BlockNumber>>,
+        transaction_hash: impl Into<Option<&'a TxHash>>,
+    ) -> Self {
+        Self {
+            deployed_contracts: deployed_contracts.into(),
+            variables: variables.into(),
+            block_number: block_number.into(),
+            transaction_hash: transaction_hash.into(),
+        }
+    }
+
+    pub fn with_deployed_contracts(
+        mut self,
+        deployed_contracts: impl Into<Option<&'a HashMap<ContractInstance, (Address, JsonAbi)>>>,
+    ) -> Self {
+        self.deployed_contracts = deployed_contracts.into();
+        self
+    }
+
+    pub fn with_variables(
+        mut self,
+        variables: impl Into<Option<&'a HashMap<String, U256>>>,
+    ) -> Self {
+        self.variables = variables.into();
+        self
+    }
+
+    pub fn with_block_number(mut self, block_number: impl Into<Option<&'a BlockNumber>>) -> Self {
+        self.block_number = block_number.into();
+        self
+    }
+
+    pub fn with_transaction_hash(
+        mut self,
+        transaction_hash: impl Into<Option<&'a TxHash>>,
+    ) -> Self {
+        self.transaction_hash = transaction_hash.into();
+        self
+    }
+
+    pub fn resolve_block_number(&self, number: BlockNumberOrTag) -> BlockNumberOrTag {
+        match self.block_number {
+            Some(block_number) => match number {
+                BlockNumberOrTag::Latest => BlockNumberOrTag::Number(*block_number),
+                n @ (BlockNumberOrTag::Finalized
+                | BlockNumberOrTag::Safe
+                | BlockNumberOrTag::Earliest
+                | BlockNumberOrTag::Pending
+                | BlockNumberOrTag::Number(_)) => n,
+            },
+            None => number,
+        }
+    }
+
+    pub fn deployed_contract(&self, instance: &ContractInstance) -> Option<&(Address, JsonAbi)> {
+        self.deployed_contracts
+            .and_then(|deployed_contracts| deployed_contracts.get(instance))
+    }
+
+    pub fn deployed_contract_address(&self, instance: &ContractInstance) -> Option<&Address> {
+        self.deployed_contract(instance).map(|(a, _)| a)
+    }
+
+    pub fn deployed_contract_abi(&self, instance: &ContractInstance) -> Option<&JsonAbi> {
+        self.deployed_contract(instance).map(|(_, a)| a)
+    }
+
+    pub fn variable(&self, name: impl AsRef<str>) -> Option<&U256> {
+        self.variables
+            .and_then(|variables| variables.get(name.as_ref()))
+    }
+
+    pub fn tip_block_number(&self) -> Option<&'a BlockNumber> {
+        self.block_number
+    }
+
+    pub fn transaction_hash(&self) -> Option<&'a TxHash> {
+        self.transaction_hash
+    }
+}

crates/node/src/geth.rs

@@ -3,9 +3,13 @@
 use std::{
     fs::{File, OpenOptions, create_dir_all, remove_dir_all},
     io::{BufRead, BufReader, Read, Write},
+    ops::ControlFlow,
     path::PathBuf,
     process::{Child, Command, Stdio},
-    sync::atomic::{AtomicU32, Ordering},
+    sync::{
+        Arc,
+        atomic::{AtomicU32, Ordering},
+    },
     time::{Duration, Instant},
 };
 
@@ -13,11 +17,12 @@ use alloy::{
     eips::BlockNumberOrTag,
     genesis::{Genesis, GenesisAccount},
     network::{Ethereum, EthereumWallet, NetworkWallet},
-    primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, FixedBytes, U256},
+    primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, FixedBytes, TxHash, U256},
     providers::{
         Provider, ProviderBuilder,
         ext::DebugApi,
         fillers::{CachedNonceManager, ChainIdFiller, FillProvider, NonceFiller, TxFiller},
+        layers::CacheLayer,
     },
     rpc::types::{
         TransactionReceipt, TransactionRequest,
@@ -25,11 +30,13 @@ use alloy::{
     },
     signers::local::PrivateKeySigner,
 };
-use revive_dt_common::fs::clear_directory;
+use anyhow::Context;
+use tracing::{Instrument, Level};
+
+use revive_dt_common::{fs::clear_directory, futures::poll};
 use revive_dt_config::Arguments;
 use revive_dt_format::traits::ResolverApi;
 use revive_dt_node_interaction::EthereumNode;
-use tracing::Level;
 
 use crate::{Node, common::FallbackGasFiller, constants::INITIAL_BALANCE};
 
@@ -77,6 +84,10 @@ impl GethNode {
     const GETH_STDERR_LOG_FILE_NAME: &str = "node_stderr.log";
 
     const TRANSACTION_INDEXING_ERROR: &str = "transaction indexing is in progress";
+    const TRANSACTION_TRACING_ERROR: &str = "historical state not available in path scheme yet";
+
+    const RECEIPT_POLLING_DURATION: Duration = Duration::from_secs(5 * 60);
+    const TRACE_POLLING_DURATION: Duration = Duration::from_secs(60);
 
     /// Create the node directory and call `geth init` to configure the genesis.
     #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
@@ -102,6 +113,8 @@ impl GethNode {
         serde_json::to_writer(File::create(&genesis_path)?, &genesis)?;
 
         let mut child = Command::new(&self.geth)
+            .arg("--state.scheme")
+            .arg("hash")
             .arg("init")
             .arg("--datadir")
             .arg(&self.data_directory)
@@ -159,6 +172,12 @@ impl GethNode {
             .arg("0")
             .arg("--cache.blocklogs")
             .arg("512")
+            .arg("--state.scheme")
+            .arg("hash")
+            .arg("--syncmode")
+            .arg("full")
+            .arg("--gcmode")
+            .arg("archive")
             .stderr(stderr_logs_file.try_clone()?)
             .stdout(stdout_logs_file.try_clone()?)
             .spawn()?
@@ -239,6 +258,7 @@ impl GethNode {
                 .filler(FallbackGasFiller::new(500_000_000, 500_000_000, 1))
                 .filler(ChainIdFiller::default())
                 .filler(NonceFiller::new(nonce_manager))
+                .layer(CacheLayer::new(10_000))
                 .wallet(wallet)
                 .connect(&connection_string)
                 .await
@@ -248,22 +268,17 @@ impl GethNode {
 }
 
 impl EthereumNode for GethNode {
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     async fn execute_transaction(
         &self,
         transaction: TransactionRequest,
     ) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
-        let outer_span = tracing::debug_span!("Submitting transaction", ?transaction);
-        let _outer_guard = outer_span.enter();
-
-        let provider = self.provider().await?;
-
-        let pending_transaction = provider.send_transaction(transaction).await?;
-        let transaction_hash = pending_transaction.tx_hash();
-
-        let span = tracing::info_span!("Awaiting transaction receipt", ?transaction_hash);
+        let span = tracing::debug_span!("Submitting transaction", ?transaction);
         let _guard = span.enter();
 
+        let provider = Arc::new(self.provider().await?);
+        let transaction_hash = *provider.send_transaction(transaction).await?.tx_hash();
+
         // The following is a fix for the "transaction indexing is in progress" error that we
         // used to get. You can find more information on this in the following GH issue in geth
         // https://github.com/ethereum/go-ethereum/issues/28877. To summarize what's going on,
@@ -282,57 +297,64 @@ impl EthereumNode for GethNode {
         // allow for a larger wait time. Therefore, in here we allow for 5 minutes of waiting
         // with exponential backoff each time we attempt to get the receipt and find that it's
         // not available.
-        let mut retries = 0;
-        let mut total_wait_duration = Duration::from_secs(0);
-        let max_allowed_wait_duration = Duration::from_secs(5 * 60);
-        loop {
-            if total_wait_duration >= max_allowed_wait_duration {
-                tracing::error!(
-                    ?total_wait_duration,
-                    ?max_allowed_wait_duration,
-                    retry_count = retries,
-                    "Failed to get receipt after polling for it"
-                );
-                anyhow::bail!(
-                    "Polled for receipt for {total_wait_duration:?} but failed to get it"
-                );
-            }
-
-            match provider.get_transaction_receipt(*transaction_hash).await {
-                Ok(Some(receipt)) => {
-                    tracing::info!(?total_wait_duration, "Found receipt");
-                    break Ok(receipt);
-                }
-                Ok(None) => {}
-                Err(error) => {
-                    let error_string = error.to_string();
-                    if !error_string.contains(Self::TRANSACTION_INDEXING_ERROR) {
-                        break Err(error.into());
+        poll(
+            Self::RECEIPT_POLLING_DURATION,
+            Default::default(),
+            move || {
+                let provider = provider.clone();
+                async move {
+                    match provider.get_transaction_receipt(transaction_hash).await {
+                        Ok(Some(receipt)) => Ok(ControlFlow::Break(receipt)),
+                        Ok(None) => Ok(ControlFlow::Continue(())),
+                        Err(error) => {
+                            let error_string = error.to_string();
+                            match error_string.contains(Self::TRANSACTION_INDEXING_ERROR) {
+                                true => Ok(ControlFlow::Continue(())),
+                                false => Err(error.into()),
+                            }
+                        }
                     }
                 }
-            };
-
-            let next_wait_duration = Duration::from_secs(2u64.pow(retries))
-                .min(max_allowed_wait_duration - total_wait_duration);
-            total_wait_duration += next_wait_duration;
-            retries += 1;
-
-            tokio::time::sleep(next_wait_duration).await;
-        }
+            },
+        )
+        .instrument(tracing::info_span!(
+            "Awaiting transaction receipt",
+            ?transaction_hash
+        ))
+        .await
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id))]
     async fn trace_transaction(
         &self,
         transaction: &TransactionReceipt,
         trace_options: GethDebugTracingOptions,
     ) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
-        let tx_hash = transaction.transaction_hash;
-        Ok(self
-            .provider()
-            .await?
-            .debug_trace_transaction(tx_hash, trace_options)
-            .await?)
+        let provider = Arc::new(self.provider().await?);
+        poll(
+            Self::TRACE_POLLING_DURATION,
+            Default::default(),
+            move || {
+                let provider = provider.clone();
+                let trace_options = trace_options.clone();
+                async move {
+                    match provider
+                        .debug_trace_transaction(transaction.transaction_hash, trace_options)
+                        .await
+                    {
+                        Ok(trace) => Ok(ControlFlow::Break(trace)),
+                        Err(error) => {
+                            let error_string = error.to_string();
+                            match error_string.contains(Self::TRANSACTION_TRACING_ERROR) {
+                                true => Ok(ControlFlow::Continue(())),
+                                false => Err(error.into()),
+                            }
+                        }
+                    }
+                }
+            },
+        )
+        .await
     }
 
     #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
@@ -363,6 +385,16 @@ impl ResolverApi for GethNode {
             .map_err(Into::into)
     }
 
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
+        self.provider()
+            .await?
+            .get_transaction_receipt(*tx_hash)
+            .await?
+            .context("Failed to get the transaction receipt")
+            .map(|receipt| receipt.effective_gas_price)
+    }
+
     #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
     async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
         self.provider()
@@ -390,7 +422,22 @@ impl ResolverApi for GethNode {
             .get_block_by_number(number)
             .await?
             .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .map(|block| block.header.difficulty)
+            .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
+    }
+
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
+    async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
+        self.provider()
+            .await?
+            .get_block_by_number(number)
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
+            .and_then(|block| {
+                block
+                    .header
+                    .base_fee_per_gas
+                    .context("Failed to get the base fee per gas")
+            })
     }
 
     #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]

crates/node/src/kitchensink.rs

@@ -16,12 +16,14 @@ use alloy::{
         TransactionBuilderError, UnbuiltTransactionError,
     },
     primitives::{
-        Address, B64, B256, BlockHash, BlockNumber, BlockTimestamp, Bloom, Bytes, FixedBytes, U256,
+        Address, B64, B256, BlockHash, BlockNumber, BlockTimestamp, Bloom, Bytes, FixedBytes,
+        TxHash, U256,
     },
     providers::{
         Provider, ProviderBuilder,
         ext::DebugApi,
         fillers::{CachedNonceManager, ChainIdFiller, FillProvider, NonceFiller, TxFiller},
+        layers::CacheLayer,
     },
     rpc::types::{
         TransactionReceipt,
@@ -30,6 +32,7 @@ use alloy::{
     },
     signers::local::PrivateKeySigner,
 };
+use anyhow::Context;
 use revive_dt_common::fs::clear_directory;
 use revive_dt_format::traits::ResolverApi;
 use serde::{Deserialize, Serialize};
@@ -370,6 +373,7 @@ impl KitchensinkNode {
                 ))
                 .filler(ChainIdFiller::default())
                 .filler(NonceFiller::new(nonce_manager))
+                .layer(CacheLayer::new(10_000))
                 .wallet(wallet)
                 .connect(&connection_string)
                 .await
@@ -438,6 +442,16 @@ impl ResolverApi for KitchensinkNode {
             .map_err(Into::into)
     }
 
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    async fn transaction_gas_price(&self, tx_hash: &TxHash) -> anyhow::Result<u128> {
+        self.provider()
+            .await?
+            .get_transaction_receipt(*tx_hash)
+            .await?
+            .context("Failed to get the transaction receipt")
+            .map(|receipt| receipt.effective_gas_price)
+    }
+
     #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
     async fn block_gas_limit(&self, number: BlockNumberOrTag) -> anyhow::Result<u128> {
         self.provider()
@@ -465,7 +479,22 @@ impl ResolverApi for KitchensinkNode {
             .get_block_by_number(number)
             .await?
             .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
-            .map(|block| block.header.difficulty)
+            .map(|block| U256::from_be_bytes(block.header.mix_hash.0))
+    }
+
+    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
+    async fn block_base_fee(&self, number: BlockNumberOrTag) -> anyhow::Result<u64> {
+        self.provider()
+            .await?
+            .get_block_by_number(number)
+            .await?
+            .ok_or(anyhow::Error::msg("Blockchain has no blocks"))
+            .and_then(|block| {
+                block
+                    .header
+                    .base_fee_per_gas
+                    .context("Failed to get the base fee per gas")
+            })
     }
 
     #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]