Add a dedicated send/recv CLSAG mask struct

Abstracts the types used internally.

Also moves the tests from monero-serai to monero-clsag.

coins/monero/src/tests/clsag.rs

@@ -1,124 +0,0 @@
-use core::ops::Deref;
-use std::sync::{Arc, Mutex};
-
-use zeroize::Zeroizing;
-use rand_core::{RngCore, OsRng};
-
-use curve25519_dalek::{constants::ED25519_BASEPOINT_TABLE, scalar::Scalar};
-
-#[cfg(feature = "multisig")]
-use transcript::{Transcript, RecommendedTranscript};
-#[cfg(feature = "multisig")]
-use frost::curve::Ed25519;
-
-use crate::{
-  Commitment,
-  wallet::Decoys,
-  ringct::{
-    generate_key_image,
-    clsag::{ClsagContext, Clsag},
-  },
-};
-#[cfg(feature = "multisig")]
-use crate::ringct::clsag::ClsagMultisig;
-
-#[cfg(feature = "multisig")]
-use frost::{
-  Participant,
-  tests::{key_gen, algorithm_machines, sign},
-};
-
-const RING_LEN: u64 = 11;
-const AMOUNT: u64 = 1337;
-
-#[cfg(feature = "multisig")]
-const RING_INDEX: u8 = 3;
-
-#[test]
-fn clsag() {
-  for real in 0 .. RING_LEN {
-    let msg = [1; 32];
-
-    let mut secrets = (Zeroizing::new(Scalar::ZERO), Scalar::ZERO);
-    let mut ring = vec![];
-    for i in 0 .. RING_LEN {
-      let dest = Zeroizing::new(Scalar::random(&mut OsRng));
-      let mask = Scalar::random(&mut OsRng);
-      let amount;
-      if i == real {
-        secrets = (dest.clone(), mask);
-        amount = AMOUNT;
-      } else {
-        amount = OsRng.next_u64();
-      }
-      ring
-        .push([dest.deref() * ED25519_BASEPOINT_TABLE, Commitment::new(mask, amount).calculate()]);
-    }
-
-    let (mut clsag, pseudo_out) = Clsag::sign(
-      &mut OsRng,
-      vec![(
-        secrets.0.clone(),
-        ClsagContext::new(
-          Decoys::new((1 ..= RING_LEN).collect(), u8::try_from(real).unwrap(), ring.clone())
-            .unwrap(),
-          Commitment::new(secrets.1, AMOUNT),
-        )
-        .unwrap(),
-      )],
-      Scalar::random(&mut OsRng),
-      msg,
-    )
-    .unwrap()
-    .swap_remove(0);
-
-    let image = generate_key_image(&secrets.0);
-    clsag.verify(&ring, &image, &pseudo_out, &msg).unwrap();
-
-    // make sure verification fails if we throw a random `c1` at it.
-    clsag.c1 = Scalar::random(&mut OsRng);
-    assert!(clsag.verify(&ring, &image, &pseudo_out, &msg).is_err());
-  }
-}
-
-#[cfg(feature = "multisig")]
-#[test]
-fn clsag_multisig() {
-  let keys = key_gen::<_, Ed25519>(&mut OsRng);
-
-  let randomness = Scalar::random(&mut OsRng);
-  let mut ring = vec![];
-  for i in 0 .. RING_LEN {
-    let dest;
-    let mask;
-    let amount;
-    if i != u64::from(RING_INDEX) {
-      dest = &Scalar::random(&mut OsRng) * ED25519_BASEPOINT_TABLE;
-      mask = Scalar::random(&mut OsRng);
-      amount = OsRng.next_u64();
-    } else {
-      dest = keys[&Participant::new(1).unwrap()].group_key().0;
-      mask = randomness;
-      amount = AMOUNT;
-    }
-    ring.push([dest, Commitment::new(mask, amount).calculate()]);
-  }
-
-  let algorithm = ClsagMultisig::new(
-    RecommendedTranscript::new(b"Monero Serai CLSAG Test"),
-    ClsagContext::new(
-      Decoys::new((1 ..= RING_LEN).collect(), RING_INDEX, ring.clone()).unwrap(),
-      Commitment::new(randomness, AMOUNT),
-    )
-    .unwrap(),
-    Arc::new(Mutex::new(Some(Scalar::random(&mut OsRng)))),
-  );
-
-  sign(
-    &mut OsRng,
-    &algorithm,
-    keys.clone(),
-    algorithm_machines(&mut OsRng, &algorithm, &keys),
-    &[1; 32],
-  );
-}

coins/monero/src/tests/mod.rs

@@ -1,5 +1,4 @@
 mod unreduced_scalar;
-mod clsag;
 mod bulletproofs;
 mod address;
 mod seed;

coins/monero/src/wallet/send/multisig.rs

@@ -3,7 +3,6 @@ use std_shims::{
   io::{self, Read},
   collections::HashMap,
 };
-use std::sync::{Arc, Mutex};
 
 use zeroize::Zeroizing;
 
@@ -27,7 +26,7 @@ use frost::{
 
 use crate::{
   ringct::{
-    clsag::{ClsagContext, ClsagAddendum, ClsagMultisig},
+    clsag::{ClsagContext, ClsagMultisigMaskSender, ClsagAddendum, ClsagMultisig},
     RctPrunable,
   },
   transaction::{Input, Transaction},
@@ -43,7 +42,7 @@ pub struct TransactionMachine {
 
   // Hashed key and scalar offset
   key_images: Vec<(EdwardsPoint, Scalar)>,
-  clsag_mask_mutexes: Vec<Arc<Mutex<Option<Scalar>>>>,
+  clsag_mask_sends: Vec<ClsagMultisigMaskSender>,
   clsags: Vec<AlgorithmMachine<Ed25519, ClsagMultisig>>,
 }
 
@@ -54,7 +53,7 @@ pub struct TransactionSignMachine {
   transcript: RecommendedTranscript,
 
   key_images: Vec<(EdwardsPoint, Scalar)>,
-  clsag_mask_mutexes: Vec<Arc<Mutex<Option<Scalar>>>>,
+  clsag_mask_sends: Vec<ClsagMultisigMaskSender>,
   clsags: Vec<AlgorithmSignMachine<Ed25519, ClsagMultisig>>,
 
   our_preprocess: Vec<Preprocess<Ed25519, ClsagAddendum>>,
@@ -73,11 +72,7 @@ impl SignableTransaction {
     keys: &ThresholdKeys<Ed25519>,
     mut transcript: RecommendedTranscript,
   ) -> Result<TransactionMachine, TransactionError> {
-    let mut clsag_mask_mutexes = vec![];
-    for _ in 0 .. self.inputs.len() {
-      // Doesn't resize as that will use a single Rc for the entire Vec
-      clsag_mask_mutexes.push(Arc::new(Mutex::new(None)));
-    }
+    let mut clsag_mask_sends = vec![];
     let mut clsags = vec![];
 
     // Create a RNG out of the input shared keys, which either requires the view key or being every
@@ -148,7 +143,8 @@ impl SignableTransaction {
 
       let context = ClsagContext::new(decoys.clone(), input.commitment())
         .map_err(TransactionError::ClsagError)?;
-      let clsag = ClsagMultisig::new(transcript.clone(), context, clsag_mask_mutexes[i].clone());
+      let (clsag, clsag_mask_send) = ClsagMultisig::new(transcript.clone(), context);
+      clsag_mask_sends.push(clsag_mask_send);
       key_images.push((
         clsag.key_image_generator(),
         keys.current_offset().unwrap_or(dfg::Scalar::ZERO).0 + self.inputs[i].0.key_offset(),
@@ -161,7 +157,7 @@ impl SignableTransaction {
       i: keys.params().i(),
       transcript,
       key_images,
-      clsag_mask_mutexes,
+      clsag_mask_sends,
       clsags,
     })
   }
@@ -206,7 +202,7 @@ impl PreprocessMachine for TransactionMachine {
         transcript: self.transcript,
 
         key_images: self.key_images,
-        clsag_mask_mutexes: self.clsag_mask_mutexes,
+        clsag_mask_sends: self.clsag_mask_sends,
         clsags,
 
         our_preprocess,
@@ -334,7 +330,7 @@ impl SignMachine<Transaction> for TransactionSignMachine {
       sorted.push((
         images.swap_remove(0),
         self.signable.inputs.swap_remove(0).1,
-        self.clsag_mask_mutexes.swap_remove(0),
+        self.clsag_mask_sends.swap_remove(0),
         self.clsags.swap_remove(0),
         commitments.swap_remove(0),
       ));
@@ -352,7 +348,7 @@ impl SignMachine<Transaction> for TransactionSignMachine {
       } else {
         sum_pseudo_outs += mask;
       }
-      *value.2.lock().unwrap() = Some(mask);
+      value.2.send(mask);
 
       tx.prefix.inputs.push(Input::ToKey {
         amount: None,