Monero processor primitives

processor/monero/src/primitives/transaction.rs

@@ -0,0 +1,137 @@
+use std::io;
+
+use rand_core::{RngCore, CryptoRng};
+
+use ciphersuite::Ed25519;
+use frost::{dkg::ThresholdKeys, sign::PreprocessMachine};
+
+use monero_wallet::{
+  transaction::Transaction as MTransaction,
+  send::{
+    SignableTransaction as MSignableTransaction, TransactionMachine, Eventuality as MEventuality,
+  },
+};
+
+use crate::output::OutputId;
+
+#[derive(Clone, Debug)]
+pub(crate) struct Transaction(pub(crate) MTransaction);
+
+impl From<MTransaction> for Transaction {
+  fn from(tx: MTransaction) -> Self {
+    Self(tx)
+  }
+}
+
+impl scheduler::Transaction for Transaction {
+  fn read(reader: &mut impl io::Read) -> io::Result<Self> {
+    MTransaction::read(reader).map(Self)
+  }
+  fn write(&self, writer: &mut impl io::Write) -> io::Result<()> {
+    self.0.write(writer)
+  }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct SignableTransaction {
+  id: [u8; 32],
+  signable: MSignableTransaction,
+}
+
+#[derive(Clone)]
+pub(crate) struct ClonableTransctionMachine(MSignableTransaction, ThresholdKeys<Ed25519>);
+impl PreprocessMachine for ClonableTransctionMachine {
+  type Preprocess = <TransactionMachine as PreprocessMachine>::Preprocess;
+  type Signature = <TransactionMachine as PreprocessMachine>::Signature;
+  type SignMachine = <TransactionMachine as PreprocessMachine>::SignMachine;
+
+  fn preprocess<R: RngCore + CryptoRng>(
+    self,
+    rng: &mut R,
+  ) -> (Self::SignMachine, Self::Preprocess) {
+    self.0.multisig(self.1).expect("incorrect keys used for SignableTransaction").preprocess(rng)
+  }
+}
+
+impl scheduler::SignableTransaction for SignableTransaction {
+  type Transaction = Transaction;
+  type Ciphersuite = Ed25519;
+  type PreprocessMachine = ClonableTransctionMachine;
+
+  fn read(reader: &mut impl io::Read) -> io::Result<Self> {
+    let mut id = [0; 32];
+    reader.read_exact(&mut id)?;
+
+    let signable = MSignableTransaction::read(reader)?;
+    Ok(SignableTransaction { id, signable })
+  }
+  fn write(&self, writer: &mut impl io::Write) -> io::Result<()> {
+    writer.write_all(&self.id)?;
+    self.signable.write(writer)
+  }
+
+  fn id(&self) -> [u8; 32] {
+    self.id
+  }
+
+  fn sign(self, keys: ThresholdKeys<Self::Ciphersuite>) -> Self::PreprocessMachine {
+    ClonableTransctionMachine(self.signable, keys)
+  }
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub(crate) struct Eventuality {
+  id: [u8; 32],
+  singular_spent_output: Option<OutputId>,
+  eventuality: MEventuality,
+}
+
+impl primitives::Eventuality for Eventuality {
+  type OutputId = OutputId;
+
+  fn id(&self) -> [u8; 32] {
+    self.id
+  }
+
+  // We define the lookup as our ID since the resolving transaction only has a singular possible ID
+  fn lookup(&self) -> Vec<u8> {
+    self.eventuality.extra()
+  }
+
+  fn singular_spent_output(&self) -> Option<Self::OutputId> {
+    self.singular_spent_output
+  }
+
+  fn read(reader: &mut impl io::Read) -> io::Result<Self> {
+    let mut id = [0; 32];
+    reader.read_exact(&mut id)?;
+
+    let singular_spent_output = {
+      let mut singular_spent_output_opt = [0xff];
+      reader.read_exact(&mut singular_spent_output_opt)?;
+      assert!(singular_spent_output_opt[0] <= 1);
+      (singular_spent_output_opt[0] == 1)
+        .then(|| -> io::Result<_> {
+          let mut singular_spent_output = [0; 32];
+          reader.read_exact(&mut singular_spent_output)?;
+          Ok(OutputId(singular_spent_output))
+        })
+        .transpose()?
+    };
+
+    let eventuality = MEventuality::read(reader)?;
+    Ok(Self { id, singular_spent_output, eventuality })
+  }
+  fn write(&self, writer: &mut impl io::Write) -> io::Result<()> {
+    writer.write_all(&self.id)?;
+
+    if let Some(singular_spent_output) = self.singular_spent_output {
+      writer.write_all(&[1])?;
+      writer.write_all(singular_spent_output.as_ref())?;
+    } else {
+      writer.write_all(&[0])?;
+    }
+
+    self.eventuality.write(writer)
+  }
+}