Struct PreparedMelt 

pub struct PreparedMelt<'a> { /* private fields */ }

A prepared melt operation that can be confirmed or cancelled.

Implementations

impl<'a> PreparedMelt<'a>

pub fn operation_id(&self) -> Uuid

Get the operation ID

pub fn quote(&self) -> &MeltQuote

Get the quote

pub fn amount(&self) -> Amount

Get the amount to be melted

pub fn proofs(&self) -> &Proofs

Get the proofs that will be used

pub fn proofs_to_swap(&self) -> &Proofs

Get the proofs that need to be swapped

pub fn swap_fee(&self) -> Amount

Get the swap fee

pub fn input_fee(&self) -> Amount

Get the input fee

pub fn total_fee(&self) -> Amount

Get the total fee (with swap, if applicable)

pub fn requires_swap(&self) -> bool

Returns true if a swap would be performed (proofs_to_swap is not empty)

pub fn total_fee_with_swap(&self) -> Amount

Get the total fee if swap is performed (current default behavior)

pub fn input_fee_without_swap(&self) -> Amount

Get the input fee if swap is skipped (fee on all proofs sent directly)

pub fn fee_savings_without_swap(&self) -> Amount

Get the fee savings from skipping the swap

pub fn change_amount_without_swap(&self) -> Amount

Get the expected change amount if swap is skipped

pub async fn confirm(self) -> Result<FinalizedMelt, Error>

Confirm the prepared melt and execute the payment.

This method waits for the payment to complete and returns the finalized melt. If the mint supports async payments (NUT-05), this may complete faster by not blocking on the payment processing.

Example

use cdk::nuts::PaymentMethod;

let quote = wallet
    .melt_quote(PaymentMethod::BOLT11, "lnbc...", None, None)
    .await?;

// Prepare the melt
let prepared = wallet.prepare_melt(&quote.id, HashMap::new()).await?;

// Confirm and wait for completion
let finalized = prepared.confirm().await?;

println!(
    "Melt completed: state={:?}, amount={}, fee_paid={}",
    finalized.state(),
    finalized.amount(),
    finalized.fee_paid()
);

pub async fn confirm_with_options( self, options: MeltConfirmOptions, ) -> Result<FinalizedMelt, Error>

Confirm the prepared melt with custom options.

This method waits for the payment to complete and returns the finalized melt. If the mint supports async payments (NUT-05), this may complete faster by not blocking on the payment processing.

pub async fn confirm_prefer_async(self) -> Result<MeltOutcome<'a>, Error>

Confirm the prepared melt using async support (NUT-05).

Sends the melt request with a Prefer: respond-async header and waits for the mint’s response. Returns Paid if the payment completed immediately, or Pending if the mint accepted the async request and will process it in the background.

Note: This waits for the mint’s initial response, which may block if the mint does not support async payments. Only returns Pending if the mint explicitly supports and accepts async melt requests.

Example

use std::collections::HashMap;

use cdk::nuts::PaymentMethod;
use cdk::wallet::MeltOutcome;

let quote = wallet
    .melt_quote(PaymentMethod::BOLT11, "lnbc...", None, None)
    .await?;

// Prepare the melt
let prepared = wallet.prepare_melt(&quote.id, HashMap::new()).await?;

// Confirm with async preference
match prepared.confirm_prefer_async().await? {
    MeltOutcome::Paid(finalized) => {
        println!(
            "Melt completed immediately: state={:?}, amount={}, fee_paid={}",
            finalized.state(),
            finalized.amount(),
            finalized.fee_paid()
        );
    }
    MeltOutcome::Pending(pending) => {
        // You can await the pending melt directly
        let finalized = pending.await?;
        println!(
            "Melt completed after waiting: state={:?}, amount={}, fee_paid={}",
            finalized.state(),
            finalized.amount(),
            finalized.fee_paid()
        );

        // Alternative: Instead of awaiting, you could:
        // 1. Store the quote ID and check status later with:
        //    wallet.check_melt_quote_status(&quote.id).await?
        // 2. Let the wallet's background task handle it via:
        //    wallet.finalize_pending_melts().await?
    }
}

pub async fn confirm_prefer_async_with_options( self, options: MeltConfirmOptions, ) -> Result<MeltOutcome<'a>, Error>

Confirm with async support and custom options.

Sends the melt request with a Prefer: respond-async header and waits for the mint’s response. Returns Paid if the payment completed immediately, or Pending if the mint accepted the async request and will process it in the background.

Note: This waits for the mint’s initial response, which may block if the mint does not support async payments. Only returns Pending if the mint explicitly supports and accepts async melt requests.

pub async fn cancel(self) -> Result<(), Error>

Cancel the prepared melt and release reserved proofs

Trait Implementations

impl Debug for PreparedMelt<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.