Struct zksync_web3_rs::middleware::SignerMiddleware

pub struct SignerMiddleware<M, S> { /* private fields */ }

Middleware used for locally signing transactions, compatible with any implementer of the Signer trait.

Example

use ethers_providers::{Middleware, Provider, Http};
use ethers_signers::LocalWallet;
use ethers_middleware::SignerMiddleware;
use ethers_core::types::{Address, TransactionRequest};
use std::convert::TryFrom;

let provider = Provider::<Http>::try_from("http://localhost:8545")
    .expect("could not instantiate HTTP Provider");

// Transactions will be signed with the private key below and will be broadcast
// via the eth_sendRawTransaction API)
let wallet: LocalWallet = "380eb0f3d505f087e438eca80bc4df9a7faa24f868e69fc0440261a0fc0567dc"
    .parse()?;

let mut client = SignerMiddleware::new(provider, wallet);

// You can sign messages with the key
let signed_msg = client.sign(b"hello".to_vec(), &client.address()).await?;

// ...and sign transactions
let tx = TransactionRequest::pay("vitalik.eth", 100);
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 = pending_tx.confirmations(6).await?;

// You can connect with other wallets at runtime via the `with_signer` function
let wallet2: LocalWallet = "cd8c407233c0560f6de24bb2dc60a8b02335c959a1a17f749ce6c1ccf63d74a7"
    .parse()?;

let signed_msg2 = client.with_signer(wallet2).sign(b"hello".to_vec(), &client.address()).await?;

// This call will be made with `wallet2` since `with_signer` takes a mutable reference.
let tx2 = TransactionRequest::new()
    .to("0xd8da6bf26964af9d7eed9e03e53415d37aa96045".parse::<Address>()?)
    .value(200);
let tx_hash2 = client.send_transaction(tx2, None).await?;

Implementations

impl<M, S> SignerMiddleware<M, S>where M: Middleware, S: Signer,

pub fn new(inner: M, signer: S) -> SignerMiddleware<M, S>

Creates a new client from the provider and signer. Sets the address of this middleware to the address of the signer. The chain_id of the signer will not be set to the chain id of the provider. If the signer passed here is initialized with a different chain id, then the client may throw errors, or methods like sign_transaction may error. To automatically set the signer’s chain id, see new_with_provider_chain.

Middleware ethers_providers::Middleware Signer ethers_signers::Signer

pub fn address(&self) -> H160

Returns the client’s address

pub fn signer(&self) -> &S

Returns a reference to the client’s signer

pub fn with_signer(&self, signer: S) -> SignerMiddleware<M, S>where S: Clone, M: Clone,

Builds a SignerMiddleware with the given Signer.

pub async fn new_with_provider_chain( inner: M, signer: S ) -> impl Future<Output = Result<SignerMiddleware<M, S>, SignerMiddlewareError<M, S>>>

Creates a new client from the provider and signer. Sets the address of this middleware to the address of the signer. Sets the chain id of the signer to the chain id of the inner Middleware passed in, using the Signer’s implementation of with_chain_id.

Middleware ethers_providers::Middleware Signer ethers_signers::Signer

Trait Implementations

impl<M, S> Clone for SignerMiddleware<M, S>where M: Clone, S: Clone,

fn clone(&self) -> SignerMiddleware<M, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<M, S> Debug for SignerMiddleware<M, S>where M: Debug, S: Debug,

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

Formats the value using the given formatter.

impl<M, S> Middleware for SignerMiddleware<M, S>where M: Middleware, S: Signer,

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

Returns the client’s address

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

SignerMiddleware is instantiated with a signer.

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

Helper for filling a transaction’s nonce using the wallet

fn send_transaction<'life0, 'async_trait, T>( &'life0 self, tx: T, block: Option<BlockId> ) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'life0, <SignerMiddleware<M, S> as Middleware>::Provider>, <SignerMiddleware<M, S> as Middleware>::Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, T: 'async_trait + Into<TypedTransaction> + Send + Sync, SignerMiddleware<M, S>: '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.

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

Signs a message with the internal signer, or if none is present it will make a call to the connected node’s eth_call API.

type Error = SignerMiddlewareError<M, S>

Error type returned by most operations

type Provider = <M as Middleware>::Provider

The JSON-RPC client type at the bottom of the stack

type Inner = M

The next-lower middleware in the middleware stack

fn inner(&self) -> &M

Get a reference to the next-lower middleware in the middleware stack

fn sign_transaction<'life0, 'life1, 'async_trait>( &'life0 self, tx: &'life1 TypedTransaction, __arg2: H160 ) -> Pin<Box<dyn Future<Output = Result<Signature, <SignerMiddleware<M, S> as Middleware>::Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, SignerMiddleware<M, S>: 'async_trait,

Sign a transaction via RPC call

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

Sends a transaction to a single Ethereum node and return the estimated amount of gas required (as a U256) to send it This is free, but only an estimate. Providing too little gas will result in a transaction being rejected (while still consuming all provided gas).

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

Querty the node for an EIP-2930 Access List.

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

Sends the read-only (constant) transaction to a single Ethereum node and return the result (as bytes) of executing it. This is free, since it does not change any state on the blockchain.

fn convert_err(p: ProviderError) -> Self::Error

Convert a provider error into the associated error type by successively converting it to every intermediate middleware error

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

The HTTP or Websocket provider.

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,

Returns the current client version using the web3_clientVersion RPC.

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,

Get the block number

fn send_escalating<'a, 'life0, 'async_trait>( &'a self, tx: &'life0 TypedTransaction, escalations: usize, policy: Box<dyn Fn(U256, usize) -> U256 + Sync + Send, 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,

Returns the address that the ens_name resolves to (or None if not configured).

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,

Returns the ENS name the address resolves to (or None if not configured).

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,

Returns the avatar HTTP link of the avatar that the ens_name resolves to (or None if not configured)

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,

Returns the URL (not necesserily HTTP) of the image behind a token.

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,

Fetch a field for the ens_name (no None if not configured).

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,

Gets the block at block_hash_or_number (transaction hashes only)

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,

Gets the block at block_hash_or_number (full transactions included)

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,

Gets the block uncle count at block_hash_or_number

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,

Gets the block uncle at block_hash_or_number and idx

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,

Returns the nonce of the address

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,

Return current client syncing status. If IsFalse sync is over.

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,

Returns the currently configured chain id, a value used in replay-protected transaction signing as introduced by EIP-155.

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,

Returns the network version.

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,

Returns the account’s balance

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,

Gets the transaction with transaction_hash

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

Gets the transaction with block and index

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,

Gets the transaction receipt with transaction_hash

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,

Returns all receipts for a block.

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,

Gets the current gas price as estimated by the node

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,

Gets a heuristic recommendation of max fee per gas and max priority fee per gas for EIP-1559 compatible transactions.

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,

Gets the accounts on the node

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,

Send the raw RLP encoded transaction to the entire Ethereum network and returns the transaction’s hash This will consume gas from the account that signed the transaction.

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,

Returns an array (possibly empty) of logs that match the filter

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 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,

Streams event logs matching the filter.

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,

Streams pending transactions.

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,

Streams new block hashes

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,

Returns the deployed code at a given address

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,

Get the storage of an address for a particular slot location

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,

Returns the EIP-1186 proof response https://github.com/ethereum/EIPs/issues/1186

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

Returns an indication if this node is currently mining.

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

Sends the given key to the node to be encrypted with the provided passphrase and stored.

fn unlock_account<'life0, 'async_trait, T>( &'life0 self, account: T, passphrase: String, duration: Option<u64> ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, T: 'async_trait + Into<H160> + Send + Sync, Self: 'async_trait,

Prompts the node to decrypt the given account from its keystore.

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

Requests adding the given peer, returning a boolean representing whether or not the peer was accepted for tracking.

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

Requests adding the given peer as a trusted peer, which the node will always connect to even when its peer slots are full.

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

Returns general information about the node as well as information about the running p2p protocols (e.g. eth, snap).

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

Returns the list of peers currently connected to the node.

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

Requests to remove the given peer, returning true if the enode was successfully parsed and the peer was removed.

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

Requests to remove the given peer, returning a boolean representing whether or not the enode url passed was validated. A return value of true does not necessarily mean that the peer was disconnected.

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

Starts the miner.

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

Stop terminates the miner, both at the consensus engine level as well as at the block creation level.

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,

Returns the details of all transactions currently pending for inclusion in the next block(s), as well as the ones that are being scheduled for future execution only. Ref: Here

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,

Returns a summary of all the transactions currently pending for inclusion in the next block(s), as well as the ones that are being scheduled for future execution only. Ref: Here

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,

Returns the number of transactions currently pending for inclusion in the next block(s), as well as the ones that are being scheduled for future execution only. Ref: Here

fn debug_trace_transaction<'life0, 'async_trait>( &'life0 self, tx_hash: H256, trace_options: GethDebugTracingOptions ) -> Pin<Box<dyn Future<Output = Result<GethTrace, Self::Error>> + 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 debug_trace_call<'life0, 'async_trait, T>( &'life0 self, req: T, block: Option<BlockId>, trace_options: GethDebugTracingCallOptions ) -> Pin<Box<dyn Future<Output = Result<GethTrace, 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 debug_trace_block_by_number<'life0, 'async_trait>( &'life0 self, block: Option<BlockNumber>, trace_options: GethDebugTracingOptions ) -> Pin<Box<dyn Future<Output = Result<Vec<GethTrace, Global>, Self::Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, Self: 'async_trait,

Replays all transactions in a given block (specified by block number) and returns the traces configured with passed options Ref: Here

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

Replays all transactions in a given block (specified by block hash) and returns the traces configured with passed options Ref: Here

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,

Executes given calls and returns a number of possible traces for each call

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,

Query the node for a [FeeHistory] object. This objct contains information about the EIP-1559 base fee in past blocks, as well as gas utilization within those blocks.

impl<M: Middleware + ZKSProvider, S: Signer> ZKSProvider for SignerMiddleware<M, S>

type Provider = <M as Middleware>::Provider

type ZKProvider = <M as ZKSProvider>::ZKProvider

fn zk_estimate_gas<'life0, 'async_trait, T>( &'life0 self, transaction: T ) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>>where T: Debug + Serialize + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

fn estimate_fee<'life0, 'async_trait, T>( &'life0 self, transaction: T ) -> Pin<Box<dyn Future<Output = Result<Fee, ProviderError>> + Send + 'async_trait>>where T: Debug + Serialize + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Returns the fee for the transaction.

fn estimate_gas_l1_to_l2<'life0, 'async_trait, T>( &'life0 self, transaction: T ) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>>where T: Debug + Serialize + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Returns an estimate of the gas required for a L1 to L2 transaction.

fn get_all_account_balances<'life0, 'async_trait>( &'life0 self, address: Address ) -> Pin<Box<dyn Future<Output = Result<HashMap<Address, U256>, ProviderError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Returns all balances for confirmed tokens given by an account address.

fn get_block_details<'life0, 'async_trait, T>( &'life0 self, block: T ) -> Pin<Box<dyn Future<Output = Result<Option<BlockDetails>, ProviderError>> + Send + 'async_trait>>where T: Into<U64> + Send + Sync + Serialize + Debug + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Returns additional zkSync-specific information about the L2 block.

fn get_bridge_contracts<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<BridgeContracts, ProviderError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Returns L1/L2 addresses of default bridges.

fn get_bytecode_by_hash<'life0, 'async_trait>( &'life0 self, hash: H256 ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, ProviderError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Returns bytecode of a transaction given by its hash.

fn get_confirmed_tokens<'life0, 'async_trait>( &'life0 self, from: u32, limit: u8 ) -> Pin<Box<dyn Future<Output = Result<Vec<TokenInfo>, ProviderError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Returns [address, symbol, name, and decimal] information of all tokens within a range of ids given by parameters from and limit.

fn get_l1_batch_block_range<'life0, 'async_trait, T>( &'life0 self, batch_id: T ) -> Pin<Box<dyn Future<Output = Result<BlockRange, ProviderError>> + Send + 'async_trait>>where T: Into<U64> + Send + Sync + Serialize + Debug + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Returns the range of blocks contained within a batch given by batch number.

fn get_l1_batch_details<'life0, 'async_trait, T>( &'life0 self, batch_id: T ) -> Pin<Box<dyn Future<Output = Result<L1BatchDetails, ProviderError>> + Send + 'async_trait>>where T: Into<U64> + Send + Sync + Serialize + Debug + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Returns data pertaining to a given batch.

fn get_l2_to_l1_log_proof<'life0, 'async_trait>( &'life0 self, tx_hash: H256, l2_to_l1_log_index: Option<u64> ) -> Pin<Box<dyn Future<Output = Result<Option<Proof>, ProviderError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Given a transaction hash, and an index of the L2 to L1 log produced within the transaction, it returns the proof for the corresponding L2 to L1 log.

fn get_l2_to_l1_msg_proof<'life0, 'async_trait, T>( &'life0 self, block: T, sender: Address, msg: H256, l2_log_position: Option<u64> ) -> Pin<Box<dyn Future<Output = Result<Option<Proof>, ProviderError>> + Send + 'async_trait>>where T: Into<U64> + Send + Sync + Serialize + Debug + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Given a block, a sender, a message, and an optional message log index in the block containing the L1->L2 message, it returns the proof for the message sent via the L1Messenger system contract.

fn get_main_contract<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Address, ProviderError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Returns the address of the zkSync Era contract.

fn get_raw_block_transactions<'life0, 'async_trait, T>( &'life0 self, block: T ) -> Pin<Box<dyn Future<Output = Result<Vec<Transaction>, ProviderError>> + Send + 'async_trait>>where T: Into<U64> + Send + Sync + Serialize + Debug + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Returns data of transactions in a block.

fn get_testnet_paymaster<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Address, ProviderError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Returns the address of the testnet paymaster: the paymaster that is available on testnets and enables paying fees in ERC-20 compatible tokens.

fn get_token_price<'life0, 'async_trait>( &'life0 self, address: Address ) -> Pin<Box<dyn Future<Output = Result<String, ProviderError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Returns the price of a given token in USD.

fn get_transaction_details<'life0, 'async_trait>( &'life0 self, hash: H256 ) -> Pin<Box<dyn Future<Output = Result<Option<TransactionDetails>, ProviderError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Returns data from a specific transaction given by the transaction hash.

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

Returns the latest L1 batch number.

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

Returns the chain id of the underlying L1.

fn debug_trace_block_by_hash<'life0, 'async_trait>( &'life0 self, hash: H256, options: Option<TracerConfig> ) -> Pin<Box<dyn Future<Output = Result<DebugTrace, ProviderError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Returns debug trace of all executed calls contained in a block given by its L2 hash.

fn debug_trace_block_by_number<'life0, 'async_trait, T>( &'life0 self, block: T, options: Option<TracerConfig> ) -> Pin<Box<dyn Future<Output = Result<DebugTrace, ProviderError>> + Send + 'async_trait>>where T: Into<U64> + Send + Sync + Serialize + Debug + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Returns debug trace of all executed calls contained in a block given by its L2 block number.

fn debug_trace_call<'life0, 'async_trait, R, T>( &'life0 self, request: R, block: Option<T>, options: Option<TracerConfig> ) -> Pin<Box<dyn Future<Output = Result<DebugTrace, ProviderError>> + Send + 'async_trait>>where R: Debug + Serialize + Send + Sync + 'async_trait, T: Into<U64> + Send + Sync + Serialize + Debug + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Returns debug trace containing information on a specific calls given by the call request.

fn debug_trace_transaction<'life0, 'async_trait>( &'life0 self, hash: H256, options: Option<TracerConfig> ) -> Pin<Box<dyn Future<Output = Result<DebugTrace, ProviderError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Uses the EVM’s callTracer to return a debug trace of a specific transaction given by its transaction hash.

fn send_eip712<'life0, 'life1, 'life2, 'async_trait, D>( &'life0 self, wallet: &'life1 Wallet<D>, contract_address: Address, function_signature: &'life2 str, function_parameters: Option<Vec<String>>, overrides: Option<Overrides> ) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'_, Self::ZKProvider>, ProviderError>> + Send + 'async_trait>>where D: PrehashSigner<(RecoverableSignature, RecoveryId)> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn send<'life0, 'life1, 'life2, 'async_trait, D>( &'life0 self, wallet: &'life1 Wallet<D>, contract_address: Address, function_signature: &'life2 str, function_parameters: Option<Vec<String>>, _overrides: Option<Overrides> ) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'_, Self::Provider>, ProviderError>> + Send + 'async_trait>>where D: PrehashSigner<(RecoverableSignature, RecoveryId)> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn send_transaction_eip712<'life0, 'life1, 'async_trait, T, D>( &'life0 self, wallet: &'life1 Wallet<D>, transaction: T ) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'_, Self::ZKProvider>, ProviderError>> + Send + 'async_trait>>where T: TryInto<Eip712TransactionRequest> + Sync + Send + Debug + 'async_trait, D: PrehashSigner<(RecoverableSignature, RecoveryId)> + Send + Sync + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn wait_for_finalize<'life0, 'async_trait>( &'life0 self, transaction_receipt: TxHash, polling_time_in_seconds: Option<Duration>, timeout_in_seconds: Option<Duration> ) -> Pin<Box<dyn Future<Output = Result<TransactionReceipt, ProviderError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

fn call<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 CallRequest ) -> Pin<Box<dyn Future<Output = Result<Vec<Token>, ProviderError>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,