Struct parity_bip39::Mnemonic

source ·

pub struct Mnemonic { /* private fields */ }

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.

Implementations§

source §

impl Mnemonic

source

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

Available on crate feature unicode-normalization only.

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.

source

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.

source

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.

source

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

Available on crate feature rand_core only.

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 parity_bip39::{Mnemonic, Language};

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

source

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

Available on crate feature rand only.

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

Example:

use parity_bip39::{Mnemonic, Language};

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

source

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

Available on crate feature rand only.

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

Example:

use parity_bip39::Mnemonic;

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

source

pub fn language(&self) -> Language

Get the language of the Mnemonic.

source

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

Returns an iterator over the words of the Mnemonic.

§Examples

Basic usage:

use parity_bip39::Mnemonic;

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

source

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

👎Deprecated: Use Mnemonic::words instead

Returns an iterator over the words of the Mnemonic.

source

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

Returns an iterator over Mnemonic word indices.

§Examples

Basic usage:

use parity_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);
}

source

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

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.

source

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

Parse a mnemonic in normalized UTF8 in the given language.

source

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

source

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

Parse a mnemonic in normalized UTF8.

source

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

Available on crate feature unicode-normalization only.

Parse a mnemonic in the given language.

source

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

Available on crate feature unicode-normalization only.

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

source

pub fn word_count(&self) -> usize

Get the number of words in the mnemonic.

source

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

Convert to seed bytes with a passphrase in normalized UTF8.

source

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

Available on crate feature unicode-normalization only.

Convert to seed bytes.

source

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>.

source

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

Available on crate feature alloc only.

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

source

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.