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

Example

async fn example() -> Result<(), Box<dyn std::error::Error>> {
    // Create transaction request
    let tx_request = TransactionRequest::default()
        .with_from(address!("d8dA6BF26964aF9D7eEd9e03E53415D37aA96045"))
        .with_value(U256::from(1000));

    let provider = ProviderBuilder::new().connect_anvil_with_wallet();

    // Fill transaction with provider data
    let filled_tx = provider.fill(tx_request).await?;

    // Build unsigned transaction
    let typed_tx =
        filled_tx.as_builder().expect("filled tx is a builder").clone().build_unsigned()?;

    // Encode, e.g. for offline signing
    let mut encoded = Vec::new();
    typed_tx.encode_for_signing(&mut encoded);

    // Decode unsigned transaction
    let decoded = TypedTransaction::decode_unsigned(&mut encoded.as_slice())?;

    Ok(())
}

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 duplicate 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 [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_info( &self, address: Address, ) -> RpcWithBlock<Address, AccountInfo>

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

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_sender_nonce( &self, sender: Address, nonce: u64, ) -> ProviderCall<(Address, U64), Option<N::TransactionResponse>>

Gets a transaction by its sender and nonce.

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 sign_transaction<'life0, 'async_trait>( &'life0 self, tx: N::TransactionRequest, ) -> Pin<Box<dyn Future<Output = TransportResult<Bytes>> + Send + 'async_trait>>

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

Signs a transaction that can be submitted to the network later using Provider::send_raw_transaction.

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 get_block_number_by_id<'life0, 'async_trait>( &'life0 self, block_id: BlockId, ) -> Pin<Box<dyn Future<Output = TransportResult<Option<BlockNumber>>> + Send + 'async_trait>>

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

Get the block number for a given block identifier.

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 watch_full_blocks<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TransportResult<WatchBlocks<N::BlockResponse>>> + Send + 'async_trait>>

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

Watch for new blocks by polling the provider with eth_getFilterChanges and transforming the returned block hashes into full blocks bodies.

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_raw_transaction_sync<'life0, 'life1, 'async_trait>( &'life0 self, encoded_tx: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = TransportResult<N::ReceiptResponse>> + Send + 'async_trait>>

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

Broadcasts a raw transaction RLP bytes to the network and returns the transaction receipt after it has been mined.

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 send_transaction_sync<'life0, 'async_trait>( &'life0 self, tx: N::TransactionRequest, ) -> Pin<Box<dyn Future<Output = TransportResult<N::ReceiptResponse>> + Send + 'async_trait>>

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

Sends a transaction and waits for its receipt in a single call.

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.