diff --git a/nssa/Cargo.toml b/nssa/Cargo.toml
index 0939c39..c050c65 100644
--- a/nssa/Cargo.toml
+++ b/nssa/Cargo.toml
@@ -18,3 +18,4 @@ hex = "0.4.3"
 
 [dev-dependencies]
 test-program-methods = { path = "test_program_methods" }
+hex-literal = "1.0.0"
diff --git a/nssa/src/merkle_tree/default_values.rs b/nssa/src/merkle_tree/default_values.rs
index 0316644..c011557 100644
--- a/nssa/src/merkle_tree/default_values.rs
+++ b/nssa/src/merkle_tree/default_values.rs
@@ -1,130 +1,36 @@
+use hex_literal::hex;
+
 pub(crate) const DEFAULT_VALUES: [[u8; 32]; 32] = [
-    [
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0,
-    ],
-    [
-        245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67, 0, 61, 35,
-        32, 217, 240, 232, 234, 152, 49, 169, 39, 89, 251, 75,
-    ],
-    [
-        219, 86, 17, 78, 0, 253, 212, 193, 248, 92, 137, 43, 243, 90, 201, 168, 146, 137, 170, 236,
-        177, 235, 208, 169, 108, 222, 96, 106, 116, 139, 93, 113,
-    ],
-    [
-        199, 128, 9, 253, 240, 127, 197, 106, 17, 241, 34, 55, 6, 88, 163, 83, 170, 165, 66, 237,
-        99, 228, 76, 75, 193, 95, 244, 205, 16, 90, 179, 60,
-    ],
-    [
-        83, 109, 152, 131, 127, 45, 209, 101, 165, 93, 94, 234, 233, 20, 133, 149, 68, 114, 213,
-        111, 36, 109, 242, 86, 191, 60, 174, 25, 53, 42, 18, 60,
-    ],
-    [
-        158, 253, 224, 82, 170, 21, 66, 159, 174, 5, 186, 212, 208, 177, 215, 198, 77, 166, 77, 3,
-        215, 161, 133, 74, 88, 140, 44, 184, 67, 12, 13, 48,
-    ],
-    [
-        216, 141, 223, 238, 212, 0, 168, 117, 85, 150, 178, 25, 66, 193, 73, 126, 17, 76, 48, 46,
-        97, 24, 41, 15, 145, 230, 119, 41, 118, 4, 31, 161,
-    ],
-    [
-        135, 235, 13, 219, 165, 126, 53, 246, 210, 134, 103, 56, 2, 164, 175, 89, 117, 226, 37, 6,
-        199, 207, 76, 100, 187, 107, 229, 238, 17, 82, 127, 44,
-    ],
-    [
-        38, 132, 100, 118, 253, 95, 197, 74, 93, 67, 56, 81, 103, 201, 81, 68, 242, 100, 63, 83,
-        60, 200, 91, 185, 209, 107, 120, 47, 141, 125, 177, 147,
-    ],
-    [
-        80, 109, 134, 88, 45, 37, 36, 5, 184, 64, 1, 135, 146, 202, 210, 191, 18, 89, 241, 239, 90,
-        165, 248, 135, 225, 60, 178, 240, 9, 79, 81, 225,
-    ],
-    [
-        255, 255, 10, 215, 230, 89, 119, 47, 149, 52, 193, 149, 200, 21, 239, 196, 1, 78, 241, 225,
-        218, 237, 68, 4, 192, 99, 133, 209, 17, 146, 233, 43,
-    ],
-    [
-        108, 240, 65, 39, 219, 5, 68, 28, 216, 51, 16, 122, 82, 190, 133, 40, 104, 137, 14, 67, 23,
-        230, 160, 42, 180, 118, 131, 170, 117, 150, 66, 32,
-    ],
-    [
-        183, 208, 95, 135, 95, 20, 0, 39, 239, 81, 24, 162, 36, 123, 187, 132, 206, 143, 47, 15,
-        17, 35, 98, 48, 133, 218, 247, 150, 12, 50, 159, 95,
-    ],
-    [
-        223, 106, 245, 245, 187, 219, 107, 233, 239, 138, 166, 24, 228, 191, 128, 115, 150, 8, 103,
-        23, 30, 41, 103, 111, 139, 40, 77, 234, 106, 8, 168, 94,
-    ],
-    [
-        181, 141, 144, 15, 94, 24, 46, 60, 80, 239, 116, 150, 158, 161, 108, 119, 38, 197, 73, 117,
-        124, 194, 53, 35, 195, 105, 88, 125, 167, 41, 55, 132,
-    ],
-    [
-        212, 154, 117, 2, 255, 207, 176, 52, 11, 29, 120, 133, 104, 133, 0, 202, 48, 129, 97, 167,
-        249, 107, 98, 223, 157, 8, 59, 113, 252, 200, 242, 187,
-    ],
-    [
-        143, 230, 177, 104, 146, 86, 192, 211, 133, 244, 47, 91, 190, 32, 39, 162, 44, 25, 150,
-        225, 16, 186, 151, 193, 113, 211, 229, 148, 141, 233, 43, 235,
-    ],
-    [
-        141, 13, 99, 195, 158, 186, 222, 133, 9, 224, 174, 60, 156, 56, 118, 251, 95, 161, 18, 190,
-        24, 249, 5, 236, 172, 254, 203, 146, 5, 118, 3, 171,
-    ],
-    [
-        149, 238, 200, 178, 229, 65, 202, 212, 233, 29, 227, 131, 133, 242, 224, 70, 97, 159, 84,
-        73, 108, 35, 130, 203, 108, 172, 213, 185, 140, 38, 245, 164,
-    ],
-    [
-        248, 147, 233, 8, 145, 119, 117, 182, 43, 255, 35, 41, 77, 187, 227, 161, 205, 142, 108,
-        193, 195, 91, 72, 1, 136, 123, 100, 106, 111, 129, 241, 127,
-    ],
-    [
-        205, 219, 167, 181, 146, 227, 19, 51, 147, 193, 97, 148, 250, 199, 67, 26, 191, 47, 84,
-        133, 237, 113, 29, 178, 130, 24, 60, 129, 158, 8, 235, 170,
-    ],
-    [
-        138, 141, 127, 227, 175, 140, 170, 8, 90, 118, 57, 168, 50, 0, 20, 87, 223, 185, 18, 138,
-        128, 97, 20, 42, 208, 51, 86, 41, 255, 35, 255, 156,
-    ],
-    [
-        254, 179, 195, 55, 215, 165, 26, 111, 191, 0, 185, 227, 76, 82, 225, 201, 25, 92, 150, 155,
-        212, 231, 160, 191, 213, 29, 92, 91, 237, 156, 17, 103,
-    ],
-    [
-        231, 31, 10, 168, 60, 195, 46, 223, 190, 250, 159, 77, 62, 1, 116, 202, 133, 24, 46, 236,
-        159, 58, 9, 246, 166, 192, 223, 99, 119, 165, 16, 215,
-    ],
-    [
-        49, 32, 111, 168, 10, 80, 187, 106, 190, 41, 8, 80, 88, 241, 98, 18, 33, 42, 96, 238, 200,
-        240, 73, 254, 203, 146, 216, 200, 224, 168, 75, 192,
-    ],
-    [
-        33, 53, 43, 254, 203, 237, 221, 233, 147, 131, 159, 97, 76, 61, 172, 10, 62, 227, 117, 67,
-        249, 180, 18, 177, 97, 153, 220, 21, 142, 35, 181, 68,
-    ],
-    [
-        97, 158, 49, 39, 36, 187, 109, 124, 49, 83, 237, 157, 231, 145, 215, 100, 163, 102, 179,
-        137, 175, 19, 197, 139, 248, 168, 217, 4, 129, 164, 103, 101,
-    ],
-    [
-        124, 221, 41, 134, 38, 130, 80, 98, 141, 12, 16, 227, 133, 197, 140, 97, 145, 230, 251,
-        224, 81, 145, 188, 192, 79, 19, 63, 44, 234, 114, 193, 196,
-    ],
-    [
-        132, 137, 48, 189, 123, 168, 202, 197, 70, 97, 7, 33, 19, 251, 39, 136, 105, 224, 123, 184,
-        88, 127, 145, 57, 41, 51, 55, 77, 1, 123, 203, 225,
-    ],
-    [
-        136, 105, 255, 44, 34, 178, 140, 193, 5, 16, 217, 133, 50, 146, 128, 51, 40, 190, 79, 176,
-        232, 4, 149, 232, 187, 141, 39, 31, 91, 136, 150, 54,
-    ],
-    [
-        181, 254, 40, 231, 159, 27, 133, 15, 134, 88, 36, 108, 233, 182, 161, 231, 180, 159, 192,
-        109, 183, 20, 62, 143, 224, 180, 242, 176, 197, 82, 58, 92,
-    ],
-    [
-        152, 94, 146, 159, 112, 175, 40, 208, 189, 209, 169, 10, 128, 143, 151, 127, 89, 124, 124,
-        119, 140, 72, 158, 152, 211, 189, 137, 16, 211, 26, 192, 247,
-    ],
+    hex!("0000000000000000000000000000000000000000000000000000000000000000"),
+    hex!("f5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a92759fb4b"),
+    hex!("db56114e00fdd4c1f85c892bf35ac9a89289aaecb1ebd0a96cde606a748b5d71"),
+    hex!("c78009fdf07fc56a11f122370658a353aaa542ed63e44c4bc15ff4cd105ab33c"),
+    hex!("536d98837f2dd165a55d5eeae91485954472d56f246df256bf3cae19352a123c"),
+    hex!("9efde052aa15429fae05bad4d0b1d7c64da64d03d7a1854a588c2cb8430c0d30"),
+    hex!("d88ddfeed400a8755596b21942c1497e114c302e6118290f91e6772976041fa1"),
+    hex!("87eb0ddba57e35f6d286673802a4af5975e22506c7cf4c64bb6be5ee11527f2c"),
+    hex!("26846476fd5fc54a5d43385167c95144f2643f533cc85bb9d16b782f8d7db193"),
+    hex!("506d86582d252405b840018792cad2bf1259f1ef5aa5f887e13cb2f0094f51e1"),
+    hex!("ffff0ad7e659772f9534c195c815efc4014ef1e1daed4404c06385d11192e92b"),
+    hex!("6cf04127db05441cd833107a52be852868890e4317e6a02ab47683aa75964220"),
+    hex!("b7d05f875f140027ef5118a2247bbb84ce8f2f0f1123623085daf7960c329f5f"),
+    hex!("df6af5f5bbdb6be9ef8aa618e4bf8073960867171e29676f8b284dea6a08a85e"),
+    hex!("b58d900f5e182e3c50ef74969ea16c7726c549757cc23523c369587da7293784"),
+    hex!("d49a7502ffcfb0340b1d7885688500ca308161a7f96b62df9d083b71fcc8f2bb"),
+    hex!("8fe6b1689256c0d385f42f5bbe2027a22c1996e110ba97c171d3e5948de92beb"),
+    hex!("8d0d63c39ebade8509e0ae3c9c3876fb5fa112be18f905ecacfecb92057603ab"),
+    hex!("95eec8b2e541cad4e91de38385f2e046619f54496c2382cb6cacd5b98c26f5a4"),
+    hex!("f893e908917775b62bff23294dbbe3a1cd8e6cc1c35b4801887b646a6f81f17f"),
+    hex!("cddba7b592e3133393c16194fac7431abf2f5485ed711db282183c819e08ebaa"),
+    hex!("8a8d7fe3af8caa085a7639a832001457dfb9128a8061142ad0335629ff23ff9c"),
+    hex!("feb3c337d7a51a6fbf00b9e34c52e1c9195c969bd4e7a0bfd51d5c5bed9c1167"),
+    hex!("e71f0aa83cc32edfbefa9f4d3e0174ca85182eec9f3a09f6a6c0df6377a510d7"),
+    hex!("31206fa80a50bb6abe29085058f16212212a60eec8f049fecb92d8c8e0a84bc0"),
+    hex!("21352bfecbeddde993839f614c3dac0a3ee37543f9b412b16199dc158e23b544"),
+    hex!("619e312724bb6d7c3153ed9de791d764a366b389af13c58bf8a8d90481a46765"),
+    hex!("7cdd2986268250628d0c10e385c58c6191e6fbe05191bcc04f133f2cea72c1c4"),
+    hex!("848930bd7ba8cac54661072113fb278869e07bb8587f91392933374d017bcbe1"),
+    hex!("8869ff2c22b28cc10510d9853292803328be4fb0e80495e8bb8d271f5b889636"),
+    hex!("b5fe28e79f1b850f8658246ce9b6a1e7b49fc06db7143e8fe0b4f2b0c5523a5c"),
+    hex!("985e929f70af28d0bdd1a90a808f977f597c7c778c489e98d3bd8910d31ac0f7"),
 ];
diff --git a/nssa/src/merkle_tree/mod.rs b/nssa/src/merkle_tree/mod.rs
index fffcb7d..30ddf79 100644
--- a/nssa/src/merkle_tree/mod.rs
+++ b/nssa/src/merkle_tree/mod.rs
@@ -23,147 +23,135 @@ fn hash_value(value: &Value) -> Node {
 
 #[cfg_attr(test, derive(Debug, PartialEq, Eq))]
 pub struct MerkleTree {
-    index_map: HashMap<Value, usize>,
-    node_map: HashMap<usize, Node>,
+    nodes: Vec<Node>,
     capacity: usize,
+    length: usize,
 }
 
 impl MerkleTree {
     pub fn root(&self) -> Node {
         let root_index = self.root_index();
-        *self.get_node(&root_index)
+        *self.get_node(root_index)
     }
 
     fn root_index(&self) -> usize {
+        let tree_depth = self.depth();
         let capacity_depth = self.capacity.trailing_zeros() as usize;
-        let diff = capacity_depth - self.depth();
-        if diff == 0 { 0 } else { (1 << diff) - 1 }
+
+        if tree_depth == capacity_depth {
+            0
+        } else {
+            (1 << (capacity_depth - tree_depth)) - 1
+        }
     }
 
+    /// Number of levels required to hold all values
     fn depth(&self) -> usize {
-        self.index_map.len().next_power_of_two().trailing_zeros() as usize
+        let result = self.length.next_power_of_two().trailing_zeros() as usize;
+        result
     }
 
-    fn get_node(&self, index: &usize) -> &Node {
-        self.node_map.get(&index).unwrap_or_else(|| {
-            let index_depth = usize::BITS as usize - (index + 1).leading_zeros() as usize - 1;
-            let total_levels = self.capacity.trailing_zeros() as usize;
-            if total_levels >= index_depth {
-                &default_values::DEFAULT_VALUES[total_levels - index_depth]
-            } else {
-                //TODO: implement error handling
-                panic!();
-            }
-        })
+    fn get_node(&self, index: usize) -> &Node {
+        &self.nodes[index]
     }
 
     fn set_node(&mut self, index: usize, node: Node) {
-        self.node_map.insert(index, node);
+        self.nodes[index] = node;
     }
 
     pub fn with_capacity(capacity: usize) -> Self {
         let capacity = capacity.next_power_of_two();
+        let total_depth = capacity.trailing_zeros() as usize;
+
+        let nodes = default_values::DEFAULT_VALUES[..(total_depth + 1)]
+            .iter()
+            .rev()
+            .enumerate()
+            .flat_map(|(level, default_value)| std::iter::repeat_n(default_value, 1 << level))
+            .cloned()
+            .collect();
+
         Self {
-            index_map: HashMap::with_capacity(capacity),
-            node_map: HashMap::with_capacity(capacity << 1),
+            nodes,
             capacity,
+            length: 0,
         }
     }
 
     fn reallocate_to_double_capacity(&mut self) {
-        let mut this = Self::with_capacity(self.capacity << 1);
-        let mut pairs: Vec<_> = self.index_map.iter().collect();
-        pairs.sort_by_key(|&(_, index)| index);
-        for (value, _) in pairs {
-            this.insert(*value);
+        let old_capacity = self.capacity;
+        let new_capacity = old_capacity << 1;
+
+        let mut this = Self::with_capacity(new_capacity);
+
+        for (index, value) in self.nodes.iter().enumerate() {
+            let offset = prev_power_of_two(index + 1);
+            let new_index = index + offset;
+            this.set_node(new_index, *value);
         }
+
+        this.length = self.length;
+
         *self = this;
     }
 
-    pub fn insert(&mut self, value: Value) -> bool {
-        if self.index_map.contains_key(&value) {
-            return false;
-        }
-
-        if self.capacity == self.index_map.len() {
+    pub fn insert(&mut self, value: Value) -> usize {
+        if self.length == self.capacity {
             self.reallocate_to_double_capacity();
         }
 
-        let new_index = self.index_map.len();
-        self.index_map.insert(value, new_index);
+        let new_index = self.length;
 
-        let base_length = self.capacity;
-        let mut layer_node = hash_value(&value);
-        let mut layer_index = new_index + base_length - 1;
-        self.set_node(layer_index, layer_node);
+        let mut node_index = new_index + self.capacity - 1;
+        let mut node_hash = hash_value(&value);
 
-        let mut layer = 0;
-        let mut top_layer = self.depth();
-        while layer < top_layer {
-            let is_left_child = layer_index & 1 == 1;
+        self.set_node(node_index, node_hash);
+        self.length += 1;
 
-            let (parent_index, new_parent_node) = if is_left_child {
-                let parent_index = (layer_index - 1) >> 1;
-                let sibling = self.get_node(&(layer_index + 1));
-                let new_parent_node = hash_two(&layer_node, sibling);
-                (parent_index, new_parent_node)
-            } else {
-                let parent_index = (layer_index - 2) >> 1;
-                let sibling = self.get_node(&(layer_index - 1));
-                let new_parent_node = hash_two(sibling, &layer_node);
-                (parent_index, new_parent_node)
-            };
-
-            self.set_node(parent_index, new_parent_node);
-
-            layer += 1;
-            layer_index = parent_index;
-            layer_node = new_parent_node
+        let root_index = self.root_index();
+        for _ in 0..self.depth() {
+            let parent_index = (node_index - 1) >> 1;
+            let left_child = self.get_node((parent_index << 1) + 1);
+            let right_child = self.get_node((parent_index << 1) + 2);
+            node_hash = hash_two(left_child, right_child);
+            self.set_node(parent_index, node_hash);
+            node_index = parent_index;
         }
 
-        true
+        new_index
     }
 
     pub fn new(values: &[Value]) -> Self {
-        let mut deduplicated_values: Vec<Value> = Vec::with_capacity(values.len());
-        let mut seen = HashSet::new();
-        for value in values.into_iter() {
-            if !seen.contains(value) {
-                deduplicated_values.push(*value);
-                seen.insert(*value);
-            }
-        }
-        let mut this = Self::with_capacity(deduplicated_values.len());
-        for value in deduplicated_values.into_iter() {
+        let mut this = Self::with_capacity(values.len());
+        for value in values.iter().cloned() {
             this.insert(value);
         }
         this
     }
 
-    pub fn get_authentication_path_for(&self, value: &Value) -> Option<(usize, Vec<Node>)> {
-        let mut result = Vec::with_capacity(self.depth());
-        let value_index = self.index_map.get(value)?;
-        let base_length = self.capacity;
-        let mut layer_index = base_length + value_index - 1;
-        let mut layer = 0;
-        let top_layer = self.depth();
-        while layer < top_layer {
-            let is_left_child = layer_index & 1 == 1;
-            let (sibling, parent_index) = if is_left_child {
-                (self.get_node(&(layer_index + 1)), (layer_index - 1) >> 1)
-            } else {
-                (self.get_node(&(layer_index - 1)), (layer_index - 2) >> 1)
-            };
-            result.push(*sibling);
-
-            layer += 1;
-            layer_index = parent_index;
+    pub fn get_authentication_path_for(&self, index: usize) -> Option<Vec<Node>> {
+        if index >= self.length {
+            return None;
         }
-        Some((*value_index, result))
-    }
 
-    pub(crate) fn contains(&self, value: &[u8; 32]) -> bool {
-        self.index_map.contains_key(value)
+        let mut path = Vec::with_capacity(self.depth());
+
+        let mut node_index = self.capacity + index - 1;
+        let root_index = self.root_index();
+
+        while node_index != root_index {
+            let parent_index = (node_index - 1) >> 1;
+            let is_left_child = node_index & 1 == 1;
+            let sibling_index = if is_left_child {
+                node_index + 1
+            } else {
+                node_index - 1
+            };
+            path.push(*self.get_node(sibling_index));
+            node_index = parent_index;
+        }
+
+        Some(path)
     }
 }
 
@@ -183,26 +171,34 @@ fn verify_authentication_path(value: &Value, index: usize, path: &[Node], root:
     &result == root
 }
 
+fn prev_power_of_two(x: usize) -> usize {
+    if x == 0 {
+        return 0; // define as 0
+    }
+    1 << (usize::BITS as usize - x.leading_zeros() as usize - 1)
+}
+
 #[cfg(test)]
 mod tests {
+    use hex_literal::hex;
     use nssa_core::account::{Account, NullifierPublicKey};
 
     use super::*;
+    #[test]
+    fn test_merkle_tree_0() {
+        let values = [[0; 32]];
+        let tree = MerkleTree::new(&values);
+        let expected_root = assert_eq!(tree.length, 1);
+        assert_eq!(tree.root(), hash_value(&[0; 32]));
+    }
 
     #[test]
     fn test_merkle_tree_1() {
         let values = [[1; 32], [2; 32], [3; 32], [4; 32]];
         let tree = MerkleTree::new(&values);
-        let expected_root = [
-            72, 199, 63, 120, 33, 165, 138, 141, 42, 112, 62, 91, 57, 197, 113, 192, 170, 32, 207,
-            20, 171, 205, 10, 248, 242, 185, 85, 188, 32, 41, 152, 222,
-        ];
-
+        let expected_root =
+            hex!("48c73f7821a58a8d2a703e5b39c571c0aa20cf14abcd0af8f2b955bc202998de");
         assert_eq!(tree.root(), expected_root);
-        assert_eq!(*tree.index_map.get(&[1; 32]).unwrap(), 0);
-        assert_eq!(*tree.index_map.get(&[2; 32]).unwrap(), 1);
-        assert_eq!(*tree.index_map.get(&[3; 32]).unwrap(), 2);
-        assert_eq!(*tree.index_map.get(&[4; 32]).unwrap(), 3);
         assert_eq!(tree.capacity, 4);
     }
 
@@ -210,16 +206,9 @@ mod tests {
     fn test_merkle_tree_2() {
         let values = [[1; 32], [2; 32], [3; 32], [0; 32]];
         let tree = MerkleTree::new(&values);
-        let expected_root = [
-            201, 187, 184, 48, 150, 223, 133, 21, 122, 20, 110, 125, 119, 4, 85, 169, 132, 18, 222,
-            224, 99, 49, 135, 238, 134, 254, 230, 200, 164, 91, 131, 26,
-        ];
-
+        let expected_root =
+            hex!("c9bbb83096df85157a146e7d770455a98412dee0633187ee86fee6c8a45b831a");
         assert_eq!(tree.root(), expected_root);
-        assert_eq!(*tree.index_map.get(&[1; 32]).unwrap(), 0);
-        assert_eq!(*tree.index_map.get(&[2; 32]).unwrap(), 1);
-        assert_eq!(*tree.index_map.get(&[3; 32]).unwrap(), 2);
-        assert_eq!(*tree.index_map.get(&[0; 32]).unwrap(), 3);
         assert_eq!(tree.capacity, 4);
     }
 
@@ -227,16 +216,9 @@ mod tests {
     fn test_merkle_tree_3() {
         let values = [[1; 32], [2; 32], [3; 32]];
         let tree = MerkleTree::new(&values);
-        let expected_root = [
-            200, 211, 216, 210, 177, 63, 39, 206, 236, 205, 198, 153, 17, 152, 113, 249, 243, 46,
-            167, 237, 134, 255, 69, 208, 173, 17, 247, 123, 40, 205, 117, 104,
-        ];
-
+        let expected_root =
+            hex!("c8d3d8d2b13f27ceeccdc699119871f9f32ea7ed86ff45d0ad11f77b28cd7568");
         assert_eq!(tree.root(), expected_root);
-        assert_eq!(*tree.index_map.get(&[1; 32]).unwrap(), 0);
-        assert_eq!(*tree.index_map.get(&[2; 32]).unwrap(), 1);
-        assert_eq!(*tree.index_map.get(&[3; 32]).unwrap(), 2);
-        assert!(tree.index_map.get(&[0; 32]).is_none());
         assert_eq!(tree.capacity, 4);
     }
 
@@ -244,17 +226,10 @@ mod tests {
     fn test_merkle_tree_4() {
         let values = [[11; 32], [12; 32], [13; 32], [14; 32], [15; 32]];
         let tree = MerkleTree::new(&values);
-        let expected_root = [
-            239, 65, 138, 237, 90, 162, 7, 2, 212, 217, 76, 146, 218, 121, 164, 1, 47, 46, 54, 241,
-            0, 139, 253, 179, 205, 30, 56, 116, 157, 202, 36, 153,
-        ];
+        let expected_root =
+            hex!("ef418aed5aa20702d4d94c92da79a4012f2e36f1008bfdb3cd1e38749dca2499");
 
         assert_eq!(tree.root(), expected_root);
-        assert_eq!(*tree.index_map.get(&[11; 32]).unwrap(), 0);
-        assert_eq!(*tree.index_map.get(&[12; 32]).unwrap(), 1);
-        assert_eq!(*tree.index_map.get(&[13; 32]).unwrap(), 2);
-        assert_eq!(*tree.index_map.get(&[14; 32]).unwrap(), 3);
-        assert_eq!(*tree.index_map.get(&[15; 32]).unwrap(), 4);
         assert_eq!(tree.capacity, 8);
     }
 
@@ -265,17 +240,9 @@ mod tests {
             [13; 32], [15; 32], [11; 32],
         ];
         let tree = MerkleTree::new(&values);
-        let expected_root = [
-            239, 65, 138, 237, 90, 162, 7, 2, 212, 217, 76, 146, 218, 121, 164, 1, 47, 46, 54, 241,
-            0, 139, 253, 179, 205, 30, 56, 116, 157, 202, 36, 153,
-        ];
-
+        let expected_root =
+            hex!("ef418aed5aa20702d4d94c92da79a4012f2e36f1008bfdb3cd1e38749dca2499");
         assert_eq!(tree.root(), expected_root);
-        assert_eq!(*tree.index_map.get(&[11; 32]).unwrap(), 0);
-        assert_eq!(*tree.index_map.get(&[12; 32]).unwrap(), 1);
-        assert_eq!(*tree.index_map.get(&[13; 32]).unwrap(), 2);
-        assert_eq!(*tree.index_map.get(&[14; 32]).unwrap(), 3);
-        assert_eq!(*tree.index_map.get(&[15; 32]).unwrap(), 4);
         assert_eq!(tree.capacity, 8);
     }
 
@@ -283,11 +250,8 @@ mod tests {
     fn test_merkle_tree_6() {
         let values = [[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
         let tree = MerkleTree::new(&values);
-        let expected_root = [
-            6, 156, 184, 37, 154, 6, 254, 110, 219, 63, 167, 255, 121, 51, 166, 221, 125, 202, 111,
-            202, 41, 147, 20, 55, 151, 148, 166, 136, 146, 108, 55, 146,
-        ];
-
+        let expected_root =
+            hex!("069cb8259a06fe6edb3fa7ff7933a6dd7dca6fca299314379794a688926c3792");
         assert_eq!(tree.root(), expected_root);
     }
 
@@ -295,33 +259,33 @@ mod tests {
     fn test_with_capacity_4() {
         let tree = MerkleTree::with_capacity(4);
 
-        assert!(tree.index_map.is_empty());
-        assert!(tree.node_map.is_empty());
+        assert_eq!(tree.length, 0);
+        assert_eq!(tree.nodes.len(), 7);
         for i in 3..7 {
-            assert_eq!(*tree.get_node(&i), default_values::DEFAULT_VALUES[0], "{i}");
+            assert_eq!(*tree.get_node(i), default_values::DEFAULT_VALUES[0], "{i}");
         }
         for i in 1..3 {
-            assert_eq!(*tree.get_node(&i), default_values::DEFAULT_VALUES[1], "{i}");
+            assert_eq!(*tree.get_node(i), default_values::DEFAULT_VALUES[1], "{i}");
         }
-        assert_eq!(*tree.get_node(&0), default_values::DEFAULT_VALUES[2]);
+        assert_eq!(*tree.get_node(0), default_values::DEFAULT_VALUES[2]);
     }
 
     #[test]
     fn test_with_capacity_5() {
         let tree = MerkleTree::with_capacity(5);
 
-        assert!(tree.index_map.is_empty());
-        assert!(tree.node_map.is_empty());
+        assert_eq!(tree.length, 0);
+        assert_eq!(tree.nodes.len(), 15);
         for i in 7..15 {
-            assert_eq!(*tree.get_node(&i), default_values::DEFAULT_VALUES[0])
+            assert_eq!(*tree.get_node(i), default_values::DEFAULT_VALUES[0])
         }
         for i in 3..7 {
-            assert_eq!(*tree.get_node(&i), default_values::DEFAULT_VALUES[1])
+            assert_eq!(*tree.get_node(i), default_values::DEFAULT_VALUES[1])
         }
         for i in 1..3 {
-            assert_eq!(*tree.get_node(&i), default_values::DEFAULT_VALUES[2])
+            assert_eq!(*tree.get_node(i), default_values::DEFAULT_VALUES[2])
         }
-        assert_eq!(*tree.get_node(&0), default_values::DEFAULT_VALUES[3])
+        assert_eq!(*tree.get_node(0), default_values::DEFAULT_VALUES[3])
     }
 
     #[test]
@@ -330,10 +294,8 @@ mod tests {
 
         let values = [[1; 32], [2; 32], [3; 32], [4; 32]];
 
-        let expected_root = [
-            72, 199, 63, 120, 33, 165, 138, 141, 42, 112, 62, 91, 57, 197, 113, 192, 170, 32, 207,
-            20, 171, 205, 10, 248, 242, 185, 85, 188, 32, 41, 152, 222,
-        ];
+        let expected_root =
+            hex!("48c73f7821a58a8d2a703e5b39c571c0aa20cf14abcd0af8f2b955bc202998de");
 
         tree.insert(values[0]);
         tree.insert(values[1]);
@@ -349,10 +311,8 @@ mod tests {
 
         let values = [[1; 32], [2; 32], [3; 32]];
 
-        let expected_root = [
-            200, 211, 216, 210, 177, 63, 39, 206, 236, 205, 198, 153, 17, 152, 113, 249, 243, 46,
-            167, 237, 134, 255, 69, 208, 173, 17, 247, 123, 40, 205, 117, 104,
-        ];
+        let expected_root =
+            hex!("c8d3d8d2b13f27ceeccdc699119871f9f32ea7ed86ff45d0ad11f77b28cd7568");
 
         tree.insert(values[0]);
         tree.insert(values[1]);
@@ -367,10 +327,8 @@ mod tests {
 
         let values = [[1; 32], [2; 32], [3; 32]];
 
-        let expected_root = [
-            200, 211, 216, 210, 177, 63, 39, 206, 236, 205, 198, 153, 17, 152, 113, 249, 243, 46,
-            167, 237, 134, 255, 69, 208, 173, 17, 247, 123, 40, 205, 117, 104,
-        ];
+        let expected_root =
+            hex!("c8d3d8d2b13f27ceeccdc699119871f9f32ea7ed86ff45d0ad11f77b28cd7568");
 
         tree.insert(values[0]);
         tree.insert(values[1]);
@@ -424,47 +382,16 @@ mod tests {
         assert_eq!(expected_tree, tree);
     }
 
-    #[test]
-    fn test_insert_value_4() {
-        let mut tree = MerkleTree::with_capacity(1);
-
-        let values = [[11; 32], [12; 32], [13; 32], [14; 32], [15; 32]];
-        let expected_tree = MerkleTree::new(&values);
-
-        tree.insert(values[0]);
-        tree.insert(values[0]);
-        tree.insert(values[1]);
-        tree.insert(values[1]);
-        tree.insert(values[2]);
-        tree.insert(values[3]);
-        tree.insert(values[2]);
-        tree.insert(values[0]);
-        tree.insert(values[4]);
-        tree.insert(values[2]);
-        tree.insert(values[4]);
-
-        assert_eq!(expected_tree, tree);
-    }
-
     #[test]
     fn test_authentication_path_1() {
         let values = [[1; 32], [2; 32], [3; 32], [4; 32]];
         let tree = MerkleTree::new(&values);
-        let expected_authentication_path = (
-            2,
-            vec![
-                [
-                    159, 79, 182, 143, 62, 29, 172, 130, 32, 47, 154, 165, 129, 206, 11, 191, 31,
-                    118, 93, 240, 233, 172, 60, 140, 87, 226, 15, 104, 90, 186, 184, 237,
-                ],
-                [
-                    80, 162, 125, 71, 70, 243, 87, 203, 112, 12, 190, 157, 72, 131, 183, 127, 182,
-                    79, 1, 40, 130, 138, 52, 137, 220, 106, 111, 33, 221, 191, 36, 20,
-                ],
-            ],
-        );
+        let expected_authentication_path = vec![
+            hex!("9f4fb68f3e1dac82202f9aa581ce0bbf1f765df0e9ac3c8c57e20f685abab8ed"),
+            hex!("50a27d4746f357cb700cbe9d4883b77fb64f0128828a3489dc6a6f21ddbf2414"),
+        ];
 
-        let authentication_path = tree.get_authentication_path_for(&[3; 32]).unwrap();
+        let authentication_path = tree.get_authentication_path_for(2).unwrap();
         assert_eq!(authentication_path, expected_authentication_path);
     }
 
@@ -472,21 +399,12 @@ mod tests {
     fn test_authentication_path_2() {
         let values = [[1; 32], [2; 32], [3; 32]];
         let tree = MerkleTree::new(&values);
-        let expected_authentication_path = (
-            0,
-            vec![
-                [
-                    117, 135, 123, 180, 29, 57, 59, 95, 184, 69, 92, 230, 14, 205, 141, 218, 0, 29,
-                    6, 49, 100, 150, 177, 77, 250, 127, 137, 86, 86, 238, 202, 74,
-                ],
-                [
-                    164, 27, 133, 93, 45, 180, 222, 144, 82, 205, 123, 229, 236, 103, 214, 88, 102,
-                    41, 203, 159, 110, 50, 70, 164, 175, 165, 186, 49, 63, 7, 169, 197,
-                ],
-            ],
-        );
+        let expected_authentication_path = vec![
+            hex!("75877bb41d393b5fb8455ce60ecd8dda001d06316496b14dfa7f895656eeca4a"),
+            hex!("a41b855d2db4de9052cd7be5ec67d6586629cb9f6e3246a4afa5ba313f07a9c5"),
+        ];
 
-        let authentication_path = tree.get_authentication_path_for(&[1; 32]).unwrap();
+        let authentication_path = tree.get_authentication_path_for(0).unwrap();
         assert_eq!(authentication_path, expected_authentication_path);
     }
 
@@ -494,25 +412,13 @@ mod tests {
     fn test_authentication_path_3() {
         let values = [[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
         let tree = MerkleTree::new(&values);
-        let expected_authentication_path = (
-            4,
-            vec![
-                [
-                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                    0, 0, 0, 0, 0, 0,
-                ],
-                [
-                    245, 165, 253, 66, 209, 106, 32, 48, 39, 152, 239, 110, 211, 9, 151, 155, 67,
-                    0, 61, 35, 32, 217, 240, 232, 234, 152, 49, 169, 39, 89, 251, 75,
-                ],
-                [
-                    72, 199, 63, 120, 33, 165, 138, 141, 42, 112, 62, 91, 57, 197, 113, 192, 170,
-                    32, 207, 20, 171, 205, 10, 248, 242, 185, 85, 188, 32, 41, 152, 222,
-                ],
-            ],
-        );
+        let expected_authentication_path = vec![
+            hex!("0000000000000000000000000000000000000000000000000000000000000000"),
+            hex!("f5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a92759fb4b"),
+            hex!("48c73f7821a58a8d2a703e5b39c571c0aa20cf14abcd0af8f2b955bc202998de"),
+        ];
 
-        let authentication_path = tree.get_authentication_path_for(&[5; 32]).unwrap();
+        let authentication_path = tree.get_authentication_path_for(4).unwrap();
         assert_eq!(authentication_path, expected_authentication_path);
     }
 
@@ -520,24 +426,16 @@ mod tests {
     fn test_authentication_path_4() {
         let values = [[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
         let tree = MerkleTree::new(&values);
-        let value = [6; 32];
-        assert!(tree.get_authentication_path_for(&value).is_none());
+        assert!(tree.get_authentication_path_for(5).is_none());
     }
 
     #[test]
     fn test_authentication_path_5() {
-        let values = vec![[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
-        let tree = MerkleTree::new(&values);
-        let value = [0; 32];
-        assert!(tree.get_authentication_path_for(&value).is_none());
-    }
-
-    #[test]
-    fn test_authentication_path_6() {
         let values = [[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
         let tree = MerkleTree::new(&values);
-        let value = [5; 32];
-        let (index, path) = tree.get_authentication_path_for(&value).unwrap();
+        let index = 4;
+        let value = values[index];
+        let path = tree.get_authentication_path_for(index).unwrap();
         assert!(verify_authentication_path(
             &value,
             index,
@@ -545,6 +443,92 @@ mod tests {
             &tree.root()
         ));
     }
+
+    #[test]
+    fn test_tree_with_63_insertions() {
+        let values = [
+            hex!("cd00acab0f45736e6c6311f1953becc0b69a062e7c2a7310875d28bdf9ef9c5b"),
+            hex!("0df5a6afbcc7bf126caf7084acfc593593ab512e6ca433c61c1a922be40a04ea"),
+            hex!("23c1258620266c7bedb6d1ee32f6da9413e4010ace975239dccb34e727e07c40"),
+            hex!("f33ccc3a11476b0ef62326ca5ec292056759b05e6a28023d2d1ce66165611353"),
+            hex!("77f914ab016b8049f6bea7704000e413a393865918a3824f9285c3db0aacff23"),
+            hex!("910a1c23188e54d57fd167ddb0f8bf68c6b70ed9ec76ef56c4b7f2632f82ca7f"),
+            hex!("047ee85526197d1e7403a559cf6d2f22c1926c8ad59481a2e2f1b697af45e40b"),
+            hex!("9d355cf89fb382ae34bf80566b28489278d10f2cebb5b0ea42fab1bac5adae0c"),
+            hex!("604018b95232596b2685a9bc737b6cccb53b10e483d2d9a2f4a755410b02a188"),
+            hex!("a16708ef7b6bf1796063addaf57d6a566b6f87b0bbe42af43a4590d05f1684cb"),
+            hex!("820f2dfa271cd2fd41e1452406d5dad552c85c1223c45d45dbd7446759fdc6b8"),
+            hex!("680b6912d7e219f8805d4d28adb4428dd78fea0dc1b8cdb2412645c4b1962c88"),
+            hex!("14d5471ce6c45506753982b17cac5790ac7bc29e6f388f31052d7dfd62b294e5"),
+            hex!("8b364200172b777d4aa16d2098b5eb98ac3dd4a1b9597e5c2bf6f6930031f230"),
+            hex!("9bb45b910711874339dda8a21a9aad73822286f5e52d7d3de0ed78dfbba329a5"),
+            hex!("d6806d5df5cb25ce5d531042f09b3cb34fb9e47c61182b63cccd9d44392f6027"),
+            hex!("b8cfa90ebc8fd09c04682d93a08fddd3e8e57715174dcc92451edd191264a58b"),
+            hex!("3463c7f81d00f809b3dfa83195447c927fb4045b3913dac6f45bee6c4010d7ed"),
+            hex!("1d6ad7f7d677905feb506c58f4b404a79370ebc567296abea3a368b61d5a8239"),
+            hex!("a58085ecf00963cb22da23c901b9b3ddc56462bb96ff03c923d67708e10dd29c"),
+            hex!("c3319f4a65fb5bbb8447137b0972c03cbd84ebf7d9da194e0fcbd68c2d4d5bdb"),
+            hex!("4aa31e90e0090faf3648d05e5d5499df2c78ebed4d6e6c23d8147de5d67dae73"),
+            hex!("9f33b1d2c8bc7bd265336de1033ede6344bc41260313bdcb43f1108b83b9be92"),
+            hex!("6500d4ad93d41c16ec81eaa5e70f173194aabe5c1072ac263b5727296f5b7cac"),
+            hex!("3584f5d260003669fad98786e13171376b0f19410cb232ce65606cbff79e6768"),
+            hex!("c8410946ebf56f13141c894a34ced85a5230088af70dcea581e44f52847830ac"),
+            hex!("71dd90281cdebb70422f2d04ae446d5d2d5ea64b803c16128d37e3fcd5d1a4cc"),
+            hex!("c05acf8d77ab4d659a538bd35af590864a7ad9c055ff5d6cda9d5aecfccecba3"),
+            hex!("f1df98822ea084cce9021aa9cc81b1746cd1e84a75690da63e10fd877633ed77"),
+            hex!("2ca822bc8f67bceb0a71a0d06fea7349036ef3e5ec21795a851e4182bd35ce01"),
+            hex!("7fd2179abc3bcf89b4d8092988ba8c23952b3bbd3d7caea6b5ea0c13cf19f68b"),
+            hex!("91b6ad516e017f6aa5a2e95776538bd3a3e933c1b1d32bb5e0f00a9db63c9c24"),
+            hex!("cd31a8b5eef5ca0be5ef1cb261d0bf0a74d774a3152bb99739cfd296a1d0b85e"),
+            hex!("3fb16f48b2bf93f3815979e6638f975d7f935088ec37db0be0f07965fbc78339"),
+            hex!("c60c61b99bf486af5f4bf780a69860dafcd35c1474306a8575666fb5449bcec0"),
+            hex!("8048d0d7e14091251f3f6c6b10bf6b5880a014b513f9f8c2395501dbffa6192a"),
+            hex!("778b5af10b9dbe80b60a8e4f0bb91caf4476bcb812801099760754ae623fbd84"),
+            hex!("d3ac25467920a4e08998b7a3226b8b54bfe66ac58cfedc71f15b2402fee0054a"),
+            hex!("029aa94598fae2961a0d43937b8a9a3138bcfeae99a7cb15f77fac7c506f8432"),
+            hex!("2eee5ef52fe669cb6882a68c893abdc1262dcf4424e4ba7a479da7cf1c10171d"),
+            hex!("de3fb3d070e3a90f0eed8b5e65088a8dc0e4e3c342b9c0bf33bab714eae5dfec"),
+            hex!("14d40177e833ab45bbfdc5f2b11fba7efaebb3f69facc554f24b549a2efe8538"),
+            hex!("5734355069702448774fb2df95f1d562e1b9fe1514aeb6b922554ee9d2d01068"),
+            hex!("8a273d49ac110343cec2cf3359d16eb2906b446bd9ec9833e2a640cebc8d5155"),
+            hex!("e3fa984dd3cbeb9a7e827ed32d3d4e6a6ba643a55d82be97d9ddb06ee809fa3e"),
+            hex!("90b1d5a364e17c8b7965396b06ec6e13749b5fc16500731518ad8fc30ae33e77"),
+            hex!("7517376541b2e8ec83cbab04522b54a26610908a9872feb663451385aea58eb1"),
+            hex!("5cba2e4cf7448e526d161133c4b2ea7c919ac4813a7308612595f46f11dea6cd"),
+            hex!("c721911b300bec0691c8a2dfaabfef1d66b7b6258918914d3c3ad690729f05b7"),
+            hex!("d0d0a70d8ae0d27806fa0b711c507290c260a89cbca0436d339d1dccdd087d62"),
+            hex!("2a625c28ea763c5e82dd0a93ecfca7ec371ccbb363cd42be359c2c875f58009d"),
+            hex!("174ef0119932ed890397d9f3837dd85f9100558b6fc9085d4af947ae8cf74bbc"),
+            hex!("b497bc267151e8efa3c6daa461e6804b01a3f05f44f1f4d5b41d5f0d3f5219b1"),
+            hex!("e987e91f5734630ddd7e6b58733b4fcdbc316ee9e8cac0e94c36c91cf58e59cc"),
+            hex!("55019ad8bbe656c51eb042190c1c8da53f42baf43fd2350ebea38fc7cca2fae3"),
+            hex!("c45a638edd18a6d9f5ad20b870c81b8626459bcb22dae7d58add7a6b6c6a84a8"),
+            hex!("d42d3a5fb2ad50b2027fe5a36d59dd71e49a63e4b1b299073c96bbf7ba5d68a1"),
+            hex!("9599e561054bcd3f647eb018ab0b069d3176497d42be9c4466551cbb959be47c"),
+            hex!("42f33b23775327ff71aea6569548255f3cc9929da73373cc9bb1743d417f7cda"),
+            hex!("ab24294f44fc6fdbeb96e0f6e93c4f6d97d035b73b9a337c353e18c6d0603bdd"),
+            hex!("33954ec63520334f99b640a2982ac966b68c363fed383d621a1ab573934f1d33"),
+            hex!("5e2a1f7df963d1fd8f50a285387cfbb5df581426619b325563e20bf7886c62b7"),
+            hex!("13ffde471d4e27c473254e766fd1328ad80c42cab4d4955cffeae43d866f86e5"),
+        ];
+
+        let expected_root =
+            hex!("1cf9b214217d7823f9de51b8f6cb34d0a99436a3a1bb762f90b815672a6afcc0");
+
+        let mut tree_less_capacity = MerkleTree::with_capacity(1);
+        let mut tree_exact_capacity = MerkleTree::with_capacity(64);
+        let mut tree_more_capacity = MerkleTree::with_capacity(128);
+
+        for value in &values {
+            tree_less_capacity.insert(*value);
+            tree_exact_capacity.insert(*value);
+            tree_more_capacity.insert(*value);
+        }
+
+        assert_eq!(tree_more_capacity.root(), expected_root);
+        assert_eq!(tree_less_capacity.root(), expected_root);
+        assert_eq!(tree_exact_capacity.root(), expected_root);
+    }
 }
 
 //
diff --git a/nssa/src/privacy_preserving_transaction/circuit.rs b/nssa/src/privacy_preserving_transaction/circuit.rs
index 639b31f..41e462a 100644
--- a/nssa/src/privacy_preserving_transaction/circuit.rs
+++ b/nssa/src/privacy_preserving_transaction/circuit.rs
@@ -192,13 +192,15 @@ mod tests {
         let sender_keys = test_private_account_keys_1();
         let recipient_keys = test_private_account_keys_2();
         let commitment_sender = Commitment::new(&sender_keys.npk(), &sender_pre.account);
+
         let recipient = AccountWithMetadata {
             account: Account::default(),
             is_authorized: false,
         };
         let balance_to_move: u128 = 37;
 
-        let commitment_set = CommitmentSet(MerkleTree::new(&[commitment_sender.to_byte_array()]));
+        let expected_new_nullifiers = vec![Nullifier::new(&commitment_sender, &sender_keys.nsk)];
+
         let program = Program::authenticated_transfer_program();
 
         let expected_private_account_1 = Account {
@@ -217,7 +219,9 @@ mod tests {
             Commitment::new(&sender_keys.npk(), &expected_private_account_1),
             Commitment::new(&recipient_keys.npk(), &expected_private_account_2),
         ];
-        let expected_new_nullifiers = vec![Nullifier::new(&commitment_sender, &sender_keys.nsk)];
+
+        let mut commitment_set = CommitmentSet::with_capacity(2);
+        commitment_set.extend(&[commitment_sender.clone()]);
 
         let (output, proof) = execute_and_prove(
             &[sender_pre.clone(), recipient],
diff --git a/nssa/src/state.rs b/nssa/src/state.rs
index fc7bcaf..69af23d 100644
--- a/nssa/src/state.rs
+++ b/nssa/src/state.rs
@@ -10,26 +10,39 @@ use nssa_core::{
 };
 use std::collections::{HashMap, HashSet};
 
-pub(crate) struct CommitmentSet(pub(crate) MerkleTree);
+pub(crate) struct CommitmentSet {
+    merkle_tree: MerkleTree,
+    commitments: HashMap<Commitment, usize>,
+}
 
 impl CommitmentSet {
     pub(crate) fn digest(&self) -> CommitmentSetDigest {
-        self.0.root()
+        self.merkle_tree.root()
     }
 
     pub(crate) fn get_proof_for(&self, commitment: &Commitment) -> Option<MembershipProof> {
-        self.0
-            .get_authentication_path_for(&commitment.to_byte_array())
+        let index = *self.commitments.get(commitment)?;
+        self.merkle_tree
+            .get_authentication_path_for(index)
+            .map(|path| (index, path))
     }
 
     pub(crate) fn extend(&mut self, commitments: &[Commitment]) {
-        for commitment in commitments {
-            self.0.insert(commitment.to_byte_array());
+        for commitment in commitments.iter().cloned() {
+            let index = self.merkle_tree.insert(commitment.to_byte_array());
+            self.commitments.insert(commitment, index);
         }
     }
 
     fn contains(&self, commitment: &Commitment) -> bool {
-        self.0.contains(&commitment.to_byte_array())
+        self.commitments.contains_key(commitment)
+    }
+
+    pub(crate) fn with_capacity(capacity: usize) -> CommitmentSet {
+        Self {
+            merkle_tree: MerkleTree::with_capacity(capacity),
+            commitments: HashMap::new(),
+        }
     }
 }
 
@@ -59,10 +72,7 @@ impl V01State {
 
         let mut this = Self {
             public_state,
-            private_state: (
-                CommitmentSet(MerkleTree::with_capacity(32)),
-                NullifierSet::new(),
-            ),
+            private_state: (CommitmentSet::with_capacity(32), NullifierSet::new()),
             builtin_programs: HashMap::new(),
         };