Add BlindedPaymentPath type, to disambiguate from message paths.

Next up, we'll add a BlindedMessagePath type so the API is clear which type of
path is expected in each context.

Author: valentinewallace

lightning/src/blinded_path/mod.rs

@@ -18,7 +18,6 @@ use message::MessageContext;
 use core::ops::Deref;
 
 use crate::ln::msgs::DecodeError;
-use crate::offers::invoice::BlindedPayInfo;
 use crate::routing::gossip::{NodeId, ReadOnlyNetworkGraph};
 use crate::sign::EntropySource;
 use crate::util::ser::{Readable, Writeable, Writer};
@@ -154,52 +153,6 @@ impl BlindedPath {
 		})
 	}
 
-	/// Create a one-hop blinded path for a payment.
-	pub fn one_hop_for_payment<ES: Deref, T: secp256k1::Signing + secp256k1::Verification>(
-		payee_node_id: PublicKey, payee_tlvs: payment::ReceiveTlvs, min_final_cltv_expiry_delta: u16,
-		entropy_source: ES, secp_ctx: &Secp256k1<T>
-	) -> Result<(BlindedPayInfo, 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();
-		Self::new_for_payment(
-			&[], payee_node_id, payee_tlvs, htlc_maximum_msat, min_final_cltv_expiry_delta,
-			entropy_source, secp_ctx
-		)
-	}
-
-	/// Create a blinded path for a payment, to be forwarded along `intermediate_nodes`.
-	///
-	/// Errors if:
-	/// * a provided node id is invalid
-	/// * [`BlindedPayInfo`] calculation results in an integer overflow
-	/// * any unknown features are required in the provided [`ForwardTlvs`]
-	///
-	/// [`ForwardTlvs`]: crate::blinded_path::payment::ForwardTlvs
-	//  TODO: make all payloads the same size with padding + add dummy hops
-	pub fn new_for_payment<ES: Deref, T: secp256k1::Signing + secp256k1::Verification>(
-		intermediate_nodes: &[payment::ForwardNode], payee_node_id: PublicKey,
-		payee_tlvs: payment::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 {
-		let introduction_node = IntroductionNode::NodeId(
-			intermediate_nodes.first().map_or(payee_node_id, |n| n.node_id)
-		);
-		let blinding_secret_bytes = entropy_source.get_secure_random_bytes();
-		let blinding_secret = SecretKey::from_slice(&blinding_secret_bytes[..]).expect("RNG is busted");
-
-		let blinded_payinfo = payment::compute_payinfo(
-			intermediate_nodes, &payee_tlvs, htlc_maximum_msat, min_final_cltv_expiry_delta
-		)?;
-		Ok((blinded_payinfo, BlindedPath {
-			introduction_node,
-			blinding_point: PublicKey::from_secret_key(secp_ctx, &blinding_secret),
-			blinded_hops: payment::blinded_hops(
-				secp_ctx, intermediate_nodes, payee_node_id, payee_tlvs, &blinding_secret
-			).map_err(|_| ())?,
-		}))
-	}
-
 	/// 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>(

lightning/src/blinded_path/payment.rs

@@ -7,9 +7,7 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.
 
-//! Data structures and methods for constructing [`BlindedPath`]s to send a payment over.
-//!
-//! [`BlindedPath`]: crate::blinded_path::BlindedPath
+//! Data structures and methods for constructing [`BlindedPaymentPath`]s to send a payment over.
 
 use bitcoin::secp256k1::{self, PublicKey, Secp256k1, SecretKey};
 
@@ -26,7 +24,7 @@ use crate::ln::onion_utils;
 use crate::offers::invoice::BlindedPayInfo;
 use crate::offers::invoice_request::InvoiceRequestFields;
 use crate::offers::offer::OfferId;
-use crate::sign::{NodeSigner, Recipient};
+use crate::sign::{EntropySource, NodeSigner, Recipient};
 use crate::util::ser::{FixedLengthReader, LengthReadableArgs, HighZeroBytesDroppedBigSize, Readable, Writeable, Writer};
 
 use core::mem;
@@ -35,6 +33,55 @@ use core::ops::Deref;
 #[allow(unused_imports)]
 use crate::prelude::*;
 
+/// A [`BlindedPath`] 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 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)?))
+	}
+}
+
+impl BlindedPaymentPath {
+	/// Create a blinded path for a payment, to be forwarded along `intermediate_nodes`.
+	///
+	/// Errors if:
+	/// * a provided node id is invalid
+	/// * [`BlindedPayInfo`] calculation results in an integer overflow
+	/// * any unknown features are required in the provided [`ForwardTlvs`]
+	//  TODO: make all payloads the same size with padding + add dummy hops
+	pub fn new<ES: Deref, T: secp256k1::Signing + secp256k1::Verification>(
+		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 {
+		let introduction_node = IntroductionNode::NodeId(
+			intermediate_nodes.first().map_or(payee_node_id, |n| n.node_id)
+		);
+		let blinding_secret_bytes = entropy_source.get_secure_random_bytes();
+		let blinding_secret = SecretKey::from_slice(&blinding_secret_bytes[..]).expect("RNG is busted");
+
+		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(|_| ())?,
+		})))
+	}
+}
+
 /// An intermediate node, its outbound channel, and relay parameters.
 #[derive(Clone, Debug)]
 pub struct ForwardNode {
@@ -117,10 +164,9 @@ pub struct PaymentConstraints {
 	pub htlc_minimum_msat: u64,
 }
 
-/// The context of an inbound payment, which is included in a [`BlindedPath`] via [`ReceiveTlvs`]
-/// and surfaced in [`PaymentPurpose`].
+/// The context of an inbound payment, which is included in a [`BlindedPaymentPath`] via
+/// [`ReceiveTlvs`] and surfaced in [`PaymentPurpose`].
 ///
-/// [`BlindedPath`]: crate::blinded_path::BlindedPath
 /// [`PaymentPurpose`]: crate::events::PaymentPurpose
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum PaymentContext {
@@ -286,16 +332,16 @@ pub(super) fn blinded_hops<T: secp256k1::Signing + secp256k1::Verification>(
 //
 // Will only modify `path` when returning `Ok`.
 pub(crate) fn advance_path_by_one<NS: Deref, NL: Deref, T>(
-	path: &mut BlindedPath, node_signer: &NS, node_id_lookup: &NL, secp_ctx: &Secp256k1<T>
+	path: &mut BlindedPaymentPath, node_signer: &NS, node_id_lookup: &NL, secp_ctx: &Secp256k1<T>
 ) -> Result<(), ()>
 where
 	NS::Target: NodeSigner,
 	NL::Target: NodeIdLookUp,
 	T: secp256k1::Signing + secp256k1::Verification,
 {
-	let control_tlvs_ss = node_signer.ecdh(Recipient::Node, &path.blinding_point, None)?;
+	let control_tlvs_ss = node_signer.ecdh(Recipient::Node, &path.0.blinding_point, None)?;
 	let rho = onion_utils::gen_rho_from_shared_secret(&control_tlvs_ss.secret_bytes());
-	let encrypted_control_tlvs = &path.blinded_hops.get(0).ok_or(())?.encrypted_payload;
+	let encrypted_control_tlvs = &path.0.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) {
@@ -307,11 +353,11 @@ where
 				None => return Err(()),
 			};
 			let mut new_blinding_point = onion_utils::next_hop_pubkey(
-				secp_ctx, path.blinding_point, control_tlvs_ss.as_ref()
+				secp_ctx, path.0.blinding_point, control_tlvs_ss.as_ref()
 			).map_err(|_| ())?;
-			mem::swap(&mut path.blinding_point, &mut new_blinding_point);
-			path.introduction_node = IntroductionNode::NodeId(next_node_id);
-			path.blinded_hops.remove(0);
+			mem::swap(&mut path.0.blinding_point, &mut new_blinding_point);
+			path.0.introduction_node = IntroductionNode::NodeId(next_node_id);
+			path.0.blinded_hops.remove(0);
 			Ok(())
 		},
 		_ => Err(())

lightning/src/ln/blinded_payment_tests.rs

@@ -8,8 +8,7 @@
 // licenses.
 
 use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
-use crate::blinded_path::BlindedPath;
-use crate::blinded_path::payment::{ForwardNode, ForwardTlvs, PaymentConstraints, PaymentContext, PaymentRelay, ReceiveTlvs};
+use crate::blinded_path::payment::{BlindedPaymentPath, ForwardNode, ForwardTlvs, PaymentConstraints, PaymentContext, PaymentRelay, ReceiveTlvs};
 use crate::events::{Event, HTLCDestination, MessageSendEvent, MessageSendEventsProvider, PaymentFailureReason};
 use crate::ln::types::PaymentSecret;
 use crate::ln::channelmanager;
@@ -31,7 +30,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, BlindedPath) {
+) -> (BlindedPayInfo, 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);
@@ -66,7 +65,7 @@ fn blinded_payment_path(
 		payment_context: PaymentContext::unknown(),
 	};
 	let mut secp_ctx = Secp256k1::new();
-	BlindedPath::new_for_payment(
+	BlindedPaymentPath::new(
 		&intermediate_nodes[..], *node_ids.last().unwrap(), payee_tlvs,
 		intro_node_max_htlc_opt.unwrap_or_else(|| channel_upds.last().unwrap().htlc_maximum_msat),
 		TEST_FINAL_CLTV as u16, keys_manager, &secp_ctx
@@ -112,8 +111,8 @@ fn do_one_hop_blinded_path(success: bool) {
 		payment_context: PaymentContext::unknown(),
 	};
 	let mut secp_ctx = Secp256k1::new();
-	let blinded_path = BlindedPath::one_hop_for_payment(
-		nodes[1].node.get_our_node_id(), payee_tlvs, TEST_FINAL_CLTV as u16,
+	let blinded_path = BlindedPaymentPath::new(
+		&[], nodes[1].node.get_our_node_id(), payee_tlvs, u64::MAX, TEST_FINAL_CLTV as u16,
 		&chanmon_cfgs[1].keys_manager, &secp_ctx
 	).unwrap();
 
@@ -155,8 +154,8 @@ fn mpp_to_one_hop_blinded_path() {
 		},
 		payment_context: PaymentContext::unknown(),
 	};
-	let blinded_path = BlindedPath::one_hop_for_payment(
-		nodes[3].node.get_our_node_id(), payee_tlvs, TEST_FINAL_CLTV as u16,
+	let blinded_path = BlindedPaymentPath::new(
+		&[], nodes[3].node.get_our_node_id(), payee_tlvs, u64::MAX, TEST_FINAL_CLTV as u16,
 		&chanmon_cfgs[3].keys_manager, &secp_ctx
 	).unwrap();
 
@@ -1301,8 +1300,8 @@ fn custom_tlvs_to_blinded_path() {
 		payment_context: PaymentContext::unknown(),
 	};
 	let mut secp_ctx = Secp256k1::new();
-	let blinded_path = BlindedPath::one_hop_for_payment(
-		nodes[1].node.get_our_node_id(), payee_tlvs, TEST_FINAL_CLTV as u16,
+	let blinded_path = BlindedPaymentPath::new(
+		&[], nodes[1].node.get_our_node_id(), payee_tlvs, u64::MAX, TEST_FINAL_CLTV as u16,
 		&chanmon_cfgs[1].keys_manager, &secp_ctx
 	).unwrap();
 

lightning/src/ln/channelmanager.rs

@@ -34,7 +34,7 @@ use bitcoin::{secp256k1, Sequence};
 use crate::blinded_path::message::{MessageContext, OffersContext};
 use crate::blinded_path::{BlindedPath, NodeIdLookUp};
 use crate::blinded_path::message::ForwardNode;
-use crate::blinded_path::payment::{Bolt12OfferContext, Bolt12RefundContext, PaymentConstraints, PaymentContext, ReceiveTlvs};
+use crate::blinded_path::payment::{BlindedPaymentPath, Bolt12OfferContext, Bolt12RefundContext, PaymentConstraints, PaymentContext, ReceiveTlvs};
 use crate::chain;
 use crate::chain::{Confirm, ChannelMonitorUpdateStatus, Watch, BestBlock};
 use crate::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator, LowerBoundedFeeEstimator};
@@ -9069,8 +9069,8 @@ where
 	/// message.
 	///
 	/// The resulting invoice uses a [`PaymentHash`] recognized by the [`ChannelManager`] and a
-	/// [`BlindedPath`] containing the [`PaymentSecret`] needed to reconstruct the corresponding
-	/// [`PaymentPreimage`]. It is returned purely for informational purposes.
+	/// [`BlindedPaymentPath`] containing the [`PaymentSecret`] needed to reconstruct the
+	/// corresponding [`PaymentPreimage`]. It is returned purely for informational purposes.
 	///
 	/// # Limitations
 	///
@@ -9346,7 +9346,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, BlindedPath)>, ()> {
+	) -> Result<Vec<(BlindedPayInfo, BlindedPaymentPath)>, ()> {
 		let secp_ctx = &self.secp_ctx;
 
 		let first_hops = self.list_usable_channels();

lightning/src/ln/max_payment_path_len_tests.rs

@@ -12,7 +12,7 @@
 
 use bitcoin::secp256k1::{Secp256k1, PublicKey};
 use crate::blinded_path::{BlindedHop, BlindedPath, IntroductionNode};
-use crate::blinded_path::payment::{PaymentConstraints, PaymentContext, ReceiveTlvs};
+use crate::blinded_path::payment::{BlindedPaymentPath, PaymentConstraints, PaymentContext, ReceiveTlvs};
 use crate::events::{Event, MessageSendEventsProvider};
 use crate::ln::PaymentSecret;
 use crate::ln::blinded_payment_tests::get_blinded_route_parameters;
@@ -167,8 +167,8 @@ fn one_hop_blinded_path_with_custom_tlv() {
 		payment_context: PaymentContext::unknown(),
 	};
 	let mut secp_ctx = Secp256k1::new();
-	let blinded_path = BlindedPath::one_hop_for_payment(
-		nodes[2].node.get_our_node_id(), payee_tlvs, TEST_FINAL_CLTV as u16,
+	let blinded_path = BlindedPaymentPath::new(
+		&[], nodes[2].node.get_our_node_id(), payee_tlvs, u64::MAX, TEST_FINAL_CLTV as u16,
 		&chanmon_cfgs[2].keys_manager, &secp_ctx
 	).unwrap();
 	let route_params = RouteParameters::from_payment_params_and_value(
@@ -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.1.0.blinded_hops[0].encrypted_payload,
+		intro_node_blinding_point: Some(blinded_path.1.0.blinding_point),
 		keysend_preimage: None,
 		custom_tlvs: &Vec::new()
 	}.serialized_length();
@@ -363,7 +363,7 @@ fn bolt12_invoice_too_large_blinded_paths() {
 			htlc_maximum_msat: 42_000_000,
 			features: BlindedHopFeatures::empty(),
 		},
-		BlindedPath {
+		BlindedPaymentPath(BlindedPath {
 			introduction_node: IntroductionNode::NodeId(PublicKey::from_slice(&[2; 33]).unwrap()),
 			blinding_point: PublicKey::from_slice(&[2; 33]).unwrap(),
 			blinded_hops: vec![
@@ -376,7 +376,7 @@ fn bolt12_invoice_too_large_blinded_paths() {
 					encrypted_payload: vec![42; 1300],
 				},
 			],
-		}
+		})
 	)]);
 
 	let offer = nodes[1].node.create_offer_builder(None).unwrap().build().unwrap();

lightning/src/ln/offers_tests.rs

@@ -571,7 +571,7 @@ fn creates_and_pays_for_offer_using_two_hop_blinded_path() {
 	assert_ne!(invoice.signing_pubkey(), alice_id);
 	assert!(!invoice.payment_paths().is_empty());
 	for (_, path) in invoice.payment_paths() {
-		assert_eq!(path.introduction_node, IntroductionNode::NodeId(bob_id));
+		assert_eq!(path.0.introduction_node, IntroductionNode::NodeId(bob_id));
 	}
 
 	route_bolt12_payment(david, &[charlie, bob, alice], &invoice);
@@ -652,7 +652,7 @@ fn creates_and_pays_for_refund_using_two_hop_blinded_path() {
 	assert_ne!(invoice.signing_pubkey(), alice_id);
 	assert!(!invoice.payment_paths().is_empty());
 	for (_, path) in invoice.payment_paths() {
-		assert_eq!(path.introduction_node, IntroductionNode::NodeId(bob_id));
+		assert_eq!(path.0.introduction_node, IntroductionNode::NodeId(bob_id));
 	}
 
 	route_bolt12_payment(david, &[charlie, bob, alice], &invoice);
@@ -717,7 +717,7 @@ fn creates_and_pays_for_offer_using_one_hop_blinded_path() {
 	assert_ne!(invoice.signing_pubkey(), alice_id);
 	assert!(!invoice.payment_paths().is_empty());
 	for (_, path) in invoice.payment_paths() {
-		assert_eq!(path.introduction_node, IntroductionNode::NodeId(alice_id));
+		assert_eq!(path.0.introduction_node, IntroductionNode::NodeId(alice_id));
 	}
 
 	route_bolt12_payment(bob, &[alice], &invoice);
@@ -772,7 +772,7 @@ fn creates_and_pays_for_refund_using_one_hop_blinded_path() {
 	assert_ne!(invoice.signing_pubkey(), alice_id);
 	assert!(!invoice.payment_paths().is_empty());
 	for (_, path) in invoice.payment_paths() {
-		assert_eq!(path.introduction_node, IntroductionNode::NodeId(alice_id));
+		assert_eq!(path.0.introduction_node, IntroductionNode::NodeId(alice_id));
 	}
 
 	route_bolt12_payment(bob, &[alice], &invoice);
@@ -1096,7 +1096,7 @@ fn pays_bolt12_invoice_asynchronously() {
 	assert_ne!(invoice.signing_pubkey(), alice_id);
 	assert!(!invoice.payment_paths().is_empty());
 	for (_, path) in invoice.payment_paths() {
-		assert_eq!(path.introduction_node, IntroductionNode::NodeId(alice_id));
+		assert_eq!(path.0.introduction_node, IntroductionNode::NodeId(alice_id));
 	}
 
 	assert!(bob.node.send_payment_for_bolt12_invoice(&invoice, context.as_ref()).is_ok());
@@ -1180,7 +1180,7 @@ fn creates_offer_with_blinded_path_using_unannounced_introduction_node() {
 	assert_ne!(invoice.signing_pubkey(), alice_id);
 	assert!(!invoice.payment_paths().is_empty());
 	for (_, path) in invoice.payment_paths() {
-		assert_eq!(path.introduction_node, IntroductionNode::NodeId(bob_id));
+		assert_eq!(path.0.introduction_node, IntroductionNode::NodeId(bob_id));
 	}
 
 	route_bolt12_payment(bob, &[alice], &invoice);
@@ -1230,7 +1230,7 @@ fn creates_refund_with_blinded_path_using_unannounced_introduction_node() {
 	assert_ne!(invoice.signing_pubkey(), alice_id);
 	assert!(!invoice.payment_paths().is_empty());
 	for (_, path) in invoice.payment_paths() {
-		assert_eq!(path.introduction_node, IntroductionNode::NodeId(bob_id));
+		assert_eq!(path.0.introduction_node, IntroductionNode::NodeId(bob_id));
 	}
 }
 

lightning/src/ln/onion_utils.rs

@@ -340,8 +340,8 @@ pub(crate) fn set_max_path_length(
 		.map(|(_, path)| path)
 		.max_by_key(|path| path.serialized_length())
 		.map(|largest_path| BlindedTailHopIter {
-			hops: largest_path.blinded_hops.iter(),
-			blinding_point: largest_path.blinding_point,
+			hops: largest_path.0.blinded_hops.iter(),
+			blinding_point: largest_path.0.blinding_point,
 			final_value_msat: final_value_msat_with_overpay_buffer,
 			excess_final_cltv_expiry_delta: 0,
 		});