cdk-ffi 0.17.0

FFI bindings for cdk wallet
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Invoice decoding FFI types and functions

use serde::{Deserialize, Serialize};

use crate::error::FfiError;

/// Type of Lightning payment request
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, uniffi::Enum)]
pub enum PaymentType {
    /// Bolt11 invoice
    Bolt11,
    /// Bolt12 offer
    Bolt12,
}

impl From<cdk::invoice::PaymentType> for PaymentType {
    fn from(payment_type: cdk::invoice::PaymentType) -> Self {
        match payment_type {
            cdk::invoice::PaymentType::Bolt11 => Self::Bolt11,
            cdk::invoice::PaymentType::Bolt12 => Self::Bolt12,
        }
    }
}

impl From<PaymentType> for cdk::invoice::PaymentType {
    fn from(payment_type: PaymentType) -> Self {
        match payment_type {
            PaymentType::Bolt11 => Self::Bolt11,
            PaymentType::Bolt12 => Self::Bolt12,
        }
    }
}

/// Decoded invoice or offer information
#[derive(Debug, Clone, Serialize, Deserialize, uniffi::Record)]
pub struct DecodedInvoice {
    /// Type of payment request (Bolt11 or Bolt12)
    pub payment_type: PaymentType,
    /// Amount in millisatoshis, if specified
    pub amount_msat: Option<u64>,
    /// Expiry timestamp (Unix timestamp), if specified
    pub expiry: Option<u64>,
    /// Description or offer description, if specified
    pub description: Option<String>,
}

impl From<cdk::invoice::DecodedInvoice> for DecodedInvoice {
    fn from(decoded: cdk::invoice::DecodedInvoice) -> Self {
        Self {
            payment_type: decoded.payment_type.into(),
            amount_msat: decoded.amount_msat,
            expiry: decoded.expiry,
            description: decoded.description,
        }
    }
}

impl From<DecodedInvoice> for cdk::invoice::DecodedInvoice {
    fn from(decoded: DecodedInvoice) -> Self {
        Self {
            payment_type: decoded.payment_type.into(),
            amount_msat: decoded.amount_msat,
            expiry: decoded.expiry,
            description: decoded.description,
        }
    }
}

/// Decode a bolt11 invoice or bolt12 offer from a string
///
/// This function attempts to parse the input as a bolt11 invoice first,
/// then as a bolt12 offer if bolt11 parsing fails.
///
/// # Arguments
///
/// * `invoice_str` - The invoice or offer string to decode
///
/// # Returns
///
/// * `Ok(DecodedInvoice)` - Successfully decoded invoice/offer information
/// * `Err(FfiError)` - Failed to parse as either bolt11 or bolt12
///
/// # Example
///
/// ```kotlin
/// val decoded = decodeInvoice("lnbc...")
/// when (decoded.paymentType) {
///     PaymentType.BOLT11 -> println("Bolt11 invoice")
///     PaymentType.BOLT12 -> println("Bolt12 offer")
/// }
/// ```
#[uniffi::export]
pub fn decode_invoice(invoice_str: String) -> Result<DecodedInvoice, FfiError> {
    let decoded = cdk::invoice::decode_invoice(&invoice_str)?;
    Ok(decoded.into())
}