feat(cast): support short cut for querying erc20 balance in cast balance

crates/cast/bin/main.rs

@@ -2,17 +2,18 @@
 extern crate tracing;
 
 use alloy_primitives::{keccak256, Address, B256};
-use cast::{Cast, SimpleCast};
+use cast::{Cast, SimpleCast, TxBuilder};
 use clap::{CommandFactory, Parser};
 use clap_complete::generate;
-use ethers_core::types::{BlockId, BlockNumber::Latest};
+use ethers_core::types::{BlockId, BlockNumber::Latest, NameOrAddress};
 use ethers_providers::Middleware;
 use eyre::Result;
 use foundry_cli::{handler, prompt, stdin, utils};
 use foundry_common::{
     abi::get_event,
     fmt::format_tokens,
     fs,
+    runtime_client::RuntimeClient,
     selectors::{
         decode_calldata, decode_event_topic, decode_function_selector, import_selectors,
         parse_signatures, pretty_calldata, ParsedSignatures, SelectorImportData,
@@ -26,6 +27,7 @@ pub mod cmd;
 pub mod opts;
 
 use opts::{Opts, Subcommands, ToBaseArgs};
+type Provider = ethers_providers::Provider<RuntimeClient>;
 
 #[tokio::main]
 async fn main() -> Result<()> {
@@ -200,14 +202,44 @@ async fn main() -> Result<()> {
                 Cast::new(provider).age(block.unwrap_or(BlockId::Number(Latest))).await?
             );
         }
-        Subcommands::Balance { block, who, ether, rpc } => {
+        Subcommands::Balance { block, who, ether, rpc, token } => {
             let config = Config::from(&rpc);
             let provider = utils::get_provider(&config)?;
-            let value = Cast::new(provider).balance(who, block).await?;
-            if ether {
-                println!("{}", SimpleCast::from_wei(&value.to_string(), "eth")?);
-            } else {
-                println!("{value}");
+
+            match token {
+                Some(token) => {
+                    let chain = utils::get_chain(config.chain, &provider).await?;
+                    let mut builder: TxBuilder<'_, Provider> = TxBuilder::new(
+                        &provider,
+                        NameOrAddress::Address(Address::ZERO.to_ethers()),
+                        Some(NameOrAddress::Address(token.to_ethers())),
+                        chain,
+                        true,
+                    )
+                    .await?;
+
+                    let account_addr = match who {
+                        NameOrAddress::Name(ens_name) => provider.resolve_name(&ens_name).await?,
+                        NameOrAddress::Address(addr) => addr,
+                    };
+
+                    builder
+                        .set_args(
+                            "balanceOf(address) returns (uint256)",
+                            vec![format!("{account_addr:#x}")],
+                        )
+                        .await?;
+                    let builder_output = builder.build();
+                    println!("{}", Cast::new(provider).call(builder_output, block).await?);
+                }
+                None => {
+                    let value = Cast::new(provider).balance(who, block).await?;
+                    if ether {
+                        println!("{}", SimpleCast::from_wei(&value.to_string(), "eth")?);
+                    } else {
+                        println!("{value}");
+                    }
+                }
             }
         }
         Subcommands::BaseFee { block, rpc } => {

crates/cast/bin/opts.rs

@@ -625,6 +625,10 @@ pub enum Subcommands {
 
         #[clap(flatten)]
         rpc: RpcOpts,
+
+        /// Token address to query, with the method `balanceOf(address) return (uint256)`
+        #[clap(short, long)]
+        token: Option<Address>,
     },
 
     /// Get the basefee of a block.