Move esplora config to ChainDataSourceConfig

After we already have `EntropySourceConfig` and `GossipSourceConfig`,
we here move the esplora server URL to a corresponding `enum
ChainDataSourceConfig`, which will us to add further variants (e.g.,
`Electrum`) in the future without breaking the API.

Additionally, we document the set default values.

Author: tnull

bindings/ldk_node.udl

@@ -3,7 +3,6 @@ namespace ldk_node {
 
 dictionary Config {
 	string storage_dir_path;
-	string esplora_server_url;
 	Network network;
 	NetAddress? listening_address;
 	u32 default_cltv_expiry_delta;
@@ -16,10 +15,10 @@ interface Builder {
 	void set_entropy_seed_path(string seed_path);
 	void set_entropy_seed_bytes(sequence<u8> seed_bytes);
 	void set_entropy_bip39_mnemonic(Mnemonic mnemonic, string? passphrase);
+	void set_esplora_server(string esplora_server_url);
 	void set_gossip_source_p2p();
 	void set_gossip_source_rgs(string rgs_server_url);
 	void set_storage_dir_path(string storage_dir_path);
-	void set_esplora_server_url(string esplora_server_url);
 	void set_network(Network network);
 	void set_listening_address(NetAddress listening_address);
 	LDKNode build();

src/lib.rs

@@ -35,7 +35,7 @@
 //! fn main() {
 //! 	let mut builder = Builder::new();
 //! 	builder.set_network(Network::Testnet);
-//! 	builder.set_esplora_server_url("https://blockstream.info/testnet/api".to_string());
+//! 	builder.set_esplora_server("https://blockstream.info/testnet/api".to_string());
 //!
 //! 	let node = builder.build();
 //! 	node.start().unwrap();
@@ -161,6 +161,13 @@ use std::time::{Duration, Instant, SystemTime};
 
 uniffi::include_scaffolding!("ldk_node");
 
+// Config defaults
+const DEFAULT_STORAGE_DIR_PATH: &str = "/tmp/ldk_node/";
+const DEFAULT_NETWORK: Network = Network::Regtest;
+const DEFAULT_LISTENING_ADDR: &str = "0.0.0.0:9735";
+const DEFAULT_CLTV_EXPIRY_DELTA: u32 = 144;
+const DEFAULT_ESPLORA_SERVER_URL: &str = "https://blockstream.info/api";
+
 // The 'stop gap' parameter used by BDK's wallet sync. This seems to configure the threshold
 // number of blocks after which BDK stops looking for scripts belonging to the wallet.
 const BDK_CLIENT_STOP_GAP: usize = 20;
@@ -185,11 +192,19 @@ const WALLET_KEYS_SEED_LEN: usize = 64;
 
 #[derive(Debug, Clone)]
 /// Represents the configuration of an [`Node`] instance.
+///
+/// ### Defaults
+///
+/// | Parameter                   | Value            |
+/// |-----------------------------|------------------|
+/// | `storage_dir_path`          | /tmp/ldk_node/   |
+/// | `network`                   | Network::Regtest |
+/// | `listening_address`         | 0.0.0.0:9735     |
+/// | `default_cltv_expiry_delta` | 144              |
+///
 pub struct Config {
 	/// The path where the underlying LDK and BDK persist their data.
 	pub storage_dir_path: String,
-	/// The URL of the utilized Esplora server.
-	pub esplora_server_url: String,
 	/// The used Bitcoin network.
 	pub network: Network,
 	/// The IP address and TCP port the node will listen on.
@@ -201,15 +216,19 @@ pub struct Config {
 impl Default for Config {
 	fn default() -> Self {
 		Self {
-			storage_dir_path: "/tmp/ldk_node/".to_string(),
-			esplora_server_url: "http://localhost:3002".to_string(),
-			network: Network::Regtest,
-			listening_address: Some("0.0.0.0:9735".parse().unwrap()),
-			default_cltv_expiry_delta: 144,
+			storage_dir_path: DEFAULT_STORAGE_DIR_PATH.to_string(),
+			network: DEFAULT_NETWORK,
+			listening_address: Some(DEFAULT_LISTENING_ADDR.parse().unwrap()),
+			default_cltv_expiry_delta: DEFAULT_CLTV_EXPIRY_DELTA,
 		}
 	}
 }
 
+#[derive(Debug, Clone)]
+enum ChainDataSourceConfig {
+	Esplora(String),
+}
+
 #[derive(Debug, Clone)]
 enum EntropySourceConfig {
 	SeedFile(String),
@@ -225,10 +244,16 @@ enum GossipSourceConfig {
 
 /// A builder for an [`Node`] instance, allowing to set some configuration and module choices from
 /// the getgo.
+///
+/// ### Defaults
+/// - Wallet entropy is sourced from a `keys_seed` file located under [`Config::storage_dir_path`]
+/// - Chain data is sourced from the Esplora endpoint `https://blockstream.info/api`
+/// - Gossip data is sourced via the peer-to-peer network
 #[derive(Debug)]
 pub struct Builder {
 	config: RwLock<Config>,
 	entropy_source_config: RwLock<Option<EntropySourceConfig>>,
+	chain_data_source_config: RwLock<Option<ChainDataSourceConfig>>,
 	gossip_source_config: RwLock<Option<GossipSourceConfig>>,
 }
 
@@ -237,16 +262,18 @@ impl Builder {
 	pub fn new() -> Self {
 		let config = RwLock::new(Config::default());
 		let entropy_source_config = RwLock::new(None);
+		let chain_data_source_config = RwLock::new(None);
 		let gossip_source_config = RwLock::new(None);
-		Self { config, entropy_source_config, gossip_source_config }
+		Self { config, entropy_source_config, chain_data_source_config, gossip_source_config }
 	}
 
 	/// Creates a new builder instance from an [`Config`].
 	pub fn from_config(config: Config) -> Self {
 		let config = RwLock::new(config);
 		let entropy_source_config = RwLock::new(None);
+		let chain_data_source_config = RwLock::new(None);
 		let gossip_source_config = RwLock::new(None);
-		Self { config, entropy_source_config, gossip_source_config }
+		Self { config, entropy_source_config, chain_data_source_config, gossip_source_config }
 	}
 
 	/// Configures the [`Node`] instance to source its wallet entropy from a seed file on disk.
@@ -278,6 +305,12 @@ impl Builder {
 			Some(EntropySourceConfig::Bip39Mnemonic { mnemonic, passphrase });
 	}
 
+	/// Configures the [`Node`] instance to source its chain data from the given Esplora server.
+	pub fn set_esplora_server(&self, esplora_server_url: String) {
+		*self.chain_data_source_config.write().unwrap() =
+			Some(ChainDataSourceConfig::Esplora(esplora_server_url));
+	}
+
 	/// Configures the [`Node`] instance to source its gossip data from the Lightning peer-to-peer
 	/// network.
 	pub fn set_gossip_source_p2p(&self) {
@@ -292,30 +325,18 @@ impl Builder {
 	}
 
 	/// Sets the used storage directory path.
-	///
-	/// Default: `/tmp/ldk_node/`
 	pub fn set_storage_dir_path(&self, storage_dir_path: String) {
 		let mut config = self.config.write().unwrap();
 		config.storage_dir_path = storage_dir_path;
 	}
 
-	/// Sets the Esplora server URL.
-	///
-	/// Default: `https://blockstream.info/api`
-	pub fn set_esplora_server_url(&self, esplora_server_url: String) {
-		let mut config = self.config.write().unwrap();
-		config.esplora_server_url = esplora_server_url;
-	}
-
 	/// Sets the Bitcoin network used.
 	pub fn set_network(&self, network: Network) {
 		let mut config = self.config.write().unwrap();
 		config.network = network;
 	}
 
 	/// Sets the IP address and TCP port on which [`Node`] will listen for incoming network connections.
-	///
-	/// Default: `0.0.0.0:9735`
 	pub fn set_listening_address(&self, listening_address: NetAddress) {
 		let mut config = self.config.write().unwrap();
 		config.listening_address = Some(listening_address);
@@ -347,24 +368,20 @@ impl Builder {
 		let logger = Arc::new(FilesystemLogger::new(log_file_path));
 
 		// Initialize the on-chain wallet and chain access
-		let seed_bytes = if let Some(entropy_source_config) =
-			&*self.entropy_source_config.read().unwrap()
-		{
-			// Use the configured entropy source, if the user set one.
-			match entropy_source_config {
-				EntropySourceConfig::SeedBytes(bytes) => bytes.clone(),
-				EntropySourceConfig::SeedFile(seed_path) => {
-					io::utils::read_or_generate_seed_file(seed_path)
-				}
-				EntropySourceConfig::Bip39Mnemonic { mnemonic, passphrase } => match passphrase {
-					Some(passphrase) => mnemonic.to_seed(passphrase),
-					None => mnemonic.to_seed(""),
-				},
+		let seed_bytes = match &*self.entropy_source_config.read().unwrap() {
+			Some(EntropySourceConfig::SeedBytes(bytes)) => bytes.clone(),
+			Some(EntropySourceConfig::SeedFile(seed_path)) => {
+				io::utils::read_or_generate_seed_file(seed_path)
+			}
+			Some(EntropySourceConfig::Bip39Mnemonic { mnemonic, passphrase }) => match passphrase {
+				Some(passphrase) => mnemonic.to_seed(passphrase),
+				None => mnemonic.to_seed(""),
+			},
+			None => {
+				// Default to read or generate from the default location generate a seed file.
+				let seed_path = format!("{}/keys_seed", config.storage_dir_path);
+				io::utils::read_or_generate_seed_file(&seed_path)
 			}
-		} else {
-			// Default to read or generate from the default location generate a seed file.
-			let seed_path = format!("{}/keys_seed", config.storage_dir_path);
-			io::utils::read_or_generate_seed_file(&seed_path)
 		};
 
 		let xprv = bitcoin::util::bip32::ExtendedPrivKey::new_master(config.network, &seed_bytes)
@@ -389,14 +406,25 @@ impl Builder {
 		)
 		.expect("Failed to set up on-chain wallet");
 
-		let tx_sync = Arc::new(EsploraSyncClient::new(
-			config.esplora_server_url.clone(),
-			Arc::clone(&logger),
-		));
-
-		let blockchain =
-			EsploraBlockchain::from_client(tx_sync.client().clone(), BDK_CLIENT_STOP_GAP)
-				.with_concurrency(BDK_CLIENT_CONCURRENCY);
+		let (blockchain, tx_sync) = match &*self.chain_data_source_config.read().unwrap() {
+			Some(ChainDataSourceConfig::Esplora(server_url)) => {
+				let tx_sync =
+					Arc::new(EsploraSyncClient::new(server_url.clone(), Arc::clone(&logger)));
+				let blockchain =
+					EsploraBlockchain::from_client(tx_sync.client().clone(), BDK_CLIENT_STOP_GAP)
+						.with_concurrency(BDK_CLIENT_CONCURRENCY);
+				(blockchain, tx_sync)
+			}
+			None => {
+				// Default to Esplora client.
+				let server_url = DEFAULT_ESPLORA_SERVER_URL.to_string();
+				let tx_sync = Arc::new(EsploraSyncClient::new(server_url, Arc::clone(&logger)));
+				let blockchain =
+					EsploraBlockchain::from_client(tx_sync.client().clone(), BDK_CLIENT_STOP_GAP)
+						.with_concurrency(BDK_CLIENT_CONCURRENCY);
+				(blockchain, tx_sync)
+			}
+		};
 
 		let runtime = Arc::new(RwLock::new(None));
 		let wallet = Arc::new(Wallet::new(

src/test/functional_tests.rs

@@ -8,15 +8,19 @@ use bitcoin::Amount;
 fn channel_full_cycle() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	println!("== Node A ==");
-	let esplora_url = electrsd.esplora_url.as_ref().unwrap();
-	let config_a = random_config(esplora_url);
-	let node_a = Builder::from_config(config_a).build();
+	let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap());
+	let config_a = random_config();
+	let builder_a = Builder::from_config(config_a);
+	builder_a.set_esplora_server(esplora_url.clone());
+	let node_a = builder_a.build();
 	node_a.start().unwrap();
 	let addr_a = node_a.new_funding_address().unwrap();
 
 	println!("\n== Node B ==");
-	let config_b = random_config(esplora_url);
-	let node_b = Builder::from_config(config_b).build();
+	let config_b = random_config();
+	let builder_b = Builder::from_config(config_b);
+	builder_b.set_esplora_server(esplora_url);
+	let node_b = builder_b.build();
 	node_b.start().unwrap();
 	let addr_b = node_b.new_funding_address().unwrap();
 
@@ -221,15 +225,19 @@ fn channel_full_cycle() {
 fn channel_open_fails_when_funds_insufficient() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	println!("== Node A ==");
-	let esplora_url = electrsd.esplora_url.as_ref().unwrap();
-	let config_a = random_config(&esplora_url);
-	let node_a = Builder::from_config(config_a).build();
+	let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap());
+	let config_a = random_config();
+	let builder_a = Builder::from_config(config_a);
+	builder_a.set_esplora_server(esplora_url.clone());
+	let node_a = builder_a.build();
 	node_a.start().unwrap();
 	let addr_a = node_a.new_funding_address().unwrap();
 
 	println!("\n== Node B ==");
-	let config_b = random_config(&esplora_url);
-	let node_b = Builder::from_config(config_b).build();
+	let config_b = random_config();
+	let builder_b = Builder::from_config(config_b);
+	builder_b.set_esplora_server(esplora_url);
+	let node_b = builder_b.build();
 	node_b.start().unwrap();
 	let addr_b = node_b.new_funding_address().unwrap();
 
@@ -261,12 +269,11 @@ fn channel_open_fails_when_funds_insufficient() {
 
 #[test]
 fn connect_to_public_testnet_esplora() {
-	let (_bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let esplora_url = electrsd.esplora_url.as_ref().unwrap();
-	let mut config = random_config(&esplora_url);
-	config.esplora_server_url = "https://blockstream.info/testnet/api".to_string();
+	let mut config = random_config();
 	config.network = bitcoin::Network::Testnet;
-	let node = Builder::from_config(config).build();
+	let builder = Builder::from_config(config);
+	builder.set_esplora_server("https://blockstream.info/testnet/api".to_string());
+	let node = builder.build();
 	node.start().unwrap();
 	node.sync_wallets().unwrap();
 	node.stop().unwrap();
@@ -275,9 +282,11 @@ fn connect_to_public_testnet_esplora() {
 #[test]
 fn start_stop_reinit() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let esplora_url = electrsd.esplora_url.as_ref().unwrap();
-	let config = random_config(&esplora_url);
-	let node = Builder::from_config(config.clone()).build();
+	let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap());
+	let config = random_config();
+	let builder = Builder::from_config(config.clone());
+	builder.set_esplora_server(esplora_url.clone());
+	let node = builder.build();
 	let expected_node_id = node.node_id();
 
 	let funding_address = node.new_funding_address().unwrap();
@@ -302,7 +311,9 @@ fn start_stop_reinit() {
 	assert_eq!(node.stop(), Err(Error::NotRunning));
 	drop(node);
 
-	let reinitialized_node = Builder::from_config(config).build();
+	let new_builder = Builder::from_config(config);
+	new_builder.set_esplora_server(esplora_url);
+	let reinitialized_node = builder.build();
 	assert_eq!(reinitialized_node.node_id(), expected_node_id);
 
 	reinitialized_node.start().unwrap();
@@ -324,15 +335,19 @@ fn start_stop_reinit() {
 #[test]
 fn onchain_spend_receive() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
-	let esplora_url = electrsd.esplora_url.as_ref().unwrap();
+	let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap());
 
-	let config_a = random_config(esplora_url);
-	let node_a = Builder::from_config(config_a).build();
+	let config_a = random_config();
+	let builder_a = Builder::from_config(config_a);
+	builder_a.set_esplora_server(esplora_url.clone());
+	let node_a = builder_a.build();
 	node_a.start().unwrap();
 	let addr_a = node_a.new_funding_address().unwrap();
 
-	let config_b = random_config(esplora_url);
-	let node_b = Builder::from_config(config_b).build();
+	let config_b = random_config();
+	let builder_b = Builder::from_config(config_b);
+	builder_b.set_esplora_server(esplora_url);
+	let node_b = builder_b.build();
 	node_b.start().unwrap();
 	let addr_b = node_b.new_funding_address().unwrap();
 
@@ -376,8 +391,11 @@ fn onchain_spend_receive() {
 #[test]
 fn sign_verify_msg() {
 	let (_, electrsd) = setup_bitcoind_and_electrsd();
-	let esplora_url = electrsd.esplora_url.as_ref().unwrap();
-	let node = Builder::from_config(random_config(esplora_url)).build();
+	let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap());
+	let config = random_config();
+	let builder = Builder::from_config(config.clone());
+	builder.set_esplora_server(esplora_url.clone());
+	let node = builder.build();
 
 	node.start().unwrap();
 

src/test/utils.rs

@@ -4,7 +4,7 @@ use lightning::util::logger::{Level, Logger, Record};
 use lightning::util::persist::KVStorePersister;
 use lightning::util::ser::Writeable;
 
-use bitcoin::{Address, Amount, OutPoint, Txid};
+use bitcoin::{Address, Amount, Network, OutPoint, Txid};
 
 use bitcoind::bitcoincore_rpc::RpcApi;
 use electrsd::bitcoind::bitcoincore_rpc::bitcoincore_rpc_json::AddressType;
@@ -251,11 +251,11 @@ pub fn random_port() -> u16 {
 	rng.gen_range(5000..65535)
 }
 
-pub fn random_config(esplora_url: &str) -> Config {
+pub fn random_config() -> Config {
 	let mut config = Config::default();
 
-	println!("Setting esplora server URL: {}", esplora_url);
-	config.esplora_server_url = format!("http://{}", esplora_url);
+	config.network = Network::Regtest;
+	println!("Setting network: {}", config.network);
 
 	let rand_dir = random_storage_path();
 	println!("Setting random LDK storage dir: {}", rand_dir);