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

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

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

#[derive(Clone, PartialEq)]
pub struct LegacySeed {
    seed_data: Data,
    fingerprint: Option<SeedFingerprint>,
}

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

impl LegacySeed {
    pub fn new(seed_data: Data, fingerprint: Option<SeedFingerprint>) -> Self {
        Self {
            seed_data,
            fingerprint,
        }
    }

    pub fn seed_data(&self) -> &Data {
        &self.seed_data
    }

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

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

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

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

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

    use super::LegacySeed;

    impl crate::RandomInstance for LegacySeed {
        fn random() -> Self {
            Self {
                seed_data: Data::random(),
                fingerprint: SeedFingerprint::opt_random(),
            }
        }
    }

    test_envelope_roundtrip!(LegacySeed);
}