expose lsps2 api in LiquidityManager

Author: johncantrell97

src/transport/message_handler.rs

@@ -1,19 +1,23 @@
 use crate::events::{Event, EventQueue};
 use crate::jit_channel::channel_manager::JITChannelManager;
+use crate::jit_channel::msgs::{OpeningFeeParams, RawOpeningFeeParams};
+use crate::transport::msgs::RequestId;
 use crate::transport::msgs::{LSPSMessage, RawLSPSMessage, LSPS_MESSAGE_TYPE_ID};
 use crate::transport::protocol::LSPS0MessageHandler;
 
 use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator};
 use lightning::chain::{self, BestBlock, Confirm, Filter, Listen};
-use lightning::ln::channelmanager::{ChainParameters, ChannelManager};
+use lightning::ln::channelmanager::{ChainParameters, ChannelManager, InterceptId};
 use lightning::ln::features::{InitFeatures, NodeFeatures};
 use lightning::ln::msgs::{
 	ChannelMessageHandler, ErrorAction, LightningError, OnionMessageHandler, RoutingMessageHandler,
 };
-use lightning::ln::peer_handler::{CustomMessageHandler, SocketDescriptor};
+use lightning::ln::peer_handler::{CustomMessageHandler, PeerManager, SocketDescriptor};
 use lightning::ln::wire::CustomMessageReader;
+use lightning::ln::ChannelId;
 use lightning::routing::router::Router;
 use lightning::sign::{EntropySource, NodeSigner, SignerProvider};
+use lightning::util::errors::APIError;
 use lightning::util::logger::{Level, Logger};
 use lightning::util::ser::Readable;
 
@@ -203,6 +207,165 @@ where {
 		self.pending_events.get_and_clear_pending_events()
 	}
 
+	/// Set a [`lightning::ln::peer_handler::PeerManager`] reference for the message handlers
+	///
+	/// This allows the message handlers to wake the [`lightning::ln::peer_handler::PeerManager`] by calling
+	/// [`lightning::ln::peer_handler::PeerManager::process_events()`] after enqueing messages to be sent.
+	///
+	/// Without this the messages will be sent based on whatever polling interval
+	/// your background processor uses.
+	pub fn set_peer_manager(
+		&self, peer_manager: Arc<PeerManager<Descriptor, CM, RM, OM, L, CMH, NS>>,
+	) {
+		if let Some(lsps2_message_handler) = &self.lsps2_message_handler {
+			lsps2_message_handler.set_peer_manager(peer_manager);
+		}
+	}
+
+	/// Initiate the creation of an invoice that when paid will open a channel
+	/// with enough inbound liquidity to be able to receive the payment.
+	///
+	/// `counterparty_node_id` is the node_id of the LSP you would like to use.
+	///
+	/// if `payment_size_msat` is [`Option::Some`] then the invoice will be for a fixed amount
+	/// and MPP can be used to pay it.
+	///
+	/// if `payment_size_msat` is [`Option::None`] then the invoice can be for an arbitrary amount
+	/// but MPP can no longer be used to pay it.
+	///
+	/// `token` is an optional String that will be provided to the LSP.
+	/// it can be used by the LSP as an API key, coupon code, or some other way to identify a user.
+	pub fn create_invoice(
+		&self, counterparty_node_id: PublicKey, payment_size_msat: Option<u64>,
+		token: Option<String>, user_channel_id: u128,
+	) -> Result<(), APIError> {
+		if let Some(lsps2_message_handler) = &self.lsps2_message_handler {
+			lsps2_message_handler.create_invoice(
+				counterparty_node_id,
+				payment_size_msat,
+				token,
+				user_channel_id,
+			);
+			Ok(())
+		} else {
+			Err(APIError::APIMisuseError {
+				err: "JIT Channels were not configured when LSPManager was instantiated"
+					.to_string(),
+			})
+		}
+	}
+
+	/// Used by LSP to provide fee parameters to a client requesting a JIT Channel.
+	///
+	/// Should be called in response to receiving a [`crate::JITChannelEvent::GetInfo`] event.
+	pub fn opening_fee_params_generated(
+		&self, counterparty_node_id: PublicKey, request_id: RequestId,
+		opening_fee_params_menu: Vec<RawOpeningFeeParams>, min_payment_size_msat: u64,
+		max_payment_size_msat: u64,
+	) -> Result<(), APIError> {
+		if let Some(lsps2_message_handler) = &self.lsps2_message_handler {
+			lsps2_message_handler.opening_fee_params_generated(
+				counterparty_node_id,
+				request_id,
+				opening_fee_params_menu,
+				min_payment_size_msat,
+				max_payment_size_msat,
+			)
+		} else {
+			Err(APIError::APIMisuseError {
+				err: "JIT Channels were not configured when LSPManager was instantiated"
+					.to_string(),
+			})
+		}
+	}
+
+	/// Used by client to confirm which channel parameters to use for the JIT Channel buy request.
+	///
+	/// Should be called in response to receiving a [`crate::JITChannelEvent::GetInfoResponse`] event.
+	pub fn opening_fee_params_selected(
+		&self, counterparty_node_id: PublicKey, channel_id: u128,
+		opening_fee_params: OpeningFeeParams,
+	) -> Result<(), APIError> {
+		if let Some(lsps2_message_handler) = &self.lsps2_message_handler {
+			lsps2_message_handler.opening_fee_params_selected(
+				counterparty_node_id,
+				channel_id,
+				opening_fee_params,
+			)
+		} else {
+			Err(APIError::APIMisuseError {
+				err: "JIT Channels were not configured when LSPManager was instantiated"
+					.to_string(),
+			})
+		}
+	}
+
+	/// Used by LSP to provide client with the scid and cltv_expiry_delta to use in their invoice
+	///
+	/// Should be called in response to receiving a [`crate::JITChannelEvent::BuyRequest`] event.
+	pub fn invoice_parameters_generated(
+		&self, counterparty_node_id: PublicKey, request_id: RequestId, scid: u64,
+		cltv_expiry_delta: u32, client_trusts_lsp: bool,
+	) -> Result<(), APIError> {
+		if let Some(lsps2_message_handler) = &self.lsps2_message_handler {
+			lsps2_message_handler.invoice_parameters_generated(
+				counterparty_node_id,
+				request_id,
+				scid,
+				cltv_expiry_delta,
+				client_trusts_lsp,
+			)
+		} else {
+			Err(APIError::APIMisuseError {
+				err: "JIT Channels were not configured when LSPManager was instantiated"
+					.to_string(),
+			})
+		}
+	}
+
+	/// Forward [`lightning::events::Event::HTLCIntercepted`] event parameters into this function.
+	///
+	/// Will fail the intercepted HTLC if the scid matches a payment we are expecting
+	/// but the payment amount is incorrect or the expiry has passed.
+	///
+	/// Will generate a [`crate::JITChannelEvent::OpenChannel`] event if the scid matches a payment we are expected
+	/// and the payment amount is correct and the offer has not expired.
+	///
+	/// Will do nothing if the scid does not match any of the ones we gave out.
+	pub fn htlc_intercepted(
+		&self, scid: u64, intercept_id: InterceptId, inbound_amount_msat: u64,
+		expected_outbound_amount_msat: u64,
+	) -> Result<(), APIError> {
+		if let Some(lsps2_message_handler) = &self.lsps2_message_handler {
+			lsps2_message_handler.htlc_intercepted(
+				scid,
+				intercept_id,
+				inbound_amount_msat,
+				expected_outbound_amount_msat,
+			)?;
+		}
+
+		Ok(())
+	}
+
+	/// Forward [`lightning::events::Event::ChannelReady`] event parameters into this function.
+	///
+	/// Will forward the intercepted HTLC if it matches a channel
+	/// we need to forward a payment over otherwise it will be ignored.
+	pub fn channel_ready(
+		&self, user_channel_id: u128, channel_id: &ChannelId, counterparty_node_id: &PublicKey,
+	) -> Result<(), APIError> {
+		if let Some(lsps2_message_handler) = &self.lsps2_message_handler {
+			lsps2_message_handler.channel_ready(
+				user_channel_id,
+				channel_id,
+				counterparty_node_id,
+			)?;
+		}
+
+		Ok(())
+	}
+
 	fn handle_lsps_message(
 		&self, msg: LSPSMessage, sender_node_id: &PublicKey,
 	) -> Result<(), lightning::ln::msgs::LightningError> {
@@ -213,15 +376,14 @@ where {
 			LSPSMessage::LSPS0(msg) => {
 				self.lsps0_message_handler.handle_message(msg, sender_node_id)?;
 			}
-			_ => {
-				return Err(LightningError {
-					err: format!(
-						"Received message without message handler configured. From node = {:?}",
-						sender_node_id
-					),
-					action: ErrorAction::IgnoreAndLog(Level::Info),
-				});
-			}
+			LSPSMessage::LSPS2(msg) => match &self.lsps2_message_handler {
+				Some(lsps2_message_handler) => {
+					lsps2_message_handler.handle_message(msg, sender_node_id)?;
+				}
+				None => {
+					return Err(LightningError { err: format!("Received LSPS2 message without LSPS2 message handler configured. From node = {:?}", sender_node_id), action: ErrorAction::IgnoreAndLog(Level::Info)});
+				}
+			},
 		}
 		Ok(())
 	}
@@ -311,9 +473,12 @@ where
 	fn handle_custom_message(
 		&self, msg: Self::CustomMessage, sender_node_id: &PublicKey,
 	) -> Result<(), lightning::ln::msgs::LightningError> {
-		let mut request_id_to_method_map = self.request_id_to_method_map.lock().unwrap();
+		let message = {
+			let mut request_id_to_method_map = self.request_id_to_method_map.lock().unwrap();
+			LSPSMessage::from_str_with_id_map(&msg.payload, &mut request_id_to_method_map)
+		};
 
-		match LSPSMessage::from_str_with_id_map(&msg.payload, &mut request_id_to_method_map) {
+		match message {
 			Ok(msg) => self.handle_lsps_message(msg, sender_node_id),
 			Err(_) => {
 				self.enqueue_message(*sender_node_id, LSPSMessage::Invalid);