Merge branch 'master' into hanyunx/celo_providers

Author: hanyunx

Diff for: Cargo.lock

@@ -19,7 +19,7 @@ ethers-contract-derive = { version = "0.2.2", path = "ethers-contract-derive", o
 serde = { version = "1.0.124", default-features = false }
 serde_json = { version = "1.0.64", default-features = false }
 thiserror = { version = "1.0.24", default-features = false }
-once_cell = { version = "1.7.2", default-features = false }
+once_cell = { version = "1.8.0", default-features = false }
 pin-project = {version = "1.0.7", default-features = false }
 futures-util = { version = "0.3.14", default-features = false }
 hex = { version = "0.4.3", default-features = false, features = ["std"] }

Diff for: ethers-contract/Cargo.toml

@@ -43,7 +43,7 @@ ethers = { version = "0.2", path = "../ethers" }
 
 serde_json = { version = "1.0.64", default-features = false }
 bincode = { version = "1.3.3", default-features = false }
-once_cell = { version = "1.7.2" }
+once_cell = { version = "1.8.0" }
 
 
 [features]

Diff for: ethers-core/Cargo.toml

@@ -4,6 +4,7 @@ use crate::{
     utils::keccak256,
 };
 use serde::{ser::SerializeStruct, Deserialize, Serialize, Serializer};
+use std::ops::{Range, RangeFrom, RangeTo};
 
 /// A log produced by a transaction.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -71,6 +72,65 @@ pub enum FilterBlockOption {
     AtBlockHash(H256),
 }
 
+impl From<BlockNumber> for FilterBlockOption {
+    fn from(block: BlockNumber) -> Self {
+        let block = Some(block);
+        FilterBlockOption::Range {
+            from_block: block,
+            to_block: block,
+        }
+    }
+}
+
+impl From<U64> for FilterBlockOption {
+    fn from(block: U64) -> Self {
+        BlockNumber::from(block).into()
+    }
+}
+
+impl From<u64> for FilterBlockOption {
+    fn from(block: u64) -> Self {
+        BlockNumber::from(block).into()
+    }
+}
+
+impl<T: Into<BlockNumber>> From<Range<T>> for FilterBlockOption {
+    fn from(r: Range<T>) -> Self {
+        let from_block = Some(r.start.into());
+        let to_block = Some(r.end.into());
+        FilterBlockOption::Range {
+            from_block,
+            to_block,
+        }
+    }
+}
+
+impl<T: Into<BlockNumber>> From<RangeTo<T>> for FilterBlockOption {
+    fn from(r: RangeTo<T>) -> Self {
+        let to_block = Some(r.end.into());
+        FilterBlockOption::Range {
+            from_block: Some(BlockNumber::Earliest),
+            to_block,
+        }
+    }
+}
+
+impl<T: Into<BlockNumber>> From<RangeFrom<T>> for FilterBlockOption {
+    fn from(r: RangeFrom<T>) -> Self {
+        let from_block = Some(r.start.into());
+        FilterBlockOption::Range {
+            from_block,
+            to_block: Some(BlockNumber::Latest),
+        }
+    }
+}
+
+impl From<H256> for FilterBlockOption {
+    fn from(hash: H256) -> Self {
+        FilterBlockOption::AtBlockHash(hash)
+    }
+}
+
 impl Default for FilterBlockOption {
     fn default() -> Self {
         FilterBlockOption::Range {
@@ -187,6 +247,72 @@ impl Filter {
         Self::default()
     }
 
+    /// Sets the inner filter object
+    ///
+    /// *NOTE:* ranges are always inclusive
+    ///
+    /// # Examples
+    ///
+    /// Match only a specific block
+    ///
+    /// ```rust
+    /// # use ethers::types::Filter;
+    /// # fn main() {
+    /// let filter = Filter::new().select(69u64);
+    /// # }
+    /// ```
+    /// This is the same as `Filter::new().from_block(1337u64).to_block(1337u64)`
+    ///
+    /// Match the latest block only
+    ///
+    /// ```rust
+    /// # use ethers::types::{Filter, BlockNumber};
+    /// # fn main() {
+    /// let filter = Filter::new().select(BlockNumber::Latest);
+    /// # }
+    /// ```
+    ///
+    /// Match a block by its hash
+    ///
+    /// ```rust
+    /// # use ethers::types::{Filter, H256};
+    /// # fn main() {
+    /// let filter = Filter::new().select(H256::zero());
+    /// # }
+    /// ```
+    /// This is the same as `at_block_hash`
+    ///
+    /// Match a range of blocks
+    ///
+    /// ```rust
+    /// # use ethers::types::{Filter, H256};
+    /// # fn main() {
+    /// let filter = Filter::new().select(0u64..100u64);
+    /// # }
+    /// ```
+    ///
+    /// Match all blocks in range `(1337..BlockNumber::Latest)`
+    ///
+    /// ```rust
+    /// # use ethers::types::{Filter, H256};
+    /// # fn main() {
+    /// let filter = Filter::new().select(1337u64..);
+    /// # }
+    /// ```
+    ///
+    /// Match all blocks in range `(BlockNumber::Earliest..1337)`
+    ///
+    /// ```rust
+    /// # use ethers::types::{Filter, H256};
+    /// # fn main() {
+    /// let filter = Filter::new().select(..1337u64);
+    /// # }
+    /// ```
+    pub fn select(mut self, filter: impl Into<FilterBlockOption>) -> Self {
+        self.block_option = filter.into();
+        self
+    }
+
     #[allow(clippy::wrong_self_convention)]
     pub fn from_block<T: Into<BlockNumber>>(mut self, block: T) -> Self {
         self.block_option = self.block_option.set_from_block(block.into());

Diff for: ethers-core/src/types/log.rs

@@ -43,7 +43,7 @@ pub struct Ws {
     requests: mpsc::UnboundedSender<TransportMessage>,
 }
 
-type Pending = oneshot::Sender<serde_json::Value>;
+type Pending = oneshot::Sender<Result<serde_json::Value, JsonRpcError>>;
 type Subscription = mpsc::UnboundedSender<serde_json::Value>;
 
 enum TransportMessage {
@@ -129,6 +129,9 @@ impl JsonRpcClient for Ws {
         // wait for the response
         let res = receiver.await?;
 
+        // in case the request itself has any errors
+        let res = res?;
+
         // parse it
         Ok(serde_json::from_value(res)?)
     }
@@ -268,7 +271,7 @@ where
         if let Ok(resp) = serde_json::from_str::<Response<serde_json::Value>>(&inner) {
             if let Some(request) = self.pending.remove(&resp.id) {
                 request
-                    .send(resp.data.into_result()?)
+                    .send(resp.data.into_result())
                     .map_err(to_client_error)?;
             }
         } else if let Ok(notification) =
@@ -286,8 +289,8 @@ where
 }
 
 // TrySendError is private :(
-fn to_client_error<T: ToString>(err: T) -> ClientError {
-    ClientError::ChannelError(err.to_string())
+fn to_client_error<T: Debug>(err: T) -> ClientError {
+    ClientError::ChannelError(format!("{:?}", err))
 }
 
 #[derive(Error, Debug)]