Add support for 128bit numbers serde (#871)

* Add support for 128bit numbers serde

* Add comment for future plans on large integer serialization

Author: m30m

pythnet/pythnet_sdk/src/wire/de.rs

@@ -180,6 +180,18 @@ where
         visitor.visit_i64(value)
     }
 
+    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde::de::Visitor<'de>,
+    {
+        let value = self
+            .cursor
+            .read_i128::<B>()
+            .map_err(DeserializerError::from)?;
+
+        visitor.visit_i128(value)
+    }
+
     fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: serde::de::Visitor<'de>,
@@ -224,6 +236,18 @@ where
         visitor.visit_u64(value)
     }
 
+    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde::de::Visitor<'de>,
+    {
+        let value = self
+            .cursor
+            .read_u128::<B>()
+            .map_err(DeserializerError::from)?;
+
+        visitor.visit_u128(value)
+    }
+
     fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
     where
         V: serde::de::Visitor<'de>,

pythnet/pythnet_sdk/src/wire/ser.rs

@@ -92,8 +92,9 @@
 //! Integers:
 //!
 //! - `{u,i}8` are serialized as a single byte
-//! - `{u,i}16/32/64` are serialized as bytes specified by the parser endianess type param.
-//! - `{u,i}128` is not supported.
+//! - `{u,i}16/32/64/128` are serialized as bytes specified by the parser endianess type param.
+//! - Custom {U,I}128/256 wrappers may be implemented later (similar to Borsh) for better support
+//!   in JS, debugging, logging, etc.
 //!
 //! Floats:
 //!
@@ -272,6 +273,13 @@ impl<'a, W: Write, B: ByteOrder> serde::Serializer for &'a mut Serializer<W, B>
         self.writer.write_i64::<B>(v).map_err(SerializerError::from)
     }
 
+    #[inline]
+    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
+        self.writer
+            .write_i128::<B>(v)
+            .map_err(SerializerError::from)
+    }
+
     #[inline]
     fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
         self.writer.write_all(&[v]).map_err(SerializerError::from)
@@ -292,6 +300,13 @@ impl<'a, W: Write, B: ByteOrder> serde::Serializer for &'a mut Serializer<W, B>
         self.writer.write_u64::<B>(v).map_err(SerializerError::from)
     }
 
+    #[inline]
+    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
+        self.writer
+            .write_u128::<B>(v)
+            .map_err(SerializerError::from)
+    }
+
     #[inline]
     fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
         Err(SerializerError::Unsupported)