Break builder pattern and expose setters via bindings

Unfortunately there is no good way of exposing the builder pattern via
Uniffi bindings currenlty. We therefore resort to internal mutability
and using setters on the `Builder` object.

Author: tnull

README.md

@@ -11,14 +11,15 @@ The primary abstraction of the library is the `Node`, which can be retrieved by
 use ldk_node::Builder;
 use ldk_node::lightning_invoice::Invoice;
 use ldk_node::bitcoin::secp256k1::PublicKey;
+use ldk_node::bitcoin::Network;
 use std::str::FromStr;
 
 fn main() {
-	let node = Builder::new()
-		.set_network("testnet")
-		.set_esplora_server_url("https://blockstream.info/testnet/api".to_string())
-		.build();
+	let mut builder = Builder::new();
+	builder.set_network(Network::Testnet);
+	builder.set_esplora_server_url("https://blockstream.info/testnet/api".to_string());
 
+	let node = builder.build();
 	node.start().unwrap();
 
 	let _funding_address = node.new_funding_address();

bindings/ldk_node.udl

@@ -13,6 +13,13 @@ interface Builder {
 	constructor();
 	[Name=from_config]
 	constructor(Config config);
+	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_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(SocketAddr listening_address);
 	Node build();
 };
 
@@ -182,3 +189,6 @@ typedef string UserChannelId;
 
 [Custom]
 typedef string Network;
+
+[Custom]
+typedef string Mnemonic;

src/lib.rs

@@ -29,14 +29,15 @@
 //! use ldk_node::Builder;
 //! use ldk_node::lightning_invoice::Invoice;
 //! use ldk_node::bitcoin::secp256k1::PublicKey;
+//! use ldk_node::bitcoin::Network;
 //! use std::str::FromStr;
 //!
 //! fn main() {
-//! 	let node = Builder::new()
-//! 		.set_network("testnet")
-//! 		.set_esplora_server_url("https://blockstream.info/testnet/api".to_string())
-//! 		.build();
+//! 	let mut builder = Builder::new();
+//! 	builder.set_network(Network::Testnet);
+//! 	builder.set_esplora_server_url("https://blockstream.info/testnet/api".to_string());
 //!
+//! 	let node = builder.build();
 //! 	node.start().unwrap();
 //!
 //! 	let _funding_address = node.new_funding_address();
@@ -142,6 +143,8 @@ use bitcoin::hashes::Hash;
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::Network;
 
+use bip39::Mnemonic;
+
 use bitcoin::{Address, BlockHash, OutPoint, Txid};
 
 use rand::Rng;
@@ -150,7 +153,6 @@ use std::convert::TryInto;
 use std::default::Default;
 use std::fs;
 use std::net::SocketAddr;
-use std::str::FromStr;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, RwLock};
 use std::time::{Duration, Instant, SystemTime};
@@ -204,93 +206,93 @@ impl Default for Config {
 enum WalletEntropySource {
 	SeedFile(String),
 	SeedBytes([u8; WALLET_KEYS_SEED_LEN]),
-	Bip39Mnemonic { mnemonic: bip39::Mnemonic, passphrase: Option<String> },
+	Bip39Mnemonic { mnemonic: Mnemonic, passphrase: Option<String> },
 }
 
 /// A builder for an [`Node`] instance, allowing to set some configuration and module choices from
 /// the getgo.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct Builder {
-	config: Config,
-	entropy_source: Option<WalletEntropySource>,
+	config: Mutex<Config>,
+	entropy_source: Mutex<Option<WalletEntropySource>>,
 }
 
 impl Builder {
 	/// Creates a new builder instance with the default configuration.
 	pub fn new() -> Self {
-		let config = Config::default();
-		let entropy_source = None;
+		let config = Mutex::new(Config::default());
+		let entropy_source = Mutex::new(None);
 		Self { config, entropy_source }
 	}
 
 	/// Creates a new builder instance from an [`Config`].
 	pub fn from_config(config: Config) -> Self {
-		let entropy_source = None;
+		let config = Mutex::new(config);
+		let entropy_source = Mutex::new(None);
 		Self { config, entropy_source }
 	}
 
 	/// Configures the [`Node`] instance to source its wallet entropy from a seed file on disk.
 	///
 	/// If the given file does not exist a new random seed file will be generated and
 	/// stored at the given location.
-	pub fn set_entropy_seed_path(&mut self, seed_path: String) -> &mut Self {
-		self.entropy_source = Some(WalletEntropySource::SeedFile(seed_path));
-		self
+	pub fn set_entropy_seed_path(&self, seed_path: String) {
+		*self.entropy_source.lock().unwrap() = Some(WalletEntropySource::SeedFile(seed_path));
 	}
 
-	/// Configures the [`Node`] instance to source its wallet entropy from the given seed bytes.
-	pub fn set_entropy_seed_bytes(&mut self, seed_bytes: [u8; WALLET_KEYS_SEED_LEN]) -> &mut Self {
-		self.entropy_source = Some(WalletEntropySource::SeedBytes(seed_bytes));
-		self
+	/// Configures the [`Node`] instance to source its wallet entropy from the given 64 seed bytes.
+	///
+	/// **Note:** Panics if the length of the given `seed_bytes` differs from 64.
+	pub fn set_entropy_seed_bytes(&self, seed_bytes: Vec<u8>) {
+		if seed_bytes.len() != WALLET_KEYS_SEED_LEN {
+			panic!("Failed to set seed due to invalid length.");
+		}
+		let mut bytes = [0u8; WALLET_KEYS_SEED_LEN];
+		bytes.copy_from_slice(&seed_bytes);
+		*self.entropy_source.lock().unwrap() = Some(WalletEntropySource::SeedBytes(bytes));
 	}
 
 	/// Configures the [`Node`] instance to source its wallet entropy from a [BIP 39] mnemonic.
 	///
 	/// [BIP 39]: https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki
-	pub fn set_entropy_bip39_mnemonic(
-		&mut self, mnemonic: bip39::Mnemonic, passphrase: Option<String>,
-	) -> &mut Self {
-		self.entropy_source = Some(WalletEntropySource::Bip39Mnemonic { mnemonic, passphrase });
-		self
+	pub fn set_entropy_bip39_mnemonic(&self, mnemonic: Mnemonic, passphrase: Option<String>) {
+		*self.entropy_source.lock().unwrap() =
+			Some(WalletEntropySource::Bip39Mnemonic { mnemonic, passphrase });
 	}
 
 	/// Sets the used storage directory path.
 	///
 	/// Default: `/tmp/ldk_node/`
-	pub fn set_storage_dir_path(&mut self, storage_dir_path: String) -> &mut Self {
-		self.config.storage_dir_path = storage_dir_path;
-		self
+	pub fn set_storage_dir_path(&self, storage_dir_path: String) {
+		let mut config = self.config.lock().unwrap();
+		config.storage_dir_path = storage_dir_path;
 	}
 
 	/// Sets the Esplora server URL.
 	///
 	/// Default: `https://blockstream.info/api`
-	pub fn set_esplora_server_url(&mut self, esplora_server_url: String) -> &mut Self {
-		self.config.esplora_server_url = esplora_server_url;
-		self
+	pub fn set_esplora_server_url(&self, esplora_server_url: String) {
+		let mut config = self.config.lock().unwrap();
+		config.esplora_server_url = esplora_server_url;
 	}
 
 	/// Sets the Bitcoin network used.
-	///
-	/// Options: `mainnet`/`bitcoin`, `testnet`, `regtest`, `signet`
-	///
-	/// Default: `regtest`
-	pub fn set_network(&mut self, network: &str) -> &mut Self {
-		self.config.network = Network::from_str(network).unwrap_or(Network::Regtest);
-		self
+	pub fn set_network(&self, network: Network) {
+		let mut config = self.config.lock().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(&mut self, listening_address: SocketAddr) -> &mut Self {
-		self.config.listening_address = Some(listening_address);
-		self
+	pub fn set_listening_address(&self, listening_address: SocketAddr) {
+		let mut config = self.config.lock().unwrap();
+		config.listening_address = Some(listening_address);
 	}
 
 	/// Builds a [`Node`] instance according to the options previously configured.
 	pub fn build(&self) -> Arc<Node> {
-		let config = Arc::new(self.config.clone());
+		let config = Arc::new(self.config.lock().unwrap().clone());
 
 		let ldk_data_dir = format!("{}/ldk", config.storage_dir_path);
 		fs::create_dir_all(ldk_data_dir.clone()).expect("Failed to create LDK data directory");
@@ -303,7 +305,7 @@ 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) = &self.entropy_source {
+		let seed_bytes = if let Some(entropy_source) = &*self.entropy_source.lock().unwrap() {
 			// Use the configured entropy source, if the user set one.
 			match entropy_source {
 				WalletEntropySource::SeedBytes(bytes) => bytes.clone(),

src/types.rs

@@ -25,6 +25,8 @@ use bitcoin::hashes::Hash;
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::{Address, Network, OutPoint, Txid};
 
+use bip39::Mnemonic;
+
 use std::convert::TryInto;
 use std::net::SocketAddr;
 use std::str::FromStr;
@@ -401,3 +403,14 @@ pub struct PeerDetails {
 	/// Indicates whether or not the user is currently has an active connection with the peer.
 	pub is_connected: bool,
 }
+
+impl UniffiCustomTypeConverter for Mnemonic {
+	type Builtin = String;
+	fn into_custom(val: Self::Builtin) -> uniffi::Result<Self> {
+		Ok(Mnemonic::from_str(&val).unwrap())
+	}
+
+	fn from_custom(obj: Self) -> Self::Builtin {
+		obj.to_string()
+	}
+}