Construct Trampoline onion from path.

fuzz/src/chanmon_consistency.rs

@@ -396,7 +396,7 @@ fn send_payment(source: &ChanMan, dest: &ChanMan, dest_chan_id: u64, amt: u64, p
 			fee_msat: amt,
 			cltv_expiry_delta: 200,
 			maybe_announced_channel: true,
-		}], blinded_tail: None }],
+		}], trampoline_hops: vec![], blinded_tail: None }],
 		route_params: None,
 	}, payment_hash, RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_id)) {
 		check_payment_err(err, amt > max_value_sendable || amt < min_value_sendable);
@@ -439,7 +439,7 @@ fn send_hop_payment(source: &ChanMan, middle: &ChanMan, middle_chan_id: u64, des
 			fee_msat: amt,
 			cltv_expiry_delta: 200,
 			maybe_announced_channel: true,
-		}], blinded_tail: None }],
+		}], trampoline_hops: vec![], blinded_tail: None }],
 		route_params: None,
 	}, payment_hash, RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_id)) {
 		let sent_amt = amt + first_hop_fee;

lightning-background-processor/src/lib.rs

@@ -1776,7 +1776,7 @@ mod tests {
 				fee_msat: 0,
 				cltv_expiry_delta: MIN_CLTV_EXPIRY_DELTA as u32,
 				maybe_announced_channel: true,
-			}], blinded_tail: None };
+			}], trampoline_hops: vec![], blinded_tail: None };
 
 			$nodes[0].scorer.write_lock().expect(TestResult::PaymentFailure { path: path.clone(), short_channel_id: scored_scid });
 			$nodes[0].node.push_pending_event(Event::PaymentPathFailed {

lightning/src/events/mod.rs

@@ -1402,7 +1402,7 @@ impl MaybeReadable for Event {
 						payment_hash,
 						payment_failed_permanently,
 						failure,
-						path: Path { hops: path.unwrap(), blinded_tail },
+						path: Path { hops: path.unwrap(), trampoline_hops: vec![], blinded_tail },
 						short_channel_id,
 						#[cfg(test)]
 						error_code,
@@ -1530,7 +1530,7 @@ impl MaybeReadable for Event {
 					Ok(Some(Event::PaymentPathSuccessful {
 						payment_id: payment_id.0.unwrap(),
 						payment_hash,
-						path: Path { hops: path, blinded_tail },
+						path: Path { hops: path, trampoline_hops: vec![], blinded_tail },
 					}))
 				};
 				f()
@@ -1595,7 +1595,7 @@ impl MaybeReadable for Event {
 					Ok(Some(Event::ProbeSuccessful {
 						payment_id: payment_id.0.unwrap(),
 						payment_hash: payment_hash.0.unwrap(),
-						path: Path { hops: path, blinded_tail },
+						path: Path { hops: path, trampoline_hops: vec![], blinded_tail },
 					}))
 				};
 				f()
@@ -1612,7 +1612,7 @@ impl MaybeReadable for Event {
 					Ok(Some(Event::ProbeFailed {
 						payment_id: payment_id.0.unwrap(),
 						payment_hash: payment_hash.0.unwrap(),
-						path: Path { hops: path, blinded_tail },
+						path: Path { hops: path, trampoline_hops: vec![], blinded_tail },
 						short_channel_id,
 					}))
 				};

lightning/src/ln/channel.rs

@@ -9531,7 +9531,7 @@ mod tests {
 			cltv_expiry: 200000000,
 			state: OutboundHTLCState::Committed,
 			source: HTLCSource::OutboundRoute {
-				path: Path { hops: Vec::new(), blinded_tail: None },
+				path: Path { hops: Vec::new(), trampoline_hops: vec![], blinded_tail: None },
 				session_priv: SecretKey::from_slice(&<Vec<u8>>::from_hex("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap(),
 				first_hop_htlc_msat: 548,
 				payment_id: PaymentId([42; 32]),
@@ -9905,6 +9905,7 @@ mod tests {
 					node_features: NodeFeatures::empty(), short_channel_id: 0, fee_msat: 0,
 					cltv_expiry_delta: 0, maybe_announced_channel: false,
 				}],
+				trampoline_hops: vec![],
 				blinded_tail: None
 			},
 			session_priv: test_utils::privkey(42),

lightning/src/ln/channelmanager.rs

@@ -506,7 +506,7 @@ impl HTLCSource {
 	#[cfg(test)]
 	pub fn dummy() -> Self {
 		HTLCSource::OutboundRoute {
-			path: Path { hops: Vec::new(), blinded_tail: None },
+			path: Path { hops: Vec::new(), trampoline_hops: Vec::new(), blinded_tail: None },
 			session_priv: SecretKey::from_slice(&[1; 32]).unwrap(),
 			first_hop_htlc_msat: 0,
 			payment_id: PaymentId([2; 32]),
@@ -10881,7 +10881,7 @@ impl Readable for HTLCSource {
 					// instead.
 					payment_id = Some(PaymentId(*session_priv.0.unwrap().as_ref()));
 				}
-				let path = Path { hops: path_hops, blinded_tail };
+				let path = Path { hops: path_hops, trampoline_hops: vec![], blinded_tail };
 				if path.hops.len() == 0 {
 					return Err(DecodeError::InvalidValue);
 				}

lightning/src/ln/functional_tests.rs

@@ -1058,7 +1058,7 @@ fn fake_network_test() {
 	hops[1].fee_msat = chan_4.1.contents.fee_base_msat as u64 + chan_4.1.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000;
 	hops[0].fee_msat = chan_3.0.contents.fee_base_msat as u64 + chan_3.0.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000;
 	let payment_preimage_1 = send_along_route(&nodes[1],
-		Route { paths: vec![Path { hops, blinded_tail: None }], route_params: None },
+		Route { paths: vec![Path { hops, trampoline_hops: vec![], blinded_tail: None }], route_params: None },
 			&vec!(&nodes[2], &nodes[3], &nodes[1])[..], 1000000).0;
 
 	let mut hops = Vec::with_capacity(3);
@@ -1092,7 +1092,7 @@ fn fake_network_test() {
 	hops[1].fee_msat = chan_2.1.contents.fee_base_msat as u64 + chan_2.1.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000;
 	hops[0].fee_msat = chan_3.1.contents.fee_base_msat as u64 + chan_3.1.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000;
 	let payment_hash_2 = send_along_route(&nodes[1],
-		Route { paths: vec![Path { hops, blinded_tail: None }], route_params: None },
+		Route { paths: vec![Path { hops, trampoline_hops: vec![], blinded_tail: None }], route_params: None },
 			&vec!(&nodes[3], &nodes[2], &nodes[1])[..], 1000000).1;
 
 	// Claim the rebalances...

lightning/src/ln/msgs.rs

@@ -41,6 +41,7 @@ use crate::sign::{NodeSigner, Recipient};
 #[allow(unused_imports)]
 use crate::prelude::*;
 
+use core::cmp;
 use core::fmt;
 use core::fmt::Debug;
 use core::ops::Deref;
@@ -55,7 +56,7 @@ use crate::io_extras::read_to_end;
 use crate::events::{EventsProvider, MessageSendEventsProvider};
 use crate::crypto::streams::ChaChaPolyReadAdapter;
 use crate::util::logger;
-use crate::util::ser::{LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer, WithoutLength, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, TransactionU16LenLimited, BigSize};
+use crate::util::ser::{BigSize, FixedLengthReader, HighZeroBytesDroppedBigSize, Hostname, LengthRead, LengthReadable, LengthReadableArgs, Readable, ReadableArgs, TransactionU16LenLimited, WithoutLength, Writeable, Writer};
 use crate::util::base32;
 
 use crate::routing::gossip::{NodeAlias, NodeId};
@@ -1767,6 +1768,21 @@ mod fuzzy_internal_msgs {
 			outgoing_cltv_value: u32,
 			/// The node id to which the trampoline node must find a route
 			outgoing_node_id: PublicKey,
+		},
+		#[allow(unused)]
+		BlindedForward {
+			encrypted_tlvs: Vec<u8>,
+			intro_node_blinding_point: Option<PublicKey>,
+		},
+		#[allow(unused)]
+		BlindedReceive {
+			sender_intended_htlc_amt_msat: u64,
+			total_msat: u64,
+			cltv_expiry_height: u32,
+			encrypted_tlvs: Vec<u8>,
+			intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
+			keysend_preimage: Option<PaymentPreimage>,
+			custom_tlvs: Vec<(u64, Vec<u8>)>,
 		}
 	}
 
@@ -1856,6 +1872,34 @@ impl Writeable for TrampolineOnionPacket {
 	}
 }
 
+impl LengthReadable for TrampolineOnionPacket {
+	fn read<R: LengthRead>(r: &mut R) -> Result<Self, DecodeError> {
+		const READ_BUFFER_SIZE: usize = 4096;
+
+		let version = Readable::read(r)?;
+		let public_key = Readable::read(r)?;
+
+		let mut hop_data = Vec::new();
+		let hop_data_len = r.total_bytes().saturating_sub(66) as usize; // 1 (version) + 33 (pubkey) + 32 (HMAC) = 66
+		let mut read_idx = 0;
+		while read_idx < hop_data_len {
+			let mut read_buffer = [0; READ_BUFFER_SIZE];
+			let read_amt = cmp::min(hop_data_len - read_idx, READ_BUFFER_SIZE);
+			r.read_exact(&mut read_buffer[..read_amt])?;
+			hop_data.extend_from_slice(&read_buffer[..read_amt]);
+			read_idx += read_amt;
+		}
+
+		let hmac = Readable::read(r)?;
+		Ok(TrampolineOnionPacket {
+			version,
+			public_key,
+			hop_data,
+			hmac,
+		})
+	}
+}
+
 impl Debug for TrampolineOnionPacket {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		f.write_fmt(format_args!("TrampolineOnionPacket version {} with hmac {:?}", self.version, &self.hmac[..]))
@@ -2644,7 +2688,31 @@ impl Writeable for OutboundTrampolinePayload {
 					(4, HighZeroBytesDroppedBigSize(*outgoing_cltv_value), required),
 					(14, outgoing_node_id, required)
 				});
-			}
+			},
+			Self::BlindedForward { encrypted_tlvs, intro_node_blinding_point } => {
+				_encode_varint_length_prefixed_tlv!(w, {
+					(10, *encrypted_tlvs, required_vec),
+					(12, intro_node_blinding_point, option)
+				});
+			},
+			Self::BlindedReceive {
+				sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
+				intro_node_blinding_point, keysend_preimage, ref custom_tlvs,
+			} => {
+				// We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
+				// to reject any reserved types in the experimental range if new ones are ever
+				// standardized.
+				let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
+				let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
+				custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
+				_encode_varint_length_prefixed_tlv!(w, {
+					(2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),
+					(4, HighZeroBytesDroppedBigSize(*cltv_expiry_height), required),
+					(10, *encrypted_tlvs, required_vec),
+					(12, intro_node_blinding_point, option),
+					(18, HighZeroBytesDroppedBigSize(*total_msat), required)
+				}, custom_tlvs.iter());
+			},
 		}
 		Ok(())
 	}
@@ -3180,7 +3248,7 @@ mod tests {
 	use crate::ln::msgs::{self, FinalOnionHopData, OnionErrorPacket, CommonOpenChannelFields, CommonAcceptChannelFields, TrampolineOnionPacket};
 	use crate::ln::msgs::SocketAddress;
 	use crate::routing::gossip::{NodeAlias, NodeId};
-	use crate::util::ser::{BigSize, Hostname, Readable, ReadableArgs, TransactionU16LenLimited, Writeable};
+	use crate::util::ser::{BigSize, FixedLengthReader, Hostname, LengthReadable, Readable, ReadableArgs, TransactionU16LenLimited, Writeable};
 	use crate::util::test_utils;
 
 	use bitcoin::hashes::hex::FromHex;
@@ -4496,6 +4564,13 @@ mod tests {
 		let encoded_trampoline_packet = trampoline_packet.encode();
 		assert_eq!(encoded_trampoline_packet.len(), 716);
 
+		{ // verify that a codec round trip works
+			let mut reader = Cursor::new(&encoded_trampoline_packet);
+			let mut trampoline_packet_reader = FixedLengthReader::new(&mut reader, encoded_trampoline_packet.len() as u64);
+			let decoded_trampoline_packet: TrampolineOnionPacket = <TrampolineOnionPacket as LengthReadable>::read(&mut trampoline_packet_reader).unwrap();
+			assert_eq!(decoded_trampoline_packet.encode(), encoded_trampoline_packet);
+		}
+
 		let msg = msgs::OutboundOnionPayload::TrampolineEntrypoint {
 			multipath_trampoline_data: None,
 			amt_to_forward: 0x0badf00d01020304,

lightning/src/ln/onion_payment.rs

@@ -532,7 +532,7 @@ mod tests {
 		// Ensure the onion will not fit all the payloads by adding a large custom TLV.
 		recipient_onion.custom_tlvs.push((13377331, vec![0; 1156]));
 
-		let path = Path { hops, blinded_tail: None, };
+		let path = Path { hops, trampoline_hops: vec![], blinded_tail: None, };
 		let onion_keys = super::onion_utils::construct_onion_keys(&secp_ctx, &path, &session_priv).unwrap();
 		let (onion_payloads, ..) = super::onion_utils::build_onion_payloads(
 			&path, total_amt_msat, recipient_onion, cur_height + 1, &Some(keysend_preimage)
@@ -558,6 +558,7 @@ mod tests {
 
 		let path = Path {
 			hops: hops,
+			trampoline_hops: vec![],
 			blinded_tail: None,
 		};