Let the funding output alone identify a funding

A channel becoming pending reported both the output that funds it and
that the transaction is a funding of that channel. The second only
repeats the first, since a funding output is what a funding transaction
is recognised by.

It also cost something. One transaction can open several channels, and
each reports only its own output; a report stating outright what the
transaction is lists one channel, so the next channel's contradicts it
and is refused whole, taking its funding output with it. The payment
then listed one of the channels opened instead of all of them.

A channel becoming ready already reports only its funding output, so
the two backstops now agree.

Co-Authored-By: HAL 9000
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: 2 people

src/event.rs

@@ -2205,15 +2205,16 @@ where
 					"LDK Node has only ever persisted ChannelPending events from rust-lightning 0.0.115 or later",
 				);
 
+				// The funding output alone says what the transaction is, and says it for every
+				// channel a batched funding opens: each channel reports its own output, and the
+				// reports of one transaction are kept together.
 				let channel = Channel { counterparty_node_id, channel_id };
-				let facts = ChannelTxFacts::new(funding_txo.txid)
-					.with_outputs(
-						&channel,
-						Some(UserChannelId(user_channel_id)),
-						ChannelOutputRole::Funding,
-						[funding_txo.vout],
-					)
-					.with_self_role(TransactionType::Funding { channels: vec![channel.clone()] });
+				let facts = ChannelTxFacts::new(funding_txo.txid).with_outputs(
+					&channel,
+					Some(UserChannelId(user_channel_id)),
+					ChannelOutputRole::Funding,
+					[funding_txo.vout],
+				);
 				self.record_channel_tx_facts(facts).await;
 
 				let event = Event::ChannelPending {

src/wallet/mod.rs

@@ -12486,6 +12486,95 @@ mod tests {
 		}
 	}
 
+	/// The funding output a channel reports is what classifies the transaction that opens it; the
+	/// report does not have to say so separately.
+	#[tokio::test]
+	async fn a_funding_transaction_is_classified_by_the_output_it_creates() {
+		let store: Arc<DynStore> = Arc::new(DynStoreWrapper(InMemoryStore::new()));
+		let wallet = new_test_wallet(Arc::clone(&store), false).await;
+
+		let (counterparty_node_id, channel_id) = test_counterparty_and_channel();
+		let channel = Channel { counterparty_node_id, channel_id };
+		let funding = wallet_paying_tx(&wallet, 5);
+		let funding_txid = funding.compute_txid();
+		insert_unconfirmed_tx(&wallet, funding.clone());
+
+		wallet
+			.record_channel_tx_facts(ChannelTxFacts::new(funding_txid).with_outputs(
+				&channel,
+				None,
+				ChannelOutputRole::Funding,
+				[0],
+			))
+			.await
+			.unwrap();
+		observe_unconfirmed(&wallet, &funding).await;
+
+		let payment = wallet
+			.payment_stores
+			.payment_store()
+			.get(&PaymentId(funding_txid.to_byte_array()))
+			.await
+			.unwrap()
+			.expect("wallet sync records the funding transaction");
+		match payment.kind {
+			PaymentKind::Onchain {
+				tx_type: Some(TransactionType::Funding { channels }), ..
+			} => {
+				assert_eq!(channels, vec![channel]);
+			},
+			kind => panic!("unexpected kind {:?}", kind),
+		}
+	}
+
+	/// One transaction can open several channels, each of which reports only the output that funds
+	/// it. The reports of one transaction are kept together, so the payment lists every channel
+	/// opened — which a report stating outright what the transaction is could not do, as the second
+	/// channel's would contradict the first's.
+	#[tokio::test]
+	async fn a_batched_funding_lists_every_channel_it_opens() {
+		let store: Arc<DynStore> = Arc::new(DynStoreWrapper(InMemoryStore::new()));
+		let wallet = new_test_wallet(Arc::clone(&store), false).await;
+
+		let (counterparty_node_id, channel_id) = test_counterparty_and_channel();
+		let first = Channel { counterparty_node_id, channel_id };
+		let second = Channel { counterparty_node_id, channel_id: ChannelId([8u8; 32]) };
+
+		let mut funding = wallet_paying_tx(&wallet, 6);
+		funding.output.push(funding.output[0].clone());
+		let funding_txid = funding.compute_txid();
+		insert_unconfirmed_tx(&wallet, funding.clone());
+
+		for (vout, channel) in [(0u32, &first), (1, &second)] {
+			wallet
+				.record_channel_tx_facts(ChannelTxFacts::new(funding_txid).with_outputs(
+					channel,
+					None,
+					ChannelOutputRole::Funding,
+					[vout],
+				))
+				.await
+				.unwrap();
+		}
+		observe_unconfirmed(&wallet, &funding).await;
+
+		let payment = wallet
+			.payment_stores
+			.payment_store()
+			.get(&PaymentId(funding_txid.to_byte_array()))
+			.await
+			.unwrap()
+			.expect("wallet sync records the funding transaction");
+		match payment.kind {
+			PaymentKind::Onchain {
+				tx_type: Some(TransactionType::Funding { channels }), ..
+			} => {
+				assert_eq!(channels, vec![first, second]);
+			},
+			kind => panic!("unexpected kind {:?}", kind),
+		}
+	}
+
 	/// The node's channel state as a test dictates it: the channels its channel manager lists,
 	/// the monitors its chain monitor has, and the outputs its sweeper tracks, for retention; and
 	/// its channel outputs, for the startup pass.