Skip to main content

cast/
args.rs

1use crate::{
2    base::{Base, NumberWithBase},
3    cmd::{erc20::IERC20, rpc_provider},
4    opts::{
5        AbiSubcommand, Cast as CastArgs, CastSubcommand, ConversionSubcommand, MiscSubcommand,
6        QuerySubcommand, ToBaseArgs, TransactionSubcommand,
7    },
8    traces::identifier::SignaturesIdentifier,
9    tx::CastTxSender,
10};
11use alloy_consensus::{
12    Typed2718,
13    transaction::{Recovered, SignerRecoverable},
14};
15use alloy_dyn_abi::{DynSolType, DynSolValue, ErrorExt, EventExt, Specifier};
16use alloy_eips::{Encodable2718, eip7702::SignedAuthorization};
17use alloy_ens::{NameOrAddress, ProviderEnsExt, namehash};
18use alloy_network::{BlockResponse, Ethereum, Network, eip2718::Decodable2718};
19use alloy_primitives::{
20    Address, B256, Bytes, I256, Keccak256, LogData, Selector, TxHash, U64, U256,
21    eip191_hash_message, hex, keccak256,
22    utils::{ParseUnits, Unit},
23};
24use alloy_provider::Provider;
25use alloy_rlp::{decode_exact, encode};
26use alloy_rpc_types::BlockId;
27use clap::{CommandFactory, Parser};
28use clap_complete::generate;
29use eyre::{ContextCompat, OptionExt, Result, WrapErr};
30use foundry_block_explorers::Client;
31use foundry_cli::{
32    json::{print_json_object, print_json_value_or_scalar, print_list, print_scalar, print_tokens},
33    opts::RpcOpts,
34    utils::{self, LoadConfig},
35};
36use foundry_common::{
37    EIP1967_ADMIN_SLOT, EIP1967_BEACON_SLOT, EIP1967_IMPLEMENTATION_SLOT,
38    abi::{
39        abi_decode_calldata, abi_decode_event_data, encode_function_args,
40        encode_function_args_packed, encode_function_args_raw, get_error, get_event, get_func,
41    },
42    fmt::{
43        UIfmt, UIfmtSignatureExt, add_configurable_account_details, format_uint_exp,
44        get_pretty_block_attr, get_pretty_tx_attr,
45    },
46    fs,
47    provider::{ProviderBuilder, RetryProvider},
48    selectors::{
49        ParsedSignatures, SelectorImportData, SelectorKind, decode_calldata, decode_event_topic,
50        decode_function_selector, decode_selectors, import_selectors, parse_signatures,
51        pretty_calldata,
52    },
53    shell, stdin,
54    tempo::classify_payment_lane,
55};
56use foundry_config::Chain;
57use foundry_evm_networks::NetworkVariant;
58use foundry_primitives::{FoundryNetwork, FoundryTxEnvelope};
59use rayon::prelude::*;
60use serde::Serialize;
61use std::{
62    str::FromStr,
63    sync::atomic::{AtomicBool, Ordering},
64    time::Instant,
65};
66use tempo_alloy::TempoNetwork;
67use tempo_contracts::precompiles::{ITIP20ChannelReserve, TIP20_CHANNEL_RESERVE_ADDRESS};
68
69#[cfg(feature = "base")]
70use base_common_network::Base as BaseNetwork;
71
72#[cfg(feature = "optimism")]
73use op_alloy_network::Optimism;
74
75/// Runs `$body` with `$provider` bound to a provider for the selected `--network`.
76/// Optionally binds `$network_type` to the selected network type.
77///
78/// The fallback arm is used for Ethereum and when no network is selected: either `$default` is a
79/// provider expression that `$body` runs against, or a full `_ => $default` arm.
80macro_rules! with_network_provider {
81    ($network:expr, $config:expr, $default:expr, |$provider:ident $(, $network_type:ident)?| $body:expr) => {
82        with_network_provider!($network, $config, |$provider $(, $network_type)?| $body, _ => {
83            $(type $network_type = Ethereum;)?
84            let $provider = $default;
85            $body
86        })
87    };
88    ($network:expr, $config:expr, |$provider:ident $(, $network_type:ident)?| $body:expr, _ => $default:expr) => {
89        match $network {
90            #[cfg(feature = "base")]
91            Some(NetworkVariant::Base) => {
92                $(type $network_type = BaseNetwork;)?
93                let $provider = ProviderBuilder::<BaseNetwork>::from_config($config)?.build()?;
94                $body
95            }
96            #[cfg(feature = "optimism")]
97            Some(NetworkVariant::Optimism) => {
98                $(type $network_type = Optimism;)?
99                let $provider = ProviderBuilder::<Optimism>::from_config($config)?.build()?;
100                $body
101            }
102            Some(NetworkVariant::Tempo) => {
103                $(type $network_type = TempoNetwork;)?
104                let $provider = ProviderBuilder::<TempoNetwork>::from_config($config)?.build()?;
105                $body
106            }
107            _ => $default,
108        }
109    };
110}
111
112/// Run the `cast` command-line interface.
113pub fn run() -> Result<()> {
114    foundry_cli::opts::GlobalArgs::check_markdown_help::<CastArgs>();
115
116    let warnings = setup()?;
117
118    let args = CastArgs::parse();
119    args.global.init()?;
120    for warning in warnings {
121        let _ = foundry_common::sh_warn!("{warning}");
122    }
123    args.global.tokio_runtime().block_on(run_command(args))
124}
125
126/// Setup the global logger and other utilities.
127pub fn setup() -> Result<Vec<String>> {
128    let warnings = utils::common_setup();
129    utils::subscriber();
130
131    Ok(warnings)
132}
133
134/// Run the subcommand.
135#[allow(clippy::large_stack_frames)]
136pub async fn run_command(args: CastArgs) -> Result<()> {
137    match args.cmd {
138        // Constants
139        CastSubcommand::Conversion(
140            ConversionSubcommand::MaxInt { r#type } | ConversionSubcommand::MaxUint { r#type },
141        ) => {
142            print_scalar(int_bound(&r#type, true)?)?;
143        }
144        CastSubcommand::Conversion(ConversionSubcommand::MinInt { r#type }) => {
145            print_scalar(int_bound(&r#type, false)?)?
146        }
147        CastSubcommand::Conversion(ConversionSubcommand::AddressZero) => {
148            print_scalar(format!("{:?}", Address::ZERO))?
149        }
150        CastSubcommand::Conversion(ConversionSubcommand::HashZero) => {
151            print_scalar(format!("{:?}", B256::ZERO))?
152        }
153
154        // Conversions & transformations
155        CastSubcommand::Conversion(ConversionSubcommand::FromUtf8 { text }) => {
156            print_scalar(hex::encode_prefixed(stdin::unwrap(text, false)?))?;
157        }
158        CastSubcommand::Conversion(ConversionSubcommand::ToAscii { hexdata }) => {
159            let bytes = hex::decode(stdin::unwrap(hexdata, false)?.trim())?;
160            eyre::ensure!(bytes.iter().all(u8::is_ascii), "Invalid ASCII bytes");
161            print_scalar(String::from_utf8(bytes).unwrap())?;
162        }
163        CastSubcommand::Conversion(ConversionSubcommand::ToUtf8 { hexdata }) => {
164            let bytes = hex::decode(stdin::unwrap(hexdata, false)?)?;
165            print_scalar(String::from_utf8_lossy(&bytes).into_owned())?;
166        }
167        CastSubcommand::Conversion(ConversionSubcommand::FromFixedPoint { value, decimals }) => {
168            let (value, decimals) = stdin::unwrap2(value, decimals)?;
169            print_scalar(ParseUnits::parse_units(&value, Unit::from_str(&decimals)?)?.to_string())?;
170        }
171        CastSubcommand::Conversion(ConversionSubcommand::ToFixedPoint { value, decimals }) => {
172            let (value, decimals) = stdin::unwrap2(value, decimals)?;
173
174            let number = NumberWithBase::parse_int(&value, None)?;
175            let sign = if number.is_nonnegative() { "" } else { "-" };
176            let mut value = number.to_string().trim_start_matches('-').to_string();
177            let value_len = value.len();
178            let decimals_num = NumberWithBase::parse_uint(&decimals, None)?.number();
179            let decimals: usize = decimals_num
180                .try_into()
181                .ok()
182                .filter(|&d: &usize| d <= u16::MAX as usize)
183                .ok_or_else(|| eyre::eyre!("decimals out of range: {decimals_num}"))?;
184
185            if decimals >= value_len {
186                value = format!("0.{value:0>decimals$}");
187            } else {
188                value.insert(value_len - decimals, '.');
189            }
190            print_scalar(format!("{sign}{value}"))?;
191        }
192        CastSubcommand::Conversion(ConversionSubcommand::ConcatHex { data }) => {
193            let input;
194            let values = if data.is_empty() {
195                input = stdin::read(true)?;
196                itertools::Either::Left(input.split_whitespace())
197            } else {
198                itertools::Either::Right(data.iter().map(String::as_str))
199            };
200            let out = values.map(strip_0x).collect::<String>();
201            print_scalar(format!("0x{out}"))?;
202        }
203        CastSubcommand::Conversion(ConversionSubcommand::FromBin) => {
204            print_scalar(hex::encode_prefixed(stdin::read_bytes(false)?))?;
205        }
206        CastSubcommand::Conversion(ConversionSubcommand::ToHexdata { input }) => {
207            let value = stdin::unwrap_line(input)?;
208            let output = match value {
209                s if s.starts_with('@') => hex::encode(std::env::var(&s[1..])?),
210                s if s.starts_with('/') => hex::encode(fs::read(s)?),
211                s => s.split(':').map(|s| s.trim_start_matches("0x").to_lowercase()).collect(),
212            };
213            print_scalar(format!("0x{output}"))?;
214        }
215        CastSubcommand::Conversion(ConversionSubcommand::ToCheckSumAddress {
216            address,
217            chain_id,
218        }) => {
219            print_scalar(stdin::unwrap_line(address)?.to_checksum(chain_id))?;
220        }
221        CastSubcommand::Conversion(ConversionSubcommand::ToUint256 { value }) => {
222            let n = NumberWithBase::parse_uint(&stdin::unwrap_line(value)?, None)?;
223            print_scalar(format!("{n:#066x}"))?;
224        }
225        CastSubcommand::Conversion(ConversionSubcommand::ToInt256 { value }) => {
226            let n = NumberWithBase::parse_int(&stdin::unwrap_line(value)?, None)?;
227            eyre::ensure!(
228                !n.is_nonnegative() || n.number() <= I256::MAX.into_raw(),
229                "value out of range for a signed 256-bit integer"
230            );
231            print_scalar(format!("{n:#066x}"))?;
232        }
233        CastSubcommand::Conversion(ConversionSubcommand::ToUnit { value, unit }) => {
234            let value = stdin::unwrap_line(value)?;
235            let value = DynSolType::coerce_str(&DynSolType::Uint(256), &value)?
236                .as_uint()
237                .wrap_err("Could not convert to uint")?
238                .0;
239            let unit = unit.parse().wrap_err("could not parse units")?;
240            print_scalar(format_unit_as_string(ParseUnits::U256(value), unit))?;
241        }
242        CastSubcommand::Conversion(ConversionSubcommand::ParseUnits { value, unit }) => {
243            let value = stdin::unwrap_line(value)?;
244            let unit = Unit::new(unit).ok_or_else(|| eyre::eyre!("invalid unit"))?;
245
246            print_scalar(ParseUnits::parse_units(&value, unit)?.to_string())?;
247        }
248        CastSubcommand::Conversion(ConversionSubcommand::FormatUnits { value, unit }) => {
249            print_scalar(format_units(&stdin::unwrap_line(value)?, unit)?)?;
250        }
251        CastSubcommand::Conversion(ConversionSubcommand::FromWei { value, unit }) => {
252            print_scalar(
253                signed_parse_units(&NumberWithBase::parse_int(&stdin::unwrap_line(value)?, None)?)?
254                    .format_units(unit.parse()?),
255            )?;
256        }
257        CastSubcommand::Conversion(ConversionSubcommand::ToWei { value, unit }) => {
258            let value = stdin::unwrap_line(value)?;
259            let unit = unit.parse().wrap_err("could not parse units")?;
260            print_scalar(ParseUnits::parse_units(&value, unit)?.to_string())?;
261        }
262        CastSubcommand::Conversion(ConversionSubcommand::FromRlp { value, as_int }) => {
263            let bytes = hex::decode(stdin::unwrap_line(value)?).wrap_err("Could not decode hex")?;
264            let value = if as_int {
265                decode_exact::<U256>(&bytes)?.to_string()
266            } else {
267                decode_exact::<crate::rlp_converter::Item>(&bytes)
268                    .wrap_err("Could not decode rlp")?
269                    .to_string()
270            };
271            print_scalar(value)?;
272        }
273        CastSubcommand::Conversion(ConversionSubcommand::ToRlp { value }) => {
274            let value = stdin::unwrap_line(value)?;
275            let val =
276                serde_json::from_str(&value).unwrap_or_else(|_| serde_json::Value::String(value));
277            let item = crate::rlp_converter::Item::value_to_item(&val)?;
278            print_scalar(hex::encode_prefixed(encode(item)))?;
279        }
280        CastSubcommand::Conversion(ConversionSubcommand::ToHex(ToBaseArgs { value, base_in })) => {
281            let value = stdin::unwrap_line(value)?;
282            print_scalar(to_base(&value, base_in.as_deref(), "hex")?)?;
283        }
284        CastSubcommand::Conversion(ConversionSubcommand::ToDec(ToBaseArgs { value, base_in })) => {
285            let value = stdin::unwrap_line(value)?;
286            print_scalar(to_base(&value, base_in.as_deref(), "dec")?)?;
287        }
288        CastSubcommand::Conversion(ConversionSubcommand::ToBase {
289            base: ToBaseArgs { value, base_in },
290            base_out,
291        }) => {
292            let (value, base_out) = stdin::unwrap2(value, base_out)?;
293            print_scalar(to_base(&value, base_in.as_deref(), &base_out)?)?;
294        }
295        CastSubcommand::Conversion(ConversionSubcommand::ToBytes32 { bytes }) => {
296            let s = stdin::unwrap_line(bytes)?;
297            let s = strip_0x(&s);
298            if s.len() > 64 {
299                eyre::bail!("string >32 bytes");
300            }
301
302            let padded = format!("{s:0<64}");
303            print_scalar(padded.parse::<B256>()?.to_string())?;
304        }
305        CastSubcommand::Conversion(ConversionSubcommand::ToBytesMemory { data }) => {
306            let data = stdin::unwrap_line(data)?;
307            const WORD: usize = 32;
308
309            let data = hex::decode(data).wrap_err("Could not decode hex")?;
310            let padded_len = data.len().next_multiple_of(WORD);
311            let mut out = Vec::with_capacity(WORD + padded_len);
312            out.extend_from_slice(&U256::from(data.len()).to_be_bytes::<WORD>());
313            out.extend_from_slice(&data);
314            out.resize(WORD + padded_len, 0);
315            print_scalar(hex::encode_prefixed(out))?;
316        }
317        CastSubcommand::Conversion(ConversionSubcommand::Pad { data, right, left: _, len }) => {
318            let s = stdin::unwrap_line(data)?;
319            let s = strip_0x(&s);
320            let hex_len = len
321                .checked_mul(2)
322                .filter(|&h| h <= u16::MAX as usize)
323                .ok_or_else(|| eyre::eyre!("len out of range: {len}"))?;
324
325            // Validate input
326            if s.len() > hex_len {
327                eyre::bail!("input length exceeds target length");
328            }
329            if !s.chars().all(|c| c.is_ascii_hexdigit()) {
330                eyre::bail!("input is not a valid hex");
331            }
332
333            print_scalar(if right {
334                format!("0x{s:0<hex_len$}")
335            } else {
336                format!("0x{s:0>hex_len$}")
337            })?;
338        }
339        CastSubcommand::Conversion(ConversionSubcommand::FormatBytes32String { string }) => {
340            let s = stdin::unwrap_line(string)?;
341            let str_bytes: &[u8] = s.as_bytes();
342            eyre::ensure!(
343                str_bytes.len() <= 32,
344                "bytes32 strings must not exceed 32 bytes in length"
345            );
346
347            let mut bytes32: [u8; 32] = [0u8; 32];
348            bytes32[..str_bytes.len()].copy_from_slice(str_bytes);
349            print_scalar(hex::encode_prefixed(bytes32))?;
350        }
351        CastSubcommand::Conversion(ConversionSubcommand::ParseBytes32String { bytes }) => {
352            let s = stdin::unwrap_line(bytes)?;
353            let bytes = hex::decode(s)?;
354            eyre::ensure!(bytes.len() == 32, "expected 32 byte hex-string");
355            let len = bytes.iter().take_while(|x| **x != 0).count();
356            print_scalar(std::str::from_utf8(&bytes[..len])?)?;
357        }
358        CastSubcommand::Conversion(ConversionSubcommand::ParseBytes32Address { bytes }) => {
359            let s = stdin::unwrap_line(bytes)?;
360            let s = strip_0x(&s);
361            if s.len() != 64 {
362                eyre::bail!("expected 64 byte hex-string, got {s}");
363            }
364            let Some(s) = s.strip_prefix("000000000000000000000000") else {
365                eyre::bail!("Not convertible to address, there are non-zero bytes");
366            };
367            print_scalar(Address::from_str(s)?.to_checksum(None))?;
368        }
369
370        // ABI encoding & decoding
371        CastSubcommand::Abi(AbiSubcommand::DecodeAbi { sig, calldata, input }) => {
372            print_tokens(&abi_decode_calldata(&sig, &calldata, input, false)?)?;
373        }
374        CastSubcommand::Abi(AbiSubcommand::AbiEncode { sig, packed, args }) => {
375            let out = if packed {
376                // If the signature is a tuple, we need to prefix it to make it a function
377                let sig = if sig.trim_start().starts_with('(') { format!("foo{sig}") } else { sig };
378
379                let func = get_func(&sig)?;
380                let encoded = encode_function_args_packed(&func, &args).map_err(|e| {
381                    let e = with_trailing_flag_hint(e, func.inputs.len(), &args);
382                    eyre::eyre!("Could not ABI encode the function and arguments: {e}")
383                })?;
384                hex::encode_prefixed(encoded)
385            } else {
386                let func = get_func(&sig)?;
387                let encoded = encode_function_args_raw(&func, &args).map_err(|e| {
388                    let e = with_trailing_flag_hint(e, func.inputs.len(), &args);
389                    eyre::eyre!("Could not ABI encode the function and arguments: {e}")
390                })?;
391                hex::encode_prefixed(encoded)
392            };
393            print_scalar(out)?;
394        }
395        CastSubcommand::Abi(AbiSubcommand::AbiEncodeEvent { sig, args }) => {
396            let event = get_event(&sig)?;
397            if event.inputs.len() != args.len() {
398                let err = eyre::eyre!(
399                    "encode length mismatch: expected {} types, got {}",
400                    event.inputs.len(),
401                    args.len(),
402                );
403                return Err(with_trailing_flag_hint(err, event.inputs.len(), &args));
404            }
405
406            let types = event
407                .inputs
408                .iter()
409                .map(Specifier::<DynSolType>::resolve)
410                .collect::<Result<Vec<_>, _>>()?;
411            let tokens = std::iter::zip(&types, &args)
412                .map(|(ty, arg)| Ok(DynSolType::coerce_str(ty, arg.as_ref())?))
413                .collect::<Result<Vec<_>>>()?;
414
415            let mut topics = if event.anonymous { vec![] } else { vec![event.selector()] };
416            // Non-indexed parameters are encoded together as the event body.
417            let mut data_tokens = Vec::new();
418            for (input, token) in event.inputs.iter().zip(tokens) {
419                if input.indexed {
420                    topics.push(encode_event_topic(&token));
421                } else {
422                    data_tokens.push(token);
423                }
424            }
425
426            let data = DynSolValue::Tuple(data_tokens).abi_encode_params();
427            let log_data = LogData::new_unchecked(topics, data.into());
428            if shell::is_json() {
429                #[derive(serde::Serialize)]
430                struct EncodedEvent {
431                    topics: Vec<String>,
432                    data: String,
433                }
434                print_json_object(EncodedEvent {
435                    topics: log_data.topics().iter().map(|t| t.to_string()).collect(),
436                    data: hex::encode_prefixed(&log_data.data),
437                })?;
438            } else {
439                for (i, topic) in log_data.topics().iter().enumerate() {
440                    sh_println!("[topic{i}]: {topic}")?;
441                }
442                if !log_data.data.is_empty() {
443                    sh_println!("[data]: {}", hex::encode_prefixed(log_data.data))?;
444                }
445            }
446        }
447        CastSubcommand::Abi(AbiSubcommand::DecodeCalldata { sig, calldata, file }) => {
448            let raw_hex = match file {
449                Some(file_path) => fs::read_to_string(&file_path)?.trim().to_string(),
450                None => calldata.unwrap(),
451            };
452            print_tokens(&abi_decode_calldata(&sig, &raw_hex, true, true)?)?;
453        }
454        CastSubcommand::Abi(AbiSubcommand::CalldataEncode { sig, args, file }) => {
455            let func = get_func(&sig)?;
456            let encoded = match file {
457                Some(file_path) => {
458                    let args = fs::read_to_string(file_path)?
459                        .lines()
460                        .map(str::trim)
461                        .filter(|line| !line.is_empty())
462                        .map(String::from)
463                        .collect::<Vec<_>>();
464                    encode_function_args(&func, &args)?
465                }
466                None => encode_function_args(&func, &args)
467                    .map_err(|e| with_trailing_flag_hint(e, func.inputs.len(), &args))?,
468            };
469            print_scalar(hex::encode_prefixed(encoded))?;
470        }
471        CastSubcommand::Abi(AbiSubcommand::DecodeString { data }) => {
472            print_tokens(&abi_decode_calldata("Any(string)", &data, true, true)?)?;
473        }
474        CastSubcommand::Abi(AbiSubcommand::DecodeEvent { sig, data, topics }) => {
475            let decoded_values = if let Some(event_sig) = sig {
476                let event = get_event(&event_sig)?;
477                let data = hex::decode(data)?;
478                if topics.is_empty() {
479                    abi_decode_event_data(&event, &data)?
480                } else {
481                    let decoded = event.decode_log_parts(topics, &data)?;
482                    let mut indexed = decoded.indexed.into_iter();
483                    let mut body = decoded.body.into_iter();
484                    event
485                        .inputs
486                        .iter()
487                        .map(|input| {
488                            if input.indexed { indexed.next() } else { body.next() }
489                                .expect("decoded event has a value for each input")
490                        })
491                        .collect()
492                }
493            } else {
494                let data = strip_0x(&data);
495                let selector: B256 = data.get(..64).unwrap_or_default().parse()?;
496                let Some(event) = SignaturesIdentifier::new(false)?.identify_event(selector).await
497                else {
498                    eyre::bail!("No matching event signature found for selector `{selector}`");
499                };
500                // Keep `--json` stdout a single JSON document.
501                if shell::is_json() {
502                    let _ = sh_eprintln!("{}", event.signature());
503                } else {
504                    let _ = sh_println!("{}", event.signature());
505                }
506                let expected = event.selector();
507                eyre::ensure!(
508                    expected == selector,
509                    alloy_dyn_abi::Error::EventSignatureMismatch { expected, actual: selector }
510                );
511                let data = hex::decode(data.get(64..).unwrap_or_default())?;
512                // Indexed parameters are not in DATA, but logs sharing a topic0 can index different
513                // parameters, like ERC-20 and ERC-721 `Transfer`. Keep the cached indexed flags
514                // only if the non-indexed parameters account for all of DATA, otherwise decode
515                // every parameter from DATA.
516                match abi_decode_event_data(&event, &data) {
517                    Ok(values)
518                        if DynSolValue::Tuple(values.clone()).abi_encode_params().len()
519                            == data.len() =>
520                    {
521                        values
522                    }
523                    _ => abi_decode_event_data(&get_event(&event.signature())?, &data)?,
524                }
525            };
526            print_tokens(&decoded_values)?;
527        }
528        CastSubcommand::Abi(AbiSubcommand::DecodeError { sig, data }) => {
529            let error = if let Some(err_sig) = sig {
530                get_error(&err_sig)?
531            } else {
532                let data = strip_0x(&data);
533                let selector = data.get(..8).unwrap_or_default();
534                let Some(error) =
535                    SignaturesIdentifier::new(false)?.identify_error(selector.parse()?).await
536                else {
537                    eyre::bail!("No matching error signature found for selector `{selector}`");
538                };
539                // Keep `--json` stdout a single JSON document.
540                if shell::is_json() {
541                    let _ = sh_eprintln!("{}", error.signature());
542                } else {
543                    let _ = sh_println!("{}", error.signature());
544                }
545                error
546            };
547            print_tokens(&error.decode_error(&hex::decode(data)?)?.body)?;
548        }
549        CastSubcommand::Abi(AbiSubcommand::Interface(cmd)) => cmd.run().await?,
550        CastSubcommand::Abi(AbiSubcommand::CreationCode(cmd)) => cmd.run().await?,
551        CastSubcommand::Abi(AbiSubcommand::ConstructorArgs(cmd)) => cmd.run().await?,
552        CastSubcommand::Abi(AbiSubcommand::Artifact(cmd)) => cmd.run().await?,
553        CastSubcommand::Abi(AbiSubcommand::Bind(cmd)) => cmd.run().await?,
554        CastSubcommand::Abi(AbiSubcommand::B2EPayload(cmd)) => cmd.run().await?,
555        CastSubcommand::Abi(AbiSubcommand::PrettyCalldata { calldata, offline }) => {
556            let calldata = stdin::unwrap_line(calldata)?;
557            print_scalar(pretty_calldata(&calldata, offline).await?.to_string())?;
558        }
559        // JSON: --optimize conflicts with --json at the clap level; optimize=None uses print_scalar
560        CastSubcommand::Abi(AbiSubcommand::Sig { sig, optimize }) => {
561            let sig = stdin::unwrap_line(sig)?;
562            match optimize {
563                Some(opt) => {
564                    sh_status!("Starting to optimize signature...")?;
565                    let start_time = Instant::now();
566                    let (selector, signature) = get_selector(&sig, opt)?;
567                    sh_status!("Successfully generated in {:?}", start_time.elapsed())?;
568                    sh_println!("Selector: {selector}")?;
569                    sh_println!("Optimized signature: {signature}")?;
570                }
571                None => print_scalar(get_selector(&sig, 0)?.0)?,
572            }
573        }
574
575        // Blockchain & RPC queries
576        CastSubcommand::Query(QuerySubcommand::AccessList(cmd)) => cmd.run().await?,
577        CastSubcommand::Query(QuerySubcommand::Age { block, rpc }) => {
578            let timestamp = rpc_provider(&rpc)?
579                .get_block(block.unwrap_or_default())
580                .await?
581                .ok_or_eyre("block not found")?
582                .header
583                .timestamp;
584            let age = i64::try_from(timestamp)
585                .ok()
586                .and_then(|timestamp| chrono::DateTime::from_timestamp(timestamp, 0))
587                .ok_or_eyre("invalid timestamp")?
588                .format("%a %b %e %H:%M:%S %Y");
589            print_scalar(format!("{age} UTC"))?;
590        }
591        CastSubcommand::Query(QuerySubcommand::Balance {
592            block,
593            who,
594            ether,
595            rpc,
596            erc20,
597            overrides,
598        }) => {
599            if erc20.is_none() && !overrides.is_empty() {
600                eyre::bail!("call overrides require `--erc20` when using `cast balance`");
601            }
602            let (provider, account_addr) = rpc_provider_and_address(&rpc, who).await?;
603
604            match erc20 {
605                Some(token) => {
606                    let token = IERC20::new(token, &provider);
607                    let balance_call =
608                        token.balanceOf(account_addr).block(block.unwrap_or_default());
609                    let balance = overrides.apply(balance_call.call())?.await?;
610
611                    sh_warn!("--erc20 flag is deprecated, use `cast erc20 balance` instead")?;
612                    print_scalar(format_uint_exp(balance))?;
613                }
614                None => {
615                    let value = provider
616                        .get_balance(account_addr)
617                        .block_id(block.unwrap_or_default())
618                        .await?;
619                    let out = if ether {
620                        ParseUnits::U256(value).format_units(Unit::ETHER)
621                    } else {
622                        value.to_string()
623                    };
624                    print_scalar(out)?;
625                }
626            }
627        }
628        CastSubcommand::Query(QuerySubcommand::BaseFee { block, rpc }) => {
629            let fee = rpc_provider(&rpc)?
630                .get_block(block.unwrap_or_default())
631                .await?
632                .ok_or_eyre("block not found")?
633                .header
634                .base_fee_per_gas
635                .ok_or_eyre("base fee not found")?;
636            print_scalar(fee.to_string())?;
637        }
638        CastSubcommand::Query(QuerySubcommand::Block {
639            block,
640            full,
641            fields,
642            raw,
643            rpc,
644            network,
645        }) => {
646            let config = rpc.load_config()?;
647            #[cfg(feature = "base")]
648            let network = if network.is_none() && (raw || fields.iter().any(|f| f == "raw")) {
649                crate::cmd::resolve_transaction_network(&config, false)
650                    .await?
651                    .is_base()
652                    .then_some(NetworkVariant::Base)
653            } else {
654                network
655            };
656            let block = block.unwrap_or_default();
657            // Can use either --raw or specify raw as a field
658            let output = if raw || fields.contains(&"raw".into()) {
659                with_network_provider!(
660                    network,
661                    &config,
662                    ProviderBuilder::<Ethereum>::from_config(&config)?.build()?,
663                    |provider, N| {
664                        let block_id = block;
665                        let block = provider
666                            .get_block(block_id)
667                            .kind(full.into())
668                            .await?
669                            .ok_or_else(|| eyre::eyre!("block {:?} not found", block_id))?;
670                        hex::encode_prefixed(alloy_rlp::encode(
671                            AsRef::<<N as Network>::Header>::as_ref(block.header()),
672                        ))
673                    }
674                )
675            } else {
676                let provider = utils::get_provider(&config)?;
677                if fields.contains(&"transactions".into()) && !full {
678                    eyre::bail!("use --full to view transactions");
679                }
680
681                let block = provider
682                    .get_block(block)
683                    .kind(full.into())
684                    .await?
685                    .ok_or_else(|| eyre::eyre!("block {:?} not found", block))?;
686
687                if !fields.is_empty() {
688                    let mut result = String::new();
689                    for field in fields {
690                        result.push_str(
691                            &get_pretty_block_attr::<alloy_network::AnyNetwork>(&block, &field)
692                                .unwrap_or_else(|| format!("{field} is not a valid block field")),
693                        );
694
695                        result.push('\n');
696                    }
697                    result.trim_end().to_string()
698                } else if shell::is_json() {
699                    serde_json::to_value(&block).unwrap().to_string()
700                } else {
701                    block.pretty()
702                }
703            };
704            print_json_value_or_scalar(output)?;
705        }
706        CastSubcommand::Query(QuerySubcommand::BlockNumber { rpc, block }) => {
707            let provider = rpc_provider(&rpc)?;
708            let number = match block {
709                Some(id) => {
710                    provider
711                        .get_block(id)
712                        .await?
713                        .ok_or_else(|| eyre::eyre!("block {id:?} not found"))?
714                        .header
715                        .number
716                }
717                None => provider.get_block_number().await?,
718            };
719            print_scalar(number)?;
720        }
721        CastSubcommand::Query(QuerySubcommand::Bal(cmd)) => cmd.run().await?,
722        CastSubcommand::Query(QuerySubcommand::Chain { rpc }) => {
723            let provider = rpc_provider(&rpc)?;
724            const GENESIS_CHAINS: &[(&str, &str)] = &[
725                ("0xa3c565fc15c7478862d50ccd6561e3c06b24cc509bf388941c25ea985ce32cb9", "kovan"),
726                ("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d", "ropsten"),
727                (
728                    "0x7ca38a1916c42007829c55e69d3e9a73265554b586a499015373241b8a3fa48b",
729                    "optimism-mainnet",
730                ),
731                (
732                    "0xc1fc15cd51159b1f1e5cbc4b82e85c1447ddfa33c52cf1d98d14fba0d6354be1",
733                    "optimism-goerli",
734                ),
735                (
736                    "0x02adc9b449ff5f2467b8c674ece7ff9b21319d76c4ad62a67a70d552655927e5",
737                    "optimism-kovan",
738                ),
739                ("0x521982bd54239dc71269eefb58601762cc15cfb2978e0becb46af7962ed6bfaa", "fraxtal"),
740                (
741                    "0x910f5c4084b63fd860d0c2f9a04615115a5a991254700b39ba072290dbd77489",
742                    "fraxtal-testnet",
743                ),
744                (
745                    "0x7ee576b35482195fc49205cec9af72ce14f003b9ae69f6ba0faef4514be8b442",
746                    "arbitrum-mainnet",
747                ),
748                ("0x0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303", "morden"),
749                ("0x6341fd3daf94b748c72ced5a5b26028f2474f5f00d824504e4fa37a75767e177", "rinkeby"),
750                ("0xbf7e331f7f7c1dd2e05159666b3bf8bc7a8a3a9eb1d518969eab529dd9b88c1a", "goerli"),
751                ("0x14c2283285a88fe5fce9bf5c573ab03d6616695d717b12a127188bcacfc743c4", "kotti"),
752                (
753                    "0xa9c28ce2141b56c474f1dc504bee9b01eb1bd7d1a507580d5519d4437a97de1b",
754                    "polygon-pos",
755                ),
756                (
757                    "0x7202b2b53c5a0836e773e319d18922cc756dd67432f9a1f65352b61f4406c697",
758                    "polygon-pos-amoy-testnet",
759                ),
760                (
761                    "0x81005434635456a16f74ff7023fbe0bf423abbc8a8deb093ffff455c0ad3b741",
762                    "polygon-zkevm",
763                ),
764                (
765                    "0x676c1a76a6c5855a32bdf7c61977a0d1510088a4eeac1330466453b3d08b60b9",
766                    "polygon-zkevm-cardona-testnet",
767                ),
768                ("0x4f1dd23188aab3a76b463e4af801b52b1248ef073c648cbdc4c9333d3da79756", "gnosis"),
769                ("0xada44fd8d2ecab8b08f256af07ad3e777f17fb434f8f8e678b312f576212ba9a", "chiado"),
770                ("0x6d3c66c5357ec91d5c43af47e234a939b22557cbb552dc45bebbceeed90fbe34", "bsctest"),
771                ("0x0d21840abff46b96c84b2ac9e10e4f5cdaeb5693cb665db62a2f3b02d2d57b5b", "bsc"),
772                ("0x23a2658170ba70d014ba0d0d2709f8fbfe2fa660cd868c5f282f991eecbe38ee", "ink"),
773                (
774                    "0xe5fd5cf0be56af58ad5751b401410d6b7a09d830fa459789746a3d0dd1c79834",
775                    "ink-sepolia",
776                ),
777            ];
778
779            let genesis_hash = provider
780                .get_block_by_number(0.into())
781                .await?
782                .ok_or_eyre("block not found")?
783                .header
784                .hash
785                .to_string();
786            let chain = match genesis_hash.as_str() {
787                // Ethereum and Ethereum Classic share the genesis block and split at the DAO fork.
788                "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3" => {
789                    match provider
790                        .get_block_by_number(1920000.into())
791                        .await?
792                        .ok_or_eyre("block not found")?
793                        .header
794                        .hash
795                        .to_string()
796                        .as_str()
797                    {
798                        "0x94365e3a8c0b35089c1d1195081fe7489b528a84b22199c916180db8b28ade7f" => {
799                            "etclive"
800                        }
801                        _ => "ethlive",
802                    }
803                }
804                // Avalanche and Fuji share the genesis block.
805                "0x31ced5b9beb7f8782b014660da0cb18cc409f121f408186886e1ca3e8eeca96b" => {
806                    match provider
807                        .get_block_by_number(1.into())
808                        .await?
809                        .ok_or_eyre("block not found")?
810                        .header
811                        .hash
812                        .to_string()
813                        .as_str()
814                    {
815                        "0x738639479dc82d199365626f90caa82f7eafcfe9ed354b456fb3d294597ceb53" => {
816                            "avalanche-fuji"
817                        }
818                        _ => "avalanche",
819                    }
820                }
821                hash => GENESIS_CHAINS
822                    .iter()
823                    .find(|(genesis, _)| *genesis == hash)
824                    .map_or("unknown", |(_, chain)| chain),
825            };
826            print_scalar(chain)?;
827        }
828        CastSubcommand::Query(QuerySubcommand::ChainId { rpc }) => {
829            print_scalar(rpc_provider(&rpc)?.get_chain_id().await?.to_string())?;
830        }
831        CastSubcommand::Query(QuerySubcommand::Client { rpc }) => {
832            print_scalar(rpc_provider(&rpc)?.get_client_version().await?)?;
833        }
834        CastSubcommand::Query(QuerySubcommand::Code { block, who, disassemble, rpc }) => {
835            let (provider, who) = rpc_provider_and_address(&rpc, who).await?;
836            let code = provider.get_code_at(who).block_id(block.unwrap_or_default()).await?;
837            print_scalar(if disassemble {
838                crate::cmd::disassemble(&code)?
839            } else {
840                code.to_string()
841            })?;
842        }
843        CastSubcommand::Query(QuerySubcommand::Codesize { block, who, rpc }) => {
844            let (provider, who) = rpc_provider_and_address(&rpc, who).await?;
845            print_scalar(
846                provider
847                    .get_code_at(who)
848                    .block_id(block.unwrap_or_default())
849                    .await?
850                    .len()
851                    .to_string(),
852            )?;
853        }
854        CastSubcommand::Query(QuerySubcommand::ComputeAddress {
855            address,
856            nonce,
857            salt,
858            init_code,
859            init_code_hash,
860            rpc,
861        }) => {
862            let address = stdin::unwrap_line(address)?;
863            let salt = salt.unwrap_or(B256::ZERO);
864            let computed = if let Some(init_code_hash) = init_code_hash {
865                address.create2(salt, init_code_hash)
866            } else if let Some(init_code) = init_code {
867                address.create2(salt, keccak256(hex::decode(init_code)?))
868            } else {
869                // CREATE addresses depend on the deployer nonce, which is fetched over RPC.
870                let nonce = match nonce {
871                    Some(nonce) => nonce,
872                    None => rpc_provider(&rpc)?.get_transaction_count(address).await?,
873                };
874                address.create(nonce)
875            };
876            print_scalar(computed.to_checksum(None))?;
877        }
878        CastSubcommand::Query(QuerySubcommand::Disassemble { bytecode }) => {
879            let bytecode = stdin::unwrap_line(bytecode)?;
880            print_scalar(crate::cmd::disassemble(&hex::decode(bytecode)?)?)?;
881        }
882        CastSubcommand::Query(QuerySubcommand::Selectors { bytecode, resolve }) => {
883            let bytecode = stdin::unwrap_line(bytecode)?;
884            let code = hex::decode(&bytecode)?;
885            let info = evmole::contract_info(
886                evmole::ContractInfoArgs::new(&code)
887                    .with_selectors()
888                    .with_arguments()
889                    .with_state_mutability(),
890            );
891            let functions = info
892                .functions
893                .expect("functions extraction was requested")
894                .into_iter()
895                .filter(|f| f.dispatch == evmole::SelectorDispatch::Abi)
896                .map(|f| {
897                    let arguments = f
898                        .arguments
899                        .expect("arguments extraction was requested")
900                        .iter()
901                        .map(|t| t.sol_type_name())
902                        .collect::<Vec<_>>()
903                        .join(",");
904                    let mutability =
905                        f.state_mutability.expect("state_mutability extraction was requested");
906                    (
907                        alloy_primitives::Selector::from(f.selector),
908                        arguments,
909                        mutability.as_json_str(),
910                    )
911                })
912                .collect::<Vec<_>>();
913
914            let resolve_results: Vec<String> = if resolve {
915                let selectors = functions
916                    .iter()
917                    .map(|&(selector, ..)| SelectorKind::Function(selector))
918                    .collect::<Vec<_>>();
919                let ds = decode_selectors(&selectors).await?;
920                ds.into_iter().map(|v| v.join("|")).collect()
921            } else {
922                vec![]
923            };
924
925            if shell::is_json() {
926                #[derive(serde::Serialize)]
927                struct SelectorInfo {
928                    selector: String,
929                    arguments: String,
930                    state_mutability: String,
931                    #[serde(skip_serializing_if = "Option::is_none")]
932                    resolved: Option<String>,
933                }
934                let infos = functions
935                    .into_iter()
936                    .enumerate()
937                    .map(|(pos, (selector, arguments, state_mutability))| SelectorInfo {
938                        selector: selector.to_string(),
939                        arguments,
940                        state_mutability: state_mutability.to_string(),
941                        resolved: resolve_results.get(pos).cloned(),
942                    })
943                    .collect::<Vec<_>>();
944                print_json_object(infos)?;
945            } else {
946                let max_args_len = functions.iter().map(|r| r.1.len()).max().unwrap_or(0);
947                let max_mutability_len = functions.iter().map(|r| r.2.len()).max().unwrap_or(0);
948                for (pos, (selector, arguments, state_mutability)) in
949                    functions.into_iter().enumerate()
950                {
951                    if resolve {
952                        let resolved = &resolve_results[pos];
953                        sh_println!(
954                            "{selector}\t{arguments:max_args_len$}\t{state_mutability:max_mutability_len$}\t{resolved}"
955                        )?
956                    } else {
957                        sh_println!("{selector}\t{arguments:max_args_len$}\t{state_mutability}")?
958                    }
959                }
960            }
961        }
962        CastSubcommand::Query(QuerySubcommand::FindBlock(cmd)) => cmd.run().await?,
963        CastSubcommand::Query(QuerySubcommand::GasPrice { rpc }) => {
964            print_scalar(rpc_provider(&rpc)?.get_gas_price().await?.to_string())?;
965        }
966        CastSubcommand::Query(QuerySubcommand::Index { key_type, key, slot_number }) => {
967            let mut hasher = Keccak256::new();
968
969            let k_ty = DynSolType::parse(&key_type).wrap_err("Could not parse type")?;
970            let k = k_ty.coerce_str(&key).wrap_err("Could not parse value")?;
971            match k_ty {
972                // For value types, `h` pads the value to 32 bytes in the same way as when storing
973                // the value in memory.
974                DynSolType::Bool
975                | DynSolType::Int(_)
976                | DynSolType::Uint(_)
977                | DynSolType::FixedBytes(_)
978                | DynSolType::Address
979                | DynSolType::Function => hasher.update(k.as_word().unwrap()),
980
981                // For strings and byte arrays, `h(k)` is just the unpadded data.
982                DynSolType::String | DynSolType::Bytes => hasher.update(k.as_packed_seq().unwrap()),
983
984                DynSolType::Array(..)
985                | DynSolType::FixedArray(..)
986                | DynSolType::Tuple(..)
987                | DynSolType::CustomStruct { .. } => {
988                    eyre::bail!("Type `{k_ty}` is not supported as a mapping key");
989                }
990            }
991
992            let p = DynSolType::Uint(256)
993                .coerce_str(&slot_number)
994                .wrap_err("Could not parse slot number")?;
995            let p = p.as_word().unwrap();
996            hasher.update(p);
997
998            let location = hasher.finalize();
999            print_scalar(location.to_string())?;
1000        }
1001        CastSubcommand::Query(QuerySubcommand::IndexErc7201 { id, formula_id }) => {
1002            eyre::ensure!(formula_id == "erc7201", "unsupported formula ID: {formula_id}");
1003            let id = stdin::unwrap_line(id)?;
1004            print_scalar(foundry_common::erc7201(&id).to_string())?;
1005        }
1006        CastSubcommand::Query(QuerySubcommand::Implementation { block, beacon, who, rpc }) => {
1007            let (provider, who) = rpc_provider_and_address(&rpc, who).await?;
1008            let slot = if beacon { EIP1967_BEACON_SLOT } else { EIP1967_IMPLEMENTATION_SLOT };
1009            print_scalar(address_at_slot(&provider, who, slot, block).await?)?;
1010        }
1011        CastSubcommand::Query(QuerySubcommand::Admin { block, who, rpc }) => {
1012            let (provider, who) = rpc_provider_and_address(&rpc, who).await?;
1013            print_scalar(address_at_slot(&provider, who, EIP1967_ADMIN_SLOT, block).await?)?;
1014        }
1015        CastSubcommand::Query(QuerySubcommand::Nonce { block, who, rpc }) => {
1016            let (provider, who) = rpc_provider_and_address(&rpc, who).await?;
1017            print_scalar(
1018                provider.get_transaction_count(who).block_id(block.unwrap_or_default()).await?,
1019            )?;
1020        }
1021        CastSubcommand::Query(QuerySubcommand::Codehash { block, who, slots, rpc }) => {
1022            let (provider, who) = rpc_provider_and_address(&rpc, who).await?;
1023            print_scalar(
1024                provider
1025                    .get_proof(who, slots)
1026                    .block_id(block.unwrap_or_default())
1027                    .await?
1028                    .code_hash
1029                    .to_string(),
1030            )?;
1031        }
1032        CastSubcommand::Query(QuerySubcommand::StorageRoot { block, who, slots, rpc }) => {
1033            let (provider, who) = rpc_provider_and_address(&rpc, who).await?;
1034            print_scalar(
1035                provider
1036                    .get_proof(who, slots)
1037                    .block_id(block.unwrap_or_default())
1038                    .await?
1039                    .storage_hash
1040                    .to_string(),
1041            )?;
1042        }
1043        CastSubcommand::Query(QuerySubcommand::ChannelId {
1044            payer,
1045            payee,
1046            token,
1047            salt,
1048            operator,
1049            authorized_signer,
1050            expiring_nonce_hash,
1051            reserve,
1052            block,
1053            rpc,
1054        }) => {
1055            let provider = rpc_provider(&rpc)?;
1056            let payer = payer.resolve(&provider).await?;
1057            let payee = payee.resolve(&provider).await?;
1058            let token = token.resolve(&provider).await?;
1059            let operator = resolve_or(operator, Address::ZERO, &provider).await?;
1060            let authorized_signer = resolve_or(authorized_signer, Address::ZERO, &provider).await?;
1061            let reserve = resolve_or(reserve, TIP20_CHANNEL_RESERVE_ADDRESS, &provider).await?;
1062
1063            let channel_id = ITIP20ChannelReserve::new(reserve, &provider)
1064                .computeChannelId(
1065                    payer,
1066                    payee,
1067                    operator,
1068                    token,
1069                    salt,
1070                    authorized_signer,
1071                    expiring_nonce_hash,
1072                )
1073                .block(block.unwrap_or_default())
1074                .call()
1075                .await?;
1076            print_scalar(format!("{channel_id:#x}"))?;
1077        }
1078        CastSubcommand::Query(QuerySubcommand::Proof { address, slots, rpc, block }) => {
1079            let (provider, address) = rpc_provider_and_address(&rpc, address).await?;
1080            let value =
1081                provider.get_proof(address, slots).block_id(block.unwrap_or_default()).await?;
1082            print_json_object(value)?;
1083        }
1084        CastSubcommand::Query(QuerySubcommand::Rpc(cmd)) => cmd.run().await?,
1085        CastSubcommand::Query(QuerySubcommand::Storage(cmd)) => cmd.run().await?,
1086
1087        // Calls & transactions
1088        CastSubcommand::Transaction(TransactionSubcommand::Call(cmd)) => cmd.run().await?,
1089        CastSubcommand::Transaction(TransactionSubcommand::Estimate(cmd)) => cmd.run().await?,
1090        CastSubcommand::Transaction(TransactionSubcommand::MakeTx(cmd)) => cmd.run().await?,
1091        CastSubcommand::Transaction(TransactionSubcommand::PublishTx {
1092            raw_tx,
1093            cast_async,
1094            rpc,
1095        }) => {
1096            let provider = rpc_provider(&rpc)?;
1097            let raw_tx = hex::decode(strip_0x(&raw_tx))?;
1098            let pending_tx = provider.send_raw_transaction(&raw_tx).await?;
1099            if cast_async {
1100                print_scalar(format!("{:#x}", pending_tx.inner().tx_hash()))?;
1101            } else {
1102                print_json_object(pending_tx.get_receipt().await?)?;
1103            }
1104        }
1105        CastSubcommand::Transaction(TransactionSubcommand::Receipt {
1106            tx_hash,
1107            field,
1108            cast_async,
1109            confirmations,
1110            rpc,
1111        }) => {
1112            // JSON: The receipt helper already formats the output.
1113            sh_println!(
1114                "{}",
1115                CastTxSender::new(rpc_provider(&rpc)?)
1116                    .receipt(tx_hash, field, confirmations, None, cast_async)
1117                    .await?
1118            )?
1119        }
1120        CastSubcommand::Transaction(TransactionSubcommand::Run(cmd)) => cmd.run().await?,
1121        CastSubcommand::Transaction(TransactionSubcommand::SendTx(cmd)) => cmd.run().await?,
1122        CastSubcommand::Transaction(TransactionSubcommand::BatchMakeTx(cmd)) => cmd.run().await?,
1123        CastSubcommand::Transaction(TransactionSubcommand::BatchSend(cmd)) => cmd.run().await?,
1124        CastSubcommand::Transaction(TransactionSubcommand::Classify { raw_tx }) => {
1125            let raw_tx = hex::decode(stdin::unwrap_line(raw_tx)?)?;
1126            let out = format_lane_classification(&raw_tx, "failed to decode raw transaction")?;
1127            print_json_value_or_scalar(out)?
1128        }
1129        CastSubcommand::Transaction(TransactionSubcommand::Tx {
1130            tx_hash,
1131            from,
1132            nonce,
1133            field,
1134            raw,
1135            lane,
1136            rpc,
1137            to_request,
1138            network,
1139        }) => {
1140            let config = rpc.load_config()?;
1141            #[cfg(feature = "base")]
1142            let network = match network {
1143                Some(network) => Some(network),
1144                None => crate::cmd::resolve_transaction_network(&config, false)
1145                    .await?
1146                    .is_base()
1147                    .then_some(NetworkVariant::Base),
1148            };
1149            // Can use either --raw or specify raw as a field
1150            let is_raw = raw || field.as_deref() == Some("raw");
1151            let output = if is_raw || lane {
1152                let encoded: Bytes = with_network_provider!(
1153                    network,
1154                    &config,
1155                    |provider| {
1156                        let tx =
1157                            transaction_response(&provider, tx_hash, from, nonce).await?;
1158                        tx.as_ref().encoded_2718().into()
1159                    },
1160                    _ => {
1161                        let provider = utils::get_provider(&config)?;
1162                        let tx =
1163                            transaction_response(&provider, tx_hash, from, nonce).await?;
1164                        FoundryTxEnvelope::encode_rpc_2718(&tx).wrap_err_with(|| {
1165                            format!("Cannot EIP-2718 encode transaction type 0x{:x}", tx.ty())
1166                        })?
1167                    }
1168                );
1169                if lane {
1170                    format_lane_classification(
1171                        &encoded,
1172                        "failed to decode transaction for lane classification",
1173                    )?
1174                } else {
1175                    hex::encode_prefixed(encoded)
1176                }
1177            } else {
1178                with_network_provider!(
1179                    network,
1180                    &config,
1181                    utils::get_provider(&config)?,
1182                    |provider| {
1183                        let tx = transaction_response(&provider, tx_hash, from, nonce).await?;
1184                        format_transaction(&provider, tx, field, to_request)?
1185                    }
1186                )
1187            };
1188            print_json_value_or_scalar(output)?;
1189        }
1190
1191        // 4Byte
1192        CastSubcommand::Abi(AbiSubcommand::FourByte { selector }) => {
1193            let selector = stdin::unwrap_line(selector)?;
1194            let sigs = with_local_first(
1195                local_function_signature(selector).await?,
1196                decode_function_selector(selector).await,
1197            )?;
1198            if sigs.is_empty() {
1199                eyre::bail!("No matching function signatures found for selector `{selector}`");
1200            }
1201            print_list(&sigs)?;
1202        }
1203
1204        // JSON envelope intentionally unsupported: output combines an interactive selector
1205        // disambiguation step with decoded token output; no single stable shape exists.
1206        CastSubcommand::Abi(AbiSubcommand::FourByteCalldata { calldata }) => {
1207            let calldata = stdin::unwrap_line(calldata)?;
1208
1209            if calldata.len() == 10 {
1210                let selector = calldata.parse()?;
1211                let sigs = with_local_first(
1212                    local_function_signature(selector).await?,
1213                    decode_function_selector(selector).await,
1214                )?;
1215                if sigs.is_empty() {
1216                    eyre::bail!("No matching function signatures found for calldata `{calldata}`");
1217                }
1218                for sig in sigs {
1219                    sh_println!("{sig}")?
1220                }
1221                return Ok(());
1222            }
1223
1224            let local = match strip_0x(&calldata).get(..8).map(str::parse::<Selector>) {
1225                // Library types such as `L.S` parse as `uint8`, so a signature whose parsed form
1226                // has another selector is used only if decoding with that form loses nothing.
1227                Some(Ok(selector)) => local_function_signature(selector).await?.filter(|sig| {
1228                    abi_decode_calldata(sig, &calldata, true, true).is_ok_and(|values| {
1229                        get_func(sig).is_ok_and(|f| f.selector() == selector)
1230                            || hex::decode(&calldata).is_ok_and(|data| {
1231                                DynSolValue::Tuple(values).abi_encode_params() == data[4..]
1232                            })
1233                    })
1234                }),
1235                _ => None,
1236            };
1237            let sigs = with_local_first(local, decode_calldata(&calldata).await)?;
1238            for (i, sig) in sigs.iter().enumerate() {
1239                let _ = sh_println!("{}) \"{sig}\"", i + 1);
1240            }
1241
1242            let sig = match sigs.len() {
1243                0 => eyre::bail!("No signatures found"),
1244                1 => &sigs[0],
1245                _ => {
1246                    let i: usize = prompt!("Select a function signature by number: ")?;
1247                    sigs.get(i - 1).ok_or_else(|| eyre::eyre!("Invalid signature index"))?
1248                }
1249            };
1250
1251            print_tokens(&abi_decode_calldata(sig, &calldata, true, true)?)?;
1252        }
1253
1254        CastSubcommand::Abi(AbiSubcommand::FourByteEvent { topic }) => {
1255            let topic = stdin::unwrap_line(topic)?;
1256            let local = SignaturesIdentifier::new(true)?.identify_event(topic).await;
1257            // Drop cached signatures whose parsed form hashes to another topic.
1258            let sigs = with_local_first(
1259                local.filter(|event| event.selector() == topic).map(|event| event.signature()),
1260                decode_event_topic(topic).await,
1261            )?;
1262            if sigs.is_empty() {
1263                eyre::bail!("No matching event signatures found for topic `{topic}`");
1264            }
1265            print_list(&sigs)?;
1266        }
1267        // JSON envelope intentionally unsupported: output is a human-readable summary from an
1268        // external selector registry API with no stable machine-readable schema.
1269        CastSubcommand::Abi(AbiSubcommand::UploadSignature { signatures }) => {
1270            let signatures = stdin::unwrap_vec(signatures)?;
1271            let ParsedSignatures { signatures, abis } = parse_signatures(signatures);
1272            if !abis.is_empty() {
1273                import_selectors(SelectorImportData::Abi(abis)).await?.describe();
1274            }
1275            if !signatures.is_empty() {
1276                import_selectors(SelectorImportData::Raw(signatures)).await?.describe();
1277            }
1278        }
1279
1280        // ENS
1281        CastSubcommand::Query(QuerySubcommand::Namehash { name }) => {
1282            print_scalar(namehash(&stdin::unwrap_line(name)?).to_string())?;
1283        }
1284        CastSubcommand::Query(QuerySubcommand::LookupAddress { who, rpc, verify }) => {
1285            let provider = rpc_provider(&rpc)?;
1286            let who = stdin::unwrap_line(who)?;
1287            let name = provider.lookup_address(&who).await?;
1288            if verify {
1289                let address = provider.resolve_name(&name).await?;
1290                eyre::ensure!(
1291                    address == who,
1292                    "Reverse lookup verification failed: got `{address}`, expected `{who}`"
1293                );
1294            }
1295            print_scalar(name)?;
1296        }
1297        CastSubcommand::Query(QuerySubcommand::ResolveName { who, rpc, verify }) => {
1298            let provider = rpc_provider(&rpc)?;
1299            let who = stdin::unwrap_line(who)?;
1300            let address = provider
1301                .resolve_name(&who)
1302                .await
1303                .wrap_err(format!("Failed to resolve ENS name: {who}"))?;
1304            if verify {
1305                let name = provider.lookup_address(&address).await?;
1306                eyre::ensure!(
1307                    name == who,
1308                    "Forward lookup verification failed: got `{name}`, expected `{who}`"
1309                );
1310            }
1311            print_scalar(address.to_string())?;
1312        }
1313
1314        // Misc
1315        CastSubcommand::Misc(MiscSubcommand::Keccak { data }) => {
1316            let bytes = match data {
1317                Some(data) => data.into_bytes(),
1318                None => stdin::read_bytes(false)?,
1319            };
1320            let out = match String::from_utf8(bytes) {
1321                Ok(s) => {
1322                    // Hex-decode if data starts with 0x.
1323                    if s.starts_with("0x") {
1324                        keccak256(hex::decode(s.trim_end())?)
1325                    } else {
1326                        keccak256(s)
1327                    }
1328                    .to_string()
1329                }
1330                Err(e) => hex::encode_prefixed(keccak256(e.as_bytes())),
1331            };
1332            print_scalar(out)?;
1333        }
1334        CastSubcommand::Misc(MiscSubcommand::HashMessage { message }) => {
1335            print_scalar(eip191_hash_message(stdin::unwrap(message, false)?).to_string())?;
1336        }
1337        CastSubcommand::Misc(MiscSubcommand::SigEvent { event_string }) => {
1338            let event = get_event(&stdin::unwrap_line(event_string)?)?;
1339            print_scalar(format!("{:?}", event.selector()))?;
1340        }
1341        CastSubcommand::Misc(MiscSubcommand::LeftShift { value, bits, base_in, base_out }) => {
1342            print_scalar(shift(&value, &bits, base_in.as_deref(), &base_out, |value, bits| {
1343                value << bits
1344            })?)?;
1345        }
1346        CastSubcommand::Misc(MiscSubcommand::RightShift { value, bits, base_in, base_out }) => {
1347            print_scalar(shift(&value, &bits, base_in.as_deref(), &base_out, |value, bits| {
1348                value.wrapping_shr(bits.saturating_to())
1349            })?)?;
1350        }
1351        CastSubcommand::Misc(MiscSubcommand::Source {
1352            address,
1353            directory,
1354            explorer_api_url,
1355            explorer_url,
1356            etherscan,
1357            flatten,
1358        }) => {
1359            let config = etherscan.load_config()?;
1360            let chain = config.chain.unwrap_or_default();
1361            let api_key = config.get_etherscan_api_key(Some(chain));
1362            let client = explorer_client(chain, api_key, explorer_api_url, explorer_url)?;
1363            let metadata = client.contract_source_code(address.parse()?).await?;
1364            match (directory, flatten) {
1365                (Some(dir), false) => {
1366                    metadata.source_tree()?.write_to(&dir)?;
1367                }
1368                (None, false) => sh_println!("{}", metadata.source_code())?,
1369                (dir, true) => {
1370                    let Some(metadata) = metadata.items.first() else {
1371                        eyre::bail!("Empty contract source code");
1372                    };
1373
1374                    let tmp = tempfile::tempdir()?;
1375                    let project = foundry_common::compile::etherscan_project(metadata, tmp.path())?;
1376                    let target_path = project.find_contract_path(&metadata.contract_name)?;
1377
1378                    let flattened = foundry_common::flatten(project, &target_path)?;
1379
1380                    if let Some(path) = dir {
1381                        fs::create_dir_all(path.parent().unwrap())?;
1382                        fs::write(&path, flattened)?;
1383                        sh_status!("Flattened file written at {}", path.display())?
1384                    } else {
1385                        sh_println!("{flattened}")?
1386                    }
1387                }
1388            }
1389        }
1390        CastSubcommand::Misc(MiscSubcommand::Create2(cmd)) => cmd.execute()?,
1391        CastSubcommand::Misc(MiscSubcommand::Wallet { command }) => command.run().await?,
1392        CastSubcommand::Misc(MiscSubcommand::Safe { command }) => command.run().await?,
1393        CastSubcommand::Misc(MiscSubcommand::Completions { shell }) => {
1394            generate(shell, &mut CastArgs::command(), "cast", &mut std::io::stdout())
1395        }
1396        CastSubcommand::Misc(MiscSubcommand::Logs(cmd)) => cmd.run().await?,
1397        CastSubcommand::Misc(MiscSubcommand::Events(cmd)) => cmd.run().await?,
1398        CastSubcommand::Misc(MiscSubcommand::DecodeTransaction { tx, network }) => {
1399            let tx = stdin::unwrap_line(tx)?;
1400            let decoded_tx = match network {
1401                #[cfg(feature = "optimism")]
1402                Some(NetworkVariant::Optimism) => decode_raw_transaction::<Optimism>(&tx)?,
1403                Some(NetworkVariant::Tempo) => decode_raw_transaction::<TempoNetwork>(&tx)?,
1404                #[cfg(feature = "base")]
1405                Some(NetworkVariant::Base) => decode_raw_transaction::<BaseNetwork>(&tx)?,
1406                Some(NetworkVariant::Ethereum) => decode_raw_transaction::<Ethereum>(&tx)?,
1407                #[cfg(feature = "monad")]
1408                Some(NetworkVariant::Monad) => decode_raw_transaction::<Ethereum>(&tx)?,
1409                // Without an explicit `--network` override, decode with the Foundry envelope,
1410                // which dispatches on the EIP-2718 type byte for the transaction types compiled
1411                // into `FoundryNetwork`, including Tempo txs (`0x76`).
1412                None => decode_raw_transaction::<FoundryNetwork>(&tx)?,
1413            };
1414            print_json_object(decoded_tx)?;
1415        }
1416        CastSubcommand::Misc(MiscSubcommand::RecoverAuthority { auth }) => {
1417            let auth: SignedAuthorization = serde_json::from_str(&auth)?;
1418            print_scalar(auth.recover_authority()?.to_string())?;
1419        }
1420        CastSubcommand::Misc(MiscSubcommand::TxPool { command }) => command.run().await?,
1421        CastSubcommand::Misc(MiscSubcommand::Erc20Token { command }) => command.run().await?,
1422        CastSubcommand::Misc(MiscSubcommand::Erc4626 { command }) => command.run().await?,
1423        CastSubcommand::Misc(MiscSubcommand::Tip20Token { command }) => command.run().await?,
1424        CastSubcommand::Misc(MiscSubcommand::ReceivePolicy { command }) => command.run().await?,
1425        CastSubcommand::Misc(MiscSubcommand::Tip403 { command }) => command.run().await?,
1426        CastSubcommand::Misc(MiscSubcommand::StorageCredits { command }) => command.run().await?,
1427        CastSubcommand::Misc(MiscSubcommand::Keychain { command }) => command.run().await?,
1428        CastSubcommand::Misc(MiscSubcommand::KeyAuthorization { command }) => command.run().await?,
1429        CastSubcommand::Misc(MiscSubcommand::Tempo(args)) => args.run().await?,
1430        CastSubcommand::Misc(MiscSubcommand::VirtualAddress { command }) => command.run().await?,
1431        #[cfg(any(feature = "base", feature = "optimism"))]
1432        CastSubcommand::Misc(MiscSubcommand::DAEstimate(cmd)) => cmd.run().await?,
1433        CastSubcommand::Misc(MiscSubcommand::Trace(cmd)) => cmd.run().await?,
1434    };
1435
1436    Ok(())
1437}
1438
1439/// Builds the default provider for `rpc` and resolves `who` against it.
1440async fn rpc_provider_and_address(
1441    rpc: &RpcOpts,
1442    who: NameOrAddress,
1443) -> Result<(RetryProvider, Address)> {
1444    let provider = rpc_provider(rpc)?;
1445    let who = who.resolve(&provider).await?;
1446    Ok((provider, who))
1447}
1448
1449/// Resolves `who` when given, otherwise returns `default`.
1450async fn resolve_or(
1451    who: Option<NameOrAddress>,
1452    default: Address,
1453    provider: &RetryProvider,
1454) -> Result<Address> {
1455    Ok(match who {
1456        Some(who) => who.resolve(provider).await?,
1457        None => default,
1458    })
1459}
1460
1461/// Validates that `encoded` is a supported EIP-2718 transaction and renders its Tempo T5 payment
1462/// lane classification.
1463fn format_lane_classification(encoded: &[u8], decode_context: &'static str) -> Result<String> {
1464    FoundryTxEnvelope::decode_2718(&mut &encoded[..]).wrap_err(decode_context)?;
1465    let classification = classify_payment_lane(encoded);
1466    if shell::is_json() {
1467        Ok(serde_json::to_string_pretty(&classification)?)
1468    } else {
1469        Ok(serde_json::to_string(&classification)?)
1470    }
1471}
1472
1473async fn address_at_slot<N: alloy_network::Network>(
1474    provider: &impl Provider<N>,
1475    who: Address,
1476    slot: B256,
1477    block: Option<BlockId>,
1478) -> Result<String> {
1479    let value =
1480        provider.get_storage_at(who, slot.into()).block_id(block.unwrap_or_default()).await?;
1481    Ok(format!("{:?}", Address::from_word(value.into())))
1482}
1483
1484async fn transaction_response<N: Network>(
1485    provider: &impl Provider<N>,
1486    tx_hash: Option<String>,
1487    from: Option<NameOrAddress>,
1488    nonce: Option<u64>,
1489) -> Result<N::TransactionResponse> {
1490    if let Some(tx_hash) = tx_hash {
1491        let tx_hash = TxHash::from_str(&tx_hash).wrap_err("invalid tx hash")?;
1492        provider
1493            .get_transaction_by_hash(tx_hash)
1494            .await?
1495            .ok_or_else(|| eyre::eyre!("tx not found: {:?}", tx_hash))
1496    } else if let Some(from) = from {
1497        let nonce = U64::from(nonce.unwrap_or_default());
1498        let from = from.resolve(provider.root()).await?;
1499        provider
1500            .raw_request::<_, Option<N::TransactionResponse>>(
1501                "eth_getTransactionBySenderAndNonce".into(),
1502                (from, nonce),
1503            )
1504            .await?
1505            .ok_or_else(|| {
1506                eyre::eyre!("tx not found for sender {from} and nonce {:?}", nonce.to::<u64>())
1507            })
1508    } else {
1509        eyre::bail!("tx hash or from address is required")
1510    }
1511}
1512
1513fn format_transaction<N: Network>(
1514    _provider: &impl Provider<N>,
1515    tx: N::TransactionResponse,
1516    field: Option<String>,
1517    to_request: bool,
1518) -> Result<String>
1519where
1520    N::TransactionResponse: UIfmt,
1521    N::TxEnvelope: UIfmtSignatureExt,
1522{
1523    Ok(if let Some(field) = field {
1524        if let Some(value) = get_pretty_tx_attr::<N>(&tx, &field) {
1525            value
1526        } else {
1527            let mut tx_json = serde_json::to_value(&tx)?;
1528            add_configurable_account_details(&mut tx_json);
1529            let value =
1530                tx_json.get(&field).ok_or_else(|| eyre::eyre!("invalid tx field: {field}"))?;
1531            match value {
1532                serde_json::Value::String(value) => value.clone(),
1533                value => value.to_string(),
1534            }
1535        }
1536    } else if shell::is_json() {
1537        // to_value first to sort json object keys
1538        let mut tx_json = serde_json::to_value(&tx)?;
1539        add_configurable_account_details(&mut tx_json);
1540        tx_json.to_string()
1541    } else if to_request {
1542        serde_json::to_string_pretty(&Into::<N::TransactionRequest>::into(tx))?
1543    } else {
1544        tx.pretty()
1545    })
1546}
1547
1548fn int_bound(s: &str, max: bool) -> Result<String> {
1549    let ty = DynSolType::parse(s).wrap_err("Invalid type, expected `(u)int<bit size>`")?;
1550    match ty {
1551        DynSolType::Int(n) => {
1552            let max_value = (U256::MAX & U256::ONE.wrapping_shl(n - 1)) - U256::ONE;
1553            if max {
1554                Ok(max_value.to_string())
1555            } else {
1556                Ok((I256::from_raw(max_value).wrapping_neg() + I256::MINUS_ONE).to_string())
1557            }
1558        }
1559        DynSolType::Uint(n) if max => {
1560            let mut max_value = U256::MAX;
1561            if n < 256 {
1562                max_value &= U256::ONE.wrapping_shl(n).wrapping_sub(U256::ONE);
1563            }
1564            Ok(max_value.to_string())
1565        }
1566        DynSolType::Uint(_) => Ok("0".to_string()),
1567        _ => Err(eyre::eyre!("Type is not int/uint: {s}")),
1568    }
1569}
1570
1571/// Converts a parsed, possibly-negative [`NumberWithBase`] into a [`ParseUnits`], preserving
1572/// its sign.
1573///
1574/// `NumberWithBase::number()` returns the two's-complement bits of a negative value modulo
1575/// 2^256, which is a wider range than [`I256`] can represent (magnitudes up to 2^255 only).
1576/// A magnitude beyond that range would silently reinterpret as a small *positive* [`I256`]
1577/// if constructed unconditionally via [`I256::from_raw`] -- reject it instead.
1578fn signed_parse_units(value: &NumberWithBase) -> Result<ParseUnits> {
1579    if value.is_nonnegative() {
1580        return Ok(ParseUnits::U256(value.number()));
1581    }
1582    let signed = I256::from_raw(value.number());
1583    if !signed.is_negative() {
1584        eyre::bail!("value out of range for a signed 256-bit integer");
1585    }
1586    Ok(ParseUnits::I256(signed))
1587}
1588
1589fn format_unit_as_string(value: ParseUnits, unit: Unit) -> String {
1590    let mut formatted = value.format_units(unit);
1591    // Trim empty fractional part.
1592    if let Some(dot) = formatted.find('.') {
1593        let fractional = &formatted[dot + 1..];
1594        if fractional.chars().all(|c: char| c == '0') {
1595            formatted = formatted[..dot].to_string();
1596        }
1597    }
1598    formatted
1599}
1600
1601pub(super) fn format_units(value: &str, unit: u8) -> Result<String> {
1602    let value = NumberWithBase::parse_int(value, None)?;
1603    let unit = Unit::new(unit).ok_or_else(|| eyre::eyre!("invalid unit"))?;
1604    let parsed = signed_parse_units(&value)?;
1605    Ok(format_unit_as_string(parsed, unit))
1606}
1607
1608fn to_base(value: &str, base_in: Option<&str>, base_out: &str) -> Result<String> {
1609    let base_in = Base::unwrap_or_detect(base_in, value)?;
1610    let base_out = base_out.parse()?;
1611    let n = NumberWithBase::parse_int_in(value, base_in)?.with_base(base_out);
1612    if base_in == base_out {
1613        return Ok(value.to_string());
1614    }
1615    Ok(format!("{n:#?}"))
1616}
1617
1618/// Parses `value` and `bits`, applies `shift` and formats the result with the `base_out`
1619/// prefix.
1620fn shift(
1621    value: &str,
1622    bits: &str,
1623    base_in: Option<&str>,
1624    base_out: &str,
1625    shift: impl FnOnce(U256, U256) -> U256,
1626) -> Result<String> {
1627    let base_out = base_out.parse()?;
1628    let value = NumberWithBase::parse_uint(value, base_in)?.number();
1629    let bits = NumberWithBase::parse_uint(bits, None)?.number();
1630    Ok(format!("{:#?}", NumberWithBase::from(shift(value, bits)).with_base(base_out)))
1631}
1632
1633fn explorer_client(
1634    chain: Chain,
1635    api_key: Option<String>,
1636    api_url: Option<String>,
1637    explorer_url: Option<String>,
1638) -> Result<Client> {
1639    let mut builder = Client::builder();
1640
1641    let deduced = chain.etherscan_urls();
1642
1643    let explorer_url = explorer_url
1644        .or(deduced.map(|d| d.1.to_string()))
1645        .ok_or_eyre("Please provide the explorer browser URL using `--explorer-url`")?;
1646    builder = builder.with_url(explorer_url)?;
1647
1648    let api_url = api_url
1649        .or(deduced.map(|d| d.0.to_string()))
1650        .ok_or_eyre("Please provide the explorer API URL using `--explorer-api-url`")?;
1651    builder = builder.with_api_url(api_url)?;
1652
1653    if let Some(api_key) = api_key {
1654        builder = builder.with_api_key(api_key);
1655    }
1656
1657    builder.build().map_err(Into::into)
1658}
1659
1660fn decode_raw_transaction<N: Network<TxEnvelope: SignerRecoverable + Serialize>>(
1661    tx: &str,
1662) -> Result<serde_json::Value> {
1663    let tx_hex = hex::decode(tx)?;
1664    let tx: N::TxEnvelope = Decodable2718::decode_2718(&mut tx_hex.as_slice())?;
1665    let mut decoded = if let Ok(signer) = tx.recover_signer() {
1666        serde_json::to_value(Recovered::new_unchecked(tx, signer))?
1667    } else {
1668        serde_json::to_value(tx)?
1669    };
1670    add_configurable_account_details(&mut decoded);
1671    Ok(decoded)
1672}
1673
1674fn get_selector(signature: &str, optimize: usize) -> Result<(String, String)> {
1675    if optimize > 4 {
1676        eyre::bail!("number of leading zeroes must not be greater than 4");
1677    }
1678    if optimize == 0 {
1679        let selector = get_func(signature)?.selector();
1680        return Ok((selector.to_string(), String::from(signature)));
1681    }
1682    let Some((name, params)) = signature.split_once('(') else {
1683        eyre::bail!("invalid function signature");
1684    };
1685
1686    find_optimized_selector(name, params, optimize, 0)
1687}
1688
1689/// Searches nonces from `first_nonce` up to `u32::MAX` for a name whose selector has exactly
1690/// `optimize` leading zero bytes.
1691fn find_optimized_selector(
1692    name: &str,
1693    params: &str,
1694    optimize: usize,
1695    first_nonce: u32,
1696) -> Result<(String, String)> {
1697    let num_threads = rayon::current_num_threads() as u32;
1698    let found = AtomicBool::new(false);
1699
1700    // Each thread walks its own residue class of nonces until one of them finds a match.
1701    (0..num_threads)
1702        .into_par_iter()
1703        .find_map_any(|offset| {
1704            let mut nonce = first_nonce.checked_add(offset)?;
1705            while nonce < u32::MAX && !found.load(Ordering::Relaxed) {
1706                let input = format!("{name}{nonce}({params}");
1707                let selector = &keccak256(input.as_bytes())[..4];
1708                if selector.iter().take_while(|&&byte| byte == 0).count() == optimize {
1709                    found.store(true, Ordering::Relaxed);
1710                    return Some((hex::encode_prefixed(selector), input));
1711                }
1712                nonce = nonce.checked_add(num_threads)?;
1713            }
1714            None
1715        })
1716        .ok_or_eyre("No selector found")
1717}
1718
1719fn strip_0x(s: &str) -> &str {
1720    s.strip_prefix("0x").unwrap_or(s)
1721}
1722
1723/// Points out a flag that was read as an extra ABI argument.
1724///
1725/// The variadic ABI arguments accept hyphen values so that negative numbers work, which also
1726/// captures flags written after the arguments.
1727fn with_trailing_flag_hint(err: eyre::Report, expected: usize, args: &[String]) -> eyre::Report {
1728    match args.iter().skip(expected).find(|arg| arg.starts_with("--")) {
1729        Some(flag) => {
1730            eyre::eyre!("{err}; `{flag}` was read as an argument; put flags before the signature")
1731        }
1732        None => err,
1733    }
1734}
1735
1736/// Encodes the topic of an indexed event parameter.
1737///
1738/// Value types are encoded as their 32-byte word. Reference types are hashed over the special
1739/// in-place encoding defined for indexed event parameters, which differs from regular ABI
1740/// encoding: `string` and `bytes` contribute their raw contents, and array or struct members are
1741/// concatenated recursively without any offsets or length prefixes.
1742///
1743/// See <https://docs.soliditylang.org/en/latest/abi-spec.html#encoding-of-indexed-event-parameters>
1744pub(super) fn encode_event_topic(value: &DynSolValue) -> B256 {
1745    if let Some(word) = value.as_word() {
1746        return word;
1747    }
1748    // Top-level `string` and `bytes` hash their raw contents without padding.
1749    if let Some(bytes) = value.as_packed_seq() {
1750        return keccak256(bytes);
1751    }
1752    let mut preimage = Vec::new();
1753    encode_event_topic_preimage(value, &mut preimage);
1754    keccak256(preimage)
1755}
1756
1757/// Encodes a value into the in-place preimage of an indexed event parameter: words as-is,
1758/// `string`/`bytes` right-padded to a multiple of 32 bytes, and sequences as the concatenation of
1759/// their encoded members.
1760fn encode_event_topic_preimage(value: &DynSolValue, out: &mut Vec<u8>) {
1761    if let Some(word) = value.as_word() {
1762        out.extend_from_slice(word.as_slice());
1763    } else if let Some(bytes) = value.as_packed_seq() {
1764        let pad = bytes.len().next_multiple_of(32) - bytes.len();
1765        out.extend_from_slice(bytes);
1766        out.resize(out.len() + pad, 0);
1767    } else if let Some(values) = value.as_fixed_seq().or_else(|| value.as_array()) {
1768        for value in values {
1769            encode_event_topic_preimage(value, out);
1770        }
1771    }
1772}
1773
1774/// Returns the signature of a function selector from the local signatures cache, which
1775/// `forge build` and trace decoding populate.
1776///
1777/// The stored text is returned as is: parsing it would turn library signatures such as
1778/// `f(L.E)` into `f(uint8)`, which hashes to another selector.
1779async fn local_function_signature(selector: Selector) -> Result<Option<String>> {
1780    Ok(SignaturesIdentifier::new(true)?
1781        .identify(&[SelectorKind::Function(selector)])
1782        .await
1783        .pop()
1784        .flatten())
1785}
1786
1787/// Lists a signature from the local cache first, followed by the other signatures found remotely.
1788/// The cached signature alone is used when the remote lookup fails.
1789fn with_local_first(local: Option<String>, remote: Result<Vec<String>>) -> Result<Vec<String>> {
1790    match (local, remote) {
1791        (Some(sig), Ok(mut sigs)) => {
1792            sigs.retain(|remote| *remote != sig);
1793            sigs.insert(0, sig);
1794            Ok(sigs)
1795        }
1796        (Some(sig), Err(_)) => Ok(vec![sig]),
1797        (None, remote) => remote,
1798    }
1799}
1800
1801#[cfg(test)]
1802mod tests {
1803    use super::*;
1804    use alloy_sol_types::{EventTopic, sol_data};
1805
1806    #[test]
1807    fn optimized_selector_search_terminates_without_a_match() {
1808        // Four leading zero bytes will not show up in the last thousand nonces, and the search must
1809        // report that instead of wrapping the nonce around and starting over.
1810        // Use two threads so one lane overflows instead of reaching u32::MAX exactly.
1811        let err = rayon::ThreadPoolBuilder::new().num_threads(2).build().unwrap().install(|| {
1812            find_optimized_selector("transfer", "address,uint256)", 4, u32::MAX - 1000).unwrap_err()
1813        });
1814        assert_eq!(err.to_string(), "No selector found");
1815    }
1816
1817    /// Compares [`super::encode_event_topic`] against alloy's static [`EventTopic`]
1818    /// implementation, which `sol!`-generated events use to compute indexed topics.
1819    #[test]
1820    fn encode_event_topic_matches_static_encoding() {
1821        let uint = |n: u64| DynSolValue::Uint(U256::from(n), 256);
1822        let string = |s: &str| DynSolValue::String(s.into());
1823        let topic = |v: &DynSolValue| super::encode_event_topic(v);
1824
1825        let long = "abcdefghijklmnopqrstuvwxyz0123456789abcd";
1826        for s in ["", "hello", long] {
1827            assert_eq!(
1828                topic(&string(s)),
1829                <sol_data::String as EventTopic>::encode_topic(&s.to_string()).0,
1830                "string {s:?}"
1831            );
1832        }
1833
1834        let bytes = hex::decode("deadbeef").unwrap();
1835        assert_eq!(
1836            topic(&DynSolValue::Bytes(bytes.clone())),
1837            <sol_data::Bytes as EventTopic>::encode_topic(&Bytes::from(bytes)).0,
1838        );
1839
1840        let addr = Address::repeat_byte(0x42);
1841        assert_eq!(
1842            topic(&DynSolValue::Address(addr)),
1843            <sol_data::Address as EventTopic>::encode_topic(&addr).0,
1844        );
1845
1846        assert_eq!(
1847            topic(&DynSolValue::Array(vec![uint(1), uint(2)])),
1848            <sol_data::Array<sol_data::Uint<256>> as EventTopic>::encode_topic(&vec![
1849                U256::ONE,
1850                U256::from(2)
1851            ])
1852            .0,
1853        );
1854
1855        assert_eq!(
1856            topic(&DynSolValue::FixedArray(vec![uint(7), uint(9)])),
1857            <sol_data::FixedArray<sol_data::Uint<256>, 2> as EventTopic>::encode_topic(&[
1858                U256::from(7),
1859                U256::from(9)
1860            ])
1861            .0,
1862        );
1863
1864        assert_eq!(
1865            topic(&DynSolValue::Array(vec![string("alpha"), string(long)])),
1866            <sol_data::Array<sol_data::String> as EventTopic>::encode_topic(&vec![
1867                "alpha".to_string(),
1868                long.to_string()
1869            ])
1870            .0,
1871        );
1872
1873        assert_eq!(
1874            topic(&DynSolValue::Tuple(vec![uint(7), string("hello")])),
1875            <(sol_data::Uint<256>, sol_data::String) as EventTopic>::encode_topic(&(
1876                U256::from(7),
1877                "hello".to_string()
1878            ))
1879            .0,
1880        );
1881
1882        assert_eq!(
1883            topic(&DynSolValue::Array(vec![
1884                DynSolValue::Array(vec![uint(1)]),
1885                DynSolValue::Array(vec![uint(2), uint(3)]),
1886            ])),
1887            <sol_data::Array<sol_data::Array<sol_data::Uint<256>>> as EventTopic>::encode_topic(
1888                &vec![vec![U256::ONE], vec![U256::from(2), U256::from(3)]]
1889            )
1890            .0,
1891        );
1892    }
1893
1894    #[test]
1895    fn trailing_flag_hint() {
1896        let hint = |expected, args: &[&str]| {
1897            let args = args.iter().map(|arg| arg.to_string()).collect::<Vec<_>>();
1898            with_trailing_flag_hint(eyre::eyre!("encode length mismatch"), expected, &args)
1899                .to_string()
1900        };
1901
1902        // A flag after the expected arguments is named in the error.
1903        assert_eq!(
1904            hint(1, &["1", "--packed"]),
1905            "encode length mismatch; `--packed` was read as an argument; put flags before the signature"
1906        );
1907        // Only the extra trailing arguments are checked.
1908        assert_eq!(hint(1, &["--x", "2"]), "encode length mismatch");
1909        // Too few arguments never mention flags, even when one starts with `--`.
1910        assert_eq!(hint(2, &["--packed"]), "encode length mismatch");
1911        assert_eq!(hint(1, &[]), "encode length mismatch");
1912    }
1913}