Struct alloy_provider::fillers::NonceFiller

pub struct NonceFiller<M: NonceManager = SimpleNonceManager> { /* 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 provider = ProviderBuilder::new()
    .with_simple_nonce_management()
    .wallet(wallet)
    .on_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.

Trait Implementations

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

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

Returns a copy 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, T>( &self, provider: &P, tx: &N::TransactionRequest, ) -> TransportResult<Self::Fillable>

where P: Provider<T, N>, T: Transport + Clone,

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 is 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 prepare_and_fill<P, T>( &self, provider: &P, tx: SendableTx<N>, ) -> impl Send + Future<Output = TransportResult<SendableTx<N>>>

where P: Provider<T, N>, T: Transport + Clone,

Prepares and fills the transaction request with the fillable properties.