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
@@ -409,3 +411,170 @@ fn retry_with_no_persist() {
409411 pass_along_path ( & nodes[ 0 ] , & [ & nodes[ 1 ] , & nodes[ 2 ] ] , 100_000 , payment_hash, Some ( payment_secret) , events. pop ( ) . unwrap ( ) , true , None ) ;
410412 claim_payment_along_route ( & nodes[ 0 ] , & [ & [ & nodes[ 1 ] , & nodes[ 2 ] ] ] , false , payment_preimage) ;
411413}
414+
415+ fn do_test_dup_htlc_onchain_fails_on_reload ( persist_manager_post_event : bool , confirm_commitment_tx : bool , payment_timeout : bool ) {
416+ // When a Channel is closed, any outbound HTLCs which were relayed through it are simply
417+ // dropped when the Channel is. From there, the ChannelManager relies on the ChannelMonitor
418+ // having a copy of the relevant fail-/claim-back data and processes the HTLC fail/claim when
419+ // the ChannelMonitor tells it to.
420+ //
421+ // If, due to an on-chain event, an HTLC is failed/claimed, we should avoid providing the
422+ // ChannelManager the HTLC event until after the monitor is re-persisted. This should prevent a
423+ // duplicate HTLC fail/claim (e.g. via a PaymentPathFailed event).
424+ let chanmon_cfgs = create_chanmon_cfgs ( 2 ) ;
425+ let node_cfgs = create_node_cfgs ( 2 , & chanmon_cfgs) ;
426+ let node_chanmgrs = create_node_chanmgrs ( 2 , & node_cfgs, & [ None , None ] ) ;
427+ let persister: test_utils:: TestPersister ;
428+ let new_chain_monitor: test_utils:: TestChainMonitor ;
429+ let nodes_0_deserialized: ChannelManager < EnforcingSigner , & test_utils:: TestChainMonitor , & test_utils:: TestBroadcaster , & test_utils:: TestKeysInterface , & test_utils:: TestFeeEstimator , & test_utils:: TestLogger > ;
430+ let mut nodes = create_network ( 2 , & node_cfgs, & node_chanmgrs) ;
431+
432+ let ( _, _, chan_id, funding_tx) = create_announced_chan_between_nodes ( & nodes, 0 , 1 , InitFeatures :: known ( ) , InitFeatures :: known ( ) ) ;
433+
434+ // Route a payment, but force-close the channel before the HTLC fulfill message arrives at
435+ // nodes[0].
436+ let ( payment_preimage, payment_hash, _) = route_payment ( & nodes[ 0 ] , & [ & nodes[ 1 ] ] , 10000000 ) ;
437+ nodes[ 0 ] . node . force_close_channel ( & nodes[ 0 ] . node . list_channels ( ) [ 0 ] . channel_id ) . unwrap ( ) ;
438+ check_closed_broadcast ! ( nodes[ 0 ] , true ) ;
439+ check_added_monitors ! ( nodes[ 0 ] , 1 ) ;
440+ check_closed_event ! ( nodes[ 0 ] , 1 , ClosureReason :: HolderForceClosed ) ;
441+
442+ nodes[ 0 ] . node . peer_disconnected ( & nodes[ 1 ] . node . get_our_node_id ( ) , false ) ;
443+ nodes[ 1 ] . node . peer_disconnected ( & nodes[ 0 ] . node . get_our_node_id ( ) , false ) ;
444+
445+ // Connect blocks until the CLTV timeout is up so that we get an HTLC-Timeout transaction
446+ connect_blocks ( & nodes[ 0 ] , TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + 1 ) ;
447+ let node_txn = nodes[ 0 ] . tx_broadcaster . txn_broadcasted . lock ( ) . unwrap ( ) . split_off ( 0 ) ;
448+ assert_eq ! ( node_txn. len( ) , 3 ) ;
449+ assert_eq ! ( node_txn[ 0 ] , node_txn[ 1 ] ) ;
450+ check_spends ! ( node_txn[ 1 ] , funding_tx) ;
451+ check_spends ! ( node_txn[ 2 ] , node_txn[ 1 ] ) ;
452+ let timeout_txn = vec ! [ node_txn[ 2 ] . clone( ) ] ;
453+
454+ assert ! ( nodes[ 1 ] . node. claim_funds( payment_preimage) ) ;
455+ check_added_monitors ! ( nodes[ 1 ] , 1 ) ;
456+
457+ let mut header = BlockHeader { version : 0x20000000 , prev_blockhash : nodes[ 1 ] . best_block_hash ( ) , merkle_root : Default :: default ( ) , time : 42 , bits : 42 , nonce : 42 } ;
458+ connect_block ( & nodes[ 1 ] , & Block { header, txdata : vec ! [ node_txn[ 1 ] . clone( ) ] } ) ;
459+ check_closed_broadcast ! ( nodes[ 1 ] , true ) ;
460+ check_added_monitors ! ( nodes[ 1 ] , 1 ) ;
461+ check_closed_event ! ( nodes[ 1 ] , 1 , ClosureReason :: CommitmentTxConfirmed ) ;
462+ let claim_txn = nodes[ 1 ] . tx_broadcaster . txn_broadcasted . lock ( ) . unwrap ( ) . split_off ( 0 ) ;
463+
464+ header. prev_blockhash = nodes[ 0 ] . best_block_hash ( ) ;
465+ connect_block ( & nodes[ 0 ] , & Block { header, txdata : vec ! [ node_txn[ 1 ] . clone( ) ] } ) ;
466+
467+ if confirm_commitment_tx {
468+ connect_blocks ( & nodes[ 0 ] , BREAKDOWN_TIMEOUT as u32 - 1 ) ;
469+ }
470+
471+ header. prev_blockhash = nodes[ 0 ] . best_block_hash ( ) ;
472+ let claim_block = Block { header, txdata : if payment_timeout { timeout_txn } else { claim_txn } } ;
473+
474+ if payment_timeout {
475+ assert ! ( confirm_commitment_tx) ; // Otherwise we're spending below our CSV!
476+ connect_block ( & nodes[ 0 ] , & claim_block) ;
477+ connect_blocks ( & nodes[ 0 ] , ANTI_REORG_DELAY - 2 ) ;
478+ }
479+
480+ // Now connect the HTLC claim transaction with the ChainMonitor-generated ChannelMonitor update
481+ // returning TemporaryFailure. This should cause the claim event to never make its way to the
482+ // ChannelManager.
483+ chanmon_cfgs[ 0 ] . persister . chain_sync_monitor_persistences . lock ( ) . unwrap ( ) . clear ( ) ;
484+ chanmon_cfgs[ 0 ] . persister . set_update_ret ( Err ( ChannelMonitorUpdateErr :: TemporaryFailure ) ) ;
485+
486+ if payment_timeout {
487+ connect_blocks ( & nodes[ 0 ] , 1 ) ;
488+ } else {
489+ connect_block ( & nodes[ 0 ] , & claim_block) ;
490+ }
491+
492+ let funding_txo = OutPoint { txid : funding_tx. txid ( ) , index : 0 } ;
493+ let mon_updates: Vec < _ > = chanmon_cfgs[ 0 ] . persister . chain_sync_monitor_persistences . lock ( ) . unwrap ( )
494+ . get_mut ( & funding_txo) . unwrap ( ) . drain ( ) . collect ( ) ;
495+ assert_eq ! ( mon_updates. len( ) , 1 ) ;
496+ assert ! ( nodes[ 0 ] . chain_monitor. release_pending_monitor_events( ) . is_empty( ) ) ;
497+ assert ! ( nodes[ 0 ] . node. get_and_clear_pending_events( ) . is_empty( ) ) ;
498+
499+ // If we persist the ChannelManager here, we should get the PaymentSent event after
500+ // deserialization.
501+ let mut chan_manager_serialized = test_utils:: TestVecWriter ( Vec :: new ( ) ) ;
502+ if !persist_manager_post_event {
503+ nodes[ 0 ] . node . write ( & mut chan_manager_serialized) . unwrap ( ) ;
504+ }
505+
506+ // Now persist the ChannelMonitor and inform the ChainMonitor that we're done, generating the
507+ // payment sent event.
508+ chanmon_cfgs[ 0 ] . persister . set_update_ret ( Ok ( ( ) ) ) ;
509+ let mut chan_0_monitor_serialized = test_utils:: TestVecWriter ( Vec :: new ( ) ) ;
510+ get_monitor ! ( nodes[ 0 ] , chan_id) . write ( & mut chan_0_monitor_serialized) . unwrap ( ) ;
511+ nodes[ 0 ] . chain_monitor . chain_monitor . channel_monitor_updated ( funding_txo, mon_updates[ 0 ] ) . unwrap ( ) ;
512+ if payment_timeout {
513+ expect_payment_failed ! ( nodes[ 0 ] , payment_hash, true ) ;
514+ } else {
515+ expect_payment_sent ! ( nodes[ 0 ] , payment_preimage) ;
516+ }
517+
518+ // If we persist the ChannelManager after we get the PaymentSent event, we shouldn't get it
519+ // twice.
520+ if persist_manager_post_event {
521+ nodes[ 0 ] . node . write ( & mut chan_manager_serialized) . unwrap ( ) ;
522+ }
523+
524+ // Now reload nodes[0]...
525+ persister = test_utils:: TestPersister :: new ( ) ;
526+ let keys_manager = & chanmon_cfgs[ 0 ] . keys_manager ;
527+ 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) ;
528+ nodes[ 0 ] . chain_monitor = & new_chain_monitor;
529+ let mut chan_0_monitor_read = & chan_0_monitor_serialized. 0 [ ..] ;
530+ let ( _, mut chan_0_monitor) = <( BlockHash , ChannelMonitor < EnforcingSigner > ) >:: read (
531+ & mut chan_0_monitor_read, keys_manager) . unwrap ( ) ;
532+ assert ! ( chan_0_monitor_read. is_empty( ) ) ;
533+
534+ let ( _, nodes_0_deserialized_tmp) = {
535+ let mut channel_monitors = HashMap :: new ( ) ;
536+ channel_monitors. insert ( chan_0_monitor. get_funding_txo ( ) . 0 , & mut chan_0_monitor) ;
537+ <( BlockHash , ChannelManager < EnforcingSigner , & test_utils:: TestChainMonitor , & test_utils:: TestBroadcaster , & test_utils:: TestKeysInterface , & test_utils:: TestFeeEstimator , & test_utils:: TestLogger > ) >
538+ :: read ( & mut io:: Cursor :: new ( & chan_manager_serialized. 0 [ ..] ) , ChannelManagerReadArgs {
539+ default_config : Default :: default ( ) ,
540+ keys_manager,
541+ fee_estimator : node_cfgs[ 0 ] . fee_estimator ,
542+ chain_monitor : nodes[ 0 ] . chain_monitor ,
543+ tx_broadcaster : nodes[ 0 ] . tx_broadcaster . clone ( ) ,
544+ logger : nodes[ 0 ] . logger ,
545+ channel_monitors,
546+ } ) . unwrap ( )
547+ } ;
548+ nodes_0_deserialized = nodes_0_deserialized_tmp;
549+
550+ assert ! ( nodes[ 0 ] . chain_monitor. watch_channel( chan_0_monitor. get_funding_txo( ) . 0 , chan_0_monitor) . is_ok( ) ) ;
551+ check_added_monitors ! ( nodes[ 0 ] , 1 ) ;
552+ nodes[ 0 ] . node = & nodes_0_deserialized;
553+
554+ if persist_manager_post_event {
555+ assert ! ( nodes[ 0 ] . node. get_and_clear_pending_events( ) . is_empty( ) ) ;
556+ } else {
557+ if payment_timeout {
558+ expect_payment_failed ! ( nodes[ 0 ] , payment_hash, true ) ;
559+ } else {
560+ expect_payment_sent ! ( nodes[ 0 ] , payment_preimage) ;
561+ }
562+ }
563+
564+ // Note that if we re-connect the block which exposed nodes[0] to the payment preimage (but
565+ // which the current ChannelMonitor has not seen), the ChannelManager's de-duplication of
566+ // payment events should kick in, leaving us with no pending events here.
567+ let height = nodes[ 0 ] . blocks . lock ( ) . unwrap ( ) . len ( ) as u32 - 1 ;
568+ nodes[ 0 ] . chain_monitor . chain_monitor . block_connected ( & claim_block, height) ;
569+ assert ! ( nodes[ 0 ] . node. get_and_clear_pending_events( ) . is_empty( ) ) ;
570+ }
571+
572+ #[ test]
573+ fn test_dup_htlc_onchain_fails_on_reload ( ) {
574+ do_test_dup_htlc_onchain_fails_on_reload ( true , true , true ) ;
575+ do_test_dup_htlc_onchain_fails_on_reload ( true , true , false ) ;
576+ do_test_dup_htlc_onchain_fails_on_reload ( true , false , false ) ;
577+ do_test_dup_htlc_onchain_fails_on_reload ( false , true , true ) ;
578+ do_test_dup_htlc_onchain_fails_on_reload ( false , true , false ) ;
579+ do_test_dup_htlc_onchain_fails_on_reload ( false , false , false ) ;
580+ }
0 commit comments