Remove redundant version checks (#3907)

commit-id:69a775ca

Author: ksew1

crates/forge/src/new.rs

@@ -13,10 +13,10 @@ use std::io::Write;
 use std::path::{Path, PathBuf};
 use toml_edit::{Array, ArrayOfTables, DocumentMut, Item, Table, Value, value};
 
+const OZ_VERSION: Version = Version::new(1, 0, 0);
+
 static TEMPLATES_DIR: Dir = include_dir!("snforge_templates");
 
-const DEFAULT_ASSERT_MACROS: Version = Version::new(0, 1, 0);
-const MINIMAL_SCARB_FOR_CORRESPONDING_ASSERT_MACROS: Version = Version::new(2, 8, 0);
 const SCARB_WITHOUT_CAIRO_TEST_TEMPLATE: Version = Version::new(2, 13, 0);
 
 struct Dependency {
@@ -134,7 +134,7 @@ impl TryFrom<&Template> for TemplateManifestConfig {
                     },
                     Dependency {
                         name: "openzeppelin_token".to_string(),
-                        version: get_oz_version()?.to_string(),
+                        version: OZ_VERSION.to_string(),
                         dev: false,
                     },
                 ],
@@ -256,12 +256,7 @@ fn set_cairo_edition(document: &mut DocumentMut, cairo_edition: &str) {
 }
 
 fn add_assert_macros(document: &mut DocumentMut) -> Result<()> {
-    let versions = scarb_version()?;
-    let version = if versions.scarb < MINIMAL_SCARB_FOR_CORRESPONDING_ASSERT_MACROS {
-        DEFAULT_ASSERT_MACROS
-    } else {
-        versions.cairo
-    };
+    let version = scarb_version()?.cairo;
 
     document
         .entry("dev-dependencies")
@@ -464,16 +459,3 @@ fn get_template_dir(template: &Template) -> Result<Dir<'_>> {
         .ok_or_else(|| anyhow!("Directory {dir_name} not found"))
         .cloned()
 }
-
-fn get_oz_version() -> Result<Version> {
-    let scarb_version = scarb_version()?.scarb;
-
-    let oz_version = match scarb_version {
-        ver if ver >= Version::new(2, 9, 4) => Version::new(1, 0, 0),
-        ver if ver >= Version::new(2, 9, 1) => Version::new(0, 20, 0),
-        ver if ver >= Version::new(2, 8, 4) => Version::new(0, 19, 0),
-        _ => bail!("Minimal Scarb version to create a new project with ERC-20 template is 2.8.4"),
-    };
-
-    Ok(oz_version)
-}

crates/forge/src/profile_validation/backtrace.rs

@@ -3,7 +3,6 @@ use crate::profile_validation::{check_cairo_profile_entries, get_manifest};
 use anyhow::ensure;
 use indoc::formatdoc;
 use scarb_metadata::Metadata;
-use semver::Version;
 
 /// Checks if backtrace can be generated based on scarb version, profile settings extracted from
 /// the provided [`Metadata`] and if native execution is disabled in the provided [`TestArgs`].
@@ -14,7 +13,6 @@ pub fn check_backtrace_compatibility(
 ) -> anyhow::Result<()> {
     #[cfg(feature = "cairo-native")]
     check_if_native_disabled(test_args)?;
-    check_scarb_version(scarb_metadata)?;
     check_profile(scarb_metadata)?;
     Ok(())
 }
@@ -28,15 +26,6 @@ fn check_if_native_disabled(test_args: &TestArgs) -> anyhow::Result<()> {
     );
     Ok(())
 }
-/// Checks if the scarb version from the provided [`Metadata`] is greater than or equal to the minimal required version.
-fn check_scarb_version(scarb_metadata: &Metadata) -> anyhow::Result<()> {
-    const MINIMAL_SCARB_VERSION: Version = Version::new(2, 8, 0);
-    ensure!(
-        scarb_metadata.app_version_info.version >= MINIMAL_SCARB_VERSION,
-        "Backtrace generation requires scarb version >= {MINIMAL_SCARB_VERSION}",
-    );
-    Ok(())
-}
 
 /// Checks if the runtime profile settings in the provided from [`Metadata`] contain the required entries for backtrace generation.
 fn check_profile(scarb_metadata: &Metadata) -> anyhow::Result<()> {

crates/forge/src/profile_validation/coverage.rs

@@ -2,23 +2,10 @@ use crate::profile_validation::{check_cairo_profile_entries, get_manifest};
 use anyhow::ensure;
 use indoc::formatdoc;
 use scarb_metadata::Metadata;
-use semver::Version;
 
 /// Checks if coverage can be based on scarb version and profile settings extracted from the provided [`Metadata`].
 pub fn check_coverage_compatibility(scarb_metadata: &Metadata) -> anyhow::Result<()> {
-    check_scarb_version(scarb_metadata)?;
-    check_profile(scarb_metadata)?;
-    Ok(())
-}
-
-/// Checks if the scarb version from the provided [`Metadata`] is greater than or equal to the minimal required version.
-fn check_scarb_version(scarb_metadata: &Metadata) -> anyhow::Result<()> {
-    const MINIMAL_SCARB_VERSION: Version = Version::new(2, 8, 0);
-    ensure!(
-        scarb_metadata.app_version_info.version >= MINIMAL_SCARB_VERSION,
-        "Coverage generation requires scarb version >= {MINIMAL_SCARB_VERSION}",
-    );
-    Ok(())
+    check_profile(scarb_metadata)
 }
 
 /// Checks if the runtime profile settings in the provided from [`Metadata`] contain the required entries for coverage generation.

crates/forge/src/run_tests/package.rs

@@ -12,14 +12,11 @@ use crate::{
     },
     scarb::{
         config::{ForgeConfigFromScarb, ForkTarget},
-        load_test_artifacts, should_compile_starknet_contract_target,
+        load_test_artifacts,
     },
     shared_cache::FailedTestsCache,
     test_filter::{NameFilter, TestsFilter},
-    warn::{
-        warn_if_available_gas_used_with_incompatible_scarb_version,
-        warn_if_incompatible_rpc_version,
-    },
+    warn::warn_if_incompatible_rpc_version,
 };
 use anyhow::Result;
 use camino::{Utf8Path, Utf8PathBuf};
@@ -88,10 +85,7 @@ impl RunForPackageArgs {
             &package,
             ui,
             CompilationOpts {
-                use_test_target_contracts: !should_compile_starknet_contract_target(
-                    &scarb_metadata.app_version_info.version,
-                    args.no_optimization,
-                ),
+                use_test_target_contracts: !args.no_optimization,
                 #[cfg(feature = "cairo-native")]
                 run_native: args.run_native,
             },
@@ -193,7 +187,6 @@ pub async fn run_for_package(
         tests_filter.filter_tests(&mut test_target.test_cases)?;
     }
 
-    warn_if_available_gas_used_with_incompatible_scarb_version(&test_targets, &ui)?;
     warn_if_incompatible_rpc_version(&test_targets, ui.clone()).await?;
 
     let not_filtered = sum_test_cases(&test_targets);

crates/forge/src/run_tests/workspace.rs

@@ -82,7 +82,6 @@ pub async fn run_for_workspace(args: TestArgs, ui: Arc<UI>) -> Result<ExitStatus
         filter.clone(),
         args.scarb_args.features.clone(),
         args.scarb_args.profile.clone(),
-        &scarb_metadata.app_version_info.version,
         args.no_optimization,
     )?;
 

crates/forge/src/scarb.rs

@@ -8,14 +8,11 @@ use forge_runner::package_tests::raw::TestTargetRaw;
 use scarb_api::{ScarbCommand, test_targets_by_name};
 use scarb_metadata::PackageMetadata;
 use scarb_ui::args::{FeaturesSpec, PackagesFilter, ProfileSpec};
-use semver::Version;
 use std::fs;
 use std::io::ErrorKind;
 
 pub mod config;
 
-const MINIMAL_SCARB_VERSION_TO_OPTIMIZE_COMPILATION: Version = Version::new(2, 8, 3);
-
 impl PackageConfig for ForgeConfigFromScarb {
     fn tool_name() -> &'static str {
         "snforge"
@@ -29,23 +26,14 @@ impl PackageConfig for ForgeConfigFromScarb {
     }
 }
 
-#[must_use]
-pub fn should_compile_starknet_contract_target(
-    scarb_version: &Version,
-    no_optimization: bool,
-) -> bool {
-    *scarb_version < MINIMAL_SCARB_VERSION_TO_OPTIMIZE_COMPILATION || no_optimization
-}
-
 #[tracing::instrument(skip_all, level = "debug")]
 pub fn build_artifacts_with_scarb(
     filter: PackagesFilter,
     features: FeaturesSpec,
     profile: ProfileSpec,
-    scarb_version: &Version,
     no_optimization: bool,
 ) -> Result<()> {
-    if should_compile_starknet_contract_target(scarb_version, no_optimization) {
+    if no_optimization {
         build_contracts_with_scarb(filter.clone(), features.clone(), profile.clone())?;
     }
     build_test_artifacts_with_scarb(filter, features, profile)?;

crates/forge/src/warn.rs

@@ -6,7 +6,6 @@ use foundry_ui::UI;
 use foundry_ui::components::warning::WarningMessage;
 use indoc::formatdoc;
 use scarb_api::package_matches_version_requirement;
-use scarb_api::version::scarb_version;
 use scarb_metadata::Metadata;
 use semver::{Comparator, Op, Version, VersionReq};
 use shared::rpc::create_rpc_client;
@@ -16,28 +15,6 @@ use std::env;
 use std::sync::Arc;
 use url::Url;
 
-pub(crate) fn warn_if_available_gas_used_with_incompatible_scarb_version(
-    test_targets: &[TestTargetWithResolvedConfig],
-    ui: &UI,
-) -> Result<()> {
-    for test_target in test_targets {
-        for case in &test_target.test_cases {
-            if case
-                .config
-                .available_gas
-                .as_ref().is_some_and(cheatnet::runtime_extensions::forge_config_extension::config::RawAvailableResourceBoundsConfig::is_zero)
-                && scarb_version()?.scarb <= Version::new(2, 4, 3)
-            {
-                ui.println(&WarningMessage::new("`available_gas` attribute was probably specified when using Scarb ~2.4.3 \
-                    Make sure to use Scarb >=2.4.4"
-                ));
-            }
-        }
-    }
-
-    Ok(())
-}
-
 pub(crate) async fn warn_if_incompatible_rpc_version(
     test_targets: &[TestTargetWithResolvedConfig],
     ui: Arc<UI>,

crates/forge/test_utils/src/lib.rs

@@ -10,9 +10,6 @@ use scarb_api::version::scarb_version;
 use semver::Version;
 use std::str::FromStr;
 
-const DEFAULT_ASSERT_MACROS: Version = Version::new(0, 1, 0);
-const MINIMAL_SCARB_FOR_CORRESPONDING_ASSERT_MACROS: Version = Version::new(2, 8, 0);
-
 pub fn tempdir_with_tool_versions() -> Result<assert_fs::TempDir> {
     let project_root = get_project_root()?;
     let temp_dir = assert_fs::TempDir::new()?;
@@ -21,14 +18,7 @@ pub fn tempdir_with_tool_versions() -> Result<assert_fs::TempDir> {
 }
 
 pub fn get_assert_macros_version() -> Result<Version> {
-    let scarb_version_output = scarb_version()?;
-    let assert_macros_version =
-        if scarb_version_output.scarb < MINIMAL_SCARB_FOR_CORRESPONDING_ASSERT_MACROS {
-            DEFAULT_ASSERT_MACROS
-        } else {
-            scarb_version_output.cairo
-        };
-    Ok(assert_macros_version)
+    Ok(scarb_version()?.cairo)
 }
 
 #[must_use]

crates/forge/tests/e2e/requirements.rs

@@ -1,35 +1,21 @@
 use crate::e2e::common::runner::{runner, setup_package};
-use indoc::{formatdoc, indoc};
-use scarb_api::version::scarb_version;
-use semver::Version;
+use indoc::indoc;
 use shared::test_utils::output_assert::assert_stdout_contains;
 
 #[test]
 fn happy_path() {
     let temp = setup_package("simple_package");
     let output = runner(&temp).arg("check-requirements").assert();
 
-    let scarb_version = scarb_version().unwrap().scarb;
-
-    let rust_check = if scarb_version < Version::new(2, 10, 0) {
-        indoc! {"
-        Checking requirements
-
-        ✅ Rust [..]
-        "}
-    } else {
-        ""
-    };
-
     assert_stdout_contains(
         output,
-        formatdoc! {r"
+        indoc! {r"
     Checking requirements
 
     ✅ Scarb [..]
     ✅ Universal Sierra Compiler [..]
-    {}
-    ", rust_check},
+
+    "},
     );
 }
 

crates/native-api/src/lib.rs

@@ -7,31 +7,23 @@ use cairo_lang_starknet_classes::contract_class::ContractClass;
 use cairo_native::executor::AotContractExecutor;
 use starknet_api::contract_class::SierraVersion;
 
-#[derive(Debug, thiserror::Error)]
-pub enum NativeCompilationError {
-    #[error("Unsupported Sierra version {0}. cairo-native requires version 1.7.0 or later.")]
-    UnsupportedSierraVersion(String),
-}
-
 /// Compiles a given Sierra [`ContractClass`] into an [`AotContractExecutor`] for `cairo-native` execution.
-pub fn compile_contract_class(
-    contract_class: &ContractClass,
-) -> Result<AotContractExecutor, NativeCompilationError> {
+#[must_use]
+pub fn compile_contract_class(contract_class: &ContractClass) -> AotContractExecutor {
     let sierra_version = extract_sierra_version(contract_class);
-    check_sierra_version(&sierra_version)?;
 
     let sierra_program = contract_class
         .extract_sierra_program()
         .expect("extraction should succeed");
 
-    Ok(AotContractExecutor::new(
+    AotContractExecutor::new(
         &sierra_program,
         &contract_class.entry_points_by_type,
         sierra_version.clone().into(),
         cairo_native::OptLevel::Default,
         None,
     )
-    .expect("compilation should succeed"))
+    .expect("compilation should succeed")
 }
 
 /// Extracts the Sierra version from the given [`ContractClass`].
@@ -46,15 +38,3 @@ fn extract_sierra_version(contract_class: &ContractClass) -> SierraVersion {
     SierraVersion::extract_from_program(&sierra_version_values)
         .expect("version extraction should succeed")
 }
-
-/// Checks if the given Sierra version is supported by `cairo-native`.
-fn check_sierra_version(sierra_version: &SierraVersion) -> Result<(), NativeCompilationError> {
-    let minimal_supported_version = SierraVersion::new(1, 7, 0);
-    if sierra_version < &minimal_supported_version {
-        Err(NativeCompilationError::UnsupportedSierraVersion(
-            sierra_version.to_string(),
-        ))
-    } else {
-        Ok(())
-    }
-}