From 6e38f4cfff43827ca67aa70e5a4397955c92aa6e Mon Sep 17 00:00:00 2001
From: Daniel Bloom <7810950-Daniel.Aaron.Bloom@users.noreply.gitlab.com>
Date: Wed, 16 Oct 2024 02:07:38 -0700
Subject: [PATCH] fix: remove clone from nonce

---
 crates/provider/src/builder.rs           | 40 ++++++++++++++++++++++--
 crates/provider/src/fillers/join_fill.rs |  6 ++--
 crates/provider/src/fillers/mod.rs       |  2 +-
 crates/provider/src/fillers/nonce.rs     |  8 ++---
 crates/provider/src/layers/anvil.rs      | 15 ++++++++-
 crates/provider/src/layers/cache.rs      | 15 ++++++++-
 crates/provider/src/layers/chain.rs      | 20 +++++++++++-
 7 files changed, 92 insertions(+), 14 deletions(-)

diff --git a/crates/provider/src/builder.rs b/crates/provider/src/builder.rs
index f3835650ec8..17e796e5427 100644
--- a/crates/provider/src/builder.rs
+++ b/crates/provider/src/builder.rs
@@ -21,7 +21,7 @@ pub trait ProviderLayer<P: Provider<T, N>, T: Transport + Clone, N: Network = Et
     type Provider: Provider<T, N>;
 
     /// Wrap the given provider in the layer's provider.
-    fn layer(&self, inner: P) -> Self::Provider;
+    fn layer(self, inner: P) -> Self::Provider;
 }
 
 /// An identity layer that does nothing.
@@ -57,6 +57,19 @@ where
     }
 }
 
+impl<'a, P, T, N> ProviderLayer<P, T, N> for &'a Identity
+where
+    T: Transport + Clone,
+    N: Network,
+    P: Provider<T, N>,
+{
+    type Provider = P;
+
+    fn layer(self, inner: P) -> Self::Provider {
+        inner
+    }
+}
+
 impl<P, T, N> ProviderLayer<P, T, N> for Identity
 where
     T: Transport + Clone,
@@ -65,7 +78,7 @@ where
 {
     type Provider = P;
 
-    fn layer(&self, inner: P) -> Self::Provider {
+    fn layer(self, inner: P) -> Self::Provider {
         inner
     }
 }
@@ -84,6 +97,27 @@ impl<Inner, Outer> Stack<Inner, Outer> {
     }
 }
 
+impl<'a, P, T, N, Inner, Outer> ProviderLayer<P, T, N> for &'a Stack<Inner, Outer>
+where
+    T: Transport + Clone,
+    N: Network,
+    P: Provider<T, N>,
+    &'a Inner: ProviderLayer<P, T, N>,
+    &'a Outer: ProviderLayer<<&'a Inner as ProviderLayer<P, T, N>>::Provider, T, N>,
+{
+    type Provider = <&'a Outer as ProviderLayer<
+        <&'a Inner as ProviderLayer<P, T, N>>::Provider,
+        T,
+        N,
+    >>::Provider;
+
+    fn layer(self, provider: P) -> Self::Provider {
+        let inner = self.inner.layer(provider);
+
+        self.outer.layer(inner)
+    }
+}
+
 impl<P, T, N, Inner, Outer> ProviderLayer<P, T, N> for Stack<Inner, Outer>
 where
     T: Transport + Clone,
@@ -94,7 +128,7 @@ where
 {
     type Provider = Outer::Provider;
 
-    fn layer(&self, provider: P) -> Self::Provider {
+    fn layer(self, provider: P) -> Self::Provider {
         let inner = self.inner.layer(provider);
 
         self.outer.layer(inner)
diff --git a/crates/provider/src/fillers/join_fill.rs b/crates/provider/src/fillers/join_fill.rs
index 3709e96eb3f..f0649c7e043 100644
--- a/crates/provider/src/fillers/join_fill.rs
+++ b/crates/provider/src/fillers/join_fill.rs
@@ -13,7 +13,7 @@ use futures::try_join;
 /// This struct is itself a [`TxFiller`], and can be nested to compose any number of fill layers.
 ///
 /// [`TransactionRequest`]: alloy_rpc_types_eth::TransactionRequest
-#[derive(Clone, Copy, Debug)]
+#[derive(Debug)]
 pub struct JoinFill<L, R> {
     left: L,
     right: R,
@@ -136,7 +136,7 @@ where
     N: Network,
 {
     type Provider = FillProvider<Self, P, T, N>;
-    fn layer(&self, inner: P) -> Self::Provider {
-        FillProvider::new(inner, self.clone())
+    fn layer(self, inner: P) -> Self::Provider {
+        FillProvider::new(inner, self)
     }
 }
diff --git a/crates/provider/src/fillers/mod.rs b/crates/provider/src/fillers/mod.rs
index 5d9504e4b27..9afa6c19aad 100644
--- a/crates/provider/src/fillers/mod.rs
+++ b/crates/provider/src/fillers/mod.rs
@@ -128,7 +128,7 @@ impl FillerControlFlow {
 /// - **Finished**: The filler has filled in all properties that it can fill. [`TxFiller::status`]
 ///   should return [`FillerControlFlow::Finished`].
 #[doc(alias = "TransactionFiller")]
-pub trait TxFiller<N: Network = Ethereum>: Clone + Send + Sync + std::fmt::Debug {
+pub trait TxFiller<N: Network = Ethereum>: Sized + Send + Sync + std::fmt::Debug {
     /// The properties that this filler retrieves from the RPC. to fill in the
     /// TransactionRequest.
     type Fillable: Send + Sync + 'static;
diff --git a/crates/provider/src/fillers/nonce.rs b/crates/provider/src/fillers/nonce.rs
index 63f6995d0e2..a4d35e1af4e 100644
--- a/crates/provider/src/fillers/nonce.rs
+++ b/crates/provider/src/fillers/nonce.rs
@@ -14,7 +14,7 @@ use std::sync::Arc;
 /// A trait that determines the behavior of filling nonces.
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait NonceManager: Clone + Send + Sync + std::fmt::Debug {
+pub trait NonceManager: Send + Sync + std::fmt::Debug {
     /// Get the next nonce for the given account.
     async fn get_next_nonce<P, T, N>(&self, provider: &P, address: Address) -> TransportResult<u64>
     where
@@ -29,7 +29,7 @@ pub trait NonceManager: Clone + Send + Sync + std::fmt::Debug {
 /// Unlike [`CachedNonceManager`], this implementation does not store the transaction count locally,
 /// which results in more frequent calls to the provider, but it is more resilient to chain
 /// reorganizations.
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 #[non_exhaustive]
 pub struct SimpleNonceManager;
 
@@ -54,7 +54,7 @@ impl NonceManager for SimpleNonceManager {
 ///
 /// There is also an alternative implementation [`SimpleNonceManager`] that does not store the
 /// transaction count locally.
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct CachedNonceManager {
     nonces: DashMap<Address, Arc<Mutex<u64>>>,
 }
@@ -116,7 +116,7 @@ impl NonceManager for CachedNonceManager {
 /// # Ok(())
 /// # }
 /// ```
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct NonceFiller<M: NonceManager = SimpleNonceManager> {
     nonce_manager: M,
 }
diff --git a/crates/provider/src/layers/anvil.rs b/crates/provider/src/layers/anvil.rs
index 3f512b67d17..c9099d7e354 100644
--- a/crates/provider/src/layers/anvil.rs
+++ b/crates/provider/src/layers/anvil.rs
@@ -44,6 +44,19 @@ impl From<Anvil> for AnvilLayer {
     }
 }
 
+impl<'a, P, T> ProviderLayer<P, T, Ethereum> for &'a AnvilLayer
+where
+    P: Provider<T>,
+    T: Transport + Clone,
+{
+    type Provider = AnvilProvider<P, T>;
+
+    fn layer(self, inner: P) -> Self::Provider {
+        let anvil = self.instance();
+        AnvilProvider::new(inner, anvil.clone())
+    }
+}
+
 impl<P, T> ProviderLayer<P, T, Ethereum> for AnvilLayer
 where
     P: Provider<T>,
@@ -51,7 +64,7 @@ where
 {
     type Provider = AnvilProvider<P, T>;
 
-    fn layer(&self, inner: P) -> Self::Provider {
+    fn layer(self, inner: P) -> Self::Provider {
         let anvil = self.instance();
         AnvilProvider::new(inner, anvil.clone())
     }
diff --git a/crates/provider/src/layers/cache.rs b/crates/provider/src/layers/cache.rs
index a94fdeb731d..3dfc8300064 100644
--- a/crates/provider/src/layers/cache.rs
+++ b/crates/provider/src/layers/cache.rs
@@ -45,6 +45,19 @@ impl CacheLayer {
     }
 }
 
+impl<'a, P, T, N> ProviderLayer<P, T, N> for &'a CacheLayer
+where
+    P: Provider<T, N>,
+    T: Transport + Clone,
+    N: Network,
+{
+    type Provider = CacheProvider<P, T, N>;
+
+    fn layer(self, inner: P) -> Self::Provider {
+        CacheProvider::new(inner, self.cache())
+    }
+}
+
 impl<P, T, N> ProviderLayer<P, T, N> for CacheLayer
 where
     P: Provider<T, N>,
@@ -53,7 +66,7 @@ where
 {
     type Provider = CacheProvider<P, T, N>;
 
-    fn layer(&self, inner: P) -> Self::Provider {
+    fn layer(self, inner: P) -> Self::Provider {
         CacheProvider::new(inner, self.cache())
     }
 }
diff --git a/crates/provider/src/layers/chain.rs b/crates/provider/src/layers/chain.rs
index 4f6e854068f..5198c4be8a3 100644
--- a/crates/provider/src/layers/chain.rs
+++ b/crates/provider/src/layers/chain.rs
@@ -25,6 +25,24 @@ impl From<NamedChain> for ChainLayer {
     }
 }
 
+impl<'a, P, T> ProviderLayer<P, T, Ethereum> for &'a ChainLayer
+where
+    P: Provider<T>,
+    T: Transport + Clone,
+{
+    type Provider = P;
+
+    fn layer(self, inner: P) -> Self::Provider {
+        if !inner.client().is_local() {
+            if let Some(avg_block_time) = self.average_blocktime_hint() {
+                let poll_interval = avg_block_time.mul_f32(0.6);
+                inner.client().set_poll_interval(poll_interval);
+            }
+        }
+        inner
+    }
+}
+
 impl<P, T> ProviderLayer<P, T, Ethereum> for ChainLayer
 where
     P: Provider<T>,
@@ -32,7 +50,7 @@ where
 {
     type Provider = P;
 
-    fn layer(&self, inner: P) -> Self::Provider {
+    fn layer(self, inner: P) -> Self::Provider {
         if !inner.client().is_local() {
             if let Some(avg_block_time) = self.average_blocktime_hint() {
                 let poll_interval = avg_block_time.mul_f32(0.6);