Struct Mnemonic

pub struct Mnemonic {
    pub(crate) lang: Language,
    pub(crate) words: [u16; 24],
}

Expand description

A mnemonic code.

The core::str::FromStr implementation will try to determine the language of the mnemonic from all the supported languages. (Languages have to be explicitly enabled using the Cargo features.)

Supported number of words are 12, 15, 18, 21, and 24.

Fields§

§lang: Language§words: [u16; 24]

Implementations§

§

impl Mnemonic

pub fn normalize_utf8_cow<'a>(cow: &mut Cow<'a, str>)

Ensure the content of the Cow is normalized UTF8. Performing this on a Cow means that all allocations for normalization can be avoided for languages without special UTF8 characters.

pub fn from_entropy_in( language: Language, entropy: &[u8], ) -> Result<Mnemonic, Error>

Create a new Mnemonic in the specified language from the given entropy. Entropy must be a multiple of 32 bits (4 bytes) and 128-256 bits in length.

pub fn from_entropy(entropy: &[u8]) -> Result<Mnemonic, Error>

Create a new English Mnemonic from the given entropy. Entropy must be a multiple of 32 bits (4 bytes) and 128-256 bits in length.

pub fn generate_in_with<R>( rng: &mut R, language: Language, word_count: usize, ) -> Result<Mnemonic, Error>
where R: RngCore + CryptoRng,

Generate a new Mnemonic in the given language with the given randomness source. For the different supported word counts, see documentation on Mnemonic.

Example:

use bip39::{Mnemonic, Language};

let mut rng = bip39::rand::thread_rng();
let m = Mnemonic::generate_in_with(&mut rng, Language::English, 24).unwrap();

pub fn generate_in( language: Language, word_count: usize, ) -> Result<Mnemonic, Error>

Generate a new Mnemonic in the given language. For the different supported word counts, see documentation on Mnemonic.

Example:

use bip39::{Mnemonic, Language};

let m = Mnemonic::generate_in(Language::English, 24).unwrap();

pub fn generate(word_count: usize) -> Result<Mnemonic, Error>

Generate a new Mnemonic in English. For the different supported word counts, see documentation on Mnemonic.

Example:

use bip39::Mnemonic;

let m = Mnemonic::generate(24).unwrap();

pub fn language(&self) -> Language

Get the language of the Mnemonic.

pub fn words(&self) -> impl Iterator<Item = &'static str> + Clone

Returns an iterator over the words of the Mnemonic.

§Examples

Basic usage:

use bip39::Mnemonic;

let mnemonic = Mnemonic::from_entropy(&[0; 32]).unwrap();
for (i, word) in mnemonic.words().enumerate() {
    println!("{}. {}", i, word);
}

pub fn word_iter(&self) -> impl Iterator<Item = &'static str> + Clone

👎Deprecated since 2.1.0: Use Mnemonic::words instead

Returns an iterator over the words of the Mnemonic.

pub fn word_indices(&self) -> impl Iterator<Item = usize> + Clone

Returns an iterator over Mnemonic word indices.

§Examples

Basic usage:

use bip39::{Language, Mnemonic};

let list = Language::English.word_list();
let mnemonic = Mnemonic::from_entropy(&[0; 32]).unwrap();
for i in mnemonic.word_indices() {
	println!("{} ({})", list[i], i);
}

pub fn language_of<S>(mnemonic: S) -> Result<Language, Error>
where S: AsRef<str>,

Determine the language of the mnemonic.

NOTE: This method only guarantees that the returned language is the correct language on the assumption that the mnemonic is valid. It does not itself validate the mnemonic.

Some word lists don’t guarantee that their words don’t occur in other word lists. In the extremely unlikely case that a word list can be interpreted in multiple languages, an [Error::AmbiguousLanguages] is returned, containing the possible languages.

pub fn parse_in_normalized( language: Language, s: &str, ) -> Result<Mnemonic, Error>

Parse a mnemonic in normalized UTF8 in the given language.

pub fn parse_in_normalized_without_checksum_check( language: Language, s: &str, ) -> Result<Mnemonic, Error>

Parse a mnemonic in normalized UTF8 in the given language without checksum check.

It is advised to use this method together with the utility methods

pub fn parse_normalized(s: &str) -> Result<Mnemonic, Error>

Parse a mnemonic in normalized UTF8.

pub fn parse_in<'a, S>(language: Language, s: S) -> Result<Mnemonic, Error>
where S: Into<Cow<'a, str>>,

Parse a mnemonic in the given language.

pub fn parse<'a, S>(s: S) -> Result<Mnemonic, Error>
where S: Into<Cow<'a, str>>,

Parse a mnemonic and detect the language from the enabled languages.

pub fn word_count(&self) -> usize

Get the number of words in the mnemonic.

pub fn to_seed_normalized(&self, normalized_passphrase: &str) -> [u8; 64]

Convert to seed bytes with a passphrase in normalized UTF8.

pub fn to_seed<'a, P>(&self, passphrase: P) -> [u8; 64]
where P: Into<Cow<'a, str>>,

Convert to seed bytes.

pub fn to_entropy_array(&self) -> ([u8; 33], usize)

Convert the mnemonic back to the entropy used to generate it. The return value is a byte array and the size. Use Mnemonic::to_entropy (needs std) to get a Vec<u8>.

pub fn to_entropy(&self) -> Vec<u8> ⓘ

Convert the mnemonic back to the entropy used to generate it.

pub fn checksum(&self) -> u8

Return checksum value for the Mnemonic.

The checksum value is the numerical value of the first self.word_count() / 3 bits of the SHA256 digest of the Mnemonic’s entropy, and is encoded by the last word of the mnemonic sentence.

This is useful for validating the integrity of a mnemonic: For a valid mnemonic m, the following assertion should hold:

let checksum_width = m.word_count() / 3;
let shift_width = 8 - checksum_width;
assert_eq!(sha256::Hash::hash(&m.to_entropy())[0] >> shift_width, m.checksum());

Note that since this library constrains initialization of Mnemonic instances through an API that guarantees validity, all Mnemonic instances should be valid and the above condition should hold.