feat: add vm.foundryVersionCmp and vm.foundryVersionAtLeast cheatcodes (foundry-rs#9845)

* feat: add foundryVersionCmp and foundryVersionAtLeast cheatcode

* fix: change the acceptable version string in version cmp cheatcodes to major.minor.patch

---------

Co-authored-by: grandizzy <[email protected]>

Author: startup-dreamer

crates/cheatcodes/assets/cheatcodes.json

@@ -1677,6 +1677,21 @@ interface Vm {
         string calldata error
     ) external pure;
 
+    /// Returns true if the current Foundry version is at least the given version.
+    /// Version string can be in the format `major.minor.patch`.
+    #[cheatcode(group = Testing, safety = Safe)]
+    function foundryVersionAtLeast(string calldata version) external view returns (bool);
+
+    /// Compares the current Foundry version with the given version string.
+    /// Version string can be in the format `major.minor.patch`.
+    /// Returns:
+    /// -1 if current version is less than the given version
+    /// 0 if current version equals the given version
+    /// 1 if current version is greater than the given version
+    #[cheatcode(group = Testing, safety = Safe)]
+    function foundryVersionCmp(string calldata version) external view returns (int256);
+
+
     // ======== OS and Filesystem ========
 
     // -------- Metadata --------

crates/cheatcodes/spec/src/vm.rs

@@ -37,6 +37,8 @@ mod config;
 
 mod crypto;
 
+mod version;
+
 mod env;
 pub use env::set_execution_context;
 

crates/cheatcodes/src/lib.rs

@@ -0,0 +1,51 @@
+use crate::{Cheatcode, Cheatcodes, Result, Vm::*};
+use alloy_sol_types::SolValue;
+use foundry_common::version::SEMVER_VERSION;
+use semver::Version;
+use std::cmp::Ordering;
+
+impl Cheatcode for foundryVersionCmpCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { version } = self;
+
+        if version.contains("+") || version.contains("-") {
+            return Err(fmt_err!("Version must be in only major.minor.patch format"));
+        }
+
+        let parsed_version = Version::parse(version)
+            .map_err(|e| fmt_err!("Invalid semver format '{}': {}", version, e))?;
+        let current_semver = Version::parse(SEMVER_VERSION)
+            .map_err(|_| fmt_err!("Invalid current version format"))?;
+
+        let current_version =
+            Version::new(current_semver.major, current_semver.minor, current_semver.patch);
+        // Note: returns -1 if current < provided, 0 if equal, 1 if current > provided.
+        let cmp_result = match current_version.cmp(&parsed_version) {
+            Ordering::Less => -1i32,
+            Ordering::Equal => 0i32,
+            Ordering::Greater => 1i32,
+        };
+        Ok(cmp_result.abi_encode())
+    }
+}
+
+impl Cheatcode for foundryVersionAtLeastCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { version } = self;
+
+        if version.contains("+") || version.contains("-") {
+            return Err(fmt_err!("Version must be in only major.minor.patch format"));
+        }
+
+        let parsed_version =
+            Version::parse(version).map_err(|_| fmt_err!("Invalid version format"))?;
+        let current_semver = Version::parse(SEMVER_VERSION)
+            .map_err(|_| fmt_err!("Invalid current version format"))?;
+
+        let current_version =
+            Version::new(current_semver.major, current_semver.minor, current_semver.patch);
+
+        let at_least = current_version.cmp(&parsed_version) != Ordering::Less;
+        Ok(at_least.abi_encode())
+    }
+}

crates/cheatcodes/src/version.rs

@@ -42,4 +42,49 @@ contract GetFoundryVersionTest is DSTest {
         // Validate build profile (e.g., "debug" or "release")
         require(bytes(buildType).length > 0, "Build type is empty");
     }
+
+    function testFoundryVersionCmp() public {
+        // Should return -1 if current version is less than argument
+        assertEq(vm.foundryVersionCmp("99.0.0"), -1);
+
+        // (e.g. 0.3.0-nightly+3cb96bde9b.1737036656.debug)
+        string memory fullVersionString = vm.getFoundryVersion();
+
+        // Step 1: Split the version at "+"
+        string[] memory plusSplit = vm.split(fullVersionString, "+");
+        require(plusSplit.length == 2, "Invalid version format: Missing '+' separator");
+
+        // Step 2: Extract parts
+        string memory semanticVersion = plusSplit[0]; // "0.3.0-dev"
+        string[] memory semanticSplit = vm.split(semanticVersion, "-");
+
+        semanticVersion = semanticSplit[0]; // "0.3.0"
+        // Should return 0 if current version is equal to argument
+        assertEq(vm.foundryVersionCmp(semanticVersion), 0);
+
+        // Should return 1 if current version is greater than argument
+        assertEq(vm.foundryVersionCmp("0.0.1"), 1);
+    }
+
+    function testFoundryVersionAtLeast() public {
+        // Should return false for future versions
+        assertEq(vm.foundryVersionAtLeast("99.0.0"), false);
+
+        // (e.g. 0.3.0-nightly+3cb96bde9b.1737036656.debug)
+        string memory fullVersionString = vm.getFoundryVersion();
+
+        // Step 1: Split the version at "+"
+        string[] memory plusSplit = vm.split(fullVersionString, "+");
+        require(plusSplit.length == 2, "Invalid version format: Missing '+' separator");
+
+        // Step 2: Extract parts
+        string memory semanticVersion = plusSplit[0]; // "0.3.0-dev"
+        string[] memory semanticSplit = vm.split(semanticVersion, "-");
+
+        semanticVersion = semanticSplit[0]; // "0.3.0"
+        assertTrue(vm.foundryVersionAtLeast(semanticVersion));
+
+        // Should return true for past versions
+        assertTrue(vm.foundryVersionAtLeast("0.2.0"));
+    }
 }