Struct ethers_signers::Wallet

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

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,
    name: Option<&str>
) -> Result<(Self, String), WalletError> where
    P: AsRef<Path>,
    R: Rng + CryptoRng + CryptoRng,
    S: AsRef<[u8]>, 

Creates a new random encrypted JSON with the provided password and stores it in the provided directory. Returns a tuple (Wallet, String) of the wallet instance for the keystore with its random UUID. Accepts an optional name for the keystore file. If None, the keystore is stored as the stringified UUID.

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

Synchronously signs the provided transaction, normalizing the signature v value with EIP-155 using the transaction’s chain_id, or the signer’s chain_id if the transaction does not specify one.

pub fn sign_hash(&self, hash: H256) -> Signature

Signs the provided hash.

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl From<SigningKey> for Wallet<SigningKey>

fn from(signer: SigningKey) -> Self

Converts to this type from the input type.

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

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>(
    &'life0 self,
    message: S
) -> Pin<Box<dyn Future<Output = Result<Signature, Self::Error>> + Send + 'async_trait>> where
    S: 'async_trait + Send + Sync + AsRef<[u8]>,
    '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, 'life1, 'async_trait, T>(
    &'life0 self,
    payload: &'life1 T
) -> Pin<Box<dyn Future<Output = Result<Signature, Self::Error>> + Send + 'async_trait>> where
    T: 'async_trait + Eip712 + Send + Sync,
    'life0: 'async_trait,
    'life1: '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