Use serde_json instead of serde_json_wasm

Author: webmaster128

Cargo.lock

@@ -65,9 +65,7 @@ hex = "0.4"
 schemars = { workspace = true }
 sha2 = "0.10.3"
 serde = { workspace = true, features = ["std"] }
-serde-json-wasm = { version = "1.0.1", default-features = false, features = [
-    "std",
-] }
+serde_json = "1.0.81"
 static_assertions = "1.1.0"
 thiserror = "1.0.26"
 rmp-serde = "1.3.0"
@@ -93,4 +91,3 @@ proptest = { version = "1.5.0", default-features = false, features = [
     "attr-macro",
     "std",
 ] }
-serde_json = "1.0.81"

packages/std/Cargo.toml

@@ -896,7 +896,7 @@ impl<T> IbcReceiveResponse<T> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use serde_json_wasm::to_string;
+    use crate::to_json_string;
 
     #[test]
     // added this to check json format for go compat, as I was unsure how some messages are snake encoded
@@ -908,7 +908,7 @@ mod tests {
             timeout: IbcTimeout::with_timestamp(Timestamp::from_nanos(1234567890)),
             memo: None,
         };
-        let encoded = to_string(&msg).unwrap();
+        let encoded = to_json_string(&msg).unwrap();
         let expected = r#"{"transfer":{"channel_id":"channel-123","to_address":"my-special-addr","amount":{"denom":"uatom","amount":"12345678"},"timeout":{"block":null,"timestamp":"1234567890"},"memo":null}}"#;
         assert_eq!(encoded.as_str(), expected);
     }
@@ -917,14 +917,14 @@ mod tests {
     fn ibc_timeout_serialize() {
         let timestamp = IbcTimeout::with_timestamp(Timestamp::from_nanos(684816844));
         let expected = r#"{"block":null,"timestamp":"684816844"}"#;
-        assert_eq!(to_string(&timestamp).unwrap(), expected);
+        assert_eq!(to_json_string(&timestamp).unwrap(), expected);
 
         let block = IbcTimeout::with_block(IbcTimeoutBlock {
             revision: 12,
             height: 129,
         });
         let expected = r#"{"block":{"revision":12,"height":129},"timestamp":null}"#;
-        assert_eq!(to_string(&block).unwrap(), expected);
+        assert_eq!(to_json_string(&block).unwrap(), expected);
 
         let both = IbcTimeout::with_both(
             IbcTimeoutBlock {
@@ -934,7 +934,7 @@ mod tests {
             Timestamp::from_nanos(684816844),
         );
         let expected = r#"{"block":{"revision":12,"height":129},"timestamp":"684816844"}"#;
-        assert_eq!(to_string(&both).unwrap(), expected);
+        assert_eq!(to_json_string(&both).unwrap(), expected);
     }
 
     #[test]
@@ -998,7 +998,7 @@ mod tests {
             ),
         };
         let expected = r#"{"data":"Zm9v","src":{"port_id":"their-port","channel_id":"channel-1234"},"dest":{"port_id":"our-port","channel_id":"chan33"},"sequence":27,"timeout":{"block":{"revision":1,"height":12345678},"timestamp":"4611686018427387904"}}"#;
-        assert_eq!(to_string(&packet).unwrap(), expected);
+        assert_eq!(to_json_string(&packet).unwrap(), expected);
 
         let no_timestamp = IbcPacket {
             data: b"foo".into(),
@@ -1017,6 +1017,6 @@ mod tests {
             }),
         };
         let expected = r#"{"data":"Zm9v","src":{"port_id":"their-port","channel_id":"channel-1234"},"dest":{"port_id":"our-port","channel_id":"chan33"},"sequence":27,"timeout":{"block":{"revision":1,"height":12345678},"timestamp":null}}"#;
-        assert_eq!(to_string(&no_timestamp).unwrap(), expected);
+        assert_eq!(to_json_string(&no_timestamp).unwrap(), expected);
     }
 }

packages/std/src/ibc.rs

@@ -13,24 +13,23 @@ use crate::{StdError, StdResult};
 ///
 /// Errors if the input is not valid JSON or cannot be deserialized to the given type.
 pub fn from_json<T: DeserializeOwned>(value: impl AsRef<[u8]>) -> StdResult<T> {
-    serde_json_wasm::from_slice(value.as_ref())
-        .map_err(|e| StdError::parse_err(type_name::<T>(), e))
+    serde_json::from_slice(value.as_ref()).map_err(|e| StdError::parse_err(type_name::<T>(), e))
 }
 
 /// Serializes the given data structure as a JSON byte vector.
 pub fn to_json_vec<T>(data: &T) -> StdResult<Vec<u8>>
 where
     T: Serialize + ?Sized,
 {
-    serde_json_wasm::to_vec(data).map_err(|e| StdError::serialize_err(type_name::<T>(), e))
+    serde_json::to_vec(data).map_err(|e| StdError::serialize_err(type_name::<T>(), e))
 }
 
 /// Serializes the given data structure as a JSON string.
 pub fn to_json_string<T>(data: &T) -> StdResult<String>
 where
     T: Serialize + ?Sized,
 {
-    serde_json_wasm::to_string(data).map_err(|e| StdError::serialize_err(type_name::<T>(), e))
+    serde_json::to_string(data).map_err(|e| StdError::serialize_err(type_name::<T>(), e))
 }
 
 /// Serializes the given data structure as JSON bytes.

packages/std/src/serde.rs

@@ -2637,7 +2637,7 @@ mod tests {
         });
         match result {
             SystemResult::Ok(ContractResult::Err(err)) => {
-                assert_eq!(err, "Error parsing into type cosmwasm_std::testing::mock::tests::wasm_querier_works::{{closure}}::MyMsg: Invalid type")
+                assert_eq!(err, "Error parsing into type cosmwasm_std::testing::mock::tests::wasm_querier_works::{{closure}}::MyMsg: expected value at line 1 column 1")
             }
             res => panic!("Unexpected result: {res:?}"),
         }