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
75macro_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
112pub 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
126pub fn setup() -> Result<Vec<String>> {
128 let warnings = utils::common_setup();
129 utils::subscriber();
130
131 Ok(warnings)
132}
133
134#[allow(clippy::large_stack_frames)]
136pub async fn run_command(args: CastArgs) -> Result<()> {
137 match args.cmd {
138 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 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 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 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 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 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 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 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 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 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 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 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 "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 "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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
1439async 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
1449async 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
1461fn 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 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
1571fn 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 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
1618fn 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
1689fn 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 (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
1723fn 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
1736pub(super) fn encode_event_topic(value: &DynSolValue) -> B256 {
1745 if let Some(word) = value.as_word() {
1746 return word;
1747 }
1748 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
1757fn 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
1774async 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
1787fn 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 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 #[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 assert_eq!(
1904 hint(1, &["1", "--packed"]),
1905 "encode length mismatch; `--packed` was read as an argument; put flags before the signature"
1906 );
1907 assert_eq!(hint(1, &["--x", "2"]), "encode length mismatch");
1909 assert_eq!(hint(2, &["--packed"]), "encode length mismatch");
1911 assert_eq!(hint(1, &[]), "encode length mismatch");
1912 }
1913}