Struct TestAccount 

pub struct TestAccount { /* private fields */ }

A test account that tracks its nonce, e.g. one of the accounts funded by the test_genesis.

Self::sign_tx_bytes fills the nonce, chain id, gas limit and fees of transaction requests that do not set them, so tests only need to set the fields they care about. The gas limit and fees default to Self::DEFAULT_GAS_LIMIT and the DEFAULT_*_FEE_PER_GAS constants and can be changed once per account with Self::with_gas_limit and Self::with_fees.

Self::tx and its shortcuts Self::call, Self::transfer and Self::deploy build and sign a transaction in a single expression:

let mut account = wallet.account(0).with_fees(max_fee_per_gas, max_priority_fee_per_gas);
let contract = account.next_contract_address();
let deploy = account.deploy(init_code).await;
let call = account.call(contract, calldata).gas_limit(100_000).await;

Implementations

impl TestAccount

pub const DEFAULT_GAS_LIMIT: u64 = 1_000_000

Initial gas limit of transactions signed by Self::sign_tx_bytes that do not set one.

pub const DEFAULT_MAX_FEE_PER_GAS: u128 = 1_000_000_000_000

Initial max fee per gas of transactions signed by Self::sign_tx_bytes that set no fees.

High enough that transactions are accepted regardless of the base fee of test chains.

pub const DEFAULT_MAX_PRIORITY_FEE_PER_GAS: u128 = 1_000_000_000

Initial max priority fee per gas of transactions signed by Self::sign_tx_bytes that set no fees.

pub const fn new(signer: PrivateKeySigner, chain_id: u64) -> Self

Creates a new account for the given signer and chain id, starting at nonce 0.

pub const fn with_gas_limit(self, gas_limit: u64) -> Self

Sets the gas limit of signed transactions that do not set one.

pub const fn with_fees( self, max_fee_per_gas: u128, max_priority_fee_per_gas: u128, ) -> Self

Sets the EIP-1559 fees of signed transactions that set neither these fees nor a legacy gas price.

pub const fn signer(&self) -> &PrivateKeySigner

Returns the signer of the account.

pub const fn address(&self) -> Address

Returns the address of the account.

pub const fn chain_id(&self) -> u64

Returns the chain id transactions of the account are signed for.

pub const fn nonce(&self) -> u64

Returns the nonce of the next transaction of the account.

pub const fn next_nonce(&mut self) -> u64

Returns the nonce of the next transaction and increments it.

pub async fn sync_nonce<N: Network>( &mut self, provider: &impl Provider<N>, ) -> Result<u64>

Sets the nonce to the pending transaction count of the account on the node behind provider, and returns it.

pub async fn sign_tx_bytes(&mut self, tx: TransactionRequest) -> Bytes

Signs the transaction request, returning the EIP-2718 encoded bytes.

Fills unset fields: the nonce with Self::next_nonce, the chain id, gas limit and, unless the request sets a legacy gas price, the EIP-1559 fees of the account. An explicit nonce does not advance the tracked nonce. Contract creations must set to, e.g. with [TransactionRequest::create] or Self::deploy.

See Self::sign_request for other networks.

Panics

If the request can not be built into a signed transaction.

pub fn next_contract_address(&self) -> Address

Returns the address of the contract created by the next transaction of the account, if it is a contract creation that does not set an explicit nonce.

pub fn tx(&mut self) -> TestTx<'_>

Starts building a transaction of the account that sets no fields yet.

See Self::tx_for for other networks.

pub fn call(&mut self, to: Address, input: impl Into<Bytes>) -> TestTx<'_>

Starts building a call of to with the given input.

pub fn transfer(&mut self, to: Address, value: U256) -> TestTx<'_>

Starts building a transfer of value to to.

pub fn deploy(&mut self, init_code: impl Into<Bytes>) -> TestTx<'_>

Starts building a contract creation with the given init code.

See Self::next_contract_address for the address of the created contract.

pub async fn sign_request<N: Network>( &mut self, tx: N::TransactionRequest, ) -> Bytes

where EthereumWallet: NetworkWallet<N>,

Signs the transaction request of the network N like Self::sign_tx_bytes, returning the EIP-2718 encoded bytes.

Only the secp256k1 key of the account signs, so transactions of networks that are signed with other keys, e.g. P256 or passkeys, need their own wallets. Transactions using a network-specific nonce scheme, such as 2D nonces, should set an explicit nonce so that the tracked protocol nonce is not advanced.

Panics

If the request can not be built into a signed transaction.

pub fn tx_for<N: Network>(&mut self) -> TestTx<'_, N>

Starts building a transaction of the network N that sets no fields yet.

The shortcuts Self::call, Self::transfer and Self::deploy build Ethereum transactions; for other networks, use the setters of TestTx, e.g. account.tx_for::<N>().to(to).input(input). See Self::sign_request for the limits.

Trait Implementations

impl Clone for TestAccount

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TestAccount

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

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 240 bytes