Add test setup and first end-to-end test

Author: tnull

Cargo.toml

@@ -48,6 +48,10 @@ futures = "0.3"
 serde_json = { version = "1.0" }
 tokio = { version = "1", features = [ "full" ] }
 
+[dev-dependencies]
+electrsd = { version = "0.22.0", features = ["legacy", "esplora_a33e97e1", "bitcoind_23_0"] }
+electrum-client = "0.12.0"
+once_cell = "1.16.0"
 
 [profile.release]
 panic = "abort"

src/error.rs

@@ -71,9 +71,7 @@ impl From<bdk::Error> for Error {
 }
 
 impl From<lightning_transaction_sync::TxSyncError> for Error {
-	fn from(e: lightning_transaction_sync::TxSyncError) -> Self {
-		match e {
-			_ => Self::TxSyncFailed,
-		}
+	fn from(_e: lightning_transaction_sync::TxSyncError) -> Self {
+		Self::TxSyncFailed
 	}
 }

src/io_utils.rs

@@ -12,8 +12,8 @@ use std::sync::Arc;
 
 pub(crate) fn read_or_generate_seed_file(config: Arc<Config>) -> [u8; 32] {
 	let keys_seed_path = format!("{}/keys_seed", config.storage_dir_path);
-	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");
+	if Path::new(&keys_seed_path).exists() {
+		let seed = fs::read(keys_seed_path).expect("Failed to read keys seed file");
 		assert_eq!(seed.len(), 32);
 		let mut key = [0; 32];
 		key.copy_from_slice(&seed);
@@ -22,21 +22,18 @@ pub(crate) fn read_or_generate_seed_file(config: Arc<Config>) -> [u8; 32] {
 		let mut key = [0; 32];
 		thread_rng().fill_bytes(&mut key);
 
-		let mut f =
-			fs::File::create(keys_seed_path.clone()).expect("Failed to create keys seed file");
+		let mut f = fs::File::create(keys_seed_path).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
-	};
-
-	keys_seed
+	}
 }
 
 pub(crate) fn read_network_graph(
 	config: Arc<Config>, logger: Arc<FilesystemLogger>,
 ) -> Result<NetworkGraph, Error> {
 	let ldk_data_dir = format!("{}/ldk", &config.storage_dir_path.clone());
-	let network_graph_path = format!("{}/network_graph", ldk_data_dir.clone());
+	let network_graph_path = format!("{}/network_graph", ldk_data_dir);
 
 	if let Ok(file) = fs::File::open(network_graph_path) {
 		if let Ok(graph) = NetworkGraph::read(&mut BufReader::new(file), Arc::clone(&logger)) {
@@ -52,8 +49,8 @@ pub(crate) fn read_network_graph(
 pub(crate) fn read_scorer(
 	config: Arc<Config>, network_graph: Arc<NetworkGraph>, logger: Arc<FilesystemLogger>,
 ) -> Scorer {
-	let ldk_data_dir = format!("{}/ldk", &config.storage_dir_path.clone());
-	let scorer_path = format!("{}/scorer", ldk_data_dir.clone());
+	let ldk_data_dir = format!("{}/ldk", &config.storage_dir_path);
+	let scorer_path = format!("{}/scorer", ldk_data_dir);
 
 	let params = ProbabilisticScoringParameters::default();
 	if let Ok(file) = fs::File::open(scorer_path) {

src/lib.rs

@@ -30,6 +30,8 @@ mod hex_utils;
 mod io_utils;
 mod logger;
 mod peer_store;
+#[cfg(test)]
+mod tests;
 mod types;
 mod wallet;
 
@@ -213,19 +215,18 @@ impl Builder {
 			.expect("Failed to read wallet master key");
 
 		let wallet_name = bdk::wallet::wallet_name_from_descriptor(
-			Bip84(xprv.clone(), bdk::KeychainKind::External),
-			Some(Bip84(xprv.clone(), bdk::KeychainKind::Internal)),
+			Bip84(xprv, bdk::KeychainKind::External),
+			Some(Bip84(xprv, bdk::KeychainKind::Internal)),
 			config.network,
 			&Secp256k1::new(),
 		)
 		.expect("Failed to derive on-chain wallet name");
 		let database = sled::open(bdk_data_dir).expect("Failed to open BDK database");
-		let database =
-			database.open_tree(wallet_name.clone()).expect("Failed to open BDK database");
+		let database = database.open_tree(wallet_name).expect("Failed to open BDK database");
 
 		let bdk_wallet = bdk::Wallet::new(
-			Bip84(xprv.clone(), bdk::KeychainKind::External),
-			Some(Bip84(xprv.clone(), bdk::KeychainKind::Internal)),
+			Bip84(xprv, bdk::KeychainKind::External),
+			Some(Bip84(xprv, bdk::KeychainKind::Internal)),
 			config.network,
 			database,
 		)
@@ -292,7 +293,7 @@ impl Builder {
 		let mut user_config = UserConfig::default();
 		user_config.channel_handshake_limits.force_announced_channel_preference = false;
 		let channel_manager = {
-			if let Ok(mut f) = fs::File::open(format!("{}/manager", ldk_data_dir.clone())) {
+			if let Ok(mut f) = fs::File::open(format!("{}/manager", ldk_data_dir)) {
 				let mut channel_monitor_mut_references = Vec::new();
 				for (_, channel_monitor) in channel_monitors.iter_mut() {
 					channel_monitor_mut_references.push(channel_monitor);
@@ -323,7 +324,7 @@ impl Builder {
 					network: config.network,
 					best_block: BestBlock::new(dummy_block_hash, 0),
 				};
-				let fresh_channel_manager = channelmanager::ChannelManager::new(
+				channelmanager::ChannelManager::new(
 					Arc::clone(&wallet),
 					Arc::clone(&chain_monitor),
 					Arc::clone(&wallet),
@@ -334,8 +335,7 @@ impl Builder {
 					Arc::clone(&keys_manager),
 					user_config,
 					chain_params,
-				);
-				fresh_channel_manager
+				)
 			}
 		};
 
@@ -387,7 +387,7 @@ impl Builder {
 
 		// Step 14: Restore event handler from disk or create a new one.
 		let event_queue = if let Ok(mut f) =
-			fs::File::open(format!("{}/{}", ldk_data_dir.clone(), event::EVENTS_PERSISTENCE_KEY))
+			fs::File::open(format!("{}/{}", ldk_data_dir, event::EVENTS_PERSISTENCE_KEY))
 		{
 			Arc::new(
 				EventQueue::read(&mut f, Arc::clone(&persister))
@@ -397,11 +397,9 @@ impl Builder {
 			Arc::new(EventQueue::new(Arc::clone(&persister)))
 		};
 
-		let peer_store = if let Ok(mut f) = fs::File::open(format!(
-			"{}/{}",
-			ldk_data_dir.clone(),
-			peer_store::PEER_INFO_PERSISTENCE_KEY
-		)) {
+		let peer_store = if let Ok(mut f) =
+			fs::File::open(format!("{}/{}", ldk_data_dir, peer_store::PEER_INFO_PERSISTENCE_KEY))
+		{
 			Arc::new(
 				PeerInfoStorage::read(&mut f, Arc::clone(&persister))
 					.expect("Failed to read peer information from disk."),
@@ -650,7 +648,7 @@ impl Node {
 						if peer_info.pubkey == node_id {
 							let _ = do_connect_peer(
 								peer_info.pubkey,
-								peer_info.address.clone(),
+								peer_info.address,
 								Arc::clone(&connect_pm),
 								Arc::clone(&connect_logger),
 							)
@@ -866,8 +864,8 @@ impl Node {
 			}
 		};
 
-		let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
-		let payment_secret = Some(invoice.payment_secret().clone());
+		let payment_hash = PaymentHash((*invoice.payment_hash()).into_inner());
+		let payment_secret = Some(*invoice.payment_secret());
 
 		let mut outbound_payments_lock = self.outbound_payments.lock().unwrap();
 		outbound_payments_lock.insert(
@@ -963,20 +961,20 @@ impl Node {
 			}
 		};
 
-		let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner());
+		let payment_hash = PaymentHash((*invoice.payment_hash()).into_inner());
 		inbound_payments_lock.insert(
 			payment_hash,
 			PaymentInfo {
 				preimage: None,
-				secret: Some(invoice.payment_secret().clone()),
+				secret: Some(*invoice.payment_secret()),
 				status: PaymentStatus::Pending,
 				amount_msat,
 			},
 		);
 		Ok(invoice)
 	}
 
-	///	Query for information about the status of a specific payment.
+	/// Query for information about the status of a specific payment.
 	pub fn payment_info(&self, payment_hash: &[u8; 32]) -> Option<PaymentInfo> {
 		let payment_hash = PaymentHash(*payment_hash);
 

src/peer_store.rs

@@ -42,7 +42,7 @@ impl<K: KVStorePersister> PeerInfoStorage<K> {
 			.persist(PEER_INFO_PERSISTENCE_KEY, &*locked_peers)
 			.map_err(|_| Error::PersistenceFailed)?;
 
-		return Ok(());
+		Ok(())
 	}
 
 	pub(crate) fn remove_peer(&self, peer_pubkey: &PublicKey) -> Result<(), Error> {
@@ -54,7 +54,7 @@ impl<K: KVStorePersister> PeerInfoStorage<K> {
 			.persist(PEER_INFO_PERSISTENCE_KEY, &*locked_peers)
 			.map_err(|_| Error::PersistenceFailed)?;
 
-		return Ok(());
+		Ok(())
 	}
 
 	pub(crate) fn peers(&self) -> Vec<PeerInfo> {
@@ -150,7 +150,7 @@ impl TryFrom<String> for PeerInfo {
 	type Error = Error;
 
 	fn try_from(peer_pubkey_and_ip_addr: String) -> Result<Self, Self::Error> {
-		let mut pubkey_and_addr = peer_pubkey_and_ip_addr.split("@");
+		let mut pubkey_and_addr = peer_pubkey_and_ip_addr.split('@');
 		let pubkey = pubkey_and_addr.next();
 		let peer_addr_str = pubkey_and_addr.next();
 		if pubkey.is_none() || peer_addr_str.is_none() {