Struct ethers_middleware::signer::SignerMiddleware

pub struct SignerMiddleware<M, S> { /* fields omitted */ }

Middleware used for locally signing transactions, compatible with any implementer of the Signer trait.

Example

use ethers::{
    providers::{Middleware, Provider, Http},
    signers::LocalWallet,
    middleware::SignerMiddleware,
    types::{Address, TransactionRequest},
};
use std::convert::TryFrom;

let provider = Provider::<Http>::try_from("http://localhost:8545")
    .expect("could not instantiate HTTP Provider");

// Transactions will be signed with the private key below and will be broadcast
// via the eth_sendRawTransaction API)
let wallet: LocalWallet = "380eb0f3d505f087e438eca80bc4df9a7faa24f868e69fc0440261a0fc0567dc"
    .parse()?;

let mut client = SignerMiddleware::new(provider, wallet);

// You can sign messages with the key
let signed_msg = client.sign(b"hello".to_vec(), &client.address()).await?;

// ...and sign transactions
let tx = TransactionRequest::pay("vitalik.eth", 100);
let pending_tx = client.send_transaction(tx, None).await?;

// You can `await` on the pending transaction to get the receipt with a pre-specified
// number of confirmations
let receipt = pending_tx.confirmations(6).await?;

// You can connect with other wallets at runtime via the `with_signer` function
let wallet2: LocalWallet = "cd8c407233c0560f6de24bb2dc60a8b02335c959a1a17f749ce6c1ccf63d74a7"
    .parse()?;

let signed_msg2 = client.with_signer(wallet2).sign(b"hello".to_vec(), &client.address()).await?;

// This call will be made with `wallet2` since `with_signer` takes a mutable reference.
let tx2 = TransactionRequest::new()
    .to("0xd8da6bf26964af9d7eed9e03e53415d37aa96045".parse::<Address>()?)
    .value(200);
let tx_hash2 = client.send_transaction(tx2, None).await?;

Implementations

impl<M, S> SignerMiddleware<M, S> where
    M: Middleware,
    S: Signer, 

pub fn new(inner: M, signer: S) -> Self

Creates a new client from the provider and signer.

pub fn address(&self) -> Address

Returns the client's address

pub fn signer(&self) -> &S

Returns a reference to the client's signer

pub fn with_signer(&self, signer: S) -> Self where
    S: Clone,
    M: Clone, 

Trait Implementations

impl<M: Clone, S: Clone> Clone for SignerMiddleware<M, S>

pub fn clone(&self) -> SignerMiddleware<M, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: Debug, S: Debug> Debug for SignerMiddleware<M, S>

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

Formats the value using the given formatter.

impl<M, S> Middleware for SignerMiddleware<M, S> where
    M: Middleware,
    S: Signer, 

type Error = SignerMiddlewareError<M, S>

type Provider = M::Provider

type Inner = M

pub fn inner(&self) -> &M

The next middleware in the stack

pub fn send_transaction<'life0, 'async_trait>(
    &'life0 self,
    tx: TransactionRequest,
    block: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'_, Self::Provider>, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Signs and broadcasts the transaction. The optional parameter block can be passed so that gas cost and nonce calculations take it into account. For simple transactions this can be left to None.

pub fn sign<'life0, 'life1, 'async_trait, T: Into<Bytes> + Send + Sync>(
    &'life0 self,
    data: T,
    __arg2: &'life1 Address
) -> Pin<Box<dyn Future<Output = Result<Signature, Self::Error>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Signs a message with the internal signer, or if none is present it will make a call to the connected node's eth_call API.

pub fn provider(&self) -> &Provider<Self::Provider>

The HTTP or Websocket provider.

#[must_use]pub fn get_block_number<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<U64, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn resolve_name<'life0, 'life1, 'async_trait>(
    &'life0 self,
    ens_name: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<H160, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn lookup_address<'life0, 'async_trait>(
    &'life0 self,
    address: H160
) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn get_block<'life0, 'async_trait, T>(
    &'life0 self,
    block_hash_or_number: T
) -> Pin<Box<dyn Future<Output = Result<Option<Block<H256>>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Into<BlockId> + Send + Sync + 'async_trait, 

#[must_use]pub fn get_block_with_txs<'life0, 'async_trait, T>(
    &'life0 self,
    block_hash_or_number: T
) -> Pin<Box<dyn Future<Output = Result<Option<Block<Transaction>>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Into<BlockId> + Send + Sync + 'async_trait, 

#[must_use]pub fn get_transaction_count<'life0, 'async_trait, T>(
    &'life0 self,
    from: T,
    block: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Into<NameOrAddress> + Send + Sync + 'async_trait, 

#[must_use]pub fn estimate_gas<'life0, 'life1, 'async_trait>(
    &'life0 self,
    tx: &'life1 TransactionRequest
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn call<'life0, 'life1, 'async_trait>(
    &'life0 self,
    tx: &'life1 TransactionRequest,
    block: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<Bytes, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn get_chainid<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn get_balance<'life0, 'async_trait, T>(
    &'life0 self,
    from: T,
    block: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Into<NameOrAddress> + Send + Sync + 'async_trait, 

#[must_use]pub fn get_transaction<'life0, 'async_trait, T>(
    &'life0 self,
    transaction_hash: T
) -> Pin<Box<dyn Future<Output = Result<Option<Transaction>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Into<H256> + Send + Sync + 'async_trait, 

#[must_use]pub fn get_transaction_receipt<'life0, 'async_trait, T>(
    &'life0 self,
    transaction_hash: T
) -> Pin<Box<dyn Future<Output = Result<Option<TransactionReceipt>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Into<H256> + Send + Sync + 'async_trait, 

#[must_use]pub fn get_gas_price<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn get_accounts<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<H160, Global>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn send_raw_transaction<'a, 'life0, 'async_trait>(
    &'a self,
    tx: &'life0 Transaction
) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'a, Self::Provider>, Self::Error>> + 'async_trait + Send, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn get_logs<'life0, 'life1, 'async_trait>(
    &'life0 self,
    filter: &'life1 Filter
) -> Pin<Box<dyn Future<Output = Result<Vec<Log, Global>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn new_filter<'life0, 'life1, 'async_trait>(
    &'life0 self,
    filter: FilterKind<'life1>
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn uninstall_filter<'life0, 'async_trait, T>(
    &'life0 self,
    id: T
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Into<U256> + Send + Sync + 'async_trait, 

#[must_use]pub fn watch<'a, 'life0, 'async_trait>(
    &'a self,
    filter: &'life0 Filter
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'a, Self::Provider, Log>, Self::Error>> + 'async_trait + Send, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn watch_pending_transactions<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'life0, Self::Provider, H256>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn get_filter_changes<'life0, 'async_trait, T, R>(
    &'life0 self,
    id: T
) -> Pin<Box<dyn Future<Output = Result<Vec<R, Global>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Into<U256> + Send + Sync + 'async_trait,
    R: Serialize + DeserializeOwned + Send + Sync + Debug + 'async_trait, 

#[must_use]pub fn watch_blocks<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'life0, Self::Provider, H256>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn get_code<'life0, 'async_trait, T>(
    &'life0 self,
    at: T,
    block: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<Bytes, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Into<NameOrAddress> + Send + Sync + 'async_trait, 

#[must_use]pub fn get_storage_at<'life0, 'async_trait, T>(
    &'life0 self,
    from: T,
    location: H256,
    block: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<H256, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Into<NameOrAddress> + Send + Sync + 'async_trait, 

#[must_use]pub fn txpool_content<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolContent, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn txpool_inspect<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolInspect, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn txpool_status<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolStatus, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn trace_call<'life0, 'async_trait>(
    &'life0 self,
    req: TransactionRequest,
    trace_type: Vec<TraceType, Global>,
    block: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Executes the given call and returns a number of possible traces for it

#[must_use]pub fn trace_raw_transaction<'life0, 'async_trait>(
    &'life0 self,
    data: Bytes,
    trace_type: Vec<TraceType, Global>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Traces a call to eth_sendRawTransaction without making the call, returning the traces

#[must_use]pub fn trace_replay_transaction<'life0, 'async_trait>(
    &'life0 self,
    hash: H256,
    trace_type: Vec<TraceType, Global>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Replays a transaction, returning the traces

#[must_use]pub fn trace_replay_block_transactions<'life0, 'async_trait>(
    &'life0 self,
    block: BlockNumber,
    trace_type: Vec<TraceType, Global>
) -> Pin<Box<dyn Future<Output = Result<Vec<BlockTrace, Global>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Replays all transactions in a block returning the requested traces for each transaction

#[must_use]pub fn trace_block<'life0, 'async_trait>(
    &'life0 self,
    block: BlockNumber
) -> Pin<Box<dyn Future<Output = Result<Vec<Trace, Global>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Returns traces created at given block

#[must_use]pub fn trace_filter<'life0, 'async_trait>(
    &'life0 self,
    filter: TraceFilter
) -> Pin<Box<dyn Future<Output = Result<Vec<Trace, Global>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Return traces matching the given filter

#[must_use]pub fn trace_get<'life0, 'async_trait, T>(
    &'life0 self,
    hash: H256,
    index: Vec<T, Global>
) -> Pin<Box<dyn Future<Output = Result<Trace, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Into<U64> + Send + Sync + 'async_trait, 

Returns trace at the given position

#[must_use]pub fn trace_transaction<'life0, 'async_trait>(
    &'life0 self,
    hash: H256
) -> Pin<Box<dyn Future<Output = Result<Vec<Trace, Global>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Returns all traces of a given transaction

#[must_use]pub fn parity_block_receipts<'life0, 'async_trait, T>(
    &'life0 self,
    block: T
) -> Pin<Box<dyn Future<Output = Result<Vec<TransactionReceipt, Global>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Into<BlockNumber> + Send + Sync + 'async_trait, 

Returns all receipts for that block. Must be done on a parity node.

#[must_use]pub fn subscribe<'life0, 'async_trait, T, R>(
    &'life0 self,
    params: T
) -> Pin<Box<dyn Future<Output = Result<SubscriptionStream<'life0, Self::Provider, R>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Debug + Serialize + Send + Sync + 'async_trait,
    R: DeserializeOwned + Send + Sync + 'async_trait,
    Self::Provider: PubsubClient, 

#[must_use]pub fn unsubscribe<'life0, 'async_trait, T>(
    &'life0 self,
    id: T
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    T: Into<U256> + Send + Sync + 'async_trait,
    Self::Provider: PubsubClient, 

#[must_use]pub fn subscribe_blocks<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<SubscriptionStream<'life0, Self::Provider, Block<H256>>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    Self::Provider: PubsubClient, 

#[must_use]pub fn subscribe_pending_txs<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<SubscriptionStream<'life0, Self::Provider, H256>, Self::Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait,
    Self::Provider: PubsubClient, 

#[must_use]pub fn subscribe_logs<'a, 'life0, 'async_trait>(
    &'a self,
    filter: &'life0 Filter
) -> Pin<Box<dyn Future<Output = Result<SubscriptionStream<'a, Self::Provider, Log>, Self::Error>> + 'async_trait + Send, Global>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait,
    Self::Provider: PubsubClient,