Struct ethers_signers::Wallet

pub struct Wallet<D: DigestSigner<ProxyDigest<Sha256>, RecoverableSignature>> { /* fields omitted */ }

An Ethereum private-public key pair which can be used for signing messages.

Examples

Signing and Verifying a message

The wallet can be used to produce ECDSA Signature objects, which can be then verified. Note that this uses hash_message under the hood which will prefix the message being hashed with the Ethereum Signed Message domain separator.

use ethers_core::rand::thread_rng;
use ethers_signers::{LocalWallet, Signer};

let wallet = LocalWallet::new(&mut thread_rng());

// Optionally, the wallet's chain id can be set, in order to use EIP-155
// replay protection with different chains
let wallet = wallet.with_chain_id(1337u64);

// The wallet can be used to sign messages
let message = b"hello";
let signature = wallet.sign_message(message).await?;
assert_eq!(signature.recover(&message[..]).unwrap(), wallet.address());

Implementations

impl Wallet<SigningKey>

pub fn new_keystore<P, R, S>(
    dir: P,
    rng: &mut R,
    password: S
) -> Result<Self, WalletError> where
    P: AsRef<Path>,
    R: Rng + CryptoRng,
    S: AsRef<[u8]>, 

Creates a new random encrypted JSON with the provided password and stores it in the provided directory

pub fn decrypt_keystore<P, S>(
    keypath: P,
    password: S
) -> Result<Self, WalletError> where
    P: AsRef<Path>,
    S: AsRef<[u8]>, 

Decrypts an encrypted JSON from the provided path to construct a Wallet instance

pub fn new<R: Rng + CryptoRng>(rng: &mut R) -> Self

Creates a new random keypair seeded with the provided RNG

impl Wallet<YubiSigner<Secp256k1>>

pub fn connect(connector: Connector, credentials: Credentials, id: Id) -> Self

Connects to a yubi key’s ECDSA account at the provided id

pub fn new(
    connector: Connector,
    credentials: Credentials,
    id: Id,
    label: Label,
    domain: Domain
) -> Self

Creates a new random ECDSA keypair on the yubi at the provided id

pub fn from_key(
    connector: Connector,
    credentials: Credentials,
    id: Id,
    label: Label,
    domain: Domain,
    key: impl Into<Vec<u8>>
) -> Self

Uploads the provided keypair on the yubi at the provided id

impl<D: DigestSigner<ProxyDigest<Sha256>, RecoverableSignature>> Wallet<D>

pub fn sign_transaction_sync(&self, tx: &TypedTransaction) -> Signature

pub fn signer(&self) -> &D

Gets the wallet’s signer

Trait Implementations

impl Clone for Wallet<SigningKey>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: DigestSigner<ProxyDigest<Sha256>, RecoverableSignature>> Debug for Wallet<D>

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

Formats the value using the given formatter.

impl From<SecretKey<Secp256k1>> for Wallet<SigningKey>

fn from(key: K256SecretKey) -> Self

Performs the conversion.

impl From<Signer<Secp256k1>> for Wallet<YubiSigner<Secp256k1>>

fn from(signer: YubiSigner<Secp256k1>) -> Self

Performs the conversion.

impl From<SigningKey> for Wallet<SigningKey>

fn from(signer: SigningKey) -> Self

Performs the conversion.

impl FromStr for Wallet<SigningKey>

type Err = WalletError

The associated error which can be returned from parsing.

fn from_str(src: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq<Wallet<SigningKey>> for Wallet<SigningKey>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<D: Sync + Send + DigestSigner<ProxyDigest<Sha256>, RecoverableSignature>> Signer for Wallet<D>

fn chain_id(&self) -> u64

Gets the wallet’s chain id

Panics

If the chain id has not already been set.

fn with_chain_id<T: Into<u64>>(self, chain_id: T) -> Self

Sets the wallet’s chain_id, used in conjunction with EIP-155 signing

type Error = WalletError

fn sign_message<'life0, 'async_trait, S: Send + Sync + AsRef<[u8]>>(
    &'life0 self,
    message: S
) -> Pin<Box<dyn Future<Output = Result<Signature, Self::Error>> + Send + 'async_trait>> where
    S: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Signs the hash of the provided message after prefixing it

fn sign_transaction<'life0, 'life1, 'async_trait>(
    &'life0 self,
    tx: &'life1 TypedTransaction
) -> Pin<Box<dyn Future<Output = Result<Signature, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Signs the transaction

fn sign_typed_data<'life0, 'async_trait, T: Eip712 + Send + Sync>(
    &'life0 self,
    payload: T
) -> Pin<Box<dyn Future<Output = Result<Signature, Self::Error>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Encodes and signs the typed data according EIP-712. Payload must implement Eip712 trait.

fn address(&self) -> Address

Returns the signer’s Ethereum Address