Struct NonceFiller

pub struct NonceFiller<M: NonceManager = CachedNonceManager> { /* private fields */ }

A TxFiller that fills nonces on transactions. The behavior of filling nonces is determined by the NonceManager.

Note

• If the transaction request does not have a sender set, this layer will not fill nonces.
• Using two providers with their own nonce layer can potentially fill invalid nonces if transactions are sent from the same address, as the next nonce to be used is cached internally in the layer.

Example

let pk: PrivateKeySigner = "0x...".parse()?;
let provider = ProviderBuilder::<_, _, Ethereum>::default()
    .with_simple_nonce_management()
    .wallet(pk)
    .connect_http(url);

provider.send_transaction(TransactionRequest::default()).await;

Implementations

impl<M: NonceManager> NonceFiller<M>

pub const fn new(nonce_manager: M) -> Self

Creates a new NonceFiller with the specified NonceManager.

To instantiate with the SimpleNonceManager, use NonceFiller::simple().

To instantiate with the CachedNonceManager, use NonceFiller::cached().

pub const fn simple() -> NonceFiller<SimpleNonceManager>

Creates a new NonceFiller with the SimpleNonceManager.

SimpleNonceManager will fetch the transaction count for any new account it sees, resulting in frequent RPC calls.

pub fn cached() -> NonceFiller<CachedNonceManager>

Creates a new NonceFiller with the CachedNonceManager.

CachedNonceManager will fetch the transaction count for any new account it sees, store it locally and increment the locally stored nonce as transactions are sent via Provider::send_transaction, reducing the number of RPC calls.

Trait Implementations

impl<M: Clone + NonceManager> Clone for NonceFiller<M>

fn clone(&self) -> NonceFiller<M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug + NonceManager> Debug for NonceFiller<M>

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

Formats the value using the given formatter.

impl<M: Default + NonceManager> Default for NonceFiller<M>

fn default() -> NonceFiller<M>

Returns the “default value” for a type.

impl<M: NonceManager, N: Network> TxFiller<N> for NonceFiller<M>

type Fillable = u64

The properties that this filler retrieves from the RPC. to fill in the TransactionRequest.

fn status(&self, tx: &<N as Network>::TransactionRequest) -> FillerControlFlow

Return a control-flow enum indicating whether the filler is ready to fill in the transaction request, or if it is missing required properties.

fn fill_sync(&self, _tx: &mut SendableTx<N>)

Performs any synchronous filling. This should be called before TxFiller::prepare and TxFiller::fill to fill in any properties that can be filled synchronously.

async fn prepare<P>( &self, provider: &P, tx: &N::TransactionRequest, ) -> TransportResult<Self::Fillable>

where P: Provider<N>,

Prepares fillable properties, potentially by making an RPC request.

async fn fill( &self, nonce: Self::Fillable, tx: SendableTx<N>, ) -> TransportResult<SendableTx<N>>

Fills in the transaction request with the fillable properties.

fn join_with<T>(self, other: T) -> JoinFill<Self, T>

where T: TxFiller<N>,

Joins this filler with another filler to compose multiple fillers.

fn continue_filling(&self, tx: &SendableTx<N>) -> bool

Returns true if the filler should continue filling.

fn ready(&self, tx: &N::TransactionRequest) -> bool

Returns true if the filler is ready to fill in the transaction request.

fn finished(&self, tx: &N::TransactionRequest) -> bool

Returns true if the filler is finished filling in the transaction request.

fn fill_envelope( &self, fillable: Self::Fillable, tx: SendableTx<N>, ) -> impl Send + Future<Output = Result<N::TxEnvelope, FillEnvelopeError<N::TransactionRequest>>>

Fills in the transaction request and try to convert it to an envelope.

fn prepare_and_fill<P>( &self, provider: &P, tx: SendableTx<N>, ) -> impl Send + Future<Output = TransportResult<SendableTx<N>>>

where P: Provider<N>,

Prepares and fills the transaction request with the fillable properties.

fn prepare_call( &self, tx: &mut N::TransactionRequest, ) -> impl Send + Future<Output = TransportResult<()>>

Prepares transaction request with necessary fillers required for eth_call operations asynchronously

fn prepare_call_sync( &self, tx: &mut N::TransactionRequest, ) -> TransportResult<()>

Prepares transaction request with necessary fillers required for eth_call operations synchronously