feat: iterate on transport generalization for recursive declaration (#…

…991)
calimero-network · Nov 27, 2024 · 93d8425 · 93d8425
1 parent 79c9c00
commit 93d8425
Show file tree

Hide file tree

Showing 12 changed files with 299 additions and 208 deletions.
diff --git a/crates/context/config/src/client.rs b/crates/context/config/src/client.rs
@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 use std::fmt::Debug;
+use std::ops::Deref;
 
 use either::Either;
 use env::Method;
@@ -10,10 +11,11 @@ pub mod env;
 pub mod protocol;
 pub mod relayer;
 pub mod transport;
+pub mod utils;
 
 use config::{ClientConfig, ClientSelectedSigner, Credentials};
 use protocol::{near, starknet, Protocol};
-use transport::{Both, Transport, TransportRequest};
+use transport::{Both, Transport, TransportArguments, TransportRequest, UnsupportedProtocol};
 
 pub type AnyTransport = Either<
     relayer::RelayerTransport,
@@ -110,17 +112,43 @@ pub enum ClientError<T: Transport> {
     Transport(T::Error),
     #[error("codec error: {0}")]
     Codec(#[from] eyre::Report),
-    #[error("unsupported protocol: {0}")]
-    UnsupportedProtocol(String),
+    #[error(
+        "unsupported protocol: `{found}`, expected {}",
+        utils::humanize_iter(expected.deref())
+    )]
+    UnsupportedProtocol {
+        found: String,
+        expected: Cow<'static, [Cow<'static, str>]>,
+    },
+}
+
+impl<'a, T: Transport> From<UnsupportedProtocol<'a>> for ClientError<T> {
+    fn from(err: UnsupportedProtocol<'a>) -> Self {
+        Self::UnsupportedProtocol {
+            found: err.args.protocol.into_owned(),
+            expected: err.expected,
+        }
+    }
 }
 
 impl<T: Transport> Client<T> {
     async fn send(
         &self,
+        protocol: Cow<'_, str>,
         request: TransportRequest<'_>,
         payload: Vec<u8>,
-    ) -> Result<Vec<u8>, T::Error> {
-        self.transport.send(request, payload).await
+    ) -> Result<Vec<u8>, ClientError<T>> {
+        let res: Result<_, _> = self
+            .transport
+            .try_send(TransportArguments {
+                protocol,
+                request,
+                payload,
+            })
+            .await
+            .into();
+
+        res?.map_err(ClientError::Transport)
     }
 
     pub fn query<'a, E: Environment<'a, T>>(
@@ -182,17 +210,15 @@ impl<'a, T: Transport> CallClient<'a, T> {
         };
 
         let request = TransportRequest {
-            protocol: Cow::Borrowed(&self.protocol),
             network_id: Cow::Borrowed(&self.network_id),
             contract_id: Cow::Borrowed(&self.contract_id),
             operation,
         };
 
         let response = self
             .client
-            .send(request, payload)
-            .await
-            .map_err(ClientError::Transport)?;
+            .send(self.protocol.as_ref().into(), request, payload)
+            .await?;
 
         M::decode(response).map_err(ClientError::Codec)
     }

diff --git a/crates/context/config/src/client/env.rs b/crates/context/config/src/client/env.rs
@@ -23,7 +23,7 @@ mod utils {
     use crate::client::{CallClient, ClientError, Operation};
 
     // todo! when crates are broken up, appropriately locate this
-    pub(super) async fn send_near_or_starknet<M, R, T: Transport>(
+    pub(super) async fn send<M, R, T: Transport>(
         client: &CallClient<'_, T>,
         params: Operation<M>,
     ) -> Result<R, ClientError<T>>
@@ -34,9 +34,10 @@ mod utils {
         match &*client.protocol {
             Near::PROTOCOL => client.send::<Near, _>(params).await,
             Starknet::PROTOCOL => client.send::<Starknet, _>(params).await,
-            unsupported_protocol => Err(ClientError::UnsupportedProtocol(
-                unsupported_protocol.to_owned(),
-            )),
+            unsupported_protocol => Err(ClientError::UnsupportedProtocol {
+                found: unsupported_protocol.to_owned(),
+                expected: vec![Near::PROTOCOL.into(), Starknet::PROTOCOL.into()].into(),
+            }),
         }
     }
 }
diff --git a/crates/context/config/src/client/env/config/mutate.rs b/crates/context/config/src/client/env/config/mutate.rs
@@ -136,6 +136,6 @@ impl<'a, T: Transport + Debug> ContextConfigMutateRequest<'a, T> {
             kind: self.kind,
         };
 
-        utils::send_near_or_starknet(&self.client, Operation::Write(request)).await
+        utils::send(&self.client, Operation::Write(request)).await
     }
 }
diff --git a/crates/context/config/src/client/env/config/query.rs b/crates/context/config/src/client/env/config/query.rs
@@ -28,7 +28,7 @@ impl<'a, T: Transport> ContextConfigQuery<'a, T> {
             context_id: Repr::new(context_id),
         };
 
-        utils::send_near_or_starknet(&self.client, Operation::Read(params)).await
+        utils::send(&self.client, Operation::Read(params)).await
     }
 
     pub async fn application_revision(
@@ -39,7 +39,7 @@ impl<'a, T: Transport> ContextConfigQuery<'a, T> {
             context_id: Repr::new(context_id),
         };
 
-        utils::send_near_or_starknet(&self.client, Operation::Read(params)).await
+        utils::send(&self.client, Operation::Read(params)).await
     }
 
     pub async fn members(
@@ -54,7 +54,7 @@ impl<'a, T: Transport> ContextConfigQuery<'a, T> {
             length,
         };
 
-        utils::send_near_or_starknet(&self.client, Operation::Read(params)).await
+        utils::send(&self.client, Operation::Read(params)).await
     }
 
     pub async fn has_member(
@@ -67,7 +67,7 @@ impl<'a, T: Transport> ContextConfigQuery<'a, T> {
             identity: Repr::new(identity),
         };
 
-        utils::send_near_or_starknet(&self.client, Operation::Read(params)).await
+        utils::send(&self.client, Operation::Read(params)).await
     }
 
     pub async fn members_revision(
@@ -78,7 +78,7 @@ impl<'a, T: Transport> ContextConfigQuery<'a, T> {
             context_id: Repr::new(context_id),
         };
 
-        utils::send_near_or_starknet(&self.client, Operation::Read(params)).await
+        utils::send(&self.client, Operation::Read(params)).await
     }
 
     pub async fn privileges(
@@ -88,7 +88,7 @@ impl<'a, T: Transport> ContextConfigQuery<'a, T> {
     ) -> Result<BTreeMap<SignerId, Vec<Capability>>, ClientError<T>> {
         let params = privileges::PrivilegesRequest::new(context_id, identities);
 
-        utils::send_near_or_starknet(&self.client, Operation::Read(params)).await
+        utils::send(&self.client, Operation::Read(params)).await
     }
 
     pub async fn get_proxy_contract(
@@ -99,6 +99,6 @@ impl<'a, T: Transport> ContextConfigQuery<'a, T> {
             context_id: Repr::new(context_id),
         };
 
-        utils::send_near_or_starknet(&self.client, Operation::Read(params)).await
+        utils::send(&self.client, Operation::Read(params)).await
     }
 }
diff --git a/crates/context/config/src/client/env/proxy/mutate.rs b/crates/context/config/src/client/env/proxy/mutate.rs
@@ -128,6 +128,6 @@ impl<'a, T: Transport> ContextProxyMutateRequest<'a, T> {
             raw_request: self.raw_request,
         };
 
-        utils::send_near_or_starknet(&self.client, Operation::Write(request)).await
+        utils::send(&self.client, Operation::Write(request)).await
     }
 }
diff --git a/crates/context/config/src/client/env/proxy/query.rs b/crates/context/config/src/client/env/proxy/query.rs
@@ -32,7 +32,7 @@ impl<'a, T: Transport> ContextProxyQuery<'a, T> {
             offset,
             length: limit,
         };
-        utils::send_near_or_starknet(&self.client, Operation::Read(params)).await
+        utils::send(&self.client, Operation::Read(params)).await
     }
 
     pub async fn proposal(
@@ -43,13 +43,13 @@ impl<'a, T: Transport> ContextProxyQuery<'a, T> {
             proposal_id: Repr::new(proposal_id),
         };
 
-        utils::send_near_or_starknet(&self.client, Operation::Read(params)).await
+        utils::send(&self.client, Operation::Read(params)).await
     }
 
     pub async fn get_number_of_active_proposals(&self) -> Result<u16, ClientError<T>> {
         let params = ActiveProposalRequest;
 
-        utils::send_near_or_starknet(&self.client, Operation::Read(params)).await
+        utils::send(&self.client, Operation::Read(params)).await
     }
 
     pub async fn get_number_of_proposal_approvals(
@@ -60,7 +60,7 @@ impl<'a, T: Transport> ContextProxyQuery<'a, T> {
             proposal_id: Repr::new(proposal_id),
         };
 
-        utils::send_near_or_starknet(&self.client, Operation::Read(params)).await
+        utils::send(&self.client, Operation::Read(params)).await
     }
 
     pub async fn get_proposal_approvers(
@@ -71,6 +71,6 @@ impl<'a, T: Transport> ContextProxyQuery<'a, T> {
             proposal_id: Repr::new(proposal_id),
         };
 
-        utils::send_near_or_starknet(&self.client, Operation::Read(params)).await
+        utils::send(&self.client, Operation::Read(params)).await
     }
 }
diff --git a/crates/context/config/src/client/protocol/near.rs b/crates/context/config/src/client/protocol/near.rs
@@ -29,7 +29,7 @@ use url::Url;
 
 use super::Protocol;
 use crate::client::transport::{
-    AssociatedTransport, Operation, Transport, TransportLike, TransportRequest,
+    AssociatedTransport, Operation, ProtocolTransport, TransportRequest,
 };
 
 #[derive(Copy, Clone, Debug)]
@@ -43,22 +43,6 @@ impl AssociatedTransport for NearTransport<'_> {
     type Protocol = Near;
 }
 
-impl TransportLike for NearTransport<'_> {
-    type Error = NearError;
-
-    async fn try_send(
-        &self,
-        request: TransportRequest<'_>,
-        payload: &Vec<u8>,
-    ) -> Option<Result<Vec<u8>, Self::Error>> {
-        if request.protocol == "near" {
-            Some(self.send(request, payload.to_vec()).await)
-        } else {
-            None
-        }
-    }
-}
-
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(try_from = "serde_creds::Credentials")]
 pub struct Credentials {
@@ -172,8 +156,6 @@ 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}")]
@@ -206,20 +188,14 @@ pub enum ErrorOperation {
     FetchAccount,
 }
 
-impl Transport for NearTransport<'_> {
+impl ProtocolTransport for NearTransport<'_> {
     type Error = NearError;
 
     async fn send(
         &self,
         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()));
         };

diff --git a/crates/context/config/src/client/protocol/starknet.rs b/crates/context/config/src/client/protocol/starknet.rs
@@ -19,7 +19,7 @@ use thiserror::Error;
 use super::Protocol;
 use crate::client::env::proxy::starknet::StarknetProposalWithApprovals;
 use crate::client::transport::{
-    AssociatedTransport, Operation, Transport, TransportLike, TransportRequest,
+    AssociatedTransport, Operation, ProtocolTransport, TransportRequest,
 };
 
 #[derive(Copy, Clone, Debug)]
@@ -33,22 +33,6 @@ impl AssociatedTransport for StarknetTransport<'_> {
     type Protocol = Starknet;
 }
 
-impl TransportLike for StarknetTransport<'_> {
-    type Error = StarknetError;
-
-    async fn try_send(
-        &self,
-        request: TransportRequest<'_>,
-        payload: &Vec<u8>,
-    ) -> Option<Result<Vec<u8>, Self::Error>> {
-        if request.protocol == "near" {
-            Some(self.send(request, payload.to_vec()).await)
-        } else {
-            None
-        }
-    }
-}
-
 #[derive(Copy, Clone, Debug, Deserialize, Serialize)]
 #[serde(try_from = "serde_creds::Credentials")]
 pub struct Credentials {
@@ -153,8 +137,6 @@ 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}")]
@@ -191,20 +173,14 @@ pub enum ErrorOperation {
     FetchNonce,
 }
 
-impl Transport for StarknetTransport<'_> {
+impl ProtocolTransport for StarknetTransport<'_> {
     type Error = StarknetError;
 
     async fn send(
         &self,
         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(),