Add esplora config

Author: tankyleo

ldk-server/ldk-server-config.toml

@@ -8,12 +8,18 @@ rest_service_address = "127.0.0.1:3002"       # LDK Server REST address
 [storage.disk]
 dir_path = "/tmp/ldk-server/"                 # Path for LDK and BDK data persistence
 
+
+# Must set either the bitcoind or the esplora table; the esplora table is prioritized over the bitcoind table
+
 # Bitcoin Core settings
 [bitcoind]
 rpc_address = "127.0.0.1:18444"               # RPC endpoint
 rpc_user = "polaruser"                        # RPC username
 rpc_password = "polarpass"                    # RPC password
 
+[esplora]
+server_url = "127.0.0.1:3000"
+
 # RabbitMQ settings (only required if using events-rabbitmq feature)
 [rabbitmq]
 connection_string = ""                        # RabbitMQ connection string

ldk-server/src/main.rs

@@ -24,7 +24,7 @@ use crate::io::persist::{
 	FORWARDED_PAYMENTS_PERSISTENCE_SECONDARY_NAMESPACE, PAYMENTS_PERSISTENCE_PRIMARY_NAMESPACE,
 	PAYMENTS_PERSISTENCE_SECONDARY_NAMESPACE,
 };
-use crate::util::config::load_config;
+use crate::util::config::{load_config, ChainSource};
 use crate::util::proto_adapter::{forwarded_payment_to_proto, payment_to_proto};
 use hex::DisplayHex;
 use ldk_node::config::Config;
@@ -79,14 +79,19 @@ fn main() {
 	let mut builder = Builder::from_config(ldk_node_config);
 	builder.set_log_facade_logger();
 
-	let bitcoind_rpc_addr = config_file.bitcoind_rpc_addr;
-
-	builder.set_chain_source_bitcoind_rpc(
-		bitcoind_rpc_addr.ip().to_string(),
-		bitcoind_rpc_addr.port(),
-		config_file.bitcoind_rpc_user,
-		config_file.bitcoind_rpc_password,
-	);
+	match config_file.chain_source {
+		ChainSource::Rpc { rpc_address, rpc_user, rpc_password } => {
+			builder.set_chain_source_bitcoind_rpc(
+				rpc_address.ip().to_string(),
+				rpc_address.port(),
+				rpc_user,
+				rpc_password,
+			);
+		},
+		ChainSource::Esplora { server_url } => {
+			builder.set_chain_source_esplora(format!("http://{}", server_url), None);
+		},
+	}
 
 	// LSPS2 support is highly experimental and for testing purposes only.
 	#[cfg(feature = "experimental-lsps2-support")]

ldk-server/src/util/config.rs

@@ -16,14 +16,18 @@ pub struct Config {
 	pub network: Network,
 	pub rest_service_addr: SocketAddr,
 	pub storage_dir_path: String,
-	pub bitcoind_rpc_addr: SocketAddr,
-	pub bitcoind_rpc_user: String,
-	pub bitcoind_rpc_password: String,
+	pub chain_source: ChainSource,
 	pub rabbitmq_connection_string: String,
 	pub rabbitmq_exchange_name: String,
 	pub lsps2_service_config: Option<LSPS2ServiceConfig>,
 }
 
+#[derive(Debug)]
+pub enum ChainSource {
+	Rpc { rpc_address: SocketAddr, rpc_user: String, rpc_password: String },
+	Esplora { server_url: SocketAddr },
+}
+
 impl TryFrom<TomlConfig> for Config {
 	type Error = io::Error;
 
@@ -42,13 +46,32 @@ impl TryFrom<TomlConfig> for Config {
 					format!("Invalid rest service address configured: {}", e),
 				)
 			})?;
-		let bitcoind_rpc_addr =
-			SocketAddr::from_str(&toml_config.bitcoind.rpc_address).map_err(|e| {
-				io::Error::new(
+		let chain_source = match (toml_config.esplora, toml_config.bitcoind) {
+			(Some(EsploraConfig { server_url }), _) => {
+				let server_url = SocketAddr::from_str(&server_url).map_err(|e| {
+					io::Error::new(
+						io::ErrorKind::InvalidInput,
+						format!("Invalid esplora server url configured: {}", e),
+					)
+				})?;
+				ChainSource::Esplora { server_url }
+			},
+			(None, Some(BitcoindConfig { rpc_address, rpc_user, rpc_password })) => {
+				let rpc_address = SocketAddr::from_str(&rpc_address).map_err(|e| {
+					io::Error::new(
+						io::ErrorKind::InvalidInput,
+						format!("Invalid bitcoind RPC address configured: {}", e),
+					)
+				})?;
+				ChainSource::Rpc { rpc_address, rpc_user, rpc_password }
+			},
+			(None, None) => {
+				return Err(io::Error::new(
 					io::ErrorKind::InvalidInput,
-					format!("Invalid bitcoind RPC address configured: {}", e),
-				)
-			})?;
+					format!("At least one of esplora or rpc config must be set"),
+				))
+			},
+		};
 
 		let alias = if let Some(alias_str) = toml_config.node.alias {
 			let mut bytes = [0u8; 32];
@@ -97,9 +120,7 @@ impl TryFrom<TomlConfig> for Config {
 			alias,
 			rest_service_addr,
 			storage_dir_path: toml_config.storage.disk.dir_path,
-			bitcoind_rpc_addr,
-			bitcoind_rpc_user: toml_config.bitcoind.rpc_user,
-			bitcoind_rpc_password: toml_config.bitcoind.rpc_password,
+			chain_source,
 			rabbitmq_connection_string,
 			rabbitmq_exchange_name,
 			lsps2_service_config,
@@ -112,7 +133,8 @@ impl TryFrom<TomlConfig> for Config {
 pub struct TomlConfig {
 	node: NodeConfig,
 	storage: StorageConfig,
-	bitcoind: BitcoindConfig,
+	bitcoind: Option<BitcoindConfig>,
+	esplora: Option<EsploraConfig>,
 	rabbitmq: Option<RabbitmqConfig>,
 	liquidity: Option<LiquidityConfig>,
 }
@@ -142,6 +164,11 @@ struct BitcoindConfig {
 	rpc_password: String,
 }
 
+#[derive(Deserialize, Serialize)]
+struct EsploraConfig {
+	server_url: String,
+}
+
 #[derive(Deserialize, Serialize)]
 struct RabbitmqConfig {
 	connection_string: String,
@@ -237,6 +264,9 @@ mod tests {
 			rpc_address = "127.0.0.1:8332"    # RPC endpoint
 			rpc_user = "bitcoind-testuser"
 			rpc_password = "bitcoind-testpassword"
+
+			[esplora]
+			server_url = "127.0.0.1:3000"
 			
 			[rabbitmq]
 			connection_string = "rabbitmq_connection_string"
@@ -266,9 +296,9 @@ mod tests {
 			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(),
+			chain_source: ChainSource::Esplora {
+				server_url: SocketAddr::from_str("127.0.0.1:3000").unwrap(),
+			},
 			rabbitmq_connection_string: "rabbitmq_connection_string".to_string(),
 			rabbitmq_exchange_name: "rabbitmq_exchange_name".to_string(),
 			lsps2_service_config: Some(LSPS2ServiceConfig {
@@ -288,9 +318,13 @@ mod tests {
 		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);
+		let ChainSource::Esplora { server_url } = config.chain_source else {
+			panic!("unexpected config chain source");
+		};
+		let ChainSource::Esplora { server_url: expected_server_url } = expected.chain_source else {
+			panic!("unexpected chain source");
+		};
+		assert_eq!(server_url, expected_server_url);
 		assert_eq!(config.rabbitmq_connection_string, expected.rabbitmq_connection_string);
 		assert_eq!(config.rabbitmq_exchange_name, expected.rabbitmq_exchange_name);
 		#[cfg(feature = "experimental-lsps2-support")]