Rust BIP39 Library

A standalone Rust library for BIP39 mnemonic generation and handling. This library provides a clean, well-tested implementation of the BIP39 standard for generating mnemonic phrases from entropy and converting them back to entropy.

Features

• Generate random entropy of various lengths (128, 160, 192, 224, or 256 bits)
• Convert entropy to mnemonic phrases
• Convert mnemonic phrases back to entropy
• Validate mnemonic phrases
• Generate seeds from mnemonic phrases with optional passphrases
• Support for multiple languages (English, Japanese, Korean, Spanish, Chinese (Simplified and Traditional), French, Italian, Czech, Portuguese)
• Comprehensive error handling
• Thoroughly tested with official BIP39 test vectors

Installation

Add this to your Cargo.toml:

[dependencies]
rust-bip39-lib = "0.1.0"

Usage

Generate Random Entropy

use rust_bip39_lib::generate_entropy;

fn main() {
    // Generate 128 bits (16 bytes) of random entropy
    let entropy = generate_entropy();
    println!("Random entropy: {}", entropy);
}

Generate Entropy of Specific Length

use rust_bip39_lib::generate_entropy_with_length;

fn main() {
    // Generate 256 bits (32 bytes) of random entropy
    let entropy = generate_entropy_with_length(32).unwrap();
    println!("Random entropy (256 bits): {}", entropy);
}

Convert Entropy to Mnemonic

use rust_bip39_lib::entropy_to_mnemonic;

fn main() {
    let entropy = "00000000000000000000000000000000";
    let mnemonic = entropy_to_mnemonic(entropy, "English").unwrap();
    println!("Mnemonic: {}", mnemonic);
    // Output: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
}

Convert Mnemonic to Entropy

use rust_bip39_lib::mnemonic_to_entropy;

fn main() {
    let mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
    let entropy = mnemonic_to_entropy(mnemonic, "English").unwrap();
    println!("Entropy: {}", entropy);
    // Output: "00000000000000000000000000000000"
}

Validate Mnemonic

use rust_bip39_lib::validate_mnemonic;

fn main() {
    let valid_mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
    let invalid_mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon ability";
    
    println!("Valid mnemonic: {}", validate_mnemonic(valid_mnemonic, "English"));
    // Output: true
    
    println!("Invalid mnemonic: {}", validate_mnemonic(invalid_mnemonic, "English"));
    // Output: false
}

Generate Seed from Mnemonic

use rust_bip39_lib::mnemonic_to_seed;

fn main() {
    let mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
    
    // Generate seed without passphrase
    let seed_no_passphrase = mnemonic_to_seed(mnemonic, "English", "").unwrap();
    println!("Seed (no passphrase): {}", seed_no_passphrase);
    
    // Generate seed with passphrase
    let seed_with_passphrase = mnemonic_to_seed(mnemonic, "English", "TREZOR").unwrap();
    println!("Seed (with passphrase): {}", seed_with_passphrase);
}

Using Different Languages

use rust_bip39_lib::entropy_to_mnemonic;

fn main() {
    let entropy = "00000000000000000000000000000000";
    
    // Generate mnemonic in different languages
    let english = entropy_to_mnemonic(entropy, "English").unwrap();
    let japanese = entropy_to_mnemonic(entropy, "Japanese").unwrap();
    let spanish = entropy_to_mnemonic(entropy, "Spanish").unwrap();
    
    println!("English: {}", english);
    println!("Japanese: {}", japanese);
    println!("Spanish: {}", spanish);
}

Error Handling

The library uses the thiserror crate to provide detailed error information:

use rust_bip39_lib::{entropy_to_mnemonic, Bip39Error};

fn main() {
    // Invalid entropy length
    let result = entropy_to_mnemonic("0102030405", "English");
    match result {
        Ok(_) => println!("Success"),
        Err(e) => println!("Error: {}", e),
    }
    // Output: Error: Invalid entropy length: Entropy length should be >= 16, <= 32 and be a multiple of 4 bytes
}

BIP39 Specification

This library implements the BIP39 specification, which defines a method for generating mnemonic phrases from entropy and converting them back to entropy. The mnemonic phrases can then be used to generate deterministic wallets.

License

This project is licensed under the MIT License - see the LICENSE file for details.