contract/money: Replace incrementalmerkletree with bridgetree crate.

Cargo.lock

@@ -523,6 +523,15 @@ dependencies = [
  "log",
 ]
 
+[[package]]
+name = "bridgetree"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63489cf3bacd4322a34940b86bf68dc51fb37669203059242c8dd37fa5a76daa"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "bs58"
 version = "0.5.0"
@@ -1415,12 +1424,12 @@ version = "0.4.1"
 dependencies = [
  "blake2b_simd",
  "blake3",
+ "bridgetree",
  "bs58",
  "chacha20poly1305",
  "darkfi-serial",
  "halo2_gadgets",
  "halo2_proofs",
- "incrementalmerkletree",
  "lazy_static",
  "num-bigint",
  "num-traits",
@@ -1437,9 +1446,9 @@ name = "darkfi-serial"
 version = "0.4.1"
 dependencies = [
  "blake3",
+ "bridgetree",
  "darkfi-derive",
  "futures-lite",
- "incrementalmerkletree",
  "pasta_curves",
  "url",
 ]
@@ -2663,15 +2672,6 @@ dependencies = [
  "png",
 ]
 
-[[package]]
-name = "incrementalmerkletree"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5ad43a3f5795945459d577f6589cf62a476e92c79b75e70cd954364e14ce17b"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "indexmap"
 version = "1.9.3"

src/contract/money/src/client/mod.rs

@@ -27,7 +27,8 @@
 //! are able to abstract away any wallet interfaces to client implementations.
 
 use darkfi_sdk::{
-    crypto::{pasta_prelude::*, MerklePosition, Nullifier, SecretKey, TokenId, DARK_TOKEN_ID},
+    bridgetree,
+    crypto::{pasta_prelude::*, Nullifier, SecretKey, TokenId, DARK_TOKEN_ID},
     pasta::pallas,
 };
 use darkfi_serial::{SerialDecodable, SerialEncodable};
@@ -131,7 +132,7 @@ pub struct OwnCoin {
     /// Coin's nullifier
     pub nullifier: Nullifier,
     /// Coin's leaf position in the Merkle tree of coins
-    pub leaf_position: MerklePosition,
+    pub leaf_position: bridgetree::Position,
 }
 
 /// `ConsensusNote` holds the inner attributes of a `Coin`.
@@ -181,7 +182,7 @@ pub struct ConsensusOwnCoin {
     /// Coin's nullifier
     pub nullifier: Nullifier,
     /// Coin's leaf position in the Merkle tree of coins
-    pub leaf_position: MerklePosition,
+    pub leaf_position: bridgetree::Position,
 }
 
 impl From<ConsensusOwnCoin> for OwnCoin {

src/contract/money/src/client/stake_v1.rs

@@ -24,11 +24,12 @@ use darkfi::{
     Result,
 };
 use darkfi_sdk::{
+    bridgetree,
+    bridgetree::Hashable,
     crypto::{
         pasta_prelude::*, pedersen_commitment_base, pedersen_commitment_u64, poseidon_hash,
-        MerkleNode, MerklePosition, MerkleTree, Nullifier, PublicKey, SecretKey, DARK_TOKEN_ID,
+        MerkleNode, MerkleTree, Nullifier, PublicKey, SecretKey, DARK_TOKEN_ID,
     },
-    incrementalmerkletree::{Hashable, Tree},
     pasta::pallas,
 };
 use log::{debug, info};
@@ -80,7 +81,7 @@ impl MoneyStakeBurnRevealed {
 }
 
 pub struct TransactionBuilderInputInfo {
-    pub leaf_position: MerklePosition,
+    pub leaf_position: bridgetree::Position,
     pub merkle_path: Vec<MerkleNode>,
     pub secret: SecretKey,
     pub note: MoneyNote,
@@ -100,21 +101,19 @@ pub struct MoneyStakeCallBuilder {
 
 impl MoneyStakeCallBuilder {
     pub fn build(&self) -> Result<MoneyStakeCallDebris> {
-        debug!("Building Money::StakeV1 contract call");
+        info!("Building Money::StakeV1 contract call");
         assert!(self.coin.note.value != 0);
         assert!(self.coin.note.token_id == *DARK_TOKEN_ID);
 
-        debug!("Building anonymous input");
+        debug!("Building Money::StakeV1 anonymous input");
         let leaf_position = self.coin.leaf_position;
-        let root = self.tree.root(0).unwrap();
-        let merkle_path = self.tree.authentication_path(leaf_position, &root).unwrap();
+        let merkle_path = self.tree.witness(leaf_position, 0).unwrap();
         let input = TransactionBuilderInputInfo {
             leaf_position,
             merkle_path,
             secret: self.coin.secret,
             note: self.coin.note.clone(),
         };
-        debug!("Finished building input");
 
         // Create new random blinds and an ephemeral signature key
         let value_blind = pallas::Scalar::random(&mut OsRng);
@@ -122,7 +121,7 @@ impl MoneyStakeCallBuilder {
         let signature_secret = SecretKey::random(&mut OsRng);
         let user_data_blind = pallas::Base::random(&mut OsRng);
 
-        info!("Creating stake burn proof for input");
+        info!("Building Money::Stake V1 Burn ZK proof");
         let (proof, public_inputs) = create_stake_burn_proof(
             &self.burn_zkbin,
             &self.burn_pk,

src/contract/money/src/client/swap_v1.rs

@@ -27,7 +27,6 @@ use darkfi_sdk::{
     crypto::{
         note::AeadEncryptedNote, pasta_prelude::*, MerkleTree, PublicKey, SecretKey, TokenId,
     },
-    incrementalmerkletree::Tree,
     pasta::pallas,
 };
 use darkfi_serial::serialize;
@@ -109,8 +108,7 @@ impl SwapCallBuilder {
         }
 
         let leaf_position = self.coin.leaf_position;
-        let root = self.tree.root(0).unwrap();
-        let merkle_path = self.tree.authentication_path(leaf_position, &root).unwrap();
+        let merkle_path = self.tree.witness(leaf_position, 0).unwrap();
 
         let input = TransactionBuilderInputInfo {
             leaf_position,

src/contract/money/src/client/transfer_v1.rs

@@ -24,12 +24,13 @@ use darkfi::{
     ClientFailed, Result,
 };
 use darkfi_sdk::{
+    bridgetree,
+    bridgetree::Hashable,
     crypto::{
         note::AeadEncryptedNote, pasta_prelude::*, pedersen_commitment_base,
-        pedersen_commitment_u64, poseidon_hash, Keypair, MerkleNode, MerklePosition, MerkleTree,
-        Nullifier, PublicKey, SecretKey, TokenId,
+        pedersen_commitment_u64, poseidon_hash, Keypair, MerkleNode, MerkleTree, Nullifier,
+        PublicKey, SecretKey, TokenId,
     },
-    incrementalmerkletree::{Hashable, Tree},
     pasta::pallas,
 };
 use log::{debug, error, info};
@@ -110,7 +111,7 @@ pub struct TransactionBuilderClearInputInfo {
 }
 
 pub struct TransactionBuilderInputInfo {
-    pub leaf_position: MerklePosition,
+    pub leaf_position: bridgetree::Position,
     pub merkle_path: Vec<MerkleNode>,
     pub secret: SecretKey,
     pub note: MoneyNote,
@@ -203,8 +204,7 @@ impl TransferCallBuilder {
                 }
 
                 let leaf_position = coin.leaf_position;
-                let root = self.tree.root(0).unwrap();
-                let merkle_path = self.tree.authentication_path(leaf_position, &root).unwrap();
+                let merkle_path = self.tree.witness(leaf_position, 0).unwrap();
                 inputs_value += coin.note.value;
 
                 let input = TransactionBuilderInputInfo {

src/contract/money/tests/genesis_mint.rs

@@ -29,10 +29,8 @@ use std::time::{Duration, Instant};
 
 use darkfi::{tx::Transaction, Result};
 use darkfi_sdk::{
-    crypto::{
-        merkle_prelude::*, pallas, pasta_prelude::*, poseidon_hash, MerkleNode, Nullifier,
-        MONEY_CONTRACT_ID,
-    },
+    crypto::{pasta_prelude::*, poseidon_hash, MerkleNode, Nullifier, MONEY_CONTRACT_ID},
+    pasta::pallas,
     ContractCall,
 };
 use darkfi_serial::{serialize, Encodable};
@@ -177,7 +175,7 @@ async fn genesis_mint() -> Result<()> {
         .verify_transactions(&[alice_genesis_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(alice_genesis_mint_params.output.coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(alice_genesis_mint_params.output.coin.inner()));
     genesis_mint_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Alice] ===============================");
@@ -192,9 +190,9 @@ async fn genesis_mint() -> Result<()> {
         .verify_transactions(&[alice_genesis_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(alice_genesis_mint_params.output.coin.inner()));
-    // Alice has to witness this coin because it's hers.
-    let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
+    th.alice.merkle_tree.append(MerkleNode::from(alice_genesis_mint_params.output.coin.inner()));
+    // Alice has to mark this coin because it's hers.
+    let alice_leaf_pos = th.alice.merkle_tree.mark().unwrap();
     genesis_mint_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Bob] ===============================");
@@ -209,7 +207,7 @@ async fn genesis_mint() -> Result<()> {
         .verify_transactions(&[alice_genesis_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(alice_genesis_mint_params.output.coin.inner()));
+    th.bob.merkle_tree.append(MerkleNode::from(alice_genesis_mint_params.output.coin.inner()));
     genesis_mint_verify_times.push(timer.elapsed());
 
     assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
@@ -260,7 +258,7 @@ async fn genesis_mint() -> Result<()> {
         .verify_transactions(&[bob_genesis_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(bob_genesis_mint_params.output.coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(bob_genesis_mint_params.output.coin.inner()));
     genesis_mint_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Alice] ===============================");
@@ -275,7 +273,7 @@ async fn genesis_mint() -> Result<()> {
         .verify_transactions(&[bob_genesis_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(bob_genesis_mint_params.output.coin.inner()));
+    th.alice.merkle_tree.append(MerkleNode::from(bob_genesis_mint_params.output.coin.inner()));
     genesis_mint_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Bob] ===============================");
@@ -290,8 +288,8 @@ async fn genesis_mint() -> Result<()> {
         .verify_transactions(&[bob_genesis_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(bob_genesis_mint_params.output.coin.inner()));
-    let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
+    th.bob.merkle_tree.append(MerkleNode::from(bob_genesis_mint_params.output.coin.inner()));
+    let bob_leaf_pos = th.bob.merkle_tree.mark().unwrap();
     genesis_mint_verify_times.push(timer.elapsed());
 
     assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
@@ -392,8 +390,8 @@ async fn genesis_mint() -> Result<()> {
         .verify_transactions(&[alice2bob_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
-    th.faucet.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
     transfer_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Alice] ==============================");
@@ -408,9 +406,9 @@ async fn genesis_mint() -> Result<()> {
         .verify_transactions(&[alice2bob_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
-    let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
-    th.alice.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
+    th.alice.merkle_tree.append(MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
+    let alice_leaf_pos = th.alice.merkle_tree.mark().unwrap();
+    th.alice.merkle_tree.append(MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
     transfer_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Bob] ==============================");
@@ -425,9 +423,9 @@ async fn genesis_mint() -> Result<()> {
         .verify_transactions(&[alice2bob_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
-    th.bob.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
-    let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
+    th.bob.merkle_tree.append(MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
+    th.bob.merkle_tree.append(MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
+    let bob_leaf_pos = th.bob.merkle_tree.mark().unwrap();
     transfer_verify_times.push(timer.elapsed());
 
     assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
@@ -530,8 +528,8 @@ async fn genesis_mint() -> Result<()> {
         .verify_transactions(&[bob2alice_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
-    th.faucet.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
     transfer_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Alice] ==============================");
@@ -546,9 +544,9 @@ async fn genesis_mint() -> Result<()> {
         .verify_transactions(&[bob2alice_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
-    th.alice.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
-    let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
+    th.alice.merkle_tree.append(MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
+    th.alice.merkle_tree.append(MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
+    let alice_leaf_pos = th.alice.merkle_tree.mark().unwrap();
     transfer_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Bob] ==================+===========");
@@ -563,9 +561,9 @@ async fn genesis_mint() -> Result<()> {
         .verify_transactions(&[bob2alice_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
-    let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
-    th.bob.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
+    th.bob.merkle_tree.append(MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
+    let bob_leaf_pos = th.bob.merkle_tree.mark().unwrap();
+    th.bob.merkle_tree.append(MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
     transfer_verify_times.push(timer.elapsed());
 
     // Alice should now have two OwnCoins

src/contract/money/tests/integration.rs

@@ -30,10 +30,7 @@
 //! TODO: Malicious cases
 
 use darkfi::Result;
-use darkfi_sdk::{
-    crypto::{poseidon_hash, Keypair, MerkleNode, Nullifier},
-    incrementalmerkletree::Tree,
-};
+use darkfi_sdk::crypto::{poseidon_hash, Keypair, MerkleNode, Nullifier};
 use log::info;
 use rand::rngs::OsRng;
 
@@ -64,7 +61,7 @@ async fn money_integration() -> Result<()> {
         .verify_transactions(&[alice_airdrop_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(alice_airdrop_params.outputs[0].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(alice_airdrop_params.outputs[0].coin.inner()));
 
     info!("[Alice] Executing Alice airdrop tx");
     let erroneous_txs = th
@@ -75,9 +72,9 @@ async fn money_integration() -> Result<()> {
         .verify_transactions(&[alice_airdrop_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(alice_airdrop_params.outputs[0].coin.inner()));
-    // Alice has to witness this coin because it's hers.
-    let leaf_position = th.alice.merkle_tree.witness().unwrap();
+    th.alice.merkle_tree.append(MerkleNode::from(alice_airdrop_params.outputs[0].coin.inner()));
+    // Alice has to mark this coin because it's hers.
+    let leaf_position = th.alice.merkle_tree.mark().unwrap();
 
     info!("[Bob] Executing Alice airdrop tx");
     let erroneous_txs = th
@@ -88,7 +85,7 @@ async fn money_integration() -> Result<()> {
         .verify_transactions(&[alice_airdrop_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(alice_airdrop_params.outputs[0].coin.inner()));
+    th.bob.merkle_tree.append(MerkleNode::from(alice_airdrop_params.outputs[0].coin.inner()));
 
     info!("[Charlie] Executing Alice airdrop tx");
     let erroneous_txs = th
@@ -99,7 +96,7 @@ async fn money_integration() -> Result<()> {
         .verify_transactions(&[alice_airdrop_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.charlie.merkle_tree.append(&MerkleNode::from(alice_airdrop_params.outputs[0].coin.inner()));
+    th.charlie.merkle_tree.append(MerkleNode::from(alice_airdrop_params.outputs[0].coin.inner()));
 
     assert_eq!(th.alice.merkle_tree.root(0).unwrap(), th.bob.merkle_tree.root(0).unwrap());
     assert_eq!(th.bob.merkle_tree.root(0).unwrap(), th.charlie.merkle_tree.root(0).unwrap());
@@ -130,7 +127,7 @@ async fn money_integration() -> Result<()> {
         .verify_transactions(&[bob_charlie_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(bob_charlie_mint_params.output.coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(bob_charlie_mint_params.output.coin.inner()));
 
     info!("[Alice] Executing BOBTOKEN mint to Charlie");
     let erroneous_txs = th
@@ -141,7 +138,7 @@ async fn money_integration() -> Result<()> {
         .verify_transactions(&[bob_charlie_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(bob_charlie_mint_params.output.coin.inner()));
+    th.alice.merkle_tree.append(MerkleNode::from(bob_charlie_mint_params.output.coin.inner()));
 
     info!("[Bob] Executing BOBTOKEN mint to Charlie");
     let erroneous_txs = th
@@ -152,7 +149,7 @@ async fn money_integration() -> Result<()> {
         .verify_transactions(&[bob_charlie_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(bob_charlie_mint_params.output.coin.inner()));
+    th.bob.merkle_tree.append(MerkleNode::from(bob_charlie_mint_params.output.coin.inner()));
 
     info!("[Charlie] Executing BOBTOKEN mint to Charlie");
     let erroneous_txs = th
@@ -163,9 +160,9 @@ async fn money_integration() -> Result<()> {
         .verify_transactions(&[bob_charlie_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.charlie.merkle_tree.append(&MerkleNode::from(bob_charlie_mint_params.output.coin.inner()));
-    // Charlie has to witness this coin because it's his.
-    let leaf_position = th.charlie.merkle_tree.witness().unwrap();
+    th.charlie.merkle_tree.append(MerkleNode::from(bob_charlie_mint_params.output.coin.inner()));
+    // Charlie has to mark this coin because it's his.
+    let leaf_position = th.charlie.merkle_tree.mark().unwrap();
 
     assert_eq!(th.alice.merkle_tree.root(0).unwrap(), th.bob.merkle_tree.root(0).unwrap());
     assert_eq!(th.bob.merkle_tree.root(0).unwrap(), th.charlie.merkle_tree.root(0).unwrap());

src/contract/money/tests/mint_pay_swap.rs

@@ -32,9 +32,9 @@ use std::time::{Duration, Instant};
 use darkfi::{tx::Transaction, Result};
 use darkfi_sdk::{
     crypto::{
-        merkle_prelude::*, pallas, pasta_prelude::*, poseidon_hash, MerkleNode, Nullifier,
-        ValueBlind, MONEY_CONTRACT_ID,
+        pasta_prelude::*, poseidon_hash, MerkleNode, Nullifier, ValueBlind, MONEY_CONTRACT_ID,
     },
+    pasta::pallas,
     ContractCall,
 };
 use darkfi_serial::{serialize, Encodable};
@@ -141,7 +141,7 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alice_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(alice_params.output.coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(alice_params.output.coin.inner()));
     mint_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Faucet] ===========================");
@@ -156,7 +156,7 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[bob_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(bob_params.output.coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(bob_params.output.coin.inner()));
     mint_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Alice] =============================");
@@ -171,9 +171,9 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alice_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(alice_params.output.coin.inner()));
-    // Alice has to witness this coin because it's hers.
-    let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
+    th.alice.merkle_tree.append(MerkleNode::from(alice_params.output.coin.inner()));
+    // Alice has to mark this coin because it's hers.
+    let alice_leaf_pos = th.alice.merkle_tree.mark().unwrap();
     mint_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Alice] ===========================");
@@ -188,7 +188,7 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[bob_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(bob_params.output.coin.inner()));
+    th.alice.merkle_tree.append(MerkleNode::from(bob_params.output.coin.inner()));
     mint_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Bob] =============================");
@@ -203,7 +203,7 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alice_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(alice_params.output.coin.inner()));
+    th.bob.merkle_tree.append(MerkleNode::from(alice_params.output.coin.inner()));
     mint_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Bob] ===========================");
@@ -218,8 +218,8 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[bob_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(bob_params.output.coin.inner()));
-    let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
+    th.bob.merkle_tree.append(MerkleNode::from(bob_params.output.coin.inner()));
+    let bob_leaf_pos = th.bob.merkle_tree.mark().unwrap();
     mint_verify_times.push(timer.elapsed());
 
     assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
@@ -319,8 +319,8 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alice2bob_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
-    th.faucet.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
     transfer_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Alice] ==============================");
@@ -335,9 +335,9 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alice2bob_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
-    let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
-    th.alice.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
+    th.alice.merkle_tree.append(MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
+    let alice_leaf_pos = th.alice.merkle_tree.mark().unwrap();
+    th.alice.merkle_tree.append(MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
     transfer_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Bob] ==============================");
@@ -352,9 +352,9 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alice2bob_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
-    th.bob.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
-    let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
+    th.bob.merkle_tree.append(MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
+    th.bob.merkle_tree.append(MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
+    let bob_leaf_pos = th.bob.merkle_tree.mark().unwrap();
     transfer_verify_times.push(timer.elapsed());
 
     assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
@@ -457,8 +457,8 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[bob2alice_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
-    th.faucet.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
     transfer_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Alice] ==============================");
@@ -473,9 +473,9 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[bob2alice_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
-    th.alice.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
-    let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
+    th.alice.merkle_tree.append(MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
+    th.alice.merkle_tree.append(MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
+    let alice_leaf_pos = th.alice.merkle_tree.mark().unwrap();
     transfer_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Bob] ==================+===========");
@@ -490,9 +490,9 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[bob2alice_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
-    let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
-    th.bob.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
+    th.bob.merkle_tree.append(MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
+    let bob_leaf_pos = th.bob.merkle_tree.mark().unwrap();
+    th.bob.merkle_tree.append(MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
     transfer_verify_times.push(timer.elapsed());
 
     // Alice should now have two OwnCoins
@@ -654,8 +654,8 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alicebob_swap_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
-    th.faucet.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
     swap_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Alice] ==========================");
@@ -670,9 +670,9 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alicebob_swap_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
-    let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
-    th.alice.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
+    th.alice.merkle_tree.append(MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
+    let alice_leaf_pos = th.alice.merkle_tree.mark().unwrap();
+    th.alice.merkle_tree.append(MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
     swap_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Bob] ==========================");
@@ -687,9 +687,9 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alicebob_swap_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
-    th.bob.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
-    let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
+    th.bob.merkle_tree.append(MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
+    th.bob.merkle_tree.append(MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
+    let bob_leaf_pos = th.bob.merkle_tree.mark().unwrap();
     swap_verify_times.push(timer.elapsed());
 
     assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
@@ -796,7 +796,7 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alice2alice_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(alice2alice_params.outputs[0].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(alice2alice_params.outputs[0].coin.inner()));
     transfer_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Alice] ================================");
@@ -811,8 +811,8 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alice2alice_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(alice2alice_params.outputs[0].coin.inner()));
-    let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
+    th.alice.merkle_tree.append(MerkleNode::from(alice2alice_params.outputs[0].coin.inner()));
+    let alice_leaf_pos = th.alice.merkle_tree.mark().unwrap();
     transfer_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Bob] ================================");
@@ -827,7 +827,7 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alice2alice_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(alice2alice_params.outputs[0].coin.inner()));
+    th.bob.merkle_tree.append(MerkleNode::from(alice2alice_params.outputs[0].coin.inner()));
     transfer_verify_times.push(timer.elapsed());
 
     assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
@@ -919,7 +919,7 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[bob2bob_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(bob2bob_params.outputs[0].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(bob2bob_params.outputs[0].coin.inner()));
     transfer_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Alice] ============================");
@@ -934,7 +934,7 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[bob2bob_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(bob2bob_params.outputs[0].coin.inner()));
+    th.alice.merkle_tree.append(MerkleNode::from(bob2bob_params.outputs[0].coin.inner()));
     transfer_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Bob] ============================");
@@ -949,8 +949,8 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[bob2bob_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(bob2bob_params.outputs[0].coin.inner()));
-    let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
+    th.bob.merkle_tree.append(MerkleNode::from(bob2bob_params.outputs[0].coin.inner()));
+    let bob_leaf_pos = th.bob.merkle_tree.mark().unwrap();
     transfer_verify_times.push(timer.elapsed());
 
     assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
@@ -1090,8 +1090,8 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alicebob_swap_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
-    th.faucet.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
     swap_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Alice] ==========================");
@@ -1106,9 +1106,9 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alicebob_swap_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
-    let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
-    th.alice.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
+    th.alice.merkle_tree.append(MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
+    let alice_leaf_pos = th.alice.merkle_tree.mark().unwrap();
+    th.alice.merkle_tree.append(MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
     swap_verify_times.push(timer.elapsed());
 
     info!(target: "money", "[Bob] ==========================");
@@ -1123,9 +1123,9 @@ async fn money_contract_transfer() -> Result<()> {
         .verify_transactions(&[alicebob_swap_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
-    th.bob.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
-    let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
+    th.bob.merkle_tree.append(MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
+    th.bob.merkle_tree.append(MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
+    let bob_leaf_pos = th.bob.merkle_tree.mark().unwrap();
     swap_verify_times.push(timer.elapsed());
 
     assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());

src/contract/money/tests/txs_verification.rs

@@ -26,10 +26,8 @@
 
 use darkfi::{tx::Transaction, Result};
 use darkfi_sdk::{
-    crypto::{
-        merkle_prelude::*, pallas, pasta_prelude::*, poseidon_hash, MerkleNode, Nullifier,
-        MONEY_CONTRACT_ID,
-    },
+    crypto::{pasta_prelude::*, poseidon_hash, MerkleNode, Nullifier, MONEY_CONTRACT_ID},
+    pasta::pallas,
     ContractCall,
 };
 use darkfi_serial::Encodable;
@@ -94,7 +92,7 @@ async fn txs_verification() -> Result<()> {
         .verify_transactions(&[alice_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(alice_params.output.coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(alice_params.output.coin.inner()));
 
     info!(target: "money", "[Alice] =============================");
     info!(target: "money", "[Alice] Executing Alice token mint tx");
@@ -107,9 +105,9 @@ async fn txs_verification() -> Result<()> {
         .verify_transactions(&[alice_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(alice_params.output.coin.inner()));
-    // Alice has to witness this coin because it's hers.
-    let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
+    th.alice.merkle_tree.append(MerkleNode::from(alice_params.output.coin.inner()));
+    // Alice has to mark this coin because it's hers.
+    let alice_leaf_pos = th.alice.merkle_tree.mark().unwrap();
 
     info!(target: "money", "[Bob] =============================");
     info!(target: "money", "[Bob] Executing Alice token mint tx");
@@ -122,7 +120,7 @@ async fn txs_verification() -> Result<()> {
         .verify_transactions(&[alice_mint_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(alice_params.output.coin.inner()));
+    th.bob.merkle_tree.append(MerkleNode::from(alice_params.output.coin.inner()));
 
     assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
     assert!(th.faucet.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
@@ -242,8 +240,8 @@ async fn txs_verification() -> Result<()> {
     let erroneous_txs =
         th.faucet.state.read().await.verify_transactions(&valid_txs, current_slot, true).await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(txs_params[0].outputs[0].coin.inner()));
-    th.faucet.merkle_tree.append(&MerkleNode::from(txs_params[0].outputs[1].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(txs_params[0].outputs[0].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(txs_params[0].outputs[1].coin.inner()));
 
     info!(target: "money", "[Alice] ==============================");
     info!(target: "money", "[Alice] Executing Alice2Bob payment tx");
@@ -254,9 +252,9 @@ async fn txs_verification() -> Result<()> {
     let erroneous_txs =
         th.alice.state.read().await.verify_transactions(&valid_txs, current_slot, true).await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(txs_params[0].outputs[0].coin.inner()));
-    let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
-    th.alice.merkle_tree.append(&MerkleNode::from(txs_params[0].outputs[1].coin.inner()));
+    th.alice.merkle_tree.append(MerkleNode::from(txs_params[0].outputs[0].coin.inner()));
+    let alice_leaf_pos = th.alice.merkle_tree.mark().unwrap();
+    th.alice.merkle_tree.append(MerkleNode::from(txs_params[0].outputs[1].coin.inner()));
 
     info!(target: "money", "[Bob] ==============================");
     info!(target: "money", "[Bob] Executing Alice2Bob payment tx");
@@ -267,9 +265,9 @@ async fn txs_verification() -> Result<()> {
     let erroneous_txs =
         th.bob.state.read().await.verify_transactions(&valid_txs, current_slot, true).await?;
     assert!(erroneous_txs.is_empty());
-    th.bob.merkle_tree.append(&MerkleNode::from(txs_params[0].outputs[0].coin.inner()));
-    th.bob.merkle_tree.append(&MerkleNode::from(txs_params[0].outputs[1].coin.inner()));
-    let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
+    th.bob.merkle_tree.append(MerkleNode::from(txs_params[0].outputs[0].coin.inner()));
+    th.bob.merkle_tree.append(MerkleNode::from(txs_params[0].outputs[1].coin.inner()));
+    let bob_leaf_pos = th.bob.merkle_tree.mark().unwrap();
 
     assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
     assert!(th.faucet.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());

src/contract/money/tests/verification_bench.rs

@@ -20,10 +20,8 @@ use std::{env, str::FromStr};
 
 use darkfi::{tx::Transaction, Result};
 use darkfi_sdk::{
-    crypto::{
-        merkle_prelude::*, pallas, pasta_prelude::*, poseidon_hash, MerkleNode, Nullifier,
-        MONEY_CONTRACT_ID,
-    },
+    crypto::{pasta_prelude::*, poseidon_hash, MerkleNode, Nullifier, MONEY_CONTRACT_ID},
+    pasta::pallas,
     ContractCall,
 };
 use darkfi_serial::Encodable;
@@ -83,7 +81,7 @@ async fn alice2alice_random_amounts() -> Result<()> {
         .verify_transactions(&[airdrop_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.faucet.merkle_tree.append(&MerkleNode::from(airdrop_params.outputs[0].coin.inner()));
+    th.faucet.merkle_tree.append(MerkleNode::from(airdrop_params.outputs[0].coin.inner()));
     info!(target: "money", "[Alice] ==========================");
     info!(target: "money", "[Alice] Executing Alice airdrop tx");
     info!(target: "money", "[Alice] ==========================");
@@ -95,13 +93,13 @@ async fn alice2alice_random_amounts() -> Result<()> {
         .verify_transactions(&[airdrop_tx.clone()], current_slot, true)
         .await?;
     assert!(erroneous_txs.is_empty());
-    th.alice.merkle_tree.append(&MerkleNode::from(airdrop_params.outputs[0].coin.inner()));
+    th.alice.merkle_tree.append(MerkleNode::from(airdrop_params.outputs[0].coin.inner()));
 
     assert!(th.faucet.merkle_tree.root(0).unwrap() == th.alice.merkle_tree.root(0).unwrap());
 
     // Gather new owncoins
     let mut owncoins = vec![];
-    let leaf_position = th.alice.merkle_tree.witness().unwrap();
+    let leaf_position = th.alice.merkle_tree.mark().unwrap();
     let note: MoneyNote = airdrop_params.outputs[0].note.decrypt(&th.alice.keypair.secret)?;
     let token_id = note.token_id;
     owncoins.push(OwnCoin {
@@ -179,7 +177,7 @@ async fn alice2alice_random_amounts() -> Result<()> {
             .await?;
         assert!(erroneous_txs.is_empty());
         for output in &params.outputs {
-            th.faucet.merkle_tree.append(&MerkleNode::from(output.coin.inner()));
+            th.faucet.merkle_tree.append(MerkleNode::from(output.coin.inner()));
         }
         info!(target: "money", "[Alice] ================================");
         info!(target: "money", "[Alice] Executing Alice2Alice payment tx");
@@ -194,9 +192,9 @@ async fn alice2alice_random_amounts() -> Result<()> {
         assert!(erroneous_txs.is_empty());
         // Gather new owncoins and apply the state transitions
         for output in params.outputs {
-            th.alice.merkle_tree.append(&MerkleNode::from(output.coin.inner()));
+            th.alice.merkle_tree.append(MerkleNode::from(output.coin.inner()));
             let note: MoneyNote = output.note.decrypt(&th.alice.keypair.secret)?;
-            let leaf_position = th.alice.merkle_tree.witness().unwrap();
+            let leaf_position = th.alice.merkle_tree.mark().unwrap();
 
             let owncoin = OwnCoin {
                 coin: Coin::from(output.coin),
@@ -266,7 +264,7 @@ async fn alice2alice_random_amounts_multiplecoins() -> Result<()> {
             .verify_transactions(&[mint_tx.clone()], current_slot, true)
             .await?;
         assert!(erroneous_txs.is_empty());
-        th.faucet.merkle_tree.append(&MerkleNode::from(mint_params.output.coin.inner()));
+        th.faucet.merkle_tree.append(MerkleNode::from(mint_params.output.coin.inner()));
         info!(target: "money", "[Alice] =======================");
         info!(target: "money", "[Alice] Executing Alice mint tx");
         info!(target: "money", "[Alice] =======================");
@@ -278,12 +276,12 @@ async fn alice2alice_random_amounts_multiplecoins() -> Result<()> {
             .verify_transactions(&[mint_tx.clone()], current_slot, true)
             .await?;
         assert!(erroneous_txs.is_empty());
-        th.alice.merkle_tree.append(&MerkleNode::from(mint_params.output.coin.inner()));
+        th.alice.merkle_tree.append(MerkleNode::from(mint_params.output.coin.inner()));
 
         assert!(th.faucet.merkle_tree.root(0).unwrap() == th.alice.merkle_tree.root(0).unwrap());
 
         // Gather new owncoins
-        let leaf_position = th.alice.merkle_tree.witness().unwrap();
+        let leaf_position = th.alice.merkle_tree.mark().unwrap();
         let note: MoneyNote = mint_params.output.note.decrypt(&th.alice.keypair.secret)?;
         let token_id = note.token_id;
         owncoins.push(vec![OwnCoin {
@@ -373,10 +371,10 @@ async fn alice2alice_random_amounts_multiplecoins() -> Result<()> {
 
             // Gather new owncoins
             for output in params.outputs {
-                th.faucet.merkle_tree.append(&MerkleNode::from(output.coin.inner()));
-                th.alice.merkle_tree.append(&MerkleNode::from(output.coin.inner()));
+                th.faucet.merkle_tree.append(MerkleNode::from(output.coin.inner()));
+                th.alice.merkle_tree.append(MerkleNode::from(output.coin.inner()));
                 let note: MoneyNote = output.note.decrypt(&th.alice.keypair.secret)?;
-                let leaf_position = th.alice.merkle_tree.witness().unwrap();
+                let leaf_position = th.alice.merkle_tree.mark().unwrap();
 
                 let owncoin = OwnCoin {
                     coin: Coin::from(output.coin),