Struct ethers_middleware::signer::SignerMiddleware [−][src]
pub struct SignerMiddleware<M, S> { /* fields omitted */ }
Expand description
Middleware used for locally signing transactions, compatible with any implementer
of the Signer
trait.
Example
use ethers_providers::{Middleware, Provider, Http};
use ethers_signers::LocalWallet;
use ethers_middleware::SignerMiddleware;
use ethers_core::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
Trait Implementations
Returns the client’s address
SignerMiddleware
is instantiated with a signer.
Helper for filling a transaction’s nonce using the wallet
fn send_transaction<'life0, 'async_trait, T: Into<TypedTransaction> + Send + Sync>(
&'life0 self,
tx: T,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'_, Self::Provider>, Self::Error>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn send_transaction<'life0, 'async_trait, T: Into<TypedTransaction> + Send + Sync>(
&'life0 self,
tx: T,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'_, Self::Provider>, Self::Error>> + Send + 'async_trait>> where
T: 'async_trait,
'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
.
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.
type Error = SignerMiddlewareError<M, S>
type Inner = M
Sign a transaction via RPC call
fn client_version<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
fn get_block_number<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<U64, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
fn send_escalating<'a, 'life0, 'async_trait>(
&'a self,
tx: &'life0 TypedTransaction,
escalations: usize,
policy: Box<dyn Fn(U256, usize) + Send + Sync + 'static, Global>
) -> Pin<Box<dyn Future<Output = Result<EscalatingPending<'a, Self::Provider>, Self::Error>> + Send + 'async_trait, Global>> where
'a: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn send_escalating<'a, 'life0, 'async_trait>(
&'a self,
tx: &'life0 TypedTransaction,
escalations: usize,
policy: Box<dyn Fn(U256, usize) + Send + Sync + 'static, Global>
) -> Pin<Box<dyn Future<Output = Result<EscalatingPending<'a, Self::Provider>, Self::Error>> + Send + 'async_trait, Global>> where
'a: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Send a transaction with a simple escalation policy. Read more
fn resolve_name<'life0, 'life1, 'async_trait>(
&'life0 self,
ens_name: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<H160, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn lookup_address<'life0, 'async_trait>(
&'life0 self,
address: H160
) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
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>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<BlockId> + Send + Sync + 'async_trait,
Self: 'async_trait,
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>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<BlockId> + Send + Sync + 'async_trait,
Self: 'async_trait,
fn get_uncle_count<'life0, 'async_trait, T>(
&'life0 self,
block_hash_or_number: T
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<BlockId> + Send + Sync + 'async_trait,
Self: 'async_trait,
fn get_uncle<'life0, 'async_trait, T>(
&'life0 self,
block_hash_or_number: T,
idx: U64
) -> Pin<Box<dyn Future<Output = Result<Option<Block<H256>>, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<BlockId> + Send + Sync + 'async_trait,
Self: 'async_trait,
fn get_transaction_count<'life0, 'async_trait, T>(
&'life0 self,
from: T,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<NameOrAddress> + Send + Sync + 'async_trait,
Self: 'async_trait,
fn estimate_gas<'life0, 'life1, 'async_trait>(
&'life0 self,
tx: &'life1 TypedTransaction
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn call<'life0, 'life1, 'async_trait>(
&'life0 self,
tx: &'life1 TypedTransaction,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<Bytes, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn get_chainid<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
fn get_net_version<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<U64, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
fn get_balance<'life0, 'async_trait, T>(
&'life0 self,
from: T,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<NameOrAddress> + Send + Sync + 'async_trait,
Self: 'async_trait,
fn get_transaction<'life0, 'async_trait, T>(
&'life0 self,
transaction_hash: T
) -> Pin<Box<dyn Future<Output = Result<Option<Transaction>, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Send + Sync + Into<H256> + 'async_trait,
Self: 'async_trait,
fn get_transaction_receipt<'life0, 'async_trait, T>(
&'life0 self,
transaction_hash: T
) -> Pin<Box<dyn Future<Output = Result<Option<TransactionReceipt>, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Send + Sync + Into<H256> + 'async_trait,
Self: 'async_trait,
fn get_block_receipts<'life0, 'async_trait, T>(
&'life0 self,
block: T
) -> Pin<Box<dyn Future<Output = Result<Vec<TransactionReceipt, Global>, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<BlockNumber> + Send + Sync + 'async_trait,
Self: 'async_trait,
fn get_gas_price<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
fn estimate_eip1559_fees<'life0, 'async_trait>(
&'life0 self,
estimator: Option<fn(U256, Vec<Vec<U256, Global>, Global>) -> (U256, U256)>
) -> Pin<Box<dyn Future<Output = Result<(U256, U256), Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
fn get_accounts<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<H160, Global>, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
fn send_raw_transaction<'a, 'async_trait>(
&'a self,
tx: Bytes
) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'a, Self::Provider>, Self::Error>> + Send + 'async_trait, Global>> where
'a: 'async_trait,
Self: 'async_trait,
fn get_logs<'life0, 'life1, 'async_trait>(
&'life0 self,
filter: &'life1 Filter
) -> Pin<Box<dyn Future<Output = Result<Vec<Log, Global>, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn new_filter<'life0, 'life1, 'async_trait>(
&'life0 self,
filter: FilterKind<'life1>
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn uninstall_filter<'life0, 'async_trait, T>(
&'life0 self,
id: T
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<U256> + Send + Sync + 'async_trait,
Self: 'async_trait,
fn watch<'a, 'life0, 'async_trait>(
&'a self,
filter: &'life0 Filter
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'a, Self::Provider, Log>, Self::Error>> + Send + 'async_trait, Global>> where
'a: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn watch_pending_transactions<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'life0, Self::Provider, H256>, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
fn get_filter_changes<'life0, 'async_trait, T, R>(
&'life0 self,
id: T
) -> Pin<Box<dyn Future<Output = Result<Vec<R, Global>, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<U256> + Send + Sync + 'async_trait,
R: Serialize + DeserializeOwned + Send + Sync + Debug + 'async_trait,
Self: 'async_trait,
fn watch_blocks<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'life0, Self::Provider, H256>, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
fn get_code<'life0, 'async_trait, T>(
&'life0 self,
at: T,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<Bytes, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<NameOrAddress> + Send + Sync + 'async_trait,
Self: 'async_trait,
fn get_storage_at<'life0, 'async_trait, T>(
&'life0 self,
from: T,
location: H256,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<H256, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<NameOrAddress> + Send + Sync + 'async_trait,
Self: 'async_trait,
fn get_proof<'life0, 'async_trait, T>(
&'life0 self,
from: T,
locations: Vec<H256, Global>,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<EIP1186ProofResponse, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<NameOrAddress> + Send + Sync + 'async_trait,
Self: 'async_trait,
fn txpool_content<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolContent, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
fn txpool_inspect<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolInspect, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
fn txpool_status<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolStatus, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
fn trace_call<'life0, 'async_trait, T>(
&'life0 self,
req: T,
trace_type: Vec<TraceType, Global>,
block: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<TypedTransaction> + Send + Sync + 'async_trait,
Self: 'async_trait,
fn trace_call<'life0, 'async_trait, T>(
&'life0 self,
req: T,
trace_type: Vec<TraceType, Global>,
block: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<TypedTransaction> + Send + Sync + 'async_trait,
Self: 'async_trait,
Executes the given call and returns a number of possible traces for it
Traces a call to eth_sendRawTransaction
without making the call, returning the traces
Replays a transaction, returning the traces
Replays all transactions in a block returning the requested traces for each transaction
Returns traces created at given block
Return traces matching the given filter
Returns trace at the given position
Returns all traces of a given transaction
Returns all receipts for that block. Must be done on a parity node.
fn subscribe<'life0, 'async_trait, T, R>(
&'life0 self,
params: T
) -> Pin<Box<dyn Future<Output = Result<SubscriptionStream<'life0, Self::Provider, R>, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Debug + Serialize + Send + Sync + 'async_trait,
R: DeserializeOwned + Send + Sync + 'async_trait,
Self: 'async_trait,
Self::Provider: PubsubClient,
fn unsubscribe<'life0, 'async_trait, T>(
&'life0 self,
id: T
) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
T: Into<U256> + Send + Sync + 'async_trait,
Self: 'async_trait,
Self::Provider: PubsubClient,
fn subscribe_blocks<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<SubscriptionStream<'life0, Self::Provider, Block<H256>>, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
Self::Provider: PubsubClient,
fn subscribe_pending_txs<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<SubscriptionStream<'life0, Self::Provider, H256>, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
Self: 'async_trait,
Self::Provider: PubsubClient,
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>> + Send + 'async_trait, Global>> where
'a: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Self::Provider: PubsubClient,
fn fee_history<'life0, 'life1, 'async_trait, T>(
&'life0 self,
block_count: T,
last_block: BlockNumber,
reward_percentiles: &'life1 [f64]
) -> Pin<Box<dyn Future<Output = Result<FeeHistory, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
'life1: 'async_trait,
T: Into<U256> + Serialize + Send + Sync + 'async_trait,
Self: 'async_trait,
fn create_access_list<'life0, 'life1, 'async_trait>(
&'life0 self,
tx: &'life1 TypedTransaction,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<AccessListWithGasUsed, Self::Error>> + Send + 'async_trait, Global>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
Auto Trait Implementations
impl<M, S> RefUnwindSafe for SignerMiddleware<M, S> where
M: RefUnwindSafe,
S: RefUnwindSafe,
impl<M, S> Send for SignerMiddleware<M, S> where
M: Send,
S: Send,
impl<M, S> Sync for SignerMiddleware<M, S> where
M: Sync,
S: Sync,
impl<M, S> Unpin for SignerMiddleware<M, S> where
M: Unpin,
S: Unpin,
impl<M, S> UnwindSafe for SignerMiddleware<M, S> where
M: UnwindSafe,
S: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more