@@ -7925,6 +7925,116 @@ fn test_can_not_accept_unknown_inbound_channel() {
7925
7925
}
7926
7926
}
7927
7927
7928
+ fn do_test_overshoot_mpp ( msat_amounts : & [ u64 ] , total_msat : u64 , should_fail : bool ) {
7929
+
7930
+ let routing_node_count = msat_amounts. len ( ) ;
7931
+ let node_count = routing_node_count + 2 ;
7932
+
7933
+ let chanmon_cfgs = create_chanmon_cfgs ( node_count) ;
7934
+ let node_cfgs = create_node_cfgs ( node_count, & chanmon_cfgs) ;
7935
+ let node_chanmgrs = create_node_chanmgrs ( node_count, & node_cfgs, & vec ! [ None ; node_count] ) ;
7936
+ let nodes = create_network ( node_count, & node_cfgs, & node_chanmgrs) ;
7937
+
7938
+ let src_idx = 0 ;
7939
+ let dst_idx = 1 ;
7940
+
7941
+ // Create channels for each amount
7942
+ let mut expected_paths = Vec :: with_capacity ( routing_node_count) ;
7943
+ let mut src_chan_ids = Vec :: with_capacity ( routing_node_count) ;
7944
+ let mut dst_chan_ids = Vec :: with_capacity ( routing_node_count) ;
7945
+ for i in 0 ..routing_node_count {
7946
+ let routing_node = 2 + i;
7947
+ let src_chan_id = create_announced_chan_between_nodes ( & nodes, src_idx, routing_node) . 0 . contents . short_channel_id ;
7948
+ src_chan_ids. push ( src_chan_id) ;
7949
+ let dst_chan_id = create_announced_chan_between_nodes ( & nodes, routing_node, dst_idx) . 0 . contents . short_channel_id ;
7950
+ dst_chan_ids. push ( dst_chan_id) ;
7951
+ let path = vec ! [ & nodes[ routing_node] , & nodes[ dst_idx] ] ;
7952
+ expected_paths. push ( path) ;
7953
+ }
7954
+ let expected_paths: Vec < & [ & Node ] > = expected_paths. iter ( ) . map ( |route| route. as_slice ( ) ) . collect ( ) ;
7955
+
7956
+ // Create a route for each amount
7957
+ let example_amount = 100000 ;
7958
+ let ( mut route, our_payment_hash, our_payment_preimage, our_payment_secret) = get_route_and_payment_hash ! ( & nodes[ src_idx] , nodes[ dst_idx] , example_amount) ;
7959
+ let sample_path = route. paths . pop ( ) . unwrap ( ) ;
7960
+ for i in 0 ..routing_node_count {
7961
+ let routing_node = 2 + i;
7962
+ let mut path = sample_path. clone ( ) ;
7963
+ path[ 0 ] . pubkey = nodes[ routing_node] . node . get_our_node_id ( ) ;
7964
+ path[ 0 ] . short_channel_id = src_chan_ids[ i] ;
7965
+ path[ 1 ] . pubkey = nodes[ dst_idx] . node . get_our_node_id ( ) ;
7966
+ path[ 1 ] . short_channel_id = dst_chan_ids[ i] ;
7967
+ path[ 1 ] . fee_msat = msat_amounts[ i] ;
7968
+ route. paths . push ( path) ;
7969
+ }
7970
+
7971
+ // Send payment with manually set total_msat
7972
+ let payment_id = PaymentId ( nodes[ src_idx] . keys_manager . backing . get_secure_random_bytes ( ) ) ;
7973
+ let onion_session_privs = nodes[ src_idx] . node . test_add_new_pending_payment ( our_payment_hash, Some ( our_payment_secret) , payment_id, & route) . unwrap ( ) ;
7974
+ nodes[ src_idx] . node . test_send_payment_internal ( & route, our_payment_hash, & Some ( our_payment_secret) , None , payment_id, Some ( total_msat) , onion_session_privs) . unwrap ( ) ;
7975
+ check_added_monitors ! ( nodes[ src_idx] , expected_paths. len( ) ) ;
7976
+
7977
+ // Similar to pass_along_route but handles failures
7978
+ let mut total_value = 0 ;
7979
+ let mut events = nodes[ src_idx] . node . get_and_clear_pending_msg_events ( ) ;
7980
+ assert_eq ! ( events. len( ) , expected_paths. len( ) ) ;
7981
+
7982
+ for ( path_idx, expected_path) in expected_paths. iter ( ) . enumerate ( ) {
7983
+ let ev = remove_first_msg_event_to_node ( & expected_path[ 0 ] . node . get_our_node_id ( ) , & mut events) ;
7984
+
7985
+ total_value += route. paths [ path_idx] [ 1 ] . fee_msat ;
7986
+ let payment_claimable_expected = total_value >= total_msat;
7987
+
7988
+ let mut payment_event = SendEvent :: from_event ( ev) ;
7989
+ let mut prev_node = & nodes[ src_idx] ;
7990
+ for ( idx, & node) in expected_path. iter ( ) . enumerate ( ) {
7991
+ assert_eq ! ( node. node. get_our_node_id( ) , payment_event. node_id) ;
7992
+
7993
+ node. node . handle_update_add_htlc ( & prev_node. node . get_our_node_id ( ) , & payment_event. msgs [ 0 ] ) ;
7994
+ check_added_monitors ! ( node, 0 ) ;
7995
+ commitment_signed_dance ! ( node, prev_node, payment_event. commitment_msg, false ) ;
7996
+ expect_pending_htlcs_forwardable ! ( node) ;
7997
+ prev_node = node;
7998
+
7999
+ let is_routing = idx != expected_path. len ( ) - 1 ;
8000
+ if is_routing {
8001
+ let mut events_2 = node. node . get_and_clear_pending_msg_events ( ) ;
8002
+ assert_eq ! ( events_2. len( ) , 1 ) ;
8003
+ check_added_monitors ! ( node, 1 ) ;
8004
+ payment_event = SendEvent :: from_event ( events_2. remove ( 0 ) ) ;
8005
+ assert_eq ! ( payment_event. msgs. len( ) , 1 ) ;
8006
+ } else if !payment_claimable_expected {
8007
+ let events_2 = node. node . get_and_clear_pending_events ( ) ;
8008
+ assert ! ( events_2. is_empty( ) ) ;
8009
+ } else if should_fail {
8010
+ expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore ! ( node, vec![ HTLCDestination :: FailedPayment { payment_hash: our_payment_hash } ] ) ;
8011
+ check_added_monitors ! ( node, 1 ) ;
8012
+ let msg_events = node. node . get_and_clear_pending_msg_events ( ) ;
8013
+ match msg_events[ 0 ] {
8014
+ MessageSendEvent :: UpdateHTLCs { .. } => { } ,
8015
+ _ => panic ! ( "Expected MessageSendEvent::UpdateHTLCs" )
8016
+ }
8017
+ } else {
8018
+ expect_payment_claimable ! ( node, our_payment_hash, our_payment_secret, total_value) ;
8019
+ claim_payment_along_route ( & nodes[ src_idx] , & expected_paths, false , our_payment_preimage) ;
8020
+ }
8021
+ }
8022
+ }
8023
+
8024
+ }
8025
+
8026
+ #[ test]
8027
+ fn test_overshoot_mpp ( ) {
8028
+ // Test an MPP that overruns the intended amount
8029
+ do_test_overshoot_mpp ( & [ 100_000 , 100_000 , 101_000 ] , 300_000 , false ) ;
8030
+ // Test an MPP where the smallest HTLC amount is less than or equal to
8031
+ // the difference between the total amount received and the expected total_msat
8032
+ do_test_overshoot_mpp ( & [ 100_000 , 10_000 , 100_000 ] , 200_000 , true ) ;
8033
+ do_test_overshoot_mpp ( & [ 100_000 , 20_000 , 5_000 , 90_000 ] , 200_000 , true ) ;
8034
+ // Note this is not meant to test for HTLCs that arrive after the total_msat
8035
+ // has already been received - see test_dup_htlc_second_rejected
8036
+ }
8037
+
7928
8038
#[ test]
7929
8039
fn test_simple_mpp ( ) {
7930
8040
// Simple test of sending a multi-path payment.
0 commit comments