Skip to content
light theme Algorand Developer Portal dark theme Algorand Developer Portal Algorand Developer Portal

Secret Key to Mnemonic

← Back to Mnemonic Utilities

Description

Section titled “Description”

This example demonstrates how to use secretKeyToMnemonic() to convert a 64-byte Algorand secret key to a 25-word mnemonic. Key concepts:

  • Algorand secret keys are 64 bytes: bytes 0-31 are the seed, bytes 32-63 are the public key
  • secretKeyToMnemonic() extracts the first 32 bytes (seed portion) and converts to mnemonic
  • This produces the same result as calling mnemonicFromSeed() on the seed directly

Prerequisites

Section titled “Prerequisites”
  • No LocalNet required

Run This Example

Section titled “Run This Example”

From the repository root:

Terminal window
cd examples
npm run example algo25/03-secret-key-to-mnemonic.ts

Code

Section titled “Code”

View source on GitHub

03-secret-key-to-mnemonic.ts
/**
 * Example: Secret Key to Mnemonic
 *
 * This example demonstrates how to use secretKeyToMnemonic() to convert a
 * 64-byte Algorand secret key to a 25-word mnemonic.
 *
 * Key concepts:
 * - Algorand secret keys are 64 bytes: bytes 0-31 are the seed, bytes 32-63 are the public key
 * - secretKeyToMnemonic() extracts the first 32 bytes (seed portion) and converts to mnemonic
 * - This produces the same result as calling mnemonicFromSeed() on the seed directly
 *
 * Prerequisites:
 * - No LocalNet required
 */


import { mnemonicFromSeed, secretKeyToMnemonic } from '@algorandfoundation/algokit-utils/algo25'
import { formatHex, printHeader, printInfo, printStep, printSuccess } from '../shared/utils.js'


function main() {
  printHeader('Secret Key to Mnemonic Example')


  // Step 1: Create a 64-byte secret key (simulating what Algorand uses)
  printStep(1, 'Create a 64-byte Algorand Secret Key')


  // In Algorand, the secret key is 64 bytes:
  // - Bytes 0-31: The seed (private key material)
  // - Bytes 32-63: The public key (derived from the seed)
  const secretKey = new Uint8Array(64)
  crypto.getRandomValues(secretKey)


  printInfo(`Secret key length: ${secretKey.length} bytes`)
  printInfo(`Structure:`)
  printInfo(`  Bytes 0-31  (seed):       ${formatHex(secretKey.slice(0, 32))}`)
  printInfo(`  Bytes 32-63 (public key): ${formatHex(secretKey.slice(32, 64))}`)


  // Step 2: Display the secret key structure
  printStep(2, 'Understand the Secret Key Structure')


  printInfo('Algorand secret keys are 64 bytes (512 bits):')
  printInfo('')
  printInfo('  ┌────────────────────────────────┬────────────────────────────────┐')
  printInfo('  │     Seed (32 bytes)            │     Public Key (32 bytes)      │')
  printInfo('  │     Bytes 0-31                 │     Bytes 32-63                │')
  printInfo('  │     (Private key material)     │     (Derived from seed)        │')
  printInfo('  └────────────────────────────────┴────────────────────────────────┘')
  printInfo('')
  printInfo('The seed is the actual secret; the public key is appended for convenience.')
  printInfo('When converting to mnemonic, only the seed portion is needed.')


  // Step 3: Convert secret key to mnemonic using secretKeyToMnemonic
  printStep(3, 'Convert Secret Key to Mnemonic using secretKeyToMnemonic()')


  const mnemonicFromSecretKey = secretKeyToMnemonic(secretKey)
  const words = mnemonicFromSecretKey.split(' ')


  printInfo(`Mnemonic has ${words.length} words`)
  printInfo('Mnemonic words:')
  // Display words in rows of 5 for readability
  for (let i = 0; i < words.length; i += 5) {
    const row = words.slice(i, i + 5)
    const numbered = row.map((w, j) => `${(i + j + 1).toString().padStart(2, ' ')}. ${w.padEnd(10)}`).join(' ')
    printInfo(`  ${numbered}`)
  }


  // Step 4: Explain what secretKeyToMnemonic does internally
  printStep(4, 'What secretKeyToMnemonic() Does Internally')


  printInfo('secretKeyToMnemonic(secretKey) performs these steps:')
  printInfo('  1. Extract the seed: secretKey.slice(0, 32)')
  printInfo('  2. Call mnemonicFromSeed(seed) on the extracted 32 bytes')
  printInfo('  3. Return the resulting 25-word mnemonic')
  printInfo('')
  printInfo('This is equivalent to:')
  printInfo('  const seed = secretKey.slice(0, 32)')
  printInfo('  const mnemonic = mnemonicFromSeed(seed)')


  // Step 5: Compare with calling mnemonicFromSeed directly
  printStep(5, 'Compare with mnemonicFromSeed() on First 32 Bytes')


  const seed = secretKey.slice(0, 32)
  const mnemonicFromSeedDirect = mnemonicFromSeed(seed)


  printInfo('Method 1: secretKeyToMnemonic(64-byte secretKey)')
  printInfo(`  Result: "${mnemonicFromSecretKey.split(' ').slice(0, 5).join(' ')}..."`)
  printInfo('')
  printInfo('Method 2: mnemonicFromSeed(secretKey.slice(0, 32))')
  printInfo(`  Result: "${mnemonicFromSeedDirect.split(' ').slice(0, 5).join(' ')}..."`)


  const mnemonicsMatch = mnemonicFromSecretKey === mnemonicFromSeedDirect
  printInfo('')
  printInfo(`Mnemonics identical: ${mnemonicsMatch ? 'Yes' : 'No'}`)


  if (mnemonicsMatch) {
    printSuccess('Both methods produce identical mnemonics!')
  }


  // Step 6: Demonstrate that only the seed portion matters
  printStep(6, 'Only the Seed Portion Affects the Mnemonic')


  // Create a second secret key with the same seed but different "public key" bytes
  const secretKey2 = new Uint8Array(64)
  secretKey2.set(seed, 0) // Same seed
  crypto.getRandomValues(secretKey2.subarray(32)) // Different public key portion


  const mnemonic1 = secretKeyToMnemonic(secretKey)
  const mnemonic2 = secretKeyToMnemonic(secretKey2)


  printInfo('Secret Key 1 (first 8 bytes of public key):')
  printInfo(`  ${formatHex(secretKey.slice(32, 40))}...`)
  printInfo('Secret Key 2 (first 8 bytes of public key):')
  printInfo(`  ${formatHex(secretKey2.slice(32, 40))}...`)
  printInfo('')
  printInfo('Same seed, different public key bytes...')
  printInfo(`Mnemonic 1: "${mnemonic1.split(' ').slice(0, 3).join(' ')}..."`)
  printInfo(`Mnemonic 2: "${mnemonic2.split(' ').slice(0, 3).join(' ')}..."`)
  printInfo(`Mnemonics identical: ${mnemonic1 === mnemonic2 ? 'Yes' : 'No'}`)


  if (mnemonic1 === mnemonic2) {
    printSuccess('The public key portion (bytes 32-63) does not affect the mnemonic.')
  }


  // Step 7: Use cases for secretKeyToMnemonic
  printStep(7, 'When to Use secretKeyToMnemonic()')


  printInfo('Use secretKeyToMnemonic() when you have a 64-byte Algorand secret key')
  printInfo('and need to convert it to a mnemonic for backup or display.')
  printInfo('')
  printInfo('Common scenarios:')
  printInfo('  - Exporting an account from a wallet')
  printInfo('  - Displaying the recovery phrase after key generation')
  printInfo('  - Converting keys from ed25519 libraries that output 64-byte keys')
  printInfo('')
  printInfo('Use mnemonicFromSeed() directly when you only have the 32-byte seed.')


  // Step 8: Summary
  printStep(8, 'Summary')


  printInfo('secretKeyToMnemonic() converts a 64-byte secret key to a 25-word mnemonic:')
  printInfo('  - Input: 64-byte Uint8Array (Algorand secret key format)')
  printInfo('  - Output: Space-separated string of 25 words')
  printInfo('  - Internally extracts bytes 0-31 (the seed portion)')
  printInfo('  - Produces identical result to mnemonicFromSeed(seed)')
  printInfo('  - Bytes 32-63 (public key portion) are ignored')
  printInfo('')
  printInfo('Relationship between functions:')
  printInfo('  secretKeyToMnemonic(sk) === mnemonicFromSeed(sk.slice(0, 32))')


  printSuccess('Secret Key to Mnemonic example completed successfully!')
}


main()

Other examples in Mnemonic Utilities

Section titled “Other examples in Mnemonic Utilities”