1use crate::{
2 opts::{Cast as CastArgs, CastSubcommand, ToBaseArgs},
3 traces::identifier::SignaturesIdentifier,
4 Cast, SimpleCast,
5};
6use alloy_consensus::transaction::{Recovered, SignerRecoverable};
7use alloy_dyn_abi::{DynSolValue, ErrorExt, EventExt};
8use alloy_ens::{namehash, ProviderEnsExt};
9use alloy_primitives::{eip191_hash_message, hex, keccak256, Address, B256};
10use alloy_provider::Provider;
11use alloy_rpc_types::{BlockId, BlockNumberOrTag::Latest};
12use clap::{CommandFactory, Parser};
13use clap_complete::generate;
14use eyre::Result;
15use foundry_cli::{handler, utils, utils::LoadConfig};
16use foundry_common::{
17 abi::{get_error, get_event},
18 fmt::{format_tokens, format_tokens_raw, format_uint_exp},
19 fs,
20 selectors::{
21 decode_calldata, decode_event_topic, decode_function_selector, decode_selectors,
22 import_selectors, parse_signatures, pretty_calldata, ParsedSignatures, SelectorImportData,
23 SelectorKind,
24 },
25 shell, stdin,
26};
27use std::time::Instant;
28
29pub fn run() -> Result<()> {
31 setup()?;
32
33 let args = CastArgs::parse();
34 args.global.init()?;
35
36 run_command(args)
37}
38
39pub fn setup() -> Result<()> {
41 utils::install_crypto_provider();
42 handler::install();
43 utils::load_dotenv();
44 utils::subscriber();
45 utils::enable_paint();
46
47 Ok(())
48}
49
50#[tokio::main]
52pub async fn run_command(args: CastArgs) -> Result<()> {
53 match args.cmd {
54 CastSubcommand::MaxInt { r#type } => {
56 sh_println!("{}", SimpleCast::max_int(&r#type)?)?;
57 }
58 CastSubcommand::MinInt { r#type } => {
59 sh_println!("{}", SimpleCast::min_int(&r#type)?)?;
60 }
61 CastSubcommand::MaxUint { r#type } => {
62 sh_println!("{}", SimpleCast::max_int(&r#type)?)?;
63 }
64 CastSubcommand::AddressZero => {
65 sh_println!("{:?}", Address::ZERO)?;
66 }
67 CastSubcommand::HashZero => {
68 sh_println!("{:?}", B256::ZERO)?;
69 }
70
71 CastSubcommand::FromUtf8 { text } => {
73 let value = stdin::unwrap(text, false)?;
74 sh_println!("{}", SimpleCast::from_utf8(&value))?
75 }
76 CastSubcommand::ToAscii { hexdata } => {
77 let value = stdin::unwrap(hexdata, false)?;
78 sh_println!("{}", SimpleCast::to_ascii(value.trim())?)?
79 }
80 CastSubcommand::ToUtf8 { hexdata } => {
81 let value = stdin::unwrap(hexdata, false)?;
82 sh_println!("{}", SimpleCast::to_utf8(&value)?)?
83 }
84 CastSubcommand::FromFixedPoint { value, decimals } => {
85 let (value, decimals) = stdin::unwrap2(value, decimals)?;
86 sh_println!("{}", SimpleCast::from_fixed_point(&value, &decimals)?)?
87 }
88 CastSubcommand::ToFixedPoint { value, decimals } => {
89 let (value, decimals) = stdin::unwrap2(value, decimals)?;
90 sh_println!("{}", SimpleCast::to_fixed_point(&value, &decimals)?)?
91 }
92 CastSubcommand::ConcatHex { data } => {
93 if data.is_empty() {
94 let s = stdin::read(true)?;
95 sh_println!("{}", SimpleCast::concat_hex(s.split_whitespace()))?
96 } else {
97 sh_println!("{}", SimpleCast::concat_hex(data))?
98 }
99 }
100 CastSubcommand::FromBin => {
101 let hex = stdin::read_bytes(false)?;
102 sh_println!("{}", hex::encode_prefixed(hex))?
103 }
104 CastSubcommand::ToHexdata { input } => {
105 let value = stdin::unwrap_line(input)?;
106 let output = match value {
107 s if s.starts_with('@') => hex::encode(std::env::var(&s[1..])?),
108 s if s.starts_with('/') => hex::encode(fs::read(s)?),
109 s => s.split(':').map(|s| s.trim_start_matches("0x").to_lowercase()).collect(),
110 };
111 sh_println!("0x{output}")?
112 }
113 CastSubcommand::ToCheckSumAddress { address } => {
114 let value = stdin::unwrap_line(address)?;
115 sh_println!("{}", value.to_checksum(None))?
116 }
117 CastSubcommand::ToUint256 { value } => {
118 let value = stdin::unwrap_line(value)?;
119 sh_println!("{}", SimpleCast::to_uint256(&value)?)?
120 }
121 CastSubcommand::ToInt256 { value } => {
122 let value = stdin::unwrap_line(value)?;
123 sh_println!("{}", SimpleCast::to_int256(&value)?)?
124 }
125 CastSubcommand::ToUnit { value, unit } => {
126 let value = stdin::unwrap_line(value)?;
127 sh_println!("{}", SimpleCast::to_unit(&value, &unit)?)?
128 }
129 CastSubcommand::ParseUnits { value, unit } => {
130 let value = stdin::unwrap_line(value)?;
131 sh_println!("{}", SimpleCast::parse_units(&value, unit)?)?;
132 }
133 CastSubcommand::FormatUnits { value, unit } => {
134 let value = stdin::unwrap_line(value)?;
135 sh_println!("{}", SimpleCast::format_units(&value, unit)?)?;
136 }
137 CastSubcommand::FromWei { value, unit } => {
138 let value = stdin::unwrap_line(value)?;
139 sh_println!("{}", SimpleCast::from_wei(&value, &unit)?)?
140 }
141 CastSubcommand::ToWei { value, unit } => {
142 let value = stdin::unwrap_line(value)?;
143 sh_println!("{}", SimpleCast::to_wei(&value, &unit)?)?
144 }
145 CastSubcommand::FromRlp { value, as_int } => {
146 let value = stdin::unwrap_line(value)?;
147 sh_println!("{}", SimpleCast::from_rlp(value, as_int)?)?
148 }
149 CastSubcommand::ToRlp { value } => {
150 let value = stdin::unwrap_line(value)?;
151 sh_println!("{}", SimpleCast::to_rlp(&value)?)?
152 }
153 CastSubcommand::ToHex(ToBaseArgs { value, base_in }) => {
154 let value = stdin::unwrap_line(value)?;
155 sh_println!("{}", SimpleCast::to_base(&value, base_in.as_deref(), "hex")?)?
156 }
157 CastSubcommand::ToDec(ToBaseArgs { value, base_in }) => {
158 let value = stdin::unwrap_line(value)?;
159 sh_println!("{}", SimpleCast::to_base(&value, base_in.as_deref(), "dec")?)?
160 }
161 CastSubcommand::ToBase { base: ToBaseArgs { value, base_in }, base_out } => {
162 let (value, base_out) = stdin::unwrap2(value, base_out)?;
163 sh_println!("{}", SimpleCast::to_base(&value, base_in.as_deref(), &base_out)?)?
164 }
165 CastSubcommand::ToBytes32 { bytes } => {
166 let value = stdin::unwrap_line(bytes)?;
167 sh_println!("{}", SimpleCast::to_bytes32(&value)?)?
168 }
169 CastSubcommand::FormatBytes32String { string } => {
170 let value = stdin::unwrap_line(string)?;
171 sh_println!("{}", SimpleCast::format_bytes32_string(&value)?)?
172 }
173 CastSubcommand::ParseBytes32String { bytes } => {
174 let value = stdin::unwrap_line(bytes)?;
175 sh_println!("{}", SimpleCast::parse_bytes32_string(&value)?)?
176 }
177 CastSubcommand::ParseBytes32Address { bytes } => {
178 let value = stdin::unwrap_line(bytes)?;
179 sh_println!("{}", SimpleCast::parse_bytes32_address(&value)?)?
180 }
181
182 CastSubcommand::DecodeAbi { sig, calldata, input } => {
184 let tokens = SimpleCast::abi_decode(&sig, &calldata, input)?;
185 print_tokens(&tokens);
186 }
187 CastSubcommand::AbiEncode { sig, packed, args } => {
188 if !packed {
189 sh_println!("{}", SimpleCast::abi_encode(&sig, &args)?)?
190 } else {
191 sh_println!("{}", SimpleCast::abi_encode_packed(&sig, &args)?)?
192 }
193 }
194 CastSubcommand::DecodeCalldata { sig, calldata } => {
195 let tokens = SimpleCast::calldata_decode(&sig, &calldata, true)?;
196 print_tokens(&tokens);
197 }
198 CastSubcommand::CalldataEncode { sig, args, file } => {
199 let final_args = if let Some(file_path) = file {
200 let contents = fs::read_to_string(file_path)?;
201 contents
202 .lines()
203 .map(str::trim)
204 .filter(|line| !line.is_empty())
205 .map(String::from)
206 .collect()
207 } else {
208 args
209 };
210 sh_println!("{}", SimpleCast::calldata_encode(sig, &final_args)?)?;
211 }
212 CastSubcommand::DecodeString { data } => {
213 let tokens = SimpleCast::calldata_decode("Any(string)", &data, true)?;
214 print_tokens(&tokens);
215 }
216 CastSubcommand::DecodeEvent { sig, data } => {
217 let decoded_event = if let Some(event_sig) = sig {
218 let event = get_event(event_sig.as_str())?;
219 event.decode_log_parts(core::iter::once(event.selector()), &hex::decode(data)?)?
220 } else {
221 let data = data.strip_prefix("0x").unwrap_or(data.as_str());
222 let selector = data.get(..64).unwrap_or_default();
223 let selector = selector.parse()?;
224 let identified_event =
225 SignaturesIdentifier::new(false)?.identify_event(selector).await;
226 if let Some(event) = identified_event {
227 let _ = sh_println!("{}", event.signature());
228 let data = data.get(64..).unwrap_or_default();
229 get_event(event.signature().as_str())?
230 .decode_log_parts(core::iter::once(selector), &hex::decode(data)?)?
231 } else {
232 eyre::bail!("No matching event signature found for selector `{selector}`")
233 }
234 };
235 print_tokens(&decoded_event.body);
236 }
237 CastSubcommand::DecodeError { sig, data } => {
238 let error = if let Some(err_sig) = sig {
239 get_error(err_sig.as_str())?
240 } else {
241 let data = data.strip_prefix("0x").unwrap_or(data.as_str());
242 let selector = data.get(..8).unwrap_or_default();
243 let identified_error =
244 SignaturesIdentifier::new(false)?.identify_error(selector.parse()?).await;
245 if let Some(error) = identified_error {
246 let _ = sh_println!("{}", error.signature());
247 error
248 } else {
249 eyre::bail!("No matching error signature found for selector `{selector}`")
250 }
251 };
252 let decoded_error = error.decode_error(&hex::decode(data)?)?;
253 print_tokens(&decoded_error.body);
254 }
255 CastSubcommand::Interface(cmd) => cmd.run().await?,
256 CastSubcommand::CreationCode(cmd) => cmd.run().await?,
257 CastSubcommand::ConstructorArgs(cmd) => cmd.run().await?,
258 CastSubcommand::Artifact(cmd) => cmd.run().await?,
259 CastSubcommand::Bind(cmd) => cmd.run().await?,
260 CastSubcommand::PrettyCalldata { calldata, offline } => {
261 let calldata = stdin::unwrap_line(calldata)?;
262 sh_println!("{}", pretty_calldata(&calldata, offline).await?)?;
263 }
264 CastSubcommand::Sig { sig, optimize } => {
265 let sig = stdin::unwrap_line(sig)?;
266 match optimize {
267 Some(opt) => {
268 sh_println!("Starting to optimize signature...")?;
269 let start_time = Instant::now();
270 let (selector, signature) = SimpleCast::get_selector(&sig, opt)?;
271 sh_println!("Successfully generated in {:?}", start_time.elapsed())?;
272 sh_println!("Selector: {selector}")?;
273 sh_println!("Optimized signature: {signature}")?;
274 }
275 None => sh_println!("{}", SimpleCast::get_selector(&sig, 0)?.0)?,
276 }
277 }
278
279 CastSubcommand::AccessList(cmd) => cmd.run().await?,
281 CastSubcommand::Age { block, rpc } => {
282 let config = rpc.load_config()?;
283 let provider = utils::get_provider(&config)?;
284 sh_println!(
285 "{} UTC",
286 Cast::new(provider).age(block.unwrap_or(BlockId::Number(Latest))).await?
287 )?
288 }
289 CastSubcommand::Balance { block, who, ether, rpc, erc20 } => {
290 let config = rpc.load_config()?;
291 let provider = utils::get_provider(&config)?;
292 let account_addr = who.resolve(&provider).await?;
293
294 match erc20 {
295 Some(token) => {
296 let balance =
297 Cast::new(&provider).erc20_balance(token, account_addr, block).await?;
298 sh_println!("{}", format_uint_exp(balance))?
299 }
300 None => {
301 let value = Cast::new(&provider).balance(account_addr, block).await?;
302 if ether {
303 sh_println!("{}", SimpleCast::from_wei(&value.to_string(), "eth")?)?
304 } else {
305 sh_println!("{value}")?
306 }
307 }
308 }
309 }
310 CastSubcommand::BaseFee { block, rpc } => {
311 let config = rpc.load_config()?;
312 let provider = utils::get_provider(&config)?;
313 sh_println!(
314 "{}",
315 Cast::new(provider).base_fee(block.unwrap_or(BlockId::Number(Latest))).await?
316 )?
317 }
318 CastSubcommand::Block { block, full, field, rpc } => {
319 let config = rpc.load_config()?;
320 let provider = utils::get_provider(&config)?;
321 sh_println!(
322 "{}",
323 Cast::new(provider)
324 .block(block.unwrap_or(BlockId::Number(Latest)), full, field)
325 .await?
326 )?
327 }
328 CastSubcommand::BlockNumber { rpc, block } => {
329 let config = rpc.load_config()?;
330 let provider = utils::get_provider(&config)?;
331 let number = match block {
332 Some(id) => {
333 provider
334 .get_block(id)
335 .await?
336 .ok_or_else(|| eyre::eyre!("block {id:?} not found"))?
337 .header
338 .number
339 }
340 None => Cast::new(provider).block_number().await?,
341 };
342 sh_println!("{number}")?
343 }
344 CastSubcommand::Chain { rpc } => {
345 let config = rpc.load_config()?;
346 let provider = utils::get_provider(&config)?;
347 sh_println!("{}", Cast::new(provider).chain().await?)?
348 }
349 CastSubcommand::ChainId { rpc } => {
350 let config = rpc.load_config()?;
351 let provider = utils::get_provider(&config)?;
352 sh_println!("{}", Cast::new(provider).chain_id().await?)?
353 }
354 CastSubcommand::Client { rpc } => {
355 let config = rpc.load_config()?;
356 let provider = utils::get_provider(&config)?;
357 sh_println!("{}", provider.get_client_version().await?)?
358 }
359 CastSubcommand::Code { block, who, disassemble, rpc } => {
360 let config = rpc.load_config()?;
361 let provider = utils::get_provider(&config)?;
362 let who = who.resolve(&provider).await?;
363 sh_println!("{}", Cast::new(provider).code(who, block, disassemble).await?)?
364 }
365 CastSubcommand::Codesize { block, who, rpc } => {
366 let config = rpc.load_config()?;
367 let provider = utils::get_provider(&config)?;
368 let who = who.resolve(&provider).await?;
369 sh_println!("{}", Cast::new(provider).codesize(who, block).await?)?
370 }
371 CastSubcommand::ComputeAddress { address, nonce, rpc } => {
372 let config = rpc.load_config()?;
373 let provider = utils::get_provider(&config)?;
374
375 let address = stdin::unwrap_line(address)?;
376 let computed = Cast::new(provider).compute_address(address, nonce).await?;
377 sh_println!("Computed Address: {}", computed.to_checksum(None))?
378 }
379 CastSubcommand::Disassemble { bytecode } => {
380 let bytecode = stdin::unwrap_line(bytecode)?;
381 sh_println!("{}", SimpleCast::disassemble(&hex::decode(bytecode)?)?)?
382 }
383 CastSubcommand::Selectors { bytecode, resolve } => {
384 let bytecode = stdin::unwrap_line(bytecode)?;
385 let functions = SimpleCast::extract_functions(&bytecode)?;
386 let max_args_len = functions.iter().map(|r| r.1.len()).max().unwrap_or(0);
387 let max_mutability_len = functions.iter().map(|r| r.2.len()).max().unwrap_or(0);
388
389 let resolve_results = if resolve {
390 let selectors = functions
391 .iter()
392 .map(|&(selector, ..)| SelectorKind::Function(selector))
393 .collect::<Vec<_>>();
394 let ds = decode_selectors(&selectors).await?;
395 ds.into_iter().map(|v| v.join("|")).collect()
396 } else {
397 vec![]
398 };
399 for (pos, (selector, arguments, state_mutability)) in functions.into_iter().enumerate()
400 {
401 if resolve {
402 let resolved = &resolve_results[pos];
403 sh_println!("{selector}\t{arguments:max_args_len$}\t{state_mutability:max_mutability_len$}\t{resolved}")?
404 } else {
405 sh_println!("{selector}\t{arguments:max_args_len$}\t{state_mutability}")?
406 }
407 }
408 }
409 CastSubcommand::FindBlock(cmd) => cmd.run().await?,
410 CastSubcommand::GasPrice { rpc } => {
411 let config = rpc.load_config()?;
412 let provider = utils::get_provider(&config)?;
413 sh_println!("{}", Cast::new(provider).gas_price().await?)?;
414 }
415 CastSubcommand::Index { key_type, key, slot_number } => {
416 sh_println!("{}", SimpleCast::index(&key_type, &key, &slot_number)?)?;
417 }
418 CastSubcommand::IndexErc7201 { id, formula_id } => {
419 eyre::ensure!(formula_id == "erc7201", "unsupported formula ID: {formula_id}");
420 let id = stdin::unwrap_line(id)?;
421 sh_println!("{}", foundry_common::erc7201(&id))?;
422 }
423 CastSubcommand::Implementation { block, beacon, who, rpc } => {
424 let config = rpc.load_config()?;
425 let provider = utils::get_provider(&config)?;
426 let who = who.resolve(&provider).await?;
427 sh_println!("{}", Cast::new(provider).implementation(who, beacon, block).await?)?;
428 }
429 CastSubcommand::Admin { block, who, rpc } => {
430 let config = rpc.load_config()?;
431 let provider = utils::get_provider(&config)?;
432 let who = who.resolve(&provider).await?;
433 sh_println!("{}", Cast::new(provider).admin(who, block).await?)?;
434 }
435 CastSubcommand::Nonce { block, who, rpc } => {
436 let config = rpc.load_config()?;
437 let provider = utils::get_provider(&config)?;
438 let who = who.resolve(&provider).await?;
439 sh_println!("{}", Cast::new(provider).nonce(who, block).await?)?;
440 }
441 CastSubcommand::Codehash { block, who, slots, rpc } => {
442 let config = rpc.load_config()?;
443 let provider = utils::get_provider(&config)?;
444 let who = who.resolve(&provider).await?;
445 sh_println!("{}", Cast::new(provider).codehash(who, slots, block).await?)?;
446 }
447 CastSubcommand::StorageRoot { block, who, slots, rpc } => {
448 let config = rpc.load_config()?;
449 let provider = utils::get_provider(&config)?;
450 let who = who.resolve(&provider).await?;
451 sh_println!("{}", Cast::new(provider).storage_root(who, slots, block).await?)?;
452 }
453 CastSubcommand::Proof { address, slots, rpc, block } => {
454 let config = rpc.load_config()?;
455 let provider = utils::get_provider(&config)?;
456 let address = address.resolve(&provider).await?;
457 let value = provider
458 .get_proof(address, slots.into_iter().collect())
459 .block_id(block.unwrap_or_default())
460 .await?;
461 sh_println!("{}", serde_json::to_string(&value)?)?;
462 }
463 CastSubcommand::Rpc(cmd) => cmd.run().await?,
464 CastSubcommand::Storage(cmd) => cmd.run().await?,
465
466 CastSubcommand::Call(cmd) => cmd.run().await?,
468 CastSubcommand::Estimate(cmd) => cmd.run().await?,
469 CastSubcommand::MakeTx(cmd) => cmd.run().await?,
470 CastSubcommand::PublishTx { raw_tx, cast_async, rpc } => {
471 let config = rpc.load_config()?;
472 let provider = utils::get_provider(&config)?;
473 let cast = Cast::new(&provider);
474 let pending_tx = cast.publish(raw_tx).await?;
475 let tx_hash = pending_tx.inner().tx_hash();
476
477 if cast_async {
478 sh_println!("{tx_hash:#x}")?;
479 } else {
480 let receipt = pending_tx.get_receipt().await?;
481 sh_println!("{}", serde_json::json!(receipt))?;
482 }
483 }
484 CastSubcommand::Receipt { tx_hash, field, cast_async, confirmations, rpc } => {
485 let config = rpc.load_config()?;
486 let provider = utils::get_provider(&config)?;
487 sh_println!(
488 "{}",
489 Cast::new(provider)
490 .receipt(tx_hash, field, confirmations, None, cast_async)
491 .await?
492 )?
493 }
494 CastSubcommand::Run(cmd) => cmd.run().await?,
495 CastSubcommand::SendTx(cmd) => cmd.run().await?,
496 CastSubcommand::Tx { tx_hash, from, nonce, field, raw, rpc } => {
497 let config = rpc.load_config()?;
498 let provider = utils::get_provider(&config)?;
499
500 let raw = raw || field.as_ref().is_some_and(|f| f == "raw");
502
503 sh_println!(
504 "{}",
505 Cast::new(&provider).transaction(tx_hash, from, nonce, field, raw).await?
506 )?
507 }
508
509 CastSubcommand::FourByte { selector } => {
511 let selector = stdin::unwrap_line(selector)?;
512 let sigs = decode_function_selector(selector).await?;
513 if sigs.is_empty() {
514 eyre::bail!("No matching function signatures found for selector `{selector}`");
515 }
516 for sig in sigs {
517 sh_println!("{sig}")?
518 }
519 }
520
521 CastSubcommand::FourByteCalldata { calldata } => {
522 let calldata = stdin::unwrap_line(calldata)?;
523
524 if calldata.len() == 10 {
525 let sigs = decode_function_selector(calldata.parse()?).await?;
526 if sigs.is_empty() {
527 eyre::bail!("No matching function signatures found for calldata `{calldata}`");
528 }
529 for sig in sigs {
530 sh_println!("{sig}")?
531 }
532 return Ok(());
533 }
534
535 let sigs = decode_calldata(&calldata).await?;
536 sigs.iter().enumerate().for_each(|(i, sig)| {
537 let _ = sh_println!("{}) \"{sig}\"", i + 1);
538 });
539
540 let sig = match sigs.len() {
541 0 => eyre::bail!("No signatures found"),
542 1 => sigs.first().unwrap(),
543 _ => {
544 let i: usize = prompt!("Select a function signature by number: ")?;
545 sigs.get(i - 1).ok_or_else(|| eyre::eyre!("Invalid signature index"))?
546 }
547 };
548
549 let tokens = SimpleCast::calldata_decode(sig, &calldata, true)?;
550 print_tokens(&tokens);
551 }
552
553 CastSubcommand::FourByteEvent { topic } => {
554 let topic = stdin::unwrap_line(topic)?;
555 let sigs = decode_event_topic(topic).await?;
556 if sigs.is_empty() {
557 eyre::bail!("No matching event signatures found for topic `{topic}`");
558 }
559 for sig in sigs {
560 sh_println!("{sig}")?
561 }
562 }
563 CastSubcommand::UploadSignature { signatures } => {
564 let signatures = stdin::unwrap_vec(signatures)?;
565 let ParsedSignatures { signatures, abis } = parse_signatures(signatures);
566 if !abis.is_empty() {
567 import_selectors(SelectorImportData::Abi(abis)).await?.describe();
568 }
569 if !signatures.is_empty() {
570 import_selectors(SelectorImportData::Raw(signatures)).await?.describe();
571 }
572 }
573
574 CastSubcommand::Namehash { name } => {
576 let name = stdin::unwrap_line(name)?;
577 sh_println!("{}", namehash(&name))?
578 }
579 CastSubcommand::LookupAddress { who, rpc, verify } => {
580 let config = rpc.load_config()?;
581 let provider = utils::get_provider(&config)?;
582
583 let who = stdin::unwrap_line(who)?;
584 let name = provider.lookup_address(&who).await?;
585 if verify {
586 let address = provider.resolve_name(&name).await?;
587 eyre::ensure!(
588 address == who,
589 "Reverse lookup verification failed: got `{address}`, expected `{who}`"
590 );
591 }
592 sh_println!("{name}")?
593 }
594 CastSubcommand::ResolveName { who, rpc, verify } => {
595 let config = rpc.load_config()?;
596 let provider = utils::get_provider(&config)?;
597
598 let who = stdin::unwrap_line(who)?;
599 let address = provider.resolve_name(&who).await?;
600 if verify {
601 let name = provider.lookup_address(&address).await?;
602 eyre::ensure!(
603 name == who,
604 "Forward lookup verification failed: got `{name}`, expected `{who}`"
605 );
606 }
607 sh_println!("{address}")?
608 }
609
610 CastSubcommand::Keccak { data } => {
612 let bytes = match data {
613 Some(data) => data.into_bytes(),
614 None => stdin::read_bytes(false)?,
615 };
616 match String::from_utf8(bytes) {
617 Ok(s) => {
618 let s = SimpleCast::keccak(&s)?;
619 sh_println!("{s}")?
620 }
621 Err(e) => {
622 let hash = keccak256(e.as_bytes());
623 let s = hex::encode(hash);
624 sh_println!("0x{s}")?
625 }
626 };
627 }
628 CastSubcommand::HashMessage { message } => {
629 let message = stdin::unwrap(message, false)?;
630 sh_println!("{}", eip191_hash_message(message))?
631 }
632 CastSubcommand::SigEvent { event_string } => {
633 let event_string = stdin::unwrap_line(event_string)?;
634 let parsed_event = get_event(&event_string)?;
635 sh_println!("{:?}", parsed_event.selector())?
636 }
637 CastSubcommand::LeftShift { value, bits, base_in, base_out } => sh_println!(
638 "{}",
639 SimpleCast::left_shift(&value, &bits, base_in.as_deref(), &base_out)?
640 )?,
641 CastSubcommand::RightShift { value, bits, base_in, base_out } => sh_println!(
642 "{}",
643 SimpleCast::right_shift(&value, &bits, base_in.as_deref(), &base_out)?
644 )?,
645 CastSubcommand::Source {
646 address,
647 directory,
648 explorer_api_url,
649 explorer_url,
650 etherscan,
651 flatten,
652 } => {
653 let config = etherscan.load_config()?;
654 let chain = config.chain.unwrap_or_default();
655 let api_key = config.get_etherscan_api_key(Some(chain));
656 match (directory, flatten) {
657 (Some(dir), false) => {
658 SimpleCast::expand_etherscan_source_to_directory(
659 chain,
660 address,
661 api_key,
662 dir,
663 explorer_api_url,
664 explorer_url,
665 )
666 .await?
667 }
668 (None, false) => sh_println!(
669 "{}",
670 SimpleCast::etherscan_source(
671 chain,
672 address,
673 api_key,
674 explorer_api_url,
675 explorer_url
676 )
677 .await?
678 )?,
679 (dir, true) => {
680 SimpleCast::etherscan_source_flatten(
681 chain,
682 address,
683 api_key,
684 dir,
685 explorer_api_url,
686 explorer_url,
687 )
688 .await?;
689 }
690 }
691 }
692 CastSubcommand::Create2(cmd) => {
693 cmd.run()?;
694 }
695 CastSubcommand::Wallet { command } => command.run().await?,
696 CastSubcommand::Completions { shell } => {
697 generate(shell, &mut CastArgs::command(), "cast", &mut std::io::stdout())
698 }
699 CastSubcommand::GenerateFigSpec => clap_complete::generate(
700 clap_complete_fig::Fig,
701 &mut CastArgs::command(),
702 "cast",
703 &mut std::io::stdout(),
704 ),
705 CastSubcommand::Logs(cmd) => cmd.run().await?,
706 CastSubcommand::DecodeTransaction { tx } => {
707 let tx = stdin::unwrap_line(tx)?;
708 let tx = SimpleCast::decode_raw_transaction(&tx)?;
709
710 if let Ok(signer) = tx.recover_signer() {
711 let recovered = Recovered::new_unchecked(tx, signer);
712 sh_println!("{}", serde_json::to_string_pretty(&recovered)?)?;
713 } else {
714 sh_println!("{}", serde_json::to_string_pretty(&tx)?)?;
715 }
716 }
717 CastSubcommand::TxPool { command } => command.run().await?,
718 CastSubcommand::DAEstimate(cmd) => {
719 cmd.run().await?;
720 }
721 };
722
723 fn print_tokens(tokens: &[DynSolValue]) {
728 if shell::is_json() {
729 let tokens: Vec<String> = format_tokens_raw(tokens).collect();
730 let _ = sh_println!("{}", serde_json::to_string_pretty(&tokens).unwrap());
731 } else {
732 let tokens = format_tokens(tokens);
733 tokens.for_each(|t| {
734 let _ = sh_println!("{t}");
735 });
736 }
737 }
738
739 Ok(())
740}