Better debug logging

ethers-core/src/types/address_or_bytes.rs

@@ -1,6 +1,7 @@
 use crate::types::{Address, Bytes};
+use std::fmt::Debug;
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq)]
 /// A type that can either be an `Address` or `Bytes`.
 pub enum AddressOrBytes {
     /// An address type
@@ -9,6 +10,15 @@ pub enum AddressOrBytes {
     Bytes(Bytes),
 }
 
+impl Debug for AddressOrBytes {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AddressOrBytes::Address(addr) => write!(f, "{addr:?}"),
+            AddressOrBytes::Bytes(bytes) => write!(f, "0x{}", hex::encode(bytes)),
+        }
+    }
+}
+
 impl From<Address> for AddressOrBytes {
     fn from(s: Address) -> Self {
         Self::Address(s)

ethers-core/src/types/ens.rs

@@ -1,17 +1,26 @@
 use crate::types::Address;
 use rlp::{Decodable, Encodable, RlpStream};
 use serde::{ser::Error as SerializationError, Deserialize, Deserializer, Serialize, Serializer};
-use std::{cmp::Ordering, convert::Infallible, str::FromStr};
+use std::{cmp::Ordering, convert::Infallible, fmt::Debug, str::FromStr};
 
 /// ENS name or Ethereum Address. Not RLP encoded/serialized if it's a name.
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq)]
 pub enum NameOrAddress {
     /// An ENS Name (format does not get checked)
     Name(String),
     /// An Ethereum Address
     Address(Address),
 }
 
+impl Debug for NameOrAddress {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            NameOrAddress::Name(name) => write!(f, "\"{name}\""),
+            NameOrAddress::Address(addr) => write!(f, "{addr:?}"),
+        }
+    }
+}
+
 // Only RLP encode the Address variant since it doesn't make sense to ever RLP encode
 // an ENS name
 impl Encodable for &NameOrAddress {

ethers-middleware/src/nonce_manager.rs

@@ -1,17 +1,20 @@
 use async_trait::async_trait;
 use ethers_core::types::{transaction::eip2718::TypedTransaction, *};
 use ethers_providers::{FromErr, Middleware, PendingTransaction};
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::{
+    fmt::Debug,
+    sync::atomic::{AtomicBool, AtomicU64, Ordering},
+};
 use thiserror::Error;
 
 #[derive(Debug)]
 /// Middleware used for calculating nonces locally, useful for signing multiple
 /// consecutive transactions without waiting for them to hit the mempool
 pub struct NonceManagerMiddleware<M> {
-    inner: M,
     initialized: AtomicBool,
     nonce: AtomicU64,
     address: Address,
+    inner: M,
 }
 
 impl<M> NonceManagerMiddleware<M>

ethers-middleware/src/signer.rs

@@ -62,9 +62,9 @@ use thiserror::Error;
 ///
 /// [`Signer`]: ethers_signers::Signer
 pub struct SignerMiddleware<M, S> {
-    pub(crate) inner: M,
     pub(crate) signer: S,
     pub(crate) address: Address,
+    pub(crate) inner: M,
 }
 
 impl<M: Middleware, S: Signer> FromErr<M::Error> for SignerMiddlewareError<M, S> {

ethers-providers/src/provider.rs

@@ -86,7 +86,7 @@ impl FromStr for NodeClient {
 /// # Ok(())
 /// # }
 /// ```
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct Provider<P> {
     inner: P,
     ens: Option<Address>,
@@ -110,6 +110,16 @@ impl FromErr<ProviderError> for ProviderError {
     }
 }
 
+impl<P: Debug> Debug for Provider<P> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Provider {{ ens: {:?}, interval: {:?}, from: {:?}, inner: {:?} }}",
+            self.ens, self.interval, self.from, self.inner
+        )
+    }
+}
+
 #[derive(Debug, Error)]
 /// An error thrown when making a call to the provider
 pub enum ProviderError {

ethers-providers/src/transports/http.rs

@@ -5,6 +5,7 @@ use async_trait::async_trait;
 use reqwest::{header::HeaderValue, Client, Error as ReqwestError};
 use serde::{de::DeserializeOwned, Serialize};
 use std::{
+    fmt::Debug,
     str::FromStr,
     sync::atomic::{AtomicU64, Ordering},
 };
@@ -28,13 +29,18 @@ use super::common::{Authorization, JsonRpcError, Request, Response};
 /// # Ok(())
 /// # }
 /// ```
-#[derive(Debug)]
 pub struct Provider {
     id: AtomicU64,
     client: Client,
     url: Url,
 }
 
+impl Debug for Provider {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Http {{ id: {:?}, url: {} }}", self.id, self.url)
+    }
+}
+
 #[derive(Error, Debug)]
 /// Error thrown when sending an HTTP request
 pub enum ClientError {

ethers-providers/src/transports/mod.rs

@@ -33,7 +33,9 @@ mod ws;
 pub use ws::{ClientError as WsClientError, Ws};
 
 mod quorum;
-pub use quorum::{JsonRpcClientWrapper, Quorum, QuorumError, QuorumProvider, WeightedProvider, WrappedParams};
+pub use quorum::{
+    JsonRpcClientWrapper, Quorum, QuorumError, QuorumProvider, WeightedProvider, WrappedParams,
+};
 
 mod rw;
 pub use rw::{RwClient, RwClientError};

ethers-providers/src/transports/quorum.rs

@@ -401,8 +401,8 @@ impl<'a, T> Future for QuorumRequest<'a, T> {
 /// The configuration of a provider for the `QuorumProvider`
 #[derive(Debug, Clone)]
 pub struct WeightedProvider<T> {
-    inner: T,
     weight: u64,
+    inner: T,
 }
 
 impl<T> WeightedProvider<T> {