feat: added borsh serde for prefixed vec

pythnet/pythnet_sdk/src/hashers/keccak256_160.rs

@@ -1,5 +1,9 @@
 use {
     crate::hashers::Hasher,
+    borsh::{
+        BorshDeserialize,
+        BorshSerialize,
+    },
     serde::Serialize,
     sha3::{
         Digest,
@@ -7,7 +11,9 @@ use {
     },
 };
 
-#[derive(Clone, Default, Debug, Eq, Hash, PartialEq, Serialize)]
+#[derive(
+    Clone, Default, Debug, Eq, Hash, PartialEq, Serialize, BorshSerialize, BorshDeserialize,
+)]
 pub struct Keccak160 {}
 
 impl Hasher for Keccak160 {

pythnet/pythnet_sdk/src/wire.rs

@@ -147,15 +147,21 @@ pub mod v1 {
 
 #[cfg(test)]
 mod tests {
-    use crate::wire::{
-        array,
-        v1::{
-            AccumulatorUpdateData,
-            Proof,
+    use {
+        crate::wire::{
+            array,
+            v1::{
+                AccumulatorUpdateData,
+                Proof,
+            },
+            Deserializer,
+            PrefixedVec,
+            Serializer,
+        },
+        borsh::{
+            BorshDeserialize,
+            BorshSerialize,
         },
-        Deserializer,
-        PrefixedVec,
-        Serializer,
     };
 
     // Test the arbitrary fixed sized array serialization implementation.
@@ -533,4 +539,16 @@ mod tests {
         buffer[4] = 0x03;
         AccumulatorUpdateData::try_from_slice(&buffer).unwrap_err();
     }
+
+    #[test]
+    fn test_borsh_prefixed_vec() {
+        let prefixed_vec: PrefixedVec<u16, u8> = PrefixedVec::from(vec![0u8, 1u8, 2u8]);
+        let mut buffer = Vec::new();
+        let mut cursor = std::io::Cursor::new(&mut buffer);
+        BorshSerialize::serialize(&prefixed_vec, &mut cursor).unwrap();
+
+        let deserialized_prefixed_vec =
+            BorshDeserialize::deserialize(&mut buffer.as_slice()).unwrap();
+        assert_eq!(prefixed_vec, deserialized_prefixed_vec);
+    }
 }

pythnet/pythnet_sdk/src/wire/prefixed_vec.rs

@@ -1,11 +1,17 @@
-use serde::{
-    de::DeserializeSeed,
-    ser::{
-        SerializeSeq,
-        SerializeStruct,
+use {
+    borsh::{
+        BorshDeserialize,
+        BorshSerialize,
+    },
+    serde::{
+        de::DeserializeSeed,
+        ser::{
+            SerializeSeq,
+            SerializeStruct,
+        },
+        Deserialize,
+        Serialize,
     },
-    Deserialize,
-    Serialize,
 };
 
 /// PrefixlessVec overrides the serialization to _not_ write a length prefix.
@@ -227,3 +233,27 @@ where
         )
     }
 }
+
+impl<L, T> BorshSerialize for PrefixedVec<L, T>
+where
+    T: BorshSerialize,
+{
+    #[inline]
+    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        BorshSerialize::serialize(self.as_ref(), writer)
+    }
+}
+
+impl<L, T> BorshDeserialize for PrefixedVec<L, T>
+where
+    T: BorshDeserialize,
+    L: BorshDeserialize,
+    L: Into<usize>,
+    L: Copy,
+{
+    #[inline]
+    fn deserialize(buf: &mut &[u8]) -> Result<Self, std::io::Error> {
+        let vec = <Vec<T> as BorshDeserialize>::deserialize(buf)?;
+        Ok(vec.into())
+    }
+}