X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fblinded_payment_tests.rs;h=198ded1cb4421aa8afbee8848f22c4381f2b7b3d;hb=19e50ebb7cc041341276d88ba74f5e268e263254;hp=3ed74a80a2f41a34b985ed3b8d786bd8ccefe330;hpb=5fbc44ee58bbaf2a74174b477916abc22b40f765;p=rust-lightning diff --git a/lightning/src/ln/blinded_payment_tests.rs b/lightning/src/ln/blinded_payment_tests.rs index 3ed74a80..198ded1c 100644 --- a/lightning/src/ln/blinded_payment_tests.rs +++ b/lightning/src/ln/blinded_payment_tests.rs @@ -20,7 +20,7 @@ use crate::ln::msgs; use crate::ln::msgs::ChannelMessageHandler; use crate::ln::onion_utils; use crate::ln::onion_utils::INVALID_ONION_BLINDING; -use crate::ln::outbound_payment::Retry; +use crate::ln::outbound_payment::{Retry, IDEMPOTENCY_TIMEOUT_TICKS}; use crate::offers::invoice::BlindedPayInfo; use crate::prelude::*; use crate::routing::router::{Payee, PaymentParameters, RouteParameters}; @@ -28,11 +28,14 @@ use crate::util::config::UserConfig; use crate::util::test_utils; fn blinded_payment_path( - payment_secret: PaymentSecret, node_ids: Vec, - channel_upds: &[&msgs::UnsignedChannelUpdate], keys_manager: &test_utils::TestKeysInterface + payment_secret: PaymentSecret, intro_node_min_htlc: u64, intro_node_max_htlc: u64, + node_ids: Vec, channel_upds: &[&msgs::UnsignedChannelUpdate], + keys_manager: &test_utils::TestKeysInterface ) -> (BlindedPayInfo, BlindedPath) { let mut intermediate_nodes = Vec::new(); - for (node_id, chan_upd) in node_ids.iter().zip(channel_upds) { + let mut intro_node_min_htlc_opt = Some(intro_node_min_htlc); + let mut intro_node_max_htlc_opt = Some(intro_node_max_htlc); + for (idx, (node_id, chan_upd)) in node_ids.iter().zip(channel_upds).enumerate() { intermediate_nodes.push(ForwardNode { node_id: *node_id, tlvs: ForwardTlvs { @@ -44,34 +47,42 @@ fn blinded_payment_path( }, payment_constraints: PaymentConstraints { max_cltv_expiry: u32::max_value(), - htlc_minimum_msat: chan_upd.htlc_minimum_msat, + htlc_minimum_msat: intro_node_min_htlc_opt.take() + .unwrap_or_else(|| channel_upds[idx - 1].htlc_minimum_msat), }, features: BlindedHopFeatures::empty(), }, - htlc_maximum_msat: chan_upd.htlc_maximum_msat, + htlc_maximum_msat: intro_node_max_htlc_opt.take() + .unwrap_or_else(|| channel_upds[idx - 1].htlc_maximum_msat), }); } let payee_tlvs = ReceiveTlvs { payment_secret, payment_constraints: PaymentConstraints { max_cltv_expiry: u32::max_value(), - htlc_minimum_msat: channel_upds.last().unwrap().htlc_minimum_msat, + htlc_minimum_msat: + intro_node_min_htlc_opt.unwrap_or_else(|| channel_upds.last().unwrap().htlc_minimum_msat), }, }; let mut secp_ctx = Secp256k1::new(); BlindedPath::new_for_payment( &intermediate_nodes[..], *node_ids.last().unwrap(), payee_tlvs, - channel_upds.last().unwrap().htlc_maximum_msat, TEST_FINAL_CLTV as u16, keys_manager, &secp_ctx + intro_node_max_htlc_opt.unwrap_or_else(|| channel_upds.last().unwrap().htlc_maximum_msat), + TEST_FINAL_CLTV as u16, keys_manager, &secp_ctx ).unwrap() } pub fn get_blinded_route_parameters( - amt_msat: u64, payment_secret: PaymentSecret, node_ids: Vec, - channel_upds: &[&msgs::UnsignedChannelUpdate], keys_manager: &test_utils::TestKeysInterface + amt_msat: u64, payment_secret: PaymentSecret, intro_node_min_htlc: u64, intro_node_max_htlc: u64, + node_ids: Vec, channel_upds: &[&msgs::UnsignedChannelUpdate], + keys_manager: &test_utils::TestKeysInterface ) -> RouteParameters { RouteParameters::from_payment_params_and_value( PaymentParameters::blinded(vec![ - blinded_payment_path(payment_secret, node_ids, channel_upds, keys_manager) + blinded_payment_path( + payment_secret, intro_node_min_htlc, intro_node_max_htlc, node_ids, channel_upds, + keys_manager + ) ]), amt_msat ) } @@ -193,13 +204,13 @@ fn mpp_to_three_hop_blinded_paths() { let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[5], Some(amt_msat), None); let route_params = { let path_1_params = get_blinded_route_parameters( - amt_msat, payment_secret, vec![ + amt_msat, payment_secret, 1, 1_0000_0000, vec![ nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id(), nodes[5].node.get_our_node_id() ], &[&chan_upd_1_3, &chan_upd_3_5], &chanmon_cfgs[5].keys_manager ); let path_2_params = get_blinded_route_parameters( - amt_msat, payment_secret, vec![ + amt_msat, payment_secret, 1, 1_0000_0000, vec![ nodes[2].node.get_our_node_id(), nodes[4].node.get_our_node_id(), nodes[5].node.get_our_node_id() ], &[&chan_upd_2_4, &chan_upd_4_5], &chanmon_cfgs[5].keys_manager @@ -268,7 +279,7 @@ fn do_forward_checks_failure(check: ForwardCheckFail, intro_fails: bool) { let amt_msat = 5000; let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None); - let route_params = get_blinded_route_parameters(amt_msat, payment_secret, + let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000, nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2, &chan_upd_2_3], &chanmon_cfgs[3].keys_manager); @@ -368,7 +379,7 @@ fn failed_backwards_to_intro_node() { let amt_msat = 5000; let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None); - let route_params = get_blinded_route_parameters(amt_msat, payment_secret, + let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000, nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2], &chanmon_cfgs[2].keys_manager); @@ -448,7 +459,7 @@ fn do_forward_fail_in_process_pending_htlc_fwds(check: ProcessPendingHTLCsCheck, let amt_msat = 5000; let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None); - let route_params = get_blinded_route_parameters(amt_msat, payment_secret, + let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000, nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2, &chan_upd_2_3], &chanmon_cfgs[2].keys_manager); @@ -565,7 +576,7 @@ fn do_blinded_intercept_payment(intercept_node_fails: bool) { let intercept_scid = nodes[1].node.get_intercept_scid(); let mut intercept_chan_upd = chan_upd; intercept_chan_upd.short_channel_id = intercept_scid; - let route_params = get_blinded_route_parameters(amt_msat, payment_secret, + let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000, nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&intercept_chan_upd], &chanmon_cfgs[2].keys_manager); @@ -642,7 +653,7 @@ fn two_hop_blinded_path_success() { let amt_msat = 5000; let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None); - let route_params = get_blinded_route_parameters(amt_msat, payment_secret, + let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000, nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2], &chanmon_cfgs[2].keys_manager); @@ -671,7 +682,7 @@ fn three_hop_blinded_path_success() { let amt_msat = 5000; let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[4], Some(amt_msat), None); - let route_params = get_blinded_route_parameters(amt_msat, payment_secret, + let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000, nodes.iter().skip(2).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_2_3, &chan_upd_3_4], &chanmon_cfgs[4].keys_manager); @@ -681,6 +692,59 @@ fn three_hop_blinded_path_success() { claim_payment(&nodes[0], &[&nodes[1], &nodes[2], &nodes[3], &nodes[4]], payment_preimage); } +#[test] +fn three_hop_blinded_path_fail() { + // Test that an intermediate blinded forwarding node gets failed back to with + // malformed and also fails back themselves with malformed. + let chanmon_cfgs = create_chanmon_cfgs(4); + let node_cfgs = create_node_cfgs(4, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]); + let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); + let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents; + let chan_upd_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0).0.contents; + + let amt_msat = 5000; + let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None); + let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000, + nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), + &[&chan_upd_1_2, &chan_upd_2_3], &chanmon_cfgs[3].keys_manager); + + nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap(); + check_added_monitors(&nodes[0], 1); + pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3]]], amt_msat, payment_hash, payment_secret); + + nodes[3].node.fail_htlc_backwards(&payment_hash); + expect_pending_htlcs_forwardable_conditions( + nodes[3].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }] + ); + nodes[3].node.process_pending_htlc_forwards(); + check_added_monitors!(nodes[3], 1); + + let updates_3_2 = get_htlc_update_msgs!(nodes[3], nodes[2].node.get_our_node_id()); + assert_eq!(updates_3_2.update_fail_malformed_htlcs.len(), 1); + let update_malformed = &updates_3_2.update_fail_malformed_htlcs[0]; + assert_eq!(update_malformed.sha256_of_onion, [0; 32]); + assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING); + nodes[2].node.handle_update_fail_malformed_htlc(&nodes[3].node.get_our_node_id(), update_malformed); + do_commitment_signed_dance(&nodes[2], &nodes[3], &updates_3_2.commitment_signed, true, false); + + let updates_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id()); + assert_eq!(updates_2_1.update_fail_malformed_htlcs.len(), 1); + let update_malformed = &updates_2_1.update_fail_malformed_htlcs[0]; + assert_eq!(update_malformed.sha256_of_onion, [0; 32]); + assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING); + nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed); + do_commitment_signed_dance(&nodes[1], &nodes[2], &updates_2_1.commitment_signed, true, false); + + let updates_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); + assert_eq!(updates_1_0.update_fail_htlcs.len(), 1); + nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_1_0.update_fail_htlcs[0]); + do_commitment_signed_dance(&nodes[0], &nodes[1], &updates_1_0.commitment_signed, false, false); + expect_payment_failed_conditions(&nodes[0], payment_hash, false, + PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32])); +} + #[derive(PartialEq)] enum ReceiveCheckFail { // The recipient fails the payment upon `PaymentClaimable`. @@ -733,7 +797,7 @@ fn do_multi_hop_receiver_fail(check: ReceiveCheckFail) { Some(TEST_FINAL_CLTV as u16 - 2) } else { None }; let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), excess_final_cltv_delta_opt); - let mut route_params = get_blinded_route_parameters(amt_msat, payment_secret, + let mut route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000, nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2], &chanmon_cfgs[2].keys_manager); @@ -750,7 +814,7 @@ fn do_multi_hop_receiver_fail(check: ReceiveCheckFail) { let high_htlc_min_bp = { let mut high_htlc_minimum_upd = chan_upd_1_2.clone(); high_htlc_minimum_upd.htlc_minimum_msat = amt_msat + 1000; - let high_htlc_min_params = get_blinded_route_parameters(amt_msat, payment_secret, + let high_htlc_min_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000, nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&high_htlc_minimum_upd], &chanmon_cfgs[2].keys_manager); if let Payee::Blinded { route_hints, .. } = high_htlc_min_params.payment_params.payee { @@ -920,11 +984,11 @@ fn blinded_path_retries() { let route_params = { let pay_params = PaymentParameters::blinded( vec![ - blinded_payment_path(payment_secret, + blinded_payment_path(payment_secret, 1, 1_0000_0000, vec![nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_1_3.0.contents], &chanmon_cfgs[3].keys_manager ), - blinded_payment_path(payment_secret, + blinded_payment_path(payment_secret, 1, 1_0000_0000, vec![nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_2_3.0.contents], &chanmon_cfgs[3].keys_manager ), @@ -998,3 +1062,205 @@ fn blinded_path_retries() { _ => panic!() } } + +#[test] +fn min_htlc() { + // The min htlc of a blinded path is the max (htlc_min - following_fees) along the path. Make sure + // the payment succeeds when we calculate the min htlc this way. + let chanmon_cfgs = create_chanmon_cfgs(4); + let node_cfgs = create_node_cfgs(4, &chanmon_cfgs); + let mut node_1_cfg = test_default_channel_config(); + node_1_cfg.channel_handshake_config.our_htlc_minimum_msat = 2000; + node_1_cfg.channel_config.forwarding_fee_base_msat = 1000; + node_1_cfg.channel_config.forwarding_fee_proportional_millionths = 100_000; + let mut node_2_cfg = test_default_channel_config(); + node_2_cfg.channel_handshake_config.our_htlc_minimum_msat = 5000; + node_2_cfg.channel_config.forwarding_fee_base_msat = 200; + node_2_cfg.channel_config.forwarding_fee_proportional_millionths = 150_000; + let mut node_3_cfg = test_default_channel_config(); + node_3_cfg.channel_handshake_config.our_htlc_minimum_msat = 2000; + let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, Some(node_1_cfg), Some(node_2_cfg), Some(node_3_cfg)]); + let nodes = create_network(4, &node_cfgs, &node_chanmgrs); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); + let chan_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0); + let chan_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0); + + let min_htlc_msat = { + // The min htlc for this setup is nodes[2]'s htlc_minimum_msat minus the + // following fees. + let post_base_fee = chan_2_3.1.contents.htlc_minimum_msat - chan_2_3.0.contents.fee_base_msat as u64; + let prop_fee = chan_2_3.0.contents.fee_proportional_millionths as u64; + (post_base_fee * 1_000_000 + 1_000_000 + prop_fee - 1) / (prop_fee + 1_000_000) + }; + let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(min_htlc_msat), None); + let mut route_params = get_blinded_route_parameters( + min_htlc_msat, payment_secret, chan_1_2.1.contents.htlc_minimum_msat, + chan_1_2.1.contents.htlc_maximum_msat, vec![nodes[1].node.get_our_node_id(), + nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()], + &[&chan_1_2.0.contents, &chan_2_3.0.contents], &chanmon_cfgs[3].keys_manager); + assert_eq!(min_htlc_msat, + route_params.payment_params.payee.blinded_route_hints()[0].0.htlc_minimum_msat); + + nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params.clone(), Retry::Attempts(0)).unwrap(); + check_added_monitors(&nodes[0], 1); + pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3]]], min_htlc_msat, payment_hash, payment_secret); + claim_payment(&nodes[0], &[&nodes[1], &nodes[2], &nodes[3]], payment_preimage); + + // Paying 1 less than the min fails. + for _ in 0..IDEMPOTENCY_TIMEOUT_TICKS + 1 { + nodes[0].node.timer_tick_occurred(); + } + if let Payee::Blinded { ref mut route_hints, .. } = route_params.payment_params.payee { + route_hints[0].0.htlc_minimum_msat -= 1; + } else { panic!() } + route_params.final_value_msat -= 1; + nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap(); + check_added_monitors(&nodes[0], 1); + + let mut payment_event_0_1 = { + let mut events = nodes[0].node.get_and_clear_pending_msg_events(); + assert_eq!(events.len(), 1); + let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events); + SendEvent::from_event(ev) + }; + nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_0_1.msgs[0]); + check_added_monitors!(nodes[1], 0); + do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event_0_1.commitment_msg, true, true); + let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); + nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]); + do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false); + expect_payment_failed_conditions(&nodes[0], payment_hash, false, + PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32])); +} + +#[test] +fn conditionally_round_fwd_amt() { + // Previously, the (rng-found) feerates below caught a bug where an intermediate node would + // calculate an amt_to_forward that underpaid them by 1 msat, caused by rounding up the outbound + // amount on top of an already rounded-up total routing fee. Ensure that we'll conditionally round + // down intermediate nodes' outbound amounts based on whether rounding up will result in + // undercharging for relay. + let chanmon_cfgs = create_chanmon_cfgs(5); + let node_cfgs = create_node_cfgs(5, &chanmon_cfgs); + + let mut node_1_cfg = test_default_channel_config(); + node_1_cfg.channel_config.forwarding_fee_base_msat = 247371; + node_1_cfg.channel_config.forwarding_fee_proportional_millionths = 86552; + + let mut node_2_cfg = test_default_channel_config(); + node_2_cfg.channel_config.forwarding_fee_base_msat = 198921; + node_2_cfg.channel_config.forwarding_fee_proportional_millionths = 681759; + + let mut node_3_cfg = test_default_channel_config(); + node_3_cfg.channel_config.forwarding_fee_base_msat = 132845; + node_3_cfg.channel_config.forwarding_fee_proportional_millionths = 552561; + + let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &[None, Some(node_1_cfg), Some(node_2_cfg), Some(node_3_cfg), None]); + let nodes = create_network(5, &node_cfgs, &node_chanmgrs); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); + let chan_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0); + let chan_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0); + let chan_3_4 = create_announced_chan_between_nodes_with_value(&nodes, 3, 4, 1_000_000, 0); + + let amt_msat = 100_000; + let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[4], Some(amt_msat), None); + let mut route_params = get_blinded_route_parameters(amt_msat, payment_secret, + chan_1_2.1.contents.htlc_minimum_msat, chan_1_2.1.contents.htlc_maximum_msat, + vec![nodes[1].node.get_our_node_id(), nodes[2].node.get_our_node_id(), + nodes[3].node.get_our_node_id(), nodes[4].node.get_our_node_id()], + &[&chan_1_2.0.contents, &chan_2_3.0.contents, &chan_3_4.0.contents], + &chanmon_cfgs[4].keys_manager); + route_params.max_total_routing_fee_msat = None; + + nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap(); + check_added_monitors(&nodes[0], 1); + pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3], &nodes[4]]], amt_msat, payment_hash, payment_secret); + nodes[4].node.claim_funds(payment_preimage); + let expected_path = &[&nodes[1], &nodes[2], &nodes[3], &nodes[4]]; + let expected_route = &[&expected_path[..]]; + let mut args = ClaimAlongRouteArgs::new(&nodes[0], &expected_route[..], payment_preimage) + .allow_1_msat_fee_overpay(); + let expected_fee = pass_claimed_payment_along_route(args); + expect_payment_sent(&nodes[0], payment_preimage, Some(Some(expected_fee)), true, true); +} + +#[test] +fn blinded_keysend() { + let mut mpp_keysend_config = test_default_channel_config(); + mpp_keysend_config.accept_mpp_keysend = true; + let chanmon_cfgs = create_chanmon_cfgs(3); + let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, Some(mpp_keysend_config)]); + let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); + let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents; + + let amt_msat = 5000; + let (keysend_preimage, _, payment_secret) = get_payment_preimage_hash(&nodes[2], None, None); + let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, + 1_0000_0000, + nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), + &[&chan_upd_1_2], &chanmon_cfgs[2].keys_manager); + + let payment_hash = nodes[0].node.send_spontaneous_payment_with_retry(Some(keysend_preimage), RecipientOnionFields::spontaneous_empty(), PaymentId(keysend_preimage.0), route_params, Retry::Attempts(0)).unwrap(); + check_added_monitors(&nodes[0], 1); + + let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[2]]]; + let mut events = nodes[0].node.get_and_clear_pending_msg_events(); + assert_eq!(events.len(), 1); + + let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events); + pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash, Some(payment_secret), ev.clone(), true, Some(keysend_preimage)); + claim_payment_along_route(&nodes[0], expected_route, false, keysend_preimage); +} + +#[test] +fn blinded_mpp_keysend() { + let mut mpp_keysend_config = test_default_channel_config(); + mpp_keysend_config.accept_mpp_keysend = true; + let chanmon_cfgs = create_chanmon_cfgs(4); + let node_cfgs = create_node_cfgs(4, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, Some(mpp_keysend_config)]); + let nodes = create_network(4, &node_cfgs, &node_chanmgrs); + + create_announced_chan_between_nodes(&nodes, 0, 1); + create_announced_chan_between_nodes(&nodes, 0, 2); + let chan_1_3 = create_announced_chan_between_nodes(&nodes, 1, 3); + let chan_2_3 = create_announced_chan_between_nodes(&nodes, 2, 3); + + let amt_msat = 15_000_000; + let (keysend_preimage, _, payment_secret) = get_payment_preimage_hash(&nodes[3], None, None); + let route_params = { + let pay_params = PaymentParameters::blinded( + vec![ + blinded_payment_path(payment_secret, 1, 1_0000_0000, + vec![nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_1_3.0.contents], + &chanmon_cfgs[3].keys_manager + ), + blinded_payment_path(payment_secret, 1, 1_0000_0000, + vec![nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_2_3.0.contents], + &chanmon_cfgs[3].keys_manager + ), + ] + ) + .with_bolt12_features(channelmanager::provided_bolt12_invoice_features(&UserConfig::default())) + .unwrap(); + RouteParameters::from_payment_params_and_value(pay_params, amt_msat) + }; + + let payment_hash = nodes[0].node.send_spontaneous_payment_with_retry(Some(keysend_preimage), RecipientOnionFields::spontaneous_empty(), PaymentId(keysend_preimage.0), route_params, Retry::Attempts(0)).unwrap(); + check_added_monitors!(nodes[0], 2); + + let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]]; + let mut events = nodes[0].node.get_and_clear_pending_msg_events(); + assert_eq!(events.len(), 2); + + let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events); + pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash.clone(), + Some(payment_secret), ev.clone(), false, Some(keysend_preimage)); + + let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events); + pass_along_path(&nodes[0], expected_route[1], amt_msat, payment_hash.clone(), + Some(payment_secret), ev.clone(), true, Some(keysend_preimage)); + claim_payment_along_route(&nodes[0], expected_route, false, keysend_preimage); +}