Fix BOLT11 DuplicatePayment triggering on-chain fallback in unified payments

UnifiedPayment::send previously treated any error from the BOLT11 leg
of a unified payment as non-terminal and fell through to the on-chain
payment method. This meant a retried BOLT11 payment that returns
Error::DuplicatePayment would still result in an on-chain transaction
being broadcast for the same invoice — a duplicate payment.

Error::DuplicatePayment is now terminal in UnifiedPayment::send: the
unified payment aborts instead of falling back to on-chain.

Fixes #1033.

unified_send_receive_bip21_uri already funds two nodes, opens a
channel, and sends a successful BOLT11 payment via uri_str_without_offer
partway through. Add the regression assertion right there — retry the
same uri_str_without_offer and assert DuplicatePayment, not a new
on-chain payment — instead of duplicating that setup in a standalone
test.

Author: elnafateh

src/payment/unified.rs

@@ -291,9 +291,22 @@ impl UnifiedPayment {
 
 					let payment_result = if let Ok(hrn) = HumanReadableName::from_encoded(uri_str) {
 						let hrn = maybe_wrap(hrn.clone());
-						self.bolt12_payment.send_using_amount_inner(&offer, amount_msat.unwrap_or(0), None, None, route_parameters, Some(hrn))
+						self.bolt12_payment.send_using_amount_inner(
+							&offer,
+							amount_msat.unwrap_or(0),
+							None,
+							None,
+							route_parameters,
+							Some(hrn),
+						)
 					} else if let Some(amount_msat) = amount_msat {
-						self.bolt12_payment.send_using_amount(&offer, amount_msat, None, None, route_parameters)
+						self.bolt12_payment.send_using_amount(
+							&offer,
+							amount_msat,
+							None,
+							None,
+							route_parameters,
+						)
 					} else {
 						self.bolt12_payment.send(&offer, None, None, route_parameters)
 					}
@@ -308,14 +321,21 @@ impl UnifiedPayment {
 				},
 				PaymentMethod::LightningBolt11(invoice) => {
 					let invoice = maybe_wrap(invoice.clone());
-					let payment_result = self.bolt11_invoice.send(&invoice, route_parameters)
-						.map_err(|e| {
+					let payment_result = self.bolt11_invoice.send(&invoice, route_parameters);
+
+					match payment_result {
+						Ok(payment_id) => {
+							return Ok(UnifiedPaymentResult::Bolt11 { payment_id });
+						},
+						// A duplicate payment already exists, so falling back to the
+						// on-chain method would pay the same invoice a second time.
+						Err(Error::DuplicatePayment) => {
+							log_error!(self.logger, "Failed to send BOLT11 invoice: DuplicatePayment. This is part of a unified payment. Aborting to avoid duplicate payment.");
+							return Err(Error::DuplicatePayment);
+						},
+						Err(e) => {
 							log_error!(self.logger, "Failed to send BOLT11 invoice: {:?}. This is part of a unified payment. Falling back to the on-chain transaction.", e);
-							e
-						});
-
-					if let Ok(payment_id) = payment_result {
-						return Ok(UnifiedPaymentResult::Bolt11 { payment_id });
+						},
 					}
 				},
 				PaymentMethod::OnChain(address) => {

tests/integration_tests_rust.rs

@@ -3395,6 +3395,22 @@ async fn unified_send_receive_bip21_uri() {
 		};
 	expect_payment_successful_event!(node_a, invoice_payment_id, None);
 
+	// Regression test for https://github.com/lightningdevkit/ldk-node/issues/1033: retrying
+	// the same BOLT11 invoice must return DuplicatePayment, not fall back to on-chain.
+	let duplicate_result = node_a.unified_payment().send(uri_str_without_offer, None, None).await;
+	match duplicate_result {
+		Err(NodeError::DuplicatePayment) => {
+			// Expected — this is the fix for #1033.
+		},
+		Ok(UnifiedPaymentResult::Onchain { txid }) => {
+			panic!(
+				"Regression: duplicate BOLT11 payment fell back to on-chain. txid={}. See #1033",
+				txid
+			);
+		},
+		other => panic!("Expected DuplicatePayment error on retry, got: {:?}", other),
+	}
+
 	let expect_onchain_amount_sats = 800_000;
 	let onchain_uni_payment =
 		node_b.unified_payment().receive(expect_onchain_amount_sats, "asdf", 4_000).unwrap();