cast: Strip placeholder from bytecode-object for source-map and matching

If a contract contains some libraries, and thus has an "unlinked"
bytecode object, it will never be matched against a deployed instance,
and the source map will never be set.

This fixes this issue by striping from the unlinked bytecode all
placeholders, replacing them with the `0x00..00` address. It doesn't
change anything regarding source-maps, but could change the matching of
the runtime bytecode. The changes are usually minimal in this case, though.

Author: ngotchac

Cargo.lock

@@ -57,6 +57,7 @@ itertools.workspace = true
 jiff.workspace = true
 num-format.workspace = true
 path-slash.workspace = true
+regex.workspace = true
 reqwest.workspace = true
 semver.workspace = true
 serde = { workspace = true, features = ["derive"] }

crates/common/Cargo.toml

@@ -1,6 +1,6 @@
 //! Commonly used contract types and functions.
 
-use crate::compile::PathOrContractInfo;
+use crate::{compile::PathOrContractInfo, strip_bytecode_placeholders};
 use alloy_dyn_abi::JsonAbiExt;
 use alloy_json_abi::{Event, Function, JsonAbi};
 use alloy_primitives::{hex, Address, Bytes, Selector, B256};
@@ -87,6 +87,16 @@ impl ContractData {
     pub fn deployed_bytecode(&self) -> Option<&Bytes> {
         self.deployed_bytecode.as_ref()?.bytes().filter(|b| !b.is_empty())
     }
+
+    /// Returns the bytecode without placeholders, if present.
+    pub fn bytecode_without_placeholders(&self) -> Option<Bytes> {
+        strip_bytecode_placeholders(self.bytecode.as_ref()?.object.as_ref()?)
+    }
+
+    /// Returns the deployed bytecode without placeholders, if present.
+    pub fn deployed_bytecode_without_placeholders(&self) -> Option<Bytes> {
+        strip_bytecode_placeholders(self.deployed_bytecode.as_ref()?.object.as_ref()?)
+    }
 }
 
 type ArtifactWithContractRef<'a> = (&'a ArtifactId, &'a ContractData);

crates/common/src/contracts.rs

@@ -1,6 +1,8 @@
 //! Uncategorised utilities.
 
-use alloy_primitives::{keccak256, B256, U256};
+use alloy_primitives::{hex, keccak256, Bytes, B256, U256};
+use foundry_compilers::artifacts::BytecodeObject;
+use regex::Regex;
 /// Block on a future using the current tokio runtime on the current thread.
 pub fn block_on<F: std::future::Future>(future: F) -> F::Output {
     block_on_handle(&tokio::runtime::Handle::current(), future)
@@ -54,3 +56,20 @@ pub fn ignore_metadata_hash(bytecode: &[u8]) -> &[u8] {
         bytecode
     }
 }
+
+/// Strips all __$xxx$__ placeholders from the bytecode if it's an unlinked bytecode.
+/// by replacing them with 20 zero bytes.
+/// This is useful for matching bytecodes to a contract source, and for the source map,
+/// in which the actual address of the placeholder isn't important.
+pub fn strip_bytecode_placeholders(bytecode: &BytecodeObject) -> Option<Bytes> {
+    match &bytecode {
+        BytecodeObject::Bytecode(bytes) => Some(bytes.clone()),
+        BytecodeObject::Unlinked(s) => {
+            // Replace all __$xxx$__ placeholders with 32 zero bytes
+            let re = Regex::new(r"__\$.{34}\$__").expect("invalid regex");
+            let s = re.replace_all(s, "00".repeat(40));
+            let bytes = hex::decode(s.as_bytes());
+            Some(bytes.ok()?.into())
+        }
+    }
+}

crates/common/src/utils.rs

@@ -1,5 +1,5 @@
 use eyre::{Context, Result};
-use foundry_common::compact_to_contract;
+use foundry_common::{compact_to_contract, strip_bytecode_placeholders};
 use foundry_compilers::{
     artifacts::{
         sourcemap::{SourceElement, SourceMap},
@@ -94,9 +94,9 @@ impl ArtifactData {
                 })
             };
 
-            // Only parse bytecode if it's not empty.
-            let pc_ic_map = if let Some(bytes) = b.bytes() {
-                (!bytes.is_empty()).then(|| PcIcMap::new(bytes))
+            // Only parse bytecode if it's not empty, stripping placeholders if necessary.
+            let pc_ic_map = if let Some(bytes) = strip_bytecode_placeholders(&b.object) {
+                (!bytes.is_empty()).then(|| PcIcMap::new(bytes.as_ref()))
             } else {
                 None
             };

crates/evm/traces/src/debug/sources.rs

@@ -59,9 +59,9 @@ impl<'a> LocalTraceIdentifier<'a> {
             let contract = self.known_contracts.get(id)?;
             // Select bytecodes to compare based on `is_creation` flag.
             let (contract_bytecode, current_bytecode) = if is_creation {
-                (contract.bytecode(), creation_code)
+                (contract.bytecode_without_placeholders(), creation_code)
             } else {
-                (contract.deployed_bytecode(), runtime_code)
+                (contract.deployed_bytecode_without_placeholders(), runtime_code)
             };
 
             if let Some(bytecode) = contract_bytecode {
@@ -78,7 +78,7 @@ impl<'a> LocalTraceIdentifier<'a> {
                     }
                 }
 
-                let score = bytecode_diff_score(bytecode, current_bytecode);
+                let score = bytecode_diff_score(&bytecode, current_bytecode);
                 if score == 0.0 {
                     trace!(target: "evm::traces::local", "found exact match");
                     return Some((id, &contract.abi));