Add experimental LSPS2 support.

Author: G8XSU

ldk-server/Cargo.toml

@@ -26,6 +26,9 @@ lapin = { version = "2.4.0", features = ["rustls"], default-features = false, op
 default = []
 events-rabbitmq = ["dep:lapin"]
 
+# Experimental Features.
+experimental-lsps2-support = []
+
 # Feature-flags related to integration tests.
 integration-tests-events-rabbitmq = ["events-rabbitmq"]
 

ldk-server/ldk-server-config.toml

@@ -17,4 +17,18 @@ rpc_password = "polarpass"                    # RPC password
 # RabbitMQ settings (only required if using events-rabbitmq feature)
 [rabbitmq]
 connection_string = ""                        # RabbitMQ connection string
-exchange_name = ""                            # RabbitMQ exchange name
+exchange_name = ""
+
+# Experimental LSPS2 Service Support
+# CAUTION: LSPS2 support is highly experimental and for testing purposes only.
+[liquidity.lsps2_service]
+advertise_service = false
+channel_opening_fee_ppm = 1000            # 0.1% fee
+channel_over_provisioning_ppm = 500000    # 50% extra capacity
+min_channel_opening_fee_msat = 10000000   # 10,000 satoshis
+min_channel_lifetime = 4320               # ~30 days
+max_client_to_self_delay = 1440           # ~10 days
+min_payment_size_msat = 10000000          # 10,000 satoshis
+max_payment_size_msat = 25000000000       # 0.25 BTC
+# Optional token for clients (uncomment and set if required)
+# require_token = ""

ldk-server/src/main.rs

@@ -29,7 +29,8 @@ use crate::util::proto_adapter::{forwarded_payment_to_proto, payment_to_proto};
 use hex::DisplayHex;
 use ldk_node::config::Config;
 use ldk_node::lightning::ln::channelmanager::PaymentId;
-use ldk_node::logger::LogLevel;
+#[cfg(feature = "experimental-lsps2-support")]
+use ldk_node::liquidity::LSPS2ServiceConfig;
 use ldk_server_protos::events;
 use ldk_server_protos::events::{event_envelope, EventEnvelope};
 use ldk_server_protos::types::Payment;
@@ -81,6 +82,12 @@ fn main() {
 		config_file.bitcoind_rpc_password,
 	);
 
+	// LSPS2 support is highly experimental and for testing purposes only.
+	#[cfg(feature = "experimental-lsps2-support")]
+	builder.set_liquidity_provider_lsps2(
+		config_file.lsps2_service_config.expect("Missing liquidity.lsps2_server config"),
+	);
+
 	let runtime = match tokio::runtime::Builder::new_multi_thread().enable_all().build() {
 		Ok(runtime) => Arc::new(runtime),
 		Err(e) => {

ldk-server/src/util/config.rs

@@ -1,13 +1,14 @@
 use ldk_node::bitcoin::Network;
 use ldk_node::lightning::ln::msgs::SocketAddress;
+use ldk_node::liquidity::LSPS2ServiceConfig;
 use serde::{Deserialize, Serialize};
 use std::net::SocketAddr;
 use std::path::Path;
 use std::str::FromStr;
 use std::{fs, io};
 
 /// Configuration for LDK Server.
-#[derive(PartialEq, Eq, Debug)]
+#[derive(Debug)]
 pub struct Config {
 	pub listening_addr: SocketAddress,
 	pub network: Network,
@@ -18,6 +19,7 @@ pub struct Config {
 	pub bitcoind_rpc_password: String,
 	pub rabbitmq_connection_string: String,
 	pub rabbitmq_exchange_name: String,
+	pub lsps2_service_config: Option<LSPS2ServiceConfig>,
 }
 
 impl TryFrom<TomlConfig> for Config {
@@ -61,6 +63,11 @@ impl TryFrom<TomlConfig> for Config {
 			(rabbitmq.connection_string, rabbitmq.exchange_name)
 		};
 
+		#[cfg(not(feature = "experimental-lsps2-support"))]
+		let lsps2_service_config: Option<LSPS2ServiceConfig> = None;
+		#[cfg(feature = "experimental-lsps2-support")]
+		let lsps2_service_config = Some(toml_config.liquidity.expect("`liquidity.lsps2_server` must be defined in config if enabling `experimental-lsps2-support` feature.").lsps2_service.into());
+
 		Ok(Config {
 			listening_addr,
 			network: toml_config.node.network,
@@ -71,6 +78,7 @@ impl TryFrom<TomlConfig> for Config {
 			bitcoind_rpc_password: toml_config.bitcoind.rpc_password,
 			rabbitmq_connection_string,
 			rabbitmq_exchange_name,
+			lsps2_service_config,
 		})
 	}
 }
@@ -82,6 +90,8 @@ pub struct TomlConfig {
 	storage: StorageConfig,
 	bitcoind: BitcoindConfig,
 	rabbitmq: Option<RabbitmqConfig>,
+	#[serde(default)]
+	liquidity: Option<LiquidityConfig>,
 }
 
 #[derive(Deserialize, Serialize)]
@@ -114,6 +124,53 @@ struct RabbitmqConfig {
 	exchange_name: String,
 }
 
+#[derive(Deserialize, Serialize)]
+struct LiquidityConfig {
+	lsps2_service: LSPS2ServiceTomlConfig,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+struct LSPS2ServiceTomlConfig {
+	advertise_service: bool,
+	channel_opening_fee_ppm: u32,
+	channel_over_provisioning_ppm: u32,
+	min_channel_opening_fee_msat: u64,
+	min_channel_lifetime: u32,
+	max_client_to_self_delay: u32,
+	min_payment_size_msat: u64,
+	max_payment_size_msat: u64,
+	#[serde(default)] // Make require_token optional
+	require_token: Option<String>,
+}
+
+impl Into<LSPS2ServiceConfig> for LSPS2ServiceTomlConfig {
+	fn into(self) -> LSPS2ServiceConfig {
+		match self {
+			LSPS2ServiceTomlConfig {
+				advertise_service,
+				channel_opening_fee_ppm,
+				channel_over_provisioning_ppm,
+				min_channel_opening_fee_msat,
+				min_channel_lifetime,
+				max_client_to_self_delay,
+				min_payment_size_msat,
+				max_payment_size_msat,
+				require_token,
+			} => LSPS2ServiceConfig {
+				advertise_service,
+				channel_opening_fee_ppm,
+				channel_over_provisioning_ppm,
+				min_channel_opening_fee_msat,
+				min_channel_lifetime,
+				min_payment_size_msat,
+				max_client_to_self_delay,
+				max_payment_size_msat,
+				require_token,
+			},
+		}
+	}
+}
+
 /// Loads the configuration from a TOML file at the given path.
 pub fn load_config<P: AsRef<Path>>(config_path: P) -> io::Result<Config> {
 	let file_contents = fs::read_to_string(config_path.as_ref()).map_err(|e| {
@@ -164,19 +221,29 @@ mod tests {
 
 		fs::write(storage_path.join(config_file_name), toml_config).unwrap();
 
-		assert_eq!(
-			load_config(storage_path.join(config_file_name)).unwrap(),
-			Config {
-				listening_addr: SocketAddress::from_str("localhost:3001").unwrap(),
-				network: Network::Regtest,
-				rest_service_addr: SocketAddr::from_str("127.0.0.1:3002").unwrap(),
-				storage_dir_path: "/tmp".to_string(),
-				bitcoind_rpc_addr: SocketAddr::from_str("127.0.0.1:8332").unwrap(),
-				bitcoind_rpc_user: "bitcoind-testuser".to_string(),
-				bitcoind_rpc_password: "bitcoind-testpassword".to_string(),
-				rabbitmq_connection_string: "rabbitmq_connection_string".to_string(),
-				rabbitmq_exchange_name: "rabbitmq_exchange_name".to_string(),
-			}
-		)
+		let config = load_config(storage_path.join(config_file_name)).unwrap();
+		let expected = Config {
+			listening_addr: SocketAddress::from_str("localhost:3001").unwrap(),
+			network: Network::Regtest,
+			rest_service_addr: SocketAddr::from_str("127.0.0.1:3002").unwrap(),
+			storage_dir_path: "/tmp".to_string(),
+			bitcoind_rpc_addr: SocketAddr::from_str("127.0.0.1:8332").unwrap(),
+			bitcoind_rpc_user: "bitcoind-testuser".to_string(),
+			bitcoind_rpc_password: "bitcoind-testpassword".to_string(),
+			rabbitmq_connection_string: "rabbitmq_connection_string".to_string(),
+			rabbitmq_exchange_name: "rabbitmq_exchange_name".to_string(),
+			lsps2_service_config: None,
+		};
+
+		assert_eq!(config.listening_addr.to_string(), expected.listening_addr.to_string());
+		assert_eq!(config.network, expected.network);
+		assert_eq!(config.rest_service_addr, expected.rest_service_addr);
+		assert_eq!(config.storage_dir_path, expected.storage_dir_path);
+		assert_eq!(config.bitcoind_rpc_addr, expected.bitcoind_rpc_addr);
+		assert_eq!(config.bitcoind_rpc_user, expected.bitcoind_rpc_user);
+		assert_eq!(config.bitcoind_rpc_password, expected.bitcoind_rpc_password);
+		assert_eq!(config.rabbitmq_connection_string, expected.rabbitmq_connection_string);
+		assert_eq!(config.rabbitmq_exchange_name, expected.rabbitmq_exchange_name);
+		assert_eq!(config.lsps2_service_config.is_some(), expected.lsps2_service_config.is_some());
 	}
 }