Remove monero-rs types

Still missing an updated RPC file. Restructures the library as it makes 
sense

coins/monero/src/tests/clsag.rs

@@ -0,0 +1,135 @@
+#[cfg(feature = "multisig")]
+use std::{rc::Rc, cell::RefCell};
+
+use rand::{RngCore, rngs::OsRng};
+
+use curve25519_dalek::{constants::ED25519_BASEPOINT_TABLE, scalar::Scalar};
+
+use monero_serai::{
+  Commitment,
+  random_scalar, generate_key_image,
+  wallet::decoys::Decoys,
+  clsag::{ClsagInput, Clsag}
+};
+#[cfg(feature = "multisig")]
+use monero_serai::{frost::{MultisigError, Transcript}, clsag::{ClsagDetails, ClsagMultisig}};
+
+#[cfg(feature = "multisig")]
+mod frost;
+#[cfg(feature = "multisig")]
+use crate::frost::{THRESHOLD, generate_keys, 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 = [Scalar::zero(), Scalar::zero()];
+    let mut ring = vec![];
+    for i in 0 .. RING_LEN {
+      let dest = random_scalar(&mut OsRng);
+      let mask = random_scalar(&mut OsRng);
+      let amount;
+      if i == u64::from(real) {
+        secrets = [dest, mask];
+        amount = AMOUNT;
+      } else {
+        amount = OsRng.next_u64();
+      }
+      ring.push([&dest * &ED25519_BASEPOINT_TABLE, Commitment::new(mask, amount).calculate()]);
+    }
+
+    let image = generate_key_image(&secrets[0]);
+    let (clsag, pseudo_out) = Clsag::sign(
+      &mut OsRng,
+      &vec![(
+        secrets[0],
+        image,
+        ClsagInput::new(
+          Commitment::new(secrets[1], AMOUNT),
+          Decoys {
+            i: u8::try_from(real).unwrap(),
+            offsets: (1 ..= RING_LEN).into_iter().collect(),
+            ring: ring.clone()
+          }
+        ).unwrap()
+      )],
+      random_scalar(&mut OsRng),
+      msg
+    ).unwrap().swap_remove(0);
+    clsag.verify(&ring, &image, &pseudo_out, &msg).unwrap();
+    #[cfg(feature = "experimental")]
+    clsag.rust_verify(&ring, &image, &pseudo_out, &msg).unwrap();
+  }
+}
+
+#[cfg(feature = "multisig")]
+#[test]
+fn clsag_multisig() -> Result<(), MultisigError> {
+  let (keys, group_private) = generate_keys();
+  let t = keys[0].params().t();
+
+  let randomness = random_scalar(&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 = random_scalar(&mut OsRng);
+      mask = random_scalar(&mut OsRng);
+      amount = OsRng.next_u64();
+    } else {
+      dest = group_private.0;
+      mask = randomness;
+      amount = AMOUNT;
+    }
+    ring.push([&dest * &ED25519_BASEPOINT_TABLE, Commitment::new(mask, amount).calculate()]);
+  }
+
+  let mask_sum = random_scalar(&mut OsRng);
+  let mut machines = Vec::with_capacity(t);
+  for i in 1 ..= t {
+    machines.push(
+      sign::AlgorithmMachine::new(
+        clsag::Multisig::new(
+          Transcript::new(b"Monero Serai CLSAG Test".to_vec()),
+          Rc::new(RefCell::new(Some(
+            ClsagDetails::new(
+              ClsagInput::new(
+                Commitment::new(randomness, AMOUNT),
+                Decoys {
+                  i: RING_INDEX,
+                  offsets: (1 ..= RING_LEN).into_iter().collect(),
+                  ring: ring.clone()
+                }
+              ).unwrap(),
+              mask_sum
+            )
+          )))
+        ).unwrap(),
+        Rc::new(keys[i - 1].clone()),
+        &(1 ..= THRESHOLD).collect::<Vec<usize>>()
+      ).unwrap()
+    );
+  }
+
+  let mut signatures = sign(&mut machines, &[1; 32]);
+  let signature = signatures.swap_remove(0);
+  for s in 0 .. (t - 1) {
+    // Verify the commitments and the non-decoy s scalar are identical to every other signature
+    // FROST will already have called verify on the produced signature, before checking individual
+    // key shares. For FROST Schnorr, it's cheaper. For CLSAG, it may be more expensive? Yet it
+    // ensures we have usable signatures, not just signatures we think are usable
+    assert_eq!(signatures[s].1, signature.1);
+    assert_eq!(signatures[s].0.s[RING_INDEX as usize], signature.0.s[RING_INDEX as usize]);
+  }
+
+  Ok(())
+}

coins/monero/src/tests/frost.rs

@@ -0,0 +1,108 @@
+#![cfg(feature = "multisig")]
+
+use rand::rngs::OsRng;
+
+use ff::Field;
+use dalek_ff_group::{ED25519_BASEPOINT_TABLE, Scalar};
+
+pub use frost::{
+  FrostError, MultisigParams, MultisigKeys,
+  key_gen, algorithm::Algorithm, sign::{self, lagrange}
+};
+
+use crate::frost::Ed25519;
+
+pub const THRESHOLD: usize = 3;
+pub const PARTICIPANTS: usize = 5;
+
+pub fn generate_keys() -> (Vec<MultisigKeys<Ed25519>>, Scalar) {
+  let mut params = vec![];
+  let mut machines = vec![];
+  let mut commitments = vec![vec![]];
+  for i in 1 ..= PARTICIPANTS {
+    params.push(
+      MultisigParams::new(THRESHOLD, PARTICIPANTS, i).unwrap()
+    );
+    machines.push(
+      key_gen::StateMachine::<Ed25519>::new(
+        params[i - 1],
+        "monero-sign-rs test suite".to_string()
+      )
+    );
+    commitments.push(machines[i - 1].generate_coefficients(&mut OsRng).unwrap());
+  }
+
+  let mut secret_shares = vec![];
+  for i in 1 ..= PARTICIPANTS {
+    secret_shares.push(
+      machines[i - 1].generate_secret_shares(
+        &mut OsRng,
+        commitments
+          .iter()
+          .enumerate()
+          .map(|(idx, commitments)| if idx == i { vec![] } else { commitments.to_vec() })
+          .collect()
+      ).unwrap()
+    );
+  }
+
+  let mut keys = vec![];
+  for i in 1 ..= PARTICIPANTS {
+    let mut our_secret_shares = vec![vec![]];
+    our_secret_shares.extend(
+      secret_shares.iter().map(|shares| shares[i].clone()).collect::<Vec<Vec<u8>>>()
+    );
+    keys.push(machines[i - 1].complete(our_secret_shares).unwrap().clone());
+  }
+
+  let mut group_private = Scalar::zero();
+  for i in 1 ..= THRESHOLD {
+    group_private += keys[i - 1].secret_share() * lagrange::<Scalar>(
+      i,
+      &(1 ..= THRESHOLD).collect::<Vec<usize>>()
+    );
+  }
+  assert_eq!(&ED25519_BASEPOINT_TABLE * group_private, keys[0].group_key());
+
+  (keys, group_private)
+}
+
+#[allow(dead_code)] // Currently has some false positive
+pub fn sign<S, M: sign::StateMachine<Signature = S>>(machines: &mut Vec<M>, msg: &[u8]) -> Vec<S> {
+  assert!(machines.len() >= THRESHOLD);
+
+  let mut commitments = Vec::with_capacity(PARTICIPANTS + 1);
+  commitments.resize(PARTICIPANTS + 1, None);
+  for i in 1 ..= THRESHOLD {
+    commitments[i] = Some(machines[i - 1].preprocess(&mut OsRng).unwrap());
+  }
+
+  let mut shares = Vec::with_capacity(PARTICIPANTS + 1);
+  shares.resize(PARTICIPANTS + 1, None);
+  for i in 1 ..= THRESHOLD {
+    shares[i] = Some(
+      machines[i - 1].sign(
+        &commitments
+          .iter()
+          .enumerate()
+          .map(|(idx, value)| if idx == i { None } else { value.to_owned() })
+          .collect::<Vec<Option<Vec<u8>>>>(),
+        msg
+      ).unwrap()
+    );
+  }
+
+  let mut res = Vec::with_capacity(THRESHOLD);
+  for i in 1 ..= THRESHOLD {
+    res.push(
+      machines[i - 1].complete(
+        &shares
+          .iter()
+          .enumerate()
+          .map(|(idx, value)| if idx == i { None } else { value.to_owned() })
+          .collect::<Vec<Option<Vec<u8>>>>()
+      ).unwrap()
+    );
+  }
+  res
+}

coins/monero/src/tests/mod.rs

@@ -0,0 +1,4 @@
+#[cfg(feature = "multisig")]
+mod frost;
+
+mod clsag;