Move old processor/src directory to processor/TODO

processor/TODO/tests/signer.rs

@@ -0,0 +1,247 @@
+// TODO
+
+use core::{pin::Pin, future::Future};
+use std::collections::HashMap;
+
+use rand_core::{RngCore, OsRng};
+
+use ciphersuite::group::GroupEncoding;
+use frost::{
+  Participant, ThresholdKeys,
+  dkg::tests::{key_gen, clone_without},
+};
+
+use serai_db::{DbTxn, Db, MemDb};
+
+use serai_client::{
+  primitives::{NetworkId, Coin, Amount, Balance},
+  validator_sets::primitives::Session,
+};
+
+use messages::sign::*;
+use crate::{
+  Payment,
+  networks::{Output, Transaction, Eventuality, Network},
+  key_gen::NetworkKeyDb,
+  multisigs::scheduler::Scheduler,
+  signer::Signer,
+};
+
+#[allow(clippy::type_complexity)]
+pub async fn sign<N: Network>(
+  network: N,
+  session: Session,
+  mut keys_txs: HashMap<
+    Participant,
+    (ThresholdKeys<N::Curve>, (N::SignableTransaction, N::Eventuality)),
+  >,
+) -> <N::Eventuality as Eventuality>::Claim {
+  let actual_id = SignId { session, id: [0xaa; 32], attempt: 0 };
+
+  let mut keys = HashMap::new();
+  let mut txs = HashMap::new();
+  for (i, (these_keys, this_tx)) in keys_txs.drain() {
+    keys.insert(i, these_keys);
+    txs.insert(i, this_tx);
+  }
+
+  let mut signers = HashMap::new();
+  let mut dbs = HashMap::new();
+  let mut t = 0;
+  for i in 1 ..= keys.len() {
+    let i = Participant::new(u16::try_from(i).unwrap()).unwrap();
+    let keys = keys.remove(&i).unwrap();
+    t = keys.params().t();
+    signers.insert(i, Signer::<_, MemDb>::new(network.clone(), Session(0), vec![keys]));
+    dbs.insert(i, MemDb::new());
+  }
+  drop(keys);
+
+  let mut signing_set = vec![];
+  while signing_set.len() < usize::from(t) {
+    let candidate = Participant::new(
+      u16::try_from((OsRng.next_u64() % u64::try_from(signers.len()).unwrap()) + 1).unwrap(),
+    )
+    .unwrap();
+    if signing_set.contains(&candidate) {
+      continue;
+    }
+    signing_set.push(candidate);
+  }
+
+  let mut preprocesses = HashMap::new();
+
+  let mut eventuality = None;
+  for i in 1 ..= signers.len() {
+    let i = Participant::new(u16::try_from(i).unwrap()).unwrap();
+    let (tx, this_eventuality) = txs.remove(&i).unwrap();
+    let mut txn = dbs.get_mut(&i).unwrap().txn();
+    match signers
+      .get_mut(&i)
+      .unwrap()
+      .sign_transaction(&mut txn, actual_id.id, tx, &this_eventuality)
+      .await
+    {
+      // All participants should emit a preprocess
+      Some(ProcessorMessage::Preprocess { id, preprocesses: mut these_preprocesses }) => {
+        assert_eq!(id, actual_id);
+        assert_eq!(these_preprocesses.len(), 1);
+        if signing_set.contains(&i) {
+          preprocesses.insert(i, these_preprocesses.swap_remove(0));
+        }
+      }
+      _ => panic!("didn't get preprocess back"),
+    }
+    txn.commit();
+
+    if eventuality.is_none() {
+      eventuality = Some(this_eventuality.clone());
+    }
+    assert_eq!(eventuality, Some(this_eventuality));
+  }
+
+  let mut shares = HashMap::new();
+  for i in &signing_set {
+    let mut txn = dbs.get_mut(i).unwrap().txn();
+    match signers
+      .get_mut(i)
+      .unwrap()
+      .handle(
+        &mut txn,
+        CoordinatorMessage::Preprocesses {
+          id: actual_id.clone(),
+          preprocesses: clone_without(&preprocesses, i),
+        },
+      )
+      .await
+      .unwrap()
+    {
+      ProcessorMessage::Share { id, shares: mut these_shares } => {
+        assert_eq!(id, actual_id);
+        assert_eq!(these_shares.len(), 1);
+        shares.insert(*i, these_shares.swap_remove(0));
+      }
+      _ => panic!("didn't get share back"),
+    }
+    txn.commit();
+  }
+
+  let mut tx_id = None;
+  for i in &signing_set {
+    let mut txn = dbs.get_mut(i).unwrap().txn();
+    match signers
+      .get_mut(i)
+      .unwrap()
+      .handle(
+        &mut txn,
+        CoordinatorMessage::Shares { id: actual_id.clone(), shares: clone_without(&shares, i) },
+      )
+      .await
+      .unwrap()
+    {
+      ProcessorMessage::Completed { session, id, tx } => {
+        assert_eq!(session, Session(0));
+        assert_eq!(id, actual_id.id);
+        if tx_id.is_none() {
+          tx_id = Some(tx.clone());
+        }
+        assert_eq!(tx_id, Some(tx));
+      }
+      _ => panic!("didn't get TX back"),
+    }
+    txn.commit();
+  }
+
+  let mut typed_claim = <N::Eventuality as Eventuality>::Claim::default();
+  typed_claim.as_mut().copy_from_slice(tx_id.unwrap().as_ref());
+  assert!(network.check_eventuality_by_claim(&eventuality.unwrap(), &typed_claim).await);
+  typed_claim
+}
+
+pub async fn test_signer<N: Network>(
+  new_network: impl Fn(MemDb) -> Pin<Box<dyn Send + Future<Output = N>>>,
+) {
+  let mut keys = key_gen(&mut OsRng);
+  for keys in keys.values_mut() {
+    N::tweak_keys(keys);
+  }
+  let key = keys[&Participant::new(1).unwrap()].group_key();
+
+  let mut db = MemDb::new();
+  {
+    let mut txn = db.txn();
+    NetworkKeyDb::set(&mut txn, Session(0), &key.to_bytes().as_ref().to_vec());
+    txn.commit();
+  }
+  let network = new_network(db.clone()).await;
+
+  let outputs = network
+    .get_outputs(&network.test_send(N::external_address(&network, key).await).await, key)
+    .await;
+  let sync_block = network.get_latest_block_number().await.unwrap() - N::CONFIRMATIONS;
+
+  let amount = (2 * N::DUST) + 1000;
+  let plan = {
+    let mut txn = db.txn();
+    let mut scheduler = N::Scheduler::new::<MemDb>(&mut txn, key, N::NETWORK);
+    let payments = vec![Payment {
+      address: N::external_address(&network, key).await,
+      balance: Balance {
+        coin: match N::NETWORK {
+          NetworkId::Serai => panic!("test_signer called with Serai"),
+          NetworkId::Bitcoin => Coin::Bitcoin,
+          NetworkId::Ethereum => Coin::Ether,
+          NetworkId::Monero => Coin::Monero,
+        },
+        amount: Amount(amount),
+      },
+    }];
+    let mut plans = scheduler.schedule::<MemDb>(&mut txn, outputs.clone(), payments, key, false);
+    assert_eq!(plans.len(), 1);
+    plans.swap_remove(0)
+  };
+
+  let mut keys_txs = HashMap::new();
+  let mut eventualities = vec![];
+  for (i, keys) in keys.drain() {
+    let (signable, eventuality) =
+      network.prepare_send(sync_block, plan.clone(), 0).await.unwrap().tx.unwrap();
+
+    eventualities.push(eventuality.clone());
+    keys_txs.insert(i, (keys, (signable, eventuality)));
+  }
+
+  let claim = sign(network.clone(), Session(0), keys_txs).await;
+
+  // Mine a block, and scan it, to ensure that the TX actually made it on chain
+  network.mine_block().await;
+  let block_number = network.get_latest_block_number().await.unwrap();
+  let tx = network.get_transaction_by_eventuality(block_number, &eventualities[0]).await;
+  let outputs = network
+    .get_outputs(
+      &network.get_block(network.get_latest_block_number().await.unwrap()).await.unwrap(),
+      key,
+    )
+    .await;
+  // Don't run if Ethereum as the received output will revert by the contract
+  // (and therefore not actually exist)
+  if N::NETWORK != NetworkId::Ethereum {
+    assert_eq!(outputs.len(), 1 + usize::from(u8::from(plan.change.is_some())));
+    // Adjust the amount for the fees
+    let amount = amount - tx.fee(&network).await;
+    if plan.change.is_some() {
+      // Check either output since Monero will randomize its output order
+      assert!(
+        (outputs[0].balance().amount.0 == amount) || (outputs[1].balance().amount.0 == amount)
+      );
+    } else {
+      assert!(outputs[0].balance().amount.0 == amount);
+    }
+  }
+
+  // Check the eventualities pass
+  for eventuality in eventualities {
+    let completion = network.confirm_completion(&eventuality, &claim).await.unwrap().unwrap();
+    assert_eq!(N::Eventuality::claim(&completion), claim);
+  }
+}