WIP: Multi-hop blinded paths

Author: jkczyz

lightning/src/ln/channelmanager.rs

@@ -6709,8 +6709,9 @@ where
 	/// Creates an [`OfferBuilder`] such that the [`Offer`] it builds is recognized by the
 	/// [`ChannelManager`] when handling [`InvoiceRequest`] messages for the offer.
 	///
-	/// Uses a one-hop [`BlindedPath`] for the offer with [`ChannelManager::get_our_node_id`] as the
-	/// introduction node and a derived signing pubkey for recipient privacy.
+	/// Uses [`Router::find_partial_paths`] to construct a [`BlindedPath`] for the offer. If one is
+	/// found, also uses a derived signing pubkey for recipient privacy. Otherwise, uses the node id
+	/// as the signing pubkey.
 	///
 	/// [`Offer`]: crate::offers::offer::Offer
 	/// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest
@@ -6725,10 +6726,10 @@ where
 			description, node_id, expanded_key, entropy, secp_ctx
 		);
 
-		match self.create_one_hop_blinded_path() {
-			Ok(path) => builder.path(path),
+		match self.create_blinded_paths(1) {
+			Ok(paths) if !paths.is_empty() => builder.path(paths.into_iter().next().unwrap()),
 			// TODO: check if node is public?
-			Err(_) => builder,
+			Ok(_) | Err(_) => builder,
 		}
 	}
 
@@ -6737,8 +6738,9 @@ where
 	///
 	/// The provided `payment_id` is used to ensure that only one invoice is paid for the refund.
 	///
-	/// Uses a one-hop [`BlindedPath`] for the refund with [`ChannelManager::get_our_node_id`] as
-	/// the introduction node and a derived payer id for sender privacy.
+	/// Uses [`Router::find_partial_paths`] to construct a [`BlindedPath`] for the refund. If one is
+	/// found, also uses a derived payer id for sender privacy. Otherwise, uses the node id as the
+	/// payer id.
 	///
 	/// [`Refund`]: crate::offers::refund::Refund
 	/// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
@@ -6753,10 +6755,10 @@ where
 		let builder = RefundBuilder::deriving_payer_id(
 			description, node_id, expanded_key, entropy, secp_ctx, amount_msats, payment_id
 		)?;
-		let builder = match self.create_one_hop_blinded_path() {
-			Ok(path) => builder.path(path),
+		let builder = match self.create_blinded_paths(1) {
+			Ok(paths) if !paths.is_empty() => builder.path(paths.into_iter().next().unwrap()),
 			// TODO: check if node is public?
-			Err(_) => builder,
+			Ok(_) | Err(_) => builder,
 		};
 		self.pending_outbound_payments
 			.add_new_awaiting_invoice(payment_id, retry_strategy)
@@ -6890,13 +6892,25 @@ where
 		inbound_payment::get_payment_preimage(payment_hash, payment_secret, &self.inbound_payment_key)
 	}
 
-	/// Creates a one-hop blinded path with [`ChannelManager::get_our_node_id`] as the introduction
-	/// node.
-	fn create_one_hop_blinded_path(&self) -> Result<BlindedPath, ()> {
+	/// Creates `count` blinded paths using our immediate peers as the introduction nodes.
+	///
+	/// May return fewer paths if there are fewer than `count` peers that [support route blinding].
+	///
+	/// [support route blinding]: crate::ln::features::InitFeatures::supports_route_blinding
+	fn create_blinded_paths(&self, count: usize) -> Result<Vec<BlindedPath>, ()> {
+		let last_hops = self.per_peer_state.read().unwrap().iter()
+			.filter(|(_, peer)| peer.lock().unwrap().latest_features.supports_route_blinding())
+			.map(|(node_id, _)| *node_id)
+			.collect::<Vec<_>>();
 		let entropy_source = self.entropy_source.deref();
 		let secp_ctx = &self.secp_ctx;
-		BlindedPath::new_for_message(&[self.get_our_node_id()], entropy_source, secp_ctx)
 
+		self.router
+			.find_partial_paths(self.get_our_node_id(), last_hops.as_slice())?
+			.into_iter()
+			.map(|node_pks| BlindedPath::new_for_message(&node_pks[..], entropy_source, secp_ctx))
+			.take(count)
+			.collect()
 	}
 
 	/// Gets a fake short channel id for use in receiving [phantom node payments]. These fake scids

lightning/src/routing/router.rs

@@ -105,6 +105,17 @@ pub trait Router {
 	) -> Result<Route, LightningError> {
 		self.find_route(payer, route_params, first_hops, inflight_htlcs)
 	}
+
+	/// Finds partial paths to the `recipient` node for creating `BlindedPath`s. The nodes in
+	/// `peers` are assumed to be direct peers with the `recipient`.
+	///
+	/// The default implementation returns two-node paths for each node in `peers` with the
+	/// `recipient` node.
+	fn find_partial_paths(
+		&self, recipient: PublicKey, peers: &[PublicKey]
+	) -> Result<Vec<Vec<PublicKey>>, ()> {
+		Ok(peers.iter().map(|hop| vec![*hop, recipient]).collect())
+	}
 }
 
 /// [`ScoreLookUp`] implementation that factors in in-flight HTLC liquidity.