Implement incrementalmerkletree serialization for Merklenode/32.

src/crypto/merkle_node.rs

@@ -133,3 +133,150 @@ impl Decodable for incrementalmerkletree::Position {
         Ok(Self::try_from(dec).unwrap())
     }
 }
+
+impl Encodable for incrementalmerkletree::bridgetree::Leaf<MerkleNode> {
+    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
+        let mut len = 0;
+
+        match self {
+            incrementalmerkletree::bridgetree::Leaf::Left(a) => {
+                len += false.encode(&mut s)?;
+                len += a.encode(&mut s)?;
+            }
+
+            incrementalmerkletree::bridgetree::Leaf::Right(a, b) => {
+                len += true.encode(&mut s)?;
+                len += a.encode(&mut s)?;
+                len += b.encode(&mut s)?;
+            }
+        }
+
+        Ok(len)
+    }
+}
+
+impl Decodable for incrementalmerkletree::bridgetree::Leaf<MerkleNode> {
+    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
+        let side: bool = Decodable::decode(&mut d)?;
+
+        match side {
+            false => {
+                let a: MerkleNode = Decodable::decode(&mut d)?;
+                Ok(Self::Left(a))
+            }
+            true => {
+                let a: MerkleNode = Decodable::decode(&mut d)?;
+                let b: MerkleNode = Decodable::decode(&mut d)?;
+                Ok(Self::Right(a, b))
+            }
+        }
+    }
+}
+
+impl Encodable for incrementalmerkletree::bridgetree::Checkpoint {
+    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
+        let mut len = 0;
+        len += self.bridges_len().encode(&mut s)?;
+        len += self.is_witnessed().encode(&mut s)?;
+        len += self.witnessed().encode(&mut s)?;
+        len += self.forgotten().encode(&mut s)?;
+        Ok(len)
+    }
+}
+
+impl Decodable for incrementalmerkletree::bridgetree::Checkpoint {
+    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
+        let bridges_len = Decodable::decode(&mut d)?;
+        let is_witnessed = Decodable::decode(&mut d)?;
+        let witnessed = Decodable::decode(&mut d)?;
+        let forgotten = Decodable::decode(&mut d)?;
+        Ok(Self::from_parts(bridges_len, is_witnessed, witnessed, forgotten))
+    }
+}
+
+impl Encodable for incrementalmerkletree::bridgetree::NonEmptyFrontier<MerkleNode> {
+    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
+        let mut len = 0;
+        len += self.position().encode(&mut s)?;
+        len += self.leaf().encode(&mut s)?;
+        len += self.ommers().to_vec().encode(&mut s)?;
+        Ok(len)
+    }
+}
+
+impl Decodable for incrementalmerkletree::bridgetree::NonEmptyFrontier<MerkleNode> {
+    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
+        let position = Decodable::decode(&mut d)?;
+        let leaf = Decodable::decode(&mut d)?;
+        let ommers = Decodable::decode(&mut d)?;
+
+        match Self::from_parts(position, leaf, ommers) {
+            Ok(v) => Ok(v),
+            Err(_) => Err(io::Error::new(io::ErrorKind::Other, "FrontierError")),
+        }
+    }
+}
+
+impl Encodable for incrementalmerkletree::bridgetree::AuthFragment<MerkleNode> {
+    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
+        let mut len = 0;
+        len += self.position().encode(&mut s)?;
+        len += self.altitudes_observed().encode(&mut s)?;
+        len += self.values().to_vec().encode(&mut s)?;
+        Ok(len)
+    }
+}
+
+impl Decodable for incrementalmerkletree::bridgetree::AuthFragment<MerkleNode> {
+    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
+        let position = Decodable::decode(&mut d)?;
+        let altitudes_observed = Decodable::decode(&mut d)?;
+        let values = Decodable::decode(&mut d)?;
+        Ok(Self::from_parts(position, altitudes_observed, values))
+    }
+}
+
+impl Encodable for incrementalmerkletree::bridgetree::MerkleBridge<MerkleNode> {
+    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
+        let mut len = 0;
+        len += self.prior_position().encode(&mut s)?;
+        len += self.auth_fragments().encode(&mut s)?;
+        len += self.frontier().encode(&mut s)?;
+        Ok(len)
+    }
+}
+
+impl Decodable for incrementalmerkletree::bridgetree::MerkleBridge<MerkleNode> {
+    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
+        let prior_position = Decodable::decode(&mut d)?;
+        let auth_fragments = Decodable::decode(&mut d)?;
+        let frontier = Decodable::decode(&mut d)?;
+        Ok(Self::from_parts(prior_position, auth_fragments, frontier))
+    }
+}
+
+impl Encodable for incrementalmerkletree::bridgetree::BridgeTree<MerkleNode, 32> {
+    fn encode<S: io::Write>(&self, mut s: S) -> core::result::Result<usize, io::Error> {
+        let mut len = 0;
+        len += self.prior_bridges().to_vec().encode(&mut s)?;
+        len += self.current_bridge().encode(&mut s)?;
+        len += self.witnessed_indices().encode(&mut s)?;
+        len += self.checkpoints().to_vec().encode(&mut s)?;
+        len += self.max_checkpoints().encode(&mut s)?;
+        Ok(len)
+    }
+}
+
+impl Decodable for incrementalmerkletree::bridgetree::BridgeTree<MerkleNode, 32> {
+    fn decode<D: io::Read>(mut d: D) -> core::result::Result<Self, io::Error> {
+        let prior_bridges = Decodable::decode(&mut d)?;
+        let current_bridge = Decodable::decode(&mut d)?;
+        let saved = Decodable::decode(&mut d)?;
+        let checkpoints = Decodable::decode(&mut d)?;
+        let max_checkpoints = Decodable::decode(&mut d)?;
+        match Self::from_parts(prior_bridges, current_bridge, saved, checkpoints, max_checkpoints) {
+            Ok(v) => Ok(v),
+            Err(_) => Err(io::Error::new(io::ErrorKind::Other, "BridgeTreeError")),
+        }
+    }
+}

src/serial/encoding_types.rs

@@ -1,6 +1,6 @@
 //! Encodings for external crates
 use std::{
-    collections::{BTreeMap, HashSet},
+    collections::{BTreeMap, BTreeSet, HashSet},
     io::{Error, Read, Write},
 };
 
@@ -55,6 +55,29 @@ impl<T: Decodable + std::cmp::Ord, U: Decodable> Decodable for BTreeMap<T, U> {
     }
 }
 
+impl<T: Encodable> Encodable for BTreeSet<T> {
+    fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
+        let mut len = 0;
+        len += VarInt(self.len() as u64).encode(&mut s)?;
+        for c in self.iter() {
+            len += c.encode(&mut s)?;
+        }
+        Ok(len)
+    }
+}
+
+impl<T: Decodable + std::cmp::Ord> Decodable for BTreeSet<T> {
+    fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
+        let len = VarInt::decode(&mut d)?.0;
+        let mut ret = BTreeSet::new();
+        for _ in 0..len {
+            let key: T = Decodable::decode(&mut d)?;
+            ret.insert(key);
+        }
+        Ok(ret)
+    }
+}
+
 #[cfg(feature = "blake3")]
 impl Encodable for blake3::Hash {
     fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {