Update Cargo.lock

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

@@ -18,9 +18,10 @@ inputs:
     required: false
     default: "main"
     type: string
-  resolc-path:
+  resolc-version:
-    description: "The path of the resolc compiler."
+    description: "The version of resolc to install and use in tests."
-    required: true
+    required: false
+    default: "0.5.0"
     type: string
   use-compilation-caches:
     description: "Controls if the compilation caches will be used for the test run or not."
@@ -28,10 +29,6 @@ inputs:
     default: true
     type: boolean
   # Test Execution Arguments
-  # TODO: We need a better way for people to pass arguments to retester. This way is not very good
-  # because we need to add support for each argument separately and support defaults and all of that
-  # perhaps having people pass in a JSON String of the arguments is the better long term solution
-  # for this.
   platform:
     description: "The identifier of the platform to run the tests on (e.g., geth-evm-solc, revive-dev-node-revm-solc)"
     required: true
@@ -59,6 +56,16 @@ runs:
         ref: ${{ inputs['revive-differential-tests-ref'] }}
         path: revive-differential-tests
         submodules: recursive
+    - name: Installing the Latest Resolc
+      shell: bash
+      if: ${{ runner.os == 'Linux' && runner.arch == 'X64' }}
+      run: |
+        VERSION="${{ inputs['resolc-version'] }}"
+        ASSET_URL="https://github.com/paritytech/revive/releases/download/v$VERSION/resolc-x86_64-unknown-linux-musl"
+        echo "Downloading resolc v$VERSION from $ASSET_URL"
+        curl -Lsf --show-error -o resolc "$ASSET_URL"
+        chmod +x resolc
+        ./resolc --version
     - name: Installing Retester
       shell: bash
       run: ${{ inputs['cargo-command'] }} install --locked --path revive-differential-tests/crates/core
@@ -113,12 +120,11 @@ runs:
           --revive-dev-node.path ${{ inputs['polkadot-sdk-path'] }}/target/release/revive-dev-node \
           --eth-rpc.path ${{ inputs['polkadot-sdk-path'] }}/target/release/eth-rpc \
           --polkadot-omni-node.path ${{ inputs['polkadot-sdk-path'] }}/target/release/polkadot-omni-node \
-          --resolc.path ${{ inputs['resolc-path'] }} \
+          --resolc.path ./resolc \
-          --resolc.heap-size 500000 \
           "${OMNI_ARGS[@]}" || true
     - name: Generate the expectation file
       shell: bash
-      run: report-processor generate-expectations-file --report-path ./workdir/report.json --output-path ./workdir/expectations.json --remove-prefix ./revive-differential-tests/resolc-compiler-tests --include-status failed
+      run: report-processor generate-expectations-file --report-path ./workdir/report.json --output-path ./workdir/expectations.json --remove-prefix ./revive-differential-tests/resolc-compiler-tests
     - name: Upload the Report to the CI
       uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f
       with:

Cargo.lock

@@ -5886,7 +5886,6 @@ dependencies = [
  "revive-dt-report",
  "serde",
  "serde_json",
- "strum",
 ]
 
 [[package]]

crates/config/src/lib.rs

@@ -806,7 +806,6 @@ pub struct ResolcConfiguration {
     /// If unspecified, the revive compiler default is used
     #[clap(id = "resolc.heap-size", long = "resolc.heap-size")]
     pub heap_size: Option<u32>,
-
     /// Specifies the PVM stack size in bytes.
     ///
     /// If unspecified, the revive compiler default is used

crates/core/src/differential_tests/driver.rs

@@ -482,16 +482,15 @@ where
                 .context("Failed to find deployment receipt for constructor call"),
             Method::Fallback | Method::FunctionName(_) => {
                 let resolver = self.platform_information.node.resolver().await?;
-                let mut tx = step
+                let tx = match step
                     .as_transaction(resolver.as_ref(), self.default_resolution_context())
-                    .await?;
+                    .await
-
+                {
-                let gas_overrides = step
+                    Ok(tx) => tx,
-                    .gas_overrides
+                    Err(err) => {
-                    .get(&self.platform_information.platform.platform_identifier())
+                        return Err(err);
-                    .copied()
+                    }
-                    .unwrap_or_default();
+                };
-                gas_overrides.apply_to::<Ethereum>(&mut tx);
 
                 self.platform_information.node.execute_transaction(tx).await
             }
@@ -912,6 +911,7 @@ where
             .get(contract_instance)
         {
             info!(
+
                 %address,
                 "Contract instance already deployed."
             );

crates/core/src/helpers/test.rs

@@ -223,24 +223,17 @@ impl<'a> TestDefinition<'a> {
 
     /// Checks if the platforms all support the desired targets in the metadata file.
     fn check_target_compatibility(&self) -> TestCheckFunctionResult {
-        // The case targets takes presence over the metadata targets.
-        let Some(targets) = self
-            .case
-            .targets
-            .as_ref()
-            .or(self.metadata.targets.as_ref())
-        else {
-            return Ok(());
-        };
-
         let mut error_map = indexmap! {
-            "test_desired_targets" => json!(targets),
+            "test_desired_targets" => json!(self.metadata.targets.as_ref()),
         };
-
         let mut is_allowed = true;
         for (_, platform_information) in self.platforms.iter() {
-            let is_allowed_for_platform =
+            let is_allowed_for_platform = match self.metadata.targets.as_ref() {
-                targets.contains(&platform_information.platform.vm_identifier());
+                None => true,
+                Some(required_vm_identifiers) => {
+                    required_vm_identifiers.contains(&platform_information.platform.vm_identifier())
+                }
+            };
             is_allowed &= is_allowed_for_platform;
             error_map.insert(
                 platform_information.platform.platform_identifier().into(),

crates/format/src/case.rs

@@ -1,22 +1,16 @@
-use alloy::primitives::{Address, map::HashSet};
+use alloy::primitives::Address;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use revive_dt_common::{
     macros::define_wrapper_type,
-    types::{Mode, ParsedMode, VmIdentifier},
+    types::{Mode, ParsedMode},
 };
 
 use crate::steps::*;
 
 #[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq, JsonSchema)]
 pub struct Case {
-    /// An optional vector of targets that this Metadata file's cases can be executed on. As an
-    /// example, if we wish for the metadata file's cases to only be run on PolkaVM then we'd
-    /// specify a target of "PolkaVM" in here.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub targets: Option<HashSet<VmIdentifier>>,
-
     /// An optional name of the test case.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub name: Option<String>,

crates/format/src/metadata.rs

@@ -8,7 +8,6 @@ use std::{
     str::FromStr,
 };
 
-use alloy::primitives::map::HashSet;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
@@ -84,7 +83,7 @@ pub struct Metadata {
     /// example, if we wish for the metadata file's cases to only be run on PolkaVM then we'd
     /// specify a target of "PolkaVM" in here.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub targets: Option<HashSet<VmIdentifier>>,
+    pub targets: Option<Vec<VmIdentifier>>,
 
     /// A vector of the test cases and workloads contained within the metadata file. This is their
     /// primary description.

crates/format/src/steps.rs

@@ -1,7 +1,6 @@
 use std::{collections::HashMap, fmt::Display, str::FromStr};
 
 use alloy::hex::ToHexExt;
-use alloy::network::Network;
 use alloy::primitives::{FixedBytes, utils::parse_units};
 use alloy::{
     eips::BlockNumberOrTag,
@@ -12,7 +11,6 @@ use alloy::{
 };
 use anyhow::Context as _;
 use futures::{FutureExt, StreamExt, TryFutureExt, TryStreamExt, stream};
-use revive_dt_common::types::PlatformIdentifier;
 use schemars::JsonSchema;
 use semver::VersionReq;
 use serde::{Deserialize, Serialize};
@@ -154,11 +152,6 @@ pub struct FunctionCallStep {
     /// during the execution.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub variable_assignments: Option<VariableAssignments>,
-
-    /// Allows for the test to set a specific value for the various gas parameter for each one of
-    /// the platforms we support. This is ignored for steps that perform contract deployments.
-    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
-    pub gas_overrides: HashMap<PlatformIdentifier, GasOverrides>,
 }
 
 /// This represents a balance assertion step where the framework needs to query the balance of some
@@ -972,62 +965,6 @@ impl<'de> Deserialize<'de> for EtherValue {
     }
 }
 
-#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, Eq, PartialEq, JsonSchema)]
-pub struct GasOverrides {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub gas_limit: Option<u64>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub gas_price: Option<u128>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_fee_per_gas: Option<u128>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_priority_fee_per_gas: Option<u128>,
-}
-
-impl GasOverrides {
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    pub fn with_gas_limit(mut self, value: impl Into<Option<u64>>) -> Self {
-        self.gas_limit = value.into();
-        self
-    }
-
-    pub fn with_gas_price(mut self, value: impl Into<Option<u128>>) -> Self {
-        self.gas_price = value.into();
-        self
-    }
-
-    pub fn with_max_fee_per_gas(mut self, value: impl Into<Option<u128>>) -> Self {
-        self.max_fee_per_gas = value.into();
-        self
-    }
-
-    pub fn with_max_priority_fee_per_gas(mut self, value: impl Into<Option<u128>>) -> Self {
-        self.max_priority_fee_per_gas = value.into();
-        self
-    }
-
-    pub fn apply_to<N: Network>(&self, transaction_request: &mut N::TransactionRequest) {
-        if let Some(gas_limit) = self.gas_limit {
-            transaction_request.set_gas_limit(gas_limit);
-        }
-        if let Some(gas_price) = self.gas_price {
-            transaction_request.set_gas_price(gas_price);
-        }
-        if let Some(max_fee_per_gas) = self.max_fee_per_gas {
-            transaction_request.set_max_fee_per_gas(max_fee_per_gas);
-        }
-        if let Some(max_priority_fee_per_gas) = self.max_priority_fee_per_gas {
-            transaction_request.set_max_priority_fee_per_gas(max_priority_fee_per_gas)
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
 

crates/report-processor/Cargo.toml

@@ -18,7 +18,6 @@ revive-dt-common = { workspace = true }
 
 anyhow = { workspace = true }
 clap = { workspace = true }
-strum = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 

crates/report-processor/src/main.rs

@@ -1,6 +1,6 @@
 use std::{
     borrow::Cow,
-    collections::{BTreeMap, BTreeSet, HashSet},
+    collections::{BTreeMap, BTreeSet},
     fmt::Display,
     fs::{File, OpenOptions},
     ops::{Deref, DerefMut},
@@ -9,12 +9,11 @@ use std::{
 };
 
 use anyhow::{Context as _, Error, Result, bail};
-use clap::{Parser, ValueEnum};
+use clap::Parser;
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
 
 use revive_dt_common::types::{Mode, ParsedTestSpecifier};
 use revive_dt_report::{Report, TestCaseStatus};
-use strum::EnumString;
 
 fn main() -> Result<()> {
     let cli = Cli::try_parse().context("Failed to parse the CLI arguments")?;
@@ -24,14 +23,11 @@ fn main() -> Result<()> {
             report_path,
             output_path: output_file,
             remove_prefix,
-            include_status,
         } => {
             let remove_prefix = remove_prefix
                 .into_iter()
                 .map(|path| path.canonicalize().context("Failed to canonicalize path"))
                 .collect::<Result<Vec<_>>>()?;
-            let include_status =
-                include_status.map(|value| value.into_iter().collect::<HashSet<_>>());
 
             let expectations = report_path
                 .execution_information
@@ -77,12 +73,7 @@ fn main() -> Result<()> {
                         Status::from(status),
                     )
                 })
-                .filter(|(_, status)| {
+                .filter(|(_, status)| *status == Status::Failed)
-                    include_status
-                        .as_ref()
-                        .map(|allowed_status| allowed_status.contains(status))
-                        .unwrap_or(true)
-                })
                 .collect::<Expectations>();
 
             let output_file = OpenOptions::new()
@@ -152,11 +143,6 @@ pub enum Cli {
         /// Prefix paths to remove from the paths in the final expectations file.
         #[clap(long)]
         remove_prefix: Vec<PathBuf>,
-
-        /// Controls which test case statuses are included in the generated expectations file. If
-        /// nothing is specified then it will include all of the test case status.
-        #[clap(long)]
-        include_status: Option<Vec<Status>>,
     },
 
     /// Compares two expectation files to ensure that they match each other.
@@ -171,21 +157,7 @@ pub enum Cli {
     },
 }
 
-#[derive(
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-    Clone,
-    Copy,
-    Debug,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Hash,
-    Serialize,
-    Deserialize,
-    ValueEnum,
-    EnumString,
-)]
-#[strum(serialize_all = "kebab-case")]
 pub enum Status {
     Succeeded,
     Failed,