Struct JoinFill

pub struct JoinFill<L, R> { /* private fields */ }

A layer that can fill in a TransactionRequest with additional information by joining two TxFillers.

This struct is itself a TxFiller, and can be nested to compose any number of fill layers.

Implementations

impl<L, R> JoinFill<L, R>

pub const fn new(left: L, right: R) -> Self

Creates a new JoinFill with the given layers.

pub const fn left(&self) -> &L

Get a reference to the left filler.

pub const fn right(&self) -> &R

Get a reference to the right filler.

Trait Implementations

impl<L: Clone, R: Clone> Clone for JoinFill<L, R>

fn clone(&self) -> JoinFill<L, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: Debug, R: Debug> Debug for JoinFill<L, R>

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

Formats the value using the given formatter.

impl<L: Default, R: Default> Default for JoinFill<L, R>

fn default() -> JoinFill<L, R>

Returns the “default value” for a type.

impl<L, R, P, N> ProviderLayer<P, N> for JoinFill<L, R>

where L: TxFiller<N>, R: TxFiller<N>, P: Provider<N>, N: Network,

type Provider = FillProvider<JoinFill<L, R>, P, N>

The provider constructed by this layer.

fn layer(&self, inner: P) -> Self::Provider

Wrap the given provider in the layer’s provider.

impl<L, R, N> TxFiller<N> for JoinFill<L, R>

where L: TxFiller<N>, R: TxFiller<N>, N: Network,

type Fillable = (Option<<L as TxFiller<N>>::Fillable>, Option<<R as TxFiller<N>>::Fillable>)

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

fn status(&self, tx: &N::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, to_fill: Self::Fillable, tx: SendableTx<N>, ) -> TransportResult<SendableTx<N>>

Fills in the transaction request with the fillable properties.

async fn prepare_call( &self, tx: &mut <N as Network>::TransactionRequest, ) -> TransportResult<()>

Prepares transaction request with necessary fillers required for eth_call operations asynchronously

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

Prepares transaction request with necessary fillers required for eth_call operations synchronously

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.

impl<L, R, N> WalletProvider<N> for JoinFill<L, R>

where R: WalletProvider<N>, N: Network,

type Wallet = <R 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.

impl<L: Copy, R: Copy> Copy for JoinFill<L, R>