@@ -3424,3 +3424,104 @@ fn test_durable_preimages_on_closed_channel() {
3424
3424
do_test_durable_preimages_on_closed_channel ( false , false , true ) ;
3425
3425
do_test_durable_preimages_on_closed_channel ( false , false , false ) ;
3426
3426
}
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