Struct ethers_middleware::nonce_manager::NonceManagerMiddleware

pub struct NonceManagerMiddleware<M> { /* private fields */ }

Middleware used for calculating nonces locally, useful for signing multiple consecutive transactions without waiting for them to hit the mempool

Implementations

impl<M> NonceManagerMiddleware<M>where
    M: Middleware,

pub fn new(inner: M, address: Address) -> Self

Instantiates the nonce manager with a 0 nonce. The address should be the address which you’ll be sending transactions from

pub fn next(&self) -> U256

Returns the next nonce to be used

pub async fn initialize_nonce(
    &self,
    block: Option<BlockId>
) -> Result<U256, NonceManagerError<M>>

Trait Implementations

impl<M: Debug> Debug for NonceManagerMiddleware<M>

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

Formats the value using the given formatter.

impl<M> Middleware for NonceManagerMiddleware<M>where
    M: Middleware,

fn send_transaction<'life0, 'async_trait, T>(
    &'life0 self,
    tx: T,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'_, Self::Provider>, Self::Error>> + Send + 'async_trait>>where
    T: 'async_trait + Into<TypedTransaction> + Send + Sync,
    'life0: 'async_trait,
    Self: 'async_trait,

Signs and broadcasts the transaction. The optional parameter block can be passed so that gas cost and nonce calculations take it into account. For simple transactions this can be left to None.

type Error = NonceManagerError<M>

type Provider = <M as Middleware>::Provider

type Inner = M

fn inner(&self) -> &M

The next middleware in the stack

fn fill_transaction<'life0, 'life1, 'async_trait>(
    &'life0 self,
    tx: &'life1 mut TypedTransaction,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Fill necessary details of a transaction for dispatch

fn provider(&self) -> &Provider<Self::Provider>

The HTTP or Websocket provider.

fn default_sender(&self) -> Option<H160>

fn client_version<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn get_block_number<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<U64, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn send_escalating<'a, 'life0, 'async_trait>(
    &'a self,
    tx: &'life0 TypedTransaction,
    escalations: usize,
    policy: Box<dyn Fn(U256, usize) -> U256 + Sync + Send + 'static, Global>
) -> Pin<Box<dyn Future<Output = Result<EscalatingPending<'a, Self::Provider>, Self::Error>> + Send + 'async_trait, Global>>where
    'a: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

Send a transaction with a simple escalation policy.

fn resolve_name<'life0, 'life1, 'async_trait>(
    &'life0 self,
    ens_name: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<H160, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

fn lookup_address<'life0, 'async_trait>(
    &'life0 self,
    address: H160
) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn resolve_avatar<'life0, 'life1, 'async_trait>(
    &'life0 self,
    ens_name: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Url, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

fn resolve_nft<'life0, 'async_trait>(
    &'life0 self,
    token: ERCNFT
) -> Pin<Box<dyn Future<Output = Result<Url, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn resolve_field<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ens_name: &'life1 str,
    field: &'life2 str
) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait,

fn get_block<'life0, 'async_trait, T>(
    &'life0 self,
    block_hash_or_number: T
) -> Pin<Box<dyn Future<Output = Result<Option<Block<H256>>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<BlockId> + Send + Sync,
    Self: 'async_trait,

fn get_block_with_txs<'life0, 'async_trait, T>(
    &'life0 self,
    block_hash_or_number: T
) -> Pin<Box<dyn Future<Output = Result<Option<Block<Transaction>>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<BlockId> + Send + Sync,
    Self: 'async_trait,

fn get_uncle_count<'life0, 'async_trait, T>(
    &'life0 self,
    block_hash_or_number: T
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<BlockId> + Send + Sync,
    Self: 'async_trait,

fn get_uncle<'life0, 'async_trait, T>(
    &'life0 self,
    block_hash_or_number: T,
    idx: U64
) -> Pin<Box<dyn Future<Output = Result<Option<Block<H256>>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<BlockId> + Send + Sync,
    Self: 'async_trait,

fn get_transaction_count<'life0, 'async_trait, T>(
    &'life0 self,
    from: T,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<NameOrAddress> + Send + Sync,
    Self: 'async_trait,

fn estimate_gas<'life0, 'life1, 'async_trait>(
    &'life0 self,
    tx: &'life1 TypedTransaction,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

fn call<'life0, 'life1, 'async_trait>(
    &'life0 self,
    tx: &'life1 TypedTransaction,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<Bytes, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

fn syncing<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<SyncingStatus, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn get_chainid<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn get_net_version<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn get_balance<'life0, 'async_trait, T>(
    &'life0 self,
    from: T,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<NameOrAddress> + Send + Sync,
    Self: 'async_trait,

fn get_transaction<'life0, 'async_trait, T>(
    &'life0 self,
    transaction_hash: T
) -> Pin<Box<dyn Future<Output = Result<Option<Transaction>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Send + Sync + Into<H256>,
    Self: 'async_trait,

fn get_transaction_receipt<'life0, 'async_trait, T>(
    &'life0 self,
    transaction_hash: T
) -> Pin<Box<dyn Future<Output = Result<Option<TransactionReceipt>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Send + Sync + Into<H256>,
    Self: 'async_trait,

fn get_block_receipts<'life0, 'async_trait, T>(
    &'life0 self,
    block: T
) -> Pin<Box<dyn Future<Output = Result<Vec<TransactionReceipt, Global>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<BlockNumber> + Send + Sync,
    Self: 'async_trait,

fn get_gas_price<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn estimate_eip1559_fees<'life0, 'async_trait>(
    &'life0 self,
    estimator: Option<fn(_: U256, _: Vec<Vec<U256, Global>, Global>) -> (U256, U256)>
) -> Pin<Box<dyn Future<Output = Result<(U256, U256), Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn get_accounts<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<H160, Global>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn send_raw_transaction<'a, 'async_trait>(
    &'a self,
    tx: Bytes
) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'a, Self::Provider>, Self::Error>> + Send + 'async_trait, Global>>where
    'a: 'async_trait,
    Self: 'async_trait,

fn is_signer<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

This returns true if either the middleware stack contains a SignerMiddleware, or the JSON-RPC provider has an unlocked key that can sign using the eth_sign call. If none of the above conditions are met, then the middleware stack is not capable of signing data.

fn sign<'life0, 'life1, 'async_trait, T>(
    &'life0 self,
    data: T,
    from: &'life1 H160
) -> Pin<Box<dyn Future<Output = Result<Signature, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    T: 'async_trait + Into<Bytes> + Send + Sync,
    Self: 'async_trait,

fn sign_transaction<'life0, 'life1, 'async_trait>(
    &'life0 self,
    tx: &'life1 TypedTransaction,
    from: H160
) -> Pin<Box<dyn Future<Output = Result<Signature, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Sign a transaction via RPC call

fn get_logs<'life0, 'life1, 'async_trait>(
    &'life0 self,
    filter: &'life1 Filter
) -> Pin<Box<dyn Future<Output = Result<Vec<Log, Global>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

fn get_logs_paginated<'a>(
    &'a self,
    filter: &Filter,
    page_size: u64
) -> LogQuery<'a, Self::Provider>

Returns a stream of logs are loaded in pages of given page size

fn new_filter<'life0, 'life1, 'async_trait>(
    &'life0 self,
    filter: FilterKind<'life1>
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

fn uninstall_filter<'life0, 'async_trait, T>(
    &'life0 self,
    id: T
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<U256> + Send + Sync,
    Self: 'async_trait,

fn watch<'a, 'life0, 'async_trait>(
    &'a self,
    filter: &'life0 Filter
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'a, Self::Provider, Log>, Self::Error>> + Send + 'async_trait, Global>>where
    'a: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,

fn watch_pending_transactions<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'life0, Self::Provider, H256>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn get_filter_changes<'life0, 'async_trait, T, R>(
    &'life0 self,
    id: T
) -> Pin<Box<dyn Future<Output = Result<Vec<R, Global>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: Into<U256> + Send + Sync + 'async_trait,
    R: Serialize + DeserializeOwned + Send + Sync + Debug + 'async_trait,
    Self: 'async_trait,

fn watch_blocks<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'life0, Self::Provider, H256>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn get_code<'life0, 'async_trait, T>(
    &'life0 self,
    at: T,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<Bytes, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<NameOrAddress> + Send + Sync,
    Self: 'async_trait,

fn get_storage_at<'life0, 'async_trait, T>(
    &'life0 self,
    from: T,
    location: H256,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<H256, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<NameOrAddress> + Send + Sync,
    Self: 'async_trait,

fn get_proof<'life0, 'async_trait, T>(
    &'life0 self,
    from: T,
    locations: Vec<H256, Global>,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<EIP1186ProofResponse, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<NameOrAddress> + Send + Sync,
    Self: 'async_trait,

fn txpool_content<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolContent, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn txpool_inspect<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolInspect, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn txpool_status<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolStatus, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

fn debug_trace_transaction<'life0, 'async_trait>(
    &'life0 self,
    tx_hash: H256,
    trace_options: GethDebugTracingOptions
) -> Pin<Box<dyn Future<Output = Result<GethTrace, ProviderError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

After replaying any previous transactions in the same block, Replays a transaction, returning the traces configured with passed options

fn trace_call<'life0, 'async_trait, T>(
    &'life0 self,
    req: T,
    trace_type: Vec<TraceType, Global>,
    block: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<TypedTransaction> + Send + Sync,
    Self: 'async_trait,

Executes the given call and returns a number of possible traces for it

fn trace_call_many<'life0, 'async_trait, T>(
    &'life0 self,
    req: Vec<(T, Vec<TraceType, Global>), Global>,
    block: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<Vec<BlockTrace, Global>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<TypedTransaction> + Send + Sync,
    Self: 'async_trait,

fn trace_raw_transaction<'life0, 'async_trait>(
    &'life0 self,
    data: Bytes,
    trace_type: Vec<TraceType, Global>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Traces a call to eth_sendRawTransaction without making the call, returning the traces

fn trace_replay_transaction<'life0, 'async_trait>(
    &'life0 self,
    hash: H256,
    trace_type: Vec<TraceType, Global>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Replays a transaction, returning the traces

fn trace_replay_block_transactions<'life0, 'async_trait>(
    &'life0 self,
    block: BlockNumber,
    trace_type: Vec<TraceType, Global>
) -> Pin<Box<dyn Future<Output = Result<Vec<BlockTrace, Global>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Replays all transactions in a block returning the requested traces for each transaction

fn trace_block<'life0, 'async_trait>(
    &'life0 self,
    block: BlockNumber
) -> Pin<Box<dyn Future<Output = Result<Vec<Trace, Global>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Returns traces created at given block

fn trace_filter<'life0, 'async_trait>(
    &'life0 self,
    filter: TraceFilter
) -> Pin<Box<dyn Future<Output = Result<Vec<Trace, Global>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Return traces matching the given filter

fn trace_get<'life0, 'async_trait, T>(
    &'life0 self,
    hash: H256,
    index: Vec<T, Global>
) -> Pin<Box<dyn Future<Output = Result<Trace, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<U64> + Send + Sync,
    Self: 'async_trait,

Returns trace at the given position

fn trace_transaction<'life0, 'async_trait>(
    &'life0 self,
    hash: H256
) -> Pin<Box<dyn Future<Output = Result<Vec<Trace, Global>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Returns all traces of a given transaction

fn parity_block_receipts<'life0, 'async_trait, T>(
    &'life0 self,
    block: T
) -> Pin<Box<dyn Future<Output = Result<Vec<TransactionReceipt, Global>, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    T: 'async_trait + Into<BlockNumber> + Send + Sync,
    Self: 'async_trait,

Returns all receipts for that block. Must be done on a parity node.

fn fee_history<'life0, 'life1, 'async_trait, T>(
    &'life0 self,
    block_count: T,
    last_block: BlockNumber,
    reward_percentiles: &'life1 [f64]
) -> Pin<Box<dyn Future<Output = Result<FeeHistory, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    T: 'async_trait + Into<U256> + Serialize + Send + Sync,
    Self: 'async_trait,

fn create_access_list<'life0, 'life1, 'async_trait>(
    &'life0 self,
    tx: &'life1 TypedTransaction,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<AccessListWithGasUsed, Self::Error>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,