fix(cast): consistent serialization of Uint/Ints depending on actual type

The current implementation dynamically tries to determine if the runtime
value can fit in 64 bits, but this leads to inconsistent serialization.
For instance if you were decoding an `uint[]`, some of the values that
fit in 64 bits will serialize as number while others serialize as string
making it require special handling on the user that is consuming the
json. This change makes it so it uses the type information to determine
the serialization. So the user will always know that specific types
will always serialize to a number or a string depending on the number
of bits that type uses.

Author: 0xferrous

crates/cast/tests/cli/selectors.rs

@@ -140,7 +140,7 @@ casttest!(event_decode_with_sig, |_prj, cmd| {
 
     cmd.args(["--json"]).assert_success().stdout_eq(str![[r#"
 [
-  78,
+  "78",
   "0x0000000000000000000000000000000000D0004F"
 ]
 
@@ -168,7 +168,7 @@ casttest!(error_decode_with_sig, |_prj, cmd| {
 
     cmd.args(["--json"]).assert_success().stdout_eq(str![[r#"
 [
-  101,
+  "101",
   "0x0000000000000000000000000000000000D0004F"
 ]
 

crates/cheatcodes/src/json.rs

@@ -590,10 +590,10 @@ fn _json_value_to_token(value: &Value, defs: &StructDefinitions) -> Result<DynSo
                     }
 
                     if let Ok(n) = s.parse() {
-                        return Ok(DynSolValue::Uint(n, 256));
+                        return Ok(DynSolValue::Uint(n, 64));
                     }
                     if let Ok(n) = s.parse() {
-                        return Ok(DynSolValue::Int(n, 256));
+                        return Ok(DynSolValue::Int(n, 64));
                     }
                 }
             }
@@ -624,13 +624,9 @@ fn _json_value_to_token(value: &Value, defs: &StructDefinitions) -> Result<DynSo
             // capacity of a 64-bit integer.
             // Note that number-like strings that *could* fit in an `i64`/`u64` will fall through
             // and be treated as literal strings.
-            if let Ok(n) = string.parse::<I256>()
-                && i64::try_from(n).is_err()
-            {
+            if let Ok(n) = string.parse::<I256>() {
                 return Ok(DynSolValue::Int(n, 256));
-            } else if let Ok(n) = string.parse::<U256>()
-                && u64::try_from(n).is_err()
-            {
+            } else if let Ok(n) = string.parse::<U256>() {
                 return Ok(DynSolValue::Uint(n, 256));
             }
 
@@ -1064,7 +1060,7 @@ mod tests {
         // Serialize the value to JSON and verify that the order is preserved.
         let json_value = serialize_value_as_json(item_struct, Some(&struct_defs.into())).unwrap();
         let json_string = serde_json::to_string(&json_value).unwrap();
-        assert_eq!(json_string, r#"{"name":"Test Item","id":123,"active":true}"#);
+        assert_eq!(json_string, r#"{"name":"Test Item","id":"123","active":true}"#);
     }
 
     #[test]
@@ -1100,7 +1096,7 @@ mod tests {
         let json_string = serde_json::to_string(&json_value).unwrap();
         assert_eq!(
             json_string,
-            format!(r#"{{"owner":"{owner_address}","balance":5000,"id":"{wallet_id}"}}"#)
+            format!(r#"{{"owner":"{owner_address}","balance":"5000","id":"{wallet_id}"}}"#)
         );
 
         // Resolve the type, which should also respect the struct definition order.

crates/common/fmt/src/dynamic.rs

@@ -175,20 +175,20 @@ fn _serialize_value_as_json(value: DynSolValue, defs: &StructDefinitions) -> Res
         }
         DynSolValue::Bytes(b) => Ok(Value::String(hex::encode_prefixed(b))),
         DynSolValue::FixedBytes(b, size) => Ok(Value::String(hex::encode_prefixed(&b[..size]))),
-        DynSolValue::Int(i, _) => {
-            if let Ok(n) = i64::try_from(i) {
+        DynSolValue::Int(i, bits) => {
+            if bits <= 64 {
                 // Use `serde_json::Number` if the number can be accurately represented.
-                Ok(Value::Number(n.into()))
+                Ok(Value::Number(TryInto::<i64>::try_into(i)?.into()))
             } else {
                 // Otherwise, fallback to its string representation to preserve precision and ensure
                 // compatibility with alloy's `DynSolType` coercion.
                 Ok(Value::String(i.to_string()))
             }
         }
-        DynSolValue::Uint(i, _) => {
-            if let Ok(n) = u64::try_from(i) {
+        DynSolValue::Uint(i, bits) => {
+            if bits <= 64 {
                 // Use `serde_json::Number` if the number can be accurately represented.
-                Ok(Value::Number(n.into()))
+                Ok(Value::Number(TryInto::<u64>::try_into(i)?.into()))
             } else {
                 // Otherwise, fallback to its string representation to preserve precision and ensure
                 // compatibility with alloy's `DynSolType` coercion.

testdata/default/cheats/Toml.t.sol

@@ -412,7 +412,7 @@ contract WriteTomlTest is DSTest {
     function test_writeToml() public {
         string memory json3 = "json3";
         string memory path = "fixtures/Toml/write_test.toml";
-        vm.serializeUint(json3, "a", uint256(123));
+        vm.serializeUint(json3, "a", uint64(123));
         string memory finalJson = vm.serializeString(json3, "b", "test");
         vm.writeToml(finalJson, path);
 

testdata/fixtures/Json/write_complex_test.json

@@ -1,8 +1,8 @@
 {
-  "a": 123,
+  "a": "123",
   "b": "test",
   "c": {
-    "a": 123,
+    "a": "123",
     "b": "test"
   }
 }

testdata/fixtures/Json/write_test.json

@@ -1,4 +1,4 @@
 {
-  "a": 123,
+  "a": "123",
   "b": "0x000000000000000000000000000000000000bEEF"
-}
+}

testdata/fixtures/Toml/write_complex_test.toml

@@ -1,6 +1,6 @@
-a = 123
+a = "123"
 b = "test"
 
 [c]
-a = 123
+a = "123"
 b = "test"

testdata/fixtures/Toml/write_test.toml

@@ -1,2 +1,2 @@
-a = 123
+a = "123"
 b = "0x000000000000000000000000000000000000bEEF"