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::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> {
    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    pub async fn request_leaves_swap(&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 mut spark_client = self.config.spark_config.get_spark_connection(None).await?;
        let network = self.config.spark_config.network;

        for leaf in &leaves {
            let leaf_id = leaf.leaf_id.clone();
            let response = spark_client
                .query_nodes(QueryNodesRequest {
                    source: Some(Source::NodeIds(TreeNodeIds {
                        node_ids: vec![leaf_id.clone()],
                    })),
                    include_parents: Default::default(),
                    network: network.marshal_proto(),
                })
                .await
                .map_err(|status| SparkSdkError::from(NetworkError::Status(status)))?
                .into_inner();

            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().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)
    }
}