spark_rust/wallet/internal_handlers/implementations/

lightning.rs

use crate::error::SparkSdkError;
use crate::signer::traits::SparkSigner;
use crate::wallet::internal_handlers::traits::commitments::StatechainCommitmentsInternalHandlers;
use crate::wallet::internal_handlers::traits::lightning::LightningInternalHandlers;
use crate::wallet::internal_handlers::traits::transfer::LeafKeyTweak;
use crate::wallet::utils::bitcoin::{
    bitcoin_tx_from_bytes, serialize_bitcoin_transaction, sighash_from_tx,
};
use crate::wallet::utils::sequence::next_sequence;
use crate::wallet::utils::transaction::create_refund_tx;
use crate::SparkSdk;
use bitcoin::hashes;
use bitcoin::hashes::Hash;
use bitcoin::secp256k1::PublicKey;
use lightning_invoice::Bolt11Invoice;
use spark_protos::spark::initiate_preimage_swap_request::Reason;
use spark_protos::spark::InitiatePreimageSwapRequest;
use spark_protos::spark::InitiatePreimageSwapResponse;
use spark_protos::spark::InvoiceAmount;
use spark_protos::spark::InvoiceAmountProof;
use spark_protos::spark::RequestedSigningCommitments;
use spark_protos::spark::SigningCommitments;
use spark_protos::spark::StartSendTransferRequest;
use spark_protos::spark::UserSignedRefund;
use tonic::async_trait;
use uuid::Uuid;

#[cfg(test)]
use spark_protos::spark::ProvidePreimageRequest;
#[cfg(test)]
use spark_protos::spark::Transfer;

#[async_trait]
impl<S: SparkSigner + Send + Sync + Clone + 'static> LightningInternalHandlers<S> for SparkSdk<S> {
    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    async fn swap_nodes_for_preimage(
        &self,
        leaves: Vec<LeafKeyTweak>,
        receiver_pubkey: &PublicKey,
        payment_hash: &hashes::sha256::Hash,
        invoice: &Bolt11Invoice,
        invoice_amount_sats: u64,
        fee_sats: u64,
        is_inbound_payment: bool,
    ) -> Result<InitiatePreimageSwapResponse, SparkSdkError> {
        // get signing commitments
        let node_ids: Vec<String> = leaves.iter().map(|l| l.leaf.id.clone()).collect();
        let spark_commitments = self.get_spark_signing_commitments(node_ids).await?;

        // get user signed refunds
        let user_signed_refunds = self
            .sign_lightning_refunds(leaves, spark_commitments, receiver_pubkey)
            .await?;

        let transfer_id = Uuid::now_v7().to_string();
        let reason = if is_inbound_payment {
            Reason::Receive
        } else {
            Reason::Send
        };

        let request_data = InitiatePreimageSwapRequest {
            payment_hash: payment_hash.to_byte_array().to_vec(),
            user_signed_refunds,
            reason: reason as i32,
            invoice_amount: Some(InvoiceAmount {
                invoice_amount_proof: Some(InvoiceAmountProof {
                    bolt11_invoice: invoice.to_string(),
                }),
                value_sats: invoice_amount_sats,
            }),
            transfer: Some(StartSendTransferRequest {
                transfer_id: transfer_id.clone(),
                owner_identity_public_key: self.get_spark_address()?.serialize().to_vec(),
                receiver_identity_public_key: receiver_pubkey.serialize().to_vec(),
                expiry_time: Default::default(),
                leaves_to_send: Default::default(),
                key_tweak_proofs: Default::default(),
            }),
            receiver_identity_public_key: receiver_pubkey.serialize().to_vec(),
            fee_sats,
        };

        let time_start = std::time::Instant::now();
        let response = self
            .config
            .spark_config
            .call_with_retry(
                request_data,
                |mut client, req| Box::pin(async move { client.initiate_preimage_swap(req).await }),
                None,
            )
            .await?;

        let duration = time_start.elapsed();
        #[cfg(feature = "telemetry")]
        tracing::debug!(duration = ?duration, "initiate_preimage_swap");

        Ok(response)
    }

    async fn sign_lightning_refunds(
        &self,
        leaves: Vec<LeafKeyTweak>,
        spark_commitments: Vec<RequestedSigningCommitments>,
        receiver_pubkey: &PublicKey,
    ) -> Result<Vec<UserSignedRefund>, SparkSdkError> {
        // sign refunds. TODO: In JS SDK, this is the `sign_refunds` function
        let mut user_signed_refunds = Vec::with_capacity(leaves.len());
        let bitcoin_network = self.config.spark_config.network.to_bitcoin_network();
        for (i, leaf) in leaves.iter().enumerate() {
            let node_tx = bitcoin_tx_from_bytes(&leaf.leaf.node_tx)?;
            let node_outpoint = bitcoin::OutPoint {
                txid: node_tx.compute_txid(),
                vout: 0,
            };

            let curr_refund_tx = bitcoin_tx_from_bytes(&leaf.leaf.refund_tx)?;
            let next_sequence = next_sequence(curr_refund_tx.input[0].sequence.0);
            let amount_sats = curr_refund_tx.output[0].value;

            let new_refund_tx = create_refund_tx(
                next_sequence,
                node_outpoint,
                amount_sats,
                receiver_pubkey,
                bitcoin_network,
            );

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

            let self_commitment = self.signer.generate_frost_signing_commitments()?;
            let spark_commitment = spark_commitments[i].signing_nonce_commitments.clone();

            // todo: clean start
            let secp = bitcoin::secp256k1::Secp256k1::new();
            let private_as_pubkey = &leaf.old_signing_private_key.public_key(&secp);
            // todo: clean end

            let user_signature_share = self.signer.sign_frost_new(
                sighash.to_vec(),
                private_as_pubkey.serialize().to_vec(),
                leaf.leaf.verifying_public_key.clone(),
                self_commitment,
                spark_commitment.clone(),
                None,
            )?;

            user_signed_refunds.push(UserSignedRefund {
                node_id: leaf.leaf.id.clone(),
                refund_tx: serialize_bitcoin_transaction(&new_refund_tx)?,
                user_signature: user_signature_share,
                user_signature_commitment: Some(marshal_frost_commitments(&self_commitment)?),
                signing_commitments: Some(SigningCommitments {
                    signing_commitments: spark_commitment,
                }),
                network: self.config.spark_config.network.marshal_proto(),
            });
        }

        Ok(user_signed_refunds)
    }

    #[cfg(test)]
    async fn provide_preimage(&self, preimage: Vec<u8>) -> Result<Transfer, SparkSdkError> {
        use crate::error::{IoError, ValidationError};

        let payment_hash = sha256::digest(&preimage);
        let payment_hash_bytes = hex::decode(&payment_hash)
            .map_err(|err| SparkSdkError::from(IoError::Decoding(err)))?;

        let request_data = ProvidePreimageRequest {
            payment_hash: payment_hash_bytes,
            preimage,
            identity_public_key: Default::default(),
        };

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

        if response.transfer.is_none() {
            return Err(SparkSdkError::from(ValidationError::InvalidInput {
                field: "Transfer not found".to_string(),
            }));
        }

        Ok(response.transfer.unwrap())
    }
}

use crate::common_types::types::frost::FrostSigningCommitments;
use spark_protos::common::SigningCommitment as ProtoSigningCommitments;

pub(crate) fn marshal_frost_commitments(
    commitments: &FrostSigningCommitments,
) -> Result<ProtoSigningCommitments, SparkSdkError> {
    let hiding = commitments.hiding().serialize().unwrap();
    let binding = commitments.binding().serialize().unwrap();

    Ok(ProtoSigningCommitments { hiding, binding })
}