This guide is intended for developers who need to dynamically generate and manage cryptocurrency wallet addresses using the ethers.js library. Whether you are developing a decentralized application (dApp), implementing a user management system that provisions wallets for new sign-ups, or integrating with a service such as the Particle Network, this guide will demonstrate how to securely and efficiently create and manage EVM-compatible wallets within your JavaScript or TypeScript code. It outlines the prerequisites, provides detailed step-by-step instructions, and concludes with best practices for sustainable wallet management.

​
Prerequisites

  • Basic JavaScript/TypeScript knowledge: You should know how to write and run JavaScript code in a Node.js environment.
  • Familiarity with Node.js tooling: You know how to install NPM packages and understand basic module imports.
  • Ethers.js installed: You have ethers.js available as a dependency in your project.
  • Particle Network or similar integration: If you’re using Particle Network or another platform, you should have access to their SDK or integration documentation. This guide assumes you know how to authenticate and interact with that platform’s services.
  • Secure storage setup: You have a strategy for securely storing private keys, such as an environment variable manager, a hardware security module (HSM), or a dedicated secret management service.

​
Instructions

​
1. Generating a New Wallet Address

ethers.js makes it easy to generate a new wallet address with a corresponding private key. The most straightforward method is to create a random wallet: 
import { Wallet } from "ethers";

// Create a new random wallet
const wallet = Wallet.createRandom();

console.log("New Wallet Address:", wallet.address);
console.log("Wallet Private Key:", wallet.privateKey);
Key points:
  • wallet.address provides the public address.
  • wallet.privateKey is extremely sensitive and should be stored securely.
  • By default, Wallet.createRandom() uses a secure RNG to generate entropy.

​
2. Encrypting and Storing Wallets

When managing a user’s wallet, treat the private key as a secret that must be kept safe. ethers.js can encrypt wallets with a password: 
(async () => {
  const password = "superstrongpassword";
  const encryptedJson = await wallet.encrypt(password);

  // Store this encrypted JSON in a secure database or secure storage solution
  console.log("Encrypted Wallet JSON:", encryptedJson);
})();
Key points:
  • The encrypt method returns a JSON Keystore V3 object.
  • This object can be safely stored and later decrypted using the password.
  • Consider integrating secure storage solutions such as AWS KMS, GCP KMS, or Vault for enterprise-level security.

​
3. Restoring an Existing Wallet

To restore a wallet from an encrypted JSON, decrypt it with the password: 
(async () => {
  const password = "superstrongpassword";
  const encryptedJson = "THE ENCRYPTED JSON FROM YOUR STORAGE";

  const restoredWallet = await Wallet.fromEncryptedJson(encryptedJson, password);
  console.log("Restored Wallet Address:", restoredWallet.address);
})();
Key points:
  • The fromEncryptedJson method returns a fully functional Wallet instance.
  • Use this method whenever you need to perform transactions, sign messages, or display the user’s address.

​
4. Integrating with Particle Network or Other Services

If you are managing multiple user wallets and need to integrate with services like Particle Network for authentication or transaction relays, consider:
  • User Authentication: Leverage Particle Network’s SDK to authenticate users and link their sessions to a particular wallet.
  • Dynamic Wallet Creation: On user registration or login, generate a new wallet on the fly and store the encrypted JSON associated with that user’s account in your secure database.
  • Transaction Management: Use ethers.js methods (wallet.sendTransaction, wallet.signTransaction) to handle transactions programmatically. Particle Network or similar services may offer APIs to help broadcast these transactions or manage gas payments.
Example snippet for integration logic (pseudo-code): 
async function handleNewUserRegistration(userId, particleInstance) {
  // Authenticate user via Particle Network (pseudo-code)
  const userSession = await particleInstance.authenticateUser(userId);

  // Generate a new wallet
  const wallet = Wallet.createRandom();
  
  // Encrypt and store it
  const encryptedJson = await wallet.encrypt(process.env.WALLET_ENCRYPTION_PASSWORD);
  await storeEncryptedWalletForUser(userId, encryptedJson);

  // Associate wallet address with user session in Particle Network
  await particleInstance.registerWalletAddress(userSession, wallet.address);
}
Key points:
  • Always handle private keys and encrypted data within secure and trusted environments.
  • Consider role-based access controls (RBAC) and never expose raw private keys to the client side.

​
Summary

Creating and managing EVM-type wallet addresses with ethers.js is straightforward once you understand the building blocks: generating a wallet, encrypting and storing keys, and restoring wallets for future transactions. By combining these practices with secure storage solutions and optional integrations with services like Particle Network, you can confidently manage a dynamic userbase and ensure their funds remain secure. In the long run, following best practices for encryption, secure storage, and careful integration with authentication services will help you maintain trust, reliability, and seamless user experiences in your decentralized applications.