mod.rs

//! Specific Subscription for the cdk crate
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};

use super::PublicKey;
use crate::nut00::KnownMethod;
use crate::nut25::MeltQuoteBolt12Response;
use crate::nut30::{MeltQuoteOnchainResponse, MintQuoteOnchainResponse};
use crate::nuts::{
    CurrencyUnit, MeltQuoteBolt11Response, MeltQuoteCustomResponse, MintQuoteBolt11Response,
    MintQuoteCustomResponse, PaymentMethod, ProofState,
};
use crate::quote_id::QuoteIdError;
use crate::MintQuoteBolt12Response;

pub mod ws;

/// Subscription Parameter according to the standard
#[derive(Debug, Clone, Serialize, Eq, PartialEq, Hash, Deserialize)]
#[serde(bound = "I: DeserializeOwned + Serialize")]
pub struct Params<I> {
    /// Kind
    pub kind: Kind,
    /// Filters
    pub filters: Vec<String>,
    /// Subscription Id
    #[serde(rename = "subId")]
    pub id: I,
}

/// Check state Settings
#[derive(Debug, Default, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct SupportedSettings {
    /// Supported methods
    pub supported: Vec<SupportedMethods>,
}

/// Supported WS Methods
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct SupportedMethods {
    /// Payment Method
    pub method: PaymentMethod,
    /// Unit
    pub unit: CurrencyUnit,
    /// Command
    pub commands: Vec<WsCommand>,
}

impl SupportedMethods {
    /// Create [`SupportedMethods`]
    pub fn new(method: PaymentMethod, unit: CurrencyUnit, commands: Vec<WsCommand>) -> Self {
        Self {
            method,
            unit,
            commands,
        }
    }

    /// Create [`SupportedMethods`] for Bolt11 with all supported commands
    pub fn default_bolt11(unit: CurrencyUnit) -> Self {
        let commands = vec![
            WsCommand::Bolt11MintQuote,
            WsCommand::Bolt11MeltQuote,
            WsCommand::ProofState,
        ];

        Self {
            method: PaymentMethod::Known(KnownMethod::Bolt11),
            unit,
            commands,
        }
    }

    /// Create [`SupportedMethods`] for Bolt12 with all supported commands
    pub fn default_bolt12(unit: CurrencyUnit) -> Self {
        let commands = vec![
            WsCommand::Bolt12MintQuote,
            WsCommand::Bolt12MeltQuote,
            WsCommand::ProofState,
        ];

        Self {
            method: PaymentMethod::Known(KnownMethod::Bolt12),
            unit,
            commands,
        }
    }

    /// Create [`SupportedMethods`] for custom payment method with all supported commands
    pub fn default_custom(method: PaymentMethod, unit: CurrencyUnit) -> Self {
        let method_name = method.to_string();
        let commands = vec![
            WsCommand::Custom(format!("{}_mint_quote", method_name)),
            WsCommand::Custom(format!("{}_melt_quote", method_name)),
            WsCommand::ProofState,
        ];

        Self {
            method,
            unit,
            commands,
        }
    }
}

impl WsCommand {
    /// Create a custom mint quote command for a payment method
    pub fn custom_mint_quote(method: &str) -> Self {
        WsCommand::Custom(format!("{}_mint_quote", method))
    }

    /// Create a custom melt quote command for a payment method
    pub fn custom_melt_quote(method: &str) -> Self {
        WsCommand::Custom(format!("{}_melt_quote", method))
    }
}

/// WebSocket commands supported by the Cashu mint
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum WsCommand {
    /// Command to request a Lightning invoice for minting tokens
    Bolt11MintQuote,
    /// Command to request a Lightning payment for melting tokens
    Bolt11MeltQuote,
    /// Websocket support for Bolt12 Mint Quote
    Bolt12MintQuote,
    /// Websocket support for Bolt12 Melt Quote
    Bolt12MeltQuote,
    /// Command to check the state of a proof
    ProofState,
    /// Custom payment method command
    Custom(String),
}

impl Serialize for WsCommand {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let s = match self {
            WsCommand::Bolt11MintQuote => "bolt11_mint_quote",
            WsCommand::Bolt11MeltQuote => "bolt11_melt_quote",
            WsCommand::Bolt12MintQuote => "bolt12_mint_quote",
            WsCommand::Bolt12MeltQuote => "bolt12_melt_quote",
            WsCommand::ProofState => "proof_state",
            WsCommand::Custom(custom) => custom.as_str(),
        };
        serializer.serialize_str(s)
    }
}

impl<'de> Deserialize<'de> for WsCommand {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;
        Ok(match s.as_str() {
            "bolt11_mint_quote" => WsCommand::Bolt11MintQuote,
            "bolt11_melt_quote" => WsCommand::Bolt11MeltQuote,
            "bolt12_mint_quote" => WsCommand::Bolt12MintQuote,
            "bolt12_melt_quote" => WsCommand::Bolt12MeltQuote,
            "proof_state" => WsCommand::ProofState,
            custom => WsCommand::Custom(custom.to_string()),
        })
    }
}

impl<T> From<MintQuoteBolt12Response<T>> for NotificationPayload<T>
where
    T: Clone,
{
    fn from(mint_quote: MintQuoteBolt12Response<T>) -> NotificationPayload<T> {
        NotificationPayload::MintQuoteBolt12Response(mint_quote)
    }
}

impl<T> From<MeltQuoteBolt12Response<T>> for NotificationPayload<T>
where
    T: Clone,
{
    fn from(melt_quote: MeltQuoteBolt12Response<T>) -> NotificationPayload<T> {
        NotificationPayload::MeltQuoteBolt12Response(melt_quote)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(bound = "T: Serialize + DeserializeOwned")]
#[serde(untagged)]
/// Subscription response
///
/// Note on variant ordering: serde `untagged` deserialization tries variants
/// in declaration order and selects the first that matches. The stricter
/// variants are declared before the more permissive ones so payloads with
/// overlapping field names are classified correctly.
pub enum NotificationPayload<T>
where
    T: Clone,
{
    /// Proof State
    ProofState(ProofState),
    /// Mint Quote Onchain Response
    ///
    /// Declared before `MintQuoteBolt12Response` to ensure untagged
    /// discrimination picks the onchain variant for onchain payloads.
    MintQuoteOnchainResponse(MintQuoteOnchainResponse<T>),
    /// Melt Quote Onchain Response
    ///
    /// Declared before `MeltQuoteBolt11Response`/`MeltQuoteBolt12Response`
    /// for the same reason.
    MeltQuoteOnchainResponse(MeltQuoteOnchainResponse<T>),
    /// Mint Quote Bolt12 Response
    MintQuoteBolt12Response(MintQuoteBolt12Response<T>),
    /// Melt Quote Bolt11 Response
    MeltQuoteBolt11Response(MeltQuoteBolt11Response<T>),
    /// Mint Quote Bolt11 Response
    MintQuoteBolt11Response(MintQuoteBolt11Response<T>),
    /// Melt Quote Bolt12 Response
    MeltQuoteBolt12Response(MeltQuoteBolt12Response<T>),
    /// Custom Mint Quote Response (method, response)
    CustomMintQuoteResponse(String, MintQuoteCustomResponse<T>),
    /// Custom Melt Quote Response (method, response)
    CustomMeltQuoteResponse(String, MeltQuoteCustomResponse<T>),
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Deserialize, Hash, Serialize)]
#[serde(bound = "T: Serialize + DeserializeOwned")]
/// A parsed notification
pub enum NotificationId<T>
where
    T: Clone,
{
    /// ProofState id is a Pubkey
    ProofState(PublicKey),
    /// MeltQuote id is an QuoteId
    MeltQuoteBolt11(T),
    /// MintQuote id is an QuoteId
    MintQuoteBolt11(T),
    /// MintQuote id is an QuoteId
    MintQuoteBolt12(T),
    /// MintQuote id is an QuoteId
    MeltQuoteBolt12(T),
    /// MintQuote id is an QuoteId
    MintQuoteOnchain(T),
    /// MintQuote id is an QuoteId
    MeltQuoteOnchain(T),
    /// MintQuote id is an QuoteId
    MintQuoteCustom(String, T),
    /// MintQuote id is an QuoteId
    MeltQuoteCustom(String, T),
}

/// Kind
#[derive(Debug, Clone, Eq, Ord, PartialOrd, PartialEq, Hash)]
pub enum Kind {
    /// Bolt 11 Melt Quote
    Bolt11MeltQuote,
    /// Bolt 11 Mint Quote
    Bolt11MintQuote,
    /// Proof State
    ProofState,
    /// Bolt 12 Mint Quote
    Bolt12MintQuote,
    /// Bolt 12 Melt Quote
    Bolt12MeltQuote,
    /// Onchain Mint Quote
    OnchainMintQuote,
    /// Onchain Melt Quote
    OnchainMeltQuote,
    /// Custom
    Custom(String),
}

impl Serialize for Kind {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let s = match self {
            Kind::Bolt11MintQuote => "bolt11_mint_quote",
            Kind::Bolt11MeltQuote => "bolt11_melt_quote",
            Kind::Bolt12MintQuote => "bolt12_mint_quote",
            Kind::Bolt12MeltQuote => "bolt12_melt_quote",
            Kind::OnchainMintQuote => "onchain_mint_quote",
            Kind::OnchainMeltQuote => "onchain_melt_quote",
            Kind::ProofState => "proof_state",
            Kind::Custom(custom) => custom.as_str(),
        };
        serializer.serialize_str(s)
    }
}

impl<'de> Deserialize<'de> for Kind {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;
        Ok(match s.as_str() {
            "bolt11_mint_quote" => Kind::Bolt11MintQuote,
            "bolt11_melt_quote" => Kind::Bolt11MeltQuote,
            "bolt12_mint_quote" => Kind::Bolt12MintQuote,
            "bolt12_melt_quote" => Kind::Bolt12MeltQuote,
            "onchain_mint_quote" => Kind::OnchainMintQuote,
            "onchain_melt_quote" => Kind::OnchainMeltQuote,
            "proof_state" => Kind::ProofState,
            custom => Kind::Custom(custom.to_string()),
        })
    }
}

impl<I> AsRef<I> for Params<I> {
    fn as_ref(&self) -> &I {
        &self.id
    }
}

/// Parsing error
#[derive(thiserror::Error, Debug)]
pub enum Error {
    #[error("Uuid Error: {0}")]
    /// Uuid Error
    QuoteId(#[from] QuoteIdError),

    #[error("PublicKey Error: {0}")]
    /// PublicKey Error
    PublicKey(#[from] crate::nuts::nut01::Error),
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::nuts::nut00::CurrencyUnit;
    use crate::nuts::nut01::PublicKey;
    use crate::nuts::{MeltQuoteState, MintQuoteState};
    use crate::Amount;

    #[test]
    fn notification_payload_onchain_mint_roundtrip() {
        let resp: MintQuoteOnchainResponse<String> = MintQuoteOnchainResponse {
            quote: "abc".to_string(),
            request: "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh".to_string(),
            unit: CurrencyUnit::Sat,
            expiry: Some(1701704757),
            pubkey: PublicKey::from_hex(
                "03d56ce4e446a85bbdaa547b4ec2b073d40ff802831352b8272b7dd7a4de5a7cac",
            )
            .unwrap(),
            amount_paid: Amount::from(100_000),
            amount_issued: Amount::from(0),
            updated_at: 0,
        };
        let payload: NotificationPayload<String> =
            NotificationPayload::MintQuoteOnchainResponse(resp.clone());

        let encoded = serde_json::to_string(&payload).unwrap();
        let decoded: NotificationPayload<String> = serde_json::from_str(&encoded).unwrap();

        match decoded {
            NotificationPayload::MintQuoteOnchainResponse(r) => {
                assert_eq!(r, resp);
            }
            other => panic!("expected MintQuoteOnchainResponse, got {:?}", other),
        }
    }

    #[test]
    fn notification_payload_bolt12_mint_roundtrip() {
        // Ensure a Bolt12 payload (with `amount`) still decodes as Bolt12 after
        // the Onchain variant was moved ahead of it and marked
        // `deny_unknown_fields`.
        let resp: MintQuoteBolt12Response<String> = MintQuoteBolt12Response {
            quote: "abc".to_string(),
            request: "lno1...".to_string(),
            amount: Some(Amount::from(100_000)),
            unit: CurrencyUnit::Sat,
            expiry: Some(1701704757),
            pubkey: PublicKey::from_hex(
                "03d56ce4e446a85bbdaa547b4ec2b073d40ff802831352b8272b7dd7a4de5a7cac",
            )
            .unwrap(),
            amount_paid: Amount::from(0),
            amount_issued: Amount::from(0),
            updated_at: 0,
        };
        let payload: NotificationPayload<String> =
            NotificationPayload::MintQuoteBolt12Response(resp.clone());

        let encoded = serde_json::to_string(&payload).unwrap();
        let decoded: NotificationPayload<String> = serde_json::from_str(&encoded).unwrap();

        match decoded {
            NotificationPayload::MintQuoteBolt12Response(r) => {
                assert_eq!(r, resp);
            }
            other => panic!("expected MintQuoteBolt12Response, got {:?}", other),
        }
    }

    #[test]
    fn notification_payload_bolt11_mint_with_pubkey_roundtrip() {
        let resp: MintQuoteBolt11Response<String> = MintQuoteBolt11Response {
            quote: "abc".to_string(),
            request: "lnbc...".to_string(),
            amount: Some(Amount::from(100_000)),
            unit: Some(CurrencyUnit::Sat),
            amount_paid: Amount::from(0),
            amount_issued: Amount::from(0),
            updated_at: 0,
            state: MintQuoteState::Unpaid,
            expiry: Some(1701704757),
            pubkey: Some(
                PublicKey::from_hex(
                    "03d56ce4e446a85bbdaa547b4ec2b073d40ff802831352b8272b7dd7a4de5a7cac",
                )
                .unwrap(),
            ),
        };
        let payload: NotificationPayload<String> =
            NotificationPayload::MintQuoteBolt11Response(resp.clone());

        let encoded = serde_json::to_string(&payload).unwrap();
        let decoded: NotificationPayload<String> = serde_json::from_str(&encoded).unwrap();

        match decoded {
            NotificationPayload::MintQuoteBolt11Response(r) => {
                assert_eq!(r, resp);
            }
            other => panic!("expected MintQuoteBolt11Response, got {:?}", other),
        }
    }

    #[test]
    fn notification_payload_onchain_melt_roundtrip() {
        let resp: MeltQuoteOnchainResponse<String> = MeltQuoteOnchainResponse {
            quote: "abc".to_string(),
            amount: Amount::from(100_000),
            unit: CurrencyUnit::Sat,
            state: MeltQuoteState::Pending,
            expiry: 1701704757,
            request: "bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh".to_string(),
            fee_options: vec![crate::nut30::MeltQuoteOnchainFeeOption {
                fee_index: 0,
                fee_reserve: Amount::from(5_000),
                estimated_blocks: 1,
            }],
            selected_fee_index: Some(0),
            outpoint: Some("3b7f3b85:2".to_string()),
            change: None,
        };
        let payload: NotificationPayload<String> =
            NotificationPayload::MeltQuoteOnchainResponse(resp.clone());

        let encoded = serde_json::to_string(&payload).unwrap();
        let decoded: NotificationPayload<String> = serde_json::from_str(&encoded).unwrap();

        match decoded {
            NotificationPayload::MeltQuoteOnchainResponse(r) => {
                assert_eq!(r, resp);
            }
            other => panic!("expected MeltQuoteOnchainResponse, got {:?}", other),
        }
    }
}