fix: Fix serde_as and ordering of the fields in AsNep297Event (#1405)

Author: pityjllk

near-sdk-macros/Cargo.toml

@@ -23,7 +23,7 @@ quote = { version = "1.0", default-features = false }
 Inflector = { version = "0.11.4", default-features = false, features = [] }
 darling = { version = "0.20.3", default-features = false }
 serde = { version = "1", default-features = false, features = ["serde_derive"] }
-serde_json = { version = "1", features = ["preserve_order"] }
+serde_json = { version = "1" }
 
 [dev-dependencies]
 insta = { version = "1.31.0", features = ["yaml"] }

near-sdk-macros/src/lib.rs

@@ -161,6 +161,22 @@ pub fn near(attr: TokenStream, item: TokenStream) -> TokenStream {
         }
     }
 
+    // Add serde_as BEFORE schema_derive so that serde_with can process
+    // the schemars = true parameter and inject schema attributes before
+    // JsonSchema derive macro runs
+    if has_json {
+        let enable_schemars = cfg!(feature = "abi").then_some(quote! {schemars = true,});
+        expanded = quote! {
+            #expanded
+            #[#near_sdk_crate::serde_with::serde_as(
+                crate = #string_serde_with_crate,
+                #enable_schemars
+            )]
+            #[derive(#near_sdk_crate::serde::Serialize, #near_sdk_crate::serde::Deserialize)]
+            #[serde(crate = #string_serde_crate)]
+        };
+    }
+
     #[cfg(feature = "abi")]
     {
         let schema_derive: proc_macro2::TokenStream =
@@ -179,19 +195,6 @@ pub fn near(attr: TokenStream, item: TokenStream) -> TokenStream {
         };
     }
 
-    if has_json {
-        let enable_schemars = cfg!(feature = "abi").then_some(quote! {schemars = true,});
-        expanded = quote! {
-            #expanded
-            #[#near_sdk_crate::serde_with::serde_as(
-                crate = #string_serde_with_crate,
-                #enable_schemars
-            )]
-            #[derive(#near_sdk_crate::serde::Serialize, #near_sdk_crate::serde::Deserialize)]
-            #[serde(crate = #string_serde_crate)]
-        };
-    }
-
     if let Ok(input) = syn::parse::<ItemStruct>(item.clone()) {
         expanded = quote! {
             #expanded

near-sdk/Cargo.toml

@@ -20,7 +20,7 @@ required-features = ["abi", "unstable"]
 [dependencies]
 # Provide near_bidgen macros.
 serde = { version = "1", features = ["derive"] }
-serde_json = "1"
+serde_json = { version = "1", features = ["preserve_order"] }
 serde_with = { version = "3", features = ["base64", "hex", "json"] }
 near-sdk-macros = { path = "../near-sdk-macros", version = "~5.17.2" }
 near-sys = { path = "../near-sys", version = "0.2.5" }

near-sdk/src/lib.rs

@@ -353,27 +353,30 @@ compile_error!(
 /// You can also use [`#[serde_as(as = "...")]` attributes](https://docs.rs/serde_with/latest/serde_with/attr.serde_as.html)
 /// as if `#[serde_as]` is added to the type (which is what actually happens under the hood of `#[near(serializers = [json])]` implementation).
 ///
+/// Note: When using the `abi` feature with base64/hex encoding, prefer the SDK's [`json_types`](crate::json_types)
+/// like [`Base64VecU8`](crate::json_types::Base64VecU8), which have full JSON Schema support.
+///
+/// For hex encoding with ABI support, you can use `#[serde_as(as = "serde_with::hex::Hex")]` by enabling
+/// the `serde_with/schemars_1` feature in your `Cargo.toml` (this requires upgrading to schemars 1.x).
+///
 /// ```
-/// # use std::{collections::BTreeMap};
+/// # use std::collections::BTreeMap;
 /// use near_sdk::{
 ///     near,
 ///     serde_json::json,
-///     serde_with::{base64::Base64, hex::Hex, json::JsonString, DisplayFromStr},
+///     serde_with::{json::JsonString, DisplayFromStr},
+///     json_types::Base64VecU8,
 /// };
 ///
 /// #[near(serializers = [json])]
 /// pub struct MyStruct {
 ///     #[serde_as(as = "DisplayFromStr")]
 ///     pub amount: u128,
 ///
-///     #[serde_as(as = "Hex")]
-///     pub hex_bytes: Vec<u8>,
-///
-///     #[serde_as(as = "Base64")]
-///     pub base64_bytes: Vec<u8>,
+///     pub base64_bytes: Base64VecU8,
 ///
-///     #[serde_as(as = "BTreeMap<Hex, Vec<DisplayFromStr>>")]
-///     pub collection: BTreeMap<Vec<u8>, Vec<u128>>,
+///     #[serde_as(as = "BTreeMap<DisplayFromStr, Vec<DisplayFromStr>>")]
+///     pub collection: BTreeMap<u128, Vec<u128>>,
 ///
 ///     #[serde_as(as = "JsonString")]
 ///     pub json_string: serde_json::Value,
@@ -382,18 +385,16 @@ compile_error!(
 /// #     assert_eq!(
 /// #         serde_json::to_value(&MyStruct {
 /// #             amount: u128::MAX,
-/// #             hex_bytes: vec![0x1a, 0x2b, 0x3c],
-/// #             base64_bytes: vec![1, 2, 3],
-/// #             collection: [(vec![0x1a, 0x2b, 0x3c], vec![u128::MAX])].into(),
+/// #             base64_bytes: Base64VecU8::from(vec![1, 2, 3]),
+/// #             collection: [(u128::MAX, vec![100, 200, u128::MAX])].into(),
 /// #             json_string: json!({"key": "value"}),
 /// #         })
 /// #         .unwrap(),
 /// #         json!({
 /// #             "amount": "340282366920938463463374607431768211455",
-/// #             "hex_bytes": "1a2b3c",
 /// #             "base64_bytes": "AQID",
 /// #             "collection": {
-/// #                 "1a2b3c": ["340282366920938463463374607431768211455"],
+/// #                 "340282366920938463463374607431768211455": ["100", "200", "340282366920938463463374607431768211455"],
 /// #             },
 /// #             "json_string": "{\"key\":\"value\"}",
 /// #         })

near-sdk/tests/schema_u128_displayfromstr_tests.rs

@@ -0,0 +1,55 @@
+// Test for Vec<u128> field with serde_as using near-sdk's U128 type
+// Demonstrates that u128::MAX values in a vector can be properly serialized as strings,
+// since JSON doesn't support integers larger than 2^53-1
+
+use near_sdk::{json_types::U128, near, serde_with::FromInto};
+
+#[near(serializers = [json])]
+#[derive(Debug, Clone, PartialEq)]
+pub struct AmountWrapper {
+    #[serde_as(as = "Vec<FromInto<U128>>")]
+    pub amounts: Vec<u128>,
+}
+
+#[test]
+fn test_vec_u128_with_serde_as_u128() {
+    // u128::MAX = 340282366920938463463374607431768211455
+    // This value cannot be represented in JSON as a number (exceeds 2^53-1)
+    // Using serde_as with Vec<FromInto<U128>> serializes each element as a string
+
+    let wrapper = AmountWrapper { amounts: vec![0, 12345, u128::MAX / 2, u128::MAX] };
+    let json = serde_json::to_string(&wrapper).unwrap();
+    println!("Serialized Vec<u128>: {}", json);
+
+    let expected = r#"{"amounts":["0","12345","170141183460469231731687303715884105727","340282366920938463463374607431768211455"]}"#;
+    assert_eq!(
+        json, expected,
+        "Vec<u128> elements must be serialized as strings to avoid precision loss"
+    );
+
+    let deserialized: AmountWrapper = serde_json::from_str(&json).unwrap();
+    assert_eq!(deserialized.amounts[0], 0, "First element should be 0");
+    assert_eq!(deserialized.amounts[1], 12345, "Second element should be 12345");
+    assert_eq!(deserialized.amounts[2], u128::MAX / 2, "Third element should be u128::MAX / 2");
+    assert_eq!(deserialized.amounts[3], u128::MAX, "Fourth element should be u128::MAX");
+    assert_eq!(wrapper, deserialized, "Round-trip serialization must preserve all values");
+}
+
+#[cfg(feature = "abi")]
+#[test]
+fn test_vec_u128_schema_generation() {
+    use near_sdk::schemars::schema_for;
+    let schema = schema_for!(AmountWrapper);
+    let schema_json = serde_json::to_string_pretty(&schema).unwrap();
+
+    println!("Generated schema:\n{}", schema_json);
+
+    let schema_value: serde_json::Value = serde_json::from_str(&schema_json).unwrap();
+    let items_type = &schema_value["properties"]["amounts"]["items"]["type"];
+
+    assert_eq!(
+        items_type.as_str().unwrap(),
+        "string",
+        "Vec<u128> elements must have type 'string' in schema (not 'integer') to match serialization behavior"
+    );
+}