Wait for invoice to be paid

[thesimplekid]

Currently we don't have a nice fn on the wallet that will wait for an invoice to be paid. If you look at the examples we look checking for state. We should add a wallet fn that takes a mint quote and a time out and just waits until it is paid and mints once it is, erroring if it can't mint or times out

[crodas]

I think it would be best if a future is returned, and the caller decides how to wait on that event, either in that thread or in another thread. Do you think that would be better and more idiomatic?

let waiter = wallet.wait_for_payment(&quote.id, Duration::from_secs(10));

Alternatively we can add more enphasis in our subscription layer, perhaps adding a timeout factor, from this current code:

    // Subscribe to updates on the mint quote state
    let mut subscription = wallet
        .subscribe(WalletSubscription::Bolt11MintQuoteState(vec![quote
            .id
            .clone()]))
        .await;

    // Wait for the mint quote to be paid
    while let Some(msg) = subscription.recv().await {
        if let NotificationPayload::MintQuoteBolt11Response(response) = msg {
            if response.state == MintQuoteState::Paid {
                break;
            }
        }
    }

To this version

    // Subscribe to updates on the mint quote state
    let mut subscription = wallet
        .subscribe_with_timepit(WalletSubscription::Bolt11MintQuoteState(vec![quote
            .id
            .clone()]), Duration::from_secs(60) )
        .await;

    // Wait for the mint quote to be paid or an error will be thrown if the timeout is reached and *no* notification has been received
    while let Some(msg) = subscription.recv().await {
        if let NotificationPayload::MintQuoteBolt11Response(response) = msg {
            if response.state == MintQuoteState::Paid {
                break;
            }
        }
    }

The wallet notification will use websocket or http underneath.

[thesimplekid]

I think the future is a good idea. This way the flow of minting is simplely

let quote = wallet.mint_quote(amount, None).await?;

let waiter = wallet.wait_for_payment(&quote.id, Duration::from_secs(10));
let proofs = waiter.await?;

Compared to the current where you have to implement the waiting yourself and then call mint.

cdk/crates/cdk/examples/wallet.rs

Lines 29 to 58 in d24a968

	// Request a mint quote from the wallet
	let quote = wallet.mint_quote(amount, None).await?;
	println!("Pay request: {}", quote.request);
	// Check the quote state in a loop with a timeout
	let timeout = Duration::from_secs(60); // Set a timeout duration
	let start = std::time::Instant::now();
	loop {
	let status = wallet.mint_quote_state(&quote.id).await?;
	if status.state == MintQuoteState::Paid {
	break;
	}
	if start.elapsed() >= timeout {
	eprintln!("Timeout while waiting for mint quote to be paid");
	return Err("Timeout while waiting for mint quote to be paid".into());
	}
	println!("Quote state: {}", status.state);
	sleep(Duration::from_secs(5)).await;
	}
	// Mint the received amount
	let proofs = wallet.mint(&quote.id, SplitTarget::default(), None).await?;
	let receive_amount = proofs.total_amount()?;
	println!("Minted {}", receive_amount);