feat(symbolic): add native symbolic testing

Cargo.toml

@@ -19,6 +19,7 @@ members = [
     "crates/evm/evm/",
     "crates/evm/fuzz/",
     "crates/evm/sancov/",
+    "crates/evm/symbolic/",
     "crates/evm/hardforks/",
     "crates/evm/traces/",
     "crates/fmt/",
@@ -333,6 +334,7 @@ foundry-evm-hardforks = { path = "crates/evm/hardforks", default-features = fals
 foundry-evm-networks = { path = "crates/evm/networks", default-features = false }
 foundry-evm-fuzz = { path = "crates/evm/fuzz", default-features = false }
 foundry-evm-sancov = { path = "crates/evm/sancov" }
+foundry-evm-symbolic = { path = "crates/evm/symbolic", default-features = false }
 foundry-evm-traces = { path = "crates/evm/traces", default-features = false }
 foundry-macros = { path = "crates/macros" }
 foundry-test-utils = { path = "crates/test-utils", default-features = false }

crates/cheatcodes/src/crypto.rs

@@ -11,6 +11,7 @@ use alloy_signer_local::{
     },
 };
 use alloy_sol_types::SolValue;
+use foundry_common::wallet::{derive_private_key, derive_private_key_with_language};
 use foundry_evm_core::evm::FoundryEvmNetwork;
 use k256::{
     FieldBytes, Scalar,
@@ -486,36 +487,14 @@ pub(super) fn parse_wallet(private_key: &U256) -> Result<PrivateKeySigner> {
 }
 
 fn derive_key_str(mnemonic: &str, path: &str, index: u32, language: &str) -> Result {
-    match language {
-        "chinese_simplified" => derive_key::<ChineseSimplified>(mnemonic, path, index),
-        "chinese_traditional" => derive_key::<ChineseTraditional>(mnemonic, path, index),
-        "czech" => derive_key::<Czech>(mnemonic, path, index),
-        "english" => derive_key::<English>(mnemonic, path, index),
-        "french" => derive_key::<French>(mnemonic, path, index),
-        "italian" => derive_key::<Italian>(mnemonic, path, index),
-        "japanese" => derive_key::<Japanese>(mnemonic, path, index),
-        "korean" => derive_key::<Korean>(mnemonic, path, index),
-        "portuguese" => derive_key::<Portuguese>(mnemonic, path, index),
-        "spanish" => derive_key::<Spanish>(mnemonic, path, index),
-        _ => Err(fmt_err!("unsupported mnemonic language: {language:?}")),
-    }
+    let private_key = derive_private_key_with_language(mnemonic, path, index, language)
+        .map_err(|e| fmt_err!("{e}"))?;
+    Ok(private_key.abi_encode())
 }
 
 fn derive_key<W: Wordlist>(mnemonic: &str, path: &str, index: u32) -> Result {
-    fn derive_key_path(path: &str, index: u32) -> String {
-        let mut out = path.to_string();
-        if !out.ends_with('/') {
-            out.push('/');
-        }
-        out.push_str(&index.to_string());
-        out
-    }
-
-    let wallet = MnemonicBuilder::<W>::default()
-        .phrase(mnemonic)
-        .derivation_path(derive_key_path(path, index))?
-        .build()?;
-    let private_key = U256::from_be_bytes(wallet.credential().to_bytes().into());
+    let private_key =
+        derive_private_key::<W>(mnemonic, path, index).map_err(|e| fmt_err!("{e}"))?;
     Ok(private_key.abi_encode())
 }
 

crates/cheatcodes/src/json.rs

@@ -855,7 +855,7 @@ mod tests {
             any::<u32>().prop_map(|v| DynSolValue::Uint(U256::from(v), 256)),
             any::<[u8; 20]>().prop_map(Address::from).prop_map(DynSolValue::Address),
             any::<[u8; 32]>().prop_map(B256::from).prop_map(|b| DynSolValue::FixedBytes(b, 32)),
-            ".*".prop_map(DynSolValue::String),
+            ".*".prop_filter("invalid string value", |s| s != "{}").prop_map(DynSolValue::String),
         ];
 
         // Combine them to create a list of unique fields that preserve the random order.

crates/common/Cargo.toml

@@ -86,7 +86,7 @@ mpp.workspace = true
 foundry-wallets = { workspace = true, features = ["browser", "tempo"] }
 tokio-tungstenite.workspace = true
 futures.workspace = true
-alloy-signer-local.workspace = true
+alloy-signer-local = { workspace = true, features = ["mnemonic-all-languages"] }
 base64.workspace = true
 sha2 = "0.10"
 tempfile.workspace = true

crates/common/src/lib.rs

@@ -38,6 +38,7 @@ pub mod traits;
 pub mod transactions;
 mod utils;
 pub mod version;
+pub mod wallet;
 
 pub use compile::Analysis;
 pub use constants::*;

crates/common/src/traits.rs

@@ -90,6 +90,11 @@ pub trait TestFunctionExt {
         self.test_function_kind().is_invariant_test()
     }
 
+    /// Returns `true` if this function is a symbolic test.
+    fn is_symbolic_test(&self) -> bool {
+        self.test_function_kind().is_symbolic_test()
+    }
+
     /// Returns `true` if this function is an `afterInvariant` function.
     fn is_after_invariant(&self) -> bool {
         self.test_function_kind().is_after_invariant()
@@ -158,6 +163,8 @@ pub enum TestFunctionKind {
     InvariantTest,
     /// `table*`, with arguments.
     TableTest,
+    /// `check*` or `prove*`, when selected by symbolic test mode.
+    SymbolicTest,
     /// `afterInvariant`.
     AfterInvariant,
     /// `fixture*`.
@@ -199,6 +206,7 @@ impl TestFunctionKind {
             Self::FuzzTest { should_fail: true } => "fuzz fail",
             Self::InvariantTest => "invariant",
             Self::TableTest => "table",
+            Self::SymbolicTest => "symbolic",
             Self::AfterInvariant => "afterInvariant",
             Self::Fixture => "fixture",
             Self::Unknown => "unknown",
@@ -216,7 +224,11 @@ impl TestFunctionKind {
     pub const fn is_any_test(&self) -> bool {
         matches!(
             self,
-            Self::UnitTest { .. } | Self::FuzzTest { .. } | Self::TableTest | Self::InvariantTest
+            Self::UnitTest { .. }
+                | Self::FuzzTest { .. }
+                | Self::TableTest
+                | Self::InvariantTest
+                | Self::SymbolicTest
         )
     }
 
@@ -250,6 +262,12 @@ impl TestFunctionKind {
         matches!(self, Self::TableTest)
     }
 
+    /// Returns `true` if this function is a symbolic test.
+    #[inline]
+    pub const fn is_symbolic_test(&self) -> bool {
+        matches!(self, Self::SymbolicTest)
+    }
+
     /// Returns `true` if this function is an `afterInvariant` function.
     #[inline]
     pub const fn is_after_invariant(&self) -> bool {

crates/common/src/wallet.rs

@@ -0,0 +1,68 @@
+use alloy_primitives::U256;
+use alloy_signer_local::{
+    MnemonicBuilder, PrivateKeySigner,
+    coins_bip39::{
+        ChineseSimplified, ChineseTraditional, Czech, English, French, Italian, Japanese, Korean,
+        Portuguese, Spanish, Wordlist,
+    },
+};
+
+/// Appends `index` to `path`, inserting a `/` separator when needed.
+pub fn derive_key_path(path: &str, index: u32) -> String {
+    let mut out = path.to_string();
+    if !out.ends_with('/') {
+        out.push('/');
+    }
+    out.push_str(&index.to_string());
+    out
+}
+
+/// Derives a private key from a BIP-39 mnemonic using the given BIP-32 path and index.
+pub fn derive_private_key<W: Wordlist>(
+    mnemonic: &str,
+    path: &str,
+    index: u32,
+) -> Result<U256, String> {
+    let wallet = MnemonicBuilder::<W>::default()
+        .phrase(mnemonic)
+        .derivation_path(derive_key_path(path, index))
+        .map_err(|e| e.to_string())?
+        .build()
+        .map_err(|e| e.to_string())?;
+    Ok(U256::from_be_bytes(wallet.credential().to_bytes().into()))
+}
+
+/// Derives a private key from a BIP-39 mnemonic, selecting the wordlist by name.
+///
+/// Recognised language names: `chinese_simplified`, `chinese_traditional`, `czech`, `english`,
+/// `french`, `italian`, `japanese`, `korean`, `portuguese`, `spanish`.
+pub fn derive_private_key_with_language(
+    mnemonic: &str,
+    path: &str,
+    index: u32,
+    language: &str,
+) -> Result<U256, String> {
+    match language {
+        "chinese_simplified" => derive_private_key::<ChineseSimplified>(mnemonic, path, index),
+        "chinese_traditional" => derive_private_key::<ChineseTraditional>(mnemonic, path, index),
+        "czech" => derive_private_key::<Czech>(mnemonic, path, index),
+        "english" => derive_private_key::<English>(mnemonic, path, index),
+        "french" => derive_private_key::<French>(mnemonic, path, index),
+        "italian" => derive_private_key::<Italian>(mnemonic, path, index),
+        "japanese" => derive_private_key::<Japanese>(mnemonic, path, index),
+        "korean" => derive_private_key::<Korean>(mnemonic, path, index),
+        "portuguese" => derive_private_key::<Portuguese>(mnemonic, path, index),
+        "spanish" => derive_private_key::<Spanish>(mnemonic, path, index),
+        _ => Err(format!("unsupported mnemonic language: {language:?}")),
+    }
+}
+
+/// Constructs a [`PrivateKeySigner`] from a raw private key value.
+///
+/// Returns `Err` when `private_key` is zero or its bytes are not a valid secp256k1 scalar.
+pub fn private_key_from_u256(private_key: U256) -> Result<PrivateKeySigner, String> {
+    if private_key.is_zero() {
+        return Err("private key cannot be zero".to_string());
+    }
+    PrivateKeySigner::from_slice(&private_key.to_be_bytes::<32>()).map_err(|e| e.to_string())
+}