[ENH]: serde util for optional u128 (#4659)

## Description of changes

Introduces a type module for serializing and deserializing optional
u128. Serde doesn't natively support serializing and deserializing
128-bit integers because the maximum integer size in JSON is a 64-bit
integer. This module solves this problem by serializing 128-bit integers
into their hex string equivalents.

## Test plan

- [x] Tests pass locally with `pytest` for python, `yarn test` for js,
`cargo test` for rust

## Documentation Changes

N/A

Author: c-gamble

rust/types/src/lib.rs

@@ -23,6 +23,7 @@ mod tenant;
 mod validators;
 mod where_parsing;
 
+pub mod optional_u128;
 pub mod regex;
 
 // Re-export the types module, so that we can use it as a single import in other modules.

rust/types/src/optional_u128.rs

@@ -0,0 +1,74 @@
+pub mod optional_u128_as_hex {
+    use serde::de::Error;
+    use serde::{Deserialize, Deserializer, Serializer};
+
+    /// Serializes `Option<u128>` as lowercase hex string if Some, skips if None.
+    pub fn serialize<S>(val: &Option<u128>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match val {
+            Some(v) => serializer.serialize_str(&format!("{:x}", v)),
+            None => serializer.serialize_none(),
+        }
+    }
+
+    /// Deserializes a lowercase hex string into `Option<u128>`.
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<u128>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let opt: Option<String> = Option::deserialize(deserializer)?;
+        match opt {
+            Some(s) => {
+                let val = u128::from_str_radix(&s, 16).map_err(D::Error::custom)?;
+                Ok(Some(val))
+            }
+            None => Ok(None),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::optional_u128_as_hex;
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Serialize, Deserialize, Debug, PartialEq)]
+    struct TestStruct {
+        #[serde(
+            with = "optional_u128_as_hex",
+            default,
+            skip_serializing_if = "Option::is_none"
+        )]
+        value: Option<u128>,
+    }
+
+    #[test]
+    fn test_serialize_some_u128() {
+        let s = TestStruct { value: Some(255) };
+        let json = serde_json::to_string(&s).unwrap();
+        assert_eq!(json, r#"{"value":"ff"}"#);
+    }
+
+    #[test]
+    fn test_serialize_none() {
+        let s = TestStruct { value: None };
+        let json = serde_json::to_string(&s).unwrap();
+        assert_eq!(json, r#"{}"#);
+    }
+
+    #[test]
+    fn test_deserialize_some_u128() {
+        let json = r#"{"value":"ff"}"#;
+        let s: TestStruct = serde_json::from_str(json).unwrap();
+        assert_eq!(s, TestStruct { value: Some(255) });
+    }
+
+    #[test]
+    fn test_deserialize_none() {
+        let json = r#"{}"#;
+        let s: TestStruct = serde_json::from_str(json).unwrap();
+        assert_eq!(s, TestStruct { value: None });
+    }
+}