Support creating reply_path for HeldHtlcAvailable

As part of supporting sending payments as an often-offline sender, the sender
needs to send held_htlc_available onion messages such that the reply path to
the message terminates at their always-online channel counterparty that is
holding the HTLC. That way when the recipient responds with release_held_htlc,
the sender's counterparty will receive that message.

Here we add a method for creating said reply path, which will be used in the
next commit.

Author: valentinewallace

lightning/src/blinded_path/message.rs

@@ -19,7 +19,7 @@ use crate::blinded_path::{BlindedHop, BlindedPath, Direction, IntroductionNode,
 use crate::crypto::streams::ChaChaPolyReadAdapter;
 use crate::io;
 use crate::io::Cursor;
-use crate::ln::channelmanager::PaymentId;
+use crate::ln::channelmanager::{InterceptId, PaymentId};
 use crate::ln::msgs::DecodeError;
 use crate::ln::onion_utils;
 use crate::offers::nonce::Nonce;
@@ -556,7 +556,7 @@ pub enum AsyncPaymentsContext {
 	},
 	/// Context contained within the reply [`BlindedMessagePath`] we put in outbound
 	/// [`HeldHtlcAvailable`] messages, provided back to us in corresponding [`ReleaseHeldHtlc`]
-	/// messages.
+	/// messages if we are an always-online sender paying an async recipient.
 	///
 	/// [`HeldHtlcAvailable`]: crate::onion_message::async_payments::HeldHtlcAvailable
 	/// [`ReleaseHeldHtlc`]: crate::onion_message::async_payments::ReleaseHeldHtlc
@@ -577,6 +577,17 @@ pub enum AsyncPaymentsContext {
 		/// able to trivially ask if we're online forever.
 		path_absolute_expiry: core::time::Duration,
 	},
+	/// Context contained within the reply [`BlindedMessagePath`] put in outbound
+	/// [`HeldHtlcAvailable`] messages, provided back to the async sender's always-online counterparty
+	/// in corresponding [`ReleaseHeldHtlc`] messages.
+	///
+	/// [`HeldHtlcAvailable`]: crate::onion_message::async_payments::HeldHtlcAvailable
+	/// [`ReleaseHeldHtlc`]: crate::onion_message::async_payments::ReleaseHeldHtlc
+	ReleaseHeldHtlc {
+		/// An identifier for the HTLC that should be released by us as the sender's always-online
+		/// channel counterparty to the often-offline recipient.
+		intercept_id: InterceptId,
+	},
 }
 
 impl_writeable_tlv_based_enum!(MessageContext,
@@ -632,6 +643,9 @@ impl_writeable_tlv_based_enum!(AsyncPaymentsContext,
 		(2, invoice_slot, required),
 		(4, path_absolute_expiry, required),
 	},
+	(6, ReleaseHeldHtlc) => {
+		(0, intercept_id, required),
+	},
 );
 
 /// Contains a simple nonce for use in a blinded path's context.

lightning/src/ln/channelmanager.rs

@@ -5450,6 +5450,18 @@ where
 		res
 	}
 
+	/// If we are holding an HTLC on behalf of an often-offline sender, this method allows us to
+	/// create a path for the sender to use as the reply path when they send the recipient a
+	/// [`HeldHtlcAvailable`] onion message, so the recipient's [`ReleaseHeldHtlc`] response will be
+	/// received to our node.
+	fn path_for_release_held_htlc(
+		&self, htlc_id: u64, channel_id: &ChannelId, counterparty_node_id: &PublicKey,
+	) -> BlindedMessagePath {
+		let intercept_id =
+			InterceptId::from_htlc_id_and_chan_id(htlc_id, channel_id, counterparty_node_id);
+		self.flow.path_for_release_held_htlc(intercept_id, &*self.entropy_source)
+	}
+
 	/// 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.

lightning/src/offers/flow.rs

@@ -32,7 +32,7 @@ use crate::prelude::*;
 
 use crate::chain::BestBlock;
 use crate::ln::channel_state::ChannelDetails;
-use crate::ln::channelmanager::{PaymentId, CLTV_FAR_FAR_AWAY};
+use crate::ln::channelmanager::{InterceptId, PaymentId, CLTV_FAR_FAR_AWAY};
 use crate::ln::inbound_payment;
 use crate::offers::async_receive_offer_cache::AsyncReceiveOfferCache;
 use crate::offers::invoice::{
@@ -52,7 +52,7 @@ use crate::onion_message::async_payments::{
 	StaticInvoicePersisted,
 };
 use crate::onion_message::messenger::{
-	Destination, MessageRouter, MessageSendInstructions, Responder,
+	Destination, MessageRouter, MessageSendInstructions, Responder, PADDED_PATH_LENGTH,
 };
 use crate::onion_message::offers::OffersMessage;
 use crate::onion_message::packet::OnionMessageContents;
@@ -1158,6 +1158,41 @@ where
 		Ok(())
 	}
 
+	/// If we are holding an HTLC on behalf of an often-offline sender, this method allows us to
+	/// create a path for the sender to use as the reply path when they send the recipient a
+	/// [`HeldHtlcAvailable`] onion message, so the recipient's [`ReleaseHeldHtlc`] response will be
+	/// received to our node.
+	///
+	/// [`ReleaseHeldHtlc`]: crate::onion_message::async_payments::ReleaseHeldHtlc
+	pub fn path_for_release_held_htlc<ES: Deref>(
+		&self, intercept_id: InterceptId, entropy: ES,
+	) -> BlindedMessagePath
+	where
+		ES::Target: EntropySource,
+	{
+		let peers = self.peers_cache.lock().unwrap().iter().map(|(peer, _)| *peer).collect();
+		let context =
+			MessageContext::AsyncPayments(AsyncPaymentsContext::ReleaseHeldHtlc { intercept_id });
+		if let Ok(mut paths) = self.create_blinded_paths(peers, context.clone()) {
+			if let Some(path) = paths.pop() {
+				return path;
+			}
+		}
+
+		// If the `MessageRouter` fails on blinded path creation, fall back to creating a 1-hop blinded
+		// path.
+		let num_dummy_hops = PADDED_PATH_LENGTH.saturating_sub(1);
+		BlindedMessagePath::new_with_dummy_hops(
+			&[],
+			self.get_our_node_id(),
+			num_dummy_hops,
+			self.receive_auth_key,
+			context,
+			&*entropy,
+			&self.secp_ctx,
+		)
+	}
+
 	/// Enqueues the created [`DNSSECQuery`] to be sent to the counterparty.
 	///
 	/// # Peers