native string utils cheatcodes

crates/cheatcodes/spec/src/vm.rs

@@ -1077,6 +1077,22 @@ interface Vm {
     #[cheatcode(group = String)]
     function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);
 
+    /// Converts the given `string` value to Lowercase.
+    #[cheatcode(group = String)]
+    function toLowercase(string calldata input) external pure returns (string memory output);
+    /// Converts the given `string` value to Uppercase.
+    #[cheatcode(group = String)]
+    function toUppercase(string calldata input) external pure returns (string memory output);
+    /// Trims leading and trailing whitespace from the given `string` value.
+    #[cheatcode(group = String)]
+    function trim(string calldata input) external pure returns (string memory output);
+    /// Replaces occurrences of `from` in the given `string` with `to`.
+    #[cheatcode(group = String)]
+    function replace(string calldata input, string calldata from, string calldata to) external pure returns (string memory output);
+    /// Splits the given `string` into an array of strings divided by the `delimiter`.
+    #[cheatcode(group = String)]
+    function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);
+
     // ======== JSON Parsing and Manipulation ========
 
     // -------- Reading --------

crates/cheatcodes/src/string.rs

@@ -1,7 +1,7 @@
 //! Implementations of [`String`](crate::Group::String) cheatcodes.
 
-use crate::{Cheatcode, Cheatcodes, Result, Vm::*};
-use alloy_dyn_abi::{DynSolType, DynSolValue};
+use crate::{ Cheatcode, Cheatcodes, Result, Vm::* };
+use alloy_dyn_abi::{ DynSolType, DynSolValue };
 use alloy_sol_types::SolValue;
 
 // address
@@ -94,22 +94,63 @@ impl Cheatcode for parseBoolCall {
     }
 }
 
+// toLowercase
+impl Cheatcode for toLowercaseCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { input } = self;
+        Ok(input.to_lowercase().abi_encode())
+    }
+}
+
+// toUppercase
+impl Cheatcode for toUppercaseCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { input } = self;
+        Ok(input.to_uppercase().abi_encode())
+    }
+}
+
+// trim
+impl Cheatcode for trimCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { input } = self;
+        Ok(input.trim().abi_encode())
+    }
+}
+
+// Replace
+impl Cheatcode for replaceCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { input, from, to } = self;
+        Ok(input.replace(from, to).abi_encode())
+    }
+}
+
+// Split
+impl Cheatcode for splitCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { input, delimiter } = self;
+        let parts: Vec<&str> = input.split(delimiter).collect();
+        Ok(parts.abi_encode())
+    }
+}
+
 pub(super) fn parse(s: &str, ty: &DynSolType) -> Result {
     parse_value(s, ty).map(|v| v.abi_encode())
 }
 
 pub(super) fn parse_array<I, S>(values: I, ty: &DynSolType) -> Result
-where
-    I: IntoIterator<Item = S>,
-    S: AsRef<str>,
+    where I: IntoIterator<Item = S>, S: AsRef<str>
 {
     let mut values = values.into_iter();
     match values.next() {
-        Some(first) if !first.as_ref().is_empty() => std::iter::once(first)
-            .chain(values)
-            .map(|s| parse_value(s.as_ref(), ty))
-            .collect::<Result<Vec<_>, _>>()
-            .map(|vec| DynSolValue::Array(vec).abi_encode()),
+        Some(first) if !first.as_ref().is_empty() =>
+            std::iter
+                ::once(first)
+                .chain(values)
+                .map(|s| parse_value(s.as_ref(), ty))
+                .collect::<Result<Vec<_>, _>>()
+                .map(|vec| DynSolValue::Array(vec).abi_encode()),
         // return the empty encoded Bytes when values is empty or the first element is empty
         _ => Ok("".abi_encode()),
     }
@@ -119,11 +160,12 @@ where
 fn parse_value(s: &str, ty: &DynSolType) -> Result<DynSolValue> {
     match ty.coerce_str(s) {
         Ok(value) => Ok(value),
-        Err(e) => match parse_value_fallback(s, ty) {
-            Some(Ok(value)) => Ok(value),
-            Some(Err(e2)) => Err(fmt_err!("failed parsing {s:?} as type `{ty}`: {e2}")),
-            None => Err(fmt_err!("failed parsing {s:?} as type `{ty}`: {e}")),
-        },
+        Err(e) =>
+            match parse_value_fallback(s, ty) {
+                Some(Ok(value)) => Ok(value),
+                Some(Err(e2)) => Err(fmt_err!("failed parsing {s:?} as type `{ty}`: {e2}")),
+                None => Err(fmt_err!("failed parsing {s:?} as type `{ty}`: {e}")),
+            }
     }
 }
 
@@ -136,16 +178,18 @@ fn parse_value_fallback(s: &str, ty: &DynSolType) -> Option<Result<DynSolValue,
                 "0" => false,
                 s if s.eq_ignore_ascii_case("true") => true,
                 s if s.eq_ignore_ascii_case("false") => false,
-                _ => return None,
+                _ => {
+                    return None;
+                }
             };
             return Some(Ok(DynSolValue::Bool(b)));
         }
-        DynSolType::Int(_) |
-        DynSolType::Uint(_) |
-        DynSolType::FixedBytes(_) |
-        DynSolType::Bytes => {
+        | DynSolType::Int(_)
+        | DynSolType::Uint(_)
+        | DynSolType::FixedBytes(_)
+        | DynSolType::Bytes => {
             if !s.starts_with("0x") && s.chars().all(|c| c.is_ascii_hexdigit()) {
-                return Some(Err("missing hex prefix (\"0x\") for hex string"))
+                return Some(Err("missing hex prefix (\"0x\") for hex string"));
             }
         }
         _ => {}

testdata/cheats/StringUtils.t.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity 0.8.18;
+
+import "ds-test/test.sol";
+import "./Vm.sol";
+
+contract StringManipulationTest is DSTest {
+    Vm constant vm = Vm(HEVM_ADDRESS);
+
+    function testToLowercase() public {
+        string memory original = "Hello World";
+        string memory lowercased = vm.toLowercase(original);
+        assertEq("hello world", lowercased);
+    }
+
+    function testToUppercase() public {
+        string memory original = "Hello World";
+        string memory uppercased = vm.toUppercase(original);
+        assertEq("HELLO WORLD", uppercased);
+    }
+
+    function testTrim() public {
+        string memory original = "   Hello World   ";
+        string memory trimmed = vm.trim(original);
+        assertEq("Hello World", trimmed);
+    }
+
+    function testReplace() public {
+        string memory original = "Hello World";
+        string memory replaced = vm.replace(original, "World", "Reth");
+        assertEq("Hello Reth", replaced);
+    }
+
+    function testSplit() public {
+        string memory original = "Hello,World,Reth";
+        string[] memory splitResult = vm.split(original, ",");
+        assertEq(3, splitResult.length);
+        assertEq("Hello", splitResult[0]);
+        assertEq("World", splitResult[1]);
+        assertEq("Reth", splitResult[2]);
+    }
+}