11
11
//! serialization ordering between ChannelManager/ChannelMonitors and ensuring we can still retry
12
12
//! payments thereafter.
13
13
14
- use chain:: { Confirm , Watch } ;
15
- use chain:: channelmonitor:: ChannelMonitor ;
14
+ use chain:: { ChannelMonitorUpdateErr , Confirm , Listen , Watch } ;
15
+ use chain:: channelmonitor:: { ANTI_REORG_DELAY , ChannelMonitor , LATENCY_GRACE_PERIOD_BLOCKS } ;
16
+ use chain:: transaction:: OutPoint ;
16
17
use ln:: { PaymentPreimage , PaymentHash } ;
17
- use ln:: channelmanager:: { ChannelManager , ChannelManagerReadArgs , PaymentId , PaymentSendFailure } ;
18
+ use ln:: channelmanager:: { BREAKDOWN_TIMEOUT , ChannelManager , ChannelManagerReadArgs , PaymentId , PaymentSendFailure } ;
18
19
use ln:: features:: InitFeatures ;
19
20
use ln:: msgs;
20
21
use ln:: msgs:: { ChannelMessageHandler , ErrorAction } ;
@@ -23,10 +24,11 @@ use util::test_utils;
23
24
use util:: errors:: APIError ;
24
25
use util:: enforcing_trait_impls:: EnforcingSigner ;
25
26
use util:: ser:: { ReadableArgs , Writeable } ;
27
+ use io;
26
28
27
29
use bitcoin:: hashes:: sha256:: Hash as Sha256 ;
28
30
use bitcoin:: hashes:: Hash ;
29
- use bitcoin:: BlockHash ;
31
+ use bitcoin:: { Block , BlockHeader , BlockHash } ;
30
32
31
33
use prelude:: * ;
32
34
@@ -459,3 +461,168 @@ fn retry_with_no_persist() {
459
461
do_retry_with_no_persist ( true ) ;
460
462
do_retry_with_no_persist ( false ) ;
461
463
}
464
+
465
+ fn do_test_dup_htlc_onchain_fails_on_reload ( persist_manager_post_event : bool , confirm_commitment_tx : bool , payment_timeout : bool ) {
466
+ // When a Channel is closed, any outbound HTLCs which were relayed through it are simply
467
+ // dropped when the Channel is. From there, the ChannelManager relies on the ChannelMonitor
468
+ // having a copy of the relevant fail-/claim-back data and processes the HTLC fail/claim when
469
+ // the ChannelMonitor tells it to.
470
+ //
471
+ // If, due to an on-chain event, an HTLC is failed/claimed, we should avoid providing the
472
+ // ChannelManager the HTLC event until after the monitor is re-persisted. This should prevent a
473
+ // duplicate HTLC fail/claim (e.g. via a PaymentPathFailed event).
474
+ let chanmon_cfgs = create_chanmon_cfgs ( 2 ) ;
475
+ let node_cfgs = create_node_cfgs ( 2 , & chanmon_cfgs) ;
476
+ let node_chanmgrs = create_node_chanmgrs ( 2 , & node_cfgs, & [ None , None ] ) ;
477
+ let persister: test_utils:: TestPersister ;
478
+ let new_chain_monitor: test_utils:: TestChainMonitor ;
479
+ let nodes_0_deserialized: ChannelManager < EnforcingSigner , & test_utils:: TestChainMonitor , & test_utils:: TestBroadcaster , & test_utils:: TestKeysInterface , & test_utils:: TestFeeEstimator , & test_utils:: TestLogger > ;
480
+ let mut nodes = create_network ( 2 , & node_cfgs, & node_chanmgrs) ;
481
+
482
+ let ( _, _, chan_id, funding_tx) = create_announced_chan_between_nodes ( & nodes, 0 , 1 , InitFeatures :: known ( ) , InitFeatures :: known ( ) ) ;
483
+
484
+ // Route a payment, but force-close the channel before the HTLC fulfill message arrives at
485
+ // nodes[0].
486
+ let ( payment_preimage, payment_hash, _) = route_payment ( & nodes[ 0 ] , & [ & nodes[ 1 ] ] , 10000000 ) ;
487
+ nodes[ 0 ] . node . force_close_channel ( & nodes[ 0 ] . node . list_channels ( ) [ 0 ] . channel_id ) . unwrap ( ) ;
488
+ check_closed_broadcast ! ( nodes[ 0 ] , true ) ;
489
+ check_added_monitors ! ( nodes[ 0 ] , 1 ) ;
490
+ check_closed_event ! ( nodes[ 0 ] , 1 , ClosureReason :: HolderForceClosed ) ;
491
+
492
+ nodes[ 0 ] . node . peer_disconnected ( & nodes[ 1 ] . node . get_our_node_id ( ) , false ) ;
493
+ nodes[ 1 ] . node . peer_disconnected ( & nodes[ 0 ] . node . get_our_node_id ( ) , false ) ;
494
+
495
+ // Connect blocks until the CLTV timeout is up so that we get an HTLC-Timeout transaction
496
+ connect_blocks ( & nodes[ 0 ] , TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + 1 ) ;
497
+ let node_txn = nodes[ 0 ] . tx_broadcaster . txn_broadcasted . lock ( ) . unwrap ( ) . split_off ( 0 ) ;
498
+ assert_eq ! ( node_txn. len( ) , 3 ) ;
499
+ assert_eq ! ( node_txn[ 0 ] , node_txn[ 1 ] ) ;
500
+ check_spends ! ( node_txn[ 1 ] , funding_tx) ;
501
+ check_spends ! ( node_txn[ 2 ] , node_txn[ 1 ] ) ;
502
+ let timeout_txn = vec ! [ node_txn[ 2 ] . clone( ) ] ;
503
+
504
+ assert ! ( nodes[ 1 ] . node. claim_funds( payment_preimage) ) ;
505
+ check_added_monitors ! ( nodes[ 1 ] , 1 ) ;
506
+
507
+ let mut header = BlockHeader { version : 0x20000000 , prev_blockhash : nodes[ 1 ] . best_block_hash ( ) , merkle_root : Default :: default ( ) , time : 42 , bits : 42 , nonce : 42 } ;
508
+ connect_block ( & nodes[ 1 ] , & Block { header, txdata : vec ! [ node_txn[ 1 ] . clone( ) ] } ) ;
509
+ check_closed_broadcast ! ( nodes[ 1 ] , true ) ;
510
+ check_added_monitors ! ( nodes[ 1 ] , 1 ) ;
511
+ check_closed_event ! ( nodes[ 1 ] , 1 , ClosureReason :: CommitmentTxConfirmed ) ;
512
+ let claim_txn = nodes[ 1 ] . tx_broadcaster . txn_broadcasted . lock ( ) . unwrap ( ) . split_off ( 0 ) ;
513
+
514
+ header. prev_blockhash = nodes[ 0 ] . best_block_hash ( ) ;
515
+ connect_block ( & nodes[ 0 ] , & Block { header, txdata : vec ! [ node_txn[ 1 ] . clone( ) ] } ) ;
516
+
517
+ if confirm_commitment_tx {
518
+ connect_blocks ( & nodes[ 0 ] , BREAKDOWN_TIMEOUT as u32 - 1 ) ;
519
+ }
520
+
521
+ header. prev_blockhash = nodes[ 0 ] . best_block_hash ( ) ;
522
+ let claim_block = Block { header, txdata : if payment_timeout { timeout_txn } else { claim_txn } } ;
523
+
524
+ if payment_timeout {
525
+ assert ! ( confirm_commitment_tx) ; // Otherwise we're spending below our CSV!
526
+ connect_block ( & nodes[ 0 ] , & claim_block) ;
527
+ connect_blocks ( & nodes[ 0 ] , ANTI_REORG_DELAY - 2 ) ;
528
+ }
529
+
530
+ // Now connect the HTLC claim transaction with the ChainMonitor-generated ChannelMonitor update
531
+ // returning TemporaryFailure. This should cause the claim event to never make its way to the
532
+ // ChannelManager.
533
+ chanmon_cfgs[ 0 ] . persister . chain_sync_monitor_persistences . lock ( ) . unwrap ( ) . clear ( ) ;
534
+ chanmon_cfgs[ 0 ] . persister . set_update_ret ( Err ( ChannelMonitorUpdateErr :: TemporaryFailure ) ) ;
535
+
536
+ if payment_timeout {
537
+ connect_blocks ( & nodes[ 0 ] , 1 ) ;
538
+ } else {
539
+ connect_block ( & nodes[ 0 ] , & claim_block) ;
540
+ }
541
+
542
+ let funding_txo = OutPoint { txid : funding_tx. txid ( ) , index : 0 } ;
543
+ let mon_updates: Vec < _ > = chanmon_cfgs[ 0 ] . persister . chain_sync_monitor_persistences . lock ( ) . unwrap ( )
544
+ . get_mut ( & funding_txo) . unwrap ( ) . drain ( ) . collect ( ) ;
545
+ assert_eq ! ( mon_updates. len( ) , 1 ) ;
546
+ assert ! ( nodes[ 0 ] . chain_monitor. release_pending_monitor_events( ) . is_empty( ) ) ;
547
+ assert ! ( nodes[ 0 ] . node. get_and_clear_pending_events( ) . is_empty( ) ) ;
548
+
549
+ // If we persist the ChannelManager here, we should get the PaymentSent event after
550
+ // deserialization.
551
+ let mut chan_manager_serialized = test_utils:: TestVecWriter ( Vec :: new ( ) ) ;
552
+ if !persist_manager_post_event {
553
+ nodes[ 0 ] . node . write ( & mut chan_manager_serialized) . unwrap ( ) ;
554
+ }
555
+
556
+ // Now persist the ChannelMonitor and inform the ChainMonitor that we're done, generating the
557
+ // payment sent event.
558
+ chanmon_cfgs[ 0 ] . persister . set_update_ret ( Ok ( ( ) ) ) ;
559
+ let mut chan_0_monitor_serialized = test_utils:: TestVecWriter ( Vec :: new ( ) ) ;
560
+ get_monitor ! ( nodes[ 0 ] , chan_id) . write ( & mut chan_0_monitor_serialized) . unwrap ( ) ;
561
+ nodes[ 0 ] . chain_monitor . chain_monitor . channel_monitor_updated ( funding_txo, mon_updates[ 0 ] ) . unwrap ( ) ;
562
+ if payment_timeout {
563
+ expect_payment_failed ! ( nodes[ 0 ] , payment_hash, true ) ;
564
+ } else {
565
+ expect_payment_sent ! ( nodes[ 0 ] , payment_preimage) ;
566
+ }
567
+
568
+ // If we persist the ChannelManager after we get the PaymentSent event, we shouldn't get it
569
+ // twice.
570
+ if persist_manager_post_event {
571
+ nodes[ 0 ] . node . write ( & mut chan_manager_serialized) . unwrap ( ) ;
572
+ }
573
+
574
+ // Now reload nodes[0]...
575
+ persister = test_utils:: TestPersister :: new ( ) ;
576
+ let keys_manager = & chanmon_cfgs[ 0 ] . keys_manager ;
577
+ new_chain_monitor = test_utils:: TestChainMonitor :: new ( Some ( nodes[ 0 ] . chain_source ) , nodes[ 0 ] . tx_broadcaster . clone ( ) , nodes[ 0 ] . logger , node_cfgs[ 0 ] . fee_estimator , & persister, keys_manager) ;
578
+ nodes[ 0 ] . chain_monitor = & new_chain_monitor;
579
+ let mut chan_0_monitor_read = & chan_0_monitor_serialized. 0 [ ..] ;
580
+ let ( _, mut chan_0_monitor) = <( BlockHash , ChannelMonitor < EnforcingSigner > ) >:: read (
581
+ & mut chan_0_monitor_read, keys_manager) . unwrap ( ) ;
582
+ assert ! ( chan_0_monitor_read. is_empty( ) ) ;
583
+
584
+ let ( _, nodes_0_deserialized_tmp) = {
585
+ let mut channel_monitors = HashMap :: new ( ) ;
586
+ channel_monitors. insert ( chan_0_monitor. get_funding_txo ( ) . 0 , & mut chan_0_monitor) ;
587
+ <( BlockHash , ChannelManager < EnforcingSigner , & test_utils:: TestChainMonitor , & test_utils:: TestBroadcaster , & test_utils:: TestKeysInterface , & test_utils:: TestFeeEstimator , & test_utils:: TestLogger > ) >
588
+ :: read ( & mut io:: Cursor :: new ( & chan_manager_serialized. 0 [ ..] ) , ChannelManagerReadArgs {
589
+ default_config : Default :: default ( ) ,
590
+ keys_manager,
591
+ fee_estimator : node_cfgs[ 0 ] . fee_estimator ,
592
+ chain_monitor : nodes[ 0 ] . chain_monitor ,
593
+ tx_broadcaster : nodes[ 0 ] . tx_broadcaster . clone ( ) ,
594
+ logger : nodes[ 0 ] . logger ,
595
+ channel_monitors,
596
+ } ) . unwrap ( )
597
+ } ;
598
+ nodes_0_deserialized = nodes_0_deserialized_tmp;
599
+
600
+ assert ! ( nodes[ 0 ] . chain_monitor. watch_channel( chan_0_monitor. get_funding_txo( ) . 0 , chan_0_monitor) . is_ok( ) ) ;
601
+ check_added_monitors ! ( nodes[ 0 ] , 1 ) ;
602
+ nodes[ 0 ] . node = & nodes_0_deserialized;
603
+
604
+ if persist_manager_post_event {
605
+ assert ! ( nodes[ 0 ] . node. get_and_clear_pending_events( ) . is_empty( ) ) ;
606
+ } else if payment_timeout {
607
+ expect_payment_failed ! ( nodes[ 0 ] , payment_hash, true ) ;
608
+ } else {
609
+ expect_payment_sent ! ( nodes[ 0 ] , payment_preimage) ;
610
+ }
611
+
612
+ // Note that if we re-connect the block which exposed nodes[0] to the payment preimage (but
613
+ // which the current ChannelMonitor has not seen), the ChannelManager's de-duplication of
614
+ // payment events should kick in, leaving us with no pending events here.
615
+ let height = nodes[ 0 ] . blocks . lock ( ) . unwrap ( ) . len ( ) as u32 - 1 ;
616
+ nodes[ 0 ] . chain_monitor . chain_monitor . block_connected ( & claim_block, height) ;
617
+ assert ! ( nodes[ 0 ] . node. get_and_clear_pending_events( ) . is_empty( ) ) ;
618
+ }
619
+
620
+ #[ test]
621
+ fn test_dup_htlc_onchain_fails_on_reload ( ) {
622
+ do_test_dup_htlc_onchain_fails_on_reload ( true , true , true ) ;
623
+ do_test_dup_htlc_onchain_fails_on_reload ( true , true , false ) ;
624
+ do_test_dup_htlc_onchain_fails_on_reload ( true , false , false ) ;
625
+ do_test_dup_htlc_onchain_fails_on_reload ( false , true , true ) ;
626
+ do_test_dup_htlc_onchain_fails_on_reload ( false , true , false ) ;
627
+ do_test_dup_htlc_onchain_fails_on_reload ( false , false , false ) ;
628
+ }
0 commit comments