Struct Mnemonic

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

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

• Mnemonic::normalize_utf8_cow
• Mnemonic::language_of

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.

Trait Implementations

impl Clone for Mnemonic

fn clone(&self) -> Mnemonic

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Mnemonic

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Mnemonic

fn deserialize<D>( deserializer: D, ) -> Result<Mnemonic, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Mnemonic

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl FromStr for Mnemonic

type Err = Error

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl Hash for Mnemonic

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Mnemonic

fn cmp(&self, other: &Mnemonic) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Mnemonic

fn eq(&self, other: &Mnemonic) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Mnemonic

fn partial_cmp(&self, other: &Mnemonic) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'de> Serialize for Mnemonic

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Mnemonic

impl StructuralPartialEq for Mnemonic