f: add end-to-end functional test

Author: a-mpch

lightning/src/ln/async_payments_tests.rs

@@ -23,8 +23,7 @@ use crate::ln::msgs::{
 };
 use crate::ln::offers_tests;
 use crate::ln::onion_utils::LocalHTLCFailureReason;
-use crate::ln::outbound_payment::PendingOutboundPayment;
-use crate::ln::outbound_payment::Retry;
+use crate::ln::outbound_payment::{PendingOutboundPayment, Retry, TEST_ASYNC_PAYMENT_TIMEOUT_RELATIVE_EXPIRY};
 use crate::offers::async_receive_offer_cache::{
 	TEST_MAX_CACHED_OFFERS_TARGET, TEST_MAX_UPDATE_ATTEMPTS,
 	TEST_MIN_OFFER_PATHS_RELATIVE_EXPIRY_SECS, TEST_OFFER_REFRESH_THRESHOLD,
@@ -681,6 +680,79 @@ fn expired_static_invoice_fail() {
 	// doesn't currently provide them with a reply path to do so.
 }
 
+#[cfg_attr(feature = "std", ignore)]
+#[test]
+fn timeout_unreleased_payment() {
+	// If a server holds a pending HTLC for too long, payment is considered expired.
+	let chanmon_cfgs = create_chanmon_cfgs(3);
+	let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
+	let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
+	let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+	create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
+	create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
+
+	let sender = &nodes[0];
+	let server = &nodes[1];
+	let recipient = &nodes[2];
+
+	let recipient_id = vec![42; 32];
+	let inv_server_paths = server.node.blinded_paths_for_async_recipient(recipient_id.clone(), None).unwrap();
+	recipient.node.set_paths_to_static_invoice_server(inv_server_paths).unwrap();
+
+	let static_invoice =
+		pass_static_invoice_server_messages(server, recipient, recipient_id.clone()).invoice;
+	let offer = recipient.node.get_async_receive_offer().unwrap();
+
+	let amt_msat = 5000;
+	let payment_id = PaymentId([1; 32]);
+	let params = RouteParametersConfig::default();
+	sender
+		.node
+		.pay_for_offer(&offer, None, Some(amt_msat), None, payment_id, Retry::Attempts(0), params)
+		.unwrap();
+
+	let invreq_om = sender
+		.onion_messenger
+		.next_onion_message_for_peer(server.node.get_our_node_id())
+		.unwrap();
+	server.onion_messenger.handle_onion_message(sender.node.get_our_node_id(), &invreq_om);
+
+	let mut events = server.node.get_and_clear_pending_events();
+	assert_eq!(events.len(), 1);
+	let reply_path = match events.pop().unwrap() {
+		Event::StaticInvoiceRequested { reply_path, .. } => reply_path,
+		_ => panic!(),
+	};
+
+	server.node.send_static_invoice(static_invoice.clone(), reply_path).unwrap();
+	let static_invoice_om = server
+		.onion_messenger
+		.next_onion_message_for_peer(sender.node.get_our_node_id())
+		.unwrap();
+
+	// We handle the static invoice to held the pending HTLC
+	sender
+		.onion_messenger
+		.handle_onion_message(sender.node.get_our_node_id(), &static_invoice_om);
+
+	// We advance enough time to expire the payment.
+	// We add 2 hours as is the margin added to remove stale payments in non-std implementation.
+	let timeout_time_expiry = TEST_ASYNC_PAYMENT_TIMEOUT_RELATIVE_EXPIRY
+								+ Duration::from_secs(7200)
+								+ Duration::from_secs(1);
+	advance_time_by(timeout_time_expiry, sender);
+	sender.node.timer_tick_occurred();
+	let events = sender.node.get_and_clear_pending_events();
+	assert_eq!(events.len(), 1);
+	match events[0] {
+		Event::PaymentFailed { payment_id: ev_payment_id, reason, .. } => {
+			assert_eq!(reason.unwrap(), PaymentFailureReason::PaymentExpired);
+			assert_eq!(ev_payment_id, payment_id);
+		},
+		_ => panic!(),
+	}
+}
+
 #[test]
 fn async_receive_mpp() {
 	let chanmon_cfgs = create_chanmon_cfgs(4);

lightning/src/ln/outbound_payment.rs

@@ -59,6 +59,9 @@ pub(crate) const IDEMPOTENCY_TIMEOUT_TICKS: u8 = 7;
 /// payee to fulfill.
 const ASYNC_PAYMENT_TIMEOUT_RELATIVE_EXPIRY: Duration = Duration::from_secs(60 * 60 * 24 * 7);
 
+#[cfg(all(async_payments, test))]
+pub(crate) const TEST_ASYNC_PAYMENT_TIMEOUT_RELATIVE_EXPIRY: Duration  = ASYNC_PAYMENT_TIMEOUT_RELATIVE_EXPIRY;
+
 /// Stores the session_priv for each part of a payment that is still pending. For versions 0.0.102
 /// and later, also stores information for retrying the payment.
 pub(crate) enum PendingOutboundPayment {
@@ -3361,109 +3364,6 @@ mod tests {
 		}, None));
 	}
 
-	#[test]
-	#[rustfmt::skip]
-	fn time_out_unreleased_async_payments_using_stale_absolute_time() {
-		let pending_events = Mutex::new(VecDeque::new());
-		let outbound_payments = OutboundPayments::new(new_hash_map());
-		let payment_id = PaymentId([0; 32]);
-		let absolute_expiry = 60;
-
-		let mut outbounds = outbound_payments.pending_outbound_payments.lock().unwrap();
-		let payment_params = PaymentParameters::from_node_id(test_utils::pubkey(42), 0)
-			.with_expiry_time(absolute_expiry);
-		let route_params = RouteParameters {
-			payment_params,
-			final_value_msat: 0,
-			max_total_routing_fee_msat: None,
-		};
-		let payment_hash = PaymentHash([0; 32]);
-		let outbound = PendingOutboundPayment::StaticInvoiceReceived {
-			payment_hash,
-			keysend_preimage: PaymentPreimage([0; 32]),
-			retry_strategy: Retry::Attempts(0),
-			route_params,
-			invoice_request: dummy_invoice_request(),
-			static_invoice: dummy_static_invoice(),
-			expiry_time: StaleExpiration::AbsoluteTimeout(Duration::from_secs(absolute_expiry)),
-		};
-		outbounds.insert(payment_id, outbound);
-		core::mem::drop(outbounds);
-
-		// The payment will not be removed if it isn't expired yet.
-		outbound_payments.remove_stale_payments(Duration::from_secs(absolute_expiry), &pending_events);
-		let outbounds = outbound_payments.pending_outbound_payments.lock().unwrap();
-		assert_eq!(outbounds.len(), 1);
-		let events = pending_events.lock().unwrap();
-		assert_eq!(events.len(), 0);
-		core::mem::drop(outbounds);
-		core::mem::drop(events);
-
-		outbound_payments.remove_stale_payments(Duration::from_secs(absolute_expiry + 1), &pending_events);
-		let outbounds = outbound_payments.pending_outbound_payments.lock().unwrap();
-		assert_eq!(outbounds.len(), 0);
-		let events = pending_events.lock().unwrap();
-		assert_eq!(events.len(), 1);
-		assert_eq!(events[0], (Event::PaymentFailed {
-			payment_hash: Some(payment_hash),
-			payment_id,
-			reason: Some(PaymentFailureReason::PaymentExpired),
-		}, None));
-	}
-
-	#[test]
-	#[rustfmt::skip]
-	fn time_out_unreleased_async_payments_using_stale_timer_ticks() {
-		let pending_events = Mutex::new(VecDeque::new());
-		let outbound_payments = OutboundPayments::new(new_hash_map());
-		let payment_id = PaymentId([0; 32]);
-		let absolute_expiry = 60;
-
-		let mut outbounds = outbound_payments.pending_outbound_payments.lock().unwrap();
-		let payment_params = PaymentParameters::from_node_id(test_utils::pubkey(42), 0)
-			.with_expiry_time(absolute_expiry);
-		let route_params = RouteParameters {
-			payment_params,
-			final_value_msat: 0,
-			max_total_routing_fee_msat: None,
-		};
-		let payment_hash = PaymentHash([0; 32]);
-		let timer_ticks = 1;
-		let expiration = StaleExpiration::TimerTicks(timer_ticks);
-		let outbound = PendingOutboundPayment::StaticInvoiceReceived {
-			payment_hash,
-			keysend_preimage: PaymentPreimage([0; 32]),
-			retry_strategy: Retry::Attempts(0),
-			route_params,
-			invoice_request: dummy_invoice_request(),
-			static_invoice: dummy_static_invoice(),
-			expiry_time: expiration,
-		};
-		outbounds.insert(payment_id, outbound);
-		core::mem::drop(outbounds);
-
-		// First time should go through
-		outbound_payments.remove_stale_payments(Duration::from_secs(absolute_expiry), &pending_events);
-		let outbounds = outbound_payments.pending_outbound_payments.lock().unwrap();
-		assert_eq!(outbounds.len(), 1);
-		let events = pending_events.lock().unwrap();
-		assert_eq!(events.len(), 0);
-		core::mem::drop(outbounds);
-		core::mem::drop(events);
-
-		// As timer ticks is 1, payment should be timed out
-		outbound_payments.remove_stale_payments(Duration::from_secs(absolute_expiry), &pending_events);
-		let outbounds = outbound_payments.pending_outbound_payments.lock().unwrap();
-		assert_eq!(outbounds.len(), 0);
-		let events = pending_events.lock().unwrap();
-		assert_eq!(events.len(), 1);
-		assert_eq!(events[0], (Event::PaymentFailed {
-			payment_hash: Some(payment_hash),
-			payment_id,
-			reason: Some(PaymentFailureReason::PaymentExpired),
-		}, None));
-	}
-
 	#[test]
 	#[rustfmt::skip]
 	fn abandon_unreleased_async_payment() {