fix(cast): try decoding custom errors when execution reverted in cast send (#9794)

* fix(cast): try decoding custom errors when gas estimation in cast send

* Changes after review: use serde_json::from_str, use itertools format

* Nits

* More nits

Author: grandizzy

crates/cast/bin/tx.rs

@@ -1,4 +1,5 @@
 use alloy_consensus::{SidecarBuilder, SimpleCoder};
+use alloy_dyn_abi::ErrorExt;
 use alloy_json_abi::Function;
 use alloy_network::{
     AnyNetwork, TransactionBuilder, TransactionBuilder4844, TransactionBuilder7702,
@@ -8,21 +9,26 @@ use alloy_provider::Provider;
 use alloy_rpc_types::{AccessList, Authorization, TransactionInput, TransactionRequest};
 use alloy_serde::WithOtherFields;
 use alloy_signer::Signer;
+use alloy_transport::TransportError;
+use cast::traces::identifier::SignaturesIdentifier;
 use eyre::Result;
 use foundry_cli::{
     opts::{CliAuthorizationList, TransactionOpts},
     utils::{self, parse_function_args},
 };
-use foundry_common::ens::NameOrAddress;
+use foundry_common::{ens::NameOrAddress, fmt::format_tokens};
 use foundry_config::{Chain, Config};
 use foundry_wallets::{WalletOpts, WalletSigner};
+use itertools::Itertools;
+use serde_json::value::RawValue;
+use std::fmt::Write;
 
 /// Different sender kinds used by [`CastTxBuilder`].
 pub enum SenderKind<'a> {
     /// An address without signer. Used for read-only calls and transactions sent through unlocked
     /// accounts.
     Address(Address),
-    /// A refersnce to a signer.
+    /// A reference to a signer.
     Signer(&'a WalletSigner),
     /// An owned signer.
     OwnedSigner(WalletSigner),
@@ -350,12 +356,36 @@ impl<P: Provider<AnyNetwork>> CastTxBuilder<P, InputState> {
         }
 
         if self.tx.gas.is_none() {
-            self.tx.gas = Some(self.provider.estimate_gas(&self.tx).await?);
+            self.estimate_gas().await?;
         }
 
         Ok((self.tx, self.state.func))
     }
 
+    /// Estimate tx gas from provider call. Tries to decode custom error if execution reverted.
+    async fn estimate_gas(&mut self) -> Result<()> {
+        match self.provider.estimate_gas(&self.tx).await {
+            Ok(estimated) => {
+                self.tx.gas = Some(estimated);
+                Ok(())
+            }
+            Err(err) => {
+                if let TransportError::ErrorResp(payload) = &err {
+                    // If execution reverted with code 3 during provider gas estimation then try
+                    // to decode custom errors and append it to the error message.
+                    if payload.code == 3 {
+                        if let Some(data) = &payload.data {
+                            if let Ok(Some(decoded_error)) = decode_execution_revert(data).await {
+                                eyre::bail!("Failed to estimate gas: {}: {}", err, decoded_error)
+                            }
+                        }
+                    }
+                }
+                eyre::bail!("Failed to estimate gas: {}", err)
+            }
+        }
+    }
+
     /// Parses the passed --auth value and sets the authorization list on the transaction.
     async fn resolve_auth(&mut self, sender: SenderKind<'_>, tx_nonce: u64) -> Result<()> {
         let Some(auth) = self.auth.take() else { return Ok(()) };
@@ -401,3 +431,25 @@ where
         Ok(self)
     }
 }
+
+/// Helper function that tries to decode custom error name and inputs from error payload data.
+async fn decode_execution_revert(data: &RawValue) -> Result<Option<String>> {
+    if let Some(err_data) = serde_json::from_str::<String>(data.get())?.strip_prefix("0x") {
+        let selector = err_data.get(..8).unwrap();
+        if let Some(known_error) = SignaturesIdentifier::new(Config::foundry_cache_dir(), false)?
+            .write()
+            .await
+            .identify_error(&hex::decode(selector)?)
+            .await
+        {
+            let mut decoded_error = known_error.name.clone();
+            if !known_error.inputs.is_empty() {
+                if let Ok(error) = known_error.decode_error(&hex::decode(err_data)?) {
+                    write!(decoded_error, "({})", format_tokens(&error.body).format(", "))?;
+                }
+            }
+            return Ok(Some(decoded_error))
+        }
+    }
+    Ok(None)
+}

crates/cast/tests/cli/main.rs

@@ -1971,3 +1971,74 @@ contract WETH9 {
     uint8  public decimals = 18;
 ..."#]]);
 });
+
+// tests cast send gas estimate execution failure message contains decoded custom error
+// <https://github.com/foundry-rs/foundry/issues/9789>
+forgetest_async!(cast_send_estimate_gas_error, |prj, cmd| {
+    let (_, handle) = anvil::spawn(NodeConfig::test()).await;
+
+    foundry_test_utils::util::initialize(prj.root());
+    prj.add_source(
+        "SimpleStorage",
+        r#"
+contract SimpleStorage {
+    uint256 private storedValue;
+    error AddressInsufficientBalance(address account, uint256 newValue);
+    function setValue(uint256 _newValue) public {
+        if (_newValue > 100) {
+            revert AddressInsufficientBalance(msg.sender, _newValue);
+        }
+        storedValue = _newValue;
+    }
+}
+   "#,
+    )
+    .unwrap();
+    prj.add_script(
+        "SimpleStorageScript",
+        r#"
+import "forge-std/Script.sol";
+import {SimpleStorage} from "../src/SimpleStorage.sol";
+contract SimpleStorageScript is Script {
+    function run() public {
+        vm.startBroadcast();
+        new SimpleStorage();
+        vm.stopBroadcast();
+    }
+}
+   "#,
+    )
+    .unwrap();
+
+    cmd.args([
+        "script",
+        "--private-key",
+        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
+        "--rpc-url",
+        &handle.http_endpoint(),
+        "--broadcast",
+        "SimpleStorageScript",
+    ])
+    .assert_success();
+
+    // Cache project selectors.
+    cmd.forge_fuse().set_current_dir(prj.root());
+    cmd.forge_fuse().args(["selectors", "cache"]).assert_success();
+
+    // Assert cast send can decode custom error on estimate gas execution failure.
+    cmd.cast_fuse()
+        .args([
+            "send",
+            "0x5FbDB2315678afecb367f032d93F642f64180aa3",
+            "setValue(uint256)",
+            "1000",
+            "--private-key",
+            "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
+            "--rpc-url",
+            &handle.http_endpoint(),
+        ])
+        .assert_failure().stderr_eq(str![[r#"
+Error: Failed to estimate gas: server returned an error response: error code 3: execution reverted: custom error 0x6786ad34: 000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb9226600000000000000000000000000000000000000000000000000000000000003e8, data: "0x6786ad34000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb9226600000000000000000000000000000000000000000000000000000000000003e8": AddressInsufficientBalance(0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266, 1000)
+
+"#]]);
+});