Move BlindedPayInfo into BlindedPaymentPath.

Also removes the implementation of Writeable for BlindedPaymentPath, to ensure
callsites are explicit about what they're writing.

Author: valentinewallace

fuzz/src/chanmon_consistency.rs

@@ -56,7 +56,7 @@ use lightning::ln::msgs::{
 };
 use lightning::ln::script::ShutdownScript;
 use lightning::ln::types::{ChannelId, PaymentHash, PaymentPreimage, PaymentSecret};
-use lightning::offers::invoice::{BlindedPayInfo, UnsignedBolt12Invoice};
+use lightning::offers::invoice::UnsignedBolt12Invoice;
 use lightning::offers::invoice_request::UnsignedInvoiceRequest;
 use lightning::onion_message::messenger::{Destination, MessageRouter, OnionMessagePath};
 use lightning::routing::router::{InFlightHtlcs, Path, Route, RouteHop, RouteParameters, Router};
@@ -126,7 +126,7 @@ impl Router for FuzzRouter {
 	fn create_blinded_payment_paths<T: secp256k1::Signing + secp256k1::Verification>(
 		&self, _recipient: PublicKey, _first_hops: Vec<ChannelDetails>, _tlvs: ReceiveTlvs,
 		_amount_msats: u64, _secp_ctx: &Secp256k1<T>,
-	) -> Result<Vec<(BlindedPayInfo, BlindedPaymentPath)>, ()> {
+	) -> Result<Vec<BlindedPaymentPath>, ()> {
 		unreachable!()
 	}
 }

fuzz/src/full_stack.rs

@@ -49,7 +49,7 @@ use lightning::ln::peer_handler::{
 };
 use lightning::ln::script::ShutdownScript;
 use lightning::ln::types::{ChannelId, PaymentHash, PaymentPreimage, PaymentSecret};
-use lightning::offers::invoice::{BlindedPayInfo, UnsignedBolt12Invoice};
+use lightning::offers::invoice::UnsignedBolt12Invoice;
 use lightning::offers::invoice_request::UnsignedInvoiceRequest;
 use lightning::onion_message::messenger::{Destination, MessageRouter, OnionMessagePath};
 use lightning::routing::gossip::{NetworkGraph, P2PGossipSync};
@@ -163,7 +163,7 @@ impl Router for FuzzRouter {
 	fn create_blinded_payment_paths<T: secp256k1::Signing + secp256k1::Verification>(
 		&self, _recipient: PublicKey, _first_hops: Vec<ChannelDetails>, _tlvs: ReceiveTlvs,
 		_amount_msats: u64, _secp_ctx: &Secp256k1<T>,
-	) -> Result<Vec<(BlindedPayInfo, BlindedPaymentPath)>, ()> {
+	) -> Result<Vec<BlindedPaymentPath>, ()> {
 		unreachable!()
 	}
 }

fuzz/src/router.rs

@@ -381,7 +381,7 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 				let mut last_hops_unblinded = Vec::new();
 				last_hops!(last_hops_unblinded);
 				let dummy_pk = PublicKey::from_slice(&[2; 33]).unwrap();
-				let last_hops: Vec<(BlindedPayInfo, BlindedPaymentPath)> = last_hops_unblinded
+				let last_hops: Vec<BlindedPaymentPath> = last_hops_unblinded
 					.into_iter()
 					.map(|hint| {
 						let hop = &hint.0[0];
@@ -401,9 +401,11 @@ pub fn do_test<Out: test_logger::Output>(data: &[u8], out: Out) {
 								encrypted_payload: Vec::new(),
 							});
 						}
-						(
+						BlindedPaymentPath::from_raw(
+							hop.src_node_id,
+							dummy_pk,
+							blinded_hops,
 							payinfo,
-							BlindedPaymentPath::from_raw(hop.src_node_id, dummy_pk, blinded_hops),
 						)
 					})
 					.collect();

lightning/src/blinded_path/mod.rs

@@ -26,7 +26,7 @@ use crate::prelude::*;
 /// Onion messages and payments can be sent and received to blinded paths, which serve to hide the
 /// identity of the recipient.
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
-struct BlindedPath {
+pub(crate) struct BlindedPath {
 	/// To send to a blinded path, the sender first finds a route to the unblinded
 	/// `introduction_node`, which can unblind its [`encrypted_payload`] to find out the onion
 	/// message or payment's next hop and forward it along.

lightning/src/blinded_path/payment.rs

@@ -37,26 +37,18 @@ use crate::prelude::*;
 /// A blinded path to be used for sending or receiving a payment, hiding the identity of the
 /// recipient.
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub struct BlindedPaymentPath(pub(super) BlindedPath);
-
-impl Writeable for BlindedPaymentPath {
-	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
-		self.0.write(w)
-	}
-}
-
-impl Readable for BlindedPaymentPath {
-	fn read<R: io::Read>(r: &mut R) -> Result<Self, DecodeError> {
-		Ok(Self(BlindedPath::read(r)?))
-	}
+pub struct BlindedPaymentPath {
+	pub(super) inner_path: BlindedPath,
+	/// The [`BlindedPayInfo`] used to pay this blinded path.
+	pub payinfo: BlindedPayInfo,
 }
 
 impl BlindedPaymentPath {
 	/// Create a one-hop blinded path for a payment.
 	pub fn one_hop<ES: Deref, T: secp256k1::Signing + secp256k1::Verification>(
 		payee_node_id: PublicKey, payee_tlvs: ReceiveTlvs, min_final_cltv_expiry_delta: u16,
 		entropy_source: ES, secp_ctx: &Secp256k1<T>
-	) -> Result<(BlindedPayInfo, Self), ()> where ES::Target: EntropySource {
+	) -> Result<Self, ()> where ES::Target: EntropySource {
 		// This value is not considered in pathfinding for 1-hop blinded paths, because it's intended to
 		// be in relation to a specific channel.
 		let htlc_maximum_msat = u64::max_value();
@@ -77,7 +69,7 @@ impl BlindedPaymentPath {
 		intermediate_nodes: &[ForwardNode], payee_node_id: PublicKey, payee_tlvs: ReceiveTlvs,
 		htlc_maximum_msat: u64, min_final_cltv_expiry_delta: u16, entropy_source: ES,
 		secp_ctx: &Secp256k1<T>
-	) -> Result<(BlindedPayInfo, Self), ()> where ES::Target: EntropySource {
+	) -> Result<Self, ()> where ES::Target: EntropySource {
 		let introduction_node = IntroductionNode::NodeId(
 			intermediate_nodes.first().map_or(payee_node_id, |n| n.node_id)
 		);
@@ -87,38 +79,41 @@ impl BlindedPaymentPath {
 		let blinded_payinfo = compute_payinfo(
 			intermediate_nodes, &payee_tlvs, htlc_maximum_msat, min_final_cltv_expiry_delta
 		)?;
-		Ok((blinded_payinfo, Self(BlindedPath {
-			introduction_node,
-			blinding_point: PublicKey::from_secret_key(secp_ctx, &blinding_secret),
-			blinded_hops: blinded_hops(
-				secp_ctx, intermediate_nodes, payee_node_id, payee_tlvs, &blinding_secret
-			).map_err(|_| ())?,
-		})))
+		Ok(Self {
+			inner_path: BlindedPath {
+				introduction_node,
+				blinding_point: PublicKey::from_secret_key(secp_ctx, &blinding_secret),
+				blinded_hops: blinded_hops(
+					secp_ctx, intermediate_nodes, payee_node_id, payee_tlvs, &blinding_secret
+				).map_err(|_| ())?,
+			},
+			payinfo: blinded_payinfo
+		})
 	}
 
 	/// Returns the introduction [`NodeId`] of the blinded path, if it is publicly reachable (i.e.,
 	/// it is found in the network graph).
 	pub fn public_introduction_node_id<'a>(
 		&self, network_graph: &'a ReadOnlyNetworkGraph
 	) -> Option<&'a NodeId> {
-		self.0.public_introduction_node_id(network_graph)
+		self.inner_path.public_introduction_node_id(network_graph)
 	}
 
 	/// The [`IntroductionNode`] of the blinded path.
 	pub fn introduction_node(&self) -> &IntroductionNode {
-		&self.0.introduction_node
+		&self.inner_path.introduction_node
 	}
 
 	/// Used by the [`IntroductionNode`] to decrypt its [`encrypted_payload`] to forward the payment.
 	///
 	/// [`encrypted_payload`]: BlindedHop::encrypted_payload
 	pub fn blinding_point(&self) -> PublicKey {
-		self.0.blinding_point
+		self.inner_path.blinding_point
 	}
 
 	/// The [`BlindedHop`]s within the blinded path.
 	pub fn blinded_hops(&self) -> &[BlindedHop] {
-		&self.0.blinded_hops
+		&self.inner_path.blinded_hops
 	}
 
 	/// Advance the blinded onion payment path by one hop, making the second hop into the new
@@ -133,9 +128,9 @@ impl BlindedPaymentPath {
 		NL::Target: NodeIdLookUp,
 		T: secp256k1::Signing + secp256k1::Verification,
 	{
-		let control_tlvs_ss = node_signer.ecdh(Recipient::Node, &self.0.blinding_point, None)?;
+		let control_tlvs_ss = node_signer.ecdh(Recipient::Node, &self.inner_path.blinding_point, None)?;
 		let rho = onion_utils::gen_rho_from_shared_secret(&control_tlvs_ss.secret_bytes());
-		let encrypted_control_tlvs = &self.0.blinded_hops.get(0).ok_or(())?.encrypted_payload;
+		let encrypted_control_tlvs = &self.inner_path.blinded_hops.get(0).ok_or(())?.encrypted_payload;
 		let mut s = Cursor::new(encrypted_control_tlvs);
 		let mut reader = FixedLengthReader::new(&mut s, encrypted_control_tlvs.len() as u64);
 		match ChaChaPolyReadAdapter::read(&mut reader, rho) {
@@ -147,31 +142,43 @@ impl BlindedPaymentPath {
 					None => return Err(()),
 				};
 				let mut new_blinding_point = onion_utils::next_hop_pubkey(
-					secp_ctx, self.0.blinding_point, control_tlvs_ss.as_ref()
+					secp_ctx, self.inner_path.blinding_point, control_tlvs_ss.as_ref()
 				).map_err(|_| ())?;
-				mem::swap(&mut self.0.blinding_point, &mut new_blinding_point);
-				self.0.introduction_node = IntroductionNode::NodeId(next_node_id);
-				self.0.blinded_hops.remove(0);
+				mem::swap(&mut self.inner_path.blinding_point, &mut new_blinding_point);
+				self.inner_path.introduction_node = IntroductionNode::NodeId(next_node_id);
+				self.inner_path.blinded_hops.remove(0);
 				Ok(())
 			},
 			_ => Err(())
 		}
 	}
 
+	pub(crate) fn inner_blinded_path(&self) -> &BlindedPath {
+		&self.inner_path
+	}
+
+	pub(crate) fn from_parts(inner_path: BlindedPath, payinfo: BlindedPayInfo) -> Self {
+		Self { inner_path, payinfo }
+	}
+
 	#[cfg(any(test, fuzzing))]
 	pub fn from_raw(
-		introduction_node_id: PublicKey, blinding_point: PublicKey, blinded_hops: Vec<BlindedHop>
+		introduction_node_id: PublicKey, blinding_point: PublicKey, blinded_hops: Vec<BlindedHop>,
+		payinfo: BlindedPayInfo
 	) -> Self {
-		Self(BlindedPath {
-			introduction_node: IntroductionNode::NodeId(introduction_node_id),
-			blinding_point,
-			blinded_hops,
-		})
+		Self {
+			inner_path: BlindedPath {
+				introduction_node: IntroductionNode::NodeId(introduction_node_id),
+				blinding_point,
+				blinded_hops,
+			},
+			payinfo
+		}
 	}
 
 	#[cfg(test)]
 	pub fn clear_blinded_hops(&mut self) {
-		self.0.blinded_hops.clear()
+		self.inner_path.blinded_hops.clear()
 	}
 }
 

lightning/src/ln/blinded_payment_tests.rs

@@ -25,7 +25,7 @@ use crate::ln::onion_payment;
 use crate::ln::onion_utils;
 use crate::ln::onion_utils::INVALID_ONION_BLINDING;
 use crate::ln::outbound_payment::{Retry, IDEMPOTENCY_TIMEOUT_TICKS};
-use crate::offers::invoice::{BlindedPayInfo, UnsignedBolt12Invoice};
+use crate::offers::invoice::UnsignedBolt12Invoice;
 use crate::offers::invoice_request::UnsignedInvoiceRequest;
 use crate::prelude::*;
 use crate::routing::router::{BlindedTail, Path, Payee, PaymentParameters, RouteHop, RouteParameters};
@@ -39,7 +39,7 @@ fn blinded_payment_path(
 	payment_secret: PaymentSecret, intro_node_min_htlc: u64, intro_node_max_htlc: u64,
 	node_ids: Vec<PublicKey>, channel_upds: &[&msgs::UnsignedChannelUpdate],
 	keys_manager: &test_utils::TestKeysInterface
-) -> (BlindedPayInfo, BlindedPaymentPath) {
+) -> BlindedPaymentPath {
 	let mut intermediate_nodes = Vec::new();
 	let mut intro_node_min_htlc_opt = Some(intro_node_min_htlc);
 	let mut intro_node_max_htlc_opt = Some(intro_node_max_htlc);
@@ -839,11 +839,12 @@ fn do_multi_hop_receiver_fail(check: ReceiveCheckFail) {
 				nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&high_htlc_minimum_upd],
 				&chanmon_cfgs[2].keys_manager);
 			if let Payee::Blinded { route_hints, .. } = high_htlc_min_params.payment_params.payee {
-				route_hints[0].1.clone()
+				route_hints[0].clone()
 			} else { panic!() }
 		};
 		if let Payee::Blinded { ref mut route_hints, .. } = route_params.payment_params.payee {
-			route_hints[0].1 = high_htlc_min_bp;
+			route_hints[0] = high_htlc_min_bp;
+			route_hints[0].payinfo.htlc_minimum_msat = amt_msat;
 		} else { panic!() }
 		find_route(&nodes[0], &route_params).unwrap()
 	} else {
@@ -1121,7 +1122,7 @@ fn min_htlc() {
 		nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()],
 		&[&chan_1_2.0.contents, &chan_2_3.0.contents], &chanmon_cfgs[3].keys_manager);
 	assert_eq!(min_htlc_msat,
-		route_params.payment_params.payee.blinded_route_hints()[0].0.htlc_minimum_msat);
+		route_params.payment_params.payee.blinded_route_hints()[0].payinfo.htlc_minimum_msat);
 
 	nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params.clone(), Retry::Attempts(0)).unwrap();
 	check_added_monitors(&nodes[0], 1);
@@ -1133,7 +1134,7 @@ fn min_htlc() {
 		nodes[0].node.timer_tick_occurred();
 	}
 	if let Payee::Blinded { ref mut route_hints, .. } = route_params.payment_params.payee {
-		route_hints[0].0.htlc_minimum_msat -= 1;
+		route_hints[0].payinfo.htlc_minimum_msat -= 1;
 	} else { panic!() }
 	route_params.final_value_msat -= 1;
 	nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();

lightning/src/ln/channelmanager.rs

@@ -62,7 +62,7 @@ use crate::ln::msgs::{ChannelMessageHandler, DecodeError, LightningError};
 use crate::ln::outbound_payment;
 use crate::ln::outbound_payment::{OutboundPayments, PaymentAttempts, PendingOutboundPayment, SendAlongPathArgs, StaleExpiration};
 use crate::ln::wire::Encode;
-use crate::offers::invoice::{BlindedPayInfo, Bolt12Invoice, DEFAULT_RELATIVE_EXPIRY, DerivedSigningPubkey, ExplicitSigningPubkey, InvoiceBuilder, UnsignedBolt12Invoice};
+use crate::offers::invoice::{Bolt12Invoice, DEFAULT_RELATIVE_EXPIRY, DerivedSigningPubkey, ExplicitSigningPubkey, InvoiceBuilder, UnsignedBolt12Invoice};
 use crate::offers::invoice_error::InvoiceError;
 use crate::offers::invoice_request::{DerivedPayerId, InvoiceRequestBuilder};
 use crate::offers::nonce::Nonce;
@@ -9373,7 +9373,7 @@ where
 	/// [`Router::create_blinded_payment_paths`].
 	fn create_blinded_payment_paths(
 		&self, amount_msats: u64, payment_secret: PaymentSecret, payment_context: PaymentContext
-	) -> Result<Vec<(BlindedPayInfo, BlindedPaymentPath)>, ()> {
+	) -> Result<Vec<BlindedPaymentPath>, ()> {
 		let secp_ctx = &self.secp_ctx;
 
 		let first_hops = self.list_usable_channels();

lightning/src/ln/max_payment_path_len_tests.rs

@@ -182,8 +182,8 @@ fn one_hop_blinded_path_with_custom_tlv() {
 		sender_intended_htlc_amt_msat: MIN_FINAL_VALUE_ESTIMATE_WITH_OVERPAY,
 		total_msat: MIN_FINAL_VALUE_ESTIMATE_WITH_OVERPAY,
 		cltv_expiry_height: nodes[0].best_block_info().1 + DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA,
-		encrypted_tlvs: &blinded_path.1.blinded_hops()[0].encrypted_payload,
-		intro_node_blinding_point: Some(blinded_path.1.blinding_point()),
+		encrypted_tlvs: &blinded_path.blinded_hops()[0].encrypted_payload,
+		intro_node_blinding_point: Some(blinded_path.blinding_point()),
 		keysend_preimage: None,
 		custom_tlvs: &Vec::new()
 	}.serialized_length();
@@ -354,15 +354,7 @@ fn bolt12_invoice_too_large_blinded_paths() {
 	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 	create_announced_chan_between_nodes(&nodes, 0, 1);
 
-	nodes[1].router.expect_blinded_payment_paths(vec![(
-		BlindedPayInfo {
-			fee_base_msat: 42,
-			fee_proportional_millionths: 42,
-			cltv_expiry_delta: 42,
-			htlc_minimum_msat: 42,
-			htlc_maximum_msat: 42_000_000,
-			features: BlindedHopFeatures::empty(),
-		},
+	nodes[1].router.expect_blinded_payment_paths(vec![
 		BlindedPaymentPath::from_raw(
 			PublicKey::from_slice(&[2; 33]).unwrap(), PublicKey::from_slice(&[2; 33]).unwrap(),
 			vec![
@@ -374,9 +366,17 @@ fn bolt12_invoice_too_large_blinded_paths() {
 					blinded_node_id: PublicKey::from_slice(&[2; 33]).unwrap(),
 					encrypted_payload: vec![42; 1300],
 				},
-			]
+			],
+			BlindedPayInfo {
+				fee_base_msat: 42,
+				fee_proportional_millionths: 42,
+				cltv_expiry_delta: 42,
+				htlc_minimum_msat: 42,
+				htlc_maximum_msat: 42_000_000,
+				features: BlindedHopFeatures::empty(),
+			}
 		)
-	)]);
+	]);
 
 	let offer = nodes[1].node.create_offer_builder(None).unwrap().build().unwrap();
 	let payment_id = PaymentId([1; 32]);