Merge branch 'main' into next

src/merkle/mmr/full.rs

@@ -7,7 +7,7 @@
 //!
 //! Additionally the structure only supports adding leaves to the right-most tree, the one with the
 //! least number of leaves. The structure preserves the invariant that each tree has different
-//! depths, i.e. as part of adding adding a new element to the forest the trees with same depth are
+//! depths, i.e. as part of adding a new element to the forest the trees with same depth are
 //! merged, creating a new tree with depth d+1, this process is continued until the property is
 //! reestablished.
 use alloc::vec::Vec;

src/merkle/mmr/inorder.rs

@@ -6,6 +6,8 @@
 //! leaves count.
 use core::num::NonZeroUsize;
 
+use winter_utils::{Deserializable, Serializable};
+
 // IN-ORDER INDEX
 // ================================================================================================
 
@@ -112,6 +114,21 @@ impl InOrderIndex {
     }
 }
 
+impl Serializable for InOrderIndex {
+    fn write_into<W: winter_utils::ByteWriter>(&self, target: &mut W) {
+        target.write_usize(self.idx);
+    }
+}
+
+impl Deserializable for InOrderIndex {
+    fn read_from<R: winter_utils::ByteReader>(
+        source: &mut R,
+    ) -> Result<Self, winter_utils::DeserializationError> {
+        let idx = source.read_usize()?;
+        Ok(InOrderIndex { idx })
+    }
+}
+
 // CONVERSIONS FROM IN-ORDER INDEX
 // ------------------------------------------------------------------------------------------------
 
@@ -127,6 +144,7 @@ impl From<InOrderIndex> for u64 {
 #[cfg(test)]
 mod test {
     use proptest::prelude::*;
+    use winter_utils::{Deserializable, Serializable};
 
     use super::InOrderIndex;
 
@@ -162,4 +180,12 @@ mod test {
         assert_eq!(left.sibling(), right);
         assert_eq!(left, right.sibling());
     }
+
+    #[test]
+    fn test_inorder_index_serialization() {
+        let index = InOrderIndex::from_leaf_pos(5);
+        let bytes = index.to_bytes();
+        let index2 = InOrderIndex::read_from_bytes(&bytes).unwrap();
+        assert_eq!(index, index2);
+    }
 }

src/merkle/mmr/partial.rs

@@ -3,6 +3,8 @@ use alloc::{
     vec::Vec,
 };
 
+use winter_utils::{Deserializable, Serializable};
+
 use super::{MmrDelta, MmrProof, Rpo256, RpoDigest};
 use crate::merkle::{
     mmr::{leaf_to_corresponding_tree, nodes_in_forest},
@@ -184,7 +186,7 @@ impl PartialMmr {
     pub fn inner_nodes<'a, I: Iterator<Item = (usize, RpoDigest)> + 'a>(
         &'a self,
         mut leaves: I,
-    ) -> impl Iterator<Item = InnerNodeInfo> + '_ {
+    ) -> impl Iterator<Item = InnerNodeInfo> + 'a {
         let stack = if let Some((pos, leaf)) = leaves.next() {
             let idx = InOrderIndex::from_leaf_pos(pos);
             vec![(idx, leaf)]
@@ -573,6 +575,28 @@ impl<'a, I: Iterator<Item = (usize, RpoDigest)>> Iterator for InnerNodeIterator<
     }
 }
 
+impl Serializable for PartialMmr {
+    fn write_into<W: winter_utils::ByteWriter>(&self, target: &mut W) {
+        self.forest.write_into(target);
+        self.peaks.write_into(target);
+        self.nodes.write_into(target);
+        target.write_bool(self.track_latest);
+    }
+}
+
+impl Deserializable for PartialMmr {
+    fn read_from<R: winter_utils::ByteReader>(
+        source: &mut R,
+    ) -> Result<Self, winter_utils::DeserializationError> {
+        let forest = usize::read_from(source)?;
+        let peaks = Vec::<RpoDigest>::read_from(source)?;
+        let nodes = NodeMap::read_from(source)?;
+        let track_latest = source.read_bool()?;
+
+        Ok(Self { forest, peaks, nodes, track_latest })
+    }
+}
+
 // UTILS
 // ================================================================================================
 
@@ -616,6 +640,8 @@ fn forest_to_rightmost_index(forest: usize) -> InOrderIndex {
 mod tests {
     use alloc::{collections::BTreeSet, vec::Vec};
 
+    use winter_utils::{Deserializable, Serializable};
+
     use super::{
         forest_to_rightmost_index, forest_to_root_index, InOrderIndex, MmrPeaks, PartialMmr,
         RpoDigest,
@@ -907,4 +933,16 @@ mod tests {
         // the openings should be the same
         assert_eq!(mmr.open(5).unwrap(), partial_mmr.open(5).unwrap().unwrap());
     }
+
+    #[test]
+    fn test_partial_mmr_serialization() {
+        let mmr = Mmr::from((0..7).map(int_to_node));
+        let forest_size = mmr.forest();
+        let partial_mmr = PartialMmr::from_peaks(mmr.peaks(forest_size).unwrap());
+
+        let bytes = partial_mmr.to_bytes();
+        let decoded = PartialMmr::read_from_bytes(&bytes).unwrap();
+
+        assert_eq!(partial_mmr, decoded);
+    }
 }