docs

crates/provider/src/lib.rs

@@ -48,9 +48,9 @@ pub mod layers;
 
 mod provider;
 pub use provider::{
-    builder, Caller, EthCall, EthCallMany, EthCallManyParams, EthCallParams, FilterPollerBuilder,
-    ParamsWithBlock, Provider, ProviderCall, RootProvider, RpcWithBlock, SendableTx, SendableTxErr,
-    WalletProvider, WrappedProvider,
+    builder, Caller, DynProvider, EthCall, EthCallMany, EthCallManyParams, EthCallParams,
+    FilterPollerBuilder, ParamsWithBlock, Provider, ProviderCall, RootProvider, RpcWithBlock,
+    SendableTx, SendableTxErr, WalletProvider,
 };
 
 pub mod utils;

crates/provider/src/provider/helper.rs → crates/provider/src/provider/erased.rs

@@ -24,11 +24,13 @@ use std::{borrow::Cow, sync::Arc};
 ///
 /// This type will delegate all functions to the wrapped provider, with the exception of non
 /// object-safe functions (e.g. [`Provider::subscribe`]) which use the default trait implementation.
+///
+/// This is a convenience type for `Arc<dyn Provider<N> + 'static>`.
 #[derive(Clone)]
-pub struct WrappedProvider<N = Ethereum>(Arc<dyn Provider<N> + 'static>);
+pub struct DynProvider<N = Ethereum>(Arc<dyn Provider<N> + 'static>);
 
-impl<N: Network> WrappedProvider<N> {
-    /// Creates a new [`WrappedProvider`] by erasing the type.
+impl<N: Network> DynProvider<N> {
+    /// Creates a new [`DynProvider`] by erasing the type.
     pub fn new<P>(provider: P) -> Self
     where
         P: Provider<N> + 'static,
@@ -39,7 +41,7 @@ impl<N: Network> WrappedProvider<N> {
 
 #[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
-impl<N: Network> Provider<N> for WrappedProvider<N> {
+impl<N: Network> Provider<N> for DynProvider<N> {
     fn root(&self) -> &RootProvider<N> {
         self.0.root()
     }
@@ -53,7 +55,7 @@ impl<N: Network> Provider<N> for WrappedProvider<N> {
     }
 
     #[allow(clippy::use_self)]
-    fn wrapped(self) -> WrappedProvider<N>
+    fn erased(self) -> DynProvider<N>
     where
         Self: Sized + 'static,
     {
@@ -411,7 +413,7 @@ impl<N: Network> Provider<N> for WrappedProvider<N> {
     }
 }
 
-impl<N> std::fmt::Debug for WrappedProvider<N> {
+impl<N> std::fmt::Debug for DynProvider<N> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_tuple("WrappedProvider").field(&"<dyn Provider>").finish()
     }
@@ -426,7 +428,7 @@ mod tests {
     #[test]
     fn test_erased_provider() {
         let provider =
-            ProviderBuilder::new().on_http("http://localhost:8080".parse().unwrap()).wrapped();
+            ProviderBuilder::new().on_http("http://localhost:8080".parse().unwrap()).erased();
         assert_provider(provider);
     }
 }

crates/provider/src/provider/mod.rs

@@ -19,5 +19,5 @@ pub use wallet::WalletProvider;
 mod with_block;
 pub use with_block::{ParamsWithBlock, RpcWithBlock};
 
-mod helper;
-pub use helper::WrappedProvider;
+mod erased;
+pub use erased::DynProvider;

crates/provider/src/provider/trait.rs

@@ -27,7 +27,7 @@ use alloy_transport::TransportResult;
 use serde_json::value::RawValue;
 use std::borrow::Cow;
 
-use super::{EthCallMany, WrappedProvider};
+use super::{DynProvider, EthCallMany};
 
 /// A task that polls the provider with `eth_getFilterChanges`, returning a list of `R`.
 ///
@@ -91,23 +91,23 @@ pub trait Provider<N: Network = Ethereum>: Send + Sync {
         self.root().weak_client()
     }
 
-    /// Returns a type erased provider wrapped in Arc [`super::WrappedProvider`].
+    /// Returns a type erased provider wrapped in Arc [`super::DynProvider`].
     ///
     /// ```no_run
-    /// use alloy_provider::{Provider, ProviderBuilder, WrappedProvider};
+    /// use alloy_provider::{DynProvider, Provider, ProviderBuilder};
     /// # async fn f() {
-    /// let provider: WrappedProvider =
-    ///     ProviderBuilder::new().on_http("http://localhost:8080".parse().unwrap()).wrapped();
+    /// let provider: DynProvider =
+    ///     ProviderBuilder::new().on_http("http://localhost:8080".parse().unwrap()).erased();
     /// let block = provider.get_block_number().await.unwrap();
     ///
     /// # }
     /// ```
     #[auto_impl(keep_default_for(&, &mut, Rc, Arc, Box))]
-    fn wrapped(self) -> WrappedProvider<N>
+    fn erased(self) -> DynProvider<N>
     where
         Self: Sized + 'static,
     {
-        WrappedProvider::new(self)
+        DynProvider::new(self)
     }
 
     /// Gets the accounts in the remote node. This is usually empty unless you're using a local