Support initiating an async payment to a static invoice.

Supported when the sender is an always-online node. Often-offline senders will
need to lock in their HTLC(s) with their always-online channel counterparty and
modify the held_htlc_available reply path to terminate at said counterparty.

Author: valentinewallace

lightning/src/ln/channelmanager.rs

@@ -69,6 +69,8 @@ use crate::offers::offer::{Offer, OfferBuilder};
 use crate::offers::parse::Bolt12SemanticError;
 use crate::offers::refund::{Refund, RefundBuilder};
 use crate::onion_message::async_payments::{AsyncPaymentsMessage, HeldHtlcAvailable, ReleaseHeldHtlc, AsyncPaymentsMessageHandler};
+#[cfg(async_payments)]
+use crate::offers::static_invoice::StaticInvoice;
 use crate::onion_message::messenger::{new_pending_onion_message, Destination, MessageRouter, PendingOnionMessage, Responder, ResponseInstruction};
 use crate::onion_message::offers::{OffersMessage, OffersMessageHandler};
 use crate::sign::{EntropySource, NodeSigner, Recipient, SignerProvider};
@@ -4251,6 +4253,37 @@ where
 			)
 	}
 
+	#[cfg(async_payments)]
+	fn initiate_async_payment(
+		&self, invoice: &StaticInvoice, payment_id: PaymentId
+	) -> Result<(), Bolt12PaymentError> {
+		let reply_paths = self.create_blinded_paths(
+			MessageContext::AsyncPayments(AsyncPaymentsContext::OutboundPayment { payment_id })
+		).map_err(|_| Bolt12PaymentError::BlindedPathNotFound)?;
+
+		let payment_release_secret = self.pending_outbound_payments.static_invoice_received(
+			invoice, payment_id, &*self.entropy_source
+		)?;
+		let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(self);
+
+		let mut pending_async_payments_messages = self.pending_async_payments_messages.lock().unwrap();
+		const HTLC_AVAILABLE_LIMIT: usize = 10;
+		reply_paths
+			.iter()
+			.flat_map(|reply_path| invoice.message_paths().iter().map(move |invoice_path| (invoice_path, reply_path)))
+			.take(HTLC_AVAILABLE_LIMIT)
+			.for_each(|(invoice_path, reply_path)| {
+				let message = new_pending_onion_message(
+					AsyncPaymentsMessage::HeldHtlcAvailable(HeldHtlcAvailable { payment_release_secret }),
+					Destination::BlindedPath(invoice_path.clone()),
+					Some(reply_path.clone()),
+				);
+				pending_async_payments_messages.push(message);
+			});
+
+		Ok(())
+	}
+
 	/// Signals that no further attempts for the given payment should occur. Useful if you have a
 	/// pending outbound payment with retries remaining, but wish to stop retrying the payment before
 	/// retries are exhausted.
@@ -10878,15 +10911,15 @@ where
 				}
 			},
 			#[cfg(async_payments)]
-			OffersMessage::StaticInvoice(_invoice) => {
-				match responder {
-					Some(responder) => {
-						responder.respond(OffersMessage::InvoiceError(
-								InvoiceError::from_string("Static invoices not yet supported".to_string())
-						))
-					},
-					None => return ResponseInstruction::NoResponse,
+			OffersMessage::StaticInvoice(invoice) => {
+				let payment_id = match context {
+					OffersContext::OutboundPayment { payment_id, nonce: _ } => payment_id,
+					_ => return ResponseInstruction::NoResponse
+				};
+				if let Err(e) = self.initiate_async_payment(&invoice, payment_id) {
+					log_trace!(self.logger, "Failed to initiate async payment to static invoice: {:?}", e);
 				}
+				ResponseInstruction::NoResponse
 			},
 			OffersMessage::InvoiceError(invoice_error) => {
 				abandon_if_payment(context);
@@ -10922,7 +10955,7 @@ where
 	fn release_held_htlc(&self, _message: ReleaseHeldHtlc, _context: AsyncPaymentsContext) {}
 
 	fn release_pending_messages(&self) -> Vec<PendingOnionMessage<AsyncPaymentsMessage>> {
-		Vec::new()
+		core::mem::take(&mut self.pending_async_payments_messages.lock().unwrap())
 	}
 }
 

lightning/src/ln/outbound_payment.rs

@@ -23,6 +23,8 @@ use crate::ln::onion_utils;
 use crate::ln::onion_utils::{DecodedOnionFailure, HTLCFailReason};
 use crate::offers::invoice::Bolt12Invoice;
 use crate::offers::invoice_request::InvoiceRequest;
+#[cfg(async_payments)]
+use crate::offers::static_invoice::StaticInvoice;
 use crate::routing::router::{BlindedTail, InFlightHtlcs, Path, PaymentParameters, Route, RouteParameters, Router};
 use crate::sign::{EntropySource, NodeSigner, Recipient};
 use crate::util::errors::APIError;
@@ -529,6 +531,10 @@ pub enum Bolt12PaymentError {
 	///
 	/// [`BlindedPath`]: crate::blinded_path::BlindedPath
 	OnionPacketSizeExceeded,
+	/// Failed to create a [`BlindedPath`] back to ourselves.
+	///
+	/// [`BlindedPath`]: crate::blinded_path::BlindedPath
+	BlindedPathNotFound,
 }
 
 /// Indicates that we failed to send a payment probe. Further errors may be surfaced later via
@@ -878,6 +884,38 @@ impl OutboundPayments {
 		Ok(())
 	}
 
+	#[cfg(async_payments)]
+	pub(super) fn static_invoice_received<ES: Deref>(
+		&self, invoice: &StaticInvoice, payment_id: PaymentId, entropy_source: ES
+	) -> Result<[u8; 32], Bolt12PaymentError> where ES::Target: EntropySource {
+		match self.pending_outbound_payments.lock().unwrap().entry(payment_id) {
+			hash_map::Entry::Occupied(entry) => match entry.get() {
+				PendingOutboundPayment::AwaitingInvoice { retry_strategy, invoice_request, .. } => {
+					let invreq = invoice_request.as_ref().ok_or(Bolt12PaymentError::UnexpectedInvoice)?;
+					if !invoice.from_same_offer(invreq) {
+						return Err(Bolt12PaymentError::UnexpectedInvoice)
+					}
+					let amount_msat = invreq.amount_msats().ok_or(Bolt12PaymentError::UnexpectedInvoice)?;
+					let keysend_preimage = PaymentPreimage(entropy_source.get_secure_random_bytes());
+					let payment_hash = PaymentHash(Sha256::hash(&keysend_preimage.0).to_byte_array());
+					let payment_release_secret = entropy_source.get_secure_random_bytes();
+					let pay_params = PaymentParameters::from_static_invoice(invoice);
+					let route_params = RouteParameters::from_payment_params_and_value(pay_params, amount_msat);
+					*entry.into_mut() = PendingOutboundPayment::StaticInvoiceReceived {
+						payment_hash,
+						keysend_preimage,
+						retry_strategy: *retry_strategy,
+						payment_release_secret,
+						route_params,
+					};
+					return Ok(payment_release_secret)
+				},
+				_ => return Err(Bolt12PaymentError::DuplicateInvoice),
+			},
+			hash_map::Entry::Vacant(_) => return Err(Bolt12PaymentError::UnexpectedInvoice),
+		};
+	}
+
 	pub(super) fn check_retry_payments<R: Deref, ES: Deref, NS: Deref, SP, IH, FH, L: Deref>(
 		&self, router: &R, first_hops: FH, inflight_htlcs: IH, entropy_source: &ES, node_signer: &NS,
 		best_block_height: u32,