Add LSPS2-backed BOLT12 JIT offer routing

Wrap `DefaultRouter` in `LSPS2BOLT12Router`, register LSPS2 buy results against `OfferId`, and expose `Bolt12Payment` JIT receive APIs that create offers and route inbound blinded paths through LSPS2 intercept parameters.

Co-Authored-By: HAL 9000

Author: tnull

src/builder.rs

@@ -39,6 +39,7 @@ use lightning::util::persist::{
 };
 use lightning::util::ser::ReadableArgs;
 use lightning::util::sweep::OutputSweeper;
+use lightning_liquidity::lsps2::router::LSPS2BOLT12Router;
 use lightning_persister::fs_store::v1::FilesystemStore;
 use vss_client::headers::VssHeaderProvider;
 
@@ -1627,13 +1628,14 @@ fn build_with_store_internal(
 	}
 
 	let scoring_fee_params = ProbabilisticScoringFeeParameters::default();
-	let router = Arc::new(DefaultRouter::new(
+	let inner_router = DefaultRouter::new(
 		Arc::clone(&network_graph),
 		Arc::clone(&logger),
 		Arc::clone(&keys_manager),
 		Arc::clone(&scorer),
 		scoring_fee_params,
-	));
+	);
+	let router = Arc::new(LSPS2BOLT12Router::new(inner_router, Arc::clone(&keys_manager)));
 
 	let mut user_config = default_user_config(&config);
 
@@ -1790,56 +1792,62 @@ fn build_with_store_internal(
 		},
 	};
 
-	let (liquidity_source, custom_message_handler) =
-		if let Some(lsc) = liquidity_source_config.as_ref() {
-			let mut liquidity_source_builder = LiquiditySourceBuilder::new(
-				Arc::clone(&wallet),
-				Arc::clone(&channel_manager),
-				Arc::clone(&keys_manager),
-				Arc::clone(&chain_source),
-				Arc::clone(&tx_broadcaster),
-				Arc::clone(&kv_store),
-				Arc::clone(&config),
-				Arc::clone(&logger),
-			);
+	let (liquidity_source, custom_message_handler) = if let Some(lsc) =
+		liquidity_source_config.as_ref()
+	{
+		let mut liquidity_source_builder = LiquiditySourceBuilder::new(
+			Arc::clone(&wallet),
+			Arc::clone(&channel_manager),
+			Arc::clone(&keys_manager),
+			Arc::clone(&router),
+			Arc::clone(&chain_source),
+			Arc::clone(&tx_broadcaster),
+			Arc::clone(&kv_store),
+			Arc::clone(&config),
+			Some(Arc::clone(&onion_messenger)
+				as Arc<
+					dyn lightning::onion_message::messenger::OnionMessageInterceptor + Send + Sync,
+				>),
+			Arc::clone(&logger),
+		);
 
-			lsc.lsps1_client.as_ref().map(|config| {
-				liquidity_source_builder.lsps1_client(
-					config.node_id,
-					config.address.clone(),
-					config.token.clone(),
-				)
-			});
+		lsc.lsps1_client.as_ref().map(|config| {
+			liquidity_source_builder.lsps1_client(
+				config.node_id,
+				config.address.clone(),
+				config.token.clone(),
+			)
+		});
 
-			lsc.lsps2_client.as_ref().map(|config| {
-				liquidity_source_builder.lsps2_client(
-					config.node_id,
-					config.address.clone(),
-					config.token.clone(),
-				)
-			});
+		lsc.lsps2_client.as_ref().map(|config| {
+			liquidity_source_builder.lsps2_client(
+				config.node_id,
+				config.address.clone(),
+				config.token.clone(),
+			)
+		});
 
-			let promise_secret = {
-				let lsps_xpriv = derive_xprv(
-					Arc::clone(&config),
-					&seed_bytes,
-					LSPS_HARDENED_CHILD_INDEX,
-					Arc::clone(&logger),
-				)?;
-				lsps_xpriv.private_key.secret_bytes()
-			};
-			lsc.lsps2_service.as_ref().map(|config| {
-				liquidity_source_builder.lsps2_service(promise_secret, config.clone())
-			});
-
-			let liquidity_source = runtime
-				.block_on(async move { liquidity_source_builder.build().await.map(Arc::new) })?;
-			let custom_message_handler =
-				Arc::new(NodeCustomMessageHandler::new_liquidity(Arc::clone(&liquidity_source)));
-			(Some(liquidity_source), custom_message_handler)
-		} else {
-			(None, Arc::new(NodeCustomMessageHandler::new_ignoring()))
+		let promise_secret = {
+			let lsps_xpriv = derive_xprv(
+				Arc::clone(&config),
+				&seed_bytes,
+				LSPS_HARDENED_CHILD_INDEX,
+				Arc::clone(&logger),
+			)?;
+			lsps_xpriv.private_key.secret_bytes()
 		};
+		lsc.lsps2_service
+			.as_ref()
+			.map(|config| liquidity_source_builder.lsps2_service(promise_secret, config.clone()));
+
+		let liquidity_source = runtime
+			.block_on(async move { liquidity_source_builder.build().await.map(Arc::new) })?;
+		let custom_message_handler =
+			Arc::new(NodeCustomMessageHandler::new_liquidity(Arc::clone(&liquidity_source)));
+		(Some(liquidity_source), custom_message_handler)
+	} else {
+		(None, Arc::new(NodeCustomMessageHandler::new_ignoring()))
+	};
 
 	let msg_handler = match gossip_source.as_gossip_sync() {
 		GossipSync::P2P(p2p_gossip_sync) => MessageHandler {

src/lib.rs

@@ -901,9 +901,13 @@ impl Node {
 	#[cfg(not(feature = "uniffi"))]
 	pub fn bolt12_payment(&self) -> Bolt12Payment {
 		Bolt12Payment::new(
+			Arc::clone(&self.runtime),
 			Arc::clone(&self.channel_manager),
+			Arc::clone(&self.connection_manager),
+			self.liquidity_source.clone(),
 			Arc::clone(&self.keys_manager),
 			Arc::clone(&self.payment_store),
+			Arc::clone(&self.peer_store),
 			Arc::clone(&self.config),
 			Arc::clone(&self.is_running),
 			Arc::clone(&self.logger),
@@ -917,9 +921,13 @@ impl Node {
 	#[cfg(feature = "uniffi")]
 	pub fn bolt12_payment(&self) -> Arc<Bolt12Payment> {
 		Arc::new(Bolt12Payment::new(
+			Arc::clone(&self.runtime),
 			Arc::clone(&self.channel_manager),
+			Arc::clone(&self.connection_manager),
+			self.liquidity_source.clone(),
 			Arc::clone(&self.keys_manager),
 			Arc::clone(&self.payment_store),
+			Arc::clone(&self.peer_store),
 			Arc::clone(&self.config),
 			Arc::clone(&self.is_running),
 			Arc::clone(&self.logger),

src/liquidity.rs

@@ -19,6 +19,8 @@ use lightning::events::HTLCHandlingFailureType;
 use lightning::ln::channelmanager::{InterceptId, MIN_FINAL_CLTV_EXPIRY_DELTA};
 use lightning::ln::msgs::SocketAddress;
 use lightning::ln::types::ChannelId;
+use lightning::offers::offer::OfferId;
+use lightning::onion_message::messenger::OnionMessageInterceptor;
 use lightning::routing::router::{RouteHint, RouteHintHop};
 use lightning::sign::EntropySource;
 use lightning_invoice::{Bolt11Invoice, Bolt11InvoiceDescription, InvoiceBuilder, RoutingFees};
@@ -32,6 +34,7 @@ use lightning_liquidity::lsps1::msgs::{
 use lightning_liquidity::lsps2::client::LSPS2ClientConfig as LdkLSPS2ClientConfig;
 use lightning_liquidity::lsps2::event::{LSPS2ClientEvent, LSPS2ServiceEvent};
 use lightning_liquidity::lsps2::msgs::{LSPS2OpeningFeeParams, LSPS2RawOpeningFeeParams};
+use lightning_liquidity::lsps2::router::LSPS2Bolt12InvoiceParameters;
 use lightning_liquidity::lsps2::service::LSPS2ServiceConfig as LdkLSPS2ServiceConfig;
 use lightning_liquidity::lsps2::utils::compute_opening_fee;
 use lightning_liquidity::{LiquidityClientConfig, LiquidityServiceConfig};
@@ -44,7 +47,8 @@ use crate::connection::ConnectionManager;
 use crate::logger::{log_debug, log_error, log_info, LdkLogger, Logger};
 use crate::runtime::Runtime;
 use crate::types::{
-	Broadcaster, ChannelManager, DynStore, KeysManager, LiquidityManager, PeerManager, Wallet,
+	Broadcaster, ChannelManager, DynStore, KeysManager, LiquidityManager, PeerManager, Router,
+	Wallet,
 };
 use crate::{total_anchor_channels_reserve_sats, Config, Error};
 
@@ -154,11 +158,13 @@ where
 	lsps2_service: Option<LSPS2Service>,
 	wallet: Arc<Wallet>,
 	channel_manager: Arc<ChannelManager>,
+	router: Arc<Router>,
 	keys_manager: Arc<KeysManager>,
 	chain_source: Arc<ChainSource>,
 	tx_broadcaster: Arc<Broadcaster>,
 	kv_store: Arc<DynStore>,
 	config: Arc<Config>,
+	onion_message_interceptor: Option<Arc<dyn OnionMessageInterceptor + Send + Sync>>,
 	logger: L,
 }
 
@@ -168,8 +174,10 @@ where
 {
 	pub(crate) fn new(
 		wallet: Arc<Wallet>, channel_manager: Arc<ChannelManager>, keys_manager: Arc<KeysManager>,
-		chain_source: Arc<ChainSource>, tx_broadcaster: Arc<Broadcaster>, kv_store: Arc<DynStore>,
-		config: Arc<Config>, logger: L,
+		router: Arc<Router>, chain_source: Arc<ChainSource>, tx_broadcaster: Arc<Broadcaster>,
+		kv_store: Arc<DynStore>, config: Arc<Config>,
+		onion_message_interceptor: Option<Arc<dyn OnionMessageInterceptor + Send + Sync>>,
+		logger: L,
 	) -> Self {
 		let lsps1_client = None;
 		let lsps2_client = None;
@@ -180,11 +188,13 @@ where
 			lsps2_service,
 			wallet,
 			channel_manager,
+			router,
 			keys_manager,
 			chain_source,
 			tx_broadcaster,
 			kv_store,
 			config,
+			onion_message_interceptor,
 			logger,
 		}
 	}
@@ -262,7 +272,7 @@ where
 				Arc::clone(&self.tx_broadcaster),
 				liquidity_service_config,
 				liquidity_client_config,
-				None,
+				self.onion_message_interceptor,
 			)
 			.await
 			.map_err(|_| BuildError::ReadFailed)?,
@@ -274,6 +284,7 @@ where
 			lsps2_service: self.lsps2_service,
 			wallet: self.wallet,
 			channel_manager: self.channel_manager,
+			router: self.router,
 			peer_manager: RwLock::new(None),
 			keys_manager: self.keys_manager,
 			liquidity_manager,
@@ -292,6 +303,7 @@ where
 	lsps2_service: Option<LSPS2Service>,
 	wallet: Arc<Wallet>,
 	channel_manager: Arc<ChannelManager>,
+	router: Arc<Router>,
 	peer_manager: RwLock<Option<Weak<PeerManager>>>,
 	keys_manager: Arc<KeysManager>,
 	liquidity_manager: Arc<LiquidityManager>,
@@ -1192,6 +1204,104 @@ where
 		Ok((invoice, min_prop_fee_ppm_msat))
 	}
 
+	pub(crate) async fn lsps2_register_bolt12_payment_paths(
+		&self, offer_id: OfferId, amount_msat: u64, max_total_lsp_fee_limit_msat: Option<u64>,
+	) -> Result<u64, Error> {
+		let fee_response = self.lsps2_request_opening_fee_params().await?;
+
+		let (min_total_fee_msat, min_opening_params) = fee_response
+			.opening_fee_params_menu
+			.into_iter()
+			.filter_map(|params| {
+				if amount_msat < params.min_payment_size_msat
+					|| amount_msat > params.max_payment_size_msat
+				{
+					log_debug!(self.logger,
+						"Skipping LSP-offered JIT parameters as the payment of {}msat doesn't meet LSP limits (min: {}msat, max: {}msat)",
+						amount_msat,
+						params.min_payment_size_msat,
+						params.max_payment_size_msat
+					);
+					None
+				} else {
+					compute_opening_fee(amount_msat, params.min_fee_msat, params.proportional as u64)
+						.map(|fee| (fee, params))
+				}
+			})
+			.min_by_key(|p| p.0)
+			.ok_or_else(|| {
+				log_error!(self.logger, "Failed to handle response from liquidity service",);
+				Error::LiquidityRequestFailed
+			})?;
+
+		if let Some(max_total_lsp_fee_limit_msat) = max_total_lsp_fee_limit_msat {
+			if min_total_fee_msat > max_total_lsp_fee_limit_msat {
+				log_error!(self.logger,
+					"Failed to request inbound JIT channel as LSP's requested total opening fee of {}msat exceeds our fee limit of {}msat",
+					min_total_fee_msat, max_total_lsp_fee_limit_msat
+				);
+				return Err(Error::LiquidityFeeTooHigh);
+			}
+		}
+
+		let buy_response =
+			self.lsps2_send_buy_request(Some(amount_msat), min_opening_params).await?;
+		self.register_lsps2_bolt12_payment_paths(offer_id, buy_response)?;
+
+		Ok(min_total_fee_msat)
+	}
+
+	pub(crate) async fn lsps2_register_variable_amount_bolt12_payment_paths(
+		&self, offer_id: OfferId, max_proportional_lsp_fee_limit_ppm_msat: Option<u64>,
+	) -> Result<u64, Error> {
+		let fee_response = self.lsps2_request_opening_fee_params().await?;
+
+		let (min_prop_fee_ppm_msat, min_opening_params) = fee_response
+			.opening_fee_params_menu
+			.into_iter()
+			.map(|params| (params.proportional as u64, params))
+			.min_by_key(|p| p.0)
+			.ok_or_else(|| {
+				log_error!(self.logger, "Failed to handle response from liquidity service",);
+				Error::LiquidityRequestFailed
+			})?;
+
+		if let Some(max_proportional_lsp_fee_limit_ppm_msat) =
+			max_proportional_lsp_fee_limit_ppm_msat
+		{
+			if min_prop_fee_ppm_msat > max_proportional_lsp_fee_limit_ppm_msat {
+				log_error!(self.logger,
+					"Failed to request inbound JIT channel as LSP's requested proportional opening fee of {} ppm msat exceeds our fee limit of {} ppm msat",
+					min_prop_fee_ppm_msat,
+					max_proportional_lsp_fee_limit_ppm_msat
+				);
+				return Err(Error::LiquidityFeeTooHigh);
+			}
+		}
+
+		let buy_response = self.lsps2_send_buy_request(None, min_opening_params).await?;
+		self.register_lsps2_bolt12_payment_paths(offer_id, buy_response)?;
+
+		Ok(min_prop_fee_ppm_msat)
+	}
+
+	fn register_lsps2_bolt12_payment_paths(
+		&self, offer_id: OfferId, buy_response: LSPS2BuyResponse,
+	) -> Result<(), Error> {
+		let lsps2_client = self.lsps2_client.as_ref().ok_or(Error::LiquiditySourceUnavailable)?;
+
+		self.router.register_offer(
+			offer_id,
+			LSPS2Bolt12InvoiceParameters {
+				counterparty_node_id: lsps2_client.lsp_node_id,
+				intercept_scid: buy_response.intercept_scid,
+				cltv_expiry_delta: buy_response.cltv_expiry_delta,
+			},
+		);
+
+		Ok(())
+	}
+
 	async fn lsps2_request_opening_fee_params(&self) -> Result<LSPS2FeeResponse, Error> {
 		let lsps2_client = self.lsps2_client.as_ref().ok_or(Error::LiquiditySourceUnavailable)?;
 
@@ -1304,7 +1414,14 @@ where
 			src_node_id: lsps2_client.lsp_node_id,
 			short_channel_id: buy_response.intercept_scid,
 			fees: RoutingFees { base_msat: 0, proportional_millionths: 0 },
-			cltv_expiry_delta: buy_response.cltv_expiry_delta as u16,
+			cltv_expiry_delta: u16::try_from(buy_response.cltv_expiry_delta).map_err(|_| {
+				log_error!(
+					self.logger,
+					"Failed to create JIT invoice as LSPS2 CLTV delta {} exceeds supported range",
+					buy_response.cltv_expiry_delta
+				);
+				Error::LiquidityRequestFailed
+			})?,
 			htlc_minimum_msat: None,
 			htlc_maximum_msat: None,
 		}]);