Clean up error types and logging outputs

Here we migrate from wrapping all upstream errors to exposing only
select error variants to the downstream user. Also, we clean up and
unify logging outputs.

Author: tnull

src/access.rs

@@ -64,11 +64,7 @@ where
 	pub(crate) async fn sync_wallet(&self) -> Result<(), Error> {
 		let sync_options = SyncOptions { progress: None };
 
-		self.wallet
-			.lock()
-			.unwrap()
-			.sync(&self.blockchain, sync_options)
-			.map_err(|e| Error::Bdk(e))?;
+		self.wallet.lock().unwrap().sync(&self.blockchain, sync_options)?;
 
 		Ok(())
 	}
@@ -140,11 +136,11 @@ where
 							if let Some(merkle_proof) = client.get_merkle_proof(&txid).await? {
 								if block_height == merkle_proof.block_height {
 									confirmed_txs.push((
-											tx,
-											block_height,
-											block_header,
-											merkle_proof.pos,
-											));
+										tx,
+										block_height,
+										block_header,
+										merkle_proof.pos,
+									));
 									continue;
 								}
 							}
@@ -300,7 +296,7 @@ where
 		match self.blockchain.broadcast(tx) {
 			Ok(_) => {}
 			Err(err) => {
-				log_error!(self.logger, "Failed to broadcast transaction: {}", err),
+				log_error!(self.logger, "Failed to broadcast transaction: {}", err);
 				panic!("Failed to broadcast transaction: {}", err);
 			}
 		}

src/error.rs

@@ -1,10 +1,5 @@
 use bdk::blockchain::esplora;
-use lightning::ln::msgs;
-use lightning::util::errors;
-use lightning_invoice::payment;
 use std::fmt;
-use std::io;
-use std::time;
 
 #[derive(Debug)]
 /// An error that possibly needs to be handled by the user.
@@ -19,112 +14,65 @@ pub enum LdkLiteError {
 	ConnectionFailed,
 	/// Payment of the given invoice has already been intiated.
 	NonUniquePaymentHash,
+	/// The given invoice is invalid.
+	InvoiceInvalid,
+	/// Invoice creation failed.
+	InvoiceCreationFailed,
+	/// No route for the given target could be found.
+	RoutingFailed,
 	/// A given peer info could not be parsed.
-	PeerInfoParse(&'static str),
-	/// A wrapped LDK `APIError`
-	LdkApi(errors::APIError),
-	/// A wrapped LDK `DecodeError`
-	LdkDecode(msgs::DecodeError),
-	/// A wrapped LDK `PaymentError`
-	LdkPayment(payment::PaymentError),
-	/// A wrapped LDK `SignOrCreationError`
-	LdkInvoiceCreation(lightning_invoice::SignOrCreationError),
-	/// A wrapped BDK error
-	Bdk(bdk::Error),
-	/// A wrapped `EsploraError`
-	Esplora(esplora::EsploraError),
-	/// A wrapped `Bip32` error
-	Bip32(bitcoin::util::bip32::Error),
-	/// A wrapped `std::io::Error`
-	StdIo(io::Error),
-	/// A wrapped `SystemTimeError`
-	StdTime(time::SystemTimeError),
+	PeerInfoParseFailed,
+	/// A channel could not be opened.
+	ChannelCreationFailed,
+	/// A channel could not be closed.
+	ChannelClosingFailed,
+	/// Persistence failed.
+	PersistenceFailed,
+	/// A wallet operation failed.
+	WalletOperationFailed,
+	/// A siging operation failed.
+	WalletSigningFailed,
+	/// A chain access operation failed.
+	ChainAccessFailed,
 }
 
 impl fmt::Display for LdkLiteError {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		match *self {
-			LdkLiteError::AlreadyRunning => write!(f, "LDKLite is already running."),
-			LdkLiteError::NotRunning => write!(f, "LDKLite is not running."),
-			LdkLiteError::FundingTxCreationFailed => {
-				write!(f, "the funding transaction could not be created")
+			Self::AlreadyRunning => write!(f, "LDKLite is already running."),
+			Self::NotRunning => write!(f, "LDKLite is not running."),
+			Self::FundingTxCreationFailed => {
+				write!(f, "Funding transaction could not be created.")
 			}
-			LdkLiteError::ConnectionFailed => write!(f, "network connection closed"),
-			LdkLiteError::NonUniquePaymentHash => write!(f, "an invoice must not get payed twice."),
-			LdkLiteError::PeerInfoParse(ref e) => {
-				write!(f, "given peer info could not be parsed: {}", e)
-			}
-			LdkLiteError::LdkDecode(ref e) => write!(f, "LDK decode error: {}", e),
-			LdkLiteError::LdkApi(ref e) => write!(f, "LDK API error: {:?}", e),
-			LdkLiteError::LdkPayment(ref e) => write!(f, "LDK payment error: {:?}", e),
-			LdkLiteError::LdkInvoiceCreation(ref e) => {
-				write!(f, "LDK invoice sign or creation error: {:?}", e)
-			}
-			LdkLiteError::Bdk(ref e) => write!(f, "BDK error: {}", e),
-			LdkLiteError::Esplora(ref e) => write!(f, "Esplora error: {}", e),
-			LdkLiteError::Bip32(ref e) => write!(f, "Bitcoin error: {}", e),
-			LdkLiteError::StdIo(ref e) => write!(f, "IO error: {}", e),
-			LdkLiteError::StdTime(ref e) => write!(f, "time error: {}", e),
+			Self::ConnectionFailed => write!(f, "Network connection closed."),
+			Self::NonUniquePaymentHash => write!(f, "An invoice must not get payed twice."),
+			Self::InvoiceInvalid => write!(f, "The given invoice is invalid."),
+			Self::InvoiceCreationFailed => write!(f, "Failed to create invoice."),
+			Self::RoutingFailed => write!(f, "Failed to find route."),
+			Self::PeerInfoParseFailed => write!(f, "Failed to parse the given peer information."),
+			Self::ChannelCreationFailed => write!(f, "Failed to create channel."),
+			Self::ChannelClosingFailed => write!(f, "Failed to close channel."),
+			Self::PersistenceFailed => write!(f, "Failed to persist data."),
+			Self::WalletOperationFailed => write!(f, "Failed to conduct wallet operation."),
+			Self::WalletSigningFailed => write!(f, "Failed to sign given transaction."),
+			Self::ChainAccessFailed => write!(f, "Failed to conduct chain access operation."),
 		}
 	}
 }
 
-impl From<errors::APIError> for LdkLiteError {
-	fn from(e: errors::APIError) -> Self {
-		Self::LdkApi(e)
-	}
-}
-
-impl From<msgs::DecodeError> for LdkLiteError {
-	fn from(e: msgs::DecodeError) -> Self {
-		Self::LdkDecode(e)
-	}
-}
-
-impl From<payment::PaymentError> for LdkLiteError {
-	fn from(e: payment::PaymentError) -> Self {
-		Self::LdkPayment(e)
-	}
-}
-
-impl From<lightning_invoice::SignOrCreationError> for LdkLiteError {
-	fn from(e: lightning_invoice::SignOrCreationError) -> Self {
-		Self::LdkInvoiceCreation(e)
-	}
-}
+impl std::error::Error for LdkLiteError {}
 
 impl From<bdk::Error> for LdkLiteError {
 	fn from(e: bdk::Error) -> Self {
-		Self::Bdk(e)
-	}
-}
-
-impl From<bdk::sled::Error> for LdkLiteError {
-	fn from(e: bdk::sled::Error) -> Self {
-		Self::Bdk(bdk::Error::Sled(e))
-	}
-}
-
-impl From<bitcoin::util::bip32::Error> for LdkLiteError {
-	fn from(e: bitcoin::util::bip32::Error) -> Self {
-		Self::Bip32(e)
-	}
-}
-
-impl From<io::Error> for LdkLiteError {
-	fn from(e: io::Error) -> Self {
-		Self::StdIo(e)
-	}
-}
-
-impl From<time::SystemTimeError> for LdkLiteError {
-	fn from(e: time::SystemTimeError) -> Self {
-		Self::StdTime(e)
+		match e {
+			bdk::Error::Signer(_) => Self::WalletSigningFailed,
+			_ => Self::WalletOperationFailed,
+		}
 	}
 }
 
 impl From<esplora::EsploraError> for LdkLiteError {
-	fn from(e: esplora::EsploraError) -> Self {
-		Self::Esplora(e)
+	fn from(_e: esplora::EsploraError) -> Self {
+		Self::ChainAccessFailed
 	}
 }

src/event.rs

@@ -154,7 +154,9 @@ impl<K: KVStorePersister> LdkLiteEventQueue<K> {
 		let mut locked_queue = self.queue.lock().unwrap();
 		locked_queue.0.push_back(event);
 
-		self.persister.persist(EVENTS_PERSISTENCE_KEY, &*locked_queue)?;
+		self.persister
+			.persist(EVENTS_PERSISTENCE_KEY, &*locked_queue)
+			.map_err(|_| Error::PersistenceFailed)?;
 
 		self.notifier.notify_one();
 		Ok(())
@@ -171,7 +173,9 @@ impl<K: KVStorePersister> LdkLiteEventQueue<K> {
 	pub(crate) fn event_handled(&self) -> Result<(), Error> {
 		let mut locked_queue = self.queue.lock().unwrap();
 		locked_queue.0.pop_front();
-		self.persister.persist(EVENTS_PERSISTENCE_KEY, &*locked_queue)?;
+		self.persister
+			.persist(EVENTS_PERSISTENCE_KEY, &*locked_queue)
+			.map_err(|_| Error::PersistenceFailed)?;
 		self.notifier.notify_one();
 		Ok(())
 	}

src/io_utils.rs

@@ -14,11 +14,13 @@ use std::convert::TryFrom;
 use std::fs;
 use std::io::{BufRead, BufReader, Write};
 use std::net::SocketAddr;
+use std::path::Path;
 use std::sync::Arc;
 
-pub(crate) fn read_or_generate_seed_file(config: Arc<LdkLiteConfig>) -> Result<[u8; 32], Error> {
+pub(crate) fn read_or_generate_seed_file(config: Arc<LdkLiteConfig>) -> [u8; 32] {
 	let keys_seed_path = format!("{}/keys_seed", config.storage_dir_path);
-	let keys_seed = if let Ok(seed) = fs::read(keys_seed_path.clone()) {
+	let keys_seed = if Path::new(&keys_seed_path).exists() {
+		let seed = fs::read(keys_seed_path.clone()).expect("Failed to read keys seed file");
 		assert_eq!(seed.len(), 32);
 		let mut key = [0; 32];
 		key.copy_from_slice(&seed);
@@ -27,13 +29,14 @@ pub(crate) fn read_or_generate_seed_file(config: Arc<LdkLiteConfig>) -> Result<[
 		let mut key = [0; 32];
 		thread_rng().fill_bytes(&mut key);
 
-		let mut f = fs::File::create(keys_seed_path.clone()).map_err(|e| Error::StdIo(e))?;
+		let mut f =
+			fs::File::create(keys_seed_path.clone()).expect("Failed to create keys seed file");
 		f.write_all(&key).expect("Failed to write node keys seed to disk");
 		f.sync_all().expect("Failed to sync node keys seed to disk");
 		key
 	};
 
-	Ok(keys_seed)
+	keys_seed
 }
 
 pub(crate) fn read_network_graph(