Remove async-trait from tendermint-machine, tributary-chain

Cargo.lock

@@ -10498,7 +10498,6 @@ dependencies = [
 name = "tendermint-machine"
 version = "0.2.0"
 dependencies = [
- "async-trait",
  "futures-channel",
  "futures-util",
  "hex",
@@ -10941,7 +10940,6 @@ dependencies = [
 name = "tributary-chain"
 version = "0.1.0"
 dependencies = [
- "async-trait",
  "blake2",
  "ciphersuite",
  "flexible-transcript",

coordinator/tributary/Cargo.toml

@@ -16,7 +16,6 @@ rustdoc-args = ["--cfg", "docsrs"]
 workspace = true
 
 [dependencies]
-async-trait = { version = "0.1", default-features = false }
 thiserror = { version = "2", default-features = false, features = ["std"] }
 
 subtle = { version = "^2", default-features = false, features = ["std"] }

coordinator/tributary/src/lib.rs

@@ -1,8 +1,6 @@
-use core::{marker::PhantomData, fmt::Debug};
+use core::{marker::PhantomData, fmt::Debug, future::Future};
 use std::{sync::Arc, io};
 
-use async_trait::async_trait;
-
 use zeroize::Zeroizing;
 
 use ciphersuite::{Ciphersuite, Ristretto};
@@ -131,20 +129,18 @@ pub trait ReadWrite: Sized {
   }
 }
 
-#[async_trait]
 pub trait P2p: 'static + Send + Sync + Clone + Debug {
   /// Broadcast a message to all other members of the Tributary with the specified genesis.
   ///
   /// The Tributary will re-broadcast consensus messages on a fixed interval to ensure they aren't
   /// prematurely dropped from the P2P layer. THe P2P layer SHOULD perform content-based
   /// deduplication to ensure a sane amount of load.
-  async fn broadcast(&self, genesis: [u8; 32], msg: Vec<u8>);
+  fn broadcast(&self, genesis: [u8; 32], msg: Vec<u8>) -> impl Send + Future<Output = ()>;
 }
 
-#[async_trait]
 impl<P: P2p> P2p for Arc<P> {
-  async fn broadcast(&self, genesis: [u8; 32], msg: Vec<u8>) {
+  fn broadcast(&self, genesis: [u8; 32], msg: Vec<u8>) -> impl Send + Future<Output = ()> {
-    (*self).broadcast(genesis, msg).await
+    P::broadcast(self, genesis, msg)
   }
 }
 

coordinator/tributary/src/tendermint/mod.rs

@@ -1,8 +1,6 @@
-use core::ops::Deref;
+use core::{ops::Deref, future::Future};
 use std::{sync::Arc, collections::HashMap};
 
-use async_trait::async_trait;
-
 use subtle::ConstantTimeEq;
 use zeroize::{Zeroize, Zeroizing};
 
@@ -74,19 +72,20 @@ impl Signer {
   }
 }
 
-#[async_trait]
 impl SignerTrait for Signer {
   type ValidatorId = [u8; 32];
   type Signature = [u8; 64];
 
   /// Returns the validator's current ID. Returns None if they aren't a current validator.
-  async fn validator_id(&self) -> Option<Self::ValidatorId> {
+  fn validator_id(&self) -> impl Send + Future<Output = Option<Self::ValidatorId>> {
-    Some((Ristretto::generator() * self.key.deref()).to_bytes())
+    async move { Some((Ristretto::generator() * self.key.deref()).to_bytes()) }
   }
 
   /// Sign a signature with the current validator's private key.
-  async fn sign(&self, msg: &[u8]) -> Self::Signature {
+  fn sign(&self, msg: &[u8]) -> impl Send + Future<Output = Self::Signature> {
-    let mut nonce = Zeroizing::new(RecommendedTranscript::new(b"Tributary Chain Tendermint Nonce"));
+    async move {
+      let mut nonce =
+        Zeroizing::new(RecommendedTranscript::new(b"Tributary Chain Tendermint Nonce"));
       nonce.append_message(b"genesis", self.genesis);
       nonce.append_message(b"key", Zeroizing::new(self.key.deref().to_repr()).as_ref());
       nonce.append_message(b"message", msg);
@@ -119,6 +118,7 @@ impl SignerTrait for Signer {
       res.copy_from_slice(&sig);
       res
     }
+  }
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -274,7 +274,6 @@ pub const BLOCK_PROCESSING_TIME: u32 = 999;
 pub const LATENCY_TIME: u32 = 1667;
 pub const TARGET_BLOCK_TIME: u32 = BLOCK_PROCESSING_TIME + (3 * LATENCY_TIME);
 
-#[async_trait]
 impl<D: Db, T: TransactionTrait, P: P2p> Network for TendermintNetwork<D, T, P> {
   type Db = D;
 
@@ -300,13 +299,20 @@ impl<D: Db, T: TransactionTrait, P: P2p> Network for TendermintNetwork<D, T, P>
     self.validators.clone()
   }
 
-  async fn broadcast(&mut self, msg: SignedMessageFor<Self>) {
+  fn broadcast(&mut self, msg: SignedMessageFor<Self>) -> impl Send + Future<Output = ()> {
+    async move {
       let mut to_broadcast = vec![TENDERMINT_MESSAGE];
       to_broadcast.extend(msg.encode());
       self.p2p.broadcast(self.genesis, to_broadcast).await
     }
+  }
 
-  async fn slash(&mut self, validator: Self::ValidatorId, slash_event: SlashEvent) {
+  fn slash(
+    &mut self,
+    validator: Self::ValidatorId,
+    slash_event: SlashEvent,
+  ) -> impl Send + Future<Output = ()> {
+    async move {
       log::error!(
         "validator {} triggered a slash event on tributary {} (with evidence: {})",
         hex::encode(validator),
@@ -340,8 +346,13 @@ impl<D: Db, T: TransactionTrait, P: P2p> Network for TendermintNetwork<D, T, P>
         self.p2p.broadcast(signer.genesis, to_broadcast).await;
       }
     }
+  }
 
-  async fn validate(&self, block: &Self::Block) -> Result<(), TendermintBlockError> {
+  fn validate(
+    &self,
+    block: &Self::Block,
+  ) -> impl Send + Future<Output = Result<(), TendermintBlockError>> {
+    async move {
       let block =
         Block::read::<&[u8]>(&mut block.0.as_ref()).map_err(|_| TendermintBlockError::Fatal)?;
       self
@@ -357,12 +368,14 @@ impl<D: Db, T: TransactionTrait, P: P2p> Network for TendermintNetwork<D, T, P>
           }
         })
     }
+  }
 
-  async fn add_block(
+  fn add_block(
     &mut self,
     serialized_block: Self::Block,
     commit: Commit<Self::SignatureScheme>,
-  ) -> Option<Self::Block> {
+  ) -> impl Send + Future<Output = Option<Self::Block>> {
+    async move {
       let invalid_block = || {
         // There's a fatal flaw in the code, it's behind a hard fork, or the validators turned
         // malicious
@@ -407,4 +420,5 @@ impl<D: Db, T: TransactionTrait, P: P2p> Network for TendermintNetwork<D, T, P>
         self.blockchain.write().await.build_block::<Self>(&self.signature_scheme()).serialize(),
       ))
     }
+  }
 }

coordinator/tributary/src/tests/p2p.rs

@@ -1,11 +1,12 @@
+use core::future::Future;
+
 pub use crate::P2p;
 
 #[derive(Clone, Debug)]
 pub struct DummyP2p;
 
-#[async_trait::async_trait]
 impl P2p for DummyP2p {
-  async fn broadcast(&self, _: [u8; 32], _: Vec<u8>) {
+  fn broadcast(&self, _: [u8; 32], _: Vec<u8>) -> impl Send + Future<Output = ()> {
-    unimplemented!()
+    async move { unimplemented!() }
   }
 }

coordinator/tributary/src/tests/tendermint.rs

@@ -1,4 +1,7 @@
+use core::future::Future;
+
 use tendermint::ext::Network;
+
 use crate::{
   P2p, TendermintTx,
   tendermint::{TARGET_BLOCK_TIME, TendermintNetwork},
@@ -11,10 +14,9 @@ fn assert_target_block_time() {
   #[derive(Clone, Debug)]
   pub struct DummyP2p;
 
-  #[async_trait::async_trait]
   impl P2p for DummyP2p {
-    async fn broadcast(&self, _: [u8; 32], _: Vec<u8>) {
+    fn broadcast(&self, _: [u8; 32], _: Vec<u8>) -> impl Send + Future<Output = ()> {
-      unimplemented!()
+      async move { unimplemented!() }
     }
   }
 

coordinator/tributary/tendermint/Cargo.toml

@@ -16,7 +16,6 @@ rustdoc-args = ["--cfg", "docsrs"]
 workspace = true
 
 [dependencies]
-async-trait = { version = "0.1", default-features = false }
 thiserror = { version = "2", default-features = false, features = ["std"] }
 
 hex = { version = "0.4", default-features = false, features = ["std"] }

coordinator/tributary/tendermint/src/ext.rs

@@ -1,7 +1,6 @@
-use core::{hash::Hash, fmt::Debug};
+use core::{hash::Hash, fmt::Debug, future::Future};
 use std::{sync::Arc, collections::HashSet};
 
-use async_trait::async_trait;
 use thiserror::Error;
 
 use parity_scale_codec::{Encode, Decode};
@@ -34,7 +33,6 @@ pub struct BlockNumber(pub u64);
 pub struct RoundNumber(pub u32);
 
 /// A signer for a validator.
-#[async_trait]
 pub trait Signer: Send + Sync {
   // Type used to identify validators.
   type ValidatorId: ValidatorId;
@@ -42,22 +40,21 @@ pub trait Signer: Send + Sync {
   type Signature: Signature;
 
   /// Returns the validator's current ID. Returns None if they aren't a current validator.
-  async fn validator_id(&self) -> Option<Self::ValidatorId>;
+  fn validator_id(&self) -> impl Send + Future<Output = Option<Self::ValidatorId>>;
   /// Sign a signature with the current validator's private key.
-  async fn sign(&self, msg: &[u8]) -> Self::Signature;
+  fn sign(&self, msg: &[u8]) -> impl Send + Future<Output = Self::Signature>;
 }
 
-#[async_trait]
 impl<S: Signer> Signer for Arc<S> {
   type ValidatorId = S::ValidatorId;
   type Signature = S::Signature;
 
-  async fn validator_id(&self) -> Option<Self::ValidatorId> {
+  fn validator_id(&self) -> impl Send + Future<Output = Option<Self::ValidatorId>> {
-    self.as_ref().validator_id().await
+    self.as_ref().validator_id()
   }
 
-  async fn sign(&self, msg: &[u8]) -> Self::Signature {
+  fn sign(&self, msg: &[u8]) -> impl Send + Future<Output = Self::Signature> {
-    self.as_ref().sign(msg).await
+    self.as_ref().sign(msg)
   }
 }
 
@@ -210,7 +207,6 @@ pub trait Block: Send + Sync + Clone + PartialEq + Eq + Debug + Encode + Decode
 }
 
 /// Trait representing the distributed system Tendermint is providing consensus over.
-#[async_trait]
 pub trait Network: Sized + Send + Sync {
   /// The database used to back this.
   type Db: serai_db::Db;
@@ -229,6 +225,7 @@ pub trait Network: Sized + Send + Sync {
   /// This should include both the time to download the block and the actual processing time.
   ///
   /// BLOCK_PROCESSING_TIME + (3 * LATENCY_TIME) must be divisible by 1000.
+  // TODO: Redefine as Duration
   const BLOCK_PROCESSING_TIME: u32;
   /// Network latency time in milliseconds.
   ///
@@ -280,15 +277,19 @@ pub trait Network: Sized + Send + Sync {
   /// Switching to unauthenticated channels in a system already providing authenticated channels is
   /// not recommended as this is a minor, temporal inefficiency, while downgrading channels may
   /// have wider implications.
-  async fn broadcast(&mut self, msg: SignedMessageFor<Self>);
+  fn broadcast(&mut self, msg: SignedMessageFor<Self>) -> impl Send + Future<Output = ()>;
 
   /// Trigger a slash for the validator in question who was definitively malicious.
   ///
   /// The exact process of triggering a slash is undefined and left to the network as a whole.
-  async fn slash(&mut self, validator: Self::ValidatorId, slash_event: SlashEvent);
+  fn slash(
+    &mut self,
+    validator: Self::ValidatorId,
+    slash_event: SlashEvent,
+  ) -> impl Send + Future<Output = ()>;
 
   /// Validate a block.
-  async fn validate(&self, block: &Self::Block) -> Result<(), BlockError>;
+  fn validate(&self, block: &Self::Block) -> impl Send + Future<Output = Result<(), BlockError>>;
 
   /// Add a block, returning the proposal for the next one.
   ///
@@ -298,9 +299,9 @@ pub trait Network: Sized + Send + Sync {
   /// This deviates from the paper which will have a local node refuse to decide on a block it
   /// considers invalid. This library acknowledges the network did decide on it, leaving handling
   /// of it to the network, and outside of this scope.
-  async fn add_block(
+  fn add_block(
     &mut self,
     block: Self::Block,
     commit: Commit<Self::SignatureScheme>,
-  ) -> Option<Self::Block>;
+  ) -> impl Send + Future<Output = Option<Self::Block>>;
 }

coordinator/tributary/tendermint/tests/ext.rs

@@ -1,10 +1,9 @@
+use core::future::Future;
 use std::{
   sync::Arc,
   time::{UNIX_EPOCH, SystemTime, Duration},
 };
 
-use async_trait::async_trait;
-
 use parity_scale_codec::{Encode, Decode};
 
 use futures_util::sink::SinkExt;
@@ -21,21 +20,22 @@ type TestValidatorId = u16;
 type TestBlockId = [u8; 4];
 
 struct TestSigner(u16);
-#[async_trait]
 impl Signer for TestSigner {
   type ValidatorId = TestValidatorId;
   type Signature = [u8; 32];
 
-  async fn validator_id(&self) -> Option<TestValidatorId> {
+  fn validator_id(&self) -> impl Send + Future<Output = Option<TestValidatorId>> {
-    Some(self.0)
+    async move { Some(self.0) }
   }
 
-  async fn sign(&self, msg: &[u8]) -> [u8; 32] {
+  fn sign(&self, msg: &[u8]) -> impl Send + Future<Output = [u8; 32]> {
+    async move {
       let mut sig = [0; 32];
       sig[.. 2].copy_from_slice(&self.0.to_le_bytes());
       sig[2 .. (2 + 30.min(msg.len()))].copy_from_slice(&msg[.. 30.min(msg.len())]);
       sig
     }
+  }
 }
 
 #[derive(Clone)]
@@ -111,7 +111,6 @@ struct TestNetwork(
   Arc<RwLock<Vec<(MessageSender<Self>, SyncedBlockSender<Self>, SyncedBlockResultReceiver)>>>,
 );
 
-#[async_trait]
 impl Network for TestNetwork {
   type Db = MemDb;