spark_rust/wallet/internal_handlers/implementations/
swap.rs1use std::collections::HashMap;
2
3use bitcoin::key::Secp256k1;
4use bitcoin::secp256k1::PublicKey;
5use spark_protos::spark::{LeafSwapRequest, StartSendTransferRequest};
6use tonic::async_trait;
7use uuid::Uuid;
8
9use crate::error::{network::NetworkError, SparkSdkError};
10use crate::signer::traits::SparkSigner;
11use crate::wallet::internal_handlers::traits::swap::{
12 SendSwapSignRefundsResponse, SwapInternalHandlers,
13};
14use crate::wallet::internal_handlers::traits::transfer::{
15 LeafKeyTweak, LeafRefundSigningData, TransferInternalHandlers,
16};
17use crate::wallet::utils::bitcoin::bitcoin_tx_from_bytes;
18use crate::wallet::utils::frost::frost_commitment_to_proto_commitment;
19use crate::SparkSdk;
20
21#[async_trait]
22impl<S: SparkSigner + Send + Sync + Clone + 'static> SwapInternalHandlers<S> for SparkSdk<S> {
23 #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
24 async fn send_swap_sign_refunds(
25 &self,
26 leaves: &Vec<LeafKeyTweak>,
27 receiver_identity_pubkey: &PublicKey,
28 expiry_time: u64,
29 adaptor_public_key: &PublicKey,
30 ) -> Result<SendSwapSignRefundsResponse, SparkSdkError> {
31 let transfer_id = Uuid::now_v7().to_string();
32 let mut leaf_data_map = HashMap::new();
33
34 for leaf_key in leaves {
35 let node_tx = bitcoin_tx_from_bytes(&leaf_key.leaf.node_tx)?;
36 let commitments = self.signer.new_frost_signing_noncepair()?;
37
38 let secp = Secp256k1::new();
39 let signing_public_key = leaf_key.old_signing_private_key.public_key(&secp);
40
41 let leaf_refund_signing_data = LeafRefundSigningData {
42 signing_public_key,
43 receiving_pubkey: *receiver_identity_pubkey,
44 commitment: frost_commitment_to_proto_commitment(&commitments)?,
45 tx: node_tx,
46 refund_tx: None,
47 vout: leaf_key.leaf.vout,
48 };
49
50 leaf_data_map.insert(leaf_key.leaf.id.clone(), leaf_refund_signing_data);
51 }
52
53 let signing_jobs =
54 self.prepare_refund_so_signing_jobs(&leaves.to_vec(), &mut leaf_data_map)?;
55
56 let mut request = tonic::Request::new(LeafSwapRequest {
57 transfer: Some(StartSendTransferRequest {
58 transfer_id: transfer_id.clone(),
59 leaves_to_send: signing_jobs,
60 owner_identity_public_key: self.get_spark_address()?.serialize().to_vec(),
61 receiver_identity_public_key: receiver_identity_pubkey.serialize().to_vec(),
62 expiry_time: Some(prost_types::Timestamp {
63 seconds: expiry_time as i64,
64 nanos: 0,
65 }),
66 key_tweak_proofs: Default::default(),
67 }),
68 swap_id: Uuid::now_v7().to_string(),
69 adaptor_public_key: adaptor_public_key.serialize().to_vec(),
70 });
71 self.add_authorization_header_to_request(&mut request, None);
72
73 let mut spark_client = self.config.spark_config.get_spark_connection(None).await?;
74 let response = spark_client
75 .leaf_swap(request)
76 .await
77 .map_err(|status| SparkSdkError::from(NetworkError::Status(status)))?
78 .into_inner();
79
80 let signatures = self.signer.sign_transfer_refunds(
81 &leaf_data_map,
82 &response.signing_results,
83 adaptor_public_key.serialize().to_vec(),
84 )?;
85
86 let mut signature_map = HashMap::new();
87 for leaf_signature in signatures {
88 signature_map.insert(leaf_signature.node_id, leaf_signature.refund_tx_signature);
89 }
90
91 Ok(SendSwapSignRefundsResponse {
92 transfer: response.transfer.unwrap(),
93 refund_signature_map: signature_map,
94 leaf_refund_signing_data: leaf_data_map,
95 leaf_refund_tx_signing_result: response.signing_results,
96 })
97 }
98}