Update InvoiceBuilder's amount_msats

1. The amount_msats function first checks if any amount is given with
   the invoice requests, and defaults to using offer's amount if it's
absent.
2. This can be a problem if the amount in offer was represent as a
   Currency.
3. Update amount_msats to take in an optional custom amount which can be
   used in case amount if absent in Invoice Request.
4. This update will be utilised in the following commits to set
   custom amount_msats when responding to Invoice Request Asychronously.

Author: shaavan

lightning/src/ln/channelmanager.rs

@@ -11082,7 +11082,7 @@ where
 				};
 
 				let amount_msats = match InvoiceBuilder::<DerivedSigningPubkey>::amount_msats(
-					&invoice_request.inner
+					&invoice_request.inner, None
 				) {
 					Ok(amount_msats) => amount_msats,
 					Err(error) => return Some((OffersMessage::InvoiceError(error.into()), responder.respond())),
@@ -11121,7 +11121,7 @@ where
 				let response = if invoice_request.keys.is_some() {
 					#[cfg(feature = "std")]
 					let builder = invoice_request.respond_using_derived_keys(
-						payment_paths, payment_hash
+						payment_paths, payment_hash, None
 					);
 					#[cfg(not(feature = "std"))]
 					let builder = invoice_request.respond_using_derived_keys_no_std(

lightning/src/ln/offers_tests.rs

@@ -2222,7 +2222,7 @@ fn fails_paying_invoice_with_unknown_required_features() {
 	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()
+		.respond_using_derived_keys_no_std(payment_paths, payment_hash, created_at, None).unwrap()
 		.features_unchecked(Bolt12InvoiceFeatures::unknown())
 		.build_and_sign(&secp_ctx).unwrap();
 

lightning/src/offers/invoice.rs

@@ -216,7 +216,7 @@ macro_rules! invoice_explicit_signing_pubkey_builder_methods { ($self: ident, $s
 		invoice_request: &'a InvoiceRequest, payment_paths: Vec<BlindedPaymentPath>,
 		created_at: Duration, payment_hash: PaymentHash, signing_pubkey: PublicKey
 	) -> Result<Self, Bolt12SemanticError> {
-		let amount_msats = Self::amount_msats(invoice_request)?;
+		let amount_msats = Self::amount_msats(invoice_request, None)?;
 		let contents = InvoiceContents::ForOffer {
 			invoice_request: invoice_request.contents.clone(),
 			fields: Self::fields(
@@ -272,9 +272,9 @@ macro_rules! invoice_derived_signing_pubkey_builder_methods { ($self: ident, $se
 	#[cfg_attr(c_bindings, allow(dead_code))]
 	pub(super) fn for_offer_using_keys(
 		invoice_request: &'a InvoiceRequest, payment_paths: Vec<BlindedPaymentPath>,
-		created_at: Duration, payment_hash: PaymentHash, keys: Keypair
+		created_at: Duration, payment_hash: PaymentHash, keys: Keypair, custom_amount_msats: Option<u64>
 	) -> Result<Self, Bolt12SemanticError> {
-		let amount_msats = Self::amount_msats(invoice_request)?;
+		let amount_msats = Self::amount_msats(invoice_request, custom_amount_msats)?;
 		let signing_pubkey = keys.public_key();
 		let contents = InvoiceContents::ForOffer {
 			invoice_request: invoice_request.contents.clone(),
@@ -340,18 +340,29 @@ macro_rules! invoice_builder_methods { (
 	$self: ident, $self_type: ty, $return_type: ty, $return_value: expr, $type_param: ty $(, $self_mut: tt)?
 ) => {
 	pub(crate) fn amount_msats(
-		invoice_request: &InvoiceRequest
+		invoice_request: &InvoiceRequest, custom_amount_msats: Option<u64>
 	) -> Result<u64, Bolt12SemanticError> {
-		match invoice_request.amount_msats() {
-			Some(amount_msats) => Ok(amount_msats),
-			None => match invoice_request.contents.inner.offer.amount() {
-				Some(Amount::Bitcoin { amount_msats }) => {
-					amount_msats.checked_mul(invoice_request.quantity().unwrap_or(1))
-						.ok_or(Bolt12SemanticError::InvalidAmount)
-				},
-				Some(Amount::Currency { .. }) => Err(Bolt12SemanticError::UnsupportedCurrency),
-				None => Err(Bolt12SemanticError::MissingAmount),
-			},
+		if invoice_request.amount_msats().is_some() && custom_amount_msats.is_some() {
+			return Err(Bolt12SemanticError::UnexpectedAmount);
+		}
+
+		if let Some(amount_msats) = invoice_request.amount_msats() {
+			return Ok(amount_msats);
+		}
+
+		if let Some(custom_amount_msats) = custom_amount_msats {
+			return Ok(custom_amount_msats);
+		}
+
+		match invoice_request.contents.inner.offer.amount() {
+			Some(Amount::Bitcoin { amount_msats }) => {
+				let quantity = invoice_request.quantity().unwrap_or(1);
+				amount_msats
+					.checked_mul(quantity)
+					.ok_or(Bolt12SemanticError::InvalidAmount)
+			}
+			Some(Amount::Currency { .. }) => Err(Bolt12SemanticError::UnsupportedCurrency),
+			None => Err(Bolt12SemanticError::MissingAmount),
 		}
 	}
 
@@ -1778,7 +1789,7 @@ mod tests {
 
 		if let Err(e) = 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()
+			.respond_using_derived_keys_no_std(payment_paths(), payment_hash(), now(), None).unwrap()
 			.build_and_sign(&secp_ctx)
 		{
 			panic!("error building invoice: {:?}", e);
@@ -1799,7 +1810,7 @@ mod tests {
 
 		match invoice_request
 			.verify_using_metadata(&expanded_key, &secp_ctx).unwrap()
-			.respond_using_derived_keys_no_std(payment_paths(), payment_hash(), now())
+			.respond_using_derived_keys_no_std(payment_paths(), payment_hash(), now(), None)
 		{
 			Ok(_) => panic!("expected error"),
 			Err(e) => assert_eq!(e, Bolt12SemanticError::InvalidMetadata),

lightning/src/offers/invoice_request.rs

@@ -884,13 +884,13 @@ macro_rules! invoice_request_respond_with_derived_signing_pubkey_methods { (
 	/// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
 	#[cfg(feature = "std")]
 	pub fn respond_using_derived_keys(
-		&$self, payment_paths: Vec<BlindedPaymentPath>, payment_hash: PaymentHash
+		&$self, payment_paths: Vec<BlindedPaymentPath>, payment_hash: PaymentHash, custom_amount_msats: Option<u64>
 	) -> Result<$builder, Bolt12SemanticError> {
 		let created_at = std::time::SystemTime::now()
 			.duration_since(std::time::SystemTime::UNIX_EPOCH)
 			.expect("SystemTime::now() should come after SystemTime::UNIX_EPOCH");
 
-		$self.respond_using_derived_keys_no_std(payment_paths, payment_hash, created_at)
+		$self.respond_using_derived_keys_no_std(payment_paths, payment_hash, created_at, custom_amount_msats)
 	}
 
 	/// Creates an [`InvoiceBuilder`] for the request using the given required fields and that uses
@@ -902,7 +902,7 @@ macro_rules! invoice_request_respond_with_derived_signing_pubkey_methods { (
 	/// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
 	pub fn respond_using_derived_keys_no_std(
 		&$self, payment_paths: Vec<BlindedPaymentPath>, payment_hash: PaymentHash,
-		created_at: core::time::Duration
+		created_at: core::time::Duration, custom_amount_msats: Option<u64>
 	) -> Result<$builder, Bolt12SemanticError> {
 		if $self.inner.invoice_request_features().requires_unknown_bits() {
 			return Err(Bolt12SemanticError::UnknownRequiredFeatures);
@@ -919,7 +919,7 @@ macro_rules! invoice_request_respond_with_derived_signing_pubkey_methods { (
 		}
 
 		<$builder>::for_offer_using_keys(
-			&$self.inner, payment_paths, created_at, payment_hash, keys
+			&$self.inner, payment_paths, created_at, payment_hash, keys, custom_amount_msats
 		)
 	}
 } }