refactor: send_transaction_inner and SendableTx

alloy-rs · prestwich · Apr 8, 2024 · Mar 29, 2024 · Mar 29, 2024 · Mar 29, 2024
commit b1358ff5fd54a3e2bd6512f5774bcfd3d0483490
@@ -12,6 +12,7 @@ repository.workspace = true
 exclude.workspace = true
 
 [dependencies]
+alloy-eips.workspace = true
 alloy-json-rpc.workspace = true
 alloy-network.workspace = true
 alloy-rpc-client.workspace = true

@@ -2,6 +2,7 @@ use crate::{
     fillers::{
         ChainIdFiller, FillerControlFlow, GasFiller, JoinFill, NonceFiller, SignerLayer, TxFiller,
     },
+    provider::SendableTx,
     Provider, RootProvider,
 };
 use alloy_network::{Ethereum, Network};
@@ -46,7 +47,7 @@ where
         Ok(())
     }
 
-    fn fill(&self, _to_fill: Self::Fillable, _tx: &mut N::TransactionRequest) {
+    fn fill(&self, _to_fill: Self::Fillable, _tx: &mut SendableTx<N>) {
         // Do nothing
     }
 }

@@ -1,9 +1,12 @@
 use std::sync::{Arc, OnceLock};
 
-use alloy_network::TransactionBuilder;
+use alloy_network::{Network, TransactionBuilder};
 use alloy_transport::TransportResult;
 
-use crate::fillers::{FillerControlFlow, TxFiller};
+use crate::{
+    fillers::{FillerControlFlow, TxFiller},
+    provider::SendableTx,
+};
 
 /// A [`TxFiller`] that populates the chain ID of a transaction.
 ///
@@ -44,14 +47,11 @@ impl ChainIdFiller {
     }
 }
 
-impl TxFiller for ChainIdFiller {
+impl<N: Network> TxFiller<N> for ChainIdFiller {
     type Fillable = u64;
 
-    fn status(
-        &self,
-        tx: &<alloy_network::Ethereum as alloy_network::Network>::TransactionRequest,
-    ) -> FillerControlFlow {
-        if tx.chain_id.is_some() {
+    fn status(&self, tx: &N::TransactionRequest) -> FillerControlFlow {
+        if tx.chain_id().is_some() {
             FillerControlFlow::Finished
         } else {
             FillerControlFlow::Ready
@@ -61,10 +61,10 @@ impl TxFiller for ChainIdFiller {
     async fn prepare<P, T>(
         &self,
         provider: &P,
-        _tx: &<alloy_network::Ethereum as alloy_network::Network>::TransactionRequest,
+        _tx: &N::TransactionRequest,
     ) -> TransportResult<Self::Fillable>
     where
-        P: crate::Provider<T, alloy_network::Ethereum>,
+        P: crate::Provider<T, N>,
         T: alloy_transport::Transport + Clone,
     {
         match self.0.get().copied() {
@@ -77,11 +77,12 @@ impl TxFiller for ChainIdFiller {
         }
     }
 
-    fn fill(
-        &self,
-        fillable: Self::Fillable,
-        tx: &mut <alloy_network::Ethereum as alloy_network::Network>::TransactionRequest,
-    ) {
+    fn fill(&self, fillable: Self::Fillable, tx: &mut SendableTx<N>) {
+        let tx = match tx {
+            SendableTx::Builder(tx) => tx,
+            _ => return,
+        };
+
         if tx.chain_id().is_none() {
             tx.set_chain_id(fillable);
         }

@@ -1,5 +1,6 @@
 use crate::{
     fillers::{FillerControlFlow, TxFiller},
+    provider::SendableTx,
     utils::Eip1559Estimation,
     Provider,
 };
@@ -212,7 +213,12 @@ impl<N: Network> TxFiller<N> for GasFiller {
         }
     }
 
-    fn fill(&self, fillable: Self::Fillable, tx: &mut <N as Network>::TransactionRequest) {
+    fn fill(&self, fillable: Self::Fillable, tx: &mut SendableTx<N>) {
+        let tx = match tx {
+            SendableTx::Builder(tx) => tx,
+            _ => return,
+        };
+
         match fillable {
             GasFillable::Legacy { gas_limit, gas_price } => {
                 tx.set_gas_limit(gas_limit);

@@ -1,4 +1,6 @@
-use crate::{PendingTransactionBuilder, Provider, ProviderLayer, RootProvider};
+use crate::{
+    provider::SendableTx, PendingTransactionBuilder, Provider, ProviderLayer, RootProvider,
+};
 use alloy_network::{Ethereum, Network};
 use alloy_transport::{Transport, TransportResult};
 use async_trait::async_trait;
@@ -114,6 +116,11 @@ pub trait TxFiller<N: Network = Ethereum>: Clone + Send + Sync {
     /// properties.
     fn status(&self, tx: &N::TransactionRequest) -> FillerControlFlow;
 
+    /// Returns `true` if the filler is should continnue filling.
+    fn continue_filling(&self, tx: &SendableTx<N>) -> bool {
+        tx.as_builder().map(|tx| self.status(tx).is_ready()).unwrap_or_default()
+    }
+
     /// Returns `true` if the filler is ready to fill in the transaction request.
     fn ready(&self, tx: &N::TransactionRequest) -> bool {
         self.status(tx).is_ready()
@@ -135,12 +142,37 @@ pub trait TxFiller<N: Network = Ethereum>: Clone + Send + Sync {
         T: Transport + Clone;
 
     /// Fills in the transaction request with the fillable properties.
-    fn fill(&self, fillable: Self::Fillable, tx: &mut N::TransactionRequest);
+    fn fill(&self, fillable: Self::Fillable, tx: &mut SendableTx<N>);
+
+    /// Prepares and fills the transaction request with the fillable properties.
+    fn prepare_and_fill<P, T>(
+        &self,
+        provider: &P,
+        tx: &mut SendableTx<N>,
+    ) -> impl_future!(<Output = TransportResult<()>>)
+    where
+        P: Provider<T, N>,
+        T: Transport + Clone,
+    {
+        async move {
+            if !tx.is_builder() {
+                return Ok(());
+            }
+
+            let fillable = self.prepare(provider, tx.as_builder().unwrap()).await?;
+
+            self.fill(fillable, tx);
+
+            Ok(())
+        }
+    }
 }
 
-/// A layer that can fill in a `TransactionRequest` with additional information
-/// by joining two [`TxFiller`]s. This  struct is itself a [`TxFiller`],
-/// and can be nested to compose any number of fill layers.
+/// A layer that can fill in a [`TransactionRequest`] with additional
+/// information by joining two [`TxFiller`]s. This  struct is itself a
+/// [`TxFiller`], and can be nested to compose any number of fill layers.
+///
+/// [`TransactionRequest`]: alloy_rpc_types::TransactionRequest
 #[derive(Debug, Clone, Copy)]
 pub struct JoinFill<L, R> {
     left: L,
@@ -218,7 +250,7 @@ where
         try_join!(self.prepare_left(provider, tx), self.prepare_right(provider, tx))
     }
 
-    fn fill(&self, to_fill: Self::Fillable, tx: &mut N::TransactionRequest) {
+    fn fill(&self, to_fill: Self::Fillable, tx: &mut SendableTx<N>) {
         if let Some(to_fill) = to_fill.0 {
             self.left.fill(to_fill, tx);
         };
@@ -245,7 +277,14 @@ where
 /// A [`Provider`] that applies one or more [`TxFiller`]s.
 ///
 /// Fills arbitrary properties in a transaction request by composing multiple
-/// fill layers.
+/// fill layers. This struct should always be the outermost layer in a provider
+/// stack, and this is enforced when using [`ProviderBuilder::filler`] to
+/// construct this layer.
+///
+/// Users should NOT use this struct directly. Instead, use
+/// [`ProviderBuilder::filler`] to construct and apply it to a stack.
+///
+/// [`ProviderBuilder::filler`]: crate::ProviderBuilder::filler
 
 #[derive(Debug, Clone)]
 pub struct FillProvider<F, P, T, N>
@@ -294,14 +333,14 @@ where
         self.inner.root()
     }
 
-    async fn send_transaction(
+    async fn send_transaction_internal(
         &self,
-        mut tx: N::TransactionRequest,
+        mut tx: SendableTx<N>,
     ) -> TransportResult<PendingTransactionBuilder<'_, T, N>> {
         let mut count = 0;
-        while self.filler.status(&tx).is_ready() {
-            let fillable = self.filler.prepare(self.root(), &tx).await?;
-            self.filler.fill(fillable, &mut tx);
+
+        while self.filler.continue_filling(&tx) {
+            self.filler.prepare_and_fill(&self.inner, &mut tx).await?;
 
             count += 1;
             if count >= 20 {
@@ -312,6 +351,6 @@ where
         }
 
         // Errors in tx building happen further down the stack.
-        self.inner.send_transaction(tx).await
+        self.inner.send_transaction_internal(tx).await
     }
 }
@@ -1,5 +1,6 @@
 use crate::{
     fillers::{FillerControlFlow, TxFiller},
+    provider::SendableTx,
     Provider,
 };
 use alloy_network::{Network, TransactionBuilder};
@@ -66,7 +67,11 @@ impl<N: Network> TxFiller<N> for NonceFiller {
         self.get_next_nonce(provider, from).await
     }
 
-    fn fill(&self, nonce: Self::Fillable, tx: &mut N::TransactionRequest) {
+    fn fill(&self, nonce: Self::Fillable, tx: &mut SendableTx<N>) {
+        let tx = match tx {
+            SendableTx::Builder(tx) => tx,
+            _ => return,
+        };
         tx.set_nonce(nonce);
     }
 }

@@ -6,6 +6,7 @@ use crate::{
     utils::{self, Eip1559Estimation, EstimatorFunction},
     PendingTransactionBuilder,
 };
+use alloy_eips::eip2718::Encodable2718;
 use alloy_json_rpc::{RpcError, RpcParam, RpcReturn};
 use alloy_network::{Ethereum, Network};
 use alloy_primitives::{
@@ -46,6 +47,51 @@ use alloy_pubsub::{PubSubFrontend, Subscription};
 /// See [`PollerBuilder`] for more details.
 pub type FilterPollerBuilder<T, R> = PollerBuilder<T, (U256,), Vec<R>>;
 
+/// A transaction that will be
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SendableTx<N: Network> {
+    /// A transaction that is not yet signed.
+    Builder(N::TransactionRequest),
+    /// A transaction that is signed and fully constructed.
+    Envelope(N::TxEnvelope),
+}
+
+impl<N: Network> SendableTx<N> {
+    /// Fallible cast to an unbuilt transaction request.
+    pub fn as_mut_builder(&mut self) -> Option<&mut N::TransactionRequest> {
+        match self {
+            Self::Builder(tx) => Some(tx),
+            _ => None,
+        }
+    }
+
+    /// Fallible cast to an unbuilt transaction request.
+    pub fn as_builder(&self) -> Option<&N::TransactionRequest> {
+        match self {
+            Self::Builder(tx) => Some(tx),
+            _ => None,
+        }
+    }
+
+    /// Checks if the transaction is a builder.
+    pub fn is_builder(&self) -> bool {
+        matches!(self, Self::Builder(_))
+    }
+
+    /// Check if the transaction is an envelope.
+    pub fn is_envelope(&self) -> bool {
+        matches!(self, Self::Envelope(_))
+    }
+
+    /// Fallible cast to a built transaction envelope.
+    pub fn as_envelope(&self) -> Option<&N::TxEnvelope> {
+        match self {
+            Self::Envelope(tx) => Some(tx),
+            _ => None,
+        }
+    }
+}
+
 /// The root provider manages the RPC client and the heartbeat. It is at the
 /// base of every provider stack.
 pub struct RootProvider<T, N = Ethereum> {
@@ -619,18 +665,44 @@ pub trait Provider<T: Transport + Clone = BoxTransport, N: Network = Ethereum>:
         &self,
         tx: N::TransactionRequest,
     ) -> TransportResult<PendingTransactionBuilder<'_, T, N>> {
-        let tx_hash = self.client().request("eth_sendTransaction", (tx,)).await?;
-        Ok(PendingTransactionBuilder::new(self.root(), tx_hash))
+        self.send_transaction_internal(SendableTx::Builder(tx)).await
+    }
+
+    /// Backing logic for [`send_transaction`].
+    ///
+    /// This method allows [`ProviderLayer`] and [`TxFiller`] to bulid the
+    /// transaction and send it to the network without changing user-facing
+    /// APIs. Generally implementors should NOT override this method.
+    ///
+    /// [`send_transaction`]: Self::send_transaction
+    /// [`ProviderLayer`]: crate::ProviderLayer
+    /// [`TxFiller`]: crate::TxFiller
+    #[doc(hidden)]
+    async fn send_transaction_internal(
+        &self,
+        tx: SendableTx<N>,
+    ) -> TransportResult<PendingTransactionBuilder<'_, T, N>> {
+        match tx {
+            SendableTx::Builder(tx) => {
+                let tx_hash = self.client().request("eth_sendTransaction", (tx,)).await?;
+                Ok(PendingTransactionBuilder::new(self.root(), tx_hash))
+            }
+            SendableTx::Envelope(tx) => {
+                let mut encoded_tx = vec![];
+                tx.encode_2718(&mut encoded_tx);
+                self.send_raw_transaction(&encoded_tx).await
+            }
+        }
     }
 
     /// Broadcasts a raw transaction RLP bytes to the network.
     ///
     /// See [`send_transaction`](Self::send_transaction) for more details.
     async fn send_raw_transaction(
         &self,
-        rlp_bytes: &[u8],
+        encoded_tx: &[u8],
     ) -> TransportResult<PendingTransactionBuilder<'_, T, N>> {
-        let rlp_hex = hex::encode_prefixed(rlp_bytes);
+        let rlp_hex = hex::encode_prefixed(encoded_tx);
         let tx_hash = self.client().request("eth_sendRawTransaction", (rlp_hex,)).await?;
         Ok(PendingTransactionBuilder::new(self.root(), tx_hash))
     }