Struct ethers_providers::PendingTransaction

pub struct PendingTransaction<'a, P> { /* private fields */ }

A pending transaction is a transaction which has been submitted but is not yet mined. await’ing on a pending transaction will resolve to a transaction receipt once the transaction has enough confirmations. The default number of confirmations is 1, but may be adjusted with the confirmations method. If the transaction does not have enough confirmations or is not mined, the future will stay in the pending state.

Example

use ethers_core::types::TransactionRequest;

let tx = TransactionRequest::new().to(to).value(1000).from(from);
let receipt = client
    .send_transaction(tx, None)
    .await?                           // PendingTransaction<_>
    .log_msg("Pending transfer hash") // print pending tx hash with message
    .await?;                          // Result<Option<TransactionReceipt>, _>

Implementations

impl<'a, P: JsonRpcClient> PendingTransaction<'a, P>

pub fn new(tx_hash: TxHash, provider: &'a Provider<P>) -> Self

Creates a new pending transaction poller from a hash and a provider

pub fn provider(&self) -> Provider<P>where P: Clone,

Returns the Provider associated with the pending transaction

pub fn tx_hash(&self) -> TxHash

Returns the transaction hash of the pending transaction

pub fn confirmations(self, confs: usize) -> Self

Sets the number of confirmations for the pending transaction to resolve to a receipt

pub fn interval<T: Into<Duration>>(self, duration: T) -> Self

Sets the polling interval

pub fn retries(self, retries: usize) -> Self

Set retries

impl<'a, P> PendingTransaction<'a, P>

pub fn inspect<F>(self, f: F) -> Selfwhere F: FnMut(&Self),

Allows inspecting the content of a pending transaction in a builder-like way to avoid more verbose calls, e.g.: let mined = token.transfer(recipient, amt).send().await?.inspect(|tx| println!(".{}", *tx)).await?;

pub fn log_msg<S: Display>(self, msg: S) -> Self

Logs the pending transaction hash along with a custom message before it.

pub fn log(self) -> Self

Logs the pending transaction’s hash

Methods from Deref<Target = TxHash>

pub fn as_bytes(&self) -> &[u8]

Extracts a byte slice containing the entire fixed hash.

pub fn as_fixed_bytes(&self) -> &[u8; 32]

Extracts a reference to the byte array containing the entire fixed hash.

pub fn as_ptr(&self) -> *const u8

Returns a constant raw pointer to the value.

pub fn covers(&self, b: &H256) -> bool

Returns true if all bits set in b are also set in self.

pub fn is_zero(&self) -> bool

Returns true if no bits are set.

pub fn to_low_u64_be(&self) -> u64

Returns the lowest 8 bytes interpreted as big-endian.

Note

For hash type with less than 8 bytes the missing bytes are interpreted as being zero.

pub fn to_low_u64_le(&self) -> u64

Returns the lowest 8 bytes interpreted as little-endian.

Note

For hash type with less than 8 bytes the missing bytes are interpreted as being zero.

pub fn to_low_u64_ne(&self) -> u64

Returns the lowest 8 bytes interpreted as native-endian.

Note

For hash type with less than 8 bytes the missing bytes are interpreted as being zero.

Trait Implementations

impl<'a, P> Debug for PendingTransaction<'a, P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, P> Deref for PendingTransaction<'a, P>

type Target = H256

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, P: JsonRpcClient> Future for PendingTransaction<'a, P>

type Output = Result<Option<TransactionReceipt>, ProviderError>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<'a, P> PartialEq<H256> for PendingTransaction<'a, P>

fn eq(&self, other: &TxHash) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, P> PartialEq<PendingTransaction<'a, P>> for PendingTransaction<'a, P>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, P> Eq for PendingTransaction<'a, P>

impl<'pin, 'a, P> Unpin for PendingTransaction<'a, P>where __PendingTransaction<'pin, 'a, P>: Unpin,