projects / rust-lightning / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Generalize BlindedPath::introduction_node_id field
[rust-lightning] / lightning / src / routing / scoring.rs
diff --git a/lightning/src/routing/scoring.rs b/lightning/src/routing/scoring.rs
index 12ffdecec429cdbd6809107215e2bc488d94a568..4cb9144d3394ed94896b861e5ac847994776f122 100644 (file)
--- a/lightning/src/routing/scoring.rs
+++ b/lightning/src/routing/scoring.rs
@@ -58,18 +58,21 @@
 
 use crate::ln::msgs::DecodeError;
 use crate::routing::gossip::{EffectiveCapacity, NetworkGraph, NodeId};
-use crate::routing::router::{Path, CandidateRouteHop};
+use crate::routing::router::{Path, CandidateRouteHop, PublicHopCandidate};
 use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer};
 use crate::util::logger::Logger;
 
 use crate::prelude::*;
 use core::{cmp, fmt};
-use core::cell::{RefCell, RefMut, Ref};
-use core::convert::TryInto;
 use core::ops::{Deref, DerefMut};
 use core::time::Duration;
 use crate::io::{self, Read};
-use crate::sync::{Mutex, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard};
+use crate::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+#[cfg(not(c_bindings))]
+use {
+       core::cell::{RefCell, RefMut, Ref},
+       crate::sync::{Mutex, MutexGuard},
+};
 
 /// We define Score ever-so-slightly differently based on whether we are being built for C bindings
 /// or not. For users, `LockableScore` must somehow be writeable to disk. For Rust users, this is
@@ -247,7 +250,7 @@ impl<'a, T: Score + 'a> LockableScore<'a> for RefCell<T> {
        }
 }
 
-#[cfg(not(c_bindings))]
+#[cfg(any(not(c_bindings), feature = "_test_utils", test))]
 impl<'a, T: Score + 'a> LockableScore<'a> for RwLock<T> {
        type ScoreUpdate = T;
        type ScoreLookUp = T;
@@ -649,7 +652,7 @@ impl Default for ProbabilisticScoringFeeParameters {
                        base_penalty_amount_multiplier_msat: 8192,
                        liquidity_penalty_multiplier_msat: 30_000,
                        liquidity_penalty_amount_multiplier_msat: 192,
-                       manual_node_penalties: HashMap::new(),
+                       manual_node_penalties: new_hash_map(),
                        anti_probing_penalty_msat: 250,
                        considered_impossible_penalty_msat: 1_0000_0000_000,
                        historical_liquidity_penalty_multiplier_msat: 10_000,
@@ -691,7 +694,7 @@ impl ProbabilisticScoringFeeParameters {
 
        /// Clears the list of manual penalties that are applied during path finding.
        pub fn clear_manual_penalties(&mut self) {
-               self.manual_node_penalties = HashMap::new();
+               self.manual_node_penalties = new_hash_map();
        }
 }
 
@@ -705,7 +708,7 @@ impl ProbabilisticScoringFeeParameters {
                        liquidity_penalty_amount_multiplier_msat: 0,
                        historical_liquidity_penalty_multiplier_msat: 0,
                        historical_liquidity_penalty_amount_multiplier_msat: 0,
-                       manual_node_penalties: HashMap::new(),
+                       manual_node_penalties: new_hash_map(),
                        anti_probing_penalty_msat: 0,
                        considered_impossible_penalty_msat: 0,
                        linear_success_probability: true,
@@ -815,7 +818,7 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref> ProbabilisticScorer<G, L> whe
                        decay_params,
                        network_graph,
                        logger,
-                       channel_liquidities: HashMap::new(),
+                       channel_liquidities: new_hash_map(),
                }
        }
 
@@ -1320,13 +1323,13 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref> ScoreLookUp for Probabilistic
                &self, candidate: &CandidateRouteHop, usage: ChannelUsage, score_params: &ProbabilisticScoringFeeParameters
        ) -> u64 {
                let (scid, target) = match candidate {
-                       CandidateRouteHop::PublicHop { info, short_channel_id } => {
+                       CandidateRouteHop::PublicHop(PublicHopCandidate { info, short_channel_id }) => {
                                (short_channel_id, info.target())
                        },
                        _ => return 0,
                };
                let source = candidate.source();
-               if let Some(penalty) = score_params.manual_node_penalties.get(&target) {
+               if let Some(penalty) = score_params.manual_node_penalties.get(target) {
                        return *penalty;
                }
 
@@ -1356,7 +1359,7 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref> ScoreLookUp for Probabilistic
                let amount_msat = usage.amount_msat.saturating_add(usage.inflight_htlc_msat);
                let capacity_msat = usage.effective_capacity.as_msat();
                self.channel_liquidities
-                       .get(&scid)
+                       .get(scid)
                        .unwrap_or(&ChannelLiquidity::new(Duration::ZERO))
                        .as_directed(&source, &target, capacity_msat)
                        .penalty_msat(amount_msat, score_params)
@@ -2069,7 +2072,7 @@ ReadableArgs<(ProbabilisticScoringDecayParameters, G, L)> for ProbabilisticScore
                r: &mut R, args: (ProbabilisticScoringDecayParameters, G, L)
        ) -> Result<Self, DecodeError> {
                let (decay_params, network_graph, logger) = args;
-               let mut channel_liquidities = HashMap::new();
+               let mut channel_liquidities = new_hash_map();
                read_tlv_fields!(r, {
                        (0, channel_liquidities, required),
                });
@@ -2149,13 +2152,13 @@ impl Readable for ChannelLiquidity {
 #[cfg(test)]
 mod tests {
        use super::{ChannelLiquidity, HistoricalBucketRangeTracker, ProbabilisticScoringFeeParameters, ProbabilisticScoringDecayParameters, ProbabilisticScorer};
-       use crate::blinded_path::{BlindedHop, BlindedPath};
+       use crate::blinded_path::{BlindedHop, BlindedPath, IntroductionNode};
        use crate::util::config::UserConfig;
 
        use crate::ln::channelmanager;
        use crate::ln::msgs::{ChannelAnnouncement, ChannelUpdate, UnsignedChannelAnnouncement, UnsignedChannelUpdate};
        use crate::routing::gossip::{EffectiveCapacity, NetworkGraph, NodeId};
-       use crate::routing::router::{BlindedTail, Path, RouteHop, CandidateRouteHop};
+       use crate::routing::router::{BlindedTail, Path, RouteHop, CandidateRouteHop, PublicHopCandidate};
        use crate::routing::scoring::{ChannelUsage, ScoreLookUp, ScoreUpdate};
        use crate::util::ser::{ReadableArgs, Writeable};
        use crate::util::test_utils::{self, TestLogger};
@@ -2531,10 +2534,10 @@ mod tests {
                let network_graph = network_graph.read_only();
                let channel = network_graph.channel(42).unwrap();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 0);
                let usage = ChannelUsage { amount_msat: 10_240, ..usage };
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 0);
@@ -2594,10 +2597,10 @@ mod tests {
                };
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 0);
                let usage = ChannelUsage { amount_msat: 50, ..usage };
                assert_ne!(scorer.channel_penalty_msat(&candidate, usage, &params), 0);
@@ -2625,10 +2628,10 @@ mod tests {
                let successful_path = payment_path_for_amount(200);
                let channel = &network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 41,
-               };
+               });
 
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 301);
 
@@ -2658,10 +2661,10 @@ mod tests {
                };
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 128);
                let usage = ChannelUsage { amount_msat: 500, ..usage };
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 301);
@@ -2698,10 +2701,10 @@ mod tests {
                };
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 128);
                let usage = ChannelUsage { amount_msat: 500, ..usage };
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 301);
@@ -2764,50 +2767,50 @@ mod tests {
                };
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&node_a).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 128);
                // Note that a default liquidity bound is used for B -> C as no channel exists
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&node_b).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 43,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 128);
                let channel = network_graph.read_only().channel(44).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&node_c).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 44,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 128);
 
                scorer.payment_path_failed(&Path { hops: path, blinded_tail: None }, 43, Duration::ZERO);
 
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&node_a).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 80);
                // Note that a default liquidity bound is used for B -> C as no channel exists
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&node_b).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 43,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 128);
                let channel = network_graph.read_only().channel(44).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&node_c).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 44,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 128);
        }
 
@@ -2830,20 +2833,20 @@ mod tests {
                let channel_42 = network_graph.get(&42).unwrap();
                let channel_43 = network_graph.get(&43).unwrap();
                let (info, _) = channel_42.as_directed_from(&source).unwrap();
-               let candidate_41 = CandidateRouteHop::PublicHop {
+               let candidate_41 = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 41,
-               };
+               });
                let (info, target) = channel_42.as_directed_from(&source).unwrap();
-               let candidate_42 = CandidateRouteHop::PublicHop {
+               let candidate_42 = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                let (info, _) = channel_43.as_directed_from(&target).unwrap();
-               let candidate_43 = CandidateRouteHop::PublicHop {
+               let candidate_43 = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 43,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate_41, usage, &params), 128);
                assert_eq!(scorer.channel_penalty_msat(&candidate_42, usage, &params), 128);
                assert_eq!(scorer.channel_penalty_msat(&candidate_43, usage, &params), 128);
@@ -2878,10 +2881,10 @@ mod tests {
                };
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 0);
                let usage = ChannelUsage { amount_msat: 1_023, ..usage };
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 2_000);
@@ -2967,10 +2970,10 @@ mod tests {
                };
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
 
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 300);
 
@@ -3022,10 +3025,10 @@ mod tests {
                scorer.payment_path_failed(&payment_path_for_amount(500), 42, Duration::ZERO);
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), u64::max_value());
 
                scorer.time_passed(Duration::from_secs(10));
@@ -3066,10 +3069,10 @@ mod tests {
                scorer.payment_path_failed(&payment_path_for_amount(500), 42, Duration::ZERO);
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), u64::max_value());
 
                if decay_before_reload {
@@ -3118,10 +3121,10 @@ mod tests {
                };
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 11497);
                let usage = ChannelUsage {
                        effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_950_000_000, htlc_maximum_msat: 1_000 }, ..usage
@@ -3183,10 +3186,10 @@ mod tests {
                let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &network_graph, &logger);
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 58);
 
                let params = ProbabilisticScoringFeeParameters {
@@ -3225,10 +3228,10 @@ mod tests {
                let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &network_graph, &logger);
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 300);
 
                let params = ProbabilisticScoringFeeParameters {
@@ -3257,10 +3260,10 @@ mod tests {
                let decay_params = ProbabilisticScoringDecayParameters::zero_penalty();
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                let scorer = ProbabilisticScorer::new(decay_params, &network_graph, &logger);
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 80_000);
        }
@@ -3284,10 +3287,10 @@ mod tests {
                let network_graph = network_graph.read_only();
                let channel = network_graph.channel(42).unwrap();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_ne!(scorer.channel_penalty_msat(&candidate, usage, &params), u64::max_value());
 
                let usage = ChannelUsage { inflight_htlc_msat: 251, ..usage };
@@ -3311,10 +3314,10 @@ mod tests {
                let network_graph = network_graph.read_only();
                let channel = network_graph.channel(42).unwrap();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), base_penalty_msat);
 
                let usage = ChannelUsage { amount_msat: 1_000, ..usage };
@@ -3356,10 +3359,10 @@ mod tests {
                        let network_graph = network_graph.read_only();
                        let channel = network_graph.channel(42).unwrap();
                        let (info, _) = channel.as_directed_from(&source).unwrap();
-                       let candidate = CandidateRouteHop::PublicHop {
+                       let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                                info,
                                short_channel_id: 42,
-                       };
+                       });
 
                        // With no historical data the normal liquidity penalty calculation is used.
                        assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 168);
@@ -3374,10 +3377,10 @@ mod tests {
                        let network_graph = network_graph.read_only();
                        let channel = network_graph.channel(42).unwrap();
                        let (info, _) = channel.as_directed_from(&source).unwrap();
-                       let candidate = CandidateRouteHop::PublicHop {
+                       let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                                info,
                                short_channel_id: 42,
-                       };
+                       });
 
                        assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 2048);
                        assert_eq!(scorer.channel_penalty_msat(&candidate, usage_1, &params), 249);
@@ -3399,10 +3402,10 @@ mod tests {
                        let network_graph = network_graph.read_only();
                        let channel = network_graph.channel(42).unwrap();
                        let (info, _) = channel.as_directed_from(&source).unwrap();
-                       let candidate = CandidateRouteHop::PublicHop {
+                       let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                                info,
                                short_channel_id: 42,
-                       };
+                       });
 
                        assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 105);
                }
@@ -3429,10 +3432,10 @@ mod tests {
                        let network_graph = network_graph.read_only();
                        let channel = network_graph.channel(42).unwrap();
                        let (info, _) = channel.as_directed_from(&source).unwrap();
-                       let candidate = CandidateRouteHop::PublicHop {
+                       let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                                info,
                                short_channel_id: 42,
-                       };
+                       });
 
                        assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 168);
                }
@@ -3442,7 +3445,7 @@ mod tests {
                        Some(([0; 32], [0; 32])));
                assert_eq!(scorer.historical_estimated_payment_success_probability(42, &target, 1, &params), None);
 
-               let mut usage = ChannelUsage {
+               let usage = ChannelUsage {
                        amount_msat: 100,
                        inflight_htlc_msat: 1024,
                        effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: 1_024 },
@@ -3452,10 +3455,10 @@ mod tests {
                        let network_graph = network_graph.read_only();
                        let channel = network_graph.channel(42).unwrap();
                        let (info, _) = channel.as_directed_from(&source).unwrap();
-                       let candidate = CandidateRouteHop::PublicHop {
+                       let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                                info,
                                short_channel_id: 42,
-                       };
+                       });
 
                        assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 2050);
 
@@ -3505,10 +3508,10 @@ mod tests {
                let network_graph = network_graph.read_only();
                let channel = network_graph.channel(42).unwrap();
                let (info, _) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 0);
 
                // Check we receive anti-probing penalty for htlc_maximum_msat == channel_capacity.
@@ -3555,16 +3558,16 @@ mod tests {
                };
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, target) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 300);
 
                let mut path = payment_path_for_amount(768);
                let recipient_hop = path.hops.pop().unwrap();
                let blinded_path = BlindedPath {
-                       introduction_node_id: path.hops.last().as_ref().unwrap().pubkey,
+                       introduction_node: IntroductionNode::NodeId(path.hops.last().as_ref().unwrap().pubkey),
                        blinding_point: test_utils::pubkey(42),
                        blinded_hops: vec![
                                BlindedHop { blinded_node_id: test_utils::pubkey(44), encrypted_payload: Vec::new() }
@@ -3624,10 +3627,10 @@ mod tests {
                };
                let channel = network_graph.read_only().channel(42).unwrap().to_owned();
                let (info, target) = channel.as_directed_from(&source).unwrap();
-               let candidate = CandidateRouteHop::PublicHop {
+               let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
                        info,
                        short_channel_id: 42,
-               };
+               });
                // With no historical data the normal liquidity penalty calculation is used, which results
                // in a success probability of ~75%.
                assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &params), 1269);
Personal fork of Rust-Lightning. Upstream is https://github.com/rust-bitcoin/rust-lightning