Various corrections to multisig API

coins/monero/tests/clsag.rs

@@ -1,5 +1,4 @@
-use rand::{RngCore, SeedableRng, rngs::OsRng};
-use rand_chacha::ChaCha12Rng;
+use rand::{RngCore, rngs::OsRng};
 
 use curve25519_dalek::{constants::ED25519_BASEPOINT_TABLE, scalar::Scalar};
 
@@ -8,7 +7,7 @@ use monero_serai::{random_scalar, Commitment, frost::MultisigError, key_image, c
 #[cfg(feature = "multisig")]
 mod frost;
 #[cfg(feature = "multisig")]
-use crate::frost::{THRESHOLD, PARTICIPANTS, generate_keys, sign};
+use crate::frost::{generate_keys, sign};
 
 const RING_INDEX: u8 = 3;
 const RING_LEN: u64 = 11;
@@ -57,24 +56,9 @@ fn test_multisig() -> Result<(), MultisigError> {
   let (keys, group_private) = generate_keys();
   let t = keys[0].params().t();
 
-  let mut images = vec![];
-  images.resize(PARTICIPANTS + 1, None);
-  let included = (1 ..= THRESHOLD).collect::<Vec<usize>>();
-  for i in &included {
-    let i = *i;
-    images[i] = Some(
-      (
-        keys[0].verification_shares()[i].0,
-        key_image::multisig(&mut OsRng, &keys[i - 1], &included)
-      )
-    );
-  }
-
   let msg = [1; 32];
 
-  images.push(None);
-  let ki_used = images.swap_remove(1).unwrap().1;
-  let image = ki_used.resolve(images).unwrap();
+  let image = key_image::generate(&group_private.0);
 
   let randomness = random_scalar(&mut OsRng);
   let mut ring = vec![];
@@ -95,14 +79,13 @@ fn test_multisig() -> Result<(), MultisigError> {
   }
 
   let mut algorithms = Vec::with_capacity(t);
-  for _ in 1 ..= t {
+  for i in 1 ..= t {
     algorithms.push(
       clsag::Multisig::new(
-        &mut ChaCha12Rng::seed_from_u64(1),
-        msg,
         clsag::Input::new(image, ring.clone(), RING_INDEX, Commitment::new(randomness, AMOUNT)).unwrap()
       ).unwrap()
     );
+    algorithms[i - 1].set_msg(msg);
   }
 
   let mut signatures = sign(algorithms, keys);

coins/monero/tests/frost.rs

@@ -2,13 +2,14 @@
 
 use std::rc::Rc;
 
+use rand_core::{RngCore, CryptoRng};
 use rand::rngs::OsRng;
 
 use ff::Field;
-use dalek_ff_group::{ED25519_BASEPOINT_TABLE, Scalar};
+use dalek_ff_group::{ED25519_BASEPOINT_TABLE, Scalar, EdwardsPoint};
 
 use frost::{
-  MultisigParams, MultisigKeys,
+  FrostError, MultisigParams, MultisigKeys,
   key_gen, algorithm::Algorithm, sign::{self, lagrange}
 };
 
@@ -17,6 +18,49 @@ use monero_serai::frost::Ed25519;
 pub const THRESHOLD: usize = 5;
 pub const PARTICIPANTS: usize = 8;
 
+#[derive(Clone)]
+pub struct DummyAlgorithm;
+impl Algorithm<Ed25519> for DummyAlgorithm {
+  type Signature = ();
+
+  fn addendum_commit_len() -> usize { unimplemented!() }
+
+  fn preprocess_addendum<R: RngCore + CryptoRng>(
+    _: &mut R,
+    _: &sign::ParamsView<Ed25519>,
+    _: &[Scalar; 2],
+  ) -> Vec<u8> { unimplemented!() }
+
+  fn process_addendum(
+    &mut self,
+    _: &sign::ParamsView<Ed25519>,
+    _: usize,
+    _: &[EdwardsPoint; 2],
+    _: &[u8],
+  ) -> Result<(), FrostError> { unimplemented!() }
+
+  fn context(&self) -> Vec<u8> { unimplemented!() }
+
+  fn process_binding(&mut self, _: &Scalar) { unimplemented!() }
+
+  fn sign_share(
+    &mut self,
+    _: &sign::ParamsView<Ed25519>,
+    _: EdwardsPoint,
+    _: Scalar,
+    _: &[u8],
+  ) -> Scalar { unimplemented!() }
+
+  fn verify(&self, _: EdwardsPoint, _: EdwardsPoint, _: Scalar) -> Option<Self::Signature> { unimplemented!() }
+
+  fn verify_share(
+    &self,
+    _: EdwardsPoint,
+    _: EdwardsPoint,
+    _: Scalar,
+  ) -> bool { unimplemented!() }
+}
+
 pub fn generate_keys() -> (Vec<Rc<MultisigKeys<Ed25519>>>, Scalar) {
   let mut params = vec![];
   let mut machines = vec![];

coins/monero/tests/key_image.rs

@@ -2,10 +2,14 @@
 
 use rand::{RngCore, rngs::OsRng};
 
+use curve25519_dalek::{traits::Identity, edwards::EdwardsPoint};
+
 use monero_serai::{frost::MultisigError, key_image};
 
+use ::frost::sign;
+
 mod frost;
-use crate::frost::{THRESHOLD, PARTICIPANTS, generate_keys};
+use crate::frost::{THRESHOLD, PARTICIPANTS, DummyAlgorithm, generate_keys};
 
 #[test]
 fn test() -> Result<(), MultisigError> {
@@ -18,23 +22,33 @@ fn test() -> Result<(), MultisigError> {
   }
   included.sort();
 
-  let mut packages = vec![];
-  packages.resize(PARTICIPANTS + 1, None);
-  for i in &included {
-    let i = *i;
-    packages[i] = Some(
-      (
-        keys[0].verification_shares()[i].0,
-        key_image::multisig(&mut OsRng, &keys[i - 1], &included)
-      )
-    );
+  let mut views = vec![];
+  let mut shares = vec![];
+  for i in 1 ..= PARTICIPANTS {
+    if included.contains(&i) {
+      // If they were included, include their view
+      views.push(sign::Params::new(DummyAlgorithm, keys[i - 1].clone(), &included).unwrap().view());
+      let share = key_image::generate_share(&mut OsRng, &views[i - 1]);
+      let mut serialized = share.0;
+      serialized.extend(b"abc");
+      serialized.extend(&share.1);
+      shares.push(serialized);
+    } else {
+      // If they weren't included, include dummy data
+      // Uses the view of someone actually included as Params::new verifies inclusion
+      views.push(sign::Params::new(DummyAlgorithm, keys[included[0] - 1].clone(), &included).unwrap().view());
+      shares.push(vec![]);
+    }
   }
 
-  for i in included {
-    let mut packages = packages.clone();
-    packages.push(None);
-    let package = packages.swap_remove(i).unwrap().1;
-    assert_eq!(image, package.resolve(packages).unwrap());
+  for i in &included {
+    let mut multi_image = EdwardsPoint::identity();
+    for l in &included {
+      let share = key_image::verify_share(&views[i - 1], *l, &shares[l - 1]).unwrap();
+      assert_eq!(share.1, b"abc");
+      multi_image += share.0;
+    }
+    assert_eq!(image, multi_image);
   }
 
   Ok(())