Add blinded path override to test utilities

Let integration tests force specific blinded payment paths, so
LSPS2 BOLT12 routing behavior can be exercised deterministically.

Co-Authored-By: HAL 9000

Author: tnull

lightning/src/util/test_utils.rs

@@ -168,6 +168,23 @@ impl chaininterface::FeeEstimator for TestFeeEstimator {
 	}
 }
 
+/// Override closure type for [`TestRouter::override_create_blinded_payment_paths`].
+///
+/// This closure is called instead of the default [`Router::create_blinded_payment_paths`]
+/// implementation when set, receiving the actual [`ReceiveTlvs`] so tests can construct custom
+/// blinded payment paths using the same TLVs the caller generated.
+pub type BlindedPaymentPathOverrideFn = Box<
+	dyn Fn(
+			PublicKey,
+			ReceiveAuthKey,
+			Vec<ChannelDetails>,
+			ReceiveTlvs,
+			Option<u64>,
+		) -> Result<Vec<BlindedPaymentPath>, ()>
+		+ Send
+		+ Sync,
+>;
+
 pub struct TestRouter<'a> {
 	pub router: DefaultRouter<
 		Arc<NetworkGraph<&'a TestLogger>>,
@@ -181,6 +198,7 @@ pub struct TestRouter<'a> {
 	pub next_routes: Mutex<VecDeque<(RouteParameters, Option<Result<Route, &'static str>>)>>,
 	pub next_blinded_payment_paths: Mutex<Vec<BlindedPaymentPath>>,
 	pub next_payment_context_metadata: Mutex<Option<BTreeMap<u64, Vec<u8>>>>,
+	pub override_create_blinded_payment_paths: Mutex<Option<BlindedPaymentPathOverrideFn>>,
 	pub scorer: &'a RwLock<TestScorer>,
 }
 
@@ -193,6 +211,7 @@ impl<'a> TestRouter<'a> {
 		let next_routes = Mutex::new(VecDeque::new());
 		let next_blinded_payment_paths = Mutex::new(Vec::new());
 		let next_payment_context_metadata = Mutex::new(None);
+		let override_create_blinded_payment_paths = Mutex::new(None);
 		Self {
 			router: DefaultRouter::new(
 				Arc::clone(&network_graph),
@@ -205,6 +224,7 @@ impl<'a> TestRouter<'a> {
 			next_routes,
 			next_blinded_payment_paths,
 			next_payment_context_metadata,
+			override_create_blinded_payment_paths,
 			scorer,
 		}
 	}
@@ -338,6 +358,12 @@ impl<'a> Router for TestRouter<'a> {
 				PaymentContext::Bolt12Refund(ctx) => ctx.payment_metadata = Some(metadata),
 			}
 		}
+		if let Some(override_fn) =
+			self.override_create_blinded_payment_paths.lock().unwrap().as_ref()
+		{
+			return override_fn(recipient, local_node_receive_key, first_hops, tlvs, amount_msats);
+		}
+
 		let mut expected_paths = self.next_blinded_payment_paths.lock().unwrap();
 		if expected_paths.is_empty() {
 			self.router.create_blinded_payment_paths(
@@ -383,6 +409,7 @@ pub enum TestMessageRouterInternal<'a> {
 pub struct TestMessageRouter<'a> {
 	pub inner: TestMessageRouterInternal<'a>,
 	pub peers_override: Mutex<Vec<PublicKey>>,
+	pub forward_node_scid_override: Mutex<HashMap<PublicKey, u64>>,
 }
 
 impl<'a> TestMessageRouter<'a> {
@@ -395,6 +422,7 @@ impl<'a> TestMessageRouter<'a> {
 				entropy_source,
 			)),
 			peers_override: Mutex::new(Vec::new()),
+			forward_node_scid_override: Mutex::new(new_hash_map()),
 		}
 	}
 
@@ -407,6 +435,7 @@ impl<'a> TestMessageRouter<'a> {
 				entropy_source,
 			)),
 			peers_override: Mutex::new(Vec::new()),
+			forward_node_scid_override: Mutex::new(new_hash_map()),
 		}
 	}
 }
@@ -438,9 +467,13 @@ impl<'a> MessageRouter for TestMessageRouter<'a> {
 		{
 			let peers_override = self.peers_override.lock().unwrap();
 			if !peers_override.is_empty() {
+				let scid_override = self.forward_node_scid_override.lock().unwrap();
 				let peer_override_nodes: Vec<_> = peers_override
 					.iter()
-					.map(|pk| MessageForwardNode { node_id: *pk, short_channel_id: None })
+					.map(|pk| MessageForwardNode {
+						node_id: *pk,
+						short_channel_id: scid_override.get(pk).copied(),
+					})
 					.collect();
 				peers = peer_override_nodes;
 			}