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, PaymentContext, PaymentRelay, ReceiveTlvs};
13 use crate::events::{Event, HTLCDestination, MessageSendEvent, MessageSendEventsProvider, PaymentFailureReason};
14 use crate::ln::types::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),
66 payment_context: PaymentContext::unknown(),
68 let mut secp_ctx = Secp256k1::new();
69 BlindedPath::new_for_payment(
70 &intermediate_nodes[..], *node_ids.last().unwrap(), payee_tlvs,
71 intro_node_max_htlc_opt.unwrap_or_else(|| channel_upds.last().unwrap().htlc_maximum_msat),
72 TEST_FINAL_CLTV as u16, keys_manager, &secp_ctx
76 pub fn get_blinded_route_parameters(
77 amt_msat: u64, payment_secret: PaymentSecret, intro_node_min_htlc: u64, intro_node_max_htlc: u64,
78 node_ids: Vec<PublicKey>, channel_upds: &[&msgs::UnsignedChannelUpdate],
79 keys_manager: &test_utils::TestKeysInterface
80 ) -> RouteParameters {
81 RouteParameters::from_payment_params_and_value(
82 PaymentParameters::blinded(vec![
84 payment_secret, intro_node_min_htlc, intro_node_max_htlc, node_ids, channel_upds,
92 fn one_hop_blinded_path() {
93 do_one_hop_blinded_path(true);
94 do_one_hop_blinded_path(false);
97 fn do_one_hop_blinded_path(success: bool) {
98 let chanmon_cfgs = create_chanmon_cfgs(2);
99 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
100 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
101 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
102 let chan_upd = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0).0.contents;
105 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[1], Some(amt_msat), None);
106 let payee_tlvs = ReceiveTlvs {
108 payment_constraints: PaymentConstraints {
109 max_cltv_expiry: u32::max_value(),
110 htlc_minimum_msat: chan_upd.htlc_minimum_msat,
112 payment_context: PaymentContext::unknown(),
114 let mut secp_ctx = Secp256k1::new();
115 let blinded_path = BlindedPath::one_hop_for_payment(
116 nodes[1].node.get_our_node_id(), payee_tlvs, TEST_FINAL_CLTV as u16,
117 &chanmon_cfgs[1].keys_manager, &secp_ctx
120 let route_params = RouteParameters::from_payment_params_and_value(
121 PaymentParameters::blinded(vec![blinded_path]),
124 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(),
125 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
126 check_added_monitors(&nodes[0], 1);
127 pass_along_route(&nodes[0], &[&[&nodes[1]]], amt_msat, payment_hash, payment_secret);
129 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
131 fail_payment(&nodes[0], &[&nodes[1]], payment_hash);
136 fn mpp_to_one_hop_blinded_path() {
137 let chanmon_cfgs = create_chanmon_cfgs(4);
138 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
139 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
140 let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
141 let mut secp_ctx = Secp256k1::new();
143 create_announced_chan_between_nodes(&nodes, 0, 1);
144 create_announced_chan_between_nodes(&nodes, 0, 2);
145 let chan_upd_1_3 = create_announced_chan_between_nodes(&nodes, 1, 3).0.contents;
146 create_announced_chan_between_nodes(&nodes, 2, 3).0.contents;
148 let amt_msat = 15_000_000;
149 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
150 let payee_tlvs = ReceiveTlvs {
152 payment_constraints: PaymentConstraints {
153 max_cltv_expiry: u32::max_value(),
154 htlc_minimum_msat: chan_upd_1_3.htlc_minimum_msat,
156 payment_context: PaymentContext::unknown(),
158 let blinded_path = BlindedPath::one_hop_for_payment(
159 nodes[3].node.get_our_node_id(), payee_tlvs, TEST_FINAL_CLTV as u16,
160 &chanmon_cfgs[3].keys_manager, &secp_ctx
163 let bolt12_features =
164 channelmanager::provided_bolt12_invoice_features(&UserConfig::default());
165 let route_params = RouteParameters::from_payment_params_and_value(
166 PaymentParameters::blinded(vec![blinded_path]).with_bolt12_features(bolt12_features).unwrap(),
169 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
170 check_added_monitors(&nodes[0], 2);
172 let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]];
173 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
174 assert_eq!(events.len(), 2);
176 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
177 pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash.clone(),
178 Some(payment_secret), ev.clone(), false, None);
180 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
181 pass_along_path(&nodes[0], expected_route[1], amt_msat, payment_hash.clone(),
182 Some(payment_secret), ev.clone(), true, None);
183 claim_payment_along_route(
184 ClaimAlongRouteArgs::new(&nodes[0], expected_route, payment_preimage)
189 fn mpp_to_three_hop_blinded_paths() {
190 let chanmon_cfgs = create_chanmon_cfgs(6);
191 let node_cfgs = create_node_cfgs(6, &chanmon_cfgs);
192 let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &[None, None, None, None, None, None]);
193 let nodes = create_network(6, &node_cfgs, &node_chanmgrs);
195 // Create this network topology so node 0 MPP's over 2 3-hop blinded paths:
201 create_announced_chan_between_nodes(&nodes, 0, 1);
202 create_announced_chan_between_nodes(&nodes, 0, 2);
203 let chan_upd_1_3 = create_announced_chan_between_nodes(&nodes, 1, 3).0.contents;
204 let chan_upd_2_4 = create_announced_chan_between_nodes(&nodes, 2, 4).0.contents;
205 let chan_upd_3_5 = create_announced_chan_between_nodes(&nodes, 3, 5).0.contents;
206 let chan_upd_4_5 = create_announced_chan_between_nodes(&nodes, 4, 5).0.contents;
208 let amt_msat = 15_000_000;
209 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[5], Some(amt_msat), None);
211 let path_1_params = get_blinded_route_parameters(
212 amt_msat, payment_secret, 1, 1_0000_0000, vec![
213 nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id(),
214 nodes[5].node.get_our_node_id()
215 ], &[&chan_upd_1_3, &chan_upd_3_5], &chanmon_cfgs[5].keys_manager
217 let path_2_params = get_blinded_route_parameters(
218 amt_msat, payment_secret, 1, 1_0000_0000, vec![
219 nodes[2].node.get_our_node_id(), nodes[4].node.get_our_node_id(),
220 nodes[5].node.get_our_node_id()
221 ], &[&chan_upd_2_4, &chan_upd_4_5], &chanmon_cfgs[5].keys_manager
223 let pay_params = PaymentParameters::blinded(
225 path_1_params.payment_params.payee.blinded_route_hints()[0].clone(),
226 path_2_params.payment_params.payee.blinded_route_hints()[0].clone()
229 .with_bolt12_features(channelmanager::provided_bolt12_invoice_features(&UserConfig::default()))
231 RouteParameters::from_payment_params_and_value(pay_params, amt_msat)
234 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(),
235 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
236 check_added_monitors(&nodes[0], 2);
238 let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[3], &nodes[5]], &[&nodes[2], &nodes[4], &nodes[5]]];
239 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
240 assert_eq!(events.len(), 2);
242 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
243 pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash.clone(),
244 Some(payment_secret), ev.clone(), false, None);
246 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
247 pass_along_path(&nodes[0], expected_route[1], amt_msat, payment_hash.clone(),
248 Some(payment_secret), ev.clone(), true, None);
249 claim_payment_along_route(
250 ClaimAlongRouteArgs::new(&nodes[0], expected_route, payment_preimage)
254 enum ForwardCheckFail {
255 // Fail a check on the inbound onion payload. In this case, we underflow when calculating the
256 // outgoing cltv_expiry.
258 // The forwarding node's payload is encoded as a receive, i.e. the next hop HMAC is [0; 32].
259 ForwardPayloadEncodedAsReceive,
260 // Fail a check on the outbound channel. In this case, our next-hop peer is offline.
261 OutboundChannelCheck,
265 fn forward_checks_failure() {
266 do_forward_checks_failure(ForwardCheckFail::InboundOnionCheck, true);
267 do_forward_checks_failure(ForwardCheckFail::InboundOnionCheck, false);
268 do_forward_checks_failure(ForwardCheckFail::ForwardPayloadEncodedAsReceive, true);
269 do_forward_checks_failure(ForwardCheckFail::ForwardPayloadEncodedAsReceive, false);
270 do_forward_checks_failure(ForwardCheckFail::OutboundChannelCheck, true);
271 do_forward_checks_failure(ForwardCheckFail::OutboundChannelCheck, false);
274 fn do_forward_checks_failure(check: ForwardCheckFail, intro_fails: bool) {
275 // Ensure we'll fail backwards properly if a forwarding check fails on initial update_add
277 let chanmon_cfgs = create_chanmon_cfgs(4);
278 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
279 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
280 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
281 // We need the session priv to construct a bogus onion packet later.
282 *nodes[0].keys_manager.override_random_bytes.lock().unwrap() = Some([3; 32]);
283 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
284 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
285 let chan_upd_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0).0.contents;
288 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
289 let mut route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
290 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(),
291 &[&chan_upd_1_2, &chan_upd_2_3], &chanmon_cfgs[3].keys_manager);
292 route_params.payment_params.max_path_length = 18;
294 let route = get_route(&nodes[0], &route_params).unwrap();
295 node_cfgs[0].router.expect_find_route(route_params.clone(), Ok(route.clone()));
296 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
297 check_added_monitors(&nodes[0], 1);
299 macro_rules! cause_error {
300 ($src_node_idx: expr, $target_node_idx: expr, $update_add: expr) => {
302 ForwardCheckFail::InboundOnionCheck => {
303 $update_add.cltv_expiry = 10; // causes outbound CLTV expiry to underflow
305 ForwardCheckFail::ForwardPayloadEncodedAsReceive => {
306 let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
307 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
308 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
309 let cur_height = nodes[0].best_block_info().1;
310 let (mut onion_payloads, ..) = onion_utils::build_onion_payloads(
311 &route.paths[0], amt_msat, &recipient_onion_fields, cur_height, &None).unwrap();
312 // Remove the receive payload so the blinded forward payload is encoded as a final payload
313 // (i.e. next_hop_hmac == [0; 32])
314 onion_payloads.pop();
315 if $target_node_idx + 1 < nodes.len() {
316 onion_payloads.pop();
318 $update_add.onion_routing_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash).unwrap();
320 ForwardCheckFail::OutboundChannelCheck => {
321 // The intro node will see that the next-hop peer is disconnected and fail the HTLC backwards.
322 nodes[$src_node_idx].node.peer_disconnected(&nodes[$target_node_idx].node.get_our_node_id());
328 let mut updates_0_1 = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
329 let update_add = &mut updates_0_1.update_add_htlcs[0];
332 cause_error!(1, 2, update_add);
335 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &update_add);
336 check_added_monitors!(nodes[1], 0);
337 do_commitment_signed_dance(&nodes[1], &nodes[0], &updates_0_1.commitment_signed, true, true);
340 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
341 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
342 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
343 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
344 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
348 expect_pending_htlcs_forwardable!(nodes[1]);
349 check_added_monitors!(nodes[1], 1);
351 let mut updates_1_2 = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
352 let mut update_add = &mut updates_1_2.update_add_htlcs[0];
354 cause_error!(2, 3, update_add);
356 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add);
357 check_added_monitors!(nodes[2], 0);
358 do_commitment_signed_dance(&nodes[2], &nodes[1], &updates_1_2.commitment_signed, true, true);
360 let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
361 let update_malformed = &mut updates.update_fail_malformed_htlcs[0];
362 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
363 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
365 // Ensure the intro node will properly blind the error if its downstream node failed to do so.
366 update_malformed.sha256_of_onion = [1; 32];
367 update_malformed.failure_code = INVALID_ONION_BLINDING ^ 1;
368 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
369 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates.commitment_signed, true, false);
371 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
372 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
373 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
374 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
375 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
379 fn failed_backwards_to_intro_node() {
380 // Ensure the intro node will error backwards properly even if the downstream node did not blind
382 let chanmon_cfgs = create_chanmon_cfgs(3);
383 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
384 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
385 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
386 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
387 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
390 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
391 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
392 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2],
393 &chanmon_cfgs[2].keys_manager);
395 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
396 check_added_monitors(&nodes[0], 1);
398 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
399 assert_eq!(events.len(), 1);
400 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
401 let mut payment_event = SendEvent::from_event(ev);
403 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
404 check_added_monitors!(nodes[1], 0);
405 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event.commitment_msg, false, false);
406 expect_pending_htlcs_forwardable!(nodes[1]);
407 check_added_monitors!(&nodes[1], 1);
409 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
410 assert_eq!(events.len(), 1);
411 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
412 let mut payment_event = SendEvent::from_event(ev);
414 // Ensure the final node fails to handle the HTLC.
415 payment_event.msgs[0].onion_routing_packet.hop_data[0] ^= 1;
416 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
417 check_added_monitors!(nodes[2], 0);
418 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event.commitment_msg, true, true);
419 nodes[2].node.process_pending_htlc_forwards();
421 let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
422 let mut update_malformed = &mut updates.update_fail_malformed_htlcs[0];
423 // Check that the final node encodes its failure correctly.
424 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
425 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
427 // Modify such the final hop does not correctly blind their error so we can ensure the intro node
428 // converts it to the correct error.
429 update_malformed.sha256_of_onion = [1; 32];
430 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
431 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates.commitment_signed, true, false);
433 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
434 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
435 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
436 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
437 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
440 enum ProcessPendingHTLCsCheck {
446 fn forward_fail_in_process_pending_htlc_fwds() {
447 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdPeerDisconnected, true);
448 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdPeerDisconnected, false);
449 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdChannelClosed, true);
450 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdChannelClosed, false);
452 fn do_forward_fail_in_process_pending_htlc_fwds(check: ProcessPendingHTLCsCheck, intro_fails: bool) {
453 // Ensure the intro node will error backwards properly if the HTLC fails in
454 // process_pending_htlc_forwards.
455 let chanmon_cfgs = create_chanmon_cfgs(4);
456 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
457 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
458 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
459 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
460 let (chan_upd_1_2, chan_id_1_2) = {
461 let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
462 (chan.0.contents, chan.2)
464 let (chan_upd_2_3, chan_id_2_3) = {
465 let chan = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
466 (chan.0.contents, chan.2)
469 let error_message = "Channel force-closed";
471 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
472 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
473 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2, &chan_upd_2_3],
474 &chanmon_cfgs[2].keys_manager);
476 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
477 check_added_monitors(&nodes[0], 1);
479 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
480 assert_eq!(events.len(), 1);
481 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
482 let mut payment_event = SendEvent::from_event(ev);
484 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
485 check_added_monitors!(nodes[1], 0);
486 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event.commitment_msg, false, false);
488 macro_rules! cause_error {
489 ($prev_node: expr, $curr_node: expr, $next_node: expr, $failed_chan_id: expr, $failed_scid: expr) => {
491 ProcessPendingHTLCsCheck::FwdPeerDisconnected => {
492 // Disconnect the next-hop peer so when we go to forward in process_pending_htlc_forwards, the
493 // intro node will error backwards.
494 $curr_node.node.peer_disconnected(&$next_node.node.get_our_node_id());
495 expect_pending_htlcs_forwardable!($curr_node);
496 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!($curr_node,
497 vec![HTLCDestination::NextHopChannel { node_id: Some($next_node.node.get_our_node_id()), channel_id: $failed_chan_id }]);
499 ProcessPendingHTLCsCheck::FwdChannelClosed => {
500 // Force close the next-hop channel so when we go to forward in process_pending_htlc_forwards,
501 // the intro node will error backwards.
502 $curr_node.node.force_close_broadcasting_latest_txn(&$failed_chan_id, &$next_node.node.get_our_node_id(), error_message.to_string()).unwrap();
503 let events = $curr_node.node.get_and_clear_pending_events();
505 crate::events::Event::PendingHTLCsForwardable { .. } => {},
506 _ => panic!("Unexpected event {:?}", events),
509 crate::events::Event::ChannelClosed { .. } => {},
510 _ => panic!("Unexpected event {:?}", events),
513 $curr_node.node.process_pending_htlc_forwards();
514 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!($curr_node,
515 vec![HTLCDestination::UnknownNextHop { requested_forward_scid: $failed_scid }]);
516 check_closed_broadcast(&$curr_node, 1, true);
517 check_added_monitors!($curr_node, 1);
518 $curr_node.node.process_pending_htlc_forwards();
525 cause_error!(nodes[0], nodes[1], nodes[2], chan_id_1_2, chan_upd_1_2.short_channel_id);
526 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
527 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
528 check_added_monitors!(nodes[1], 1);
529 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
531 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
532 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
536 expect_pending_htlcs_forwardable!(nodes[1]);
537 check_added_monitors!(nodes[1], 1);
539 let mut updates_1_2 = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
540 let mut update_add = &mut updates_1_2.update_add_htlcs[0];
541 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add);
542 check_added_monitors!(nodes[2], 0);
543 do_commitment_signed_dance(&nodes[2], &nodes[1], &updates_1_2.commitment_signed, true, true);
545 cause_error!(nodes[1], nodes[2], nodes[3], chan_id_2_3, chan_upd_2_3.short_channel_id);
546 check_added_monitors!(nodes[2], 1);
548 let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
549 let update_malformed = &mut updates.update_fail_malformed_htlcs[0];
550 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
551 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
553 // Ensure the intro node will properly blind the error if its downstream node failed to do so.
554 update_malformed.sha256_of_onion = [1; 32];
555 update_malformed.failure_code = INVALID_ONION_BLINDING ^ 1;
556 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
557 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates.commitment_signed, true, false);
559 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
560 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
561 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
562 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
563 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
567 fn blinded_intercept_payment() {
568 do_blinded_intercept_payment(true);
569 do_blinded_intercept_payment(false);
571 fn do_blinded_intercept_payment(intercept_node_fails: bool) {
572 let chanmon_cfgs = create_chanmon_cfgs(3);
573 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
574 let mut intercept_forwards_config = test_default_channel_config();
575 intercept_forwards_config.accept_intercept_htlcs = true;
576 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(intercept_forwards_config), None]);
577 let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
578 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
579 let (channel_id, chan_upd) = {
580 let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
581 (chan.2, chan.0.contents)
585 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
586 let intercept_scid = nodes[1].node.get_intercept_scid();
587 let mut intercept_chan_upd = chan_upd;
588 intercept_chan_upd.short_channel_id = intercept_scid;
589 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
590 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&intercept_chan_upd],
591 &chanmon_cfgs[2].keys_manager);
593 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(),
594 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
595 check_added_monitors(&nodes[0], 1);
596 let payment_event = {
597 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
598 assert_eq!(events.len(), 1);
599 SendEvent::from_event(events.remove(0))
601 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
602 commitment_signed_dance!(nodes[1], nodes[0], &payment_event.commitment_msg, false, true);
604 let events = nodes[1].node.get_and_clear_pending_events();
605 assert_eq!(events.len(), 1);
606 let (intercept_id, expected_outbound_amount_msat) = match events[0] {
607 crate::events::Event::HTLCIntercepted {
608 intercept_id, payment_hash: pmt_hash,
609 requested_next_hop_scid: short_channel_id, expected_outbound_amount_msat, ..
611 assert_eq!(pmt_hash, payment_hash);
612 assert_eq!(short_channel_id, intercept_scid);
613 (intercept_id, expected_outbound_amount_msat)
618 if intercept_node_fails {
619 nodes[1].node.fail_intercepted_htlc(intercept_id).unwrap();
620 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(nodes[1], vec![HTLCDestination::UnknownNextHop { requested_forward_scid: intercept_scid }]);
621 nodes[1].node.process_pending_htlc_forwards();
622 let update_fail = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
623 check_added_monitors!(&nodes[1], 1);
624 assert!(update_fail.update_fail_htlcs.len() == 1);
625 let fail_msg = update_fail.update_fail_htlcs[0].clone();
626 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_msg);
627 commitment_signed_dance!(nodes[0], nodes[1], update_fail.commitment_signed, false);
628 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
629 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
633 nodes[1].node.forward_intercepted_htlc(intercept_id, &channel_id, nodes[2].node.get_our_node_id(), expected_outbound_amount_msat).unwrap();
634 expect_pending_htlcs_forwardable!(nodes[1]);
636 let payment_event = {
638 let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
639 assert_eq!(added_monitors.len(), 1);
640 added_monitors.clear();
642 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
643 assert_eq!(events.len(), 1);
644 SendEvent::from_event(events.remove(0))
646 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
647 commitment_signed_dance!(nodes[2], nodes[1], &payment_event.commitment_msg, false, true);
648 expect_pending_htlcs_forwardable!(nodes[2]);
650 expect_payment_claimable!(&nodes[2], payment_hash, payment_secret, amt_msat, None, nodes[2].node.get_our_node_id());
651 do_claim_payment_along_route(
652 ClaimAlongRouteArgs::new(&nodes[0], &[&[&nodes[1], &nodes[2]]], payment_preimage)
654 expect_payment_sent(&nodes[0], payment_preimage, Some(Some(1000)), true, true);
658 fn two_hop_blinded_path_success() {
659 let chanmon_cfgs = create_chanmon_cfgs(3);
660 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
661 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
662 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
663 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
664 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
667 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
668 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
669 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2],
670 &chanmon_cfgs[2].keys_manager);
672 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
673 check_added_monitors(&nodes[0], 1);
674 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], amt_msat, payment_hash, payment_secret);
675 claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
679 fn three_hop_blinded_path_success() {
680 let chanmon_cfgs = create_chanmon_cfgs(5);
681 let node_cfgs = create_node_cfgs(5, &chanmon_cfgs);
682 let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &[None, None, None, None, None]);
683 let mut nodes = create_network(5, &node_cfgs, &node_chanmgrs);
684 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
685 create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
686 let chan_upd_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0).0.contents;
687 let chan_upd_3_4 = create_announced_chan_between_nodes_with_value(&nodes, 3, 4, 1_000_000, 0).0.contents;
689 // Get all our nodes onto the same height so payments don't fail for CLTV violations.
690 connect_blocks(&nodes[0], nodes[4].best_block_info().1 - nodes[0].best_block_info().1);
691 connect_blocks(&nodes[1], nodes[4].best_block_info().1 - nodes[1].best_block_info().1);
692 connect_blocks(&nodes[2], nodes[4].best_block_info().1 - nodes[2].best_block_info().1);
693 assert_eq!(nodes[4].best_block_info().1, nodes[3].best_block_info().1);
696 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[4], Some(amt_msat), None);
697 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
698 nodes.iter().skip(2).map(|n| n.node.get_our_node_id()).collect(),
699 &[&chan_upd_2_3, &chan_upd_3_4], &chanmon_cfgs[4].keys_manager);
701 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
702 check_added_monitors(&nodes[0], 1);
703 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3], &nodes[4]]], amt_msat, payment_hash, payment_secret);
704 claim_payment(&nodes[0], &[&nodes[1], &nodes[2], &nodes[3], &nodes[4]], payment_preimage);
708 fn three_hop_blinded_path_fail() {
709 // Test that an intermediate blinded forwarding node gets failed back to with
710 // malformed and also fails back themselves with malformed.
711 let chanmon_cfgs = create_chanmon_cfgs(4);
712 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
713 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
714 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
715 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
716 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
717 let chan_upd_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0).0.contents;
720 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
721 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
722 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(),
723 &[&chan_upd_1_2, &chan_upd_2_3], &chanmon_cfgs[3].keys_manager);
725 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
726 check_added_monitors(&nodes[0], 1);
727 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3]]], amt_msat, payment_hash, payment_secret);
729 nodes[3].node.fail_htlc_backwards(&payment_hash);
730 expect_pending_htlcs_forwardable_conditions(
731 nodes[3].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }]
733 nodes[3].node.process_pending_htlc_forwards();
734 check_added_monitors!(nodes[3], 1);
736 let updates_3_2 = get_htlc_update_msgs!(nodes[3], nodes[2].node.get_our_node_id());
737 assert_eq!(updates_3_2.update_fail_malformed_htlcs.len(), 1);
738 let update_malformed = &updates_3_2.update_fail_malformed_htlcs[0];
739 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
740 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
741 nodes[2].node.handle_update_fail_malformed_htlc(&nodes[3].node.get_our_node_id(), update_malformed);
742 do_commitment_signed_dance(&nodes[2], &nodes[3], &updates_3_2.commitment_signed, true, false);
744 let updates_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
745 assert_eq!(updates_2_1.update_fail_malformed_htlcs.len(), 1);
746 let update_malformed = &updates_2_1.update_fail_malformed_htlcs[0];
747 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
748 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
749 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
750 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates_2_1.commitment_signed, true, false);
752 let updates_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
753 assert_eq!(updates_1_0.update_fail_htlcs.len(), 1);
754 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_1_0.update_fail_htlcs[0]);
755 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates_1_0.commitment_signed, false, false);
756 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
757 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
761 enum ReceiveCheckFail {
762 // The recipient fails the payment upon `PaymentClaimable`.
764 // Failure to decode the recipient's onion payload.
766 // The incoming HTLC did not satisfy our requirements; in this case it underpaid us according to
767 // the expected receive amount in the onion.
769 // The incoming HTLC errors when added to the Channel, in this case due to the HTLC being
770 // delivered out-of-order with a shutdown message.
772 // The HTLC is successfully added to the inbound channel but fails receive checks in
773 // process_pending_htlc_forwards.
774 ProcessPendingHTLCsCheck,
775 // The HTLC violates the `PaymentConstraints` contained within the receiver's encrypted payload.
780 fn multi_hop_receiver_fail() {
781 do_multi_hop_receiver_fail(ReceiveCheckFail::RecipientFail);
782 do_multi_hop_receiver_fail(ReceiveCheckFail::OnionDecodeFail);
783 do_multi_hop_receiver_fail(ReceiveCheckFail::ReceiveRequirements);
784 do_multi_hop_receiver_fail(ReceiveCheckFail::ChannelCheck);
785 do_multi_hop_receiver_fail(ReceiveCheckFail::ProcessPendingHTLCsCheck);
786 do_multi_hop_receiver_fail(ReceiveCheckFail::PaymentConstraints);
789 fn do_multi_hop_receiver_fail(check: ReceiveCheckFail) {
790 // Test that the receiver to a multihop blinded path fails back correctly.
791 let chanmon_cfgs = create_chanmon_cfgs(3);
792 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
793 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
794 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
795 // We need the session priv to construct an invalid onion packet later.
796 let session_priv = [3; 32];
797 *nodes[0].keys_manager.override_random_bytes.lock().unwrap() = Some(session_priv);
798 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
799 let (chan_upd_1_2, chan_id_1_2) = {
800 let (chan_upd, _, channel_id, ..) = create_announced_chan_between_nodes_with_value(
801 &nodes, 1, 2, 1_000_000, 0
803 (chan_upd.contents, channel_id)
807 let excess_final_cltv_delta_opt = if check == ReceiveCheckFail::ProcessPendingHTLCsCheck {
808 // Set the final CLTV expiry too low to trigger the failure in process_pending_htlc_forwards.
809 Some(TEST_FINAL_CLTV as u16 - 2)
811 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), excess_final_cltv_delta_opt);
812 let mut route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
813 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2],
814 &chanmon_cfgs[2].keys_manager);
816 let route = if check == ReceiveCheckFail::ProcessPendingHTLCsCheck {
817 let mut route = get_route(&nodes[0], &route_params).unwrap();
818 // Set the final CLTV expiry too low to trigger the failure in process_pending_htlc_forwards.
819 route.paths[0].hops.last_mut().map(|h| h.cltv_expiry_delta += excess_final_cltv_delta_opt.unwrap() as u32);
820 route.paths[0].blinded_tail.as_mut().map(|bt| bt.excess_final_cltv_expiry_delta = excess_final_cltv_delta_opt.unwrap() as u32);
822 } else if check == ReceiveCheckFail::PaymentConstraints {
823 // Create a blinded path where the receiver's encrypted payload has an htlc_minimum_msat that is
824 // violated by `amt_msat`, and stick it in the route_params without changing the corresponding
825 // BlindedPayInfo (to ensure pathfinding still succeeds).
826 let high_htlc_min_bp = {
827 let mut high_htlc_minimum_upd = chan_upd_1_2.clone();
828 high_htlc_minimum_upd.htlc_minimum_msat = amt_msat + 1000;
829 let high_htlc_min_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
830 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&high_htlc_minimum_upd],
831 &chanmon_cfgs[2].keys_manager);
832 if let Payee::Blinded { route_hints, .. } = high_htlc_min_params.payment_params.payee {
833 route_hints[0].1.clone()
836 if let Payee::Blinded { ref mut route_hints, .. } = route_params.payment_params.payee {
837 route_hints[0].1 = high_htlc_min_bp;
839 find_route(&nodes[0], &route_params).unwrap()
841 find_route(&nodes[0], &route_params).unwrap()
843 node_cfgs[0].router.expect_find_route(route_params.clone(), Ok(route.clone()));
844 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
845 check_added_monitors(&nodes[0], 1);
847 let mut payment_event_0_1 = {
848 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
849 assert_eq!(events.len(), 1);
850 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
851 SendEvent::from_event(ev)
853 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_0_1.msgs[0]);
854 check_added_monitors!(nodes[1], 0);
855 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event_0_1.commitment_msg, false, false);
856 expect_pending_htlcs_forwardable!(nodes[1]);
857 check_added_monitors!(&nodes[1], 1);
859 let mut payment_event_1_2 = {
860 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
861 assert_eq!(events.len(), 1);
862 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
863 SendEvent::from_event(ev)
867 ReceiveCheckFail::RecipientFail => {
868 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
869 check_added_monitors!(nodes[2], 0);
870 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
871 expect_pending_htlcs_forwardable!(nodes[2]);
872 check_payment_claimable(
873 &nodes[2].node.get_and_clear_pending_events()[0], payment_hash, payment_secret, amt_msat,
874 None, nodes[2].node.get_our_node_id()
876 nodes[2].node.fail_htlc_backwards(&payment_hash);
877 expect_pending_htlcs_forwardable_conditions(
878 nodes[2].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }]
880 nodes[2].node.process_pending_htlc_forwards();
881 check_added_monitors!(nodes[2], 1);
883 ReceiveCheckFail::OnionDecodeFail => {
884 let session_priv = SecretKey::from_slice(&session_priv).unwrap();
885 let mut onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
886 let cur_height = nodes[0].best_block_info().1;
887 let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
888 let (mut onion_payloads, ..) = onion_utils::build_onion_payloads(
889 &route.paths[0], amt_msat, &recipient_onion_fields, cur_height, &None).unwrap();
891 let update_add = &mut payment_event_1_2.msgs[0];
892 onion_payloads.last_mut().map(|p| {
893 if let msgs::OutboundOnionPayload::BlindedReceive { ref mut intro_node_blinding_point, .. } = p {
894 // The receiver should error if both the update_add blinding_point and the
895 // intro_node_blinding_point are set.
896 assert!(intro_node_blinding_point.is_none() && update_add.blinding_point.is_some());
897 *intro_node_blinding_point = Some(PublicKey::from_slice(&[2; 33]).unwrap());
900 update_add.onion_routing_packet = onion_utils::construct_onion_packet(
901 vec![onion_payloads.pop().unwrap()], vec![onion_keys.pop().unwrap()], [0; 32],
904 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), update_add);
905 check_added_monitors!(nodes[2], 0);
906 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
908 ReceiveCheckFail::ReceiveRequirements => {
909 let update_add = &mut payment_event_1_2.msgs[0];
910 update_add.amount_msat -= 1;
911 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), update_add);
912 check_added_monitors!(nodes[2], 0);
913 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
915 ReceiveCheckFail::ChannelCheck => {
916 nodes[2].node.close_channel(&chan_id_1_2, &nodes[1].node.get_our_node_id()).unwrap();
917 let node_2_shutdown = get_event_msg!(nodes[2], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
918 nodes[1].node.handle_shutdown(&nodes[2].node.get_our_node_id(), &node_2_shutdown);
919 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
921 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
922 nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event_1_2.commitment_msg);
923 check_added_monitors!(nodes[2], 1);
925 nodes[2].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
926 commitment_signed_dance!(nodes[2], nodes[1], (), false, true, false, false);
928 ReceiveCheckFail::ProcessPendingHTLCsCheck => {
929 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);
930 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
931 check_added_monitors!(nodes[2], 0);
932 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
933 expect_pending_htlcs_forwardable!(nodes[2]);
934 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(nodes[2],
935 vec![HTLCDestination::FailedPayment { payment_hash }]);
936 check_added_monitors!(nodes[2], 1);
938 ReceiveCheckFail::PaymentConstraints => {
939 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
940 check_added_monitors!(nodes[2], 0);
941 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
945 let updates_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
946 assert_eq!(updates_2_1.update_fail_malformed_htlcs.len(), 1);
947 let update_malformed = &updates_2_1.update_fail_malformed_htlcs[0];
948 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
949 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
950 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
951 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates_2_1.commitment_signed, true, false);
953 let updates_1_0 = if check == ReceiveCheckFail::ChannelCheck {
954 let events = nodes[1].node.get_and_clear_pending_msg_events();
955 assert_eq!(events.len(), 2);
956 events.into_iter().find_map(|ev| {
958 MessageSendEvent:: UpdateHTLCs { node_id, updates } => {
959 assert_eq!(node_id, nodes[0].node.get_our_node_id());
962 MessageSendEvent::SendClosingSigned { .. } => None,
966 } else { get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()) };
967 assert_eq!(updates_1_0.update_fail_htlcs.len(), 1);
968 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_1_0.update_fail_htlcs[0]);
969 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates_1_0.commitment_signed, false, false);
970 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
971 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
975 fn blinded_path_retries() {
976 let chanmon_cfgs = create_chanmon_cfgs(4);
977 // Make one blinded path's fees slightly higher so they are tried in a deterministic order.
978 let mut higher_fee_chan_cfg = test_default_channel_config();
979 higher_fee_chan_cfg.channel_config.forwarding_fee_base_msat += 1;
980 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
981 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, Some(higher_fee_chan_cfg), None]);
982 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
984 // Create this network topology so nodes[0] has a blinded route hint to retry over.
990 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
991 create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1_000_000, 0);
992 let chan_1_3 = create_announced_chan_between_nodes_with_value(&nodes, 1, 3, 1_000_000, 0);
993 let chan_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
996 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
998 let pay_params = PaymentParameters::blinded(
1000 blinded_payment_path(payment_secret, 1, 1_0000_0000,
1001 vec![nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_1_3.0.contents],
1002 &chanmon_cfgs[3].keys_manager
1004 blinded_payment_path(payment_secret, 1, 1_0000_0000,
1005 vec![nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_2_3.0.contents],
1006 &chanmon_cfgs[3].keys_manager
1010 .with_bolt12_features(channelmanager::provided_bolt12_invoice_features(&UserConfig::default()))
1012 RouteParameters::from_payment_params_and_value(pay_params, amt_msat)
1015 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params.clone(), Retry::Attempts(2)).unwrap();
1016 check_added_monitors(&nodes[0], 1);
1017 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[3]]], amt_msat, payment_hash, payment_secret);
1019 macro_rules! fail_payment_back {
1020 ($intro_node: expr) => {
1021 nodes[3].node.fail_htlc_backwards(&payment_hash);
1022 expect_pending_htlcs_forwardable_conditions(
1023 nodes[3].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }]
1025 nodes[3].node.process_pending_htlc_forwards();
1026 check_added_monitors!(nodes[3], 1);
1028 let updates = get_htlc_update_msgs!(nodes[3], $intro_node.node.get_our_node_id());
1029 assert_eq!(updates.update_fail_malformed_htlcs.len(), 1);
1030 let update_malformed = &updates.update_fail_malformed_htlcs[0];
1031 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
1032 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
1033 $intro_node.node.handle_update_fail_malformed_htlc(&nodes[3].node.get_our_node_id(), update_malformed);
1034 do_commitment_signed_dance(&$intro_node, &nodes[3], &updates.commitment_signed, true, false);
1036 let updates = get_htlc_update_msgs!($intro_node, nodes[0].node.get_our_node_id());
1037 assert_eq!(updates.update_fail_htlcs.len(), 1);
1038 nodes[0].node.handle_update_fail_htlc(&$intro_node.node.get_our_node_id(), &updates.update_fail_htlcs[0]);
1039 do_commitment_signed_dance(&nodes[0], &$intro_node, &updates.commitment_signed, false, false);
1041 let mut events = nodes[0].node.get_and_clear_pending_events();
1042 assert_eq!(events.len(), 2);
1044 Event::PaymentPathFailed { payment_hash: ev_payment_hash, payment_failed_permanently, .. } => {
1045 assert_eq!(payment_hash, ev_payment_hash);
1046 assert_eq!(payment_failed_permanently, false);
1048 _ => panic!("Unexpected event"),
1051 Event::PendingHTLCsForwardable { .. } => {},
1052 _ => panic!("Unexpected event"),
1054 nodes[0].node.process_pending_htlc_forwards();
1058 fail_payment_back!(nodes[1]);
1060 // Pass the retry along.
1061 check_added_monitors!(nodes[0], 1);
1062 let mut msg_events = nodes[0].node.get_and_clear_pending_msg_events();
1063 assert_eq!(msg_events.len(), 1);
1064 pass_along_path(&nodes[0], &[&nodes[2], &nodes[3]], amt_msat, payment_hash, Some(payment_secret), msg_events.pop().unwrap(), true, None);
1066 fail_payment_back!(nodes[2]);
1067 let evs = nodes[0].node.get_and_clear_pending_events();
1068 assert_eq!(evs.len(), 1);
1070 Event::PaymentFailed { payment_hash: ev_payment_hash, reason, .. } => {
1071 assert_eq!(ev_payment_hash, payment_hash);
1072 // We have 1 retry attempt remaining, but we're out of blinded paths to try.
1073 assert_eq!(reason, Some(PaymentFailureReason::RouteNotFound));
1081 // The min htlc of a blinded path is the max (htlc_min - following_fees) along the path. Make sure
1082 // the payment succeeds when we calculate the min htlc this way.
1083 let chanmon_cfgs = create_chanmon_cfgs(4);
1084 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
1085 let mut node_1_cfg = test_default_channel_config();
1086 node_1_cfg.channel_handshake_config.our_htlc_minimum_msat = 2000;
1087 node_1_cfg.channel_config.forwarding_fee_base_msat = 1000;
1088 node_1_cfg.channel_config.forwarding_fee_proportional_millionths = 100_000;
1089 let mut node_2_cfg = test_default_channel_config();
1090 node_2_cfg.channel_handshake_config.our_htlc_minimum_msat = 5000;
1091 node_2_cfg.channel_config.forwarding_fee_base_msat = 200;
1092 node_2_cfg.channel_config.forwarding_fee_proportional_millionths = 150_000;
1093 let mut node_3_cfg = test_default_channel_config();
1094 node_3_cfg.channel_handshake_config.our_htlc_minimum_msat = 2000;
1095 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, Some(node_1_cfg), Some(node_2_cfg), Some(node_3_cfg)]);
1096 let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
1097 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
1098 let chan_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
1099 let chan_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
1101 let min_htlc_msat = {
1102 // The min htlc for this setup is nodes[2]'s htlc_minimum_msat minus the
1104 let post_base_fee = chan_2_3.1.contents.htlc_minimum_msat - chan_2_3.0.contents.fee_base_msat as u64;
1105 let prop_fee = chan_2_3.0.contents.fee_proportional_millionths as u64;
1106 (post_base_fee * 1_000_000 + 1_000_000 + prop_fee - 1) / (prop_fee + 1_000_000)
1108 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(min_htlc_msat), None);
1109 let mut route_params = get_blinded_route_parameters(
1110 min_htlc_msat, payment_secret, chan_1_2.1.contents.htlc_minimum_msat,
1111 chan_1_2.1.contents.htlc_maximum_msat, vec![nodes[1].node.get_our_node_id(),
1112 nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()],
1113 &[&chan_1_2.0.contents, &chan_2_3.0.contents], &chanmon_cfgs[3].keys_manager);
1114 assert_eq!(min_htlc_msat,
1115 route_params.payment_params.payee.blinded_route_hints()[0].0.htlc_minimum_msat);
1117 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params.clone(), Retry::Attempts(0)).unwrap();
1118 check_added_monitors(&nodes[0], 1);
1119 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3]]], min_htlc_msat, payment_hash, payment_secret);
1120 claim_payment(&nodes[0], &[&nodes[1], &nodes[2], &nodes[3]], payment_preimage);
1122 // Paying 1 less than the min fails.
1123 for _ in 0..IDEMPOTENCY_TIMEOUT_TICKS + 1 {
1124 nodes[0].node.timer_tick_occurred();
1126 if let Payee::Blinded { ref mut route_hints, .. } = route_params.payment_params.payee {
1127 route_hints[0].0.htlc_minimum_msat -= 1;
1129 route_params.final_value_msat -= 1;
1130 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
1131 check_added_monitors(&nodes[0], 1);
1133 let mut payment_event_0_1 = {
1134 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1135 assert_eq!(events.len(), 1);
1136 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
1137 SendEvent::from_event(ev)
1139 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_0_1.msgs[0]);
1140 check_added_monitors!(nodes[1], 0);
1141 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event_0_1.commitment_msg, true, true);
1142 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1143 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
1144 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
1145 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
1146 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
1150 fn conditionally_round_fwd_amt() {
1151 // Previously, the (rng-found) feerates below caught a bug where an intermediate node would
1152 // calculate an amt_to_forward that underpaid them by 1 msat, caused by rounding up the outbound
1153 // amount on top of an already rounded-up total routing fee. Ensure that we'll conditionally round
1154 // down intermediate nodes' outbound amounts based on whether rounding up will result in
1155 // undercharging for relay.
1156 let chanmon_cfgs = create_chanmon_cfgs(5);
1157 let node_cfgs = create_node_cfgs(5, &chanmon_cfgs);
1159 let mut node_1_cfg = test_default_channel_config();
1160 node_1_cfg.channel_config.forwarding_fee_base_msat = 247371;
1161 node_1_cfg.channel_config.forwarding_fee_proportional_millionths = 86552;
1163 let mut node_2_cfg = test_default_channel_config();
1164 node_2_cfg.channel_config.forwarding_fee_base_msat = 198921;
1165 node_2_cfg.channel_config.forwarding_fee_proportional_millionths = 681759;
1167 let mut node_3_cfg = test_default_channel_config();
1168 node_3_cfg.channel_config.forwarding_fee_base_msat = 132845;
1169 node_3_cfg.channel_config.forwarding_fee_proportional_millionths = 552561;
1171 let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &[None, Some(node_1_cfg), Some(node_2_cfg), Some(node_3_cfg), None]);
1172 let nodes = create_network(5, &node_cfgs, &node_chanmgrs);
1173 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
1174 let chan_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
1175 let chan_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
1176 let chan_3_4 = create_announced_chan_between_nodes_with_value(&nodes, 3, 4, 1_000_000, 0);
1178 let amt_msat = 100_000;
1179 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[4], Some(amt_msat), None);
1180 let mut route_params = get_blinded_route_parameters(amt_msat, payment_secret,
1181 chan_1_2.1.contents.htlc_minimum_msat, chan_1_2.1.contents.htlc_maximum_msat,
1182 vec![nodes[1].node.get_our_node_id(), nodes[2].node.get_our_node_id(),
1183 nodes[3].node.get_our_node_id(), nodes[4].node.get_our_node_id()],
1184 &[&chan_1_2.0.contents, &chan_2_3.0.contents, &chan_3_4.0.contents],
1185 &chanmon_cfgs[4].keys_manager);
1186 route_params.max_total_routing_fee_msat = None;
1188 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
1189 check_added_monitors(&nodes[0], 1);
1190 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3], &nodes[4]]], amt_msat, payment_hash, payment_secret);
1191 nodes[4].node.claim_funds(payment_preimage);
1192 let expected_path = &[&nodes[1], &nodes[2], &nodes[3], &nodes[4]];
1193 let expected_route = &[&expected_path[..]];
1194 let mut args = ClaimAlongRouteArgs::new(&nodes[0], &expected_route[..], payment_preimage)
1195 .allow_1_msat_fee_overpay();
1196 let expected_fee = pass_claimed_payment_along_route(args);
1197 expect_payment_sent(&nodes[0], payment_preimage, Some(Some(expected_fee)), true, true);
1201 fn blinded_keysend() {
1202 let mut mpp_keysend_config = test_default_channel_config();
1203 mpp_keysend_config.accept_mpp_keysend = true;
1204 let chanmon_cfgs = create_chanmon_cfgs(3);
1205 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1206 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, Some(mpp_keysend_config)]);
1207 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1208 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
1209 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
1211 let amt_msat = 5000;
1212 let (keysend_preimage, _, payment_secret) = get_payment_preimage_hash(&nodes[2], None, None);
1213 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1,
1215 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(),
1216 &[&chan_upd_1_2], &chanmon_cfgs[2].keys_manager);
1218 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();
1219 check_added_monitors(&nodes[0], 1);
1221 let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[2]]];
1222 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1223 assert_eq!(events.len(), 1);
1225 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
1226 pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash, Some(payment_secret), ev.clone(), true, Some(keysend_preimage));
1227 claim_payment_along_route(
1228 ClaimAlongRouteArgs::new(&nodes[0], expected_route, keysend_preimage)
1233 fn blinded_mpp_keysend() {
1234 let mut mpp_keysend_config = test_default_channel_config();
1235 mpp_keysend_config.accept_mpp_keysend = true;
1236 let chanmon_cfgs = create_chanmon_cfgs(4);
1237 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
1238 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, Some(mpp_keysend_config)]);
1239 let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
1241 create_announced_chan_between_nodes(&nodes, 0, 1);
1242 create_announced_chan_between_nodes(&nodes, 0, 2);
1243 let chan_1_3 = create_announced_chan_between_nodes(&nodes, 1, 3);
1244 let chan_2_3 = create_announced_chan_between_nodes(&nodes, 2, 3);
1246 let amt_msat = 15_000_000;
1247 let (keysend_preimage, _, payment_secret) = get_payment_preimage_hash(&nodes[3], None, None);
1248 let route_params = {
1249 let pay_params = PaymentParameters::blinded(
1251 blinded_payment_path(payment_secret, 1, 1_0000_0000,
1252 vec![nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_1_3.0.contents],
1253 &chanmon_cfgs[3].keys_manager
1255 blinded_payment_path(payment_secret, 1, 1_0000_0000,
1256 vec![nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_2_3.0.contents],
1257 &chanmon_cfgs[3].keys_manager
1261 .with_bolt12_features(channelmanager::provided_bolt12_invoice_features(&UserConfig::default()))
1263 RouteParameters::from_payment_params_and_value(pay_params, amt_msat)
1266 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();
1267 check_added_monitors!(nodes[0], 2);
1269 let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]];
1270 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1271 assert_eq!(events.len(), 2);
1273 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
1274 pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash.clone(),
1275 Some(payment_secret), ev.clone(), false, Some(keysend_preimage));
1277 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
1278 pass_along_path(&nodes[0], expected_route[1], amt_msat, payment_hash.clone(),
1279 Some(payment_secret), ev.clone(), true, Some(keysend_preimage));
1280 claim_payment_along_route(
1281 ClaimAlongRouteArgs::new(&nodes[0], expected_route, keysend_preimage)
1286 fn custom_tlvs_to_blinded_path() {
1287 let chanmon_cfgs = create_chanmon_cfgs(2);
1288 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1289 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1290 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1291 let chan_upd = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0).0.contents;
1293 let amt_msat = 5000;
1294 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[1], Some(amt_msat), None);
1295 let payee_tlvs = ReceiveTlvs {
1297 payment_constraints: PaymentConstraints {
1298 max_cltv_expiry: u32::max_value(),
1299 htlc_minimum_msat: chan_upd.htlc_minimum_msat,
1301 payment_context: PaymentContext::unknown(),
1303 let mut secp_ctx = Secp256k1::new();
1304 let blinded_path = BlindedPath::one_hop_for_payment(
1305 nodes[1].node.get_our_node_id(), payee_tlvs, TEST_FINAL_CLTV as u16,
1306 &chanmon_cfgs[1].keys_manager, &secp_ctx
1309 let route_params = RouteParameters::from_payment_params_and_value(
1310 PaymentParameters::blinded(vec![blinded_path]),
1314 let recipient_onion_fields = RecipientOnionFields::spontaneous_empty()
1315 .with_custom_tlvs(vec![((1 << 16) + 1, vec![42, 42])])
1317 nodes[0].node.send_payment(payment_hash, recipient_onion_fields.clone(),
1318 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
1319 check_added_monitors(&nodes[0], 1);
1321 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1322 assert_eq!(events.len(), 1);
1323 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
1325 let path = &[&nodes[1]];
1326 let args = PassAlongPathArgs::new(&nodes[0], path, amt_msat, payment_hash, ev)
1327 .with_payment_secret(payment_secret)
1328 .with_custom_tlvs(recipient_onion_fields.custom_tlvs.clone());
1329 do_pass_along_path(args);
1330 claim_payment_along_route(
1331 ClaimAlongRouteArgs::new(&nodes[0], &[&[&nodes[1]]], payment_preimage)
1332 .with_custom_tlvs(recipient_onion_fields.custom_tlvs.clone())