spark_rust/wallet/handlers/

swap.rs

use crate::constants::spark::DEFAULT_TRANSFER_EXPIRY;
use crate::error::{IoError, NetworkError, SparkSdkError};
use crate::signer::traits::derivation_path::SparkKeyType;
use crate::signer::traits::SparkSigner;
use crate::wallet::internal_handlers::traits::ssp::SspInternalHandlers;
use crate::wallet::internal_handlers::traits::ssp::SwapLeaf;
use crate::wallet::internal_handlers::traits::transfer::LeafKeyTweak;
use crate::wallet::internal_handlers::traits::transfer::TransferInternalHandlers;
use crate::wallet::leaf_manager::SparkNodeStatus;
use crate::wallet::utils::bitcoin::{bitcoin_tx_from_bytes, parse_public_key, sighash_from_tx};
use crate::wallet::utils::bitcoin::{
    compute_taproot_key_no_script_from_internal_key, parse_secret_key,
};
use crate::with_handler_lock;
use crate::SparkSdk;
use bitcoin::key::Secp256k1;
use spark_cryptography::adaptor_signature::apply_adaptor_to_signature;
use spark_cryptography::adaptor_signature::generate_adaptor_from_signature;
use spark_cryptography::adaptor_signature::generate_signature_from_existing_adaptor;
use spark_protos::spark::query_nodes_request::Source;
use spark_protos::spark::QueryNodesRequest;
use spark_protos::spark::TreeNodeIds;

impl<S: SparkSigner + Send + Sync + Clone + 'static> SparkSdk<S> {
    /// Optimizes your wallet's leaf structure by swapping your current leaves with the Spark Service Provider (SSP).
    ///
    /// This function allows you to obtain leaves of specific denominations by swapping your existing
    /// leaves with the SSP. This is particularly useful when you need to transfer a specific amount
    /// but don't have a leaf of that exact denomination.
    ///
    /// For example, if you have a single leaf of 100,000 satoshis but need to send 80,000 satoshis,
    /// this function will swap with the SSP to get leaves totaling 100,000 satoshis but with
    /// denominations that include the 80,000 you need. The SSP typically provides leaves in
    /// power-of-2 denominations for optimal efficiency.
    ///
    /// The swap process involves:
    /// 1. Locking all your available Bitcoin leaves
    /// 2. Preparing leaf key tweaks for each leaf
    /// 3. Creating a transfer to the SSP with all your available leaves
    /// 4. Using cryptographic adaptor signatures for security
    /// 5. Requesting new leaves from the SSP with your desired target amount
    /// 6. Verifying the cryptographic integrity of the returned leaves
    /// 7. Completing the swap process and claiming the new leaves
    /// 8. Deleting your old leaves
    ///
    /// # Arguments
    ///
    /// * `target_amount` - The amount (in satoshis) you want to have in a specific leaf after the swap
    ///
    /// # Returns
    ///
    /// * `Ok(String)` - The ID of the newly created leaf with the target amount if successful
    /// * `Err(SparkSdkError)` - If there was an error during the swap process
    ///
    /// # Example
    ///
    /// ```
    /// # use spark_rust::SparkSdk;
    /// # use bitcoin::secp256k1::PublicKey;
    /// # use std::str::FromStr;
    /// # async fn example(sdk: SparkSdk) -> Result<(), Box<dyn std::error::Error>> {
    /// // Let's say you have a single leaf of 100,000 satoshis but need to send 80,000
    /// let target_amount = 80_000;
    ///
    /// // Request a swap with the SSP to get optimized leaves
    /// let new_leaf_id = sdk.request_leaves_swap(target_amount).await?;
    /// println!("Created new leaf with ID: {}", new_leaf_id);
    ///
    /// // Now you can transfer exactly 80,000 satoshis
    /// let receiver_spark_address = PublicKey::from_str(
    ///     "02782d7ba8764306bd324e23082f785f7c880b7202cb10c85a2cb96496aedcaba7"
    /// ).unwrap();
    /// sdk.transfer(target_amount, &receiver_spark_address).await?;
    /// # Ok(())
    /// # }
    /// ```
    ///
    /// # Note
    ///
    /// Leaves swaps incur a service fee charged by the SSP. You can estimate this fee before
    /// initiating a swap using the `get_leaves_swap_fee_estimate` method. The swap operates on
    /// all available leaves in your wallet, so the total balance will remain the same (minus fees),
    /// but the denomination structure will change.
    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    pub async fn request_leaves_swap(&self, target_amount: u64) -> Result<String, SparkSdkError> {
        with_handler_lock!(self, async {
            self.request_leaves_swap_internal(target_amount).await
        })
        .await
    }

    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    pub(crate) async fn request_leaves_swap_internal(
        &self,
        target_amount: u64,
    ) -> Result<String, SparkSdkError> {
        // Lock all availables leaves to provide to SSP. This allows the SSP to aggregate
        // and optimize the number of leaves.
        let available_leaves = self
            .leaf_manager
            .lock_available_bitcoin_leaves(SparkNodeStatus::Swap);

        // leaf selection for atomic swap
        let mut leaf_key_tweaks = Vec::with_capacity(available_leaves.leaves.len());

        for leaf in available_leaves.leaves.iter() {
            let tree_leaf = leaf.get_tree_node()?;

            let old_signing_private_key = self.signer.expose_leaf_secret_key_for_transfer(
                leaf.get_id().clone(),
                SparkKeyType::BaseSigning,
                0,
                self.config.spark_config.network.to_bitcoin_network(),
            )?;

            // Generate new private key for the leaf
            let new_signing_public_key = self.signer.new_ephemeral_keypair()?;

            leaf_key_tweaks.push(LeafKeyTweak {
                leaf: tree_leaf,
                old_signing_private_key,
                new_signing_public_key,
            });
        }

        let expiry_time = chrono::Utc::now().timestamp() as u64 + DEFAULT_TRANSFER_EXPIRY;

        let (transfer, refund_signature_map) = self
            .send_transfer_sign_refunds(
                &leaf_key_tweaks,
                &self.config.spark_config.ssp_identity_public_key,
                expiry_time,
            )
            .await?;

        let leaf = transfer.leaves[0].leaf.as_ref().unwrap();
        let leaf_refund_signature = refund_signature_map[&leaf.id].clone();

        let adaptor_signature =
            generate_adaptor_from_signature(leaf_refund_signature.as_slice().try_into().unwrap())
                .unwrap();

        let mut user_leaves = Vec::new();
        user_leaves.push(SwapLeaf {
            leaf_id: transfer.leaves[0].leaf.as_ref().unwrap().id.clone(),
            raw_unsigned_refund_transaction: hex::encode(
                &transfer.leaves[0].intermediate_refund_tx,
            ),
            adaptor_added_signature: hex::encode(adaptor_signature.signature),
        });

        for leaf in transfer.leaves.iter().skip(1) {
            let leaf_id = leaf.leaf.as_ref().unwrap().id.clone();
            let leaf_refund_signature = refund_signature_map[&leaf_id].clone();

            let signature = generate_signature_from_existing_adaptor(
                &leaf_refund_signature,
                adaptor_signature.adaptor_private_key.as_slice(),
            )
            .unwrap();

            user_leaves.push(SwapLeaf {
                leaf_id,
                raw_unsigned_refund_transaction: hex::encode(&leaf.intermediate_refund_tx),
                adaptor_added_signature: hex::encode(signature),
            });
        }

        // total leaf value
        let total_amount = leaf_key_tweaks
            .iter()
            .map(|leaf| leaf.leaf.value)
            .sum::<u64>();

        let secp = Secp256k1::new();
        let adaptor_private_key =
            parse_secret_key(&adaptor_signature.adaptor_private_key.to_vec())?;
        let adaptor_public_key = adaptor_private_key.public_key(&secp);

        let (request_id, leaves) = self
            .request_swap_leaves_with_ssp(
                hex::encode(adaptor_public_key.serialize()),
                total_amount,
                target_amount,
                0,
                user_leaves,
            )
            .await?;

        let network = self.config.spark_config.network;

        for leaf in &leaves {
            let leaf_id = leaf.leaf_id.clone();
            let request_data = QueryNodesRequest {
                source: Some(Source::NodeIds(TreeNodeIds {
                    node_ids: vec![leaf_id.clone()],
                })),
                include_parents: Default::default(),
                network: network.marshal_proto(),
            };

            let response = self
                .config
                .spark_config
                .call_with_retry(
                    request_data,
                    |mut client, req| Box::pin(async move { client.query_nodes(req).await }),
                    None,
                )
                .await?;

            let node = response
                .nodes
                .get(&leaf_id)
                .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

            #[cfg(feature = "telemetry")]
            tracing::trace!(
                leaf_id = leaf_id.clone(),
                "Leaf balance returned for SSP swap: {:?}",
                node.value
            );

            let node_tx = bitcoin_tx_from_bytes(&node.node_tx)?;
            let refund_tx_bytes = hex::decode(&leaf.raw_unsigned_refund_transaction)
                .map_err(|err| SparkSdkError::from(IoError::Decoding(err)))?;
            let refund_tx = bitcoin_tx_from_bytes(&refund_tx_bytes)?;

            let sighash = sighash_from_tx(&refund_tx, 0, &node_tx.output[0])?;

            // First, parse the public key from the node
            let verifying_public_key = parse_public_key(&node.verifying_public_key)?;

            let taproot_key = compute_taproot_key_no_script_from_internal_key(
                &verifying_public_key.x_only_public_key().0.serialize(),
            )?;

            let adaptor_signature_bytes = hex::decode(&leaf.adaptor_added_signature)
                .map_err(|err| SparkSdkError::from(IoError::Decoding(err)))?;

            let _ = apply_adaptor_to_signature(
                &taproot_key,
                &sighash,
                &adaptor_signature_bytes,
                &adaptor_private_key.secret_bytes(),
            )
            .unwrap();
        }

        let transfer_id = transfer.id.clone();
        self.send_transfer_tweak_key(transfer.clone(), &leaf_key_tweaks, &refund_signature_map)
            .await?;

        // TODO: print the UUID in the response
        let _completion = self
            .complete_leaves_swap_with_ssp(
                hex::encode(adaptor_private_key.secret_bytes()),
                transfer_id,
                request_id.clone(),
            )
            .await?;

        self.claim_transfers_internal().await?;

        // Unlock and delete old leaves.
        let leaf_ids = available_leaves
            .leaves
            .iter()
            .map(|leaf| leaf.get_id().clone())
            .collect();
        self.leaf_manager
            .unlock_leaves(available_leaves.unlocking_id.unwrap(), &leaf_ids, true)?;

        // return the leaf ID with the amount that was swapped
        let leaf_id = leaves[0].leaf_id.clone();

        Ok(leaf_id)
    }
}