blueprint-keystore 0.2.0-alpha.10

Keystore for Tangle Blueprints
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::Keystore;
use crate::error::{Error, Result};
use blueprint_crypto::bn254::{
    ArkBlsBn254, ArkBlsBn254Public, ArkBlsBn254Secret, ArkBlsBn254Signature,
};
use blueprint_crypto::{BytesEncoding, KeyType, KeyTypeId};
use blueprint_std::boxed::Box;

pub trait Bn254Backend: Send + Sync {
    /// Generate a new BN254 key pair from seed
    ///
    /// # Errors
    ///
    /// Depending on the backend, this may error when attempting to store the key into the keystore.
    fn bls_bn254_generate_new(&self, seed: Option<&[u8]>) -> Result<ArkBlsBn254Public>;

    /// Generate a BN254 key pair from a string seed
    ///
    /// # Errors
    ///
    /// Depending on the backend, this may error when attempting to store the key into the keystore.
    fn bls_bn254_generate_from_string(&self, secret: &str) -> Result<ArkBlsBn254Public>;

    /// Sign a message using BN254 key
    ///
    /// # Errors
    ///
    /// Depending on the backend, this may error when attempting to open and/or read the keystore.
    fn bls_bn254_sign(
        &self,
        public: &ArkBlsBn254Public,
        msg: &[u8; 32],
    ) -> Result<Option<ArkBlsBn254Signature>>;

    /// Get the secret key for a BN254 public key
    ///
    /// # Errors
    ///
    /// Depending on the backend, this may error when attempting to open and/or read the keystore.
    fn expose_bls_bn254_secret(
        &self,
        public: &ArkBlsBn254Public,
    ) -> Result<Option<ArkBlsBn254Secret>>;

    /// Iterate over all BN254 public keys
    fn iter_bls_bn254(&self) -> Box<dyn Iterator<Item = ArkBlsBn254Public> + '_>;
}

impl Bn254Backend for Keystore {
    fn bls_bn254_generate_new(&self, seed: Option<&[u8]>) -> Result<ArkBlsBn254Public> {
        let secret =
            ArkBlsBn254::generate_with_seed(seed).map_err(|e| Error::Other(e.to_string()))?;
        insert_bls_bn254_key(self, &secret)
    }

    fn bls_bn254_generate_from_string(&self, seed_string: &str) -> Result<ArkBlsBn254Public> {
        let secret = ArkBlsBn254::generate_with_string(seed_string.to_string())
            .map_err(|e| Error::Other(e.to_string()))?;
        insert_bls_bn254_key(self, &secret)
    }

    fn bls_bn254_sign(
        &self,
        public: &ArkBlsBn254Public,
        msg: &[u8; 32],
    ) -> Result<Option<ArkBlsBn254Signature>> {
        if let Some(mut secret) = self.expose_bls_bn254_secret(public)? {
            Ok(Some(
                ArkBlsBn254::sign_with_secret(&mut secret, msg)
                    .map_err(|e| Error::Other(e.to_string()))?,
            ))
        } else {
            Ok(None)
        }
    }

    fn expose_bls_bn254_secret(
        &self,
        public: &ArkBlsBn254Public,
    ) -> Result<Option<ArkBlsBn254Secret>> {
        let public_bytes = public.to_bytes();

        if let Some(storages) = self.storages.get(&KeyTypeId::Bn254) {
            for entry in storages {
                if let Some(secret_bytes) = entry
                    .storage
                    .load_secret_raw(KeyTypeId::Bn254, public_bytes.clone())?
                {
                    return Ok(Some(ArkBlsBn254Secret::from_bytes(&secret_bytes)?));
                }
            }
        }

        Ok(None)
    }

    fn iter_bls_bn254(&self) -> Box<dyn Iterator<Item = ArkBlsBn254Public> + '_> {
        let Some(storages) = self.storages.get(&KeyTypeId::Bn254) else {
            return Box::new(std::iter::empty());
        };

        let mut keys = Vec::new();
        for entry in storages {
            let mut storage_keys = entry
                .storage
                .list_raw(KeyTypeId::Bn254)
                .filter_map(|bytes| ArkBlsBn254Public::from_bytes(&bytes).ok())
                .collect::<Vec<_>>();
            keys.append(&mut storage_keys);
        }
        Box::new(keys.into_iter())
    }
}

fn insert_bls_bn254_key(
    keystore: &Keystore,
    secret: &ArkBlsBn254Secret,
) -> Result<ArkBlsBn254Public> {
    let public = ArkBlsBn254::public_from_secret(secret);
    let public_bytes = public.to_bytes();
    let secret_bytes = secret.to_bytes();

    if let Some(storages) = keystore.storages.get(&KeyTypeId::Bn254) {
        for entry in storages {
            entry.storage.store_raw(
                KeyTypeId::Bn254,
                public_bytes.clone(),
                secret_bytes.clone(),
            )?;
        }
    }

    Ok(public)
}