chore: touchups (#946)

crates/context/config/src/client/protocol/near.rs

@@ -151,6 +151,8 @@ impl<'a> NearTransport<'a> {
 #[derive(Debug, Error)]
 #[non_exhaustive]
 pub enum NearError {
+    #[error("unsupported protocol `{0}`")]
+    UnsupportedProtocol(String),
     #[error("unknown network `{0}`")]
     UnknownNetwork(String),
     #[error("invalid response from RPC while {operation}")]
@@ -191,6 +193,12 @@ impl Transport for NearTransport<'_> {
         request: TransportRequest<'_>,
         payload: Vec<u8>,
     ) -> Result<Vec<u8>, Self::Error> {
+        if request.protocol != Near::PROTOCOL {
+            return Err(NearError::UnsupportedProtocol(
+                request.protocol.into_owned(),
+            ));
+        }
+
         let Some(network) = self.networks.get(&request.network_id) else {
             return Err(NearError::UnknownNetwork(request.network_id.into_owned()));
         };

crates/context/config/src/client/protocol/starknet.rs

@@ -130,6 +130,8 @@ impl<'a> StarknetTransport<'a> {
 #[derive(Debug, Error)]
 #[non_exhaustive]
 pub enum StarknetError {
+    #[error("unsupported protocol: {0}")]
+    UnsupportedProtocol(String),
     #[error("unknown network `{0}`")]
     UnknownNetwork(String),
     #[error("invalid response from RPC while {operation}")]
@@ -174,6 +176,12 @@ impl Transport for StarknetTransport<'_> {
         request: TransportRequest<'_>,
         payload: Vec<u8>,
     ) -> Result<Vec<u8>, Self::Error> {
+        if request.protocol != Starknet::PROTOCOL {
+            return Err(StarknetError::UnsupportedProtocol(
+                request.protocol.into_owned(),
+            ));
+        }
+
         let Some(network) = self.networks.get(&request.network_id) else {
             return Err(StarknetError::UnknownNetwork(
                 request.network_id.into_owned(),

crates/context/config/src/client/transport.rs

@@ -18,21 +18,6 @@ pub trait Transport {
     ) -> Result<Vec<u8>, Self::Error>;
 }
 
-impl<L: Transport, R: Transport> Transport for Either<L, R> {
-    type Error = Either<L::Error, R::Error>;
-
-    async fn send(
-        &self,
-        request: TransportRequest<'_>,
-        payload: Vec<u8>,
-    ) -> Result<Vec<u8>, Self::Error> {
-        match self {
-            Self::Left(left) => left.send(request, payload).await.map_err(Either::Left),
-            Self::Right(right) => right.send(request, payload).await.map_err(Either::Right),
-        }
-    }
-}
-
 #[derive(Debug)]
 #[non_exhaustive]
 pub struct TransportRequest<'a> {
@@ -59,6 +44,34 @@ impl<'a> TransportRequest<'a> {
     }
 }
 
+#[derive(Debug, Error)]
+pub enum EitherError<L, R> {
+    #[error(transparent)]
+    Left(L),
+    #[error(transparent)]
+    Right(R),
+    #[error("unsupported protocol: {0}")]
+    UnsupportedProtocol(String),
+}
+
+impl<L: Transport, R: Transport> Transport for Either<L, R> {
+    type Error = EitherError<L::Error, R::Error>;
+
+    async fn send(
+        &self,
+        request: TransportRequest<'_>,
+        payload: Vec<u8>,
+    ) -> Result<Vec<u8>, Self::Error> {
+        match self {
+            Self::Left(left) => left.send(request, payload).await.map_err(EitherError::Left),
+            Self::Right(right) => right
+                .send(request, payload)
+                .await
+                .map_err(EitherError::Right),
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[expect(clippy::exhaustive_enums, reason = "Considered to be exhaustive")]
 pub enum Operation<'a> {
@@ -83,22 +96,12 @@ pub struct Both<L, R> {
     pub right: R,
 }
 
-#[derive(Debug, Error)]
-pub enum BothError<L, R> {
-    #[error("left error: {0}")]
-    Left(L),
-    #[error("right error: {0}")]
-    Right(R),
-    #[error("unsupported protocol: {0}")]
-    UnsupportedProtocol(String),
-}
-
 impl<L, R> Transport for Both<L, R>
 where
     L: AssociatedTransport,
     R: AssociatedTransport,
 {
-    type Error = BothError<L::Error, R::Error>;
+    type Error = EitherError<L::Error, R::Error>;
 
     async fn send(
         &self,
@@ -109,14 +112,14 @@ where
             self.left
                 .send(request, payload)
                 .await
-                .map_err(BothError::Left)
+                .map_err(EitherError::Left)
         } else if request.protocol == R::protocol() {
             self.right
                 .send(request, payload)
                 .await
-                .map_err(BothError::Right)
+                .map_err(EitherError::Right)
         } else {
-            return Err(BothError::UnsupportedProtocol(
+            return Err(EitherError::UnsupportedProtocol(
                 request.protocol.into_owned(),
             ));
         }

crates/context/src/lib.rs

@@ -1005,8 +1005,4 @@ impl ContextManager {
 
         Ok(Some(stream))
     }
-
-    pub fn is_application_blob_installed(&self, blob_id: BlobId) -> EyreResult<bool> {
-        self.blob_manager.has(blob_id)
-    }
 }

crates/network/src/stream.rs

@@ -7,7 +7,7 @@ use core::pin::Pin;
 use core::task::{Context, Poll};
 
 use eyre::{bail, Result as EyreResult};
-use futures_util::{Sink as FuturesSink, SinkExt, Stream as FuturesStream};
+use futures_util::{Sink as FuturesSink, SinkExt, Stream as FuturesStream, StreamExt};
 use libp2p::{PeerId, Stream as P2pStream, StreamProtocol};
 use tokio::io::BufStream;
 use tokio_util::codec::Framed;
@@ -43,9 +43,8 @@ impl Stream {
 impl FuturesStream for Stream {
     type Item = Result<Message<'static>, CodecError>;
 
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let inner = Pin::new(&mut self.get_mut().inner);
-        inner.poll_next(cx)
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        self.inner.poll_next_unpin(cx)
     }
 }
 

crates/network/src/stream/codec.rs

@@ -25,9 +25,9 @@ impl<'a> Message<'a> {
 }
 
 #[derive(Debug, ThisError)]
-#[error("CodecError")]
 #[non_exhaustive]
 pub enum CodecError {
+    #[error(transparent)]
     StdIo(#[from] IoError),
 }