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