Returning a PendingTransaction after sending a tx

ethers-contract/src/call.rs

@@ -1,9 +1,9 @@
 use super::base::{decode_fn, AbiError};
 use ethers_core::{
     abi::{Detokenize, Function, InvalidOutputType},
-    types::{Address, BlockNumber, Bytes, TransactionRequest, TxHash, U256},
+    types::{Address, BlockNumber, Bytes, TransactionRequest, U256},
 };
-use ethers_providers::Middleware;
+use ethers_providers::{Middleware, PendingTransaction};
 
 use std::{fmt::Debug, marker::PhantomData, sync::Arc};
 
@@ -126,9 +126,9 @@ where
     }
 
     /// Signs and broadcasts the provided transaction
-    pub async fn send(self) -> Result<TxHash, ContractError<M>> {
+    pub async fn send(&self) -> Result<PendingTransaction<'_, M::Provider>, ContractError<M>> {
         self.client
-            .send_transaction(self.tx, self.block)
+            .send_transaction(self.tx.clone(), self.block)
             .await
             .map_err(ContractError::MiddlewareError)
     }

ethers-contract/src/contract.rs

@@ -6,9 +6,9 @@ use super::{
 
 use ethers_core::{
     abi::{Abi, Detokenize, Error, EventExt, Function, Tokenize},
-    types::{Address, Filter, NameOrAddress, Selector, TransactionRequest, TxHash},
+    types::{Address, Filter, NameOrAddress, Selector, TransactionRequest},
 };
-use ethers_providers::{Middleware, PendingTransaction};
+use ethers_providers::Middleware;
 
 use rustc_hex::ToHex;
 use std::{fmt::Debug, marker::PhantomData, sync::Arc};
@@ -90,11 +90,12 @@ use std::{fmt::Debug, marker::PhantomData, sync::Arc};
 ///     .await?;
 ///
 /// // Non-constant methods are executed via the `send()` call on the method builder.
-/// let tx_hash = contract
-///     .method::<_, H256>("setValue", "hi".to_owned())?.send().await?;
+/// let call = contract
+///     .method::<_, H256>("setValue", "hi".to_owned())?;
+/// let pending_tx = call.send().await?;
 ///
 /// // `await`ing on the pending transaction resolves to a transaction receipt
-/// let receipt = contract.pending_transaction(tx_hash).confirmations(6).await?;
+/// let receipt = pending_tx.confirmations(6).await?;
 ///
 /// # Ok(())
 /// # }
@@ -283,8 +284,4 @@ impl<M: Middleware> Contract<M> {
     pub fn client(&self) -> &M {
         &self.client
     }
-
-    pub fn pending_transaction(&self, tx_hash: TxHash) -> PendingTransaction<'_, M::Provider> {
-        self.client.pending_transaction(tx_hash)
-    }
 }

ethers-contract/src/factory.rs

@@ -35,16 +35,14 @@ impl<M: Middleware> Deployer<M> {
     /// be sufficiently confirmed (default: 1), it returns a [`Contract`](crate::Contract)
     /// struct at the deployed contract's address.
     pub async fn send(self) -> Result<Contract<M>, ContractError<M>> {
-        let tx_hash = self
+        let pending_tx = self
             .client
             .send_transaction(self.tx, Some(self.block))
             .await
             .map_err(ContractError::MiddlewareError)?;
 
         // TODO: Should this be calculated "optimistically" by address/nonce?
-        let receipt = self
-            .client
-            .pending_transaction(tx_hash)
+        let receipt = pending_tx
             .confirmations(self.confs)
             .await
             .map_err(|_| ContractError::ContractNotDeployed)?;

ethers-contract/src/multicall/mod.rs

@@ -61,7 +61,7 @@ pub static ADDRESS_BOOK: Lazy<HashMap<U256, Address>> = Lazy::new(|| {
 /// use ethers::{
 ///     abi::Abi,
 ///     contract::{Contract, Multicall},
-///     providers::{Middleware, Http, Provider},
+///     providers::{Middleware, Http, Provider, PendingTransaction},
 ///     types::{Address, H256, U256},
 /// };
 /// use std::{convert::TryFrom, sync::Arc};
@@ -110,7 +110,7 @@ pub static ADDRESS_BOOK: Lazy<HashMap<U256, Address>> = Lazy::new(|| {
 /// // `await`ing the `send` method waits for the transaction to be broadcast, which also
 /// // returns the transaction hash
 /// let tx_hash = multicall.send().await?;
-/// let _tx_receipt = client.pending_transaction(tx_hash).await?;
+/// let _tx_receipt = PendingTransaction::new(tx_hash, &client).await?;
 ///
 /// // you can also query ETH balances of multiple addresses
 /// let address_1 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".parse::<Address>()?;
@@ -345,7 +345,9 @@ impl<M: Middleware> Multicall<M> {
         let contract_call = self.as_contract_call();
 
         // Broadcast transaction and return the transaction hash
-        let tx_hash = contract_call.send().await?;
+        // TODO: Can we make this return a PendingTransaction directly instead?
+        // Seems hard due to `returns a value referencing data owned by the current function`
+        let tx_hash = *contract_call.send().await?;
 
         Ok(tx_hash)
     }

ethers-contract/tests/contract.rs

@@ -8,7 +8,7 @@ mod eth_tests {
     use super::*;
     use ethers::{
         contract::Multicall,
-        providers::{Http, Middleware, Provider, StreamExt},
+        providers::{Http, Middleware, PendingTransaction, Provider, StreamExt},
         types::{Address, U256},
         utils::Ganache,
     };
@@ -51,13 +51,9 @@ mod eth_tests {
             .unwrap();
         let calldata = contract_call.calldata().unwrap();
         let gas_estimate = contract_call.estimate_gas().await.unwrap();
-        let tx_hash = contract_call.send().await.unwrap();
-        let tx = client.get_transaction(tx_hash).await.unwrap().unwrap();
-        let tx_receipt = client
-            .get_transaction_receipt(tx_hash)
-            .await
-            .unwrap()
-            .unwrap();
+        let pending_tx = contract_call.send().await.unwrap();
+        let tx = client.get_transaction(*pending_tx).await.unwrap().unwrap();
+        let tx_receipt = pending_tx.await.unwrap();
         assert_eq!(last_sender.clone().call().await.unwrap(), client2.address());
         assert_eq!(get_value.clone().call().await.unwrap(), "hi");
         assert_eq!(tx.input, calldata);
@@ -88,6 +84,8 @@ mod eth_tests {
             .unwrap()
             .send()
             .await
+            .unwrap()
+            .await
             .unwrap();
     }
 
@@ -99,7 +97,7 @@ mod eth_tests {
         let contract = deploy(client.clone(), abi, bytecode).await;
 
         // make a call with `client2`
-        let _tx_hash = contract
+        let _tx_hash = *contract
             .method::<_, H256>("setValue", "hi".to_owned())
             .unwrap()
             .send()
@@ -143,13 +141,11 @@ mod eth_tests {
 
         // and we make a few calls
         for i in 0..num_calls {
-            let tx_hash = contract
+            let call = contract
                 .method::<_, H256>("setValue", i.to_string())
-                .unwrap()
-                .send()
-                .await
                 .unwrap();
-            let _receipt = contract.pending_transaction(tx_hash).await.unwrap();
+            let pending_tx = call.send().await.unwrap();
+            let _receipt = pending_tx.await.unwrap();
         }
 
         for i in 0..num_calls {
@@ -180,13 +176,14 @@ mod eth_tests {
         let contract = deploy(client, abi, bytecode).await;
 
         // make a call without the signer
-        let tx_hash = contract
+        let _receipt = contract
             .method::<_, H256>("setValue", "hi".to_owned())
             .unwrap()
             .send()
             .await
+            .unwrap()
+            .await
             .unwrap();
-        let _receipt = contract.pending_transaction(tx_hash).await.unwrap();
         let value: String = contract
             .method::<_, String>("getValue", ())
             .unwrap()
@@ -313,7 +310,9 @@ mod eth_tests {
 
         // broadcast the transaction and wait for it to be mined
         let tx_hash = multicall_send.send().await.unwrap();
-        let _tx_receipt = client4.pending_transaction(tx_hash).await.unwrap();
+        let _tx_receipt = PendingTransaction::new(tx_hash, client.provider())
+            .await
+            .unwrap();
 
         // Do another multicall to check the updated return values
         // The `getValue` calls should return the last value we set in the batched broadcast
@@ -385,14 +384,14 @@ mod celo_tests {
         assert_eq!(value, "initial value");
 
         // make a state mutating transaction
-        let tx_hash = contract
+        let call = contract
             .method::<_, H256>("setValue", "hi".to_owned())
-            .unwrap()
+            .unwrap();
+        let pending_tx = call
             .send()
             .await
             .unwrap();
-        let receipt = contract.pending_transaction(tx_hash).await.unwrap();
-        assert_eq!(receipt.status.unwrap(), 1.into());
+        let _receipt = pending_tx.await.unwrap();
 
         let value: String = contract
             .method("getValue", ())

ethers-middleware/src/gas_escalator/mod.rs

@@ -6,7 +6,7 @@ pub use linear::LinearGasPrice;
 
 use async_trait::async_trait;
 use ethers_core::types::{BlockNumber, TransactionRequest, TxHash, U256};
-use ethers_providers::{interval, FromErr, Middleware, StreamExt};
+use ethers_providers::{interval, FromErr, Middleware, PendingTransaction, StreamExt};
 use futures_util::lock::Mutex;
 use std::sync::Arc;
 use std::{pin::Pin, time::Instant};
@@ -97,18 +97,18 @@ where
         &self,
         tx: TransactionRequest,
         block: Option<BlockNumber>,
-    ) -> Result<TxHash, Self::Error> {
-        let tx_hash = self
+    ) -> Result<PendingTransaction<'_, Self::Provider>, Self::Error> {
+        let pending_tx = self
             .inner()
             .send_transaction(tx.clone(), block)
             .await
             .map_err(GasEscalatorError::MiddlewareError)?;
 
         // insert the tx in the pending txs
         let mut lock = self.txs.lock().await;
-        lock.push((tx_hash, tx, Instant::now(), block));
+        lock.push((*pending_tx, tx, Instant::now(), block));
 
-        Ok(tx_hash)
+        Ok(pending_tx)
     }
 }
 
@@ -188,7 +188,7 @@ where
                             .send_transaction(replacement_tx.clone(), priority)
                             .await
                         {
-                            Ok(tx_hash) => tx_hash,
+                            Ok(tx_hash) => *tx_hash,
                             Err(err) => {
                                 if err.to_string().contains("nonce too low") {
                                     // ignore "nonce too low" errors because they

ethers-middleware/src/gas_oracle/middleware.rs

@@ -1,7 +1,7 @@
 use super::{GasOracle, GasOracleError};
 use async_trait::async_trait;
 use ethers_core::types::*;
-use ethers_providers::{FromErr, Middleware};
+use ethers_providers::{FromErr, Middleware, PendingTransaction};
 use thiserror::Error;
 
 #[derive(Debug)]
@@ -60,7 +60,7 @@ where
         &self,
         mut tx: TransactionRequest,
         block: Option<BlockNumber>,
-    ) -> Result<TxHash, Self::Error> {
+    ) -> Result<PendingTransaction<'_, Self::Provider>, Self::Error> {
         if tx.gas_price.is_none() {
             tx.gas_price = Some(self.get_gas_price().await?);
         }

ethers-middleware/src/nonce_manager.rs

@@ -1,6 +1,6 @@
 use async_trait::async_trait;
 use ethers_core::types::*;
-use ethers_providers::{FromErr, Middleware};
+use ethers_providers::{FromErr, Middleware, PendingTransaction};
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use thiserror::Error;
 
@@ -87,7 +87,7 @@ where
         &self,
         mut tx: TransactionRequest,
         block: Option<BlockNumber>,
-    ) -> Result<TxHash, Self::Error> {
+    ) -> Result<PendingTransaction<'_, Self::Provider>, Self::Error> {
         if tx.nonce.is_none() {
             tx.nonce = Some(self.get_transaction_count_with_manager(block).await?);
         }

ethers-middleware/src/signer.rs

@@ -1,11 +1,11 @@
 use ethers_core::{
     types::{
         Address, BlockNumber, Bytes, NameOrAddress, Signature, Transaction, TransactionRequest,
-        TxHash, U256,
+        U256,
     },
     utils::keccak256,
 };
-use ethers_providers::{FromErr, Middleware};
+use ethers_providers::{FromErr, Middleware, PendingTransaction};
 use ethers_signers::Signer;
 
 use async_trait::async_trait;
@@ -44,11 +44,11 @@ use thiserror::Error;
 ///
 /// // ...and sign transactions
 /// let tx = TransactionRequest::pay("vitalik.eth", 100);
-/// let tx_hash = client.send_transaction(tx, None).await?;
+/// let pending_tx = client.send_transaction(tx, None).await?;
 ///
 /// // You can `await` on the pending transaction to get the receipt with a pre-specified
 /// // number of confirmations
-/// let receipt = client.pending_transaction(tx_hash).confirmations(6).await?;
+/// let receipt = pending_tx.confirmations(6).await?;
 ///
 /// // You can connect with other wallets at runtime via the `with_signer` function
 /// let wallet2: LocalWallet = "cd8c407233c0560f6de24bb2dc60a8b02335c959a1a17f749ce6c1ccf63d74a7"
@@ -242,7 +242,7 @@ where
         &self,
         mut tx: TransactionRequest,
         block: Option<BlockNumber>,
-    ) -> Result<TxHash, Self::Error> {
+    ) -> Result<PendingTransaction<'_, Self::Provider>, Self::Error> {
         if let Some(ref to) = tx.to {
             if let NameOrAddress::Name(ens_name) = to {
                 let addr = self

ethers-middleware/tests/gas_oracle.rs

@@ -27,7 +27,7 @@ async fn using_gas_oracle() {
         .value(10000);
     let tx_hash = provider.send_transaction(tx, None).await.unwrap();
 
-    let tx = provider.get_transaction(tx_hash).await.unwrap().unwrap();
+    let tx = provider.get_transaction(*tx_hash).await.unwrap().unwrap();
     assert_eq!(tx.gas_price, expected_gas_price);
 }
 

ethers-middleware/tests/nonce_manager.rs

@@ -36,7 +36,7 @@ async fn nonce_manager() {
             .send_transaction(TransactionRequest::pay(address, 100u64), None)
             .await
             .unwrap();
-        tx_hashes.push(tx);
+        tx_hashes.push(*tx);
     }
 
     // sleep a bit to ensure there's no flakiness in the test

ethers-middleware/tests/signer.rs

@@ -58,9 +58,10 @@ async fn test_send_transaction() {
 
     let balance_before = client.get_balance(client.address(), None).await.unwrap();
     let tx = TransactionRequest::pay(client.address(), 100);
-    let tx_hash = client.send_transaction(tx, None).await.unwrap();
     let _receipt = client
-        .pending_transaction(tx_hash)
+        .send_transaction(tx, None)
+        .await
+        .unwrap()
         .confirmations(3)
         .await
         .unwrap();