+fn do_test_onion_failure_stale_channel_update(announced_channel: bool) {
+ // Create a network of three nodes and two channels connecting them. We'll be updating the
+ // HTLC relay policy of the second channel, causing forwarding failures at the first hop.
+ let mut config = UserConfig::default();
+ config.channel_handshake_config.announced_channel = announced_channel;
+ config.channel_handshake_limits.force_announced_channel_preference = false;
+ config.accept_forwards_to_priv_channels = !announced_channel;
+ let chanmon_cfgs = create_chanmon_cfgs(3);
+ let persister;
+ let chain_monitor;
+ let channel_manager_1_deserialized;
+ let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
+ let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(config), None]);
+ let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+
+ let other_channel = create_chan_between_nodes(
+ &nodes[0], &nodes[1],
+ );
+ let channel_to_update = if announced_channel {
+ let channel = create_announced_chan_between_nodes(
+ &nodes, 1, 2,
+ );
+ (channel.2, channel.0.contents.short_channel_id)
+ } else {
+ let channel = create_unannounced_chan_between_nodes_with_value(
+ &nodes, 1, 2, 100000, 10001,
+ );
+ (channel.0.channel_id, channel.0.short_channel_id_alias.unwrap())
+ };
+ let channel_to_update_counterparty = &nodes[2].node.get_our_node_id();
+
+ let default_config = ChannelConfig::default();
+
+ // A test payment should succeed as the ChannelConfig has not been changed yet.
+ const PAYMENT_AMT: u64 = 40000;
+ let (route, payment_hash, payment_preimage, payment_secret) = if announced_channel {
+ get_route_and_payment_hash!(nodes[0], nodes[2], PAYMENT_AMT)
+ } else {
+ let hop_hints = vec![RouteHint(vec![RouteHintHop {
+ src_node_id: nodes[1].node.get_our_node_id(),
+ short_channel_id: channel_to_update.1,
+ fees: RoutingFees {
+ base_msat: default_config.forwarding_fee_base_msat,
+ proportional_millionths: default_config.forwarding_fee_proportional_millionths,
+ },
+ cltv_expiry_delta: default_config.cltv_expiry_delta,
+ htlc_maximum_msat: None,
+ htlc_minimum_msat: None,
+ }])];
+ let payment_params = PaymentParameters::from_node_id(*channel_to_update_counterparty)
+ .with_features(nodes[2].node.invoice_features())
+ .with_route_hints(hop_hints);
+ get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, PAYMENT_AMT, TEST_FINAL_CLTV)
+ };
+ send_along_route_with_secret(&nodes[0], route.clone(), &[&[&nodes[1], &nodes[2]]], PAYMENT_AMT,
+ payment_hash, payment_secret);
+ claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
+
+ // Closure to force expiry of a channel's previous config.
+ let expire_prev_config = || {
+ for _ in 0..EXPIRE_PREV_CONFIG_TICKS {
+ nodes[1].node.timer_tick_occurred();
+ }
+ };
+
+ // Closure to update and retrieve the latest ChannelUpdate.
+ let update_and_get_channel_update = |config: &ChannelConfig, expect_new_update: bool,
+ prev_update: Option<&msgs::ChannelUpdate>, should_expire_prev_config: bool| -> Option<msgs::ChannelUpdate> {
+ nodes[1].node.update_channel_config(
+ channel_to_update_counterparty, &[channel_to_update.0], config,
+ ).unwrap();
+ let events = nodes[1].node.get_and_clear_pending_msg_events();
+ assert_eq!(events.len(), expect_new_update as usize);
+ if !expect_new_update {
+ return None;
+ }
+ let new_update = match &events[0] {
+ MessageSendEvent::BroadcastChannelUpdate { msg } => {
+ assert!(announced_channel);
+ msg.clone()
+ },
+ MessageSendEvent::SendChannelUpdate { node_id, msg } => {
+ assert_eq!(node_id, channel_to_update_counterparty);
+ assert!(!announced_channel);
+ msg.clone()
+ },
+ _ => panic!("expected Broadcast/SendChannelUpdate event"),
+ };
+ if prev_update.is_some() {
+ assert!(new_update.contents.timestamp > prev_update.unwrap().contents.timestamp)
+ }
+ if should_expire_prev_config {
+ expire_prev_config();
+ }
+ Some(new_update)
+ };
+
+ // We'll be attempting to route payments using the default ChannelUpdate for channels. This will
+ // lead to onion failures at the first hop once we update the ChannelConfig for the
+ // second hop.
+ let expect_onion_failure = |name: &str, error_code: u16, channel_update: &msgs::ChannelUpdate| {
+ let short_channel_id = channel_to_update.1;
+ let network_update = NetworkUpdate::ChannelUpdateMessage { msg: channel_update.clone() };
+ run_onion_failure_test(
+ name, 0, &nodes, &route, &payment_hash, &payment_secret, |_| {}, || {}, true,
+ Some(error_code), Some(network_update), Some(short_channel_id),
+ );
+ };
+
+ // Updates to cltv_expiry_delta below MIN_CLTV_EXPIRY_DELTA should fail with APIMisuseError.
+ let mut invalid_config = default_config.clone();
+ invalid_config.cltv_expiry_delta = 0;
+ match nodes[1].node.update_channel_config(
+ channel_to_update_counterparty, &[channel_to_update.0], &invalid_config,
+ ) {
+ Err(APIError::APIMisuseError{ .. }) => {},
+ _ => panic!("unexpected result applying invalid cltv_expiry_delta"),
+ }
+
+ // Increase the base fee which should trigger a new ChannelUpdate.
+ let mut config = nodes[1].node.list_usable_channels().iter()
+ .find(|channel| channel.channel_id == channel_to_update.0).unwrap()
+ .config.unwrap();
+ config.forwarding_fee_base_msat = u32::max_value();
+ let msg = update_and_get_channel_update(&config, true, None, false).unwrap();
+
+ // The old policy should still be in effect until a new block is connected.
+ send_along_route_with_secret(&nodes[0], route.clone(), &[&[&nodes[1], &nodes[2]]], PAYMENT_AMT,
+ payment_hash, payment_secret);
+ claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
+
+ // Connect a block, which should expire the previous config, leading to a failure when
+ // forwarding the HTLC.
+ expire_prev_config();
+ expect_onion_failure("fee_insufficient", UPDATE|12, &msg);
+
+ // Redundant updates should not trigger a new ChannelUpdate.
+ assert!(update_and_get_channel_update(&config, false, None, false).is_none());
+
+ // Similarly, updates that do not have an affect on ChannelUpdate should not trigger a new one.
+ config.force_close_avoidance_max_fee_satoshis *= 2;
+ assert!(update_and_get_channel_update(&config, false, None, false).is_none());
+
+ // Reset the base fee to the default and increase the proportional fee which should trigger a
+ // new ChannelUpdate.
+ config.forwarding_fee_base_msat = default_config.forwarding_fee_base_msat;
+ config.cltv_expiry_delta = u16::max_value();
+ let msg = update_and_get_channel_update(&config, true, Some(&msg), true).unwrap();
+ expect_onion_failure("incorrect_cltv_expiry", UPDATE|13, &msg);
+
+ // Reset the proportional fee and increase the CLTV expiry delta which should trigger a new
+ // ChannelUpdate.
+ config.cltv_expiry_delta = default_config.cltv_expiry_delta;
+ config.forwarding_fee_proportional_millionths = u32::max_value();
+ let msg = update_and_get_channel_update(&config, true, Some(&msg), true).unwrap();
+ expect_onion_failure("fee_insufficient", UPDATE|12, &msg);
+
+ // To test persistence of the updated config, we'll re-initialize the ChannelManager.
+ let config_after_restart = {
+ let chan_1_monitor_serialized = get_monitor!(nodes[1], other_channel.3).encode();
+ let chan_2_monitor_serialized = get_monitor!(nodes[1], channel_to_update.0).encode();
+ reload_node!(nodes[1], *nodes[1].node.get_current_default_configuration(), &nodes[1].node.encode(),
+ &[&chan_1_monitor_serialized, &chan_2_monitor_serialized], persister, chain_monitor, channel_manager_1_deserialized);
+ nodes[1].node.list_channels().iter()
+ .find(|channel| channel.channel_id == channel_to_update.0).unwrap()
+ .config.unwrap()
+ };
+ assert_eq!(config, config_after_restart);
+}
+
+#[test]
+fn test_onion_failure_stale_channel_update() {
+ do_test_onion_failure_stale_channel_update(false);
+ do_test_onion_failure_stale_channel_update(true);
+}
+
+#[test]
+fn test_always_create_tlv_format_onion_payloads() {
+ // Verify that we always generate tlv onion format payloads, even if the features specifically
+ // specifies no support for variable length onions, as the legacy payload format has been
+ // deprecated in BOLT4.
+ let chanmon_cfgs = create_chanmon_cfgs(3);
+ let mut node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
+
+ // Set `node[1]`'s init features to features which return `false` for
+ // `supports_variable_length_onion()`
+ let mut no_variable_length_onion_features = InitFeatures::empty();
+ no_variable_length_onion_features.set_static_remote_key_required();
+ *node_cfgs[1].override_init_features.borrow_mut() = Some(no_variable_length_onion_features);
+
+ let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
+ let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+
+ create_announced_chan_between_nodes(&nodes, 0, 1);
+ create_announced_chan_between_nodes(&nodes, 1, 2);
+
+ let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id())
+ .with_features(InvoiceFeatures::empty());
+ let (route, _payment_hash, _payment_preimage, _payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 40000, TEST_FINAL_CLTV);
+
+ let hops = &route.paths[0];
+ // Asserts that the first hop to `node[1]` signals no support for variable length onions.
+ assert!(!hops[0].node_features.supports_variable_length_onion());
+ // Asserts that the first hop to `node[1]` signals no support for variable length onions.
+ assert!(!hops[1].node_features.supports_variable_length_onion());
+
+ let cur_height = nodes[0].best_block_info().1 + 1;
+ let (onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, cur_height, &None).unwrap();
+
+ match onion_payloads[0].format {
+ msgs::OnionHopDataFormat::NonFinalNode {..} => {},
+ _ => { panic!(
+ "Should have generated a `msgs::OnionHopDataFormat::NonFinalNode` payload for `hops[0]`,
+ despite that the features signals no support for variable length onions"
+ )}
+ }
+ match onion_payloads[1].format {
+ msgs::OnionHopDataFormat::FinalNode {..} => {},
+ _ => {panic!(
+ "Should have generated a `msgs::OnionHopDataFormat::FinalNode` payload for `hops[1]`,
+ despite that the features signals no support for variable length onions"
+ )}
+ }
+}
+