Ethereum Development: Generate Mnemonic Phrase When Creating a Wallet

·

Creating a secure and functional cryptocurrency wallet is a foundational step in blockchain development. In Ethereum-based applications, developers often rely on tools like Node.js and Web3.js to generate wallets programmatically. However, many implementations only return basic information such as the address, private key, and keystore — overlooking one of the most critical components: the mnemonic phrase.

This article dives into how to enhance your Ethereum wallet creation process by generating a mnemonic phrase alongside other wallet credentials. We'll compare the old approach with a modern, more secure method that supports full key recovery using BIP39 standards, and show you how to retrieve wallet details from a mnemonic.

Why Include a Mnemonic Phrase?

A mnemonic phrase (often 12 or 24 words) serves as a human-readable representation of a wallet’s seed. It enables users to back up and restore entire wallets across different platforms securely. Without it, losing the private key or keystore means irreversible loss of funds.

Including the mnemonic during wallet creation aligns with industry best practices and improves user experience by enabling seamless recovery options.

👉 Discover how secure wallet integration powers next-gen blockchain apps.

Legacy Wallet Creation (Without Mnemonic)

Previously, developers used web3.eth.accounts.create() to generate Ethereum accounts. While simple, this method only returns:

Here's an example of the legacy implementation:

router.get('/eth/account/createWallet', async (ctx, next) => {
  if (!ctx.request.query.password) {
    ctx.body = { code: 1, data: {}, message: 'Missing parameter: password.' };
    return;
  }

  try {
    let account = web3.eth.accounts.create();
    let keystore = web3.eth.accounts.encrypt(account.privateKey, ctx.request.query.password);

    ctx.body = {
      code: 0,
      address: account.address,
      privateKey: account.privateKey.substr(2),
      keystore: keystore,
      message: 'Success'
    };
  } catch (error) {
    ctx.body = { code: 1, data: {}, message: error.stack };
  }
});

While functional, this approach lacks mnemonic support — making backup and cross-platform restoration difficult.

Modern Wallet Creation (With Mnemonic)

To generate a mnemonic phrase during wallet creation, we use three essential libraries:

Step-by-Step Implementation

1. Install Required Packages

npm install bip39 ethereumjs-wallet ethereumjs-util

2. Import Dependencies

const bip39 = require('bip39');
const hdkey = require('ethereumjs-wallet/hdkey');
const util = require('ethereumjs-util');

3. Generate Wallet with Mnemonic

router.get('/eth/account/createWallet', async (ctx, next) => {
  if (!ctx.request.query.password) {
    ctx.body = { code: 1, data: {}, message: 'Missing parameter: password.' };
    return;
  }

  try {
    // Step 1: Generate 12-word mnemonic
    const mnemonic = bip39.generateMnemonic();

    // Step 2: Convert mnemonic to seed
    const seed = bip39.mnemonicToSeedSync(mnemonic);

    // Step 3: Create HD wallet from seed
    const hdWallet = hdkey.fromMasterSeed(seed);

    // Step 4: Derive key at standard Ethereum path m/44'/60'/0'/0/0
    const key = hdWallet.derivePath("m/44'/60'/0'/0/0");

    // Step 5: Extract private and public keys
    const privateKey = util.bufferToHex(key._hdkey._privateKey);
    const publicKey = util.bufferToHex(key._hdkey._publicKey);

    // Step 6: Derive Ethereum address
    const addressBuffer = util.pubToAddress(publicKey, true);
    const address = util.toChecksumAddress(addressBuffer.toString('hex'));

    // Step 7: Encrypt private key into keystore
    const keystore = web3.eth.accounts.encrypt(privateKey, ctx.request.query.password);

    ctx.body = {
      code: 0,
      address,
      password: ctx.request.query.password,
      privateKey: privateKey.substr(2),
      publicKey,
      keystore,
      mnemonic,
      message: 'Success'
    };
  } catch (error) {
    ctx.body = { code: 1, data: {}, message: error.stack };
  }
});

This enhanced version now returns all essential components — including the mnemonic, enabling full wallet recovery.

Recover Wallet from Mnemonic

One of the primary benefits of using a mnemonic is the ability to restore a wallet from just those words.

Here’s how to derive an Ethereum account from a given mnemonic and password:

router.get('/eth/account/getAccount', async (ctx, next) => {
  const { password, mnemonic } = ctx.request.query;

  if (!password) {
    ctx.body = { code: 1, data: {}, message: 'Missing parameter: password.' };
    return;
  }

  if (!mnemonic) {
    ctx.body = { code: 1, data: {}, message: 'Missing parameter: mnemonic.' };
    return;
  }

  try {
    const seed = bip39.mnemonicToSeedSync(mnemonic);
    const hdWallet = hdkey.fromMasterSeed(seed);
    const key = hdWallet.derivePath("m/44'/60'/0'/0/0");

    const privateKey = util.bufferToHex(key._hdkey._privateKey);
    const publicKey = util.bufferToHex(key._hdkey._publicKey);

    const addressBuffer = util.pubToAddress(publicKey, true);
    const address = util.toChecksumAddress(addressBuffer.toString('hex'));

    const keystore = web3.eth.accounts.encrypt(privateKey, password);

    ctx.body = {
      code: 0,
      address,
      privateKey: privateKey.substr(2),
      publicKey,
      keystore,
      message: 'Success'
    };
  } catch (error) {
    ctx.body = { code: 1, data: {}, message: error.stack };
  }
});

With this endpoint, users can recover their wallets anytime using just the mnemonic and password.

👉 Learn how developers build resilient wallets using standard cryptographic flows.

Frequently Asked Questions

What is a mnemonic phrase in Ethereum wallets?

A mnemonic phrase is a set of 12 or 24 human-readable words generated from a random seed. It represents the root of a hierarchical deterministic (HD) wallet and allows for secure backup and restoration of private keys.

Is it safe to generate mnemonics client-side?

Yes — as long as the environment is secure and free from malicious scripts. Always avoid logging or storing mnemonics in plaintext. Never transmit them over unsecured channels.

Can I use the same mnemonic for multiple blockchains?

Yes. Many wallets use BIP44 derivation paths to support multiple chains from a single mnemonic. For Ethereum, the standard path is m/44'/60'/0'/0/0.

What happens if I lose my mnemonic?

Losing your mnemonic typically means permanent loss of access to funds, especially if no backup of the private key or keystore exists. Always store mnemonics securely offline.

How does BIP39 improve wallet security?

BIP39 standardizes mnemonic generation and seed derivation, ensuring interoperability between wallets and reducing implementation errors that could lead to fund loss.

Can I regenerate a private key from a mnemonic?

Yes. The mnemonic generates a seed via PBKDF2, which is then used to derive the master private key through HD wallet algorithms. All subsequent keys follow standardized derivation paths.

Core Keywords

By integrating mnemonic generation into your wallet creation flow, you empower users with better control, improved security, and seamless recovery options — all aligned with modern blockchain standards.

👉 Explore secure methods for managing Ethereum identities in decentralized systems.