zingolabs-zewif 0.0.2

Fork of Blockhain Commons's zewif crate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use anyhow::{Context, Result};
use bc_envelope::prelude::*;

use crate::{MnemonicLanguage, NoQuotesDebugOption, SeedFingerprint};

#[derive(Clone, PartialEq)]
pub struct Bip39Mnemonic {
    mnemonic: String,
    language: Option<MnemonicLanguage>,
    fingerprint: Option<SeedFingerprint>,
}

impl std::fmt::Debug for Bip39Mnemonic {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("MnemonicSeed")
            .field("language", &NoQuotesDebugOption(&self.language))
            .field("mnemonic", &"<elided>".to_string())
            .field(
                "fingerprint",
                &NoQuotesDebugOption(&self.fingerprint.map(|f| f.to_hex())),
            )
            .finish()
    }
}

impl Bip39Mnemonic {
    pub fn new(mnemonic: impl AsRef<str>, language: Option<MnemonicLanguage>) -> Self {
        Self {
            mnemonic: mnemonic.as_ref().to_string(),
            language,
            fingerprint: None,
        }
    }

    pub fn set_fingerprint(&mut self, fingerprint: SeedFingerprint) {
        self.fingerprint = Some(fingerprint);
    }

    pub fn mnemonic(&self) -> &String {
        &self.mnemonic
    }

    pub fn set_mnemonic(&mut self, mnemonic: String) {
        self.mnemonic = mnemonic;
    }

    pub fn language(&self) -> Option<&MnemonicLanguage> {
        self.language.as_ref()
    }

    pub fn fingerprint(&self) -> Option<&SeedFingerprint> {
        self.fingerprint.as_ref()
    }

    pub fn set_language(&mut self, language: MnemonicLanguage) {
        self.language = Some(language);
    }
}

impl From<Bip39Mnemonic> for Envelope {
    fn from(value: Bip39Mnemonic) -> Self {
        Envelope::new(value.mnemonic)
            .add_type("Bip39Mnemonic")
            .add_optional_assertion("language", value.language)
            .add_optional_assertion("fingerprint", value.fingerprint)
    }
}

impl TryFrom<Envelope> for Bip39Mnemonic {
    type Error = anyhow::Error;

    fn try_from(envelope: Envelope) -> Result<Self, Self::Error> {
        envelope
            .check_type_envelope("Bip39Mnemonic")
            .context("Bip39Mnemonic")?;
        let mnemonic = envelope.extract_subject().context("mnemonic")?;
        let language = envelope
            .try_optional_object_for_predicate("language")
            .context("language")?;
        let fingerprint = envelope
            .try_optional_object_for_predicate("fingerprint")
            .context("fingerprint")?;
        Ok(Self {
            mnemonic,
            language,
            fingerprint,
        })
    }
}

#[cfg(test)]
mod tests {
    use crate::{MnemonicLanguage, SeedFingerprint, test_envelope_roundtrip};

    use super::Bip39Mnemonic;

    impl crate::RandomInstance for Bip39Mnemonic {
        fn random() -> Self {
            Self {
                mnemonic: String::random(),
                language: MnemonicLanguage::opt_random(),
                fingerprint: SeedFingerprint::opt_random(),
            }
        }
    }

    test_envelope_roundtrip!(Bip39Mnemonic);
}