Fail earlier on expired static invoice

Prior to this patch, if we received an expired static invoice we would delay
surfacing the payment failure until after the recipient had come online and
sent the release_held_htlc OM, which could be a long time later. Now, we'll
detect that the invoice is expired as soon as it's received.

Author: valentinewallace

lightning/src/ln/async_payments_tests.rs

@@ -579,3 +579,74 @@ fn pays_static_invoice() {
 		.handle_onion_message(nodes[2].node.get_our_node_id(), &release_held_htlc_om);
 	assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 }
+
+#[cfg_attr(feature = "std", ignore)]
+#[test]
+fn expired_static_invoice_fail() {
+	// Test that if we receive an expired static invoice we'll fail the payment.
+	let secp_ctx = Secp256k1::new();
+	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);
+
+	const INVOICE_EXPIRY_SECS: u32 = 10;
+	let relative_expiry = Duration::from_secs(INVOICE_EXPIRY_SECS as u64);
+	let (offer, static_invoice) =
+		create_static_invoice(&nodes[1], &nodes[2], Some(relative_expiry), &secp_ctx);
+
+	let amt_msat = 5000;
+	let payment_id = PaymentId([1; 32]);
+	nodes[0]
+		.node
+		.pay_for_offer(&offer, None, Some(amt_msat), None, payment_id, Retry::Attempts(0), None)
+		.unwrap();
+
+	let invreq_om = nodes[0]
+		.onion_messenger
+		.next_onion_message_for_peer(nodes[1].node.get_our_node_id())
+		.unwrap();
+	let invreq_reply_path = offers_tests::extract_invoice_request(&nodes[1], &invreq_om).1;
+	// TODO: update to not manually send here when we add support for being the recipient's
+	// always-online counterparty
+	nodes[1]
+		.onion_messenger
+		.send_onion_message(
+			ParsedOnionMessageContents::<Infallible>::Offers(OffersMessage::StaticInvoice(
+				static_invoice,
+			)),
+			MessageSendInstructions::WithoutReplyPath {
+				destination: Destination::BlindedPath(invreq_reply_path),
+			},
+		)
+		.unwrap();
+	let static_invoice_om = nodes[1]
+		.onion_messenger
+		.next_onion_message_for_peer(nodes[0].node.get_our_node_id())
+		.unwrap();
+
+	// Wait until the static invoice expires before providing it to the sender.
+	let block = create_dummy_block(
+		nodes[0].best_block_hash(),
+		nodes[0].node.duration_since_epoch().as_secs() as u32 + INVOICE_EXPIRY_SECS + 1,
+		Vec::new(),
+	);
+	connect_block(&nodes[0], &block);
+	nodes[0]
+		.onion_messenger
+		.handle_onion_message(nodes[1].node.get_our_node_id(), &static_invoice_om);
+
+	let events = nodes[0].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!(),
+	}
+	// The sender doesn't reply with InvoiceError right now because the always-online node doesn't
+	// currently provide them with a reply path to do so.
+}

lightning/src/ln/channelmanager.rs

@@ -4757,8 +4757,8 @@ where
 			let best_block_height = self.best_block.read().unwrap().height;
 			let features = self.bolt12_invoice_features();
 			let outbound_pmts_res = self.pending_outbound_payments.static_invoice_received(
-				invoice, payment_id, features, best_block_height, &*self.entropy_source,
-				&self.pending_events
+				invoice, payment_id, features, best_block_height, self.duration_since_epoch(),
+				&*self.entropy_source, &self.pending_events
 			);
 			match outbound_pmts_res {
 				Ok(()) => {},

lightning/src/ln/outbound_payment.rs

@@ -458,7 +458,8 @@ impl_writeable_tlv_based_enum_legacy!(StaleExpiration,
 /// [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum RetryableSendFailure {
-	/// The provided [`PaymentParameters::expiry_time`] indicated that the payment has expired.
+	/// The BOLT 12 invoice was expired by the time we received it or the
+	/// [`PaymentParameters::expiry_time`] were expired on a retry attempt.
 	#[cfg_attr(feature = "std", doc = "")]
 	#[cfg_attr(feature = "std", doc = "Note that this error is *not* caused by [`Retry::Timeout`].")]
 	///
@@ -1011,7 +1012,7 @@ impl OutboundPayments {
 	#[cfg(async_payments)]
 	pub(super) fn static_invoice_received<ES: Deref>(
 		&self, invoice: &StaticInvoice, payment_id: PaymentId, features: Bolt12InvoiceFeatures,
-		best_block_height: u32, entropy_source: ES,
+		best_block_height: u32, duration_since_epoch: Duration, entropy_source: ES,
 		pending_events: &Mutex<VecDeque<(events::Event, Option<EventCompletionAction>)>>
 	) -> Result<(), Bolt12PaymentError> where ES::Target: EntropySource {
 		macro_rules! abandon_with_entry {
@@ -1045,6 +1046,11 @@ impl OutboundPayments {
 						abandon_with_entry!(entry, PaymentFailureReason::UnknownRequiredFeatures);
 						return Err(Bolt12PaymentError::UnknownRequiredFeatures)
 					}
+					if duration_since_epoch > invoice.created_at().saturating_add(invoice.relative_expiry()) {
+						abandon_with_entry!(entry, PaymentFailureReason::PaymentExpired);
+						return Err(Bolt12PaymentError::SendingFailed(RetryableSendFailure::PaymentExpired))
+					}
+
 					let amount_msat = match InvoiceBuilder::<DerivedSigningPubkey>::amount_msats(invreq) {
 						Ok(amt) => amt,
 						Err(_) => {