WIP: Include blinded paths

Author: jkczyz

lightning/src/ln/channelmanager.rs

@@ -58,6 +58,7 @@ use crate::offers::invoice_request::InvoiceRequestBuilder;
 use crate::offers::offer::{Offer, OfferBuilder};
 use crate::offers::parse::SemanticError;
 use crate::offers::refund::RefundBuilder;
+use crate::onion_message::BlindedPath;
 use crate::util::config::{UserConfig, ChannelConfig};
 use crate::util::events::{Event, EventHandler, EventsProvider, MessageSendEvent, MessageSendEventsProvider, ClosureReason, HTLCDestination};
 use crate::util::events;
@@ -5434,6 +5435,10 @@ where
 	/// Creates an [`OfferBuilder`] such that the [`Offer`] it builds is recognized by the
 	/// [`OnionMessenger`] when handling [`InvoiceRequest`] messages for the offer.
 	///
+	/// 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
 	/// [`OnionMessenger`]: crate::onion_message::OnionMessenger
 	/// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest
@@ -5442,13 +5447,25 @@ where
 		let expanded_key = &self.inbound_payment_key;
 		let nonce = inbound_payment::Nonce::from_entropy_source(&*self.entropy_source);
 
-		// TODO: Set blinded paths
-		OfferBuilder::deriving_signing_pubkey(description, node_id, expanded_key, nonce)
+		match self.create_blinded_paths(1) {
+			Ok(paths) if !paths.is_empty() => {
+				OfferBuilder::deriving_signing_pubkey(description, node_id, expanded_key, nonce)
+					.path(paths.into_iter().next().unwrap())
+			},
+			// TODO: check if node is public?
+			Ok(_) | Err(_) => {
+				OfferBuilder::deriving_signing_pubkey(description, node_id, expanded_key, nonce)
+			},
+		}
 	}
 
 	/// Creates a [`RefundBuilder`] such that the [`Refund`] it builds is recognized by the
 	/// [`OnionMessenger`] when handling [`Invoice`] messages for the refund.
 	///
+	/// 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
 	/// [`OnionMessenger`]: crate::onion_message::OnionMessenger
 	/// [`Invoice`]: crate::offers::invoice::Invoice
@@ -5459,8 +5476,21 @@ where
 		let expanded_key = &self.inbound_payment_key;
 		let nonce = inbound_payment::Nonce::from_entropy_source(&*self.entropy_source);
 
-		// TODO: Set blinded paths
-		RefundBuilder::deriving_payer_id(description, node_id, expanded_key, nonce, amount_msats)
+		let builder = match self.create_blinded_paths(1) {
+			Ok(paths) if !paths.is_empty() => {
+				RefundBuilder::deriving_payer_id(
+					description, node_id, expanded_key, nonce, amount_msats
+				)?.path(paths.into_iter().next().unwrap())
+			},
+			// TODO: check if node is public?
+			Ok(_) | Err(_) => {
+				RefundBuilder::deriving_payer_id(
+					description, node_id, expanded_key, nonce, amount_msats
+				)?
+			},
+		};
+
+		Ok(builder)
 	}
 
 	/// Creates an [`InvoiceRequestBuilder`] such that the [`InvoiceRequest`] it builds is
@@ -5608,6 +5638,23 @@ where
 		inbound_payment::get_payment_preimage(payment_hash, payment_secret, &self.inbound_payment_key)
 	}
 
+	///
+	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;
+
+		self.router
+			.find_partial_paths(self.get_our_node_id(), last_hops.as_slice())?
+			.into_iter()
+			.map(|node_pks| BlindedPath::without_id(&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
 	/// are used when constructing the phantom invoice's route hints.
 	///

lightning/src/onion_message/blinded_path.rs

@@ -62,26 +62,26 @@ impl BlindedPath {
 	/// will be the destination node and will receive the `path_id`.
 	///
 	/// Errors if less than two hops are provided or if `node_pk`(s) are invalid.
-	pub fn with_id<ES: EntropySource, T: secp256k1::Signing + secp256k1::Verification>(
-		id: [u8; 32], node_pks: &[PublicKey], entropy_source: &ES, secp_ctx: &Secp256k1<T>
-	) -> Result<Self, ()> {
+	pub fn with_id<ES: Deref, T: secp256k1::Signing + secp256k1::Verification>(
+		id: [u8; 32], node_pks: &[PublicKey], entropy_source: ES, secp_ctx: &Secp256k1<T>
+	) -> Result<Self, ()> where ES::Target: EntropySource {
 		Self::new(Some(id), node_pks, entropy_source, secp_ctx)
 	}
 
 	/// Create a blinded path to be forwarded along `node_pks`. The last node pubkey in `node_pks`
 	/// will be the destination node.
 	///
 	/// Errors if less than two hops are provided or if `node_pk`(s) are invalid.
-	pub fn without_id<ES: EntropySource, T: secp256k1::Signing + secp256k1::Verification>(
-		node_pks: &[PublicKey], entropy_source: &ES, secp_ctx: &Secp256k1<T>
-	) -> Result<Self, ()> {
+	pub fn without_id<ES: Deref, T: secp256k1::Signing + secp256k1::Verification>(
+		node_pks: &[PublicKey], entropy_source: ES, secp_ctx: &Secp256k1<T>
+	) -> Result<Self, ()> where ES::Target: EntropySource {
 		Self::new(None, node_pks, entropy_source, secp_ctx)
 	}
 
 	//  TODO: make all payloads the same size with padding + add dummy hops
-	fn new<ES: EntropySource, T: secp256k1::Signing + secp256k1::Verification>(
-		id: Option<[u8; 32]>, node_pks: &[PublicKey], entropy_source: &ES, secp_ctx: &Secp256k1<T>
-	) -> Result<Self, ()> {
+	fn new<ES: Deref, T: secp256k1::Signing + secp256k1::Verification>(
+		id: Option<[u8; 32]>, node_pks: &[PublicKey], entropy_source: ES, secp_ctx: &Secp256k1<T>
+	) -> Result<Self, ()> where ES::Target: EntropySource {
 		if node_pks.len() < 2 { return Err(()) }
 		let blinding_secret_bytes = entropy_source.get_secure_random_bytes();
 		let blinding_secret = SecretKey::from_slice(&blinding_secret_bytes[..]).expect("RNG is busted");

lightning/src/routing/router.rs

@@ -81,6 +81,7 @@ pub trait Router {
 		&self, payer: &PublicKey, route_params: &RouteParameters,
 		first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: &InFlightHtlcs
 	) -> Result<Route, LightningError>;
+
 	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values. Includes
 	/// `PaymentHash` and `PaymentId` to be able to correlate the request with a specific payment.
 	fn find_route_with_id(
@@ -90,6 +91,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())
+	}
 }
 
 /// [`Score`] implementation that factors in in-flight HTLC liquidity.