### Install bip39 Package

Source: https://github.com/bitcoinjs/bip39/blob/master/README.md

Install the bip39 package using npm. This is the first step before using the library.

```bash
npm install bip39
```

--------------------------------

### Install Dependencies

Source: https://github.com/bitcoinjs/bip39/blob/master/CONTRIBUTING.md

Install project dependencies using npm.

```bash
npm install
```

--------------------------------

### Usage Example with Wordlists

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/types.md

Demonstrates how to access, use, and validate mnemonics with custom or default wordlists in JavaScript.

```javascript
const bip39 = require('bip39')

// Access the wordlists object
const wordlists = bip39.wordlists
// => { english: [...], spanish: [...], ... }

// Check available wordlist
if (wordlists.italian) {
  // Italian wordlist was compiled in
  const words = wordlists.italian
  console.log(words[0])     // => 'abaco'
  console.log(words.length) // => 2048
}

// Create custom wordlist for testing
const customWordlist = [
  'abandon', 'ability', 'able', /* ... 2045 more words ... */
]

// Use custom wordlist with BIP39 functions
const entropy = '00000000000000000000000000000000'
const mnemonic = bip39.entropyToMnemonic(entropy, customWordlist)
// => 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'

// Verify phrase with custom wordlist
const isValid = bip39.validateMnemonic(mnemonic, customWordlist)
// => true
```

--------------------------------

### Example BIP39 Test Vector

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/cryptographic-specification.md

An example test vector demonstrating the format for entropy, mnemonic phrase, and seed. This is used to verify correct implementation of the BIP39 standard.

```json
[
  "00000000000000000000000000000000",
  "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
  "5cf2d4a8b0355e90295bdfc565a022a409af063d5365bb57bf74d9528f494bfa4400f53d8349b80fdae44082d7f9541e1dba2b003bcfec9d0d53781ca676651f"
]
```

--------------------------------

### Build a Custom BIP39 Wordlist

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Example structure for creating a custom BIP39 wordlist, which must contain exactly 2048 unique words.

```javascript
// Create custom wordlist (must be 2048 unique words)
const customWordlist = [
  'ability', 'abolish', 'abort', 'abs', 'absent', 'abuse',
  // ... (need 2042 more words)
]

const bip39 = require('bip39')

if (customWordlist.length === 2048) {
  const mnemonic = bip39.entropyToMnemonic('00000000000000000000000000000000', customWordlist)
}
```

--------------------------------

### Async Seed Derivation for Wallet Generation

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

An example of asynchronous seed derivation used in conjunction with BIP32 for HD wallet creation. It generates a mnemonic, derives the seed, and then derives a public key.

```javascript
const bip39 = require('bip39')

async function generateWallet() {
  const mnemonic = bip39.generateMnemonic()
  const seed = await bip39.mnemonicToSeed(mnemonic)
  
  // Use seed for HD wallet derivation
  const bip32 = require('bip32')
  const node = bip32.fromSeed(seed)
  
  return {
    mnemonic,
    seed: seed.toString('hex'),
    publicKey: node.publicKey.toString('hex')
  }
}

generateWallet().then(wallet => {
  console.log(wallet)
})
```

--------------------------------

### BIP39 Mnemonic Generation Examples

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/types.md

Demonstrates generating BIP39 mnemonics using the default RNG, a custom Node.js crypto RNG, and a deterministic RNG for testing purposes. Also shows the expected size calculation for the RNG function.

```javascript
const bip39 = require('bip39')
const crypto = require('crypto')

// Default RNG (uses @noble/hashes)
const mnemonic1 = bip39.generateMnemonic()

// Custom RNG using Node.js crypto
const nodeRng = (size) => crypto.randomBytes(size)
const mnemonic2 = bip39.generateMnemonic(128, nodeRng)

// Deterministic RNG for testing
const testRng = (size) => Buffer.from('00'.repeat(size), 'hex')
const testMnemonic = bip39.generateMnemonic(128, testRng)
// => 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'

// Request validation: size must equal entropy bytes
bip39.generateMnemonic(160, (size) => {
  console.log(size) // => 20 (160 bits / 8)
  return Buffer.allocUnsafe(size)
})
```

--------------------------------

### Use Explicit Wordlist with Try-Catch

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/errors.md

When using a specific wordlist, such as English, ensure it's correctly loaded. This example shows how to load the English wordlist and includes a try-catch block for handling potential errors during the mnemonic to entropy conversion with a custom wordlist.

```javascript
const bip39 = require('bip39')

const wordlist = bip39.wordlists.english || require('bip39/src/wordlists/english.json')

try {
  const entropy = bip39.mnemonicToEntropy(userInput, wordlist)
} catch (err) {
  // Handle wordlist-specific errors
}
```

--------------------------------

### Convert Mnemonic to Entropy with bip39

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/api-reference.md

Demonstrates how to convert a mnemonic phrase to its hexadecimal entropy string. Includes examples of invalid and valid mnemonics, and usage with a custom Italian wordlist.

```javascript
const bip39 = require('bip39')

const entropy = bip39.mnemonicToEntropy('basket actual')
// Error: Invalid mnemonic (too few words)
```

```javascript
const validMnemonic = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
const entropy = bip39.mnemonicToEntropy(validMnemonic)
// => '00000000000000000000000000000000'
```

```javascript
// Verify with custom wordlist
const italianWords = require('./wordlists/italian.json')
const entropy = bip39.mnemonicToEntropy('abaco abaco abaco abaco abaco abaco abaco abaco abaco abaco aforisma zibetto', italianWords)
// => '00000000000000000000000000000fff'
```

--------------------------------

### getDefaultWordlist

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/module-exports.md

Gets the currently set default wordlist.

```APIDOC
## getDefaultWordlist

### Description
Gets the currently set default wordlist.

### Signature
```typescript
function getDefaultWordlist(): string
```

### Returns
- **string** - The language code of the current default wordlist.
```

--------------------------------

### Get Default Wordlist

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/module-exports.md

Retrieves the currently set default wordlist.

```typescript
export declare function getDefaultWordlist(): string
```

--------------------------------

### Convert Entropy to Mnemonic (Japanese)

Source: https://github.com/bitcoinjs/bip39/blob/master/README.md

Converts entropy to a mnemonic phrase using the Japanese wordlist. This example is shown before changing the default wordlist.

```javascript
bip39.entropyToMnemonic('00000000000000000000000000000fff')
```

--------------------------------

### Get Default BIP39 Wordlist

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/module-exports.md

Retrieves the language code of the currently set default BIP39 wordlist. Useful for checking the active wordlist configuration.

```typescript
function getDefaultWordlist(): string
```

--------------------------------

### Get and Set Default Wordlist

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/api-reference.md

Use `getDefaultWordlist` to retrieve the current default wordlist's language code. Use `setDefaultWordlist` to change the default. Ensure the wordlist exists before setting it.

```javascript
const bip39 = require('bip39')

// Get current default
const current = bip39.getDefaultWordlist()
// => 'english'

// Change default
bip39.setDefaultWordlist('italian')
bip39.getDefaultWordlist()
// => 'italian'

// Restore and verify
bip39.setDefaultWordlist('english')
bip39.getDefaultWordlist()
// => 'english'
```

--------------------------------

### Validate BIP39 Mnemonic with Specific Wordlist

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

This example shows how to validate a mnemonic string against a specific wordlist, demonstrating that validation fails if the wrong wordlist is used.

```javascript
const bip39 = require('bip39')

const italianMnemonic = 'abaco abaco abaco abaco abaco abaco abaco abaco abaco abaco aforisma zibetto'
const italianWords = bip39.wordlists.italian

// Validate with Italian wordlist
console.log(bip39.validateMnemonic(italianMnemonic, italianWords))
// => true

// Validate with English wordlist (wrong language)
console.log(bip39.validateMnemonic(italianMnemonic, bip39.wordlists.english))
// => false
```

--------------------------------

### BIP39 Entropy and Seed Generation with Buffer

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/types.md

Demonstrates creating an entropy Buffer, converting it to a mnemonic, and deriving a seed as a Buffer using bip39 functions. Shows how to check Buffer length, type, and access individual bytes.

```javascript
const bip39 = require('bip39')

// Create entropy Buffer
const entropy = Buffer.from('00000000000000000000000000000000', 'hex')
console.log(entropy.length) // => 16 bytes

// Convert to mnemonic
const mnemonic = bip39.entropyToMnemonic(entropy)

// Derive seed as Buffer
const seed = bip39.mnemonicToSeedSync(mnemonic)
console.log(seed.length)           // => 64 bytes
console.log(seed.toString('hex'))  // => Hex representation
console.log(seed instanceof Buffer) // => true

// Access individual bytes
console.log(seed[0])       // => First byte as number 0-255
console.log(seed.slice(0, 32)) // => First 32 bytes as new Buffer
```

--------------------------------

### Using a Custom BIP39 Wordlist in JavaScript

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/cryptographic-specification.md

Demonstrates how to use a custom wordlist, loaded from a local JSON file, with the 'bip39' library's entropyToMnemonic function.

```javascript
const customWords = require('./my-wordlist.json')
bip39.entropyToMnemonic(entropy, customWords)
```

--------------------------------

### Get Default Wordlist

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/configuration.md

Retrieves the language code of the currently set default wordlist. This is useful for verifying the active wordlist or for debugging.

```javascript
const bip39 = require('bip39')

// Get default
const lang = bip39.getDefaultWordlist()
console.log(lang) // => 'english'

// Verify specific language is default
const isEnglishDefault = bip39.getDefaultWordlist() === 'english'
console.log(isEnglishDefault) // => true

// Change and verify
bip39.setDefaultWordlist('spanish')
console.log(bip39.getDefaultWordlist()) // => 'spanish'

// Restore
bip39.setDefaultWordlist('english')
```

--------------------------------

### Set and Use Default BIP39 Wordlist

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Illustrates how to check the current default wordlist, change it to Italian, and then generate mnemonics in the new default language. Remember to reset it if necessary.

```javascript
const bip39 = require('bip39')

// Check current default
console.log(bip39.getDefaultWordlist())
// => 'english'

// Generate in English
let mnemonic = bip39.entropyToMnemonic('00000000000000000000000000000000')
console.log(mnemonic.slice(0, 7))
// => 'abandon'

// Change to Italian
bip39.setDefaultWordlist('italian')
console.log(bip39.getDefaultWordlist())
// => 'italian'

// Now generates Italian
mnemonic = bip39.entropyToMnemonic('00000000000000000000000000000000')
console.log(mnemonic.slice(0, 5))
// => 'abaco'

// Change back
bip39.setDefaultWordlist('english')
```

--------------------------------

### Generate a Random Mnemonic

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Generates a random 12-word mnemonic phrase using the bip39 library. Ensure the 'bip39' module is installed and required.

```javascript
const bip39 = require('bip39')

// Generate a random 12-word mnemonic
const mnemonic = bip39.generateMnemonic()
console.log(mnemonic)
// => 'seed sock milk update focus rotate barely fade car face mechanic mercy'
```

--------------------------------

### Run Tests

Source: https://github.com/bitcoinjs/bip39/blob/master/CONTRIBUTING.md

Execute project tests using npm.

```bash
npm test
```

--------------------------------

### Accessing and Inspecting BIP39 Wordlists

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/configuration.md

Demonstrates how to check for the availability of a wordlist, access it using its key, and inspect its contents. This includes checking the length and finding the index of a specific word.

```javascript
const bip39 = require('bip39')

// Check if wordlist is available
if (bip39.wordlists.italian) {
  console.log('Italian wordlist available')
  console.log(bip39.wordlists.italian.length) // => 2048
}

// Access by key
const englishWords = bip39.wordlists.english
const englishWords2 = bip39.wordlists.EN  // Same wordlist, alias

// Inspect wordlist
const word = bip39.wordlists.english[0]  // => 'abandon'
const index = bip39.wordlists.english.indexOf('able') // => 2

// All available languages
const languages = Object.keys(bip39.wordlists).filter(
  lang => !['EN', 'JA'].includes(lang)
)
console.log(languages)
// => ['czech', 'chinese_simplified', 'chinese_traditional', 'korean', 'french', 'italian', 'spanish', 'japanese', 'portuguese', 'english']
```

--------------------------------

### BIP39 Main Entry Point Exports

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/api-reference.md

Lists all exported functions from the main BIP39 module, including mnemonic to seed conversion, entropy generation, mnemonic validation, and wordlist utilities.

```typescript
export function mnemonicToSeedSync(mnemonic: string, password?: string): Buffer
export function mnemonicToSeed(mnemonic: string, password?: string): Promise<Buffer>
export function mnemonicToEntropy(mnemonic: string, wordlist?: string[]): string
export function entropyToMnemonic(entropy: Buffer | string, wordlist?: string[]): string
export function generateMnemonic(strength?: number, rng?: (size: number) => Buffer, wordlist?: string[]): string
export function validateMnemonic(mnemonic: string, wordlist?: string[]): boolean
export function setDefaultWordlist(language: string): void
export function getDefaultWordlist(): string
export { wordlists }
```

--------------------------------

### Accessing Compiled BIP39 Wordlists in JavaScript

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/cryptographic-specification.md

Shows how to access the built-in English, Italian, and Spanish wordlists provided by the 'bip39' library.

```javascript
require('bip39').wordlists.english    // English
require('bip39').wordlists.italian    // Italian
require('bip39').wordlists.spanish    // Spanish
// ... etc for all 10 languages
```

--------------------------------

### Generate BIP39 Mnemonic in Italian

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Demonstrates how to generate a BIP39 mnemonic using the Italian wordlist. Ensure the Italian wordlist is available before use.

```javascript
const bip39 = require('bip39')

const italianWords = bip39.wordlists.italian
const mnemonic = bip39.entropyToMnemonic('00000000000000000000000000000000', italianWords)
console.log(mnemonic)
// => 'abaco abaco abaco abaco abaco abaco abaco abaco abaco abaco aforisma zibetto'
```

--------------------------------

### Accessing BIP39 Wordlists

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/module-exports.md

Demonstrates how to access the English wordlist from the BIP39 module and log its length and the first word. This is useful for verifying wordlist integrity or accessing specific words.

```javascript
const bip39 = require('bip39')

const englishWords = bip39.wordlists.english
console.log(englishWords.length) // => 2048
console.log(englishWords[0]) // => 'abandon'
console.log(englishWords.indexOf('bitcoin')) // => word index (or -1)
```

--------------------------------

### Exclude Wordlists with Webpack 5

Source: https://github.com/bitcoinjs/bip39/blob/master/README.md

Configure Webpack 5's IgnorePlugin to exclude specific wordlists at build time, optimizing bundle size. This example excludes all non-English wordlists.

```javascript
plugins: [
  new webpack.IgnorePlugin({
     checkResource(resource) {
       return /.*\/wordlists\/(?!english).*\.json/.test(resource)
     }
   }),
 ],
...
```

--------------------------------

### Using Explicit Wordlists with BIP39 Functions

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/configuration.md

Demonstrates how to use a specific wordlist (e.g., Italian) when generating or validating BIP39 mnemonics. Functions will use the globally set DEFAULT_WORDLIST if no wordlist is provided.

```javascript
const bip39 = require('bip39')

// Use explicitly provided wordlist
const italianWords = bip39.wordlists.italian
const mnemonic = bip39.entropyToMnemonic('00000000000000000000000000000000', italianWords)
// => 'abaco abaco abaco abaco abaco abaco abaco abaco abaco abaco aforisma zibetto'

// All functions support wordlist parameter
bip39.validateMnemonic(mnemonic, italianWords)      // => true
bip39.generateMnemonic(128, undefined, italianWords) // => Italian mnemonic

// Function without wordlist uses default
const mnemonic2 = bip39.entropyToMnemonic('00000000000000000000000000000000')
// Uses DEFAULT_WORDLIST (English if not changed)
```

--------------------------------

### Optional Language Support with Try-Catch

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/architecture.md

This pattern demonstrates how to load wordlists using a try-catch block, allowing bundlers to exclude certain wordlists without causing build errors. It ensures graceful handling of excluded dependencies.

```typescript
// From _wordlists.ts
try {
  _default = require('./wordlists/english.json')
  wordlists.english = _default as string[]
} catch (err) {}
```

--------------------------------

### Check for BIP39 Wordlist Availability

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Demonstrates how to check if a specific wordlist, like Italian, is available in the bundle before attempting to use it for mnemonic generation. This prevents errors if a wordlist is not included.

```javascript
const bip39 = require('bip39')

// Check if wordlist is available
if (bip39.wordlists.italian) {
  console.log('Italian wordlist available')
  const mnemonic = bip39.generateMnemonic(128, undefined, bip39.wordlists.italian)
} else {
  console.log('Italian wordlist not in this bundle')
}
```

--------------------------------

### List Available BIP39 Wordlists

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

This snippet shows how to retrieve a list of all supported wordlists available in the bip39 library. It's useful for understanding the multilingual capabilities.

```javascript
const bip39 = require('bip39')

// Available wordlists
console.log(Object.keys(bip39.wordlists))
// => ['czech', 'chinese_simplified', 'chinese_traditional', 'korean', 'french', 'italian', 'spanish', 'japanese', 'portuguese', 'english', 'EN', 'JA']
```

--------------------------------

### TypeScript Default Import

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/module-exports.md

Import the entire bip39 module as a namespace in TypeScript.

```typescript
import * as bip39 from 'bip39'
const mnemonic: string = bip39.generateMnemonic()
```

--------------------------------

### Change Default Wordlist and Convert Entropy

Source: https://github.com/bitcoinjs/bip39/blob/master/README.md

Demonstrates changing the default wordlist to Italian at runtime and then converting entropy to a mnemonic phrase using the newly set default wordlist.

```javascript
bip39.setDefaultWordlist('italian')
bip39.entropyToMnemonic('00000000000000000000000000000fff')
```

--------------------------------

### Generate Mnemonic without Default Wordlist

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/errors.md

Shows how generating a mnemonic fails when no default wordlist is available in minimal builds, and how to explicitly provide a custom wordlist.

```javascript
// Minimal browserified bundle with no wordlists
const bip39 = require('bip39-minimal')

// No default wordlist available
try {
  bip39.generateMnemonic()
} catch (err) {
  console.log(err.message)
  // => 'A wordlist is required but a default could not be found.\nPlease pass a 2048 word array explicitly.'
}

// Must provide wordlist explicitly
const customWords = require('./my-wordlist.json')
const mnemonic = bip39.generateMnemonic(128, undefined, customWords)
// => 'success...'
```

--------------------------------

### Generate BIP39 Mnemonic in Spanish

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Shows how to generate a BIP39 mnemonic using the Spanish wordlist. This requires the Spanish wordlist to be present.

```javascript
const bip39 = require('bip39')

const spanishWords = bip39.wordlists.spanish
const mnemonic = bip39.entropyToMnemonic('00000000000000000000000000000000', spanishWords)
// => Spanish mnemonic
```

--------------------------------

### Integrate with HD Wallet

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/README.md

Initializes an HD wallet node from a derived seed. This is a common step for managing multiple accounts and addresses.

```javascript
const bip32 = require('bip32')
const node = bip32.fromSeed(seed)
```

--------------------------------

### Set Default Wordlist

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/module-exports.md

Sets the default wordlist for the BIP39 library. Accepts a language string (e.g., 'EN', 'ES').

```typescript
export declare function setDefaultWordlist(language: string): void
```

--------------------------------

### Round-Trip Validation: Entropy to Mnemonic to Entropy

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Demonstrates a round-trip conversion by converting entropy to a mnemonic and then back to entropy, verifying that the original and recovered entropy match. Requires the 'bip39' module.

```javascript
const bip39 = require('bip39')

// Generate mnemonic from entropy
const originalEntropy = Buffer.allocUnsafe(16).fill(0x42)
const mnemonic = bip39.entropyToMnemonic(originalEntropy)

// Convert back to entropy
const recoveredEntropy = bip39.mnemonicToEntropy(mnemonic)

// Verify they match
console.log(originalEntropy.toString('hex') === recoveredEntropy)
// => true
```

--------------------------------

### Mnemonic to Seed Performance Notes

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/architecture.md

Compares the synchronous and asynchronous methods for mnemonic to seed derivation, highlighting performance characteristics.

```text
Performance:
- `mnemonicToSeedSync()` — Blocking, ~100ms per derivation
- `mnemonicToSeed()` — Async (PBKDF2-async), allows event loop interleaving
```

--------------------------------

### Seed Derivation using PBKDF2

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/architecture.md

Explains the BIP39 specification for deriving a seed from a mnemonic and optional password using PBKDF2 with SHA-512.

```text
BIP39 Spec: MNEMONIC → SEED

Uses PBKDF2 Key Derivation Function (NIST SP 800-132):

Inputs:
  - Mnemonic (UTF-8 normalized NFKD)
  - Password (UTF-8 normalized NFKD, optional)
  - Salt = "mnemonic" + password
  - Hash function = SHA-512
  - Iterations = 2048
  - Output length = 64 bytes (512 bits)

Output:
  - 64-byte seed suitable for HD wallet derivation (BIP32)
```

--------------------------------

### Validate BIP39 Mnemonic Before Use (Recommended)

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/errors.md

Recommended for safety, this pattern first validates the mnemonic using `validateMnemonic`. If valid, it proceeds to convert it to a seed; otherwise, it handles the invalid input.

```javascript
const bip39 = require('bip39')

const isValid = bip39.validateMnemonic(userInput)
if (isValid) {
  // Proceed safely
  const seed = bip39.mnemonicToSeedSync(userInput)
} else {
  // Handle invalid input
  console.error('Invalid mnemonic phrase')
}
```

--------------------------------

### Asynchronous Seed Derivation for Multiple Users

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Use asynchronous derivation for concurrent operations or when the event loop must remain responsive, such as in server environments handling multiple requests. Requires the 'bip39' module.

```javascript
const bip39 = require('bip39')

// Use async when:
// - Multiple derivations concurrently
// - Server handling many requests
// - Event loop should remain responsive

async function deriveSeedsForMultipleUsers(mnemonics) {
  const seeds = await Promise.all(
    mnemonics.map(m => bip39.mnemonicToSeed(m))
  )
  return seeds
}

const mnemonics = [
  'abandon abandon...',
  'about about...',
  'acid acid...'
]

deriveSeedsForMultipleUsers(mnemonics).then(seeds => {
  console.log('All seeds derived:', seeds.length)
})
```

--------------------------------

### Mnemonic to Entropy Algorithm Steps

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/cryptographic-specification.md

Outlines the algorithmic steps for converting a mnemonic phrase to entropy, including validation and checksum verification.

```plaintext
word_count = mnemonic.split(' ').length
If word_count % 3 ≠ 0, throw Error('Invalid mnemonic')
Constraints: 12 ≤ word_count ≤ 24
```

```plaintext
For each word in mnemonic:
  index = wordlist.indexOf(word)
  If index = -1, throw Error('Invalid mnemonic')
  Convert index to 11-bit binary
  Concatenate all binary representations
```

```plaintext
total_bits = words.length × 11
entropy_bits_count = ⌊(total_bits ÷ 33)⌋ × 32
entropy_bits = first entropy_bits_count bits
checksum_bits = remaining bits

entropy_bytes = entropy_bits converted to bytes
```

```plaintext
If entropy.length < 16 or > 32 or % 4 ≠ 0:
  throw Error('Invalid entropy')
```

```plaintext
computed_checksum = SHA256(entropy).bits[0:checksum_bits.length]
If computed_checksum ≠ extracted_checksum:
  throw Error('Invalid mnemonic checksum')
```

```plaintext
Return entropy.toString('hex')
```

--------------------------------

### Entropy to Mnemonic Encoding Algorithm

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/architecture.md

Explains the BIP39 specification for converting entropy to a mnemonic phrase, including checksum calculation and word mapping.

```text
BIP39 Spec: ENTROPY → MNEMONIC

1. Take entropy bytes (ENT bits, 128-256, multiple of 32)
2. Compute SHA256 hash of entropy
3. Extract first ENT/32 bits from hash → checksum bits (CS)
4. Concatenate: ENT bits + CS bits = (ENT + CS) total bits
5. Split into 11-bit chunks (always results in whole chunks)
6. Map each 11-bit value (0-2047) to wordlist index
7. Join with space (U+3000 for Japanese)
```

--------------------------------

### Construct Salt for PBKDF2

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/cryptographic-specification.md

Creates the salt string by concatenating the prefix 'mnemonic' with the normalized password. If no password is provided, the salt is simply 'mnemonic'.

```plaintext
salt_string = "mnemonic" + password_normalized
salt_bytes = UTF-8 encode(salt_string)
```

--------------------------------

### Create a Recoverable Wallet with Mnemonic

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Generates a new mnemonic phrase for a recoverable wallet. It is crucial to back up the generated mnemonic securely.

```javascript
const bip39 = require('bip39')

function createWallet() {
  const mnemonic = bip39.generateMnemonic()
  
  return {
    mnemonic: mnemonic,
    // Back up this mnemonic securely!
    
    entropy: bip39.mnemonicToEntropy(mnemonic),
    // Optional: also back up entropy in hex format
  }
}

const wallet = createWallet()
console.log('Save this mnemonic safely:')
console.log(wallet.mnemonic)
```

--------------------------------

### BIP39 Project Structure

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/architecture.md

Illustrates the directory layout of the bip39 project, highlighting the source code organization for TypeScript, compiled JavaScript, type definitions, and tests.

```tree
bip39/
├── ts_src/
│   ├── index.ts                    # Main API implementation
│   ├── _wordlists.ts               # Wordlist loading and export
│   └── wordlists/
│       ├── english.json            # 2048 English words
│       ├── spanish.json            # 2048 Spanish words
│       ├── italian.json            # 2048 Italian words
│       ├── french.json             # 2048 French words
│       ├── portuguese.json         # 2048 Portuguese words
│       ├── czech.json              # 2048 Czech words
│       ├── japanese.json           # 2048 Japanese words
│       ├── korean.json             # 2048 Korean words
│       ├── chinese_simplified.json # 2048 Simplified Chinese words
│       └── chinese_traditional.json # 2048 Traditional Chinese words
├── src/                            # Compiled JavaScript (generated by tsc)
├── types/
│   ├── index.d.ts                  # Main API types
│   ├── _wordlists.d.ts            # Wordlist types
│   └── wordlists.d.ts             # Wordlist type re-exports
└── test/
    ├── index.js                    # Main test suite
    ├── vectors.json                # BIP39 test vectors
    └── wordlist.json               # Custom wordlist for testing
```

--------------------------------

### Convert Entropy to Mnemonic

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Converts a given entropy (as a hex string or Buffer) into a BIP39 mnemonic phrase. Ensure the 'bip39' module is required.

```javascript
const bip39 = require('bip39')

// From hex string
const entropy = '00000000000000000000000000000000'
const mnemonic = bip39.entropyToMnemonic(entropy)
console.log(mnemonic)
// => 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'

// From Buffer
const entropyBuffer = Buffer.from(entropy, 'hex')
const mnemonic2 = bip39.entropyToMnemonic(entropyBuffer)
// => 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
```

--------------------------------

### Entropy to Mnemonic Conversion Flow

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/architecture.md

Illustrates the process of converting entropy bytes into a BIP39 mnemonic phrase. Includes entropy validation, checksum derivation, and word mapping.

```text
External RNG (or @noble/hashes)
    ↓
generateMnemonic(strength, rng, wordlist)
    ↓
rng(strength / 8) → bytes
    ↓
entropyToMnemonic(bytes, wordlist)
    ├─ Validate entropy size (16-32, div by 4)
    ├─ Convert bytes to binary
    ├─ Derive checksum (SHA256 hash)
    ├─ Append checksum bits
    ├─ Split into 11-bit chunks
    ├─ Map chunks to wordlist indices
    └─ Join words with space (or U+3000 for Japanese)
    ↓
Mnemonic phrase (string)
```

--------------------------------

### Generate Deterministic Mnemonic for Testing

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Employ a fixed random number generator to create reproducible BIP39 mnemonics, ideal for testing purposes.

```javascript
const bip39 = require('bip39')

// Fixed RNG for reproducible results
const fixedRng = (size) => Buffer.alloc(size, 0)
const mnemonic = bip39.generateMnemonic(128, fixedRng)
console.log(mnemonic)
// => 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
// (Always the same)
```

--------------------------------

### Handle Missing Default Wordlist in BIP39

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/errors.md

Provides a recovery strategy for handling missing default wordlists by setting a default or explicitly passing a wordlist during mnemonic generation.

```javascript
const bip39 = require('bip39')
const englishWords = require('bip39/src/wordlists/english.json')

// Handle potential missing default
if (!bip39.wordlists.english) {
  // Fallback: load wordlist from file or external source
  bip39.setDefaultWordlist('english')
}

try {
  const mnemonic = bip39.generateMnemonic()
} catch (err) {
  if (err.message.includes('wordlist is required')) {
    const mnemonic = bip39.generateMnemonic(128, undefined, englishWords)
  } else {
    throw err
  }
}
```

--------------------------------

### Generating BIP39 Mnemonics with Different Strengths

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/configuration.md

Shows how to generate BIP39 mnemonics of varying lengths by specifying the entropy strength. The default strength is 128 bits, resulting in a 12-word mnemonic. Invalid strengths will throw an error.

```javascript
const bip39 = require('bip39')

// 12-word mnemonic (default)
const mnemonic12 = bip39.generateMnemonic()
console.log(mnemonic12.split(' ').length) // => 12

// 15-word mnemonic (160 bits)
const mnemonic15 = bip39.generateMnemonic(160)
console.log(mnemonic15.split(' ').length) // => 15

// 24-word mnemonic (256 bits, maximum)
const mnemonic24 = bip39.generateMnemonic(256)
console.log(mnemonic24.split(' ').length) // => 24

// Invalid strength throws error
try {
  bip39.generateMnemonic(100)
} catch (err) {
  console.log(err.message) // => 'Invalid entropy'
}
```

--------------------------------

### Derive Seed from Mnemonic with Password

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Shows how to derive a seed from a mnemonic when a password is provided. The resulting seed will differ from one generated without a password.

```javascript
const bip39 = require('bip39')

const mnemonic = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
const password = 'my-super-secure-password'

const seed = bip39.mnemonicToSeedSync(mnemonic, password)
console.log(seed.toString('hex'))
// => Different from seed without password
```

--------------------------------

### Performance Comparison: Sync vs. Async Seed Derivation

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Compares the execution time and blocking behavior of synchronous and asynchronous seed derivation. The asynchronous version allows other code to run concurrently.

```javascript
const bip39 = require('bip39')
const mnemonic = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'

// Synchronous: blocks for ~100ms
console.time('sync')
const seed1 = bip39.mnemonicToSeedSync(mnemonic)
console.timeEnd('sync')
// => ~100ms

// Asynchronous: non-blocking
console.time('async')
bip39.mnemonicToSeed(mnemonic).then(seed2 => {
  console.timeEnd('async')
  // => ~100ms (but other code can run during this time)
})

// Continue other work while async completes
console.log('This runs immediately')
```

--------------------------------

### Handle BIP39 Errors with Try-Catch

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/errors.md

Use a try-catch block to handle potential errors during mnemonic to entropy conversion. Differentiate between 'Invalid mnemonic' and 'Invalid mnemonic checksum' for specific user feedback.

```javascript
const bip39 = require('bip39')

try {
  const entropy = bip39.mnemonicToEntropy(userInput, wordlist)
} catch (err) {
  if (err.message === 'Invalid mnemonic') {
    console.error('Phrase has wrong format or contains unknown words')
  } else if (err.message === 'Invalid mnemonic checksum') {
    console.error('Phrase is not valid (wrong checksum)')
    console.error('Allow user to continue at own risk?')
  } else {
    throw err
  }
}
```

--------------------------------

### mnemonicToSeed()

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/api-reference.md

Asynchronously derives a BIP39 seed from a mnemonic phrase and an optional password. It uses asynchronous PBKDF2 for better performance in high-concurrency scenarios.

```APIDOC
## mnemonicToSeed()

### Description
Asynchronously derive a BIP39 seed from a mnemonic phrase.

### Method
Asynchronous function (returns a Promise)

### Parameters
#### Parameters
- **mnemonic** (string) - Required - Mnemonic phrase
- **password** (string) - Optional - Optional passphrase (defaults to '')

### Returns
`Promise<Buffer>` — Promise resolving to a 64-byte seed buffer.

### Behavior
- Same as `mnemonicToSeedSync` but uses async PBKDF2 for better performance with large async queues.
- May allow event loop processing between iterations on high-concurrency systems.

### Example
```javascript
const bip39 = require('bip39')

const mnemonic = 'basket actual abandon abandon abandon abandon abandon abandon abandon abandon abandon about'

// Promise-based
bip39.mnemonicToSeed(mnemonic, 'password').then(seed => {
  console.log(seed.toString('hex'))
})

// With async/await
async function deriveSeed() {
  const seed = await bip39.mnemonicToSeed(mnemonic, 'password')
  return seed
}

// Multiple concurrent derivations
const promises = [
  bip39.mnemonicToSeed(mnemonic1),
  bip39.mnemonicToSeed(mnemonic2),
  bip39.mnemonicToSeed(mnemonic3),
]
Promise.all(promises).then(seeds => {
  console.log('All seeds ready:', seeds)
})
```
```

--------------------------------

### Synchronous Seed Derivation

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Use synchronous derivation when blocking is acceptable, such as for single derivations during application startup. Requires the 'bip39' module.

```javascript
const bip39 = require('bip39')

// Use sync when:
// - Single derivation in startup sequence
// - Blocking is acceptable
// - Simple, synchronous code preferred

function initializeWallet() {
  const mnemonic = bip39.generateMnemonic()
  const seed = bip39.mnemonicToSeedSync(mnemonic)
  // Wallet ready
  return { mnemonic, seed }
}

const wallet = initializeWallet()
```

--------------------------------

### Derive Seed from Mnemonic (Synchronous and Asynchronous)

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Demonstrates deriving a seed from a mnemonic using both synchronous and asynchronous methods. Verifies the seed length.

```javascript
const bip39 = require('bip39')

const mnemonic = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'

// Synchronous
const seed1 = bip39.mnemonicToSeedSync(mnemonic)
console.log(seed1.length)
// => 64

// Asynchronous
bip39.mnemonicToSeed(mnemonic).then(seed2 => {
  console.log(seed2.length)
  // => 64
})
```

--------------------------------

### Derive HD Wallet Keys from Mnemonic

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Generates a mnemonic, derives the seed, and then creates an HD master node to derive private and public keys for a specific account path.

```javascript
const bip39 = require('bip39')
const bip32 = require('bip32')

// Step 1: Generate mnemonic
const mnemonic = bip39.generateMnemonic()
console.log('Mnemonic:', mnemonic)

// Step 2: Derive seed
const seed = bip39.mnemonicToSeedSync(mnemonic)

// Step 3: Create master HD node
const masterNode = bip32.fromSeed(seed)

// Step 4: Derive account
const account = masterNode.derivePath("m/44'/0'/0'")

// Step 5: Derive address path
const address = account.derivePath('0/0')

console.log('Private key:', address.privateKey.toString('hex'))
console.log('Public key:', address.publicKey.toString('hex'))
```

--------------------------------

### Accessing BIP39 Wordlists

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/module-exports.md

The `wordlists` object allows direct access to different language wordlists. Each wordlist is an array of 2048 unique words. You can access them using their language keys (e.g., 'english', 'spanish', 'japanese').

```APIDOC
## Accessing BIP39 Wordlists

### Description

The `wordlists` object provides access to various language-specific wordlists used in BIP39. Each wordlist is an array containing 2048 unique words.

### Access

`require('bip39').wordlists`

### Available Wordlists

- **english**: 2048 English words
- **EN**: Alias for `english`
- **italian**: 2048 Italian words
- **spanish**: 2048 Spanish words
- **french**: 2048 French words
- **portuguese**: 2048 Portuguese words
- **czech**: 2048 Czech words
- **japanese**: 2048 Japanese words
- **JA**: Alias for `japanese`
- **korean**: 2048 Korean words
- **chinese_simplified**: 2048 Simplified Chinese words
- **chinese_traditional**: 2048 Traditional Chinese words

### Properties

- Each wordlist contains exactly 2048 unique words.
- Wordlists are loaded as JSON at module initialization.
- May be `undefined` if excluded by a bundler.
- All imports reference the same global arrays.

### Example

```javascript
const bip39 = require('bip39')

const englishWords = bip39.wordlists.english
console.log(englishWords.length) // => 2048
console.log(englishWords[0]) // => 'abandon'
console.log(englishWords.indexOf('bitcoin')) // => word index (or -1)
```
```

--------------------------------

### Exclude Wordlists with Browserify

Source: https://github.com/bitcoinjs/bip39/blob/master/README.md

Use this command to create a smaller browser bundle by excluding specific wordlists, leaving only the desired ones. This reduces the overall size of your application.

```bash
browserify -r bip39 -s bip39 \
  --exclude=./wordlists/english.json \
  --exclude=./wordlists/japanese.json \
  --exclude=./wordlists/spanish.json \
  --exclude=./wordlists/italian.json \
  --exclude=./wordlists/french.json \
  --exclude=./wordlists/korean.json \
  --exclude=./wordlists/czech.json \
  --exclude=./wordlists/portuguese.json \
  --exclude=./wordlists/chinese_traditional.json \
   > bip39.browser.js
```

--------------------------------

### Verify Different Passwords Yield Different Seeds

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/usage-examples.md

Illustrates that using the same mnemonic but different passwords results in distinct seeds. This is crucial for key derivation.

```javascript
const bip39 = require('bip39')

const mnemonic = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'

const seed1 = bip39.mnemonicToSeedSync(mnemonic, 'password1')
const seed2 = bip39.mnemonicToSeedSync(mnemonic, 'password2')

console.log(seed1.toString('hex') === seed2.toString('hex'))
// => false

// Same mnemonic + different password = different keys
```

--------------------------------

### Format Code

Source: https://github.com/bitcoinjs/bip39/blob/master/CONTRIBUTING.md

Format TypeScript code using npm scripts.

```bash
npm run format
```

--------------------------------

### Derive Seed with Password (BIP39 Salt)

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/configuration.md

Use the password parameter to derive a seed with an additional layer of security. The same mnemonic with a different password will produce a different seed.

```javascript
const bip39 = require('bip39')

const mnemonic = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'

// Derive seed without password
const seed1 = bip39.mnemonicToSeedSync(mnemonic)
console.log(seed1.toString('hex').slice(0, 32))
// => '5cf2d4a8b0355e90295bdfc565a022a409af063d5365bb57bf74d9528f494bfa'

// Derive seed with password
const seed2 = bip39.mnemonicToSeedSync(mnemonic, 'my-password')
console.log(seed2.toString('hex').slice(0, 32))
// => '46168448...'

// Same mnemonic, different password = different seed
const seed3 = bip39.mnemonicToSeedSync(mnemonic, 'different-password')
console.log(seed3.toString('hex').slice(0, 32))
// => 'a1b2c3d4...'

// Empty string is same as no password
const seed4 = bip39.mnemonicToSeedSync(mnemonic, '')
console.log(seed4.toString('hex') === seed1.toString('hex')) // => true

// UTF-8 passwords are normalized (NFKD)
const seed5 = bip39.mnemonicToSeedSync(mnemonic, '㍍ガバヴァ')
const seed6 = bip39.mnemonicToSeedSync(mnemonic, 'メートルガバヴァ')
// Both may produce same seed depending on normalization equivalence
```

--------------------------------

### Mnemonic to Seed (Synchronous)

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/module-exports.md

Converts a BIP39 mnemonic phrase to a seed buffer synchronously. Requires a mnemonic string and an optional password.

```typescript
export declare function mnemonicToSeedSync(
  mnemonic: string,
  password?: string
): Buffer
```

--------------------------------

### mnemonicToSeedSync()

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/api-reference.md

Synchronously derives a BIP39 seed from a mnemonic phrase and an optional password. It uses PBKDF2-SHA512 with specific parameters and normalizes inputs using NFKD Unicode normalization.

```APIDOC
## mnemonicToSeedSync()

### Description
Synchronously derive a BIP39 seed from a mnemonic phrase (PBKDF2-SHA512).

### Method
Synchronous function call

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **mnemonic** (string) - Required - Mnemonic phrase
- **password** (string) - Optional - Optional passphrase (BIP39 refers to this as the "salt")

### Returns
`Buffer` — 64-byte seed buffer suitable for HD wallet derivation

### Behavior
- Normalizes both mnemonic and password using NFKD Unicode normalization
- Uses PBKDF2 with SHA-512, 2048 iterations, salt is "mnemonic" + password
- Returns 64-byte derived key

### Request Example
```javascript
const bip39 = require('bip39')

// Without password
const seed = bip39.mnemonicToSeedSync('basket actual abandon abandon abandon abandon abandon abandon abandon abandon abandon about')

// With password
const seedWithPass = bip39.mnemonicToSeedSync('basket actual abandon abandon abandon abandon abandon abandon abandon abandon abandon about', 'mypassword')

// Convert to hex for inspection
const hexSeed = seed.toString('hex')

// Use with HD wallet library (e.g., bip32)
const bip32 = require('bip32')
const node = bip32.fromSeed(seed)
```

### Response
#### Success Response (Buffer)
- A 64-byte seed buffer.

#### Response Example
```javascript
// Example seed buffer output (first few bytes shown)
// Buffer <5c f2 d4 a8 b0 35 5e 90 ...>
// Example hex seed output
// '5cf2d4a8b0355e90295bdfc565a022a409af063d5365bb57bf74d9528f494bfa4400f53d8349b80fdae44082d7f9541e1dba2b003bcfec9d0d53781ca676651f'
```
```

--------------------------------

### Generate Mnemonic with Custom RNG

Source: https://github.com/bitcoinjs/bip39/blob/master/_autodocs/architecture.md

This snippet demonstrates how to generate a mnemonic using a custom random number generator (RNG). Replace `getRandomBytesFromHardware` with your specific RNG implementation.

```javascript
const bip39 = require('bip39')
const myRng = (size) => getRandomBytesFromHardware(size)
const mnemonic = bip39.generateMnemonic(128, myRng)
```