Move the Ethereum Action machine to its own file

processor/ethereum/src/primitives/transaction.rs

@@ -1,14 +1,7 @@
-use std::{io, collections::HashMap};
+use std::io;
 
-use rand_core::{RngCore, CryptoRng};
-
-use ciphersuite::{Ciphersuite, Secp256k1};
-use frost::{
-  dkg::{Participant, ThresholdKeys},
-  FrostError,
-  algorithm::*,
-  sign::*,
-};
+use ciphersuite::Secp256k1;
+use frost::dkg::ThresholdKeys;
 
 use alloy_core::primitives::U256;
 
@@ -20,7 +13,7 @@ use ethereum_primitives::keccak256;
 use ethereum_schnorr::{PublicKey, Signature};
 use ethereum_router::{Coin, OutInstructions, Executed, Router};
 
-use crate::output::OutputId;
+use crate::{output::OutputId, machine::ClonableTransctionMachine};
 
 #[derive(Clone, PartialEq, Debug)]
 pub(crate) enum Action {
@@ -32,13 +25,13 @@ pub(crate) enum Action {
 pub(crate) struct Eventuality(pub(crate) Executed);
 
 impl Action {
-  fn nonce(&self) -> u64 {
+  pub(crate) fn nonce(&self) -> u64 {
     match self {
       Action::SetKey { nonce, .. } | Action::Batch { nonce, .. } => *nonce,
     }
   }
 
-  fn message(&self) -> Vec<u8> {
+  pub(crate) fn message(&self) -> Vec<u8> {
     match self {
       Action::SetKey { chain_id, nonce, key } => {
         Router::update_serai_key_message(*chain_id, *nonce, key)
@@ -67,155 +60,20 @@ impl Action {
 }
 
 #[derive(Clone, PartialEq, Debug)]
-pub(crate) struct Transaction(Action, Signature);
+pub(crate) struct Transaction(pub(crate) Action, pub(crate) Signature);
 impl scheduler::Transaction for Transaction {
   fn read(reader: &mut impl io::Read) -> io::Result<Self> {
-    /*
-    let buf: Vec<u8> = borsh::from_reader(reader)?;
-    // We can only read this from a &[u8], hence prior reading into a Vec<u8>
-    <TxLegacy as alloy_rlp::Decodable>::decode(&mut buf.as_slice())
-      .map(Self)
-      .map_err(io::Error::other)
-    */
     let action = Action::read(reader)?;
     let signature = Signature::read(reader)?;
     Ok(Transaction(action, signature))
   }
   fn write(&self, writer: &mut impl io::Write) -> io::Result<()> {
-    /*
-    let mut buf = Vec::with_capacity(256);
-    <TxLegacy as alloy_rlp::Encodable>::encode(&self.0, &mut buf);
-    borsh::BorshSerialize::serialize(&buf, writer)
-    */
     self.0.write(writer)?;
     self.1.write(writer)?;
     Ok(())
   }
 }
 
-/// The HRAm to use for the Schnorr Solidity library.
-///
-/// This will panic if the public key being signed for is not representable within the Schnorr
-/// Solidity library.
-#[derive(Clone, Default, Debug)]
-pub struct EthereumHram;
-impl Hram<Secp256k1> for EthereumHram {
-  #[allow(non_snake_case)]
-  fn hram(
-    R: &<Secp256k1 as Ciphersuite>::G,
-    A: &<Secp256k1 as Ciphersuite>::G,
-    m: &[u8],
-  ) -> <Secp256k1 as Ciphersuite>::F {
-    Signature::challenge(*R, &PublicKey::new(*A).unwrap(), m)
-  }
-}
-
-#[derive(Clone)]
-pub(crate) struct ClonableTransctionMachine(ThresholdKeys<Secp256k1>, Action);
-
-type LiteralAlgorithmMachine = AlgorithmMachine<Secp256k1, IetfSchnorr<Secp256k1, EthereumHram>>;
-type LiteralAlgorithmSignMachine =
-  AlgorithmSignMachine<Secp256k1, IetfSchnorr<Secp256k1, EthereumHram>>;
-
-pub(crate) struct ActionSignMachine(PublicKey, Action, LiteralAlgorithmSignMachine);
-
-type LiteralAlgorithmSignatureMachine =
-  AlgorithmSignatureMachine<Secp256k1, IetfSchnorr<Secp256k1, EthereumHram>>;
-
-pub(crate) struct ActionSignatureMachine(PublicKey, Action, LiteralAlgorithmSignatureMachine);
-
-impl PreprocessMachine for ClonableTransctionMachine {
-  type Preprocess = <LiteralAlgorithmMachine as PreprocessMachine>::Preprocess;
-  type Signature = Transaction;
-  type SignMachine = ActionSignMachine;
-
-  fn preprocess<R: RngCore + CryptoRng>(
-    self,
-    rng: &mut R,
-  ) -> (Self::SignMachine, Self::Preprocess) {
-    let (machine, preprocess) =
-      AlgorithmMachine::new(IetfSchnorr::<Secp256k1, EthereumHram>::ietf(), self.0.clone())
-        .preprocess(rng);
-    (
-      ActionSignMachine(
-        PublicKey::new(self.0.group_key()).expect("signing with non-representable key"),
-        self.1,
-        machine,
-      ),
-      preprocess,
-    )
-  }
-}
-
-impl SignMachine<Transaction> for ActionSignMachine {
-  type Params = <LiteralAlgorithmSignMachine as SignMachine<
-    <LiteralAlgorithmMachine as PreprocessMachine>::Signature,
-  >>::Params;
-  type Keys = <LiteralAlgorithmSignMachine as SignMachine<
-    <LiteralAlgorithmMachine as PreprocessMachine>::Signature,
-  >>::Keys;
-  type Preprocess = <LiteralAlgorithmSignMachine as SignMachine<
-    <LiteralAlgorithmMachine as PreprocessMachine>::Signature,
-  >>::Preprocess;
-  type SignatureShare = <LiteralAlgorithmSignMachine as SignMachine<
-    <LiteralAlgorithmMachine as PreprocessMachine>::Signature,
-  >>::SignatureShare;
-  type SignatureMachine = ActionSignatureMachine;
-
-  fn cache(self) -> CachedPreprocess {
-    unimplemented!()
-  }
-  fn from_cache(
-    params: Self::Params,
-    keys: Self::Keys,
-    cache: CachedPreprocess,
-  ) -> (Self, Self::Preprocess) {
-    unimplemented!()
-  }
-
-  fn read_preprocess<R: io::Read>(&self, reader: &mut R) -> io::Result<Self::Preprocess> {
-    self.2.read_preprocess(reader)
-  }
-  fn sign(
-    self,
-    commitments: HashMap<Participant, Self::Preprocess>,
-    msg: &[u8],
-  ) -> Result<(Self::SignatureMachine, Self::SignatureShare), FrostError> {
-    assert!(msg.is_empty());
-    self
-      .2
-      .sign(commitments, &self.1.message())
-      .map(|(machine, shares)| (ActionSignatureMachine(self.0, self.1, machine), shares))
-  }
-}
-
-impl SignatureMachine<Transaction> for ActionSignatureMachine {
-  type SignatureShare = <LiteralAlgorithmSignatureMachine as SignatureMachine<
-    <LiteralAlgorithmMachine as PreprocessMachine>::Signature,
-  >>::SignatureShare;
-
-  fn read_share<R: io::Read>(&self, reader: &mut R) -> io::Result<Self::SignatureShare> {
-    self.2.read_share(reader)
-  }
-
-  fn complete(
-    self,
-    shares: HashMap<Participant, Self::SignatureShare>,
-  ) -> Result<Transaction, FrostError> {
-    /*
-    match self.1 {
-      Action::SetKey { chain_id: _, nonce: _, key } => self.0.update_serai_key(key, signature),
-      Action::Batch { chain_id: _, nonce: _, outs } => self.0.execute(outs, signature),
-    }
-    */
-    self.2.complete(shares).map(|signature| {
-      let s = signature.s;
-      let c = Signature::challenge(signature.R, &self.0, &self.1.message());
-      Transaction(self.1, Signature::new(c, s))
-    })
-  }
-}
-
 impl SignableTransaction for Action {
   type Transaction = Transaction;
   type Ciphersuite = Secp256k1;
@@ -296,7 +154,7 @@ impl SignableTransaction for Action {
   }
 
   fn sign(self, keys: ThresholdKeys<Self::Ciphersuite>) -> Self::PreprocessMachine {
-    ClonableTransctionMachine(keys, self)
+    ClonableTransctionMachine { keys, action: self }
   }
 }