Skip to content

Commit 183e904

Browse files
committed
Test monitor update completion actions on pre-startup completion
This adds a test for monitor update actions being completed on startup if a monitor update completed "while we were shut down" (or, really, the manager didn't get persisted after the update completed).
1 parent 8ce1abe commit 183e904

File tree

1 file changed

+101
-0
lines changed

1 file changed

+101
-0
lines changed

lightning/src/ln/chanmon_update_fail_tests.rs

+101
Original file line numberDiff line numberDiff line change
@@ -3424,3 +3424,104 @@ fn test_durable_preimages_on_closed_channel() {
34243424
do_test_durable_preimages_on_closed_channel(false, false, true);
34253425
do_test_durable_preimages_on_closed_channel(false, false, false);
34263426
}
3427+
3428+
fn do_test_reload_mon_update_completion_actions(close_during_reload: bool) {
3429+
// Test that if a `ChannelMonitorUpdate` completes but a `ChannelManager` isn't serialized
3430+
// before restart we run the monitor update completion action on startup.
3431+
let chanmon_cfgs = create_chanmon_cfgs(3);
3432+
let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
3433+
3434+
let persister;
3435+
let new_chain_monitor;
3436+
let nodes_1_deserialized;
3437+
3438+
let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
3439+
let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
3440+
3441+
let chan_id_ab = create_announced_chan_between_nodes(&nodes, 0, 1).2;
3442+
let chan_id_bc = create_announced_chan_between_nodes(&nodes, 1, 2).2;
3443+
3444+
// Route a payment from A, through B, to C, then claim it on C. Once we pass B the
3445+
// `update_fulfill_htlc` we have a monitor update for both of B's channels. We complete the
3446+
// commitment signed dance on the B<->C channel but leave the A<->B monitor update pending,
3447+
// then reload B. At that point, the final monitor update on the B<->C channel is still pending
3448+
// because it can't fly until the preimage is persisted on the A<->B monitor.
3449+
let (payment_preimage, payment_hash, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1_000_000);
3450+
3451+
nodes[2].node.claim_funds(payment_preimage);
3452+
check_added_monitors(&nodes[2], 1);
3453+
expect_payment_claimed!(nodes[2], payment_hash, 1_000_000);
3454+
3455+
chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress);
3456+
let cs_updates = get_htlc_update_msgs(&nodes[2], &nodes[1].node.get_our_node_id());
3457+
nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &cs_updates.update_fulfill_htlcs[0]);
3458+
3459+
// B generates a new monitor update for the A <-> B channel, but doesn't send the new messages
3460+
// for it since the monitor update is marked in-progress.
3461+
check_added_monitors(&nodes[1], 1);
3462+
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3463+
3464+
// Now step the Commitment Signed Dance between B and C and check that after the final RAA B
3465+
// doesn't let the preimage-removing monitor update fly.
3466+
nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &cs_updates.commitment_signed);
3467+
check_added_monitors(&nodes[1], 1);
3468+
let (bs_raa, bs_cs) = get_revoke_commit_msgs!(nodes[1], nodes[2].node.get_our_node_id());
3469+
3470+
nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
3471+
check_added_monitors(&nodes[2], 1);
3472+
nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_cs);
3473+
check_added_monitors(&nodes[2], 1);
3474+
3475+
let cs_final_raa = get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
3476+
nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &cs_final_raa);
3477+
check_added_monitors(&nodes[1], 0);
3478+
3479+
// Finally, reload node B and check that after we call `process_events` once we realize we've
3480+
// completed the A<->B preimage-including monitor update and so can release the B<->C
3481+
// preimage-removing monitor update.
3482+
let mon_ab = get_monitor!(nodes[1], chan_id_ab).encode();
3483+
let mon_bc = get_monitor!(nodes[1], chan_id_bc).encode();
3484+
let manager_b = nodes[1].node.encode();
3485+
reload_node!(nodes[1], &manager_b, &[&mon_ab, &mon_bc], persister, new_chain_monitor, nodes_1_deserialized);
3486+
3487+
if close_during_reload {
3488+
// Test that we still free the B<->C channel if the A<->B channel closed while we reloaded
3489+
// (as learned about during the on-reload block connection).
3490+
nodes[0].node.force_close_broadcasting_latest_txn(&chan_id_ab, &nodes[1].node.get_our_node_id()).unwrap();
3491+
check_added_monitors!(nodes[0], 1);
3492+
check_closed_broadcast!(nodes[0], true);
3493+
check_closed_event(&nodes[0], 1, ClosureReason::HolderForceClosed, false, &[nodes[1].node.get_our_node_id()], 100_000);
3494+
let as_closing_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
3495+
mine_transaction_without_checks(&nodes[1], &as_closing_tx[0]);
3496+
}
3497+
3498+
let bc_update_id = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id_bc).unwrap().2;
3499+
let mut events = nodes[1].node.get_and_clear_pending_events();
3500+
assert_eq!(events.len(), if close_during_reload { 2 } else { 1 });
3501+
expect_payment_forwarded(events.pop().unwrap(), &nodes[1], &nodes[0], &nodes[2], Some(1000), close_during_reload, false);
3502+
if close_during_reload {
3503+
match events[0] {
3504+
Event::ChannelClosed { .. } => {},
3505+
_ => panic!(),
3506+
}
3507+
check_closed_broadcast!(nodes[1], true);
3508+
}
3509+
3510+
// Once we run event processing the monitor should free, check that it was indeed the B<->C
3511+
// channel which was updated.
3512+
check_added_monitors(&nodes[1], if close_during_reload { 2 } else { 1 });
3513+
let post_ev_bc_update_id = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id_bc).unwrap().2;
3514+
assert!(bc_update_id != post_ev_bc_update_id);
3515+
3516+
// Finally, check that there's nothing left to do on B<->C reconnect and the channel operates
3517+
// fine.
3518+
nodes[2].node.peer_disconnected(&nodes[1].node.get_our_node_id());
3519+
reconnect_nodes(ReconnectArgs::new(&nodes[1], &nodes[2]));
3520+
send_payment(&nodes[1], &[&nodes[2]], 100_000);
3521+
}
3522+
3523+
#[test]
3524+
fn test_reload_mon_update_completion_actions() {
3525+
do_test_reload_mon_update_completion_actions(true);
3526+
do_test_reload_mon_update_completion_actions(false);
3527+
}

0 commit comments

Comments
 (0)