Struct FillProvider

pub struct FillProvider<F, P, N = Ethereum>
where
    F: TxFiller<N>,
    P: Provider<N>,
    N: Network,
{ /* private fields */ }

A Provider that applies one or more TxFillers.

Fills arbitrary properties in a transaction request by composing multiple fill layers. This struct should always be the outermost layer in a provider stack, and this is enforced when using ProviderBuilder::filler to construct this layer.

Users should NOT use this struct directly. Instead, use ProviderBuilder::filler to construct and apply it to a stack.

Implementations

impl<F, P, N> FillProvider<F, P, N>

where F: TxFiller<N>, P: Provider<N>, N: Network,

pub fn new(inner: P, filler: F) -> Self

Creates a new FillProvider with the given filler and inner provider.

pub fn join_with<Other: TxFiller<N>>( self, other: Other, ) -> FillProvider<JoinFill<F, Other>, P, N>

Joins a filler to this provider

pub async fn fill( &self, tx: N::TransactionRequest, ) -> TransportResult<SendableTx<N>>

Fills the transaction request, using the configured fillers

pub fn prepare_call( &self, tx: N::TransactionRequest, ) -> TransportResult<N::TransactionRequest>

Prepares a transaction request for eth_call operations using the configured fillers

Trait Implementations

impl<F, P, N> Clone for FillProvider<F, P, N>

where F: TxFiller<N> + Clone, P: Provider<N> + Clone, N: Network + Clone,

fn clone(&self) -> FillProvider<F, P, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F, P, N> Debug for FillProvider<F, P, N>

where F: TxFiller<N> + Debug, P: Provider<N> + Debug, N: Network + Debug,

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

Formats the value using the given formatter.

impl<F, P, N> Provider<N> for FillProvider<F, P, N>

where F: TxFiller<N>, P: Provider<N>, N: Network,

fn root(&self) -> &RootProvider<N>

Returns the root provider.

fn get_accounts(&self) -> ProviderCall<NoParams, Vec<Address>>

Gets the accounts in the remote node. This is usually empty unless you’re using a local node.

fn get_blob_base_fee(&self) -> ProviderCall<NoParams, U128, u128>

Returns the base fee per blob gas (blob gas price) in wei.

fn get_block_number(&self) -> ProviderCall<NoParams, U64, BlockNumber>

Get the last block number available.

fn call<'req>(&self, tx: N::TransactionRequest) -> EthCall<N, Bytes>

Execute a smart contract call with a transaction request and state overrides, without publishing a transaction.

fn call_many<'req>( &self, bundles: &'req Vec<Bundle>, ) -> EthCallMany<'req, N, Vec<Vec<EthCallResponse>>>

Execute a list of Bundle against the provided StateContext and StateOverride, without publishing a transaction.

fn simulate<'req>( &self, payload: &'req SimulatePayload, ) -> RpcWithBlock<&'req SimulatePayload, Vec<SimulatedBlock<N::BlockResponse>>>

Executes an arbitrary number of transactions on top of the requested state.

fn get_chain_id(&self) -> ProviderCall<NoParams, U64, u64>

Gets the chain ID.

fn create_access_list<'a>( &self, request: &'a N::TransactionRequest, ) -> RpcWithBlock<&'a N::TransactionRequest, AccessListResult>

Create an EIP-2930 access list.

fn estimate_gas<'req>(&self, tx: N::TransactionRequest) -> EthCall<N, U64, u64>

Create an EthCall future to estimate the gas required for a transaction.

fn get_fee_history<'life0, 'life1, 'async_trait>( &'life0 self, block_count: u64, last_block: BlockNumberOrTag, reward_percentiles: &'life1 [f64], ) -> Pin<Box<dyn Future<Output = TransportResult<FeeHistory>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns a collection of historical gas information FeeHistory which can be used to calculate the EIP1559 fields maxFeePerGas and maxPriorityFeePerGas. block_count can range from 1 to 1024 blocks in a single request.

fn get_gas_price(&self) -> ProviderCall<NoParams, U128, u128>

Gets the current gas price in wei.

fn get_account(&self, address: Address) -> RpcWithBlock<Address, Account>

Retrieves account information (Account) for the given Address at the particular BlockId.

fn get_balance(&self, address: Address) -> RpcWithBlock<Address, U256, U256>

Gets the balance of the account.

fn get_block(&self, block: BlockId) -> EthGetBlock<N::BlockResponse>

Gets a block by either its hash, tag, or number

fn get_block_by_hash(&self, hash: BlockHash) -> EthGetBlock<N::BlockResponse>

Gets a block by its BlockHash

fn get_block_by_number( &self, number: BlockNumberOrTag, ) -> EthGetBlock<N::BlockResponse>

Gets a block by its BlockNumberOrTag

fn get_block_transaction_count_by_hash<'life0, 'async_trait>( &'life0 self, hash: BlockHash, ) -> Pin<Box<dyn Future<Output = TransportResult<Option<u64>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the number of transactions in a block from a block matching the given block hash.

fn get_block_transaction_count_by_number<'life0, 'async_trait>( &'life0 self, block_number: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = TransportResult<Option<u64>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the number of transactions in a block matching the given block number.

fn get_block_receipts( &self, block: BlockId, ) -> ProviderCall<(BlockId,), Option<Vec<N::ReceiptResponse>>>

Gets the selected block BlockId receipts.

fn get_code_at(&self, address: Address) -> RpcWithBlock<Address, Bytes>

Gets the bytecode located at the corresponding Address.

fn watch_blocks<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TransportResult<FilterPollerBuilder<B256>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Watch for new blocks by polling the provider with eth_getFilterChanges.

fn watch_pending_transactions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TransportResult<FilterPollerBuilder<B256>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Watch for new pending transaction by polling the provider with eth_getFilterChanges.

fn watch_logs<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 Filter, ) -> Pin<Box<dyn Future<Output = TransportResult<FilterPollerBuilder<Log>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Watch for new logs using the given filter by polling the provider with eth_getFilterChanges.

fn watch_full_pending_transactions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TransportResult<FilterPollerBuilder<N::TransactionResponse>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Watch for new pending transaction bodies by polling the provider with eth_getFilterChanges.

fn get_filter_changes_dyn<'life0, 'async_trait>( &'life0 self, id: U256, ) -> Pin<Box<dyn Future<Output = TransportResult<FilterChanges>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get a list of values that have been added since the last poll.

fn get_filter_logs<'life0, 'async_trait>( &'life0 self, id: U256, ) -> Pin<Box<dyn Future<Output = TransportResult<Vec<Log>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieves a Vec<Log> for the given filter ID.

fn uninstall_filter<'life0, 'async_trait>( &'life0 self, id: U256, ) -> Pin<Box<dyn Future<Output = TransportResult<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Request provider to uninstall the filter with the given ID.

fn watch_pending_transaction<'life0, 'async_trait>( &'life0 self, config: PendingTransactionConfig, ) -> Pin<Box<dyn Future<Output = Result<PendingTransaction, PendingTransactionError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Watch for the confirmation of a single pending transaction with the given configuration.

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

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves a Vec<Log> with the given Filter.

fn get_proof( &self, address: Address, keys: Vec<StorageKey>, ) -> RpcWithBlock<(Address, Vec<StorageKey>), EIP1186AccountProofResponse>

Get the account and storage values of the specified account including the merkle proofs.

fn get_storage_at( &self, address: Address, key: U256, ) -> RpcWithBlock<(Address, U256), StorageValue>

Gets the specified storage value from Address.

fn get_transaction_by_hash( &self, hash: TxHash, ) -> ProviderCall<(TxHash,), Option<N::TransactionResponse>>

Gets a transaction by its TxHash.

fn get_transaction_by_block_hash_and_index( &self, block_hash: B256, index: usize, ) -> ProviderCall<(B256, Index), Option<N::TransactionResponse>>

Gets a transaction by block hash and transaction index position.

fn get_raw_transaction_by_block_hash_and_index( &self, block_hash: B256, index: usize, ) -> ProviderCall<(B256, Index), Option<Bytes>>

Gets a raw transaction by block hash and transaction index position.

fn get_transaction_by_block_number_and_index( &self, block_number: BlockNumberOrTag, index: usize, ) -> ProviderCall<(BlockNumberOrTag, Index), Option<N::TransactionResponse>>

Gets a transaction by block number and transaction index position.

fn get_raw_transaction_by_block_number_and_index( &self, block_number: BlockNumberOrTag, index: usize, ) -> ProviderCall<(BlockNumberOrTag, Index), Option<Bytes>>

Gets a raw transaction by block number and transaction index position.

fn get_raw_transaction_by_hash( &self, hash: TxHash, ) -> ProviderCall<(TxHash,), Option<Bytes>>

Returns the EIP-2718 encoded transaction if it exists, see also Decodable2718.

fn get_transaction_count( &self, address: Address, ) -> RpcWithBlock<Address, U64, u64, fn(U64) -> u64>

Gets the transaction count (AKA “nonce”) of the corresponding address.

fn get_transaction_receipt( &self, hash: TxHash, ) -> ProviderCall<(TxHash,), Option<N::ReceiptResponse>>

Gets a transaction receipt if it exists, by its TxHash.

fn get_uncle<'life0, 'async_trait>( &'life0 self, tag: BlockId, idx: u64, ) -> Pin<Box<dyn Future<Output = TransportResult<Option<N::BlockResponse>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets an uncle block through the tag BlockId and index u64.

fn get_uncle_count<'life0, 'async_trait>( &'life0 self, tag: BlockId, ) -> Pin<Box<dyn Future<Output = TransportResult<u64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets the number of uncles for the block specified by the tag BlockId.

fn get_max_priority_fee_per_gas(&self) -> ProviderCall<NoParams, U128, u128>

Returns a suggestion for the current maxPriorityFeePerGas in wei.

fn new_block_filter<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TransportResult<U256>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Notify the provider that we are interested in new blocks.

fn new_filter<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 Filter, ) -> Pin<Box<dyn Future<Output = TransportResult<U256>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Notify the provider that we are interested in logs that match the given filter.

fn new_pending_transactions_filter<'life0, 'async_trait>( &'life0 self, full: bool, ) -> Pin<Box<dyn Future<Output = TransportResult<U256>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Notify the provider that we are interested in new pending transactions.

fn send_raw_transaction<'life0, 'life1, 'async_trait>( &'life0 self, encoded_tx: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = TransportResult<PendingTransactionBuilder<N>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Broadcasts a raw transaction RLP bytes to the network.

fn send_raw_transaction_conditional<'life0, 'life1, 'async_trait>( &'life0 self, encoded_tx: &'life1 [u8], conditional: TransactionConditional, ) -> Pin<Box<dyn Future<Output = TransportResult<PendingTransactionBuilder<N>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Broadcasts a raw transaction RLP bytes with a conditional TransactionConditional to the network.

fn subscribe_blocks<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TransportResult<Subscription<N::HeaderResponse>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Available on crate feature pubsub only.

Subscribe to a stream of new block headers.

fn subscribe_pending_transactions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TransportResult<Subscription<B256>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Available on crate feature pubsub only.

Subscribe to a stream of pending transaction hashes.

fn subscribe_full_pending_transactions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TransportResult<Subscription<N::TransactionResponse>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Available on crate feature pubsub only.

Subscribe to a stream of pending transaction bodies.

fn subscribe_logs<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 Filter, ) -> Pin<Box<dyn Future<Output = TransportResult<Subscription<Log>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Available on crate feature pubsub only.

Subscribe to a stream of logs matching given filter.

fn unsubscribe<'life0, 'async_trait>( &'life0 self, id: B256, ) -> Pin<Box<dyn Future<Output = TransportResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Available on crate feature pubsub only.

Cancels a subscription given the subscription ID.

fn syncing(&self) -> ProviderCall<NoParams, SyncStatus>

Gets syncing info.

fn get_client_version(&self) -> ProviderCall<NoParams, String>

Gets the client version.

fn get_sha3(&self, data: &[u8]) -> ProviderCall<(String,), B256>

Gets the Keccak-256 hash of the given data.

fn get_net_version(&self) -> ProviderCall<NoParams, U64, u64>

Gets the network ID. Same as eth_chainId.

fn raw_request_dyn<'life0, 'life1, 'async_trait>( &'life0 self, method: Cow<'static, str>, params: &'life1 RawValue, ) -> Pin<Box<dyn Future<Output = TransportResult<Box<RawValue>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Sends a raw JSON-RPC request with type-erased parameters and return.

fn transaction_request(&self) -> N::TransactionRequest

Creates a new TransactionRequest.

fn builder() -> ProviderBuilder<Identity, Identity, N>

where Self: Sized,

Returns the ProviderBuilder to build on.

fn client(&self) -> ClientRef<'_>

Returns the RPC client used to send requests.

fn weak_client(&self) -> WeakClient

Returns a Weak RPC client used to send requests.

fn erased(self) -> DynProvider<N>

where Self: Sized + 'static,

Returns a type erased provider wrapped in Arc. See DynProvider.

fn multicall(&self) -> MulticallBuilder<Empty, &Self, N>

where Self: Sized,

Execute a multicall by leveraging the MulticallBuilder.

fn estimate_eip1559_fees_with<'life0, 'async_trait>( &'life0 self, estimator: Eip1559Estimator, ) -> Pin<Box<dyn Future<Output = TransportResult<Eip1559Estimation>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Estimates the EIP1559 maxFeePerGas and maxPriorityFeePerGas fields.

fn estimate_eip1559_fees<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TransportResult<Eip1559Estimation>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Estimates the EIP1559 maxFeePerGas and maxPriorityFeePerGas fields.

fn get_filter_changes<'life0, 'async_trait, R>( &'life0 self, id: U256, ) -> Pin<Box<dyn Future<Output = TransportResult<Vec<R>>> + Send + 'async_trait>>

where Self: Sized + 'async_trait, R: 'async_trait + RpcRecv, 'life0: 'async_trait,

Get a list of values that have been added since the last poll.

fn send_transaction<'life0, 'async_trait>( &'life0 self, tx: N::TransactionRequest, ) -> Pin<Box<dyn Future<Output = TransportResult<PendingTransactionBuilder<N>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Broadcasts a transaction to the network.

fn send_tx_envelope<'life0, 'async_trait>( &'life0 self, tx: N::TxEnvelope, ) -> Pin<Box<dyn Future<Output = TransportResult<PendingTransactionBuilder<N>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Broadcasts a transaction envelope to the network.

fn subscribe<'life0, 'async_trait, P, R>( &'life0 self, params: P, ) -> Pin<Box<dyn Future<Output = TransportResult<Subscription<R>>> + Send + 'async_trait>>

where P: RpcSend + 'async_trait, R: RpcRecv + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait,

Available on crate feature pubsub only.

Subscribe to an RPC event.

fn raw_request<'life0, 'async_trait, P, R>( &'life0 self, method: Cow<'static, str>, params: P, ) -> Pin<Box<dyn Future<Output = TransportResult<R>> + Send + 'async_trait>>

where P: RpcSend + 'async_trait, R: RpcRecv + 'async_trait, Self: Sized + 'async_trait, 'life0: 'async_trait,

Sends a raw JSON-RPC request.

impl<F, P, N> WalletProvider<N> for FillProvider<F, P, N>

where F: TxFiller<N> + WalletProvider<N>, P: Provider<N>, N: Network,

type Wallet = <F as WalletProvider<N>>::Wallet

The underlying NetworkWallet type contained in this stack.

fn wallet(&self) -> &Self::Wallet

Get a reference to the underlying wallet.

fn wallet_mut(&mut self) -> &mut Self::Wallet

Get a mutable reference to the underlying wallet.

fn default_signer_address(&self) -> Address

Get the default signer address.

fn has_signer_for(&self, address: &Address) -> bool

Check if the signer can sign for the given address.

fn signer_addresses(&self) -> impl Iterator<Item = Address>

Get an iterator of all signer addresses. Note that because the signer always has at least one address, this iterator will always have at least one element.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.