}
}
+#[test]
+fn accept_underpaying_htlcs_config() {
+ do_accept_underpaying_htlcs_config(1);
+ do_accept_underpaying_htlcs_config(2);
+ do_accept_underpaying_htlcs_config(3);
+}
+
+fn do_accept_underpaying_htlcs_config(num_mpp_parts: usize) {
+ let chanmon_cfgs = create_chanmon_cfgs(3);
+ let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
+ let mut intercept_forwards_config = test_default_channel_config();
+ intercept_forwards_config.accept_intercept_htlcs = true;
+ let mut underpay_config = test_default_channel_config();
+ underpay_config.channel_config.accept_underpaying_htlcs = true;
+ let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(intercept_forwards_config), Some(underpay_config)]);
+ let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+
+ let mut chan_ids = Vec::new();
+ for _ in 0..num_mpp_parts {
+ let _ = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000, 0);
+ let channel_id = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 2_000_000, 0).0.channel_id;
+ chan_ids.push(channel_id);
+ }
+
+ // Send the initial payment.
+ let amt_msat = 900_000;
+ let skimmed_fee_msat = 20;
+ let mut route_hints = Vec::new();
+ for _ in 0..num_mpp_parts {
+ route_hints.push(RouteHint(vec![RouteHintHop {
+ src_node_id: nodes[1].node.get_our_node_id(),
+ short_channel_id: nodes[1].node.get_intercept_scid(),
+ fees: RoutingFees {
+ base_msat: 1000,
+ proportional_millionths: 0,
+ },
+ cltv_expiry_delta: MIN_CLTV_EXPIRY_DELTA,
+ htlc_minimum_msat: None,
+ htlc_maximum_msat: Some(amt_msat / num_mpp_parts as u64 + 5),
+ }]));
+ }
+ let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV)
+ .with_route_hints(route_hints).unwrap()
+ .with_bolt11_features(nodes[2].node.invoice_features()).unwrap();
+ let route_params = RouteParameters {
+ payment_params,
+ final_value_msat: amt_msat,
+ };
+ let (payment_hash, payment_secret) = nodes[2].node.create_inbound_payment(Some(amt_msat), 60 * 60, None).unwrap();
+ nodes[0].node.send_payment(payment_hash, RecipientOnionFields::secret_only(payment_secret),
+ PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
+ check_added_monitors!(nodes[0], num_mpp_parts); // one monitor per path
+ let mut events: Vec<SendEvent> = nodes[0].node.get_and_clear_pending_msg_events().into_iter().map(|e| SendEvent::from_event(e)).collect();
+ assert_eq!(events.len(), num_mpp_parts);
+
+ // Forward the intercepted payments.
+ for (idx, ev) in events.into_iter().enumerate() {
+ nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &ev.msgs[0]);
+ do_commitment_signed_dance(&nodes[1], &nodes[0], &ev.commitment_msg, false, true);
+
+ let events = nodes[1].node.get_and_clear_pending_events();
+ assert_eq!(events.len(), 1);
+ let (intercept_id, expected_outbound_amt_msat) = match events[0] {
+ crate::events::Event::HTLCIntercepted {
+ intercept_id, expected_outbound_amount_msat, payment_hash: pmt_hash, ..
+ } => {
+ assert_eq!(pmt_hash, payment_hash);
+ (intercept_id, expected_outbound_amount_msat)
+ },
+ _ => panic!()
+ };
+ nodes[1].node.forward_intercepted_htlc(intercept_id, &chan_ids[idx],
+ nodes[2].node.get_our_node_id(), expected_outbound_amt_msat - skimmed_fee_msat).unwrap();
+ expect_pending_htlcs_forwardable!(nodes[1]);
+ let payment_event = {
+ {
+ let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
+ assert_eq!(added_monitors.len(), 1);
+ added_monitors.clear();
+ }
+ let mut events = nodes[1].node.get_and_clear_pending_msg_events();
+ assert_eq!(events.len(), 1);
+ SendEvent::from_event(events.remove(0))
+ };
+ nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
+ do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event.commitment_msg, false, true);
+ if idx == num_mpp_parts - 1 {
+ expect_pending_htlcs_forwardable!(nodes[2]);
+ }
+ }
+
+ // Claim the payment and check that the skimmed fee is as expected.
+ let payment_preimage = nodes[2].node.get_payment_preimage(payment_hash, payment_secret).unwrap();
+ let events = nodes[2].node.get_and_clear_pending_events();
+ assert_eq!(events.len(), 1);
+ match events[0] {
+ crate::events::Event::PaymentClaimable {
+ ref payment_hash, ref purpose, amount_msat, counterparty_skimmed_fee_msat, receiver_node_id, ..
+ } => {
+ assert_eq!(payment_hash, payment_hash);
+ assert_eq!(amt_msat - skimmed_fee_msat * num_mpp_parts as u64, amount_msat);
+ assert_eq!(skimmed_fee_msat * num_mpp_parts as u64, counterparty_skimmed_fee_msat);
+ assert_eq!(nodes[2].node.get_our_node_id(), receiver_node_id.unwrap());
+ match purpose {
+ crate::events::PaymentPurpose::InvoicePayment { payment_preimage: ev_payment_preimage,
+ payment_secret: ev_payment_secret, .. } =>
+ {
+ assert_eq!(payment_preimage, ev_payment_preimage.unwrap());
+ assert_eq!(payment_secret, *ev_payment_secret);
+ },
+ _ => panic!(),
+ }
+ },
+ _ => panic!("Unexpected event"),
+ }
+ let mut expected_paths_vecs = Vec::new();
+ let mut expected_paths = Vec::new();
+ for _ in 0..num_mpp_parts { expected_paths_vecs.push(vec!(&nodes[1], &nodes[2])); }
+ for i in 0..num_mpp_parts { expected_paths.push(&expected_paths_vecs[i][..]); }
+ let total_fee_msat = do_claim_payment_along_route_with_extra_penultimate_hop_fees(
+ &nodes[0], &expected_paths[..], &vec![skimmed_fee_msat as u32; num_mpp_parts][..], false,
+ payment_preimage);
+ // The sender doesn't know that the penultimate hop took an extra fee.
+ expect_payment_sent(&nodes[0], payment_preimage,
+ Some(Some(total_fee_msat - skimmed_fee_msat * num_mpp_parts as u64)), true);
+}
+
#[derive(PartialEq)]
enum AutoRetry {
Success,