diff --git a/taiga_halo2/examples/tx_examples/partial_fulfillment_token_swap.rs b/taiga_halo2/examples/tx_examples/partial_fulfillment_token_swap.rs
index ff2d3a87..c841d990 100644
--- a/taiga_halo2/examples/tx_examples/partial_fulfillment_token_swap.rs
+++ b/taiga_halo2/examples/tx_examples/partial_fulfillment_token_swap.rs
@@ -34,9 +34,8 @@ pub fn create_token_intent_ptx<R: RngCore>(
     let mut intent_note = swap.create_intent_note(&mut rng);
 
     // padding the zero notes
-    let padding_input_note = Note::random_padding_input_note(&mut rng);
-    let padding_input_note_nf = padding_input_note.get_nf().unwrap();
-    let mut padding_output_note = Note::random_padding_output_note(&mut rng, padding_input_note_nf);
+    let padding_input_note = Note::random_padding_note(&mut rng);
+    let mut padding_output_note = Note::random_padding_note(&mut rng);
     let merkle_path = MerklePath::random(&mut rng, TAIGA_COMMITMENT_TREE_DEPTH);
 
     // Create action pairs
diff --git a/taiga_halo2/examples/tx_examples/token.rs b/taiga_halo2/examples/tx_examples/token.rs
index b4f38e1e..5a0cdba3 100644
--- a/taiga_halo2/examples/tx_examples/token.rs
+++ b/taiga_halo2/examples/tx_examples/token.rs
@@ -35,9 +35,8 @@ pub fn create_token_swap_ptx<R: RngCore>(
     let mut output_note = output_token.create_random_output_token_note(output_nk_com, &output_auth);
 
     // padding the zero notes
-    let padding_input_note = Note::random_padding_input_note(&mut rng);
-    let padding_input_note_nf = padding_input_note.get_nf().unwrap();
-    let mut padding_output_note = Note::random_padding_output_note(&mut rng, padding_input_note_nf);
+    let padding_input_note = Note::random_padding_note(&mut rng);
+    let mut padding_output_note = Note::random_padding_note(&mut rng);
 
     // Generate proving info
     let merkle_path = MerklePath::random(&mut rng, TAIGA_COMMITMENT_TREE_DEPTH);
diff --git a/taiga_halo2/examples/tx_examples/token_swap_with_intent.rs b/taiga_halo2/examples/tx_examples/token_swap_with_intent.rs
index 69fc5c39..099f21b5 100644
--- a/taiga_halo2/examples/tx_examples/token_swap_with_intent.rs
+++ b/taiga_halo2/examples/tx_examples/token_swap_with_intent.rs
@@ -53,9 +53,8 @@ pub fn create_token_intent_ptx<R: RngCore>(
     );
 
     // padding the zero notes
-    let padding_input_note = Note::random_padding_input_note(&mut rng);
-    let padding_input_note_nf = padding_input_note.get_nf().unwrap();
-    let mut padding_output_note = Note::random_padding_output_note(&mut rng, padding_input_note_nf);
+    let padding_input_note = Note::random_padding_note(&mut rng);
+    let mut padding_output_note = Note::random_padding_note(&mut rng);
 
     let merkle_path = MerklePath::random(&mut rng, TAIGA_COMMITMENT_TREE_DEPTH);
 
@@ -169,9 +168,8 @@ pub fn consume_token_intent_ptx<R: RngCore>(
     let mut output_note = output_token.create_random_output_token_note(output_nk_com, &output_auth);
 
     // padding the zero notes
-    let padding_input_note = Note::random_padding_input_note(&mut rng);
-    let padding_input_note_nf = padding_input_note.get_nf().unwrap();
-    let mut padding_output_note = Note::random_padding_output_note(&mut rng, padding_input_note_nf);
+    let padding_input_note = Note::random_padding_note(&mut rng);
+    let mut padding_output_note = Note::random_padding_note(&mut rng);
 
     let merkle_path = MerklePath::random(&mut rng, TAIGA_COMMITMENT_TREE_DEPTH);
 
diff --git a/taiga_halo2/src/action.rs b/taiga_halo2/src/action.rs
index e5210e04..0888fec5 100644
--- a/taiga_halo2/src/action.rs
+++ b/taiga_halo2/src/action.rs
@@ -204,12 +204,12 @@ pub mod tests {
     use super::ActionInfo;
     use crate::constant::TAIGA_COMMITMENT_TREE_DEPTH;
     use crate::merkle_tree::MerklePath;
-    use crate::note::tests::{random_input_note, random_output_note};
+    use crate::note::tests::random_note;
     use rand::RngCore;
 
     pub fn random_action_info<R: RngCore>(mut rng: R) -> ActionInfo {
-        let input_note = random_input_note(&mut rng);
-        let mut output_note = random_output_note(&mut rng, input_note.get_nf().unwrap());
+        let input_note = random_note(&mut rng);
+        let mut output_note = random_note(&mut rng);
         let input_merkle_path = MerklePath::random(&mut rng, TAIGA_COMMITMENT_TREE_DEPTH);
         ActionInfo::new(
             input_note,
diff --git a/taiga_halo2/src/circuit/vp_examples.rs b/taiga_halo2/src/circuit/vp_examples.rs
index b63dadcb..764591fc 100644
--- a/taiga_halo2/src/circuit/vp_examples.rs
+++ b/taiga_halo2/src/circuit/vp_examples.rs
@@ -240,25 +240,15 @@ impl ValidityPredicateVerifyingInfo for TrivialValidityPredicateCircuit {
 #[cfg(test)]
 pub mod tests {
     use super::TrivialValidityPredicateCircuit;
-    use crate::{
-        constant::NUM_NOTE,
-        note::tests::{random_input_note, random_output_note},
-    };
+    use crate::{constant::NUM_NOTE, note::tests::random_note};
     use ff::Field;
     use pasta_curves::pallas;
     use rand::RngCore;
     pub fn random_trivial_vp_circuit<R: RngCore>(mut rng: R) -> TrivialValidityPredicateCircuit {
         let owned_note_pub_id = pallas::Base::random(&mut rng);
-        let input_notes = [(); NUM_NOTE].map(|_| random_input_note(&mut rng));
-        let output_notes = input_notes
-            .iter()
-            .map(|input| random_output_note(&mut rng, input.get_nf().unwrap()))
-            .collect::<Vec<_>>();
-        TrivialValidityPredicateCircuit::new(
-            owned_note_pub_id,
-            input_notes,
-            output_notes.try_into().unwrap(),
-        )
+        let input_notes = [(); NUM_NOTE].map(|_| random_note(&mut rng));
+        let output_notes = [(); NUM_NOTE].map(|_| random_note(&mut rng));
+        TrivialValidityPredicateCircuit::new(owned_note_pub_id, input_notes, output_notes)
     }
 
     #[test]
diff --git a/taiga_halo2/src/circuit/vp_examples/cascade_intent.rs b/taiga_halo2/src/circuit/vp_examples/cascade_intent.rs
index 3c14b625..686aec0a 100644
--- a/taiga_halo2/src/circuit/vp_examples/cascade_intent.rs
+++ b/taiga_halo2/src/circuit/vp_examples/cascade_intent.rs
@@ -171,27 +171,24 @@ pub fn create_intent_note<R: RngCore>(
 #[test]
 fn test_halo2_cascade_intent_vp_circuit() {
     use crate::constant::VP_CIRCUIT_PARAMS_SIZE;
-    use crate::note::tests::{random_input_note, random_output_note};
+    use crate::note::tests::random_note;
     use halo2_proofs::arithmetic::Field;
     use halo2_proofs::dev::MockProver;
     use rand::rngs::OsRng;
 
     let mut rng = OsRng;
     let circuit = {
-        let cascade_input_note = random_input_note(&mut rng);
+        let cascade_input_note = random_note(&mut rng);
         let cascade_note_cm = cascade_input_note.commitment().inner();
         let nk = pallas::Base::random(&mut rng);
         let intent_note = create_intent_note(&mut rng, cascade_note_cm, nk);
         let input_notes = [intent_note, cascade_input_note];
-        let output_notes = input_notes
-            .iter()
-            .map(|input| random_output_note(&mut rng, input.get_nf().unwrap()))
-            .collect::<Vec<_>>();
+        let output_notes = [(); NUM_NOTE].map(|_| random_note(&mut rng));
 
         CascadeIntentValidityPredicateCircuit {
             owned_note_pub_id: input_notes[0].get_nf().unwrap().inner(),
             input_notes,
-            output_notes: output_notes.try_into().unwrap(),
+            output_notes,
             cascade_note_cm,
         }
     };
diff --git a/taiga_halo2/src/circuit/vp_examples/field_addition.rs b/taiga_halo2/src/circuit/vp_examples/field_addition.rs
index d021cfed..90b77b2d 100644
--- a/taiga_halo2/src/circuit/vp_examples/field_addition.rs
+++ b/taiga_halo2/src/circuit/vp_examples/field_addition.rs
@@ -110,25 +110,22 @@ vp_verifying_info_impl!(FieldAdditionValidityPredicateCircuit);
 #[test]
 fn test_halo2_addition_vp_circuit() {
     use crate::constant::VP_CIRCUIT_PARAMS_SIZE;
-    use crate::note::tests::{random_input_note, random_output_note};
+    use crate::note::tests::random_note;
     use halo2_proofs::arithmetic::Field;
     use halo2_proofs::dev::MockProver;
     use rand::rngs::OsRng;
 
     let mut rng = OsRng;
     let circuit = {
-        let input_notes = [(); NUM_NOTE].map(|_| random_input_note(&mut rng));
-        let output_notes = input_notes
-            .iter()
-            .map(|input| random_output_note(&mut rng, input.get_nf().unwrap()))
-            .collect::<Vec<_>>();
+        let input_notes = [(); NUM_NOTE].map(|_| random_note(&mut rng));
+        let output_notes = [(); NUM_NOTE].map(|_| random_note(&mut rng));
         let a = pallas::Base::random(&mut rng);
         let b = pallas::Base::random(&mut rng);
         let owned_note_pub_id = pallas::Base::random(&mut rng);
         FieldAdditionValidityPredicateCircuit {
             owned_note_pub_id,
             input_notes,
-            output_notes: output_notes.try_into().unwrap(),
+            output_notes,
             a,
             b,
         }
diff --git a/taiga_halo2/src/circuit/vp_examples/or_relation_intent.rs b/taiga_halo2/src/circuit/vp_examples/or_relation_intent.rs
index 51fa52b3..efbdb533 100644
--- a/taiga_halo2/src/circuit/vp_examples/or_relation_intent.rs
+++ b/taiga_halo2/src/circuit/vp_examples/or_relation_intent.rs
@@ -305,20 +305,14 @@ pub fn create_intent_note<R: RngCore>(
 #[test]
 fn test_halo2_or_relation_intent_vp_circuit() {
     use crate::constant::VP_CIRCUIT_PARAMS_SIZE;
-    use crate::{
-        circuit::vp_examples::token::COMPRESSED_TOKEN_VK, note::tests::random_output_note,
-        nullifier::tests::random_nullifier,
-    };
+    use crate::{circuit::vp_examples::token::COMPRESSED_TOKEN_VK, note::tests::random_note};
     use halo2_proofs::arithmetic::Field;
     use halo2_proofs::dev::MockProver;
     use rand::rngs::OsRng;
 
     let mut rng = OsRng;
     let circuit = {
-        let mut output_notes = [(); NUM_NOTE].map(|_| {
-            let padding_rho = random_nullifier(&mut rng);
-            random_output_note(&mut rng, padding_rho)
-        });
+        let mut output_notes = [(); NUM_NOTE].map(|_| random_note(&mut rng));
         let token_1 = Token::new("token1".to_string(), 1u64);
         let token_2 = Token::new("token2".to_string(), 2u64);
         output_notes[0].note_type.app_vk = *COMPRESSED_TOKEN_VK;
@@ -335,7 +329,7 @@ fn test_halo2_or_relation_intent_vp_circuit() {
             output_notes[0].app_data_dynamic,
             nk,
         );
-        let padding_input_note = Note::random_padding_input_note(&mut rng);
+        let padding_input_note = Note::random_padding_note(&mut rng);
         let input_notes = [intent_note, padding_input_note];
         OrRelationIntentValidityPredicateCircuit {
             owned_note_pub_id: input_notes[0].get_nf().unwrap().inner(),
diff --git a/taiga_halo2/src/circuit/vp_examples/partial_fulfillment_intent.rs b/taiga_halo2/src/circuit/vp_examples/partial_fulfillment_intent.rs
index 682c0bcf..b1700a9d 100644
--- a/taiga_halo2/src/circuit/vp_examples/partial_fulfillment_intent.rs
+++ b/taiga_halo2/src/circuit/vp_examples/partial_fulfillment_intent.rs
@@ -206,8 +206,6 @@ mod tests {
 
     #[test]
     fn create_intent() {
-        use crate::nullifier::Nullifier;
-
         let mut rng = OsRng;
         let sell = Token::new("token1".to_string(), 2u64);
         let buy = Token::new("token2".to_string(), 4u64);
@@ -215,9 +213,8 @@ mod tests {
         let swap = swap(&mut rng, sell, buy);
         let intent_note = swap.create_intent_note(&mut rng);
 
-        let input_padding_note = Note::random_padding_input_note(&mut rng);
-        let nf = Nullifier::random(&mut rng);
-        let output_padding_note = Note::random_padding_output_note(&mut rng, nf);
+        let input_padding_note = Note::random_padding_note(&mut rng);
+        let output_padding_note = Note::random_padding_note(&mut rng);
 
         let input_notes = [*swap.sell.note(), input_padding_note];
         let output_notes = [intent_note, output_padding_note];
diff --git a/taiga_halo2/src/circuit/vp_examples/partial_fulfillment_intent/swap.rs b/taiga_halo2/src/circuit/vp_examples/partial_fulfillment_intent/swap.rs
index 29589eef..40db7c9a 100644
--- a/taiga_halo2/src/circuit/vp_examples/partial_fulfillment_intent/swap.rs
+++ b/taiga_halo2/src/circuit/vp_examples/partial_fulfillment_intent/swap.rs
@@ -60,7 +60,7 @@ impl Swap {
             &self.auth,
         );
 
-        let input_padding_note = Note::random_padding_input_note(&mut rng);
+        let input_padding_note = Note::random_padding_note(&mut rng);
 
         let returned_note = if offer.value() < self.buy.value() {
             let filled_value = offer.value() / ratio;
@@ -74,7 +74,7 @@ impl Swap {
                 )
                 .note()
         } else {
-            Note::random_padding_output_note(&mut rng, input_padding_note.get_nf().unwrap())
+            Note::random_padding_note(&mut rng)
         };
 
         let input_notes = [intent_note, input_padding_note];
diff --git a/taiga_halo2/src/circuit/vp_examples/receiver_vp.rs b/taiga_halo2/src/circuit/vp_examples/receiver_vp.rs
index 7c5afd1a..7990344d 100644
--- a/taiga_halo2/src/circuit/vp_examples/receiver_vp.rs
+++ b/taiga_halo2/src/circuit/vp_examples/receiver_vp.rs
@@ -285,21 +285,15 @@ vp_verifying_info_impl!(ReceiverValidityPredicateCircuit);
 #[test]
 fn test_halo2_receiver_vp_circuit() {
     use crate::constant::VP_CIRCUIT_PARAMS_SIZE;
-    use crate::{
-        note::tests::{random_input_note, random_output_note},
-        utils::poseidon_hash_n,
-    };
+    use crate::{note::tests::random_note, utils::poseidon_hash_n};
     use ff::{Field, PrimeField};
     use halo2_proofs::dev::MockProver;
     use rand::rngs::OsRng;
 
     let mut rng = OsRng;
     let (circuit, rcv_sk) = {
-        let input_notes = [(); NUM_NOTE].map(|_| random_input_note(&mut rng));
-        let mut output_notes = input_notes
-            .iter()
-            .map(|input| random_output_note(&mut rng, input.get_nf().unwrap()))
-            .collect::<Vec<_>>();
+        let input_notes = [(); NUM_NOTE].map(|_| random_note(&mut rng));
+        let mut output_notes = [(); NUM_NOTE].map(|_| random_note(&mut rng));
         let nonce = pallas::Base::from_u128(23333u128);
         let sk = pallas::Base::random(&mut rng);
         let rcv_sk = pallas::Base::random(&mut rng);
@@ -317,7 +311,7 @@ fn test_halo2_receiver_vp_circuit() {
             ReceiverValidityPredicateCircuit {
                 owned_note_pub_id,
                 input_notes,
-                output_notes: output_notes.try_into().unwrap(),
+                output_notes,
                 vp_vk: *COMPRESSED_RECEIVER_VK,
                 nonce,
                 sk,
diff --git a/taiga_halo2/src/circuit/vp_examples/signature_verification.rs b/taiga_halo2/src/circuit/vp_examples/signature_verification.rs
index 0677cc77..004a9509 100644
--- a/taiga_halo2/src/circuit/vp_examples/signature_verification.rs
+++ b/taiga_halo2/src/circuit/vp_examples/signature_verification.rs
@@ -295,17 +295,14 @@ fn test_halo2_sig_verification_vp_circuit() {
         receiver_vp::COMPRESSED_RECEIVER_VK, token::TokenAuthorization,
     };
     use crate::constant::VP_CIRCUIT_PARAMS_SIZE;
-    use crate::note::tests::{random_input_note, random_output_note};
+    use crate::note::tests::random_note;
     use halo2_proofs::dev::MockProver;
     use rand::rngs::OsRng;
 
     let mut rng = OsRng;
     let circuit = {
-        let mut input_notes = [(); NUM_NOTE].map(|_| random_input_note(&mut rng));
-        let output_notes = input_notes
-            .iter()
-            .map(|input| random_output_note(&mut rng, input.get_nf().unwrap()))
-            .collect::<Vec<_>>();
+        let mut input_notes = [(); NUM_NOTE].map(|_| random_note(&mut rng));
+        let output_notes = [(); NUM_NOTE].map(|_| random_note(&mut rng));
         let sk = pallas::Scalar::random(&mut rng);
         let auth_vk = pallas::Base::random(&mut rng);
         let auth = TokenAuthorization::from_sk_vk(&sk, &auth_vk);
@@ -315,7 +312,7 @@ fn test_halo2_sig_verification_vp_circuit() {
             &mut rng,
             owned_note_pub_id,
             input_notes,
-            output_notes.try_into().unwrap(),
+            output_notes,
             auth_vk,
             sk,
             *COMPRESSED_RECEIVER_VK,
diff --git a/taiga_halo2/src/circuit/vp_examples/token.rs b/taiga_halo2/src/circuit/vp_examples/token.rs
index 1b5d8f85..59ec34bb 100644
--- a/taiga_halo2/src/circuit/vp_examples/token.rs
+++ b/taiga_halo2/src/circuit/vp_examples/token.rs
@@ -533,17 +533,14 @@ impl TokenAuthorization {
 #[test]
 fn test_halo2_token_vp_circuit() {
     use crate::constant::VP_CIRCUIT_PARAMS_SIZE;
-    use crate::note::tests::{random_input_note, random_output_note};
+    use crate::note::tests::random_note;
     use halo2_proofs::dev::MockProver;
     use rand::rngs::OsRng;
 
     let mut rng = OsRng;
     let circuit = {
-        let mut input_notes = [(); NUM_NOTE].map(|_| random_input_note(&mut rng));
-        let output_notes = input_notes
-            .iter()
-            .map(|input| random_output_note(&mut rng, input.get_nf().unwrap()))
-            .collect::<Vec<_>>();
+        let mut input_notes = [(); NUM_NOTE].map(|_| random_note(&mut rng));
+        let output_notes = [(); NUM_NOTE].map(|_| random_note(&mut rng));
         let token_name = TokenName("Token_name".to_string());
         let auth = TokenAuthorization::random(&mut rng);
         input_notes[0].note_type.app_data_static = token_name.encode();
@@ -551,7 +548,7 @@ fn test_halo2_token_vp_circuit() {
         TokenValidityPredicateCircuit {
             owned_note_pub_id: input_notes[0].get_nf().unwrap().inner(),
             input_notes,
-            output_notes: output_notes.try_into().unwrap(),
+            output_notes,
             token_name,
             auth,
             receiver_vp_vk: *COMPRESSED_RECEIVER_VK,
diff --git a/taiga_halo2/src/note.rs b/taiga_halo2/src/note.rs
index bca7a861..b6538f56 100644
--- a/taiga_halo2/src/note.rs
+++ b/taiga_halo2/src/note.rs
@@ -203,7 +203,7 @@ impl Note {
         }
     }
 
-    pub fn random_padding_input_note<R: RngCore>(mut rng: R) -> Self {
+    pub fn random_padding_note<R: RngCore>(mut rng: R) -> Self {
         let app_vk = *COMPRESSED_TRIVIAL_VP_VK;
         let app_data_static = pallas::Base::random(&mut rng);
         let note_type = NoteType::new(app_vk, app_data_static);
@@ -223,25 +223,6 @@ impl Note {
         }
     }
 
-    pub fn random_padding_output_note<R: RngCore>(mut rng: R, rho: Nullifier) -> Self {
-        let app_vk = *COMPRESSED_TRIVIAL_VP_VK;
-        let app_data_static = pallas::Base::random(&mut rng);
-        let note_type = NoteType::new(app_vk, app_data_static);
-        let app_data_dynamic = pallas::Base::random(&mut rng);
-        let nk_com = NullifierKeyContainer::from_commitment(pallas::Base::random(&mut rng));
-        let rseed = RandomSeed::random(&mut rng);
-        Note {
-            note_type,
-            app_data_dynamic,
-            value: 0,
-            nk_container: nk_com,
-            rho,
-            psi: rseed.get_psi(&rho),
-            rcm: rseed.get_rcm(&rho),
-            is_merkle_checked: false,
-        }
-    }
-
     // note_commitment = poseidon_hash(app_vk || app_data_static || app_data_dynamic || nk_commitment || rho || psi || is_merkle_checked || value || rcm)
     pub fn commitment(&self) -> NoteCommitment {
         let ret = poseidon_hash_n([
@@ -577,7 +558,7 @@ impl NoteValidityPredicates {
 #[cfg(test)]
 pub mod tests {
     use super::{Note, NoteType, RandomSeed};
-    use crate::nullifier::{tests::*, Nullifier, NullifierKeyContainer};
+    use crate::nullifier::tests::*;
     use halo2_proofs::arithmetic::Field;
     use pasta_curves::pallas;
     use rand::{Rng, RngCore};
@@ -588,31 +569,14 @@ pub mod tests {
         NoteType::new(app_vk, app_data_static)
     }
 
-    pub fn random_input_note<R: RngCore>(mut rng: R) -> Note {
+    pub fn random_note<R: RngCore>(mut rng: R) -> Note {
         let rho = random_nullifier(&mut rng);
-        let nk = random_nullifier_key(&mut rng);
-        random_note_from_parts(&mut rng, rho, nk)
-    }
-
-    pub fn random_output_note<R: RngCore>(mut rng: R, rho: Nullifier) -> Note {
-        let nk_com = random_nullifier_key_commitment(&mut rng);
-        random_note_from_parts(&mut rng, rho, nk_com)
-    }
-
-    fn random_note_from_parts<R: RngCore>(
-        mut rng: R,
-        rho: Nullifier,
-        nk_container: NullifierKeyContainer,
-    ) -> Note {
-        let note_type = random_note_type(&mut rng);
-        let app_data_dynamic = pallas::Base::random(&mut rng);
-        let value: u64 = rng.gen();
         let rseed = RandomSeed::random(&mut rng);
         Note {
-            note_type,
-            app_data_dynamic,
-            value,
-            nk_container,
+            note_type: random_note_type(&mut rng),
+            app_data_dynamic: pallas::Base::random(&mut rng),
+            value: rng.gen(),
+            nk_container: random_nullifier_key(&mut rng),
             is_merkle_checked: true,
             psi: rseed.get_psi(&rho),
             rcm: rseed.get_rcm(&rho),
@@ -629,7 +593,7 @@ pub mod tests {
         use crate::note::NoteCommitment;
         let mut rng = OsRng;
 
-        let input_note = random_input_note(&mut rng);
+        let input_note = random_note(&mut rng);
         {
             // BorshSerialize
             let borsh = borsh::to_vec(&input_note).unwrap();
@@ -638,8 +602,9 @@ pub mod tests {
             assert_eq!(input_note, de_note);
         }
 
-        let output_note = random_output_note(&mut rng, input_note.rho);
+        let mut output_note = input_note;
         {
+            output_note.nk_container = random_nullifier_key_commitment(&mut rng);
             // BorshSerialize
             let borsh = borsh::to_vec(&output_note).unwrap();
             // BorshDeserialize
diff --git a/taiga_halo2/src/taiga_api.rs b/taiga_halo2/src/taiga_api.rs
index e1b40b3b..a75ce5c0 100644
--- a/taiga_halo2/src/taiga_api.rs
+++ b/taiga_halo2/src/taiga_api.rs
@@ -227,15 +227,14 @@ pub fn verify_shielded_partial_transaction(ptx_bytes: Vec<u8>) -> Result<(), Tra
 #[cfg(feature = "borsh")]
 pub mod tests {
     use crate::{
-        note::tests::{random_input_note, random_output_note},
-        taiga_api::*,
+        note::tests::random_note, nullifier::tests::random_nullifier_key_commitment, taiga_api::*,
     };
     use rand::rngs::OsRng;
 
     #[test]
     fn note_borsh_serialization_api_test() {
         let mut rng = OsRng;
-        let input_note = random_input_note(&mut rng);
+        let input_note = random_note(&mut rng);
         {
             let bytes = note_serialize(&input_note).unwrap();
             let de_input_note = note_deserialize(bytes).unwrap();
@@ -243,28 +242,29 @@ pub mod tests {
         }
 
         {
-            let output_note = random_output_note(&mut rng, input_note.rho);
+            let mut output_note = input_note;
+            output_note.nk_container = random_nullifier_key_commitment(&mut rng);
             let bytes = note_serialize(&output_note).unwrap();
             let de_output_note = note_deserialize(bytes).unwrap();
             assert_eq!(output_note, de_output_note);
         }
     }
 
-    #[ignore]
+    // #[ignore]
     #[test]
     fn ptx_example_test() {
         use crate::action::ActionInfo;
         use crate::circuit::vp_examples::TrivialValidityPredicateCircuit;
         use crate::constant::TAIGA_COMMITMENT_TREE_DEPTH;
         use crate::merkle_tree::MerklePath;
-        use crate::note::tests::{random_input_note, random_output_note};
+        use crate::note::tests::random_note;
 
         let mut rng = OsRng;
 
         // construct notes
-        let input_note_1 = random_input_note(&mut rng);
+        let input_note_1 = random_note(&mut rng);
         let input_note_1_nf = input_note_1.get_nf().unwrap();
-        let mut output_note_1 = random_output_note(&mut rng, input_note_1_nf);
+        let mut output_note_1 = random_note(&mut rng);
         let merkle_path_1 = MerklePath::random(&mut rng, TAIGA_COMMITMENT_TREE_DEPTH);
         let action_1 = ActionInfo::new(
             input_note_1,
@@ -274,9 +274,9 @@ pub mod tests {
             &mut rng,
         );
 
-        let input_note_2 = random_input_note(&mut rng);
+        let input_note_2 = random_note(&mut rng);
         let input_note_2_nf = input_note_2.get_nf().unwrap();
-        let mut output_note_2 = random_output_note(&mut rng, input_note_2_nf);
+        let mut output_note_2 = random_note(&mut rng);
         let merkle_path_2 = MerklePath::random(&mut rng, TAIGA_COMMITMENT_TREE_DEPTH);
         let action_2 = ActionInfo::new(
             input_note_2,
diff --git a/taiga_halo2/src/transparent_ptx.rs b/taiga_halo2/src/transparent_ptx.rs
index bb05089c..b8523eb3 100644
--- a/taiga_halo2/src/transparent_ptx.rs
+++ b/taiga_halo2/src/transparent_ptx.rs
@@ -12,14 +12,34 @@ use serde;
 
 #[cfg(feature = "borsh")]
 use borsh::{BorshDeserialize, BorshSerialize};
+use rand::RngCore;
 
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "borsh", derive(BorshSerialize, BorshDeserialize))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct TransparentPartialTransaction {
-    pub inputs: Vec<InputResource>,
-    pub outputs: Vec<OutputResource>,
-    pub hints: Vec<u8>,
+    inputs: Vec<InputResource>,
+    outputs: Vec<OutputResource>,
+    hints: Vec<u8>,
+}
+
+impl TransparentPartialTransaction {
+    pub fn new<R: RngCore>(
+        inputs: Vec<InputResource>,
+        mut outputs: Vec<OutputResource>,
+        hints: Vec<u8>,
+        mut rng: R,
+    ) -> Self {
+        outputs
+            .iter_mut()
+            .zip(inputs.iter())
+            .for_each(|(output, input)| output.note.reset_rho(&input.note, &mut rng));
+        Self {
+            inputs,
+            outputs,
+            hints,
+        }
+    }
 }
 
 impl Executable for TransparentPartialTransaction {
@@ -102,9 +122,7 @@ pub struct OutputResource {
 #[cfg(test)]
 pub mod testing {
     use crate::{
-        constant::TAIGA_COMMITMENT_TREE_DEPTH,
-        merkle_tree::MerklePath,
-        note::tests::{random_input_note, random_output_note},
+        constant::TAIGA_COMMITMENT_TREE_DEPTH, merkle_tree::MerklePath, note::tests::random_note,
         transparent_ptx::*,
     };
     use rand::rngs::OsRng;
@@ -113,7 +131,7 @@ pub mod testing {
     pub fn create_transparent_ptx() -> TransparentPartialTransaction {
         let mut rng = OsRng;
         let input_resource_1 = {
-            let note = random_input_note(&mut rng);
+            let note = random_note(&mut rng);
             let merkle_path = MerklePath::random(&mut rng, TAIGA_COMMITMENT_TREE_DEPTH);
             InputResource {
                 note,
@@ -121,7 +139,7 @@ pub mod testing {
             }
         };
         let output_resource_1 = {
-            let mut note = random_output_note(&mut rng, input_resource_1.note.rho);
+            let mut note = random_note(&mut rng);
             // Adjust the random note to keep the balance
             note.note_type = input_resource_1.note.note_type;
             note.value = input_resource_1.note.value;
@@ -129,7 +147,7 @@ pub mod testing {
         };
 
         let input_resource_2 = {
-            let mut note = random_input_note(&mut rng);
+            let mut note = random_note(&mut rng);
             note.is_merkle_checked = false;
             InputResource {
                 note,
@@ -137,17 +155,18 @@ pub mod testing {
             }
         };
         let output_resource_2 = {
-            let mut note = random_output_note(&mut rng, input_resource_2.note.rho);
+            let mut note = random_note(&mut rng);
             // Adjust the random note to keep the balance
             note.note_type = input_resource_2.note.note_type;
             note.value = input_resource_2.note.value;
             OutputResource { note }
         };
 
-        TransparentPartialTransaction {
-            inputs: vec![input_resource_1, input_resource_2],
-            outputs: vec![output_resource_1, output_resource_2],
-            hints: vec![],
-        }
+        TransparentPartialTransaction::new(
+            vec![input_resource_1, input_resource_2],
+            vec![output_resource_1, output_resource_2],
+            vec![],
+            &mut rng,
+        )
     }
 }