chore(jsonrpc): extract config primitives

chain/jsonrpc-primitives/Cargo.toml

@@ -13,14 +13,16 @@ description = "This crate hosts structures for the NEAR JSON RPC Requests, Respo
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+uuid = { version = "~0.8", features = ["v4"] }
 serde = { version = "1", features = ["derive"] }
-serde_json = "1"
+chrono = { version = "0.4.4", features = ["serde"] }
 thiserror = "1.0"
-uuid = { version = "~0.8", features = ["v4"] }
+serde_json = "1"
+num-rational = { version = "0.3", features = ["serde"] }
 
 near-crypto = { path = "../../core/crypto" }
+near-account-id = { path = "../../core/account-id" }
 near-primitives = { path = "../../core/primitives" }
-near-chain-configs = { path = "../../core/chain-configs" }
 near-rpc-error-macro = { path = "../../tools/rpctypegen/macro" }
 near-client-primitives = { path = "../client-primitives" }
 

chain/jsonrpc-primitives/src/lib.rs

@@ -1,3 +1,4 @@
 pub mod errors;
 pub mod message;
+mod serde_with;
 pub mod types;

chain/jsonrpc-primitives/src/serde_with.rs

@@ -0,0 +1,47 @@
+pub mod u128_dec_format {
+    use serde::de;
+    use serde::{Deserialize, Deserializer, Serializer};
+
+    pub fn serialize<S>(num: &u128, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&num.to_string())
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<u128, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        u128::from_str_radix(&s, 10).map_err(de::Error::custom)
+    }
+}
+
+pub mod u128_dec_format_compatible {
+    //! This in an extension to `u128_dec_format` that serves a compatibility layer role to
+    //! deserialize u128 from a "small" JSON number (u64).
+    //!
+    //! It is unfortunate that we cannot enable "arbitrary_precision" feature in
+    //! serde_json due to a bug: <https://github.com/serde-rs/json/issues/505>.
+    use serde::{de, Deserialize, Deserializer};
+
+    pub use super::u128_dec_format::serialize;
+
+    #[derive(Deserialize)]
+    #[serde(untagged)]
+    enum U128 {
+        Number(u64),
+        String(String),
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<u128, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        match U128::deserialize(deserializer)? {
+            U128::Number(value) => Ok(u128::from(value)),
+            U128::String(value) => u128::from_str_radix(&value, 10).map_err(de::Error::custom),
+        }
+    }
+}