Classify LDK on-chain broadcasts

Record close, claim, anchor-bump, and sweep broadcasts.

Wallet sync can then retain the LDK transaction type.

Co-Authored-By: HAL 9000

Author: tnull

src/wallet/mod.rs

@@ -1171,9 +1171,8 @@ impl Wallet {
 		Ok(tx)
 	}
 
-	/// Classifies a funding broadcast (channel open or splice) handed to the broadcaster by LDK,
-	/// recording a payment for it before it is sent. Other transaction types are left for wallet
-	/// sync to record normally.
+	/// Classifies an on-chain broadcast handed to the broadcaster by LDK, recording a payment for it
+	/// before it is sent when it affects this node's wallet.
 	pub(crate) async fn classify_broadcast(
 		&self, tx: &Transaction, tx_type: &LdkTransactionType,
 	) -> Result<(), Error> {
@@ -1184,7 +1183,13 @@ impl Wallet {
 			LdkTransactionType::InteractiveFunding { candidates } => {
 				self.classify_interactive_funding(tx, candidates, tx_type.clone().into()).await
 			},
-			_ => Ok(()),
+			LdkTransactionType::CooperativeClose { .. }
+			| LdkTransactionType::UnilateralClose { .. }
+			| LdkTransactionType::AnchorBump { .. }
+			| LdkTransactionType::Claim { .. }
+			| LdkTransactionType::Sweep { .. } => {
+				self.classify_regular_broadcast(tx, tx_type.clone().into()).await
+			},
 		}
 	}
 
@@ -1325,6 +1330,40 @@ impl Wallet {
 		Ok(())
 	}
 
+	/// Records a non-funding LDK broadcast as an on-chain payment, tagged with its transaction type.
+	/// Wallet sync later refreshes confirmation status while preserving the type.
+	async fn classify_regular_broadcast(
+		&self, tx: &Transaction, tx_type: TransactionType,
+	) -> Result<(), Error> {
+		let txid = tx.compute_txid();
+		let (amount_msat, fee_paid_msat, direction) = self.onchain_payment_fields(tx);
+
+		if amount_msat == Some(0) && fee_paid_msat == Some(0) {
+			log_trace!(
+				self.logger,
+				"Not recording classified broadcast {} as a payment: no wallet-level activity",
+				txid,
+			);
+			return Ok(());
+		}
+
+		let details = PaymentDetails::new(
+			PaymentId(txid.to_byte_array()),
+			PaymentKind::Onchain {
+				txid,
+				status: ConfirmationStatus::Unconfirmed,
+				tx_type: Some(tx_type),
+			},
+			amount_msat,
+			fee_paid_msat,
+			direction,
+			PaymentStatus::Pending,
+		);
+		self.payment_store.insert_or_update(details).await?;
+		log_debug!(self.logger, "Recorded classified on-chain broadcast {}", txid);
+		Ok(())
+	}
+
 	/// Writes a freshly-classified funding payment to the authoritative payment store and adds a
 	/// pending-store index entry, so wallet sync graduates it through `ANTI_REORG_DELAY`.
 	async fn persist_funding_payment(

tests/common/mod.rs

@@ -30,6 +30,7 @@ use std::time::Duration;
 use bitcoin::hashes::hex::FromHex;
 use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::hashes::Hash;
+use bitcoin::secp256k1::PublicKey;
 use bitcoin::{
 	Address, Amount, Network, OutPoint, ScriptBuf, Sequence, Transaction, Txid, Witness,
 };
@@ -42,7 +43,7 @@ use ldk_node::config::{
 };
 use ldk_node::entropy::{generate_entropy_mnemonic, NodeEntropy};
 use ldk_node::io::sqlite_store::SqliteStore;
-use ldk_node::payment::{PaymentDirection, PaymentKind, PaymentStatus};
+use ldk_node::payment::{PaymentDirection, PaymentKind, PaymentStatus, TransactionType};
 use ldk_node::{
 	Builder, ChannelShutdownState, CustomTlvRecord, Event, LightningBalance, Node, NodeError,
 	PendingSweepBalance, UserChannelId,
@@ -407,6 +408,116 @@ type TestNode = Arc<Node>;
 #[cfg(not(feature = "uniffi"))]
 type TestNode = Node;
 
+fn has_onchain_tx_type<F: Fn(&TransactionType) -> bool>(node: &TestNode, predicate: F) -> bool {
+	node.list_payments().into_iter().any(|payment| {
+		matches!(
+			payment.kind,
+			PaymentKind::Onchain { tx_type: Some(ref tx_type), .. } if predicate(tx_type)
+		)
+	})
+}
+
+fn assert_any_node_has_onchain_tx_type<F: Fn(&TransactionType) -> bool + Copy>(
+	nodes: &[(&str, &TestNode)], tx_type_name: &str, predicate: F,
+) {
+	if nodes.iter().any(|(_, node)| has_onchain_tx_type(node, predicate)) {
+		return;
+	}
+
+	let observed: Vec<String> = nodes
+		.iter()
+		.flat_map(|(name, node)| {
+			node.list_payments().into_iter().filter_map(move |payment| match payment.kind {
+				PaymentKind::Onchain { tx_type, .. } => Some(format!("{}:{:?}", name, tx_type)),
+				_ => None,
+			})
+		})
+		.collect();
+	panic!("Expected on-chain payment with tx_type {}; observed {:?}", tx_type_name, observed);
+}
+
+fn assert_all_nodes_have_onchain_tx_type<F: Fn(&TransactionType) -> bool + Copy>(
+	nodes: &[(&str, &TestNode)], tx_type_name: &str, predicate: F,
+) {
+	if nodes.iter().all(|(_, node)| has_onchain_tx_type(node, predicate)) {
+		return;
+	}
+
+	let observed: Vec<String> = nodes
+		.iter()
+		.flat_map(|(name, node)| {
+			node.list_payments().into_iter().filter_map(move |payment| match payment.kind {
+				PaymentKind::Onchain { tx_type, .. } => Some(format!("{}:{:?}", name, tx_type)),
+				_ => None,
+			})
+		})
+		.collect();
+	panic!(
+		"Expected all nodes to have on-chain payment with tx_type {}; observed {:?}",
+		tx_type_name, observed
+	);
+}
+
+async fn settle_force_close_balance<E: ElectrumApi>(
+	node: &TestNode, counterparty_node_id: PublicKey, peer_node: &TestNode,
+	bitcoind: &BitcoindClient, electrsd: &E,
+) {
+	let balances = node.list_balances();
+	if balances.lightning_balances.len() == 1 {
+		match balances.lightning_balances[0] {
+			LightningBalance::ClaimableAwaitingConfirmations {
+				counterparty_node_id: actual_counterparty_node_id,
+				confirmation_height,
+				..
+			} => {
+				assert_eq!(actual_counterparty_node_id, counterparty_node_id);
+				let cur_height = node.status().current_best_block.height;
+				let blocks_to_go = confirmation_height - cur_height;
+				generate_blocks_and_wait(bitcoind, electrsd, blocks_to_go as usize).await;
+				node.sync_wallets().unwrap();
+				peer_node.sync_wallets().unwrap();
+			},
+			_ => panic!("Unexpected balance state!"),
+		}
+	} else {
+		assert!(balances.lightning_balances.is_empty(), "Unexpected balance state: {:?}", balances);
+		assert_eq!(balances.pending_balances_from_channel_closures.len(), 1);
+	}
+
+	for _ in 0..6 {
+		if node.list_balances().lightning_balances.is_empty() {
+			break;
+		}
+		generate_blocks_and_wait(bitcoind, electrsd, 1).await;
+		node.sync_wallets().unwrap();
+		peer_node.sync_wallets().unwrap();
+	}
+
+	let balances = node.list_balances();
+	assert!(balances.lightning_balances.is_empty(), "Unexpected balance state: {:?}", balances);
+	assert_eq!(balances.pending_balances_from_channel_closures.len(), 1);
+	match balances.pending_balances_from_channel_closures[0] {
+		PendingSweepBalance::BroadcastAwaitingConfirmation { .. } => {
+			generate_blocks_and_wait(bitcoind, electrsd, 1).await;
+			node.sync_wallets().unwrap();
+			peer_node.sync_wallets().unwrap();
+
+			assert!(node.list_balances().lightning_balances.is_empty());
+			assert_eq!(node.list_balances().pending_balances_from_channel_closures.len(), 1);
+			match node.list_balances().pending_balances_from_channel_closures[0] {
+				PendingSweepBalance::AwaitingThresholdConfirmations { .. } => {},
+				_ => panic!("Unexpected balance state!"),
+			}
+		},
+		PendingSweepBalance::AwaitingThresholdConfirmations { .. } => {},
+		_ => panic!("Unexpected balance state!"),
+	}
+
+	generate_blocks_and_wait(bitcoind, electrsd, 5).await;
+	node.sync_wallets().unwrap();
+	peer_node.sync_wallets().unwrap();
+}
+
 #[derive(Clone)]
 pub(crate) enum TestChainSource<'a> {
 	Esplora(&'a ElectrsD),
@@ -1474,84 +1585,11 @@ pub(crate) async fn do_channel_full_cycle<E: ElectrumApi>(
 	node_b.sync_wallets().unwrap();
 
 	if force_close {
-		// Check node_b properly sees all balances and sweeps them.
-		assert_eq!(node_b.list_balances().lightning_balances.len(), 1);
-		match node_b.list_balances().lightning_balances[0] {
-			LightningBalance::ClaimableAwaitingConfirmations {
-				counterparty_node_id,
-				confirmation_height,
-				..
-			} => {
-				assert_eq!(counterparty_node_id, node_a.node_id());
-				let cur_height = node_b.status().current_best_block.height;
-				let blocks_to_go = confirmation_height - cur_height;
-				generate_blocks_and_wait(&bitcoind, electrsd, blocks_to_go as usize).await;
-				node_b.sync_wallets().unwrap();
-				node_a.sync_wallets().unwrap();
-			},
-			_ => panic!("Unexpected balance state!"),
-		}
-
-		assert!(node_b.list_balances().lightning_balances.is_empty());
-		assert_eq!(node_b.list_balances().pending_balances_from_channel_closures.len(), 1);
-		match node_b.list_balances().pending_balances_from_channel_closures[0] {
-			PendingSweepBalance::BroadcastAwaitingConfirmation { .. } => {},
-			_ => panic!("Unexpected balance state!"),
-		}
-		generate_blocks_and_wait(&bitcoind, electrsd, 1).await;
-		node_b.sync_wallets().unwrap();
-		node_a.sync_wallets().unwrap();
-
+		settle_force_close_balance(&node_b, node_a.node_id(), &node_a, &bitcoind, electrsd).await;
 		assert!(node_b.list_balances().lightning_balances.is_empty());
 		assert_eq!(node_b.list_balances().pending_balances_from_channel_closures.len(), 1);
-		match node_b.list_balances().pending_balances_from_channel_closures[0] {
-			PendingSweepBalance::AwaitingThresholdConfirmations { .. } => {},
-			_ => panic!("Unexpected balance state!"),
-		}
-		generate_blocks_and_wait(&bitcoind, electrsd, 5).await;
-		node_b.sync_wallets().unwrap();
-		node_a.sync_wallets().unwrap();
-
-		assert!(node_b.list_balances().lightning_balances.is_empty());
-		assert_eq!(node_b.list_balances().pending_balances_from_channel_closures.len(), 1);
-
-		// Check node_a properly sees all balances and sweeps them.
-		assert_eq!(node_a.list_balances().lightning_balances.len(), 1);
-		match node_a.list_balances().lightning_balances[0] {
-			LightningBalance::ClaimableAwaitingConfirmations {
-				counterparty_node_id,
-				confirmation_height,
-				..
-			} => {
-				assert_eq!(counterparty_node_id, node_b.node_id());
-				let cur_height = node_a.status().current_best_block.height;
-				let blocks_to_go = confirmation_height - cur_height;
-				generate_blocks_and_wait(&bitcoind, electrsd, blocks_to_go as usize).await;
-				node_a.sync_wallets().unwrap();
-				node_b.sync_wallets().unwrap();
-			},
-			_ => panic!("Unexpected balance state!"),
-		}
-
-		assert!(node_a.list_balances().lightning_balances.is_empty());
-		assert_eq!(node_a.list_balances().pending_balances_from_channel_closures.len(), 1);
-		match node_a.list_balances().pending_balances_from_channel_closures[0] {
-			PendingSweepBalance::BroadcastAwaitingConfirmation { .. } => {},
-			_ => panic!("Unexpected balance state!"),
-		}
-		generate_blocks_and_wait(&bitcoind, electrsd, 1).await;
-		node_a.sync_wallets().unwrap();
-		node_b.sync_wallets().unwrap();
 
-		assert!(node_a.list_balances().lightning_balances.is_empty());
-		assert_eq!(node_a.list_balances().pending_balances_from_channel_closures.len(), 1);
-		match node_a.list_balances().pending_balances_from_channel_closures[0] {
-			PendingSweepBalance::AwaitingThresholdConfirmations { .. } => {},
-			_ => panic!("Unexpected balance state!"),
-		}
-		generate_blocks_and_wait(&bitcoind, electrsd, 5).await;
-		node_a.sync_wallets().unwrap();
-		node_b.sync_wallets().unwrap();
+		settle_force_close_balance(&node_a, node_b.node_id(), &node_b, &bitcoind, electrsd).await;
 	} else {
 		assert_eq!(node_a.list_balances().lightning_balances.len(), 1);
 		assert!(node_a.list_balances().pending_balances_from_channel_closures.is_empty());
@@ -1597,6 +1635,25 @@ pub(crate) async fn do_channel_full_cycle<E: ElectrumApi>(
 		assert!(node_b.list_balances().pending_balances_from_channel_closures.is_empty());
 	}
 
+	if force_close {
+		assert_any_node_has_onchain_tx_type(
+			&[("node_a", &node_a), ("node_b", &node_b)],
+			"UnilateralClose",
+			|tx_type| matches!(tx_type, TransactionType::UnilateralClose { .. }),
+		);
+		assert_any_node_has_onchain_tx_type(
+			&[("node_a", &node_a), ("node_b", &node_b)],
+			"Sweep",
+			|tx_type| matches!(tx_type, TransactionType::Sweep { .. }),
+		);
+	} else {
+		assert_all_nodes_have_onchain_tx_type(
+			&[("node_a", &node_a), ("node_b", &node_b)],
+			"CooperativeClose",
+			|tx_type| matches!(tx_type, TransactionType::CooperativeClose { .. }),
+		);
+	}
+
 	let sum_of_all_payments_sat = (push_msat
 		+ invoice_amount_1_msat
 		+ overpaid_amount_msat
@@ -1619,20 +1676,20 @@ pub(crate) async fn do_channel_full_cycle<E: ElectrumApi>(
 	assert_eq!(node_b.list_balances().total_anchor_channels_reserve_sats, 0);
 
 	// Now we should have seen the channel closing transaction on-chain.
-	assert_eq!(
-		node_a
-			.list_payments_with_filter(|p| p.direction == PaymentDirection::Inbound
-				&& matches!(p.kind, PaymentKind::Onchain { .. }))
-			.len(),
-		3
-	);
-	assert_eq!(
-		node_b
-			.list_payments_with_filter(|p| p.direction == PaymentDirection::Inbound
-				&& matches!(p.kind, PaymentKind::Onchain { .. }))
-			.len(),
-		2
-	);
+	let node_a_inbound_onchain_count = node_a
+		.list_payments_with_filter(|p| {
+			p.direction == PaymentDirection::Inbound
+				&& matches!(p.kind, PaymentKind::Onchain { .. })
+		})
+		.len();
+	let node_b_inbound_onchain_count = node_b
+		.list_payments_with_filter(|p| {
+			p.direction == PaymentDirection::Inbound
+				&& matches!(p.kind, PaymentKind::Onchain { .. })
+		})
+		.len();
+	assert!(node_a_inbound_onchain_count >= 3);
+	assert!(node_b_inbound_onchain_count >= 2);
 
 	// Check we handled all events
 	assert_eq!(node_a.next_event(), None);