cdk 0.16.0

Core Cashu Development Kit library implementing the Cashu protocol
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

use std::str::FromStr;

use cdk_common::nut00::KnownMethod;
use cdk_common::wallet::MeltQuote;
use cdk_common::{MeltQuoteRequest, MeltQuoteResponse, PaymentMethod};
use lightning_invoice::Bolt11Invoice;
use tracing::instrument;

use crate::nuts::{CurrencyUnit, MeltOptions, MeltQuoteBolt11Request};
use crate::{Amount, Error, Wallet};

impl Wallet {
    /// Melt Quote for Bolt11
    #[instrument(skip(self, request))]
    pub(crate) async fn melt_bolt11_quote(
        &self,
        request: String,
        options: Option<MeltOptions>,
    ) -> Result<MeltQuote, Error> {
        let invoice = Bolt11Invoice::from_str(&request)?;

        let quote_request = MeltQuoteBolt11Request {
            request: invoice.clone(),
            unit: self.unit.clone(),
            options,
        };

        let quote_res = self
            .client
            .post_melt_quote(MeltQuoteRequest::Bolt11(quote_request))
            .await?;

        let quote_res = match quote_res {
            MeltQuoteResponse::Bolt11(response) => response,
            _ => return Err(Error::InvalidPaymentMethod),
        };

        if self.unit == CurrencyUnit::Msat || self.unit == CurrencyUnit::Sat {
            let amount_msat = options
                .map(|opt| opt.amount_msat().into())
                .or_else(|| invoice.amount_milli_satoshis())
                .ok_or(Error::InvoiceAmountUndefined)?;

            let amount_quote_unit = Amount::new(amount_msat, CurrencyUnit::Msat)
                .convert_to(&self.unit)?
                .into();

            if quote_res.amount != amount_quote_unit {
                tracing::warn!(
                    "Mint returned incorrect quote amount. Expected {}, got {}",
                    amount_quote_unit,
                    quote_res.amount
                );
                return Err(Error::IncorrectQuoteAmount);
            }
        }

        // Construct MeltQuote from response
        let quote = MeltQuote {
            id: quote_res.quote,
            mint_url: Some(self.mint_url.clone()),
            amount: quote_res.amount,
            request,
            unit: self.unit.clone(),
            fee_reserve: quote_res.fee_reserve,
            state: quote_res.state,
            expiry: quote_res.expiry,
            payment_preimage: quote_res.payment_preimage,
            payment_method: PaymentMethod::Known(KnownMethod::Bolt11),
            used_by_operation: None,
            version: 0,
        };

        self.localstore.add_melt_quote(quote.clone()).await?;

        Ok(quote)
    }
}