breez_sdk_spark/signer/
spark.rs

1use spark_wallet::{
2    AggregateFrostRequest, EncryptedSecret, FrostSigningCommitmentsWithNonces, SecretSource,
3    SecretToSplit, SignFrostRequest, Signer, SignerError, TreeNodeId, VerifiableSecretShare,
4};
5use std::sync::Arc;
6
7use crate::signer::BreezSigner;
8use bitcoin::{
9    bip32::DerivationPath,
10    secp256k1::{self, PublicKey, SecretKey, schnorr},
11};
12use frost_secp256k1_tr::round2::SignatureShare;
13use macros::async_trait;
14
15pub struct SparkSigner {
16    signer: Arc<dyn BreezSigner>,
17}
18
19impl SparkSigner {
20    pub fn new(signer: Arc<dyn BreezSigner>) -> Self {
21        Self { signer }
22    }
23}
24
25#[async_trait]
26impl Signer for SparkSigner {
27    async fn sign_message_ecdsa_with_identity_key(
28        &self,
29        message: &[u8],
30    ) -> Result<secp256k1::ecdsa::Signature, SignerError> {
31        use bitcoin::hashes::{Hash, sha256};
32        use bitcoin::secp256k1::Message;
33
34        let identity_path = DerivationPath::master();
35        let hash = sha256::Hash::hash(message);
36        let msg = Message::from_digest(hash.to_byte_array());
37        self.signer
38            .sign_ecdsa(msg, &identity_path)
39            .await
40            .map_err(|e| SignerError::Generic(e.to_string()))
41    }
42
43    async fn sign_hash_schnorr_with_identity_key(
44        &self,
45        hash: &[u8],
46    ) -> Result<schnorr::Signature, SignerError> {
47        let identity_path = DerivationPath::master();
48        self.signer
49            .sign_hash_schnorr(hash, &identity_path)
50            .await
51            .map_err(|e| SignerError::Generic(e.to_string()))
52    }
53
54    async fn generate_random_signing_commitment(
55        &self,
56    ) -> Result<FrostSigningCommitmentsWithNonces, SignerError> {
57        self.signer
58            .generate_random_signing_commitment()
59            .await
60            .map_err(|e| SignerError::Generic(e.to_string()))
61    }
62
63    async fn get_public_key_for_node(&self, id: &TreeNodeId) -> Result<PublicKey, SignerError> {
64        self.signer
65            .get_public_key_for_node(id)
66            .await
67            .map_err(|e| SignerError::Generic(e.to_string()))
68    }
69
70    async fn generate_random_secret(&self) -> Result<EncryptedSecret, SignerError> {
71        self.signer
72            .generate_random_secret()
73            .await
74            .map_err(|e| SignerError::Generic(e.to_string()))
75    }
76
77    async fn get_identity_public_key(&self) -> Result<PublicKey, SignerError> {
78        self.signer
79            .identity_public_key()
80            .map_err(|e| SignerError::Generic(e.to_string()))
81    }
82
83    async fn static_deposit_secret_encrypted(
84        &self,
85        index: u32,
86    ) -> Result<SecretSource, SignerError> {
87        self.signer
88            .static_deposit_secret_encrypted(index)
89            .await
90            .map_err(|e| SignerError::Generic(e.to_string()))
91    }
92
93    async fn static_deposit_secret(&self, index: u32) -> Result<SecretKey, SignerError> {
94        self.signer
95            .static_deposit_secret(index)
96            .await
97            .map_err(|e| SignerError::Generic(e.to_string()))
98    }
99
100    async fn static_deposit_signing_key(&self, index: u32) -> Result<PublicKey, SignerError> {
101        self.signer
102            .static_deposit_signing_key(index)
103            .await
104            .map_err(|e| SignerError::Generic(e.to_string()))
105    }
106
107    async fn subtract_secrets(
108        &self,
109        signing_key: &SecretSource,
110        new_signing_key: &SecretSource,
111    ) -> Result<SecretSource, SignerError> {
112        self.signer
113            .subtract_secrets(signing_key, new_signing_key)
114            .await
115            .map_err(|e| SignerError::Generic(e.to_string()))
116    }
117
118    async fn split_secret_with_proofs(
119        &self,
120        secret: &SecretToSplit,
121        threshold: u32,
122        num_shares: usize,
123    ) -> Result<Vec<VerifiableSecretShare>, SignerError> {
124        self.signer
125            .split_secret_with_proofs(secret, threshold, num_shares)
126            .await
127            .map_err(|e| SignerError::Generic(e.to_string()))
128    }
129
130    async fn encrypt_secret_for_receiver(
131        &self,
132        private_key: &EncryptedSecret,
133        receiver_public_key: &PublicKey,
134    ) -> Result<Vec<u8>, SignerError> {
135        self.signer
136            .encrypt_secret_for_receiver(private_key, receiver_public_key)
137            .await
138            .map_err(|e| SignerError::Generic(e.to_string()))
139    }
140
141    async fn public_key_from_secret(
142        &self,
143        private_key: &SecretSource,
144    ) -> Result<PublicKey, SignerError> {
145        self.signer
146            .public_key_from_secret(private_key)
147            .await
148            .map_err(|e| SignerError::Generic(e.to_string()))
149    }
150
151    async fn sign_frost<'a>(
152        &self,
153        request: SignFrostRequest<'a>,
154    ) -> Result<SignatureShare, SignerError> {
155        self.signer
156            .sign_frost(request)
157            .await
158            .map_err(|e| SignerError::Generic(e.to_string()))
159    }
160
161    async fn aggregate_frost<'a>(
162        &self,
163        request: AggregateFrostRequest<'a>,
164    ) -> Result<frost_secp256k1_tr::Signature, SignerError> {
165        self.signer
166            .aggregate_frost(request)
167            .await
168            .map_err(|e| SignerError::Generic(e.to_string()))
169    }
170}
breez_sdk_spark/signer/spark.rs

breez_sdk_spark/signer/
spark.rs
