Support linking at compile time

* Re-order the input file.

This commit reorders the input file such that we have a definitions
section and an implementations section and such that the the order of
the items in both sections is the same.

* Implement a reverse polish calculator for calldata arithmetic

Cargo.lock

@@ -3963,6 +3963,7 @@ dependencies = [
 name = "revive-dt-compiler"
 version = "0.1.0"
 dependencies = [
+ "alloy-primitives",
  "anyhow",
  "revive-common",
  "revive-dt-config",

crates/common/src/macros/define_wrapper_type.rs

@@ -48,11 +48,7 @@ macro_rules! define_wrapper_type {
         $vis struct $ident($ty);
 
         impl $ident {
-            pub fn new(value: $ty) -> Self {
-                Self(value)
-            }
-
-            pub fn new_from<T: Into<$ty>>(value: T) -> Self {
+            pub fn new(value: impl Into<$ty>) -> Self {
                 Self(value.into())
             }
 

crates/compiler/Cargo.toml

@@ -9,11 +9,13 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
 revive-solc-json-interface = { workspace = true }
 revive-dt-config = { workspace = true }
 revive-dt-solc-binaries = { workspace = true }
 revive-common = { workspace = true }
+
+alloy-primitives = { workspace = true }
+anyhow = { workspace = true }
 semver = { workspace = true }
 serde_json = { workspace = true }
 tracing = { workspace = true }

crates/compiler/src/lib.rs

@@ -9,6 +9,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use alloy_primitives::Address;
 use revive_dt_config::Arguments;
 
 use revive_common::EVMVersion;
@@ -158,6 +159,26 @@ where
         self
     }
 
+    pub fn with_library(
+        mut self,
+        scope: impl AsRef<Path>,
+        library_ident: impl AsRef<str>,
+        library_address: Address,
+    ) -> Self {
+        self.input
+            .settings
+            .libraries
+            .get_or_insert_with(Default::default)
+            .entry(scope.as_ref().display().to_string())
+            .or_default()
+            .insert(
+                library_ident.as_ref().to_owned(),
+                library_address.to_string(),
+            );
+
+        self
+    }
+
     pub fn try_build(self, solc_path: PathBuf) -> anyhow::Result<CompilerOutput<T::Options>> {
         T::new(solc_path).build(CompilerInput {
             extra_options: self.extra_options,

crates/core/src/driver/mod.rs

@@ -26,8 +26,8 @@ use revive_dt_common::iterators::FilesWithExtensionIterator;
 use revive_dt_compiler::{Compiler, SolidityCompiler};
 use revive_dt_config::Arguments;
 use revive_dt_format::case::CaseIdx;
-use revive_dt_format::input::{Calldata, Expected, ExpectedOutput, Method};
-use revive_dt_format::metadata::{ContractInstance, ContractPathAndIdentifier};
+use revive_dt_format::input::{Calldata, EtherValue, Expected, ExpectedOutput, Method};
+use revive_dt_format::metadata::{ContractInstance, ContractPathAndIdent};
 use revive_dt_format::{input::Input, metadata::Metadata, mode::SolcMode};
 use revive_dt_node::Node;
 use revive_dt_node_interaction::EthereumNode;
@@ -57,6 +57,12 @@ pub struct State<'a, T: Platform> {
     /// files.
     deployed_contracts: HashMap<CaseIdx, HashMap<ContractInstance, (Address, JsonAbi)>>,
 
+    /// This is a map of the deployed libraries.
+    ///
+    /// This map is not per case, but rather, per metadata file. This means that we do not redeploy
+    /// the libraries with each case.
+    deployed_libraries: HashMap<ContractInstance, (Address, JsonAbi)>,
+
     phantom: PhantomData<T>,
 }
 
@@ -70,6 +76,7 @@ where
             span,
             contracts: Default::default(),
             deployed_contracts: Default::default(),
+            deployed_libraries: Default::default(),
             phantom: Default::default(),
         }
     }
@@ -96,10 +103,28 @@ where
         let compiler = Compiler::<T::Compiler>::new()
             .allow_path(metadata.directory()?)
             .solc_optimizer(mode.solc_optimize());
-
-        let compiler = FilesWithExtensionIterator::new(metadata.directory()?)
+        let mut compiler = FilesWithExtensionIterator::new(metadata.directory()?)
             .with_allowed_extension("sol")
             .try_fold(compiler, |compiler, path| compiler.with_source(&path))?;
+        for (library_instance, (library_address, _)) in self.deployed_libraries.iter() {
+            let library_ident = &metadata
+                .contracts
+                .as_ref()
+                .and_then(|contracts| contracts.get(library_instance))
+                .expect("Impossible for library to not be found in contracts")
+                .contract_ident;
+
+            // Note the following: we need to tell solc which files require the libraries to be
+            // linked into them. We do not have access to this information and therefore we choose
+            // an easier, yet more compute intensive route, of telling solc that all of the files
+            // need to link the library and it will only perform the linking for the files that do
+            // actually need the library.
+            compiler = FilesWithExtensionIterator::new(metadata.directory()?)
+                .with_allowed_extension("sol")
+                .fold(compiler, |compiler, path| {
+                    compiler.with_library(&path, library_ident.as_str(), *library_address)
+                });
+        }
 
         let mut task = CompilationTask {
             json_input: compiler.input(),
@@ -141,6 +166,34 @@ where
         }
     }
 
+    pub fn build_and_publish_libraries(
+        &mut self,
+        metadata: &Metadata,
+        mode: &SolcMode,
+        node: &T::Blockchain,
+    ) -> anyhow::Result<()> {
+        self.build_contracts(mode, metadata)?;
+
+        for library_instance in metadata
+            .libraries
+            .iter()
+            .flatten()
+            .flat_map(|(_, map)| map.values())
+        {
+            self.get_or_deploy_contract_instance(
+                library_instance,
+                metadata,
+                None,
+                Input::default_caller(),
+                None,
+                None,
+                node,
+            )?;
+        }
+
+        Ok(())
+    }
+
     pub fn handle_input(
         &mut self,
         metadata: &Metadata,
@@ -173,12 +226,7 @@ where
 
         let mut instances_we_must_deploy = IndexMap::<ContractInstance, bool>::new();
         for instance in input.find_all_contract_instances().into_iter() {
-            if !self
-                .deployed_contracts
-                .entry(case_idx)
-                .or_default()
-                .contains_key(&instance)
-            {
+            if !self.deployed_contracts(case_idx).contains_key(&instance) {
                 instances_we_must_deploy.entry(instance).or_insert(false);
             }
         }
@@ -194,124 +242,22 @@ where
 
         let mut receipts = HashMap::new();
         for (instance, deploy_with_constructor_arguments) in instances_we_must_deploy.into_iter() {
-            // What we have at this moment is just a contract instance which is kind of like a variable
-            // name for an actual underlying contract. So, we need to resolve this instance to the info
-            // of the contract that it belongs to.
-            let Some(ContractPathAndIdentifier {
-                contract_source_path,
-                contract_ident,
-            }) = metadata.contract_sources()?.remove(&instance)
-            else {
-                tracing::error!("Contract source not found for instance");
-                anyhow::bail!("Contract source not found for instance {:?}", instance)
-            };
+            let calldata = deploy_with_constructor_arguments.then_some(&input.calldata);
+            let value = deploy_with_constructor_arguments
+                .then_some(input.value)
+                .flatten();
 
-            let compiled_contract = self.contracts.iter().find_map(|output| {
-                output
-                    .contracts
-                    .as_ref()?
-                    .get(&contract_source_path.display().to_string())
-                    .and_then(|source_file_contracts| {
-                        source_file_contracts.get(contract_ident.as_ref())
-                    })
-            });
-            let Some(code) = compiled_contract
-                .and_then(|contract| contract.evm.as_ref().and_then(|evm| evm.bytecode.as_ref()))
-            else {
-                tracing::error!(
-                    contract_source_path = contract_source_path.display().to_string(),
-                    contract_ident = contract_ident.as_ref(),
-                    "Failed to find bytecode for contract"
-                );
-                anyhow::bail!("Failed to find bytecode for contract {:?}", instance)
-            };
-
-            // TODO: When we want to do linking it would be best to do it at this stage here. We have
-            // the context from the metadata files and therefore know what needs to be linked and in
-            // what order it needs to happen.
-
-            let mut code = match alloy::hex::decode(&code.object) {
-                Ok(code) => code,
-                Err(error) => {
-                    tracing::error!(
-                        ?error,
-                        contract_source_path = contract_source_path.display().to_string(),
-                        contract_ident = contract_ident.as_ref(),
-                        "Failed to hex-decode byte code - This could possibly mean that the bytecode requires linking"
-                    );
-                    anyhow::bail!("Failed to hex-decode the byte code {}", error)
-                }
-            };
-
-            if deploy_with_constructor_arguments {
-                let encoded_input = input
-                    .encoded_input(self.deployed_contracts.entry(case_idx).or_default(), node)?;
-                code.extend(encoded_input.to_vec());
+            if let (_, _, Some(receipt)) = self.get_or_deploy_contract_instance(
+                &instance,
+                metadata,
+                case_idx,
+                input.caller,
+                calldata,
+                value,
+                node,
+            )? {
+                receipts.insert(instance.clone(), receipt);
             }
-
-            let tx = {
-                let tx = TransactionRequest::default().from(input.caller);
-                let tx = match input.value {
-                    Some(ref value) if deploy_with_constructor_arguments => {
-                        tx.value(value.into_inner())
-                    }
-                    _ => tx,
-                };
-                TransactionBuilder::<Ethereum>::with_deploy_code(tx, code)
-            };
-
-            let receipt = match node.execute_transaction(tx) {
-                Ok(receipt) => receipt,
-                Err(error) => {
-                    tracing::error!(
-                        node = std::any::type_name::<T>(),
-                        ?error,
-                        "Contract deployment transaction failed."
-                    );
-                    return Err(error);
-                }
-            };
-
-            let Some(address) = receipt.contract_address else {
-                tracing::error!("Contract deployment transaction didn't return an address");
-                anyhow::bail!("Contract deployment didn't return an address");
-            };
-            tracing::info!(
-                instance_name = ?instance,
-                instance_address = ?address,
-                "Deployed contract"
-            );
-
-            let Some(Value::String(metadata)) =
-                compiled_contract.and_then(|contract| contract.metadata.as_ref())
-            else {
-                tracing::error!("Contract does not have a metadata field");
-                anyhow::bail!("Contract does not have a metadata field");
-            };
-
-            let Ok(metadata) = serde_json::from_str::<Value>(metadata) else {
-                tracing::error!(%metadata, "Failed to parse solc metadata into a structured value");
-                anyhow::bail!("Failed to parse solc metadata into a structured value {metadata}");
-            };
-
-            let Some(abi) = metadata.get("output").and_then(|value| value.get("abi")) else {
-                tracing::error!(%metadata, "Failed to access the .output.abi field of the solc metadata");
-                anyhow::bail!(
-                    "Failed to access the .output.abi field of the solc metadata {metadata}"
-                );
-            };
-
-            let Ok(abi) = serde_json::from_value::<JsonAbi>(abi.clone()) else {
-                tracing::error!(%metadata, "Failed to deserialize ABI into a structured format");
-                anyhow::bail!("Failed to deserialize ABI into a structured format {metadata}");
-            };
-
-            self.deployed_contracts
-                .entry(case_idx)
-                .or_default()
-                .insert(instance.clone(), (address, abi));
-
-            receipts.insert(instance.clone(), receipt);
         }
 
         Ok(receipts)
@@ -332,9 +278,7 @@ where
                 .remove(&input.instance)
                 .context("Failed to find deployment receipt"),
             Method::Fallback | Method::FunctionName(_) => {
-                let tx = match input
-                    .legacy_transaction(self.deployed_contracts.entry(case_idx).or_default(), node)
-                {
+                let tx = match input.legacy_transaction(self.deployed_contracts(case_idx), node) {
                     Ok(tx) => {
                         tracing::debug!("Legacy transaction data: {tx:#?}");
                         tx
@@ -442,7 +386,7 @@ where
         // Additionally, what happens if the compiler filter doesn't match? Do we consider that the
         // transaction should succeed? Do we just ignore the expectation?
 
-        let deployed_contracts = self.deployed_contracts.entry(case_idx).or_default();
+        let deployed_contracts = self.deployed_contracts(case_idx);
         let chain_state_provider = node;
 
         // Handling the receipt state assertion.
@@ -509,7 +453,7 @@ where
                     .iter()
                     .zip(actual_event.topics())
                 {
-                    let expected = Calldata::Compound(vec![expected.clone()]);
+                    let expected = Calldata::new_compound([expected]);
                     if !expected.is_equivalent(
                         &actual.0,
                         deployed_contracts,
@@ -567,6 +511,162 @@ where
 
         Ok((execution_receipt, trace, diff))
     }
+
+    fn deployed_contracts(
+        &mut self,
+        case_idx: impl Into<Option<CaseIdx>>,
+    ) -> &mut HashMap<ContractInstance, (Address, JsonAbi)> {
+        match case_idx.into() {
+            Some(case_idx) => self
+                .deployed_contracts
+                .entry(case_idx)
+                .or_insert_with(|| self.deployed_libraries.clone()),
+            None => &mut self.deployed_libraries,
+        }
+    }
+
+    /// 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.
+    ///
+    /// If a [`CaseIdx`] is not specified then this contact instance address will be stored in the
+    /// cross-case deployed contracts address mapping.
+    #[allow(clippy::too_many_arguments)]
+    pub fn get_or_deploy_contract_instance(
+        &mut self,
+        contract_instance: &ContractInstance,
+        metadata: &Metadata,
+        case_idx: impl Into<Option<CaseIdx>>,
+        deployer: Address,
+        calldata: Option<&Calldata>,
+        value: Option<EtherValue>,
+        node: &T::Blockchain,
+    ) -> anyhow::Result<(Address, JsonAbi, Option<TransactionReceipt>)> {
+        let case_idx = case_idx.into();
+
+        if let Some((address, abi)) = self.deployed_libraries.get(contract_instance) {
+            return Ok((*address, abi.clone(), None));
+        }
+        if let Some(case_idx) = case_idx {
+            if let Some((address, abi)) = self
+                .deployed_contracts
+                .get(&case_idx)
+                .and_then(|contracts| contracts.get(contract_instance))
+            {
+                return Ok((*address, abi.clone(), None));
+            }
+        }
+
+        let Some(ContractPathAndIdent {
+            contract_source_path,
+            contract_ident,
+        }) = metadata.contract_sources()?.remove(contract_instance)
+        else {
+            tracing::error!("Contract source not found for instance");
+            anyhow::bail!(
+                "Contract source not found for instance {:?}",
+                contract_instance
+            )
+        };
+
+        let compiled_contract = self.contracts.iter().rev().find_map(|output| {
+            output
+                .contracts
+                .as_ref()?
+                .get(&contract_source_path.display().to_string())
+                .and_then(|source_file_contracts| {
+                    source_file_contracts.get(contract_ident.as_ref())
+                })
+        });
+        let Some(code) = compiled_contract
+            .and_then(|contract| contract.evm.as_ref().and_then(|evm| evm.bytecode.as_ref()))
+        else {
+            tracing::error!(
+                contract_source_path = contract_source_path.display().to_string(),
+                contract_ident = contract_ident.as_ref(),
+                "Failed to find bytecode for contract"
+            );
+            anyhow::bail!(
+                "Failed to find bytecode for contract {:?}",
+                contract_instance
+            )
+        };
+
+        let mut code = match alloy::hex::decode(&code.object) {
+            Ok(code) => code,
+            Err(error) => {
+                tracing::error!(
+                    ?error,
+                    contract_source_path = contract_source_path.display().to_string(),
+                    contract_ident = contract_ident.as_ref(),
+                    "Failed to hex-decode byte code - This could possibly mean that the bytecode requires linking"
+                );
+                anyhow::bail!("Failed to hex-decode the byte code {}", error)
+            }
+        };
+
+        let Some(Value::String(metadata)) =
+            compiled_contract.and_then(|contract| contract.metadata.as_ref())
+        else {
+            tracing::error!("Contract does not have a metadata field");
+            anyhow::bail!("Contract does not have a metadata field");
+        };
+
+        let Ok(metadata) = serde_json::from_str::<Value>(metadata) else {
+            tracing::error!(%metadata, "Failed to parse solc metadata into a structured value");
+            anyhow::bail!("Failed to parse solc metadata into a structured value {metadata}");
+        };
+
+        let Some(abi) = metadata.get("output").and_then(|value| value.get("abi")) else {
+            tracing::error!(%metadata, "Failed to access the .output.abi field of the solc metadata");
+            anyhow::bail!("Failed to access the .output.abi field of the solc metadata {metadata}");
+        };
+
+        let Ok(abi) = serde_json::from_value::<JsonAbi>(abi.clone()) else {
+            tracing::error!(%metadata, "Failed to deserialize ABI into a structured format");
+            anyhow::bail!("Failed to deserialize ABI into a structured format {metadata}");
+        };
+
+        if let Some(calldata) = calldata {
+            let calldata = calldata.calldata(self.deployed_contracts(case_idx), node)?;
+            code.extend(calldata);
+        }
+
+        let tx = {
+            let tx = TransactionRequest::default().from(deployer);
+            let tx = match value {
+                Some(ref value) => tx.value(value.into_inner()),
+                _ => tx,
+            };
+            TransactionBuilder::<Ethereum>::with_deploy_code(tx, code)
+        };
+
+        let receipt = match node.execute_transaction(tx) {
+            Ok(receipt) => receipt,
+            Err(error) => {
+                tracing::error!(
+                    node = std::any::type_name::<T>(),
+                    ?error,
+                    "Contract deployment transaction failed."
+                );
+                return Err(error);
+            }
+        };
+
+        let Some(address) = receipt.contract_address else {
+            tracing::error!("Contract deployment transaction didn't return an address");
+            anyhow::bail!("Contract deployment didn't return an address");
+        };
+        tracing::info!(
+            instance_name = ?contract_instance,
+            instance_address = ?address,
+            "Deployed contract"
+        );
+
+        self.deployed_contracts(case_idx)
+            .insert(contract_instance.clone(), (address, abi.clone()));
+
+        Ok((address, abi, Some(receipt)))
+    }
 }
 
 pub struct Driver<'a, Leader: Platform, Follower: Platform> {
@@ -673,6 +773,42 @@ where
             let mut leader_state = State::<L>::new(self.config, span);
             let mut follower_state = State::<F>::new(self.config, span);
 
+            // Note: we are currently forced to do two compilation passes due to linking. In the
+            // first compilation pass we compile the libraries and publish them to the chain. In the
+            // second compilation pass we compile the contracts with the library addresses so that
+            // they're linked at compile-time.
+            let build_result = tracing::info_span!("Building and publishing libraries")
+                .in_scope(|| {
+                    match leader_state.build_and_publish_libraries(self.metadata, &mode, self.leader_node) {
+                        Ok(_) => {
+                            tracing::debug!(target = ?Target::Leader, "Library building succeeded");
+                            execution_result.add_successful_build(Target::Leader, mode.clone());
+                        },
+                        Err(error) => {
+                            tracing::error!(target = ?Target::Leader, ?error, "Library building failed");
+                            execution_result.add_failed_build(Target::Leader, mode.clone(), error);
+                            return Err(());
+                        }
+                    }
+                    match follower_state.build_and_publish_libraries(self.metadata, &mode, self.follower_node) {
+                        Ok(_) => {
+                            tracing::debug!(target = ?Target::Follower, "Library building succeeded");
+                            execution_result.add_successful_build(Target::Follower, mode.clone());
+                        },
+                        Err(error) => {
+                            tracing::error!(target = ?Target::Follower, ?error, "Library building failed");
+                            execution_result.add_failed_build(Target::Follower, mode.clone(), error);
+                            return Err(());
+                        }
+                    }
+                    Ok(())
+                });
+            if build_result.is_err() {
+                // Note: We skip to the next solc mode as there's nothing that we can do at this
+                // point, the building has failed. We do NOT bail out of the execution as a whole.
+                continue;
+            }
+
             // We build the contracts. If building the contracts for the metadata file fails then we
             // have no other option but to keep note of this error and move on to the next solc mode
             // and NOT just bail out of the execution as a whole.
@@ -709,7 +845,6 @@ where
 
             // For cases if one of the inputs fail then we move on to the next case and we do NOT
             // bail out of the whole thing.
-
             'case_loop: for (case_idx, case) in self.metadata.cases.iter().enumerate() {
                 let tracing_span = tracing::info_span!(
                     "Handling case",
@@ -718,7 +853,7 @@ where
                 );
                 let _guard = tracing_span.enter();
 
-                let case_idx = CaseIdx::new_from(case_idx);
+                let case_idx = CaseIdx::new(case_idx);
 
                 // For inputs if one of the inputs fail we move on to the next case (we do not move
                 // on to the next input as it doesn't make sense. It depends on the previous one).

crates/format/src/input.rs

@@ -8,6 +8,7 @@ use alloy::{
     rpc::types::TransactionRequest,
 };
 use alloy_primitives::{FixedBytes, utils::parse_units};
+use anyhow::Context;
 use semver::VersionReq;
 use serde::{Deserialize, Serialize};
 
@@ -18,10 +19,10 @@ use crate::traits::ResolverApi;
 
 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
 pub struct Input {
-    #[serde(default = "default_caller")]
+    #[serde(default = "Input::default_caller")]
     pub caller: Address,
     pub comment: Option<String>,
-    #[serde(default = "default_instance")]
+    #[serde(default = "Input::default_instance")]
     pub instance: ContractInstance,
     pub method: Method,
     #[serde(default)]
@@ -55,11 +56,86 @@ pub struct Event {
     pub values: Calldata,
 }
 
+/// A type definition for the calldata supported by the testing framework.
+///
+/// We choose to document all of the types used in [`Calldata`] in this one doc comment to elaborate
+/// on why they exist and consolidate all of the documentation for calldata in a single place where
+/// it can be viewed and understood.
+///
+/// The [`Single`] variant of this enum is quite simple and straightforward: it's a hex-encoded byte
+/// array of the calldata.
+///
+/// The [`Compound`] type is more intricate and allows for capabilities such as resolution and some
+/// simple arithmetic operations. It houses a vector of [`CalldataItem`]s which is just a wrapper
+/// around an owned string.
+///
+/// A [`CalldataItem`] could be a simple hex string of a single calldata argument, but it could also
+/// be something that requires resolution such as `MyContract.address` which is a variable that is
+/// understood by the resolution logic to mean "Lookup the address of this particular contract
+/// instance".
+///
+/// In addition to the above, the format supports some simple arithmetic operations like add, sub,
+/// divide, multiply, bitwise AND, bitwise OR, and bitwise XOR. Our parser understands the [reverse
+/// polish notation] simply because it's easy to write a calculator for that notation and since we
+/// do not have plans to use arithmetic too often in tests. In reverse polish notation a typical
+/// `2 + 4` would be written as `2 4 +` which makes this notation very simple to implement through
+/// a stack.
+///
+/// Combining the above, a single [`CalldataItem`] could employ both resolution and arithmetic at
+/// the same time. For example, a [`CalldataItem`] of `$BLOCK_NUMBER $BLOCK_NUMBER +` means that
+/// the block number should be retrieved and then it should be added to itself.
+///
+/// Internally, we split the [`CalldataItem`] by spaces. Therefore, `$BLOCK_NUMBER $BLOCK_NUMBER+`
+/// is invalid but `$BLOCK_NUMBER $BLOCK_NUMBER +` is valid and can be understood by the parser and
+/// calculator. After the split is done, each token is parsed into a [`CalldataToken<&str>`] forming
+/// an [`Iterator`] over [`CalldataToken<&str>`]. A [`CalldataToken<&str>`] can then be resolved
+/// into a [`CalldataToken<U256>`] through the resolution logic. Finally, after resolution is done,
+/// this iterator of [`CalldataToken<U256>`] is collapsed into the final result by applying the
+/// arithmetic operations requested.
+///
+/// For example, supplying a [`Compound`] calldata of `0xdeadbeef` produces an iterator of a single
+/// [`CalldataToken<&str>`] items of the value [`CalldataToken::Item`] of the string value 12 which
+/// we can then resolve into the appropriate [`U256`] value and convert into calldata.
+///
+/// In summary, the various types used in [`Calldata`] represent the following:
+/// - [`CalldataItem`]: A calldata string from the metadata files.
+/// - [`CalldataToken<&str>`]: Typically used in an iterator of items from the space splitted
+///   [`CalldataItem`] and represents a token that has not yet been resolved into its value.
+/// - [`CalldataToken<U256>`]: Represents a token that's been resolved from being a string and into
+///   the word-size calldata argument on which we can perform arithmetic.
+///
+/// [`Single`]: Calldata::Single
+/// [`Compound`]: Calldata::Compound
+/// [reverse polish notation]: https://en.wikipedia.org/wiki/Reverse_Polish_notation
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
 #[serde(untagged)]
 pub enum Calldata {
     Single(Bytes),
-    Compound(Vec<String>),
+    Compound(Vec<CalldataItem>),
+}
+
+define_wrapper_type! {
+    /// This represents an item in the [`Calldata::Compound`] variant.
+    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+    #[serde(transparent)]
+    pub struct CalldataItem(String);
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+enum CalldataToken<T> {
+    Item(T),
+    Operation(Operation),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+enum Operation {
+    Addition,
+    Subtraction,
+    Multiplication,
+    Division,
+    BitwiseAnd,
+    BitwiseOr,
+    BitwiseXor,
 }
 
 /// Specify how the contract is called.
@@ -88,154 +164,17 @@ define_wrapper_type!(
     pub struct EtherValue(U256);
 );
 
-impl Serialize for EtherValue {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        format!("{} wei", self.0).serialize(serializer)
-    }
-}
-
-impl<'de> Deserialize<'de> for EtherValue {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let string = String::deserialize(deserializer)?;
-        let mut splitted = string.split(' ');
-        let (Some(value), Some(unit)) = (splitted.next(), splitted.next()) else {
-            return Err(serde::de::Error::custom("Failed to parse the value"));
-        };
-        let parsed = parse_units(value, unit.replace("eth", "ether"))
-            .map_err(|_| serde::de::Error::custom("Failed to parse units"))?
-            .into();
-        Ok(Self(parsed))
-    }
-}
-
-impl ExpectedOutput {
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    pub fn with_success(mut self) -> Self {
-        self.exception = false;
-        self
-    }
-
-    pub fn with_failure(mut self) -> Self {
-        self.exception = true;
-        self
-    }
-
-    pub fn with_calldata(mut self, calldata: Calldata) -> Self {
-        self.return_data = Some(calldata);
-        self
-    }
-}
-
-impl Default for Calldata {
-    fn default() -> Self {
-        Self::Compound(Default::default())
-    }
-}
-
-impl Calldata {
-    pub fn find_all_contract_instances(&self, vec: &mut Vec<ContractInstance>) {
-        if let Calldata::Compound(compound) = self {
-            for item in compound {
-                if let Some(instance) = item.strip_suffix(".address") {
-                    vec.push(ContractInstance::new_from(instance))
-                }
-            }
-        }
-    }
-
-    pub fn calldata(
-        &self,
-        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        chain_state_provider: &impl ResolverApi,
-    ) -> anyhow::Result<Vec<u8>> {
-        let mut buffer = Vec::<u8>::with_capacity(self.size_requirement());
-        self.calldata_into_slice(&mut buffer, deployed_contracts, chain_state_provider)?;
-        Ok(buffer)
-    }
-
-    pub fn calldata_into_slice(
-        &self,
-        buffer: &mut Vec<u8>,
-        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        chain_state_provider: &impl ResolverApi,
-    ) -> anyhow::Result<()> {
-        match self {
-            Calldata::Single(bytes) => {
-                buffer.extend_from_slice(bytes);
-            }
-            Calldata::Compound(items) => {
-                for (arg_idx, arg) in items.iter().enumerate() {
-                    match resolve_argument(arg, deployed_contracts, chain_state_provider) {
-                        Ok(resolved) => {
-                            buffer.extend(resolved.to_be_bytes::<32>());
-                        }
-                        Err(error) => {
-                            tracing::error!(arg, arg_idx, ?error, "Failed to resolve argument");
-                            return Err(error);
-                        }
-                    };
-                }
-            }
-        };
-        Ok(())
-    }
-
-    pub fn size_requirement(&self) -> usize {
-        match self {
-            Calldata::Single(single) => single.len(),
-            Calldata::Compound(items) => items.len() * 32,
-        }
-    }
-
-    /// Checks if this [`Calldata`] is equivalent to the passed calldata bytes.
-    pub fn is_equivalent(
-        &self,
-        other: &[u8],
-        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-        chain_state_provider: &impl ResolverApi,
-    ) -> anyhow::Result<bool> {
-        match self {
-            Calldata::Single(calldata) => Ok(calldata == other),
-            Calldata::Compound(items) => {
-                // Chunking the "other" calldata into 32 byte chunks since each
-                // one of the items in the compound calldata represents 32 bytes
-                for (this, other) in items.iter().zip(other.chunks(32)) {
-                    // The matterlabs format supports wildcards and therefore we
-                    // also need to support them.
-                    if this == "*" {
-                        continue;
-                    }
-
-                    let other = if other.len() < 32 {
-                        let mut vec = other.to_vec();
-                        vec.resize(32, 0);
-                        std::borrow::Cow::Owned(vec)
-                    } else {
-                        std::borrow::Cow::Borrowed(other)
-                    };
-
-                    let this = resolve_argument(this, deployed_contracts, chain_state_provider)?;
-                    let other = U256::from_be_slice(&other);
-                    if this != other {
-                        return Ok(false);
-                    }
-                }
-                Ok(true)
-            }
-        }
-    }
-}
-
 impl Input {
+    pub const fn default_caller() -> Address {
+        Address(FixedBytes(alloy::hex!(
+            "0x90F8bf6A479f320ead074411a4B0e7944Ea8c9C1"
+        )))
+    }
+
+    fn default_instance() -> ContractInstance {
+        ContractInstance::new("Test")
+    }
+
     fn instance_to_address(
         &self,
         instance: &ContractInstance,
@@ -343,84 +282,337 @@ impl Input {
     }
 }
 
-fn default_instance() -> ContractInstance {
-    ContractInstance::new_from("Test")
+impl ExpectedOutput {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn with_success(mut self) -> Self {
+        self.exception = false;
+        self
+    }
+
+    pub fn with_failure(mut self) -> Self {
+        self.exception = true;
+        self
+    }
+
+    pub fn with_calldata(mut self, calldata: Calldata) -> Self {
+        self.return_data = Some(calldata);
+        self
+    }
 }
 
-pub const fn default_caller() -> Address {
-    Address(FixedBytes(alloy::hex!(
-        "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1"
-    )))
+impl Default for Calldata {
+    fn default() -> Self {
+        Self::Compound(Default::default())
+    }
 }
 
-/// This function takes in the string calldata argument provided in the JSON input and resolves it
-/// into a [`U256`] which is later used to construct the calldata.
-///
-/// # Note
-///
-/// 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
-fn resolve_argument(
-    value: &str,
-    deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
-    chain_state_provider: &impl ResolverApi,
-) -> anyhow::Result<U256> {
-    if let Some(instance) = value.strip_suffix(".address") {
-        Ok(U256::from_be_slice(
-            deployed_contracts
-                .get(&ContractInstance::new_from(instance))
-                .map(|(a, _)| *a)
-                .ok_or_else(|| anyhow::anyhow!("Instance `{}` not found", instance))?
-                .as_ref(),
-        ))
-    } else if let Some(value) = value.strip_prefix('-') {
-        let value = U256::from_str_radix(value, 10)
-            .map_err(|error| anyhow::anyhow!("Invalid decimal literal after `-`: {}", error))?;
-        if value > U256::ONE << 255u8 {
-            anyhow::bail!("Decimal literal after `-` is too big");
+impl Calldata {
+    pub fn new_single(item: impl Into<Bytes>) -> Self {
+        Self::Single(item.into())
+    }
+
+    pub fn new_compound(items: impl IntoIterator<Item = impl AsRef<str>>) -> Self {
+        Self::Compound(
+            items
+                .into_iter()
+                .map(|item| item.as_ref().to_owned())
+                .map(CalldataItem::new)
+                .collect(),
+        )
+    }
+
+    pub fn find_all_contract_instances(&self, vec: &mut Vec<ContractInstance>) {
+        if let Calldata::Compound(compound) = self {
+            for item in compound {
+                if let Some(instance) =
+                    item.strip_suffix(CalldataToken::<()>::ADDRESS_VARIABLE_SUFFIX)
+                {
+                    vec.push(ContractInstance::new(instance))
+                }
+            }
         }
-        let value = value
-            .checked_sub(U256::ONE)
-            .ok_or_else(|| anyhow::anyhow!("`-0` is invalid literal"))?;
-        Ok(U256::MAX.checked_sub(value).expect("Always valid"))
-    } else if let Some(value) = value.strip_prefix("0x") {
-        Ok(U256::from_str_radix(value, 16)
-            .map_err(|error| anyhow::anyhow!("Invalid hexadecimal literal: {}", error))?)
-    } else if value == "$CHAIN_ID" {
-        let chain_id = chain_state_provider.chain_id()?;
-        Ok(U256::from(chain_id))
-    } else if value == "$GAS_LIMIT" {
-        let gas_limit = chain_state_provider.block_gas_limit(BlockNumberOrTag::Latest)?;
-        Ok(U256::from(gas_limit))
-    } else if value == "$COINBASE" {
-        let coinbase = chain_state_provider.block_coinbase(BlockNumberOrTag::Latest)?;
-        Ok(U256::from_be_slice(coinbase.as_ref()))
-    } else if value == "$DIFFICULTY" {
-        let block_difficulty = chain_state_provider.block_difficulty(BlockNumberOrTag::Latest)?;
-        Ok(block_difficulty)
-    } else if value.starts_with("$BLOCK_HASH") {
-        let offset: u64 = value
-            .split(':')
-            .next_back()
-            .and_then(|value| value.parse().ok())
-            .unwrap_or_default();
+    }
 
-        let current_block_number = chain_state_provider.last_block_number()?;
-        let desired_block_number = current_block_number - offset;
+    pub fn calldata(
+        &self,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
+        chain_state_provider: &impl ResolverApi,
+    ) -> anyhow::Result<Vec<u8>> {
+        let mut buffer = Vec::<u8>::with_capacity(self.size_requirement());
+        self.calldata_into_slice(&mut buffer, deployed_contracts, chain_state_provider)?;
+        Ok(buffer)
+    }
 
-        let block_hash = chain_state_provider.block_hash(desired_block_number.into())?;
+    pub fn calldata_into_slice(
+        &self,
+        buffer: &mut Vec<u8>,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
+        chain_state_provider: &impl ResolverApi,
+    ) -> anyhow::Result<()> {
+        match self {
+            Calldata::Single(bytes) => {
+                buffer.extend_from_slice(bytes);
+            }
+            Calldata::Compound(items) => {
+                for (arg_idx, arg) in items.iter().enumerate() {
+                    match arg.resolve(deployed_contracts, chain_state_provider) {
+                        Ok(resolved) => {
+                            buffer.extend(resolved.to_be_bytes::<32>());
+                        }
+                        Err(error) => {
+                            tracing::error!(?arg, arg_idx, ?error, "Failed to resolve argument");
+                            return Err(error);
+                        }
+                    };
+                }
+            }
+        };
+        Ok(())
+    }
 
-        Ok(U256::from_be_bytes(block_hash.0))
-    } else if value == "$BLOCK_NUMBER" {
-        let current_block_number = chain_state_provider.last_block_number()?;
-        Ok(U256::from(current_block_number))
-    } else if value == "$BLOCK_TIMESTAMP" {
-        let timestamp = chain_state_provider.block_timestamp(BlockNumberOrTag::Latest)?;
-        Ok(U256::from(timestamp))
-    } else {
-        Ok(U256::from_str_radix(value, 10)
-            .map_err(|error| anyhow::anyhow!("Invalid decimal literal: {}", error))?)
+    pub fn size_requirement(&self) -> usize {
+        match self {
+            Calldata::Single(single) => single.len(),
+            Calldata::Compound(items) => items.len() * 32,
+        }
+    }
+
+    /// Checks if this [`Calldata`] is equivalent to the passed calldata bytes.
+    pub fn is_equivalent(
+        &self,
+        other: &[u8],
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
+        chain_state_provider: &impl ResolverApi,
+    ) -> anyhow::Result<bool> {
+        match self {
+            Calldata::Single(calldata) => Ok(calldata == other),
+            Calldata::Compound(items) => {
+                // Chunking the "other" calldata into 32 byte chunks since each
+                // one of the items in the compound calldata represents 32 bytes
+                for (this, other) in items.iter().zip(other.chunks(32)) {
+                    // The matterlabs format supports wildcards and therefore we
+                    // also need to support them.
+                    if this.as_ref() == "*" {
+                        continue;
+                    }
+
+                    let other = if other.len() < 32 {
+                        let mut vec = other.to_vec();
+                        vec.resize(32, 0);
+                        std::borrow::Cow::Owned(vec)
+                    } else {
+                        std::borrow::Cow::Borrowed(other)
+                    };
+
+                    let this = this.resolve(deployed_contracts, chain_state_provider)?;
+                    let other = U256::from_be_slice(&other);
+                    if this != other {
+                        return Ok(false);
+                    }
+                }
+                Ok(true)
+            }
+        }
+    }
+}
+
+impl CalldataItem {
+    fn resolve(
+        &self,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
+        chain_state_provider: &impl ResolverApi,
+    ) -> anyhow::Result<U256> {
+        let mut stack = Vec::<CalldataToken<U256>>::new();
+
+        for token in self
+            .calldata_tokens()
+            .map(|token| token.resolve(deployed_contracts, chain_state_provider))
+        {
+            let token = token?;
+            let new_token = match token {
+                CalldataToken::Item(_) => token,
+                CalldataToken::Operation(operation) => {
+                    let right_operand = stack
+                        .pop()
+                        .and_then(CalldataToken::into_item)
+                        .context("Invalid calldata arithmetic operation")?;
+                    let left_operand = stack
+                        .pop()
+                        .and_then(CalldataToken::into_item)
+                        .context("Invalid calldata arithmetic operation")?;
+
+                    let result = match operation {
+                        Operation::Addition => left_operand.checked_add(right_operand),
+                        Operation::Subtraction => left_operand.checked_sub(right_operand),
+                        Operation::Multiplication => left_operand.checked_mul(right_operand),
+                        Operation::Division => left_operand.checked_div(right_operand),
+                        Operation::BitwiseAnd => Some(left_operand & right_operand),
+                        Operation::BitwiseOr => Some(left_operand | right_operand),
+                        Operation::BitwiseXor => Some(left_operand ^ right_operand),
+                    }
+                    .context("Invalid calldata arithmetic operation")?;
+
+                    CalldataToken::Item(result)
+                }
+            };
+            stack.push(new_token)
+        }
+
+        match stack.as_slice() {
+            // Empty stack means that we got an empty compound calldata which we resolve to zero.
+            [] => Ok(U256::ZERO),
+            [CalldataToken::Item(item)] => Ok(*item),
+            _ => Err(anyhow::anyhow!("Invalid calldata arithmetic operation")),
+        }
+    }
+
+    fn calldata_tokens<'a>(&'a self) -> impl Iterator<Item = CalldataToken<&'a str>> + 'a {
+        self.0.split(' ').map(|item| match item {
+            "+" => CalldataToken::Operation(Operation::Addition),
+            "-" => CalldataToken::Operation(Operation::Subtraction),
+            "/" => CalldataToken::Operation(Operation::Division),
+            "*" => CalldataToken::Operation(Operation::Multiplication),
+            "&" => CalldataToken::Operation(Operation::BitwiseAnd),
+            "|" => CalldataToken::Operation(Operation::BitwiseOr),
+            "^" => CalldataToken::Operation(Operation::BitwiseXor),
+            _ => CalldataToken::Item(item),
+        })
+    }
+}
+
+impl<T> CalldataToken<T> {
+    const ADDRESS_VARIABLE_SUFFIX: &str = ".address";
+    const NEGATIVE_VALUE_PREFIX: char = '-';
+    const HEX_LITERAL_PREFIX: &str = "0x";
+    const CHAIN_VARIABLE: &str = "$CHAIN_ID";
+    const GAS_LIMIT_VARIABLE: &str = "$GAS_LIMIT";
+    const COINBASE_VARIABLE: &str = "$COINBASE";
+    const DIFFICULTY_VARIABLE: &str = "$DIFFICULTY";
+    const BLOCK_HASH_VARIABLE_PREFIX: &str = "$BLOCK_HASH";
+    const BLOCK_NUMBER_VARIABLE: &str = "$BLOCK_NUMBER";
+    const BLOCK_TIMESTAMP_VARIABLE: &str = "$BLOCK_TIMESTAMP";
+
+    fn into_item(self) -> Option<T> {
+        match self {
+            CalldataToken::Item(item) => Some(item),
+            CalldataToken::Operation(_) => None,
+        }
+    }
+}
+
+impl<T: AsRef<str>> CalldataToken<T> {
+    /// This function takes in the string calldata argument provided in the JSON input and resolves
+    /// it into a [`U256`] which is later used to construct the calldata.
+    ///
+    /// # Note
+    ///
+    /// 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
+    fn resolve(
+        self,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
+        chain_state_provider: &impl ResolverApi,
+    ) -> 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(),
+                    ))
+                } 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)
+                    })?;
+                    if value > U256::ONE << 255u8 {
+                        anyhow::bail!("Decimal literal after `-` is too big");
+                    }
+                    let value = value
+                        .checked_sub(U256::ONE)
+                        .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)
+                    })?)
+                } else if item == Self::CHAIN_VARIABLE {
+                    let chain_id = chain_state_provider.chain_id()?;
+                    Ok(U256::from(chain_id))
+                } else if item == Self::GAS_LIMIT_VARIABLE {
+                    let gas_limit =
+                        chain_state_provider.block_gas_limit(BlockNumberOrTag::Latest)?;
+                    Ok(U256::from(gas_limit))
+                } else if item == Self::COINBASE_VARIABLE {
+                    let coinbase = chain_state_provider.block_coinbase(BlockNumberOrTag::Latest)?;
+                    Ok(U256::from_be_slice(coinbase.as_ref()))
+                } else if item == Self::DIFFICULTY_VARIABLE {
+                    let block_difficulty =
+                        chain_state_provider.block_difficulty(BlockNumberOrTag::Latest)?;
+                    Ok(block_difficulty)
+                } else if item.starts_with(Self::BLOCK_HASH_VARIABLE_PREFIX) {
+                    let offset: u64 = item
+                        .split(':')
+                        .next_back()
+                        .and_then(|value| value.parse().ok())
+                        .unwrap_or_default();
+
+                    let current_block_number = chain_state_provider.last_block_number()?;
+                    let desired_block_number = current_block_number - offset;
+
+                    let block_hash =
+                        chain_state_provider.block_hash(desired_block_number.into())?;
+
+                    Ok(U256::from_be_bytes(block_hash.0))
+                } else if item == Self::BLOCK_NUMBER_VARIABLE {
+                    let current_block_number = chain_state_provider.last_block_number()?;
+                    Ok(U256::from(current_block_number))
+                } else if item == Self::BLOCK_TIMESTAMP_VARIABLE {
+                    let timestamp =
+                        chain_state_provider.block_timestamp(BlockNumberOrTag::Latest)?;
+                    Ok(U256::from(timestamp))
+                } else {
+                    Ok(U256::from_str_radix(item, 10)
+                        .map_err(|error| anyhow::anyhow!("Invalid decimal literal: {}", error))?)
+                };
+                value.map(CalldataToken::Item)
+            }
+            Self::Operation(operation) => Ok(CalldataToken::Operation(operation)),
+        }
+    }
+}
+
+impl Serialize for EtherValue {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        format!("{} wei", self.0).serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for EtherValue {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let string = String::deserialize(deserializer)?;
+        let mut splitted = string.split(' ');
+        let (Some(value), Some(unit)) = (splitted.next(), splitted.next()) else {
+            return Err(serde::de::Error::custom("Failed to parse the value"));
+        };
+        let parsed = parse_units(value, unit.replace("eth", "ether"))
+            .map_err(|_| serde::de::Error::custom("Failed to parse units"))?
+            .into();
+        Ok(Self(parsed))
     }
 }
 
@@ -495,15 +687,15 @@ mod tests {
             .0;
 
         let input = Input {
-            instance: ContractInstance::new_from("Contract"),
+            instance: ContractInstance::new("Contract"),
             method: Method::FunctionName("store".to_owned()),
-            calldata: Calldata::Compound(vec!["42".into()]),
+            calldata: Calldata::new_compound(["42"]),
             ..Default::default()
         };
 
         let mut contracts = HashMap::new();
         contracts.insert(
-            ContractInstance::new_from("Contract"),
+            ContractInstance::new("Contract"),
             (Address::ZERO, parsed_abi),
         );
 
@@ -539,15 +731,13 @@ mod tests {
         let input: Input = Input {
             instance: "Contract".to_owned().into(),
             method: Method::FunctionName("send(address)".to_owned()),
-            calldata: Calldata::Compound(vec![
-                "0x1000000000000000000000000000000000000001".to_string(),
-            ]),
+            calldata: Calldata::new_compound(["0x1000000000000000000000000000000000000001"]),
             ..Default::default()
         };
 
         let mut contracts = HashMap::new();
         contracts.insert(
-            ContractInstance::new_from("Contract"),
+            ContractInstance::new("Contract"),
             (Address::ZERO, parsed_abi),
         );
 
@@ -584,17 +774,15 @@ mod tests {
             .0;
 
         let input: Input = Input {
-            instance: ContractInstance::new_from("Contract"),
+            instance: ContractInstance::new("Contract"),
             method: Method::FunctionName("send".to_owned()),
-            calldata: Calldata::Compound(vec![
-                "0x1000000000000000000000000000000000000001".to_string(),
-            ]),
+            calldata: Calldata::new_compound(["0x1000000000000000000000000000000000000001"]),
             ..Default::default()
         };
 
         let mut contracts = HashMap::new();
         contracts.insert(
-            ContractInstance::new_from("Contract"),
+            ContractInstance::new("Contract"),
             (Address::ZERO, parsed_abi),
         );
 
@@ -609,13 +797,21 @@ mod tests {
         );
     }
 
+    fn resolve_calldata_item(
+        input: &str,
+        deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
+        chain_state_provider: &impl ResolverApi,
+    ) -> anyhow::Result<U256> {
+        CalldataItem::new(input).resolve(deployed_contracts, chain_state_provider)
+    }
+
     #[test]
     fn resolver_can_resolve_chain_id_variable() {
         // Arrange
         let input = "$CHAIN_ID";
 
         // Act
-        let resolved = resolve_argument(input, &Default::default(), &MockResolver);
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
 
         // Assert
         let resolved = resolved.expect("Failed to resolve argument");
@@ -628,7 +824,7 @@ mod tests {
         let input = "$GAS_LIMIT";
 
         // Act
-        let resolved = resolve_argument(input, &Default::default(), &MockResolver);
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
 
         // Assert
         let resolved = resolved.expect("Failed to resolve argument");
@@ -644,7 +840,7 @@ mod tests {
         let input = "$COINBASE";
 
         // Act
-        let resolved = resolve_argument(input, &Default::default(), &MockResolver);
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
 
         // Assert
         let resolved = resolved.expect("Failed to resolve argument");
@@ -665,7 +861,7 @@ mod tests {
         let input = "$DIFFICULTY";
 
         // Act
-        let resolved = resolve_argument(input, &Default::default(), &MockResolver);
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
 
         // Assert
         let resolved = resolved.expect("Failed to resolve argument");
@@ -681,7 +877,7 @@ mod tests {
         let input = "$BLOCK_HASH";
 
         // Act
-        let resolved = resolve_argument(input, &Default::default(), &MockResolver);
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
 
         // Assert
         let resolved = resolved.expect("Failed to resolve argument");
@@ -697,7 +893,7 @@ mod tests {
         let input = "$BLOCK_NUMBER";
 
         // Act
-        let resolved = resolve_argument(input, &Default::default(), &MockResolver);
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
 
         // Assert
         let resolved = resolved.expect("Failed to resolve argument");
@@ -713,7 +909,7 @@ mod tests {
         let input = "$BLOCK_TIMESTAMP";
 
         // Act
-        let resolved = resolve_argument(input, &Default::default(), &MockResolver);
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
 
         // Assert
         let resolved = resolved.expect("Failed to resolve argument");
@@ -722,4 +918,96 @@ mod tests {
             U256::from(MockResolver.block_timestamp(Default::default()).unwrap())
         )
     }
+
+    #[test]
+    fn simple_addition_can_be_resolved() {
+        // Arrange
+        let input = "2 4 +";
+
+        // Act
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
+
+        // Assert
+        let resolved = resolved.expect("Failed to resolve argument");
+        assert_eq!(resolved, U256::from(6));
+    }
+
+    #[test]
+    fn simple_subtraction_can_be_resolved() {
+        // Arrange
+        let input = "4 2 -";
+
+        // Act
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
+
+        // Assert
+        let resolved = resolved.expect("Failed to resolve argument");
+        assert_eq!(resolved, U256::from(2));
+    }
+
+    #[test]
+    fn simple_multiplication_can_be_resolved() {
+        // Arrange
+        let input = "4 2 *";
+
+        // Act
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
+
+        // Assert
+        let resolved = resolved.expect("Failed to resolve argument");
+        assert_eq!(resolved, U256::from(8));
+    }
+
+    #[test]
+    fn simple_division_can_be_resolved() {
+        // Arrange
+        let input = "4 2 /";
+
+        // Act
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
+
+        // Assert
+        let resolved = resolved.expect("Failed to resolve argument");
+        assert_eq!(resolved, U256::from(2));
+    }
+
+    #[test]
+    fn arithmetic_errors_are_not_panics() {
+        // Arrange
+        let input = "4 0 /";
+
+        // Act
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
+
+        // Assert
+        assert!(resolved.is_err())
+    }
+
+    #[test]
+    fn arithmetic_with_resolution_works() {
+        // Arrange
+        let input = "$BLOCK_NUMBER 10 +";
+
+        // Act
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
+
+        // Assert
+        let resolved = resolved.expect("Failed to resolve argument");
+        assert_eq!(
+            resolved,
+            U256::from(MockResolver.last_block_number().unwrap() + 10)
+        );
+    }
+
+    #[test]
+    fn incorrect_number_of_arguments_errors() {
+        // Arrange
+        let input = "$BLOCK_NUMBER 10 + +";
+
+        // Act
+        let resolved = resolve_calldata_item(input, &Default::default(), &MockResolver);
+
+        // Assert
+        assert!(resolved.is_err())
+    }
 }

crates/format/src/metadata.rs

@@ -47,9 +47,9 @@ impl Deref for MetadataFile {
 pub struct Metadata {
     pub targets: Option<Vec<String>>,
     pub cases: Vec<Case>,
-    pub contracts: Option<BTreeMap<ContractInstance, ContractPathAndIdentifier>>,
+    pub contracts: Option<BTreeMap<ContractInstance, ContractPathAndIdent>>,
     // TODO: Convert into wrapper types for clarity.
-    pub libraries: Option<BTreeMap<String, BTreeMap<String, String>>>,
+    pub libraries: Option<BTreeMap<PathBuf, BTreeMap<ContractIdent, ContractInstance>>>,
     pub ignore: Option<bool>,
     pub modes: Option<Vec<Mode>>,
     pub file_path: Option<PathBuf>,
@@ -86,7 +86,7 @@ impl Metadata {
     /// Returns the contract sources with canonicalized paths for the files
     pub fn contract_sources(
         &self,
-    ) -> anyhow::Result<BTreeMap<ContractInstance, ContractPathAndIdentifier>> {
+    ) -> anyhow::Result<BTreeMap<ContractInstance, ContractPathAndIdent>> {
         let directory = self.directory()?;
         let mut sources = BTreeMap::new();
         let Some(contracts) = &self.contracts else {
@@ -95,7 +95,7 @@ impl Metadata {
 
         for (
             alias,
-            ContractPathAndIdentifier {
+            ContractPathAndIdent {
                 contract_source_path,
                 contract_ident,
             },
@@ -107,7 +107,7 @@ impl Metadata {
 
             sources.insert(
                 alias,
-                ContractPathAndIdentifier {
+                ContractPathAndIdent {
                     contract_source_path: absolute_path,
                     contract_ident,
                 },
@@ -193,10 +193,10 @@ impl Metadata {
                 metadata.file_path = Some(path.to_path_buf());
                 metadata.contracts = Some(
                     [(
-                        ContractInstance::new_from("test"),
-                        ContractPathAndIdentifier {
+                        ContractInstance::new("test"),
+                        ContractPathAndIdent {
                             contract_source_path: path.to_path_buf(),
-                            contract_ident: ContractIdent::new_from("Test"),
+                            contract_ident: ContractIdent::new("Test"),
                         },
                     )]
                     .into(),
@@ -245,7 +245,7 @@ define_wrapper_type!(
 /// ```
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
 #[serde(try_from = "String", into = "String")]
-pub struct ContractPathAndIdentifier {
+pub struct ContractPathAndIdent {
     /// The path of the contract source code relative to the directory containing the metadata file.
     pub contract_source_path: PathBuf,
 
@@ -253,7 +253,7 @@ pub struct ContractPathAndIdentifier {
     pub contract_ident: ContractIdent,
 }
 
-impl Display for ContractPathAndIdentifier {
+impl Display for ContractPathAndIdent {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
@@ -264,7 +264,7 @@ impl Display for ContractPathAndIdentifier {
     }
 }
 
-impl FromStr for ContractPathAndIdentifier {
+impl FromStr for ContractPathAndIdent {
     type Err = anyhow::Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -300,7 +300,7 @@ impl FromStr for ContractPathAndIdentifier {
     }
 }
 
-impl TryFrom<String> for ContractPathAndIdentifier {
+impl TryFrom<String> for ContractPathAndIdent {
     type Error = anyhow::Error;
 
     fn try_from(value: String) -> Result<Self, Self::Error> {
@@ -308,8 +308,8 @@ impl TryFrom<String> for ContractPathAndIdentifier {
     }
 }
 
-impl From<ContractPathAndIdentifier> for String {
-    fn from(value: ContractPathAndIdentifier) -> Self {
+impl From<ContractPathAndIdent> for String {
+    fn from(value: ContractPathAndIdent) -> Self {
         value.to_string()
     }
 }
@@ -324,7 +324,7 @@ mod test {
         let string = "ERC20/ERC20.sol:ERC20";
 
         // Act
-        let identifier = ContractPathAndIdentifier::from_str(string);
+        let identifier = ContractPathAndIdent::from_str(string);
 
         // Assert
         let identifier = identifier.expect("Failed to parse");