1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
11 use crate::blinded_path::BlindedPath;
12 use crate::blinded_path::payment::{ForwardNode, ForwardTlvs, PaymentConstraints, PaymentRelay, ReceiveTlvs};
13 use crate::events::{Event, HTLCDestination, MessageSendEvent, MessageSendEventsProvider, PaymentFailureReason};
14 use crate::ln::PaymentSecret;
15 use crate::ln::channelmanager;
16 use crate::ln::channelmanager::{PaymentId, RecipientOnionFields};
17 use crate::ln::features::BlindedHopFeatures;
18 use crate::ln::functional_test_utils::*;
20 use crate::ln::msgs::ChannelMessageHandler;
21 use crate::ln::onion_utils;
22 use crate::ln::onion_utils::INVALID_ONION_BLINDING;
23 use crate::ln::outbound_payment::{Retry, IDEMPOTENCY_TIMEOUT_TICKS};
24 use crate::offers::invoice::BlindedPayInfo;
25 use crate::prelude::*;
26 use crate::routing::router::{Payee, PaymentParameters, RouteParameters};
27 use crate::util::config::UserConfig;
28 use crate::util::test_utils;
30 fn blinded_payment_path(
31 payment_secret: PaymentSecret, intro_node_min_htlc: u64, intro_node_max_htlc: u64,
32 node_ids: Vec<PublicKey>, channel_upds: &[&msgs::UnsignedChannelUpdate],
33 keys_manager: &test_utils::TestKeysInterface
34 ) -> (BlindedPayInfo, BlindedPath) {
35 let mut intermediate_nodes = Vec::new();
36 let mut intro_node_min_htlc_opt = Some(intro_node_min_htlc);
37 let mut intro_node_max_htlc_opt = Some(intro_node_max_htlc);
38 for (idx, (node_id, chan_upd)) in node_ids.iter().zip(channel_upds).enumerate() {
39 intermediate_nodes.push(ForwardNode {
42 short_channel_id: chan_upd.short_channel_id,
43 payment_relay: PaymentRelay {
44 cltv_expiry_delta: chan_upd.cltv_expiry_delta,
45 fee_proportional_millionths: chan_upd.fee_proportional_millionths,
46 fee_base_msat: chan_upd.fee_base_msat,
48 payment_constraints: PaymentConstraints {
49 max_cltv_expiry: u32::max_value(),
50 htlc_minimum_msat: intro_node_min_htlc_opt.take()
51 .unwrap_or_else(|| channel_upds[idx - 1].htlc_minimum_msat),
53 features: BlindedHopFeatures::empty(),
55 htlc_maximum_msat: intro_node_max_htlc_opt.take()
56 .unwrap_or_else(|| channel_upds[idx - 1].htlc_maximum_msat),
59 let payee_tlvs = ReceiveTlvs {
61 payment_constraints: PaymentConstraints {
62 max_cltv_expiry: u32::max_value(),
64 intro_node_min_htlc_opt.unwrap_or_else(|| channel_upds.last().unwrap().htlc_minimum_msat),
67 let mut secp_ctx = Secp256k1::new();
68 BlindedPath::new_for_payment(
69 &intermediate_nodes[..], *node_ids.last().unwrap(), payee_tlvs,
70 intro_node_max_htlc_opt.unwrap_or_else(|| channel_upds.last().unwrap().htlc_maximum_msat),
71 TEST_FINAL_CLTV as u16, keys_manager, &secp_ctx
75 pub fn get_blinded_route_parameters(
76 amt_msat: u64, payment_secret: PaymentSecret, intro_node_min_htlc: u64, intro_node_max_htlc: u64,
77 node_ids: Vec<PublicKey>, channel_upds: &[&msgs::UnsignedChannelUpdate],
78 keys_manager: &test_utils::TestKeysInterface
79 ) -> RouteParameters {
80 RouteParameters::from_payment_params_and_value(
81 PaymentParameters::blinded(vec![
83 payment_secret, intro_node_min_htlc, intro_node_max_htlc, node_ids, channel_upds,
91 fn one_hop_blinded_path() {
92 do_one_hop_blinded_path(true);
93 do_one_hop_blinded_path(false);
96 fn do_one_hop_blinded_path(success: bool) {
97 let chanmon_cfgs = create_chanmon_cfgs(2);
98 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
99 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
100 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
101 let chan_upd = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0).0.contents;
104 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[1], Some(amt_msat), None);
105 let payee_tlvs = ReceiveTlvs {
107 payment_constraints: PaymentConstraints {
108 max_cltv_expiry: u32::max_value(),
109 htlc_minimum_msat: chan_upd.htlc_minimum_msat,
112 let mut secp_ctx = Secp256k1::new();
113 let blinded_path = BlindedPath::one_hop_for_payment(
114 nodes[1].node.get_our_node_id(), payee_tlvs, TEST_FINAL_CLTV as u16,
115 &chanmon_cfgs[1].keys_manager, &secp_ctx
118 let route_params = RouteParameters::from_payment_params_and_value(
119 PaymentParameters::blinded(vec![blinded_path]),
122 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(),
123 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
124 check_added_monitors(&nodes[0], 1);
125 pass_along_route(&nodes[0], &[&[&nodes[1]]], amt_msat, payment_hash, payment_secret);
127 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
129 fail_payment(&nodes[0], &[&nodes[1]], payment_hash);
134 fn mpp_to_one_hop_blinded_path() {
135 let chanmon_cfgs = create_chanmon_cfgs(4);
136 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
137 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
138 let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
139 let mut secp_ctx = Secp256k1::new();
141 create_announced_chan_between_nodes(&nodes, 0, 1);
142 create_announced_chan_between_nodes(&nodes, 0, 2);
143 let chan_upd_1_3 = create_announced_chan_between_nodes(&nodes, 1, 3).0.contents;
144 create_announced_chan_between_nodes(&nodes, 2, 3).0.contents;
146 let amt_msat = 15_000_000;
147 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
148 let payee_tlvs = ReceiveTlvs {
150 payment_constraints: PaymentConstraints {
151 max_cltv_expiry: u32::max_value(),
152 htlc_minimum_msat: chan_upd_1_3.htlc_minimum_msat,
155 let blinded_path = BlindedPath::one_hop_for_payment(
156 nodes[3].node.get_our_node_id(), payee_tlvs, TEST_FINAL_CLTV as u16,
157 &chanmon_cfgs[3].keys_manager, &secp_ctx
160 let bolt12_features =
161 channelmanager::provided_bolt12_invoice_features(&UserConfig::default());
162 let route_params = RouteParameters::from_payment_params_and_value(
163 PaymentParameters::blinded(vec![blinded_path]).with_bolt12_features(bolt12_features).unwrap(),
166 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
167 check_added_monitors(&nodes[0], 2);
169 let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]];
170 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
171 assert_eq!(events.len(), 2);
173 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
174 pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash.clone(),
175 Some(payment_secret), ev.clone(), false, None);
177 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
178 pass_along_path(&nodes[0], expected_route[1], amt_msat, payment_hash.clone(),
179 Some(payment_secret), ev.clone(), true, None);
180 claim_payment_along_route(&nodes[0], expected_route, false, payment_preimage);
184 fn mpp_to_three_hop_blinded_paths() {
185 let chanmon_cfgs = create_chanmon_cfgs(6);
186 let node_cfgs = create_node_cfgs(6, &chanmon_cfgs);
187 let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &[None, None, None, None, None, None]);
188 let nodes = create_network(6, &node_cfgs, &node_chanmgrs);
190 // Create this network topology so node 0 MPP's over 2 3-hop blinded paths:
196 create_announced_chan_between_nodes(&nodes, 0, 1);
197 create_announced_chan_between_nodes(&nodes, 0, 2);
198 let chan_upd_1_3 = create_announced_chan_between_nodes(&nodes, 1, 3).0.contents;
199 let chan_upd_2_4 = create_announced_chan_between_nodes(&nodes, 2, 4).0.contents;
200 let chan_upd_3_5 = create_announced_chan_between_nodes(&nodes, 3, 5).0.contents;
201 let chan_upd_4_5 = create_announced_chan_between_nodes(&nodes, 4, 5).0.contents;
203 let amt_msat = 15_000_000;
204 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[5], Some(amt_msat), None);
206 let path_1_params = get_blinded_route_parameters(
207 amt_msat, payment_secret, 1, 1_0000_0000, vec![
208 nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id(),
209 nodes[5].node.get_our_node_id()
210 ], &[&chan_upd_1_3, &chan_upd_3_5], &chanmon_cfgs[5].keys_manager
212 let path_2_params = get_blinded_route_parameters(
213 amt_msat, payment_secret, 1, 1_0000_0000, vec![
214 nodes[2].node.get_our_node_id(), nodes[4].node.get_our_node_id(),
215 nodes[5].node.get_our_node_id()
216 ], &[&chan_upd_2_4, &chan_upd_4_5], &chanmon_cfgs[5].keys_manager
218 let pay_params = PaymentParameters::blinded(
220 path_1_params.payment_params.payee.blinded_route_hints()[0].clone(),
221 path_2_params.payment_params.payee.blinded_route_hints()[0].clone()
224 .with_bolt12_features(channelmanager::provided_bolt12_invoice_features(&UserConfig::default()))
226 RouteParameters::from_payment_params_and_value(pay_params, amt_msat)
229 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(),
230 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
231 check_added_monitors(&nodes[0], 2);
233 let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[3], &nodes[5]], &[&nodes[2], &nodes[4], &nodes[5]]];
234 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
235 assert_eq!(events.len(), 2);
237 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
238 pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash.clone(),
239 Some(payment_secret), ev.clone(), false, None);
241 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
242 pass_along_path(&nodes[0], expected_route[1], amt_msat, payment_hash.clone(),
243 Some(payment_secret), ev.clone(), true, None);
244 claim_payment_along_route(&nodes[0], expected_route, false, payment_preimage);
247 enum ForwardCheckFail {
248 // Fail a check on the inbound onion payload. In this case, we underflow when calculating the
249 // outgoing cltv_expiry.
251 // The forwarding node's payload is encoded as a receive, i.e. the next hop HMAC is [0; 32].
252 ForwardPayloadEncodedAsReceive,
253 // Fail a check on the outbound channel. In this case, our next-hop peer is offline.
254 OutboundChannelCheck,
258 fn forward_checks_failure() {
259 do_forward_checks_failure(ForwardCheckFail::InboundOnionCheck, true);
260 do_forward_checks_failure(ForwardCheckFail::InboundOnionCheck, false);
261 do_forward_checks_failure(ForwardCheckFail::ForwardPayloadEncodedAsReceive, true);
262 do_forward_checks_failure(ForwardCheckFail::ForwardPayloadEncodedAsReceive, false);
263 do_forward_checks_failure(ForwardCheckFail::OutboundChannelCheck, true);
264 do_forward_checks_failure(ForwardCheckFail::OutboundChannelCheck, false);
267 fn do_forward_checks_failure(check: ForwardCheckFail, intro_fails: bool) {
268 // Ensure we'll fail backwards properly if a forwarding check fails on initial update_add
270 let chanmon_cfgs = create_chanmon_cfgs(4);
271 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
272 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
273 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
274 // We need the session priv to construct a bogus onion packet later.
275 *nodes[0].keys_manager.override_random_bytes.lock().unwrap() = Some([3; 32]);
276 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
277 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
278 let chan_upd_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0).0.contents;
281 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
282 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
283 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(),
284 &[&chan_upd_1_2, &chan_upd_2_3], &chanmon_cfgs[3].keys_manager);
286 let route = get_route(&nodes[0], &route_params).unwrap();
287 node_cfgs[0].router.expect_find_route(route_params.clone(), Ok(route.clone()));
288 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
289 check_added_monitors(&nodes[0], 1);
291 macro_rules! cause_error {
292 ($src_node_idx: expr, $target_node_idx: expr, $update_add: expr) => {
294 ForwardCheckFail::InboundOnionCheck => {
295 $update_add.cltv_expiry = 10; // causes outbound CLTV expiry to underflow
297 ForwardCheckFail::ForwardPayloadEncodedAsReceive => {
298 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
299 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
300 let cur_height = nodes[0].best_block_info().1;
301 let (mut onion_payloads, ..) = onion_utils::build_onion_payloads(
302 &route.paths[0], amt_msat, RecipientOnionFields::spontaneous_empty(), cur_height, &None).unwrap();
303 // Remove the receive payload so the blinded forward payload is encoded as a final payload
304 // (i.e. next_hop_hmac == [0; 32])
305 onion_payloads.pop();
306 if $target_node_idx + 1 < nodes.len() {
307 onion_payloads.pop();
309 $update_add.onion_routing_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash).unwrap();
311 ForwardCheckFail::OutboundChannelCheck => {
312 // The intro node will see that the next-hop peer is disconnected and fail the HTLC backwards.
313 nodes[$src_node_idx].node.peer_disconnected(&nodes[$target_node_idx].node.get_our_node_id());
319 let mut updates_0_1 = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
320 let update_add = &mut updates_0_1.update_add_htlcs[0];
323 cause_error!(1, 2, update_add);
326 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &update_add);
327 check_added_monitors!(nodes[1], 0);
328 do_commitment_signed_dance(&nodes[1], &nodes[0], &updates_0_1.commitment_signed, true, true);
331 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
332 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
333 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
334 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
335 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
339 expect_pending_htlcs_forwardable!(nodes[1]);
340 check_added_monitors!(nodes[1], 1);
342 let mut updates_1_2 = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
343 let mut update_add = &mut updates_1_2.update_add_htlcs[0];
345 cause_error!(2, 3, update_add);
347 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add);
348 check_added_monitors!(nodes[2], 0);
349 do_commitment_signed_dance(&nodes[2], &nodes[1], &updates_1_2.commitment_signed, true, true);
351 let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
352 let update_malformed = &mut updates.update_fail_malformed_htlcs[0];
353 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
354 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
356 // Ensure the intro node will properly blind the error if its downstream node failed to do so.
357 update_malformed.sha256_of_onion = [1; 32];
358 update_malformed.failure_code = INVALID_ONION_BLINDING ^ 1;
359 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
360 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates.commitment_signed, true, false);
362 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
363 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
364 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
365 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
366 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
370 fn failed_backwards_to_intro_node() {
371 // Ensure the intro node will error backwards properly even if the downstream node did not blind
373 let chanmon_cfgs = create_chanmon_cfgs(3);
374 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
375 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
376 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
377 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
378 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
381 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
382 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
383 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2],
384 &chanmon_cfgs[2].keys_manager);
386 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
387 check_added_monitors(&nodes[0], 1);
389 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
390 assert_eq!(events.len(), 1);
391 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
392 let mut payment_event = SendEvent::from_event(ev);
394 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
395 check_added_monitors!(nodes[1], 0);
396 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event.commitment_msg, false, false);
397 expect_pending_htlcs_forwardable!(nodes[1]);
398 check_added_monitors!(&nodes[1], 1);
400 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
401 assert_eq!(events.len(), 1);
402 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
403 let mut payment_event = SendEvent::from_event(ev);
405 // Ensure the final node fails to handle the HTLC.
406 payment_event.msgs[0].onion_routing_packet.hop_data[0] ^= 1;
407 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
408 check_added_monitors!(nodes[2], 0);
409 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event.commitment_msg, true, true);
410 nodes[2].node.process_pending_htlc_forwards();
412 let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
413 let mut update_malformed = &mut updates.update_fail_malformed_htlcs[0];
414 // Check that the final node encodes its failure correctly.
415 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
416 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
418 // Modify such the final hop does not correctly blind their error so we can ensure the intro node
419 // converts it to the correct error.
420 update_malformed.sha256_of_onion = [1; 32];
421 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
422 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates.commitment_signed, true, false);
424 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
425 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
426 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
427 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
428 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
431 enum ProcessPendingHTLCsCheck {
437 fn forward_fail_in_process_pending_htlc_fwds() {
438 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdPeerDisconnected, true);
439 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdPeerDisconnected, false);
440 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdChannelClosed, true);
441 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdChannelClosed, false);
443 fn do_forward_fail_in_process_pending_htlc_fwds(check: ProcessPendingHTLCsCheck, intro_fails: bool) {
444 // Ensure the intro node will error backwards properly if the HTLC fails in
445 // process_pending_htlc_forwards.
446 let chanmon_cfgs = create_chanmon_cfgs(4);
447 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
448 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
449 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
450 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
451 let (chan_upd_1_2, chan_id_1_2) = {
452 let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
453 (chan.0.contents, chan.2)
455 let (chan_upd_2_3, chan_id_2_3) = {
456 let chan = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
457 (chan.0.contents, chan.2)
460 let error_message = "Channel force-closed";
462 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
463 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
464 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2, &chan_upd_2_3],
465 &chanmon_cfgs[2].keys_manager);
467 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
468 check_added_monitors(&nodes[0], 1);
470 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
471 assert_eq!(events.len(), 1);
472 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
473 let mut payment_event = SendEvent::from_event(ev);
475 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
476 check_added_monitors!(nodes[1], 0);
477 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event.commitment_msg, false, false);
479 macro_rules! cause_error {
480 ($prev_node: expr, $curr_node: expr, $next_node: expr, $failed_chan_id: expr, $failed_scid: expr) => {
482 ProcessPendingHTLCsCheck::FwdPeerDisconnected => {
483 // Disconnect the next-hop peer so when we go to forward in process_pending_htlc_forwards, the
484 // intro node will error backwards.
485 $curr_node.node.peer_disconnected(&$next_node.node.get_our_node_id());
486 expect_pending_htlcs_forwardable!($curr_node);
487 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!($curr_node,
488 vec![HTLCDestination::NextHopChannel { node_id: Some($next_node.node.get_our_node_id()), channel_id: $failed_chan_id }]);
490 ProcessPendingHTLCsCheck::FwdChannelClosed => {
491 // Force close the next-hop channel so when we go to forward in process_pending_htlc_forwards,
492 // the intro node will error backwards.
493 $curr_node.node.force_close_broadcasting_latest_txn(&$failed_chan_id, &$next_node.node.get_our_node_id(), error_message.to_string()).unwrap();
494 let events = $curr_node.node.get_and_clear_pending_events();
496 crate::events::Event::PendingHTLCsForwardable { .. } => {},
497 _ => panic!("Unexpected event {:?}", events),
500 crate::events::Event::ChannelClosed { .. } => {},
501 _ => panic!("Unexpected event {:?}", events),
504 $curr_node.node.process_pending_htlc_forwards();
505 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!($curr_node,
506 vec![HTLCDestination::UnknownNextHop { requested_forward_scid: $failed_scid }]);
507 check_closed_broadcast(&$curr_node, 1, true);
508 check_added_monitors!($curr_node, 1);
509 $curr_node.node.process_pending_htlc_forwards();
516 cause_error!(nodes[0], nodes[1], nodes[2], chan_id_1_2, chan_upd_1_2.short_channel_id);
517 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
518 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
519 check_added_monitors!(nodes[1], 1);
520 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
522 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
523 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
527 expect_pending_htlcs_forwardable!(nodes[1]);
528 check_added_monitors!(nodes[1], 1);
530 let mut updates_1_2 = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
531 let mut update_add = &mut updates_1_2.update_add_htlcs[0];
532 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add);
533 check_added_monitors!(nodes[2], 0);
534 do_commitment_signed_dance(&nodes[2], &nodes[1], &updates_1_2.commitment_signed, true, true);
536 cause_error!(nodes[1], nodes[2], nodes[3], chan_id_2_3, chan_upd_2_3.short_channel_id);
537 check_added_monitors!(nodes[2], 1);
539 let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
540 let update_malformed = &mut updates.update_fail_malformed_htlcs[0];
541 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
542 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
544 // Ensure the intro node will properly blind the error if its downstream node failed to do so.
545 update_malformed.sha256_of_onion = [1; 32];
546 update_malformed.failure_code = INVALID_ONION_BLINDING ^ 1;
547 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
548 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates.commitment_signed, true, false);
550 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
551 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
552 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
553 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
554 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
558 fn blinded_intercept_payment() {
559 do_blinded_intercept_payment(true);
560 do_blinded_intercept_payment(false);
562 fn do_blinded_intercept_payment(intercept_node_fails: bool) {
563 let chanmon_cfgs = create_chanmon_cfgs(3);
564 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
565 let mut intercept_forwards_config = test_default_channel_config();
566 intercept_forwards_config.accept_intercept_htlcs = true;
567 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(intercept_forwards_config), None]);
568 let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
569 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
570 let (channel_id, chan_upd) = {
571 let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
572 (chan.2, chan.0.contents)
576 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
577 let intercept_scid = nodes[1].node.get_intercept_scid();
578 let mut intercept_chan_upd = chan_upd;
579 intercept_chan_upd.short_channel_id = intercept_scid;
580 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
581 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&intercept_chan_upd],
582 &chanmon_cfgs[2].keys_manager);
584 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(),
585 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
586 check_added_monitors(&nodes[0], 1);
587 let payment_event = {
588 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
589 assert_eq!(events.len(), 1);
590 SendEvent::from_event(events.remove(0))
592 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
593 commitment_signed_dance!(nodes[1], nodes[0], &payment_event.commitment_msg, false, true);
595 let events = nodes[1].node.get_and_clear_pending_events();
596 assert_eq!(events.len(), 1);
597 let (intercept_id, expected_outbound_amount_msat) = match events[0] {
598 crate::events::Event::HTLCIntercepted {
599 intercept_id, payment_hash: pmt_hash,
600 requested_next_hop_scid: short_channel_id, expected_outbound_amount_msat, ..
602 assert_eq!(pmt_hash, payment_hash);
603 assert_eq!(short_channel_id, intercept_scid);
604 (intercept_id, expected_outbound_amount_msat)
609 if intercept_node_fails {
610 nodes[1].node.fail_intercepted_htlc(intercept_id).unwrap();
611 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(nodes[1], vec![HTLCDestination::UnknownNextHop { requested_forward_scid: intercept_scid }]);
612 nodes[1].node.process_pending_htlc_forwards();
613 let update_fail = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
614 check_added_monitors!(&nodes[1], 1);
615 assert!(update_fail.update_fail_htlcs.len() == 1);
616 let fail_msg = update_fail.update_fail_htlcs[0].clone();
617 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_msg);
618 commitment_signed_dance!(nodes[0], nodes[1], update_fail.commitment_signed, false);
619 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
620 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
624 nodes[1].node.forward_intercepted_htlc(intercept_id, &channel_id, nodes[2].node.get_our_node_id(), expected_outbound_amount_msat).unwrap();
625 expect_pending_htlcs_forwardable!(nodes[1]);
627 let payment_event = {
629 let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
630 assert_eq!(added_monitors.len(), 1);
631 added_monitors.clear();
633 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
634 assert_eq!(events.len(), 1);
635 SendEvent::from_event(events.remove(0))
637 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
638 commitment_signed_dance!(nodes[2], nodes[1], &payment_event.commitment_msg, false, true);
639 expect_pending_htlcs_forwardable!(nodes[2]);
641 expect_payment_claimable!(&nodes[2], payment_hash, payment_secret, amt_msat, None, nodes[2].node.get_our_node_id());
642 do_claim_payment_along_route(&nodes[0], &vec!(&vec!(&nodes[1], &nodes[2])[..]), false, payment_preimage);
643 expect_payment_sent(&nodes[0], payment_preimage, Some(Some(1000)), true, true);
647 fn two_hop_blinded_path_success() {
648 let chanmon_cfgs = create_chanmon_cfgs(3);
649 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
650 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
651 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
652 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
653 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
656 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
657 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
658 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2],
659 &chanmon_cfgs[2].keys_manager);
661 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
662 check_added_monitors(&nodes[0], 1);
663 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], amt_msat, payment_hash, payment_secret);
664 claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
668 fn three_hop_blinded_path_success() {
669 let chanmon_cfgs = create_chanmon_cfgs(5);
670 let node_cfgs = create_node_cfgs(5, &chanmon_cfgs);
671 let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &[None, None, None, None, None]);
672 let mut nodes = create_network(5, &node_cfgs, &node_chanmgrs);
673 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
674 create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
675 let chan_upd_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0).0.contents;
676 let chan_upd_3_4 = create_announced_chan_between_nodes_with_value(&nodes, 3, 4, 1_000_000, 0).0.contents;
678 // Get all our nodes onto the same height so payments don't fail for CLTV violations.
679 connect_blocks(&nodes[0], nodes[4].best_block_info().1 - nodes[0].best_block_info().1);
680 connect_blocks(&nodes[1], nodes[4].best_block_info().1 - nodes[1].best_block_info().1);
681 connect_blocks(&nodes[2], nodes[4].best_block_info().1 - nodes[2].best_block_info().1);
682 assert_eq!(nodes[4].best_block_info().1, nodes[3].best_block_info().1);
685 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[4], Some(amt_msat), None);
686 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
687 nodes.iter().skip(2).map(|n| n.node.get_our_node_id()).collect(),
688 &[&chan_upd_2_3, &chan_upd_3_4], &chanmon_cfgs[4].keys_manager);
690 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
691 check_added_monitors(&nodes[0], 1);
692 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3], &nodes[4]]], amt_msat, payment_hash, payment_secret);
693 claim_payment(&nodes[0], &[&nodes[1], &nodes[2], &nodes[3], &nodes[4]], payment_preimage);
697 fn three_hop_blinded_path_fail() {
698 // Test that an intermediate blinded forwarding node gets failed back to with
699 // malformed and also fails back themselves with malformed.
700 let chanmon_cfgs = create_chanmon_cfgs(4);
701 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
702 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
703 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
704 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
705 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
706 let chan_upd_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0).0.contents;
709 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
710 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
711 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(),
712 &[&chan_upd_1_2, &chan_upd_2_3], &chanmon_cfgs[3].keys_manager);
714 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
715 check_added_monitors(&nodes[0], 1);
716 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3]]], amt_msat, payment_hash, payment_secret);
718 nodes[3].node.fail_htlc_backwards(&payment_hash);
719 expect_pending_htlcs_forwardable_conditions(
720 nodes[3].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }]
722 nodes[3].node.process_pending_htlc_forwards();
723 check_added_monitors!(nodes[3], 1);
725 let updates_3_2 = get_htlc_update_msgs!(nodes[3], nodes[2].node.get_our_node_id());
726 assert_eq!(updates_3_2.update_fail_malformed_htlcs.len(), 1);
727 let update_malformed = &updates_3_2.update_fail_malformed_htlcs[0];
728 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
729 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
730 nodes[2].node.handle_update_fail_malformed_htlc(&nodes[3].node.get_our_node_id(), update_malformed);
731 do_commitment_signed_dance(&nodes[2], &nodes[3], &updates_3_2.commitment_signed, true, false);
733 let updates_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
734 assert_eq!(updates_2_1.update_fail_malformed_htlcs.len(), 1);
735 let update_malformed = &updates_2_1.update_fail_malformed_htlcs[0];
736 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
737 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
738 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
739 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates_2_1.commitment_signed, true, false);
741 let updates_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
742 assert_eq!(updates_1_0.update_fail_htlcs.len(), 1);
743 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_1_0.update_fail_htlcs[0]);
744 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates_1_0.commitment_signed, false, false);
745 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
746 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
750 enum ReceiveCheckFail {
751 // The recipient fails the payment upon `PaymentClaimable`.
753 // Failure to decode the recipient's onion payload.
755 // The incoming HTLC did not satisfy our requirements; in this case it underpaid us according to
756 // the expected receive amount in the onion.
758 // The incoming HTLC errors when added to the Channel, in this case due to the HTLC being
759 // delivered out-of-order with a shutdown message.
761 // The HTLC is successfully added to the inbound channel but fails receive checks in
762 // process_pending_htlc_forwards.
763 ProcessPendingHTLCsCheck,
764 // The HTLC violates the `PaymentConstraints` contained within the receiver's encrypted payload.
769 fn multi_hop_receiver_fail() {
770 do_multi_hop_receiver_fail(ReceiveCheckFail::RecipientFail);
771 do_multi_hop_receiver_fail(ReceiveCheckFail::OnionDecodeFail);
772 do_multi_hop_receiver_fail(ReceiveCheckFail::ReceiveRequirements);
773 do_multi_hop_receiver_fail(ReceiveCheckFail::ChannelCheck);
774 do_multi_hop_receiver_fail(ReceiveCheckFail::ProcessPendingHTLCsCheck);
775 do_multi_hop_receiver_fail(ReceiveCheckFail::PaymentConstraints);
778 fn do_multi_hop_receiver_fail(check: ReceiveCheckFail) {
779 // Test that the receiver to a multihop blinded path fails back correctly.
780 let chanmon_cfgs = create_chanmon_cfgs(3);
781 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
782 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
783 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
784 // We need the session priv to construct an invalid onion packet later.
785 let session_priv = [3; 32];
786 *nodes[0].keys_manager.override_random_bytes.lock().unwrap() = Some(session_priv);
787 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
788 let (chan_upd_1_2, chan_id_1_2) = {
789 let (chan_upd, _, channel_id, ..) = create_announced_chan_between_nodes_with_value(
790 &nodes, 1, 2, 1_000_000, 0
792 (chan_upd.contents, channel_id)
796 let excess_final_cltv_delta_opt = if check == ReceiveCheckFail::ProcessPendingHTLCsCheck {
797 // Set the final CLTV expiry too low to trigger the failure in process_pending_htlc_forwards.
798 Some(TEST_FINAL_CLTV as u16 - 2)
800 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), excess_final_cltv_delta_opt);
801 let mut route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
802 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2],
803 &chanmon_cfgs[2].keys_manager);
805 let route = if check == ReceiveCheckFail::ProcessPendingHTLCsCheck {
806 let mut route = get_route(&nodes[0], &route_params).unwrap();
807 // Set the final CLTV expiry too low to trigger the failure in process_pending_htlc_forwards.
808 route.paths[0].hops.last_mut().map(|h| h.cltv_expiry_delta += excess_final_cltv_delta_opt.unwrap() as u32);
809 route.paths[0].blinded_tail.as_mut().map(|bt| bt.excess_final_cltv_expiry_delta = excess_final_cltv_delta_opt.unwrap() as u32);
811 } else if check == ReceiveCheckFail::PaymentConstraints {
812 // Create a blinded path where the receiver's encrypted payload has an htlc_minimum_msat that is
813 // violated by `amt_msat`, and stick it in the route_params without changing the corresponding
814 // BlindedPayInfo (to ensure pathfinding still succeeds).
815 let high_htlc_min_bp = {
816 let mut high_htlc_minimum_upd = chan_upd_1_2.clone();
817 high_htlc_minimum_upd.htlc_minimum_msat = amt_msat + 1000;
818 let high_htlc_min_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
819 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&high_htlc_minimum_upd],
820 &chanmon_cfgs[2].keys_manager);
821 if let Payee::Blinded { route_hints, .. } = high_htlc_min_params.payment_params.payee {
822 route_hints[0].1.clone()
825 if let Payee::Blinded { ref mut route_hints, .. } = route_params.payment_params.payee {
826 route_hints[0].1 = high_htlc_min_bp;
828 find_route(&nodes[0], &route_params).unwrap()
830 find_route(&nodes[0], &route_params).unwrap()
832 node_cfgs[0].router.expect_find_route(route_params.clone(), Ok(route.clone()));
833 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
834 check_added_monitors(&nodes[0], 1);
836 let mut payment_event_0_1 = {
837 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
838 assert_eq!(events.len(), 1);
839 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
840 SendEvent::from_event(ev)
842 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_0_1.msgs[0]);
843 check_added_monitors!(nodes[1], 0);
844 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event_0_1.commitment_msg, false, false);
845 expect_pending_htlcs_forwardable!(nodes[1]);
846 check_added_monitors!(&nodes[1], 1);
848 let mut payment_event_1_2 = {
849 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
850 assert_eq!(events.len(), 1);
851 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
852 SendEvent::from_event(ev)
856 ReceiveCheckFail::RecipientFail => {
857 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
858 check_added_monitors!(nodes[2], 0);
859 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
860 expect_pending_htlcs_forwardable!(nodes[2]);
861 check_payment_claimable(
862 &nodes[2].node.get_and_clear_pending_events()[0], payment_hash, payment_secret, amt_msat,
863 None, nodes[2].node.get_our_node_id()
865 nodes[2].node.fail_htlc_backwards(&payment_hash);
866 expect_pending_htlcs_forwardable_conditions(
867 nodes[2].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }]
869 nodes[2].node.process_pending_htlc_forwards();
870 check_added_monitors!(nodes[2], 1);
872 ReceiveCheckFail::OnionDecodeFail => {
873 let session_priv = SecretKey::from_slice(&session_priv).unwrap();
874 let mut onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
875 let cur_height = nodes[0].best_block_info().1;
876 let (mut onion_payloads, ..) = onion_utils::build_onion_payloads(
877 &route.paths[0], amt_msat, RecipientOnionFields::spontaneous_empty(), cur_height, &None).unwrap();
879 let update_add = &mut payment_event_1_2.msgs[0];
880 onion_payloads.last_mut().map(|p| {
881 if let msgs::OutboundOnionPayload::BlindedReceive { ref mut intro_node_blinding_point, .. } = p {
882 // The receiver should error if both the update_add blinding_point and the
883 // intro_node_blinding_point are set.
884 assert!(intro_node_blinding_point.is_none() && update_add.blinding_point.is_some());
885 *intro_node_blinding_point = Some(PublicKey::from_slice(&[2; 33]).unwrap());
888 update_add.onion_routing_packet = onion_utils::construct_onion_packet(
889 vec![onion_payloads.pop().unwrap()], vec![onion_keys.pop().unwrap()], [0; 32],
892 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), update_add);
893 check_added_monitors!(nodes[2], 0);
894 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
896 ReceiveCheckFail::ReceiveRequirements => {
897 let update_add = &mut payment_event_1_2.msgs[0];
898 update_add.amount_msat -= 1;
899 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), update_add);
900 check_added_monitors!(nodes[2], 0);
901 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
903 ReceiveCheckFail::ChannelCheck => {
904 nodes[2].node.close_channel(&chan_id_1_2, &nodes[1].node.get_our_node_id()).unwrap();
905 let node_2_shutdown = get_event_msg!(nodes[2], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
906 nodes[1].node.handle_shutdown(&nodes[2].node.get_our_node_id(), &node_2_shutdown);
907 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
909 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
910 nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event_1_2.commitment_msg);
911 check_added_monitors!(nodes[2], 1);
913 nodes[2].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
914 commitment_signed_dance!(nodes[2], nodes[1], (), false, true, false, false);
916 ReceiveCheckFail::ProcessPendingHTLCsCheck => {
917 assert_eq!(payment_event_1_2.msgs[0].cltv_expiry, nodes[0].best_block_info().1 + 1 + excess_final_cltv_delta_opt.unwrap() as u32 + TEST_FINAL_CLTV);
918 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
919 check_added_monitors!(nodes[2], 0);
920 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
921 expect_pending_htlcs_forwardable!(nodes[2]);
922 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(nodes[2],
923 vec![HTLCDestination::FailedPayment { payment_hash }]);
924 check_added_monitors!(nodes[2], 1);
926 ReceiveCheckFail::PaymentConstraints => {
927 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
928 check_added_monitors!(nodes[2], 0);
929 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
933 let updates_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
934 assert_eq!(updates_2_1.update_fail_malformed_htlcs.len(), 1);
935 let update_malformed = &updates_2_1.update_fail_malformed_htlcs[0];
936 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
937 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
938 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
939 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates_2_1.commitment_signed, true, false);
941 let updates_1_0 = if check == ReceiveCheckFail::ChannelCheck {
942 let events = nodes[1].node.get_and_clear_pending_msg_events();
943 assert_eq!(events.len(), 2);
944 events.into_iter().find_map(|ev| {
946 MessageSendEvent:: UpdateHTLCs { node_id, updates } => {
947 assert_eq!(node_id, nodes[0].node.get_our_node_id());
950 MessageSendEvent::SendClosingSigned { .. } => None,
954 } else { get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()) };
955 assert_eq!(updates_1_0.update_fail_htlcs.len(), 1);
956 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_1_0.update_fail_htlcs[0]);
957 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates_1_0.commitment_signed, false, false);
958 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
959 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
963 fn blinded_path_retries() {
964 let chanmon_cfgs = create_chanmon_cfgs(4);
965 // Make one blinded path's fees slightly higher so they are tried in a deterministic order.
966 let mut higher_fee_chan_cfg = test_default_channel_config();
967 higher_fee_chan_cfg.channel_config.forwarding_fee_base_msat += 1;
968 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
969 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, Some(higher_fee_chan_cfg), None]);
970 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
972 // Create this network topology so nodes[0] has a blinded route hint to retry over.
978 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
979 create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1_000_000, 0);
980 let chan_1_3 = create_announced_chan_between_nodes_with_value(&nodes, 1, 3, 1_000_000, 0);
981 let chan_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
984 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
986 let pay_params = PaymentParameters::blinded(
988 blinded_payment_path(payment_secret, 1, 1_0000_0000,
989 vec![nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_1_3.0.contents],
990 &chanmon_cfgs[3].keys_manager
992 blinded_payment_path(payment_secret, 1, 1_0000_0000,
993 vec![nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_2_3.0.contents],
994 &chanmon_cfgs[3].keys_manager
998 .with_bolt12_features(channelmanager::provided_bolt12_invoice_features(&UserConfig::default()))
1000 RouteParameters::from_payment_params_and_value(pay_params, amt_msat)
1003 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params.clone(), Retry::Attempts(2)).unwrap();
1004 check_added_monitors(&nodes[0], 1);
1005 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[3]]], amt_msat, payment_hash, payment_secret);
1007 macro_rules! fail_payment_back {
1008 ($intro_node: expr) => {
1009 nodes[3].node.fail_htlc_backwards(&payment_hash);
1010 expect_pending_htlcs_forwardable_conditions(
1011 nodes[3].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }]
1013 nodes[3].node.process_pending_htlc_forwards();
1014 check_added_monitors!(nodes[3], 1);
1016 let updates = get_htlc_update_msgs!(nodes[3], $intro_node.node.get_our_node_id());
1017 assert_eq!(updates.update_fail_malformed_htlcs.len(), 1);
1018 let update_malformed = &updates.update_fail_malformed_htlcs[0];
1019 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
1020 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
1021 $intro_node.node.handle_update_fail_malformed_htlc(&nodes[3].node.get_our_node_id(), update_malformed);
1022 do_commitment_signed_dance(&$intro_node, &nodes[3], &updates.commitment_signed, true, false);
1024 let updates = get_htlc_update_msgs!($intro_node, nodes[0].node.get_our_node_id());
1025 assert_eq!(updates.update_fail_htlcs.len(), 1);
1026 nodes[0].node.handle_update_fail_htlc(&$intro_node.node.get_our_node_id(), &updates.update_fail_htlcs[0]);
1027 do_commitment_signed_dance(&nodes[0], &$intro_node, &updates.commitment_signed, false, false);
1029 let mut events = nodes[0].node.get_and_clear_pending_events();
1030 assert_eq!(events.len(), 2);
1032 Event::PaymentPathFailed { payment_hash: ev_payment_hash, payment_failed_permanently, .. } => {
1033 assert_eq!(payment_hash, ev_payment_hash);
1034 assert_eq!(payment_failed_permanently, false);
1036 _ => panic!("Unexpected event"),
1039 Event::PendingHTLCsForwardable { .. } => {},
1040 _ => panic!("Unexpected event"),
1042 nodes[0].node.process_pending_htlc_forwards();
1046 fail_payment_back!(nodes[1]);
1048 // Pass the retry along.
1049 check_added_monitors!(nodes[0], 1);
1050 let mut msg_events = nodes[0].node.get_and_clear_pending_msg_events();
1051 assert_eq!(msg_events.len(), 1);
1052 pass_along_path(&nodes[0], &[&nodes[2], &nodes[3]], amt_msat, payment_hash, Some(payment_secret), msg_events.pop().unwrap(), true, None);
1054 fail_payment_back!(nodes[2]);
1055 let evs = nodes[0].node.get_and_clear_pending_events();
1056 assert_eq!(evs.len(), 1);
1058 Event::PaymentFailed { payment_hash: ev_payment_hash, reason, .. } => {
1059 assert_eq!(ev_payment_hash, payment_hash);
1060 // We have 1 retry attempt remaining, but we're out of blinded paths to try.
1061 assert_eq!(reason, Some(PaymentFailureReason::RouteNotFound));
1069 // The min htlc of a blinded path is the max (htlc_min - following_fees) along the path. Make sure
1070 // the payment succeeds when we calculate the min htlc this way.
1071 let chanmon_cfgs = create_chanmon_cfgs(4);
1072 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
1073 let mut node_1_cfg = test_default_channel_config();
1074 node_1_cfg.channel_handshake_config.our_htlc_minimum_msat = 2000;
1075 node_1_cfg.channel_config.forwarding_fee_base_msat = 1000;
1076 node_1_cfg.channel_config.forwarding_fee_proportional_millionths = 100_000;
1077 let mut node_2_cfg = test_default_channel_config();
1078 node_2_cfg.channel_handshake_config.our_htlc_minimum_msat = 5000;
1079 node_2_cfg.channel_config.forwarding_fee_base_msat = 200;
1080 node_2_cfg.channel_config.forwarding_fee_proportional_millionths = 150_000;
1081 let mut node_3_cfg = test_default_channel_config();
1082 node_3_cfg.channel_handshake_config.our_htlc_minimum_msat = 2000;
1083 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, Some(node_1_cfg), Some(node_2_cfg), Some(node_3_cfg)]);
1084 let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
1085 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
1086 let chan_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
1087 let chan_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
1089 let min_htlc_msat = {
1090 // The min htlc for this setup is nodes[2]'s htlc_minimum_msat minus the
1092 let post_base_fee = chan_2_3.1.contents.htlc_minimum_msat - chan_2_3.0.contents.fee_base_msat as u64;
1093 let prop_fee = chan_2_3.0.contents.fee_proportional_millionths as u64;
1094 (post_base_fee * 1_000_000 + 1_000_000 + prop_fee - 1) / (prop_fee + 1_000_000)
1096 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(min_htlc_msat), None);
1097 let mut route_params = get_blinded_route_parameters(
1098 min_htlc_msat, payment_secret, chan_1_2.1.contents.htlc_minimum_msat,
1099 chan_1_2.1.contents.htlc_maximum_msat, vec![nodes[1].node.get_our_node_id(),
1100 nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()],
1101 &[&chan_1_2.0.contents, &chan_2_3.0.contents], &chanmon_cfgs[3].keys_manager);
1102 assert_eq!(min_htlc_msat,
1103 route_params.payment_params.payee.blinded_route_hints()[0].0.htlc_minimum_msat);
1105 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params.clone(), Retry::Attempts(0)).unwrap();
1106 check_added_monitors(&nodes[0], 1);
1107 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3]]], min_htlc_msat, payment_hash, payment_secret);
1108 claim_payment(&nodes[0], &[&nodes[1], &nodes[2], &nodes[3]], payment_preimage);
1110 // Paying 1 less than the min fails.
1111 for _ in 0..IDEMPOTENCY_TIMEOUT_TICKS + 1 {
1112 nodes[0].node.timer_tick_occurred();
1114 if let Payee::Blinded { ref mut route_hints, .. } = route_params.payment_params.payee {
1115 route_hints[0].0.htlc_minimum_msat -= 1;
1117 route_params.final_value_msat -= 1;
1118 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
1119 check_added_monitors(&nodes[0], 1);
1121 let mut payment_event_0_1 = {
1122 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1123 assert_eq!(events.len(), 1);
1124 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
1125 SendEvent::from_event(ev)
1127 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_0_1.msgs[0]);
1128 check_added_monitors!(nodes[1], 0);
1129 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event_0_1.commitment_msg, true, true);
1130 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1131 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
1132 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
1133 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
1134 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
1138 fn conditionally_round_fwd_amt() {
1139 // Previously, the (rng-found) feerates below caught a bug where an intermediate node would
1140 // calculate an amt_to_forward that underpaid them by 1 msat, caused by rounding up the outbound
1141 // amount on top of an already rounded-up total routing fee. Ensure that we'll conditionally round
1142 // down intermediate nodes' outbound amounts based on whether rounding up will result in
1143 // undercharging for relay.
1144 let chanmon_cfgs = create_chanmon_cfgs(5);
1145 let node_cfgs = create_node_cfgs(5, &chanmon_cfgs);
1147 let mut node_1_cfg = test_default_channel_config();
1148 node_1_cfg.channel_config.forwarding_fee_base_msat = 247371;
1149 node_1_cfg.channel_config.forwarding_fee_proportional_millionths = 86552;
1151 let mut node_2_cfg = test_default_channel_config();
1152 node_2_cfg.channel_config.forwarding_fee_base_msat = 198921;
1153 node_2_cfg.channel_config.forwarding_fee_proportional_millionths = 681759;
1155 let mut node_3_cfg = test_default_channel_config();
1156 node_3_cfg.channel_config.forwarding_fee_base_msat = 132845;
1157 node_3_cfg.channel_config.forwarding_fee_proportional_millionths = 552561;
1159 let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &[None, Some(node_1_cfg), Some(node_2_cfg), Some(node_3_cfg), None]);
1160 let nodes = create_network(5, &node_cfgs, &node_chanmgrs);
1161 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
1162 let chan_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
1163 let chan_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
1164 let chan_3_4 = create_announced_chan_between_nodes_with_value(&nodes, 3, 4, 1_000_000, 0);
1166 let amt_msat = 100_000;
1167 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[4], Some(amt_msat), None);
1168 let mut route_params = get_blinded_route_parameters(amt_msat, payment_secret,
1169 chan_1_2.1.contents.htlc_minimum_msat, chan_1_2.1.contents.htlc_maximum_msat,
1170 vec![nodes[1].node.get_our_node_id(), nodes[2].node.get_our_node_id(),
1171 nodes[3].node.get_our_node_id(), nodes[4].node.get_our_node_id()],
1172 &[&chan_1_2.0.contents, &chan_2_3.0.contents, &chan_3_4.0.contents],
1173 &chanmon_cfgs[4].keys_manager);
1174 route_params.max_total_routing_fee_msat = None;
1176 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
1177 check_added_monitors(&nodes[0], 1);
1178 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3], &nodes[4]]], amt_msat, payment_hash, payment_secret);
1179 nodes[4].node.claim_funds(payment_preimage);
1180 let expected_path = &[&nodes[1], &nodes[2], &nodes[3], &nodes[4]];
1181 let expected_route = &[&expected_path[..]];
1182 let mut args = ClaimAlongRouteArgs::new(&nodes[0], &expected_route[..], payment_preimage)
1183 .allow_1_msat_fee_overpay();
1184 let expected_fee = pass_claimed_payment_along_route(args);
1185 expect_payment_sent(&nodes[0], payment_preimage, Some(Some(expected_fee)), true, true);
1189 fn blinded_keysend() {
1190 let mut mpp_keysend_config = test_default_channel_config();
1191 mpp_keysend_config.accept_mpp_keysend = true;
1192 let chanmon_cfgs = create_chanmon_cfgs(3);
1193 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1194 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, Some(mpp_keysend_config)]);
1195 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1196 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
1197 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
1199 let amt_msat = 5000;
1200 let (keysend_preimage, _, payment_secret) = get_payment_preimage_hash(&nodes[2], None, None);
1201 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1,
1203 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(),
1204 &[&chan_upd_1_2], &chanmon_cfgs[2].keys_manager);
1206 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();
1207 check_added_monitors(&nodes[0], 1);
1209 let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[2]]];
1210 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1211 assert_eq!(events.len(), 1);
1213 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
1214 pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash, Some(payment_secret), ev.clone(), true, Some(keysend_preimage));
1215 claim_payment_along_route(&nodes[0], expected_route, false, keysend_preimage);
1219 fn blinded_mpp_keysend() {
1220 let mut mpp_keysend_config = test_default_channel_config();
1221 mpp_keysend_config.accept_mpp_keysend = true;
1222 let chanmon_cfgs = create_chanmon_cfgs(4);
1223 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
1224 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, Some(mpp_keysend_config)]);
1225 let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
1227 create_announced_chan_between_nodes(&nodes, 0, 1);
1228 create_announced_chan_between_nodes(&nodes, 0, 2);
1229 let chan_1_3 = create_announced_chan_between_nodes(&nodes, 1, 3);
1230 let chan_2_3 = create_announced_chan_between_nodes(&nodes, 2, 3);
1232 let amt_msat = 15_000_000;
1233 let (keysend_preimage, _, payment_secret) = get_payment_preimage_hash(&nodes[3], None, None);
1234 let route_params = {
1235 let pay_params = PaymentParameters::blinded(
1237 blinded_payment_path(payment_secret, 1, 1_0000_0000,
1238 vec![nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_1_3.0.contents],
1239 &chanmon_cfgs[3].keys_manager
1241 blinded_payment_path(payment_secret, 1, 1_0000_0000,
1242 vec![nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_2_3.0.contents],
1243 &chanmon_cfgs[3].keys_manager
1247 .with_bolt12_features(channelmanager::provided_bolt12_invoice_features(&UserConfig::default()))
1249 RouteParameters::from_payment_params_and_value(pay_params, amt_msat)
1252 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();
1253 check_added_monitors!(nodes[0], 2);
1255 let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]];
1256 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1257 assert_eq!(events.len(), 2);
1259 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
1260 pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash.clone(),
1261 Some(payment_secret), ev.clone(), false, Some(keysend_preimage));
1263 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
1264 pass_along_path(&nodes[0], expected_route[1], amt_msat, payment_hash.clone(),
1265 Some(payment_secret), ev.clone(), true, Some(keysend_preimage));
1266 claim_payment_along_route(&nodes[0], expected_route, false, keysend_preimage);
1270 fn custom_tlvs_to_blinded_path() {
1271 let chanmon_cfgs = create_chanmon_cfgs(2);
1272 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1273 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1274 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1275 let chan_upd = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0).0.contents;
1277 let amt_msat = 5000;
1278 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[1], Some(amt_msat), None);
1279 let payee_tlvs = ReceiveTlvs {
1281 payment_constraints: PaymentConstraints {
1282 max_cltv_expiry: u32::max_value(),
1283 htlc_minimum_msat: chan_upd.htlc_minimum_msat,
1286 let mut secp_ctx = Secp256k1::new();
1287 let blinded_path = BlindedPath::one_hop_for_payment(
1288 nodes[1].node.get_our_node_id(), payee_tlvs, TEST_FINAL_CLTV as u16,
1289 &chanmon_cfgs[1].keys_manager, &secp_ctx
1292 let route_params = RouteParameters::from_payment_params_and_value(
1293 PaymentParameters::blinded(vec![blinded_path]),
1297 let recipient_onion_fields = RecipientOnionFields::spontaneous_empty()
1298 .with_custom_tlvs(vec![((1 << 16) + 1, vec![42, 42])])
1300 nodes[0].node.send_payment(payment_hash, recipient_onion_fields.clone(),
1301 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
1302 check_added_monitors(&nodes[0], 1);
1304 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1305 assert_eq!(events.len(), 1);
1306 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
1308 let path = &[&nodes[1]];
1309 let args = PassAlongPathArgs::new(&nodes[0], path, amt_msat, payment_hash, ev)
1310 .with_payment_secret(payment_secret)
1311 .with_custom_tlvs(recipient_onion_fields.custom_tlvs.clone());
1312 do_pass_along_path(args);
1313 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);