breez_sdk_spark/models/

adaptors.rs

use bitcoin::{
    Address, Transaction, address::NetworkUnchecked, consensus::encode::deserialize_hex,
};
use breez_sdk_common::input::{
    self, InputType, PaymentRequestSource, SparkInvoiceDetails, parse_spark_address,
};
use spark_wallet::{
    CoopExitAcceptance, CoopExitFeeQuote, CoopExitRequest, CoopExitSpeedFeeQuote, ExitSpeed,
    LightningSendPayment, LightningSendStatus, Network as SparkNetwork, PreimageRequest,
    PreimageRequestStatus, SilentPaymentAddress, SspUserRequest, TokenTransactionStatus,
    TransferDirection, TransferStatus, TransferType, WalletTransfer,
};
use std::time::Duration;

use platform_utils::time::UNIX_EPOCH;
use tracing::{debug, warn};

use crate::{
    AutoOptimizationEvent, Fee, Network, OnchainConfirmationSpeed, OptimizationOutcome, Payment,
    PaymentDetails, PaymentMethod, PaymentStatus, PaymentType, SdkError, SendOnchainFeeQuote,
    SendOnchainSpeedFeeQuote, SparkHtlcDetails, SparkHtlcStatus, SparkInvoicePaymentDetails,
    TokenBalance, TokenMetadata,
};

/// Feb 1, 2026 00:00:00 UTC — transfers before this may lack HTLC data on the operator.
#[allow(clippy::duration_suboptimal_units)]
const HTLC_DATA_REQUIRED_SINCE: Duration = Duration::from_secs(1_769_904_000);

/// Derive HTLC details from SSP request fields when the operator lacks the
/// `PreimageRequest`. Only allowed for old transfers (before [`HTLC_DATA_REQUIRED_SINCE`]);
/// new transfers without HTLC data are considered an error.
fn derive_htlc_details_from_ssp(
    transfer: &WalletTransfer,
    payment_hash: &str,
    preimage: Option<&str>,
) -> Result<SparkHtlcDetails, SdkError> {
    let cutoff = UNIX_EPOCH
        .checked_add(HTLC_DATA_REQUIRED_SINCE)
        .ok_or_else(|| SdkError::Generic("HTLC cutoff time overflow".to_string()))?;
    let is_old = transfer.created_at.is_none_or(|t| t < cutoff);
    if !is_old {
        return Err(SdkError::Generic(format!(
            "Missing HTLC details for Lightning payment transfer {}",
            transfer.id
        )));
    }

    warn!(
        "Missing HTLC preimage request for Lightning transfer {}, deriving from SSP data",
        transfer.id
    );

    let status = match transfer.status {
        TransferStatus::Completed => SparkHtlcStatus::PreimageShared,
        TransferStatus::Expired | TransferStatus::Returned => SparkHtlcStatus::Returned,
        _ => SparkHtlcStatus::WaitingForPreimage,
    };
    Ok(SparkHtlcDetails {
        payment_hash: payment_hash.to_string(),
        preimage: preimage.map(ToString::to_string),
        expiry_time: transfer
            .expiry_time
            .and_then(|t| t.duration_since(UNIX_EPOCH).ok())
            .map_or(0, |d| d.as_secs()),
        status,
    })
}

/// If the HTLC details are missing a preimage, fill it in from the given fallback and update
/// the status to [`SparkHtlcStatus::PreimageShared`] accordingly.
fn reconcile_htlc_preimage(details: &mut SparkHtlcDetails, preimage: Option<&str>) {
    if details.preimage.is_none() {
        details.preimage = preimage.map(ToString::to_string);
    }
    if details.preimage.is_some() {
        details.status = SparkHtlcStatus::PreimageShared;
    }
}

/// Builds HTLC details from the operator's preimage request, taking a missing preimage from
/// `fallback_preimage`. A known preimage means [`SparkHtlcStatus::PreimageShared`], so an
/// unrecognized status is only an error when no preimage is known.
fn htlc_details_from_preimage_request(
    request: &PreimageRequest,
    fallback_preimage: Option<&str>,
) -> Result<SparkHtlcDetails, SdkError> {
    let preimage = request
        .preimage
        .as_ref()
        .map(spark_wallet::Preimage::encode_hex)
        .or_else(|| fallback_preimage.map(ToString::to_string));
    let status = if preimage.is_some() {
        SparkHtlcStatus::PreimageShared
    } else {
        request.status.try_into()?
    };
    Ok(SparkHtlcDetails {
        payment_hash: request.payment_hash.to_string(),
        preimage,
        expiry_time: request
            .expiry_time
            .duration_since(UNIX_EPOCH)
            .map_err(|e| SdkError::Generic(format!("Invalid expiry time: {e}")))?
            .as_secs(),
        status,
    })
}

fn withdrawal_vout(request: &CoopExitRequest) -> Option<u32> {
    let address = request.withdrawal_address.as_str();
    let transaction: Transaction = deserialize_hex(&request.raw_coop_exit_transaction).ok()?;
    let Ok(bitcoin_address) = address.parse::<Address<NetworkUnchecked>>() else {
        // The SDK cannot derive a silent payment output's script from the address,
        // because the script also depends on the transaction's inputs. Under
        // Spark's rules the payout to a silent payment address is output 0.
        return address.parse::<SilentPaymentAddress>().is_ok().then_some(0);
    };
    let script_pubkey = bitcoin_address.assume_checked().script_pubkey();
    let index = transaction
        .output
        .iter()
        .position(|output| output.script_pubkey == script_pubkey)?;
    u32::try_from(index).ok()
}

impl PaymentMethod {
    fn from_transfer(transfer: &WalletTransfer) -> Self {
        match transfer.transfer_type {
            TransferType::PreimageSwap => {
                if transfer.is_ssp_transfer {
                    PaymentMethod::Lightning
                } else {
                    PaymentMethod::Spark
                }
            }
            TransferType::CooperativeExit => PaymentMethod::Withdraw,
            TransferType::UtxoSwap => PaymentMethod::Deposit,
            TransferType::Transfer => PaymentMethod::Spark,
            _ => PaymentMethod::Unknown,
        }
    }
}

impl PaymentDetails {
    #[allow(clippy::too_many_lines)]
    fn from_transfer(transfer: &WalletTransfer) -> Result<Option<Self>, SdkError> {
        if !transfer.is_ssp_transfer {
            // Check for Spark invoice payments
            if let Some(spark_invoice) = &transfer.spark_invoice {
                let Some(InputType::SparkInvoice(invoice_details)) =
                    parse_spark_address(spark_invoice, &PaymentRequestSource::default())
                else {
                    return Err(SdkError::Generic("Invalid spark invoice".to_string()));
                };

                return Ok(Some(PaymentDetails::Spark {
                    invoice_details: Some(invoice_details.into()),
                    htlc_details: None,
                    conversion_info: None,
                }));
            }

            // Check for Spark HTLC payments (when no user request is present)
            if let Some(htlc_preimage_request) = &transfer.htlc_preimage_request {
                return Ok(Some(PaymentDetails::Spark {
                    invoice_details: None,
                    htlc_details: Some(htlc_details_from_preimage_request(
                        htlc_preimage_request,
                        None,
                    )?),
                    conversion_info: None,
                }));
            }

            return Ok(Some(PaymentDetails::Spark {
                invoice_details: None,
                htlc_details: None,
                conversion_info: None,
            }));
        }

        let Some(user_request) = &transfer.user_request else {
            return Ok(None);
        };

        let details = match user_request {
            SspUserRequest::LightningReceiveRequest(request) => {
                let invoice_details = input::parse_invoice(&request.invoice.encoded_invoice)
                    .ok_or(SdkError::Generic(
                        "Invalid invoice in SspUserRequest::LightningReceiveRequest".to_string(),
                    ))?;
                let htlc_details = if let Some(req) = &transfer.htlc_preimage_request {
                    htlc_details_from_preimage_request(
                        req,
                        request.lightning_receive_payment_preimage.as_deref(),
                    )?
                } else {
                    derive_htlc_details_from_ssp(
                        transfer,
                        &request.invoice.payment_hash,
                        request.lightning_receive_payment_preimage.as_deref(),
                    )?
                };
                PaymentDetails::Lightning {
                    description: invoice_details.description,
                    invoice: request.invoice.encoded_invoice.clone(),
                    destination_pubkey: invoice_details.payee_pubkey,
                    htlc_details,
                    lnurl_pay_info: None,
                    lnurl_withdraw_info: None,
                    lnurl_receive_metadata: None,
                    conversion_info: None,
                }
            }
            SspUserRequest::LightningSendRequest(request) => {
                let invoice_details =
                    input::parse_invoice(&request.encoded_invoice).ok_or(SdkError::Generic(
                        "Invalid invoice in SspUserRequest::LightningSendRequest".to_string(),
                    ))?;
                let htlc_details = if let Some(req) = &transfer.htlc_preimage_request {
                    htlc_details_from_preimage_request(
                        req,
                        request.lightning_send_payment_preimage.as_deref(),
                    )?
                } else {
                    derive_htlc_details_from_ssp(
                        transfer,
                        &invoice_details.payment_hash,
                        request.lightning_send_payment_preimage.as_deref(),
                    )?
                };
                PaymentDetails::Lightning {
                    description: invoice_details.description,
                    invoice: request.encoded_invoice.clone(),
                    destination_pubkey: invoice_details.payee_pubkey,
                    htlc_details,
                    lnurl_pay_info: None,
                    lnurl_withdraw_info: None,
                    lnurl_receive_metadata: None,
                    conversion_info: None,
                }
            }
            SspUserRequest::CoopExitRequest(request) => {
                let Some(vout) = withdrawal_vout(request) else {
                    // An error here would stall the sync, so the payment is
                    // stored without details instead.
                    warn!(
                        "The SSP's record of coop exit {} has no payout output; storing the payment without details",
                        request.id
                    );
                    return Ok(None);
                };
                PaymentDetails::Withdraw {
                    tx_id: request.coop_exit_txid.clone(),
                    vout,
                    destination_address: request.withdrawal_address.clone(),
                }
            }
            SspUserRequest::LeavesSwapRequest(_) => PaymentDetails::Spark {
                invoice_details: None,
                htlc_details: None,
                conversion_info: None,
            },
            SspUserRequest::ClaimStaticDeposit(request) => {
                let Ok(vout) = u32::try_from(request.output_index) else {
                    // vout=0 is a valid output index, so we can't safely default.
                    // Returning Ok(None) mirrors the early return for a missing
                    // user_request above: the downstream branch records the deposit
                    // as Pending without details and the sync loop keeps advancing
                    // the offset. Erroring here would deadlock the whole sync until
                    // the offending transfer leaves the SSP's response.
                    warn!(
                        "Invalid output_index {} in SspUserRequest::ClaimStaticDeposit; skipping details",
                        request.output_index
                    );
                    return Ok(None);
                };
                PaymentDetails::Deposit {
                    tx_id: request.transaction_id.clone(),
                    vout,
                }
            }
        };

        Ok(Some(details))
    }
}

impl From<SparkInvoiceDetails> for SparkInvoicePaymentDetails {
    fn from(value: SparkInvoiceDetails) -> Self {
        Self {
            description: value.description,
            invoice: value.invoice,
        }
    }
}

impl TryFrom<WalletTransfer> for Payment {
    type Error = SdkError;
    fn try_from(transfer: WalletTransfer) -> Result<Self, Self::Error> {
        if [
            TransferType::CounterSwap,
            TransferType::CounterSwapV3,
            TransferType::Swap,
            TransferType::PrimarySwapV3,
        ]
        .contains(&transfer.transfer_type)
        {
            debug!("Tried to convert swap-related transfer to payment. Transfer: {transfer:?}");
            return Err(SdkError::Generic(
                "Swap-related transfers are not considered payments".to_string(),
            ));
        }
        let payment_type = match transfer.direction {
            TransferDirection::Incoming => PaymentType::Receive,
            TransferDirection::Outgoing => PaymentType::Send,
        };
        let mut status = match transfer.status {
            TransferStatus::Completed => PaymentStatus::Completed,
            TransferStatus::SenderKeyTweaked
                if transfer.direction == TransferDirection::Outgoing =>
            {
                PaymentStatus::Completed
            }
            TransferStatus::Expired | TransferStatus::Returned => PaymentStatus::Failed,
            _ => PaymentStatus::Pending,
        };
        let (fees_sat, mut amount_sat) = match transfer.clone().user_request {
            Some(user_request) => match user_request {
                SspUserRequest::LightningSendRequest(r) => {
                    // TODO: if we have the preimage it is not pending. This is a workaround
                    // until spark will implement incremental syncing based on updated time.
                    if r.lightning_send_payment_preimage.is_some() {
                        status = PaymentStatus::Completed;
                    }
                    let fee_sat = r.fee.as_sats().unwrap_or(0);
                    (fee_sat, transfer.total_value_sat.saturating_sub(fee_sat))
                }
                SspUserRequest::CoopExitRequest(r) => {
                    // A committed transfer hands the funds to the provider; only
                    // the provider broadcasts the payout, and only once it has
                    // accepted the exit. Until then the withdrawal is still in
                    // flight, however far the transfer itself got.
                    status = match r.exit_status.acceptance() {
                        CoopExitAcceptance::Accepted => status,
                        CoopExitAcceptance::AwaitingCompletion => PaymentStatus::Pending,
                        CoopExitAcceptance::Failed => PaymentStatus::Failed,
                    };
                    let fee_sat = r
                        .fee
                        .as_sats()
                        .unwrap_or(0)
                        .saturating_add(r.l1_broadcast_fee.as_sats().unwrap_or(0));
                    (fee_sat, transfer.total_value_sat.saturating_sub(fee_sat))
                }
                SspUserRequest::ClaimStaticDeposit(r) => {
                    let fee_sat = r
                        .deposit_amount
                        .as_sats()
                        .unwrap_or(0)
                        .saturating_sub(r.credit_amount.as_sats().unwrap_or(0));
                    (fee_sat, transfer.total_value_sat)
                }
                _ => (0, transfer.total_value_sat),
            },
            None => (0, transfer.total_value_sat),
        };

        let details = match PaymentDetails::from_transfer(&transfer) {
            Ok(Some(details)) => Some(details),
            Ok(None) => {
                // in case we have a completed status without user object we want
                // to keep syncing this payment
                if status == PaymentStatus::Completed
                    && [
                        TransferType::CooperativeExit,
                        TransferType::PreimageSwap,
                        TransferType::UtxoSwap,
                    ]
                    .contains(&transfer.transfer_type)
                {
                    status = PaymentStatus::Pending;
                }
                amount_sat = transfer.total_value_sat;
                None
            }
            // Failing here would stop sync at this transfer on every pass. Recording it as
            // Pending lets sync move on while reconciliation keeps re-fetching it, so the
            // details fill in once the operator or SSP serves data that maps again.
            Err(e) => {
                warn!(
                    "Recording transfer {} as pending without payment details: {e:?}",
                    transfer.id
                );
                status = PaymentStatus::Pending;
                None
            }
        };

        Ok(Payment {
            id: transfer.id.to_string(),
            payment_type,
            status,
            amount: amount_sat.into(),
            fees: fees_sat.into(),
            timestamp: match transfer.created_at.map(|t| t.duration_since(UNIX_EPOCH)) {
                Some(Ok(duration)) => duration.as_secs(),
                _ => 0,
            },
            method: PaymentMethod::from_transfer(&transfer),
            details,
            conversion_details: None,
        })
    }
}

impl Payment {
    /// Creates a [`Payment`] from a [`LightningSendPayment`] and its associated HTLC details.
    ///
    /// The `htlc_details` may be stale (e.g. captured at payment creation time), so this
    /// method reconciles them with the current state of the `payment`:
    /// - The preimage is taken from `htlc_details` if present, otherwise from the payment.
    /// - If a preimage is available from either source, the HTLC status is set to
    ///   [`SparkHtlcStatus::PreimageShared`].
    pub fn from_lightning(
        payment: LightningSendPayment,
        amount_sat: u128,
        transfer_id: String,
        mut htlc_details: SparkHtlcDetails,
    ) -> Result<Self, SdkError> {
        let mut status = match payment.status {
            LightningSendStatus::LightningPaymentSucceeded => PaymentStatus::Completed,
            LightningSendStatus::LightningPaymentFailed
            | LightningSendStatus::TransferFailed
            | LightningSendStatus::PreimageProvidingFailed
            | LightningSendStatus::UserSwapReturnFailed
            | LightningSendStatus::UserSwapReturned => PaymentStatus::Failed,
            _ => PaymentStatus::Pending,
        };
        if payment.payment_preimage.is_some() {
            status = PaymentStatus::Completed;
        }

        reconcile_htlc_preimage(&mut htlc_details, payment.payment_preimage.as_deref());

        let invoice_details = input::parse_invoice(&payment.encoded_invoice).ok_or(
            SdkError::Generic("Invalid invoice in LightnintSendPayment".to_string()),
        )?;
        let details = PaymentDetails::Lightning {
            description: invoice_details.description,
            invoice: payment.encoded_invoice,
            destination_pubkey: invoice_details.payee_pubkey,
            htlc_details,
            lnurl_pay_info: None,
            lnurl_withdraw_info: None,
            lnurl_receive_metadata: None,
            conversion_info: None,
        };

        Ok(Payment {
            id: transfer_id,
            payment_type: PaymentType::Send,
            status,
            amount: amount_sat,
            fees: payment.fee_sat.into(),
            timestamp: payment.created_at.cast_unsigned(),
            method: PaymentMethod::Lightning,
            details: Some(details),
            conversion_details: None,
        })
    }
}

impl From<Network> for SparkNetwork {
    fn from(network: Network) -> Self {
        match network {
            Network::Mainnet => SparkNetwork::Mainnet,
            Network::Regtest => SparkNetwork::Regtest,
            Network::Signet => SparkNetwork::Signet,
        }
    }
}

impl From<Fee> for spark_wallet::Fee {
    fn from(fee: Fee) -> Self {
        match fee {
            Fee::Fixed { amount } => spark_wallet::Fee::Fixed { amount },
            Fee::Rate { sat_per_vbyte } => spark_wallet::Fee::Rate { sat_per_vbyte },
        }
    }
}

impl From<spark_wallet::TokenBalance> for TokenBalance {
    fn from(value: spark_wallet::TokenBalance) -> Self {
        Self {
            balance: value.balance,
            token_metadata: value.token_metadata.into(),
        }
    }
}

impl From<spark_wallet::TokenMetadata> for TokenMetadata {
    fn from(value: spark_wallet::TokenMetadata) -> Self {
        Self {
            identifier: value.identifier,
            issuer_public_key: hex::encode(value.issuer_public_key.serialize()),
            name: value.name,
            ticker: value.ticker,
            decimals: value.decimals,
            max_supply: value.max_supply,
            is_freezable: value.is_freezable,
        }
    }
}

impl From<CoopExitFeeQuote> for SendOnchainFeeQuote {
    fn from(value: CoopExitFeeQuote) -> Self {
        Self {
            id: value.id,
            expires_at: value.expires_at,
            speed_fast: value.speed_fast.into(),
            speed_medium: value.speed_medium.into(),
            speed_slow: value.speed_slow.into(),
            is_estimate: false,
        }
    }
}

impl From<SendOnchainFeeQuote> for CoopExitFeeQuote {
    fn from(value: SendOnchainFeeQuote) -> Self {
        Self {
            id: value.id,
            expires_at: value.expires_at,
            speed_fast: value.speed_fast.into(),
            speed_medium: value.speed_medium.into(),
            speed_slow: value.speed_slow.into(),
        }
    }
}

impl From<CoopExitSpeedFeeQuote> for SendOnchainSpeedFeeQuote {
    fn from(value: CoopExitSpeedFeeQuote) -> Self {
        Self {
            user_fee_sat: value.user_fee_sat,
            l1_broadcast_fee_sat: value.l1_broadcast_fee_sat,
        }
    }
}

impl From<SendOnchainSpeedFeeQuote> for CoopExitSpeedFeeQuote {
    fn from(value: SendOnchainSpeedFeeQuote) -> Self {
        Self {
            user_fee_sat: value.user_fee_sat,
            l1_broadcast_fee_sat: value.l1_broadcast_fee_sat,
        }
    }
}

impl From<OnchainConfirmationSpeed> for ExitSpeed {
    fn from(speed: OnchainConfirmationSpeed) -> Self {
        match speed {
            OnchainConfirmationSpeed::Fast => ExitSpeed::Fast,
            OnchainConfirmationSpeed::Medium => ExitSpeed::Medium,
            OnchainConfirmationSpeed::Slow => ExitSpeed::Slow,
        }
    }
}

impl From<ExitSpeed> for OnchainConfirmationSpeed {
    fn from(speed: ExitSpeed) -> Self {
        match speed {
            ExitSpeed::Fast => OnchainConfirmationSpeed::Fast,
            ExitSpeed::Medium => OnchainConfirmationSpeed::Medium,
            ExitSpeed::Slow => OnchainConfirmationSpeed::Slow,
        }
    }
}

impl PaymentStatus {
    pub(crate) fn from_token_transaction_status(
        status: TokenTransactionStatus,
        is_transfer_transaction: bool,
    ) -> Self {
        match status {
            TokenTransactionStatus::Started
            | TokenTransactionStatus::Revealed
            | TokenTransactionStatus::Unknown => PaymentStatus::Pending,
            TokenTransactionStatus::Signed if is_transfer_transaction => PaymentStatus::Pending,
            TokenTransactionStatus::Finalized | TokenTransactionStatus::Signed => {
                PaymentStatus::Completed
            }
            TokenTransactionStatus::StartedCancelled | TokenTransactionStatus::SignedCancelled => {
                PaymentStatus::Failed
            }
        }
    }
}

impl TryFrom<PreimageRequest> for SparkHtlcDetails {
    type Error = SdkError;
    fn try_from(value: PreimageRequest) -> Result<Self, Self::Error> {
        htlc_details_from_preimage_request(&value, None)
    }
}

impl TryFrom<PreimageRequestStatus> for SparkHtlcStatus {
    type Error = SdkError;
    fn try_from(status: PreimageRequestStatus) -> Result<Self, Self::Error> {
        match status {
            PreimageRequestStatus::WaitingForPreimage => Ok(SparkHtlcStatus::WaitingForPreimage),
            PreimageRequestStatus::PreimageShared => Ok(SparkHtlcStatus::PreimageShared),
            PreimageRequestStatus::Returned => Ok(SparkHtlcStatus::Returned),
            // No public status fits: any of them would claim a state we don't know,
            // e.g. `WaitingForPreimage` would list the HTLC as claimable.
            PreimageRequestStatus::Unknown => Err(SdkError::Generic(
                "Unrecognized preimage request status".to_string(),
            )),
        }
    }
}

impl From<spark_wallet::AutoOptimizationEvent> for AutoOptimizationEvent {
    fn from(value: spark_wallet::AutoOptimizationEvent) -> Self {
        match value {
            spark_wallet::AutoOptimizationEvent::Started { total_rounds } => {
                Self::Started { total_rounds }
            }
            spark_wallet::AutoOptimizationEvent::RoundCompleted {
                current_round,
                total_rounds,
            } => Self::RoundCompleted {
                current_round,
                total_rounds,
            },
            spark_wallet::AutoOptimizationEvent::Completed => Self::Completed,
            spark_wallet::AutoOptimizationEvent::Cancelled => Self::Cancelled,
            spark_wallet::AutoOptimizationEvent::Failed { error } => Self::Failed { error },
            spark_wallet::AutoOptimizationEvent::Skipped => Self::Skipped,
        }
    }
}

impl From<spark_wallet::OptimizationOutcome> for OptimizationOutcome {
    fn from(value: spark_wallet::OptimizationOutcome) -> Self {
        match value {
            spark_wallet::OptimizationOutcome::Completed { rounds_executed } => {
                Self::Completed { rounds_executed }
            }
            spark_wallet::OptimizationOutcome::InProgress => Self::InProgress,
        }
    }
}

impl From<crate::CpfpFundingStrategy> for spark_wallet::CpfpFundingStrategy {
    fn from(value: crate::CpfpFundingStrategy) -> Self {
        match value {
            crate::CpfpFundingStrategy::PerBranch => Self::PerBranch,
            crate::CpfpFundingStrategy::PerNode => Self::PerNode,
        }
    }
}

impl From<crate::WebhookEventType> for spark_wallet::SparkWalletWebhookEventType {
    fn from(value: crate::WebhookEventType) -> Self {
        match value {
            crate::WebhookEventType::LightningReceiveFinished => {
                Self::SparkLightningReceiveFinished
            }
            crate::WebhookEventType::LightningSendFinished => Self::SparkLightningSendFinished,
            crate::WebhookEventType::CoopExitFinished => Self::SparkCoopExitFinished,
            crate::WebhookEventType::StaticDepositFinished => Self::SparkStaticDepositFinished,
            crate::WebhookEventType::Unknown(s) => Self::Unknown(s),
        }
    }
}

impl From<spark_wallet::SparkWalletWebhookEventType> for crate::WebhookEventType {
    fn from(value: spark_wallet::SparkWalletWebhookEventType) -> Self {
        match value {
            spark_wallet::SparkWalletWebhookEventType::SparkLightningReceiveFinished => {
                Self::LightningReceiveFinished
            }
            spark_wallet::SparkWalletWebhookEventType::SparkLightningSendFinished => {
                Self::LightningSendFinished
            }
            spark_wallet::SparkWalletWebhookEventType::SparkCoopExitFinished => {
                Self::CoopExitFinished
            }
            spark_wallet::SparkWalletWebhookEventType::SparkStaticDepositFinished => {
                Self::StaticDepositFinished
            }
            spark_wallet::SparkWalletWebhookEventType::Unknown(s) => Self::Unknown(s),
        }
    }
}

impl From<spark_wallet::WebhookEntry> for crate::Webhook {
    fn from(value: spark_wallet::WebhookEntry) -> Self {
        Self {
            id: value.webhook_id,
            url: value.url,
            event_types: value.event_types.into_iter().map(Into::into).collect(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::SendOnchainFeeQuote;
    use chrono::Utc;
    use macros::test_all;
    use platform_utils::time::SystemTime;
    use spark_wallet::{
        BitcoinNetwork, CoopExitFeeQuote, CoopExitSpeedFeeQuote, CurrencyAmount, CurrencyUnit,
        LightningSendRequest, LightningSendRequestStatus, PublicKey, SparkCoopExitRequestStatus,
        SspTransfer, Transfer, TransferId,
    };

    #[cfg(feature = "browser-tests")]
    wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);

    #[test_all]
    fn test_a_provider_quote_is_never_an_estimate() {
        // What keeps a real quote distinguishable from a locally derived one.
        // Marking it an estimate would give it an estimate's fee headroom and
        // stop it being refreshed near expiry.
        let speed = || CoopExitSpeedFeeQuote {
            user_fee_sat: 750,
            l1_broadcast_fee_sat: 960,
        };
        let quote: SendOnchainFeeQuote = CoopExitFeeQuote {
            id: "SparkCoopExitFeeQuote:test".to_string(),
            expires_at: 1_787_907_773,
            speed_fast: speed(),
            speed_medium: speed(),
            speed_slow: speed(),
        }
        .into();

        assert!(!quote.is_estimate);
        assert_eq!(quote.id, "SparkCoopExitFeeQuote:test");
        assert_eq!(quote.expires_at, 1_787_907_773);
    }

    fn pk(fill_byte: u8) -> PublicKey {
        let mut bytes = [fill_byte; 33];
        bytes[0] = 2;
        PublicKey::from_slice(&bytes).unwrap()
    }

    /// A completed transfer created now, sent from `sender` to `receiver`.
    fn transfer(sender: PublicKey, receiver: PublicKey, transfer_type: TransferType) -> Transfer {
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_secs();
        Transfer {
            id: TransferId::generate(),
            sender_identity_public_key: sender,
            receiver_identity_public_key: receiver,
            status: TransferStatus::Completed,
            total_value: 1_010,
            expiry_time: None,
            leaves: Vec::new(),
            created_time: Some(now),
            updated_time: Some(now),
            transfer_type,
            spark_invoice: None,
        }
    }

    #[test_all]
    fn a_lightning_send_whose_details_fail_to_map_is_pending_with_its_amount() {
        let (ours, ssp) = (pk(1), pk(2));
        let request = LightningSendRequest {
            id: "request".to_string(),
            created_at: Utc::now(),
            updated_at: Utc::now(),
            network: BitcoinNetwork::Regtest,
            encoded_invoice: "not an invoice".to_string(),
            fee: CurrencyAmount {
                original_value: 10,
                original_unit: CurrencyUnit::Satoshi,
                preferred_currency_unit: CurrencyUnit::Satoshi,
                preferred_currency_value_rounded: 10,
            },
            idempotency_key: "key".to_string(),
            status: LightningSendRequestStatus::LightningPaymentSucceeded,
            transfer: None,
            lightning_send_payment_preimage: None,
        };
        let wallet_transfer = WalletTransfer::from_transfer(
            transfer(ours, ssp, TransferType::PreimageSwap),
            Some(SspTransfer {
                total_amount: request.fee.clone(),
                spark_id: None,
                user_request: Some(SspUserRequest::LightningSendRequest(request)),
            }),
            None,
            ours,
            ssp,
        );

        let payment = Payment::try_from(wallet_transfer).unwrap();

        assert!(payment.details.is_none());
        assert_eq!(payment.method, PaymentMethod::Lightning);
        assert_eq!(payment.payment_type, PaymentType::Send);
        // Pending so reconciliation re-fetches it until its details map.
        assert_eq!(payment.status, PaymentStatus::Pending);
        assert_eq!(payment.amount, 1_000);
        assert_eq!(payment.fees, 10);
    }

    #[test_all]
    fn a_spark_transfer_with_an_invalid_invoice_is_a_pending_payment() {
        let (ours, other, ssp) = (pk(1), pk(7), pk(2));
        let mut raw = transfer(other, ours, TransferType::Transfer);
        raw.spark_invoice = Some("not an invoice".to_string());
        let wallet_transfer = WalletTransfer::from_transfer(raw, None, None, ours, ssp);

        let payment = Payment::try_from(wallet_transfer).unwrap();

        assert!(payment.details.is_none());
        assert_eq!(payment.method, PaymentMethod::Spark);
        assert_eq!(payment.payment_type, PaymentType::Receive);
        assert_eq!(payment.status, PaymentStatus::Pending);
        assert_eq!(payment.amount, 1_010);
    }

    #[test_all]
    fn a_spark_htlc_with_an_unknown_preimage_status_is_pending_without_details() {
        use bitcoin::hashes::{Hash, sha256};

        let (ours, other, ssp) = (pk(1), pk(7), pk(2));
        let preimage_request = PreimageRequest {
            payment_hash: sha256::Hash::hash(b"preimage"),
            status: PreimageRequestStatus::Unknown,
            created_time: SystemTime::now(),
            expiry_time: SystemTime::now(),
            preimage: None,
        };
        let wallet_transfer = WalletTransfer::from_transfer(
            transfer(other, ours, TransferType::PreimageSwap),
            None,
            Some(preimage_request),
            ours,
            ssp,
        );

        let payment = Payment::try_from(wallet_transfer).unwrap();

        // No HTLC details, so an `htlc_status` filter can't list it as claimable.
        assert!(payment.details.is_none());
        assert_eq!(payment.method, PaymentMethod::Spark);
        assert_eq!(payment.status, PaymentStatus::Pending);
    }

    #[test_all]
    fn an_unknown_preimage_status_with_a_known_preimage_is_preimage_shared() {
        use bitcoin::hashes::{Hash, sha256};

        let preimage_request = PreimageRequest {
            payment_hash: sha256::Hash::hash(b"preimage"),
            status: PreimageRequestStatus::Unknown,
            created_time: SystemTime::now(),
            expiry_time: SystemTime::now(),
            preimage: None,
        };
        let preimage = "00".repeat(32);

        let details =
            htlc_details_from_preimage_request(&preimage_request, Some(&preimage)).unwrap();

        assert_eq!(details.status, SparkHtlcStatus::PreimageShared);
        assert_eq!(details.preimage, Some(preimage));
    }

    fn coop_exit(withdrawal_address: &str, raw_coop_exit_transaction: &str) -> CoopExitRequest {
        CoopExitRequest {
            id: "request".to_string(),
            created_at: Utc::now(),
            updated_at: Utc::now(),
            network: BitcoinNetwork::Regtest,
            fee: CurrencyAmount::default(),
            withdrawal_address: withdrawal_address.to_string(),
            l1_broadcast_fee: CurrencyAmount::default(),
            exit_status: SparkCoopExitRequestStatus::Succeeded,
            exit_expired_at: Utc::now(),
            raw_connector_transaction: String::new(),
            raw_coop_exit_transaction: raw_coop_exit_transaction.to_string(),
            coop_exit_txid: "exit_txid".to_string(),
            transfer: None,
        }
    }

    fn regtest_address(key: PublicKey) -> Address {
        Address::p2wpkh(
            &bitcoin::CompressedPublicKey(key),
            bitcoin::Network::Regtest,
        )
    }

    fn exit_transaction_hex(addresses: &[&Address]) -> String {
        let transaction = Transaction {
            version: bitcoin::transaction::Version::TWO,
            lock_time: bitcoin::absolute::LockTime::ZERO,
            input: vec![bitcoin::TxIn::default()],
            output: addresses
                .iter()
                .map(|address| bitcoin::TxOut {
                    value: bitcoin::Amount::from_sat(1_000),
                    script_pubkey: address.script_pubkey(),
                })
                .collect(),
        };
        bitcoin::consensus::encode::serialize_hex(&transaction)
    }

    #[test_all]
    fn a_withdrawal_carries_its_address_and_the_index_of_its_payout_output() {
        let (ours, ssp) = (pk(1), pk(2));
        let address = regtest_address(pk(7));
        let raw_transaction = exit_transaction_hex(&[&regtest_address(ssp), &address]);
        let wallet_transfer = WalletTransfer::from_transfer(
            transfer(ours, ssp, TransferType::CooperativeExit),
            Some(SspTransfer {
                total_amount: CurrencyAmount::default(),
                spark_id: None,
                user_request: Some(SspUserRequest::CoopExitRequest(coop_exit(
                    &address.to_string(),
                    &raw_transaction,
                ))),
            }),
            None,
            ours,
            ssp,
        );

        let payment = Payment::try_from(wallet_transfer).unwrap();

        let Some(PaymentDetails::Withdraw {
            tx_id,
            vout,
            destination_address,
        }) = payment.details
        else {
            panic!("expected withdraw details, got {:?}", payment.details);
        };
        assert_eq!(tx_id, "exit_txid");
        assert_eq!(vout, 1);
        assert_eq!(destination_address, address.to_string());
    }

    #[test_all]
    fn a_withdrawal_without_a_payout_output_has_no_details() {
        let (ours, ssp) = (pk(1), pk(2));
        let address = regtest_address(pk(7));
        let raw_transaction = exit_transaction_hex(&[&regtest_address(ssp)]);
        let wallet_transfer = WalletTransfer::from_transfer(
            transfer(ours, ssp, TransferType::CooperativeExit),
            Some(SspTransfer {
                total_amount: CurrencyAmount::default(),
                spark_id: None,
                user_request: Some(SspUserRequest::CoopExitRequest(coop_exit(
                    &address.to_string(),
                    &raw_transaction,
                ))),
            }),
            None,
            ours,
            ssp,
        );

        let payment = Payment::try_from(wallet_transfer).unwrap();

        assert_eq!(payment.method, PaymentMethod::Withdraw);
        assert!(payment.details.is_none(), "{:?}", payment.details);
    }

    #[test_all]
    fn no_output_index_without_an_output_to_the_withdrawal_address() {
        let address = regtest_address(pk(7));
        let raw_transaction = exit_transaction_hex(&[&regtest_address(pk(2))]);

        let vout = withdrawal_vout(&coop_exit(&address.to_string(), &raw_transaction));

        assert_eq!(vout, None);
    }

    #[test_all]
    fn the_payout_to_a_silent_payment_address_is_output_zero() {
        let address = SilentPaymentAddress::new(pk(1), pk(7), SparkNetwork::Regtest);
        let raw_transaction = exit_transaction_hex(&[&regtest_address(pk(2))]);

        let vout = withdrawal_vout(&coop_exit(&address.to_string(), &raw_transaction));

        assert_eq!(vout, Some(0));
    }

    #[test_all]
    fn no_output_index_when_the_exit_transaction_does_not_decode() {
        let address = SilentPaymentAddress::new(pk(1), pk(7), SparkNetwork::Regtest);

        let vout = withdrawal_vout(&coop_exit(&address.to_string(), "not a transaction"));

        assert_eq!(vout, None);
    }
}