Support sending async payments as an always-online sender.

Async receive is not yet supported.

lightning/src/ln/channelmanager.rs

@@ -4161,6 +4161,21 @@ where
 		Ok(())
 	}
 
+	#[cfg(async_payments)]
+	fn send_payment_for_static_invoice(
+		&self, payment_id: PaymentId, payment_release_secret: [u8; 32]
+	) -> Result<(), Bolt12PaymentError> {
+		let best_block_height = self.best_block.read().unwrap().height;
+		let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(self);
+		self.pending_outbound_payments
+			.send_payment_for_static_invoice(
+				payment_id, payment_release_secret, &self.router, self.list_usable_channels(),
+				|| self.compute_inflight_htlcs(), &self.entropy_source, &self.node_signer,
+				best_block_height, &self.logger, &self.pending_events,
+				|args| self.send_payment_along_path(args)
+			)
+	}
+
 	/// 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.
@@ -10732,7 +10747,17 @@ where
 		ResponseInstruction::NoResponse
 	}
 
-	fn release_held_htlc(&self, _message: ReleaseHeldHtlc, _context: AsyncPaymentsContext) {}
+	fn release_held_htlc(&self, _message: ReleaseHeldHtlc, _context: AsyncPaymentsContext) {
+		#[cfg(async_payments)] {
+			let AsyncPaymentsContext::OutboundPayment { payment_id } = _context;
+			if let Err(e) = self.send_payment_for_static_invoice(payment_id, _message.payment_release_secret) {
+				log_trace!(
+					self.logger, "Failed to release held HTLC with payment id {} and release secret {:02x?}: {:?}",
+					payment_id, _message.payment_release_secret, e
+				);
+			}
+		}
+	}
 
 	fn release_pending_messages(&self) -> Vec<PendingOnionMessage<AsyncPaymentsMessage>> {
 		core::mem::take(&mut self.pending_async_payments_messages.lock().unwrap())

lightning/src/ln/outbound_payment.rs

@@ -912,6 +912,47 @@ impl OutboundPayments {
 		};
 	}
 
+	#[cfg(async_payments)]
+	pub(super) fn send_payment_for_static_invoice<R: Deref, ES: Deref, NS: Deref, IH, SP, L: Deref>(
+		&self, payment_id: PaymentId, payment_release_secret: [u8; 32], router: &R,
+		first_hops: Vec<ChannelDetails>, inflight_htlcs: IH, entropy_source: &ES, node_signer: &NS,
+		best_block_height: u32, logger: &L,
+		pending_events: &Mutex<VecDeque<(events::Event, Option<EventCompletionAction>)>>,
+		send_payment_along_path: SP,
+	) -> Result<(), Bolt12PaymentError>
+	where
+		R::Target: Router,
+		ES::Target: EntropySource,
+		NS::Target: NodeSigner,
+		L::Target: Logger,
+		IH: Fn() -> InFlightHtlcs,
+		SP: Fn(SendAlongPathArgs) -> Result<(), APIError>,
+	{
+		let (payment_hash, route_params) =
+			match self.pending_outbound_payments.lock().unwrap().entry(payment_id) {
+				hash_map::Entry::Occupied(entry) => match entry.get() {
+					PendingOutboundPayment::StaticInvoiceReceived {
+						payment_hash, payment_release_secret: release_secret, route_params, ..
+					} => {
+						if payment_release_secret != *release_secret {
+							return Err(Bolt12PaymentError::UnexpectedInvoice)
+						}
+						(*payment_hash, route_params.clone())
+					},
+					_ => return Err(Bolt12PaymentError::DuplicateInvoice),
+				},
+				hash_map::Entry::Vacant(_) => return Err(Bolt12PaymentError::UnexpectedInvoice),
+			};
+
+		self.find_route_and_send_payment(
+			payment_hash, payment_id, route_params, router, first_hops, &inflight_htlcs,
+			entropy_source, node_signer, best_block_height, logger, pending_events,
+			&send_payment_along_path
+		);
+
+		Ok(())
+	}
+
 	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,
@@ -1177,7 +1218,21 @@ impl OutboundPayments {
 							*payment.into_mut() = retryable_payment;
 							(total_amount, recipient_onion, None, onion_session_privs)
 						},
-						PendingOutboundPayment::StaticInvoiceReceived { .. } => todo!(),
+						PendingOutboundPayment::StaticInvoiceReceived {
+							payment_hash, keysend_preimage, retry_strategy, ..
+						} => {
+							let keysend_preimage = Some(*keysend_preimage);
+							let total_amount = route_params.final_value_msat;
+							let recipient_onion = RecipientOnionFields::spontaneous_empty();
+							let retry_strategy = Some(*retry_strategy);
+							let payment_params = Some(route_params.payment_params.clone());
+							let (retryable_payment, onion_session_privs) = self.create_pending_payment(
+								*payment_hash, recipient_onion.clone(), keysend_preimage, &route,
+								retry_strategy, payment_params, entropy_source, best_block_height
+							);
+							*payment.into_mut() = retryable_payment;
+							(total_amount, recipient_onion, keysend_preimage, onion_session_privs)
+						},
 						PendingOutboundPayment::Fulfilled { .. } => {
 							log_error!(logger, "Payment already completed");
 							return