Generating a Taproot Wallet on OP_NET

On OP_NET, only Taproot addresses are accepted for interacting with the ecosystem. This guide will walk you through generating a valid Taproot wallet that can be used on OP_NET. Using the BitcoinJS library and BIP32, we will create and import wallets that comply with OP_NET's Taproot-only requirement.

---

Prerequisites

Before you begin, ensure you have the necessary packages installed:

npm install bip32 bip39 bitcoinjs-lib tiny-secp256k1
# or
yarn add bip32 bip39 bitcoinjs-lib tiny-secp256k1

---

Create a Taproot Wallet

The following example demonstrates how to generate a new Taproot wallet that is compatible with OP_NET. This class, WalletManager, is an example implementation of wallet creation using the BitcoinJS library and BIP32.

import { BIP32Factory } from "bip32";
import { generateMnemonic, mnemonicToSeedSync } from "bip39";
import * as bitcoinjs from "bitcoinjs-lib";
import * as ecc from "tiny-secp256k1";

/**
 * WalletManager class for creating and managing Taproot wallets on OP_NET.
 */
export class WalletManager {
  private bip32: any;

  /**
   * Constructor initializes the BIP32 factory and ECC library.
   */
  constructor() {
    // Create a BIP32 factory instance with the secp256k1 elliptic curve library (ECC).
    this.bip32 = BIP32Factory(ecc);
    bitcoinjs.initEccLib(ecc); // Initialize ECC library for BitcoinJS to use.
  }

  /**
   * Create a new Taproot wallet on the specified network.
   *
   * @param network The Bitcoin network (e.g., regtest, testnet, mainnet)
   * @returns An object containing the mnemonic, private key (WIF format), and Taproot address
   */
  createWallet(network: bitcoinjs.Network) {
    // Generate a new mnemonic phrase (24 words).
    const mnemonic = generateMnemonic(256);

    // Convert mnemonic phrase to a seed (used for wallet derivation).
    const seed = mnemonicToSeedSync(mnemonic);

    // Create a BIP32 root key from the seed for the specified network.
    const root = this.bip32.fromSeed(seed, network);

    // BIP86 derivation path for Taproot (m/86'/0'/0'/0/0).
    const path = "m/86'/0'/0'/0/0";
    const child = root.derivePath(path); // Derive the child key from the path.

    // Generate a Taproot address using the derived child key.
    const { address } = bitcoinjs.payments.p2tr({
      internalPubkey: child.publicKey.slice(1, 33), // Slice the internal public key for Taproot.
      network,
    });

    // Return the mnemonic, private key in WIF format, and the generated Taproot address.
    return {
      mnemonic,
      privateKey: child.toWIF(), // Export the private key in Wallet Import Format (WIF).
      address,
    };
  }
}

// Example usage:

/**
 * Define the Bitcoin network you're using (e.g., regtest, testnet, or mainnet).
 * 'bitcoinjs.networks.regtest' is used for local testing on regtest.
 */
const network = bitcoinjs.networks.regtest;

// Initialize the WalletManager
const walletManager = new WalletManager();

// Create a new wallet on the specified network.
const newWallet = walletManager.createWallet(network);

console.log("Mnemonic:", newWallet.mnemonic); // Log the generated mnemonic phrase.
console.log("Private Key (WIF):", newWallet.privateKey); // Log the private key (WIF format).
console.log("Taproot Address:", newWallet.address); // Log the Taproot address.

This WalletManager class allows you to generate a mnemonic and derive a Taproot address using the BIP86 path (m/86'/0'/0'/0/0), which is the format OP_NET expects for valid Taproot addresses. This is just an example implementation, and you can adapt it as needed for your own project.

---

Import an Existing Wallet

You can import an existing Taproot wallet for use on OP_NET by using the mnemonic phrase or the wallet's private key (WIF format). Below are both methods.

1. Using the Mnemonic Phrase

If you have the mnemonic phrase of an existing wallet, you can re-derive the wallet's Taproot address using an example method like importWallet:

/**
 * Import an existing wallet using the mnemonic phrase.
 *
 * @param mnemonic The mnemonic phrase of the wallet
 * @param network The Bitcoin network (e.g., regtest, testnet, mainnet)
 * @returns An object containing the mnemonic, private key (WIF format), and Taproot address
 */
importWallet(mnemonic: string, network: bitcoinjs.Network) {
  // Validate if the provided mnemonic is valid according to BIP39 standards.
  if (!validateMnemonic(mnemonic)) return null;

  // Convert the mnemonic phrase to a seed.
  const seed = mnemonicToSeedSync(mnemonic);

  // Create a BIP32 root key from the seed for the specified network.
  const root = this.bip32.fromSeed(seed, network);

  // BIP86 derivation path for Taproot (m/86'/0'/0'/0/0), which is required for OP_NET compatibility.
  const path = "m/86'/0'/0'/0/0";
  const child = root.derivePath(path); // Derive the child key from the path.

  // Generate a Taproot address using the derived child key.
  const { address } = bitcoinjs.payments.p2tr({
    internalPubkey: child.publicKey.slice(1, 33), // Slice the internal public key for Taproot.
    network,
  });

  // Return the mnemonic, private key in WIF format, and the derived Taproot address.
  return {
    mnemonic, // The original mnemonic phrase.
    privateKey: child.toWIF(), // The private key exported in Wallet Import Format (WIF).
    address, // The derived Taproot address.
  };
}

// Example usage:

/**
 * Define the Bitcoin network you're using (e.g., regtest, testnet, or mainnet).
 * 'bitcoinjs.networks.testnet' is used for testing on testnet.
 */
const network = bitcoinjs.networks.testnet;

// Example mnemonic phrase for an existing wallet.
const mnemonic =
  "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";

// Initialize the WalletManager
const walletManager = new WalletManager();

// Import the wallet using the mnemonic phrase.
const importedWallet = walletManager.importWallet(mnemonic, network);

if (!importedWallet) {
  throw new Error("Invalid mnemonic phrase.");
}

console.log("Mnemonic:", importedWallet.mnemonic); // Log the imported mnemonic phrase.
console.log("Private Key (WIF):", importedWallet.privateKey); // Log the private key (WIF format).
console.log("Taproot Address:", importedWallet.address); // Log the imported Taproot address.

This example method validates the mnemonic and derives the same Taproot address used during wallet creation, ensuring compatibility with OP_NET.

2. Using the Private Key (WIF Format)

Alternatively, if you have the wallet's private key in WIF format, you can use the Wallet.fromWif method from the @btc-vision/transaction package to import the wallet:

import { Wallet } from "@btc-vision/transaction";
import * as bitcoinjs from "bitcoinjs-lib";

const walletPrivateKey = "your-wallet-private-key-in-wif-format"; // Replace this with the actual WIF.
const network = bitcoinjs.networks.regtest; // Specify the bitcoinjs network ('mainnet', 'testnet', 'regtest').

// Import the wallet using the private key and network.
const importedWallet = Wallet.fromWif(walletPrivateKey, network);

// Output the Taproot address associated with the imported wallet.
console.log("Taproot Address:", importedWallet.p2tr);

This method allows you to directly import the wallet using its private key without needing the mnemonic phrase.