Remove check_closed_event macro

Replace calls to `check_closed_event` macro
to the identically-named function.

Author: elnosh

lightning-liquidity/tests/lsps5_integration_tests.rs

@@ -8,12 +8,11 @@ use common::{
 };
 
 use lightning::chain::{BestBlock, Filter};
-use lightning::check_closed_event;
 use lightning::events::ClosureReason;
 use lightning::ln::channelmanager::{ChainParameters, InterceptId};
 use lightning::ln::functional_test_utils::{
-	close_channel, create_chan_between_nodes, create_chanmon_cfgs, create_network,
-	create_node_cfgs, create_node_chanmgrs, Node,
+	check_closed_event, close_channel, create_chan_between_nodes, create_chanmon_cfgs,
+	create_network, create_node_cfgs, create_node_chanmgrs, Node,
 };
 use lightning::ln::msgs::Init;
 use lightning::ln::peer_handler::CustomMessageHandler;
@@ -1480,9 +1479,9 @@ fn dos_protection() {
 
 	close_channel(&service_node.inner, &client_node.inner, &channel_id, funding_tx, true);
 	let node_a_reason = ClosureReason::CounterpartyInitiatedCooperativeClosure;
-	check_closed_event!(service_node.inner, 1, node_a_reason, [client_node_id], 100000);
+	check_closed_event(&service_node.inner, 1, node_a_reason, &[client_node_id], 100000);
 	let node_b_reason = ClosureReason::LocallyInitiatedCooperativeClosure;
-	check_closed_event!(client_node.inner, 1, node_b_reason, [service_node_id], 100000);
+	check_closed_event(&client_node.inner, 1, node_b_reason, &[service_node_id], 100000);
 
 	// channel is now closed again -> should reject
 	assert_lsps5_reject(&service_node, &client_node);

lightning-persister/src/fs_store.rs

@@ -720,7 +720,6 @@ mod tests {
 
 	use lightning::chain::chainmonitor::Persist;
 	use lightning::chain::ChannelMonitorUpdateStatus;
-	use lightning::check_closed_event;
 	use lightning::events::ClosureReason;
 	use lightning::ln::functional_test_utils::*;
 	use lightning::ln::msgs::BaseMessageHandler;
@@ -884,7 +883,7 @@ mod tests {
 			.unwrap();
 		let reason =
 			ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true), message };
-		check_closed_event!(nodes[1], 1, reason, [node_a_id], 100000);
+		check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
 		let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
 
 		// Set the store's directory to read-only, which should result in
@@ -928,7 +927,7 @@ mod tests {
 			.unwrap();
 		let reason =
 			ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true), message };
-		check_closed_event!(nodes[1], 1, reason, [node_a_id], 100000);
+		check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
 		let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
 		let update_map = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap();
 		let update_id = update_map.get(&added_monitors[0].1.channel_id()).unwrap();

lightning-persister/src/test_utils.rs

@@ -1,14 +1,14 @@
 use lightning::events::ClosureReason;
 use lightning::ln::functional_test_utils::{
-	connect_block, create_announced_chan_between_nodes, create_chanmon_cfgs, create_dummy_block,
-	create_network, create_node_cfgs, create_node_chanmgrs, send_payment,
+	check_closed_event, connect_block, create_announced_chan_between_nodes, create_chanmon_cfgs,
+	create_dummy_block, create_network, create_node_cfgs, create_node_chanmgrs, send_payment,
 };
 use lightning::util::persist::{
 	migrate_kv_store_data, read_channel_monitors, KVStoreSync, MigratableKVStore,
 	KVSTORE_NAMESPACE_KEY_ALPHABET, KVSTORE_NAMESPACE_KEY_MAX_LEN,
 };
 use lightning::util::test_utils;
-use lightning::{check_added_monitors, check_closed_broadcast, check_closed_event};
+use lightning::{check_added_monitors, check_closed_broadcast};
 
 use std::panic::RefUnwindSafe;
 
@@ -188,7 +188,7 @@ pub(crate) fn do_test_store<K: KVStoreSync + Sync>(store_0: &K, store_1: &K) {
 		.force_close_broadcasting_latest_txn(&chan_id, &node_b_id, message.clone())
 		.unwrap();
 	let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true), message };
-	check_closed_event!(nodes[0], 1, reason, [node_b_id], 100000);
+	check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
 	check_closed_broadcast!(nodes[0], true);
 	check_added_monitors!(nodes[0], 1);
 
@@ -204,13 +204,8 @@ pub(crate) fn do_test_store<K: KVStoreSync + Sync>(store_0: &K, store_1: &K) {
 		),
 	);
 	check_closed_broadcast!(nodes[1], true);
-	check_closed_event!(
-		nodes[1],
-		1,
-		ClosureReason::CommitmentTxConfirmed,
-		[nodes[0].node.get_our_node_id()],
-		100000
-	);
+	let reason = ClosureReason::CommitmentTxConfirmed;
+	check_closed_event(&nodes[1], 1, reason, &[nodes[0].node.get_our_node_id()], 100000);
 	check_added_monitors!(nodes[1], 1);
 
 	// Make sure everything is persisted as expected after close.

lightning-tests/src/upgrade_downgrade_tests.rs

@@ -291,7 +291,7 @@ fn test_0_1_legacy_remote_key_derivation() {
 
 	mine_transaction(&nodes[0], &commitment_tx[0]);
 	let reason = ClosureReason::CommitmentTxConfirmed;
-	check_closed_event(&nodes[0], 1, reason, false, &[node_b_id], 100_000);
+	check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100_000);
 	check_added_monitors(&nodes[0], 1);
 	check_closed_broadcast(&nodes[0], 1, false);
 

lightning/src/chain/chainmonitor.rs

@@ -1596,10 +1596,10 @@ where
 mod tests {
 	use crate::chain::channelmonitor::ANTI_REORG_DELAY;
 	use crate::chain::{ChannelMonitorUpdateStatus, Watch};
+	use crate::check_added_monitors;
 	use crate::events::{ClosureReason, Event};
 	use crate::ln::functional_test_utils::*;
 	use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, MessageSendEvent};
-	use crate::{check_added_monitors, check_closed_event};
 	use crate::{expect_payment_path_successful, get_event_msg};
 
 	const CHAINSYNC_MONITOR_PARTITION_FACTOR: u32 = 5;
@@ -1780,7 +1780,7 @@ mod tests {
 			.unwrap();
 		let closure_reason =
 			ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true), message };
-		check_closed_event!(&nodes[0], 1, closure_reason, false, [node_c_id], 1000000);
+		check_closed_event(&nodes[0], 1, closure_reason, &[node_c_id], 1000000);
 		check_closed_broadcast(&nodes[0], 1, true);
 		let close_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 		assert_eq!(close_tx.len(), 1);
@@ -1789,7 +1789,7 @@ mod tests {
 		check_closed_broadcast(&nodes[2], 1, true);
 		check_added_monitors(&nodes[2], 1);
 		let closure_reason = ClosureReason::CommitmentTxConfirmed;
-		check_closed_event!(&nodes[2], 1, closure_reason, false, [node_a_id], 1000000);
+		check_closed_event(&nodes[2], 1, closure_reason, &[node_a_id], 1000000);
 
 		chanmon_cfgs[0].persister.chain_sync_monitor_persistences.lock().unwrap().clear();
 		chanmon_cfgs[2].persister.chain_sync_monitor_persistences.lock().unwrap().clear();

lightning/src/chain/channelmonitor.rs

@@ -7012,7 +7012,7 @@ mod tests {
 		check_spends!(htlc_txn[1], broadcast_tx);
 
 		check_closed_broadcast(&nodes[1], 1, true);
-		check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, false, &[nodes[0].node.get_our_node_id()], 100000);
+		check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 100000);
 		check_added_monitors(&nodes[1], 1);
 	}
 

lightning/src/ln/async_signer_tests.rs

@@ -1025,7 +1025,7 @@ fn do_test_async_holder_signatures(keyed_anchors: bool, p2a_anchor: bool, remote
 		check_closed_broadcast(&nodes[1], 1, true);
 		let reason =
 			ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true), message };
-		check_closed_event(&nodes[1], 1, reason, false, &[node_a_id], 100_000);
+		check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100_000);
 	} else {
 		nodes[0].disable_channel_signer_op(&node_b_id, &chan_id, SignerOp::SignHolderCommitment);
 		nodes[0].disable_channel_signer_op(
@@ -1100,7 +1100,7 @@ fn do_test_async_holder_signatures(keyed_anchors: bool, p2a_anchor: bool, remote
 	} else {
 		ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash) }
 	};
-	check_closed_event(&nodes[0], 1, closure_reason, false, &[node_b_id], 100_000);
+	check_closed_event(&nodes[0], 1, closure_reason, &[node_b_id], 100_000);
 
 	// If the counterparty broadcast its latest commitment, we need to mine enough blocks for the
 	// HTLC timeout.
@@ -1319,9 +1319,9 @@ fn do_test_closing_signed(extra_closing_signed: bool, reconnect: bool) {
 	assert!(nodes[0].node.list_channels().is_empty());
 	assert!(nodes[1].node.list_channels().is_empty());
 	let reason_a = ClosureReason::LocallyInitiatedCooperativeClosure;
-	check_closed_event!(nodes[0], 1, reason_a, [node_b_id], 100000);
+	check_closed_event(&nodes[0], 1, reason_a, &[node_b_id], 100000);
 	let reason_b = ClosureReason::CounterpartyInitiatedCooperativeClosure;
-	check_closed_event!(nodes[1], 1, reason_b, [node_a_id], 100000);
+	check_closed_event(&nodes[1], 1, reason_b, &[node_a_id], 100000);
 }
 
 #[test]

lightning/src/ln/chanmon_update_fail_tests.rs

@@ -288,7 +288,7 @@ fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) {
 	// PaymentPathFailed event
 
 	assert_eq!(nodes[0].node.list_channels().len(), 0);
-	check_closed_event!(nodes[0], 1, reason, [node_b_id], 100000);
+	check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
 }
 
 #[test]
@@ -2274,9 +2274,9 @@ fn do_during_funding_monitor_fail(
 	send_payment(&nodes[0], &[&nodes[1]], 8000000);
 	close_channel(&nodes[0], &nodes[1], &channel_id, funding_tx, true);
 	let reason_a = ClosureReason::CounterpartyInitiatedCooperativeClosure;
-	check_closed_event!(nodes[0], 1, reason_a, [node_b_id], 100000);
+	check_closed_event(&nodes[0], 1, reason_a, &[node_b_id], 100000);
 	let reason_b = ClosureReason::LocallyInitiatedCooperativeClosure;
-	check_closed_event!(nodes[1], 1, reason_b, [node_a_id], 100000);
+	check_closed_event(&nodes[1], 1, reason_b, &[node_a_id], 100000);
 }
 
 #[test]
@@ -2514,7 +2514,8 @@ fn test_fail_htlc_on_broadcast_after_claim() {
 	expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false);
 
 	mine_transaction(&nodes[1], &bs_txn[0]);
-	check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [node_c_id], 100000);
+	let reason = ClosureReason::CommitmentTxConfirmed;
+	check_closed_event(&nodes[1], 1, reason, &[node_c_id], 100000);
 	check_closed_broadcast!(nodes[1], true);
 	connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
 	check_added_monitors!(nodes[1], 1);
@@ -3070,9 +3071,9 @@ fn test_temporary_error_during_shutdown() {
 	assert_eq!(txn_a.len(), 1);
 	check_spends!(txn_a[0], funding_tx);
 	let reason_b = ClosureReason::CounterpartyInitiatedCooperativeClosure;
-	check_closed_event!(nodes[1], 1, reason_b, [node_a_id], 100000);
+	check_closed_event(&nodes[1], 1, reason_b, &[node_a_id], 100000);
 	let reason_a = ClosureReason::LocallyInitiatedCooperativeClosure;
-	check_closed_event!(nodes[0], 1, reason_a, [node_b_id], 100000);
+	check_closed_event(&nodes[0], 1, reason_a, &[node_b_id], 100000);
 }
 
 #[test]
@@ -3309,7 +3310,7 @@ fn do_test_outbound_reload_without_init_mon(use_0conf: bool) {
 
 	let node_a_ser = nodes[0].node.encode();
 	reload_node!(nodes[0], &node_a_ser, &[], persister, new_chain_monitor, node_a_reload);
-	check_closed_event!(nodes[0], 1, ClosureReason::DisconnectedPeer, [node_b_id], 100000);
+	check_closed_event(&nodes[0], 1, ClosureReason::DisconnectedPeer, &[node_b_id], 100000);
 	assert!(nodes[0].node.list_channels().is_empty());
 }
 
@@ -3417,7 +3418,7 @@ fn do_test_inbound_reload_without_init_mon(use_0conf: bool, lock_commitment: boo
 	let node_b_ser = nodes[1].node.encode();
 	reload_node!(nodes[1], &node_b_ser, &[], persister, new_chain_monitor, node_b_reload);
 
-	check_closed_event!(nodes[1], 1, ClosureReason::DisconnectedPeer, [node_a_id], 100000);
+	check_closed_event(&nodes[1], 1, ClosureReason::DisconnectedPeer, &[node_a_id], 100000);
 	assert!(nodes[1].node.list_channels().is_empty());
 }
 
@@ -3715,7 +3716,7 @@ fn do_test_inverted_mon_completion_order(
 		persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress);
 		persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress);
 		let reason = ClosureReason::OutdatedChannelManager;
-		check_closed_event(&nodes[1], 1, reason, false, &[node_c_id], 100_000);
+		check_closed_event(&nodes[1], 1, reason, &[node_c_id], 100_000);
 		check_added_monitors(&nodes[1], 2);
 
 		nodes[1].node.timer_tick_occurred();
@@ -3838,7 +3839,7 @@ fn do_test_durable_preimages_on_closed_channel(
 			check_closed_broadcast(&nodes[1], 1, true);
 			let reason =
 				ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true), message };
-			check_closed_event(&nodes[1], 1, reason, false, &[node_c_id], 100000);
+			check_closed_event(&nodes[1], 1, reason, &[node_c_id], 100000);
 		}
 
 		chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress);
@@ -3850,7 +3851,7 @@ fn do_test_durable_preimages_on_closed_channel(
 		check_closed_broadcast(&nodes[1], 1, true);
 		let reason =
 			ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true), message };
-		check_closed_event(&nodes[1], 1, reason, false, &[node_a_id], 100000);
+		check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
 	}
 
 	// Now reload node B
@@ -3876,7 +3877,7 @@ fn do_test_durable_preimages_on_closed_channel(
 		message: err_msg.clone(),
 	};
 	nodes[0].node.force_close_broadcasting_latest_txn(&chan_id_ab, &node_b_id, err_msg).unwrap();
-	check_closed_event(&nodes[0], 1, reason, false, &[node_b_id], 100000);
+	check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
 	check_added_monitors(&nodes[0], 1);
 	let as_closing_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 	assert_eq!(as_closing_tx.len(), 1);
@@ -3906,7 +3907,7 @@ fn do_test_durable_preimages_on_closed_channel(
 	if !close_chans_before_reload {
 		check_closed_broadcast(&nodes[1], 1, false);
 		let reason = ClosureReason::CommitmentTxConfirmed;
-		check_closed_event(&nodes[1], 1, reason, false, &[node_a_id], 100000);
+		check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
 	}
 	nodes[1].node.timer_tick_occurred();
 	check_added_monitors(&nodes[1], mons_added);
@@ -4046,7 +4047,7 @@ fn do_test_reload_mon_update_completion_actions(close_during_reload: bool) {
 		nodes[0].node.force_close_broadcasting_latest_txn(&chan_id_ab, &node_b_id, msg).unwrap();
 		check_added_monitors!(nodes[0], 1);
 		check_closed_broadcast!(nodes[0], true);
-		check_closed_event(&nodes[0], 1, reason, false, &[node_b_id], 100_000);
+		check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100_000);
 		let as_closing_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
 		mine_transaction_without_consistency_checks(&nodes[1], &as_closing_tx[0]);
 	}
@@ -4493,7 +4494,7 @@ fn test_claim_to_closed_channel_blocks_forwarded_preimage_removal() {
 		.unwrap();
 	check_added_monitors!(nodes[0], 1);
 	let a_reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true), message };
-	check_closed_event!(nodes[0], 1, a_reason, [node_b_id], 1000000);
+	check_closed_event(&nodes[0], 1, a_reason, &[node_b_id], 1000000);
 	check_closed_broadcast!(nodes[0], true);
 
 	let as_commit_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
@@ -4502,7 +4503,8 @@ fn test_claim_to_closed_channel_blocks_forwarded_preimage_removal() {
 	mine_transaction(&nodes[1], &as_commit_tx[0]);
 	check_closed_broadcast!(nodes[1], true);
 	check_added_monitors!(nodes[1], 1);
-	check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [node_a_id], 1000000);
+	let b_reason = ClosureReason::CommitmentTxConfirmed;
+	check_closed_event(&nodes[1], 1, b_reason, &[node_a_id], 1000000);
 
 	// Now that B has a pending forwarded payment across it with the inbound edge on-chain, claim
 	// the payment on C and give B the preimage for it.
@@ -4569,7 +4571,7 @@ fn test_claim_to_closed_channel_blocks_claimed_event() {
 		.unwrap();
 	check_added_monitors!(nodes[0], 1);
 	let a_reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true), message };
-	check_closed_event!(nodes[0], 1, a_reason, [node_b_id], 1000000);
+	check_closed_event(&nodes[0], 1, a_reason, &[node_b_id], 1000000);
 	check_closed_broadcast!(nodes[0], true);
 
 	let as_commit_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
@@ -4578,7 +4580,8 @@ fn test_claim_to_closed_channel_blocks_claimed_event() {
 	mine_transaction(&nodes[1], &as_commit_tx[0]);
 	check_closed_broadcast!(nodes[1], true);
 	check_added_monitors!(nodes[1], 1);
-	check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [node_a_id], 1000000);
+	let b_reason = ClosureReason::CommitmentTxConfirmed;
+	check_closed_event(&nodes[1], 1, b_reason, &[node_a_id], 1000000);
 
 	// Now that B has a pending payment with the inbound HTLC on a closed channel, claim the
 	// payment on disk, but don't let the `ChannelMonitorUpdate` complete. This should prevent the

lightning/src/ln/channel_open_tests.rs

@@ -1045,7 +1045,7 @@ pub fn test_user_configurable_csv_delay() {
 		panic!();
 	}
 	let reason = ClosureReason::ProcessingError { err: reason_msg };
-	check_closed_event!(nodes[0], 1, reason, [node_b_id], 1000000);
+	check_closed_event(&nodes[0], 1, reason, &[node_b_id], 1000000);
 
 	// We test msg.to_self_delay <= config.their_to_self_delay is enforced in InboundV1Channel::new()
 	nodes[1].node.create_channel(node_a_id, 1000000, 1000000, 42, None, None).unwrap();
@@ -1705,7 +1705,7 @@ pub fn test_invalid_funding_tx() {
 	confirm_transaction_at(&nodes[1], &tx, 1);
 
 	let reason = ClosureReason::ProcessingError { err: expected_err.to_string() };
-	check_closed_event!(nodes[1], 1, reason, [node_a_id], 100000);
+	check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
 
 	check_added_monitors(&nodes[1], 1);
 	let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
@@ -1963,7 +1963,7 @@ pub fn test_channel_close_when_not_timely_accepted() {
 	// Since we disconnected from peer and did not connect back within time,
 	// we should have forced-closed the channel by now.
 	let reason = ClosureReason::FundingTimedOut;
-	check_closed_event!(nodes[0], 1, reason, [node_b_id], 100000);
+	check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
 	assert_eq!(nodes[0].node.list_channels().len(), 0);
 
 	{
@@ -2346,12 +2346,12 @@ pub fn test_funding_and_commitment_tx_confirm_same_block() {
 	check_msg_events(&nodes[0]);
 	check_added_monitors(&nodes[0], 1);
 	let reason = ClosureReason::CommitmentTxConfirmed;
-	check_closed_event(&nodes[0], 1, reason, false, &[node_b_id], 1_000_000);
+	check_closed_event(&nodes[0], 1, reason, &[node_b_id], 1_000_000);
 
 	check_msg_events(&nodes[1]);
 	check_added_monitors(&nodes[1], 1);
 	let reason = ClosureReason::CommitmentTxConfirmed;
-	check_closed_event(&nodes[1], 1, reason, false, &[node_a_id], 1_000_000);
+	check_closed_event(&nodes[1], 1, reason, &[node_a_id], 1_000_000);
 
 	assert!(nodes[0].node.list_channels().is_empty());
 	assert!(nodes[1].node.list_channels().is_empty());
@@ -2542,5 +2542,5 @@ fn test_fund_pending_channel() {
 	let reason = ClosureReason::ProcessingError {
 		err: "Error in transaction funding: Misuse error: Channel f7fee84016d554015f5166c0a0df6479942ef55fd70713883b0493493a38e13a with counterparty 0355f8d2238a322d16b602bd0ceaad5b01019fb055971eaadcc9b29226a4da6c23 is not an unfunded, outbound channel ready to fund".to_owned(),
 	};
-	check_closed_event!(nodes[0], 1, reason, [node_b_id], 100_000);
+	check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100_000);
 }