Mnemonic Management

/**
 * Generate a BIP39 mnemonic phrase
 * @param numWords - Number of words (12, 15, 18, 21, or 24)
 * @param wordlist - Optional custom wordlist (defaults to English)
 * @returns BIP39 mnemonic string
 */
function mnemonicGenerate(numWords?: 12 | 15 | 18 | 21 | 24, wordlist?: string[]): string;

import { mnemonicGenerate } from "@polkadot/util-crypto";

// Generate 12-word mnemonic (default)
const mnemonic12 = mnemonicGenerate();
console.log(mnemonic12); // "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"

// Generate 24-word mnemonic for higher security
const mnemonic24 = mnemonicGenerate(24);
console.log(mnemonic24.split(' ').length); // 24

// Generate 15-word mnemonic
const mnemonic15 = mnemonicGenerate(15);

/**
 * Validate a BIP39 mnemonic phrase
 * @param mnemonic - Mnemonic string to validate
 * @param wordlist - Optional custom wordlist
 * @returns true if mnemonic is valid
 */
function mnemonicValidate(mnemonic: string, wordlist?: string[]): boolean;

import { mnemonicGenerate, mnemonicValidate } from "@polkadot/util-crypto";

const mnemonic = mnemonicGenerate();
const isValid = mnemonicValidate(mnemonic);
console.log("Valid mnemonic:", isValid); // true

// Test invalid mnemonic
const invalid = "invalid mnemonic phrase here";
const isInvalid = mnemonicValidate(invalid);
console.log("Invalid mnemonic:", isInvalid); // false

/**
 * Convert mnemonic to mini secret (32 bytes)
 * @param mnemonic - BIP39 mnemonic phrase
 * @param password - Optional password for additional security
 * @returns 32-byte mini secret for sr25519
 */
function mnemonicToMiniSecret(mnemonic: string, password?: string): Uint8Array;

import { 
  mnemonicGenerate, 
  mnemonicToMiniSecret, 
  sr25519PairFromSeed 
} from "@polkadot/util-crypto";

const mnemonic = mnemonicGenerate();

// Without password
const seed = mnemonicToMiniSecret(mnemonic);
const pair = sr25519PairFromSeed(seed);

// With password for additional security
const seedWithPassword = mnemonicToMiniSecret(mnemonic, "my-secure-password");
const pairWithPassword = sr25519PairFromSeed(seedWithPassword);

/**
 * Convert mnemonic to BIP39-compatible seed (deprecated - use mnemonicToMiniSecret for new projects)
 * @param mnemonic - BIP39 mnemonic phrase
 * @param password - Optional password for seed derivation (default: '')
 * @param onlyJs - Optional: force JavaScript implementation (default: false)
 * @param byteLength - Optional: seed length 32 or 64 bytes (default: 32)
 * @param rounds - Optional: PBKDF2 iterations (default: 2048)
 * @returns Seed bytes for compatibility with Bitcoin/Ethereum wallets
 */
function mnemonicToLegacySeed(mnemonic: string, password?: string, onlyJs?: boolean, byteLength?: 32 | 64, rounds?: number): Uint8Array;

import { mnemonicToLegacySeed, ed25519PairFromSeed } from "@polkadot/util-crypto";

const mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
const legacySeed = mnemonicToLegacySeed(mnemonic);

// Use first 32 bytes for ed25519
const pair = ed25519PairFromSeed(legacySeed.slice(0, 32));

/**
 * Convert mnemonic to entropy bytes
 * @param mnemonic - BIP39 mnemonic phrase
 * @param wordlist - Optional custom wordlist
 * @returns Entropy bytes (16, 20, 24, 28, or 32 bytes)
 */
function mnemonicToEntropy(mnemonic: string, wordlist?: string[]): Uint8Array;

import { mnemonicGenerate, mnemonicToEntropy } from "@polkadot/util-crypto";

const mnemonic = mnemonicGenerate(12);
const entropy = mnemonicToEntropy(mnemonic);
console.log(entropy.length); // 16 bytes for 12-word mnemonic

const mnemonic24 = mnemonicGenerate(24);
const entropy24 = mnemonicToEntropy(mnemonic24);
console.log(entropy24.length); // 32 bytes for 24-word mnemonic

import { 
  cryptoWaitReady,
  mnemonicGenerate,
  mnemonicValidate,
  mnemonicToMiniSecret,
  sr25519PairFromSeed,
  encodeAddress
} from "@polkadot/util-crypto";

async function createAccount() {
  // Initialize crypto
  await cryptoWaitReady();
  
  // Generate mnemonic
  const mnemonic = mnemonicGenerate(24);
  console.log("Mnemonic:", mnemonic);
  
  // Validate mnemonic
  if (!mnemonicValidate(mnemonic)) {
    throw new Error("Invalid mnemonic generated");
  }
  
  // Convert to seed with password
  const password = "my-secure-password";
  const seed = mnemonicToMiniSecret(mnemonic, password);
  
  // Generate key pair
  const pair = sr25519PairFromSeed(seed);
  
  // Generate address
  const address = encodeAddress(pair.publicKey, 0); // Polkadot network
  
  return {
    mnemonic,
    address,
    publicKey: pair.publicKey
  };
}