Struct PendingTransactionBuilder

pub struct PendingTransactionBuilder<T, N: Network> { /* private fields */ }

A builder for configuring a pending transaction watcher.

Examples

Send and wait for a transaction to be confirmed 2 times, with a timeout of 60 seconds:

// Send a transaction, and configure the pending transaction.
let builder = provider.send_transaction(tx)
    .await?
    .with_required_confirmations(2)
    .with_timeout(Some(std::time::Duration::from_secs(60)));
// Register the pending transaction with the provider.
let pending_tx = builder.register().await?;
// Wait for the transaction to be confirmed 2 times.
let tx_hash = pending_tx.await?;

This can also be more concisely written using watch:

let tx_hash = provider.send_transaction(tx)
    .await?
    .with_required_confirmations(2)
    .with_timeout(Some(std::time::Duration::from_secs(60)))
    .watch()
    .await?;

Implementations

impl<T: Transport + Clone, N: Network> PendingTransactionBuilder<T, N>

pub const fn new(provider: RootProvider<T, N>, tx_hash: TxHash) -> Self

Creates a new pending transaction builder.

pub const fn from_config( provider: RootProvider<T, N>, config: PendingTransactionConfig, ) -> Self

Creates a new pending transaction builder from the given configuration.

pub const fn inner(&self) -> &PendingTransactionConfig

Returns the inner configuration.

pub fn into_inner(self) -> PendingTransactionConfig

Consumes this builder, returning the inner configuration.

pub const fn provider(&self) -> &RootProvider<T, N>

Returns the provider.

pub fn split(self) -> (RootProvider<T, N>, PendingTransactionConfig)

Consumes this builder, returning the provider and the configuration.

pub const fn tx_hash(&self) -> &TxHash

Returns the transaction hash.

pub fn set_tx_hash(&mut self, tx_hash: TxHash)

Sets the transaction hash.

pub const fn with_tx_hash(self, tx_hash: TxHash) -> Self

Sets the transaction hash.

pub const fn required_confirmations(&self) -> u64

Returns the number of confirmations to wait for.

pub fn set_required_confirmations(&mut self, confirmations: u64)

Sets the number of confirmations to wait for.

pub const fn with_required_confirmations(self, confirmations: u64) -> Self

Sets the number of confirmations to wait for.

pub const fn timeout(&self) -> Option<Duration>

Returns the timeout.

pub fn set_timeout(&mut self, timeout: Option<Duration>)

Sets the timeout.

pub const fn with_timeout(self, timeout: Option<Duration>) -> Self

Sets the timeout.

pub async fn register( self, ) -> Result<PendingTransaction, PendingTransactionError>

Registers the watching configuration with the provider.

This does not wait for the transaction to be confirmed, but returns a PendingTransaction that can be awaited at a later moment.

See:

• watch for watching the transaction without fetching the receipt.
• get_receipt for fetching the receipt after the transaction has been confirmed.

pub async fn watch(self) -> Result<TxHash, PendingTransactionError>

Waits for the transaction to confirm with the given number of confirmations.

See:

• register: for registering the transaction without waiting for it to be confirmed.
• get_receipt for fetching the receipt after the transaction has been confirmed.

pub async fn get_receipt( self, ) -> Result<N::ReceiptResponse, PendingTransactionError>

Waits for the transaction to confirm with the given number of confirmations, and then fetches its receipt.

Note that this method will call eth_getTransactionReceipt on the root provider, and not on a specific network provider. This means that any overrides or customizations made to the network provider will not be used.

See:

• register: for registering the transaction without waiting for it to be confirmed.
• watch for watching the transaction without fetching the receipt.

Trait Implementations

impl<T: Debug, N: Debug + Network> Debug for PendingTransactionBuilder<T, N>

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

Formats the value using the given formatter.