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

use blueprint_crypto::KeyType;
use serde::de::DeserializeOwned;

use super::Backend;
use crate::error::{Error, Result};
use crate::keystore::Keystore;
pub use crate::remote::{EcdsaRemoteSigner, RemoteCapabilities, RemoteConfig};

#[derive(Clone)]
/// Represents a remote signer configuration and its capabilities
pub struct RemoteEntry {
    config: RemoteConfig,
    capabilities: RemoteCapabilities,
}

impl RemoteEntry {
    /// Create a new remote signer entry
    #[must_use]
    pub fn new(config: RemoteConfig, capabilities: RemoteCapabilities) -> Self {
        Self {
            config,
            capabilities,
        }
    }

    /// Get the remote signer configuration
    #[must_use]
    pub fn config(&self) -> &RemoteConfig {
        &self.config
    }

    /// Get the remote signer capabilities
    #[must_use]
    pub fn capabilities(&self) -> &RemoteCapabilities {
        &self.capabilities
    }
}

pub trait RemoteBackend: Backend {
    /// Sign a message using a remote signer
    async fn sign_with_remote<T, R>(
        &self,
        public: &T::Public,
        msg: &[u8],
        chain_id: Option<u64>,
    ) -> Result<T::Signature>
    where
        T: KeyType,
        R: EcdsaRemoteSigner<T>,
        T::Public: DeserializeOwned + Send,
        R::Public: Send,
        R::KeyId: Send;

    /// List all public keys from remote signers
    async fn list_remote<T, R>(&self, chain_id: Option<u64>) -> Result<Vec<T::Public>>
    where
        T: KeyType,
        R: EcdsaRemoteSigner<T>,
        T::Public: DeserializeOwned + Send,
        R::Public: Send,
        R::KeyId: Send;
}

impl RemoteBackend for Keystore {
    /// Sign a message using a remote signer
    async fn sign_with_remote<T, R>(
        &self,
        public: &T::Public,
        msg: &[u8],
        chain_id: Option<u64>,
    ) -> Result<T::Signature>
    where
        T: KeyType,
        R: EcdsaRemoteSigner<T>,
        T::Public: DeserializeOwned + Send,
        R::Public: Send,
        R::KeyId: Send,
    {
        let remotes = self
            .remotes
            .get(&T::key_type_id())
            .ok_or(Error::KeyTypeNotSupported)?;

        for entry in remotes {
            if entry.capabilities().signing {
                let remote = R::build(entry.config().clone()).await?;
                let public_bytes = serde_json::to_vec(public)?;
                let remote_public = serde_json::from_slice::<R::Public>(&public_bytes)?;
                let key_id = remote
                    .get_key_id_from_public_key(&remote_public, chain_id)
                    .await?;
                remote
                    .sign_message_with_key_id(msg, &key_id, chain_id)
                    .await?;
            }
        }

        Err(Error::KeyNotFound)
    }

    /// List all public keys from remote signers
    async fn list_remote<T, R>(&self, chain_id: Option<u64>) -> Result<Vec<T::Public>>
    where
        T: KeyType,
        R: EcdsaRemoteSigner<T>,
        T::Public: DeserializeOwned + Send,
        R::Public: Send,
        R::KeyId: Send,
    {
        let mut keys = Vec::new();
        let key_type = T::key_type_id();

        if let Some(remotes) = self.remotes.get(&key_type) {
            for entry in remotes {
                if entry.capabilities().signing {
                    let remote = R::build(entry.config().clone()).await?;
                    let key_ids = remote.iter_public_keys(chain_id).await?;
                    for key_id in key_ids {
                        let public_bytes = serde_json::to_vec(&key_id)?;
                        let public = serde_json::from_slice(&public_bytes)?;
                        keys.push(public);
                    }
                }
            }
        }

        Ok(keys)
    }
}