fix: display max_fee as int (#763)

<!-- Reference any GitHub issues resolved by this PR -->

Closes #410 

## Introduced changes

<!-- A brief description of the changes -->

- display `max_fee` as int unless `--hex-format` is specified for it

## Breaking changes

<!-- List of all breaking changes, if applicable -->

## Checklist

<!-- Make sure all of these are complete -->

- [x] Linked relevant issue
- [x] Updated relevant documentation
- [x] Added relevant tests
- [x] Performed self-review of the code
- [x] Added changes to `CHANGELOG.md`

Author: itzlambda

CHANGELOG.md

@@ -28,6 +28,10 @@ Read more [here](https://foundry-rs.github.io/starknet-foundry/appendix/forge.ht
 
 - `show-config` subcommand to display currently used configuration
 - `account delete` command for removing accounts from the accounts file
+- `--hex-format` flag has been added
+
+#### Removed
+- `-i` short for `--int-format` is removed, now have to use the full form `--int-format`
 
 ## [0.8.3] - 2023-10-17
 

crates/cast/src/helpers/response_structs.rs

@@ -27,7 +27,7 @@ pub struct CallResponse {
 #[derive(Serialize)]
 pub struct AccountCreateResponse {
     pub address: FieldElement,
-    pub max_fee: FieldElement,
+    pub max_fee: u64,
     pub add_profile: String,
 }
 

crates/cast/src/lib.rs

@@ -1,7 +1,6 @@
 use anyhow::{anyhow, bail, Context, Error, Result};
 use camino::Utf8PathBuf;
 use helpers::constants::{DEFAULT_RETRIES, KEYSTORE_PASSWORD_ENV_VAR, UDC_ADDRESS};
-use primitive_types::U256;
 use rand::rngs::OsRng;
 use rand::RngCore;
 use serde::{Deserialize, Serialize};
@@ -33,6 +32,7 @@ use starknet::{
     providers::{MaybeUnknownErrorCode, StarknetErrorWithMessage},
 };
 use std::collections::HashMap;
+use std::str::FromStr;
 use std::thread::sleep;
 use std::time::Duration;
 use std::{env, fs};
@@ -50,6 +50,38 @@ struct Account {
     class_hash: Option<String>,
 }
 
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum ValueFormat {
+    // Addresses as hex, fees as int
+    Default,
+    // everything as int
+    Int,
+    // everything as hex
+    Hex,
+}
+
+impl ValueFormat {
+    #[must_use]
+    pub fn format_u64(&self, input: u64) -> String {
+        match self {
+            ValueFormat::Default | ValueFormat::Int => format!("{input}"),
+            ValueFormat::Hex => format!("{input:#x}"),
+        }
+    }
+
+    #[must_use]
+    pub fn format_str(&self, input: &str) -> String {
+        if let Ok(field) = FieldElement::from_str(input) {
+            return match self {
+                ValueFormat::Int => format!("{field:#}"),
+                ValueFormat::Hex | ValueFormat::Default => format!("{field:#x}"),
+            };
+        }
+
+        input.to_string()
+    }
+}
+
 pub fn get_provider(url: &str) -> Result<JsonRpcClient<HttpTransport>> {
     raise_if_empty(url, "RPC url")?;
     let parsed_url = Url::parse(url)?;
@@ -305,25 +337,7 @@ pub async fn handle_wait_for_tx<T>(
     Ok(return_value)
 }
 
-pub fn print_formatted(
-    mut output: Vec<(&str, String)>,
-    int_format: bool,
-    json: bool,
-    error: bool,
-) -> Result<()> {
-    if !int_format {
-        output = output
-            .into_iter()
-            .map(|(key, value)| {
-                if let Ok(int_value) = U256::from_dec_str(&value) {
-                    (key, format!("{int_value:#x}"))
-                } else {
-                    (key, value)
-                }
-            })
-            .collect();
-    }
-
+pub fn print_formatted(output: Vec<(&str, String)>, json: bool, error: bool) -> Result<()> {
     if json {
         let json_output: HashMap<&str, String> = output.into_iter().collect();
         let json_value: Value = serde_json::to_value(json_output)?;
@@ -341,7 +355,7 @@ pub fn print_formatted(
 pub fn print_command_result<T: Serialize>(
     command: &str,
     result: &mut Result<T>,
-    int_format: bool,
+    value_format: ValueFormat,
     json: bool,
 ) -> Result<()> {
     let mut output = vec![("command", command.to_string())];
@@ -359,8 +373,16 @@ pub fn print_command_result<T: Serialize>(
                     .expect("Invalid JSON value")
                     .iter()
                     .filter_map(|(k, v)| {
-                        // skip values that are not convertable to string
-                        v.as_str().map(|value| (k.as_str(), value.to_string()))
+                        let value = match v {
+                            Value::Number(n) => {
+                                let n = n.as_u64().expect("found unexpected value");
+                                value_format.format_u64(n)
+                            }
+                            Value::String(s) => value_format.format_str(s),
+                            _ => return None,
+                        };
+
+                        Some((k.as_str(), value))
                     })
                     .collect::<Vec<(&str, String)>>(),
             );
@@ -370,7 +392,7 @@ pub fn print_command_result<T: Serialize>(
             error = true;
         }
     };
-    print_formatted(output, int_format, json, error)
+    print_formatted(output, json, error)
 }
 
 fn write_to_output<T: std::fmt::Display>(value: T, error: bool) {

crates/cast/src/main.rs

@@ -10,7 +10,7 @@ use cast::helpers::constants::{DEFAULT_ACCOUNTS_FILE, DEFAULT_MULTICALL_CONTENTS
 use cast::helpers::scarb_utils::{parse_scarb_config, CastConfig};
 use cast::{
     chain_id_to_network_name, get_account, get_block_id, get_chain_id, get_provider,
-    print_command_result,
+    print_command_result, ValueFormat,
 };
 use clap::{Parser, Subcommand};
 
@@ -19,6 +19,7 @@ mod starknet_commands;
 #[derive(Parser)]
 #[command(version)]
 #[command(about = "Cast - a Starknet Foundry CLI", long_about = None)]
+#[allow(clippy::struct_excessive_bools)]
 struct Cli {
     /// Profile name in Scarb.toml config file
     #[clap(short, long)]
@@ -46,10 +47,14 @@ struct Cli {
     #[clap(short, long)]
     keystore: Option<Utf8PathBuf>,
 
-    /// If passed, values will be displayed as integers, otherwise as hexes
-    #[clap(short, long)]
+    /// If passed, values will be displayed as integers
+    #[clap(long, conflicts_with = "hex_format")]
     int_format: bool,
 
+    /// If passed, values will be displayed as hex
+    #[clap(long, conflicts_with = "int_format")]
+    hex_format: bool,
+
     /// If passed, output will be displayed in json format
     #[clap(short, long)]
     json: bool,
@@ -91,6 +96,15 @@ enum Commands {
 async fn main() -> Result<()> {
     let cli = Cli::parse();
 
+    // Clap validates that both are not passed at same time
+    let value_format = if cli.hex_format {
+        ValueFormat::Hex
+    } else if cli.int_format {
+        ValueFormat::Int
+    } else {
+        ValueFormat::Default
+    };
+
     let mut config = parse_scarb_config(&cli.profile, &cli.path_to_scarb_toml)?;
     update_cast_config(&mut config, &cli);
 
@@ -114,7 +128,7 @@ async fn main() -> Result<()> {
             )
             .await;
 
-            print_command_result("declare", &mut result, cli.int_format, cli.json)?;
+            print_command_result("declare", &mut result, value_format, cli.json)?;
             Ok(())
         }
         Commands::Deploy(deploy) => {
@@ -136,7 +150,7 @@ async fn main() -> Result<()> {
             )
             .await;
 
-            print_command_result("deploy", &mut result, cli.int_format, cli.json)?;
+            print_command_result("deploy", &mut result, value_format, cli.json)?;
             Ok(())
         }
         Commands::Call(call) => {
@@ -151,7 +165,7 @@ async fn main() -> Result<()> {
             )
             .await;
 
-            print_command_result("call", &mut result, cli.int_format, cli.json)?;
+            print_command_result("call", &mut result, value_format, cli.json)?;
             Ok(())
         }
         Commands::Invoke(invoke) => {
@@ -172,7 +186,7 @@ async fn main() -> Result<()> {
             )
             .await;
 
-            print_command_result("invoke", &mut result, cli.int_format, cli.json)?;
+            print_command_result("invoke", &mut result, value_format, cli.json)?;
             Ok(())
         }
         Commands::Multicall(multicall) => {
@@ -181,12 +195,7 @@ async fn main() -> Result<()> {
                     if let Some(output_path) = &new.output_path {
                         let mut result =
                             starknet_commands::multicall::new::new(output_path, new.overwrite);
-                        print_command_result(
-                            "multicall new",
-                            &mut result,
-                            cli.int_format,
-                            cli.json,
-                        )?;
+                        print_command_result("multicall new", &mut result, value_format, cli.json)?;
                     } else {
                         println!("{DEFAULT_MULTICALL_CONTENTS}");
                     }
@@ -207,7 +216,7 @@ async fn main() -> Result<()> {
                     )
                     .await;
 
-                    print_command_result("multicall run", &mut result, cli.int_format, cli.json)?;
+                    print_command_result("multicall run", &mut result, value_format, cli.json)?;
                 }
             }
             Ok(())
@@ -225,7 +234,7 @@ async fn main() -> Result<()> {
                 )
                 .await;
 
-                print_command_result("account add", &mut result, cli.int_format, cli.json)?;
+                print_command_result("account add", &mut result, value_format, cli.json)?;
                 Ok(())
             }
             account::Commands::Create(create) => {
@@ -246,10 +255,11 @@ async fn main() -> Result<()> {
                     create.salt,
                     create.add_profile,
                     create.class_hash,
+                    value_format,
                 )
                 .await;
 
-                print_command_result("account create", &mut result, cli.int_format, cli.json)?;
+                print_command_result("account create", &mut result, value_format, cli.json)?;
                 Ok(())
             }
             account::Commands::Deploy(deploy) => {
@@ -276,7 +286,7 @@ async fn main() -> Result<()> {
                 )
                 .await;
 
-                print_command_result("account deploy", &mut result, cli.int_format, cli.json)?;
+                print_command_result("account deploy", &mut result, value_format, cli.json)?;
                 Ok(())
             }
             account::Commands::Delete(delete) => {
@@ -296,7 +306,7 @@ async fn main() -> Result<()> {
                     &network_name,
                 );
 
-                print_command_result("account delete", &mut result, cli.int_format, cli.json)?;
+                print_command_result("account delete", &mut result, value_format, cli.json)?;
                 Ok(())
             }
         },
@@ -308,7 +318,7 @@ async fn main() -> Result<()> {
                 cli.path_to_scarb_toml,
             )
             .await;
-            print_command_result("show-config", &mut result, cli.int_format, cli.json)?;
+            print_command_result("show-config", &mut result, value_format, cli.json)?;
             Ok(())
         }
     }

crates/cast/src/starknet_commands/account/create.rs

@@ -6,7 +6,9 @@ use camino::Utf8PathBuf;
 use cast::helpers::constants::{CREATE_KEYSTORE_PASSWORD_ENV_VAR, OZ_CLASS_HASH};
 use cast::helpers::response_structs::AccountCreateResponse;
 use cast::helpers::scarb_utils::CastConfig;
-use cast::{extract_or_generate_salt, get_chain_id, get_keystore_password, parse_number};
+use cast::{
+    extract_or_generate_salt, get_chain_id, get_keystore_password, parse_number, ValueFormat,
+};
 use clap::Args;
 use serde_json::json;
 use starknet::accounts::{AccountFactory, OpenZeppelinAccountFactory};
@@ -48,6 +50,7 @@ pub async fn create(
     salt: Option<FieldElement>,
     add_profile: bool,
     class_hash: Option<String>,
+    value_format: ValueFormat,
 ) -> Result<AccountCreateResponse> {
     let salt = extract_or_generate_salt(salt);
     let class_hash = {
@@ -94,7 +97,9 @@ pub async fn create(
     let mut output = vec![("address", format!("{address:#x}"))];
     if account_json["deployed"] == json!(false) {
         println!("Account successfully created. Prefund generated address with at least {max_fee} tokens. It is good to send more in the case of higher demand, max_fee * 2 = {}", max_fee * 2);
-        output.push(("max_fee", format!("{max_fee:#x}")));
+        // For default and Int it should be in int
+        let max_fee_str = value_format.format_u64(max_fee);
+        output.push(("max_fee", max_fee_str));
     }
 
     if add_profile {
@@ -106,7 +111,7 @@ pub async fn create(
 
     Ok(AccountCreateResponse {
         address,
-        max_fee: FieldElement::from(max_fee),
+        max_fee,
         add_profile: if add_profile {
             "Profile successfully added to Scarb.toml".to_string()
         } else {