Add the bones of the processor

Cargo.toml

@@ -6,4 +6,5 @@ members = [
   "crypto/frost",
   "crypto/dalek-ff-group",
   "coins/monero",
+  "processor",
 ]

processor/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "serai-processor"
+version = "0.1.0"
+description = "Multichain processor premised on canonicity to reach distributed consensus automatically"
+license = "MIT"
+authors = ["Luke Parker <lukeparker5132@gmail.com>"]
+edition = "2021"
+
+[dependencies]
+async-trait = "0.1"
+thiserror = "1"
+
+monero = { version = "0.16", features = ["experimental"] }
+monero-serai = { path = "../coins/monero", features = ["multisig"] }
+
+[dev-dependencies]
+tokio = { version = "1", features = ["full"] }

processor/src/coins/mod.rs

@@ -0,0 +1 @@
+pub mod monero;

processor/src/coins/monero.rs

@@ -0,0 +1,62 @@
+use async_trait::async_trait;
+
+use monero::util::address::Address;
+use monero_serai::{/*transaction::Output, */ rpc::Rpc, wallet::SpendableOutput};
+
+use crate::{Output as OutputTrait, CoinError, Coin};
+
+pub struct Output(SpendableOutput);
+impl OutputTrait for Output {
+  // If Monero ever does support more than 255 outputs at once, which it could, this u8 could be a
+  // u16 which serializes as little endian, dropping the last byte if empty, without conflict
+  type Id = ([u8; 32], u8);
+
+  fn id(&self) -> Self::Id {
+    (self.0.tx, self.0.o.try_into().unwrap())
+  }
+
+  fn amount(&self) -> u64 {
+    self.0.commitment.amount
+  }
+
+  fn serialize(&self) -> Vec<u8> {
+    self.0.serialize()
+  }
+
+  fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
+    SpendableOutput::deserialize(reader).map(|o| Output(o))
+  }
+}
+
+pub struct Monero(Rpc);
+
+impl Monero {
+  pub fn new(url: String) -> Monero {
+    Monero(Rpc::new(url))
+  }
+}
+
+#[async_trait]
+impl Coin for Monero {
+  type Output = Output;
+  type Address = Address;
+
+  async fn confirmations() -> usize { 10 }
+  async fn max_inputs() -> usize { 16 } // TODO
+  async fn max_outputs() -> usize { 16 }
+
+  async fn get_height(&self) -> Result<usize, CoinError> {
+    self.0.get_height().await.map_err(|_| CoinError::ConnectionError)
+  }
+
+  async fn get_outputs_in_block(&self) -> Result<Vec<Self::Output>, CoinError> {
+    todo!()
+  }
+
+  async fn send(
+    &self,
+    _payments: &[(Address, u64)]
+  ) -> Result<Vec<<Self::Output as OutputTrait>::Id>, CoinError> {
+    todo!()
+  }
+}

processor/src/lib.rs

@@ -0,0 +1,40 @@
+use async_trait::async_trait;
+use thiserror::Error;
+
+pub mod coins;
+
+#[cfg(test)]
+mod tests;
+
+trait Output: Sized {
+  type Id;
+
+  fn id(&self) -> Self::Id;
+  fn amount(&self) -> u64;
+
+  fn serialize(&self) -> Vec<u8>;
+  fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self>;
+}
+
+#[derive(Error, Debug)]
+enum CoinError {
+  #[error("failed to connect to coin daemon")]
+  ConnectionError
+}
+
+#[async_trait]
+trait Coin {
+  type Output: Output;
+  type Address;
+
+  async fn confirmations() -> usize;
+  async fn max_inputs() -> usize;
+  async fn max_outputs() -> usize;
+
+  async fn get_height(&self) -> Result<usize, CoinError>;
+  async fn get_outputs_in_block(&self) -> Result<Vec<Self::Output>, CoinError>;
+  async fn send(
+    &self,
+    payments: &[(Self::Address, u64)]
+  ) -> Result<Vec<<Self::Output as Output>::Id>, CoinError>;
+}

processor/src/scanner.rs

@@ -0,0 +1,5 @@
+struct Scanner<C: Coin> {}
+
+impl Scanner {
+
+}

processor/src/scheduler.rs

@@ -0,0 +1,4 @@
+// For n existing inputs, and n target outputs, multiplex the inputs in while log scheduling the
+// outputs out. Monero, which has a limit of 16 TXOs, could do 15 at a time, carrying a change
+// Combined with the 20 minute lock, this is completely infeasible. By instead doing 15 TX seeds,
+// and then 16 outputs on each, in just two lock cycles you can accomplish 240 TXs (not just 30).

processor/src/tests/mod.rs

@@ -0,0 +1,6 @@
+use crate::{Coin, coins::monero::Monero};
+
+#[tokio::test]
+async fn test() {
+  println!("{}", Monero::new("http://127.0.0.1:18081".to_string()).get_height().await.unwrap());
+}