Simplify check_binding_signature tests (r2542907997)

Author: ConstanceBeguier

src/value.rs

@@ -481,12 +481,13 @@ pub mod testing {
 
 #[cfg(test)]
 mod tests {
+    use alloc::collections::BTreeMap;
     use alloc::vec::Vec;
     use proptest::prelude::*;
 
     use super::{
         testing::{arb_note_value_bounded, arb_trapdoor, arb_value_sum_bounded},
-        OverflowError, ValueCommitTrapdoor, ValueCommitment, ValueSum, MAX_NOTE_VALUE,
+        ValueCommitTrapdoor, ValueCommitment, ValueSum, MAX_NOTE_VALUE,
     };
     use crate::{
         note::asset_base::testing::arb_asset_base, note::AssetBase, primitives::redpallas,
@@ -506,59 +507,72 @@ mod tests {
     fn check_binding_signature(
         native_values: &[(ValueSum, ValueCommitTrapdoor)],
         arb_values: &[(ValueSum, ValueCommitTrapdoor, AssetBase)],
-        neg_trapdoors: &[ValueCommitTrapdoor],
         arb_values_to_burn: &[(ValueSum, ValueCommitTrapdoor, AssetBase)],
     ) {
-        // for each arb value, create a negative value with a different trapdoor
-        let neg_arb_values: Vec<_> = arb_values
-            .iter()
-            .cloned()
-            .zip(neg_trapdoors.iter().cloned())
-            .map(|((value, _, asset), rcv)| (negate_value_sum(value), rcv, asset))
-            .collect();
-
-        let native_value_balance = native_values
-            .iter()
-            .map(|(value, _)| value)
-            .sum::<Result<ValueSum, OverflowError>>()
-            .expect("we generate values that won't overflow");
-
         let native_values_with_asset: Vec<(ValueSum, ValueCommitTrapdoor, AssetBase)> =
             native_values
                 .iter()
                 .map(|(value_sum, trapdoor)| (*value_sum, trapdoor.clone(), AssetBase::native()))
                 .collect();
 
         let values = [
-            &native_values_with_asset,
+            &native_values_with_asset[..],
             arb_values,
-            &neg_arb_values,
             arb_values_to_burn,
         ]
         .concat();
 
+        // bsk = Sum(rcv)
         let bsk = values
             .iter()
             .map(|(_, rcv, _)| rcv)
             .sum::<ValueCommitTrapdoor>()
             .into_bsk();
 
-        let bvk = (values
-            .into_iter()
+        // total_commitments = Sum(ValueCommit^{OrchardZSA}_{rcv}(asset, value))
+        let total_commitments = values
+            .iter()
+            .cloned()
             .map(|(value, rcv, asset)| ValueCommitment::derive(value, rcv, asset))
-            .sum::<ValueCommitment>()
-            - ValueCommitment::derive(
-                native_value_balance,
-                ValueCommitTrapdoor::zero(),
-                AssetBase::native(),
-            )
-            - arb_values_to_burn
-                .iter()
-                .map(|(value, _, asset)| {
-                    ValueCommitment::derive(*value, ValueCommitTrapdoor::zero(), *asset)
-                })
-                .sum::<ValueCommitment>())
-        .into_bvk();
+            .sum::<ValueCommitment>();
+
+        // Expected value balance per asset
+        let mut expected_balance_by_asset: BTreeMap<AssetBase, ValueSum> = BTreeMap::new();
+
+        // Add native_values into expected_balance_by_asset
+        for (value, _) in native_values.iter() {
+            let entry = expected_balance_by_asset
+                .entry(AssetBase::native())
+                .or_insert(ValueSum::zero());
+            *entry = (*entry + *value).expect("we generate values that won't overflow");
+        }
+
+        // Add arb_values into expected_balance_by_asset
+        for (value, _, asset) in arb_values.iter().cloned() {
+            let entry = expected_balance_by_asset
+                .entry(asset)
+                .or_insert(ValueSum::zero());
+            *entry = (*entry + value).expect("we generate values that won't overflow");
+        }
+
+        // Subtract burned values into expected_balance_by_asset
+        for (value, _, asset) in arb_values_to_burn.iter().cloned() {
+            let entry = expected_balance_by_asset
+                .entry(asset)
+                .or_insert(ValueSum::zero());
+            *entry =
+                (*entry + negate_value_sum(value)).expect("we generate values that won't overflow");
+        }
+
+        // Build the expected commitments using a zero trapdoor
+        let expected_commitments = expected_balance_by_asset
+            .into_iter()
+            .map(|(asset, balance)| {
+                ValueCommitment::derive(balance, ValueCommitTrapdoor::zero(), asset)
+            })
+            .sum::<ValueCommitment>();
+
+        let bvk = (total_commitments - expected_commitments).into_bvk();
 
         assert_eq!(redpallas::VerificationKey::from(&bsk), bvk);
     }
@@ -571,20 +585,20 @@ mod tests {
                     prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor()), n_values)
                 )
             ),
-            (asset_values, neg_trapdoors) in (1usize..10).prop_flat_map(|n_values|
-                (arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64).prop_flat_map(move |bound|
+            asset_values in (1usize..10).prop_flat_map(|n_values|
+                arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64).prop_flat_map(move |bound|
                     prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), arb_asset_base()), n_values)
-                ), prop::collection::vec(arb_trapdoor(), n_values))
+                )
             ),
             burn_values in (1usize..10).prop_flat_map(|n_values|
                 arb_note_value_bounded(MAX_NOTE_VALUE / n_values as u64)
                 .prop_flat_map(move |bound| prop::collection::vec((arb_value_sum_bounded(bound), arb_trapdoor(), arb_asset_base()), n_values))
             )
         ) {
-            check_binding_signature(&native_values, &[], &[], &[]);
-            check_binding_signature(&native_values, &[], &[], &burn_values);
-            check_binding_signature(&native_values, &asset_values, &neg_trapdoors, &[]);
-            check_binding_signature(&native_values, &asset_values, &neg_trapdoors, &burn_values);
+            check_binding_signature(&native_values, &[], &[]);
+            check_binding_signature(&native_values, &[], &burn_values);
+            check_binding_signature(&native_values, &asset_values, &[]);
+            check_binding_signature(&native_values, &asset_values, &burn_values);
         }
     }
 }