feat(cast,common): calldata-decode, abi-decode, and 4byte-decode json flag (#8494)

* add calldata-decode json flag

* use print_tokens for calldata-decate, abi-decode, and 4byte-decode

* fix clippy

Author: minhd-vu

crates/cast/bin/main.rs

@@ -12,7 +12,7 @@ use foundry_cli::{handler, prompt, stdin, utils};
 use foundry_common::{
     abi::get_event,
     ens::{namehash, ProviderEnsExt},
-    fmt::{format_tokens, format_uint_exp},
+    fmt::{format_uint_exp, print_tokens},
     fs,
     selectors::{
         decode_calldata, decode_event_topic, decode_function_selector, decode_selectors,
@@ -163,10 +163,9 @@ async fn main() -> Result<()> {
         }
 
         // ABI encoding & decoding
-        CastSubcommand::AbiDecode { sig, calldata, input } => {
+        CastSubcommand::AbiDecode { sig, calldata, input, json } => {
             let tokens = SimpleCast::abi_decode(&sig, &calldata, input)?;
-            let tokens = format_tokens(&tokens);
-            tokens.for_each(|t| println!("{t}"));
+            print_tokens(&tokens, json)
         }
         CastSubcommand::AbiEncode { sig, packed, args } => {
             if !packed {
@@ -175,10 +174,9 @@ async fn main() -> Result<()> {
                 println!("{}", SimpleCast::abi_encode_packed(&sig, &args)?);
             }
         }
-        CastSubcommand::CalldataDecode { sig, calldata } => {
+        CastSubcommand::CalldataDecode { sig, calldata, json } => {
             let tokens = SimpleCast::calldata_decode(&sig, &calldata, true)?;
-            let tokens = format_tokens(&tokens);
-            tokens.for_each(|t| println!("{t}"));
+            print_tokens(&tokens, json)
         }
         CastSubcommand::CalldataEncode { sig, args } => {
             println!("{}", SimpleCast::calldata_encode(sig, &args)?);
@@ -425,7 +423,7 @@ async fn main() -> Result<()> {
                 println!("{sig}");
             }
         }
-        CastSubcommand::FourByteDecode { calldata } => {
+        CastSubcommand::FourByteDecode { calldata, json } => {
             let calldata = stdin::unwrap_line(calldata)?;
             let sigs = decode_calldata(&calldata).await?;
             sigs.iter().enumerate().for_each(|(i, sig)| println!("{}) \"{sig}\"", i + 1));
@@ -440,9 +438,7 @@ async fn main() -> Result<()> {
             };
 
             let tokens = SimpleCast::calldata_decode(sig, &calldata, true)?;
-            for token in format_tokens(&tokens) {
-                println!("{token}");
-            }
+            print_tokens(&tokens, json)
         }
         CastSubcommand::FourByteEvent { topic } => {
             let topic = stdin::unwrap_line(topic)?;

crates/cast/bin/opts.rs

@@ -490,6 +490,10 @@ pub enum CastSubcommand {
 
         /// The ABI-encoded calldata.
         calldata: String,
+
+        /// Print the decoded calldata as JSON.
+        #[arg(long, short, help_heading = "Display options")]
+        json: bool,
     },
 
     /// Decode ABI-encoded input or output data.
@@ -508,6 +512,10 @@ pub enum CastSubcommand {
         /// Whether to decode the input or output data.
         #[arg(long, short, help_heading = "Decode input data instead of output data")]
         input: bool,
+
+        /// Print the decoded calldata as JSON.
+        #[arg(long, short, help_heading = "Display options")]
+        json: bool,
     },
 
     /// ABI encode the given function argument, excluding the selector.
@@ -594,6 +602,10 @@ pub enum CastSubcommand {
     FourByteDecode {
         /// The ABI-encoded calldata.
         calldata: Option<String>,
+
+        /// Print the decoded calldata as JSON.
+        #[arg(long, short, help_heading = "Display options")]
+        json: bool,
     },
 
     /// Get the event signature for a given topic 0 from https://openchain.xyz.

crates/common/fmt/src/dynamic.rs

@@ -119,6 +119,23 @@ pub fn format_tokens(tokens: &[DynSolValue]) -> impl Iterator<Item = String> + '
     tokens.iter().map(format_token)
 }
 
+/// Pretty-prints a slice of tokens using [`format_token_raw`].
+pub fn format_tokens_raw(tokens: &[DynSolValue]) -> impl Iterator<Item = String> + '_ {
+    tokens.iter().map(format_token_raw)
+}
+
+/// Prints slice of tokens using [`format_tokens`] or [`format_tokens_raw`] depending on `json`
+/// parameter.
+pub fn print_tokens(tokens: &[DynSolValue], json: bool) {
+    if json {
+        let tokens: Vec<String> = format_tokens_raw(tokens).collect();
+        println!("{}", serde_json::to_string_pretty(&tokens).unwrap());
+    } else {
+        let tokens = format_tokens(tokens);
+        tokens.for_each(|t| println!("{t}"));
+    }
+}
+
 /// Pretty-prints the given value into a string suitable for user output.
 pub fn format_token(value: &DynSolValue) -> String {
     DynValueDisplay::new(value, false).to_string()

crates/common/fmt/src/lib.rs

@@ -4,7 +4,9 @@ mod console;
 pub use console::{console_format, ConsoleFmt, FormatSpec};
 
 mod dynamic;
-pub use dynamic::{format_token, format_token_raw, format_tokens, parse_tokens};
+pub use dynamic::{
+    format_token, format_token_raw, format_tokens, format_tokens_raw, parse_tokens, print_tokens,
+};
 
 mod exp;
 pub use exp::{format_int_exp, format_uint_exp, to_exp_notation};