Three-hop blinded paths

lightning/src/blinded_path/payment.rs

@@ -23,6 +23,7 @@ use crate::ln::msgs::DecodeError;
 use crate::offers::invoice::BlindedPayInfo;
 use crate::offers::invoice_request::InvoiceRequestFields;
 use crate::offers::offer::OfferId;
+use crate::routing::gossip::DirectedChannelInfo;
 use crate::util::ser::{HighZeroBytesDroppedBigSize, Readable, Writeable, Writer};
 
 #[allow(unused_imports)]
@@ -170,6 +171,19 @@ impl PaymentContext {
 	}
 }
 
+impl PaymentRelay {
+	fn normalize_cltv_expiry_delta(cltv_expiry_delta: u16) -> Result<u16, ()> {
+ // Avoid exposing esoteric CLTV expiry deltas, which could de-anonymize the path.
+ match cltv_expiry_delta {
+ 0..=40 => Ok(40),
+ 41..=80 => Ok(80),
+ 81..=144 => Ok(144),
+ 145..=216 => Ok(216),
+ _ => Err(()),
+ }
+	}
+}
+
 impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
 	type Error = ();
 
@@ -178,16 +192,25 @@ impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
  fee_base_msat, fee_proportional_millionths, cltv_expiry_delta
  } = info;
 
- // Avoid exposing esoteric CLTV expiry deltas
- let cltv_expiry_delta = match cltv_expiry_delta {
- 0..=40 => 40,
- 41..=80 => 80,
- 81..=144 => 144,
- 145..=216 => 216,
- _ => return Err(()),
- };
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(cltv_expiry_delta)?,
+ fee_proportional_millionths,
+ fee_base_msat
+ })
+	}
+}
+
+impl<'a> TryFrom<DirectedChannelInfo<'a>> for PaymentRelay {
+	type Error = ();
+
+	fn try_from(info: DirectedChannelInfo<'a>) -> Result<Self, ()> {
+ let direction = info.direction();
 
- Ok(Self { cltv_expiry_delta, fee_proportional_millionths, fee_base_msat })
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(direction.cltv_expiry_delta)?,
+ fee_proportional_millionths: direction.fees.proportional_millionths,
+ fee_base_msat: direction.fees.base_msat,
+ })
 	}
 }
 

lightning/src/onion_message/messenger.rs

@@ -186,7 +186,7 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// &keys_manager, &keys_manager, logger, &node_id_lookup, message_router,
 /// &offers_message_handler, &custom_message_handler
 /// );
-
+///
 /// # #[derive(Debug)]
 /// # struct YourCustomMessage {}
 /// impl Writeable for YourCustomMessage {
@@ -195,13 +195,15 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// // Write your custom onion message to `w`
 /// }
 /// }
+///
 /// impl OnionMessageContents for YourCustomMessage {
 /// fn tlv_type(&self) -> u64 {
 /// # let your_custom_message_type = 42;
 /// your_custom_message_type
 /// }
 /// fn msg_type(&self) -> &'static str { "YourCustomMessageType" }
 /// }
+///
 /// // Send a custom onion message to a node id.
 /// let destination = Destination::Node(destination_node_id);
 /// let reply_path = None;
@@ -457,6 +459,9 @@ pub trait MessageRouter {
 
 /// A [`MessageRouter`] that can only route to a directly connected [`Destination`].
 ///
+/// When creating [`BlindedPath`]s, prefers three-hop paths over two-hops paths for the compact
+/// representation. For the non-compact representation, three-hop paths are not considered.
+///
 /// # Privacy
 ///
 /// Creating [`BlindedPath`]s may affect privacy since, if a suitable path cannot be found, it will
@@ -488,6 +493,9 @@ where
 	>(
  &self, recipient: PublicKey, peers: I, secp_ctx: &Secp256k1<T>, compact_paths: bool
 	) -> Result<Vec<BlindedPath>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PATHS: usize = 3;
 
@@ -500,40 +508,69 @@ where
  network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient));
 
  let mut peer_info = peers
+ .map(|peer| (NodeId::from_pubkey(&peer.node_id), peer))
  // Limit to peers with announced channels
- .filter_map(|peer|
+ .filter_map(|(node_id, peer)|
  network_graph
- .node(&NodeId::from_pubkey(&peer.node_id))
+ .node(&node_id)
  .filter(|info| info.channels.len() >= MIN_PEER_CHANNELS)
- .map(|info| (peer, info.is_tor_only(), info.channels.len()))
+ .map(|info| (node_id, peer, info.is_tor_only(), &info.channels))
  )
  // Exclude Tor-only nodes when the recipient is announced.
- .filter(|(_, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
+ .filter(|(_, _, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
  .collect::<Vec<_>>();
 
  // Prefer using non-Tor nodes with the most channels as the introduction node.
- peer_info.sort_unstable_by(|(_, a_tor_only, a_channels), (_, b_tor_only, b_channels)| {
- a_tor_only.cmp(b_tor_only).then(a_channels.cmp(b_channels).reverse())
+ peer_info.sort_unstable_by(|(_, _, a_tor_only, a_channels), (_, _, b_tor_only, b_channels)| {
+ a_tor_only.cmp(b_tor_only).then(a_channels.len().cmp(&b_channels.len()).reverse())
  });
 
- let paths = peer_info.into_iter()
- .map(|(peer, _, _)| {
- BlindedPath::new_for_message(&[peer], recipient, &*self.entropy_source, secp_ctx)
- })
- .take(MAX_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- let mut paths = match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if is_recipient_announced {
- BlindedPath::one_hop_for_message(recipient, &*self.entropy_source, secp_ctx)
- .map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }?;
+ let three_hop_paths = peer_info.iter()
+ // Pair peers with their other peers
+ .flat_map(|(node_id, peer, _, channels)|
+ channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get(scid))
+ .filter_map(move |info| info
+ .as_directed_to(&node_id)
+ .map(|(_, source)| source)
+ )
+ .filter(|source| **source != recipient_node_id)
+ .filter(|source| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_onion_messages())
+ .unwrap_or(false)
+ )
+ .filter_map(|source| source.as_pubkey().ok())
+ .map(move |source_pubkey| (source_pubkey, peer.clone()))
+ )
+ .map(|(source_pubkey, peer)| BlindedPath::new_for_message(&[ForwardNode { node_id: source_pubkey, short_channel_id: None }, peer], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ let two_hop_paths = peer_info
+ .iter()
+ .map(|(_, peer, _, _)| BlindedPath::new_for_message(&[peer.clone()], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ // Prefer three-hop paths over two-hop paths for compact paths. Fallback to a one-hop path
+ // if none were found and the recipient node is announced.
+ let mut paths = (!compact_paths).then(|| vec![])
+ .or_else(|| three_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| is_recipient_announced
+ .then(|| BlindedPath::one_hop_for_message(recipient, entropy_source, secp_ctx)
+ .map(|path| vec![path])
+ .unwrap_or(vec![])
+ )
+ )
+ .ok_or(())?;
+
+ if paths.is_empty() {
+ return Err(());
+ }
 
  if compact_paths {
  for path in &mut paths {

lightning/src/routing/gossip.rs

@@ -1040,7 +1040,7 @@ impl<'a> DirectedChannelInfo<'a> {
 
 	/// Returns information for the direction.
 	#[inline]
-	pub(super) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
+	pub(crate) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
 
 	/// Returns the `node_id` of the source hop.
 	///

lightning/src/routing/router.rs

@@ -93,25 +93,37 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  &self, recipient: PublicKey, first_hops: Vec<ChannelDetails>, tlvs: ReceiveTlvs,
  amount_msats: u64, secp_ctx: &Secp256k1<T>
 	) -> Result<Vec<(BlindedPayInfo, BlindedPath)>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PAYMENT_PATHS: usize = 3;
 
  // Ensure peers have at least three channels so that it is more difficult to infer the
  // recipient's node_id.
  const MIN_PEER_CHANNELS: usize = 3;
 
+ // The minimum channel balance certainty required for using a channel in a blinded path.
+ const MIN_CHANNEL_CERTAINTY: f64 = 0.5;
+
+ // The minimum success probability required for using a channel in a blinded path.
+ const MIN_SUCCESS_PROBABILITY: f64 = 0.25;
+
  let network_graph = self.network_graph.deref().read_only();
- let paths = first_hops.into_iter()
+ let counterparty_channels = first_hops.into_iter()
  .filter(|details| details.counterparty.features.supports_route_blinding())
  .filter(|details| amount_msats <= details.inbound_capacity_msat)
  .filter(|details| amount_msats >= details.inbound_htlc_minimum_msat.unwrap_or(0))
  .filter(|details| amount_msats <= details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX))
- .filter(|details| network_graph
+ // Limit to counterparties with announced channels
+ .filter_map(|details|
+ network_graph
  .node(&NodeId::from_pubkey(&details.counterparty.node_id))
- .map(|node_info| node_info.channels.len() >= MIN_PEER_CHANNELS)
- .unwrap_or(false)
+ .map(|info| &info.channels[..])
+ .and_then(|channels| (channels.len() >= MIN_PEER_CHANNELS).then(|| channels))
+ .map(|channels| (details, channels))
  )
- .filter_map(|details| {
+ .filter_map(|(details, counterparty_channels)| {
  let short_channel_id = match details.get_inbound_payment_scid() {
  Some(short_channel_id) => short_channel_id,
  None => return None,
@@ -129,7 +141,7 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  max_cltv_expiry: tlvs.payment_constraints.max_cltv_expiry + cltv_expiry_delta,
  htlc_minimum_msat: details.inbound_htlc_minimum_msat.unwrap_or(0),
  };
-Some(payment::ForwardNode {
+let forward_node = payment::ForwardNode {
  tlvs: ForwardTlvs {
  short_channel_id,
  payment_relay,
@@ -138,29 +150,112 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  },
  node_id: details.counterparty.node_id,
  htlc_maximum_msat: details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX),
- })
- })
- .map(|forward_node| {
+ };
+ Some((forward_node, counterparty_channels))
+ });
+
+ let scorer = self.scorer.read_lock();
+ let three_hop_paths = counterparty_channels.clone()
+ // Pair counterparties with their other channels
+ .flat_map(|(forward_node, counterparty_channels)|
+ counterparty_channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get_key_value(scid))
+ .filter_map(move |(scid, info)| info
+ .as_directed_to(&NodeId::from_pubkey(&forward_node.node_id))
+ .map(|(info, source)| (source, *scid, info))
+ )
+ .filter(|(source, _, _)| **source != recipient_node_id)
+ .filter(|(source, _, _)| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_route_blinding())
+ .unwrap_or(false)
+ )
+ .filter(|(_, _, info)| amount_msats >= info.direction().htlc_minimum_msat)
+ .filter(|(_, _, info)| amount_msats <= info.direction().htlc_maximum_msat)
+ .filter(|(_, scid, info)| {
+ scorer.channel_balance_certainty(*scid, info) >= MIN_CHANNEL_CERTAINTY
+ })
+ .map(move |(source, scid, info)| (source, scid, info, forward_node.clone()))
+ )
+ // Construct blinded paths where the counterparty's counterparty is the introduction
+ // node:
+ //
+ // source --- info ---> counterparty --- counterparty_forward_node ---> recipient
+ .filter_map(|(introduction_node_id, scid, info, counterparty_forward_node)| {
+ let amount_msat = amount_msats;
+ let effective_capacity = info.effective_capacity();
+ let usage = ChannelUsage { amount_msat, inflight_htlc_msat: 0, effective_capacity };
+ let success_probability = scorer.channel_success_probability(
+ scid, &info, usage, &self.score_params
+ );
+
+ if !success_probability.is_finite() {
+ return None;
+ }
+
+ if success_probability < MIN_SUCCESS_PROBABILITY {
+ return None;
+ }
+
+ let htlc_minimum_msat = info.direction().htlc_minimum_msat;
+ let htlc_maximum_msat = info.direction().htlc_maximum_msat;
+ let payment_relay: PaymentRelay = match info.try_into() {
+ Ok(payment_relay) => payment_relay,
+ Err(()) => return None,
+ };
+ let payment_constraints = PaymentConstraints {
+ max_cltv_expiry: payment_relay.cltv_expiry_delta as u32
+ + counterparty_forward_node.tlvs.payment_constraints.max_cltv_expiry,
+ htlc_minimum_msat,
+ };
+ let introduction_forward_node = payment::ForwardNode {
+ tlvs: ForwardTlvs {
+ short_channel_id: scid,
+ payment_relay,
+ payment_constraints,
+ features: BlindedHopFeatures::empty(),
+ },
+ node_id: introduction_node_id.as_pubkey().unwrap(),
+ htlc_maximum_msat,
+ };
+ let path = BlindedPath::new_for_payment(
+ &[introduction_forward_node, counterparty_forward_node], recipient,
+ tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ );
+
+ Some(path.map(|path| (path, success_probability)))
+ });
+
+ let two_hop_paths = counterparty_channels
+ .map(|(forward_node, _)| {
  BlindedPath::new_for_payment(
  &[forward_node], recipient, tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA,
-&*self.entropy_source, secp_ctx
+ entropy_source, secp_ctx
  )
  })
- .take(MAX_PAYMENT_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient)) {
- BlindedPath::one_hop_for_payment(
- recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, &*self.entropy_source, secp_ctx
- ).map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }
+ .take(MAX_PAYMENT_PATHS);
+
+ three_hop_paths
+ .collect::<Result<Vec<_>, _>>().ok()
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .map(|mut paths| {
+ paths.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+ paths.into_iter().map(|(path, _)| path).take(MAX_PAYMENT_PATHS).collect::<Vec<_>>()
+ })
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| network_graph
+ .node(&NodeId::from_pubkey(&recipient)).ok_or(())
+ .and_then(|_| BlindedPath::one_hop_for_payment(
+ recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ )
+ )
+ .map(|path| vec![path])
+ .ok()
+ )
+ .ok_or(())
 	}
 }
 

lightning/src/blinded_path/payment.rs

@@ -23,6 +23,7 @@ use crate::ln::msgs::DecodeError;
 use crate::offers::invoice::BlindedPayInfo;
 use crate::offers::invoice_request::InvoiceRequestFields;
 use crate::offers::offer::OfferId;
+use crate::routing::gossip::DirectedChannelInfo;
 use crate::util::ser::{HighZeroBytesDroppedBigSize, Readable, Writeable, Writer};
 
 #[allow(unused_imports)]
@@ -170,6 +171,19 @@ impl PaymentContext {
 	}
 }
 
+impl PaymentRelay {
+	fn normalize_cltv_expiry_delta(cltv_expiry_delta: u16) -> Result<u16, ()> {
+ // Avoid exposing esoteric CLTV expiry deltas, which could de-anonymize the path.
+ match cltv_expiry_delta {
+ 0..=40 => Ok(40),
+ 41..=80 => Ok(80),
+ 81..=144 => Ok(144),
+ 145..=216 => Ok(216),
+ _ => Err(()),
+ }
+	}
+}
+
 impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
 	type Error = ();
 
@@ -178,16 +192,25 @@ impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
  fee_base_msat, fee_proportional_millionths, cltv_expiry_delta
  } = info;
 
- // Avoid exposing esoteric CLTV expiry deltas
- let cltv_expiry_delta = match cltv_expiry_delta {
- 0..=40 => 40,
- 41..=80 => 80,
- 81..=144 => 144,
- 145..=216 => 216,
- _ => return Err(()),
- };
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(cltv_expiry_delta)?,
+ fee_proportional_millionths,
+ fee_base_msat
+ })
+	}
+}
+
+impl<'a> TryFrom<DirectedChannelInfo<'a>> for PaymentRelay {
+	type Error = ();
+
+	fn try_from(info: DirectedChannelInfo<'a>) -> Result<Self, ()> {
+ let direction = info.direction();
 
- Ok(Self { cltv_expiry_delta, fee_proportional_millionths, fee_base_msat })
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(direction.cltv_expiry_delta)?,
+ fee_proportional_millionths: direction.fees.proportional_millionths,
+ fee_base_msat: direction.fees.base_msat,
+ })
 	}
 }
 

lightning/src/onion_message/messenger.rs

@@ -186,7 +186,7 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// &keys_manager, &keys_manager, logger, &node_id_lookup, message_router,
 /// &offers_message_handler, &custom_message_handler
 /// );
-
+///
 /// # #[derive(Debug)]
 /// # struct YourCustomMessage {}
 /// impl Writeable for YourCustomMessage {
@@ -195,13 +195,15 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// // Write your custom onion message to `w`
 /// }
 /// }
+///
 /// impl OnionMessageContents for YourCustomMessage {
 /// fn tlv_type(&self) -> u64 {
 /// # let your_custom_message_type = 42;
 /// your_custom_message_type
 /// }
 /// fn msg_type(&self) -> &'static str { "YourCustomMessageType" }
 /// }
+///
 /// // Send a custom onion message to a node id.
 /// let destination = Destination::Node(destination_node_id);
 /// let reply_path = None;
@@ -457,6 +459,9 @@ pub trait MessageRouter {
 
 /// A [`MessageRouter`] that can only route to a directly connected [`Destination`].
 ///
+/// When creating [`BlindedPath`]s, prefers three-hop paths over two-hops paths for the compact
+/// representation. For the non-compact representation, three-hop paths are not considered.
+///
 /// # Privacy
 ///
 /// Creating [`BlindedPath`]s may affect privacy since, if a suitable path cannot be found, it will
@@ -488,6 +493,9 @@ where
 	>(
  &self, recipient: PublicKey, peers: I, secp_ctx: &Secp256k1<T>, compact_paths: bool
 	) -> Result<Vec<BlindedPath>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PATHS: usize = 3;
 
@@ -500,40 +508,69 @@ where
  network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient));
 
  let mut peer_info = peers
+ .map(|peer| (NodeId::from_pubkey(&peer.node_id), peer))
  // Limit to peers with announced channels
- .filter_map(|peer|
+ .filter_map(|(node_id, peer)|
  network_graph
- .node(&NodeId::from_pubkey(&peer.node_id))
+ .node(&node_id)
  .filter(|info| info.channels.len() >= MIN_PEER_CHANNELS)
- .map(|info| (peer, info.is_tor_only(), info.channels.len()))
+ .map(|info| (node_id, peer, info.is_tor_only(), &info.channels))
  )
  // Exclude Tor-only nodes when the recipient is announced.
- .filter(|(_, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
+ .filter(|(_, _, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
  .collect::<Vec<_>>();
 
  // Prefer using non-Tor nodes with the most channels as the introduction node.
- peer_info.sort_unstable_by(|(_, a_tor_only, a_channels), (_, b_tor_only, b_channels)| {
- a_tor_only.cmp(b_tor_only).then(a_channels.cmp(b_channels).reverse())
+ peer_info.sort_unstable_by(|(_, _, a_tor_only, a_channels), (_, _, b_tor_only, b_channels)| {
+ a_tor_only.cmp(b_tor_only).then(a_channels.len().cmp(&b_channels.len()).reverse())
  });
 
- let paths = peer_info.into_iter()
- .map(|(peer, _, _)| {
- BlindedPath::new_for_message(&[peer], recipient, &*self.entropy_source, secp_ctx)
- })
- .take(MAX_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- let mut paths = match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if is_recipient_announced {
- BlindedPath::one_hop_for_message(recipient, &*self.entropy_source, secp_ctx)
- .map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }?;
+ let three_hop_paths = peer_info.iter()
+ // Pair peers with their other peers
+ .flat_map(|(node_id, peer, _, channels)|
+ channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get(scid))
+ .filter_map(move |info| info
+ .as_directed_to(&node_id)
+ .map(|(_, source)| source)
+ )
+ .filter(|source| **source != recipient_node_id)
+ .filter(|source| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_onion_messages())
+ .unwrap_or(false)
+ )
+ .filter_map(|source| source.as_pubkey().ok())
+ .map(move |source_pubkey| (source_pubkey, peer.clone()))
+ )
+ .map(|(source_pubkey, peer)| BlindedPath::new_for_message(&[ForwardNode { node_id: source_pubkey, short_channel_id: None }, peer], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ let two_hop_paths = peer_info
+ .iter()
+ .map(|(_, peer, _, _)| BlindedPath::new_for_message(&[peer.clone()], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ // Prefer three-hop paths over two-hop paths for compact paths. Fallback to a one-hop path
+ // if none were found and the recipient node is announced.
+ let mut paths = (!compact_paths).then(|| vec![])
+ .or_else(|| three_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| is_recipient_announced
+ .then(|| BlindedPath::one_hop_for_message(recipient, entropy_source, secp_ctx)
+ .map(|path| vec![path])
+ .unwrap_or(vec![])
+ )
+ )
+ .ok_or(())?;
+
+ if paths.is_empty() {
+ return Err(());
+ }
 
  if compact_paths {
  for path in &mut paths {

lightning/src/routing/gossip.rs

@@ -1040,7 +1040,7 @@ impl<'a> DirectedChannelInfo<'a> {
 
 	/// Returns information for the direction.
 	#[inline]
-	pub(super) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
+	pub(crate) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
 
 	/// Returns the `node_id` of the source hop.
 	///

lightning/src/routing/router.rs

@@ -93,25 +93,37 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  &self, recipient: PublicKey, first_hops: Vec<ChannelDetails>, tlvs: ReceiveTlvs,
  amount_msats: u64, secp_ctx: &Secp256k1<T>
 	) -> Result<Vec<(BlindedPayInfo, BlindedPath)>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PAYMENT_PATHS: usize = 3;
 
  // Ensure peers have at least three channels so that it is more difficult to infer the
  // recipient's node_id.
  const MIN_PEER_CHANNELS: usize = 3;
 
+ // The minimum channel balance certainty required for using a channel in a blinded path.
+ const MIN_CHANNEL_CERTAINTY: f64 = 0.5;
+
+ // The minimum success probability required for using a channel in a blinded path.
+ const MIN_SUCCESS_PROBABILITY: f64 = 0.25;
+
  let network_graph = self.network_graph.deref().read_only();
- let paths = first_hops.into_iter()
+ let counterparty_channels = first_hops.into_iter()
  .filter(|details| details.counterparty.features.supports_route_blinding())
  .filter(|details| amount_msats <= details.inbound_capacity_msat)
  .filter(|details| amount_msats >= details.inbound_htlc_minimum_msat.unwrap_or(0))
  .filter(|details| amount_msats <= details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX))
- .filter(|details| network_graph
+ // Limit to counterparties with announced channels
+ .filter_map(|details|
+ network_graph
  .node(&NodeId::from_pubkey(&details.counterparty.node_id))
- .map(|node_info| node_info.channels.len() >= MIN_PEER_CHANNELS)
- .unwrap_or(false)
+ .map(|info| &info.channels[..])
+ .and_then(|channels| (channels.len() >= MIN_PEER_CHANNELS).then(|| channels))
+ .map(|channels| (details, channels))
  )
- .filter_map(|details| {
+ .filter_map(|(details, counterparty_channels)| {
  let short_channel_id = match details.get_inbound_payment_scid() {
  Some(short_channel_id) => short_channel_id,
  None => return None,
@@ -129,7 +141,7 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  max_cltv_expiry: tlvs.payment_constraints.max_cltv_expiry + cltv_expiry_delta,
  htlc_minimum_msat: details.inbound_htlc_minimum_msat.unwrap_or(0),
  };
-Some(payment::ForwardNode {
+let forward_node = payment::ForwardNode {
  tlvs: ForwardTlvs {
  short_channel_id,
  payment_relay,
@@ -138,29 +150,112 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  },
  node_id: details.counterparty.node_id,
  htlc_maximum_msat: details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX),
- })
- })
- .map(|forward_node| {
+ };
+ Some((forward_node, counterparty_channels))
+ });
+
+ let scorer = self.scorer.read_lock();
+ let three_hop_paths = counterparty_channels.clone()
+ // Pair counterparties with their other channels
+ .flat_map(|(forward_node, counterparty_channels)|
+ counterparty_channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get_key_value(scid))
+ .filter_map(move |(scid, info)| info
+ .as_directed_to(&NodeId::from_pubkey(&forward_node.node_id))
+ .map(|(info, source)| (source, *scid, info))
+ )
+ .filter(|(source, _, _)| **source != recipient_node_id)
+ .filter(|(source, _, _)| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_route_blinding())
+ .unwrap_or(false)
+ )
+ .filter(|(_, _, info)| amount_msats >= info.direction().htlc_minimum_msat)
+ .filter(|(_, _, info)| amount_msats <= info.direction().htlc_maximum_msat)
+ .filter(|(_, scid, info)| {
+ scorer.channel_balance_certainty(*scid, info) >= MIN_CHANNEL_CERTAINTY
+ })
+ .map(move |(source, scid, info)| (source, scid, info, forward_node.clone()))
+ )
+ // Construct blinded paths where the counterparty's counterparty is the introduction
+ // node:
+ //
+ // source --- info ---> counterparty --- counterparty_forward_node ---> recipient
+ .filter_map(|(introduction_node_id, scid, info, counterparty_forward_node)| {
+ let amount_msat = amount_msats;
+ let effective_capacity = info.effective_capacity();
+ let usage = ChannelUsage { amount_msat, inflight_htlc_msat: 0, effective_capacity };
+ let success_probability = scorer.channel_success_probability(
+ scid, &info, usage, &self.score_params
+ );
+
+ if !success_probability.is_finite() {
+ return None;
+ }
+
+ if success_probability < MIN_SUCCESS_PROBABILITY {
+ return None;
+ }
+
+ let htlc_minimum_msat = info.direction().htlc_minimum_msat;
+ let htlc_maximum_msat = info.direction().htlc_maximum_msat;
+ let payment_relay: PaymentRelay = match info.try_into() {
+ Ok(payment_relay) => payment_relay,
+ Err(()) => return None,
+ };
+ let payment_constraints = PaymentConstraints {
+ max_cltv_expiry: payment_relay.cltv_expiry_delta as u32
+ + counterparty_forward_node.tlvs.payment_constraints.max_cltv_expiry,
+ htlc_minimum_msat,
+ };
+ let introduction_forward_node = payment::ForwardNode {
+ tlvs: ForwardTlvs {
+ short_channel_id: scid,
+ payment_relay,
+ payment_constraints,
+ features: BlindedHopFeatures::empty(),
+ },
+ node_id: introduction_node_id.as_pubkey().unwrap(),
+ htlc_maximum_msat,
+ };
+ let path = BlindedPath::new_for_payment(
+ &[introduction_forward_node, counterparty_forward_node], recipient,
+ tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ );
+
+ Some(path.map(|path| (path, success_probability)))
+ });
+
+ let two_hop_paths = counterparty_channels
+ .map(|(forward_node, _)| {
  BlindedPath::new_for_payment(
  &[forward_node], recipient, tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA,
-&*self.entropy_source, secp_ctx
+ entropy_source, secp_ctx
  )
  })
- .take(MAX_PAYMENT_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient)) {
- BlindedPath::one_hop_for_payment(
- recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, &*self.entropy_source, secp_ctx
- ).map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }
+ .take(MAX_PAYMENT_PATHS);
+
+ three_hop_paths
+ .collect::<Result<Vec<_>, _>>().ok()
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .map(|mut paths| {
+ paths.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+ paths.into_iter().map(|(path, _)| path).take(MAX_PAYMENT_PATHS).collect::<Vec<_>>()
+ })
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| network_graph
+ .node(&NodeId::from_pubkey(&recipient)).ok_or(())
+ .and_then(|_| BlindedPath::one_hop_for_payment(
+ recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ )
+ )
+ .map(|path| vec![path])
+ .ok()
+ )
+ .ok_or(())
 	}
 }
 

lightning/src/blinded_path/payment.rs

@@ -23,6 +23,7 @@ use crate::ln::msgs::DecodeError;
 use crate::offers::invoice::BlindedPayInfo;
 use crate::offers::invoice_request::InvoiceRequestFields;
 use crate::offers::offer::OfferId;
+use crate::routing::gossip::DirectedChannelInfo;
 use crate::util::ser::{HighZeroBytesDroppedBigSize, Readable, Writeable, Writer};
 
 #[allow(unused_imports)]
@@ -170,6 +171,19 @@ impl PaymentContext {
 	}
 }
 
+impl PaymentRelay {
+	fn normalize_cltv_expiry_delta(cltv_expiry_delta: u16) -> Result<u16, ()> {
+ // Avoid exposing esoteric CLTV expiry deltas, which could de-anonymize the path.
+ match cltv_expiry_delta {
+ 0..=40 => Ok(40),
+ 41..=80 => Ok(80),
+ 81..=144 => Ok(144),
+ 145..=216 => Ok(216),
+ _ => Err(()),
+ }
+	}
+}
+
 impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
 	type Error = ();
 
@@ -178,16 +192,25 @@ impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
  fee_base_msat, fee_proportional_millionths, cltv_expiry_delta
  } = info;
 
- // Avoid exposing esoteric CLTV expiry deltas
- let cltv_expiry_delta = match cltv_expiry_delta {
- 0..=40 => 40,
- 41..=80 => 80,
- 81..=144 => 144,
- 145..=216 => 216,
- _ => return Err(()),
- };
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(cltv_expiry_delta)?,
+ fee_proportional_millionths,
+ fee_base_msat
+ })
+	}
+}
+
+impl<'a> TryFrom<DirectedChannelInfo<'a>> for PaymentRelay {
+	type Error = ();
+
+	fn try_from(info: DirectedChannelInfo<'a>) -> Result<Self, ()> {
+ let direction = info.direction();
 
- Ok(Self { cltv_expiry_delta, fee_proportional_millionths, fee_base_msat })
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(direction.cltv_expiry_delta)?,
+ fee_proportional_millionths: direction.fees.proportional_millionths,
+ fee_base_msat: direction.fees.base_msat,
+ })
 	}
 }
 

lightning/src/onion_message/messenger.rs

@@ -186,7 +186,7 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// &keys_manager, &keys_manager, logger, &node_id_lookup, message_router,
 /// &offers_message_handler, &custom_message_handler
 /// );
-
+///
 /// # #[derive(Debug)]
 /// # struct YourCustomMessage {}
 /// impl Writeable for YourCustomMessage {
@@ -195,13 +195,15 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// // Write your custom onion message to `w`
 /// }
 /// }
+///
 /// impl OnionMessageContents for YourCustomMessage {
 /// fn tlv_type(&self) -> u64 {
 /// # let your_custom_message_type = 42;
 /// your_custom_message_type
 /// }
 /// fn msg_type(&self) -> &'static str { "YourCustomMessageType" }
 /// }
+///
 /// // Send a custom onion message to a node id.
 /// let destination = Destination::Node(destination_node_id);
 /// let reply_path = None;
@@ -457,6 +459,9 @@ pub trait MessageRouter {
 
 /// A [`MessageRouter`] that can only route to a directly connected [`Destination`].
 ///
+/// When creating [`BlindedPath`]s, prefers three-hop paths over two-hops paths for the compact
+/// representation. For the non-compact representation, three-hop paths are not considered.
+///
 /// # Privacy
 ///
 /// Creating [`BlindedPath`]s may affect privacy since, if a suitable path cannot be found, it will
@@ -488,6 +493,9 @@ where
 	>(
  &self, recipient: PublicKey, peers: I, secp_ctx: &Secp256k1<T>, compact_paths: bool
 	) -> Result<Vec<BlindedPath>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PATHS: usize = 3;
 
@@ -500,40 +508,69 @@ where
  network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient));
 
  let mut peer_info = peers
+ .map(|peer| (NodeId::from_pubkey(&peer.node_id), peer))
  // Limit to peers with announced channels
- .filter_map(|peer|
+ .filter_map(|(node_id, peer)|
  network_graph
- .node(&NodeId::from_pubkey(&peer.node_id))
+ .node(&node_id)
  .filter(|info| info.channels.len() >= MIN_PEER_CHANNELS)
- .map(|info| (peer, info.is_tor_only(), info.channels.len()))
+ .map(|info| (node_id, peer, info.is_tor_only(), &info.channels))
  )
  // Exclude Tor-only nodes when the recipient is announced.
- .filter(|(_, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
+ .filter(|(_, _, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
  .collect::<Vec<_>>();
 
  // Prefer using non-Tor nodes with the most channels as the introduction node.
- peer_info.sort_unstable_by(|(_, a_tor_only, a_channels), (_, b_tor_only, b_channels)| {
- a_tor_only.cmp(b_tor_only).then(a_channels.cmp(b_channels).reverse())
+ peer_info.sort_unstable_by(|(_, _, a_tor_only, a_channels), (_, _, b_tor_only, b_channels)| {
+ a_tor_only.cmp(b_tor_only).then(a_channels.len().cmp(&b_channels.len()).reverse())
  });
 
- let paths = peer_info.into_iter()
- .map(|(peer, _, _)| {
- BlindedPath::new_for_message(&[peer], recipient, &*self.entropy_source, secp_ctx)
- })
- .take(MAX_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- let mut paths = match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if is_recipient_announced {
- BlindedPath::one_hop_for_message(recipient, &*self.entropy_source, secp_ctx)
- .map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }?;
+ let three_hop_paths = peer_info.iter()
+ // Pair peers with their other peers
+ .flat_map(|(node_id, peer, _, channels)|
+ channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get(scid))
+ .filter_map(move |info| info
+ .as_directed_to(&node_id)
+ .map(|(_, source)| source)
+ )
+ .filter(|source| **source != recipient_node_id)
+ .filter(|source| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_onion_messages())
+ .unwrap_or(false)
+ )
+ .filter_map(|source| source.as_pubkey().ok())
+ .map(move |source_pubkey| (source_pubkey, peer.clone()))
+ )
+ .map(|(source_pubkey, peer)| BlindedPath::new_for_message(&[ForwardNode { node_id: source_pubkey, short_channel_id: None }, peer], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ let two_hop_paths = peer_info
+ .iter()
+ .map(|(_, peer, _, _)| BlindedPath::new_for_message(&[peer.clone()], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ // Prefer three-hop paths over two-hop paths for compact paths. Fallback to a one-hop path
+ // if none were found and the recipient node is announced.
+ let mut paths = (!compact_paths).then(|| vec![])
+ .or_else(|| three_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| is_recipient_announced
+ .then(|| BlindedPath::one_hop_for_message(recipient, entropy_source, secp_ctx)
+ .map(|path| vec![path])
+ .unwrap_or(vec![])
+ )
+ )
+ .ok_or(())?;
+
+ if paths.is_empty() {
+ return Err(());
+ }
 
  if compact_paths {
  for path in &mut paths {

lightning/src/routing/gossip.rs

@@ -1040,7 +1040,7 @@ impl<'a> DirectedChannelInfo<'a> {
 
 	/// Returns information for the direction.
 	#[inline]
-	pub(super) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
+	pub(crate) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
 
 	/// Returns the `node_id` of the source hop.
 	///

lightning/src/routing/router.rs

@@ -93,25 +93,37 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  &self, recipient: PublicKey, first_hops: Vec<ChannelDetails>, tlvs: ReceiveTlvs,
  amount_msats: u64, secp_ctx: &Secp256k1<T>
 	) -> Result<Vec<(BlindedPayInfo, BlindedPath)>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PAYMENT_PATHS: usize = 3;
 
  // Ensure peers have at least three channels so that it is more difficult to infer the
  // recipient's node_id.
  const MIN_PEER_CHANNELS: usize = 3;
 
+ // The minimum channel balance certainty required for using a channel in a blinded path.
+ const MIN_CHANNEL_CERTAINTY: f64 = 0.5;
+
+ // The minimum success probability required for using a channel in a blinded path.
+ const MIN_SUCCESS_PROBABILITY: f64 = 0.25;
+
  let network_graph = self.network_graph.deref().read_only();
- let paths = first_hops.into_iter()
+ let counterparty_channels = first_hops.into_iter()
  .filter(|details| details.counterparty.features.supports_route_blinding())
  .filter(|details| amount_msats <= details.inbound_capacity_msat)
  .filter(|details| amount_msats >= details.inbound_htlc_minimum_msat.unwrap_or(0))
  .filter(|details| amount_msats <= details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX))
- .filter(|details| network_graph
+ // Limit to counterparties with announced channels
+ .filter_map(|details|
+ network_graph
  .node(&NodeId::from_pubkey(&details.counterparty.node_id))
- .map(|node_info| node_info.channels.len() >= MIN_PEER_CHANNELS)
- .unwrap_or(false)
+ .map(|info| &info.channels[..])
+ .and_then(|channels| (channels.len() >= MIN_PEER_CHANNELS).then(|| channels))
+ .map(|channels| (details, channels))
  )
- .filter_map(|details| {
+ .filter_map(|(details, counterparty_channels)| {
  let short_channel_id = match details.get_inbound_payment_scid() {
  Some(short_channel_id) => short_channel_id,
  None => return None,
@@ -129,7 +141,7 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  max_cltv_expiry: tlvs.payment_constraints.max_cltv_expiry + cltv_expiry_delta,
  htlc_minimum_msat: details.inbound_htlc_minimum_msat.unwrap_or(0),
  };
-Some(payment::ForwardNode {
+let forward_node = payment::ForwardNode {
  tlvs: ForwardTlvs {
  short_channel_id,
  payment_relay,
@@ -138,29 +150,112 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  },
  node_id: details.counterparty.node_id,
  htlc_maximum_msat: details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX),
- })
- })
- .map(|forward_node| {
+ };
+ Some((forward_node, counterparty_channels))
+ });
+
+ let scorer = self.scorer.read_lock();
+ let three_hop_paths = counterparty_channels.clone()
+ // Pair counterparties with their other channels
+ .flat_map(|(forward_node, counterparty_channels)|
+ counterparty_channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get_key_value(scid))
+ .filter_map(move |(scid, info)| info
+ .as_directed_to(&NodeId::from_pubkey(&forward_node.node_id))
+ .map(|(info, source)| (source, *scid, info))
+ )
+ .filter(|(source, _, _)| **source != recipient_node_id)
+ .filter(|(source, _, _)| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_route_blinding())
+ .unwrap_or(false)
+ )
+ .filter(|(_, _, info)| amount_msats >= info.direction().htlc_minimum_msat)
+ .filter(|(_, _, info)| amount_msats <= info.direction().htlc_maximum_msat)
+ .filter(|(_, scid, info)| {
+ scorer.channel_balance_certainty(*scid, info) >= MIN_CHANNEL_CERTAINTY
+ })
+ .map(move |(source, scid, info)| (source, scid, info, forward_node.clone()))
+ )
+ // Construct blinded paths where the counterparty's counterparty is the introduction
+ // node:
+ //
+ // source --- info ---> counterparty --- counterparty_forward_node ---> recipient
+ .filter_map(|(introduction_node_id, scid, info, counterparty_forward_node)| {
+ let amount_msat = amount_msats;
+ let effective_capacity = info.effective_capacity();
+ let usage = ChannelUsage { amount_msat, inflight_htlc_msat: 0, effective_capacity };
+ let success_probability = scorer.channel_success_probability(
+ scid, &info, usage, &self.score_params
+ );
+
+ if !success_probability.is_finite() {
+ return None;
+ }
+
+ if success_probability < MIN_SUCCESS_PROBABILITY {
+ return None;
+ }
+
+ let htlc_minimum_msat = info.direction().htlc_minimum_msat;
+ let htlc_maximum_msat = info.direction().htlc_maximum_msat;
+ let payment_relay: PaymentRelay = match info.try_into() {
+ Ok(payment_relay) => payment_relay,
+ Err(()) => return None,
+ };
+ let payment_constraints = PaymentConstraints {
+ max_cltv_expiry: payment_relay.cltv_expiry_delta as u32
+ + counterparty_forward_node.tlvs.payment_constraints.max_cltv_expiry,
+ htlc_minimum_msat,
+ };
+ let introduction_forward_node = payment::ForwardNode {
+ tlvs: ForwardTlvs {
+ short_channel_id: scid,
+ payment_relay,
+ payment_constraints,
+ features: BlindedHopFeatures::empty(),
+ },
+ node_id: introduction_node_id.as_pubkey().unwrap(),
+ htlc_maximum_msat,
+ };
+ let path = BlindedPath::new_for_payment(
+ &[introduction_forward_node, counterparty_forward_node], recipient,
+ tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ );
+
+ Some(path.map(|path| (path, success_probability)))
+ });
+
+ let two_hop_paths = counterparty_channels
+ .map(|(forward_node, _)| {
  BlindedPath::new_for_payment(
  &[forward_node], recipient, tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA,
-&*self.entropy_source, secp_ctx
+ entropy_source, secp_ctx
  )
  })
- .take(MAX_PAYMENT_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient)) {
- BlindedPath::one_hop_for_payment(
- recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, &*self.entropy_source, secp_ctx
- ).map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }
+ .take(MAX_PAYMENT_PATHS);
+
+ three_hop_paths
+ .collect::<Result<Vec<_>, _>>().ok()
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .map(|mut paths| {
+ paths.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+ paths.into_iter().map(|(path, _)| path).take(MAX_PAYMENT_PATHS).collect::<Vec<_>>()
+ })
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| network_graph
+ .node(&NodeId::from_pubkey(&recipient)).ok_or(())
+ .and_then(|_| BlindedPath::one_hop_for_payment(
+ recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ )
+ )
+ .map(|path| vec![path])
+ .ok()
+ )
+ .ok_or(())
 	}
 }
 

lightning/src/blinded_path/payment.rs

@@ -23,6 +23,7 @@ use crate::ln::msgs::DecodeError;
 use crate::offers::invoice::BlindedPayInfo;
 use crate::offers::invoice_request::InvoiceRequestFields;
 use crate::offers::offer::OfferId;
+use crate::routing::gossip::DirectedChannelInfo;
 use crate::util::ser::{HighZeroBytesDroppedBigSize, Readable, Writeable, Writer};
 
 #[allow(unused_imports)]
@@ -170,6 +171,19 @@ impl PaymentContext {
 	}
 }
 
+impl PaymentRelay {
+	fn normalize_cltv_expiry_delta(cltv_expiry_delta: u16) -> Result<u16, ()> {
+ // Avoid exposing esoteric CLTV expiry deltas, which could de-anonymize the path.
+ match cltv_expiry_delta {
+ 0..=40 => Ok(40),
+ 41..=80 => Ok(80),
+ 81..=144 => Ok(144),
+ 145..=216 => Ok(216),
+ _ => Err(()),
+ }
+	}
+}
+
 impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
 	type Error = ();
 
@@ -178,16 +192,25 @@ impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
  fee_base_msat, fee_proportional_millionths, cltv_expiry_delta
  } = info;
 
- // Avoid exposing esoteric CLTV expiry deltas
- let cltv_expiry_delta = match cltv_expiry_delta {
- 0..=40 => 40,
- 41..=80 => 80,
- 81..=144 => 144,
- 145..=216 => 216,
- _ => return Err(()),
- };
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(cltv_expiry_delta)?,
+ fee_proportional_millionths,
+ fee_base_msat
+ })
+	}
+}
+
+impl<'a> TryFrom<DirectedChannelInfo<'a>> for PaymentRelay {
+	type Error = ();
+
+	fn try_from(info: DirectedChannelInfo<'a>) -> Result<Self, ()> {
+ let direction = info.direction();
 
- Ok(Self { cltv_expiry_delta, fee_proportional_millionths, fee_base_msat })
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(direction.cltv_expiry_delta)?,
+ fee_proportional_millionths: direction.fees.proportional_millionths,
+ fee_base_msat: direction.fees.base_msat,
+ })
 	}
 }
 

lightning/src/onion_message/messenger.rs

@@ -186,7 +186,7 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// &keys_manager, &keys_manager, logger, &node_id_lookup, message_router,
 /// &offers_message_handler, &custom_message_handler
 /// );
-
+///
 /// # #[derive(Debug)]
 /// # struct YourCustomMessage {}
 /// impl Writeable for YourCustomMessage {
@@ -195,13 +195,15 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// // Write your custom onion message to `w`
 /// }
 /// }
+///
 /// impl OnionMessageContents for YourCustomMessage {
 /// fn tlv_type(&self) -> u64 {
 /// # let your_custom_message_type = 42;
 /// your_custom_message_type
 /// }
 /// fn msg_type(&self) -> &'static str { "YourCustomMessageType" }
 /// }
+///
 /// // Send a custom onion message to a node id.
 /// let destination = Destination::Node(destination_node_id);
 /// let reply_path = None;
@@ -457,6 +459,9 @@ pub trait MessageRouter {
 
 /// A [`MessageRouter`] that can only route to a directly connected [`Destination`].
 ///
+/// When creating [`BlindedPath`]s, prefers three-hop paths over two-hops paths for the compact
+/// representation. For the non-compact representation, three-hop paths are not considered.
+///
 /// # Privacy
 ///
 /// Creating [`BlindedPath`]s may affect privacy since, if a suitable path cannot be found, it will
@@ -488,6 +493,9 @@ where
 	>(
  &self, recipient: PublicKey, peers: I, secp_ctx: &Secp256k1<T>, compact_paths: bool
 	) -> Result<Vec<BlindedPath>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PATHS: usize = 3;
 
@@ -500,40 +508,69 @@ where
  network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient));
 
  let mut peer_info = peers
+ .map(|peer| (NodeId::from_pubkey(&peer.node_id), peer))
  // Limit to peers with announced channels
- .filter_map(|peer|
+ .filter_map(|(node_id, peer)|
  network_graph
- .node(&NodeId::from_pubkey(&peer.node_id))
+ .node(&node_id)
  .filter(|info| info.channels.len() >= MIN_PEER_CHANNELS)
- .map(|info| (peer, info.is_tor_only(), info.channels.len()))
+ .map(|info| (node_id, peer, info.is_tor_only(), &info.channels))
  )
  // Exclude Tor-only nodes when the recipient is announced.
- .filter(|(_, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
+ .filter(|(_, _, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
  .collect::<Vec<_>>();
 
  // Prefer using non-Tor nodes with the most channels as the introduction node.
- peer_info.sort_unstable_by(|(_, a_tor_only, a_channels), (_, b_tor_only, b_channels)| {
- a_tor_only.cmp(b_tor_only).then(a_channels.cmp(b_channels).reverse())
+ peer_info.sort_unstable_by(|(_, _, a_tor_only, a_channels), (_, _, b_tor_only, b_channels)| {
+ a_tor_only.cmp(b_tor_only).then(a_channels.len().cmp(&b_channels.len()).reverse())
  });
 
- let paths = peer_info.into_iter()
- .map(|(peer, _, _)| {
- BlindedPath::new_for_message(&[peer], recipient, &*self.entropy_source, secp_ctx)
- })
- .take(MAX_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- let mut paths = match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if is_recipient_announced {
- BlindedPath::one_hop_for_message(recipient, &*self.entropy_source, secp_ctx)
- .map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }?;
+ let three_hop_paths = peer_info.iter()
+ // Pair peers with their other peers
+ .flat_map(|(node_id, peer, _, channels)|
+ channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get(scid))
+ .filter_map(move |info| info
+ .as_directed_to(&node_id)
+ .map(|(_, source)| source)
+ )
+ .filter(|source| **source != recipient_node_id)
+ .filter(|source| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_onion_messages())
+ .unwrap_or(false)
+ )
+ .filter_map(|source| source.as_pubkey().ok())
+ .map(move |source_pubkey| (source_pubkey, peer.clone()))
+ )
+ .map(|(source_pubkey, peer)| BlindedPath::new_for_message(&[ForwardNode { node_id: source_pubkey, short_channel_id: None }, peer], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ let two_hop_paths = peer_info
+ .iter()
+ .map(|(_, peer, _, _)| BlindedPath::new_for_message(&[peer.clone()], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ // Prefer three-hop paths over two-hop paths for compact paths. Fallback to a one-hop path
+ // if none were found and the recipient node is announced.
+ let mut paths = (!compact_paths).then(|| vec![])
+ .or_else(|| three_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| is_recipient_announced
+ .then(|| BlindedPath::one_hop_for_message(recipient, entropy_source, secp_ctx)
+ .map(|path| vec![path])
+ .unwrap_or(vec![])
+ )
+ )
+ .ok_or(())?;
+
+ if paths.is_empty() {
+ return Err(());
+ }
 
  if compact_paths {
  for path in &mut paths {

lightning/src/routing/gossip.rs

@@ -1040,7 +1040,7 @@ impl<'a> DirectedChannelInfo<'a> {
 
 	/// Returns information for the direction.
 	#[inline]
-	pub(super) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
+	pub(crate) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
 
 	/// Returns the `node_id` of the source hop.
 	///

lightning/src/routing/router.rs

@@ -93,25 +93,37 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  &self, recipient: PublicKey, first_hops: Vec<ChannelDetails>, tlvs: ReceiveTlvs,
  amount_msats: u64, secp_ctx: &Secp256k1<T>
 	) -> Result<Vec<(BlindedPayInfo, BlindedPath)>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PAYMENT_PATHS: usize = 3;
 
  // Ensure peers have at least three channels so that it is more difficult to infer the
  // recipient's node_id.
  const MIN_PEER_CHANNELS: usize = 3;
 
+ // The minimum channel balance certainty required for using a channel in a blinded path.
+ const MIN_CHANNEL_CERTAINTY: f64 = 0.5;
+
+ // The minimum success probability required for using a channel in a blinded path.
+ const MIN_SUCCESS_PROBABILITY: f64 = 0.25;
+
  let network_graph = self.network_graph.deref().read_only();
- let paths = first_hops.into_iter()
+ let counterparty_channels = first_hops.into_iter()
  .filter(|details| details.counterparty.features.supports_route_blinding())
  .filter(|details| amount_msats <= details.inbound_capacity_msat)
  .filter(|details| amount_msats >= details.inbound_htlc_minimum_msat.unwrap_or(0))
  .filter(|details| amount_msats <= details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX))
- .filter(|details| network_graph
+ // Limit to counterparties with announced channels
+ .filter_map(|details|
+ network_graph
  .node(&NodeId::from_pubkey(&details.counterparty.node_id))
- .map(|node_info| node_info.channels.len() >= MIN_PEER_CHANNELS)
- .unwrap_or(false)
+ .map(|info| &info.channels[..])
+ .and_then(|channels| (channels.len() >= MIN_PEER_CHANNELS).then(|| channels))
+ .map(|channels| (details, channels))
  )
- .filter_map(|details| {
+ .filter_map(|(details, counterparty_channels)| {
  let short_channel_id = match details.get_inbound_payment_scid() {
  Some(short_channel_id) => short_channel_id,
  None => return None,
@@ -129,7 +141,7 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  max_cltv_expiry: tlvs.payment_constraints.max_cltv_expiry + cltv_expiry_delta,
  htlc_minimum_msat: details.inbound_htlc_minimum_msat.unwrap_or(0),
  };
-Some(payment::ForwardNode {
+let forward_node = payment::ForwardNode {
  tlvs: ForwardTlvs {
  short_channel_id,
  payment_relay,
@@ -138,29 +150,112 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  },
  node_id: details.counterparty.node_id,
  htlc_maximum_msat: details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX),
- })
- })
- .map(|forward_node| {
+ };
+ Some((forward_node, counterparty_channels))
+ });
+
+ let scorer = self.scorer.read_lock();
+ let three_hop_paths = counterparty_channels.clone()
+ // Pair counterparties with their other channels
+ .flat_map(|(forward_node, counterparty_channels)|
+ counterparty_channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get_key_value(scid))
+ .filter_map(move |(scid, info)| info
+ .as_directed_to(&NodeId::from_pubkey(&forward_node.node_id))
+ .map(|(info, source)| (source, *scid, info))
+ )
+ .filter(|(source, _, _)| **source != recipient_node_id)
+ .filter(|(source, _, _)| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_route_blinding())
+ .unwrap_or(false)
+ )
+ .filter(|(_, _, info)| amount_msats >= info.direction().htlc_minimum_msat)
+ .filter(|(_, _, info)| amount_msats <= info.direction().htlc_maximum_msat)
+ .filter(|(_, scid, info)| {
+ scorer.channel_balance_certainty(*scid, info) >= MIN_CHANNEL_CERTAINTY
+ })
+ .map(move |(source, scid, info)| (source, scid, info, forward_node.clone()))
+ )
+ // Construct blinded paths where the counterparty's counterparty is the introduction
+ // node:
+ //
+ // source --- info ---> counterparty --- counterparty_forward_node ---> recipient
+ .filter_map(|(introduction_node_id, scid, info, counterparty_forward_node)| {
+ let amount_msat = amount_msats;
+ let effective_capacity = info.effective_capacity();
+ let usage = ChannelUsage { amount_msat, inflight_htlc_msat: 0, effective_capacity };
+ let success_probability = scorer.channel_success_probability(
+ scid, &info, usage, &self.score_params
+ );
+
+ if !success_probability.is_finite() {
+ return None;
+ }
+
+ if success_probability < MIN_SUCCESS_PROBABILITY {
+ return None;
+ }
+
+ let htlc_minimum_msat = info.direction().htlc_minimum_msat;
+ let htlc_maximum_msat = info.direction().htlc_maximum_msat;
+ let payment_relay: PaymentRelay = match info.try_into() {
+ Ok(payment_relay) => payment_relay,
+ Err(()) => return None,
+ };
+ let payment_constraints = PaymentConstraints {
+ max_cltv_expiry: payment_relay.cltv_expiry_delta as u32
+ + counterparty_forward_node.tlvs.payment_constraints.max_cltv_expiry,
+ htlc_minimum_msat,
+ };
+ let introduction_forward_node = payment::ForwardNode {
+ tlvs: ForwardTlvs {
+ short_channel_id: scid,
+ payment_relay,
+ payment_constraints,
+ features: BlindedHopFeatures::empty(),
+ },
+ node_id: introduction_node_id.as_pubkey().unwrap(),
+ htlc_maximum_msat,
+ };
+ let path = BlindedPath::new_for_payment(
+ &[introduction_forward_node, counterparty_forward_node], recipient,
+ tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ );
+
+ Some(path.map(|path| (path, success_probability)))
+ });
+
+ let two_hop_paths = counterparty_channels
+ .map(|(forward_node, _)| {
  BlindedPath::new_for_payment(
  &[forward_node], recipient, tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA,
-&*self.entropy_source, secp_ctx
+ entropy_source, secp_ctx
  )
  })
- .take(MAX_PAYMENT_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient)) {
- BlindedPath::one_hop_for_payment(
- recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, &*self.entropy_source, secp_ctx
- ).map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }
+ .take(MAX_PAYMENT_PATHS);
+
+ three_hop_paths
+ .collect::<Result<Vec<_>, _>>().ok()
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .map(|mut paths| {
+ paths.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+ paths.into_iter().map(|(path, _)| path).take(MAX_PAYMENT_PATHS).collect::<Vec<_>>()
+ })
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| network_graph
+ .node(&NodeId::from_pubkey(&recipient)).ok_or(())
+ .and_then(|_| BlindedPath::one_hop_for_payment(
+ recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ )
+ )
+ .map(|path| vec![path])
+ .ok()
+ )
+ .ok_or(())
 	}
 }
 

lightning/src/blinded_path/payment.rs

@@ -23,6 +23,7 @@ use crate::ln::msgs::DecodeError;
 use crate::offers::invoice::BlindedPayInfo;
 use crate::offers::invoice_request::InvoiceRequestFields;
 use crate::offers::offer::OfferId;
+use crate::routing::gossip::DirectedChannelInfo;
 use crate::util::ser::{HighZeroBytesDroppedBigSize, Readable, Writeable, Writer};
 
 #[allow(unused_imports)]
@@ -170,6 +171,19 @@ impl PaymentContext {
 	}
 }
 
+impl PaymentRelay {
+	fn normalize_cltv_expiry_delta(cltv_expiry_delta: u16) -> Result<u16, ()> {
+ // Avoid exposing esoteric CLTV expiry deltas, which could de-anonymize the path.
+ match cltv_expiry_delta {
+ 0..=40 => Ok(40),
+ 41..=80 => Ok(80),
+ 81..=144 => Ok(144),
+ 145..=216 => Ok(216),
+ _ => Err(()),
+ }
+	}
+}
+
 impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
 	type Error = ();
 
@@ -178,16 +192,25 @@ impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
  fee_base_msat, fee_proportional_millionths, cltv_expiry_delta
  } = info;
 
- // Avoid exposing esoteric CLTV expiry deltas
- let cltv_expiry_delta = match cltv_expiry_delta {
- 0..=40 => 40,
- 41..=80 => 80,
- 81..=144 => 144,
- 145..=216 => 216,
- _ => return Err(()),
- };
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(cltv_expiry_delta)?,
+ fee_proportional_millionths,
+ fee_base_msat
+ })
+	}
+}
+
+impl<'a> TryFrom<DirectedChannelInfo<'a>> for PaymentRelay {
+	type Error = ();
+
+	fn try_from(info: DirectedChannelInfo<'a>) -> Result<Self, ()> {
+ let direction = info.direction();
 
- Ok(Self { cltv_expiry_delta, fee_proportional_millionths, fee_base_msat })
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(direction.cltv_expiry_delta)?,
+ fee_proportional_millionths: direction.fees.proportional_millionths,
+ fee_base_msat: direction.fees.base_msat,
+ })
 	}
 }
 

lightning/src/onion_message/messenger.rs

@@ -186,7 +186,7 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// &keys_manager, &keys_manager, logger, &node_id_lookup, message_router,
 /// &offers_message_handler, &custom_message_handler
 /// );
-
+///
 /// # #[derive(Debug)]
 /// # struct YourCustomMessage {}
 /// impl Writeable for YourCustomMessage {
@@ -195,13 +195,15 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// // Write your custom onion message to `w`
 /// }
 /// }
+///
 /// impl OnionMessageContents for YourCustomMessage {
 /// fn tlv_type(&self) -> u64 {
 /// # let your_custom_message_type = 42;
 /// your_custom_message_type
 /// }
 /// fn msg_type(&self) -> &'static str { "YourCustomMessageType" }
 /// }
+///
 /// // Send a custom onion message to a node id.
 /// let destination = Destination::Node(destination_node_id);
 /// let reply_path = None;
@@ -457,6 +459,9 @@ pub trait MessageRouter {
 
 /// A [`MessageRouter`] that can only route to a directly connected [`Destination`].
 ///
+/// When creating [`BlindedPath`]s, prefers three-hop paths over two-hops paths for the compact
+/// representation. For the non-compact representation, three-hop paths are not considered.
+///
 /// # Privacy
 ///
 /// Creating [`BlindedPath`]s may affect privacy since, if a suitable path cannot be found, it will
@@ -488,6 +493,9 @@ where
 	>(
  &self, recipient: PublicKey, peers: I, secp_ctx: &Secp256k1<T>, compact_paths: bool
 	) -> Result<Vec<BlindedPath>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PATHS: usize = 3;
 
@@ -500,40 +508,69 @@ where
  network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient));
 
  let mut peer_info = peers
+ .map(|peer| (NodeId::from_pubkey(&peer.node_id), peer))
  // Limit to peers with announced channels
- .filter_map(|peer|
+ .filter_map(|(node_id, peer)|
  network_graph
- .node(&NodeId::from_pubkey(&peer.node_id))
+ .node(&node_id)
  .filter(|info| info.channels.len() >= MIN_PEER_CHANNELS)
- .map(|info| (peer, info.is_tor_only(), info.channels.len()))
+ .map(|info| (node_id, peer, info.is_tor_only(), &info.channels))
  )
  // Exclude Tor-only nodes when the recipient is announced.
- .filter(|(_, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
+ .filter(|(_, _, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
  .collect::<Vec<_>>();
 
  // Prefer using non-Tor nodes with the most channels as the introduction node.
- peer_info.sort_unstable_by(|(_, a_tor_only, a_channels), (_, b_tor_only, b_channels)| {
- a_tor_only.cmp(b_tor_only).then(a_channels.cmp(b_channels).reverse())
+ peer_info.sort_unstable_by(|(_, _, a_tor_only, a_channels), (_, _, b_tor_only, b_channels)| {
+ a_tor_only.cmp(b_tor_only).then(a_channels.len().cmp(&b_channels.len()).reverse())
  });
 
- let paths = peer_info.into_iter()
- .map(|(peer, _, _)| {
- BlindedPath::new_for_message(&[peer], recipient, &*self.entropy_source, secp_ctx)
- })
- .take(MAX_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- let mut paths = match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if is_recipient_announced {
- BlindedPath::one_hop_for_message(recipient, &*self.entropy_source, secp_ctx)
- .map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }?;
+ let three_hop_paths = peer_info.iter()
+ // Pair peers with their other peers
+ .flat_map(|(node_id, peer, _, channels)|
+ channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get(scid))
+ .filter_map(move |info| info
+ .as_directed_to(&node_id)
+ .map(|(_, source)| source)
+ )
+ .filter(|source| **source != recipient_node_id)
+ .filter(|source| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_onion_messages())
+ .unwrap_or(false)
+ )
+ .filter_map(|source| source.as_pubkey().ok())
+ .map(move |source_pubkey| (source_pubkey, peer.clone()))
+ )
+ .map(|(source_pubkey, peer)| BlindedPath::new_for_message(&[ForwardNode { node_id: source_pubkey, short_channel_id: None }, peer], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ let two_hop_paths = peer_info
+ .iter()
+ .map(|(_, peer, _, _)| BlindedPath::new_for_message(&[peer.clone()], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ // Prefer three-hop paths over two-hop paths for compact paths. Fallback to a one-hop path
+ // if none were found and the recipient node is announced.
+ let mut paths = (!compact_paths).then(|| vec![])
+ .or_else(|| three_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| is_recipient_announced
+ .then(|| BlindedPath::one_hop_for_message(recipient, entropy_source, secp_ctx)
+ .map(|path| vec![path])
+ .unwrap_or(vec![])
+ )
+ )
+ .ok_or(())?;
+
+ if paths.is_empty() {
+ return Err(());
+ }
 
  if compact_paths {
  for path in &mut paths {

lightning/src/routing/gossip.rs

@@ -1040,7 +1040,7 @@ impl<'a> DirectedChannelInfo<'a> {
 
 	/// Returns information for the direction.
 	#[inline]
-	pub(super) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
+	pub(crate) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
 
 	/// Returns the `node_id` of the source hop.
 	///

lightning/src/routing/router.rs

@@ -93,25 +93,37 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  &self, recipient: PublicKey, first_hops: Vec<ChannelDetails>, tlvs: ReceiveTlvs,
  amount_msats: u64, secp_ctx: &Secp256k1<T>
 	) -> Result<Vec<(BlindedPayInfo, BlindedPath)>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PAYMENT_PATHS: usize = 3;
 
  // Ensure peers have at least three channels so that it is more difficult to infer the
  // recipient's node_id.
  const MIN_PEER_CHANNELS: usize = 3;
 
+ // The minimum channel balance certainty required for using a channel in a blinded path.
+ const MIN_CHANNEL_CERTAINTY: f64 = 0.5;
+
+ // The minimum success probability required for using a channel in a blinded path.
+ const MIN_SUCCESS_PROBABILITY: f64 = 0.25;
+
  let network_graph = self.network_graph.deref().read_only();
- let paths = first_hops.into_iter()
+ let counterparty_channels = first_hops.into_iter()
  .filter(|details| details.counterparty.features.supports_route_blinding())
  .filter(|details| amount_msats <= details.inbound_capacity_msat)
  .filter(|details| amount_msats >= details.inbound_htlc_minimum_msat.unwrap_or(0))
  .filter(|details| amount_msats <= details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX))
- .filter(|details| network_graph
+ // Limit to counterparties with announced channels
+ .filter_map(|details|
+ network_graph
  .node(&NodeId::from_pubkey(&details.counterparty.node_id))
- .map(|node_info| node_info.channels.len() >= MIN_PEER_CHANNELS)
- .unwrap_or(false)
+ .map(|info| &info.channels[..])
+ .and_then(|channels| (channels.len() >= MIN_PEER_CHANNELS).then(|| channels))
+ .map(|channels| (details, channels))
  )
- .filter_map(|details| {
+ .filter_map(|(details, counterparty_channels)| {
  let short_channel_id = match details.get_inbound_payment_scid() {
  Some(short_channel_id) => short_channel_id,
  None => return None,
@@ -129,7 +141,7 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  max_cltv_expiry: tlvs.payment_constraints.max_cltv_expiry + cltv_expiry_delta,
  htlc_minimum_msat: details.inbound_htlc_minimum_msat.unwrap_or(0),
  };
-Some(payment::ForwardNode {
+let forward_node = payment::ForwardNode {
  tlvs: ForwardTlvs {
  short_channel_id,
  payment_relay,
@@ -138,29 +150,112 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  },
  node_id: details.counterparty.node_id,
  htlc_maximum_msat: details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX),
- })
- })
- .map(|forward_node| {
+ };
+ Some((forward_node, counterparty_channels))
+ });
+
+ let scorer = self.scorer.read_lock();
+ let three_hop_paths = counterparty_channels.clone()
+ // Pair counterparties with their other channels
+ .flat_map(|(forward_node, counterparty_channels)|
+ counterparty_channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get_key_value(scid))
+ .filter_map(move |(scid, info)| info
+ .as_directed_to(&NodeId::from_pubkey(&forward_node.node_id))
+ .map(|(info, source)| (source, *scid, info))
+ )
+ .filter(|(source, _, _)| **source != recipient_node_id)
+ .filter(|(source, _, _)| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_route_blinding())
+ .unwrap_or(false)
+ )
+ .filter(|(_, _, info)| amount_msats >= info.direction().htlc_minimum_msat)
+ .filter(|(_, _, info)| amount_msats <= info.direction().htlc_maximum_msat)
+ .filter(|(_, scid, info)| {
+ scorer.channel_balance_certainty(*scid, info) >= MIN_CHANNEL_CERTAINTY
+ })
+ .map(move |(source, scid, info)| (source, scid, info, forward_node.clone()))
+ )
+ // Construct blinded paths where the counterparty's counterparty is the introduction
+ // node:
+ //
+ // source --- info ---> counterparty --- counterparty_forward_node ---> recipient
+ .filter_map(|(introduction_node_id, scid, info, counterparty_forward_node)| {
+ let amount_msat = amount_msats;
+ let effective_capacity = info.effective_capacity();
+ let usage = ChannelUsage { amount_msat, inflight_htlc_msat: 0, effective_capacity };
+ let success_probability = scorer.channel_success_probability(
+ scid, &info, usage, &self.score_params
+ );
+
+ if !success_probability.is_finite() {
+ return None;
+ }
+
+ if success_probability < MIN_SUCCESS_PROBABILITY {
+ return None;
+ }
+
+ let htlc_minimum_msat = info.direction().htlc_minimum_msat;
+ let htlc_maximum_msat = info.direction().htlc_maximum_msat;
+ let payment_relay: PaymentRelay = match info.try_into() {
+ Ok(payment_relay) => payment_relay,
+ Err(()) => return None,
+ };
+ let payment_constraints = PaymentConstraints {
+ max_cltv_expiry: payment_relay.cltv_expiry_delta as u32
+ + counterparty_forward_node.tlvs.payment_constraints.max_cltv_expiry,
+ htlc_minimum_msat,
+ };
+ let introduction_forward_node = payment::ForwardNode {
+ tlvs: ForwardTlvs {
+ short_channel_id: scid,
+ payment_relay,
+ payment_constraints,
+ features: BlindedHopFeatures::empty(),
+ },
+ node_id: introduction_node_id.as_pubkey().unwrap(),
+ htlc_maximum_msat,
+ };
+ let path = BlindedPath::new_for_payment(
+ &[introduction_forward_node, counterparty_forward_node], recipient,
+ tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ );
+
+ Some(path.map(|path| (path, success_probability)))
+ });
+
+ let two_hop_paths = counterparty_channels
+ .map(|(forward_node, _)| {
  BlindedPath::new_for_payment(
  &[forward_node], recipient, tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA,
-&*self.entropy_source, secp_ctx
+ entropy_source, secp_ctx
  )
  })
- .take(MAX_PAYMENT_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient)) {
- BlindedPath::one_hop_for_payment(
- recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, &*self.entropy_source, secp_ctx
- ).map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }
+ .take(MAX_PAYMENT_PATHS);
+
+ three_hop_paths
+ .collect::<Result<Vec<_>, _>>().ok()
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .map(|mut paths| {
+ paths.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+ paths.into_iter().map(|(path, _)| path).take(MAX_PAYMENT_PATHS).collect::<Vec<_>>()
+ })
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| network_graph
+ .node(&NodeId::from_pubkey(&recipient)).ok_or(())
+ .and_then(|_| BlindedPath::one_hop_for_payment(
+ recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ )
+ )
+ .map(|path| vec![path])
+ .ok()
+ )
+ .ok_or(())
 	}
 }
 

lightning/src/blinded_path/payment.rs

@@ -23,6 +23,7 @@ use crate::ln::msgs::DecodeError;
 use crate::offers::invoice::BlindedPayInfo;
 use crate::offers::invoice_request::InvoiceRequestFields;
 use crate::offers::offer::OfferId;
+use crate::routing::gossip::DirectedChannelInfo;
 use crate::util::ser::{HighZeroBytesDroppedBigSize, Readable, Writeable, Writer};
 
 #[allow(unused_imports)]
@@ -170,6 +171,19 @@ impl PaymentContext {
 	}
 }
 
+impl PaymentRelay {
+	fn normalize_cltv_expiry_delta(cltv_expiry_delta: u16) -> Result<u16, ()> {
+ // Avoid exposing esoteric CLTV expiry deltas, which could de-anonymize the path.
+ match cltv_expiry_delta {
+ 0..=40 => Ok(40),
+ 41..=80 => Ok(80),
+ 81..=144 => Ok(144),
+ 145..=216 => Ok(216),
+ _ => Err(()),
+ }
+	}
+}
+
 impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
 	type Error = ();
 
@@ -178,16 +192,25 @@ impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
  fee_base_msat, fee_proportional_millionths, cltv_expiry_delta
  } = info;
 
- // Avoid exposing esoteric CLTV expiry deltas
- let cltv_expiry_delta = match cltv_expiry_delta {
- 0..=40 => 40,
- 41..=80 => 80,
- 81..=144 => 144,
- 145..=216 => 216,
- _ => return Err(()),
- };
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(cltv_expiry_delta)?,
+ fee_proportional_millionths,
+ fee_base_msat
+ })
+	}
+}
+
+impl<'a> TryFrom<DirectedChannelInfo<'a>> for PaymentRelay {
+	type Error = ();
+
+	fn try_from(info: DirectedChannelInfo<'a>) -> Result<Self, ()> {
+ let direction = info.direction();
 
- Ok(Self { cltv_expiry_delta, fee_proportional_millionths, fee_base_msat })
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(direction.cltv_expiry_delta)?,
+ fee_proportional_millionths: direction.fees.proportional_millionths,
+ fee_base_msat: direction.fees.base_msat,
+ })
 	}
 }
 

lightning/src/onion_message/messenger.rs

@@ -186,7 +186,7 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// &keys_manager, &keys_manager, logger, &node_id_lookup, message_router,
 /// &offers_message_handler, &custom_message_handler
 /// );
-
+///
 /// # #[derive(Debug)]
 /// # struct YourCustomMessage {}
 /// impl Writeable for YourCustomMessage {
@@ -195,13 +195,15 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// // Write your custom onion message to `w`
 /// }
 /// }
+///
 /// impl OnionMessageContents for YourCustomMessage {
 /// fn tlv_type(&self) -> u64 {
 /// # let your_custom_message_type = 42;
 /// your_custom_message_type
 /// }
 /// fn msg_type(&self) -> &'static str { "YourCustomMessageType" }
 /// }
+///
 /// // Send a custom onion message to a node id.
 /// let destination = Destination::Node(destination_node_id);
 /// let reply_path = None;
@@ -457,6 +459,9 @@ pub trait MessageRouter {
 
 /// A [`MessageRouter`] that can only route to a directly connected [`Destination`].
 ///
+/// When creating [`BlindedPath`]s, prefers three-hop paths over two-hops paths for the compact
+/// representation. For the non-compact representation, three-hop paths are not considered.
+///
 /// # Privacy
 ///
 /// Creating [`BlindedPath`]s may affect privacy since, if a suitable path cannot be found, it will
@@ -488,6 +493,9 @@ where
 	>(
  &self, recipient: PublicKey, peers: I, secp_ctx: &Secp256k1<T>, compact_paths: bool
 	) -> Result<Vec<BlindedPath>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PATHS: usize = 3;
 
@@ -500,40 +508,69 @@ where
  network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient));
 
  let mut peer_info = peers
+ .map(|peer| (NodeId::from_pubkey(&peer.node_id), peer))
  // Limit to peers with announced channels
- .filter_map(|peer|
+ .filter_map(|(node_id, peer)|
  network_graph
- .node(&NodeId::from_pubkey(&peer.node_id))
+ .node(&node_id)
  .filter(|info| info.channels.len() >= MIN_PEER_CHANNELS)
- .map(|info| (peer, info.is_tor_only(), info.channels.len()))
+ .map(|info| (node_id, peer, info.is_tor_only(), &info.channels))
  )
  // Exclude Tor-only nodes when the recipient is announced.
- .filter(|(_, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
+ .filter(|(_, _, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
  .collect::<Vec<_>>();
 
  // Prefer using non-Tor nodes with the most channels as the introduction node.
- peer_info.sort_unstable_by(|(_, a_tor_only, a_channels), (_, b_tor_only, b_channels)| {
- a_tor_only.cmp(b_tor_only).then(a_channels.cmp(b_channels).reverse())
+ peer_info.sort_unstable_by(|(_, _, a_tor_only, a_channels), (_, _, b_tor_only, b_channels)| {
+ a_tor_only.cmp(b_tor_only).then(a_channels.len().cmp(&b_channels.len()).reverse())
  });
 
- let paths = peer_info.into_iter()
- .map(|(peer, _, _)| {
- BlindedPath::new_for_message(&[peer], recipient, &*self.entropy_source, secp_ctx)
- })
- .take(MAX_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- let mut paths = match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if is_recipient_announced {
- BlindedPath::one_hop_for_message(recipient, &*self.entropy_source, secp_ctx)
- .map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }?;
+ let three_hop_paths = peer_info.iter()
+ // Pair peers with their other peers
+ .flat_map(|(node_id, peer, _, channels)|
+ channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get(scid))
+ .filter_map(move |info| info
+ .as_directed_to(&node_id)
+ .map(|(_, source)| source)
+ )
+ .filter(|source| **source != recipient_node_id)
+ .filter(|source| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_onion_messages())
+ .unwrap_or(false)
+ )
+ .filter_map(|source| source.as_pubkey().ok())
+ .map(move |source_pubkey| (source_pubkey, peer.clone()))
+ )
+ .map(|(source_pubkey, peer)| BlindedPath::new_for_message(&[ForwardNode { node_id: source_pubkey, short_channel_id: None }, peer], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ let two_hop_paths = peer_info
+ .iter()
+ .map(|(_, peer, _, _)| BlindedPath::new_for_message(&[peer.clone()], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ // Prefer three-hop paths over two-hop paths for compact paths. Fallback to a one-hop path
+ // if none were found and the recipient node is announced.
+ let mut paths = (!compact_paths).then(|| vec![])
+ .or_else(|| three_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| is_recipient_announced
+ .then(|| BlindedPath::one_hop_for_message(recipient, entropy_source, secp_ctx)
+ .map(|path| vec![path])
+ .unwrap_or(vec![])
+ )
+ )
+ .ok_or(())?;
+
+ if paths.is_empty() {
+ return Err(());
+ }
 
  if compact_paths {
  for path in &mut paths {

lightning/src/routing/gossip.rs

@@ -1040,7 +1040,7 @@ impl<'a> DirectedChannelInfo<'a> {
 
 	/// Returns information for the direction.
 	#[inline]
-	pub(super) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
+	pub(crate) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
 
 	/// Returns the `node_id` of the source hop.
 	///

lightning/src/routing/router.rs

@@ -93,25 +93,37 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  &self, recipient: PublicKey, first_hops: Vec<ChannelDetails>, tlvs: ReceiveTlvs,
  amount_msats: u64, secp_ctx: &Secp256k1<T>
 	) -> Result<Vec<(BlindedPayInfo, BlindedPath)>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PAYMENT_PATHS: usize = 3;
 
  // Ensure peers have at least three channels so that it is more difficult to infer the
  // recipient's node_id.
  const MIN_PEER_CHANNELS: usize = 3;
 
+ // The minimum channel balance certainty required for using a channel in a blinded path.
+ const MIN_CHANNEL_CERTAINTY: f64 = 0.5;
+
+ // The minimum success probability required for using a channel in a blinded path.
+ const MIN_SUCCESS_PROBABILITY: f64 = 0.25;
+
  let network_graph = self.network_graph.deref().read_only();
- let paths = first_hops.into_iter()
+ let counterparty_channels = first_hops.into_iter()
  .filter(|details| details.counterparty.features.supports_route_blinding())
  .filter(|details| amount_msats <= details.inbound_capacity_msat)
  .filter(|details| amount_msats >= details.inbound_htlc_minimum_msat.unwrap_or(0))
  .filter(|details| amount_msats <= details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX))
- .filter(|details| network_graph
+ // Limit to counterparties with announced channels
+ .filter_map(|details|
+ network_graph
  .node(&NodeId::from_pubkey(&details.counterparty.node_id))
- .map(|node_info| node_info.channels.len() >= MIN_PEER_CHANNELS)
- .unwrap_or(false)
+ .map(|info| &info.channels[..])
+ .and_then(|channels| (channels.len() >= MIN_PEER_CHANNELS).then(|| channels))
+ .map(|channels| (details, channels))
  )
- .filter_map(|details| {
+ .filter_map(|(details, counterparty_channels)| {
  let short_channel_id = match details.get_inbound_payment_scid() {
  Some(short_channel_id) => short_channel_id,
  None => return None,
@@ -129,7 +141,7 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  max_cltv_expiry: tlvs.payment_constraints.max_cltv_expiry + cltv_expiry_delta,
  htlc_minimum_msat: details.inbound_htlc_minimum_msat.unwrap_or(0),
  };
-Some(payment::ForwardNode {
+let forward_node = payment::ForwardNode {
  tlvs: ForwardTlvs {
  short_channel_id,
  payment_relay,
@@ -138,29 +150,112 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  },
  node_id: details.counterparty.node_id,
  htlc_maximum_msat: details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX),
- })
- })
- .map(|forward_node| {
+ };
+ Some((forward_node, counterparty_channels))
+ });
+
+ let scorer = self.scorer.read_lock();
+ let three_hop_paths = counterparty_channels.clone()
+ // Pair counterparties with their other channels
+ .flat_map(|(forward_node, counterparty_channels)|
+ counterparty_channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get_key_value(scid))
+ .filter_map(move |(scid, info)| info
+ .as_directed_to(&NodeId::from_pubkey(&forward_node.node_id))
+ .map(|(info, source)| (source, *scid, info))
+ )
+ .filter(|(source, _, _)| **source != recipient_node_id)
+ .filter(|(source, _, _)| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_route_blinding())
+ .unwrap_or(false)
+ )
+ .filter(|(_, _, info)| amount_msats >= info.direction().htlc_minimum_msat)
+ .filter(|(_, _, info)| amount_msats <= info.direction().htlc_maximum_msat)
+ .filter(|(_, scid, info)| {
+ scorer.channel_balance_certainty(*scid, info) >= MIN_CHANNEL_CERTAINTY
+ })
+ .map(move |(source, scid, info)| (source, scid, info, forward_node.clone()))
+ )
+ // Construct blinded paths where the counterparty's counterparty is the introduction
+ // node:
+ //
+ // source --- info ---> counterparty --- counterparty_forward_node ---> recipient
+ .filter_map(|(introduction_node_id, scid, info, counterparty_forward_node)| {
+ let amount_msat = amount_msats;
+ let effective_capacity = info.effective_capacity();
+ let usage = ChannelUsage { amount_msat, inflight_htlc_msat: 0, effective_capacity };
+ let success_probability = scorer.channel_success_probability(
+ scid, &info, usage, &self.score_params
+ );
+
+ if !success_probability.is_finite() {
+ return None;
+ }
+
+ if success_probability < MIN_SUCCESS_PROBABILITY {
+ return None;
+ }
+
+ let htlc_minimum_msat = info.direction().htlc_minimum_msat;
+ let htlc_maximum_msat = info.direction().htlc_maximum_msat;
+ let payment_relay: PaymentRelay = match info.try_into() {
+ Ok(payment_relay) => payment_relay,
+ Err(()) => return None,
+ };
+ let payment_constraints = PaymentConstraints {
+ max_cltv_expiry: payment_relay.cltv_expiry_delta as u32
+ + counterparty_forward_node.tlvs.payment_constraints.max_cltv_expiry,
+ htlc_minimum_msat,
+ };
+ let introduction_forward_node = payment::ForwardNode {
+ tlvs: ForwardTlvs {
+ short_channel_id: scid,
+ payment_relay,
+ payment_constraints,
+ features: BlindedHopFeatures::empty(),
+ },
+ node_id: introduction_node_id.as_pubkey().unwrap(),
+ htlc_maximum_msat,
+ };
+ let path = BlindedPath::new_for_payment(
+ &[introduction_forward_node, counterparty_forward_node], recipient,
+ tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ );
+
+ Some(path.map(|path| (path, success_probability)))
+ });
+
+ let two_hop_paths = counterparty_channels
+ .map(|(forward_node, _)| {
  BlindedPath::new_for_payment(
  &[forward_node], recipient, tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA,
-&*self.entropy_source, secp_ctx
+ entropy_source, secp_ctx
  )
  })
- .take(MAX_PAYMENT_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient)) {
- BlindedPath::one_hop_for_payment(
- recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, &*self.entropy_source, secp_ctx
- ).map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }
+ .take(MAX_PAYMENT_PATHS);
+
+ three_hop_paths
+ .collect::<Result<Vec<_>, _>>().ok()
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .map(|mut paths| {
+ paths.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+ paths.into_iter().map(|(path, _)| path).take(MAX_PAYMENT_PATHS).collect::<Vec<_>>()
+ })
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| network_graph
+ .node(&NodeId::from_pubkey(&recipient)).ok_or(())
+ .and_then(|_| BlindedPath::one_hop_for_payment(
+ recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ )
+ )
+ .map(|path| vec![path])
+ .ok()
+ )
+ .ok_or(())
 	}
 }
 

lightning/src/blinded_path/payment.rs

@@ -23,6 +23,7 @@ use crate::ln::msgs::DecodeError;
 use crate::offers::invoice::BlindedPayInfo;
 use crate::offers::invoice_request::InvoiceRequestFields;
 use crate::offers::offer::OfferId;
+use crate::routing::gossip::DirectedChannelInfo;
 use crate::util::ser::{HighZeroBytesDroppedBigSize, Readable, Writeable, Writer};
 
 #[allow(unused_imports)]
@@ -170,6 +171,19 @@ impl PaymentContext {
 	}
 }
 
+impl PaymentRelay {
+	fn normalize_cltv_expiry_delta(cltv_expiry_delta: u16) -> Result<u16, ()> {
+ // Avoid exposing esoteric CLTV expiry deltas, which could de-anonymize the path.
+ match cltv_expiry_delta {
+ 0..=40 => Ok(40),
+ 41..=80 => Ok(80),
+ 81..=144 => Ok(144),
+ 145..=216 => Ok(216),
+ _ => Err(()),
+ }
+	}
+}
+
 impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
 	type Error = ();
 
@@ -178,16 +192,25 @@ impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
  fee_base_msat, fee_proportional_millionths, cltv_expiry_delta
  } = info;
 
- // Avoid exposing esoteric CLTV expiry deltas
- let cltv_expiry_delta = match cltv_expiry_delta {
- 0..=40 => 40,
- 41..=80 => 80,
- 81..=144 => 144,
- 145..=216 => 216,
- _ => return Err(()),
- };
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(cltv_expiry_delta)?,
+ fee_proportional_millionths,
+ fee_base_msat
+ })
+	}
+}
+
+impl<'a> TryFrom<DirectedChannelInfo<'a>> for PaymentRelay {
+	type Error = ();
+
+	fn try_from(info: DirectedChannelInfo<'a>) -> Result<Self, ()> {
+ let direction = info.direction();
 
- Ok(Self { cltv_expiry_delta, fee_proportional_millionths, fee_base_msat })
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(direction.cltv_expiry_delta)?,
+ fee_proportional_millionths: direction.fees.proportional_millionths,
+ fee_base_msat: direction.fees.base_msat,
+ })
 	}
 }
 

lightning/src/onion_message/messenger.rs

@@ -186,7 +186,7 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// &keys_manager, &keys_manager, logger, &node_id_lookup, message_router,
 /// &offers_message_handler, &custom_message_handler
 /// );
-
+///
 /// # #[derive(Debug)]
 /// # struct YourCustomMessage {}
 /// impl Writeable for YourCustomMessage {
@@ -195,13 +195,15 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// // Write your custom onion message to `w`
 /// }
 /// }
+///
 /// impl OnionMessageContents for YourCustomMessage {
 /// fn tlv_type(&self) -> u64 {
 /// # let your_custom_message_type = 42;
 /// your_custom_message_type
 /// }
 /// fn msg_type(&self) -> &'static str { "YourCustomMessageType" }
 /// }
+///
 /// // Send a custom onion message to a node id.
 /// let destination = Destination::Node(destination_node_id);
 /// let reply_path = None;
@@ -457,6 +459,9 @@ pub trait MessageRouter {
 
 /// A [`MessageRouter`] that can only route to a directly connected [`Destination`].
 ///
+/// When creating [`BlindedPath`]s, prefers three-hop paths over two-hops paths for the compact
+/// representation. For the non-compact representation, three-hop paths are not considered.
+///
 /// # Privacy
 ///
 /// Creating [`BlindedPath`]s may affect privacy since, if a suitable path cannot be found, it will
@@ -488,6 +493,9 @@ where
 	>(
  &self, recipient: PublicKey, peers: I, secp_ctx: &Secp256k1<T>, compact_paths: bool
 	) -> Result<Vec<BlindedPath>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PATHS: usize = 3;
 
@@ -500,40 +508,69 @@ where
  network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient));
 
  let mut peer_info = peers
+ .map(|peer| (NodeId::from_pubkey(&peer.node_id), peer))
  // Limit to peers with announced channels
- .filter_map(|peer|
+ .filter_map(|(node_id, peer)|
  network_graph
- .node(&NodeId::from_pubkey(&peer.node_id))
+ .node(&node_id)
  .filter(|info| info.channels.len() >= MIN_PEER_CHANNELS)
- .map(|info| (peer, info.is_tor_only(), info.channels.len()))
+ .map(|info| (node_id, peer, info.is_tor_only(), &info.channels))
  )
  // Exclude Tor-only nodes when the recipient is announced.
- .filter(|(_, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
+ .filter(|(_, _, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
  .collect::<Vec<_>>();
 
  // Prefer using non-Tor nodes with the most channels as the introduction node.
- peer_info.sort_unstable_by(|(_, a_tor_only, a_channels), (_, b_tor_only, b_channels)| {
- a_tor_only.cmp(b_tor_only).then(a_channels.cmp(b_channels).reverse())
+ peer_info.sort_unstable_by(|(_, _, a_tor_only, a_channels), (_, _, b_tor_only, b_channels)| {
+ a_tor_only.cmp(b_tor_only).then(a_channels.len().cmp(&b_channels.len()).reverse())
  });
 
- let paths = peer_info.into_iter()
- .map(|(peer, _, _)| {
- BlindedPath::new_for_message(&[peer], recipient, &*self.entropy_source, secp_ctx)
- })
- .take(MAX_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- let mut paths = match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if is_recipient_announced {
- BlindedPath::one_hop_for_message(recipient, &*self.entropy_source, secp_ctx)
- .map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }?;
+ let three_hop_paths = peer_info.iter()
+ // Pair peers with their other peers
+ .flat_map(|(node_id, peer, _, channels)|
+ channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get(scid))
+ .filter_map(move |info| info
+ .as_directed_to(&node_id)
+ .map(|(_, source)| source)
+ )
+ .filter(|source| **source != recipient_node_id)
+ .filter(|source| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_onion_messages())
+ .unwrap_or(false)
+ )
+ .filter_map(|source| source.as_pubkey().ok())
+ .map(move |source_pubkey| (source_pubkey, peer.clone()))
+ )
+ .map(|(source_pubkey, peer)| BlindedPath::new_for_message(&[ForwardNode { node_id: source_pubkey, short_channel_id: None }, peer], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ let two_hop_paths = peer_info
+ .iter()
+ .map(|(_, peer, _, _)| BlindedPath::new_for_message(&[peer.clone()], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ // Prefer three-hop paths over two-hop paths for compact paths. Fallback to a one-hop path
+ // if none were found and the recipient node is announced.
+ let mut paths = (!compact_paths).then(|| vec![])
+ .or_else(|| three_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| is_recipient_announced
+ .then(|| BlindedPath::one_hop_for_message(recipient, entropy_source, secp_ctx)
+ .map(|path| vec![path])
+ .unwrap_or(vec![])
+ )
+ )
+ .ok_or(())?;
+
+ if paths.is_empty() {
+ return Err(());
+ }
 
  if compact_paths {
  for path in &mut paths {

lightning/src/routing/gossip.rs

@@ -1040,7 +1040,7 @@ impl<'a> DirectedChannelInfo<'a> {
 
 	/// Returns information for the direction.
 	#[inline]
-	pub(super) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
+	pub(crate) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
 
 	/// Returns the `node_id` of the source hop.
 	///

lightning/src/routing/router.rs

@@ -93,25 +93,37 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  &self, recipient: PublicKey, first_hops: Vec<ChannelDetails>, tlvs: ReceiveTlvs,
  amount_msats: u64, secp_ctx: &Secp256k1<T>
 	) -> Result<Vec<(BlindedPayInfo, BlindedPath)>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PAYMENT_PATHS: usize = 3;
 
  // Ensure peers have at least three channels so that it is more difficult to infer the
  // recipient's node_id.
  const MIN_PEER_CHANNELS: usize = 3;
 
+ // The minimum channel balance certainty required for using a channel in a blinded path.
+ const MIN_CHANNEL_CERTAINTY: f64 = 0.5;
+
+ // The minimum success probability required for using a channel in a blinded path.
+ const MIN_SUCCESS_PROBABILITY: f64 = 0.25;
+
  let network_graph = self.network_graph.deref().read_only();
- let paths = first_hops.into_iter()
+ let counterparty_channels = first_hops.into_iter()
  .filter(|details| details.counterparty.features.supports_route_blinding())
  .filter(|details| amount_msats <= details.inbound_capacity_msat)
  .filter(|details| amount_msats >= details.inbound_htlc_minimum_msat.unwrap_or(0))
  .filter(|details| amount_msats <= details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX))
- .filter(|details| network_graph
+ // Limit to counterparties with announced channels
+ .filter_map(|details|
+ network_graph
  .node(&NodeId::from_pubkey(&details.counterparty.node_id))
- .map(|node_info| node_info.channels.len() >= MIN_PEER_CHANNELS)
- .unwrap_or(false)
+ .map(|info| &info.channels[..])
+ .and_then(|channels| (channels.len() >= MIN_PEER_CHANNELS).then(|| channels))
+ .map(|channels| (details, channels))
  )
- .filter_map(|details| {
+ .filter_map(|(details, counterparty_channels)| {
  let short_channel_id = match details.get_inbound_payment_scid() {
  Some(short_channel_id) => short_channel_id,
  None => return None,
@@ -129,7 +141,7 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  max_cltv_expiry: tlvs.payment_constraints.max_cltv_expiry + cltv_expiry_delta,
  htlc_minimum_msat: details.inbound_htlc_minimum_msat.unwrap_or(0),
  };
-Some(payment::ForwardNode {
+let forward_node = payment::ForwardNode {
  tlvs: ForwardTlvs {
  short_channel_id,
  payment_relay,
@@ -138,29 +150,112 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  },
  node_id: details.counterparty.node_id,
  htlc_maximum_msat: details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX),
- })
- })
- .map(|forward_node| {
+ };
+ Some((forward_node, counterparty_channels))
+ });
+
+ let scorer = self.scorer.read_lock();
+ let three_hop_paths = counterparty_channels.clone()
+ // Pair counterparties with their other channels
+ .flat_map(|(forward_node, counterparty_channels)|
+ counterparty_channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get_key_value(scid))
+ .filter_map(move |(scid, info)| info
+ .as_directed_to(&NodeId::from_pubkey(&forward_node.node_id))
+ .map(|(info, source)| (source, *scid, info))
+ )
+ .filter(|(source, _, _)| **source != recipient_node_id)
+ .filter(|(source, _, _)| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_route_blinding())
+ .unwrap_or(false)
+ )
+ .filter(|(_, _, info)| amount_msats >= info.direction().htlc_minimum_msat)
+ .filter(|(_, _, info)| amount_msats <= info.direction().htlc_maximum_msat)
+ .filter(|(_, scid, info)| {
+ scorer.channel_balance_certainty(*scid, info) >= MIN_CHANNEL_CERTAINTY
+ })
+ .map(move |(source, scid, info)| (source, scid, info, forward_node.clone()))
+ )
+ // Construct blinded paths where the counterparty's counterparty is the introduction
+ // node:
+ //
+ // source --- info ---> counterparty --- counterparty_forward_node ---> recipient
+ .filter_map(|(introduction_node_id, scid, info, counterparty_forward_node)| {
+ let amount_msat = amount_msats;
+ let effective_capacity = info.effective_capacity();
+ let usage = ChannelUsage { amount_msat, inflight_htlc_msat: 0, effective_capacity };
+ let success_probability = scorer.channel_success_probability(
+ scid, &info, usage, &self.score_params
+ );
+
+ if !success_probability.is_finite() {
+ return None;
+ }
+
+ if success_probability < MIN_SUCCESS_PROBABILITY {
+ return None;
+ }
+
+ let htlc_minimum_msat = info.direction().htlc_minimum_msat;
+ let htlc_maximum_msat = info.direction().htlc_maximum_msat;
+ let payment_relay: PaymentRelay = match info.try_into() {
+ Ok(payment_relay) => payment_relay,
+ Err(()) => return None,
+ };
+ let payment_constraints = PaymentConstraints {
+ max_cltv_expiry: payment_relay.cltv_expiry_delta as u32
+ + counterparty_forward_node.tlvs.payment_constraints.max_cltv_expiry,
+ htlc_minimum_msat,
+ };
+ let introduction_forward_node = payment::ForwardNode {
+ tlvs: ForwardTlvs {
+ short_channel_id: scid,
+ payment_relay,
+ payment_constraints,
+ features: BlindedHopFeatures::empty(),
+ },
+ node_id: introduction_node_id.as_pubkey().unwrap(),
+ htlc_maximum_msat,
+ };
+ let path = BlindedPath::new_for_payment(
+ &[introduction_forward_node, counterparty_forward_node], recipient,
+ tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ );
+
+ Some(path.map(|path| (path, success_probability)))
+ });
+
+ let two_hop_paths = counterparty_channels
+ .map(|(forward_node, _)| {
  BlindedPath::new_for_payment(
  &[forward_node], recipient, tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA,
-&*self.entropy_source, secp_ctx
+ entropy_source, secp_ctx
  )
  })
- .take(MAX_PAYMENT_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient)) {
- BlindedPath::one_hop_for_payment(
- recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, &*self.entropy_source, secp_ctx
- ).map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }
+ .take(MAX_PAYMENT_PATHS);
+
+ three_hop_paths
+ .collect::<Result<Vec<_>, _>>().ok()
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .map(|mut paths| {
+ paths.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+ paths.into_iter().map(|(path, _)| path).take(MAX_PAYMENT_PATHS).collect::<Vec<_>>()
+ })
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| network_graph
+ .node(&NodeId::from_pubkey(&recipient)).ok_or(())
+ .and_then(|_| BlindedPath::one_hop_for_payment(
+ recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ )
+ )
+ .map(|path| vec![path])
+ .ok()
+ )
+ .ok_or(())
 	}
 }
 

lightning/src/blinded_path/payment.rs

@@ -23,6 +23,7 @@ use crate::ln::msgs::DecodeError;
 use crate::offers::invoice::BlindedPayInfo;
 use crate::offers::invoice_request::InvoiceRequestFields;
 use crate::offers::offer::OfferId;
+use crate::routing::gossip::DirectedChannelInfo;
 use crate::util::ser::{HighZeroBytesDroppedBigSize, Readable, Writeable, Writer};
 
 #[allow(unused_imports)]
@@ -170,6 +171,19 @@ impl PaymentContext {
 	}
 }
 
+impl PaymentRelay {
+	fn normalize_cltv_expiry_delta(cltv_expiry_delta: u16) -> Result<u16, ()> {
+ // Avoid exposing esoteric CLTV expiry deltas, which could de-anonymize the path.
+ match cltv_expiry_delta {
+ 0..=40 => Ok(40),
+ 41..=80 => Ok(80),
+ 81..=144 => Ok(144),
+ 145..=216 => Ok(216),
+ _ => Err(()),
+ }
+	}
+}
+
 impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
 	type Error = ();
 
@@ -178,16 +192,25 @@ impl TryFrom<CounterpartyForwardingInfo> for PaymentRelay {
  fee_base_msat, fee_proportional_millionths, cltv_expiry_delta
  } = info;
 
- // Avoid exposing esoteric CLTV expiry deltas
- let cltv_expiry_delta = match cltv_expiry_delta {
- 0..=40 => 40,
- 41..=80 => 80,
- 81..=144 => 144,
- 145..=216 => 216,
- _ => return Err(()),
- };
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(cltv_expiry_delta)?,
+ fee_proportional_millionths,
+ fee_base_msat
+ })
+	}
+}
+
+impl<'a> TryFrom<DirectedChannelInfo<'a>> for PaymentRelay {
+	type Error = ();
+
+	fn try_from(info: DirectedChannelInfo<'a>) -> Result<Self, ()> {
+ let direction = info.direction();
 
- Ok(Self { cltv_expiry_delta, fee_proportional_millionths, fee_base_msat })
+ Ok(Self {
+ cltv_expiry_delta: Self::normalize_cltv_expiry_delta(direction.cltv_expiry_delta)?,
+ fee_proportional_millionths: direction.fees.proportional_millionths,
+ fee_base_msat: direction.fees.base_msat,
+ })
 	}
 }
 

lightning/src/onion_message/messenger.rs

@@ -186,7 +186,7 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// &keys_manager, &keys_manager, logger, &node_id_lookup, message_router,
 /// &offers_message_handler, &custom_message_handler
 /// );
-
+///
 /// # #[derive(Debug)]
 /// # struct YourCustomMessage {}
 /// impl Writeable for YourCustomMessage {
@@ -195,13 +195,15 @@ for OnionMessenger<ES, NS, L, NL, MR, OMH, CMH> where
 /// // Write your custom onion message to `w`
 /// }
 /// }
+///
 /// impl OnionMessageContents for YourCustomMessage {
 /// fn tlv_type(&self) -> u64 {
 /// # let your_custom_message_type = 42;
 /// your_custom_message_type
 /// }
 /// fn msg_type(&self) -> &'static str { "YourCustomMessageType" }
 /// }
+///
 /// // Send a custom onion message to a node id.
 /// let destination = Destination::Node(destination_node_id);
 /// let reply_path = None;
@@ -457,6 +459,9 @@ pub trait MessageRouter {
 
 /// A [`MessageRouter`] that can only route to a directly connected [`Destination`].
 ///
+/// When creating [`BlindedPath`]s, prefers three-hop paths over two-hops paths for the compact
+/// representation. For the non-compact representation, three-hop paths are not considered.
+///
 /// # Privacy
 ///
 /// Creating [`BlindedPath`]s may affect privacy since, if a suitable path cannot be found, it will
@@ -488,6 +493,9 @@ where
 	>(
  &self, recipient: PublicKey, peers: I, secp_ctx: &Secp256k1<T>, compact_paths: bool
 	) -> Result<Vec<BlindedPath>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PATHS: usize = 3;
 
@@ -500,40 +508,69 @@ where
  network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient));
 
  let mut peer_info = peers
+ .map(|peer| (NodeId::from_pubkey(&peer.node_id), peer))
  // Limit to peers with announced channels
- .filter_map(|peer|
+ .filter_map(|(node_id, peer)|
  network_graph
- .node(&NodeId::from_pubkey(&peer.node_id))
+ .node(&node_id)
  .filter(|info| info.channels.len() >= MIN_PEER_CHANNELS)
- .map(|info| (peer, info.is_tor_only(), info.channels.len()))
+ .map(|info| (node_id, peer, info.is_tor_only(), &info.channels))
  )
  // Exclude Tor-only nodes when the recipient is announced.
- .filter(|(_, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
+ .filter(|(_, _, is_tor_only, _)| !(*is_tor_only && is_recipient_announced))
  .collect::<Vec<_>>();
 
  // Prefer using non-Tor nodes with the most channels as the introduction node.
- peer_info.sort_unstable_by(|(_, a_tor_only, a_channels), (_, b_tor_only, b_channels)| {
- a_tor_only.cmp(b_tor_only).then(a_channels.cmp(b_channels).reverse())
+ peer_info.sort_unstable_by(|(_, _, a_tor_only, a_channels), (_, _, b_tor_only, b_channels)| {
+ a_tor_only.cmp(b_tor_only).then(a_channels.len().cmp(&b_channels.len()).reverse())
  });
 
- let paths = peer_info.into_iter()
- .map(|(peer, _, _)| {
- BlindedPath::new_for_message(&[peer], recipient, &*self.entropy_source, secp_ctx)
- })
- .take(MAX_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- let mut paths = match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if is_recipient_announced {
- BlindedPath::one_hop_for_message(recipient, &*self.entropy_source, secp_ctx)
- .map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }?;
+ let three_hop_paths = peer_info.iter()
+ // Pair peers with their other peers
+ .flat_map(|(node_id, peer, _, channels)|
+ channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get(scid))
+ .filter_map(move |info| info
+ .as_directed_to(&node_id)
+ .map(|(_, source)| source)
+ )
+ .filter(|source| **source != recipient_node_id)
+ .filter(|source| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_onion_messages())
+ .unwrap_or(false)
+ )
+ .filter_map(|source| source.as_pubkey().ok())
+ .map(move |source_pubkey| (source_pubkey, peer.clone()))
+ )
+ .map(|(source_pubkey, peer)| BlindedPath::new_for_message(&[ForwardNode { node_id: source_pubkey, short_channel_id: None }, peer], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ let two_hop_paths = peer_info
+ .iter()
+ .map(|(_, peer, _, _)| BlindedPath::new_for_message(&[peer.clone()], recipient, entropy_source, secp_ctx))
+ .take(MAX_PATHS);
+
+ // Prefer three-hop paths over two-hop paths for compact paths. Fallback to a one-hop path
+ // if none were found and the recipient node is announced.
+ let mut paths = (!compact_paths).then(|| vec![])
+ .or_else(|| three_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| is_recipient_announced
+ .then(|| BlindedPath::one_hop_for_message(recipient, entropy_source, secp_ctx)
+ .map(|path| vec![path])
+ .unwrap_or(vec![])
+ )
+ )
+ .ok_or(())?;
+
+ if paths.is_empty() {
+ return Err(());
+ }
 
  if compact_paths {
  for path in &mut paths {

lightning/src/routing/gossip.rs

@@ -1040,7 +1040,7 @@ impl<'a> DirectedChannelInfo<'a> {
 
 	/// Returns information for the direction.
 	#[inline]
-	pub(super) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
+	pub(crate) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction }
 
 	/// Returns the `node_id` of the source hop.
 	///

lightning/src/routing/router.rs

@@ -93,25 +93,37 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  &self, recipient: PublicKey, first_hops: Vec<ChannelDetails>, tlvs: ReceiveTlvs,
  amount_msats: u64, secp_ctx: &Secp256k1<T>
 	) -> Result<Vec<(BlindedPayInfo, BlindedPath)>, ()> {
+ let entropy_source = &*self.entropy_source;
+ let recipient_node_id = NodeId::from_pubkey(&recipient);
+
  // Limit the number of blinded paths that are computed.
  const MAX_PAYMENT_PATHS: usize = 3;
 
  // Ensure peers have at least three channels so that it is more difficult to infer the
  // recipient's node_id.
  const MIN_PEER_CHANNELS: usize = 3;
 
+ // The minimum channel balance certainty required for using a channel in a blinded path.
+ const MIN_CHANNEL_CERTAINTY: f64 = 0.5;
+
+ // The minimum success probability required for using a channel in a blinded path.
+ const MIN_SUCCESS_PROBABILITY: f64 = 0.25;
+
  let network_graph = self.network_graph.deref().read_only();
- let paths = first_hops.into_iter()
+ let counterparty_channels = first_hops.into_iter()
  .filter(|details| details.counterparty.features.supports_route_blinding())
  .filter(|details| amount_msats <= details.inbound_capacity_msat)
  .filter(|details| amount_msats >= details.inbound_htlc_minimum_msat.unwrap_or(0))
  .filter(|details| amount_msats <= details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX))
- .filter(|details| network_graph
+ // Limit to counterparties with announced channels
+ .filter_map(|details|
+ network_graph
  .node(&NodeId::from_pubkey(&details.counterparty.node_id))
- .map(|node_info| node_info.channels.len() >= MIN_PEER_CHANNELS)
- .unwrap_or(false)
+ .map(|info| &info.channels[..])
+ .and_then(|channels| (channels.len() >= MIN_PEER_CHANNELS).then(|| channels))
+ .map(|channels| (details, channels))
  )
- .filter_map(|details| {
+ .filter_map(|(details, counterparty_channels)| {
  let short_channel_id = match details.get_inbound_payment_scid() {
  Some(short_channel_id) => short_channel_id,
  None => return None,
@@ -129,7 +141,7 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  max_cltv_expiry: tlvs.payment_constraints.max_cltv_expiry + cltv_expiry_delta,
  htlc_minimum_msat: details.inbound_htlc_minimum_msat.unwrap_or(0),
  };
-Some(payment::ForwardNode {
+let forward_node = payment::ForwardNode {
  tlvs: ForwardTlvs {
  short_channel_id,
  payment_relay,
@@ -138,29 +150,112 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, ES: Deref, S: Deref,
  },
  node_id: details.counterparty.node_id,
  htlc_maximum_msat: details.inbound_htlc_maximum_msat.unwrap_or(u64::MAX),
- })
- })
- .map(|forward_node| {
+ };
+ Some((forward_node, counterparty_channels))
+ });
+
+ let scorer = self.scorer.read_lock();
+ let three_hop_paths = counterparty_channels.clone()
+ // Pair counterparties with their other channels
+ .flat_map(|(forward_node, counterparty_channels)|
+ counterparty_channels
+ .iter()
+ .filter_map(|scid| network_graph.channels().get_key_value(scid))
+ .filter_map(move |(scid, info)| info
+ .as_directed_to(&NodeId::from_pubkey(&forward_node.node_id))
+ .map(|(info, source)| (source, *scid, info))
+ )
+ .filter(|(source, _, _)| **source != recipient_node_id)
+ .filter(|(source, _, _)| network_graph
+ .node(source)
+ .and_then(|info| info.announcement_info.as_ref())
+ .map(|info| info.features().supports_route_blinding())
+ .unwrap_or(false)
+ )
+ .filter(|(_, _, info)| amount_msats >= info.direction().htlc_minimum_msat)
+ .filter(|(_, _, info)| amount_msats <= info.direction().htlc_maximum_msat)
+ .filter(|(_, scid, info)| {
+ scorer.channel_balance_certainty(*scid, info) >= MIN_CHANNEL_CERTAINTY
+ })
+ .map(move |(source, scid, info)| (source, scid, info, forward_node.clone()))
+ )
+ // Construct blinded paths where the counterparty's counterparty is the introduction
+ // node:
+ //
+ // source --- info ---> counterparty --- counterparty_forward_node ---> recipient
+ .filter_map(|(introduction_node_id, scid, info, counterparty_forward_node)| {
+ let amount_msat = amount_msats;
+ let effective_capacity = info.effective_capacity();
+ let usage = ChannelUsage { amount_msat, inflight_htlc_msat: 0, effective_capacity };
+ let success_probability = scorer.channel_success_probability(
+ scid, &info, usage, &self.score_params
+ );
+
+ if !success_probability.is_finite() {
+ return None;
+ }
+
+ if success_probability < MIN_SUCCESS_PROBABILITY {
+ return None;
+ }
+
+ let htlc_minimum_msat = info.direction().htlc_minimum_msat;
+ let htlc_maximum_msat = info.direction().htlc_maximum_msat;
+ let payment_relay: PaymentRelay = match info.try_into() {
+ Ok(payment_relay) => payment_relay,
+ Err(()) => return None,
+ };
+ let payment_constraints = PaymentConstraints {
+ max_cltv_expiry: payment_relay.cltv_expiry_delta as u32
+ + counterparty_forward_node.tlvs.payment_constraints.max_cltv_expiry,
+ htlc_minimum_msat,
+ };
+ let introduction_forward_node = payment::ForwardNode {
+ tlvs: ForwardTlvs {
+ short_channel_id: scid,
+ payment_relay,
+ payment_constraints,
+ features: BlindedHopFeatures::empty(),
+ },
+ node_id: introduction_node_id.as_pubkey().unwrap(),
+ htlc_maximum_msat,
+ };
+ let path = BlindedPath::new_for_payment(
+ &[introduction_forward_node, counterparty_forward_node], recipient,
+ tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ );
+
+ Some(path.map(|path| (path, success_probability)))
+ });
+
+ let two_hop_paths = counterparty_channels
+ .map(|(forward_node, _)| {
  BlindedPath::new_for_payment(
  &[forward_node], recipient, tlvs.clone(), u64::MAX, MIN_FINAL_CLTV_EXPIRY_DELTA,
-&*self.entropy_source, secp_ctx
+ entropy_source, secp_ctx
  )
  })
- .take(MAX_PAYMENT_PATHS)
- .collect::<Result<Vec<_>, _>>();
-
- match paths {
- Ok(paths) if !paths.is_empty() => Ok(paths),
- _ => {
- if network_graph.nodes().contains_key(&NodeId::from_pubkey(&recipient)) {
- BlindedPath::one_hop_for_payment(
- recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, &*self.entropy_source, secp_ctx
- ).map(|path| vec![path])
- } else {
- Err(())
- }
- },
- }
+ .take(MAX_PAYMENT_PATHS);
+
+ three_hop_paths
+ .collect::<Result<Vec<_>, _>>().ok()
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .map(|mut paths| {
+ paths.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+ paths.into_iter().map(|(path, _)| path).take(MAX_PAYMENT_PATHS).collect::<Vec<_>>()
+ })
+ .or_else(|| two_hop_paths.collect::<Result<Vec<_>, _>>().ok())
+ .and_then(|paths| (!paths.is_empty()).then(|| paths))
+ .or_else(|| network_graph
+ .node(&NodeId::from_pubkey(&recipient)).ok_or(())
+ .and_then(|_| BlindedPath::one_hop_for_payment(
+ recipient, tlvs, MIN_FINAL_CLTV_EXPIRY_DELTA, entropy_source, secp_ctx
+ )
+ )
+ .map(|path| vec![path])
+ .ok()
+ )
+ .ok_or(())
 	}
 }