Parse blinded Trampoline forward payloads

We will be using the same logic for decoding onion payloads for outer
and for Trampoline onions. To accommodate some Trampoline-only payloads,
we add the ability to parse blinded forward payloads that carry a next
node ID rather than an SCID.

Author: arik-so

lightning/src/blinded_path/payment.rs

@@ -297,6 +297,25 @@ pub struct ForwardTlvs {
 	pub next_blinding_override: Option<PublicKey>,
 }
 
+/// Data to construct a [`BlindedHop`] for forwarding a Trampoline payment.
+#[derive(Clone, Debug)]
+pub struct TrampolineForwardTlvs {
+	/// The node id to which the trampoline node must find a route.
+	pub outgoing_node_id: NodeId,
+	/// Payment parameters for relaying over [`Self::outgoing_node_id`].
+	pub payment_relay: PaymentRelay,
+	/// Payment constraints for relaying over [`Self::outgoing_node_id`].
+	pub payment_constraints: PaymentConstraints,
+	/// Supported and required features when relaying a payment onion containing this object's
+	/// corresponding [`BlindedHop::encrypted_payload`].
+	///
+	/// [`BlindedHop::encrypted_payload`]: crate::blinded_path::BlindedHop::encrypted_payload
+	pub features: BlindedHopFeatures,
+	/// Set if this [`BlindedPaymentPath`] is concatenated to another, to indicate the
+	/// [`BlindedPaymentPath::blinding_point`] of the appended blinded path.
+	pub next_blinding_override: Option<PublicKey>,
+}
+
 /// Data to construct a [`BlindedHop`] for receiving a payment. This payload is custom to LDK and
 /// may not be valid if received by another lightning implementation.
 ///
@@ -344,6 +363,9 @@ impl UnauthenticatedReceiveTlvs {
 pub(crate) enum BlindedPaymentTlvs {
 	/// This blinded payment data is for a forwarding node.
 	Forward(ForwardTlvs),
+	/// This blinded payment data is for a forwarding Trampoline node.
+	#[allow(unused)]
+	TrampolineForward(TrampolineForwardTlvs),
 	/// This blinded payment data is for the receiving node.
 	Receive(ReceiveTlvs),
 }

lightning/src/ln/msgs.rs

@@ -31,7 +31,7 @@ use bitcoin::{secp256k1, Witness};
 use bitcoin::script::ScriptBuf;
 use bitcoin::hash_types::Txid;
 
-use crate::blinded_path::payment::{BlindedPaymentTlvs, ForwardTlvs, ReceiveTlvs, UnauthenticatedReceiveTlvs};
+use crate::blinded_path::payment::{BlindedPaymentTlvs, ForwardTlvs, ReceiveTlvs, TrampolineForwardTlvs, UnauthenticatedReceiveTlvs};
 use crate::ln::channelmanager::Verification;
 use crate::ln::types::ChannelId;
 use crate::types::payment::{PaymentPreimage, PaymentHash, PaymentSecret};
@@ -1844,6 +1844,17 @@ mod fuzzy_internal_msgs {
 		pub intro_node_blinding_point: Option<PublicKey>,
 		pub next_blinding_override: Option<PublicKey>,
 	}
+
+	#[allow(unused)]
+	pub struct InboundTrampolineBlindedForwardPayload {
+		pub outgoing_node_id: NodeId,
+		pub payment_relay: PaymentRelay,
+		pub payment_constraints: PaymentConstraints,
+		pub features: BlindedHopFeatures,
+		pub intro_node_blinding_point: Option<PublicKey>,
+		pub next_blinding_override: Option<PublicKey>,
+	}
+
 	pub struct InboundOnionBlindedReceivePayload {
 		pub sender_intended_htlc_amt_msat: u64,
 		pub total_msat: u64,
@@ -1868,6 +1879,8 @@ mod fuzzy_internal_msgs {
 		// These payloads should be seen inside an inner Trampoline onion
 		#[allow(unused)]
 		TrampolineForward(InboundTrampolineForwardPayload),
+		#[allow(unused)]
+		TrampolineBlindedForward(InboundTrampolineBlindedForwardPayload),
 	}
 
 	pub(crate) enum OutboundOnionPayload<'a> {
@@ -3028,6 +3041,23 @@ impl<NS: Deref> ReadableArgs<(Option<PublicKey>, NS)> for InboundOnionPayload wh
 						next_blinding_override,
 					}))
 				},
+				ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::TrampolineForward(TrampolineForwardTlvs {
+					outgoing_node_id, payment_relay, payment_constraints, features, next_blinding_override
+				})} => {
+					if amt.is_some() || cltv_value.is_some() || total_msat.is_some() ||
+						keysend_preimage.is_some() || invoice_request.is_some()
+					{
+						return Err(DecodeError::InvalidValue)
+					}
+					Ok(Self::TrampolineBlindedForward(InboundTrampolineBlindedForwardPayload {
+						outgoing_node_id,
+						payment_relay,
+						payment_constraints,
+						features,
+						intro_node_blinding_point,
+						next_blinding_override,
+					}))
+				},
 				ChaChaPolyReadAdapter { readable: BlindedPaymentTlvs::Receive(receive_tlvs) } => {
 					let ReceiveTlvs { tlvs, authentication: (hmac, nonce) } = receive_tlvs;
 					let expanded_key = node_signer.get_inbound_payment_key();