Merge PR 'Don't process monitor events in `get_and_clear_pending_msg_events`' (#5031)
What changed, and why it matters
This change stops one internal function from automatically processing monitor events when the caller only asked for pending message events. It is a cleanup of how background tasks are triggered, not a fix for an externally exploitable bug. Most of the patch is test updates that reorder event checks to match the new behavior.
Treat as a normal refactor/behavioral-hardening commit. Reviewers should confirm that callers which previously relied on the side effect now explicitly process pending events, and that no production path loses monitor-event handling. No urgent security response is indicated by the diff alone.
Security signals we found
Behavioral change in event-processing order
Removal of side-effecting monitor-event processing from a getter-style API
Large test-only diff reordering event assertions
No cryptographic, boundary, or input-validation changes
Evidence from the diff
The commit removes a call to process_pending_monitor_events() from ChannelManager::get_and_clear_pending_msg_events() and instead lets callers process monitor events through the normal event-handling path. A notifier is added in ChainMonitor::update_channel() so monitor updates can wake the event processor. The bulk of the diff updates tests to check events before message events and to explicitly drain pending events after monitor update completions, reflecting the changed ordering rather than a vulnerability.
Changed components
lightning/src/ln/channelmanager.rslightning/src/chain/chainmonitor.rslightning/src/chain/channelmonitor.rstest utilities in lightning/src/ln/functional_test_utils.rsInspect captured patch +411 / −387
### lightning-persister/src/test_utils.rs
@@ -250,9 +250,9 @@ pub(crate) fn do_test_store<K: KVStoreSync + Sync>(store_0: &K, store_1: &K) {
vec![node_txn[0].clone(), node_txn[0].clone()],
),
);
- check_closed_broadcast(&nodes[1], 1, true);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[nodes[0].node.get_our_node_id()], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
// Make sure everything is persisted as expected after close.
### lightning/src/chain/chainmonitor.rs
@@ -1649,7 +1649,11 @@ where
&self, channel_id: ChannelId, update: &ChannelMonitorUpdate,
) -> ChannelMonitorUpdateStatus {
if !self.deferred {
- return self.update_channel_internal(channel_id, update);
+ let status = self.update_channel_internal(channel_id, update);
+ // Applying the update may have generated new events, so assume we have some and wake
+ // the event processor.
+ self.event_notifier.notify();
+ return status;
}
let mut pending_ops = self.pending_ops.lock().unwrap();
@@ -1839,7 +1843,7 @@ mod tests {
TestBroadcaster, TestChainSource, TestFeeEstimator, TestKeysInterface, TestLogger,
TestPersister,
};
- use crate::{expect_payment_path_successful, get_event_msg};
+ use crate::{expect_payment_claimed, expect_payment_path_successful, get_event_msg};
use bitcoin::Network;
const CHAINSYNC_MONITOR_PARTITION_FACTOR: u32 = 5;
@@ -2031,10 +2035,10 @@ mod tests {
assert_eq!(close_tx.len(), 1);
mine_transaction(&nodes[2], &close_tx[0]);
- 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, &[node_a_id], 1000000);
+ check_closed_broadcast(&nodes[2], 1, true);
+ check_added_monitors(&nodes[2], 1);
chanmon_cfgs[0].persister.chain_sync_monitor_persistences.lock().unwrap().clear();
chanmon_cfgs[2].persister.chain_sync_monitor_persistences.lock().unwrap().clear();
@@ -2244,21 +2248,45 @@ mod tests {
/// Tests that `ChainMonitor` in deferred mode properly defers `watch_channel` and
/// `update_channel` operations, verifying correctness through a complete channel open
/// and payment flow. Operations are auto-flushed via the `TestChainMonitor`
- /// `release_pending_monitor_events` helper.
+ /// `release_pending_monitor_events` helper whenever a node handles its events.
#[test]
fn test_deferred_monitor_payment() {
let chanmon_cfgs = create_chanmon_cfgs(2);
let node_cfgs = create_node_cfgs_deferred(2, &chanmon_cfgs);
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+ let node_a_id = nodes[0].node.get_our_node_id();
+ let node_b_id = nodes[1].node.get_our_node_id();
+
let chain_monitor_a = &nodes[0].chain_monitor.chain_monitor;
let chain_monitor_b = &nodes[1].chain_monitor.chain_monitor;
create_announced_chan_between_nodes(&nodes, 0, 1);
- let (preimage, _hash, ..) = route_payment(&nodes[0], &[&nodes[1]], 10_000);
- claim_payment(&nodes[0], &[&nodes[1]], preimage);
+ let (preimage, hash, ..) = route_payment_deferred(&nodes[0], &nodes[1], 10_000);
+
+ nodes[1].node.claim_funds(preimage, Default::default());
+ check_added_monitors(&nodes[1], 1);
+ expect_payment_claimed!(nodes[1], hash, 10_000);
+
+ let mut updates = get_htlc_update_msgs(&nodes[1], &node_a_id);
+ nodes[0].node.handle_update_fulfill_htlc(node_b_id, updates.update_fulfill_htlcs.remove(0));
+ nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &updates.commitment_signed);
+ check_added_monitors(&nodes[0], 1);
+ expect_payment_sent(&nodes[0], preimage, None, false, false);
+
+ let (raa, cs) = get_revoke_commit_msgs(&nodes[0], &node_b_id);
+ nodes[1].node.handle_revoke_and_ack(node_a_id, &raa);
+ check_added_monitors(&nodes[1], 1);
+ nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &cs);
+ check_added_monitors(&nodes[1], 1);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
+
+ let raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id);
+ nodes[0].node.handle_revoke_and_ack(node_b_id, &raa);
+ check_added_monitors(&nodes[0], 1);
+ expect_payment_path_successful!(nodes[0]);
assert_eq!(chain_monitor_a.list_monitors().len(), 1);
assert_eq!(chain_monitor_b.list_monitors().len(), 1);
### lightning/src/chain/channelmonitor.rs
@@ -7538,7 +7538,6 @@ mod tests {
check_spends!(htlc_txn[0], broadcast_tx);
check_spends!(htlc_txn[1], broadcast_tx);
- check_closed_broadcast(&nodes[1], 1, true);
if !use_local_txn {
// When the counterparty commitment confirms, FundingSpendConfirmation matures
// immediately (no CSV delay), so funding_spend_confirmed is set. The new payment's
@@ -7554,6 +7553,7 @@ mod tests {
check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 100000);
check_added_monitors(&nodes[1], 1);
}
+ check_closed_broadcast(&nodes[1], 1, true);
}
#[test]
### lightning/src/ln/async_signer_tests.rs
@@ -617,6 +617,10 @@ fn test_signer_unblocked_clears_monitor_pending_raa_after_reestablish() {
let (latest_update, _) = nodes[1].chain_monitor.get_latest_mon_update_id(chan_bc.2);
nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_bc.2, latest_update);
check_added_monitors(&nodes[1], 0);
+ expect_htlc_failure_conditions(
+ nodes[1].node.get_and_clear_pending_events(),
+ &[HTLCHandlingFailureType::Forward { node_id: Some(node_c_id), channel_id: chan_bc.2 }],
+ );
let (_, duplicate_revoke_and_ack, monitor_commitment_update, _, _, _, _, _, _) =
handle_chan_reestablish_msgs!(nodes[1], nodes[2]);
assert!(duplicate_revoke_and_ack.is_none());
@@ -697,10 +701,6 @@ fn test_signer_unblocked_clears_monitor_pending_raa_after_reestablish() {
None,
node_c_id,
);
- expect_htlc_failure_conditions(
- nodes[1].node.get_and_clear_pending_events(),
- &[HTLCHandlingFailureType::Forward { node_id: Some(node_c_id), channel_id: chan_bc.2 }],
- );
}
fn do_test_async_raa_peer_disconnect(
@@ -798,6 +798,7 @@ fn do_test_async_raa_peer_disconnect(
}
dst.chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update);
check_added_monitors(&dst, 0);
+ assert!(dst.node.get_and_clear_pending_events().is_empty());
}
// Expect the RAA
@@ -948,6 +949,7 @@ fn do_test_async_commitment_signature_peer_disconnect(
}
dst.chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update);
check_added_monitors(&dst, 0);
+ assert!(dst.node.get_and_clear_pending_events().is_empty());
}
// Expect the RAA
@@ -1098,6 +1100,7 @@ fn do_test_async_commitment_signature_ordering(monitor_update_failure: bool) {
}
nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update);
check_added_monitors(&nodes[0], 0);
+ assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
}
// Make sure that on signer_unblocked we have the same behavior (even though RAA is ready,
@@ -1297,14 +1300,14 @@ fn do_test_async_holder_signatures(keyed_anchors: bool, p2a_anchor: bool, remote
nodes[0].disable_channel_signer_op(&node_b_id, &chan_id, sign_htlc_op);
mine_transaction(&nodes[0], &commitment_tx);
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let closure_reason = if remote_commitment {
ClosureReason::CommitmentTxConfirmed
} else {
ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash) }
};
check_closed_event(&nodes[0], 1, closure_reason, &[node_b_id], 100_000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
// If the counterparty broadcast its latest commitment, we need to mine enough blocks for the
// HTLC timeout.
@@ -1935,6 +1938,7 @@ fn test_async_splice_initial_commit_sig_waits_for_monitor_before_tx_signatures()
acceptor.chain_monitor.complete_sole_pending_chan_update(&channel_id);
chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
+ assert!(acceptor.node.get_and_clear_pending_events().is_empty());
let tx_signatures =
get_event_msg!(acceptor, MessageSendEvent::SendTxSignatures, initiator_node_id);
### lightning/src/ln/chanmon_update_fail_tests.rs
@@ -217,10 +217,9 @@ fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) {
let (latest_update, _) = nodes[0].chain_monitor.get_latest_mon_update_id(channel_id);
nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update);
check_added_monitors(&nodes[0], 0);
+ assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
- let mut events_2 = nodes[0].node.get_and_clear_pending_msg_events();
- assert_eq!(events_2.len(), 1);
- let payment_event = SendEvent::from_event(events_2.pop().unwrap());
+ let payment_event = SendEvent::from_node(&nodes[0]);
assert_eq!(payment_event.node_id, node_b_id);
nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]);
do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event.commitment_msg, false, false);
@@ -410,6 +409,7 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
let (latest_update, _) = nodes[0].chain_monitor.get_latest_mon_update_id(channel_id);
nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update);
check_added_monitors(&nodes[0], 0);
+ assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
macro_rules! disconnect_reconnect_peers {
() => {{
@@ -442,7 +442,6 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
}
let (payment_event, initial_revoke_and_ack) = if disconnect_count & !disconnect_flags > 0 {
- assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
let init_msg = msgs::Init {
@@ -528,18 +527,8 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
as_resp.1.unwrap(),
)
} else {
- let mut events_4 = nodes[0].node.get_and_clear_pending_msg_events();
- assert_eq!(events_4.len(), 2);
- (
- SendEvent::from_event(events_4.remove(0)),
- match events_4[0] {
- MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
- assert_eq!(*node_id, node_b_id);
- msg.clone()
- },
- _ => panic!("Unexpected event"),
- },
- )
+ let (as_updates, as_raa) = get_updates_and_revoke(&nodes[0], &node_b_id);
+ (SendEvent::from_commitment_update(node_b_id, channel_id, as_updates), as_raa)
};
assert_eq!(payment_event.node_id, node_b_id);
@@ -763,41 +752,23 @@ fn test_monitor_update_fail_cs() {
let (latest_update, _) = nodes[1].chain_monitor.get_latest_mon_update_id(channel_id);
nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update);
check_added_monitors(&nodes[1], 0);
- let responses = nodes[1].node.get_and_clear_pending_msg_events();
- assert_eq!(responses.len(), 2);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
+ let (bs_raa, bs_cs) = get_revoke_commit_msgs(&nodes[1], &node_a_id);
- match responses[0] {
- MessageSendEvent::SendRevokeAndACK { ref msg, ref node_id } => {
- assert_eq!(*node_id, node_a_id);
- nodes[0].node.handle_revoke_and_ack(node_b_id, &msg);
- check_added_monitors(&nodes[0], 1);
- },
- _ => panic!("Unexpected event"),
- }
- match responses[1] {
- MessageSendEvent::UpdateHTLCs { ref updates, ref node_id, channel_id: _ } => {
- assert!(updates.update_add_htlcs.is_empty());
- assert!(updates.update_fulfill_htlcs.is_empty());
- assert!(updates.update_fail_htlcs.is_empty());
- assert!(updates.update_fail_malformed_htlcs.is_empty());
- assert!(updates.update_fee.is_none());
- assert_eq!(*node_id, node_a_id);
+ nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_raa);
+ check_added_monitors(&nodes[0], 1);
- chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress);
- nodes[0]
- .node
- .handle_commitment_signed_batch_test(node_b_id, &updates.commitment_signed);
- assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
- check_added_monitors(&nodes[0], 1);
- assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
- },
- _ => panic!("Unexpected event"),
- }
+ chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress);
+ nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_cs);
+ assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
+ check_added_monitors(&nodes[0], 1);
+ assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
let (latest_update, _) = nodes[0].chain_monitor.get_latest_mon_update_id(channel_id);
nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update);
check_added_monitors(&nodes[0], 0);
+ assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
let final_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id);
nodes[1].node.handle_revoke_and_ack(node_a_id, &final_raa);
@@ -873,6 +844,7 @@ fn test_monitor_update_fail_no_rebroadcast() {
chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
let (latest_update, _) = nodes[1].chain_monitor.get_latest_mon_update_id(channel_id);
nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
check_added_monitors(&nodes[1], 0);
expect_and_process_pending_htlcs(&nodes[1], false);
@@ -944,6 +916,7 @@ fn test_monitor_update_raa_while_paused() {
let (latest_update, _) = nodes[0].chain_monitor.get_latest_mon_update_id(channel_id);
nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update);
check_added_monitors(&nodes[0], 0);
+ assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
let as_update_raa = get_revoke_commit_msgs(&nodes[0], &node_b_id);
nodes[1].node.handle_revoke_and_ack(node_a_id, &as_update_raa.0);
@@ -1361,6 +1334,7 @@ fn test_monitor_update_fail_reestablish() {
let (latest_update, _) = nodes[1].chain_monitor.get_latest_mon_update_id(chan_1.2);
nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_1.2, latest_update);
check_added_monitors(&nodes[1], 0);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
updates = get_htlc_update_msgs(&nodes[1], &node_a_id);
assert!(updates.update_add_htlcs.is_empty());
@@ -1447,6 +1421,7 @@ fn raa_no_response_awaiting_raa_state() {
nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update);
// nodes[1] should be AwaitingRAA here!
check_added_monitors(&nodes[1], 0);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
let bs_responses = get_revoke_commit_msgs(&nodes[1], &node_a_id);
expect_and_process_pending_htlcs(&nodes[1], false);
expect_payment_claimable!(nodes[1], payment_hash_1, payment_secret_1, 1000000);
@@ -1576,36 +1551,22 @@ fn claim_while_disconnected_monitor_update_fail() {
let (latest_update, _) = nodes[1].chain_monitor.get_latest_mon_update_id(channel_id);
nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update);
check_added_monitors(&nodes[1], 0);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
- let mut bs_msgs = nodes[1].node.get_and_clear_pending_msg_events();
- assert_eq!(bs_msgs.len(), 2);
+ let (mut bs_updates, bs_raa) = get_updates_and_revoke(&nodes[1], &node_a_id);
- match bs_msgs.remove(0) {
- MessageSendEvent::UpdateHTLCs { node_id, channel_id: _, mut updates } => {
- assert_eq!(node_id, node_a_id);
- let update_fulfill = updates.update_fulfill_htlcs.remove(0);
- nodes[0].node.handle_update_fulfill_htlc(node_b_id, update_fulfill);
- expect_payment_sent(&nodes[0], payment_preimage_1, None, false, false);
- nodes[0]
- .node
- .handle_commitment_signed_batch_test(node_b_id, &updates.commitment_signed);
- check_added_monitors(&nodes[0], 1);
+ let update_fulfill = bs_updates.update_fulfill_htlcs.remove(0);
+ nodes[0].node.handle_update_fulfill_htlc(node_b_id, update_fulfill);
+ expect_payment_sent(&nodes[0], payment_preimage_1, None, false, false);
+ nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_updates.commitment_signed);
+ check_added_monitors(&nodes[0], 1);
- let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id);
- nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa);
- check_added_monitors(&nodes[1], 1);
- },
- _ => panic!("Unexpected event"),
- }
+ let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id);
+ nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa);
+ check_added_monitors(&nodes[1], 1);
- match bs_msgs[0] {
- MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
- assert_eq!(*node_id, node_a_id);
- nodes[0].node.handle_revoke_and_ack(node_b_id, msg);
- check_added_monitors(&nodes[0], 1);
- },
- _ => panic!("Unexpected event"),
- }
+ nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_raa);
+ check_added_monitors(&nodes[0], 1);
let as_commitment = get_htlc_update_msgs(&nodes[0], &node_b_id);
@@ -1705,6 +1666,7 @@ fn monitor_failed_no_reestablish_response() {
let (latest_update, _) = nodes[1].chain_monitor.get_latest_mon_update_id(channel_id);
nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update);
check_added_monitors(&nodes[1], 0);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
let bs_responses = get_revoke_commit_msgs(&nodes[1], &node_a_id);
nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_responses.0);
@@ -2032,6 +1994,7 @@ fn test_monitor_update_on_pending_forwards() {
let (latest_update, _) = nodes[1].chain_monitor.get_latest_mon_update_id(chan_1.2);
nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_1.2, latest_update);
check_added_monitors(&nodes[1], 0);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
let bs_updates = get_htlc_update_msgs(&nodes[1], &node_a_id);
nodes[0].node.handle_update_fail_htlc(node_b_id, &bs_updates.update_fail_htlcs[0]);
@@ -2228,6 +2191,11 @@ fn do_during_funding_monitor_fail(
let (latest_update, _) = nodes[1].chain_monitor.get_latest_mon_update_id(channel_id);
nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update);
check_added_monitors(&nodes[1], 0);
+ if !restore_b_before_conf && !restore_b_before_lock {
+ expect_channel_ready_event(&nodes[1], &node_a_id);
+ } else {
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
+ }
let (channel_id, (announcement, as_update, bs_update)) = if !confirm_a_first {
if !restore_b_before_lock {
@@ -2253,7 +2221,6 @@ fn do_during_funding_monitor_fail(
} else {
if restore_b_before_conf {
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
- assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
confirm_transaction(&nodes[1], &funding_tx);
}
let (channel_ready, channel_id) =
@@ -2270,9 +2237,9 @@ fn do_during_funding_monitor_fail(
node.gossip_sync.handle_channel_update(Some(counterparty_node_id), &bs_update).unwrap();
}
- if !restore_b_before_lock {
+ if restore_b_before_conf {
expect_channel_ready_event(&nodes[1], &node_a_id);
- } else {
+ } else if restore_b_before_lock {
expect_channel_ready_event(&nodes[0], &node_b_id);
}
@@ -2346,6 +2313,7 @@ fn test_path_paused_mpp() {
// HTLC along to nodes[3] and claim the whole payment back to nodes[0].
let (latest_update, _) = nodes[0].chain_monitor.get_latest_mon_update_id(chan_2_id);
nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_2_id, latest_update);
+ assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
let mut events = nodes[0].node.get_and_clear_pending_msg_events();
assert_eq!(events.len(), 1);
@@ -3046,6 +3014,7 @@ fn test_temporary_error_during_shutdown() {
let (latest_update, _) = nodes[0].chain_monitor.get_latest_mon_update_id(channel_id);
nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update);
+ assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
nodes[1].node.handle_closing_signed(
node_a_id,
&get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, node_b_id),
@@ -3056,6 +3025,7 @@ fn test_temporary_error_during_shutdown() {
chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
let (latest_update, _) = nodes[1].chain_monitor.get_latest_mon_update_id(channel_id);
nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
nodes[0].node.handle_closing_signed(
node_b_id,
@@ -3111,14 +3081,13 @@ fn double_temp_error() {
let (latest_update_2, _) = nodes[1].chain_monitor.get_latest_mon_update_id(channel_id);
nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update_1);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
check_added_monitors(&nodes[1], 0);
nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update_2);
- // Complete the first HTLC. Note that as a side-effect we handle the monitor update completions
- // and get both PaymentClaimed events at once.
- let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
-
+ // Handling events processes both monitor update completions, so we get both PaymentClaimed
+ // events at once.
let events = nodes[1].node.get_and_clear_pending_events();
assert_eq!(events.len(), 2);
match events[0] {
@@ -3134,6 +3103,8 @@ fn double_temp_error() {
_ => panic!("Unexpected Event: {:?}", events[1]),
}
+ // Complete the first HTLC.
+ let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
assert_eq!(msg_events.len(), 1);
let (update_fulfill_1, commitment_signed_b1, node_id) = {
match &msg_events[0] {
@@ -3534,25 +3505,8 @@ fn do_test_blocked_chan_preimage_release(completion_mode: BlockedUpdateComplMode
.unwrap();
}
- // Finish the CS dance between nodes[0] and nodes[1]. Note that until the event handling, the
- // update_fulfill_htlc + CS is held, even though the preimage is already on disk for the
- // channel.
- // Note that when completing as a side effect of a reload we completed the CS dance in
- // `reconnect_nodes` above.
- if completion_mode != BlockedUpdateComplMode::AtReload {
- nodes[1]
- .node
- .handle_commitment_signed_batch_test(node_a_id, &as_htlc_fulfill.commitment_signed);
- check_added_monitors(&nodes[1], 1);
- let (a, raa, holding_cell) = do_main_commitment_signed_dance(&nodes[1], &nodes[0], false);
- assert!(a.is_none());
- assert!(holding_cell.is_empty());
-
- nodes[1].node.handle_revoke_and_ack(node_a_id, &raa);
- check_added_monitors(&nodes[1], 1);
- assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
- }
-
+ // Note that until the event handling, the update_fulfill_htlc + CS is held, even though the
+ // preimage is already on disk for the channel.
let events = nodes[1].node.get_and_clear_pending_events();
assert_eq!(events.len(), 3, "{events:?}");
if let Event::PaymentSent { .. } = events[0] {
@@ -3574,6 +3528,23 @@ fn do_test_blocked_chan_preimage_release(completion_mode: BlockedUpdateComplMode
let mut bs_htlc_fulfill = get_htlc_update_msgs(&nodes[1], &node_c_id);
check_added_monitors(&nodes[1], 0);
+ // Finish the CS dance between nodes[0] and nodes[1].
+ // Note that when completing as a side effect of a reload we completed the CS dance in
+ // `reconnect_nodes` above.
+ if completion_mode != BlockedUpdateComplMode::AtReload {
+ nodes[1]
+ .node
+ .handle_commitment_signed_batch_test(node_a_id, &as_htlc_fulfill.commitment_signed);
+ check_added_monitors(&nodes[1], 1);
+ let (a, raa, holding_cell) = do_main_commitment_signed_dance(&nodes[1], &nodes[0], false);
+ assert!(a.is_none());
+ assert!(holding_cell.is_empty());
+
+ nodes[1].node.handle_revoke_and_ack(node_a_id, &raa);
+ check_added_monitors(&nodes[1], 1);
+ assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
+ }
+
nodes[2]
.node
.handle_update_fulfill_htlc(node_b_id, bs_htlc_fulfill.update_fulfill_htlcs.remove(0));
@@ -3711,10 +3682,9 @@ fn do_test_inverted_mon_completion_order(
.chain_monitor
.channel_monitor_updated(chan_id_ab, ab_update_id)
.unwrap();
-
- // When we fetch B's HTLC update messages next (now that the ChannelMonitorUpdate has
- // completed), it will also release the final RAA ChannelMonitorUpdate on the B <-> C
- // channel.
+ // Processing the ChannelMonitorUpdate completion will also release the final RAA
+ // ChannelMonitorUpdate on the B <-> C channel.
+ expect_payment_forwarded!(nodes[1], &nodes[0], &nodes[2], Some(1_000), false, false);
} else {
// If the ChannelManager used in the reload was stale, check that the B <-> C channel was
// closed.
@@ -3747,10 +3717,10 @@ fn do_test_inverted_mon_completion_order(
// The ChannelMonitorUpdate which was completed prior to the reconnect only contained the
// preimage (as it was a replay of the original ChannelMonitorUpdate from before we
- // restarted). When we go to fetch the commitment transaction updates we'll poll the
- // ChannelMonitorUpdate completion, then generate (and complete) a new ChannelMonitorUpdate
- // with the actual commitment transaction, which will allow us to fulfill the HTLC with
- // node A.
+ // restarted). When we process the ChannelMonitorUpdate completion we'll generate (and
+ // complete) a new ChannelMonitorUpdate with the actual commitment transaction, which will
+ // allow us to fulfill the HTLC with node A.
+ expect_payment_forwarded!(nodes[1], &nodes[0], &nodes[2], Some(1_000), false, true);
}
let mut bs_updates = get_htlc_update_msgs(&nodes[1], &node_a_id);
@@ -3759,15 +3729,6 @@ fn do_test_inverted_mon_completion_order(
nodes[0].node.handle_update_fulfill_htlc(node_b_id, bs_updates.update_fulfill_htlcs.remove(0));
do_commitment_signed_dance(&nodes[0], &nodes[1], &bs_updates.commitment_signed, false, false);
- expect_payment_forwarded!(
- nodes[1],
- &nodes[0],
- &nodes[2],
- Some(1_000),
- false,
- !with_latest_manager
- );
-
// Finally, check that the payment was, ultimately, seen as sent by node A.
expect_payment_sent(&nodes[0], payment_preimage, None, true, true);
}
@@ -3922,20 +3883,19 @@ fn do_test_durable_preimages_on_closed_channel(
}
}
if !close_chans_before_reload {
- check_closed_broadcast(&nodes[1], 1, false);
- // When hold=false, get_and_clear_pending_events also triggers
- // process_background_events (replaying the preimage and force-close updates)
- // and resolves the deferred completions, firing PaymentForwarded alongside
- // ChannelClosed. When hold=true, only ChannelClosed fires.
let evs = nodes[1].node.get_and_clear_pending_events();
- let expected = if hold_post_reload_mon_update { 1 } else { 2 };
- assert_eq!(evs.len(), expected, "{:?}", evs);
- assert!(evs.iter().any(|e| matches!(
- e,
+ assert_eq!(evs.len(), 1, "{:?}", evs);
+ assert!(matches!(
+ evs[0],
Event::ChannelClosed { reason: ClosureReason::CommitmentTxConfirmed, .. }
- )));
+ ));
+ check_closed_broadcast(&nodes[1], 1, false);
if !hold_post_reload_mon_update {
- assert!(evs.iter().any(|e| matches!(e, Event::PaymentForwarded { .. })));
+ // Handling events above also ran process_background_events, replaying the preimage
+ // and force-close updates. Processing their completions fires PaymentForwarded.
+ let evs = nodes[1].node.get_and_clear_pending_events();
+ assert_eq!(evs.len(), 1, "{:?}", evs);
+ assert!(matches!(evs[0], Event::PaymentForwarded { .. }));
check_added_monitors(&nodes[1], mons_added);
}
}
@@ -3959,11 +3919,11 @@ fn do_test_durable_preimages_on_closed_channel(
check_closed_broadcast(&nodes[0], 1, false);
expect_payment_sent(&nodes[0], payment_preimage, None, true, true);
- if close_chans_before_reload && !hold_post_reload_mon_update {
- // For close_chans_before_reload with hold=false, the deferred completions
- // haven't been processed yet. Trigger process_pending_monitor_events now.
- let _ = nodes[1].node.get_and_clear_pending_msg_events();
- check_added_monitors(&nodes[1], 0);
+ // Unless the A<->B monitor update is still in-flight, handling B's events runs the A<->B
+ // monitor update completion actions, unblocking the B<->C channel before we reconnect it.
+ let mut evs = Vec::new();
+ if !hold_post_reload_mon_update {
+ evs = nodes[1].node.get_and_clear_pending_events();
}
if !close_chans_before_reload || close_only_a {
@@ -3992,7 +3952,7 @@ fn do_test_durable_preimages_on_closed_channel(
// If the A<->B channel was closed before we reload, we'll replay the claim against it on
// reload, causing the `PaymentForwarded` event to get replayed.
- let evs = nodes[1].node.get_and_clear_pending_events();
+ evs.extend(nodes[1].node.get_and_clear_pending_events());
if !close_chans_before_reload && !hold_post_reload_mon_update {
// PaymentForwarded already fired during get_and_clear_pending_events above.
assert!(evs.is_empty(), "{:?}", evs);
@@ -4230,6 +4190,7 @@ fn do_test_glacial_peer_cant_hang(hold_chan_a: bool) {
.chain_monitor
.channel_monitor_updated(chan_id_ab, ab_update_id)
.is_ok());
+ expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false);
let mut msg_events = nodes[1].node.get_and_clear_pending_msg_events();
assert_eq!(msg_events.len(), 2);
@@ -4263,7 +4224,6 @@ fn do_test_glacial_peer_cant_hang(hold_chan_a: bool) {
let commitment = &a_update[0].commitment_signed;
do_commitment_signed_dance(&nodes[0], &nodes[1], commitment, false, false);
expect_payment_sent(&nodes[0], payment_preimage, None, true, true);
- expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false);
pass_along_path(
&nodes[1],
@@ -4394,9 +4354,9 @@ fn do_test_partial_claim_mon_update_compl_actions(reload_a: bool, reload_b: bool
// unblocks the 1<->3 channel, allowing node 3 to release the two blocked monitor updates and
// respond to the final commitment_signed.
assert!(get_monitor!(nodes[3], chan_3_id).get_stored_preimages().contains_key(&payment_hash));
- assert!(nodes[3].node.get_and_clear_pending_events().is_empty());
nodes[3].chain_monitor.complete_sole_pending_chan_update(&chan_4_id);
+ assert!(nodes[3].node.get_and_clear_pending_events().is_empty());
let mut ds_msgs = nodes[3].node.get_and_clear_pending_msg_events();
assert_eq!(ds_msgs.len(), 2, "{ds_msgs:?}");
check_added_monitors(&nodes[3], 2);
@@ -4562,10 +4522,10 @@ fn test_claim_to_closed_channel_blocks_forwarded_preimage_removal() {
assert_eq!(as_commit_tx.len(), 1);
mine_transaction(&nodes[1], &as_commit_tx[0]);
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let b_reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, b_reason, &[node_a_id], 1000000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
// 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.
@@ -4588,21 +4548,20 @@ fn test_claim_to_closed_channel_blocks_forwarded_preimage_removal() {
.any(|(_, (_, preimage))| *preimage == Some(payment_preimage)));
// Once we complete the `ChannelMonitorUpdate` on channel A, and the `ChannelManager` processes
- // background events (via `get_and_clear_pending_msg_events`), the final `ChannelMonitorUpdate`
- // will fly and we'll drop the preimage from channel B's `ChannelMonitor`. We'll also release
- // the `Event::PaymentForwarded`.
+ // events, the final `ChannelMonitorUpdate` will fly and we'll drop the preimage from channel B's
+ // `ChannelMonitor`. We'll also release the `Event::PaymentForwarded`.
check_added_monitors(&nodes[1], 0);
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
nodes[1].chain_monitor.complete_sole_pending_chan_update(&chan_a.2);
+ expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], None, true, false);
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
check_added_monitors(&nodes[1], 1);
assert!(!get_monitor!(nodes[1], chan_b.2)
.get_all_current_outbound_htlcs()
.iter()
.any(|(_, (_, preimage))| *preimage == Some(payment_preimage)));
- expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], None, true, false);
}
#[test]
@@ -4640,10 +4599,10 @@ fn test_claim_to_closed_channel_blocks_claimed_event() {
assert_eq!(as_commit_tx.len(), 1);
mine_transaction(&nodes[1], &as_commit_tx[0]);
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let b_reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, b_reason, &[node_a_id], 1000000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
// 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
@@ -5210,6 +5169,7 @@ fn test_mpp_claim_to_holding_cell() {
// Complete the B <-> D monitor update, freeing the first fulfill.
let (latest_id, _) = nodes[3].chain_monitor.get_latest_mon_update_id(chan_3_id);
nodes[3].chain_monitor.chain_monitor.channel_monitor_updated(chan_3_id, latest_id).unwrap();
+ expect_payment_claimed!(nodes[3], paymnt_hash_1, 500_000);
let mut b_claim = get_htlc_update_msgs(&nodes[3], &node_b_id);
// When we deliver the pre-claim RAA, node D will shove the monitor update into the blocked
@@ -5221,11 +5181,10 @@ fn test_mpp_claim_to_holding_cell() {
// due to the existence of the blocked RAA update above.
let (latest_id, _) = nodes[3].chain_monitor.get_latest_mon_update_id(chan_4_id);
nodes[3].chain_monitor.chain_monitor.channel_monitor_updated(chan_4_id, latest_id).unwrap();
- // Once we process monitor events (in this case by checking for the `PaymentClaimed` event, the
- // RAA monitor update blocked above will be released.
+ // Once we process monitor events, the RAA monitor update blocked above will be released.
// At the same time, the RAA monitor update completion will allow the C <-> D channel to
// generate its fulfill update.
- expect_payment_claimed!(nodes[3], paymnt_hash_1, 500_000);
+ assert!(nodes[3].node.get_and_clear_pending_events().is_empty());
check_added_monitors(&nodes[3], 2);
let mut c_claim = get_htlc_update_msgs(&nodes[3], &node_c_id);
check_added_monitors(&nodes[3], 0);
@@ -5396,7 +5355,7 @@ fn do_test_late_counterparty_commitment_update_after_holder_commitment_spend(dus
let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2;
// Route HTLC X fully (committed in both commitments).
- let (_, payment_hash_x, ..) = route_payment(&nodes[0], &[&nodes[1]], 1_000_000);
+ let (_, payment_hash_x, ..) = route_payment_deferred(&nodes[0], &nodes[1], 1_000_000);
// Get A's holder commitment which now contains HTLC X. For legacy (non-anchor) channels,
// the HTLC-timeout transaction is also returned.
@@ -5742,12 +5701,12 @@ fn test_stale_manager_with_since_applied_blocked_mon_update() {
mine_transaction(&nodes[1], &cs_txn[0]);
mine_transaction(&nodes[1], &cs_txn[1]);
+ expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, true);
let bs_claim = get_htlc_update_msgs(&nodes[1], &node_a_id);
check_added_monitors(&nodes[1], 1);
nodes[0].node.handle_update_fulfill_htlc(node_b_id, bs_claim.update_fulfill_htlcs[0].clone());
do_commitment_signed_dance(&nodes[0], &nodes[1], &bs_claim.commitment_signed, false, false);
expect_payment_sent(&nodes[0], preimage_2, None, true, true);
- expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, true);
}
#[derive(Clone, Copy, PartialEq)]
### lightning/src/ln/channel_open_tests.rs
@@ -2373,15 +2373,15 @@ pub fn test_funding_and_commitment_tx_confirm_same_block() {
panic!();
}
};
- check_msg_events(&nodes[0]);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 1_000_000);
+ check_msg_events(&nodes[0]);
+ check_added_monitors(&nodes[0], 1);
- check_msg_events(&nodes[1]);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 1_000_000);
+ check_msg_events(&nodes[1]);
+ check_added_monitors(&nodes[1], 1);
assert!(nodes[0].node.list_channels().is_empty());
assert!(nodes[1].node.list_channels().is_empty());
### lightning/src/ln/channelmanager.rs
@@ -16780,9 +16780,7 @@ impl<
// need, especially anything that might end up causing I/O (like a
// `ChannelMonitorUpdate`)!
- // TODO: This behavior should be documented. It's unintuitive that we query
- // ChannelMonitors when clearing other events.
- let mut result = self.process_pending_monitor_events();
+ let mut result = NotifyOption::SkipPersistNoEvents;
if self.maybe_generate_initial_closing_signed() {
result = NotifyOption::DoPersist;
### lightning/src/ln/functional_test_utils.rs
@@ -4427,6 +4427,46 @@ pub fn route_payment<'a, 'b, 'c>(
(res.0, res.1, res.2, res.3)
}
+/// Routes a payment from `origin_node` to its peer `recipient`, where both use a deferred
+/// [`TestChainMonitor`]. Queued monitor updates are only flushed, and their completions processed,
+/// when a node handles its events, so each node handles its events after every step which
+/// generates a monitor update.
+pub fn route_payment_deferred<'a, 'b, 'c>(
+ origin_node: &Node<'a, 'b, 'c>, recipient: &Node<'a, 'b, 'c>, recv_value: u64,
+) -> (PaymentPreimage, PaymentHash, PaymentSecret, PaymentId) {
+ let origin_id = origin_node.node.get_our_node_id();
+ let recipient_id = recipient.node.get_our_node_id();
+ let (route, payment_hash, payment_preimage, payment_secret) =
+ get_route_and_payment_hash!(origin_node, recipient, recv_value);
+ let onion = RecipientOnionFields::secret_only(payment_secret, recv_value);
+ let payment_id = PaymentId(payment_hash.0);
+ origin_node.node.send_payment_with_route(route, payment_hash, onion, payment_id).unwrap();
+ check_added_monitors(origin_node, 1);
+ assert!(origin_node.node.get_and_clear_pending_events().is_empty());
+
+ let updates = get_htlc_update_msgs(origin_node, &recipient_id);
+ recipient.node.handle_update_add_htlc(origin_id, &updates.update_add_htlcs[0]);
+ recipient.node.handle_commitment_signed_batch_test(origin_id, &updates.commitment_signed);
+ check_added_monitors(recipient, 1);
+ assert!(recipient.node.get_and_clear_pending_events().is_empty());
+
+ let (raa, cs) = get_revoke_commit_msgs(recipient, &origin_id);
+ origin_node.node.handle_revoke_and_ack(recipient_id, &raa);
+ check_added_monitors(origin_node, 1);
+ origin_node.node.handle_commitment_signed_batch_test(recipient_id, &cs);
+ check_added_monitors(origin_node, 1);
+ assert!(origin_node.node.get_and_clear_pending_events().is_empty());
+
+ let raa = get_event_msg!(origin_node, MessageSendEvent::SendRevokeAndACK, recipient_id);
+ recipient.node.handle_revoke_and_ack(origin_id, &raa);
+ check_added_monitors(recipient, 1);
+ assert!(recipient.node.get_and_clear_pending_events().is_empty());
+
+ expect_and_process_pending_htlcs(recipient, false);
+ expect_payment_claimable!(recipient, payment_hash, payment_secret, recv_value);
+ (payment_preimage, payment_hash, payment_secret, payment_id)
+}
+
pub fn send_payment<'a, 'b, 'c>(
origin: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64,
) -> (PaymentPreimage, PaymentHash, PaymentSecret, PaymentId) {
### lightning/src/ln/functional_tests.rs
@@ -374,6 +374,8 @@ pub fn test_duplicate_htlc_different_direction_onchain() {
assert_eq!(has_both_htlcs, 2);
mine_transaction(&nodes[0], &remote_txn[0]);
+ let reason = ClosureReason::CommitmentTxConfirmed;
+ check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
let events = nodes[0].node.get_and_clear_pending_msg_events();
assert_eq!(events.len(), 3);
for e in events {
@@ -408,8 +410,6 @@ pub fn test_duplicate_htlc_different_direction_onchain() {
}
}
check_added_monitors(&nodes[0], 1);
- let reason = ClosureReason::CommitmentTxConfirmed;
- check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
connect_blocks(&nodes[0], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
let claim_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
@@ -579,9 +579,9 @@ fn do_test_fail_back_before_backwards_timeout(post_fail_back_action: PostFailBac
connect_blocks(&nodes[2], TEST_FINAL_CLTV - CLTV_CLAIM_BUFFER + 2);
let node_2_txn = test_txn_broadcast(&nodes[2], &chan_2, None, HTLCType::SUCCESS);
- check_closed_broadcast(&nodes[2], 1, true);
let reason = ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash) };
check_closed_event(&nodes[2], 1, reason, &[node_b_id], 100_000);
+ check_closed_broadcast(&nodes[2], 1, true);
check_added_monitors(&nodes[2], 1);
mine_transaction(&nodes[1], &node_2_txn[0]); // Commitment
@@ -648,15 +648,15 @@ fn test_preimage_claim_reconfirmed_before_event_handled() {
connect_blocks(&nodes[1], TEST_FINAL_CLTV - CLTV_CLAIM_BUFFER + 2);
let node_1_txn = test_txn_broadcast(&nodes[1], &chan, None, HTLCType::SUCCESS);
- check_closed_broadcast(&nodes[1], 1, true);
let reason = ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash) };
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100_000);
+ check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
// A sees B's commitment transaction confirm.
mine_transaction(&nodes[0], &node_1_txn[0]);
- check_closed_broadcast(&nodes[0], 1, true);
check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[node_b_id], 100_000);
+ check_closed_broadcast(&nodes[0], 1, true);
check_added_monitors(&nodes[0], 1);
// A sees the HTLC-Success confirm, which queues a claim event for the `ChannelManager`. Before
@@ -740,14 +740,14 @@ pub fn channel_monitor_network_test() {
}
mine_transaction(&nodes[0], &node_txn[0]);
+ let reason = ClosureReason::CommitmentTxConfirmed;
+ check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
check_closed_broadcast(&nodes[0], 1, true);
check_added_monitors(&nodes[0], 1);
test_txn_broadcast(&nodes[0], &chan_1, Some(node_txn[0].clone()), HTLCType::NONE);
}
assert_eq!(nodes[0].node.list_channels().len(), 0);
assert_eq!(nodes[1].node.list_channels().len(), 1);
- let reason = ClosureReason::CommitmentTxConfirmed;
- check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
// One pending HTLC is discarded by the force-close:
let (payment_preimage_1, payment_hash_1, ..) =
@@ -770,6 +770,8 @@ pub fn channel_monitor_network_test() {
);
test_txn_broadcast(&nodes[1], &chan_2, None, HTLCType::TIMEOUT);
mine_transaction(&nodes[2], &node_txn[0]);
+ let node_c_reason = ClosureReason::CommitmentTxConfirmed;
+ check_closed_event(&nodes[2], 1, node_c_reason, &[node_b_id], 100000);
check_closed_broadcast(&nodes[2], 1, true);
check_added_monitors(&nodes[2], 1);
test_txn_broadcast(&nodes[2], &chan_2, Some(node_txn[0].clone()), HTLCType::NONE);
@@ -779,8 +781,6 @@ pub fn channel_monitor_network_test() {
let node_b_reason =
ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true), message };
check_closed_event(&nodes[1], 1, node_b_reason, &[node_c_id], 100000);
- let node_c_reason = ClosureReason::CommitmentTxConfirmed;
- check_closed_event(&nodes[2], 1, node_c_reason, &[node_b_id], 100000);
macro_rules! claim_funds {
($node: expr, $prev_node: expr, $preimage: expr, $payment_hash: expr) => {{
@@ -825,6 +825,8 @@ pub fn channel_monitor_network_test() {
// Claim the payment on nodes[3], giving it knowledge of the preimage
claim_funds!(nodes[3], nodes[2], payment_preimage_1, payment_hash_1);
mine_transaction(&nodes[3], &node_txn[0]);
+ let node_d_reason = ClosureReason::CommitmentTxConfirmed;
+ check_closed_event(&nodes[3], 1, node_d_reason, &[node_c_id], 100000);
check_closed_broadcast(&nodes[3], 1, true);
check_added_monitors(&nodes[3], 1);
check_preimage_claim(&nodes[3], &node_txn);
@@ -834,8 +836,6 @@ pub fn channel_monitor_network_test() {
let node_c_reason =
ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true), message };
check_closed_event(&nodes[2], 1, node_c_reason, &[node_d_id], 100000);
- let node_d_reason = ClosureReason::CommitmentTxConfirmed;
- check_closed_event(&nodes[3], 1, node_d_reason, &[node_c_id], 100000);
// Drop the ChannelMonitor for the previous channel to avoid it broadcasting transactions and
// confusing us in the following tests.
@@ -849,6 +849,8 @@ pub fn channel_monitor_network_test() {
let (close_chan_update_1, close_chan_update_2) = {
connect_blocks(&nodes[3], TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + 1);
+ let reason = ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash_2) };
+ check_closed_event(&nodes[3], 1, reason, &[node_e_id], 100000);
let events = nodes[3].node.get_and_clear_pending_msg_events();
assert_eq!(events.len(), 2);
let close_chan_update_1 = match events[1] {
@@ -884,6 +886,8 @@ pub fn channel_monitor_network_test() {
claim_funds!(nodes[4], nodes[3], payment_preimage_2, payment_hash_2);
connect_blocks(&nodes[4], TEST_FINAL_CLTV - CLTV_CLAIM_BUFFER + 2);
+ let reason = ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash_2) };
+ check_closed_event(&nodes[4], 1, reason, &[node_d_id], 100000);
let events = nodes[4].node.get_and_clear_pending_msg_events();
assert_eq!(events.len(), 2);
let close_chan_update_2 = match events[1] {
@@ -901,8 +905,6 @@ pub fn channel_monitor_network_test() {
}
check_added_monitors(&nodes[4], 1);
test_txn_broadcast(&nodes[4], &chan_4, None, HTLCType::SUCCESS);
- let reason = ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash_2) };
- check_closed_event(&nodes[4], 1, reason, &[node_d_id], 100000);
mine_transaction(&nodes[4], &node_txn[0]);
check_preimage_claim(&nodes[4], &node_txn);
@@ -919,8 +921,6 @@ pub fn channel_monitor_network_test() {
nodes[3].chain_monitor.chain_monitor.watch_channel(chan_3.2, chan_3_mon),
Ok(ChannelMonitorUpdateStatus::Completed)
);
- let reason = ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash_2) };
- check_closed_event(&nodes[3], 1, reason, &[node_id_4], 100000);
}
#[xtest(feature = "_externalize_tests")]
@@ -1058,14 +1058,15 @@ pub fn test_justice_tx_htlc_success() {
check_spends!(node_txn[0], revoked_local_txn[0]);
node_txn.swap_remove(0);
}
+ let reason = ClosureReason::CommitmentTxConfirmed;
+ check_closed_event(&nodes[0], 1, reason.clone(), &[node_b_id], 100000);
check_closed_broadcast(&nodes[0], 1, true);
check_added_monitors(&nodes[0], 1);
test_txn_broadcast(&nodes[0], &chan_6, Some(revoked_local_txn[0].clone()), HTLCType::NONE);
mine_transaction(&nodes[1], &revoked_local_txn[0]);
+ check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
check_closed_broadcast(&nodes[1], 1, true);
- let reason = ClosureReason::CommitmentTxConfirmed;
- check_closed_event(&nodes[1], 1, reason.clone(), &[node_a_id], 100000);
let node_txn = test_txn_broadcast(
&nodes[1],
&chan_6,
@@ -1074,7 +1075,6 @@ pub fn test_justice_tx_htlc_success() {
);
check_added_monitors(&nodes[1], 1);
mine_transaction(&nodes[0], &node_txn[1]);
- check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
test_revoked_htlc_claim_txn_broadcast(
&nodes[0],
node_txn[1].clone(),
@@ -1120,9 +1120,9 @@ pub fn revoked_output_claim() {
// Inform nodes[0] that a watchtower cheated on its behalf, so it will force-close the chan
mine_transaction(&nodes[0], &revoked_local_txn[0]);
+ check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
get_announce_close_broadcast_events(&nodes, 0, 1);
check_added_monitors(&nodes[0], 1);
- check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
}
#[xtest(feature = "_externalize_tests")]
@@ -1175,15 +1175,15 @@ fn do_test_forming_justice_tx_from_monitor_updates(broadcast_initial_commitment:
mine_transactions(&nodes[1], &[revoked_commitment_tx, &justice_tx]);
mine_transactions(&nodes[0], &[revoked_commitment_tx, &justice_tx]);
- get_announce_close_broadcast_events(&nodes, 1, 0);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100_000);
-
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100_000);
+ get_announce_close_broadcast_events(&nodes, 1, 0);
+ check_added_monitors(&nodes[1], 1);
+ check_added_monitors(&nodes[0], 1);
+
// Check that the justice tx has sent the revoked output value to nodes[1]
let monitor = get_monitor!(nodes[1], channel_id);
let total_claimable_balance =
@@ -1248,14 +1248,14 @@ pub fn claim_htlc_outputs() {
{
mine_transaction(&nodes[0], &revoked_local_txn[0]);
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason.clone(), &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
mine_transaction(&nodes[1], &revoked_local_txn[0]);
+ check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
- check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
@@ -1425,6 +1425,31 @@ pub fn do_test_multiple_package_conflicts(p2a_anchor: bool) {
// logic to run. Package 2 should get split so that only HTLC 3 gets claimed.
mine_transaction(&nodes[1], &conflict_tx);
+ let mut events = nodes[1].node.get_and_clear_pending_events();
+ assert_eq!(events.len(), 2);
+ expect_payment_forwarded(
+ events.pop().unwrap(),
+ &nodes[1],
+ &nodes[0],
+ &nodes[2],
+ Some(1000),
+ None,
+ false,
+ true,
+ false,
+ );
+ expect_payment_forwarded(
+ events.pop().unwrap(),
+ &nodes[1],
+ &nodes[0],
+ &nodes[2],
+ Some(1000),
+ None,
+ false,
+ true,
+ false,
+ );
+
// Check that node 1 only attempts to claim HTLC 3 now. There should be no conflicting spends
// in the newly broadcasted transaction.
let broadcasted_txs = nodes[1].tx_broadcaster.txn_broadcast();
@@ -1468,31 +1493,6 @@ pub fn do_test_multiple_package_conflicts(p2a_anchor: bool) {
nodes[0].node.handle_update_fulfill_htlc(node_b_id, updates.update_fulfill_htlcs.remove(0));
do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
expect_payment_sent!(nodes[0], preimage_2);
-
- let mut events = nodes[1].node.get_and_clear_pending_events();
- assert_eq!(events.len(), 2);
- expect_payment_forwarded(
- events.pop().unwrap(),
- &nodes[1],
- &nodes[0],
- &nodes[2],
- Some(1000),
- None,
- false,
- true,
- false,
- );
- expect_payment_forwarded(
- events.pop().unwrap(),
- &nodes[1],
- &nodes[0],
- &nodes[2],
- Some(1000),
- None,
- false,
- true,
- false,
- );
}
// Test that the HTLC package logic removes HTLCs from the package when they are claimed by the
@@ -1573,10 +1573,10 @@ pub fn test_htlc_on_chain_success() {
assert_eq!(updates.update_fulfill_htlcs.len(), 1);
mine_transaction(&nodes[2], &commitment_tx[0]);
- check_closed_broadcast(&nodes[2], 1, true);
- check_added_monitors(&nodes[2], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[2], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[2], 1, true);
+ check_added_monitors(&nodes[2], 1);
let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelMonitor: 2 (2 * HTLC-Success tx)
assert_eq!(node_txn.len(), 2);
check_spends!(node_txn[0], commitment_tx[0]);
@@ -1701,10 +1701,10 @@ pub fn test_htlc_on_chain_success() {
let node_a_commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
check_spends!(node_a_commitment_tx[0], chan_1.3);
mine_transaction(&nodes[1], &node_a_commitment_tx[0]);
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
assert!(node_txn.len() == 1 || node_txn.len() == 2); // HTLC-Success, RBF bump of above aggregated HTLC txn
let commitment_spend = if node_txn.len() == 1 {
@@ -1736,10 +1736,9 @@ pub fn test_htlc_on_chain_success() {
let txn = vec![node_a_commitment_tx[0].clone(), commitment_spend.clone()];
connect_block(&nodes[0], &create_dummy_block(nodes[0].best_block_hash(), 42, txn));
connect_blocks(&nodes[0], TEST_FINAL_CLTV + MIN_CLTV_EXPIRY_DELTA as u32); // Confirm blocks until the HTLC expires
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let events = nodes[0].node.get_and_clear_pending_events();
- check_added_monitors(&nodes[0], 2);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 3);
assert_eq!(events.len(), 5);
let mut first_claimed = false;
for event in events {
@@ -1844,10 +1843,10 @@ fn do_test_htlc_on_chain_timeout(connect_style: ConnectStyle) {
_ => panic!("Unexpected event"),
};
mine_transaction(&nodes[2], &commitment_tx[0]);
- check_closed_broadcast(&nodes[2], 1, true);
- check_added_monitors(&nodes[2], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[2], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[2], 1, true);
+ check_added_monitors(&nodes[2], 1);
let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
assert_eq!(node_txn.len(), 0);
@@ -1928,10 +1927,10 @@ fn do_test_htlc_on_chain_timeout(connect_style: ConnectStyle) {
mine_transaction(&nodes[0], &commitment_tx[0]);
connect_blocks(&nodes[0], TEST_FINAL_CLTV + MIN_CLTV_EXPIRY_DELTA as u32); // Confirm blocks until the HTLC expires
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // 1 timeout tx
assert_eq!(node_txn.len(), 1);
check_spends!(node_txn[0], commitment_tx[0]);
@@ -2490,10 +2489,10 @@ pub fn test_htlc_ignore_latest_remote_commitment() {
let block = create_dummy_block(nodes[1].best_block_hash(), 42, vec![node_txn[0].clone()]);
connect_block(&nodes[1], &block);
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
// Duplicate the connect_block call since this may happen due to other listeners
// registering new transactions
@@ -2576,10 +2575,10 @@ pub fn test_force_close_fail_back() {
mine_transaction(&nodes[1], &commitment_tx);
// Note no UpdateHTLCs event here from nodes[1] to nodes[0]!
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_c_id], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
// Now check that if we add the preimage to ChannelMonitor it broadcasts our HTLC-Success..
{
@@ -3733,10 +3732,10 @@ pub fn test_claim_on_remote_sizeable_push_msat() {
assert_eq!(node_txn[0].output.len(), 2); // We can't force trimming of to_remote output as channel_reserve_satoshis block us to do so at channel opening
mine_transaction(&nodes[1], &node_txn[0]);
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
let spend_txn = check_spendable_outputs!(nodes[1], node_cfgs[1].keys_manager);
@@ -3766,10 +3765,10 @@ pub fn test_claim_on_remote_revoked_sizeable_push_msat() {
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
mine_transaction(&nodes[1], &revoked_local_txn[0]);
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
mine_transaction(&nodes[1], &node_txn[0]);
@@ -3807,6 +3806,8 @@ pub fn test_static_spendable_outputs_preimage_tx() {
expect_payment_claimed!(nodes[1], payment_hash, 3_000_000);
check_added_monitors(&nodes[1], 1);
mine_transaction(&nodes[1], &commitment_tx[0]);
+ let reason = ClosureReason::CommitmentTxConfirmed;
+ check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
let events = nodes[1].node.get_and_clear_pending_msg_events();
match events[0] {
MessageSendEvent::UpdateHTLCs { .. } => {},
@@ -3825,8 +3826,6 @@ pub fn test_static_spendable_outputs_preimage_tx() {
assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
mine_transaction(&nodes[1], &node_txn[0]);
- let reason = ClosureReason::CommitmentTxConfirmed;
- check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
let spend_txn = check_spendable_outputs!(nodes[1], node_cfgs[1].keys_manager);
@@ -3859,6 +3858,8 @@ pub fn test_static_spendable_outputs_timeout_tx() {
// Settle A's commitment tx on B' chain
mine_transaction(&nodes[1], &commitment_tx[0]);
+ let reason = ClosureReason::CommitmentTxConfirmed;
+ check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
let events = nodes[1].node.get_and_clear_pending_msg_events();
match events[1] {
MessageSendEvent::BroadcastChannelUpdate { .. } => {},
@@ -3874,8 +3875,6 @@ pub fn test_static_spendable_outputs_timeout_tx() {
assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
mine_transaction(&nodes[1], &node_txn[0]);
- let reason = ClosureReason::CommitmentTxConfirmed;
- check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
let conditions = PaymentFailedConditions::new().from_mon_update();
expect_payment_failed_conditions(&nodes[1], our_payment_hash, false, conditions);
@@ -3913,10 +3912,10 @@ fn do_test_static_spendable_outputs_justice_tx_revoked_commitment_tx(split_tx: b
}
mine_transaction(&nodes[1], &revoked_local_txn[0]);
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
// If the HTLC expires in more than COUNTERPARTY_CLAIMABLE_WITHIN_BLOCKS_PINNABLE blocks, we'll
// claim both the revoked and HTLC outputs in one transaction, otherwise we'll split them as we
@@ -3971,10 +3970,10 @@ pub fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() {
// A will generate HTLC-Timeout from revoked commitment tx
mine_transaction(&nodes[0], &revoked_local_txn[0]);
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
connect_blocks(&nodes[0], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
let revoked_htlc_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
@@ -3994,10 +3993,10 @@ pub fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() {
// B will generate justice tx from A's revoked commitment/HTLC tx
let txn = vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()];
connect_block(&nodes[1], &create_dummy_block(nodes[1].best_block_hash(), 42, txn));
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
// There will be 2 justice transactions:
// - One on the unpinnable, revoked to_self output on the commitment transaction and on
@@ -4055,10 +4054,10 @@ pub fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() {
// B will generate HTLC-Success from revoked commitment tx
mine_transaction(&nodes[1], &revoked_local_txn[0]);
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
let revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
assert_eq!(revoked_htlc_txn.len(), 1);
@@ -4076,10 +4075,10 @@ pub fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() {
// A will generate justice tx from B's revoked commitment/HTLC tx
let txn = vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()];
connect_block(&nodes[0], &create_dummy_block(nodes[0].best_block_hash(), 42, txn));
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
// There will be 2 justice transactions, one on the revoked HTLC output on the commitment
// transaction, and one on the revoked to_self output on the HTLC-success transaction.
@@ -4162,10 +4161,10 @@ pub fn test_onchain_to_onchain_claim() {
assert!(updates.update_fail_malformed_htlcs.is_empty());
mine_transaction(&nodes[2], &commitment_tx[0]);
- check_closed_broadcast(&nodes[2], 1, true);
- check_added_monitors(&nodes[2], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[2], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[2], 1, true);
+ check_added_monitors(&nodes[2], 1);
let c_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelMonitor: 1 (HTLC-Success tx)
assert_eq!(c_txn.len(), 1);
@@ -4327,10 +4326,10 @@ pub fn test_duplicate_payment_hash_one_failure_one_success() {
check_spends!(commitment_txn[0], chan_2.3);
mine_transaction(&nodes[1], &commitment_txn[0]);
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_c_id], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
// Confirm blocks until both HTLCs expire and get a transaction which times out one HTLC.
connect_blocks(&nodes[1], TEST_FINAL_CLTV + config.channel_config.cltv_expiry_delta as u32);
@@ -4376,10 +4375,10 @@ pub fn test_duplicate_payment_hash_one_failure_one_success() {
// generate (note that the ChannelMonitor doesn't differentiate between HTLCs once it has the
// preimage).
mine_transaction(&nodes[2], &commitment_txn[0]);
- check_closed_broadcast(&nodes[2], 1, true);
- check_added_monitors(&nodes[2], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[2], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[2], 1, true);
+ check_added_monitors(&nodes[2], 1);
let htlc_success_txn: Vec<_> = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
assert_eq!(htlc_success_txn.len(), 2); // ChannelMonitor: HTLC-Success txn (*2 due to 2-HTLC outputs)
@@ -4478,6 +4477,8 @@ pub fn test_dynamic_spendable_outputs_local_htlc_success_tx() {
check_added_monitors(&nodes[1], 1);
mine_transaction(&nodes[1], &local_txn[0]);
+ let reason = ClosureReason::CommitmentTxConfirmed;
+ check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
let events = nodes[1].node.get_and_clear_pending_msg_events();
match events[0] {
MessageSendEvent::UpdateHTLCs { .. } => {},
@@ -4488,8 +4489,6 @@ pub fn test_dynamic_spendable_outputs_local_htlc_success_tx() {
_ => panic!("Unexepected event"),
}
check_added_monitors(&nodes[1], 1);
- let reason = ClosureReason::CommitmentTxConfirmed;
- check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
let node_tx = {
let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
assert_eq!(node_txn.len(), 1);
@@ -4731,42 +4730,21 @@ fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, anno
connect_blocks(&nodes[2], ANTI_REORG_DELAY - 1);
check_closed_broadcast(&nodes[2], 1, true);
- if deliver_last_raa {
- nodes[2].node.process_pending_htlc_forwards();
-
- let expected_destinations: Vec<HTLCHandlingFailureType> =
- repeat(HTLCHandlingFailureType::Forward {
- node_id: Some(node_d_id),
- channel_id: chan_2_3.2,
- })
- .take(3)
- .collect();
- expect_htlc_handling_failed_destinations!(
- nodes[2].node.get_and_clear_pending_events(),
- expected_destinations
- );
+ let failed_count = if deliver_last_raa {
+ 3
+ } else if announce_latest {
+ 9
} else {
- let expected_destinations: Vec<HTLCHandlingFailureType> = if announce_latest {
- repeat(HTLCHandlingFailureType::Forward {
- node_id: Some(node_d_id),
- channel_id: chan_2_3.2,
- })
- .take(9)
- .collect()
- } else {
- repeat(HTLCHandlingFailureType::Forward {
- node_id: Some(node_d_id),
- channel_id: chan_2_3.2,
- })
- .take(6)
- .collect()
- };
-
- expect_and_process_pending_htlcs_and_htlc_handling_failed(
- &nodes[2],
- &expected_destinations,
- );
- }
+ 6
+ };
+ let expected_destinations: Vec<HTLCHandlingFailureType> =
+ repeat(HTLCHandlingFailureType::Forward {
+ node_id: Some(node_d_id),
+ channel_id: chan_2_3.2,
+ })
+ .take(failed_count)
+ .collect();
+ expect_and_process_pending_htlcs_and_htlc_handling_failed(&nodes[2], &expected_destinations);
check_added_monitors(&nodes[2], 3);
let cs_msgs = nodes[2].node.get_and_clear_pending_msg_events();
@@ -4962,10 +4940,10 @@ pub fn test_dynamic_spendable_outputs_local_htlc_timeout_tx() {
// Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx
mine_transaction(&nodes[0], &local_txn[0]);
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
connect_blocks(&nodes[0], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
let htlc_timeout = {
@@ -5090,10 +5068,10 @@ pub fn test_key_derivation_params() {
// Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx
mine_transaction(&nodes[0], &local_txn_1[0]);
connect_blocks(&nodes[0], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
let htlc_timeout = {
let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
@@ -5199,10 +5177,10 @@ fn do_htlc_claim_local_commitment_only(use_dust: bool) {
}
let htlc_type = if use_dust { HTLCType::NONE } else { HTLCType::SUCCESS };
test_txn_broadcast(&nodes[1], &chan, None, htlc_type);
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash) };
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
}
fn do_htlc_claim_current_remote_commitment_only(use_dust: bool) {
@@ -5241,10 +5219,10 @@ fn do_htlc_claim_current_remote_commitment_only(use_dust: bool) {
block.header.prev_blockhash = block.block_hash();
}
test_txn_broadcast(&nodes[0], &chan, None, HTLCType::NONE);
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash) };
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
}
fn do_htlc_claim_previous_remote_commitment_only(use_dust: bool, check_revoke_no_close: bool) {
@@ -5302,10 +5280,10 @@ fn do_htlc_claim_previous_remote_commitment_only(use_dust: bool, check_revoke_no
}
if !check_revoke_no_close {
test_txn_broadcast(&nodes[0], &chan, None, HTLCType::NONE);
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::HTLCsTimedOut { payment_hash: Some(our_payment_hash) };
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
} else {
expect_payment_failed!(nodes[0], our_payment_hash, true);
}
@@ -6025,10 +6003,10 @@ fn do_test_failure_delay_dust_htlc_local_commitment(announce_latest: bool) {
mine_transaction(&nodes[0], &as_prev_commitment_tx[0]);
}
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
@@ -6132,10 +6110,10 @@ fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
} else {
// We fail dust-HTLC 1 by broadcast of remote commitment tx. If revoked, fail also non-dust HTLC
mine_transaction(&nodes[0], &bs_commitment_tx[0]);
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
connect_blocks(&nodes[0], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
@@ -6409,6 +6387,8 @@ pub fn test_bump_penalty_txn_on_revoked_commitment() {
// Actually revoke tx by claiming a HTLC
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
connect_block(&nodes[1], &create_dummy_block(header_114, 42, vec![revoked_txn[0].clone()]));
+ let reason = ClosureReason::CommitmentTxConfirmed;
+ check_closed_event(&nodes[1], 1, reason, &[node_a_id], 1000000);
check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
@@ -6547,10 +6527,10 @@ pub fn test_bump_penalty_txn_on_revoked_htlcs() {
&nodes[1],
&create_dummy_block(nodes[1].best_block_hash(), 42, vec![revoked_local_txn[0].clone()]),
);
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 1000000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
connect_blocks(&nodes[1], 50); // Confirm blocks until the HTLC expires (note CLTV was explicitly 50 above)
let revoked_htlc_txn = {
@@ -6573,14 +6553,6 @@ pub fn test_bump_penalty_txn_on_revoked_htlcs() {
let hash_128 = connect_blocks(&nodes[0], 40);
let block_11 = create_dummy_block(hash_128, 42, vec![revoked_local_txn[0].clone()]);
connect_block(&nodes[0], &block_11);
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
- let block_129 = create_dummy_block(
- block_11.block_hash(),
- 42,
- vec![revoked_htlc_txn[0].clone(), revoked_htlc_txn[1].clone()],
- );
- connect_block(&nodes[0], &block_129);
let events = nodes[0].node.get_and_clear_pending_events();
expect_htlc_failure_conditions(
events[0..1].to_vec(),
@@ -6590,6 +6562,14 @@ pub fn test_bump_penalty_txn_on_revoked_htlcs() {
Event::ChannelClosed { reason: ClosureReason::CommitmentTxConfirmed, .. } => {},
_ => panic!("Unexpected event"),
}
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
+ let block_129 = create_dummy_block(
+ block_11.block_hash(),
+ 42,
+ vec![revoked_htlc_txn[0].clone(), revoked_htlc_txn[1].clone()],
+ );
+ connect_block(&nodes[0], &block_129);
let first;
let feerate_1;
let penalty_txn;
@@ -6720,6 +6700,8 @@ pub fn test_bump_penalty_txn_on_remote_commitment() {
expect_payment_claimed!(nodes[1], payment_hash, htlc_value_a_msats);
let _ = get_htlc_update_msgs(&nodes[1], &nodes[0].node.get_our_node_id());
mine_transaction(&nodes[1], &remote_txn[0]);
+ let reason = ClosureReason::CommitmentTxConfirmed;
+ check_closed_event(&nodes[1], 1, reason, &[nodes[0].node.get_our_node_id()], 1000000);
check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 2);
connect_blocks(&nodes[1], TEST_FINAL_CLTV); // Confirm blocks until the HTLC expires
@@ -6900,10 +6882,10 @@ pub fn test_bump_txn_sanitize_tracking_maps() {
assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 0);
mine_transaction(&nodes[0], &revoked_local_txn[0]);
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 1000000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
let penalty_txn = {
let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
assert_eq!(node_txn.len(), 2); //ChannelMonitor: justice txn * 2
@@ -7823,9 +7805,9 @@ pub fn test_concurrent_monitor_claim() {
// We confirm Bob's state Y on Alice, she should broadcast a HTLC-timeout
let height = HTLC_TIMEOUT_BROADCAST + 1;
connect_blocks(&nodes[0], height - nodes[0].best_block_info().1);
- check_closed_broadcast(&nodes[0], 1, true);
let reason = ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash_timeout) };
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[0], 1, true);
watchtower_alice.chain_monitor.block_connected(
&create_dummy_block(BlockHash::all_zeros(), 42, vec![bob_state_y.clone()]),
height,
@@ -7926,10 +7908,10 @@ pub fn test_htlc_no_detection() {
&block,
nodes[0].best_block_info().1 + 1,
);
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[node_b_id], 100000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
connect_blocks(&nodes[0], TEST_FINAL_CLTV);
let htlc_timeout = {
@@ -8029,10 +8011,10 @@ fn do_test_onchain_htlc_settlement_after_close(
&create_dummy_block(nodes[1].best_block_hash(), 42, vec![txn_to_broadcast[0].clone()]),
);
if broadcast_alice {
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
}
}
@@ -8118,10 +8100,10 @@ fn do_test_onchain_htlc_settlement_after_close(
);
// If Bob was the one to force-close, he will have already passed these checks earlier.
if broadcast_alice {
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
}
let mut bob_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
if broadcast_alice {
@@ -10436,13 +10418,13 @@ fn test_dup_htlc_claim_onchain_and_offchain() {
// Mine C's commitment on B. B sees the counterparty commitment on-chain.
mine_transaction(&nodes[1], &cs_txn[0]);
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let events = nodes[1].node.get_and_clear_pending_events();
assert!(
events.iter().any(|e| matches!(e, Event::ChannelClosed { .. })),
"Expected ChannelClosed event"
);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
// Mine C's HTLC-success transaction. B's monitor sees the preimage being used on-chain
// and generates an HTLCEvent with the preimage.
### lightning/src/ln/monitor_tests.rs
@@ -85,9 +85,9 @@ fn chanmon_fail_from_stale_commitment() {
// Don't bother delivering the new HTLC add/commits, instead confirming the pre-HTLC commitment
// transaction for nodes[1].
mine_transaction(&nodes[1], &bs_txn[0]);
+ check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[2].node.get_our_node_id()], 100000);
check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
- check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[2].node.get_our_node_id()], 100000);
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1);
@@ -141,9 +141,9 @@ fn revoked_output_htlc_resolution_timing() {
// Confirm the revoked commitment transaction, closing the channel.
mine_transaction(&nodes[1], &revoked_local_txn[0]);
+ check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 1000000);
check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
- check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 1000000);
// Two justice transactions will be broadcast, one on the unpinnable, revoked to_self output,
// and one on the pinnable revoked HTLC output.
@@ -405,6 +405,10 @@ fn archive_monitor_with_pending_closure_event() {
_ => panic!("Unexpected event"),
}
+ // Applying our force-close `ChannelMonitorUpdate` caused the monitor to queue a redundant closure
+ // `MonitorEvent`, which must be processed before the monitor can be archived.
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
+
// Now that the `ChannelManager` knows the channel is closed, the monitor can be archived.
nodes[1].chain_monitor.chain_monitor.archive_fully_resolved_channel_monitors();
assert_eq!(nodes[1].chain_monitor.chain_monitor.list_monitors().len(), 0);
@@ -785,13 +789,13 @@ fn do_test_claim_value_force_close(keyed_anchors: bool, p2a_anchor: bool, prev_c
assert_eq!(remote_txn[0].output[b_broadcast_txn[0].input[0].previous_output.vout as usize].value.to_sat(), 3_000);
assert_eq!(remote_txn[0].output[b_broadcast_txn[1].input[0].previous_output.vout as usize].value.to_sat(), 4_000);
+ check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[1].node.get_our_node_id()], 1000000);
check_closed_broadcast(&nodes[0], 1, true);
check_added_monitors(&nodes[0], 1);
- check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[1].node.get_our_node_id()], 1000000);
assert!(nodes[0].node.list_channels().is_empty());
+ check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 1000000);
check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
- check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 1000000);
assert!(nodes[1].node.list_channels().is_empty());
assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
@@ -1083,9 +1087,9 @@ fn do_test_balances_on_local_commitment_htlcs(keyed_anchors: bool, p2a_anchor: b
// Get nodes[1]'s HTLC claim tx for the second HTLC
mine_transaction(&nodes[1], &commitment_tx);
+ check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 1000000);
check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
- check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 1000000);
let bs_htlc_claim_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
assert_eq!(bs_htlc_claim_txn.len(), 1);
check_spends!(bs_htlc_claim_txn[0], commitment_tx);
@@ -1314,17 +1318,17 @@ fn test_no_preimage_inbound_htlc_balances() {
mine_transaction(&nodes[0], &as_txn[0]);
nodes[0].tx_broadcaster.clear();
+ check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[1].node.get_our_node_id()], 1000000);
check_closed_broadcast(&nodes[0], 1, true);
check_added_monitors(&nodes[0], 1);
- check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[1].node.get_our_node_id()], 1000000);
assert_eq!(as_pre_spend_claims,
sorted_vec(nodes[0].chain_monitor.chain_monitor.get_monitor(chan_id).unwrap().get_claimable_balances()));
mine_transaction(&nodes[1], &as_txn[0]);
+ check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 1000000);
check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
- check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 1000000);
let node_b_commitment_claimable = nodes[1].best_block_info().1 + ANTI_REORG_DELAY - 1;
let mut bs_pre_spend_claims = sorted_vec(vec![Balance::ClaimableAwaitingConfirmations {
@@ -1535,10 +1539,10 @@ fn do_test_revoked_counterparty_commitment_balances(keyed_anchors: bool, p2a_anc
let _b_htlc_msgs = get_htlc_update_msgs(&nodes[1], &nodes[0].node.get_our_node_id());
connect_blocks(&nodes[0], htlc_cltv_timeout + 1 - 10);
+ let mut events = nodes[0].node.get_and_clear_pending_events();
check_closed_broadcast(&nodes[0], 1, true);
check_added_monitors(&nodes[0], 1);
- let mut events = nodes[0].node.get_and_clear_pending_events();
assert_eq!(events.len(), 5);
let mut failed_payments: HashSet<_> =
[timeout_payment_hash, dust_payment_hash, live_payment_hash, missing_htlc_payment_hash]
@@ -1564,8 +1568,6 @@ fn do_test_revoked_counterparty_commitment_balances(keyed_anchors: bool, p2a_anc
}
connect_blocks(&nodes[1], htlc_cltv_timeout + 1 - 10);
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
check_closed_events(&nodes[1], &[ExpectedCloseEvent {
channel_capacity_sats: Some(1_000_000),
channel_id: Some(chan_id),
@@ -1576,6 +1578,8 @@ fn do_test_revoked_counterparty_commitment_balances(keyed_anchors: bool, p2a_anc
channel_funding_txo: None,
user_channel_id: None,
}]);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
// Prior to channel closure, B considers the preimage HTLC as its own, and otherwise only
// lists the two on-chain timeout-able HTLCs as claimable balances.
@@ -1825,9 +1829,9 @@ fn do_test_revoked_counterparty_htlc_tx_balances(keyed_anchors: bool, p2a_anchor
// B will generate an HTLC-Success from its revoked commitment tx
mine_transaction(&nodes[1], &revoked_local_txn[0]);
+ check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 1000000);
check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
- check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 1000000);
if keyed_anchors || p2a_anchor {
handle_bump_htlc_event(&nodes[1], 1);
}
@@ -1869,9 +1873,9 @@ fn do_test_revoked_counterparty_htlc_tx_balances(keyed_anchors: bool, p2a_anchor
&[HTLCHandlingFailureType::Receive { payment_hash: failed_payment_hash }]);
// A will generate justice tx from B's revoked commitment/HTLC tx
mine_transaction(&nodes[0], &revoked_local_txn[0]);
+ check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[1].node.get_our_node_id()], 1000000);
check_closed_broadcast(&nodes[0], 1, true);
check_added_monitors(&nodes[0], 1);
- check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[1].node.get_our_node_id()], 1000000);
let to_remote_conf_height = nodes[0].best_block_info().1 + ANTI_REORG_DELAY - 1;
let revoked_to_self_claim = {
@@ -2149,8 +2153,8 @@ fn do_test_revoked_counterparty_aggregated_claims(keyed_anchors: bool, p2a_ancho
sorted_vec(nodes[1].chain_monitor.chain_monitor.get_monitor(chan_id).unwrap().get_claimable_balances()));
mine_transaction(&nodes[1], &as_revoked_txn[0]);
- check_closed_broadcast(&nodes[1], 1, true);
check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 1000000);
+ check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
let mut claim_txn = nodes[1].tx_broadcaster.txn_broadcast();
@@ -2190,9 +2194,9 @@ fn do_test_revoked_counterparty_aggregated_claims(keyed_anchors: bool, p2a_ancho
// new claim.
if keyed_anchors || p2a_anchor {
mine_transaction(&nodes[0], &as_revoked_txn[0]);
+ check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[1].node.get_our_node_id()], 1_000_000);
check_closed_broadcast(&nodes[0], 1, true);
check_added_monitors(&nodes[0], 1);
- check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[1].node.get_our_node_id()], 1_000_000);
handle_bump_htlc_event(&nodes[0], 1);
}
let htlc_success_claim = if keyed_anchors || p2a_anchor {
@@ -2521,8 +2525,8 @@ fn do_test_monitor_rebroadcast_pending_claims(keyed_anchors: bool, p2a_anchor: b
assert_eq!(commitment_txn.len(), if keyed_anchors || p2a_anchor { 1 /* commitment tx only */} else { 2 /* commitment and htlc timeout tx */ });
check_spends!(&commitment_txn[0], &funding_tx);
mine_transaction(&nodes[0], &commitment_txn[0]);
- check_closed_broadcast(&nodes[0], 1, true);
check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[1].node.get_our_node_id()], 1000000);
+ check_closed_broadcast(&nodes[0], 1, true);
check_added_monitors(&nodes[0], 1);
// Set up a helper closure we'll use throughout our test. We should only expect retries without
@@ -2693,21 +2697,21 @@ fn do_test_yield_anchors_events(have_htlcs: bool, p2a_anchor: bool) {
nodes[0].node.force_close_broadcasting_latest_txn(&chan_id, &nodes[1].node.get_our_node_id(), "".to_string()).unwrap();
}
- check_closed_broadcast(&nodes[0], 1, true);
let a_events = nodes[0].node.get_and_clear_pending_events();
assert_eq!(a_events.len(), if have_htlcs { 2 } else { 1 });
if have_htlcs {
assert!(a_events.iter().any(|ev| matches!(ev, Event::HTLCHandlingFailed { .. })));
}
assert!(a_events.iter().any(|ev| matches!(ev, Event::ChannelClosed { .. })));
+ check_closed_broadcast(&nodes[0], 1, true);
- check_closed_broadcast(&nodes[1], 1, true);
let b_events = nodes[1].node.get_and_clear_pending_events();
assert_eq!(b_events.len(), if have_htlcs { 2 } else { 1 });
if have_htlcs {
assert!(b_events.iter().any(|ev| matches!(ev, Event::HTLCHandlingFailed { .. })));
}
assert!(b_events.iter().any(|ev| matches!(ev, Event::ChannelClosed { .. })));
+ check_closed_broadcast(&nodes[1], 1, true);
let mut holder_events = nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events();
assert_eq!(holder_events.len(), 1);
@@ -2928,9 +2932,9 @@ fn do_test_anchors_aggregated_revoked_htlc_tx(p2a_anchor: bool) {
mine_transactions(node, &[&revoked_commitment_txs[0], &revoked_commitment_txs[1]]);
}
}
+ check_closed_event(&nodes[0], 2, ClosureReason::CommitmentTxConfirmed, &[nodes[1].node.get_our_node_id(); 2], 1000000);
check_closed_broadcast(&nodes[0], 2, true);
check_added_monitors(&nodes[0], 2);
- check_closed_event(&nodes[0], 2, ClosureReason::CommitmentTxConfirmed, &[nodes[1].node.get_our_node_id(); 2], 1000000);
// Alice should detect the confirmed revoked commitments, and attempt to claim all of the
// revoked outputs in aggregated transactions per channel, grouped into pinnable and unpinnable
@@ -3180,6 +3184,7 @@ fn do_test_anchors_monitor_fixes_counterparty_payment_script_on_reload(confirm_c
// with the incorrect P2WPKH script but reading it with the correct P2WSH script.
*nodes[1].chain_monitor.expect_monitor_round_trip_fail.lock().unwrap() = Some(chan_id);
let commitment_tx_conf_height = block_from_scid(mine_transaction(&nodes[1], &commitment_tx));
+ check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 100000);
check_closed_broadcast(&nodes[1], 1, true);
let serialized_monitor = get_monitor!(nodes[1], chan_id).encode();
reload_node!(nodes[1], user_config, &nodes[1].node.encode(), &[&serialized_monitor], persister, chain_monitor, node_deserialized);
@@ -3188,11 +3193,11 @@ fn do_test_anchors_monitor_fixes_counterparty_payment_script_on_reload(confirm_c
let serialized_monitor = get_monitor!(nodes[1], chan_id).encode();
reload_node!(nodes[1], user_config, &nodes[1].node.encode(), &[&serialized_monitor], persister, chain_monitor, node_deserialized);
let commitment_tx_conf_height = block_from_scid(mine_transaction(&nodes[1], &commitment_tx));
+ check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 100000);
check_closed_broadcast(&nodes[1], 1, false);
check_added_monitors(&nodes[1], 1);
commitment_tx_conf_height
};
- check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[nodes[0].node.get_our_node_id()], 100000);
assert!(get_monitor!(nodes[1], chan_id).get_counterparty_payment_script().is_p2wsh());
connect_blocks(&nodes[0], ANTI_REORG_DELAY - 1);
@@ -3267,15 +3272,15 @@ fn do_test_monitor_claims_with_random_signatures(keyed_anchors: bool, p2a_anchor
if p2a_anchor {
mine_transaction(closing_node, anchor_tx.as_ref().unwrap());
}
- check_closed_broadcast(closing_node, 1, true);
- check_added_monitors(&closing_node, 1);
let message = "ChannelMonitor-initiated commitment transaction broadcast".to_string();
check_closed_event(&closing_node, 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true), message }, &[other_node.node.get_our_node_id()], 1_000_000);
+ check_closed_broadcast(closing_node, 1, true);
+ check_added_monitors(&closing_node, 1);
mine_transaction(other_node, &commitment_tx);
+ check_closed_event(&other_node, 1, ClosureReason::CommitmentTxConfirmed, &[closing_node.node.get_our_node_id()], 1_000_000);
check_closed_broadcast(other_node, 1, true);
check_added_monitors(&other_node, 1);
- check_closed_event(&other_node, 1, ClosureReason::CommitmentTxConfirmed, &[closing_node.node.get_our_node_id()], 1_000_000);
// If we update the best block to the new height before providing the confirmed transactions,
// we'll see another broadcast of the commitment transaction.
@@ -3709,9 +3714,9 @@ fn test_ladder_preimage_htlc_claims() {
mine_transaction(&nodes[0], &commitment_tx);
mine_transaction(&nodes[1], &commitment_tx);
+ check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[node_id_0], 1_000_000);
check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
- check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[node_id_0], 1_000_000);
nodes[1].node.claim_funds(payment_preimage1, Default::default());
expect_payment_claimed!(&nodes[1], payment_hash1, 1_000_000);
@@ -3806,9 +3811,9 @@ fn test_onchain_preimage_after_fail_back_before_backwards_timeout() {
connect_blocks(&nodes[2], TEST_FINAL_CLTV - CLTV_CLAIM_BUFFER + 2);
let node_2_txn = test_txn_broadcast(&nodes[2], &chan_2, None, HTLCType::SUCCESS);
- check_closed_broadcast(&nodes[2], 1, true);
let reason = ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash) };
check_closed_event(&nodes[2], 1, reason, &[node_b_id], 100_000);
+ check_closed_broadcast(&nodes[2], 1, true);
check_added_monitors(&nodes[2], 1);
// Once the A<->B HTLC gets within LATENCY_GRACE_PERIOD_BLOCKS of expiry, B's monitor queues a
### lightning/src/ln/payment_tests.rs
@@ -970,8 +970,8 @@ fn do_retry_with_no_persist(confirm_before_reload: bool) {
let fulfill_msg = htlc_fulfill.update_fulfill_htlcs.remove(0);
nodes[1].node.handle_update_fulfill_htlc(node_c_id, fulfill_msg);
check_added_monitors(&nodes[1], 1);
- do_commitment_signed_dance(&nodes[1], &nodes[2], &htlc_fulfill.commitment_signed, false, false);
expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], None, true, false);
+ do_commitment_signed_dance(&nodes[1], &nodes[2], &htlc_fulfill.commitment_signed, false, false);
if confirm_before_reload {
let best_block = nodes[0].blocks.lock().unwrap().last().unwrap().clone();
@@ -1356,10 +1356,10 @@ fn do_test_dup_htlc_onchain_doesnt_fail_on_reload(
expect_payment_claimed!(nodes[1], payment_hash, 10_000_000);
mine_transaction(&nodes[1], &commitment_tx);
- check_closed_broadcast(&nodes[1], 1, false);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[node_a_id], 100000);
+ check_closed_broadcast(&nodes[1], 1, false);
+ check_added_monitors(&nodes[1], 1);
let htlc_success_tx = {
let mut txn = nodes[1].tx_broadcaster.txn_broadcast();
assert_eq!(txn.len(), 1);
@@ -1917,12 +1917,10 @@ fn onchain_failed_probe_yields_event() {
// Node A, which after 6 confirmations should result in a probe failure event.
let bs_txn = get_local_commitment_txn!(nodes[1], chan_id);
confirm_transaction(&nodes[0], &bs_txn[0]);
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
-
check_added_monitors(&nodes[0], 0);
let mut events = nodes[0].node.get_and_clear_pending_events();
- check_added_monitors(&nodes[0], 1);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 2);
assert_eq!(events.len(), 2);
let mut found_probe_failed = false;
for event in events.drain(..) {
@@ -4666,10 +4664,10 @@ fn do_claim_from_closed_chan(fail_payment: bool) {
assert_eq!(bs_tx.len(), 1);
mine_transaction(&nodes[3], &bs_tx[0]);
- check_closed_broadcast(&nodes[3], 1, true);
- check_added_monitors(&nodes[3], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[3], 1, reason, &[node_b_id], 1000000);
+ check_closed_broadcast(&nodes[3], 1, true);
+ check_added_monitors(&nodes[3], 1);
nodes[3].node.claim_funds(payment_preimage, Default::default());
check_added_monitors(&nodes[3], 2);
### lightning/src/ln/reload_tests.rs
@@ -1867,6 +1867,7 @@ fn test_manager_persisted_post_outbound_edge_holding_cell() {
chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
let (latest_update, _) = get_latest_mon_update_id(&nodes[1], chan_id_2);
nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id_2, latest_update);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
reconnect_nodes(ReconnectArgs::new(&nodes[1], &nodes[0]));
### lightning/src/ln/reorg_tests.rs
@@ -86,10 +86,10 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) {
let block =
create_dummy_block(nodes[2].best_block_hash(), 42, node_1_commitment_txn.clone());
connect_block(&nodes[2], &block);
- check_closed_broadcast(&nodes[2], 1, true); // We should get a BroadcastChannelUpdate (and *only* a BroadcstChannelUpdate)
- check_added_monitors(&nodes[2], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[2], 1, reason, &[node_id_1], 100000);
+ check_closed_broadcast(&nodes[2], 1, true); // We should get a BroadcastChannelUpdate (and *only* a BroadcstChannelUpdate)
+ check_added_monitors(&nodes[2], 1);
let node_2_commitment_txn = nodes[2].tx_broadcaster.txn_broadcast();
assert_eq!(node_2_commitment_txn.len(), 1); // ChannelMonitor: 1 offered HTLC-Claim
check_spends!(node_2_commitment_txn[0], node_1_commitment_txn[0]);
@@ -123,9 +123,9 @@ fn do_test_onchain_htlc_reorg(local_commitment: bool, claim: bool) {
// ...but return node 2's commitment tx (and claim) in case claim is set and we're preparing to reorg
vec![node_2_commitment_txn.pop().unwrap()]
};
+ check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[node_id_2], 100000);
check_closed_broadcast(&nodes[1], 1, true); // We should get a BroadcastChannelUpdate (and *only* a BroadcstChannelUpdate)
check_added_monitors(&nodes[1], 1);
- check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[node_id_2], 100000);
// Connect ANTI_REORG_DELAY - 2 blocks, giving us a confirmation count of ANTI_REORG_DELAY - 1.
connect_blocks(&nodes[1], ANTI_REORG_DELAY - 2);
check_added_monitors(&nodes[1], 0);
@@ -230,9 +230,9 @@ fn test_counterparty_revoked_reorg() {
// Now mine A's old commitment transaction, which should close the channel, but take no action
// on any of the HTLCs, at least until we get six confirmations (which we won't get).
mine_transaction(&nodes[1], &revoked_local_txn[0]);
+ check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[node_id_0], 1000000);
check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
- check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[node_id_0], 1000000);
// Connect up to one block before the revoked transaction would be considered final, then do a
// reorg that disconnects the full chain and goes up to the height at which the revoked
@@ -648,8 +648,8 @@ fn test_set_outpoints_partial_claiming() {
// Connect blocks on node A commitment transaction
mine_transaction(&nodes[0], &remote_txn[0]);
- check_closed_broadcast(&nodes[0], 1, true);
check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[node_id_1], 1000000);
+ check_closed_broadcast(&nodes[0], 1, true);
check_added_monitors(&nodes[0], 1);
// Verify node A broadcast tx claiming both HTLCs
{
@@ -663,7 +663,6 @@ fn test_set_outpoints_partial_claiming() {
// Connect blocks on node B
connect_blocks(&nodes[1], TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + 1);
- check_closed_broadcast(&nodes[1], 1, true);
let expected_close = ExpectedCloseEvent {
channel_capacity_sats: Some(1_000_000),
channel_id: Some(chan.2),
@@ -675,6 +674,7 @@ fn test_set_outpoints_partial_claiming() {
user_channel_id: None,
};
check_closed_events(&nodes[1], &[expected_close]);
+ check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
// Verify node B broadcast 2 HTLC-timeout txn
let partial_claim_tx = {
@@ -750,14 +750,14 @@ fn do_test_to_remote_after_local_detection(style: ConnectStyle) {
mine_transaction(&nodes[0], &remote_txn_a[0]);
mine_transaction(&nodes[1], &remote_txn_a[0]);
+ check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[node_id_1], 1000000);
check_closed_broadcast(&nodes[0], 1, true);
assert!(nodes[0].node.list_channels().is_empty());
check_added_monitors(&nodes[0], 1);
- check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[node_id_1], 1000000);
+ check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[node_id_0], 1000000);
check_closed_broadcast(&nodes[1], 1, true);
assert!(nodes[1].node.list_channels().is_empty());
check_added_monitors(&nodes[1], 1);
- check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[node_id_0], 1000000);
assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
assert!(nodes[1].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty());
@@ -1004,9 +1004,9 @@ fn test_htlc_preimage_claim_prev_counterparty_commitment_after_current_counterpa
mine_transaction(&nodes[0], ¤t_commitment_a);
mine_transaction(&nodes[1], ¤t_commitment_a);
+ check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[node_id_0], 100000);
check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
- check_closed_event(&nodes[1], 1, ClosureReason::CommitmentTxConfirmed, &[node_id_0], 100000);
disconnect_blocks(&nodes[0], 1);
disconnect_blocks(&nodes[1], 1);
@@ -1086,10 +1086,10 @@ fn do_test_retries_own_commitment_broadcast_after_reorg(
// Connect blocks until the HTLC expiry is met, prompting a commitment broadcast by A.
connect_blocks(&nodes[0], TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + 1);
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash) };
check_closed_event(&nodes[0], 1, reason, &[node_id_1], 100_000);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
if keyed_anchors || p2a_anchor {
handle_bump_close_event(&nodes[0]);
}
@@ -1283,9 +1283,9 @@ fn do_test_split_htlc_expiry_tracking(use_third_htlc: bool, reorg_out: bool, p2a
} else {
mine_transaction(&nodes[0], &commitment_tx);
}
- check_closed_broadcast(&nodes[0], 1, false);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[node_id_1], 10_000_000);
+ check_closed_broadcast(&nodes[0], 1, false);
check_added_monitors(&nodes[0], 1);
if let Some(ref a_tx) = anchor_tx {
@@ -1575,9 +1575,9 @@ fn do_test_reorg_resurrect_split_htlc_package_with_future_locktime(style: Connec
let commitment_conf_height = nodes[0].best_block_info().1;
println!("[repro] commitment confirmed on A at height {commitment_conf_height}");
assert_eq!(commitment_conf_height, cltv_b);
- check_closed_broadcast(&nodes[0], 1, false);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[node_id_1], 10_000_000);
+ check_closed_broadcast(&nodes[0], 1, false);
check_added_monitors(&nodes[0], 1);
// Both timeout claims must have aggregated into a single transaction, otherwise the path we
### lightning/src/ln/shutdown_tests.rs
@@ -372,12 +372,12 @@ fn expect_channel_shutdown_state_with_force_closure() {
assert_eq!(node_txn.len(), 1);
check_spends!(node_txn[0], chan_1.3);
mine_transaction(&nodes[0], &node_txn[0]);
+ check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[node_b_id], 100000);
check_closed_broadcast(&nodes[0], 1, true);
check_added_monitors(&nodes[0], 1);
assert!(nodes[0].node.list_channels().is_empty());
assert!(nodes[1].node.list_channels().is_empty());
- check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, &[node_b_id], 100000);
let reason_b = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true), message };
check_closed_event(&nodes[1], 1, reason_b, &[node_a_id], 100000);
}
@@ -1636,6 +1636,7 @@ fn do_outbound_update_no_early_closing_signed(use_htlc: bool) {
latest_monitor_update_id.get(&chan_id).unwrap().clone()
};
nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update);
+ assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
let as_raa_closing_signed = nodes[0].node.get_and_clear_pending_msg_events();
assert_eq!(as_raa_closing_signed.len(), 2);
### lightning/src/ln/splicing_tests.rs
@@ -2906,6 +2906,8 @@ fn do_test_splice_reestablish(reload: bool, async_monitor_update: bool) {
nodes[1].chain_monitor.complete_sole_pending_chan_update(&channel_id);
chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
+ assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
}
// Both nodes should have their `tx_signatures` ready after completing the monitor update, but
@@ -3017,6 +3019,8 @@ fn do_test_splice_reestablish(reload: bool, async_monitor_update: bool) {
nodes[1].chain_monitor.complete_sole_pending_chan_update(&channel_id);
chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
+ assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
}
// We shouldn't have any further events or messages to process.
@@ -3748,6 +3752,7 @@ fn test_holding_cell_claim_freed_after_inferred_splice_locked() {
nodes[1].chain_monitor.complete_sole_pending_chan_update(&channel_id);
chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
let mut commitment_update = get_htlc_update_msgs(&nodes[1], &node_id_0);
check_added_monitors(&nodes[1], 1);
@@ -3836,6 +3841,7 @@ fn test_stale_monitor_pending_resends_cleared_by_reestablish() {
// Let node 1 release its RAA+CS to node 0 and process them.
nodes[1].chain_monitor.complete_sole_pending_chan_update(&channel_id);
chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
let (raa, commitment_signed) = get_revoke_commit_msgs(&nodes[1], &node_id_0);
nodes[0].node.handle_revoke_and_ack(node_id_1, &raa);
check_added_monitors(&nodes[0], 1);
@@ -3880,6 +3886,7 @@ fn test_stale_monitor_pending_resends_cleared_by_reestablish() {
nodes[1].chain_monitor.complete_sole_pending_chan_update(&channel_id);
persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
+ expect_channel_ready_event(&nodes[1], &node_id_0);
let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
assert!(
@@ -3889,7 +3896,6 @@ fn test_stale_monitor_pending_resends_cleared_by_reestablish() {
)),
"stale monitor-pending resend leaked after reestablish: {msg_events:?}"
);
- expect_channel_ready_event(&nodes[1], &node_id_0);
nodes[0].node.handle_channel_reestablish(node_id_1, reestablish_1.first().unwrap());
check_added_monitors(&nodes[0], 1);
@@ -3903,6 +3909,7 @@ fn test_stale_monitor_pending_resends_cleared_by_reestablish() {
check_added_monitors(&nodes[1], 1);
nodes[1].chain_monitor.complete_sole_pending_chan_update(&channel_id);
persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
+ assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
nodes[1].node.process_pending_htlc_forwards();
@@ -6467,14 +6474,14 @@ fn do_splice_waits_for_initial_commitment_monitor_update_before_releasing_tx_sig
nodes[0].chain_monitor.complete_sole_pending_chan_update(&channel_id);
chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
+ expect_splice_pending_event(&nodes[0], &node_id_1);
if !complete_update_while_disconnected {
let initiator_tx_signatures =
get_event_msg!(nodes[0], MessageSendEvent::SendTxSignatures, node_id_1);
nodes[1].node.handle_tx_signatures(node_id_0, &initiator_tx_signatures);
}
- expect_splice_pending_event(&nodes[0], &node_id_1);
if !complete_update_while_disconnected {
assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
}
@@ -6731,6 +6738,7 @@ fn retransmit_completed_tx_signatures_during_monitor_update_after_reestablish()
// Once the monitor update completes, only the freed holding cell update remains to be sent.
initiator.chain_monitor.complete_sole_pending_chan_update(&channel_id);
chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed);
+ assert!(initiator.node.get_and_clear_pending_events().is_empty());
let msg_events = initiator.node.get_and_clear_pending_msg_events();
assert_eq!(msg_events.len(), 1, "{msg_events:?}");
@@ -11555,14 +11563,13 @@ fn do_test_splice_locked_deferred_during_rbf_signing(
nodes[0].enable_channel_signer_op(&node_id_1, &channel_id, SignerOp::SignSpliceSharedInput);
nodes[0].node.signer_unblocked(None);
}
+ let _ = get_event!(nodes[0], Event::SpliceNegotiated);
let initiator_tx_signatures =
get_event_msg!(nodes[0], MessageSendEvent::SendTxSignatures, node_id_1);
check_added_monitors(&nodes[0], 0);
assert_eq!(get_monitor!(nodes[0], channel_id).get_funding_txo().txid, previous_funding_txid);
- let _ = get_event!(nodes[0], Event::SpliceNegotiated);
-
// A timer tick, rather than signing completion, releases the deferred lock and handles any
// resulting promotion.
let early_initiator_splice_locked = if early_peer_splice_locked {
@@ -14535,6 +14542,7 @@ fn test_async_splice_receives_tx_signatures_while_unrelated_monitor_update_pendi
// is the update for which `monitor_pending_tx_signatures` is expected to be
// set.
acceptor.chain_monitor.complete_sole_pending_chan_update(&channel_id);
+ assert!(acceptor.node.get_and_clear_pending_events().is_empty());
let acceptor_tx_signatures =
get_event_msg!(acceptor, MessageSendEvent::SendTxSignatures, initiator_node_id);
@@ -14583,8 +14591,6 @@ fn test_async_splice_receives_tx_signatures_while_unrelated_monitor_update_pendi
// Finally, drive the state machines to completion.
acceptor.chain_monitor.complete_sole_pending_chan_update(&channel_id);
- let mut update_fulfill = get_htlc_update_msgs(acceptor, &initiator_node_id);
- check_added_monitors(acceptor, 1);
let payment_forwarded = get_event!(acceptor, Event::PaymentForwarded);
expect_payment_forwarded(
payment_forwarded,
@@ -14597,6 +14603,8 @@ fn test_async_splice_receives_tx_signatures_while_unrelated_monitor_update_pendi
false,
false,
);
+ let mut update_fulfill = get_htlc_update_msgs(acceptor, &initiator_node_id);
+ check_added_monitors(acceptor, 1);
do_commitment_signed_dance(
acceptor,
### lightning/src/ln/zero_fee_commitment_tests.rs
@@ -185,15 +185,15 @@ fn test_htlc_claim_chunking() {
assert_eq!(htlc_claims[1].input.len(), 34);
assert_eq!(htlc_claims[1].output.len(), 24);
- check_closed_broadcast(&nodes[0], 1, true);
- check_added_monitors(&nodes[0], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[0], 1, reason, &[nodes[1].node.get_our_node_id()], CHAN_CAPACITY);
+ check_closed_broadcast(&nodes[0], 1, true);
+ check_added_monitors(&nodes[0], 1);
assert!(nodes[0].node.list_channels().is_empty());
- check_closed_broadcast(&nodes[1], 1, true);
- check_added_monitors(&nodes[1], 1);
let reason = ClosureReason::CommitmentTxConfirmed;
check_closed_event(&nodes[1], 1, reason, &[nodes[0].node.get_our_node_id()], CHAN_CAPACITY);
+ check_closed_broadcast(&nodes[1], 1, true);
+ check_added_monitors(&nodes[1], 1);
assert!(nodes[1].node.list_channels().is_empty());
assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
### lightning/src/util/persist.rs
@@ -2406,10 +2406,10 @@ mod tests {
let dummy_block = create_dummy_block(nodes[0].best_block_hash(), 42, txn);
connect_block(&nodes[1], &dummy_block);
- check_closed_broadcast(&nodes[1], 1, true);
let reason = ClosureReason::CommitmentTxConfirmed;
let node_id_0 = nodes[0].node.get_our_node_id();
check_closed_event(&nodes[1], 1, reason, &[node_id_0], 100000);
+ check_closed_broadcast(&nodes[1], 1, true);
check_added_monitors(&nodes[1], 1);
// Make sure everything is persisted as expected after close.Why this scored 45/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.