make the errors more generic

Author: gakonst

Diff for: ethers-providers/src/lib.rs

@@ -127,7 +127,7 @@ pub use provider::{Provider, ProviderError};
 #[async_trait]
 /// Trait which must be implemented by data transports to be used with the Ethereum
 /// JSON-RPC provider.
-pub trait JsonRpcClient: Send + Sync {
+pub trait JsonRpcClient: Send + Sync + Debug {
     /// A JSON-RPC Error
     type Error: Error + Into<ProviderError>;
 
@@ -141,8 +141,8 @@ pub trait JsonRpcClient: Send + Sync {
 use ethers_core::types::*;
 
 #[async_trait]
-pub trait Middleware: Sync + Send {
-    type Error;
+pub trait Middleware: Sync + Send + Debug {
+    type Error: Debug;
 
     async fn send_transaction(
         &self,
@@ -154,40 +154,40 @@ pub trait Middleware: Sync + Send {
 
     async fn lookup_address(&self, address: Address) -> Result<String, Self::Error>;
 
-    async fn get_block_number(&self) -> Result<U64, ProviderError>;
+    async fn get_block_number(&self) -> Result<U64, Self::Error>;
 
     async fn get_block<T: Into<BlockId> + Send + Sync>(
         &self,
         block_hash_or_number: T,
-    ) -> Result<Option<Block<TxHash>>, ProviderError>;
+    ) -> Result<Option<Block<TxHash>>, Self::Error>;
 
     async fn get_block_with_txs<T: Into<BlockId> + Send + Sync>(
         &self,
         block_hash_or_number: T,
-    ) -> Result<Option<Block<Transaction>>, ProviderError>;
+    ) -> Result<Option<Block<Transaction>>, Self::Error>;
 
     async fn get_transaction_count<T: Into<NameOrAddress> + Send + Sync>(
         &self,
         from: T,
         block: Option<BlockNumber>,
-    ) -> Result<U256, ProviderError>;
+    ) -> Result<U256, Self::Error>;
 
     async fn call(
         &self,
         tx: &TransactionRequest,
         block: Option<BlockNumber>,
-    ) -> Result<Bytes, ProviderError>;
+    ) -> Result<Bytes, Self::Error>;
 
     async fn get_code<T: Into<NameOrAddress> + Send + Sync>(
         &self,
         at: T,
         block: Option<BlockNumber>,
-    ) -> Result<Bytes, ProviderError>;
+    ) -> Result<Bytes, Self::Error>;
 
     async fn get_storage_at<T: Into<NameOrAddress> + Send + Sync>(
         &self,
         from: T,
         location: H256,
         block: Option<BlockNumber>,
-    ) -> Result<H256, ProviderError>;
+    ) -> Result<H256, Self::Error>;
 }

Diff for: ethers-providers/src/provider.rs

@@ -47,21 +47,30 @@ pub struct Provider<P>(P, Option<Duration>);
 #[derive(Clone, Debug)]
 pub struct EnsProvider<M>(M, Option<Address>);
 
+#[derive(Debug, Error)]
+pub enum EnsError<M: Middleware> {
+    #[error("MiddlewareError: {0:?}")]
+    MiddlewareError(M::Error),
+    #[error(transparent)]
+    ProviderError(#[from] ProviderError),
+}
+
 // The ENS Middleware overrides functions involving from/to and forwards everything
 // else to the inner layer
 #[async_trait]
-impl<M: Middleware<Error = ProviderError>> Middleware for EnsProvider<M> {
-    type Error = ProviderError;
+impl<M: Middleware> Middleware for EnsProvider<M> {
+    type Error = EnsError<M>;
 
     /// Returns the address that the `ens_name` resolves to (or None if not configured).
     ///
     /// # Panics
     ///
     /// If the bytes returned from the ENS registrar/resolver cannot be interpreted as
     /// an address. This should theoretically never happen.
-    async fn resolve_name(&self, ens_name: &str) -> Result<Address, ProviderError> {
-        self.query_resolver(ParamType::Address, ens_name, ens::ADDR_SELECTOR)
-            .await
+    async fn resolve_name(&self, ens_name: &str) -> Result<Address, Self::Error> {
+        Ok(self
+            .query_resolver(ParamType::Address, ens_name, ens::ADDR_SELECTOR)
+            .await?)
     }
 
     ////// Ethereum Naming Service
@@ -76,10 +85,11 @@ impl<M: Middleware<Error = ProviderError>> Middleware for EnsProvider<M> {
     ///
     /// If the bytes returned from the ENS registrar/resolver cannot be interpreted as
     /// a string. This should theoretically never happen.
-    async fn lookup_address(&self, address: Address) -> Result<String, ProviderError> {
+    async fn lookup_address(&self, address: Address) -> Result<String, Self::Error> {
         let ens_name = ens::reverse_address(address);
-        self.query_resolver(ParamType::String, &ens_name, ens::NAME_SELECTOR)
-            .await
+        Ok(self
+            .query_resolver(ParamType::String, &ens_name, ens::NAME_SELECTOR)
+            .await?)
     }
 
     /// Sends the transaction to the entire Ethereum network and returns the transaction's hash
@@ -88,7 +98,7 @@ impl<M: Middleware<Error = ProviderError>> Middleware for EnsProvider<M> {
         &self,
         mut tx: TransactionRequest,
         block: Option<BlockNumber>,
-    ) -> Result<TxHash, ProviderError> {
+    ) -> Result<TxHash, Self::Error> {
         if let Some(ref to) = tx.to {
             if let NameOrAddress::Name(ens_name) = to {
                 // resolve to an address
@@ -99,20 +109,26 @@ impl<M: Middleware<Error = ProviderError>> Middleware for EnsProvider<M> {
             }
         }
 
-        self.0.send_transaction(tx, block).await
+        self.0
+            .send_transaction(tx, block)
+            .await
+            .map_err(EnsError::MiddlewareError)
     }
 
     /// Returns the nonce of the address
     async fn get_transaction_count<T: Into<NameOrAddress> + Send + Sync>(
         &self,
         from: T,
         block: Option<BlockNumber>,
-    ) -> Result<U256, ProviderError> {
+    ) -> Result<U256, Self::Error> {
         let from = match from.into() {
             NameOrAddress::Name(ens_name) => self.resolve_name(&ens_name).await?,
             NameOrAddress::Address(addr) => addr,
         };
-        self.0.get_transaction_count(from, block).await
+        self.0
+            .get_transaction_count(from, block)
+            .await
+            .map_err(EnsError::MiddlewareError)
     }
 
     /// Get the storage of an address for a particular slot location
@@ -121,54 +137,72 @@ impl<M: Middleware<Error = ProviderError>> Middleware for EnsProvider<M> {
         from: T,
         location: H256,
         block: Option<BlockNumber>,
-    ) -> Result<H256, ProviderError> {
+    ) -> Result<H256, Self::Error> {
         let from = match from.into() {
             NameOrAddress::Name(ens_name) => self.resolve_name(&ens_name).await?,
             NameOrAddress::Address(addr) => addr,
         };
-        self.0.get_storage_at(from, location, block).await
+        self.0
+            .get_storage_at(from, location, block)
+            .await
+            .map_err(EnsError::MiddlewareError)
     }
 
     /// Returns the deployed code at a given address
     async fn get_code<T: Into<NameOrAddress> + Send + Sync>(
         &self,
         at: T,
         block: Option<BlockNumber>,
-    ) -> Result<Bytes, ProviderError> {
+    ) -> Result<Bytes, Self::Error> {
         let at = match at.into() {
             NameOrAddress::Name(ens_name) => self.resolve_name(&ens_name).await?,
             NameOrAddress::Address(addr) => addr,
         };
-        self.0.get_code(at, block).await
+        self.0
+            .get_code(at, block)
+            .await
+            .map_err(EnsError::MiddlewareError)
     }
 
     /// Gets the latest block number via the `eth_BlockNumber` API
-    async fn get_block_number(&self) -> Result<U64, ProviderError> {
-        self.0.get_block_number().await
+    async fn get_block_number(&self) -> Result<U64, Self::Error> {
+        self.0
+            .get_block_number()
+            .await
+            .map_err(EnsError::MiddlewareError)
     }
 
     /// Gets the block at `block_hash_or_number` (transaction hashes only)
     async fn get_block<T: Into<BlockId> + Send + Sync>(
         &self,
         block_hash_or_number: T,
-    ) -> Result<Option<Block<TxHash>>, ProviderError> {
-        self.0.get_block(block_hash_or_number).await
+    ) -> Result<Option<Block<TxHash>>, Self::Error> {
+        self.0
+            .get_block(block_hash_or_number)
+            .await
+            .map_err(EnsError::MiddlewareError)
     }
 
     /// Gets the block at `block_hash_or_number` (full transactions included)
     async fn get_block_with_txs<T: Into<BlockId> + Send + Sync>(
         &self,
         block_hash_or_number: T,
-    ) -> Result<Option<Block<Transaction>>, ProviderError> {
-        self.0.get_block_with_txs(block_hash_or_number).await
+    ) -> Result<Option<Block<Transaction>>, Self::Error> {
+        self.0
+            .get_block_with_txs(block_hash_or_number)
+            .await
+            .map_err(EnsError::MiddlewareError)
     }
 
     async fn call(
         &self,
         tx: &TransactionRequest,
         block: Option<BlockNumber>,
-    ) -> Result<Bytes, ProviderError> {
-        self.0.call(tx, block).await
+    ) -> Result<Bytes, Self::Error> {
+        self.0
+            .call(tx, block)
+            .await
+            .map_err(EnsError::MiddlewareError)
     }
 }
 
@@ -204,7 +238,7 @@ impl<M: Middleware> EnsProvider<M> {
         param: ParamType,
         ens_name: &str,
         selector: Selector,
-    ) -> Result<T, ProviderError> {
+    ) -> Result<T, EnsError<M>> {
         // Get the ENS address, prioritize the local override variable
         let ens_addr = self.1.unwrap_or(ens::ENS_ADDRESS);
 
@@ -213,18 +247,20 @@ impl<M: Middleware> EnsProvider<M> {
         let data = self
             .0
             .call(&ens::get_resolver(ens_addr, ens_name), None)
-            .await?;
+            .await
+            .map_err(EnsError::MiddlewareError)?;
 
         let resolver_address: Address = decode_bytes(ParamType::Address, data);
         if resolver_address == Address::zero() {
-            return Err(ProviderError::EnsError(ens_name.to_owned()));
+            return Err(ProviderError::EnsError(ens_name.to_owned()).into());
         }
 
         // resolve
         let data = self
             .0
             .call(&ens::resolve(resolver_address, selector, ens_name), None)
-            .await?;
+            .await
+            .map_err(EnsError::MiddlewareError)?;
 
         Ok(decode_bytes(param, data))
     }
@@ -239,9 +275,9 @@ impl<P: JsonRpcClient> Middleware for Provider<P> {
     /// This will consume gas from the account that signed the transaction.
     async fn send_transaction(
         &self,
-        mut tx: TransactionRequest,
-        block: Option<BlockNumber>,
-    ) -> Result<TxHash, ProviderError> {
+        tx: TransactionRequest,
+        _: Option<BlockNumber>,
+    ) -> Result<TxHash, Self::Error> {
         Ok(self
             .0
             .request("eth_sendTransaction", [tx])
@@ -254,7 +290,7 @@ impl<P: JsonRpcClient> Middleware for Provider<P> {
     // Functions for querying the state of the blockchain
 
     /// Gets the latest block number via the `eth_BlockNumber` API
-    async fn get_block_number(&self) -> Result<U64, ProviderError> {
+    async fn get_block_number(&self) -> Result<U64, Self::Error> {
         Ok(self
             .0
             .request("eth_blockNumber", ())
@@ -266,7 +302,7 @@ impl<P: JsonRpcClient> Middleware for Provider<P> {
     async fn get_block<T: Into<BlockId> + Send + Sync>(
         &self,
         block_hash_or_number: T,
-    ) -> Result<Option<Block<TxHash>>, ProviderError> {
+    ) -> Result<Option<Block<TxHash>>, Self::Error> {
         Ok(self
             .get_block_gen(block_hash_or_number.into(), false)
             .await?)
@@ -276,7 +312,7 @@ impl<P: JsonRpcClient> Middleware for Provider<P> {
     async fn get_block_with_txs<T: Into<BlockId> + Send + Sync>(
         &self,
         block_hash_or_number: T,
-    ) -> Result<Option<Block<Transaction>>, ProviderError> {
+    ) -> Result<Option<Block<Transaction>>, Self::Error> {
         Ok(self
             .get_block_gen(block_hash_or_number.into(), true)
             .await?)
@@ -287,7 +323,7 @@ impl<P: JsonRpcClient> Middleware for Provider<P> {
         &self,
         from: T,
         block: Option<BlockNumber>,
-    ) -> Result<U256, ProviderError> {
+    ) -> Result<U256, Self::Error> {
         let from = utils::serialize(&from.into());
         let block = utils::serialize(&block.unwrap_or(BlockNumber::Latest));
         Ok(self
@@ -303,7 +339,7 @@ impl<P: JsonRpcClient> Middleware for Provider<P> {
         &self,
         tx: &TransactionRequest,
         block: Option<BlockNumber>,
-    ) -> Result<Bytes, ProviderError> {
+    ) -> Result<Bytes, Self::Error> {
         let tx = utils::serialize(tx);
         let block = utils::serialize(&block.unwrap_or(BlockNumber::Latest));
         Ok(self
@@ -319,7 +355,7 @@ impl<P: JsonRpcClient> Middleware for Provider<P> {
         from: T,
         location: H256,
         block: Option<BlockNumber>,
-    ) -> Result<H256, ProviderError> {
+    ) -> Result<H256, Self::Error> {
         let from = utils::serialize(&from.into());
         let location = utils::serialize(&location);
         let block = utils::serialize(&block.unwrap_or(BlockNumber::Latest));
@@ -335,7 +371,7 @@ impl<P: JsonRpcClient> Middleware for Provider<P> {
         &self,
         at: T,
         block: Option<BlockNumber>,
-    ) -> Result<Bytes, ProviderError> {
+    ) -> Result<Bytes, Self::Error> {
         let at = utils::serialize(&at.into());
         let block = utils::serialize(&block.unwrap_or(BlockNumber::Latest));
         Ok(self
@@ -345,11 +381,11 @@ impl<P: JsonRpcClient> Middleware for Provider<P> {
             .map_err(Into::into)?)
     }
 
-    async fn resolve_name(&self, ens_name: &str) -> Result<Address, Self::Error> {
+    async fn resolve_name(&self, _: &str) -> Result<Address, Self::Error> {
         unimplemented!("No ENS at the inner layer of the onion");
     }
 
-    async fn lookup_address(&self, address: Address) -> Result<String, Self::Error> {
+    async fn lookup_address(&self, _: Address) -> Result<String, Self::Error> {
         unimplemented!("No ENS at the inner layer of the onion");
     }
 }

Diff for: ethers-providers/src/transports/ws.rs

@@ -107,6 +107,12 @@ impl Provider<WebSocketStream<MaybeTlsStream>> {
     }
 }
 
+impl<S> std::fmt::Debug for Provider<S> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("WebSockets Provider").finish()
+    }
+}
+
 impl<S> Provider<S>
 where
     S: Send