Assert expected TransactionType in integration tests

Extend `channel_full_cycle`, `onchain_send_receive`, and
`run_splice_channel_test` to verify that the `tx_type` field on
`PaymentKind::Onchain` matches the expected variant (`Funding`,
`OnchainSend`, `Splice`, or `None` for externally-received payments).

Co-Authored-By: HAL 9000
Signed-off-by: Elias Rohrer <dev@tnull.de>

Author: tnull

tests/common/mod.rs

@@ -29,7 +29,7 @@ use electrum_client::ElectrumApi;
 use ldk_node::config::{AsyncPaymentsRole, Config, ElectrumSyncConfig, EsploraSyncConfig};
 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, CustomTlvRecord, Event, LightningBalance, Node, NodeError, PendingSweepBalance,
 };
@@ -765,14 +765,21 @@ pub(crate) async fn do_channel_full_cycle<E: ElectrumApi>(
 	node_a.sync_wallets().unwrap();
 	node_b.sync_wallets().unwrap();
 
-	// Check we now see the channel funding transaction as outbound.
-	assert_eq!(
-		node_a
-			.list_payments_with_filter(|p| p.direction == PaymentDirection::Outbound
-				&& matches!(p.kind, PaymentKind::Onchain { .. }))
-			.len(),
-		1
-	);
+	// Check we now see the channel funding transaction as outbound with the correct type.
+	let funding_payments_a = node_a.list_payments_with_filter(|p| {
+		p.direction == PaymentDirection::Outbound && matches!(p.kind, PaymentKind::Onchain { .. })
+	});
+	assert_eq!(funding_payments_a.len(), 1);
+	match funding_payments_a[0].kind {
+		PaymentKind::Onchain { ref tx_type, .. } => {
+			assert!(
+				matches!(tx_type, Some(TransactionType::Funding { .. })),
+				"Expected Funding transaction type, got {:?}",
+				tx_type
+			);
+		},
+		_ => panic!("Unexpected payment kind"),
+	}
 
 	let onchain_fee_buffer_sat = 5000;
 	let node_a_anchor_reserve_sat = if expect_anchor_channel { 25_000 } else { 0 };
@@ -1115,13 +1122,21 @@ pub(crate) async fn do_channel_full_cycle<E: ElectrumApi>(
 	expect_channel_ready_event!(node_a, node_b.node_id());
 	expect_channel_ready_event!(node_b, node_a.node_id());
 
-	assert_eq!(
-		node_a
-			.list_payments_with_filter(|p| p.direction == PaymentDirection::Inbound
-				&& matches!(p.kind, PaymentKind::Onchain { .. }))
-			.len(),
-		2
-	);
+	let inbound_onchain_a = node_a.list_payments_with_filter(|p| {
+		p.direction == PaymentDirection::Inbound && matches!(p.kind, PaymentKind::Onchain { .. })
+	});
+	assert_eq!(inbound_onchain_a.len(), 2);
+	// The second inbound on-chain payment should be from the splice-out.
+	match inbound_onchain_a[1].kind {
+		PaymentKind::Onchain { ref tx_type, .. } => {
+			assert!(
+				matches!(tx_type, Some(TransactionType::Splice { .. })),
+				"Expected Splice transaction type, got {:?}",
+				tx_type
+			);
+		},
+		_ => panic!("Unexpected payment kind"),
+	}
 
 	println!("\nA splices in the splice-out payment from B");
 	let splice_in_sat = splice_out_sat;
@@ -1137,13 +1152,21 @@ pub(crate) async fn do_channel_full_cycle<E: ElectrumApi>(
 	expect_channel_ready_event!(node_a, node_b.node_id());
 	expect_channel_ready_event!(node_b, node_a.node_id());
 
-	assert_eq!(
-		node_a
-			.list_payments_with_filter(|p| p.direction == PaymentDirection::Outbound
-				&& matches!(p.kind, PaymentKind::Onchain { .. }))
-			.len(),
-		2
-	);
+	let outbound_onchain_a = node_a.list_payments_with_filter(|p| {
+		p.direction == PaymentDirection::Outbound && matches!(p.kind, PaymentKind::Onchain { .. })
+	});
+	assert_eq!(outbound_onchain_a.len(), 2);
+	// The second outbound on-chain payment should be from the splice-in.
+	match outbound_onchain_a[1].kind {
+		PaymentKind::Onchain { ref tx_type, .. } => {
+			assert!(
+				matches!(tx_type, Some(TransactionType::Splice { .. })),
+				"Expected Splice transaction type, got {:?}",
+				tx_type
+			);
+		},
+		_ => panic!("Unexpected payment kind"),
+	}
 
 	println!("\nB close_channel (force: {})", force_close);
 	if force_close {

tests/integration_tests_rust.rs

@@ -31,7 +31,7 @@ use ldk_node::entropy::NodeEntropy;
 use ldk_node::liquidity::LSPS2ServiceConfig;
 use ldk_node::payment::{
 	ConfirmationStatus, PaymentDetails, PaymentDirection, PaymentKind, PaymentStatus,
-	UnifiedPaymentResult,
+	TransactionType, UnifiedPaymentResult,
 };
 use ldk_node::{Builder, Event, NodeError};
 use lightning::ln::channelmanager::PaymentId;
@@ -418,17 +418,19 @@ async fn onchain_send_receive() {
 	let payment_a = node_a.payment(&payment_id).unwrap();
 	assert_eq!(payment_a.status, PaymentStatus::Pending);
 	match payment_a.kind {
-		PaymentKind::Onchain { status, .. } => {
+		PaymentKind::Onchain { status, ref tx_type, .. } => {
 			assert!(matches!(status, ConfirmationStatus::Unconfirmed));
+			assert_eq!(*tx_type, None);
 		},
 		_ => panic!("Unexpected payment kind"),
 	}
 	assert!(payment_a.fee_paid_msat > Some(0));
 	let payment_b = node_b.payment(&payment_id).unwrap();
 	assert_eq!(payment_b.status, PaymentStatus::Pending);
-	match payment_a.kind {
-		PaymentKind::Onchain { status, .. } => {
+	match payment_b.kind {
+		PaymentKind::Onchain { status, ref tx_type, .. } => {
 			assert!(matches!(status, ConfirmationStatus::Unconfirmed));
+			assert_eq!(*tx_type, Some(TransactionType::OnchainSend));
 		},
 		_ => panic!("Unexpected payment kind"),
 	}
@@ -457,18 +459,20 @@ async fn onchain_send_receive() {
 
 	let payment_a = node_a.payment(&payment_id).unwrap();
 	match payment_a.kind {
-		PaymentKind::Onchain { txid: _txid, status, .. } => {
+		PaymentKind::Onchain { txid: _txid, status, ref tx_type, .. } => {
 			assert_eq!(_txid, txid);
 			assert!(matches!(status, ConfirmationStatus::Confirmed { .. }));
+			assert_eq!(*tx_type, None);
 		},
 		_ => panic!("Unexpected payment kind"),
 	}
 
-	let payment_b = node_a.payment(&payment_id).unwrap();
+	let payment_b = node_b.payment(&payment_id).unwrap();
 	match payment_b.kind {
-		PaymentKind::Onchain { txid: _txid, status, .. } => {
+		PaymentKind::Onchain { txid: _txid, status, ref tx_type, .. } => {
 			assert_eq!(_txid, txid);
 			assert!(matches!(status, ConfirmationStatus::Confirmed { .. }));
+			assert_eq!(*tx_type, Some(TransactionType::OnchainSend));
 		},
 		_ => panic!("Unexpected payment kind"),
 	}
@@ -1018,6 +1022,16 @@ async fn run_splice_channel_test(bitcoind_chain_source: bool) {
 	let payment =
 		payments.into_iter().find(|p| p.id == PaymentId(txo.txid.to_byte_array())).unwrap();
 	assert_eq!(payment.fee_paid_msat, Some(expected_splice_in_fee_sat * 1_000));
+	match payment.kind {
+		PaymentKind::Onchain { ref tx_type, .. } => {
+			assert!(
+				matches!(tx_type, Some(TransactionType::Splice { .. })),
+				"Expected Splice transaction type, got {:?}",
+				tx_type
+			);
+		},
+		_ => panic!("Unexpected payment kind"),
+	}
 
 	assert_eq!(
 		node_b.list_balances().total_onchain_balance_sats,
@@ -1061,6 +1075,16 @@ async fn run_splice_channel_test(bitcoind_chain_source: bool) {
 	let payment =
 		payments.into_iter().find(|p| p.id == PaymentId(txo.txid.to_byte_array())).unwrap();
 	assert_eq!(payment.fee_paid_msat, Some(expected_splice_out_fee_sat * 1_000));
+	match payment.kind {
+		PaymentKind::Onchain { ref tx_type, .. } => {
+			assert!(
+				matches!(tx_type, Some(TransactionType::Splice { .. })),
+				"Expected Splice transaction type, got {:?}",
+				tx_type
+			);
+		},
+		_ => panic!("Unexpected payment kind"),
+	}
 
 	assert_eq!(
 		node_a.list_balances().total_onchain_balance_sats,