Split InvoiceRequest::verify_and_respond_using_derived_keys

InvoiceRequest::verify_and_respond_using_derived_keys takes a payment
hash. To avoid generating one for invoice requests that ultimately
cannot be verified, split the method into one for verifying and another
for responding.

Author: jkczyz

lightning/src/offers/invoice.rs

@@ -1250,36 +1250,31 @@ mod tests {
 			.build().unwrap()
 			.sign(payer_sign).unwrap();
 
-		if let Err(e) = invoice_request
-			.verify_and_respond_using_derived_keys_no_std(
-				payment_paths(), payment_hash(), now(), &expanded_key, &secp_ctx
-			)
-			.unwrap()
+		if let Err(e) = invoice_request.clone()
+			.verify(&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);
 		}
 
 		let expanded_key = ExpandedKey::new(&KeyMaterial([41; 32]));
-		match invoice_request.verify_and_respond_using_derived_keys_no_std(
-			payment_paths(), payment_hash(), now(), &expanded_key, &secp_ctx
-		) {
-			Ok(_) => panic!("expected error"),
-			Err(e) => assert_eq!(e, SemanticError::InvalidMetadata),
-		}
+		assert!(invoice_request.verify(&expanded_key, &secp_ctx).is_err());
 
 		let desc = "foo".to_string();
 		let offer = OfferBuilder
 			::deriving_signing_pubkey(desc, node_id, &expanded_key, &entropy, &secp_ctx)
 			.amount_msats(1000)
+			// Omit the path so that node_id is used for the signing pubkey instead of deriving
 			.build().unwrap();
 		let invoice_request = offer.request_invoice(vec![1; 32], payer_pubkey()).unwrap()
 			.build().unwrap()
 			.sign(payer_sign).unwrap();
 
-		match invoice_request.verify_and_respond_using_derived_keys_no_std(
-			payment_paths(), payment_hash(), now(), &expanded_key, &secp_ctx
-		) {
+		match invoice_request
+			.verify(&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, SemanticError::InvalidMetadata),
 		}

lightning/src/offers/invoice_request.rs

@@ -400,6 +400,22 @@ pub struct InvoiceRequest {
 	signature: Signature,
 }
 
+/// An [`InvoiceRequest`] that has been verified by [`InvoiceRequest::verify`] and exposes different
+/// ways to respond depending on whether the signing keys were derived.
+#[derive(Clone, Debug)]
+pub struct VerifiedInvoiceRequest {
+	/// The verified request.
+	pub inner: InvoiceRequest,
+
+	/// Keys used for signing an [`Invoice`] if they can be derived.
+	///
+	/// If `Some`, then must respond with methods that use derived keys. Otherwise, should respond
+	/// with an invoice signed explicitly.
+	///
+	/// [`Invoice`]: crate::offers::invoice::Invoice
+	pub keys: Option<KeyPair>,
+}
+
 /// The contents of an [`InvoiceRequest`], which may be shared with an [`Invoice`].
 ///
 /// [`Invoice`]: crate::offers::invoice::Invoice
@@ -523,6 +539,60 @@ impl InvoiceRequest {
 		InvoiceBuilder::for_offer(self, payment_paths, created_at, payment_hash)
 	}
 
+	/// Verifies that the request was for an offer created using the given key. Returns the verified
+	/// request along with the derived keys needed to sign an [`Invoice`] for the request if they
+	/// could be extracted from the metadata.
+	///
+	/// [`Invoice`]: crate::offers::invoice::Invoice
+	pub fn verify<T: secp256k1::Signing>(
+		self, key: &ExpandedKey, secp_ctx: &Secp256k1<T>
+	) -> Result<VerifiedInvoiceRequest, ()> {
+		let keys = self.contents.inner.offer.verify(&self.bytes, key, secp_ctx)?;
+		Ok(VerifiedInvoiceRequest {
+			inner: self,
+			keys,
+		})
+	}
+
+	#[cfg(test)]
+	fn as_tlv_stream(&self) -> FullInvoiceRequestTlvStreamRef {
+		let (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream) =
+			self.contents.as_tlv_stream();
+		let signature_tlv_stream = SignatureTlvStreamRef {
+			signature: Some(&self.signature),
+		};
+		(payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, signature_tlv_stream)
+	}
+}
+
+impl VerifiedInvoiceRequest {
+	/// Creates an [`InvoiceBuilder`] for the request with the given required fields and using the
+	/// [`Duration`] since [`std::time::SystemTime::UNIX_EPOCH`] as the creation time.
+	///
+	/// See [`InvoiceRequest::respond_with_no_std`] for further details.
+	///
+	/// This is not exported to bindings users as builder patterns don't map outside of move semantics.
+	///
+	/// [`Duration`]: core::time::Duration
+	#[cfg(feature = "std")]
+	pub fn respond_with(
+		&self, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, payment_hash: PaymentHash
+	) -> Result<InvoiceBuilder<ExplicitSigningPubkey>, SemanticError> {
+		self.inner.respond_with(payment_paths, payment_hash)
+	}
+
+	/// Creates an [`InvoiceBuilder`] for the request with the given required fields.
+	///
+	/// See [`InvoiceRequest::respond_with_no_std`] for further details.
+	///
+	/// This is not exported to bindings users as builder patterns don't map outside of move semantics.
+	pub fn respond_with_no_std(
+		&self, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, payment_hash: PaymentHash,
+		created_at: core::time::Duration
+	) -> Result<InvoiceBuilder<ExplicitSigningPubkey>, SemanticError> {
+		self.inner.respond_with_no_std(payment_paths, payment_hash, created_at)
+	}
+
 	/// Creates an [`InvoiceBuilder`] for the request using the given required fields and that uses
 	/// derived signing keys from the originating [`Offer`] to sign the [`Invoice`]. Must use the
 	/// same [`ExpandedKey`] as the one used to create the offer.
@@ -533,17 +603,14 @@ impl InvoiceRequest {
 	///
 	/// [`Invoice`]: crate::offers::invoice::Invoice
 	#[cfg(feature = "std")]
-	pub fn verify_and_respond_using_derived_keys<T: secp256k1::Signing>(
-		&self, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, payment_hash: PaymentHash,
-		expanded_key: &ExpandedKey, secp_ctx: &Secp256k1<T>
+	pub fn respond_using_derived_keys(
+		&self, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, payment_hash: PaymentHash
 	) -> Result<InvoiceBuilder<DerivedSigningPubkey>, SemanticError> {
 		let created_at = std::time::SystemTime::now()
 			.duration_since(std::time::SystemTime::UNIX_EPOCH)
 			.expect("SystemTime::now() should come after SystemTime::UNIX_EPOCH");
 
-		self.verify_and_respond_using_derived_keys_no_std(
-			payment_paths, payment_hash, created_at, expanded_key, secp_ctx
-		)
+		self.respond_using_derived_keys_no_std(payment_paths, payment_hash, created_at)
 	}
 
 	/// Creates an [`InvoiceBuilder`] for the request using the given required fields and that uses
@@ -555,42 +622,22 @@ impl InvoiceRequest {
 	/// This is not exported to bindings users as builder patterns don't map outside of move semantics.
 	///
 	/// [`Invoice`]: crate::offers::invoice::Invoice
-	pub fn verify_and_respond_using_derived_keys_no_std<T: secp256k1::Signing>(
+	pub fn respond_using_derived_keys_no_std(
 		&self, payment_paths: Vec<(BlindedPayInfo, BlindedPath)>, payment_hash: PaymentHash,
-		created_at: core::time::Duration, expanded_key: &ExpandedKey, secp_ctx: &Secp256k1<T>
+		created_at: core::time::Duration
 	) -> Result<InvoiceBuilder<DerivedSigningPubkey>, SemanticError> {
-		if self.features().requires_unknown_bits() {
+		if self.inner.features().requires_unknown_bits() {
 			return Err(SemanticError::UnknownRequiredFeatures);
 		}
 
-		let keys = match self.verify(expanded_key, secp_ctx) {
-			Err(()) => return Err(SemanticError::InvalidMetadata),
-			Ok(None) => return Err(SemanticError::InvalidMetadata),
-			Ok(Some(keys)) => keys,
+		let keys = match self.keys {
+			None => return Err(SemanticError::InvalidMetadata),
+			Some(keys) => keys,
 		};
 
-		InvoiceBuilder::for_offer_using_keys(self, payment_paths, created_at, payment_hash, keys)
-	}
-
-	/// Verifies that the request was for an offer created using the given key. Returns the derived
-	/// keys need to sign an [`Invoice`] for the request if they could be extracted from the
-	/// metadata.
-	///
-	/// [`Invoice`]: crate::offers::invoice::Invoice
-	pub fn verify<T: secp256k1::Signing>(
-		&self, key: &ExpandedKey, secp_ctx: &Secp256k1<T>
-	) -> Result<Option<KeyPair>, ()> {
-		self.contents.inner.offer.verify(&self.bytes, key, secp_ctx)
-	}
-
-	#[cfg(test)]
-	fn as_tlv_stream(&self) -> FullInvoiceRequestTlvStreamRef {
-		let (payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream) =
-			self.contents.as_tlv_stream();
-		let signature_tlv_stream = SignatureTlvStreamRef {
-			signature: Some(&self.signature),
-		};
-		(payer_tlv_stream, offer_tlv_stream, invoice_request_tlv_stream, signature_tlv_stream)
+		InvoiceBuilder::for_offer_using_keys(
+			&self.inner, payment_paths, created_at, payment_hash, keys
+		)
 	}
 }