Overview

Mnemonic generation converts a small, human-readable set of words into a cryptographically strong wallet seed. A Prokey-style implementation usually follows the BIP39 standard, combined with BIP32 and BIP44 ideas, so that users can recover private keys without handling long hexadecimal strings directly.

1. Entropy Collection

The process starts with entropy, which is random data used as the foundation of the wallet.

  • Typical entropy lengths are 128, 160, 192, 224, or 256 bits.
  • Strong entropy sources include a cryptographic pseudorandom number generator, operating system randomness, and hardware random generators when available.
  • If a product combines user actions, timing inputs, or server-provided randomness, those inputs should be mixed carefully so that no single source can predict the final result.
  • The entropy must remain confidential; anyone who knows it can reproduce the mnemonic.

2. Checksum Creation

BIP39 uses a checksum to protect against mistyped or copied words.

  • The SHA-256 hash of the entropy is computed.
  • A number of leading bits from the hash are appended to the entropy.
  • The checksum length depends on entropy length: 128 bits entropy adds 4 checksum bits, 256 bits entropy adds 8 checksum bits.
  • The combined value is then split into 11-bit groups.

entropy

3. Wordlist Mapping

Each 11-bit group maps to one word in a fixed dictionary.

  • BIP39 commonly uses a list of 2,048 words.
  • Eleven bits are enough to address all 2,048 words because 2^11 equals 2,048.
  • The resulting sequence of words is the mnemonic phrase.
  • A 128-bit entropy value normally produces 12 words, while a 256-bit entropy value produces 24 words.

4. Optional Passphrase

A Prokey-style wallet may ask whether to add a passphrase.

  • Without a passphrase, the mnemonic is converted with the fixed salt string mnemonic.
  • With a passphrase, the user secret is added to the salt.
  • PBKDF2 with HMAC-SHA512 is commonly used to stretch the mnemonic into a 512-bit seed.
  • The passphrase must be remembered in addition to the words because it changes the resulting wallet.

5. Seed Derivation

The final seed is the key material used by a hierarchical deterministic wallet.

Prokey

  • The seed is not a private key itself, but it is the parent material for all derived keys.
  • BIP32 defines how to derive a master private key, master public key, and chain code from the seed.
  • BIP44 defines derivation paths for multiple accounts, chains, and addresses.
  • A typical path may look like m/44'/0'/0'/0/0 for a standard chain and address.

6. Address and Key Generation

From the derived private key, the wallet produces public keys and addresses.

  • A private key is used to sign transactions.
  • A public key is generated through elliptic curve cryptography.
  • An address is usually a hash-encoded representation of the public key.
  • The wallet can create many addresses from one seed while keeping recovery manageable.

7. Validation Logic

Mnemonic validation focuses on whether the phrase is internally consistent.

  • Each word must exist in the accepted wordlist.
  • The checksum must match the embedded entropy and hash bits.
  • Some tools only check word validity and ignore the checksum, so users should not rely on superficial acceptance.
  • Recovery should fail safely when the phrase is incomplete, reordered, or corrupted.

checksum

8. Security Assumptions

The security of mnemonic generation depends on several design choices.

  • The entropy generator must be unpredictable and not seeded by weak data.
  • Backup storage must resist theft, loss, and unauthorized access.
  • The user interface should encourage correct verification instead of blind confirmation.
  • Software updates and supply-chain integrity matter because a compromised implementation can leak seeds.
  • If Prokey-style systems use encryption, biometrics, PINs, or multi-device storage, those are access controls that protect the local key material, not replacements for the entropy.

9. Common Misconceptions

  • A mnemonic is not a password. Passwords can be changed easily, but mnemonic loss usually means wallet loss.
  • More words are not always safer. Properly generated 12-word phrases from 128-bit entropy are already strong.
  • The phrase and passphrase are different. The words alone may not restore a wallet if a passphrase was used.
  • Generation and storage are separate problems. Even a correctly generated mnemonic can be compromised if it is stored in an insecure file or cloud note.

Conclusion

Prokey-style mnemonic generation is best understood as a deterministic pipeline: entropy is collected, a checksum is appended, the bits are mapped to words, the mnemonic is converted into a seed, and that seed is used to derive keys and addresses. The cryptographic safety comes from strong randomness, standard encoding, careful key stretching, and disciplined user backup practices.