feat(forge): eip712 cheatcodes + forge cmd (eip712 + bind-json) with solar

crates/anvil/core/src/eth/mod.rs

@@ -664,7 +664,7 @@ pub enum EthRequest {
 
     /// Add an address to the [`DelegationCapability`] of the wallet
     ///
-    /// [`DelegationCapability`]: wallet::DelegationCapability  
+    /// [`DelegationCapability`]: wallet::DelegationCapability
     #[serde(rename = "anvil_addCapability", with = "sequence")]
     AnvilAddCapability(Address),
 

crates/cheatcodes/spec/src/vm.rs

@@ -2888,6 +2888,55 @@ interface Vm {
     /// catch (bytes memory interceptedInitcode) { initcode = interceptedInitcode; }
     #[cheatcode(group = Utilities, safety = Unsafe)]
     function interceptInitcode() external;
+
+    /// Generates the hash of the canonical EIP-712 type representation.
+    ///
+    /// Supports 2 different inputs:
+    ///  1. Name of the type (i.e. "Transaction"):
+    ///     * requires previous binding generation with `forge bind-json`.
+    ///     * bindings will be retrieved from the path configured in `foundry.toml`.
+    ///
+    ///  2. String representation of the type (i.e. "Foo(Bar bar) Bar(uint256 baz)").
+    ///     * Note: the cheatcode will output the canonical type even if the input is malformated
+    ///             with the wrong order of elements or with extra whitespaces.
+    #[cheatcode(group = Utilities)]
+    function eip712HashType(string calldata typeNameOrDefinition) external pure returns (bytes32 typeHash);
+
+    /// Generates the hash of the canonical EIP-712 type representation.
+    /// Requires previous binding generation with `forge bind-json`.
+    ///
+    /// Params:
+    ///  * `bindingsPath`: path where the output of `forge bind-json` is stored.
+    ///  * `typeName`: Name of the type (i.e. "Transaction").
+    #[cheatcode(group = Utilities)]
+    function eip712HashType(string calldata bindingsPath, string calldata typeName) external pure returns (bytes32 typeHash);
+
+    /// Generates the struct hash of the canonical EIP-712 type representation and its abi-encoded data.
+    ///
+    /// Supports 2 different inputs:
+    ///  1. Name of the type (i.e. "PermitSingle"):
+    ///     * requires previous binding generation with `forge bind-json`.
+    ///     * bindings will be retrieved from the path configured in `foundry.toml`.
+    ///
+    ///  2. String representation of the type (i.e. "Foo(Bar bar) Bar(uint256 baz)").
+    ///     * Note: the cheatcode will use the canonical type even if the input is malformated
+    ///             with the wrong order of elements or with extra whitespaces.
+    #[cheatcode(group = Utilities)]
+    function eip712HashStruct(string calldata typeNameOrDefinition, bytes calldata abiEncodedData) external pure returns (bytes32 typeHash);
+
+    /// Generates the struct hash of the canonical EIP-712 type representation and its abi-encoded data.
+    /// Requires previous binding generation with `forge bind-json`.
+    ///
+    /// Params:
+    ///  * `bindingsPath`: path where the output of `forge bind-json` is stored.
+    ///  * `typeName`: Name of the type (i.e. "PermitSingle").
+    ///  * `abiEncodedData`: ABI-encoded data for the struct that is being hashed.
+    #[cheatcode(group = Utilities)]
+    function eip712HashStruct(string calldata bindingsPath, string calldata typeName, bytes calldata abiEncodedData) external pure returns (bytes32 typeHash);
+
+    /// Generates a ready-to-sign digest of human-readable typed data following the EIP-712 standard.
+    #[cheatcode(group = Utilities)]
+    function eip712HashTypedData(string calldata jsonData) external pure returns (bytes32 digest);
 }
 }
 

crates/cheatcodes/src/config.rs

@@ -33,6 +33,8 @@ pub struct CheatsConfig {
     pub rpc_endpoints: ResolvedRpcEndpoints,
     /// Project's paths as configured
     pub paths: ProjectPathsConfig,
+    /// Path to the directory that contains the bindings generated by `forge bind-json`.
+    pub bind_json_path: PathBuf,
     /// Filesystem permissions for cheatcodes like `writeFile`, `readFile`
     pub fs_permissions: FsPermissions,
     /// Project root
@@ -98,6 +100,7 @@ impl CheatsConfig {
             no_storage_caching: config.no_storage_caching,
             rpc_endpoints,
             paths: config.project_paths(),
+            bind_json_path: config.bind_json.out.clone(),
             fs_permissions: config.fs_permissions.clone().joined(config.root.as_ref()),
             root: config.root.clone(),
             broadcast: config.root.clone().join(&config.broadcast),
@@ -303,6 +306,7 @@ impl Default for CheatsConfig {
             paths: ProjectPathsConfig::builder().build_with_root("./"),
             fs_permissions: Default::default(),
             root: Default::default(),
+            bind_json_path: PathBuf::default().join("utils").join("jsonBindings.sol"),
             broadcast: Default::default(),
             allowed_paths: vec![],
             evm_opts: Default::default(),

crates/cheatcodes/src/utils.rs

@@ -1,14 +1,17 @@
 //! Implementations of [`Utilities`](spec::Group::Utilities) cheatcodes.
 
 use crate::{Cheatcode, Cheatcodes, CheatcodesExecutor, CheatsCtxt, Result, Vm::*};
-use alloy_dyn_abi::{DynSolType, DynSolValue};
+use alloy_dyn_abi::{eip712_parser::EncodeType, DynSolType, DynSolValue, Resolver, TypedData};
 use alloy_ens::namehash;
-use alloy_primitives::{aliases::B32, map::HashMap, B64, U256};
+use alloy_primitives::{aliases::B32, keccak256, map::HashMap, Bytes, B64, U256};
 use alloy_sol_types::SolValue;
+use foundry_common::{fs, TYPE_BINDING_PREFIX};
+use foundry_config::fs_permissions::FsAccessKind;
 use foundry_evm_core::constants::DEFAULT_CREATE2_DEPLOYER;
 use proptest::prelude::Strategy;
 use rand::{seq::SliceRandom, Rng, RngCore};
 use revm::context::JournalTr;
+use std::path::PathBuf;
 
 /// Contains locations of traces ignored via cheatcodes.
 ///
@@ -314,3 +317,148 @@ fn random_int(state: &mut Cheatcodes, bits: Option<U256>) -> Result {
         .current()
         .abi_encode())
 }
+
+impl Cheatcode for eip712HashType_0Call {
+    fn apply(&self, state: &mut Cheatcodes) -> Result {
+        let Self { typeNameOrDefinition } = self;
+
+        let type_def = get_canonical_type_def(typeNameOrDefinition, state, None)?;
+
+        Ok(keccak256(type_def.as_bytes()).to_vec())
+    }
+}
+
+impl Cheatcode for eip712HashType_1Call {
+    fn apply(&self, state: &mut Cheatcodes) -> Result {
+        let Self { bindingsPath, typeName } = self;
+
+        let path = state.config.ensure_path_allowed(bindingsPath, FsAccessKind::Read)?;
+        let type_def = get_type_def_from_bindings(typeName, path, &state.config.root)?;
+
+        Ok(keccak256(type_def.as_bytes()).to_vec())
+    }
+}
+
+impl Cheatcode for eip712HashStruct_0Call {
+    fn apply(&self, state: &mut Cheatcodes) -> Result {
+        let Self { typeNameOrDefinition, abiEncodedData } = self;
+
+        let type_def = get_canonical_type_def(typeNameOrDefinition, state, None)?;
+        let primary = &type_def[..type_def.find('(').unwrap_or(type_def.len())];
+
+        get_struct_hash(primary, &type_def, abiEncodedData)
+    }
+}
+
+impl Cheatcode for eip712HashStruct_1Call {
+    fn apply(&self, state: &mut Cheatcodes) -> Result {
+        let Self { bindingsPath, typeName, abiEncodedData } = self;
+
+        let path = state.config.ensure_path_allowed(bindingsPath, FsAccessKind::Read)?;
+        let type_def = get_type_def_from_bindings(typeName, path, &state.config.root)?;
+
+        get_struct_hash(typeName, &type_def, abiEncodedData)
+    }
+}
+
+impl Cheatcode for eip712HashTypedDataCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { jsonData } = self;
+        let typed_data: TypedData = serde_json::from_str(jsonData)?;
+        let digest = typed_data.eip712_signing_hash()?;
+
+        Ok(digest.to_vec())
+    }
+}
+
+/// Returns EIP-712 canonical type definition from the provided string type representation or type
+/// name. If type name provided, then it looks up bindings from file generated by `forge bind-json`.
+fn get_canonical_type_def(
+    name_or_def: &String,
+    state: &mut Cheatcodes,
+    path: Option<PathBuf>,
+) -> Result<String> {
+    let type_def = if name_or_def.contains('(') {
+        // If the input contains '(', it must be the type definition.
+        EncodeType::parse(name_or_def).and_then(|parsed| parsed.canonicalize())?
+    } else {
+        // Otherwise, it must be the type name.
+        let path = path.as_ref().unwrap_or(&state.config.bind_json_path);
+        let path = state.config.ensure_path_allowed(path, FsAccessKind::Read)?;
+        get_type_def_from_bindings(name_or_def, path, &state.config.root)?
+    };
+
+    Ok(type_def)
+}
+
+/// Returns the EIP-712 type definition from the bindings in the provided path.
+/// Assumes that read validation for the path has already been checked.
+fn get_type_def_from_bindings(name: &String, path: PathBuf, root: &PathBuf) -> Result<String> {
+    let content = fs::read_to_string(&path)?;
+
+    let type_defs: HashMap<&str, &str> = content
+        .lines()
+        .filter_map(|line| {
+            let relevant = line.trim().strip_prefix(TYPE_BINDING_PREFIX)?;
+            let (name, def) = relevant.split_once('=')?;
+            Some((name.trim(), def.trim().strip_prefix('"')?.strip_suffix("\";")?))
+        })
+        .collect();
+
+    match type_defs.get(name.as_str()) {
+        Some(value) => Ok(value.to_string()),
+        None => {
+            let bindings =
+                type_defs.keys().map(|k| format!(" - {k}")).collect::<Vec<String>>().join("\n");
+
+            bail!(
+                "'{}' not found in '{}'.{}",
+                name,
+                path.strip_prefix(root).unwrap_or(&path).to_string_lossy(),
+                if bindings.is_empty() {
+                    String::new()
+                } else {
+                    format!("\nAvailable bindings:\n{bindings}\n")
+                }
+            );
+        }
+    }
+}
+
+/// Returns the EIP-712 struct hash for provided name, definition and ABI encoded data.
+fn get_struct_hash(primary: &str, type_def: &String, abi_encoded_data: &Bytes) -> Result {
+    let mut resolver = Resolver::default();
+
+    // Populate the resolver by ingesting the canonical type definition, and then get the
+    // corresponding `DynSolType` of the primary type.
+    resolver
+        .ingest_string(type_def)
+        .map_err(|e| fmt_err!("Resolver failed to ingest type definition: {e}"))?;
+
+    let resolved_sol_type = resolver
+        .resolve(primary)
+        .map_err(|e| fmt_err!("Failed to resolve EIP-712 primary type '{primary}': {e}"))?;
+
+    // ABI-decode the bytes into `DynSolValue::CustomStruct`.
+    let sol_value = resolved_sol_type.abi_decode(abi_encoded_data.as_ref()).map_err(|e| {
+        fmt_err!("Failed to ABI decode using resolved_sol_type directly for '{primary}': {e}.")
+    })?;
+
+    // Use the resolver to properly encode the data.
+    let encoded_data: Vec<u8> = resolver
+        .encode_data(&sol_value)
+        .map_err(|e| fmt_err!("Failed to EIP-712 encode data for struct '{primary}': {e}"))?
+        .ok_or_else(|| fmt_err!("EIP-712 data encoding returned 'None' for struct '{primary}'"))?;
+
+    // Compute the type hash of the primary type.
+    let type_hash = resolver
+        .type_hash(primary)
+        .map_err(|e| fmt_err!("Failed to compute typeHash for EIP712 type '{primary}': {e}"))?;
+
+    // Compute the struct hash of the concatenated type hash and encoded data.
+    let mut bytes_to_hash = Vec::with_capacity(32 + encoded_data.len());
+    bytes_to_hash.extend_from_slice(type_hash.as_slice());
+    bytes_to_hash.extend_from_slice(&encoded_data);
+
+    Ok(keccak256(&bytes_to_hash).to_vec())
+}