Merge pull request #138 from tnull/2023-07-vss-prep

Author: tnull

bindings/ldk_node.udl

@@ -81,7 +81,7 @@ interface LDKNode {
 	Invoice receive_variable_amount_payment([ByRef]string description, u32 expiry_secs);
 	PaymentDetails? payment([ByRef]PaymentHash payment_hash);
 	[Throws=NodeError]
-	boolean remove_payment([ByRef]PaymentHash payment_hash);
+	void remove_payment([ByRef]PaymentHash payment_hash);
 	sequence<PaymentDetails> list_payments();
 	sequence<PeerDetails> list_peers();
 	sequence<ChannelDetails> list_channels();

src/builder.rs

@@ -250,16 +250,21 @@ impl NodeBuilder {
 	pub fn build_with_store<K: KVStore + Sync + Send + 'static>(
 		&self, kv_store: Arc<K>,
 	) -> Result<Node<K>, BuildError> {
+		let logger = setup_logger(&self.config)?;
+		let seed_bytes = seed_bytes_from_config(
+			&self.config,
+			self.entropy_source_config.as_ref(),
+			Arc::clone(&logger),
+		)?;
 		let config = Arc::new(self.config.clone());
 
-		let runtime = Arc::new(RwLock::new(None));
 		build_with_store_internal(
 			config,
-			self.entropy_source_config.as_ref(),
 			self.chain_data_source_config.as_ref(),
 			self.gossip_source_config.as_ref(),
+			seed_bytes,
+			logger,
 			kv_store,
-			runtime,
 		)
 	}
 }
@@ -377,57 +382,27 @@ impl ArcedNodeBuilder {
 
 /// Builds a [`Node`] instance according to the options previously configured.
 fn build_with_store_internal<K: KVStore + Sync + Send + 'static>(
-	config: Arc<Config>, entropy_source_config: Option<&EntropySourceConfig>,
-	chain_data_source_config: Option<&ChainDataSourceConfig>,
-	gossip_source_config: Option<&GossipSourceConfig>, kv_store: Arc<K>,
-	runtime: Arc<RwLock<Option<tokio::runtime::Runtime>>>,
+	config: Arc<Config>, chain_data_source_config: Option<&ChainDataSourceConfig>,
+	gossip_source_config: Option<&GossipSourceConfig>, seed_bytes: [u8; 64],
+	logger: Arc<FilesystemLogger>, kv_store: Arc<K>,
 ) -> Result<Node<K>, BuildError> {
-	let ldk_data_dir = format!("{}/ldk", config.storage_dir_path);
-	fs::create_dir_all(ldk_data_dir.clone()).map_err(|_| BuildError::StoragePathAccessFailed)?;
-
-	let bdk_data_dir = format!("{}/bdk", config.storage_dir_path);
-	fs::create_dir_all(bdk_data_dir.clone()).map_err(|_| BuildError::StoragePathAccessFailed)?;
-
-	let log_dir = match &config.log_dir_path {
-		Some(log_dir) => String::from(log_dir),
-		None => config.storage_dir_path.clone() + "/logs",
-	};
-
-	// Initialize the Logger
-	let logger = Arc::new(
-		FilesystemLogger::new(log_dir, config.log_level)
-			.map_err(|_| BuildError::LoggerSetupFailed)?,
-	);
-
 	// Initialize the on-chain wallet and chain access
-	let seed_bytes = match entropy_source_config {
-		Some(EntropySourceConfig::SeedBytes(bytes)) => bytes.clone(),
-		Some(EntropySourceConfig::SeedFile(seed_path)) => {
-			io::utils::read_or_generate_seed_file(seed_path, Arc::clone(&logger))
-				.map_err(|_| BuildError::InvalidSeedFile)?
-		}
-		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, Arc::clone(&logger))
-				.map_err(|_| BuildError::InvalidSeedFile)?
-		}
-	};
-
 	let xprv = bitcoin::util::bip32::ExtendedPrivKey::new_master(config.network, &seed_bytes)
-		.map_err(|_| BuildError::InvalidSeedBytes)?;
+		.map_err(|e| {
+			log_error!(logger, "Failed to derive master secret: {}", e);
+			BuildError::InvalidSeedBytes
+		})?;
 
 	let wallet_name = bdk::wallet::wallet_name_from_descriptor(
 		Bip84(xprv, bdk::KeychainKind::External),
 		Some(Bip84(xprv, bdk::KeychainKind::Internal)),
 		config.network,
 		&Secp256k1::new(),
 	)
-	.map_err(|_| BuildError::WalletSetupFailed)?;
+	.map_err(|e| {
+		log_error!(logger, "Failed to derive wallet name: {}", e);
+		BuildError::WalletSetupFailed
+	})?;
 
 	let database_path = format!("{}/bdk_wallet_{}.sqlite", config.storage_dir_path, wallet_name);
 	let database = SqliteDatabase::new(database_path);
@@ -438,7 +413,10 @@ fn build_with_store_internal<K: KVStore + Sync + Send + 'static>(
 		config.network,
 		database,
 	)
-	.map_err(|_| BuildError::WalletSetupFailed)?;
+	.map_err(|e| {
+		log_error!(logger, "Failed to set up wallet: {}", e);
+		BuildError::WalletSetupFailed
+	})?;
 
 	let (blockchain, tx_sync) = match chain_data_source_config {
 		Some(ChainDataSourceConfig::Esplora(server_url)) => {
@@ -459,6 +437,7 @@ fn build_with_store_internal<K: KVStore + Sync + Send + 'static>(
 		}
 	};
 
+	let runtime = Arc::new(RwLock::new(None));
 	let wallet =
 		Arc::new(Wallet::new(blockchain, bdk_wallet, Arc::clone(&runtime), Arc::clone(&logger)));
 
@@ -472,9 +451,11 @@ fn build_with_store_internal<K: KVStore + Sync + Send + 'static>(
 	));
 
 	// Initialize the KeysManager
-	let cur_time = SystemTime::now()
-		.duration_since(SystemTime::UNIX_EPOCH)
-		.map_err(|_| BuildError::InvalidSystemTime)?;
+	let cur_time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).map_err(|e| {
+		log_error!(logger, "Failed to get current time: {}", e);
+		BuildError::InvalidSystemTime
+	})?;
+
 	let ldk_seed_bytes: [u8; 32] = xprv.private_key.secret_bytes();
 	let keys_manager = Arc::new(KeysManager::new(
 		&ldk_seed_bytes,
@@ -615,10 +596,6 @@ fn build_with_store_internal<K: KVStore + Sync + Send + 'static>(
 	));
 	let ephemeral_bytes: [u8; 32] = keys_manager.get_secure_random_bytes();
 
-	let cur_time = SystemTime::now()
-		.duration_since(SystemTime::UNIX_EPOCH)
-		.map_err(|_| BuildError::InvalidSystemTime)?;
-
 	// Initialize the GossipSource
 	// Use the configured gossip source, if the user set one, otherwise default to P2PNetwork.
 	let gossip_source_config = gossip_source_config.unwrap_or(&GossipSourceConfig::P2PNetwork);
@@ -634,7 +611,10 @@ fn build_with_store_internal<K: KVStore + Sync + Send + 'static>(
 				Arc::clone(&kv_store),
 				Arc::clone(&logger),
 			)
-			.map_err(|_| BuildError::WriteFailed)?;
+			.map_err(|e| {
+				log_error!(logger, "Failed writing to store: {}", e);
+				BuildError::WriteFailed
+			})?;
 			p2p_source
 		}
 		GossipSourceConfig::RapidGossipSync(rgs_server) => {
@@ -670,9 +650,17 @@ fn build_with_store_internal<K: KVStore + Sync + Send + 'static>(
 		}
 	};
 
+	let cur_time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).map_err(|e| {
+		log_error!(logger, "Failed to get current time: {}", e);
+		BuildError::InvalidSystemTime
+	})?;
+
 	let peer_manager = Arc::new(PeerManager::new(
 		msg_handler,
-		cur_time.as_secs().try_into().map_err(|_| BuildError::InvalidSystemTime)?,
+		cur_time.as_secs().try_into().map_err(|e| {
+			log_error!(logger, "Failed to get current time: {}", e);
+			BuildError::InvalidSystemTime
+		})?,
 		&ephemeral_bytes,
 		Arc::clone(&logger),
 		IgnoringMessageHandler {},
@@ -736,3 +724,38 @@ fn build_with_store_internal<K: KVStore + Sync + Send + 'static>(
 		payment_store,
 	})
 }
+
+fn setup_logger(config: &Config) -> Result<Arc<FilesystemLogger>, BuildError> {
+	let log_dir = match &config.log_dir_path {
+		Some(log_dir) => String::from(log_dir),
+		None => config.storage_dir_path.clone() + "/logs",
+	};
+
+	Ok(Arc::new(
+		FilesystemLogger::new(log_dir, config.log_level)
+			.map_err(|_| BuildError::LoggerSetupFailed)?,
+	))
+}
+
+fn seed_bytes_from_config(
+	config: &Config, entropy_source_config: Option<&EntropySourceConfig>,
+	logger: Arc<FilesystemLogger>,
+) -> Result<[u8; 64], BuildError> {
+	match entropy_source_config {
+		Some(EntropySourceConfig::SeedBytes(bytes)) => Ok(bytes.clone()),
+		Some(EntropySourceConfig::SeedFile(seed_path)) => {
+			Ok(io::utils::read_or_generate_seed_file(&seed_path, Arc::clone(&logger))
+				.map_err(|_| BuildError::InvalidSeedFile)?)
+		}
+		Some(EntropySourceConfig::Bip39Mnemonic { mnemonic, passphrase }) => match passphrase {
+			Some(passphrase) => Ok(mnemonic.to_seed(passphrase)),
+			None => Ok(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);
+			Ok(io::utils::read_or_generate_seed_file(&seed_path, Arc::clone(&logger))
+				.map_err(|_| BuildError::InvalidSeedFile)?)
+		}
+	}
+}

src/io/fs_store.rs

@@ -136,7 +136,7 @@ impl KVStore for FilesystemStore {
 		Ok(())
 	}
 
-	fn remove(&self, namespace: &str, key: &str) -> std::io::Result<bool> {
+	fn remove(&self, namespace: &str, key: &str) -> std::io::Result<()> {
 		let mut outer_lock = self.locks.lock().unwrap();
 		let lock_key = (namespace.to_string(), key.to_string());
 		let inner_lock_ref = Arc::clone(&outer_lock.entry(lock_key.clone()).or_default());
@@ -148,7 +148,7 @@ impl KVStore for FilesystemStore {
 		dest_file_path.push(key);
 
 		if !dest_file_path.is_file() {
-			return Ok(false);
+			return Ok(());
 		}
 
 		fs::remove_file(&dest_file_path)?;
@@ -190,7 +190,7 @@ impl KVStore for FilesystemStore {
 		// Garbage collect all lock entries that are not referenced anymore.
 		outer_lock.retain(|_, v| Arc::strong_count(&v) > 1);
 
-		Ok(true)
+		Ok(())
 	}
 
 	fn list(&self, namespace: &str) -> std::io::Result<Vec<String>> {

src/io/mod.rs

@@ -69,9 +69,7 @@ pub trait KVStore: KVStorePersister {
 	/// Will create the given `namespace` if not already present in the store.
 	fn write(&self, namespace: &str, key: &str, buf: &[u8]) -> std::io::Result<()>;
 	/// Removes any data that had previously been persisted under the given `key`.
-	///
-	/// Returns `true` if the `key` was present in the given `namespace`, and `false` otherwise.
-	fn remove(&self, namespace: &str, key: &str) -> std::io::Result<bool>;
+	fn remove(&self, namespace: &str, key: &str) -> std::io::Result<()>;
 	/// Returns a list of keys that are stored under the given `namespace`.
 	///
 	/// Will return an empty list if the `namespace` is unknown.

src/io/sqlite_store.rs

@@ -116,11 +116,11 @@ impl KVStore for SqliteStore {
 			})
 	}
 
-	fn remove(&self, namespace: &str, key: &str) -> std::io::Result<bool> {
+	fn remove(&self, namespace: &str, key: &str) -> std::io::Result<()> {
 		let locked_conn = self.connection.lock().unwrap();
 
 		let sql = format!("DELETE FROM {} WHERE namespace=:namespace AND key=:key;", KV_TABLE_NAME);
-		let changes = locked_conn
+		locked_conn
 			.execute(
 				&sql,
 				named_params! {
@@ -132,10 +132,7 @@ impl KVStore for SqliteStore {
 				let msg = format!("Failed to delete key {}/{}: {}", namespace, key, e);
 				std::io::Error::new(std::io::ErrorKind::Other, msg)
 			})?;
-
-		let was_present = changes != 0;
-
-		Ok(was_present)
+		Ok(())
 	}
 
 	fn list(&self, namespace: &str) -> std::io::Result<Vec<String>> {

src/lib.rs

@@ -1445,9 +1445,7 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 	}
 
 	/// Remove the payment with the given hash from the store.
-	///
-	/// Returns `true` if the payment was present and `false` otherwise.
-	pub fn remove_payment(&self, payment_hash: &PaymentHash) -> Result<bool, Error> {
+	pub fn remove_payment(&self, payment_hash: &PaymentHash) -> Result<(), Error> {
 		self.payment_store.remove(&payment_hash)
 	}
 

src/payment_store.rs

@@ -121,7 +121,7 @@ where
 		Ok(updated)
 	}
 
-	pub(crate) fn remove(&self, hash: &PaymentHash) -> Result<bool, Error> {
+	pub(crate) fn remove(&self, hash: &PaymentHash) -> Result<(), Error> {
 		let store_key = hex_utils::to_string(&hash.0);
 		self.kv_store.remove(PAYMENT_INFO_PERSISTENCE_NAMESPACE, &store_key).map_err(|e| {
 			log_error!(

src/test/utils.rs

@@ -96,13 +96,14 @@ impl KVStore for TestStore {
 		Ok(())
 	}
 
-	fn remove(&self, namespace: &str, key: &str) -> std::io::Result<bool> {
+	fn remove(&self, namespace: &str, key: &str) -> std::io::Result<()> {
 		match self.persisted_bytes.write().unwrap().entry(namespace.to_string()) {
 			hash_map::Entry::Occupied(mut e) => {
 				self.did_persist.store(true, Ordering::SeqCst);
-				Ok(e.get_mut().remove(&key.to_string()).is_some())
+				e.get_mut().remove(&key.to_string());
+				Ok(())
 			}
-			hash_map::Entry::Vacant(_) => Ok(false),
+			hash_map::Entry::Vacant(_) => Ok(()),
 		}
 	}