[feat] Quote currency-denominated offer amounts in invoices

Use CurrencyConversion when turning an authenticated InvoiceRequest into
a BOLT12 invoice and when validating the returned invoice on the payer.

This keeps invoice_request.amount_msats omitted on the wire for
currency-denominated offers while still letting the payee quote a
concrete millisatoshi amount in the invoice. The same payable-amount
logic is then reused to validate the authenticated invoice before it is
recorded or paid.

Payer-side amount validation failures are treated as local terminal
errors. Invalid quoted amounts and unsupported local currency conversion
now abandon the pending payment immediately instead of surfacing later as
an invoice-request timeout, and they do not send InvoiceError back to the
payee.

Async and static invoice paths resolve offer amounts through the same
conversion-aware builder so resolved amounts, payment secrets, and
payment handling stay in sync.

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

Author: shaavan

fuzz/src/invoice_request_deser.rs

@@ -153,7 +153,10 @@ fn build_response<T: secp256k1::Signing + secp256k1::Verification>(
 	.unwrap();
 
 	let payment_hash = PaymentHash([42; 32]);
-	invoice_request.respond_with(vec![payment_path], payment_hash)?.build()
+	let conversion = FuzzCurrencyConversion;
+	invoice_request
+		.respond_with(&conversion, vec![payment_path], payment_hash)?
+		.build()
 }
 
 pub fn invoice_request_deser_test<Out: test_logger::Output>(data: &[u8], out: Out) {

lightning/src/ln/async_payments_tests.rs

@@ -60,7 +60,6 @@ use crate::types::features::Bolt12InvoiceFeatures;
 use crate::types::payment::{PaymentHash, PaymentPreimage, PaymentSecret};
 use crate::util::config::{HTLCInterceptionFlags, UserConfig};
 use crate::util::ser::Writeable;
-use crate::util::test_utils::TestCurrencyConversion;
 use bitcoin::constants::ChainHash;
 use bitcoin::network::Network;
 use bitcoin::secp256k1;
@@ -1456,8 +1455,6 @@ fn amount_doesnt_match_invreq() {
 
 	let amt_msat = 5000;
 	let payment_id = PaymentId([1; 32]);
-	let conversion = TestCurrencyConversion;
-
 	nodes[0].node.pay_for_offer(&offer, Some(amt_msat), payment_id, Default::default()).unwrap();
 	let release_held_htlc_om_3_0 = pass_async_payments_oms(
 		static_invoice,

lightning/src/ln/channelmanager.rs

@@ -5760,6 +5760,15 @@ impl<
 	fn send_payment_for_verified_bolt12_invoice(
 		&self, invoice: &Bolt12Invoice, payment_id: PaymentId,
 	) -> Result<(), Bolt12PaymentError> {
+		self.check_bolt12_invoice_amount(invoice).inspect_err(|e| {
+			if matches!(
+				e,
+				Bolt12PaymentError::InvalidAmount | Bolt12PaymentError::UnsupportedCurrency
+			) {
+				self.abandon_payment_with_reason(payment_id, PaymentFailureReason::UnexpectedError);
+			}
+		})?;
+
 		let best_block_height = self.best_block.read().unwrap().height;
 		let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(self);
 		let features = self.bolt12_invoice_features();
@@ -5781,6 +5790,24 @@ impl<
 		)
 	}
 
+	fn check_bolt12_invoice_amount(
+		&self, invoice: &Bolt12Invoice,
+	) -> Result<(), Bolt12PaymentError> {
+		let requested_amount =
+			invoice.payable_amount(&self.currency_conversion).map_err(|e| match e {
+				Bolt12SemanticError::UnsupportedCurrency => Bolt12PaymentError::UnsupportedCurrency,
+				_ => Bolt12PaymentError::UnexpectedInvoice,
+			})?;
+		// A returned invoice quotes the amount the payee expects to receive. Make
+		// sure it matches the payer's locally expected amount before recording the
+		// invoice as received or initiating payment.
+		if !requested_amount.contains(invoice.amount_msats()) {
+			return Err(Bolt12PaymentError::InvalidAmount);
+		}
+
+		Ok(())
+	}
+
 	fn check_refresh_async_receive_offer_cache(&self, timer_tick_occurred: bool) {
 		let peers = self.get_peers_for_blinded_path();
 		let channels = self.list_usable_channels();
@@ -5789,6 +5816,7 @@ impl<
 			peers,
 			channels,
 			router,
+			&self.currency_conversion,
 			timer_tick_occurred,
 		);
 		match refresh_res {
@@ -16909,12 +16937,12 @@ impl<
 {
 	#[rustfmt::skip]
 	fn handle_message(
-		&self, message: OffersMessage, context: Option<OffersContext>, responder: Option<Responder>,
-	) -> Option<(OffersMessage, ResponseInstruction)> {
-		macro_rules! handle_pay_invoice_res {
-			($res: expr, $invoice: expr, $logger: expr) => {{
-				let error = match $res {
-					Err(Bolt12PaymentError::UnknownRequiredFeatures) => {
+			&self, message: OffersMessage, context: Option<OffersContext>, responder: Option<Responder>,
+		) -> Option<(OffersMessage, ResponseInstruction)> {
+			macro_rules! handle_pay_invoice_res {
+				($res: expr, $invoice: expr, $payment_id: expr, $logger: expr) => {{
+					let error = match $res {
+						Err(Bolt12PaymentError::UnknownRequiredFeatures) => {
 						log_trace!(
 							$logger, "Invoice requires unknown features: {:?}",
 							$invoice.invoice_features()
@@ -16930,6 +16958,13 @@ impl<
 						log_trace!($logger, "{}", err_msg);
 						InvoiceError::from_string(err_msg.to_string())
 					},
+					Err(Bolt12PaymentError::InvalidAmount)
+						| Err(Bolt12PaymentError::UnsupportedCurrency) => {
+						self.abandon_payment_with_reason(
+							$payment_id, PaymentFailureReason::UnexpectedError
+						);
+						return None;
+					},
 					Err(Bolt12PaymentError::UnexpectedInvoice)
 						| Err(Bolt12PaymentError::DuplicateInvoice)
 						| Ok(()) => return None,
@@ -16978,6 +17013,7 @@ impl<
 							&self.router,
 							&request,
 							self.list_usable_channels(),
+							&self.currency_conversion,
 							get_payment_info,
 						);
 
@@ -17002,6 +17038,7 @@ impl<
 							&self.router,
 							&request,
 							self.list_usable_channels(),
+							&self.currency_conversion,
 							get_payment_info,
 						);
 
@@ -17051,6 +17088,10 @@ impl<
 				);
 
 				if self.config.read().unwrap().manually_handle_bolt12_invoices {
+					if let Err(e) = self.check_bolt12_invoice_amount(&invoice) {
+						handle_pay_invoice_res!(Err(e), invoice, payment_id, logger);
+					}
+
 					// Update the corresponding entry in `PendingOutboundPayment` for this invoice.
 					// This ensures that event generation remains idempotent in case we receive
 					// the same invoice multiple times.
@@ -17064,15 +17105,15 @@ impl<
 				}
 
 				let res = self.send_payment_for_verified_bolt12_invoice(&invoice, payment_id);
-				handle_pay_invoice_res!(res, invoice, logger);
+				handle_pay_invoice_res!(res, invoice, payment_id, logger);
 			},
 			OffersMessage::StaticInvoice(invoice) => {
 				let payment_id = match context {
 					Some(OffersContext::OutboundPaymentForOffer { payment_id, .. }) => payment_id,
 					_ => return None
 				};
 				let res = self.initiate_async_payment(&invoice, payment_id);
-				handle_pay_invoice_res!(res, invoice, self.logger);
+				handle_pay_invoice_res!(res, invoice, payment_id, self.logger);
 			},
 			OffersMessage::InvoiceError(invoice_error) => {
 				let payment_hash = match context {
@@ -17144,6 +17185,7 @@ impl<
 			self.list_usable_channels(),
 			&self.entropy_source,
 			&self.router,
+			&self.currency_conversion,
 		) {
 			Some((msg, ctx)) => (msg, ctx),
 			None => return None,

lightning/src/ln/offers_tests.rs

@@ -56,10 +56,10 @@ use crate::types::features::Bolt12InvoiceFeatures;
 use crate::ln::functional_test_utils::*;
 use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, Init, NodeAnnouncement, OnionMessage, OnionMessageHandler, RoutingMessageHandler, SocketAddress, UnsignedGossipMessage, UnsignedNodeAnnouncement};
 use crate::ln::outbound_payment::IDEMPOTENCY_TIMEOUT_TICKS;
+use crate::offers::currency::DefaultCurrencyConversion;
 use crate::offers::invoice::Bolt12Invoice;
 use crate::offers::invoice_error::InvoiceError;
 use crate::offers::invoice_request::{InvoiceRequest, InvoiceRequestFields, InvoiceRequestVerifiedFromOffer};
-use crate::offers::currency::DefaultCurrencyConversion;
 use crate::offers::nonce::Nonce;
 use crate::offers::parse::Bolt12SemanticError;
 use crate::onion_message::messenger::{DefaultMessageRouter, Destination, MessageSendInstructions, NodeIdMessageRouter, NullMessageRouter, PeeledOnion, DUMMY_HOPS_PATH_LENGTH, QR_CODED_DUMMY_HOPS_PATH_LENGTH};
@@ -68,6 +68,7 @@ use crate::routing::gossip::{NodeAlias, NodeId};
 use crate::routing::router::{DEFAULT_PAYMENT_DUMMY_HOPS, PaymentParameters, RouteParameters, RouteParametersConfig};
 use crate::sign::{NodeSigner, Recipient};
 use crate::util::ser::Writeable;
+use crate::util::test_utils::TestCurrencyConversion;
 
 /// This used to determine whether we built a compact path or not, but now its just a random
 /// constant we apply to blinded path expiry in these tests.
@@ -525,7 +526,7 @@ fn check_dummy_hop_pattern_in_offer() {
 	let (invoice_request, reply_path) = extract_invoice_request(alice, &onion_message);
 
 	assert_eq!(
-		invoice_request.payable_amount_msats(),
+		invoice_request.payable_amount(&DefaultCurrencyConversion).map(|amount| amount.amount_msats()),
 		Ok(10_000_000)
 	);
 	assert_ne!(invoice_request.payer_signing_pubkey(), bob_id);
@@ -550,7 +551,7 @@ fn check_dummy_hop_pattern_in_offer() {
 	let (invoice_request, reply_path) = extract_invoice_request(alice, &onion_message);
 
 	assert_eq!(
-		invoice_request.payable_amount_msats(),
+		invoice_request.payable_amount(&DefaultCurrencyConversion).map(|amount| amount.amount_msats()),
 		Ok(10_000_000)
 	);
 	assert_ne!(invoice_request.payer_signing_pubkey(), bob_id);
@@ -739,7 +740,7 @@ fn creates_and_pays_for_offer_using_two_hop_blinded_path() {
 		},
 	});
 	assert_eq!(
-		invoice_request.payable_amount_msats(),
+		invoice_request.payable_amount(&DefaultCurrencyConversion).map(|amount| amount.amount_msats()),
 		Ok(10_000_000)
 	);
 	assert_ne!(invoice_request.payer_signing_pubkey(), david_id);
@@ -900,7 +901,7 @@ fn creates_and_pays_for_offer_using_one_hop_blinded_path() {
 		},
 	});
 	assert_eq!(
-		invoice_request.payable_amount_msats(),
+		invoice_request.payable_amount(&DefaultCurrencyConversion).map(|amount| amount.amount_msats()),
 		Ok(10_000_000)
 	);
 	assert_ne!(invoice_request.payer_signing_pubkey(), bob_id);
@@ -1292,7 +1293,7 @@ fn creates_and_pays_for_offer_with_retry() {
 		},
 	});
 	assert_eq!(
-		invoice_request.payable_amount_msats(),
+		invoice_request.payable_amount(&DefaultCurrencyConversion).map(|amount| amount.amount_msats()),
 		Ok(10_000_000)
 	);
 	assert_ne!(invoice_request.payer_signing_pubkey(), bob_id);
@@ -1610,7 +1611,7 @@ fn fails_authentication_when_handling_invoice_request() {
 
 	let (invoice_request, reply_path) = extract_invoice_request(alice, &onion_message);
 	assert_eq!(
-		invoice_request.payable_amount_msats(),
+		invoice_request.payable_amount(&DefaultCurrencyConversion).map(|amount| amount.amount_msats()),
 		Ok(10_000_000)
 	);
 	assert_ne!(invoice_request.payer_signing_pubkey(), david_id);
@@ -1642,7 +1643,7 @@ fn fails_authentication_when_handling_invoice_request() {
 
 	let (invoice_request, reply_path) = extract_invoice_request(alice, &onion_message);
 	assert_eq!(
-		invoice_request.payable_amount_msats(),
+		invoice_request.payable_amount(&DefaultCurrencyConversion).map(|amount| amount.amount_msats()),
 		Ok(10_000_000)
 	);
 	assert_ne!(invoice_request.payer_signing_pubkey(), david_id);
@@ -1746,7 +1747,7 @@ fn fails_authentication_when_handling_invoice_for_offer() {
 
 	let (invoice_request, reply_path) = extract_invoice_request(alice, &onion_message);
 	assert_eq!(
-		invoice_request.payable_amount_msats(),
+		invoice_request.payable_amount(&DefaultCurrencyConversion).map(|amount| amount.amount_msats()),
 		Ok(10_000_000)
 	);
 	assert_ne!(invoice_request.payer_signing_pubkey(), david_id);
@@ -2385,6 +2386,7 @@ fn fails_paying_invoice_with_unknown_required_features() {
 		.build();
 
 	let payment_id = PaymentId([1; 32]);
+	let conversion = TestCurrencyConversion;
 	david.node.pay_for_offer(&offer, None, payment_id, Default::default()).unwrap();
 
 	connect_peers(david, bob);
@@ -2420,7 +2422,9 @@ fn fails_paying_invoice_with_unknown_required_features() {
 	let invoice = match verified_invoice_request {
 		InvoiceRequestVerifiedFromOffer::DerivedKeys(request) => {
 			request
-				.respond_using_derived_keys_no_std(payment_paths,
+				.respond_using_derived_keys_no_std(
+					&conversion,
+					payment_paths,
 					payment_hash,
 					created_at,
 				)

lightning/src/ln/outbound_payment.rs

@@ -24,6 +24,7 @@ use crate::ln::channelmanager::{
 use crate::ln::msgs::DecodeError;
 use crate::ln::onion_utils;
 use crate::ln::onion_utils::{DecodedOnionFailure, HTLCFailReason};
+use crate::offers::currency::DefaultCurrencyConversion;
 use crate::offers::invoice::Bolt12Invoice;
 use crate::offers::invoice_request::InvoiceRequest;
 use crate::offers::nonce::Nonce;
@@ -655,6 +656,11 @@ pub enum Bolt12PaymentError {
 	UnexpectedInvoice,
 	/// Payment for an invoice with the corresponding [`PaymentId`] was already initiated.
 	DuplicateInvoice,
+	/// The invoice was valid for the corresponding [`PaymentId`], but quoted an invalid amount.
+	InvalidAmount,
+	/// The invoice was valid for the corresponding [`PaymentId`], but the payer could not validate
+	/// its amount because local currency conversion was unavailable.
+	UnsupportedCurrency,
 	/// The invoice was valid for the corresponding [`PaymentId`], but required unknown features.
 	UnknownRequiredFeatures,
 	/// The invoice was valid for the corresponding [`PaymentId`], but sending the payment failed.
@@ -1104,7 +1110,6 @@ impl OutboundPayments {
 		IH: Fn() -> InFlightHtlcs,
 		SP: Fn(SendAlongPathArgs) -> Result<(), APIError>,
 	{
-
 		let (payment_hash, retry_strategy, params_config, _) = self
 			.mark_invoice_received_and_get_details(invoice, payment_id)?;
 
@@ -1285,7 +1290,10 @@ impl OutboundPayments {
 						));
 					}
 
-					let amount_msat = match invreq.payable_amount_msats() {
+					let amount_msat = match invreq
+						.payable_amount(&DefaultCurrencyConversion)
+						.map(|amount| amount.amount_msats())
+					{
 						Ok(amt) => amt,
 						Err(_) => {
 							// We check this during invoice request parsing, when constructing the invreq's
@@ -2092,9 +2100,12 @@ impl OutboundPayments {
 				// event generation remains idempotent, even if the same invoice is received again before the
 				// event is handled by the user.
 				PendingOutboundPayment::InvoiceReceived {
-					retry_strategy, route_params_config, ..
+					payment_hash, retry_strategy, route_params_config,
 				} => {
-					Ok((invoice.payment_hash(), *retry_strategy, *route_params_config, false))
+					if *payment_hash != invoice.payment_hash() {
+						return Err(Bolt12PaymentError::DuplicateInvoice);
+					}
+					Ok((*payment_hash, *retry_strategy, *route_params_config, false))
 				},
 				_ => Err(Bolt12PaymentError::DuplicateInvoice),
 			},
@@ -3259,7 +3270,7 @@ mod tests {
 			.build()
 			.request_invoice(&expanded_key, nonce, &secp_ctx, payment_id).unwrap()
 			.build_and_sign().unwrap()
-			.respond_with_no_std(payment_paths(), payment_hash(), created_at).unwrap()
+			.respond_with_no_std(&TestCurrencyConversion, payment_paths(), payment_hash(), created_at).unwrap()
 			.build().unwrap()
 			.sign(recipient_sign).unwrap();
 
@@ -3309,7 +3320,7 @@ mod tests {
 			.build()
 			.request_invoice(&expanded_key, nonce, &secp_ctx, payment_id).unwrap()
 			.build_and_sign().unwrap()
-			.respond_with_no_std(payment_paths(), payment_hash(), now()).unwrap()
+			.respond_with_no_std(&conversion, payment_paths(), payment_hash(), now()).unwrap()
 			.build().unwrap()
 			.sign(recipient_sign).unwrap();
 
@@ -3375,7 +3386,7 @@ mod tests {
 			.build()
 			.request_invoice(&expanded_key, nonce, &secp_ctx, payment_id).unwrap()
 			.build_and_sign().unwrap()
-			.respond_with_no_std(payment_paths(), payment_hash(), now()).unwrap()
+			.respond_with_no_std(&conversion, payment_paths(), payment_hash(), now()).unwrap()
 			.build().unwrap()
 			.sign(recipient_sign).unwrap();