WIP: move BlindedPayInfo into BlindedPaymentPath.

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

Author: valentinewallace

lightning/src/blinded_path/payment.rs

@@ -37,17 +37,27 @@ 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);
+pub struct BlindedPaymentPath {
+	pub(super) inner_path: BlindedPath,
+	/// The [`BlindedPayInfo`] used to pay this blinded path.
+	pub payinfo: BlindedPayInfo,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub(crate) struct WriteableBlindedPath<'a>(&'a BlindedPath);
 
-impl Writeable for BlindedPaymentPath {
+impl<'a> Writeable for WriteableBlindedPath<'a> {
 	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
 		self.0.write(w)
 	}
 }
 
-impl Readable for BlindedPaymentPath {
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub(crate) struct ReadableBlindedPath(BlindedPath);
+
+impl Readable for ReadableBlindedPath {
 	fn read<R: io::Read>(r: &mut R) -> Result<Self, DecodeError> {
-		Ok(Self(BlindedPath::read(r)?))
+		Ok(ReadableBlindedPath(Readable::read(r)?))
 	}
 }
 
@@ -56,7 +66,7 @@ impl BlindedPaymentPath {
 	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 +87,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 +97,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 +146,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 +160,45 @@ 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 writeable_path(&self) -> WriteableBlindedPath {
+		WriteableBlindedPath(&self.inner_path)
+	}
+
+	pub(crate) fn from_readable_blinded_path(
+		inner_path: ReadableBlindedPath, payinfo: BlindedPayInfo
+	) -> Self {
+		Self { inner_path: inner_path.0, 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/channelmanager.rs

@@ -61,7 +61,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;
@@ -9350,7 +9350,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/onion_utils.rs

@@ -337,8 +337,7 @@ pub(crate) fn set_max_path_length(
 		.payee
 		.blinded_route_hints()
 		.iter()
-		.map(|(_, path)| path)
-		.max_by_key(|path| path.serialized_length())
+		.max_by_key(|path| path.writeable_path().serialized_length())
 		.map(|largest_path| BlindedTailHopIter {
 			hops: largest_path.blinded_hops().iter(),
 			blinding_point: largest_path.blinding_point(),

lightning/src/ln/outbound_payment.rs

@@ -833,7 +833,7 @@ impl OutboundPayments {
 
 		// Advance any blinded path where the introduction node is our node.
 		if let Ok(our_node_id) = node_signer.get_node_id(Recipient::Node) {
-			for (_, path) in payment_params.payee.blinded_route_hints_mut().iter_mut() {
+			for path in payment_params.payee.blinded_route_hints_mut().iter_mut() {
 				let introduction_node_id = match path.introduction_node() {
 					IntroductionNode::NodeId(pubkey) => *pubkey,
 					IntroductionNode::DirectedShortChannelId(direction, scid) => {

lightning/src/offers/invoice.rs

@@ -32,7 +32,7 @@
 //! # use lightning::offers::invoice::{BlindedPayInfo, ExplicitSigningPubkey, InvoiceBuilder};
 //! # use lightning::blinded_path::payment::BlindedPaymentPath;
 //! #
-//! # fn create_payment_paths() -> Vec<(BlindedPayInfo, BlindedPaymentPath)> { unimplemented!() }
+//! # fn create_payment_paths() -> Vec<BlindedPaymentPath> { unimplemented!() }
 //! # fn create_payment_hash() -> PaymentHash { unimplemented!() }
 //! #
 //! # fn parse_invoice_request(bytes: Vec<u8>) -> Result<(), lightning::offers::parse::Bolt12ParseError> {
@@ -111,7 +111,7 @@ use core::time::Duration;
 use core::hash::{Hash, Hasher};
 use crate::io;
 use crate::blinded_path::message::BlindedMessagePath;
-use crate::blinded_path::payment::BlindedPaymentPath;
+use crate::blinded_path::payment::{WriteableBlindedPath, ReadableBlindedPath, BlindedPaymentPath};
 use crate::ln::types::PaymentHash;
 use crate::ln::channelmanager::PaymentId;
 use crate::ln::features::{BlindedHopFeatures, Bolt12InvoiceFeatures, InvoiceRequestFeatures, OfferFeatures};
@@ -128,7 +128,7 @@ use crate::offers::parse::{Bolt12ParseError, Bolt12SemanticError, ParsedMessage}
 use crate::offers::payer::{PAYER_METADATA_TYPE, PayerTlvStream, PayerTlvStreamRef};
 use crate::offers::refund::{IV_BYTES_WITH_METADATA as REFUND_IV_BYTES_WITH_METADATA, IV_BYTES_WITHOUT_METADATA as REFUND_IV_BYTES_WITHOUT_METADATA, Refund, RefundContents};
 use crate::offers::signer::{Metadata, self};
-use crate::util::ser::{HighZeroBytesDroppedBigSize, Iterable, Readable, SeekReadable, WithoutLength, Writeable, Writer};
+use crate::util::ser::{HighZeroBytesDroppedBigSize, Iterable, IterableOwned, Readable, SeekReadable, WithoutLength, Writeable, Writer};
 use crate::util::string::PrintableString;
 
 #[allow(unused_imports)]
@@ -212,7 +212,7 @@ impl SigningPubkeyStrategy for DerivedSigningPubkey {}
 macro_rules! invoice_explicit_signing_pubkey_builder_methods { ($self: ident, $self_type: ty) => {
 	#[cfg_attr(c_bindings, allow(dead_code))]
 	pub(super) fn for_offer(
-		invoice_request: &'a InvoiceRequest, payment_paths: Vec<(BlindedPayInfo, BlindedPaymentPath)>,
+		invoice_request: &'a InvoiceRequest, payment_paths: Vec<BlindedPaymentPath>,
 		created_at: Duration, payment_hash: PaymentHash, signing_pubkey: PublicKey
 	) -> Result<Self, Bolt12SemanticError> {
 		let amount_msats = Self::amount_msats(invoice_request)?;
@@ -228,7 +228,7 @@ macro_rules! invoice_explicit_signing_pubkey_builder_methods { ($self: ident, $s
 
 	#[cfg_attr(c_bindings, allow(dead_code))]
 	pub(super) fn for_refund(
-		refund: &'a Refund, payment_paths: Vec<(BlindedPayInfo, BlindedPaymentPath)>, created_at: Duration,
+		refund: &'a Refund, payment_paths: Vec<BlindedPaymentPath>, created_at: Duration,
 		payment_hash: PaymentHash, signing_pubkey: PublicKey
 	) -> Result<Self, Bolt12SemanticError> {
 		let amount_msats = refund.amount_msats();
@@ -270,7 +270,7 @@ macro_rules! invoice_explicit_signing_pubkey_builder_methods { ($self: ident, $s
 macro_rules! invoice_derived_signing_pubkey_builder_methods { ($self: ident, $self_type: ty) => {
 	#[cfg_attr(c_bindings, allow(dead_code))]
 	pub(super) fn for_offer_using_keys(
-		invoice_request: &'a InvoiceRequest, payment_paths: Vec<(BlindedPayInfo, BlindedPaymentPath)>,
+		invoice_request: &'a InvoiceRequest, payment_paths: Vec<BlindedPaymentPath>,
 		created_at: Duration, payment_hash: PaymentHash, keys: Keypair
 	) -> Result<Self, Bolt12SemanticError> {
 		let amount_msats = Self::amount_msats(invoice_request)?;
@@ -287,7 +287,7 @@ macro_rules! invoice_derived_signing_pubkey_builder_methods { ($self: ident, $se
 
 	#[cfg_attr(c_bindings, allow(dead_code))]
 	pub(super) fn for_refund_using_keys(
-		refund: &'a Refund, payment_paths: Vec<(BlindedPayInfo, BlindedPaymentPath)>, created_at: Duration,
+		refund: &'a Refund, payment_paths: Vec<BlindedPaymentPath>, created_at: Duration,
 		payment_hash: PaymentHash, keys: Keypair,
 	) -> Result<Self, Bolt12SemanticError> {
 		let amount_msats = refund.amount_msats();
@@ -356,8 +356,8 @@ macro_rules! invoice_builder_methods { (
 
 	#[cfg_attr(c_bindings, allow(dead_code))]
 	fn fields(
-		payment_paths: Vec<(BlindedPayInfo, BlindedPaymentPath)>, created_at: Duration,
-		payment_hash: PaymentHash, amount_msats: u64, signing_pubkey: PublicKey
+		payment_paths: Vec<BlindedPaymentPath>, created_at: Duration, payment_hash: PaymentHash,
+		amount_msats: u64, signing_pubkey: PublicKey
 	) -> InvoiceFields {
 		InvoiceFields {
 			payment_paths, created_at, relative_expiry: None, payment_hash, amount_msats,
@@ -603,7 +603,7 @@ enum InvoiceContents {
 /// Invoice-specific fields for an `invoice` message.
 #[derive(Clone, Debug, PartialEq)]
 struct InvoiceFields {
-	payment_paths: Vec<(BlindedPayInfo, BlindedPaymentPath)>,
+	payment_paths: Vec<BlindedPaymentPath>,
 	created_at: Duration,
 	relative_expiry: Option<Duration>,
 	payment_hash: PaymentHash,
@@ -988,7 +988,7 @@ impl InvoiceContents {
 		}
 	}
 
-	fn payment_paths(&self) -> &[(BlindedPayInfo, BlindedPaymentPath)] {
+	fn payment_paths(&self) -> &[BlindedPaymentPath] {
 		&self.fields().payment_paths[..]
 	}
 
@@ -1125,8 +1125,8 @@ impl InvoiceFields {
 		};
 
 		InvoiceTlvStreamRef {
-			paths: Some(Iterable(self.payment_paths.iter().map(|(_, path)| path))),
-			blindedpay: Some(Iterable(self.payment_paths.iter().map(|(payinfo, _)| payinfo))),
+			paths: Some(IterableOwned(self.payment_paths.iter().map(|path| path.writeable_path()))),
+			blindedpay: Some(Iterable(self.payment_paths.iter().map(|path| &path.payinfo))),
 			created_at: Some(self.created_at.as_secs()),
 			relative_expiry: self.relative_expiry.map(|duration| duration.as_secs() as u32),
 			payment_hash: Some(&self.payment_hash),
@@ -1193,7 +1193,7 @@ impl TryFrom<Vec<u8>> for Bolt12Invoice {
 }
 
 tlv_stream!(InvoiceTlvStream, InvoiceTlvStreamRef, 160..240, {
-	(160, paths: (Vec<BlindedPaymentPath>, WithoutLength, Iterable<'a, BlindedPathIter<'a>, BlindedPaymentPath>)),
+	(160, paths: (Vec<ReadableBlindedPath>, WithoutLength, IterableOwned<BlindedPathIter<'a>, WriteableBlindedPath<'a>>)),
 	(162, blindedpay: (Vec<BlindedPayInfo>, WithoutLength, Iterable<'a, BlindedPayInfoIter<'a>, BlindedPayInfo>)),
 	(164, created_at: (u64, HighZeroBytesDroppedBigSize)),
 	(166, relative_expiry: (u32, HighZeroBytesDroppedBigSize)),
@@ -1207,13 +1207,13 @@ tlv_stream!(InvoiceTlvStream, InvoiceTlvStreamRef, 160..240, {
 });
 
 pub(super) type BlindedPathIter<'a> = core::iter::Map<
-	core::slice::Iter<'a, (BlindedPayInfo, BlindedPaymentPath)>,
-	for<'r> fn(&'r (BlindedPayInfo, BlindedPaymentPath)) -> &'r BlindedPaymentPath,
+	core::slice::Iter<'a, BlindedPaymentPath>,
+	for<'r> fn(&'r BlindedPaymentPath) -> WriteableBlindedPath<'r>,
 >;
 
 pub(super) type BlindedPayInfoIter<'a> = core::iter::Map<
-	core::slice::Iter<'a, (BlindedPayInfo, BlindedPaymentPath)>,
-	for<'r> fn(&'r (BlindedPayInfo, BlindedPaymentPath)) -> &'r BlindedPayInfo,
+	core::slice::Iter<'a, BlindedPaymentPath>,
+	for<'r> fn(&'r BlindedPaymentPath) -> &'r BlindedPayInfo,
 >;
 
 /// Information needed to route a payment across a [`BlindedPaymentPath`].
@@ -1388,8 +1388,8 @@ impl TryFrom<PartialInvoiceTlvStream> for InvoiceContents {
 }
 
 pub(super) fn construct_payment_paths(
-	blinded_payinfos: Option<Vec<BlindedPayInfo>>, blinded_paths: Option<Vec<BlindedPaymentPath>>
-) -> Result<Vec<(BlindedPayInfo, BlindedPaymentPath)>, Bolt12SemanticError> {
+	blinded_payinfos: Option<Vec<BlindedPayInfo>>, blinded_paths: Option<Vec<ReadableBlindedPath>>
+) -> Result<Vec<BlindedPaymentPath>, Bolt12SemanticError> {
 	match (blinded_payinfos, blinded_paths) {
 		(_, None) => Err(Bolt12SemanticError::MissingPaths),
 		(None, _) => Err(Bolt12SemanticError::InvalidPayInfo),
@@ -1398,7 +1398,12 @@ pub(super) fn construct_payment_paths(
 			Err(Bolt12SemanticError::InvalidPayInfo)
 		},
 		(Some(blindedpay), Some(paths)) => {
-			Ok(blindedpay.into_iter().zip(paths.into_iter()).collect::<Vec<_>>())
+			Ok(blindedpay
+				.into_iter()
+				.zip(paths.into_iter())
+				.map(|(payinfo, path)| BlindedPaymentPath::from_readable_blinded_path(path, payinfo))
+				.collect::<Vec<_>>()
+			)
 		},
 	}
 }

lightning/src/offers/invoice_macros.rs

@@ -107,7 +107,7 @@ macro_rules! invoice_accessors_common { ($self: ident, $contents: expr, $invoice
 	///
 	/// This is not exported to bindings users as slices with non-reference types cannot be ABI
 	/// matched in another language.
-	pub fn payment_paths(&$self) -> &[(BlindedPayInfo, BlindedPaymentPath)] {
+	pub fn payment_paths(&$self) -> &[BlindedPaymentPath] {
 		$contents.payment_paths()
 	}