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(&nodes[0], expected_route, false, payment_preimage);
187 fn mpp_to_three_hop_blinded_paths() {
188 let chanmon_cfgs = create_chanmon_cfgs(6);
189 let node_cfgs = create_node_cfgs(6, &chanmon_cfgs);
190 let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &[None, None, None, None, None, None]);
191 let nodes = create_network(6, &node_cfgs, &node_chanmgrs);
193 // Create this network topology so node 0 MPP's over 2 3-hop blinded paths:
199 create_announced_chan_between_nodes(&nodes, 0, 1);
200 create_announced_chan_between_nodes(&nodes, 0, 2);
201 let chan_upd_1_3 = create_announced_chan_between_nodes(&nodes, 1, 3).0.contents;
202 let chan_upd_2_4 = create_announced_chan_between_nodes(&nodes, 2, 4).0.contents;
203 let chan_upd_3_5 = create_announced_chan_between_nodes(&nodes, 3, 5).0.contents;
204 let chan_upd_4_5 = create_announced_chan_between_nodes(&nodes, 4, 5).0.contents;
206 let amt_msat = 15_000_000;
207 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[5], Some(amt_msat), None);
209 let path_1_params = get_blinded_route_parameters(
210 amt_msat, payment_secret, 1, 1_0000_0000, vec![
211 nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id(),
212 nodes[5].node.get_our_node_id()
213 ], &[&chan_upd_1_3, &chan_upd_3_5], &chanmon_cfgs[5].keys_manager
215 let path_2_params = get_blinded_route_parameters(
216 amt_msat, payment_secret, 1, 1_0000_0000, vec![
217 nodes[2].node.get_our_node_id(), nodes[4].node.get_our_node_id(),
218 nodes[5].node.get_our_node_id()
219 ], &[&chan_upd_2_4, &chan_upd_4_5], &chanmon_cfgs[5].keys_manager
221 let pay_params = PaymentParameters::blinded(
223 path_1_params.payment_params.payee.blinded_route_hints()[0].clone(),
224 path_2_params.payment_params.payee.blinded_route_hints()[0].clone()
227 .with_bolt12_features(channelmanager::provided_bolt12_invoice_features(&UserConfig::default()))
229 RouteParameters::from_payment_params_and_value(pay_params, amt_msat)
232 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(),
233 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
234 check_added_monitors(&nodes[0], 2);
236 let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[3], &nodes[5]], &[&nodes[2], &nodes[4], &nodes[5]]];
237 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
238 assert_eq!(events.len(), 2);
240 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
241 pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash.clone(),
242 Some(payment_secret), ev.clone(), false, None);
244 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
245 pass_along_path(&nodes[0], expected_route[1], amt_msat, payment_hash.clone(),
246 Some(payment_secret), ev.clone(), true, None);
247 claim_payment_along_route(&nodes[0], expected_route, false, payment_preimage);
250 enum ForwardCheckFail {
251 // Fail a check on the inbound onion payload. In this case, we underflow when calculating the
252 // outgoing cltv_expiry.
254 // The forwarding node's payload is encoded as a receive, i.e. the next hop HMAC is [0; 32].
255 ForwardPayloadEncodedAsReceive,
256 // Fail a check on the outbound channel. In this case, our next-hop peer is offline.
257 OutboundChannelCheck,
261 fn forward_checks_failure() {
262 do_forward_checks_failure(ForwardCheckFail::InboundOnionCheck, true);
263 do_forward_checks_failure(ForwardCheckFail::InboundOnionCheck, false);
264 do_forward_checks_failure(ForwardCheckFail::ForwardPayloadEncodedAsReceive, true);
265 do_forward_checks_failure(ForwardCheckFail::ForwardPayloadEncodedAsReceive, false);
266 do_forward_checks_failure(ForwardCheckFail::OutboundChannelCheck, true);
267 do_forward_checks_failure(ForwardCheckFail::OutboundChannelCheck, false);
270 fn do_forward_checks_failure(check: ForwardCheckFail, intro_fails: bool) {
271 // Ensure we'll fail backwards properly if a forwarding check fails on initial update_add
273 let chanmon_cfgs = create_chanmon_cfgs(4);
274 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
275 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
276 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
277 // We need the session priv to construct a bogus onion packet later.
278 *nodes[0].keys_manager.override_random_bytes.lock().unwrap() = Some([3; 32]);
279 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
280 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
281 let chan_upd_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0).0.contents;
284 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
285 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
286 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(),
287 &[&chan_upd_1_2, &chan_upd_2_3], &chanmon_cfgs[3].keys_manager);
289 let route = get_route(&nodes[0], &route_params).unwrap();
290 node_cfgs[0].router.expect_find_route(route_params.clone(), Ok(route.clone()));
291 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
292 check_added_monitors(&nodes[0], 1);
294 macro_rules! cause_error {
295 ($src_node_idx: expr, $target_node_idx: expr, $update_add: expr) => {
297 ForwardCheckFail::InboundOnionCheck => {
298 $update_add.cltv_expiry = 10; // causes outbound CLTV expiry to underflow
300 ForwardCheckFail::ForwardPayloadEncodedAsReceive => {
301 let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
302 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
303 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
304 let cur_height = nodes[0].best_block_info().1;
305 let (mut onion_payloads, ..) = onion_utils::build_onion_payloads(
306 &route.paths[0], amt_msat, &recipient_onion_fields, cur_height, &None).unwrap();
307 // Remove the receive payload so the blinded forward payload is encoded as a final payload
308 // (i.e. next_hop_hmac == [0; 32])
309 onion_payloads.pop();
310 if $target_node_idx + 1 < nodes.len() {
311 onion_payloads.pop();
313 $update_add.onion_routing_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash).unwrap();
315 ForwardCheckFail::OutboundChannelCheck => {
316 // The intro node will see that the next-hop peer is disconnected and fail the HTLC backwards.
317 nodes[$src_node_idx].node.peer_disconnected(&nodes[$target_node_idx].node.get_our_node_id());
323 let mut updates_0_1 = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
324 let update_add = &mut updates_0_1.update_add_htlcs[0];
327 cause_error!(1, 2, update_add);
330 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &update_add);
331 check_added_monitors!(nodes[1], 0);
332 do_commitment_signed_dance(&nodes[1], &nodes[0], &updates_0_1.commitment_signed, true, true);
335 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
336 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
337 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
338 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
339 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
343 expect_pending_htlcs_forwardable!(nodes[1]);
344 check_added_monitors!(nodes[1], 1);
346 let mut updates_1_2 = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
347 let mut update_add = &mut updates_1_2.update_add_htlcs[0];
349 cause_error!(2, 3, update_add);
351 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add);
352 check_added_monitors!(nodes[2], 0);
353 do_commitment_signed_dance(&nodes[2], &nodes[1], &updates_1_2.commitment_signed, true, true);
355 let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
356 let update_malformed = &mut updates.update_fail_malformed_htlcs[0];
357 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
358 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
360 // Ensure the intro node will properly blind the error if its downstream node failed to do so.
361 update_malformed.sha256_of_onion = [1; 32];
362 update_malformed.failure_code = INVALID_ONION_BLINDING ^ 1;
363 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
364 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates.commitment_signed, true, false);
366 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
367 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
368 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
369 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
370 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
374 fn failed_backwards_to_intro_node() {
375 // Ensure the intro node will error backwards properly even if the downstream node did not blind
377 let chanmon_cfgs = create_chanmon_cfgs(3);
378 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
379 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
380 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
381 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
382 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
385 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
386 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
387 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2],
388 &chanmon_cfgs[2].keys_manager);
390 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
391 check_added_monitors(&nodes[0], 1);
393 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
394 assert_eq!(events.len(), 1);
395 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
396 let mut payment_event = SendEvent::from_event(ev);
398 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
399 check_added_monitors!(nodes[1], 0);
400 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event.commitment_msg, false, false);
401 expect_pending_htlcs_forwardable!(nodes[1]);
402 check_added_monitors!(&nodes[1], 1);
404 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
405 assert_eq!(events.len(), 1);
406 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
407 let mut payment_event = SendEvent::from_event(ev);
409 // Ensure the final node fails to handle the HTLC.
410 payment_event.msgs[0].onion_routing_packet.hop_data[0] ^= 1;
411 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
412 check_added_monitors!(nodes[2], 0);
413 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event.commitment_msg, true, true);
414 nodes[2].node.process_pending_htlc_forwards();
416 let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
417 let mut update_malformed = &mut updates.update_fail_malformed_htlcs[0];
418 // Check that the final node encodes its failure correctly.
419 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
420 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
422 // Modify such the final hop does not correctly blind their error so we can ensure the intro node
423 // converts it to the correct error.
424 update_malformed.sha256_of_onion = [1; 32];
425 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
426 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates.commitment_signed, true, false);
428 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
429 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
430 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
431 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
432 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
435 enum ProcessPendingHTLCsCheck {
441 fn forward_fail_in_process_pending_htlc_fwds() {
442 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdPeerDisconnected, true);
443 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdPeerDisconnected, false);
444 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdChannelClosed, true);
445 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdChannelClosed, false);
447 fn do_forward_fail_in_process_pending_htlc_fwds(check: ProcessPendingHTLCsCheck, intro_fails: bool) {
448 // Ensure the intro node will error backwards properly if the HTLC fails in
449 // process_pending_htlc_forwards.
450 let chanmon_cfgs = create_chanmon_cfgs(4);
451 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
452 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
453 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
454 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
455 let (chan_upd_1_2, chan_id_1_2) = {
456 let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
457 (chan.0.contents, chan.2)
459 let (chan_upd_2_3, chan_id_2_3) = {
460 let chan = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
461 (chan.0.contents, chan.2)
465 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
466 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
467 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2, &chan_upd_2_3],
468 &chanmon_cfgs[2].keys_manager);
470 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
471 check_added_monitors(&nodes[0], 1);
473 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
474 assert_eq!(events.len(), 1);
475 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
476 let mut payment_event = SendEvent::from_event(ev);
478 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
479 check_added_monitors!(nodes[1], 0);
480 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event.commitment_msg, false, false);
482 macro_rules! cause_error {
483 ($prev_node: expr, $curr_node: expr, $next_node: expr, $failed_chan_id: expr, $failed_scid: expr) => {
485 ProcessPendingHTLCsCheck::FwdPeerDisconnected => {
486 // Disconnect the next-hop peer so when we go to forward in process_pending_htlc_forwards, the
487 // intro node will error backwards.
488 $curr_node.node.peer_disconnected(&$next_node.node.get_our_node_id());
489 expect_pending_htlcs_forwardable!($curr_node);
490 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!($curr_node,
491 vec![HTLCDestination::NextHopChannel { node_id: Some($next_node.node.get_our_node_id()), channel_id: $failed_chan_id }]);
493 ProcessPendingHTLCsCheck::FwdChannelClosed => {
494 // Force close the next-hop channel so when we go to forward in process_pending_htlc_forwards,
495 // the intro node will error backwards.
496 $curr_node.node.force_close_broadcasting_latest_txn(&$failed_chan_id, &$next_node.node.get_our_node_id()).unwrap();
497 let events = $curr_node.node.get_and_clear_pending_events();
499 crate::events::Event::PendingHTLCsForwardable { .. } => {},
500 _ => panic!("Unexpected event {:?}", events),
503 crate::events::Event::ChannelClosed { .. } => {},
504 _ => panic!("Unexpected event {:?}", events),
507 $curr_node.node.process_pending_htlc_forwards();
508 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!($curr_node,
509 vec![HTLCDestination::UnknownNextHop { requested_forward_scid: $failed_scid }]);
510 check_closed_broadcast(&$curr_node, 1, true);
511 check_added_monitors!($curr_node, 1);
512 $curr_node.node.process_pending_htlc_forwards();
519 cause_error!(nodes[0], nodes[1], nodes[2], chan_id_1_2, chan_upd_1_2.short_channel_id);
520 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
521 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
522 check_added_monitors!(nodes[1], 1);
523 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
525 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
526 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
530 expect_pending_htlcs_forwardable!(nodes[1]);
531 check_added_monitors!(nodes[1], 1);
533 let mut updates_1_2 = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
534 let mut update_add = &mut updates_1_2.update_add_htlcs[0];
535 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add);
536 check_added_monitors!(nodes[2], 0);
537 do_commitment_signed_dance(&nodes[2], &nodes[1], &updates_1_2.commitment_signed, true, true);
539 cause_error!(nodes[1], nodes[2], nodes[3], chan_id_2_3, chan_upd_2_3.short_channel_id);
540 check_added_monitors!(nodes[2], 1);
542 let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
543 let update_malformed = &mut updates.update_fail_malformed_htlcs[0];
544 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
545 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
547 // Ensure the intro node will properly blind the error if its downstream node failed to do so.
548 update_malformed.sha256_of_onion = [1; 32];
549 update_malformed.failure_code = INVALID_ONION_BLINDING ^ 1;
550 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
551 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates.commitment_signed, true, false);
553 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
554 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
555 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
556 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
557 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
561 fn blinded_intercept_payment() {
562 do_blinded_intercept_payment(true);
563 do_blinded_intercept_payment(false);
565 fn do_blinded_intercept_payment(intercept_node_fails: bool) {
566 let chanmon_cfgs = create_chanmon_cfgs(3);
567 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
568 let mut intercept_forwards_config = test_default_channel_config();
569 intercept_forwards_config.accept_intercept_htlcs = true;
570 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(intercept_forwards_config), None]);
571 let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
572 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
573 let (channel_id, chan_upd) = {
574 let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
575 (chan.2, chan.0.contents)
579 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
580 let intercept_scid = nodes[1].node.get_intercept_scid();
581 let mut intercept_chan_upd = chan_upd;
582 intercept_chan_upd.short_channel_id = intercept_scid;
583 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
584 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&intercept_chan_upd],
585 &chanmon_cfgs[2].keys_manager);
587 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(),
588 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
589 check_added_monitors(&nodes[0], 1);
590 let payment_event = {
591 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
592 assert_eq!(events.len(), 1);
593 SendEvent::from_event(events.remove(0))
595 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
596 commitment_signed_dance!(nodes[1], nodes[0], &payment_event.commitment_msg, false, true);
598 let events = nodes[1].node.get_and_clear_pending_events();
599 assert_eq!(events.len(), 1);
600 let (intercept_id, expected_outbound_amount_msat) = match events[0] {
601 crate::events::Event::HTLCIntercepted {
602 intercept_id, payment_hash: pmt_hash,
603 requested_next_hop_scid: short_channel_id, expected_outbound_amount_msat, ..
605 assert_eq!(pmt_hash, payment_hash);
606 assert_eq!(short_channel_id, intercept_scid);
607 (intercept_id, expected_outbound_amount_msat)
612 if intercept_node_fails {
613 nodes[1].node.fail_intercepted_htlc(intercept_id).unwrap();
614 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(nodes[1], vec![HTLCDestination::UnknownNextHop { requested_forward_scid: intercept_scid }]);
615 nodes[1].node.process_pending_htlc_forwards();
616 let update_fail = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
617 check_added_monitors!(&nodes[1], 1);
618 assert!(update_fail.update_fail_htlcs.len() == 1);
619 let fail_msg = update_fail.update_fail_htlcs[0].clone();
620 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_msg);
621 commitment_signed_dance!(nodes[0], nodes[1], update_fail.commitment_signed, false);
622 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
623 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
627 nodes[1].node.forward_intercepted_htlc(intercept_id, &channel_id, nodes[2].node.get_our_node_id(), expected_outbound_amount_msat).unwrap();
628 expect_pending_htlcs_forwardable!(nodes[1]);
630 let payment_event = {
632 let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
633 assert_eq!(added_monitors.len(), 1);
634 added_monitors.clear();
636 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
637 assert_eq!(events.len(), 1);
638 SendEvent::from_event(events.remove(0))
640 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
641 commitment_signed_dance!(nodes[2], nodes[1], &payment_event.commitment_msg, false, true);
642 expect_pending_htlcs_forwardable!(nodes[2]);
644 expect_payment_claimable!(&nodes[2], payment_hash, payment_secret, amt_msat, None, nodes[2].node.get_our_node_id());
645 do_claim_payment_along_route(&nodes[0], &vec!(&vec!(&nodes[1], &nodes[2])[..]), false, payment_preimage);
646 expect_payment_sent(&nodes[0], payment_preimage, Some(Some(1000)), true, true);
650 fn two_hop_blinded_path_success() {
651 let chanmon_cfgs = create_chanmon_cfgs(3);
652 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
653 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
654 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
655 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
656 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
659 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
660 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
661 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2],
662 &chanmon_cfgs[2].keys_manager);
664 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
665 check_added_monitors(&nodes[0], 1);
666 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], amt_msat, payment_hash, payment_secret);
667 claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
671 fn three_hop_blinded_path_success() {
672 let chanmon_cfgs = create_chanmon_cfgs(5);
673 let node_cfgs = create_node_cfgs(5, &chanmon_cfgs);
674 let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &[None, None, None, None, None]);
675 let mut nodes = create_network(5, &node_cfgs, &node_chanmgrs);
676 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
677 create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
678 let chan_upd_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0).0.contents;
679 let chan_upd_3_4 = create_announced_chan_between_nodes_with_value(&nodes, 3, 4, 1_000_000, 0).0.contents;
681 // Get all our nodes onto the same height so payments don't fail for CLTV violations.
682 connect_blocks(&nodes[0], nodes[4].best_block_info().1 - nodes[0].best_block_info().1);
683 connect_blocks(&nodes[1], nodes[4].best_block_info().1 - nodes[1].best_block_info().1);
684 connect_blocks(&nodes[2], nodes[4].best_block_info().1 - nodes[2].best_block_info().1);
685 assert_eq!(nodes[4].best_block_info().1, nodes[3].best_block_info().1);
688 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[4], Some(amt_msat), None);
689 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
690 nodes.iter().skip(2).map(|n| n.node.get_our_node_id()).collect(),
691 &[&chan_upd_2_3, &chan_upd_3_4], &chanmon_cfgs[4].keys_manager);
693 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
694 check_added_monitors(&nodes[0], 1);
695 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3], &nodes[4]]], amt_msat, payment_hash, payment_secret);
696 claim_payment(&nodes[0], &[&nodes[1], &nodes[2], &nodes[3], &nodes[4]], payment_preimage);
700 fn three_hop_blinded_path_fail() {
701 // Test that an intermediate blinded forwarding node gets failed back to with
702 // malformed and also fails back themselves with malformed.
703 let chanmon_cfgs = create_chanmon_cfgs(4);
704 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
705 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
706 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
707 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
708 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
709 let chan_upd_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0).0.contents;
712 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
713 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
714 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(),
715 &[&chan_upd_1_2, &chan_upd_2_3], &chanmon_cfgs[3].keys_manager);
717 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
718 check_added_monitors(&nodes[0], 1);
719 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3]]], amt_msat, payment_hash, payment_secret);
721 nodes[3].node.fail_htlc_backwards(&payment_hash);
722 expect_pending_htlcs_forwardable_conditions(
723 nodes[3].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }]
725 nodes[3].node.process_pending_htlc_forwards();
726 check_added_monitors!(nodes[3], 1);
728 let updates_3_2 = get_htlc_update_msgs!(nodes[3], nodes[2].node.get_our_node_id());
729 assert_eq!(updates_3_2.update_fail_malformed_htlcs.len(), 1);
730 let update_malformed = &updates_3_2.update_fail_malformed_htlcs[0];
731 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
732 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
733 nodes[2].node.handle_update_fail_malformed_htlc(&nodes[3].node.get_our_node_id(), update_malformed);
734 do_commitment_signed_dance(&nodes[2], &nodes[3], &updates_3_2.commitment_signed, true, false);
736 let updates_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
737 assert_eq!(updates_2_1.update_fail_malformed_htlcs.len(), 1);
738 let update_malformed = &updates_2_1.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[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
742 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates_2_1.commitment_signed, true, false);
744 let updates_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
745 assert_eq!(updates_1_0.update_fail_htlcs.len(), 1);
746 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_1_0.update_fail_htlcs[0]);
747 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates_1_0.commitment_signed, false, false);
748 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
749 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
753 enum ReceiveCheckFail {
754 // The recipient fails the payment upon `PaymentClaimable`.
756 // Failure to decode the recipient's onion payload.
758 // The incoming HTLC did not satisfy our requirements; in this case it underpaid us according to
759 // the expected receive amount in the onion.
761 // The incoming HTLC errors when added to the Channel, in this case due to the HTLC being
762 // delivered out-of-order with a shutdown message.
764 // The HTLC is successfully added to the inbound channel but fails receive checks in
765 // process_pending_htlc_forwards.
766 ProcessPendingHTLCsCheck,
767 // The HTLC violates the `PaymentConstraints` contained within the receiver's encrypted payload.
772 fn multi_hop_receiver_fail() {
773 do_multi_hop_receiver_fail(ReceiveCheckFail::RecipientFail);
774 do_multi_hop_receiver_fail(ReceiveCheckFail::OnionDecodeFail);
775 do_multi_hop_receiver_fail(ReceiveCheckFail::ReceiveRequirements);
776 do_multi_hop_receiver_fail(ReceiveCheckFail::ChannelCheck);
777 do_multi_hop_receiver_fail(ReceiveCheckFail::ProcessPendingHTLCsCheck);
778 do_multi_hop_receiver_fail(ReceiveCheckFail::PaymentConstraints);
781 fn do_multi_hop_receiver_fail(check: ReceiveCheckFail) {
782 // Test that the receiver to a multihop blinded path fails back correctly.
783 let chanmon_cfgs = create_chanmon_cfgs(3);
784 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
785 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
786 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
787 // We need the session priv to construct an invalid onion packet later.
788 let session_priv = [3; 32];
789 *nodes[0].keys_manager.override_random_bytes.lock().unwrap() = Some(session_priv);
790 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
791 let (chan_upd_1_2, chan_id_1_2) = {
792 let (chan_upd, _, channel_id, ..) = create_announced_chan_between_nodes_with_value(
793 &nodes, 1, 2, 1_000_000, 0
795 (chan_upd.contents, channel_id)
799 let excess_final_cltv_delta_opt = if check == ReceiveCheckFail::ProcessPendingHTLCsCheck {
800 // Set the final CLTV expiry too low to trigger the failure in process_pending_htlc_forwards.
801 Some(TEST_FINAL_CLTV as u16 - 2)
803 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), excess_final_cltv_delta_opt);
804 let mut route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
805 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2],
806 &chanmon_cfgs[2].keys_manager);
808 let route = if check == ReceiveCheckFail::ProcessPendingHTLCsCheck {
809 let mut route = get_route(&nodes[0], &route_params).unwrap();
810 // Set the final CLTV expiry too low to trigger the failure in process_pending_htlc_forwards.
811 route.paths[0].hops.last_mut().map(|h| h.cltv_expiry_delta += excess_final_cltv_delta_opt.unwrap() as u32);
812 route.paths[0].blinded_tail.as_mut().map(|bt| bt.excess_final_cltv_expiry_delta = excess_final_cltv_delta_opt.unwrap() as u32);
814 } else if check == ReceiveCheckFail::PaymentConstraints {
815 // Create a blinded path where the receiver's encrypted payload has an htlc_minimum_msat that is
816 // violated by `amt_msat`, and stick it in the route_params without changing the corresponding
817 // BlindedPayInfo (to ensure pathfinding still succeeds).
818 let high_htlc_min_bp = {
819 let mut high_htlc_minimum_upd = chan_upd_1_2.clone();
820 high_htlc_minimum_upd.htlc_minimum_msat = amt_msat + 1000;
821 let high_htlc_min_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
822 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&high_htlc_minimum_upd],
823 &chanmon_cfgs[2].keys_manager);
824 if let Payee::Blinded { route_hints, .. } = high_htlc_min_params.payment_params.payee {
825 route_hints[0].1.clone()
828 if let Payee::Blinded { ref mut route_hints, .. } = route_params.payment_params.payee {
829 route_hints[0].1 = high_htlc_min_bp;
831 find_route(&nodes[0], &route_params).unwrap()
833 find_route(&nodes[0], &route_params).unwrap()
835 node_cfgs[0].router.expect_find_route(route_params.clone(), Ok(route.clone()));
836 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
837 check_added_monitors(&nodes[0], 1);
839 let mut payment_event_0_1 = {
840 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
841 assert_eq!(events.len(), 1);
842 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
843 SendEvent::from_event(ev)
845 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_0_1.msgs[0]);
846 check_added_monitors!(nodes[1], 0);
847 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event_0_1.commitment_msg, false, false);
848 expect_pending_htlcs_forwardable!(nodes[1]);
849 check_added_monitors!(&nodes[1], 1);
851 let mut payment_event_1_2 = {
852 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
853 assert_eq!(events.len(), 1);
854 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
855 SendEvent::from_event(ev)
859 ReceiveCheckFail::RecipientFail => {
860 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
861 check_added_monitors!(nodes[2], 0);
862 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
863 expect_pending_htlcs_forwardable!(nodes[2]);
864 check_payment_claimable(
865 &nodes[2].node.get_and_clear_pending_events()[0], payment_hash, payment_secret, amt_msat,
866 None, nodes[2].node.get_our_node_id()
868 nodes[2].node.fail_htlc_backwards(&payment_hash);
869 expect_pending_htlcs_forwardable_conditions(
870 nodes[2].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }]
872 nodes[2].node.process_pending_htlc_forwards();
873 check_added_monitors!(nodes[2], 1);
875 ReceiveCheckFail::OnionDecodeFail => {
876 let session_priv = SecretKey::from_slice(&session_priv).unwrap();
877 let mut onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
878 let cur_height = nodes[0].best_block_info().1;
879 let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
880 let (mut onion_payloads, ..) = onion_utils::build_onion_payloads(
881 &route.paths[0], amt_msat, &recipient_onion_fields, cur_height, &None).unwrap();
883 let update_add = &mut payment_event_1_2.msgs[0];
884 onion_payloads.last_mut().map(|p| {
885 if let msgs::OutboundOnionPayload::BlindedReceive { ref mut intro_node_blinding_point, .. } = p {
886 // The receiver should error if both the update_add blinding_point and the
887 // intro_node_blinding_point are set.
888 assert!(intro_node_blinding_point.is_none() && update_add.blinding_point.is_some());
889 *intro_node_blinding_point = Some(PublicKey::from_slice(&[2; 33]).unwrap());
892 update_add.onion_routing_packet = onion_utils::construct_onion_packet(
893 vec![onion_payloads.pop().unwrap()], vec![onion_keys.pop().unwrap()], [0; 32],
896 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), update_add);
897 check_added_monitors!(nodes[2], 0);
898 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
900 ReceiveCheckFail::ReceiveRequirements => {
901 let update_add = &mut payment_event_1_2.msgs[0];
902 update_add.amount_msat -= 1;
903 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), update_add);
904 check_added_monitors!(nodes[2], 0);
905 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
907 ReceiveCheckFail::ChannelCheck => {
908 nodes[2].node.close_channel(&chan_id_1_2, &nodes[1].node.get_our_node_id()).unwrap();
909 let node_2_shutdown = get_event_msg!(nodes[2], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
910 nodes[1].node.handle_shutdown(&nodes[2].node.get_our_node_id(), &node_2_shutdown);
911 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
913 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
914 nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event_1_2.commitment_msg);
915 check_added_monitors!(nodes[2], 1);
917 nodes[2].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
918 commitment_signed_dance!(nodes[2], nodes[1], (), false, true, false, false);
920 ReceiveCheckFail::ProcessPendingHTLCsCheck => {
921 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);
922 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
923 check_added_monitors!(nodes[2], 0);
924 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
925 expect_pending_htlcs_forwardable!(nodes[2]);
926 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(nodes[2],
927 vec![HTLCDestination::FailedPayment { payment_hash }]);
928 check_added_monitors!(nodes[2], 1);
930 ReceiveCheckFail::PaymentConstraints => {
931 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
932 check_added_monitors!(nodes[2], 0);
933 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
937 let updates_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
938 assert_eq!(updates_2_1.update_fail_malformed_htlcs.len(), 1);
939 let update_malformed = &updates_2_1.update_fail_malformed_htlcs[0];
940 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
941 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
942 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
943 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates_2_1.commitment_signed, true, false);
945 let updates_1_0 = if check == ReceiveCheckFail::ChannelCheck {
946 let events = nodes[1].node.get_and_clear_pending_msg_events();
947 assert_eq!(events.len(), 2);
948 events.into_iter().find_map(|ev| {
950 MessageSendEvent:: UpdateHTLCs { node_id, updates } => {
951 assert_eq!(node_id, nodes[0].node.get_our_node_id());
954 MessageSendEvent::SendClosingSigned { .. } => None,
958 } else { get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()) };
959 assert_eq!(updates_1_0.update_fail_htlcs.len(), 1);
960 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_1_0.update_fail_htlcs[0]);
961 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates_1_0.commitment_signed, false, false);
962 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
963 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
967 fn blinded_path_retries() {
968 let chanmon_cfgs = create_chanmon_cfgs(4);
969 // Make one blinded path's fees slightly higher so they are tried in a deterministic order.
970 let mut higher_fee_chan_cfg = test_default_channel_config();
971 higher_fee_chan_cfg.channel_config.forwarding_fee_base_msat += 1;
972 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
973 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, Some(higher_fee_chan_cfg), None]);
974 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
976 // Create this network topology so nodes[0] has a blinded route hint to retry over.
982 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
983 create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1_000_000, 0);
984 let chan_1_3 = create_announced_chan_between_nodes_with_value(&nodes, 1, 3, 1_000_000, 0);
985 let chan_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
988 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
990 let pay_params = PaymentParameters::blinded(
992 blinded_payment_path(payment_secret, 1, 1_0000_0000,
993 vec![nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_1_3.0.contents],
994 &chanmon_cfgs[3].keys_manager
996 blinded_payment_path(payment_secret, 1, 1_0000_0000,
997 vec![nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_2_3.0.contents],
998 &chanmon_cfgs[3].keys_manager
1002 .with_bolt12_features(channelmanager::provided_bolt12_invoice_features(&UserConfig::default()))
1004 RouteParameters::from_payment_params_and_value(pay_params, amt_msat)
1007 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params.clone(), Retry::Attempts(2)).unwrap();
1008 check_added_monitors(&nodes[0], 1);
1009 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[3]]], amt_msat, payment_hash, payment_secret);
1011 macro_rules! fail_payment_back {
1012 ($intro_node: expr) => {
1013 nodes[3].node.fail_htlc_backwards(&payment_hash);
1014 expect_pending_htlcs_forwardable_conditions(
1015 nodes[3].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }]
1017 nodes[3].node.process_pending_htlc_forwards();
1018 check_added_monitors!(nodes[3], 1);
1020 let updates = get_htlc_update_msgs!(nodes[3], $intro_node.node.get_our_node_id());
1021 assert_eq!(updates.update_fail_malformed_htlcs.len(), 1);
1022 let update_malformed = &updates.update_fail_malformed_htlcs[0];
1023 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
1024 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
1025 $intro_node.node.handle_update_fail_malformed_htlc(&nodes[3].node.get_our_node_id(), update_malformed);
1026 do_commitment_signed_dance(&$intro_node, &nodes[3], &updates.commitment_signed, true, false);
1028 let updates = get_htlc_update_msgs!($intro_node, nodes[0].node.get_our_node_id());
1029 assert_eq!(updates.update_fail_htlcs.len(), 1);
1030 nodes[0].node.handle_update_fail_htlc(&$intro_node.node.get_our_node_id(), &updates.update_fail_htlcs[0]);
1031 do_commitment_signed_dance(&nodes[0], &$intro_node, &updates.commitment_signed, false, false);
1033 let mut events = nodes[0].node.get_and_clear_pending_events();
1034 assert_eq!(events.len(), 2);
1036 Event::PaymentPathFailed { payment_hash: ev_payment_hash, payment_failed_permanently, .. } => {
1037 assert_eq!(payment_hash, ev_payment_hash);
1038 assert_eq!(payment_failed_permanently, false);
1040 _ => panic!("Unexpected event"),
1043 Event::PendingHTLCsForwardable { .. } => {},
1044 _ => panic!("Unexpected event"),
1046 nodes[0].node.process_pending_htlc_forwards();
1050 fail_payment_back!(nodes[1]);
1052 // Pass the retry along.
1053 check_added_monitors!(nodes[0], 1);
1054 let mut msg_events = nodes[0].node.get_and_clear_pending_msg_events();
1055 assert_eq!(msg_events.len(), 1);
1056 pass_along_path(&nodes[0], &[&nodes[2], &nodes[3]], amt_msat, payment_hash, Some(payment_secret), msg_events.pop().unwrap(), true, None);
1058 fail_payment_back!(nodes[2]);
1059 let evs = nodes[0].node.get_and_clear_pending_events();
1060 assert_eq!(evs.len(), 1);
1062 Event::PaymentFailed { payment_hash: ev_payment_hash, reason, .. } => {
1063 assert_eq!(ev_payment_hash, payment_hash);
1064 // We have 1 retry attempt remaining, but we're out of blinded paths to try.
1065 assert_eq!(reason, Some(PaymentFailureReason::RouteNotFound));
1073 // The min htlc of a blinded path is the max (htlc_min - following_fees) along the path. Make sure
1074 // the payment succeeds when we calculate the min htlc this way.
1075 let chanmon_cfgs = create_chanmon_cfgs(4);
1076 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
1077 let mut node_1_cfg = test_default_channel_config();
1078 node_1_cfg.channel_handshake_config.our_htlc_minimum_msat = 2000;
1079 node_1_cfg.channel_config.forwarding_fee_base_msat = 1000;
1080 node_1_cfg.channel_config.forwarding_fee_proportional_millionths = 100_000;
1081 let mut node_2_cfg = test_default_channel_config();
1082 node_2_cfg.channel_handshake_config.our_htlc_minimum_msat = 5000;
1083 node_2_cfg.channel_config.forwarding_fee_base_msat = 200;
1084 node_2_cfg.channel_config.forwarding_fee_proportional_millionths = 150_000;
1085 let mut node_3_cfg = test_default_channel_config();
1086 node_3_cfg.channel_handshake_config.our_htlc_minimum_msat = 2000;
1087 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, Some(node_1_cfg), Some(node_2_cfg), Some(node_3_cfg)]);
1088 let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
1089 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
1090 let chan_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
1091 let chan_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
1093 let min_htlc_msat = {
1094 // The min htlc for this setup is nodes[2]'s htlc_minimum_msat minus the
1096 let post_base_fee = chan_2_3.1.contents.htlc_minimum_msat - chan_2_3.0.contents.fee_base_msat as u64;
1097 let prop_fee = chan_2_3.0.contents.fee_proportional_millionths as u64;
1098 (post_base_fee * 1_000_000 + 1_000_000 + prop_fee - 1) / (prop_fee + 1_000_000)
1100 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(min_htlc_msat), None);
1101 let mut route_params = get_blinded_route_parameters(
1102 min_htlc_msat, payment_secret, chan_1_2.1.contents.htlc_minimum_msat,
1103 chan_1_2.1.contents.htlc_maximum_msat, vec![nodes[1].node.get_our_node_id(),
1104 nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()],
1105 &[&chan_1_2.0.contents, &chan_2_3.0.contents], &chanmon_cfgs[3].keys_manager);
1106 assert_eq!(min_htlc_msat,
1107 route_params.payment_params.payee.blinded_route_hints()[0].0.htlc_minimum_msat);
1109 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params.clone(), Retry::Attempts(0)).unwrap();
1110 check_added_monitors(&nodes[0], 1);
1111 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3]]], min_htlc_msat, payment_hash, payment_secret);
1112 claim_payment(&nodes[0], &[&nodes[1], &nodes[2], &nodes[3]], payment_preimage);
1114 // Paying 1 less than the min fails.
1115 for _ in 0..IDEMPOTENCY_TIMEOUT_TICKS + 1 {
1116 nodes[0].node.timer_tick_occurred();
1118 if let Payee::Blinded { ref mut route_hints, .. } = route_params.payment_params.payee {
1119 route_hints[0].0.htlc_minimum_msat -= 1;
1121 route_params.final_value_msat -= 1;
1122 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
1123 check_added_monitors(&nodes[0], 1);
1125 let mut payment_event_0_1 = {
1126 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1127 assert_eq!(events.len(), 1);
1128 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
1129 SendEvent::from_event(ev)
1131 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_0_1.msgs[0]);
1132 check_added_monitors!(nodes[1], 0);
1133 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event_0_1.commitment_msg, true, true);
1134 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1135 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
1136 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
1137 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
1138 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
1142 fn conditionally_round_fwd_amt() {
1143 // Previously, the (rng-found) feerates below caught a bug where an intermediate node would
1144 // calculate an amt_to_forward that underpaid them by 1 msat, caused by rounding up the outbound
1145 // amount on top of an already rounded-up total routing fee. Ensure that we'll conditionally round
1146 // down intermediate nodes' outbound amounts based on whether rounding up will result in
1147 // undercharging for relay.
1148 let chanmon_cfgs = create_chanmon_cfgs(5);
1149 let node_cfgs = create_node_cfgs(5, &chanmon_cfgs);
1151 let mut node_1_cfg = test_default_channel_config();
1152 node_1_cfg.channel_config.forwarding_fee_base_msat = 247371;
1153 node_1_cfg.channel_config.forwarding_fee_proportional_millionths = 86552;
1155 let mut node_2_cfg = test_default_channel_config();
1156 node_2_cfg.channel_config.forwarding_fee_base_msat = 198921;
1157 node_2_cfg.channel_config.forwarding_fee_proportional_millionths = 681759;
1159 let mut node_3_cfg = test_default_channel_config();
1160 node_3_cfg.channel_config.forwarding_fee_base_msat = 132845;
1161 node_3_cfg.channel_config.forwarding_fee_proportional_millionths = 552561;
1163 let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &[None, Some(node_1_cfg), Some(node_2_cfg), Some(node_3_cfg), None]);
1164 let nodes = create_network(5, &node_cfgs, &node_chanmgrs);
1165 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
1166 let chan_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
1167 let chan_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
1168 let chan_3_4 = create_announced_chan_between_nodes_with_value(&nodes, 3, 4, 1_000_000, 0);
1170 let amt_msat = 100_000;
1171 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[4], Some(amt_msat), None);
1172 let mut route_params = get_blinded_route_parameters(amt_msat, payment_secret,
1173 chan_1_2.1.contents.htlc_minimum_msat, chan_1_2.1.contents.htlc_maximum_msat,
1174 vec![nodes[1].node.get_our_node_id(), nodes[2].node.get_our_node_id(),
1175 nodes[3].node.get_our_node_id(), nodes[4].node.get_our_node_id()],
1176 &[&chan_1_2.0.contents, &chan_2_3.0.contents, &chan_3_4.0.contents],
1177 &chanmon_cfgs[4].keys_manager);
1178 route_params.max_total_routing_fee_msat = None;
1180 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
1181 check_added_monitors(&nodes[0], 1);
1182 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3], &nodes[4]]], amt_msat, payment_hash, payment_secret);
1183 nodes[4].node.claim_funds(payment_preimage);
1184 let expected_path = &[&nodes[1], &nodes[2], &nodes[3], &nodes[4]];
1185 let expected_route = &[&expected_path[..]];
1186 let mut args = ClaimAlongRouteArgs::new(&nodes[0], &expected_route[..], payment_preimage)
1187 .allow_1_msat_fee_overpay();
1188 let expected_fee = pass_claimed_payment_along_route(args);
1189 expect_payment_sent(&nodes[0], payment_preimage, Some(Some(expected_fee)), true, true);
1193 fn blinded_keysend() {
1194 let mut mpp_keysend_config = test_default_channel_config();
1195 mpp_keysend_config.accept_mpp_keysend = true;
1196 let chanmon_cfgs = create_chanmon_cfgs(3);
1197 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1198 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, Some(mpp_keysend_config)]);
1199 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1200 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
1201 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
1203 let amt_msat = 5000;
1204 let (keysend_preimage, _, payment_secret) = get_payment_preimage_hash(&nodes[2], None, None);
1205 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1,
1207 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(),
1208 &[&chan_upd_1_2], &chanmon_cfgs[2].keys_manager);
1210 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();
1211 check_added_monitors(&nodes[0], 1);
1213 let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[2]]];
1214 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1215 assert_eq!(events.len(), 1);
1217 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
1218 pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash, Some(payment_secret), ev.clone(), true, Some(keysend_preimage));
1219 claim_payment_along_route(&nodes[0], expected_route, false, keysend_preimage);
1223 fn blinded_mpp_keysend() {
1224 let mut mpp_keysend_config = test_default_channel_config();
1225 mpp_keysend_config.accept_mpp_keysend = true;
1226 let chanmon_cfgs = create_chanmon_cfgs(4);
1227 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
1228 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, Some(mpp_keysend_config)]);
1229 let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
1231 create_announced_chan_between_nodes(&nodes, 0, 1);
1232 create_announced_chan_between_nodes(&nodes, 0, 2);
1233 let chan_1_3 = create_announced_chan_between_nodes(&nodes, 1, 3);
1234 let chan_2_3 = create_announced_chan_between_nodes(&nodes, 2, 3);
1236 let amt_msat = 15_000_000;
1237 let (keysend_preimage, _, payment_secret) = get_payment_preimage_hash(&nodes[3], None, None);
1238 let route_params = {
1239 let pay_params = PaymentParameters::blinded(
1241 blinded_payment_path(payment_secret, 1, 1_0000_0000,
1242 vec![nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_1_3.0.contents],
1243 &chanmon_cfgs[3].keys_manager
1245 blinded_payment_path(payment_secret, 1, 1_0000_0000,
1246 vec![nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_2_3.0.contents],
1247 &chanmon_cfgs[3].keys_manager
1251 .with_bolt12_features(channelmanager::provided_bolt12_invoice_features(&UserConfig::default()))
1253 RouteParameters::from_payment_params_and_value(pay_params, amt_msat)
1256 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();
1257 check_added_monitors!(nodes[0], 2);
1259 let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]];
1260 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1261 assert_eq!(events.len(), 2);
1263 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
1264 pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash.clone(),
1265 Some(payment_secret), ev.clone(), false, Some(keysend_preimage));
1267 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
1268 pass_along_path(&nodes[0], expected_route[1], amt_msat, payment_hash.clone(),
1269 Some(payment_secret), ev.clone(), true, Some(keysend_preimage));
1270 claim_payment_along_route(&nodes[0], expected_route, false, keysend_preimage);
1274 fn custom_tlvs_to_blinded_path() {
1275 let chanmon_cfgs = create_chanmon_cfgs(2);
1276 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1277 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1278 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1279 let chan_upd = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0).0.contents;
1281 let amt_msat = 5000;
1282 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[1], Some(amt_msat), None);
1283 let payee_tlvs = ReceiveTlvs {
1285 payment_constraints: PaymentConstraints {
1286 max_cltv_expiry: u32::max_value(),
1287 htlc_minimum_msat: chan_upd.htlc_minimum_msat,
1289 payment_context: PaymentContext::unknown(),
1291 let mut secp_ctx = Secp256k1::new();
1292 let blinded_path = BlindedPath::one_hop_for_payment(
1293 nodes[1].node.get_our_node_id(), payee_tlvs, TEST_FINAL_CLTV as u16,
1294 &chanmon_cfgs[1].keys_manager, &secp_ctx
1297 let route_params = RouteParameters::from_payment_params_and_value(
1298 PaymentParameters::blinded(vec![blinded_path]),
1302 let recipient_onion_fields = RecipientOnionFields::spontaneous_empty()
1303 .with_custom_tlvs(vec![((1 << 16) + 1, vec![42, 42])])
1305 nodes[0].node.send_payment(payment_hash, recipient_onion_fields.clone(),
1306 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
1307 check_added_monitors(&nodes[0], 1);
1309 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1310 assert_eq!(events.len(), 1);
1311 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
1313 let path = &[&nodes[1]];
1314 let args = PassAlongPathArgs::new(&nodes[0], path, amt_msat, payment_hash, ev)
1315 .with_payment_secret(payment_secret)
1316 .with_custom_tlvs(recipient_onion_fields.custom_tlvs.clone());
1317 do_pass_along_path(args);
1318 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);