Wallets and Signers in ethers.js: A Complete Guide

Managing digital assets on the Ethereum blockchain requires secure and reliable tools. At the heart of this infrastructure lies the Wallet object in ethers.js, a powerful JavaScript library used for interacting with Ethereum. This guide dives into how wallets work, how they sign transactions, and their integration with the broader Signer API — all essential knowledge for developers building decentralized applications.

Understanding Ethereum Wallets

A Wallet in ethers.js manages a private/public key pair used to cryptographically sign transactions and prove ownership on the Ethereum network. It implements the Signer API, meaning it can be used wherever a signer is expected, such as sending transactions or signing messages.

Wallets are fundamental to Ethereum development because they enable secure interactions with smart contracts and decentralized protocols.

Core Functionalities of a Wallet

Generate and manage cryptographic keys
Sign transactions and messages
Connect to Ethereum nodes via providers
Support mnemonic phrases and encrypted storage
Interact directly with the blockchain (when connected)

These capabilities make Wallet objects indispensable in both front-end dApps and backend services.

Creating Wallet Instances

You can create a wallet in several ways depending on your use case: from a private key, randomly, from a mnemonic phrase, or by decrypting an encrypted JSON file.

From a Private Key

To instantiate a wallet from an existing private key:

let privateKey = "0x0123456789012345678901234567890123456789012345678901234567890123";
let wallet = new ethers.Wallet(privateKey);

You can also connect it to a provider (e.g., Infura or Alchemy) to enable blockchain queries:

let provider = ethers.getDefaultProvider();
let walletWithProvider = new ethers.Wallet(privateKey, provider);

👉 Discover secure ways to manage Ethereum wallets using modern tools.

Random Wallet Generation

Generate a new random wallet securely:

let randomWallet = ethers.Wallet.createRandom();
console.log("Address:", randomWallet.address);
console.log("Private Key:", randomWallet.privateKey);
console.log("Mnemonic:", randomWallet.mnemonic);

⚠️ Critical Security Note: If you lose access to this wallet — especially the private key or mnemonic — there is no way to recover it. Always store credentials securely offline.

Additional entropy can be added during generation:

Wallet.createRandom({ extraEntropy: "additional-seed-data" });

From Encrypted JSON (Keystore Files)

Decrypt wallets stored in standard formats like those generated by Geth or MetaMask:

let json = '{"version":3,"id":"...","address":"...","Crypto":{...}}';
let password = "user-password";
ethers.Wallet.fromEncryptedJson(json, password).then(function(wallet) {
  console.log("Address:", wallet.address);
});

This method supports progress callbacks for long decryption operations.

From Mnemonic Phrase (BIP-39/44)

Use a recovery phrase to recreate a wallet:

let mnemonic = "radar blur cabbage chef fix engine embark joy scheme fiction master release";
let wallet = ethers.Wallet.fromMnemonic(mnemonic);

Custom derivation paths are supported (e.g., for multi-account wallets):

let path = "m/44'/60'/1'/0/0"; // Second account
let secondWallet = ethers.Wallet.fromMnemonic(mnemonic, path);

Language-specific wordlists (like Japanese or Korean) can be used, though only English is included by default in browser builds.

Wallet Properties and Methods

Each wallet instance exposes key properties that allow inspection and interaction.

Key Prototype Properties

Property	Description
`address`	Public Ethereum address (e.g., `0x...`)
`privateKey`	Secret key — must never be shared
`provider`	Connected node interface for blockchain access
`mnemonic`	Recovery phrase (if derived from BIP-39)
`path`	Derivation path used

To change the provider, use .connect(provider) — this returns a new instance with the updated connection.

Signing Transactions and Messages

Cryptographic signing is central to Ethereum’s security model. The Wallet class provides two main methods: sign() and signMessage().

Signing Transactions

While sendTransaction() is often preferred (as it auto-fills gas, nonce, etc.), you can manually sign raw transactions:

let transaction = {
  to: "0x88a5C2d9919e46F883EB62F7b8Dd9d0CC45bc290",
  value: ethers.utils.parseEther("1.0"),
  gasLimit: 21000,
  gasPrice: ethers.utils.parseUnits("20", "gwei"),
  chainId: 1
};

wallet.sign(transaction).then(signedTx => {
  console.log("Signed Transaction:", signedTx);
});

This outputs a hex-encoded RLP-serialized transaction ready for broadcast.

Signing Text and Binary Messages

Sign arbitrary messages for authentication or off-chain verification:

wallet.signMessage("Hello World!").then(signature => {
  console.log("Signature:", signature);
});

For binary data (like hashing a message first), ensure you pass byte arrays:

let hash = "0x3ea2f1d0abf3fc66cf29eebb70cbd4e7fe762ef8a09bcc06c8edf641230afec0";
let binaryData = ethers.utils.arrayify(hash);
wallet.signMessage(binaryData).then(sig => {
  console.log("Binary Signature:", sig);
});

These signatures follow Ethereum’s personal_sign standard and can be verified on-chain.

👉 Learn how to integrate secure signing workflows into your dApp today.

Blockchain Operations with a Provider

When connected to a provider, wallets can perform live operations on the Ethereum network.

Querying Balance and Nonce

wallet.getBalance().then(balance => {
  console.log("Balance in Wei:", balance.toString());
  console.log("Balance in ETH:", ethers.utils.formatEther(balance));
});

wallet.getTransactionCount().then(nonce => {
  console.log("Transaction Count (Nonce):", nonce);
});

You can query historical states using the optional blockTag parameter.

Estimating Gas and Sending Transactions

Estimate gas cost before sending:

let tx = { to: "0xRecipient", value: ethers.utils.parseEther("0.5") };
wallet.estimateGas(tx).then(gas => {
  console.log("Estimated Gas:", gas.toString());
});

Send transactions directly:

wallet.sendTransaction(tx).then(response => {
  console.log("Transaction Hash:", response.hash);
  // Wait for confirmation
  return response.wait();
}).then(receipt => {
  console.log("Confirmed in block:", receipt.blockNumber);
});

All missing fields (like gasPrice, nonce) are automatically populated when possible.

Encrypted JSON Wallets (Keystore Files)

Securely store private keys using encrypted JSON wallets — commonly known as keystore files.

Encrypting a Wallet

let password = "securePassword123";
let encryptPromise = wallet.encrypt(password, (progress) => {
  console.log(`Encryption: ${Math.round(progress * 100)}% complete`);
});

encryptPromise.then(json => {
  console.log("Encrypted Wallet:", json);
});

This generates a scrypt-based encrypted file compatible with most Ethereum clients.

🔐 Only scrypt encryption is supported for creation, but various formats can be read for backward compatibility.

Options like custom salt, IV, or UUID can be provided, though defaults are secure for most use cases.

The Signer API: Extending Wallet Functionality

The Signer API is an abstract interface that standardizes interaction across different types of signers — including hardware wallets, JSON-RPC signers, and custom implementations.

Implementing a Custom Signer

To create your own signer (e.g., for Ledger, MPC, or cloud-based solutions), extend ethers.types.Signer and implement:

getAddress() → returns Promise
signMessage(message) → returns Promise
sendTransaction(tx) → returns Promise

Example minimal implementation:

class CustomSigner extends ethers.Signer {
  async getAddress() { return "0x..."; }
  async signMessage(msg) { /* custom logic */ }
  async sendTransaction(tx) { /* broadcast logic */ }
}

This design enables seamless integration with libraries like ethers-ledger or wallet connectors like MetaMask.

Frequently Asked Questions (FAQ)

Q: Can I recover a wallet if I lose my private key?
A: No. Without the private key or mnemonic phrase, recovery is impossible. Always back up your credentials securely.

Q: Is it safe to generate wallets in-browser?
A: Yes, if done over HTTPS and without exposing secrets. However, avoid generating production keys on potentially compromised systems.

Q: What’s the difference between sign() and sendTransaction()?
A: sign() only produces a signed transaction blob; sendTransaction() signs and broadcasts it automatically.

Q: Can I use non-English mnemonics?
A: Yes. Supported languages include Japanese, Korean, Italian, and both simplified/traditional Chinese — though additional wordlists must be loaded manually in browser environments.

Q: How do I switch networks (e.g., from Mainnet to Goerli)?
A: Change the provider: wallet.connect(newProvider) where the new provider points to the desired network.

👉 Explore advanced wallet management features with trusted platforms.

Conclusion

Understanding how wallets and signers work in ethers.js is crucial for any developer engaging with Ethereum. Whether creating accounts, signing messages, or interacting with smart contracts, mastering these concepts ensures robust, secure application design.

By leveraging built-in features like mnemonic recovery, encrypted storage, and provider connectivity, you can build powerful dApps while maintaining user trust and security.