diff --git a/nssa/src/merkle_tree/mod.rs b/nssa/src/merkle_tree/mod.rs
index ff4ac76..fffcb7d 100644
--- a/nssa/src/merkle_tree/mod.rs
+++ b/nssa/src/merkle_tree/mod.rs
@@ -124,13 +124,13 @@ impl MerkleTree {
         true
     }
 
-    pub fn new(values: Vec<Value>) -> Self {
-        let mut deduplicated_values = Vec::with_capacity(values.len());
+    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);
+            if !seen.contains(value) {
+                deduplicated_values.push(*value);
+                seen.insert(*value);
             }
         }
         let mut this = Self::with_capacity(deduplicated_values.len());
@@ -191,8 +191,8 @@ mod tests {
 
     #[test]
     fn test_merkle_tree_1() {
-        let values = vec![[1; 32], [2; 32], [3; 32], [4; 32]];
-        let tree = MerkleTree::new(values.clone());
+        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,
@@ -208,8 +208,8 @@ mod tests {
 
     #[test]
     fn test_merkle_tree_2() {
-        let values = vec![[1; 32], [2; 32], [3; 32], [0; 32]];
-        let tree = MerkleTree::new(values.clone());
+        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,
@@ -225,8 +225,8 @@ mod tests {
 
     #[test]
     fn test_merkle_tree_3() {
-        let values = vec![[1; 32], [2; 32], [3; 32]];
-        let tree = MerkleTree::new(values.clone());
+        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,
@@ -242,8 +242,8 @@ mod tests {
 
     #[test]
     fn test_merkle_tree_4() {
-        let values = vec![[11; 32], [12; 32], [13; 32], [14; 32], [15; 32]];
-        let tree = MerkleTree::new(values.clone());
+        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,
@@ -260,11 +260,11 @@ mod tests {
 
     #[test]
     fn test_merkle_tree_5() {
-        let values = vec![
+        let values = [
             [11; 32], [12; 32], [12; 32], [13; 32], [14; 32], [15; 32], [15; 32], [13; 32],
             [13; 32], [15; 32], [11; 32],
         ];
-        let tree = MerkleTree::new(values);
+        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,
@@ -281,8 +281,8 @@ mod tests {
 
     #[test]
     fn test_merkle_tree_6() {
-        let values = vec![[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
-        let tree = MerkleTree::new(values);
+        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,
@@ -328,7 +328,7 @@ mod tests {
     fn test_with_capacity_6() {
         let mut tree = MerkleTree::with_capacity(100);
 
-        let values = vec![[1; 32], [2; 32], [3; 32], [4; 32]];
+        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,
@@ -347,7 +347,7 @@ mod tests {
     fn test_with_capacity_7() {
         let mut tree = MerkleTree::with_capacity(599);
 
-        let values = vec![[1; 32], [2; 32], [3; 32]];
+        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,
@@ -365,7 +365,7 @@ mod tests {
     fn test_with_capacity_8() {
         let mut tree = MerkleTree::with_capacity(1);
 
-        let values = vec![[1; 32], [2; 32], [3; 32]];
+        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,
@@ -383,8 +383,8 @@ mod tests {
     fn test_insert_value_1() {
         let mut tree = MerkleTree::with_capacity(1);
 
-        let values = vec![[1; 32], [2; 32], [3; 32]];
-        let expected_tree = MerkleTree::new(values.clone());
+        let values = [[1; 32], [2; 32], [3; 32]];
+        let expected_tree = MerkleTree::new(&values);
 
         tree.insert(values[0]);
         tree.insert(values[1]);
@@ -397,8 +397,8 @@ mod tests {
     fn test_insert_value_2() {
         let mut tree = MerkleTree::with_capacity(1);
 
-        let values = vec![[1; 32], [2; 32], [3; 32], [4; 32]];
-        let expected_tree = MerkleTree::new(values.clone());
+        let values = [[1; 32], [2; 32], [3; 32], [4; 32]];
+        let expected_tree = MerkleTree::new(&values);
 
         tree.insert(values[0]);
         tree.insert(values[1]);
@@ -412,8 +412,8 @@ mod tests {
     fn test_insert_value_3() {
         let mut tree = MerkleTree::with_capacity(1);
 
-        let values = vec![[11; 32], [12; 32], [13; 32], [14; 32], [15; 32]];
-        let expected_tree = MerkleTree::new(values.clone());
+        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[1]);
@@ -428,8 +428,8 @@ mod tests {
     fn test_insert_value_4() {
         let mut tree = MerkleTree::with_capacity(1);
 
-        let values = vec![[11; 32], [12; 32], [13; 32], [14; 32], [15; 32]];
-        let expected_tree = MerkleTree::new(values.clone());
+        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]);
@@ -448,8 +448,8 @@ mod tests {
 
     #[test]
     fn test_authentication_path_1() {
-        let values = vec![[1; 32], [2; 32], [3; 32], [4; 32]];
-        let tree = MerkleTree::new(values);
+        let values = [[1; 32], [2; 32], [3; 32], [4; 32]];
+        let tree = MerkleTree::new(&values);
         let expected_authentication_path = (
             2,
             vec![
@@ -470,8 +470,8 @@ mod tests {
 
     #[test]
     fn test_authentication_path_2() {
-        let values = vec![[1; 32], [2; 32], [3; 32]];
-        let tree = MerkleTree::new(values);
+        let values = [[1; 32], [2; 32], [3; 32]];
+        let tree = MerkleTree::new(&values);
         let expected_authentication_path = (
             0,
             vec![
@@ -492,8 +492,8 @@ mod tests {
 
     #[test]
     fn test_authentication_path_3() {
-        let values = vec![[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
-        let tree = MerkleTree::new(values);
+        let values = [[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
+        let tree = MerkleTree::new(&values);
         let expected_authentication_path = (
             4,
             vec![
@@ -518,8 +518,8 @@ mod tests {
 
     #[test]
     fn test_authentication_path_4() {
-        let values = vec![[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
-        let tree = MerkleTree::new(values);
+        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());
     }
@@ -527,15 +527,15 @@ mod tests {
     #[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 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 = vec![[1; 32], [2; 32], [3; 32], [4; 32], [5; 32]];
-        let tree = MerkleTree::new(values);
+        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();
         assert!(verify_authentication_path(
diff --git a/nssa/src/privacy_preserving_transaction/circuit.rs b/nssa/src/privacy_preserving_transaction/circuit.rs
index 00ee78c..16a5d0d 100644
--- a/nssa/src/privacy_preserving_transaction/circuit.rs
+++ b/nssa/src/privacy_preserving_transaction/circuit.rs
@@ -105,7 +105,10 @@ mod tests {
         merkle_tree::MerkleTree,
         privacy_preserving_transaction::circuit::{Proof, execute_and_prove},
         program::Program,
-        state::CommitmentSet,
+        state::{
+            CommitmentSet,
+            tests::{test_private_account_keys_1, test_private_account_keys_2},
+        },
     };
 
     use rand::{Rng, RngCore, rngs::OsRng};
@@ -163,7 +166,7 @@ mod tests {
 
     #[test]
     fn prove_privacy_preserving_execution_circuit_fully_private() {
-        let sender = AccountWithMetadata {
+        let sender_pre = AccountWithMetadata {
             account: Account {
                 balance: 100,
                 nonce: 0xdeadbeef,
@@ -171,18 +174,16 @@ mod tests {
             },
             is_authorized: true,
         };
-        let private_key_1 = [1; 32];
-        let Npk1 = NullifierPublicKey::from(&private_key_1);
-        let commitment_sender = Commitment::new(&Npk1, &sender.account);
+        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 Npk2 = NullifierPublicKey::from(&[99; 32]);
         let balance_to_move: u128 = 37;
-        let commitment_set =
-            CommitmentSet(MerkleTree::new(vec![commitment_sender.to_byte_array()]));
 
+        let commitment_set = CommitmentSet(MerkleTree::new(&[commitment_sender.to_byte_array()]));
         let program = Program::authenticated_transfer_program();
 
         let expected_private_account_1 = Account {
@@ -198,22 +199,22 @@ mod tests {
             ..Default::default()
         };
         let expected_new_commitments = vec![
-            Commitment::new(&Npk1, &expected_private_account_1),
-            Commitment::new(&Npk2, &expected_private_account_2),
+            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, &private_key_1)];
+        let expected_new_nullifiers = vec![Nullifier::new(&commitment_sender, &sender_keys.nsk)];
 
         let (output, proof) = execute_and_prove(
-            &[sender.clone(), recipient],
+            &[sender_pre.clone(), recipient],
             &Program::serialize_instruction(balance_to_move).unwrap(),
             &[1, 2],
             &[0xdeadbeef1, 0xdeadbeef2],
             &[
-                (Npk1.clone(), [2; 32], [3; 32]),
-                (Npk2.clone(), [4; 32], [5; 32]),
+                (sender_keys.npk(), sender_keys.ivk, [3; 32]),
+                (recipient_keys.npk(), recipient_keys.ivk, [5; 32]),
             ],
             &[(
-                private_key_1,
+                sender_keys.nsk,
                 commitment_set.get_proof_for(&commitment_sender).unwrap(),
             )],
             &program,
diff --git a/nssa/src/state.rs b/nssa/src/state.rs
index aef4046..350743f 100644
--- a/nssa/src/state.rs
+++ b/nssa/src/state.rs
@@ -22,7 +22,7 @@ impl CommitmentSet {
             .get_authentication_path_for(&commitment.to_byte_array())
     }
 
-    fn extend(&mut self, commitments: &[Commitment]) {
+    pub(crate) fn extend(&mut self, commitments: &[Commitment]) {
         for commitment in commitments {
             self.0.insert(commitment.to_byte_array());
         }
@@ -693,12 +693,12 @@ pub mod tests {
         assert!(matches!(result, Err(NssaError::InvalidProgramBehavior)));
     }
 
-    struct TestPublicKeys {
-        signing_key: PrivateKey,
+    pub struct TestPublicKeys {
+        pub signing_key: PrivateKey,
     }
 
     impl TestPublicKeys {
-        fn address(&self) -> Address {
+        pub fn address(&self) -> Address {
             Address::from(&PublicKey::new_from_private_key(&self.signing_key))
         }
     }
@@ -709,25 +709,25 @@ pub mod tests {
         }
     }
 
-    struct TestPrivateKeys {
-        nsk: NullifierSecretKey,
-        ivk: IncomingViewingPublicKey,
+    pub struct TestPrivateKeys {
+        pub nsk: NullifierSecretKey,
+        pub ivk: IncomingViewingPublicKey,
     }
 
     impl TestPrivateKeys {
-        fn npk(&self) -> NullifierPublicKey {
+        pub fn npk(&self) -> NullifierPublicKey {
             NullifierPublicKey::from(&self.nsk)
         }
     }
 
-    fn test_private_account_keys_1() -> TestPrivateKeys {
+    pub fn test_private_account_keys_1() -> TestPrivateKeys {
         TestPrivateKeys {
             nsk: [13; 32],
             ivk: [31; 32],
         }
     }
 
-    fn test_private_account_keys_2() -> TestPrivateKeys {
+    pub fn test_private_account_keys_2() -> TestPrivateKeys {
         TestPrivateKeys {
             nsk: [38; 32],
             ivk: [83; 32],