Add serde support (#805)

module-system/sov-state/src/containers/accessory_map.rs

@@ -15,7 +15,15 @@ use crate::{AccessoryWorkingSet, Prefix, StateReaderAndWriter, Storage};
 /// - a key type `K`;
 /// - a value type `V`;
 /// - a [`StateValueCodec`] `VC`.
-#[derive(Debug, Clone, PartialEq, borsh::BorshDeserialize, borsh::BorshSerialize)]
+#[derive(
+    Debug,
+    Clone,
+    PartialEq,
+    borsh::BorshDeserialize,
+    borsh::BorshSerialize,
+    serde::Serialize,
+    serde::Deserialize,
+)]
 pub struct AccessoryStateMap<K, V, VC = BorshCodec> {
     _phantom: (PhantomData<K>, PhantomData<V>),
     value_codec: VC,

module-system/sov-state/src/containers/accessory_value.rs

@@ -8,7 +8,16 @@ use crate::{AccessoryWorkingSet, Prefix, StateReaderAndWriter, Storage};
 
 /// Container for a single value stored as "accessory" state, outside of the
 /// JMT.
-#[derive(Debug, PartialEq, Eq, Clone, BorshDeserialize, BorshSerialize)]
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    Clone,
+    BorshDeserialize,
+    BorshSerialize,
+    serde::Serialize,
+    serde::Deserialize,
+)]
 pub struct AccessoryStateValue<V, VC = BorshCodec> {
     _phantom: PhantomData<V>,
     codec: VC,

module-system/sov-state/src/containers/accessory_vec.rs

@@ -6,14 +6,22 @@ use crate::{
     AccessoryStateMap, AccessoryStateValue, AccessoryWorkingSet, Prefix, StateVecError, Storage,
 };
 
-#[derive(Debug, Clone)]
+#[derive(
+    Debug,
+    Clone,
+    PartialEq,
+    borsh::BorshDeserialize,
+    borsh::BorshSerialize,
+    serde::Serialize,
+    serde::Deserialize,
+)]
 pub struct AccessoryStateVec<V, VC = BorshCodec>
 where
     VC: StateValueCodec<V>,
 {
     _phantom: PhantomData<V>,
     prefix: Prefix,
-    len_value: AccessoryStateValue<usize>,
+    len_value: AccessoryStateValue<usize, VC>,
     elems: AccessoryStateMap<usize, V, VC>,
 }
 
@@ -30,15 +38,16 @@ where
 
 impl<V, VC> AccessoryStateVec<V, VC>
 where
-    VC: StateValueCodec<V>,
+    VC: StateValueCodec<V> + StateValueCodec<usize> + Clone,
 {
     /// Creates a new [`AccessoryStateVec`] with the given prefix and codec.
     pub fn with_codec(prefix: Prefix, codec: VC) -> Self {
         // Differentiating the prefixes for the length and the elements
         // shouldn't be necessary, but it's best not to rely on implementation
         // details of `StateValue` and `StateMap` as they both have the right to
         // reserve the whole key space for themselves.
-        let len_value = AccessoryStateValue::<usize>::new(prefix.extended(b"l"));
+        let len_value =
+            AccessoryStateValue::<usize, VC>::with_codec(prefix.extended(b"l"), codec.clone());
         let elems = AccessoryStateMap::with_codec(prefix.extended(b"e"), codec);
         Self {
             _phantom: PhantomData,
@@ -187,7 +196,7 @@ where
 
 impl<'a, 'ws, V, VC, S> Iterator for AccessoryStateVecIter<'a, 'ws, V, VC, S>
 where
-    VC: StateValueCodec<V>,
+    VC: StateValueCodec<V> + StateValueCodec<usize> + Clone,
     S: Storage,
 {
     type Item = V;
@@ -204,7 +213,7 @@ where
 
 impl<'a, 'ws, V, VC, S> ExactSizeIterator for AccessoryStateVecIter<'a, 'ws, V, VC, S>
 where
-    VC: StateValueCodec<V>,
+    VC: StateValueCodec<V> + StateValueCodec<usize> + Clone,
     S: Storage,
 {
     fn len(&self) -> usize {
@@ -214,7 +223,7 @@ where
 
 impl<'a, 'ws, V, VC, S> FusedIterator for AccessoryStateVecIter<'a, 'ws, V, VC, S>
 where
-    VC: StateValueCodec<V>,
+    VC: StateValueCodec<V> + StateValueCodec<usize> + Clone,
     S: Storage,
 {
 }

module-system/sov-state/src/containers/map.rs

@@ -15,7 +15,15 @@ use crate::{Prefix, StateReaderAndWriter, Storage, WorkingSet};
 /// - a key type `K`;
 /// - a value type `V`;
 /// - a [`StateValueCodec`] `VC`.
-#[derive(Debug, Clone, PartialEq, borsh::BorshDeserialize, borsh::BorshSerialize)]
+#[derive(
+    Debug,
+    Clone,
+    PartialEq,
+    borsh::BorshDeserialize,
+    borsh::BorshSerialize,
+    serde::Serialize,
+    serde::Deserialize,
+)]
 pub struct StateMap<K, V, VC = BorshCodec> {
     _phantom: (PhantomData<K>, PhantomData<V>),
     value_codec: VC,

module-system/sov-state/src/containers/value.rs

@@ -1,13 +1,20 @@
 use std::marker::PhantomData;
 
-use borsh::{BorshDeserialize, BorshSerialize};
 use thiserror::Error;
 
 use crate::codec::{BorshCodec, StateValueCodec};
 use crate::{Prefix, StateReaderAndWriter, Storage, WorkingSet};
 
 /// Container for a single value.
-#[derive(Debug, PartialEq, Eq, Clone, BorshDeserialize, BorshSerialize)]
+#[derive(
+    Debug,
+    Clone,
+    PartialEq,
+    borsh::BorshDeserialize,
+    borsh::BorshSerialize,
+    serde::Serialize,
+    serde::Deserialize,
+)]
 pub struct StateValue<V, VC = BorshCodec> {
     _phantom: PhantomData<V>,
     codec: VC,

module-system/sov-state/src/containers/vec.rs

@@ -6,14 +6,22 @@ use thiserror::Error;
 use crate::codec::{BorshCodec, StateValueCodec};
 use crate::{Prefix, StateMap, StateValue, Storage, WorkingSet};
 
-#[derive(Debug, Clone)]
+#[derive(
+    Debug,
+    Clone,
+    PartialEq,
+    borsh::BorshDeserialize,
+    borsh::BorshSerialize,
+    serde::Serialize,
+    serde::Deserialize,
+)]
 pub struct StateVec<V, VC = BorshCodec>
 where
     VC: StateValueCodec<V>,
 {
     _phantom: PhantomData<V>,
     prefix: Prefix,
-    len_value: StateValue<usize>,
+    len_value: StateValue<usize, VC>,
     elems: StateMap<usize, V, VC>,
 }
 
@@ -39,15 +47,15 @@ where
 
 impl<V, VC> StateVec<V, VC>
 where
-    VC: StateValueCodec<V>,
+    VC: StateValueCodec<V> + StateValueCodec<usize> + Clone,
 {
     /// Creates a new [`StateVec`] with the given prefix and codec.
     pub fn with_codec(prefix: Prefix, codec: VC) -> Self {
         // Differentiating the prefixes for the length and the elements
         // shouldn't be necessary, but it's best not to rely on implementation
         // details of `StateValue` and `StateMap` as they both have the right to
         // reserve the whole key space for themselves.
-        let len_value = StateValue::<usize>::new(prefix.extended(b"l"));
+        let len_value = StateValue::with_codec(prefix.extended(b"l"), codec.clone());
         let elems = StateMap::with_codec(prefix.extended(b"e"), codec);
         Self {
             _phantom: PhantomData,
@@ -192,7 +200,7 @@ where
 
 impl<'a, 'ws, V, VC, S> Iterator for StateVecIter<'a, 'ws, V, VC, S>
 where
-    VC: StateValueCodec<V>,
+    VC: StateValueCodec<V> + StateValueCodec<usize> + Clone,
     S: Storage,
 {
     type Item = V;
@@ -209,7 +217,7 @@ where
 
 impl<'a, 'ws, V, VC, S> ExactSizeIterator for StateVecIter<'a, 'ws, V, VC, S>
 where
-    VC: StateValueCodec<V>,
+    VC: StateValueCodec<V> + StateValueCodec<usize> + Clone,
     S: Storage,
 {
     fn len(&self) -> usize {
@@ -219,7 +227,7 @@ where
 
 impl<'a, 'ws, V, VC, S> FusedIterator for StateVecIter<'a, 'ws, V, VC, S>
 where
-    VC: StateValueCodec<V>,
+    VC: StateValueCodec<V> + StateValueCodec<usize> + Clone,
     S: Storage,
 {
 }

module-system/sov-state/src/lib.rs

@@ -40,7 +40,16 @@ pub use crate::witness::{ArrayWitness, TreeWitnessReader, Witness};
 // All the collection types in this crate are backed by the same storage instance, this means that insertions of the same key
 // to two different `StorageMaps` would collide with each other. We solve it by instantiating every collection type with a unique
 // prefix that is prepended to each key.
-#[derive(borsh::BorshDeserialize, borsh::BorshSerialize, Debug, PartialEq, Eq, Clone)]
+#[derive(
+    borsh::BorshDeserialize,
+    borsh::BorshSerialize,
+    Debug,
+    PartialEq,
+    Eq,
+    Clone,
+    serde::Serialize,
+    serde::Deserialize,
+)]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 pub struct Prefix {
     prefix: AlignedVec,

module-system/sov-state/src/utils.rs

@@ -2,7 +2,16 @@
 // This makes certain operations cheaper in zk-context (concatenation)
 // TODO: Currently the implementation defaults to `stc::vec::Vec` see:
 // https://github.com/Sovereign-Labs/sovereign-sdk/issues/47
-#[derive(borsh::BorshDeserialize, borsh::BorshSerialize, Debug, PartialEq, Eq, Clone)]
+#[derive(
+    borsh::BorshDeserialize,
+    borsh::BorshSerialize,
+    Debug,
+    PartialEq,
+    Eq,
+    Clone,
+    serde::Serialize,
+    serde::Deserialize,
+)]
 pub struct AlignedVec {
     inner: Vec<u8>,
 }