serial: Replace incrementalmerkletree with bridgetree crate.

src/serial/Cargo.toml

@@ -14,7 +14,7 @@ futures-lite = {version = "1.13.0", optional = true}
 
 # Supported types for encoding
 blake3 = {version = "1.3.3", optional = true}
-incrementalmerkletree = {version = "0.3.1", optional = true}
+bridgetree = {version = "0.2.0", optional = true}
 pasta_curves = {version = "0.5.1", optional = true}
 url = {version = "2.4.0", optional = true}
 
@@ -24,5 +24,5 @@ derive = ["darkfi-derive"]
 
 async = ["futures-lite"]
 collections = []
-crypto = ["collections", "hash", "incrementalmerkletree", "pasta_curves"]
+crypto = ["collections", "hash", "bridgetree", "pasta_curves"]
 hash = ["blake3"]

src/serial/src/lib.rs

@@ -16,7 +16,10 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use std::io::{Cursor, Error, ErrorKind, Read, Write};
+use std::{
+    collections::VecDeque,
+    io::{Cursor, Error, ErrorKind, Read, Write},
+};
 
 #[cfg(feature = "derive")]
 pub use darkfi_derive::{SerialDecodable, SerialEncodable};
@@ -467,6 +470,30 @@ impl<T: Decodable> Decodable for Vec<T> {
     }
 }
 
+impl<T: Encodable> Encodable for VecDeque<T> {
+    #[inline]
+    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 val in self {
+            len += val.encode(&mut s)?;
+        }
+        Ok(len)
+    }
+}
+
+impl<T: Decodable> Decodable for VecDeque<T> {
+    #[inline]
+    fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
+        let len = VarInt::decode(&mut d)?.0;
+        let mut ret = VecDeque::with_capacity(len as usize);
+        for _ in 0..len {
+            ret.push_back(Decodable::decode(&mut d)?);
+        }
+        Ok(ret)
+    }
+}
+
 impl<T: Encodable> Encodable for Option<T> {
     fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
         let mut len = 0;

src/serial/src/types.rs

@@ -24,8 +24,8 @@ mod collections;
 #[cfg(feature = "hash")]
 mod hash;
 
-#[cfg(feature = "incrementalmerkletree")]
-mod incrementalmerkletree;
+#[cfg(feature = "bridgetree")]
+mod bridgetree;
 
 #[cfg(feature = "pasta_curves")]
 mod pasta;

src/serial/src/types/incrementalmerkletree.rs → src/serial/src/types/bridgetree.rs

@@ -16,88 +16,42 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+use core::fmt::Debug;
 use std::io::{Error, ErrorKind, Read, Write};
 
-use incrementalmerkletree::Hashable;
-
 use crate::{Decodable, Encodable};
 
-impl Encodable for incrementalmerkletree::Position {
+impl Encodable for bridgetree::Position {
     fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
         u64::from(*self).encode(&mut s)
     }
 }
 
-impl Decodable for incrementalmerkletree::Position {
+impl Decodable for bridgetree::Position {
     fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
         let dec: u64 = Decodable::decode(&mut d)?;
         Ok(Self::try_from(dec).unwrap())
     }
 }
 
-impl<T: Encodable + Ord> Encodable for incrementalmerkletree::bridgetree::Leaf<T> {
-    fn encode<S: Write>(&self, mut s: S) -> Result<usize, 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<T: Decodable + Ord> Decodable for incrementalmerkletree::bridgetree::Leaf<T> {
-    fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
-        let side: bool = Decodable::decode(&mut d)?;
-
-        match side {
-            false => {
-                let a: T = Decodable::decode(&mut d)?;
-                Ok(Self::Left(a))
-            }
-            true => {
-                let a: T = Decodable::decode(&mut d)?;
-                let b: T = Decodable::decode(&mut d)?;
-                Ok(Self::Right(a, b))
-            }
-        }
-    }
-}
-
-impl Encodable for incrementalmerkletree::bridgetree::Checkpoint {
+impl Encodable for bridgetree::Address {
     fn encode<S: Write>(&self, mut s: S) -> Result<usize, 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)?;
+        len += u8::from(self.level()).encode(&mut s)?;
+        len += self.index().encode(&mut s)?;
         Ok(len)
     }
 }
 
-impl Decodable for incrementalmerkletree::bridgetree::Checkpoint {
+impl Decodable for bridgetree::Address {
     fn decode<D: Read>(mut d: D) -> Result<Self, 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))
+        let level: u8 = Decodable::decode(&mut d)?;
+        let index = Decodable::decode(&mut d)?;
+        Ok(Self::from_parts(level.into(), index))
     }
 }
 
-impl<T: Encodable + Ord + Clone> Encodable
-    for incrementalmerkletree::bridgetree::NonEmptyFrontier<T>
-{
+impl<H: Encodable + Ord + Clone> Encodable for bridgetree::NonEmptyFrontier<H> {
     fn encode<S: Write>(&self, mut s: S) -> Result<usize, Error> {
         let mut len = 0;
         len += self.position().encode(&mut s)?;
@@ -107,9 +61,7 @@ impl<T: Encodable + Ord + Clone> Encodable
     }
 }
 
-impl<T: Decodable + Ord + Clone> Decodable
-    for incrementalmerkletree::bridgetree::NonEmptyFrontier<T>
-{
+impl<H: Decodable + Ord + Clone> Decodable for bridgetree::NonEmptyFrontier<H> {
     fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
         let position = Decodable::decode(&mut d)?;
         let leaf = Decodable::decode(&mut d)?;
@@ -122,60 +74,67 @@ impl<T: Decodable + Ord + Clone> Decodable
     }
 }
 
-impl<T: Encodable + Ord + Clone> Encodable for incrementalmerkletree::bridgetree::AuthFragment<T> {
+impl<H: Encodable + Ord + Clone> Encodable for bridgetree::MerkleBridge<H> {
     fn encode<S: Write>(&self, mut s: S) -> Result<usize, 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)?;
+        len += self.prior_position().encode(&mut s)?;
+        len += self.tracking().encode(&mut s)?;
+        len += self.ommers().encode(&mut s)?;
+        len += self.frontier().encode(&mut s)?;
         Ok(len)
     }
 }
 
-impl<T: Decodable + Ord + Clone> Decodable for incrementalmerkletree::bridgetree::AuthFragment<T> {
+impl<H: Decodable + Ord + Clone> Decodable for bridgetree::MerkleBridge<H> {
     fn decode<D: Read>(mut d: D) -> Result<Self, 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))
+        let prior_position = Decodable::decode(&mut d)?;
+        let tracking = Decodable::decode(&mut d)?;
+        let ommers = Decodable::decode(&mut d)?;
+        let frontier = Decodable::decode(&mut d)?;
+        Ok(Self::from_parts(prior_position, tracking, ommers, frontier))
     }
 }
 
-impl<T: Encodable + Ord + Clone> Encodable for incrementalmerkletree::bridgetree::MerkleBridge<T> {
+impl<C: Encodable> Encodable for bridgetree::Checkpoint<C> {
     fn encode<S: Write>(&self, mut s: S) -> Result<usize, 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)?;
+        len += self.id().encode(&mut s)?;
+        len += self.bridges_len().encode(&mut s)?;
+        len += self.marked().encode(&mut s)?;
+        len += self.forgotten().encode(&mut s)?;
         Ok(len)
     }
 }
 
-impl<T: Decodable + Ord + Clone> Decodable for incrementalmerkletree::bridgetree::MerkleBridge<T> {
+impl<C: Decodable> Decodable for bridgetree::Checkpoint<C> {
     fn decode<D: Read>(mut d: D) -> Result<Self, 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))
+        let id = Decodable::decode(&mut d)?;
+        let bridges_len = Decodable::decode(&mut d)?;
+        let marked = Decodable::decode(&mut d)?;
+        let forgotten = Decodable::decode(&mut d)?;
+        Ok(Self::from_parts(id, bridges_len, marked, forgotten))
     }
 }
 
-impl<T: Encodable + Ord + Clone, const V: u8> Encodable
-    for incrementalmerkletree::bridgetree::BridgeTree<T, V>
+impl<H: Encodable + Ord + Clone, C: Encodable + Debug, const DEPTH: u8> Encodable
+    for bridgetree::BridgeTree<H, C, DEPTH>
 {
     fn encode<S: Write>(&self, mut s: S) -> Result<usize, 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.marked_indices().encode(&mut s)?;
+        len += self.checkpoints().encode(&mut s)?;
         len += self.max_checkpoints().encode(&mut s)?;
         Ok(len)
     }
 }
 
-impl<T: Decodable + Ord + Clone + Hashable, const V: u8> Decodable
-    for incrementalmerkletree::bridgetree::BridgeTree<T, V>
+impl<
+        H: Decodable + Clone + Ord + bridgetree::Hashable,
+        C: Decodable + Clone + Ord + Eq + Debug,
+        const DEPTH: u8,
+    > Decodable for bridgetree::BridgeTree<H, C, DEPTH>
 {
     fn decode<D: Read>(mut d: D) -> Result<Self, Error> {
         let prior_bridges = Decodable::decode(&mut d)?;
@@ -193,7 +152,7 @@ impl<T: Decodable + Ord + Clone + Hashable, const V: u8> Decodable
 #[cfg(test)]
 mod tests {
     use crate::{deserialize, serialize, SerialDecodable, SerialEncodable};
-    use incrementalmerkletree::{bridgetree::BridgeTree, Altitude, Hashable, Tree};
+    use bridgetree::{BridgeTree, Hashable, Level};
 
     #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, SerialEncodable, SerialDecodable)]
     struct Node(String);
@@ -203,7 +162,7 @@ mod tests {
             Self("_".to_string())
         }
 
-        fn combine(_: Altitude, a: &Self, b: &Self) -> Self {
+        fn combine(_: Level, a: &Self, b: &Self) -> Self {
             Self(a.0.to_string() + &b.0)
         }
     }
@@ -213,29 +172,29 @@ mod tests {
         const DEPTH: u8 = 8;
 
         // Fill the tree with 100 leaves
-        let mut tree: BridgeTree<Node, DEPTH> = BridgeTree::new(100);
+        let mut tree: BridgeTree<Node, usize, DEPTH> = BridgeTree::new(100);
         for i in 0..100 {
-            tree.append(&Node(format!("test{}", i)));
-            tree.witness();
-            tree.checkpoint();
+            tree.append(Node(format!("test{}", i)));
+            tree.mark();
+            tree.checkpoint(i);
         }
         let serial_tree = serialize(&tree);
-        let deserial_tree: BridgeTree<Node, DEPTH> = deserialize(&serial_tree).unwrap();
+        let deserial_tree: BridgeTree<Node, usize, DEPTH> = deserialize(&serial_tree).unwrap();
 
         // Empty tree
-        let tree2: BridgeTree<Node, DEPTH> = BridgeTree::new(100);
+        let tree2: BridgeTree<Node, usize, DEPTH> = BridgeTree::new(100);
         let serial_tree2 = serialize(&tree2);
-        let deserial_tree2: BridgeTree<Node, DEPTH> = deserialize(&serial_tree2).unwrap();
+        let deserial_tree2: BridgeTree<Node, usize, DEPTH> = deserialize(&serial_tree2).unwrap();
 
         // Max leaves
-        let mut tree3: BridgeTree<Node, DEPTH> = BridgeTree::new(100);
+        let mut tree3: BridgeTree<Node, usize, DEPTH> = BridgeTree::new(100);
         for i in 0..2_i32.pow(DEPTH as u32) {
-            tree3.append(&Node(format!("test{}", i)));
-            tree3.witness();
-            tree3.checkpoint();
+            tree3.append(Node(format!("test{}", i)));
+            tree3.mark();
+            tree3.checkpoint(i.try_into().unwrap());
         }
         let serial_tree3 = serialize(&tree3);
-        let deserial_tree3: BridgeTree<Node, DEPTH> = deserialize(&serial_tree3).unwrap();
+        let deserial_tree3: BridgeTree<Node, usize, DEPTH> = deserialize(&serial_tree3).unwrap();
 
         assert!(tree == deserial_tree);
         assert!(tree2 == deserial_tree2);