fluidity-core 0.1.5

The core package for fluidity is a complete digital identity management solution.
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

/*
    Appellation: primitives <module>
    Creator: FL03 <jo3mccain@icloud.com>
    Description:
        ... Summary ...
*/
pub use self::{constants::*, types::*};

#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, serde::Deserialize, serde::Serialize)]
pub enum Language {
    English,
    French,
}

impl Language {
    pub fn new(data: String) -> Self {
        Self::related()
            .get(data.clone().to_lowercase().as_str())
            .clone()
            .expect("")
            .clone()
    }
    pub fn from(data: Self) -> String {
        match data {
            Language::English => Self::english(),
            Language::French => Self::french(),
        }
    }
    pub fn related() -> scsys::Dictionary<Self> {
        let data = [
            ("english".to_string(), Self::English),
            ("french".to_string(), Self::French),
        ];
        scsys::Dictionary::from(data.clone())
    }

    pub fn english() -> String {
        "english".to_string()
    }
    pub fn french() -> String {
        "french".to_string()
    }
}

#[derive(Clone, Debug, Hash, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct BIP0039(pub Vec<String>);

impl BIP0039 {
    pub fn new(data: Vec<String>) -> Self {
        Self(data)
    }
    pub async fn fetch(lang: Language) -> scsys::BoxResult<Self> {
        let response = reqwest::get(format!(
            "{}/{}.txt",
            BIP0039_WORDLIST_ENDPOINT,
            Language::from(lang)
        ))
        .await?
        .text()
        .await?;
        let mut data = response.split("\n").collect::<Vec<_>>();
        data.retain(|&x| x != "");
        let res = data.iter().map(|i| i.to_string()).collect();
        Ok(Self::new(res))
    }
    pub fn from_file(path: &str) -> Self {
        let mut data = crate::extract_file_from_path(path);
        data.retain(|x| x != &"".to_string());
        Self::new(data)
    }
}

impl Default for BIP0039 {
    fn default() -> Self {
        Self::from_file(PATH_TO_BIP0039_DATA)
    }
}

mod constants {
    /// Define the valid sizes of generated access grants
    pub const ACCESS_GRANT_VALID_BIT_SIZES: [usize; 5] = [128, 160, 192, 224, 256];
    /// Define the default filepath for locating the BIP0039 english text file
    pub const PATH_TO_BIP0039_DATA: &str = "../.artifacts/data/BIP0039/english.txt";
    /// Define the endpoint pointing to BIP0039 Mnemonics
    pub const BIP0039_WORDLIST_ENDPOINT: &str =
        "https://raw.githubusercontent.com/bitcoin/bips/master/bip-0039";
}

mod types {
    use secp256k1::{PublicKey, SecretKey};

    /// Type alias for a tuple ([secp256k1::SecretKey], [secp256k1::PublicKey])
    pub type SecpKeypair = (SecretKey, PublicKey);
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_wordlist_english() {
        let actual = BIP0039::fetch(Language::English).await.ok().unwrap();
        let expected = actual.clone();
        assert_eq!(actual, expected)
    }
}