client-rust: use a normal vector for ConfigKeys

clients/rust/src/hooked/short_vec.rs

@@ -1,9 +1,12 @@
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use {
     borsh::{BorshDeserialize, BorshSerialize},
     solana_program::pubkey::Pubkey,
 };
+#[cfg(feature = "serde")]
+use {
+    serde::{Deserialize, Deserializer, Serialize, Serializer},
+    solana_program::short_vec,
+};
 
 struct ShortU16(u16);
 
@@ -52,13 +55,20 @@ impl BorshDeserialize for ShortU16 {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ShortVec<T>(pub Vec<T>);
 
+fn borsh_serialize_as_short_vec<T: BorshSerialize, W: std::io::Write>(
+    vec: &Vec<T>,
+    writer: &mut W,
+) -> std::io::Result<()> {
+    ShortU16(vec.len() as u16).serialize(writer)?;
+    for item in vec {
+        item.serialize(writer)?;
+    }
+    Ok(())
+}
+
 impl<T: BorshSerialize> BorshSerialize for ShortVec<T> {
     fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
-        ShortU16(self.0.len() as u16).serialize(writer)?;
-        for item in &self.0 {
-            item.serialize(writer)?;
-        }
-        Ok(())
+        borsh_serialize_as_short_vec(&self.0, writer)
     }
 }
 
@@ -79,7 +89,7 @@ impl<T: Serialize> Serialize for ShortVec<T> {
     where
         S: Serializer,
     {
-        solana_program::short_vec::serialize(&self.0, serializer)
+        short_vec::serialize(&self.0, serializer)
     }
 }
 
@@ -89,16 +99,31 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for ShortVec<T> {
     where
         D: Deserializer<'de>,
     {
-        solana_program::short_vec::deserialize(deserializer).map(ShortVec)
+        short_vec::deserialize(deserializer).map(ShortVec)
     }
 }
 
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(BorshDeserialize, BorshSerialize, Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ConfigKeys {
     /// Each key tuple comprises a unique `Pubkey` identifier,
     /// and `bool` whether that key is a signer of the data.
-    pub keys: ShortVec<(Pubkey, bool)>,
+    #[cfg_attr(feature = "serde", serde(with = "short_vec"))]
+    pub keys: Vec<(Pubkey, bool)>,
+}
+
+impl BorshSerialize for ConfigKeys {
+    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        borsh_serialize_as_short_vec(&self.keys, writer)
+    }
+}
+
+impl BorshDeserialize for ConfigKeys {
+    fn deserialize_reader<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
+        Ok(ConfigKeys {
+            keys: ShortVec::deserialize_reader(reader)?.0,
+        })
+    }
 }
 
 /// Utility for extracting the `ConfigKeys` data from the account data.
@@ -111,12 +136,16 @@ pub fn get_config_data(bytes: &[u8]) -> Result<&[u8], bincode::Error> {
 
 #[cfg(test)]
 mod tests {
-    #[cfg(feature = "serde")]
-    use {super::*, assert_matches::assert_matches, bincode::serialize};
     use {
+        super::*,
         bincode::deserialize,
-        solana_program::short_vec::{decode_shortu16_len, ShortU16},
+        solana_program::{
+            pubkey::Pubkey,
+            short_vec::{decode_shortu16_len, ShortU16},
+        },
     };
+    #[cfg(feature = "serde")]
+    use {assert_matches::assert_matches, bincode::serialize};
 
     /// Return the serialized length.
     fn encode_len(len: u16) -> Vec<u8> {
@@ -225,4 +254,34 @@ mod tests {
         ];
         assert!(deserialize::<ShortVec<u8>>(&bytes).is_err());
     }
+
+    #[test]
+    fn test_serialization_borsh() {
+        fn test_serialization(data: ConfigKeys) {
+            let bytes = data.try_to_vec().unwrap();
+            let data1 = ConfigKeys::try_from_slice(&bytes).unwrap();
+            assert_eq!(data, data1);
+        }
+
+        test_serialization(ConfigKeys { keys: vec![] });
+
+        test_serialization(ConfigKeys {
+            keys: vec![(Pubkey::new_unique(), false)],
+        });
+
+        test_serialization(ConfigKeys {
+            keys: vec![(Pubkey::new_unique(), true), (Pubkey::new_unique(), false)],
+        });
+
+        test_serialization(ConfigKeys {
+            keys: vec![
+                (Pubkey::new_unique(), true),
+                (Pubkey::new_unique(), false),
+                (Pubkey::new_unique(), true),
+                (Pubkey::new_unique(), true),
+                (Pubkey::new_unique(), false),
+                (Pubkey::new_unique(), true),
+            ],
+        });
+    }
 }

clients/rust/src/instructions_bincode.rs

@@ -1,7 +1,7 @@
 //! Program instruction helpers.
 
 use {
-    crate::{ConfigKeys, ShortVec, ID},
+    crate::{ConfigKeys, ID},
     bincode::serialized_size,
     solana_program::{
         instruction::{AccountMeta, Instruction},
@@ -18,12 +18,7 @@ pub trait ConfigState: serde::Serialize + Default {
 
 fn initialize_account<T: ConfigState>(config_pubkey: &Pubkey) -> Instruction {
     let account_metas = vec![AccountMeta::new(*config_pubkey, true)];
-    let account_data = (
-        ConfigKeys {
-            keys: ShortVec(vec![]),
-        },
-        T::default(),
-    );
+    let account_data = (ConfigKeys { keys: vec![] }, T::default());
     Instruction::new_with_bincode(ID, &account_data, account_metas)
 }
 
@@ -34,12 +29,7 @@ pub fn create_account<T: ConfigState>(
     lamports: u64,
     keys: Vec<(Pubkey, bool)>,
 ) -> Vec<Instruction> {
-    let space = T::max_space().saturating_add(
-        serialized_size(&ConfigKeys {
-            keys: ShortVec(keys),
-        })
-        .unwrap(),
-    );
+    let space = T::max_space().saturating_add(serialized_size(&ConfigKeys { keys }).unwrap());
     vec![
         system_instruction::create_account(
             from_account_pubkey,
@@ -65,11 +55,6 @@ pub fn store<T: ConfigState>(
             account_metas.push(AccountMeta::new(*signer_pubkey, true));
         }
     }
-    let account_data = (
-        ConfigKeys {
-            keys: ShortVec(keys),
-        },
-        data,
-    );
+    let account_data = (ConfigKeys { keys }, data);
     Instruction::new_with_bincode(ID, &account_data, account_metas)
 }