Initial implementation of LdkLite

Author: tnull

.github/workflows/build.yml

@@ -25,3 +25,5 @@ jobs:
       - name: Check formatting
         if: matrix.check-fmt
         run: rustup component add rustfmt && cargo fmt --all -- --check
+      - name: Test on Rust ${{ matrix.toolchain }}
+        run: cargo test

Cargo.toml

@@ -8,16 +8,30 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-lightning = { version = "0.0.110", features = ["max_level_trace", "std"] }
-lightning-invoice = { version = "0.18" }
-lightning-net-tokio = { version = "0.0.110" }
-lightning-persister = { version = "0.0.110" }
-lightning-background-processor = { version = "0.0.110" }
-lightning-rapid-gossip-sync = { version = "0.0.110" }
-
-#bdk = "0.20.0"
-bdk = { git = "https://github.com/tnull/bdk", branch="feat/use-external-esplora-client", features = ["use-esplora-ureq", "key-value-db"]}
-bitcoin = "0.28.1"
+#lightning = { version = "0.0.112", features = ["max_level_trace", "std"] }
+#lightning-invoice = { version = "0.20" }
+#lightning-net-tokio = { version = "0.0.112" }
+#lightning-persister = { version = "0.0.112" }
+#lightning-background-processor = { version = "0.0.112" }
+#lightning-rapid-gossip-sync = { version = "0.0.112" }
+
+#lightning = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main", features = ["max_level_trace", "std"] }
+#lightning-invoice = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main" }
+#lightning-net-tokio = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main" }
+#lightning-persister = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main" }
+#lightning-background-processor = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main" }
+#lightning-rapid-gossip-sync = { git = "https://github.com/lightningdevkit/rust-lightning", branch="main" }
+
+lightning = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate", features = ["max_level_trace", "std"] }
+lightning-invoice = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate" }
+lightning-net-tokio = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate" }
+lightning-persister = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate" }
+lightning-background-processor = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate" }
+lightning-rapid-gossip-sync = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate" }
+lightning-transaction-sync = { git = "https://github.com/tnull/rust-lightning", branch="2022-11-add-transaction-sync-crate", features = ["esplora-async"] }
+
+bdk = { git = "https://github.com/tnull/bdk.git", branch="2022-10-use-esplora-merkleblock", features = ["use-esplora-async", "key-value-db"]}
+bitcoin = "0.29.2"
 
 rand = "0.8.5"
 chrono = "0.4"

src/error.rs

@@ -1,14 +1,8 @@
-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.
-pub enum LdkLiteError {
+pub enum Error {
 	/// Returned when trying to start LdkLite while it is already running.
 	AlreadyRunning,
 	/// Returned when trying to stop LdkLite while it is not running.
@@ -19,112 +13,67 @@ 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 transaction sync operation failed.
+	TxSyncFailed,
 }
 
-impl fmt::Display for LdkLiteError {
+impl fmt::Display for Error {
 	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::TxSyncFailed => write!(f, "Failed to sync transactions."),
 		}
 	}
 }
 
-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 std::error::Error for Error {}
 
-impl From<lightning_invoice::SignOrCreationError> for LdkLiteError {
-	fn from(e: lightning_invoice::SignOrCreationError) -> Self {
-		Self::LdkInvoiceCreation(e)
-	}
-}
-
-impl From<bdk::Error> for LdkLiteError {
+impl From<bdk::Error> for Error {
 	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)
+impl From<lightning_transaction_sync::TxSyncError> for Error {
+	fn from(e: lightning_transaction_sync::TxSyncError) -> Self {
+		match e {
+			_ => Self::TxSyncFailed,
+		}
 	}
 }

src/event.rs

@@ -317,7 +317,8 @@ where
 							log_error!(self.logger, "Channel went away before we could fund it. The peer disconnected or refused the channel");
 						}
 					}
-					Err(_err) => {
+					Err(err) => {
+						log_error!(self.logger, "Failed to create funding transaction: {}", err);
 						self.channel_manager
 							.force_close_without_broadcasting_txn(
 								&temporary_channel_id,

src/io_utils.rs

@@ -0,0 +1,66 @@
+use crate::{Config, Error, FilesystemLogger, NetworkGraph, Scorer};
+
+use lightning::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringParameters};
+use lightning::util::ser::ReadableArgs;
+
+use rand::{thread_rng, RngCore};
+
+use std::fs;
+use std::io::{BufReader, Write};
+use std::path::Path;
+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");
+		assert_eq!(seed.len(), 32);
+		let mut key = [0; 32];
+		key.copy_from_slice(&seed);
+		key
+	} else {
+		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");
+		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());
+
+	if let Ok(file) = fs::File::open(network_graph_path) {
+		if let Ok(graph) = NetworkGraph::read(&mut BufReader::new(file), Arc::clone(&logger)) {
+			return Ok(graph);
+		}
+	}
+
+	let genesis_hash =
+		bitcoin::blockdata::constants::genesis_block(config.network).header.block_hash();
+	Ok(NetworkGraph::new(genesis_hash, logger))
+}
+
+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 params = ProbabilisticScoringParameters::default();
+	if let Ok(file) = fs::File::open(scorer_path) {
+		let args = (params.clone(), Arc::clone(&network_graph), Arc::clone(&logger));
+		if let Ok(scorer) = ProbabilisticScorer::read(&mut BufReader::new(file), args) {
+			return scorer;
+		}
+	}
+	ProbabilisticScorer::new(params, network_graph, logger)
+}