Move LSPS2 client logic into liquidity/client/lsps2.rs

Author: Camillarhi

src/liquidity/client/lsps2.rs

@@ -0,0 +1,319 @@
+// This file is Copyright its original authors, visible in version control history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
+// accordance with one or both of these licenses.
+
+use std::collections::HashMap;
+use std::ops::Deref;
+use std::sync::Mutex;
+use std::time::Duration;
+
+use bitcoin::secp256k1::{PublicKey, Secp256k1};
+use lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA;
+use lightning::ln::msgs::SocketAddress;
+use lightning::routing::router::{RouteHint, RouteHintHop};
+use lightning_invoice::{Bolt11Invoice, Bolt11InvoiceDescription, InvoiceBuilder, RoutingFees};
+use lightning_liquidity::lsps0::ser::LSPSRequestId;
+use lightning_liquidity::lsps2::client::LSPS2ClientConfig as LdkLSPS2ClientConfig;
+use lightning_liquidity::lsps2::msgs::LSPS2OpeningFeeParams;
+use lightning_liquidity::lsps2::utils::compute_opening_fee;
+use lightning_types::payment::PaymentHash;
+use tokio::sync::oneshot;
+
+use crate::logger::{log_debug, log_error, log_info, LdkLogger};
+use crate::Error;
+
+use super::super::{LiquiditySource, LIQUIDITY_REQUEST_TIMEOUT_SECS};
+
+pub(crate) struct LSPS2Client {
+	pub(crate) lsp_node_id: PublicKey,
+	pub(crate) lsp_address: SocketAddress,
+	pub(crate) token: Option<String>,
+	pub(crate) ldk_client_config: LdkLSPS2ClientConfig,
+	pub(crate) pending_fee_requests:
+		Mutex<HashMap<LSPSRequestId, oneshot::Sender<LSPS2FeeResponse>>>,
+	pub(crate) pending_buy_requests:
+		Mutex<HashMap<LSPSRequestId, oneshot::Sender<LSPS2BuyResponse>>>,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct LSPS2ClientConfig {
+	pub node_id: PublicKey,
+	pub address: SocketAddress,
+	pub token: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct LSPS2FeeResponse {
+	pub(crate) opening_fee_params_menu: Vec<LSPS2OpeningFeeParams>,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct LSPS2BuyResponse {
+	pub(crate) intercept_scid: u64,
+	pub(crate) cltv_expiry_delta: u32,
+}
+
+impl<L: Deref> LiquiditySource<L>
+where
+	L::Target: LdkLogger,
+{
+	pub(crate) fn get_lsps2_lsp_details(&self) -> Option<(PublicKey, SocketAddress)> {
+		self.lsps2_client.as_ref().map(|s| (s.lsp_node_id, s.lsp_address.clone()))
+	}
+
+	pub(crate) async fn lsps2_receive_to_jit_channel(
+		&self, amount_msat: u64, description: &Bolt11InvoiceDescription, expiry_secs: u32,
+		max_total_lsp_fee_limit_msat: Option<u64>, payment_hash: Option<PaymentHash>,
+	) -> Result<(Bolt11Invoice, 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);
+			}
+		}
+
+		log_debug!(
+			self.logger,
+			"Choosing cheapest liquidity offer, will pay {}msat in total LSP fees",
+			min_total_fee_msat
+		);
+
+		let buy_response =
+			self.lsps2_send_buy_request(Some(amount_msat), min_opening_params).await?;
+		let invoice = self.lsps2_create_jit_invoice(
+			buy_response,
+			Some(amount_msat),
+			description,
+			expiry_secs,
+			payment_hash,
+		)?;
+
+		log_info!(self.logger, "JIT-channel invoice created: {}", invoice);
+		Ok((invoice, min_total_fee_msat))
+	}
+
+	pub(crate) async fn lsps2_receive_variable_amount_to_jit_channel(
+		&self, description: &Bolt11InvoiceDescription, expiry_secs: u32,
+		max_proportional_lsp_fee_limit_ppm_msat: Option<u64>, payment_hash: Option<PaymentHash>,
+	) -> Result<(Bolt11Invoice, 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);
+			}
+		}
+
+		log_debug!(
+			self.logger,
+			"Choosing cheapest liquidity offer, will pay {}ppm msat in proportional LSP fees",
+			min_prop_fee_ppm_msat
+		);
+
+		let buy_response = self.lsps2_send_buy_request(None, min_opening_params).await?;
+		let invoice = self.lsps2_create_jit_invoice(
+			buy_response,
+			None,
+			description,
+			expiry_secs,
+			payment_hash,
+		)?;
+
+		log_info!(self.logger, "JIT-channel invoice created: {}", invoice);
+		Ok((invoice, min_prop_fee_ppm_msat))
+	}
+
+	async fn lsps2_request_opening_fee_params(&self) -> Result<LSPS2FeeResponse, Error> {
+		let lsps2_client = self.lsps2_client.as_ref().ok_or(Error::LiquiditySourceUnavailable)?;
+
+		let client_handler = self.liquidity_manager.lsps2_client_handler().ok_or_else(|| {
+			log_error!(self.logger, "Liquidity client was not configured.",);
+			Error::LiquiditySourceUnavailable
+		})?;
+
+		let (fee_request_sender, fee_request_receiver) = oneshot::channel();
+		{
+			let mut pending_fee_requests_lock =
+				lsps2_client.pending_fee_requests.lock().expect("lock");
+			let request_id = client_handler
+				.request_opening_params(lsps2_client.lsp_node_id, lsps2_client.token.clone());
+			pending_fee_requests_lock.insert(request_id, fee_request_sender);
+		}
+
+		tokio::time::timeout(
+			Duration::from_secs(LIQUIDITY_REQUEST_TIMEOUT_SECS),
+			fee_request_receiver,
+		)
+		.await
+		.map_err(|e| {
+			log_error!(self.logger, "Liquidity request timed out: {}", e);
+			Error::LiquidityRequestFailed
+		})?
+		.map_err(|e| {
+			log_error!(self.logger, "Failed to handle response from liquidity service: {}", e);
+			Error::LiquidityRequestFailed
+		})
+	}
+
+	async fn lsps2_send_buy_request(
+		&self, amount_msat: Option<u64>, opening_fee_params: LSPS2OpeningFeeParams,
+	) -> Result<LSPS2BuyResponse, Error> {
+		let lsps2_client = self.lsps2_client.as_ref().ok_or(Error::LiquiditySourceUnavailable)?;
+
+		let client_handler = self.liquidity_manager.lsps2_client_handler().ok_or_else(|| {
+			log_error!(self.logger, "Liquidity client was not configured.",);
+			Error::LiquiditySourceUnavailable
+		})?;
+
+		let (buy_request_sender, buy_request_receiver) = oneshot::channel();
+		{
+			let mut pending_buy_requests_lock =
+				lsps2_client.pending_buy_requests.lock().expect("lock");
+			let request_id = client_handler
+				.select_opening_params(lsps2_client.lsp_node_id, amount_msat, opening_fee_params)
+				.map_err(|e| {
+					log_error!(
+						self.logger,
+						"Failed to send buy request to liquidity service: {:?}",
+						e
+					);
+					Error::LiquidityRequestFailed
+				})?;
+			pending_buy_requests_lock.insert(request_id, buy_request_sender);
+		}
+
+		let buy_response = tokio::time::timeout(
+			Duration::from_secs(LIQUIDITY_REQUEST_TIMEOUT_SECS),
+			buy_request_receiver,
+		)
+		.await
+		.map_err(|e| {
+			log_error!(self.logger, "Liquidity request timed out: {}", e);
+			Error::LiquidityRequestFailed
+		})?
+		.map_err(|e| {
+			log_error!(self.logger, "Failed to handle response from liquidity service: {:?}", e);
+			Error::LiquidityRequestFailed
+		})?;
+
+		Ok(buy_response)
+	}
+
+	fn lsps2_create_jit_invoice(
+		&self, buy_response: LSPS2BuyResponse, amount_msat: Option<u64>,
+		description: &Bolt11InvoiceDescription, expiry_secs: u32,
+		payment_hash: Option<PaymentHash>,
+	) -> Result<Bolt11Invoice, Error> {
+		let lsps2_client = self.lsps2_client.as_ref().ok_or(Error::LiquiditySourceUnavailable)?;
+
+		// LSPS2 requires min_final_cltv_expiry_delta to be at least 2 more than usual.
+		let min_final_cltv_expiry_delta = MIN_FINAL_CLTV_EXPIRY_DELTA + 2;
+		let (payment_hash, payment_secret) = match payment_hash {
+			Some(payment_hash) => {
+				let payment_secret = self
+					.channel_manager
+					.create_inbound_payment_for_hash(
+						payment_hash,
+						None,
+						expiry_secs,
+						Some(min_final_cltv_expiry_delta),
+					)
+					.map_err(|e| {
+						log_error!(self.logger, "Failed to register inbound payment: {:?}", e);
+						Error::InvoiceCreationFailed
+					})?;
+				(payment_hash, payment_secret)
+			},
+			None => self
+				.channel_manager
+				.create_inbound_payment(None, expiry_secs, Some(min_final_cltv_expiry_delta))
+				.map_err(|e| {
+					log_error!(self.logger, "Failed to register inbound payment: {:?}", e);
+					Error::InvoiceCreationFailed
+				})?,
+		};
+
+		let route_hint = RouteHint(vec![RouteHintHop {
+			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,
+			htlc_minimum_msat: None,
+			htlc_maximum_msat: None,
+		}]);
+
+		let currency = self.config.network.into();
+		let mut invoice_builder = InvoiceBuilder::new(currency)
+			.invoice_description(description.clone())
+			.payment_hash(payment_hash)
+			.payment_secret(payment_secret)
+			.current_timestamp()
+			.min_final_cltv_expiry_delta(min_final_cltv_expiry_delta.into())
+			.expiry_time(Duration::from_secs(expiry_secs.into()))
+			.private_route(route_hint);
+
+		if let Some(amount_msat) = amount_msat {
+			invoice_builder = invoice_builder.amount_milli_satoshis(amount_msat).basic_mpp();
+		}
+
+		invoice_builder
+			.build_signed(|hash| {
+				Secp256k1::new()
+					.sign_ecdsa_recoverable(hash, &self.keys_manager.get_node_secret_key())
+			})
+			.map_err(|e| {
+				log_error!(self.logger, "Failed to build and sign invoice: {}", e);
+				Error::InvoiceCreationFailed
+			})
+	}
+}

src/liquidity/client/mod.rs

@@ -6,3 +6,4 @@
 // accordance with one or both of these licenses.
 
 pub(crate) mod lsps1;
+pub(crate) mod lsps2;