Struct bdk::keys::bip39::Mnemonic

pub struct Mnemonic { /* private fields */ }

Available on crate feature keys-bip39 only.

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

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

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.

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<Ctx: ScriptContext> DerivableKey<Ctx> for Mnemonic

fn into_extended_key(self) -> Result<ExtendedKey<Ctx>, KeyError>

Consume self and turn it into an ExtendedKey

fn into_descriptor_key(
    self,
    source: Option<KeySource>,
    derivation_path: DerivationPath
) -> Result<DescriptorKey<Ctx>, KeyError>

Consume self and turn it into a DescriptorKey by adding the extra metadata, such as key origin and derivation path

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<Ctx: ScriptContext> GeneratableKey<Ctx> for Mnemonic

type Entropy = [u8; 32]

Type specifying the amount of entropy required e.g. [u8;32]

type Options = (WordCount, Language)

Extra options required by the generate_with_entropy

type Error = Option<Error>

Returned error in case of failure

fn generate_with_entropy(
    (word_count, language): Self::Options,
    entropy: Self::Entropy
) -> Result<GeneratedKey<Self, Ctx>, Self::Error>

Generate a key given the extra options and the entropy

fn generate(
    options: Self::Options
) -> Result<GeneratedKey<Self, Ctx>, Self::Error>

Generate a key given the options with a random entropy

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) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<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: &Rhs) -> bool

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

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.

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<'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 StructuralEq for Mnemonic

impl StructuralPartialEq for Mnemonic