Struct bip39::Mnemonic

pub struct Mnemonic { /* fields omitted */ }

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, 18 and 24.

Implementations

impl Mnemonic

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:

extern crate rand;
extern crate bip39;

use bip39::{Mnemonic, Language};

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

pub fn language(&self) -> Language

Get the language of the Mnemonic.

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

Get an iterator over the words.

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.

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_normalized(s: &str) -> Result<Mnemonic, Error>

Parse a mnemonic in normalized UTF8.

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

Parse a mnemonic in the given language.

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

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: Into<Cow<'a, str>>>(&self, passphrase: P) -> [u8; 64]

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.

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

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

Trait Implementations

impl Clone for Mnemonic

fn clone(&self) -> Mnemonic

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Mnemonic

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

Formats the value using the given formatter.

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

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

Deserialize this value from the given Serde deserializer.

impl Display for Mnemonic

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

Formats the value using the given formatter.

impl Eq for Mnemonic

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: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub 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

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

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Mnemonic> for Mnemonic

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

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

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

This method tests for !=.

impl PartialOrd<Mnemonic> for Mnemonic

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

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

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

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

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

#[must_use]pub 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<'de> Serialize for Mnemonic

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

Serialize this value into the given Serde serializer.

impl StructuralEq for Mnemonic

impl StructuralPartialEq for Mnemonic