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);