1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
11 use crate::blinded_path::BlindedPath;
12 use crate::blinded_path::payment::{ForwardNode, ForwardTlvs, PaymentConstraints, PaymentRelay, ReceiveTlvs};
13 use crate::events::{Event, HTLCDestination, MessageSendEvent, MessageSendEventsProvider, PaymentFailureReason};
14 use crate::ln::PaymentSecret;
15 use crate::ln::channelmanager;
16 use crate::ln::channelmanager::{PaymentId, RecipientOnionFields};
17 use crate::ln::features::BlindedHopFeatures;
18 use crate::ln::functional_test_utils::*;
20 use crate::ln::msgs::ChannelMessageHandler;
21 use crate::ln::onion_utils;
22 use crate::ln::onion_utils::INVALID_ONION_BLINDING;
23 use crate::ln::outbound_payment::Retry;
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 for (node_id, chan_upd) in node_ids.iter().zip(channel_upds) {
37 intermediate_nodes.push(ForwardNode {
40 short_channel_id: chan_upd.short_channel_id,
41 payment_relay: PaymentRelay {
42 cltv_expiry_delta: chan_upd.cltv_expiry_delta,
43 fee_proportional_millionths: chan_upd.fee_proportional_millionths,
44 fee_base_msat: chan_upd.fee_base_msat,
46 payment_constraints: PaymentConstraints {
47 max_cltv_expiry: u32::max_value(),
48 htlc_minimum_msat: chan_upd.htlc_minimum_msat,
50 features: BlindedHopFeatures::empty(),
52 htlc_maximum_msat: chan_upd.htlc_maximum_msat,
55 let payee_tlvs = ReceiveTlvs {
57 payment_constraints: PaymentConstraints {
58 max_cltv_expiry: u32::max_value(),
59 htlc_minimum_msat: channel_upds.last().unwrap().htlc_minimum_msat,
62 let mut secp_ctx = Secp256k1::new();
63 BlindedPath::new_for_payment(
64 &intermediate_nodes[..], *node_ids.last().unwrap(), payee_tlvs,
65 channel_upds.last().unwrap().htlc_maximum_msat, TEST_FINAL_CLTV as u16, keys_manager, &secp_ctx
69 pub fn get_blinded_route_parameters(
70 amt_msat: u64, payment_secret: PaymentSecret, intro_node_min_htlc: u64, intro_node_max_htlc: u64,
71 node_ids: Vec<PublicKey>, channel_upds: &[&msgs::UnsignedChannelUpdate],
72 keys_manager: &test_utils::TestKeysInterface
73 ) -> RouteParameters {
74 RouteParameters::from_payment_params_and_value(
75 PaymentParameters::blinded(vec![
77 payment_secret, intro_node_min_htlc, intro_node_max_htlc, node_ids, channel_upds,
85 fn one_hop_blinded_path() {
86 do_one_hop_blinded_path(true);
87 do_one_hop_blinded_path(false);
90 fn do_one_hop_blinded_path(success: bool) {
91 let chanmon_cfgs = create_chanmon_cfgs(2);
92 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
93 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
94 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
95 let chan_upd = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0).0.contents;
98 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[1], Some(amt_msat), None);
99 let payee_tlvs = ReceiveTlvs {
101 payment_constraints: PaymentConstraints {
102 max_cltv_expiry: u32::max_value(),
103 htlc_minimum_msat: chan_upd.htlc_minimum_msat,
106 let mut secp_ctx = Secp256k1::new();
107 let blinded_path = BlindedPath::one_hop_for_payment(
108 nodes[1].node.get_our_node_id(), payee_tlvs, TEST_FINAL_CLTV as u16,
109 &chanmon_cfgs[1].keys_manager, &secp_ctx
112 let route_params = RouteParameters::from_payment_params_and_value(
113 PaymentParameters::blinded(vec![blinded_path]),
116 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(),
117 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
118 check_added_monitors(&nodes[0], 1);
119 pass_along_route(&nodes[0], &[&[&nodes[1]]], amt_msat, payment_hash, payment_secret);
121 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
123 fail_payment(&nodes[0], &[&nodes[1]], payment_hash);
128 fn mpp_to_one_hop_blinded_path() {
129 let chanmon_cfgs = create_chanmon_cfgs(4);
130 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
131 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
132 let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
133 let mut secp_ctx = Secp256k1::new();
135 create_announced_chan_between_nodes(&nodes, 0, 1);
136 create_announced_chan_between_nodes(&nodes, 0, 2);
137 let chan_upd_1_3 = create_announced_chan_between_nodes(&nodes, 1, 3).0.contents;
138 create_announced_chan_between_nodes(&nodes, 2, 3).0.contents;
140 let amt_msat = 15_000_000;
141 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
142 let payee_tlvs = ReceiveTlvs {
144 payment_constraints: PaymentConstraints {
145 max_cltv_expiry: u32::max_value(),
146 htlc_minimum_msat: chan_upd_1_3.htlc_minimum_msat,
149 let blinded_path = BlindedPath::one_hop_for_payment(
150 nodes[3].node.get_our_node_id(), payee_tlvs, TEST_FINAL_CLTV as u16,
151 &chanmon_cfgs[3].keys_manager, &secp_ctx
154 let bolt12_features =
155 channelmanager::provided_bolt12_invoice_features(&UserConfig::default());
156 let route_params = RouteParameters::from_payment_params_and_value(
157 PaymentParameters::blinded(vec![blinded_path]).with_bolt12_features(bolt12_features).unwrap(),
160 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
161 check_added_monitors(&nodes[0], 2);
163 let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]];
164 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
165 assert_eq!(events.len(), 2);
167 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
168 pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash.clone(),
169 Some(payment_secret), ev.clone(), false, None);
171 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
172 pass_along_path(&nodes[0], expected_route[1], amt_msat, payment_hash.clone(),
173 Some(payment_secret), ev.clone(), true, None);
174 claim_payment_along_route(&nodes[0], expected_route, false, payment_preimage);
178 fn mpp_to_three_hop_blinded_paths() {
179 let chanmon_cfgs = create_chanmon_cfgs(6);
180 let node_cfgs = create_node_cfgs(6, &chanmon_cfgs);
181 let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &[None, None, None, None, None, None]);
182 let nodes = create_network(6, &node_cfgs, &node_chanmgrs);
184 // Create this network topology so node 0 MPP's over 2 3-hop blinded paths:
190 create_announced_chan_between_nodes(&nodes, 0, 1);
191 create_announced_chan_between_nodes(&nodes, 0, 2);
192 let chan_upd_1_3 = create_announced_chan_between_nodes(&nodes, 1, 3).0.contents;
193 let chan_upd_2_4 = create_announced_chan_between_nodes(&nodes, 2, 4).0.contents;
194 let chan_upd_3_5 = create_announced_chan_between_nodes(&nodes, 3, 5).0.contents;
195 let chan_upd_4_5 = create_announced_chan_between_nodes(&nodes, 4, 5).0.contents;
197 let amt_msat = 15_000_000;
198 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[5], Some(amt_msat), None);
200 let path_1_params = get_blinded_route_parameters(
201 amt_msat, payment_secret, 1, 1_0000_0000, vec![
202 nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id(),
203 nodes[5].node.get_our_node_id()
204 ], &[&chan_upd_1_3, &chan_upd_3_5], &chanmon_cfgs[5].keys_manager
206 let path_2_params = get_blinded_route_parameters(
207 amt_msat, payment_secret, 1, 1_0000_0000, vec![
208 nodes[2].node.get_our_node_id(), nodes[4].node.get_our_node_id(),
209 nodes[5].node.get_our_node_id()
210 ], &[&chan_upd_2_4, &chan_upd_4_5], &chanmon_cfgs[5].keys_manager
212 let pay_params = PaymentParameters::blinded(
214 path_1_params.payment_params.payee.blinded_route_hints()[0].clone(),
215 path_2_params.payment_params.payee.blinded_route_hints()[0].clone()
218 .with_bolt12_features(channelmanager::provided_bolt12_invoice_features(&UserConfig::default()))
220 RouteParameters::from_payment_params_and_value(pay_params, amt_msat)
223 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(),
224 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
225 check_added_monitors(&nodes[0], 2);
227 let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[3], &nodes[5]], &[&nodes[2], &nodes[4], &nodes[5]]];
228 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
229 assert_eq!(events.len(), 2);
231 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
232 pass_along_path(&nodes[0], expected_route[0], amt_msat, payment_hash.clone(),
233 Some(payment_secret), ev.clone(), false, None);
235 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
236 pass_along_path(&nodes[0], expected_route[1], amt_msat, payment_hash.clone(),
237 Some(payment_secret), ev.clone(), true, None);
238 claim_payment_along_route(&nodes[0], expected_route, false, payment_preimage);
241 enum ForwardCheckFail {
242 // Fail a check on the inbound onion payload. In this case, we underflow when calculating the
243 // outgoing cltv_expiry.
245 // The forwarding node's payload is encoded as a receive, i.e. the next hop HMAC is [0; 32].
246 ForwardPayloadEncodedAsReceive,
247 // Fail a check on the outbound channel. In this case, our next-hop peer is offline.
248 OutboundChannelCheck,
252 fn forward_checks_failure() {
253 do_forward_checks_failure(ForwardCheckFail::InboundOnionCheck, true);
254 do_forward_checks_failure(ForwardCheckFail::InboundOnionCheck, false);
255 do_forward_checks_failure(ForwardCheckFail::ForwardPayloadEncodedAsReceive, true);
256 do_forward_checks_failure(ForwardCheckFail::ForwardPayloadEncodedAsReceive, false);
257 do_forward_checks_failure(ForwardCheckFail::OutboundChannelCheck, true);
258 do_forward_checks_failure(ForwardCheckFail::OutboundChannelCheck, false);
261 fn do_forward_checks_failure(check: ForwardCheckFail, intro_fails: bool) {
262 // Ensure we'll fail backwards properly if a forwarding check fails on initial update_add
264 let chanmon_cfgs = create_chanmon_cfgs(4);
265 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
266 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
267 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
268 // We need the session priv to construct a bogus onion packet later.
269 *nodes[0].keys_manager.override_random_bytes.lock().unwrap() = Some([3; 32]);
270 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
271 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
272 let chan_upd_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0).0.contents;
275 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
276 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
277 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(),
278 &[&chan_upd_1_2, &chan_upd_2_3], &chanmon_cfgs[3].keys_manager);
280 let route = get_route(&nodes[0], &route_params).unwrap();
281 node_cfgs[0].router.expect_find_route(route_params.clone(), Ok(route.clone()));
282 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
283 check_added_monitors(&nodes[0], 1);
285 macro_rules! cause_error {
286 ($src_node_idx: expr, $target_node_idx: expr, $update_add: expr) => {
288 ForwardCheckFail::InboundOnionCheck => {
289 $update_add.cltv_expiry = 10; // causes outbound CLTV expiry to underflow
291 ForwardCheckFail::ForwardPayloadEncodedAsReceive => {
292 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
293 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
294 let cur_height = nodes[0].best_block_info().1;
295 let (mut onion_payloads, ..) = onion_utils::build_onion_payloads(
296 &route.paths[0], amt_msat, RecipientOnionFields::spontaneous_empty(), cur_height, &None).unwrap();
297 // Remove the receive payload so the blinded forward payload is encoded as a final payload
298 // (i.e. next_hop_hmac == [0; 32])
299 onion_payloads.pop();
300 if $target_node_idx + 1 < nodes.len() {
301 onion_payloads.pop();
303 $update_add.onion_routing_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash).unwrap();
305 ForwardCheckFail::OutboundChannelCheck => {
306 // The intro node will see that the next-hop peer is disconnected and fail the HTLC backwards.
307 nodes[$src_node_idx].node.peer_disconnected(&nodes[$target_node_idx].node.get_our_node_id());
313 let mut updates_0_1 = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
314 let update_add = &mut updates_0_1.update_add_htlcs[0];
317 cause_error!(1, 2, update_add);
320 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &update_add);
321 check_added_monitors!(nodes[1], 0);
322 do_commitment_signed_dance(&nodes[1], &nodes[0], &updates_0_1.commitment_signed, true, true);
325 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
326 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
327 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
328 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
329 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
333 expect_pending_htlcs_forwardable!(nodes[1]);
334 check_added_monitors!(nodes[1], 1);
336 let mut updates_1_2 = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
337 let mut update_add = &mut updates_1_2.update_add_htlcs[0];
339 cause_error!(2, 3, update_add);
341 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add);
342 check_added_monitors!(nodes[2], 0);
343 do_commitment_signed_dance(&nodes[2], &nodes[1], &updates_1_2.commitment_signed, true, true);
345 let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
346 let update_malformed = &mut updates.update_fail_malformed_htlcs[0];
347 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
348 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
350 // Ensure the intro node will properly blind the error if its downstream node failed to do so.
351 update_malformed.sha256_of_onion = [1; 32];
352 update_malformed.failure_code = INVALID_ONION_BLINDING ^ 1;
353 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
354 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates.commitment_signed, true, false);
356 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
357 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
358 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
359 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
360 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
364 fn failed_backwards_to_intro_node() {
365 // Ensure the intro node will error backwards properly even if the downstream node did not blind
367 let chanmon_cfgs = create_chanmon_cfgs(3);
368 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
369 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
370 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
371 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
372 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
375 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
376 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
377 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2],
378 &chanmon_cfgs[2].keys_manager);
380 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
381 check_added_monitors(&nodes[0], 1);
383 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
384 assert_eq!(events.len(), 1);
385 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
386 let mut payment_event = SendEvent::from_event(ev);
388 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
389 check_added_monitors!(nodes[1], 0);
390 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event.commitment_msg, false, false);
391 expect_pending_htlcs_forwardable!(nodes[1]);
392 check_added_monitors!(&nodes[1], 1);
394 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
395 assert_eq!(events.len(), 1);
396 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
397 let mut payment_event = SendEvent::from_event(ev);
399 // Ensure the final node fails to handle the HTLC.
400 payment_event.msgs[0].onion_routing_packet.hop_data[0] ^= 1;
401 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
402 check_added_monitors!(nodes[2], 0);
403 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event.commitment_msg, true, true);
404 nodes[2].node.process_pending_htlc_forwards();
406 let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
407 let mut update_malformed = &mut updates.update_fail_malformed_htlcs[0];
408 // Check that the final node encodes its failure correctly.
409 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
410 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
412 // Modify such the final hop does not correctly blind their error so we can ensure the intro node
413 // converts it to the correct error.
414 update_malformed.sha256_of_onion = [1; 32];
415 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
416 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates.commitment_signed, true, false);
418 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
419 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
420 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
421 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
422 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
425 enum ProcessPendingHTLCsCheck {
431 fn forward_fail_in_process_pending_htlc_fwds() {
432 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdPeerDisconnected, true);
433 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdPeerDisconnected, false);
434 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdChannelClosed, true);
435 do_forward_fail_in_process_pending_htlc_fwds(ProcessPendingHTLCsCheck::FwdChannelClosed, false);
437 fn do_forward_fail_in_process_pending_htlc_fwds(check: ProcessPendingHTLCsCheck, intro_fails: bool) {
438 // Ensure the intro node will error backwards properly if the HTLC fails in
439 // process_pending_htlc_forwards.
440 let chanmon_cfgs = create_chanmon_cfgs(4);
441 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
442 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
443 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
444 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
445 let (chan_upd_1_2, chan_id_1_2) = {
446 let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
447 (chan.0.contents, chan.2)
449 let (chan_upd_2_3, chan_id_2_3) = {
450 let chan = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
451 (chan.0.contents, chan.2)
455 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
456 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
457 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2, &chan_upd_2_3],
458 &chanmon_cfgs[2].keys_manager);
460 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
461 check_added_monitors(&nodes[0], 1);
463 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
464 assert_eq!(events.len(), 1);
465 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
466 let mut payment_event = SendEvent::from_event(ev);
468 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
469 check_added_monitors!(nodes[1], 0);
470 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event.commitment_msg, false, false);
472 macro_rules! cause_error {
473 ($prev_node: expr, $curr_node: expr, $next_node: expr, $failed_chan_id: expr, $failed_scid: expr) => {
475 ProcessPendingHTLCsCheck::FwdPeerDisconnected => {
476 // Disconnect the next-hop peer so when we go to forward in process_pending_htlc_forwards, the
477 // intro node will error backwards.
478 $curr_node.node.peer_disconnected(&$next_node.node.get_our_node_id());
479 expect_pending_htlcs_forwardable!($curr_node);
480 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!($curr_node,
481 vec![HTLCDestination::NextHopChannel { node_id: Some($next_node.node.get_our_node_id()), channel_id: $failed_chan_id }]);
483 ProcessPendingHTLCsCheck::FwdChannelClosed => {
484 // Force close the next-hop channel so when we go to forward in process_pending_htlc_forwards,
485 // the intro node will error backwards.
486 $curr_node.node.force_close_broadcasting_latest_txn(&$failed_chan_id, &$next_node.node.get_our_node_id()).unwrap();
487 let events = $curr_node.node.get_and_clear_pending_events();
489 crate::events::Event::PendingHTLCsForwardable { .. } => {},
490 _ => panic!("Unexpected event {:?}", events),
493 crate::events::Event::ChannelClosed { .. } => {},
494 _ => panic!("Unexpected event {:?}", events),
497 $curr_node.node.process_pending_htlc_forwards();
498 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!($curr_node,
499 vec![HTLCDestination::UnknownNextHop { requested_forward_scid: $failed_scid }]);
500 check_closed_broadcast(&$curr_node, 1, true);
501 check_added_monitors!($curr_node, 1);
502 $curr_node.node.process_pending_htlc_forwards();
509 cause_error!(nodes[0], nodes[1], nodes[2], chan_id_1_2, chan_upd_1_2.short_channel_id);
510 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
511 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
512 check_added_monitors!(nodes[1], 1);
513 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
515 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
516 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
520 expect_pending_htlcs_forwardable!(nodes[1]);
521 check_added_monitors!(nodes[1], 1);
523 let mut updates_1_2 = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
524 let mut update_add = &mut updates_1_2.update_add_htlcs[0];
525 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add);
526 check_added_monitors!(nodes[2], 0);
527 do_commitment_signed_dance(&nodes[2], &nodes[1], &updates_1_2.commitment_signed, true, true);
529 cause_error!(nodes[1], nodes[2], nodes[3], chan_id_2_3, chan_upd_2_3.short_channel_id);
530 check_added_monitors!(nodes[2], 1);
532 let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
533 let update_malformed = &mut updates.update_fail_malformed_htlcs[0];
534 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
535 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
537 // Ensure the intro node will properly blind the error if its downstream node failed to do so.
538 update_malformed.sha256_of_onion = [1; 32];
539 update_malformed.failure_code = INVALID_ONION_BLINDING ^ 1;
540 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
541 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates.commitment_signed, true, false);
543 let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
544 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
545 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates.commitment_signed, false, false);
546 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
547 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
551 fn blinded_intercept_payment() {
552 do_blinded_intercept_payment(true);
553 do_blinded_intercept_payment(false);
555 fn do_blinded_intercept_payment(intercept_node_fails: bool) {
556 let chanmon_cfgs = create_chanmon_cfgs(3);
557 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
558 let mut intercept_forwards_config = test_default_channel_config();
559 intercept_forwards_config.accept_intercept_htlcs = true;
560 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(intercept_forwards_config), None]);
561 let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
562 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
563 let (channel_id, chan_upd) = {
564 let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
565 (chan.2, chan.0.contents)
569 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
570 let intercept_scid = nodes[1].node.get_intercept_scid();
571 let mut intercept_chan_upd = chan_upd;
572 intercept_chan_upd.short_channel_id = intercept_scid;
573 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
574 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&intercept_chan_upd],
575 &chanmon_cfgs[2].keys_manager);
577 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(),
578 PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
579 check_added_monitors(&nodes[0], 1);
580 let payment_event = {
581 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
582 assert_eq!(events.len(), 1);
583 SendEvent::from_event(events.remove(0))
585 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
586 commitment_signed_dance!(nodes[1], nodes[0], &payment_event.commitment_msg, false, true);
588 let events = nodes[1].node.get_and_clear_pending_events();
589 assert_eq!(events.len(), 1);
590 let (intercept_id, expected_outbound_amount_msat) = match events[0] {
591 crate::events::Event::HTLCIntercepted {
592 intercept_id, payment_hash: pmt_hash,
593 requested_next_hop_scid: short_channel_id, expected_outbound_amount_msat, ..
595 assert_eq!(pmt_hash, payment_hash);
596 assert_eq!(short_channel_id, intercept_scid);
597 (intercept_id, expected_outbound_amount_msat)
602 if intercept_node_fails {
603 nodes[1].node.fail_intercepted_htlc(intercept_id).unwrap();
604 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(nodes[1], vec![HTLCDestination::UnknownNextHop { requested_forward_scid: intercept_scid }]);
605 nodes[1].node.process_pending_htlc_forwards();
606 let update_fail = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
607 check_added_monitors!(&nodes[1], 1);
608 assert!(update_fail.update_fail_htlcs.len() == 1);
609 let fail_msg = update_fail.update_fail_htlcs[0].clone();
610 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_msg);
611 commitment_signed_dance!(nodes[0], nodes[1], update_fail.commitment_signed, false);
612 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
613 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
617 nodes[1].node.forward_intercepted_htlc(intercept_id, &channel_id, nodes[2].node.get_our_node_id(), expected_outbound_amount_msat).unwrap();
618 expect_pending_htlcs_forwardable!(nodes[1]);
620 let payment_event = {
622 let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap();
623 assert_eq!(added_monitors.len(), 1);
624 added_monitors.clear();
626 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
627 assert_eq!(events.len(), 1);
628 SendEvent::from_event(events.remove(0))
630 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
631 commitment_signed_dance!(nodes[2], nodes[1], &payment_event.commitment_msg, false, true);
632 expect_pending_htlcs_forwardable!(nodes[2]);
634 expect_payment_claimable!(&nodes[2], payment_hash, payment_secret, amt_msat, None, nodes[2].node.get_our_node_id());
635 do_claim_payment_along_route(&nodes[0], &vec!(&vec!(&nodes[1], &nodes[2])[..]), false, payment_preimage);
636 expect_payment_sent(&nodes[0], payment_preimage, Some(Some(1000)), true, true);
640 fn two_hop_blinded_path_success() {
641 let chanmon_cfgs = create_chanmon_cfgs(3);
642 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
643 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
644 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
645 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
646 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
649 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
650 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
651 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2],
652 &chanmon_cfgs[2].keys_manager);
654 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
655 check_added_monitors(&nodes[0], 1);
656 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], amt_msat, payment_hash, payment_secret);
657 claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
661 fn three_hop_blinded_path_success() {
662 let chanmon_cfgs = create_chanmon_cfgs(5);
663 let node_cfgs = create_node_cfgs(5, &chanmon_cfgs);
664 let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &[None, None, None, None, None]);
665 let mut nodes = create_network(5, &node_cfgs, &node_chanmgrs);
666 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
667 create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
668 let chan_upd_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0).0.contents;
669 let chan_upd_3_4 = create_announced_chan_between_nodes_with_value(&nodes, 3, 4, 1_000_000, 0).0.contents;
671 // Get all our nodes onto the same height so payments don't fail for CLTV violations.
672 connect_blocks(&nodes[0], nodes[4].best_block_info().1 - nodes[0].best_block_info().1);
673 connect_blocks(&nodes[1], nodes[4].best_block_info().1 - nodes[1].best_block_info().1);
674 connect_blocks(&nodes[2], nodes[4].best_block_info().1 - nodes[2].best_block_info().1);
675 assert_eq!(nodes[4].best_block_info().1, nodes[3].best_block_info().1);
678 let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[4], Some(amt_msat), None);
679 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
680 nodes.iter().skip(2).map(|n| n.node.get_our_node_id()).collect(),
681 &[&chan_upd_2_3, &chan_upd_3_4], &chanmon_cfgs[4].keys_manager);
683 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
684 check_added_monitors(&nodes[0], 1);
685 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3], &nodes[4]]], amt_msat, payment_hash, payment_secret);
686 claim_payment(&nodes[0], &[&nodes[1], &nodes[2], &nodes[3], &nodes[4]], payment_preimage);
690 fn three_hop_blinded_path_fail() {
691 // Test that an intermediate blinded forwarding node gets failed back to with
692 // malformed and also fails back themselves with malformed.
693 let chanmon_cfgs = create_chanmon_cfgs(4);
694 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
695 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
696 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
697 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
698 let chan_upd_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
699 let chan_upd_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0).0.contents;
702 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
703 let route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
704 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(),
705 &[&chan_upd_1_2, &chan_upd_2_3], &chanmon_cfgs[3].keys_manager);
707 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
708 check_added_monitors(&nodes[0], 1);
709 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2], &nodes[3]]], amt_msat, payment_hash, payment_secret);
711 nodes[3].node.fail_htlc_backwards(&payment_hash);
712 expect_pending_htlcs_forwardable_conditions(
713 nodes[3].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }]
715 nodes[3].node.process_pending_htlc_forwards();
716 check_added_monitors!(nodes[3], 1);
718 let updates_3_2 = get_htlc_update_msgs!(nodes[3], nodes[2].node.get_our_node_id());
719 assert_eq!(updates_3_2.update_fail_malformed_htlcs.len(), 1);
720 let update_malformed = &updates_3_2.update_fail_malformed_htlcs[0];
721 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
722 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
723 nodes[2].node.handle_update_fail_malformed_htlc(&nodes[3].node.get_our_node_id(), update_malformed);
724 do_commitment_signed_dance(&nodes[2], &nodes[3], &updates_3_2.commitment_signed, true, false);
726 let updates_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
727 assert_eq!(updates_2_1.update_fail_malformed_htlcs.len(), 1);
728 let update_malformed = &updates_2_1.update_fail_malformed_htlcs[0];
729 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
730 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
731 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
732 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates_2_1.commitment_signed, true, false);
734 let updates_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
735 assert_eq!(updates_1_0.update_fail_htlcs.len(), 1);
736 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_1_0.update_fail_htlcs[0]);
737 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates_1_0.commitment_signed, false, false);
738 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
739 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
743 enum ReceiveCheckFail {
744 // The recipient fails the payment upon `PaymentClaimable`.
746 // Failure to decode the recipient's onion payload.
748 // The incoming HTLC did not satisfy our requirements; in this case it underpaid us according to
749 // the expected receive amount in the onion.
751 // The incoming HTLC errors when added to the Channel, in this case due to the HTLC being
752 // delivered out-of-order with a shutdown message.
754 // The HTLC is successfully added to the inbound channel but fails receive checks in
755 // process_pending_htlc_forwards.
756 ProcessPendingHTLCsCheck,
757 // The HTLC violates the `PaymentConstraints` contained within the receiver's encrypted payload.
762 fn multi_hop_receiver_fail() {
763 do_multi_hop_receiver_fail(ReceiveCheckFail::RecipientFail);
764 do_multi_hop_receiver_fail(ReceiveCheckFail::OnionDecodeFail);
765 do_multi_hop_receiver_fail(ReceiveCheckFail::ReceiveRequirements);
766 do_multi_hop_receiver_fail(ReceiveCheckFail::ChannelCheck);
767 do_multi_hop_receiver_fail(ReceiveCheckFail::ProcessPendingHTLCsCheck);
768 do_multi_hop_receiver_fail(ReceiveCheckFail::PaymentConstraints);
771 fn do_multi_hop_receiver_fail(check: ReceiveCheckFail) {
772 // Test that the receiver to a multihop blinded path fails back correctly.
773 let chanmon_cfgs = create_chanmon_cfgs(3);
774 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
775 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
776 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
777 // We need the session priv to construct an invalid onion packet later.
778 let session_priv = [3; 32];
779 *nodes[0].keys_manager.override_random_bytes.lock().unwrap() = Some(session_priv);
780 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
781 let (chan_upd_1_2, chan_id_1_2) = {
782 let (chan_upd, _, channel_id, ..) = create_announced_chan_between_nodes_with_value(
783 &nodes, 1, 2, 1_000_000, 0
785 (chan_upd.contents, channel_id)
789 let excess_final_cltv_delta_opt = if check == ReceiveCheckFail::ProcessPendingHTLCsCheck {
790 // Set the final CLTV expiry too low to trigger the failure in process_pending_htlc_forwards.
791 Some(TEST_FINAL_CLTV as u16 - 2)
793 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), excess_final_cltv_delta_opt);
794 let mut route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
795 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_upd_1_2],
796 &chanmon_cfgs[2].keys_manager);
798 let route = if check == ReceiveCheckFail::ProcessPendingHTLCsCheck {
799 let mut route = get_route(&nodes[0], &route_params).unwrap();
800 // Set the final CLTV expiry too low to trigger the failure in process_pending_htlc_forwards.
801 route.paths[0].hops.last_mut().map(|h| h.cltv_expiry_delta += excess_final_cltv_delta_opt.unwrap() as u32);
802 route.paths[0].blinded_tail.as_mut().map(|bt| bt.excess_final_cltv_expiry_delta = excess_final_cltv_delta_opt.unwrap() as u32);
804 } else if check == ReceiveCheckFail::PaymentConstraints {
805 // Create a blinded path where the receiver's encrypted payload has an htlc_minimum_msat that is
806 // violated by `amt_msat`, and stick it in the route_params without changing the corresponding
807 // BlindedPayInfo (to ensure pathfinding still succeeds).
808 let high_htlc_min_bp = {
809 let mut high_htlc_minimum_upd = chan_upd_1_2.clone();
810 high_htlc_minimum_upd.htlc_minimum_msat = amt_msat + 1000;
811 let high_htlc_min_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
812 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&high_htlc_minimum_upd],
813 &chanmon_cfgs[2].keys_manager);
814 if let Payee::Blinded { route_hints, .. } = high_htlc_min_params.payment_params.payee {
815 route_hints[0].1.clone()
818 if let Payee::Blinded { ref mut route_hints, .. } = route_params.payment_params.payee {
819 route_hints[0].1 = high_htlc_min_bp;
821 find_route(&nodes[0], &route_params).unwrap()
823 find_route(&nodes[0], &route_params).unwrap()
825 node_cfgs[0].router.expect_find_route(route_params.clone(), Ok(route.clone()));
826 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
827 check_added_monitors(&nodes[0], 1);
829 let mut payment_event_0_1 = {
830 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
831 assert_eq!(events.len(), 1);
832 let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
833 SendEvent::from_event(ev)
835 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_0_1.msgs[0]);
836 check_added_monitors!(nodes[1], 0);
837 do_commitment_signed_dance(&nodes[1], &nodes[0], &payment_event_0_1.commitment_msg, false, false);
838 expect_pending_htlcs_forwardable!(nodes[1]);
839 check_added_monitors!(&nodes[1], 1);
841 let mut payment_event_1_2 = {
842 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
843 assert_eq!(events.len(), 1);
844 let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
845 SendEvent::from_event(ev)
849 ReceiveCheckFail::RecipientFail => {
850 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
851 check_added_monitors!(nodes[2], 0);
852 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
853 expect_pending_htlcs_forwardable!(nodes[2]);
854 check_payment_claimable(
855 &nodes[2].node.get_and_clear_pending_events()[0], payment_hash, payment_secret, amt_msat,
856 None, nodes[2].node.get_our_node_id()
858 nodes[2].node.fail_htlc_backwards(&payment_hash);
859 expect_pending_htlcs_forwardable_conditions(
860 nodes[2].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }]
862 nodes[2].node.process_pending_htlc_forwards();
863 check_added_monitors!(nodes[2], 1);
865 ReceiveCheckFail::OnionDecodeFail => {
866 let session_priv = SecretKey::from_slice(&session_priv).unwrap();
867 let mut onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
868 let cur_height = nodes[0].best_block_info().1;
869 let (mut onion_payloads, ..) = onion_utils::build_onion_payloads(
870 &route.paths[0], amt_msat, RecipientOnionFields::spontaneous_empty(), cur_height, &None).unwrap();
872 let update_add = &mut payment_event_1_2.msgs[0];
873 onion_payloads.last_mut().map(|p| {
874 if let msgs::OutboundOnionPayload::BlindedReceive { ref mut intro_node_blinding_point, .. } = p {
875 // The receiver should error if both the update_add blinding_point and the
876 // intro_node_blinding_point are set.
877 assert!(intro_node_blinding_point.is_none() && update_add.blinding_point.is_some());
878 *intro_node_blinding_point = Some(PublicKey::from_slice(&[2; 33]).unwrap());
881 update_add.onion_routing_packet = onion_utils::construct_onion_packet(
882 vec![onion_payloads.pop().unwrap()], vec![onion_keys.pop().unwrap()], [0; 32],
885 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), update_add);
886 check_added_monitors!(nodes[2], 0);
887 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
889 ReceiveCheckFail::ReceiveRequirements => {
890 let update_add = &mut payment_event_1_2.msgs[0];
891 update_add.amount_msat -= 1;
892 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), update_add);
893 check_added_monitors!(nodes[2], 0);
894 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
896 ReceiveCheckFail::ChannelCheck => {
897 nodes[2].node.close_channel(&chan_id_1_2, &nodes[1].node.get_our_node_id()).unwrap();
898 let node_2_shutdown = get_event_msg!(nodes[2], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
899 nodes[1].node.handle_shutdown(&nodes[2].node.get_our_node_id(), &node_2_shutdown);
900 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
902 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
903 nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event_1_2.commitment_msg);
904 check_added_monitors!(nodes[2], 1);
906 nodes[2].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
907 commitment_signed_dance!(nodes[2], nodes[1], (), false, true, false, false);
909 ReceiveCheckFail::ProcessPendingHTLCsCheck => {
910 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);
911 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
912 check_added_monitors!(nodes[2], 0);
913 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
914 expect_pending_htlcs_forwardable!(nodes[2]);
915 expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(nodes[2],
916 vec![HTLCDestination::FailedPayment { payment_hash }]);
917 check_added_monitors!(nodes[2], 1);
919 ReceiveCheckFail::PaymentConstraints => {
920 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_1_2.msgs[0]);
921 check_added_monitors!(nodes[2], 0);
922 do_commitment_signed_dance(&nodes[2], &nodes[1], &payment_event_1_2.commitment_msg, true, true);
926 let updates_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
927 assert_eq!(updates_2_1.update_fail_malformed_htlcs.len(), 1);
928 let update_malformed = &updates_2_1.update_fail_malformed_htlcs[0];
929 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
930 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
931 nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), update_malformed);
932 do_commitment_signed_dance(&nodes[1], &nodes[2], &updates_2_1.commitment_signed, true, false);
934 let updates_1_0 = if check == ReceiveCheckFail::ChannelCheck {
935 let events = nodes[1].node.get_and_clear_pending_msg_events();
936 assert_eq!(events.len(), 2);
937 events.into_iter().find_map(|ev| {
939 MessageSendEvent:: UpdateHTLCs { node_id, updates } => {
940 assert_eq!(node_id, nodes[0].node.get_our_node_id());
943 MessageSendEvent::SendClosingSigned { .. } => None,
947 } else { get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()) };
948 assert_eq!(updates_1_0.update_fail_htlcs.len(), 1);
949 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_1_0.update_fail_htlcs[0]);
950 do_commitment_signed_dance(&nodes[0], &nodes[1], &updates_1_0.commitment_signed, false, false);
951 expect_payment_failed_conditions(&nodes[0], payment_hash, false,
952 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
956 fn blinded_path_retries() {
957 let chanmon_cfgs = create_chanmon_cfgs(4);
958 // Make one blinded path's fees slightly higher so they are tried in a deterministic order.
959 let mut higher_fee_chan_cfg = test_default_channel_config();
960 higher_fee_chan_cfg.channel_config.forwarding_fee_base_msat += 1;
961 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
962 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, Some(higher_fee_chan_cfg), None]);
963 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
965 // Create this network topology so nodes[0] has a blinded route hint to retry over.
971 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
972 create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1_000_000, 0);
973 let chan_1_3 = create_announced_chan_between_nodes_with_value(&nodes, 1, 3, 1_000_000, 0);
974 let chan_2_3 = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 1_000_000, 0);
977 let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
979 let pay_params = PaymentParameters::blinded(
981 blinded_payment_path(payment_secret, 1, 1_0000_0000,
982 vec![nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_1_3.0.contents],
983 &chanmon_cfgs[3].keys_manager
985 blinded_payment_path(payment_secret, 1, 1_0000_0000,
986 vec![nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()], &[&chan_2_3.0.contents],
987 &chanmon_cfgs[3].keys_manager
991 .with_bolt12_features(channelmanager::provided_bolt12_invoice_features(&UserConfig::default()))
993 RouteParameters::from_payment_params_and_value(pay_params, amt_msat)
996 nodes[0].node.send_payment(payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0), route_params.clone(), Retry::Attempts(2)).unwrap();
997 check_added_monitors(&nodes[0], 1);
998 pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[3]]], amt_msat, payment_hash, payment_secret);
1000 macro_rules! fail_payment_back {
1001 ($intro_node: expr) => {
1002 nodes[3].node.fail_htlc_backwards(&payment_hash);
1003 expect_pending_htlcs_forwardable_conditions(
1004 nodes[3].node.get_and_clear_pending_events(), &[HTLCDestination::FailedPayment { payment_hash }]
1006 nodes[3].node.process_pending_htlc_forwards();
1007 check_added_monitors!(nodes[3], 1);
1009 let updates = get_htlc_update_msgs!(nodes[3], $intro_node.node.get_our_node_id());
1010 assert_eq!(updates.update_fail_malformed_htlcs.len(), 1);
1011 let update_malformed = &updates.update_fail_malformed_htlcs[0];
1012 assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
1013 assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
1014 $intro_node.node.handle_update_fail_malformed_htlc(&nodes[3].node.get_our_node_id(), update_malformed);
1015 do_commitment_signed_dance(&$intro_node, &nodes[3], &updates.commitment_signed, true, false);
1017 let updates = get_htlc_update_msgs!($intro_node, nodes[0].node.get_our_node_id());
1018 assert_eq!(updates.update_fail_htlcs.len(), 1);
1019 nodes[0].node.handle_update_fail_htlc(&$intro_node.node.get_our_node_id(), &updates.update_fail_htlcs[0]);
1020 do_commitment_signed_dance(&nodes[0], &$intro_node, &updates.commitment_signed, false, false);
1022 let mut events = nodes[0].node.get_and_clear_pending_events();
1023 assert_eq!(events.len(), 2);
1025 Event::PaymentPathFailed { payment_hash: ev_payment_hash, payment_failed_permanently, .. } => {
1026 assert_eq!(payment_hash, ev_payment_hash);
1027 assert_eq!(payment_failed_permanently, false);
1029 _ => panic!("Unexpected event"),
1032 Event::PendingHTLCsForwardable { .. } => {},
1033 _ => panic!("Unexpected event"),
1035 nodes[0].node.process_pending_htlc_forwards();
1039 fail_payment_back!(nodes[1]);
1041 // Pass the retry along.
1042 check_added_monitors!(nodes[0], 1);
1043 let mut msg_events = nodes[0].node.get_and_clear_pending_msg_events();
1044 assert_eq!(msg_events.len(), 1);
1045 pass_along_path(&nodes[0], &[&nodes[2], &nodes[3]], amt_msat, payment_hash, Some(payment_secret), msg_events.pop().unwrap(), true, None);
1047 fail_payment_back!(nodes[2]);
1048 let evs = nodes[0].node.get_and_clear_pending_events();
1049 assert_eq!(evs.len(), 1);
1051 Event::PaymentFailed { payment_hash: ev_payment_hash, reason, .. } => {
1052 assert_eq!(ev_payment_hash, payment_hash);
1053 // We have 1 retry attempt remaining, but we're out of blinded paths to try.
1054 assert_eq!(reason, Some(PaymentFailureReason::RouteNotFound));