Expose blinded payment paths in decoded BOLT12 invoices

`DecodeInvoiceResponse` previously dropped the blinded payment paths of
a decoded BOLT12 invoice. It now carries them in a new `paths` field,
mirroring the `paths` already exposed for decoded BOLT12 offers. BOLT11
invoices leave the field empty, as they carry route hints instead.

The blinded-path-to-proto conversion is extracted from `decode_offer`
into a shared `blinded_path_to_proto` helper, so offer decoding (blinded
message paths) and invoice decoding (blinded payment paths) build the
same `BlindedPath` representation.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: vincenzopalazzo

ldk-server-grpc/src/api.rs

@@ -1123,7 +1123,8 @@ pub struct DecodeInvoiceRequest {
 }
 /// The response for the `DecodeInvoice` RPC. On failure, a gRPC error status is returned.
 /// `kind` indicates which invoice type was decoded; fields that do not apply to that type
-/// are left empty (e.g. `payment_secret` and `route_hints` are BOLT11-only).
+/// are left empty (e.g. `payment_secret` and `route_hints` are BOLT11-only, `paths` is
+/// BOLT12-only).
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
 #[cfg_attr(feature = "serde", serde(default))]
@@ -1178,6 +1179,9 @@ pub struct DecodeInvoiceResponse {
 	/// The kind of decoded invoice: "bolt11" or "bolt12".
 	#[prost(string, tag = "16")]
 	pub kind: ::prost::alloc::string::String,
+	/// Blinded payment paths to the recipient. Only present for BOLT12 invoices.
+	#[prost(message, repeated, tag = "17")]
+	pub paths: ::prost::alloc::vec::Vec<super::types::BlindedPath>,
 }
 /// Decode a BOLT12 offer and return its parsed fields.
 /// This does not require a running node — it only parses the offer string.

ldk-server-grpc/src/proto/api.proto

@@ -804,7 +804,8 @@ message DecodeInvoiceRequest {
 
 // The response for the `DecodeInvoice` RPC. On failure, a gRPC error status is returned.
 // `kind` indicates which invoice type was decoded; fields that do not apply to that type
-// are left empty (e.g. `payment_secret` and `route_hints` are BOLT11-only).
+// are left empty (e.g. `payment_secret` and `route_hints` are BOLT11-only, `paths` is
+// BOLT12-only).
 message DecodeInvoiceResponse {
   // The hex-encoded public key of the destination node.
   string destination = 1;
@@ -853,6 +854,9 @@ message DecodeInvoiceResponse {
 
   // The kind of decoded invoice: "bolt11" or "bolt12".
   string kind = 16;
+
+  // Blinded payment paths to the recipient. Only present for BOLT12 invoices.
+  repeated types.BlindedPath paths = 17;
 }
 
 // Decode a BOLT12 offer and return its parsed fields.

ldk-server/src/api/decode_invoice.rs

@@ -17,8 +17,8 @@ use ldk_node::lightning_types::features::{Bolt11InvoiceFeatures, Bolt12InvoiceFe
 use ldk_server_grpc::api::{DecodeInvoiceRequest, DecodeInvoiceResponse};
 use ldk_server_grpc::types::{Bolt11HopHint, Bolt11RouteHint};
 
-use crate::api::decode_features;
 use crate::api::error::LdkServerError;
+use crate::api::{blinded_path_to_proto, decode_features};
 use crate::service::Context;
 
 const INVOICE_KIND_BOLT11: &str = "bolt11";
@@ -57,6 +57,18 @@ fn decode_bolt12_invoice(invoice: &str) -> Option<DecodeInvoiceResponse> {
 		Bolt12InvoiceFeatures::from_le_bytes(bytes).to_string()
 	});
 
+	let paths = invoice
+		.payment_paths()
+		.iter()
+		.map(|path| {
+			blinded_path_to_proto(
+				path.introduction_node(),
+				path.blinding_point(),
+				path.blinded_hops().len(),
+			)
+		})
+		.collect();
+
 	Some(DecodeInvoiceResponse {
 		destination: invoice.signing_pubkey().to_string(),
 		payment_hash: invoice.payment_hash().0.to_lower_hex_string(),
@@ -68,6 +80,7 @@ fn decode_bolt12_invoice(invoice: &str) -> Option<DecodeInvoiceResponse> {
 		features,
 		is_expired: invoice.is_expired(),
 		kind: INVOICE_KIND_BOLT12.to_string(),
+		paths,
 		..Default::default()
 	})
 }
@@ -149,6 +162,8 @@ fn decode_bolt11_invoice(invoice: &Bolt11Invoice) -> DecodeInvoiceResponse {
 		payment_metadata,
 		is_expired,
 		kind: INVOICE_KIND_BOLT11.to_string(),
+		// BOLT11 invoices carry route hints rather than blinded paths.
+		paths: Vec::new(),
 	}
 }
 
@@ -162,6 +177,7 @@ mod tests {
 	use ldk_node::lightning::types::features::BlindedHopFeatures;
 	use ldk_node::lightning::types::payment::PaymentHash;
 	use ldk_node::lightning::util::ser::Writeable;
+	use ldk_server_grpc::types::blinded_path::IntroductionNode;
 
 	use super::*;
 
@@ -237,5 +253,13 @@ mod tests {
 		assert_eq!(response.amount_msat, Some(1_000));
 		assert_eq!(response.expiry, 3600);
 		assert!(!response.is_expired);
+
+		// The sample invoice carries a single blinded payment path with two hops,
+		// introduced by `pubkey(40)` and blinded with `pubkey(41)`.
+		assert_eq!(response.paths.len(), 1);
+		let path = &response.paths[0];
+		assert_eq!(path.num_hops, 2);
+		assert_eq!(path.blinding_point, pubkey(41).to_string());
+		assert_eq!(path.introduction_node, Some(IntroductionNode::NodeId(pubkey(40).to_string())));
 	}
 }

ldk-server/src/api/decode_offer.rs

@@ -16,16 +16,12 @@ use ldk_node::lightning::bitcoin::Network;
 use ldk_node::lightning::offers::offer::Offer;
 use ldk_node::lightning_types::features::OfferFeatures;
 use ldk_server_grpc::api::{DecodeOfferRequest, DecodeOfferResponse};
-use ldk_server_grpc::types::blinded_path::IntroductionNode;
 use ldk_server_grpc::types::offer_amount::Amount;
 use ldk_server_grpc::types::offer_quantity::Quantity;
-use ldk_server_grpc::types::{
-	BlindedPath, ChannelDirection, CurrencyAmount, DirectedShortChannelId, OfferAmount,
-	OfferQuantity,
-};
+use ldk_server_grpc::types::{CurrencyAmount, OfferAmount, OfferQuantity};
 
-use crate::api::decode_features;
 use crate::api::error::LdkServerError;
+use crate::api::{blinded_path_to_proto, decode_features};
 use crate::service::Context;
 
 pub(crate) async fn handle_decode_offer_request(
@@ -74,33 +70,11 @@ pub(crate) async fn handle_decode_offer_request(
 		.paths()
 		.iter()
 		.map(|path| {
-			let introduction_node = match path.introduction_node() {
-				ldk_node::lightning::blinded_path::IntroductionNode::NodeId(pk) => {
-					IntroductionNode::NodeId(pk.to_string())
-				},
-				ldk_node::lightning::blinded_path::IntroductionNode::DirectedShortChannelId(
-					dir,
-					scid,
-				) => {
-					let direction = match dir {
-						ldk_node::lightning::blinded_path::Direction::NodeOne => {
-							ChannelDirection::NodeOne
-						},
-						ldk_node::lightning::blinded_path::Direction::NodeTwo => {
-							ChannelDirection::NodeTwo
-						},
-					};
-					IntroductionNode::DirectedScid(DirectedShortChannelId {
-						scid: *scid,
-						direction: direction as i32,
-					})
-				},
-			};
-			BlindedPath {
-				introduction_node: Some(introduction_node),
-				blinding_point: path.blinding_point().to_string(),
-				num_hops: path.blinded_hops().len() as u32,
-			}
+			blinded_path_to_proto(
+				path.introduction_node(),
+				path.blinding_point(),
+				path.blinded_hops().len(),
+			)
 		})
 		.collect();
 

ldk-server/src/api/mod.rs

@@ -10,9 +10,14 @@
 use std::collections::HashMap;
 
 use ldk_node::config::{ChannelConfig, MaxDustHTLCExposure};
+use ldk_node::lightning::bitcoin::secp256k1::PublicKey;
+use ldk_node::lightning::blinded_path::{Direction, IntroductionNode};
 use ldk_node::lightning::routing::router::RouteParametersConfig;
+use ldk_server_grpc::types::blinded_path::IntroductionNode as ProtoIntroductionNode;
 use ldk_server_grpc::types::channel_config::MaxDustHtlcExposure;
-use ldk_server_grpc::types::Bolt11Feature;
+use ldk_server_grpc::types::{
+	BlindedPath, Bolt11Feature, ChannelDirection, DirectedShortChannelId,
+};
 
 use crate::api::error::LdkServerError;
 use crate::api::error::LdkServerErrorCode::InvalidRequestError;
@@ -129,6 +134,33 @@ pub(crate) fn build_route_parameters_config_from_proto(
 	}
 }
 
+/// Converts a blinded path into its proto representation. Shared by BOLT12 offer and
+/// invoice decoding: offers expose blinded message paths and invoices expose blinded
+/// payment paths, but both carry the same introduction node, blinding point, and hop
+/// count surfaced here.
+pub(crate) fn blinded_path_to_proto(
+	introduction_node: &IntroductionNode, blinding_point: PublicKey, num_hops: usize,
+) -> BlindedPath {
+	let introduction_node = match introduction_node {
+		IntroductionNode::NodeId(node_id) => ProtoIntroductionNode::NodeId(node_id.to_string()),
+		IntroductionNode::DirectedShortChannelId(direction, scid) => {
+			let direction = match direction {
+				Direction::NodeOne => ChannelDirection::NodeOne,
+				Direction::NodeTwo => ChannelDirection::NodeTwo,
+			};
+			ProtoIntroductionNode::DirectedScid(DirectedShortChannelId {
+				scid: *scid,
+				direction: direction as i32,
+			})
+		},
+	};
+	BlindedPath {
+		introduction_node: Some(introduction_node),
+		blinding_point: blinding_point.to_string(),
+		num_hops: num_hops as u32,
+	}
+}
+
 /// Decodes feature flags into a map keyed by bit number. Feature names are derived
 /// from LDK's `Features::Display` impl, so they stay in sync automatically.
 ///