Struct zcash_primitives::zip339::Mnemonic

pub struct Mnemonic { /* fields omitted */ }

A mnemonic representation.

First, an initial entropy of ENT bits is generated. A checksum is generated by taking the first ENT/32 bits of its SHA256 hash. This checksum is appended to the end of the initial entropy.

Next, these concatenated bits are split into groups of 11 bits, each encoding a number from 0-2047, serving as an index into a wordlist.

Finally, we convert these numbers into words and use the joined words as a mnemonic sentence.

• ENT: the initial entropy length
• CS: the checksum length
• MS: the length of the generated mnemonic sentence in words

CS = ENT / 32

MS = (ENT + CS) / 11

ENT	CS	ENT+CS	MS
128	4	132	12
160	5	165	15
192	6	198	18
224	7	231	21
256	8	264	24

For example, a 12 word mnemonic phrase is essentially a friendly representation of a 128-bit key, while a 24 word mnemonic phrase is essentially a 256-bit key.

Implementations

impl Mnemonic

pub fn generate(word_count: Count) -> Mnemonic

Generates a new English Mnemonic randomly in the specified word count.

Example

use bip0039::{Count, Mnemonic};

let mnemonic = Mnemonic::generate(Count::Words12);
let phrase = mnemonic.phrase();

pub fn generate_in(lang: Language, word_count: Count) -> Mnemonic

Generates a new Mnemonic randomly in the specified language and word count.

Example

use bip0039::{Count, Language, Mnemonic};

let mnemonic = Mnemonic::generate_in(Language::SimplifiedChinese, Count::Words24);
let phrase = mnemonic.phrase();

pub fn from_entropy<E>(entropy: E) -> Result<Mnemonic, Error> where
    E: Into<Vec<u8, Global>>, 

Creates a new English Mnemonic from the given entropy.

Example

use bip0039::Mnemonic;

let entropy = vec![0x1a, 0x48, 0x6a, 0x5f, 0xbe, 0x53, 0x63, 0x99, 0x84, 0xcb, 0x64, 0xb0, 0x70, 0x75, 0x5f, 0x7b];
let mnemonic = Mnemonic::from_entropy(entropy).unwrap();
assert_eq!(mnemonic.phrase(), "bottom drive obey lake curtain smoke basket hold race lonely fit walk");

pub fn from_entropy_in<E>(lang: Language, entropy: E) -> Result<Mnemonic, Error> where
    E: Into<Vec<u8, Global>>, 

Creates a new Mnemonic in the specified language from the given entropy.

Example

use bip0039::{Language, Mnemonic};

let entropy = vec![0x1a, 0x48, 0x6a, 0x5f, 0xbe, 0x53, 0x63, 0x99, 0x84, 0xcb, 0x64, 0xb0, 0x70, 0x75, 0x5f, 0x7b];
let mnemonic = Mnemonic::from_entropy_in(Language::English, entropy).unwrap();
assert_eq!(mnemonic.phrase(), "bottom drive obey lake curtain smoke basket hold race lonely fit walk");

pub fn from_phrase<'a, P>(phrase: P) -> Result<Mnemonic, Error> where
    P: Into<Cow<'a, str>>, 

Creates a Mnemonic from an existing mnemonic phrase.

Example

use bip0039::Mnemonic;

let phrase = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
let mnemonic = Mnemonic::from_phrase(phrase).unwrap();
assert_eq!(mnemonic.phrase(), phrase);

pub fn from_phrase_in<'a, P>(
    lang: Language,
    phrase: P
) -> Result<Mnemonic, Error> where
    P: Into<Cow<'a, str>>, 

Creates a Mnemonic from an existing mnemonic phrase in the given language.

Example

use bip0039::{Error, Mnemonic, Language};

let phrase = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
let mnemonic = Mnemonic::from_phrase_in(Language::English, phrase).unwrap();
assert_eq!(mnemonic.phrase(), phrase);

let phrase = "bottom drive obey lake curtain smoke basket hold race lonely fit shit";
let mnemonic = Mnemonic::from_phrase_in(Language::English, phrase);
assert_eq!(mnemonic.unwrap_err(), Error::UnknownWord("shit".into()));

pub fn validate<'a, P>(phrase: P) -> Result<(), Error> where
    P: Into<Cow<'a, str>>, 

Validates the word count and checksum of an English mnemonic phrase.

Example

use bip0039::Mnemonic;

let result = Mnemonic::validate("bottom drive obey lake curtain smoke basket hold race lonely fit walk");
assert!(result.is_ok());

pub fn validate_in<'a, P>(lang: Language, phrase: P) -> Result<(), Error> where
    P: Into<Cow<'a, str>>, 

Validates the word count and checksum of a mnemonic phrase in the given language.

Example

use bip0039::{Error, Language, Mnemonic};
use unicode_normalization::UnicodeNormalization;

let phrase = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
let result = Mnemonic::validate_in(Language::English, phrase);
assert!(result.is_ok());
let phrase = "bottom drive obey lake curtain smoke basket hold race lonely fit shit";
let result = Mnemonic::validate_in(Language::English, phrase);
assert_eq!(result.unwrap_err(), Error::UnknownWord("shit".into()));

let phrase = "そつう　れきだい　ほんやく　わかす　りくつ　ばいか　ろせん　やちん　そつう　れきだい　ほんやく　わかめ";
let result = Mnemonic::validate_in(Language::Japanese, phrase);
assert!(result.is_ok());
let phrase = "そつう　れきだい　ほんやく　わかす　りくつ　ばいか　ろせん　やちん　そつう　れきだい　ほんやく　ばか";
let result = Mnemonic::validate_in(Language::Japanese, phrase);
assert_eq!(result.unwrap_err(), Error::UnknownWord("ばか".nfkd().to_string()));

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

Generates the seed from the Mnemonic and the passphrase.

If a passphrase is not present, an empty string "" is used instead.

Example

use bip0039::Mnemonic;

let phrase = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
let mnemonic = Mnemonic::from_phrase(phrase).unwrap();
assert_eq!(
    mnemonic.to_seed("").to_vec(),
    hex::decode("02d5cd1db85b4d1397d78978062a1160e76e94cc5aaad3089644846865bb18fc68ddf383059d3fe82902a203d60790a8c8ab488de5013d10a8a8bded8d9174b9").unwrap()
);

pub fn lang(&self) -> Language

Returns the Language of the mnemonic.

pub fn phrase(&self) -> &str

Returns the mnemonic phrase as a string slice.

pub fn into_phrase(self) -> String

Consumes the Mnemonic and return the phrase as a String.

pub fn entropy(&self) -> &[u8]

Returns the original entropy of the mnemonic phrase.

pub fn into_entropy(self) -> Vec<u8, Global>

Consumes the Mnemonic and return the entropy as a Vec<u8>.

Trait Implementations

impl AsRef<str> for Mnemonic

pub fn as_ref(&self) -> &str

Performs the conversion.

impl Clone for Mnemonic

pub 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

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

Formats the value using the given formatter.

impl Display for Mnemonic

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

Formats the value using the given formatter.

impl Drop for Mnemonic

pub fn drop(&mut self)

Executes the destructor for this type.

impl FromStr for Mnemonic

type Err = Error

The associated error which can be returned from parsing.

pub fn from_str(s: &str) -> Result<Mnemonic, <Mnemonic as FromStr>::Err>

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

impl Hash for Mnemonic

pub 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, 

Feeds a slice of this type into the given Hasher.

impl Ord for Mnemonic

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl PartialEq<Mnemonic> for Mnemonic

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<Mnemonic> for Mnemonic

pub 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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Zeroize for Mnemonic

pub fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl Eq for Mnemonic

impl StructuralEq for Mnemonic

impl StructuralPartialEq for Mnemonic