feat(forge, cast): add RunArgs generate_local_signatures to enable trace with local contracts functions and events

crates/cast/bin/cmd/run.rs

@@ -6,9 +6,9 @@ use clap::Parser;
 use eyre::{Result, WrapErr};
 use foundry_cli::{
     opts::RpcOpts,
-    utils::{handle_traces, init_progress, TraceResult},
+    utils::{cache_local_signatures, handle_traces, init_progress, TraceResult},
 };
-use foundry_common::{is_known_system_sender, SYSTEM_TRANSACTION_TYPE};
+use foundry_common::{compile::ProjectCompiler, is_known_system_sender, SYSTEM_TRANSACTION_TYPE};
 use foundry_compilers::artifacts::EvmVersion;
 use foundry_config::{
     figment::{
@@ -86,6 +86,13 @@ pub struct RunArgs {
     /// Enables Alphanet features.
     #[arg(long)]
     pub alphanet: bool,
+
+    /// If generate a file with the signatures of the functions and events of the project.
+    /// The file will be saved in the foundry cache directory.
+    ///
+    /// default value: false
+    #[arg(long, short = 'c', visible_alias = "cls")]
+    pub cache_local_signatures: bool,
 }
 
 impl RunArgs {
@@ -242,6 +249,18 @@ impl RunArgs {
             }
         };
 
+        if self.cache_local_signatures {
+            let project = config.project()?;
+            let compiler = ProjectCompiler::new().quiet(true);
+            let output = compiler.compile(&project)?;
+            if let Err(err) = cache_local_signatures(&output, Config::foundry_cache_dir().unwrap())
+            {
+                warn!(target: "cast::run", ?err, "failed to flush signature cache");
+            } else {
+                trace!(target: "cast::run", "flushed signature cache")
+            }
+        }
+
         handle_traces(
             result,
             &config,

crates/cli/src/opts/build/core.rs

@@ -140,6 +140,14 @@ pub struct CoreBuildArgs {
     #[command(flatten)]
     #[serde(flatten)]
     pub project_paths: ProjectPathsArgs,
+
+    /// If generate a file with the signatures of the functions and events of the project.
+    /// The file will be saved in the foundry cache directory.
+    ///
+    /// default value: false
+    #[arg(long, visible_alias = "cls")]
+    #[serde(skip)]
+    pub cache_local_signatures: bool,
 }
 
 impl CoreBuildArgs {

crates/cli/src/utils/cmd.rs

@@ -16,7 +16,7 @@ use foundry_evm::{
     traces::{
         debug::DebugTraceIdentifier,
         decode_trace_arena,
-        identifier::{EtherscanIdentifier, SignaturesIdentifier},
+        identifier::{CachedSignatures, EtherscanIdentifier, SignaturesIdentifier},
         render_trace_arena_with_bytecodes, CallTraceDecoder, CallTraceDecoderBuilder, TraceKind,
         Traces,
     },
@@ -441,3 +441,25 @@ pub async fn print_traces(
     println!("Gas used: {}", result.gas_used);
     Ok(())
 }
+
+/// Traverse the artifacts in the project to generate local signatures and merge them into the cache
+/// file.
+pub fn cache_local_signatures(output: &ProjectCompileOutput, cache_path: PathBuf) -> Result<()> {
+    let path = cache_path.join("signatures");
+    let mut cached_signatures = CachedSignatures::load(cache_path);
+    output.artifacts().for_each(|(_, artifact)| {
+        if let Some(abi) = &artifact.abi {
+            for func in abi.functions() {
+                cached_signatures.functions.insert(func.selector().to_string(), func.signature());
+            }
+            for event in abi.events() {
+                cached_signatures
+                    .events
+                    .insert(event.selector().to_string(), event.full_signature());
+            }
+        }
+    });
+
+    fs::write_json_file(&path, &cached_signatures)?;
+    Ok(())
+}

crates/evm/traces/src/identifier/mod.rs

@@ -12,7 +12,7 @@ mod etherscan;
 pub use etherscan::EtherscanIdentifier;
 
 mod signatures;
-pub use signatures::{SignaturesIdentifier, SingleSignaturesIdentifier};
+pub use signatures::{CachedSignatures, SignaturesIdentifier, SingleSignaturesIdentifier};
 
 /// An address identity
 pub struct AddressIdentity<'a> {

crates/evm/traces/src/identifier/signatures.rs

@@ -16,11 +16,29 @@ use tokio::sync::RwLock;
 pub type SingleSignaturesIdentifier = Arc<RwLock<SignaturesIdentifier>>;
 
 #[derive(Debug, Default, Serialize, Deserialize)]
-struct CachedSignatures {
-    events: BTreeMap<String, String>,
-    functions: BTreeMap<String, String>,
+pub struct CachedSignatures {
+    pub events: BTreeMap<String, String>,
+    pub functions: BTreeMap<String, String>,
 }
 
+impl CachedSignatures {
+    #[instrument(target = "evm::traces")]
+    pub fn load(cache_path: PathBuf) -> Self {
+        let path = cache_path.join("signatures");
+        if path.is_file() {
+            fs::read_json_file(&path)
+                .map_err(
+                    |err| warn!(target: "evm::traces", ?path, ?err, "failed to read cache file"),
+                )
+                .unwrap_or_default()
+        } else {
+            if let Err(err) = std::fs::create_dir_all(cache_path) {
+                warn!(target: "evm::traces", "could not create signatures cache dir: {:?}", err);
+            }
+            Self::default()
+        }
+    }
+}
 /// An identifier that tries to identify functions and events using signatures found at
 /// `https://openchain.xyz` or a local cache.
 #[derive(Debug)]
@@ -46,16 +64,7 @@ impl SignaturesIdentifier {
         let identifier = if let Some(cache_path) = cache_path {
             let path = cache_path.join("signatures");
             trace!(target: "evm::traces", ?path, "reading signature cache");
-            let cached = if path.is_file() {
-                fs::read_json_file(&path)
-                    .map_err(|err| warn!(target: "evm::traces", ?path, ?err, "failed to read cache file"))
-                    .unwrap_or_default()
-            } else {
-                if let Err(err) = std::fs::create_dir_all(cache_path) {
-                    warn!(target: "evm::traces", "could not create signatures cache dir: {:?}", err);
-                }
-                CachedSignatures::default()
-            };
+            let cached = CachedSignatures::load(cache_path);
             Self { cached, cached_path: Some(path), unavailable: HashSet::default(), client }
         } else {
             Self {

crates/forge/bin/cmd/build.rs

@@ -1,7 +1,10 @@
 use super::{install, watch::WatchArgs};
 use clap::Parser;
 use eyre::Result;
-use foundry_cli::{opts::CoreBuildArgs, utils::LoadConfig};
+use foundry_cli::{
+    opts::CoreBuildArgs,
+    utils::{cache_local_signatures, LoadConfig},
+};
 use foundry_common::compile::ProjectCompiler;
 use foundry_compilers::{
     compilers::{multi::MultiCompilerLanguage, Language},
@@ -111,6 +114,15 @@ impl BuildArgs {
             println!("{}", serde_json::to_string_pretty(&output.output())?);
         }
 
+        if self.args.cache_local_signatures {
+            if let Err(err) = cache_local_signatures(&output, Config::foundry_cache_dir().unwrap())
+            {
+                warn!(target: "forge::build", ?err, "failed to flush signature cache");
+            } else {
+                trace!(target: "forge::build", "flushed signature cache")
+            }
+        }
+
         Ok(output)
     }