simplify the random and padding note creation

anoma · Nov 1, 2023 · 10059db · 10059db
1 parent 2f3e1cd
commit 10059db
Show file tree

Hide file tree

Showing 16 changed files with 96 additions and 153 deletions.
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -206,18 +206,15 @@ 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);
 
         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
@@ -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
@@ -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
@@ -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
@@ -533,25 +533,22 @@ 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();
         input_notes[0].app_data_dynamic = auth.to_app_data_dynamic();
         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,