Permit size difference in step output

assets/test_metadata.json

@@ -12,14 +12,6 @@
                     "address": "0xdeadbeef00000000000000000000000000000042",
                     "expected_balance": "1233"
                 },
-                {
-                    "address": "0xdeadbeef00000000000000000000000000000042",
-                    "is_storage_empty": true
-                },
-                {
-                    "address": "0xdeadbeef00000000000000000000000000000042",
-                    "is_storage_empty": false
-                },
                 {
                     "instance": "WBTC_1",
                     "method": "#deployer",

crates/core/src/driver/mod.rs

@@ -4,7 +4,6 @@ use std::collections::HashMap;
 use std::marker::PhantomData;
 use std::path::PathBuf;
 
-use alloy::consensus::EMPTY_ROOT_HASH;
 use alloy::hex;
 use alloy::json_abi::JsonAbi;
 use alloy::network::{Ethereum, TransactionBuilder};
@@ -29,7 +28,6 @@ use semver::Version;
 use revive_dt_format::case::{Case, CaseIdx};
 use revive_dt_format::input::{
     BalanceAssertion, Calldata, EtherValue, Expected, ExpectedOutput, Input, Method,
-    StorageEmptyAssertion,
 };
 use revive_dt_format::metadata::{ContractInstance, ContractPathAndIdent};
 use revive_dt_format::{input::Step, metadata::Metadata};
@@ -92,11 +90,6 @@ where
                     .await?;
                 Ok(StepOutput::BalanceAssertion)
             }
-            Step::StorageEmptyAssertion(storage_empty) => {
-                self.handle_storage_empty(metadata, case_idx, storage_empty, node)
-                    .await?;
-                Ok(StepOutput::StorageEmptyAssertion)
-            }
         }
     }
 
@@ -132,22 +125,7 @@ where
     ) -> anyhow::Result<()> {
         self.handle_balance_assertion_contract_deployment(metadata, balance_assertion, node)
             .await?;
-        self.handle_balance_assertion_execution(balance_assertion, node)
-            .await?;
-        Ok(())
-    }
 
-    pub async fn handle_storage_empty(
-        &mut self,
-        metadata: &Metadata,
-        _: CaseIdx,
-        storage_empty: &StorageEmptyAssertion,
-        node: &T::Blockchain,
-    ) -> anyhow::Result<()> {
-        self.handle_storage_empty_assertion_contract_deployment(metadata, storage_empty, node)
-            .await?;
-        self.handle_storage_empty_assertion_execution(storage_empty, node)
-            .await?;
         Ok(())
     }
 
@@ -579,67 +557,6 @@ where
         Ok(())
     }
 
-    pub async fn handle_storage_empty_assertion_contract_deployment(
-        &mut self,
-        metadata: &Metadata,
-        storage_empty_assertion: &StorageEmptyAssertion,
-        node: &T::Blockchain,
-    ) -> anyhow::Result<()> {
-        let Some(instance) = storage_empty_assertion
-            .address
-            .strip_prefix(".address")
-            .map(ContractInstance::new)
-        else {
-            return Ok(());
-        };
-        self.get_or_deploy_contract_instance(
-            &instance,
-            metadata,
-            Input::default_caller(),
-            None,
-            None,
-            node,
-        )
-        .await?;
-        Ok(())
-    }
-
-    pub async fn handle_storage_empty_assertion_execution(
-        &mut self,
-        StorageEmptyAssertion {
-            address: address_string,
-            is_storage_empty,
-        }: &StorageEmptyAssertion,
-        node: &T::Blockchain,
-    ) -> anyhow::Result<()> {
-        let address = Address::from_slice(
-            Calldata::new_compound([address_string])
-                .calldata(node, self.default_resolution_context())
-                .await?
-                .get(12..32)
-                .expect("Can't fail"),
-        );
-
-        let storage = node.latest_state_proof(address, Default::default()).await?;
-        let is_empty = storage.storage_hash == EMPTY_ROOT_HASH;
-
-        let expected = is_storage_empty;
-        let actual = is_empty;
-
-        if *expected != actual {
-            tracing::error!(%expected, %actual, %address, "Storage Empty Assertion failed");
-            anyhow::bail!(
-                "Storage Empty Assertion failed - Expected {} but got {} for {} resolved to {}",
-                expected,
-                actual,
-                address_string,
-                address,
-            )
-        };
-
-        Ok(())
-    }
-
     /// Gets the information of a deployed contract or library from the state. If it's found to not
     /// be deployed then it will be deployed.
     ///
@@ -863,7 +780,6 @@ where
                     }
                 }
                 (StepOutput::BalanceAssertion, StepOutput::BalanceAssertion) => {}
-                (StepOutput::StorageEmptyAssertion, StepOutput::StorageEmptyAssertion) => {}
                 _ => unreachable!("The two step outputs can not be of a different kind"),
             }
 
@@ -879,5 +795,4 @@ where
 pub enum StepOutput {
     FunctionCall(TransactionReceipt, GethTrace, DiffMode),
     BalanceAssertion,
-    StorageEmptyAssertion,
 }

crates/core/src/main.rs

@@ -451,7 +451,6 @@ where
             .filter_map(|step| match step {
                 Step::FunctionCall(input) => Some(input.caller),
                 Step::BalanceAssertion(..) => None,
-                Step::StorageEmptyAssertion(..) => None,
             })
             .next()
             .unwrap_or(Input::default_caller());

crates/format/src/case.rs

@@ -9,19 +9,13 @@ use crate::{
 
 #[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq)]
 pub struct Case {
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub comment: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub modes: Option<Vec<Mode>>,
     #[serde(rename = "inputs")]
     pub steps: Vec<Step>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub group: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub expected: Option<Expected>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub ignore: Option<bool>,
 }
 

crates/format/src/input.rs

@@ -28,37 +28,26 @@ pub enum Step {
     FunctionCall(Box<Input>),
     /// A step for performing a balance assertion on some account or contract.
     BalanceAssertion(Box<BalanceAssertion>),
-    /// A step for asserting that the storage of some contract or account is empty.
-    StorageEmptyAssertion(Box<StorageEmptyAssertion>),
 }
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
 pub struct Input {
     #[serde(default = "Input::default_caller")]
     pub caller: Address,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub comment: Option<String>,
     #[serde(default = "Input::default_instance")]
     pub instance: ContractInstance,
     pub method: Method,
     #[serde(default)]
     pub calldata: Calldata,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub expected: Option<Expected>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub value: Option<EtherValue>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub storage: Option<HashMap<String, Calldata>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub variable_assignments: Option<VariableAssignments>,
 }
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
 pub struct BalanceAssertion {
-    /// An optional comment on the balance assertion.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub comment: Option<String>,
-
     /// The address that the balance assertion should be done on.
     ///
     /// This is a string which will be resolved into an address when being processed. Therefore,
@@ -71,24 +60,6 @@ pub struct BalanceAssertion {
     pub expected_balance: U256,
 }
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
-pub struct StorageEmptyAssertion {
-    /// An optional comment on the storage empty assertion.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub comment: Option<String>,
-
-    /// The address that the balance assertion should be done on.
-    ///
-    /// This is a string which will be resolved into an address when being processed. Therefore,
-    /// this could be a normal hex address, a variable such as `Test.address`, or perhaps even a
-    /// full on variable like `$VARIABLE:Uniswap`. It follows the same resolution rules that are
-    /// followed in the calldata.
-    pub address: String,
-
-    /// A boolean of whether the storage of the address is empty or not.
-    pub is_storage_empty: bool,
-}
-
 #[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
 #[serde(untagged)]
 pub enum Expected {
@@ -99,11 +70,8 @@ pub enum Expected {
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
 pub struct ExpectedOutput {
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub compiler_version: Option<VersionReq>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub return_data: Option<Calldata>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub events: Option<Vec<Event>>,
     #[serde(default)]
     pub exception: bool,
@@ -111,7 +79,6 @@ pub struct ExpectedOutput {
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize, Eq, PartialEq)]
 pub struct Event {
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub address: Option<String>,
     pub topics: Vec<String>,
     pub values: Calldata,

crates/format/src/metadata.rs

@@ -45,18 +45,12 @@ impl Deref for MetadataFile {
 
 #[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq)]
 pub struct Metadata {
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub targets: Option<Vec<String>>,
     pub cases: Vec<Case>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub contracts: Option<BTreeMap<ContractInstance, ContractPathAndIdent>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub libraries: Option<BTreeMap<PathBuf, BTreeMap<ContractIdent, ContractInstance>>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub ignore: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub modes: Option<Vec<Mode>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub file_path: Option<PathBuf>,
 }
 

crates/node-interaction/src/lib.rs

@@ -1,8 +1,8 @@
 //! This crate implements all node interactions.
 
-use alloy::primitives::{Address, StorageKey, U256};
+use alloy::primitives::{Address, U256};
 use alloy::rpc::types::trace::geth::{DiffMode, GethDebugTracingOptions, GethTrace};
-use alloy::rpc::types::{EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest};
+use alloy::rpc::types::{TransactionReceipt, TransactionRequest};
 use anyhow::Result;
 
 /// An interface for all interactions with Ethereum compatible nodes.
@@ -25,11 +25,4 @@ pub trait EthereumNode {
 
     /// Returns the balance of the provided [`Address`] back.
     fn balance_of(&self, address: Address) -> impl Future<Output = Result<U256>>;
-
-    /// Returns the latest storage proof of the provided [`Address`]
-    fn latest_state_proof(
-        &self,
-        address: Address,
-        keys: Vec<StorageKey>,
-    ) -> impl Future<Output = Result<EIP1186AccountProofResponse>>;
 }

crates/node/src/geth.rs

@@ -17,16 +17,14 @@ use alloy::{
     eips::BlockNumberOrTag,
     genesis::{Genesis, GenesisAccount},
     network::{Ethereum, EthereumWallet, NetworkWallet},
-    primitives::{
-        Address, BlockHash, BlockNumber, BlockTimestamp, FixedBytes, StorageKey, TxHash, U256,
-    },
+    primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, FixedBytes, TxHash, U256},
     providers::{
         Provider, ProviderBuilder,
         ext::DebugApi,
         fillers::{CachedNonceManager, ChainIdFiller, FillProvider, NonceFiller, TxFiller},
     },
     rpc::types::{
-        EIP1186AccountProofResponse, TransactionReceipt, TransactionRequest,
+        TransactionReceipt, TransactionRequest,
         trace::geth::{DiffMode, GethDebugTracingOptions, PreStateConfig, PreStateFrame},
     },
     signers::local::PrivateKeySigner,
@@ -382,20 +380,6 @@ impl EthereumNode for GethNode {
             .await
             .map_err(Into::into)
     }
-
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
-    async fn latest_state_proof(
-        &self,
-        address: Address,
-        keys: Vec<StorageKey>,
-    ) -> anyhow::Result<EIP1186AccountProofResponse> {
-        self.provider()
-            .await?
-            .get_proof(address, keys)
-            .latest()
-            .await
-            .map_err(Into::into)
-    }
 }
 
 impl ResolverApi for GethNode {

crates/node/src/kitchensink.rs

@@ -17,7 +17,7 @@ use alloy::{
     },
     primitives::{
         Address, B64, B256, BlockHash, BlockNumber, BlockTimestamp, Bloom, Bytes, FixedBytes,
-        StorageKey, TxHash, U256,
+        TxHash, U256,
     },
     providers::{
         Provider, ProviderBuilder,
@@ -25,7 +25,7 @@ use alloy::{
         fillers::{CachedNonceManager, ChainIdFiller, FillProvider, NonceFiller, TxFiller},
     },
     rpc::types::{
-        EIP1186AccountProofResponse, TransactionReceipt,
+        TransactionReceipt,
         eth::{Block, Header, Transaction},
         trace::geth::{DiffMode, GethDebugTracingOptions, PreStateConfig, PreStateFrame},
     },
@@ -437,20 +437,6 @@ impl EthereumNode for KitchensinkNode {
             .await
             .map_err(Into::into)
     }
-
-    #[tracing::instrument(skip_all, fields(kitchensink_node_id = self.id))]
-    async fn latest_state_proof(
-        &self,
-        address: Address,
-        keys: Vec<StorageKey>,
-    ) -> anyhow::Result<EIP1186AccountProofResponse> {
-        self.provider()
-            .await?
-            .get_proof(address, keys)
-            .latest()
-            .await
-            .map_err(Into::into)
-    }
 }
 
 impl ResolverApi for KitchensinkNode {