Struct WalletFiller

pub struct WalletFiller<W> { /* private fields */ }

A layer that signs transactions locally.

The layer uses a NetworkWallet to sign transactions sent using Provider::send_transaction locally before passing them to the node with Provider::send_raw_transaction.

Example

let pk: PrivateKeySigner = "0x...".parse()?;
let provider = ProviderBuilder::new().wallet(pk).connect_http(url);

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

Implementations

impl<W> WalletFiller<W>

pub const fn new(wallet: W) -> Self

Creates a new wallet layer with the given wallet.

Trait Implementations

impl<W> AsMut<W> for WalletFiller<W>

fn as_mut(&mut self) -> &mut W

Converts this type into a mutable reference of the (usually inferred) input type.

impl<W> AsRef<W> for WalletFiller<W>

fn as_ref(&self) -> &W

Converts this type into a shared reference of the (usually inferred) input type.

impl<W: Clone> Clone for WalletFiller<W>

fn clone(&self) -> WalletFiller<W>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<W: Debug> Debug for WalletFiller<W>

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

Formats the value using the given formatter.

impl<W, N> TxFiller<N> for WalletFiller<W>

where N: Network, W: NetworkWallet<N> + Clone,

type Fillable = ()

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 as Network>::TransactionRequest, ) -> TransportResult<Self::Fillable>

where P: Provider<N>,

Prepares fillable properties, potentially by making an RPC request.

async fn fill( &self, _fillable: 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::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<W, N> WalletProvider<N> for WalletFiller<W>

where W: NetworkWallet<N> + Clone, N: Network,

type Wallet = W

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.