Acknowledge Substrate's ordering and move to a multi-key wallet setup

processor/src/wallet.rs

@@ -1,30 +1,102 @@
+use std::collections::HashMap;
+
 use frost::{Curve, MultisigKeys};
 
-use crate::Coin;
+use crate::{CoinError, Coin};
 
-struct Wallet<C: Coin> {
-  keys: MultisigKeys<C::Curve>,
+pub struct WalletKeys<C: Curve> {
+  keys: MultisigKeys<C>,
+  creation_height: usize
+}
+
+impl<C: Curve> WalletKeys<C> {
+  pub fn new(keys: MultisigKeys<C>, creation_height: usize) -> WalletKeys<C> {
+    WalletKeys { keys, creation_height }
+  }
+
+  // Bind this key to a specific network by applying an additive offset
+  // While it would be fine to just C::id(), including the group key creates distinct
+  // offsets instead of static offsets. Under a statically offset system, a BTC key could
+  // have X subtracted to find the potential group key, and then have Y added to find the
+  // potential ETH group key. While this shouldn't be an issue, as this isn't a private
+  // system, there are potentially other benefits to binding this to a specific group key
+  // It's no longer possible to influence group key gen to key cancel without breaking the hash
+  // function, although that degree of influence means key gen is broken already
+  fn bind(&self, chain: &[u8]) -> MultisigKeys<C> {
+    self.keys.offset(
+      C::hash_to_F(
+        &[
+          b"Serai Processor Wallet",
+          chain,
+          &C::G_to_bytes(&self.keys.group_key())
+        ].concat()
+      )
+    )
+  }
+}
+
+pub struct CoinDb {
+  // Height this coin has been scanned to
+  scanned_height: usize,
+  // Acknowledged height for a given canonical height
+  acknowledged_heights: HashMap<usize, usize>
+}
+
+pub struct Wallet<C: Coin> {
+  db: CoinDb,
+  coin: C,
+  keys: Vec<MultisigKeys<C::Curve>>,
+  pending: Vec<(usize, MultisigKeys<C::Curve>)>,
   outputs: Vec<C::Output>
 }
 
 impl<C: Coin> Wallet<C> {
-  fn new(keys: &MultisigKeys<C::Curve>) -> Wallet<C> {
+  pub fn new(coin: C) -> Wallet<C> {
     Wallet {
-      keys: keys.offset(
-        C::Curve::hash_to_F(
-          // Use distinct keys on each network by applying an additive offset
-          // While it would be fine to just C::id(), including the group key creates distinct
-          // offsets instead of static offsets. Under a statically offset system, a BTC key could
-          // have X subtracted to find the potential group key, and then have Y added to find the
-          // potential BCH group key. While this shouldn't be an issue, as this isn't a private
-          // system, there are potentially other benefits to binding this to a specific group key
-          &[b"Serai Processor Wallet", C::id(), &C::Curve::G_to_bytes(&keys.group_key())].concat()
-        )
-      ),
+      db: CoinDb {
+        scanned_height: 0,
+        acknowledged_heights: HashMap::new(),
+      },
 
+      coin,
+
+      keys: vec![],
+      pending: vec![],
       outputs: vec![]
     }
   }
 
-  async fn poll() { todo!() }
+  pub fn scanned_height(&self) -> usize { self.db.scanned_height }
+  pub fn acknowledge_height(&mut self, canonical: usize, height: usize) {
+    debug_assert!(!self.db.acknowledged_heights.contains_key(&canonical));
+    self.db.acknowledged_heights.insert(canonical, height);
+  }
+  pub fn acknowledged_height(&self, canonical: usize) -> usize {
+    self.db.acknowledged_heights[&canonical]
+  }
+
+  pub fn add_keys(&mut self, keys: &WalletKeys<C::Curve>) {
+    // Doesn't use +1 as this is height, not block index, and poll moves by block index
+    self.pending.push((self.acknowledged_height(keys.creation_height), keys.bind(C::id())));
+  }
+
+  pub async fn poll(&mut self) -> Result<(), CoinError> {
+    let confirmed_height = self.coin.get_height().await? - C::confirmations();
+    for h in self.scanned_height() .. confirmed_height {
+      let mut k = 0;
+      while k < self.pending.len() {
+        if h == self.pending[k].0 {
+          self.keys.push(self.pending.swap_remove(k).1);
+        } else {
+          k += 1;
+        }
+      }
+
+      let block = self.coin.get_block(h).await?;
+      for keys in &self.keys {
+        let outputs = self.coin.get_outputs(&block, keys.group_key());
+      }
+    }
+    Ok(())
+  }
 }