sdk: Replace incrementalmerkletree with bridgetree crate.

example/zk-inclusion-proof.rs

@@ -28,16 +28,14 @@ use darkfi::{
     Result,
 };
 use darkfi_sdk::{
-    crypto::{constants::MERKLE_DEPTH, poseidon_hash, MerkleNode},
-    incrementalmerkletree::{bridgetree::BridgeTree, Hashable, Tree},
+    bridgetree::Hashable,
+    crypto::{poseidon_hash, MerkleNode, MerkleTree},
     pasta::{group::ff::Field, pallas},
 };
 use darkfi_serial::Encodable;
 use halo2_proofs::circuit::Value;
 use rand::rngs::OsRng;
 
-type MerkleTree = BridgeTree<MerkleNode, { MERKLE_DEPTH }>;
-
 fn main() -> Result<()> {
     let mut tree = MerkleTree::new(100);
 
@@ -45,26 +43,23 @@ fn main() -> Result<()> {
     for _ in 0..10 {
         let random_leaf = pallas::Base::random(&mut OsRng);
         let node = MerkleNode::from(random_leaf);
-        tree.append(&node);
+        tree.append(node);
     }
 
     let leaf = pallas::Base::random(&mut OsRng);
     let node = MerkleNode::from(leaf);
-    tree.append(&node);
+    tree.append(node);
 
-    let leaf_position = tree.witness().unwrap();
+    let leaf_position = tree.mark().unwrap();
 
     // Add 10 more random things to the tree
     for _ in 0..10 {
         let random_leaf = pallas::Base::random(&mut OsRng);
         let node = MerkleNode::from(random_leaf);
-        tree.append(&node);
+        tree.append(node);
     }
 
-    let root = tree.root(0).unwrap();
-
     // Now begin zk proof API
-
     let bincode = include_bytes!("../proof/inclusion_proof.zk.bin");
     let zkbin = ZkBinary::decode(bincode)?;
 
@@ -77,7 +72,7 @@ fn main() -> Result<()> {
     println!("k = {}", k);
 
     // Witness values
-    let merkle_path = tree.authentication_path(leaf_position, &root).unwrap();
+    let merkle_path = tree.witness(leaf_position, 0).unwrap();
     let leaf_position: u64 = leaf_position.into();
     let blind = pallas::Base::random(&mut OsRng);
 
@@ -103,7 +98,7 @@ fn main() -> Result<()> {
         current
     };
 
-    let enc_leaf = poseidon_hash::<2>([leaf, blind]);
+    let enc_leaf = poseidon_hash([leaf, blind]);
     let public_inputs = vec![merkle_root.inner(), enc_leaf];
 
     // Create the circuit

src/runtime/import/merkle.rs

@@ -18,18 +18,13 @@
 
 use std::io::Cursor;
 
-use darkfi_sdk::{
-    crypto::{constants::MERKLE_DEPTH, MerkleNode},
-    incrementalmerkletree::{bridgetree::BridgeTree, Tree},
-};
+use darkfi_sdk::crypto::{MerkleNode, MerkleTree};
 use darkfi_serial::{serialize, Decodable, Encodable, WriteExt};
 use log::{debug, error};
 use wasmer::{FunctionEnvMut, WasmPtr};
 
 use crate::runtime::vm_runtime::{ContractSection, Env};
 
-type MerkleTree = BridgeTree<MerkleNode, { MERKLE_DEPTH }>;
-
 pub(crate) fn merkle_add(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i32 {
     let env = ctx.data();
     match env.contract_section {
@@ -166,7 +161,7 @@ pub(crate) fn merkle_add(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -
             let mut new_roots = vec![];
 
             for coin in coins {
-                tree.append(&coin);
+                tree.append(coin);
                 let Some(root) = tree.root(0) else {
                     error!(target: "runtime::merkle", "Unable to read the root of tree");
                     return -2;

src/sdk/Cargo.toml

@@ -26,7 +26,7 @@ blake2b_simd = "1.0.1"
 blake3 = "1.3.3"
 chacha20poly1305 = "0.10.1"
 halo2_gadgets = "0.3.0"
-incrementalmerkletree = "0.3.1"
+bridgetree = "0.2.0"
 num-bigint = "0.4.3"
 num-traits = "0.2.15"
 pasta_curves = "0.5.1"

src/sdk/src/crypto/merkle_node.rs

@@ -19,9 +19,9 @@
 use core::{fmt, str::FromStr};
 use std::{io, iter};
 
+use bridgetree::{BridgeTree, Hashable, Level};
 use darkfi_serial::{SerialDecodable, SerialEncodable};
 use halo2_gadgets::sinsemilla::primitives::HashDomain;
-use incrementalmerkletree::{bridgetree::BridgeTree, Altitude, Hashable};
 use lazy_static::lazy_static;
 use pasta_curves::{
     group::ff::{PrimeField, PrimeFieldBits},
@@ -34,7 +34,7 @@ use crate::crypto::constants::{
     MERKLE_DEPTH,
 };
 
-pub type MerkleTree = BridgeTree<MerkleNode, { MERKLE_DEPTH }>;
+pub type MerkleTree = BridgeTree<MerkleNode, usize, { MERKLE_DEPTH }>;
 
 lazy_static! {
     static ref UNCOMMITTED_ORCHARD: pallas::Base = pallas::Base::from(2);
@@ -137,7 +137,7 @@ impl Hashable for MerkleNode {
     ///       above the the leaves, i.e. layer = 31, l = 0
     ///     - when hashing to the final root, we produce the anchor
     ///       with layer = 0, l = 31.
-    fn combine(altitude: Altitude, left: &Self, right: &Self) -> Self {
+    fn combine(altitude: Level, left: &Self, right: &Self) -> Self {
         // MerkleCRH Sinsemilla hash domain.
         let domain = HashDomain::new(MERKLE_CRH_PERSONALIZATION);
 
@@ -153,7 +153,7 @@ impl Hashable for MerkleNode {
         )
     }
 
-    fn empty_root(altitude: Altitude) -> Self {
+    fn empty_root(altitude: Level) -> Self {
         EMPTY_ROOTS[<usize>::from(altitude)]
     }
 }
@@ -163,7 +163,6 @@ mod tests {
     use super::*;
 
     use halo2_proofs::arithmetic::Field;
-    use incrementalmerkletree::Tree;
     use pasta_curves::pallas;
     use rand::rngs::OsRng;
 
@@ -173,11 +172,11 @@ mod tests {
         let mut tree = MerkleTree::new(MAX_CHECKPOINTS);
         let mut roots = vec![];
 
-        for _ in 0..MAX_CHECKPOINTS {
+        for id in 0..MAX_CHECKPOINTS {
             let leaf = MerkleNode::from(pallas::Base::random(&mut OsRng));
-            tree.append(&leaf);
+            tree.append(leaf);
             roots.push(tree.root(0).unwrap());
-            tree.checkpoint();
+            tree.checkpoint(id);
         }
 
         for root in roots.iter().rev() {

src/sdk/src/crypto/mod.rs

@@ -42,11 +42,6 @@ pub use token_id::{TokenId, DARK_TOKEN_ID};
 pub mod merkle_node;
 pub use merkle_node::{MerkleNode, MerkleTree};
 
-pub mod merkle_prelude {
-    pub use incrementalmerkletree::{Hashable, Tree};
-}
-pub use incrementalmerkletree::Position as MerklePosition;
-
 /// Note encryption
 pub mod note;
 
@@ -70,9 +65,6 @@ pub mod ecvrf;
 /// Sparse Merkle Tree implementation
 pub mod smt;
 
-pub use incrementalmerkletree;
-pub use pasta_curves::{pallas, vesta};
-
 /// Convenience module to import all the pasta traits.
 /// You still have to import the curves.
 pub mod pasta_prelude {

src/sdk/src/lib.rs

@@ -16,7 +16,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-pub use incrementalmerkletree;
+pub use bridgetree;
 pub use num_bigint;
 pub use num_traits;
 pub use pasta_curves as pasta;

tests/halo2_vk_ser.rs

@@ -17,9 +17,8 @@
  */
 use std::io::Cursor;
 
-use darkfi_sdk::{
-    crypto::{pedersen::pedersen_commitment_u64, util::mod_r_p, MerkleNode, PublicKey, SecretKey},
-    incrementalmerkletree::{bridgetree::BridgeTree, Tree},
+use darkfi_sdk::crypto::{
+    pedersen::pedersen_commitment_u64, util::mod_r_p, MerkleNode, MerkleTree, PublicKey, SecretKey,
 };
 use halo2_gadgets::poseidon::{
     primitives as poseidon,
@@ -90,7 +89,7 @@ fn halo2_vk_ser() -> Result<()> {
     let a = pallas::Base::from(42);
     let b = pallas::Base::from(69);
 
-    let mut tree = BridgeTree::<MerkleNode, 32>::new(100);
+    let mut tree = MerkleTree::new(100);
     let c0 = pallas::Base::random(&mut OsRng);
     let c1 = pallas::Base::random(&mut OsRng);
     let c3 = pallas::Base::random(&mut OsRng);
@@ -99,16 +98,16 @@ fn halo2_vk_ser() -> Result<()> {
         poseidon::Hash::<_, P128Pow5T3, ConstantLength<3>, 3, 2>::init().hash(messages)
     };
 
-    tree.append(&MerkleNode::from(c0));
-    tree.witness();
-    tree.append(&MerkleNode::from(c1));
-    tree.append(&MerkleNode::from(c2));
-    let leaf_pos = tree.witness().unwrap();
-    tree.append(&MerkleNode::from(c3));
-    tree.witness();
+    tree.append(MerkleNode::from(c0));
+    tree.mark();
+    tree.append(MerkleNode::from(c1));
+    tree.append(MerkleNode::from(c2));
+    let leaf_pos = tree.mark().unwrap();
+    tree.append(MerkleNode::from(c3));
+    tree.mark();
 
     let root = tree.root(0).unwrap();
-    let merkle_path = tree.authentication_path(leaf_pos, &root).unwrap();
+    let merkle_path = tree.witness(leaf_pos, 0).unwrap();
     let leaf_pos: u64 = leaf_pos.into();
 
     let ephem_secret = SecretKey::random(&mut OsRng);

tests/zkvm_opcodes.rs

@@ -16,9 +16,8 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use darkfi_sdk::{
-    crypto::{pedersen::pedersen_commitment_u64, util::mod_r_p, MerkleNode, PublicKey, SecretKey},
-    incrementalmerkletree::{bridgetree::BridgeTree, Tree},
+use darkfi_sdk::crypto::{
+    pedersen::pedersen_commitment_u64, util::mod_r_p, MerkleNode, MerkleTree, PublicKey, SecretKey,
 };
 use halo2_gadgets::poseidon::{
     primitives as poseidon,
@@ -56,7 +55,7 @@ fn zkvm_opcodes() -> Result<()> {
     let a = pallas::Base::from(42);
     let b = pallas::Base::from(69);
 
-    let mut tree = BridgeTree::<MerkleNode, 32>::new(100);
+    let mut tree = MerkleTree::new(100);
     let c0 = pallas::Base::random(&mut OsRng);
     let c1 = pallas::Base::random(&mut OsRng);
     let c3 = pallas::Base::random(&mut OsRng);
@@ -65,16 +64,16 @@ fn zkvm_opcodes() -> Result<()> {
         poseidon::Hash::<_, P128Pow5T3, ConstantLength<3>, 3, 2>::init().hash(messages)
     };
 
-    tree.append(&MerkleNode::from(c0));
-    tree.witness();
-    tree.append(&MerkleNode::from(c1));
-    tree.append(&MerkleNode::from(c2));
-    let leaf_pos = tree.witness().unwrap();
-    tree.append(&MerkleNode::from(c3));
-    tree.witness();
+    tree.append(MerkleNode::from(c0));
+    tree.mark();
+    tree.append(MerkleNode::from(c1));
+    tree.append(MerkleNode::from(c2));
+    let leaf_pos = tree.mark().unwrap();
+    tree.append(MerkleNode::from(c3));
+    tree.mark();
 
     let root = tree.root(0).unwrap();
-    let merkle_path = tree.authentication_path(leaf_pos, &root).unwrap();
+    let merkle_path = tree.witness(leaf_pos, 0).unwrap();
     let leaf_pos: u64 = leaf_pos.into();
 
     let ephem_secret = SecretKey::random(&mut OsRng);