chore: bump alloy 0.11 (#14122)

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>

bin/reth-bench/src/authenticated_transport.rs

@@ -7,7 +7,7 @@ use alloy_json_rpc::{RequestPacket, ResponsePacket};
 use alloy_pubsub::{PubSubConnect, PubSubFrontend};
 use alloy_rpc_types_engine::{Claims, JwtSecret};
 use alloy_transport::{
-    utils::guess_local_url, Authorization, Pbf, TransportConnect, TransportError,
+    utils::guess_local_url, Authorization, BoxTransport, TransportConnect, TransportError,
     TransportErrorKind, TransportFut,
 };
 use alloy_transport_http::{reqwest::Url, Http, ReqwestTransport};
@@ -175,19 +175,9 @@ impl AuthenticatedTransport {
             }
 
             match inner_and_claims.0 {
-                InnerTransport::Http(ref http) => {
-                    let mut http = http;
-                    http.call(req)
-                }
-                InnerTransport::Ws(ref ws) => {
-                    let mut ws = ws;
-                    ws.call(req)
-                }
-                InnerTransport::Ipc(ref ipc) => {
-                    let mut ipc = ipc;
-                    // we don't need to recreate the client for IPC
-                    ipc.call(req)
-                }
+                InnerTransport::Http(ref mut http) => http.call(req),
+                InnerTransport::Ws(ref mut ws) => ws.call(req),
+                InnerTransport::Ipc(ref mut ipc) => ipc.call(req),
             }
             .await
         })
@@ -221,21 +211,21 @@ impl AuthenticatedTransportConnect {
 }
 
 impl TransportConnect for AuthenticatedTransportConnect {
-    type Transport = AuthenticatedTransport;
-
     fn is_local(&self) -> bool {
         guess_local_url(&self.url)
     }
 
-    fn get_transport<'a: 'b, 'b>(&'a self) -> Pbf<'b, Self::Transport, TransportError> {
-        AuthenticatedTransport::connect(self.url.clone(), self.jwt)
-            .map(|res| match res {
-                Ok(transport) => Ok(transport),
-                Err(err) => {
-                    Err(TransportError::Transport(TransportErrorKind::Custom(Box::new(err))))
-                }
-            })
-            .boxed()
+    async fn get_transport(&self) -> Result<BoxTransport, TransportError> {
+        Ok(BoxTransport::new(
+            AuthenticatedTransport::connect(self.url.clone(), self.jwt)
+                .map(|res| match res {
+                    Ok(transport) => Ok(transport),
+                    Err(err) => {
+                        Err(TransportError::Transport(TransportErrorKind::Custom(Box::new(err))))
+                    }
+                })
+                .await?,
+        ))
     }
 }
 

bin/reth-bench/src/bench/context.rs

@@ -3,12 +3,10 @@
 
 use crate::{authenticated_transport::AuthenticatedTransportConnect, bench_mode::BenchMode};
 use alloy_eips::BlockNumberOrTag;
-use alloy_provider::{network::AnyNetwork, Provider, ProviderBuilder, RootProvider};
+use alloy_provider::{network::AnyNetwork, Provider, RootProvider};
 use alloy_rpc_client::ClientBuilder;
 use alloy_rpc_types_engine::JwtSecret;
-use alloy_transport::BoxTransport;
-use alloy_transport_http::Http;
-use reqwest::{Client, Url};
+use reqwest::Url;
 use reth_node_core::args::BenchmarkArgs;
 use tracing::info;
 
@@ -19,9 +17,9 @@ use tracing::info;
 /// range of blocks, and the next block to fetch.
 pub(crate) struct BenchContext {
     /// The auth provider is used for engine API queries.
-    pub(crate) auth_provider: RootProvider<BoxTransport, AnyNetwork>,
+    pub(crate) auth_provider: RootProvider<AnyNetwork>,
     /// The block provider is used for block queries.
-    pub(crate) block_provider: RootProvider<Http<Client>, AnyNetwork>,
+    pub(crate) block_provider: RootProvider<AnyNetwork>,
     /// The benchmark mode, which defines whether the benchmark should run for a closed or open
     /// range of blocks.
     pub(crate) benchmark_mode: BenchMode,
@@ -43,8 +41,8 @@ impl BenchContext {
         }
 
         // set up alloy client for blocks
-        let block_provider =
-            ProviderBuilder::new().network::<AnyNetwork>().on_http(rpc_url.parse()?);
+        let client = ClientBuilder::default().http(rpc_url.parse()?);
+        let block_provider = RootProvider::<AnyNetwork>::new(client);
 
         // If neither `--from` nor `--to` are provided, we will run the benchmark continuously,
         // starting at the latest block.
@@ -68,8 +66,8 @@ impl BenchContext {
         // construct the authed transport
         info!("Connecting to Engine RPC at {} for replay", auth_url);
         let auth_transport = AuthenticatedTransportConnect::new(auth_url, jwt);
-        let client = ClientBuilder::default().connect_boxed(auth_transport).await?;
-        let auth_provider = RootProvider::<_, AnyNetwork>::new(client);
+        let client = ClientBuilder::default().connect_with(auth_transport).await?;
+        let auth_provider = RootProvider::<AnyNetwork>::new(client);
 
         let first_block = match benchmark_mode {
             BenchMode::Continuous => {

bin/reth-bench/src/valid_payload.rs

@@ -8,13 +8,13 @@ use alloy_rpc_types_engine::{
     ExecutionPayload, ExecutionPayloadInputV2, ExecutionPayloadV1, ExecutionPayloadV3,
     ForkchoiceState, ForkchoiceUpdated, PayloadAttributes, PayloadStatus,
 };
-use alloy_transport::{Transport, TransportResult};
+use alloy_transport::TransportResult;
 use reth_node_api::EngineApiMessageVersion;
 use tracing::error;
 
 /// An extension trait for providers that implement the engine API, to wait for a VALID response.
 #[async_trait::async_trait]
-pub trait EngineApiValidWaitExt<N, T>: Send + Sync {
+pub trait EngineApiValidWaitExt<N>: Send + Sync {
     /// Calls `engine_newPayloadV1` with the given [ExecutionPayloadV1], and waits until the
     /// response is VALID.
     async fn new_payload_v1_wait(
@@ -64,11 +64,10 @@ pub trait EngineApiValidWaitExt<N, T>: Send + Sync {
 }
 
 #[async_trait::async_trait]
-impl<T, N, P> EngineApiValidWaitExt<N, T> for P
+impl<N, P> EngineApiValidWaitExt<N> for P
 where
     N: Network,
-    T: Transport + Clone,
-    P: EngineApi<N, T>,
+    P: EngineApi<N>,
 {
     async fn new_payload_v1_wait(
         &self,
@@ -208,7 +207,7 @@ where
 ///
 /// # Panics
 /// If the given payload is a V3 payload, but a parent beacon block root is provided as `None`.
-pub(crate) async fn call_new_payload<N, T, P: EngineApiValidWaitExt<N, T>>(
+pub(crate) async fn call_new_payload<N, P: EngineApiValidWaitExt<N>>(
     provider: P,
     payload: ExecutionPayload,
     parent_beacon_block_root: Option<B256>,
@@ -246,7 +245,7 @@ pub(crate) async fn call_new_payload<N, T, P: EngineApiValidWaitExt<N, T>>(
 /// Calls the correct `engine_forkchoiceUpdated` method depending on the given
 /// `EngineApiMessageVersion`, using the provided forkchoice state and payload attributes for the
 /// actual engine api message call.
-pub(crate) async fn call_forkchoice_updated<N, T, P: EngineApiValidWaitExt<N, T>>(
+pub(crate) async fn call_forkchoice_updated<N, P: EngineApiValidWaitExt<N>>(
     provider: P,
     message_version: EngineApiMessageVersion,
     forkchoice_state: ForkchoiceState,