Introduce VerifiedInvoiceRequest<S: SigningPubkeyStrategy>

This commit reintroduces `VerifiedInvoiceRequest`, now parameterized by
`SigningPubkeyStrategy`.

The key motivation is to restrict which functions can be called on a
`VerifiedInvoiceRequest` based on its strategy type. This enables
compile-time guarantees — ensuring that an incorrect `InvoiceBuilder`
cannot be constructed for a given request, and misuses are caught early.

Author: shaavan

lightning/src/ln/channelmanager.rs

@@ -7422,7 +7422,7 @@ where
 								};
 								let payment_purpose_context =
 									PaymentContext::Bolt12Offer(Bolt12OfferContext {
-										offer_id: verified_invreq.offer_id,
+										offer_id: verified_invreq.offer_id(),
 										invoice_request: verified_invreq.fields(),
 									});
 								let from_parts_res = events::PaymentPurpose::from_parts(
@@ -14330,7 +14330,7 @@ where
 				};
 
 				let amount_msats = match InvoiceBuilder::<DerivedSigningPubkey>::amount_msats(
-					&invoice_request.inner
+					&invoice_request.inner()
 				) {
 					Ok(amount_msats) => amount_msats,
 					Err(error) => return Some((OffersMessage::InvoiceError(error.into()), responder.respond())),

lightning/src/ln/offers_tests.rs

@@ -57,7 +57,7 @@ use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, Init, NodeAnnou
 use crate::ln::outbound_payment::IDEMPOTENCY_TIMEOUT_TICKS;
 use crate::offers::invoice::Bolt12Invoice;
 use crate::offers::invoice_error::InvoiceError;
-use crate::offers::invoice_request::{InvoiceRequest, InvoiceRequestFields};
+use crate::offers::invoice_request::{InvoiceRequest, InvoiceRequestFields, InvoiceRequestVerifiedFromOffer};
 use crate::offers::nonce::Nonce;
 use crate::offers::parse::Bolt12SemanticError;
 use crate::onion_message::messenger::{Destination, MessageSendInstructions, NodeIdMessageRouter, NullMessageRouter, PeeledOnion};
@@ -2276,11 +2276,19 @@ fn fails_paying_invoice_with_unknown_required_features() {
 	let secp_ctx = Secp256k1::new();
 
 	let created_at = alice.node.duration_since_epoch();
-	let invoice = invoice_request
-		.verify_using_recipient_data(nonce, &expanded_key, &secp_ctx).unwrap()
-		.respond_using_derived_keys_no_std(payment_paths, payment_hash, created_at).unwrap()
-		.features_unchecked(Bolt12InvoiceFeatures::unknown())
-		.build_and_sign(&secp_ctx).unwrap();
+	let verified_invoice_request = invoice_request
+		.verify_using_recipient_data(nonce, &expanded_key, &secp_ctx).unwrap();
+
+	let invoice = match verified_invoice_request {
+		InvoiceRequestVerifiedFromOffer::DerivedKeys(request) => {
+			request.respond_using_derived_keys_no_std(payment_paths, payment_hash, created_at).unwrap()
+				.features_unchecked(Bolt12InvoiceFeatures::unknown())
+				.build_and_sign(&secp_ctx).unwrap()
+		},
+		InvoiceRequestVerifiedFromOffer::ExplicitKeys(_) => {
+			panic!("Expected invoice request with keys");
+		},
+	};
 
 	// Enqueue an onion message containing the new invoice.
 	let instructions = MessageSendInstructions::WithoutReplyPath {

lightning/src/offers/flow.rs

@@ -41,7 +41,7 @@ use crate::offers::invoice::{
 };
 use crate::offers::invoice_error::InvoiceError;
 use crate::offers::invoice_request::{
-	InvoiceRequest, InvoiceRequestBuilder, VerifiedInvoiceRequest,
+	InvoiceRequest, InvoiceRequestBuilder, InvoiceRequestVerifiedFromOffer,
 };
 use crate::offers::nonce::Nonce;
 use crate::offers::offer::{Amount, DerivedMetadata, Offer, OfferBuilder};
@@ -393,7 +393,7 @@ fn enqueue_onion_message_with_reply_paths<T: OnionMessageContents + Clone>(
 pub enum InvreqResponseInstructions {
 	/// We are the recipient of this payment, and a [`Bolt12Invoice`] should be sent in response to
 	/// the invoice request since it is now verified.
-	SendInvoice(VerifiedInvoiceRequest),
+	SendInvoice(InvoiceRequestVerifiedFromOffer),
 	/// We are a static invoice server and should respond to this invoice request by retrieving the
 	/// [`StaticInvoice`] corresponding to the `recipient_id` and `invoice_id` and calling
 	/// `OffersMessageFlow::enqueue_static_invoice`.
@@ -902,7 +902,7 @@ where
 		Ok(builder.into())
 	}
 
-	/// Creates a response for the provided [`VerifiedInvoiceRequest`].
+	/// Creates a response for the provided [`InvoiceRequestVerifiedFromOffer`].
 	///
 	/// A response can be either an [`OffersMessage::Invoice`] with additional [`MessageContext`],
 	/// or an [`OffersMessage::InvoiceError`], depending on the [`InvoiceRequest`].
@@ -912,8 +912,9 @@ where
 	/// - We fail to generate a valid signed [`Bolt12Invoice`] for the [`InvoiceRequest`].
 	pub fn create_response_for_invoice_request<ES: Deref, NS: Deref, R: Deref>(
 		&self, signer: &NS, router: &R, entropy_source: ES,
-		invoice_request: VerifiedInvoiceRequest, amount_msats: u64, payment_hash: PaymentHash,
-		payment_secret: PaymentSecret, usable_channels: Vec<ChannelDetails>,
+		invoice_request: InvoiceRequestVerifiedFromOffer, amount_msats: u64,
+		payment_hash: PaymentHash, payment_secret: PaymentSecret,
+		usable_channels: Vec<ChannelDetails>,
 	) -> (OffersMessage, Option<MessageContext>)
 	where
 		ES::Target: EntropySource,
@@ -926,7 +927,7 @@ where
 		let relative_expiry = DEFAULT_RELATIVE_EXPIRY.as_secs() as u32;
 
 		let context = PaymentContext::Bolt12Offer(Bolt12OfferContext {
-			offer_id: invoice_request.offer_id,
+			offer_id: invoice_request.offer_id(),
 			invoice_request: invoice_request.fields(),
 		});
 
@@ -949,35 +950,36 @@ where
 		#[cfg(not(feature = "std"))]
 		let created_at = Duration::from_secs(self.highest_seen_timestamp.load(Ordering::Acquire) as u64);
 
-		let response = if invoice_request.keys.is_some() {
-			#[cfg(feature = "std")]
-			let builder = invoice_request.respond_using_derived_keys(payment_paths, payment_hash);
-			#[cfg(not(feature = "std"))]
-			let builder = invoice_request.respond_using_derived_keys_no_std(
-				payment_paths,
-				payment_hash,
-				created_at,
-			);
-			builder
-				.map(InvoiceBuilder::<DerivedSigningPubkey>::from)
-				.and_then(|builder| builder.allow_mpp().build_and_sign(secp_ctx))
-				.map_err(InvoiceError::from)
-		} else {
-			#[cfg(feature = "std")]
-			let builder = invoice_request.respond_with(payment_paths, payment_hash);
-			#[cfg(not(feature = "std"))]
-			let builder = invoice_request.respond_with_no_std(payment_paths, payment_hash, created_at);
-			builder
-				.map(InvoiceBuilder::<ExplicitSigningPubkey>::from)
-				.and_then(|builder| builder.allow_mpp().build())
-				.map_err(InvoiceError::from)
-				.and_then(|invoice| {
-					#[cfg(c_bindings)]
-					let mut invoice = invoice;
-					invoice
-						.sign(|invoice: &UnsignedBolt12Invoice| signer.sign_bolt12_invoice(invoice))
-						.map_err(InvoiceError::from)
-				})
+		let response = match invoice_request {
+			InvoiceRequestVerifiedFromOffer::DerivedKeys(request) => {
+				#[cfg(feature = "std")]
+				let builder = request.respond_using_derived_keys(payment_paths, payment_hash);
+				#[cfg(not(feature = "std"))]
+				let builder = request.respond_using_derived_keys_no_std(payment_paths, payment_hash, created_at);
+				builder
+					.map(InvoiceBuilder::<DerivedSigningPubkey>::from)
+					.and_then(|builder| builder.allow_mpp().build_and_sign(secp_ctx))
+					.map_err(InvoiceError::from)
+			},
+			InvoiceRequestVerifiedFromOffer::ExplicitKeys(request) => {
+				#[cfg(feature = "std")]
+				let builder = request.respond_with(payment_paths, payment_hash);
+				#[cfg(not(feature = "std"))]
+				let builder = request.respond_with_no_std(payment_paths, payment_hash, created_at);
+				builder
+					.map(InvoiceBuilder::<ExplicitSigningPubkey>::from)
+					.and_then(|builder| builder.allow_mpp().build())
+					.map_err(InvoiceError::from)
+					.and_then(|invoice| {
+						#[cfg(c_bindings)]
+						let mut invoice = invoice;
+						invoice
+							.sign(|invoice: &UnsignedBolt12Invoice| {
+								signer.sign_bolt12_invoice(invoice)
+							})
+							.map_err(InvoiceError::from)
+					})
+			},
 		};
 
 		match response {

lightning/src/offers/invoice.rs

@@ -1819,6 +1819,7 @@ mod tests {
 	use crate::ln::msgs::DecodeError;
 	use crate::offers::invoice_request::{
 		ExperimentalInvoiceRequestTlvStreamRef, InvoiceRequestTlvStreamRef,
+		InvoiceRequestVerifiedFromOffer,
 	};
 	use crate::offers::merkle::{self, SignError, SignatureTlvStreamRef, TaggedHash, TlvStream};
 	use crate::offers::nonce::Nonce;
@@ -2235,42 +2236,31 @@ mod tests {
 				.build_and_sign()
 				.unwrap();
 
-		if let Err(e) = invoice_request
+		let verified_request = invoice_request
 			.clone()
 			.verify_using_recipient_data(nonce, &expanded_key, &secp_ctx)
-			.unwrap()
-			.respond_using_derived_keys_no_std(payment_paths(), payment_hash(), now())
-			.unwrap()
-			.build_and_sign(&secp_ctx)
-		{
-			panic!("error building invoice: {:?}", e);
+			.unwrap();
+
+		match verified_request {
+			InvoiceRequestVerifiedFromOffer::DerivedKeys(req) => {
+				let invoice = req
+					.respond_using_derived_keys_no_std(payment_paths(), payment_hash(), now())
+					.unwrap()
+					.build_and_sign(&secp_ctx);
+
+				if let Err(e) = invoice {
+					panic!("error building invoice: {:?}", e);
+				}
+			},
+			InvoiceRequestVerifiedFromOffer::ExplicitKeys(_) => {
+				panic!("expected invoice request with keys");
+			},
 		}
 
 		let expanded_key = ExpandedKey::new([41; 32]);
 		assert!(invoice_request
 			.verify_using_recipient_data(nonce, &expanded_key, &secp_ctx)
 			.is_err());
-
-		let invoice_request =
-			OfferBuilder::deriving_signing_pubkey(node_id, &expanded_key, nonce, &secp_ctx)
-				.amount_msats(1000)
-				// Omit the path so that node_id is used for the signing pubkey instead of deriving it
-				.experimental_foo(42)
-				.build()
-				.unwrap()
-				.request_invoice(&expanded_key, nonce, &secp_ctx, payment_id)
-				.unwrap()
-				.build_and_sign()
-				.unwrap();
-
-		match invoice_request
-			.verify_using_metadata(&expanded_key, &secp_ctx)
-			.unwrap()
-			.respond_using_derived_keys_no_std(payment_paths(), payment_hash(), now())
-		{
-			Ok(_) => panic!("expected error"),
-			Err(e) => assert_eq!(e, Bolt12SemanticError::InvalidMetadata),
-		}
 	}
 
 	#[test]