Include invoice requests in async payment onions

fuzz/src/onion_message.rs

@@ -121,16 +121,16 @@ impl OffersMessageHandler for TestOffersMessageHandler {
 struct TestAsyncPaymentsMessageHandler {}
 
 impl AsyncPaymentsMessageHandler for TestAsyncPaymentsMessageHandler {
-	fn held_htlc_available(
- &self, message: HeldHtlcAvailable, responder: Option<Responder>,
+	fn handle_held_htlc_available(
+ &self, _message: HeldHtlcAvailable, responder: Option<Responder>,
 	) -> Option<(ReleaseHeldHtlc, ResponseInstruction)> {
  let responder = match responder {
  Some(resp) => resp,
  None => return None,
  };
  Some((ReleaseHeldHtlc {}, responder.respond()))
 	}
-	fn release_held_htlc(&self, _message: ReleaseHeldHtlc, _context: AsyncPaymentsContext) {}
+	fn handle_release_held_htlc(&self, _message: ReleaseHeldHtlc, _context: AsyncPaymentsContext) {}
 }
 
 #[derive(Debug)]

lightning/src/events/mod.rs

@@ -560,11 +560,15 @@ pub enum PaymentFailureReason {
 	/// [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
 	/// [`InvoiceRequestExpired`]: Self::InvoiceRequestExpired
 	PaymentExpired,
-	/// We failed to find a route while retrying the payment.
+	/// We failed to find a route while sending or retrying the payment.
 	///
 	/// Note that this generally indicates that we've exhausted the available set of possible
 	/// routes - we tried the payment over a few routes but were not able to find any further
 	/// candidate routes beyond those.
+	///
+	/// Also used for [`BlindedPathCreationFailed`] when downgrading to versions prior to 0.0.124.
+	///
+	/// [`BlindedPathCreationFailed`]: Self::BlindedPathCreationFailed
 	RouteNotFound,
 	/// This error should generally never happen. This likely means that there is a problem with
 	/// your router.
@@ -577,6 +581,12 @@ pub enum PaymentFailureReason {
 	///
 	/// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest
 	InvoiceRequestRejected,
+	/// Failed to create a blinded path back to ourselves.
+	/// We attempted to initiate payment to a static invoice but failed to create a reply path for our
+	/// [`HeldHtlcAvailable`] message.
+	///
+	/// [`HeldHtlcAvailable`]: crate::onion_message::async_payments::HeldHtlcAvailable
+	BlindedPathCreationFailed,
 }
 
 impl_writeable_tlv_based_enum_upgradable!(PaymentFailureReason,
@@ -587,6 +597,7 @@ impl_writeable_tlv_based_enum_upgradable!(PaymentFailureReason,
 	(4, RetriesExhausted) => {},
 	(5, InvoiceRequestRejected) => {},
 	(6, PaymentExpired) => {},
+	(7, BlindedPathCreationFailed) => {},
 	(8, RouteNotFound) => {},
 	(10, UnexpectedError) => {},
 );
@@ -1651,6 +1662,8 @@ impl Writeable for Event {
  &Some(PaymentFailureReason::RetriesExhausted),
  Some(PaymentFailureReason::InvoiceRequestRejected) =>
  &Some(PaymentFailureReason::RecipientRejected),
+ Some(PaymentFailureReason::BlindedPathCreationFailed) =>
+ &Some(PaymentFailureReason::RouteNotFound)
  };
  write_tlv_fields!(writer, {
  (0, payment_id, required),

lightning/src/ln/blinded_payment_tests.rs

@@ -318,7 +318,7 @@ fn do_forward_checks_failure(check: ForwardCheckFail, intro_fails: bool) {
  let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
  let cur_height = nodes[0].best_block_info().1;
  let (mut onion_payloads, ..) = onion_utils::build_onion_payloads(
- &route.paths[0], amt_msat, &recipient_onion_fields, cur_height, &None).unwrap();
+ &route.paths[0], amt_msat, &recipient_onion_fields, cur_height, &None, None).unwrap();
  // Remove the receive payload so the blinded forward payload is encoded as a final payload
  // (i.e. next_hop_hmac == [0; 32])
  onion_payloads.pop();
@@ -897,7 +897,7 @@ fn do_multi_hop_receiver_fail(check: ReceiveCheckFail) {
  let cur_height = nodes[0].best_block_info().1;
  let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
  let (mut onion_payloads, ..) = onion_utils::build_onion_payloads(
- &route.paths[0], amt_msat, &recipient_onion_fields, cur_height, &None).unwrap();
+ &route.paths[0], amt_msat, &recipient_onion_fields, cur_height, &None, None).unwrap();
 
  let update_add = &mut payment_event_1_2.msgs[0];
  onion_payloads.last_mut().map(|p| {
@@ -1447,7 +1447,7 @@ fn route_blinding_spec_test_vector() {
  }),
 	};
 	let cur_height = 747_000;
-	let (bob_onion, _, _) = onion_utils::create_payment_onion(&secp_ctx, &path, &session_priv, amt_msat, &RecipientOnionFields::spontaneous_empty(), cur_height, &PaymentHash([0; 32]), &None, [0; 32]).unwrap();
+	let (bob_onion, _, _) = onion_utils::create_payment_onion(&secp_ctx, &path, &session_priv, amt_msat, &RecipientOnionFields::spontaneous_empty(), cur_height, &PaymentHash([0; 32]), &None, None, [0; 32]).unwrap();
 
 	struct TestEcdhSigner {
  node_secret: SecretKey,

lightning/src/ln/channelmanager.rs

@@ -4179,14 +4179,14 @@ where
  let _lck = self.total_consistency_lock.read().unwrap();
  self.send_payment_along_path(SendAlongPathArgs {
  path, payment_hash, recipient_onion: &recipient_onion, total_value,
- cur_height, payment_id, keysend_preimage, session_priv_bytes
+ cur_height, payment_id, keysend_preimage, invoice_request: None, session_priv_bytes
  })
 	}
 
 	fn send_payment_along_path(&self, args: SendAlongPathArgs) -> Result<(), APIError> {
  let SendAlongPathArgs {
  path, payment_hash, recipient_onion, total_value, cur_height, payment_id, keysend_preimage,
- session_priv_bytes
+invoice_request, session_priv_bytes
  } = args;
  // The top-level caller should hold the total_consistency_lock read lock.
  debug_assert!(self.total_consistency_lock.try_write().is_err());
@@ -4195,7 +4195,7 @@ where
 
  let (onion_packet, htlc_msat, htlc_cltv) = onion_utils::create_payment_onion(
  &self.secp_ctx, &path, &session_priv, total_value, recipient_onion, cur_height,
- payment_hash, keysend_preimage, prng_seed
+ payment_hash, keysend_preimage, invoice_request, prng_seed
  ).map_err(|e| {
  let logger = WithContext::from(&self.logger, Some(path.hops.first().unwrap().pubkey), None, Some(*payment_hash));
  log_error!(logger, "Failed to build an onion for path for payment hash {}", payment_hash);
@@ -4463,7 +4463,7 @@ where
  ) {
  Ok(paths) => paths,
  Err(()) => {
- self.abandon_payment_with_reason(payment_id, PaymentFailureReason::RouteNotFound);
+ self.abandon_payment_with_reason(payment_id, PaymentFailureReason::BlindedPathCreationFailed);
  res = Err(Bolt12PaymentError::BlindedPathCreationFailed);
  return NotifyOption::DoPersist
  }
@@ -11327,13 +11327,13 @@ where
 	MR::Target: MessageRouter,
 	L::Target: Logger,
 {
-	fn held_htlc_available(
+	fn handle_held_htlc_available(
  &self, _message: HeldHtlcAvailable, _responder: Option<Responder>
 	) -> Option<(ReleaseHeldHtlc, ResponseInstruction)> {
  None
 	}
 
-	fn release_held_htlc(&self, _message: ReleaseHeldHtlc, _context: AsyncPaymentsContext) {
+	fn handle_release_held_htlc(&self, _message: ReleaseHeldHtlc, _context: AsyncPaymentsContext) {
  #[cfg(async_payments)] {
  let AsyncPaymentsContext::OutboundPayment { payment_id, hmac, nonce } = _context;
  if payment_id.verify_for_async_payment(hmac, nonce, &self.inbound_payment_key).is_err() { return }

lightning/src/ln/functional_tests.rs

@@ -1438,7 +1438,7 @@ fn test_fee_spike_violation_fails_htlc() {
 	let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
 	let recipient_onion_fields = RecipientOnionFields::secret_only(payment_secret);
 	let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0],
- 3460001, &recipient_onion_fields, cur_height, &None).unwrap();
+ 3460001, &recipient_onion_fields, cur_height, &None, None).unwrap();
 	let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash).unwrap();
 	let msg = msgs::UpdateAddHTLC {
  channel_id: chan.2,
@@ -1637,7 +1637,7 @@ fn test_chan_reserve_violation_inbound_htlc_outbound_channel() {
 	let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
 	let recipient_onion_fields = RecipientOnionFields::secret_only(payment_secret);
 	let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0],
- 700_000, &recipient_onion_fields, cur_height, &None).unwrap();
+ 700_000, &recipient_onion_fields, cur_height, &None, None).unwrap();
 	let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash).unwrap();
 	let msg = msgs::UpdateAddHTLC {
  channel_id: chan.2,
@@ -1817,7 +1817,7 @@ fn test_chan_reserve_violation_inbound_htlc_inbound_chan() {
 	let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route_2.paths[0], &session_priv).unwrap();
 	let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
 	let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(
- &route_2.paths[0], recv_value_2, &recipient_onion_fields, cur_height, &None).unwrap();
+ &route_2.paths[0], recv_value_2, &recipient_onion_fields, cur_height, &None, None).unwrap();
 	let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &our_payment_hash_1).unwrap();
 	let msg = msgs::UpdateAddHTLC {
  channel_id: chan.2,
@@ -3556,7 +3556,7 @@ fn fail_backward_pending_htlc_upon_channel_failure() {
  let current_height = nodes[1].node.best_block.read().unwrap().height + 1;
  let recipient_onion_fields = RecipientOnionFields::secret_only(payment_secret);
  let (onion_payloads, _amount_msat, cltv_expiry) = onion_utils::build_onion_payloads(
- &route.paths[0], 50_000, &recipient_onion_fields, current_height, &None).unwrap();
+ &route.paths[0], 50_000, &recipient_onion_fields, current_height, &None, None).unwrap();
  let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
  let onion_routing_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash).unwrap();
 
@@ -6548,7 +6548,7 @@ fn test_update_add_htlc_bolt2_receiver_check_max_htlc_limit() {
 	let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::signing_only(), &route.paths[0], &session_priv).unwrap();
 	let recipient_onion_fields = RecipientOnionFields::secret_only(our_payment_secret);
 	let (onion_payloads, _htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(
- &route.paths[0], send_amt, &recipient_onion_fields, cur_height, &None).unwrap();
+ &route.paths[0], send_amt, &recipient_onion_fields, cur_height, &None, None).unwrap();
 	let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &our_payment_hash).unwrap();
 
 	let mut msg = msgs::UpdateAddHTLC {
@@ -8291,7 +8291,7 @@ fn test_onion_value_mpp_set_calculation() {
  let mut onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
  let recipient_onion_fields = RecipientOnionFields::secret_only(our_payment_secret);
  let (mut onion_payloads, _, _) = onion_utils::build_onion_payloads(&route.paths[0], 100_000,
- &recipient_onion_fields, height + 1, &None).unwrap();
+ &recipient_onion_fields, height + 1, &None, None).unwrap();
  // Edit amt_to_forward to simulate the sender having set
  // the final amount and the routing node taking less fee
  if let msgs::OutboundOnionPayload::Receive {

lightning/src/ln/max_payment_path_len_tests.rs

@@ -110,7 +110,7 @@ fn large_payment_metadata() {
 	let secp_ctx = Secp256k1::signing_only();
 	route_0_1.paths[0].hops[0].fee_msat = MIN_FINAL_VALUE_ESTIMATE_WITH_OVERPAY;
 	route_0_1.paths[0].hops[0].cltv_expiry_delta = DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA;
-	let err = onion_utils::create_payment_onion(&secp_ctx, &route_0_1.paths[0], &test_utils::privkey(42), MIN_FINAL_VALUE_ESTIMATE_WITH_OVERPAY, &recipient_onion_too_large_md, nodes[0].best_block_info().1 + DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, &payment_hash, &None, [0; 32]).unwrap_err();
+	let err = onion_utils::create_payment_onion(&secp_ctx, &route_0_1.paths[0], &test_utils::privkey(42), MIN_FINAL_VALUE_ESTIMATE_WITH_OVERPAY, &recipient_onion_too_large_md, nodes[0].best_block_info().1 + DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, &payment_hash, &None, None, [0; 32]).unwrap_err();
 	match err {
  APIError::InvalidRoute { err } => {
  assert_eq!(err, "Route size too large considering onion data");
@@ -184,6 +184,7 @@ fn one_hop_blinded_path_with_custom_tlv() {
  encrypted_tlvs: &blinded_path.blinded_hops()[0].encrypted_payload,
  intro_node_blinding_point: Some(blinded_path.blinding_point()),
  keysend_preimage: None,
+ invoice_request: None,
  custom_tlvs: &Vec::new()
 	}.serialized_length();
 	let max_custom_tlv_len = 1300
@@ -275,7 +276,7 @@ fn blinded_path_with_custom_tlv() {
 	let reserved_packet_bytes_without_custom_tlv: usize = onion_utils::build_onion_payloads(
  &route.paths[0], MIN_FINAL_VALUE_ESTIMATE_WITH_OVERPAY,
  &RecipientOnionFields::spontaneous_empty(),
- nodes[0].best_block_info().1 + DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, &None
+ nodes[0].best_block_info().1 + DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, &None, None
 	)
  .unwrap()
  .0
@@ -317,7 +318,7 @@ fn blinded_path_with_custom_tlv() {
 	let secp_ctx = Secp256k1::signing_only();
 	route.paths[0].hops[0].fee_msat = MIN_FINAL_VALUE_ESTIMATE_WITH_OVERPAY;
 	route.paths[0].hops[0].cltv_expiry_delta = DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA;
-	let err = onion_utils::create_payment_onion(&secp_ctx, &route.paths[0], &test_utils::privkey(42), MIN_FINAL_VALUE_ESTIMATE_WITH_OVERPAY, &recipient_onion_too_large_custom_tlv, nodes[0].best_block_info().1 + DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, &payment_hash, &None, [0; 32]).unwrap_err();
+	let err = onion_utils::create_payment_onion(&secp_ctx, &route.paths[0], &test_utils::privkey(42), MIN_FINAL_VALUE_ESTIMATE_WITH_OVERPAY, &recipient_onion_too_large_custom_tlv, nodes[0].best_block_info().1 + DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, &payment_hash, &None, None, [0; 32]).unwrap_err();
 	match err {
  APIError::InvalidRoute { err } => {
  assert_eq!(err, "Route size too large considering onion data");

lightning/src/ln/msgs.rs

@@ -1747,6 +1747,7 @@ pub struct FinalOnionHopData {
 mod fuzzy_internal_msgs {
 	use bitcoin::secp256k1::PublicKey;
 	use crate::blinded_path::payment::{BlindedPaymentPath, PaymentConstraints, PaymentContext, PaymentRelay};
+	use crate::offers::invoice_request::InvoiceRequest;
 	use crate::types::payment::{PaymentPreimage, PaymentSecret};
 	use crate::types::features::{BlindedHopFeatures, Bolt12InvoiceFeatures};
 	use super::{FinalOnionHopData, TrampolineOnionPacket};
@@ -1827,6 +1828,7 @@ mod fuzzy_internal_msgs {
  intro_node_blinding_point: Option<PublicKey>, // Set if the introduction node of the blinded path is the final node
  keysend_preimage: Option<PaymentPreimage>,
  custom_tlvs: &'a Vec<(u64, Vec<u8>)>,
+ invoice_request: Option<&'a InvoiceRequest>,
  }
 	}
 
@@ -2760,13 +2762,17 @@ impl<'a> Writeable for OutboundOnionPayload<'a> {
  },
  Self::BlindedReceive {
  sender_intended_htlc_amt_msat, total_msat, cltv_expiry_height, encrypted_tlvs,
- intro_node_blinding_point, keysend_preimage, ref custom_tlvs,
+ intro_node_blinding_point, keysend_preimage, ref invoice_request, ref custom_tlvs,
  } => {
  // We need to update [`ln::outbound_payment::RecipientOnionFields::with_custom_tlvs`]
  // to reject any reserved types in the experimental range if new ones are ever
  // standardized.
+ let invoice_request_tlv = invoice_request.map(|invreq| (77_777, invreq.encode())); // TODO: update TLV type once the async payments spec is merged
  let keysend_tlv = keysend_preimage.map(|preimage| (5482373484, preimage.encode()));
- let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter().chain(keysend_tlv.iter()).collect();
+ let mut custom_tlvs: Vec<&(u64, Vec<u8>)> = custom_tlvs.iter()
+ .chain(invoice_request_tlv.iter())
+ .chain(keysend_tlv.iter())
+ .collect();
  custom_tlvs.sort_unstable_by_key(|(typ, _)| *typ);
  _encode_varint_length_prefixed_tlv!(w, {
  (2, HighZeroBytesDroppedBigSize(*sender_intended_htlc_amt_msat), required),

lightning/src/ln/onion_payment.rs

@@ -541,7 +541,7 @@ mod tests {
  let path = Path { hops, blinded_tail: None, };
  let onion_keys = super::onion_utils::construct_onion_keys(&secp_ctx, &path, &session_priv).unwrap();
  let (onion_payloads, ..) = super::onion_utils::build_onion_payloads(
- &path, total_amt_msat, &recipient_onion, cur_height + 1, &Some(keysend_preimage)
+ &path, total_amt_msat, &recipient_onion, cur_height + 1, &Some(keysend_preimage), None
  ).unwrap();
 
  assert!(super::onion_utils::construct_onion_packet(
@@ -569,7 +569,7 @@ mod tests {
 
  let (onion, amount_msat, cltv_expiry) = create_payment_onion(
  &secp_ctx, &path, &session_priv, total_amt_msat, &recipient_onion,
- cur_height, &payment_hash, &Some(preimage), prng_seed
+ cur_height, &payment_hash, &Some(preimage), None, prng_seed
  ).unwrap();
 
  let msg = make_update_add_msg(amount_msat, cltv_expiry, payment_hash, onion);

lightning/src/ln/onion_route_tests.rs

@@ -356,7 +356,7 @@ fn test_onion_failure() {
  let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
  let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
  let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(
- &route.paths[0], 40000, &recipient_onion_fields, cur_height, &None).unwrap();
+ &route.paths[0], 40000, &recipient_onion_fields, cur_height, &None, None).unwrap();
  let mut new_payloads = Vec::new();
  for payload in onion_payloads.drain(..) {
  new_payloads.push(BogusOnionHopData::new(payload));
@@ -375,7 +375,7 @@ fn test_onion_failure() {
  let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
  let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
  let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(
- &route.paths[0], 40000, &recipient_onion_fields, cur_height, &None).unwrap();
+ &route.paths[0], 40000, &recipient_onion_fields, cur_height, &None, None).unwrap();
  let mut new_payloads = Vec::new();
  for payload in onion_payloads.drain(..) {
  new_payloads.push(BogusOnionHopData::new(payload));
@@ -627,7 +627,7 @@ fn test_onion_failure() {
  let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
  let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
  let (onion_payloads, _, htlc_cltv) = onion_utils::build_onion_payloads(
- &route.paths[0], 40000, &recipient_onion_fields, height, &None).unwrap();
+ &route.paths[0], 40000, &recipient_onion_fields, height, &None, None).unwrap();
  let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash).unwrap();
  msg.cltv_expiry = htlc_cltv;
  msg.onion_routing_packet = onion_packet;
@@ -964,7 +964,7 @@ fn test_always_create_tlv_format_onion_payloads() {
 	let cur_height = nodes[0].best_block_info().1 + 1;
 	let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
 	let (onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(
- &route.paths[0], 40000, &recipient_onion_fields, cur_height, &None).unwrap();
+ &route.paths[0], 40000, &recipient_onion_fields, cur_height, &None, None).unwrap();
 
 	match onion_payloads[0] {
  msgs::OutboundOnionPayload::Forward {..} => {},
@@ -1221,7 +1221,7 @@ fn test_phantom_invalid_onion_payload() {
  let recipient_onion_fields = RecipientOnionFields::secret_only(payment_secret);
  let (mut onion_payloads, _, _) = onion_utils::build_onion_payloads(
  &route.paths[0], msgs::MAX_VALUE_MSAT + 1,
- &recipient_onion_fields, height + 1, &None).unwrap();
+ &recipient_onion_fields, height + 1, &None, None).unwrap();
  // We only want to construct the onion packet for the last hop, not the entire route, so
  // remove the first hop's payload and its keys.
  onion_keys.remove(0);