[test] Cover currency-denominated offer invoice responses

Add tests covering invoice request and invoice response handling for
currency-denominated offers.

This combines coverage for the standard flow that derives the final
invoice amount through currency conversion and the insufficient-msat
request path that must be rejected while building the invoice
response.

The merged test coverage exercises both the positive and deferred-
validation paths for currency-denominated invoice responses.

AI-assisted: Planning and writing the tests

Co-Authored-By: OpenAI Codex <codex@openai.com>

Author: shaavan

lightning/src/offers/invoice_request.rs

@@ -1568,10 +1568,12 @@ impl Readable for InvoiceRequestFields {
 mod tests {
 	use super::{
 		ExperimentalInvoiceRequestTlvStreamRef, InvoiceRequest, InvoiceRequestFields,
-		InvoiceRequestTlvStreamRef, UnsignedInvoiceRequest, EXPERIMENTAL_INVOICE_REQUEST_TYPES,
-		INVOICE_REQUEST_TYPES, PAYER_NOTE_LIMIT, SIGNATURE_TAG,
+		InvoiceRequestTlvStreamRef, InvoiceRequestVerifiedFromOffer, UnsignedInvoiceRequest,
+		EXPERIMENTAL_INVOICE_REQUEST_TYPES, INVOICE_REQUEST_TYPES, PAYER_NOTE_LIMIT, SIGNATURE_TAG,
 	};
 
+	use crate::blinded_path::message::BlindedMessagePath;
+	use crate::blinded_path::BlindedHop;
 	use crate::ln::channelmanager::PaymentId;
 	use crate::ln::inbound_payment::ExpandedKey;
 	use crate::ln::msgs::{DecodeError, MAX_VALUE_MSAT};
@@ -1593,6 +1595,7 @@ mod tests {
 	use crate::types::features::{InvoiceRequestFeatures, OfferFeatures};
 	use crate::types::string::{PrintableString, UntrustedString};
 	use crate::util::ser::{BigSize, Readable, Writeable};
+	use crate::util::test_utils::TestCurrencyConversion;
 	use bitcoin::constants::ChainHash;
 	use bitcoin::network::Network;
 	use bitcoin::secp256k1::{self, Keypair, Secp256k1, SecretKey};
@@ -2346,6 +2349,127 @@ mod tests {
 		}
 	}
 
+	#[test]
+	fn responds_to_invoice_request_using_currency_conversion() {
+		let expanded_key = ExpandedKey::new([42; 32]);
+		let entropy = FixedEntropy {};
+		let nonce = Nonce::from_entropy_source(&entropy);
+		let secp_ctx = Secp256k1::new();
+		let payment_id = PaymentId([1; 32]);
+		let converter = TestCurrencyConversion {};
+
+		let invoice = OfferBuilder::new(recipient_pubkey(), &converter)
+			.amount(Amount::Currency {
+				iso4217_code: CurrencyCode::new(*b"USD").unwrap(),
+				amount: 10,
+			})
+			.build()
+			.unwrap()
+			.request_invoice(&expanded_key, nonce, &secp_ctx, payment_id)
+			.unwrap()
+			.build_and_sign()
+			.unwrap()
+			.respond_with_no_std(&converter, payment_paths(), payment_hash(), now())
+			.unwrap()
+			.build()
+			.unwrap()
+			.sign(recipient_sign)
+			.unwrap();
+
+		assert_eq!(invoice.amount_msats(), 10_000);
+		assert_eq!(
+			invoice.verify_using_payer_data(payment_id, nonce, &expanded_key, &secp_ctx),
+			Ok(payment_id),
+		);
+	}
+
+	#[test]
+	fn fails_responding_to_invoice_request_with_insufficient_amount_for_currency_offer() {
+		let expanded_key = ExpandedKey::new([42; 32]);
+		let entropy = FixedEntropy {};
+		let nonce = Nonce::from_entropy_source(&entropy);
+		let secp_ctx = Secp256k1::new();
+		let payment_id = PaymentId([1; 32]);
+		let converter = TestCurrencyConversion {};
+
+		match OfferBuilder::new(recipient_pubkey(), &converter)
+			.amount(Amount::Currency {
+				iso4217_code: CurrencyCode::new(*b"USD").unwrap(),
+				amount: 10,
+			})
+			.build()
+			.unwrap()
+			.request_invoice(&expanded_key, nonce, &secp_ctx, payment_id)
+			.unwrap()
+			.amount_msats(9_999)
+			.unwrap()
+			.build_and_sign()
+			.unwrap()
+			.respond_with_no_std(&converter, payment_paths(), payment_hash(), now())
+		{
+			Ok(_) => panic!("expected error"),
+			Err(e) => assert_eq!(e, Bolt12SemanticError::InsufficientAmount),
+		}
+	}
+
+	#[test]
+	fn responds_to_invoice_request_using_derived_keys_with_currency_conversion() {
+		let expanded_key = ExpandedKey::new([42; 32]);
+		let entropy = FixedEntropy {};
+		let nonce = Nonce::from_entropy_source(&entropy);
+		let secp_ctx = Secp256k1::new();
+		let payment_id = PaymentId([1; 32]);
+		let converter = TestCurrencyConversion {};
+		let blinded_path = BlindedMessagePath::from_blinded_path(
+			pubkey(40),
+			pubkey(41),
+			vec![
+				BlindedHop { blinded_node_id: pubkey(42), encrypted_payload: vec![0; 43] },
+				BlindedHop { blinded_node_id: recipient_pubkey(), encrypted_payload: vec![0; 44] },
+			],
+		);
+
+		let offer = OfferBuilder::deriving_signing_pubkey(
+			recipient_pubkey(),
+			&expanded_key,
+			nonce,
+			&converter,
+			&secp_ctx,
+		)
+		.amount(Amount::Currency { iso4217_code: CurrencyCode::new(*b"USD").unwrap(), amount: 10 })
+		.path(blinded_path)
+		.build()
+		.unwrap();
+
+		let invoice_request = offer
+			.request_invoice(&expanded_key, nonce, &secp_ctx, payment_id)
+			.unwrap()
+			.build_and_sign()
+			.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(
+					&converter,
+					payment_paths(),
+					payment_hash(),
+					now(),
+				)
+				.unwrap()
+				.build_and_sign(&secp_ctx)
+				.unwrap(),
+			InvoiceRequestVerifiedFromOffer::ExplicitKeys(_) => panic!("expected derived keys"),
+		};
+
+		assert_eq!(invoice.amount_msats(), 10_000);
+		assert_eq!(
+			invoice.verify_using_payer_data(payment_id, nonce, &expanded_key, &secp_ctx),
+			Ok(payment_id),
+		);
+	}
+
 	#[test]
 	fn parses_invoice_request_with_metadata() {
 		let expanded_key = ExpandedKey::new([42; 32]);