diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 000000000..1a70ea03f --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,27 @@ +name: Continuous Integration Checks + +on: [push, pull_request] + +jobs: + build: + strategy: + matrix: + toolchain: [ stable, beta ] + include: + - toolchain: stable + check-fmt: true + runs-on: ubuntu-latest + steps: + - name: Checkout source code + uses: actions/checkout@v2 + - name: Install Rust ${{ matrix.toolchain }} toolchain + uses: actions-rs/toolchain@v1 + with: + toolchain: ${{ matrix.toolchain }} + override: true + profile: minimal + - name: Build on Rust ${{ matrix.toolchain }} + run: cargo build --verbose --color always + - name: Check formatting + if: matrix.check-fmt + run: rustup component add rustfmt && cargo fmt --all -- --check diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 000000000..f25cddc61 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,33 @@ +[package] +name = "ldk-lite" +version = "0.1.0" +authors = ["Elias Rohrer "] +license = "MIT OR Apache-2.0" +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", "keys-bip39"]} +bitcoin = "0.28.1" + +rand = "0.8.5" +chrono = "0.4" +futures = "0.3" +serde_json = { version = "1.0" } +tokio = { version = "1", features = [ "io-util", "macros", "rt", "rt-multi-thread", "sync", "net", "time" ] } + + +[profile.release] +panic = "abort" + +[profile.dev] +panic = "abort" diff --git a/LICENSE-APACHE b/LICENSE-APACHE new file mode 100644 index 000000000..261eeb9e9 --- /dev/null +++ b/LICENSE-APACHE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/LICENSE-MIT b/LICENSE-MIT new file mode 100644 index 000000000..9d982a4d6 --- /dev/null +++ b/LICENSE-MIT @@ -0,0 +1,16 @@ +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 000000000..c3f44cabd --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,14 @@ +This software is licensed under [Apache 2.0](LICENSE-APACHE) or +[MIT](LICENSE-MIT), at your option. + +Some files retain their own copyright notice, however, for full authorship +information, see version control history. + +Except as otherwise noted in individual files, all files in this repository are +licensed under the Apache License, Version 2.0 or the MIT license , at your option. + +You may not use, copy, modify, merge, publish, distribute, sublicense, and/or +sell copies of this software or any files in this repository except in +accordance with one or both of these licenses. diff --git a/rustfmt.toml b/rustfmt.toml new file mode 100644 index 000000000..c00f65546 --- /dev/null +++ b/rustfmt.toml @@ -0,0 +1,5 @@ +hard_tabs = true # use tab characters for indentation, spaces for alignment +use_field_init_shorthand = true +max_width = 100 +use_small_heuristics = "Max" +fn_args_layout = "Compressed" diff --git a/src/access.rs b/src/access.rs new file mode 100644 index 000000000..865aa656b --- /dev/null +++ b/src/access.rs @@ -0,0 +1,325 @@ +use crate::error::LdkLiteError as Error; +#[allow(unused_imports)] +use crate::logger::{ + log_error, log_given_level, log_info, log_internal, log_trace, log_warn, FilesystemLogger, + Logger, +}; + +use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator}; +use lightning::chain::WatchedOutput; +use lightning::chain::{Confirm, Filter}; + +use bdk::blockchain::{Blockchain, EsploraBlockchain, GetBlockHash, GetHeight, GetTx}; +use bdk::database::BatchDatabase; +use bdk::wallet::AddressIndex; +use bdk::{SignOptions, SyncOptions}; + +use bitcoin::{BlockHash, Script, Transaction, Txid}; + +use std::sync::{Arc, Mutex}; + +pub struct LdkLiteChainAccess +where + D: BatchDatabase, +{ + blockchain: EsploraBlockchain, + wallet: Mutex>, + queued_transactions: Mutex>, + watched_transactions: Mutex>, + queued_outputs: Mutex>, + watched_outputs: Mutex>, + last_sync_height: Mutex>, + logger: Arc, +} + +impl LdkLiteChainAccess +where + D: BatchDatabase, +{ + pub(crate) fn new( + blockchain: EsploraBlockchain, wallet: bdk::Wallet, logger: Arc, + ) -> Self { + let wallet = Mutex::new(wallet); + let watched_transactions = Mutex::new(Vec::new()); + let queued_transactions = Mutex::new(Vec::new()); + let watched_outputs = Mutex::new(Vec::new()); + let queued_outputs = Mutex::new(Vec::new()); + let last_sync_height = Mutex::new(None); + Self { + blockchain, + wallet, + queued_transactions, + watched_transactions, + queued_outputs, + watched_outputs, + last_sync_height, + logger, + } + } + + pub(crate) 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))?; + + Ok(()) + } + + pub(crate) fn sync(&self, confirmables: Vec<&(dyn Confirm + Sync)>) -> Result<(), Error> { + let client = &*self.blockchain; + + let cur_height = client.get_height()?; + + let mut locked_last_sync_height = self.last_sync_height.lock().unwrap(); + if cur_height >= locked_last_sync_height.unwrap_or(0) { + { + // First, inform the interface of the new block. + let cur_block_header = client.get_header(cur_height)?; + for c in &confirmables { + c.best_block_updated(&cur_block_header, cur_height); + } + + *locked_last_sync_height = Some(cur_height); + } + + { + // First, check the confirmation status of registered transactions as well as the + // status of dependent transactions of registered outputs. + let mut locked_queued_transactions = self.queued_transactions.lock().unwrap(); + let mut locked_queued_outputs = self.queued_outputs.lock().unwrap(); + let mut locked_watched_transactions = self.watched_transactions.lock().unwrap(); + let mut locked_watched_outputs = self.watched_outputs.lock().unwrap(); + + let mut confirmed_txs = Vec::new(); + + // Check in the current queue, as well as in registered transactions leftover from + // previous iterations. + let mut registered_txs: Vec = locked_watched_transactions + .iter() + .chain(locked_queued_transactions.iter()) + .cloned() + .collect(); + + registered_txs.sort_unstable_by(|txid1, txid2| txid1.cmp(&txid2)); + registered_txs.dedup_by(|txid1, txid2| txid1.eq(&txid2)); + + // Remember all registered but unconfirmed transactions for future processing. + let mut unconfirmed_registered_txs = Vec::new(); + + for txid in registered_txs { + if let Some(tx_status) = client.get_tx_status(&txid)? { + if tx_status.confirmed { + if let Some(tx) = client.get_tx(&txid)? { + if let Some(block_height) = tx_status.block_height { + let block_header = client.get_header(block_height)?; + if let Some(merkle_proof) = client.get_merkle_proof(&txid)? { + confirmed_txs.push(( + tx, + block_height, + block_header, + merkle_proof.pos, + )); + continue; + } + } + } + } + } + unconfirmed_registered_txs.push(txid); + } + + // Check all registered outputs for dependent spending transactions. + let registered_outputs: Vec = locked_watched_outputs + .iter() + .chain(locked_queued_outputs.iter()) + .cloned() + .collect(); + + // Remember all registered outputs that haven't been spent for future processing. + let mut unspent_registered_outputs = Vec::new(); + + for output in registered_outputs { + if let Some(output_status) = client + .get_output_status(&output.outpoint.txid, output.outpoint.index as u64)? + { + if output_status.spent { + if let Some(spending_tx_status) = output_status.status { + if spending_tx_status.confirmed { + let spending_txid = output_status.txid.unwrap(); + if let Some(spending_tx) = client.get_tx(&spending_txid)? { + let block_height = spending_tx_status.block_height.unwrap(); + let block_header = client.get_header(block_height)?; + if let Some(merkle_proof) = + client.get_merkle_proof(&spending_txid)? + { + confirmed_txs.push(( + spending_tx, + block_height, + block_header, + merkle_proof.pos, + )); + continue; + } + } + } + } + } + } + unspent_registered_outputs.push(output); + } + + // Sort all confirmed transactions by block height and feed them to the interface + // in order. + confirmed_txs.sort_unstable_by( + |(_, block_height1, _, _), (_, block_height2, _, _)| { + block_height1.cmp(&block_height2) + }, + ); + for (tx, block_height, block_header, pos) in confirmed_txs { + for c in &confirmables { + c.transactions_confirmed(&block_header, &[(pos, &tx)], block_height); + } + } + + *locked_watched_transactions = unconfirmed_registered_txs; + *locked_queued_transactions = Vec::new(); + *locked_watched_outputs = unspent_registered_outputs; + *locked_queued_outputs = Vec::new(); + } + + { + // Query the interface for relevant txids and check whether they have been + // reorged-out of the chain. + let unconfirmed_txids = confirmables + .iter() + .flat_map(|c| c.get_relevant_txids()) + .filter(|txid| { + client + .get_tx_status(txid) + .ok() + .unwrap_or(None) + .map_or(true, |status| !status.confirmed) + }) + .collect::>(); + + // Mark all relevant unconfirmed transactions as unconfirmed. + for txid in &unconfirmed_txids { + for c in &confirmables { + c.transaction_unconfirmed(txid); + } + } + } + } + + // TODO: check whether new outputs have been registered by now and process them + Ok(()) + } + + pub(crate) fn create_funding_transaction( + &self, output_script: &Script, value_sats: u64, confirmation_target: ConfirmationTarget, + ) -> Result { + let num_blocks = num_blocks_from_conf_target(confirmation_target); + let fee_rate = self.blockchain.estimate_fee(num_blocks)?; + + let locked_wallet = self.wallet.lock().unwrap(); + let mut tx_builder = locked_wallet.build_tx(); + + tx_builder.add_recipient(output_script.clone(), value_sats).fee_rate(fee_rate).enable_rbf(); + + let (mut psbt, _) = tx_builder.finish()?; + log_trace!(self.logger, "Created funding PSBT: {:?}", psbt); + + // We double-check that no inputs try to spend non-witness outputs. As we use a SegWit + // wallet descriptor this technically shouldn't ever happen, but better safe than sorry. + for input in &psbt.inputs { + if input.witness_utxo.is_none() { + return Err(Error::FundingTxNonWitnessOuputSpend); + } + } + + let finalized = locked_wallet.sign(&mut psbt, SignOptions::default())?; + if !finalized { + return Err(Error::FundingTxNotFinalized); + } + + Ok(psbt.extract_tx()) + } + + pub(crate) fn get_new_address(&self) -> Result { + let address_info = self.wallet.lock().unwrap().get_address(AddressIndex::New)?; + Ok(address_info.address) + } +} + +impl FeeEstimator for LdkLiteChainAccess +where + D: BatchDatabase, +{ + fn get_est_sat_per_1000_weight(&self, confirmation_target: ConfirmationTarget) -> u32 { + let num_blocks = num_blocks_from_conf_target(confirmation_target); + self.blockchain.estimate_fee(num_blocks).map_or(253, |fee_rate| fee_rate.fee_wu(1000)) + as u32 + } +} + +impl BroadcasterInterface for LdkLiteChainAccess +where + D: BatchDatabase, +{ + fn broadcast_transaction(&self, tx: &Transaction) { + self.blockchain.broadcast(tx).ok(); + } +} + +impl Filter for LdkLiteChainAccess +where + D: BatchDatabase, +{ + fn register_tx(&self, txid: &Txid, _script_pubkey: &Script) { + self.queued_transactions.lock().unwrap().push(*txid); + } + + fn register_output(&self, output: WatchedOutput) -> Option<(usize, Transaction)> { + self.queued_outputs.lock().unwrap().push(output); + return None; + } +} + +impl GetHeight for LdkLiteChainAccess +where + D: BatchDatabase, +{ + fn get_height(&self) -> Result { + self.blockchain.get_height() + } +} + +impl GetBlockHash for LdkLiteChainAccess +where + D: BatchDatabase, +{ + fn get_block_hash(&self, height: u64) -> Result { + self.blockchain.get_block_hash(height) + } +} + +impl GetTx for LdkLiteChainAccess +where + D: BatchDatabase, +{ + fn get_tx(&self, txid: &Txid) -> Result, bdk::Error> { + self.blockchain.get_tx(txid) + } +} + +fn num_blocks_from_conf_target(confirmation_target: ConfirmationTarget) -> usize { + match confirmation_target { + ConfirmationTarget::Background => 6, + ConfirmationTarget::Normal => 3, + ConfirmationTarget::HighPriority => 1, + } +} diff --git a/src/error.rs b/src/error.rs new file mode 100644 index 000000000..4dfd13722 --- /dev/null +++ b/src/error.rs @@ -0,0 +1,128 @@ +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 { + /// Returned when trying to start LdkLite while it is already running. + AlreadyRunning, + /// Returned when trying to stop LdkLite while it is not running. + NotRunning, + /// An input of the funding transaction tried spending a non-SegWit output. This should never happen, but + /// better safe than sorry.. + FundingTxNonWitnessOuputSpend, + /// The funding transaction could not be finalized. + FundingTxNotFinalized, + /// A network connection has been closed. + ConnectionFailed, + /// Payment of the given invoice has already been intiated. + NonUniquePaymentHash, + /// 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), +} + +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::FundingTxNonWitnessOuputSpend => write!(f, "an input of the funding transaction tried spending a non-SegWit output, which is insecure"), + LdkLiteError::FundingTxNotFinalized => write!(f, "the funding transaction could not be finalized"), + 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), + } + } +} + +impl From for LdkLiteError { + fn from(e: errors::APIError) -> Self { + Self::LdkApi(e) + } +} + +impl From for LdkLiteError { + fn from(e: msgs::DecodeError) -> Self { + Self::LdkDecode(e) + } +} + +impl From for LdkLiteError { + fn from(e: payment::PaymentError) -> Self { + Self::LdkPayment(e) + } +} + +impl From for LdkLiteError { + fn from(e: lightning_invoice::SignOrCreationError) -> Self { + Self::LdkInvoiceCreation(e) + } +} + +impl From for LdkLiteError { + fn from(e: bdk::Error) -> Self { + Self::Bdk(e) + } +} + +impl From for LdkLiteError { + fn from(e: bdk::sled::Error) -> Self { + Self::Bdk(bdk::Error::Sled(e)) + } +} + +impl From for LdkLiteError { + fn from(e: bitcoin::util::bip32::Error) -> Self { + Self::Bip32(e) + } +} + +impl From for LdkLiteError { + fn from(e: io::Error) -> Self { + Self::StdIo(e) + } +} + +impl From for LdkLiteError { + fn from(e: time::SystemTimeError) -> Self { + Self::StdTime(e) + } +} + +impl From for LdkLiteError { + fn from(e: esplora::EsploraError) -> Self { + Self::Esplora(e) + } +} diff --git a/src/event.rs b/src/event.rs new file mode 100644 index 000000000..b2f782786 --- /dev/null +++ b/src/event.rs @@ -0,0 +1,528 @@ +use crate::{ + hex, ChannelManager, Error, FilesystemPersister, LdkLiteChainAccess, LdkLiteConfig, + NetworkGraph, PaymentInfo, PaymentInfoStorage, PaymentStatus, +}; + +#[allow(unused_imports)] +use crate::logger::{ + log_error, log_given_level, log_info, log_internal, log_trace, log_warn, FilesystemLogger, + Logger, +}; + +use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator}; +use lightning::chain::keysinterface::KeysManager; +use lightning::ln::PaymentHash; +use lightning::routing::gossip::NodeId; +use lightning::util::events as ldk_events; +use lightning::util::persist::KVStorePersister; +use lightning::util::ser::{MaybeReadable, Readable, ReadableArgs, Writeable, Writer}; + +use bitcoin::secp256k1::Secp256k1; +use rand::{thread_rng, Rng}; +use std::collections::{hash_map, VecDeque}; +use std::sync::{Arc, Condvar, Mutex}; +use std::thread; +use std::time::Duration; + +/// The event queue will be persisted under this key. +pub(crate) const EVENTS_PERSISTENCE_KEY: &str = "events"; + +/// An event emitted by [`LdkLite`] that should be handled by the user. This will more often than +/// not wrap a LDK event accessible via the `inner` field. +#[derive(Debug, Clone)] +pub enum LdkLiteEvent { + /// A payment we sent was successful. + PaymentSuccessful { + /// The hash of the payment. + payment_hash: PaymentHash, + /// The wrapped LDK event. + inner: ldk_events::Event, + }, + /// A payment we sent has failed. + PaymentFailed { + /// The hash of the payment. + payment_hash: PaymentHash, + /// The wrapped LDK event. + inner: ldk_events::Event, + }, + /// A payment has been received. + PaymentReceived { + /// The hash of the payment. + payment_hash: PaymentHash, + /// The value, in thousandths of a satoshi that has been received. + amount_msat: u64, + /// The wrapped LDK event. + inner: ldk_events::Event, + }, + // TODO: Implement after a corresponding LDK event is added. + //ChannelOpened { + //}, + /// A channel has been closed. + ChannelClosed { + /// The channel_id of the channel which has been closed. + channel_id: [u8; 32], + /// The wrapped LDK event. + inner: ldk_events::Event, + }, + // TODO: Implement on-chain events when better integrating with BDK wallet sync. + //OnChainPaymentSent { + //}, + //OnChainPaymentReceived { + //} +} + +impl Readable for LdkLiteEvent { + fn read( + reader: &mut R, + ) -> Result { + match Readable::read(reader)? { + 0u8 => { + let payment_hash: PaymentHash = Readable::read(reader)?; + let inner: ldk_events::Event = MaybeReadable::read(reader)?.unwrap(); + Ok(Self::PaymentSuccessful { payment_hash, inner }) + } + 1u8 => { + let payment_hash: PaymentHash = Readable::read(reader)?; + let inner: ldk_events::Event = MaybeReadable::read(reader)?.unwrap(); + Ok(Self::PaymentFailed { payment_hash, inner }) + } + 2u8 => { + let payment_hash: PaymentHash = Readable::read(reader)?; + let amount_msat: u64 = Readable::read(reader)?; + let inner: ldk_events::Event = MaybeReadable::read(reader)?.unwrap(); + Ok(Self::PaymentReceived { payment_hash, amount_msat, inner }) + } + //3u8 => { + // TODO ChannelOpened + //} + 4u8 => { + let channel_id: [u8; 32] = Readable::read(reader)?; + let inner: ldk_events::Event = MaybeReadable::read(reader)?.unwrap(); + Ok(Self::ChannelClosed { channel_id, inner }) + } + //5u8 => { + // TODO OnChainPaymentSent + //} + //6u8 => { + // TODO OnChainPaymentReceived + //} + _ => Err(lightning::ln::msgs::DecodeError::InvalidValue), + } + } +} + +impl Writeable for LdkLiteEvent { + fn write(&self, writer: &mut W) -> Result<(), lightning::io::Error> { + match self { + Self::PaymentSuccessful { payment_hash, inner } => { + 0u8.write(writer)?; + payment_hash.write(writer)?; + inner.write(writer)?; + Ok(()) + } + Self::PaymentFailed { payment_hash, inner } => { + 1u8.write(writer)?; + payment_hash.write(writer)?; + inner.write(writer)?; + Ok(()) + } + Self::PaymentReceived { payment_hash, amount_msat, inner } => { + 2u8.write(writer)?; + payment_hash.write(writer)?; + amount_msat.write(writer)?; + inner.write(writer)?; + Ok(()) + } + //Self::ChannelOpened { .. } => { + //TODO + //} + Self::ChannelClosed { channel_id, inner } => { + 4u8.write(writer)?; + channel_id.write(writer)?; + inner.write(writer)?; + Ok(()) + } //Self::OnChainPaymentSent { .. } => { + //TODO + //} + //Self::OnChainPaymentReceived { .. } => { + //TODO + //} + } + } +} + +pub(crate) struct LdkLiteEventQueue { + queue: Mutex, + notifier: Condvar, + persister: Arc, +} + +impl LdkLiteEventQueue { + pub(crate) fn new(persister: Arc) -> Self { + let queue: Mutex = Mutex::new(EventQueueSerWrapper(VecDeque::new())); + let notifier = Condvar::new(); + Self { queue, notifier, persister } + } + pub(crate) fn add_event(&self, event: LdkLiteEvent) -> Result<(), Error> { + let mut locked_queue = self.queue.lock().unwrap(); + locked_queue.0.push_back(event); + + self.persister.persist(EVENTS_PERSISTENCE_KEY, &*locked_queue)?; + + self.notifier.notify_one(); + Ok(()) + } + + pub(crate) fn next_event(&self) -> LdkLiteEvent { + let locked_queue = self + .notifier + .wait_while(self.queue.lock().unwrap(), |queue| queue.0.is_empty()) + .unwrap(); + locked_queue.0.front().unwrap().clone() + } + + 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.notifier.notify_one(); + Ok(()) + } +} + +impl ReadableArgs> for LdkLiteEventQueue { + #[inline] + fn read( + reader: &mut R, persister: Arc, + ) -> Result { + let queue: Mutex = Mutex::new(Readable::read(reader)?); + let notifier = Condvar::new(); + Ok(Self { queue, notifier, persister }) + } +} + +struct EventQueueSerWrapper(VecDeque); + +impl Readable for EventQueueSerWrapper { + fn read( + reader: &mut R, + ) -> Result { + let len: u16 = Readable::read(reader)?; + let mut queue = VecDeque::with_capacity(len as usize); + for _ in 0..len { + queue.push_back(Readable::read(reader)?); + } + Ok(EventQueueSerWrapper(queue)) + } +} + +impl Writeable for EventQueueSerWrapper { + fn write(&self, writer: &mut W) -> Result<(), lightning::io::Error> { + (self.0.len() as u16).write(writer)?; + for e in self.0.iter() { + e.write(writer)?; + } + Ok(()) + } +} + +pub(crate) struct LdkLiteEventHandler { + chain_access: Arc>, + event_queue: Arc>, + channel_manager: Arc, + network_graph: Arc, + keys_manager: Arc, + inbound_payments: Arc, + outbound_payments: Arc, + logger: Arc, + _config: Arc, +} + +impl LdkLiteEventHandler { + pub fn new( + chain_access: Arc>, + event_queue: Arc>, + channel_manager: Arc, network_graph: Arc, + keys_manager: Arc, inbound_payments: Arc, + outbound_payments: Arc, logger: Arc, + _config: Arc, + ) -> Self { + Self { + event_queue, + chain_access, + channel_manager, + network_graph, + keys_manager, + inbound_payments, + outbound_payments, + logger, + _config, + } + } +} + +impl ldk_events::EventHandler for LdkLiteEventHandler { + fn handle_event(&self, event: &ldk_events::Event) { + match event { + ldk_events::Event::FundingGenerationReady { + temporary_channel_id, + counterparty_node_id, + channel_value_satoshis, + output_script, + .. + } => { + // Construct the raw transaction with one output, that is paid the amount of the + // channel. + let confirmation_target = ConfirmationTarget::Normal; + + // Sign the final funding transaction and broadcast it. + match self.chain_access.create_funding_transaction( + &output_script, + *channel_value_satoshis, + confirmation_target, + ) { + Ok(final_tx) => { + // Give the funding transaction back to LDK for opening the channel. + if self + .channel_manager + .funding_transaction_generated( + &temporary_channel_id, + counterparty_node_id, + final_tx, + ) + .is_err() + { + log_error!(self.logger, "Channel went away before we could fund it. The peer disconnected or refused the channel"); + } + } + Err(err) => { + log_error!(self.logger, "Failed to create funding transaction: {}", err); + } + } + } + ldk_events::Event::PaymentReceived { payment_hash, purpose, amount_msat } => { + log_info!( + self.logger, + "Received payment from payment hash {} of {} millisatoshis", + hex::to_string(&payment_hash.0), + amount_msat, + ); + let payment_preimage = match purpose { + ldk_events::PaymentPurpose::InvoicePayment { payment_preimage, .. } => { + *payment_preimage + } + ldk_events::PaymentPurpose::SpontaneousPayment(preimage) => Some(*preimage), + }; + self.channel_manager.claim_funds(payment_preimage.unwrap()); + self.event_queue + .add_event(LdkLiteEvent::PaymentReceived { + payment_hash: *payment_hash, + amount_msat: *amount_msat, + inner: event.clone(), + }) + .unwrap(); + } + ldk_events::Event::PaymentClaimed { payment_hash, purpose, amount_msat } => { + log_info!( + self.logger, + "Claimed payment from payment hash {} of {} millisatoshis", + hex::to_string(&payment_hash.0), + amount_msat, + ); + let (payment_preimage, payment_secret) = match purpose { + ldk_events::PaymentPurpose::InvoicePayment { + payment_preimage, + payment_secret, + .. + } => (*payment_preimage, Some(*payment_secret)), + ldk_events::PaymentPurpose::SpontaneousPayment(preimage) => { + (Some(*preimage), None) + } + }; + let mut payments = self.inbound_payments.lock().unwrap(); + match payments.entry(*payment_hash) { + hash_map::Entry::Occupied(mut e) => { + let payment = e.get_mut(); + payment.status = PaymentStatus::Succeeded; + payment.preimage = payment_preimage; + payment.secret = payment_secret; + } + hash_map::Entry::Vacant(e) => { + e.insert(PaymentInfo { + preimage: payment_preimage, + secret: payment_secret, + status: PaymentStatus::Succeeded, + amount_msat: Some(*amount_msat), + }); + } + } + } + ldk_events::Event::PaymentSent { + payment_preimage, + payment_hash, + fee_paid_msat, + .. + } => { + let mut payments = self.outbound_payments.lock().unwrap(); + for (hash, payment) in payments.iter_mut() { + if *hash == *payment_hash { + payment.preimage = Some(*payment_preimage); + payment.status = PaymentStatus::Succeeded; + log_info!( + self.logger, + "Successfully sent payment of {} millisatoshis{} from \ + payment hash {:?} with preimage {:?}", + payment.amount_msat.unwrap(), + if let Some(fee) = fee_paid_msat { + format!(" (fee {} msat)", fee) + } else { + "".to_string() + }, + hex::to_string(&payment_hash.0), + hex::to_string(&payment_preimage.0) + ); + } + } + self.event_queue + .add_event(LdkLiteEvent::PaymentSuccessful { + payment_hash: *payment_hash, + inner: event.clone(), + }) + .unwrap(); + } + ldk_events::Event::PaymentFailed { payment_hash, .. } => { + log_info!( + self.logger, + "Failed to send payment to payment hash {:?}: exhausted payment retry attempts", + hex::to_string(&payment_hash.0) + ); + + let mut payments = self.outbound_payments.lock().unwrap(); + if payments.contains_key(&payment_hash) { + let payment = payments.get_mut(&payment_hash).unwrap(); + payment.status = PaymentStatus::Failed; + } + self.event_queue + .add_event(LdkLiteEvent::PaymentFailed { + payment_hash: *payment_hash, + inner: event.clone(), + }) + .unwrap(); + } + + ldk_events::Event::PaymentPathSuccessful { .. } => {} + ldk_events::Event::PaymentPathFailed { .. } => {} + ldk_events::Event::ProbeSuccessful { .. } => {} + ldk_events::Event::ProbeFailed { .. } => {} + ldk_events::Event::HTLCHandlingFailed { .. } => {} + ldk_events::Event::PendingHTLCsForwardable { time_forwardable } => { + let forwarding_channel_manager = self.channel_manager.clone(); + let min = time_forwardable.as_millis() as u64; + + // TODO: any way we still can use tokio here? + // TODO: stop this thread on shutdown + thread::spawn(move || { + let millis_to_sleep = thread_rng().gen_range(min..min * 5) as u64; + thread::sleep(Duration::from_millis(millis_to_sleep)); + forwarding_channel_manager.process_pending_htlc_forwards(); + }); + } + ldk_events::Event::SpendableOutputs { outputs } => { + let destination_address = self.chain_access.get_new_address().unwrap(); + let output_descriptors = &outputs.iter().map(|a| a).collect::>(); + let tx_feerate = + self.chain_access.get_est_sat_per_1000_weight(ConfirmationTarget::Normal); + let spending_tx = self + .keys_manager + .spend_spendable_outputs( + output_descriptors, + Vec::new(), + destination_address.script_pubkey(), + tx_feerate, + &Secp256k1::new(), + ) + .unwrap(); + self.chain_access.broadcast_transaction(&spending_tx); + } + ldk_events::Event::OpenChannelRequest { .. } => {} + ldk_events::Event::PaymentForwarded { + prev_channel_id, + next_channel_id, + fee_earned_msat, + claim_from_onchain_tx, + } => { + let read_only_network_graph = self.network_graph.read_only(); + let nodes = read_only_network_graph.nodes(); + let channels = self.channel_manager.list_channels(); + + let node_str = |channel_id: &Option<[u8; 32]>| match channel_id { + None => String::new(), + Some(channel_id) => match channels.iter().find(|c| c.channel_id == *channel_id) + { + None => String::new(), + Some(channel) => { + match nodes.get(&NodeId::from_pubkey(&channel.counterparty.node_id)) { + None => "private node".to_string(), + Some(node) => match &node.announcement_info { + None => "unnamed node".to_string(), + Some(announcement) => { + format!("node {}", announcement.alias) + } + }, + } + } + }, + }; + let channel_str = |channel_id: &Option<[u8; 32]>| { + channel_id + .map(|channel_id| format!(" with channel {}", hex::to_string(&channel_id))) + .unwrap_or_default() + }; + let from_prev_str = + format!(" from {}{}", node_str(prev_channel_id), channel_str(prev_channel_id)); + let to_next_str = + format!(" to {}{}", node_str(next_channel_id), channel_str(next_channel_id)); + + let from_onchain_str = if *claim_from_onchain_tx { + "from onchain downstream claim" + } else { + "from HTLC fulfill message" + }; + if let Some(fee_earned) = fee_earned_msat { + log_info!( + self.logger, + "Forwarded payment{}{}, earning {} msat {}", + from_prev_str, + to_next_str, + fee_earned, + from_onchain_str + ); + } else { + log_info!( + self.logger, + "Forwarded payment{}{}, claiming onchain {}", + from_prev_str, + to_next_str, + from_onchain_str + ); + } + } + + ldk_events::Event::ChannelClosed { channel_id, reason, user_channel_id: _ } => { + log_info!( + self.logger, + "Channel {} closed due to: {:?}", + hex::to_string(channel_id), + reason + ); + self.event_queue + .add_event(LdkLiteEvent::ChannelClosed { + channel_id: *channel_id, + inner: event.clone(), + }) + .unwrap(); + } + ldk_events::Event::DiscardFunding { .. } => {} + } + } +} diff --git a/src/hex.rs b/src/hex.rs new file mode 100644 index 000000000..f1ca00c35 --- /dev/null +++ b/src/hex.rs @@ -0,0 +1,45 @@ +use bitcoin::secp256k1::PublicKey; + +pub fn to_vec(hex: &str) -> Option> { + let mut out = Vec::with_capacity(hex.len() / 2); + + let mut b = 0; + for (idx, c) in hex.as_bytes().iter().enumerate() { + b <<= 4; + match *c { + b'A'..=b'F' => b |= c - b'A' + 10, + b'a'..=b'f' => b |= c - b'a' + 10, + b'0'..=b'9' => b |= c - b'0', + _ => return None, + } + if (idx & 1) == 1 { + out.push(b); + b = 0; + } + } + + Some(out) +} + +#[inline] +pub fn to_string(value: &[u8]) -> String { + let mut res = String::with_capacity(64); + for v in value { + res += &format!("{:02x}", v); + } + res +} + +pub fn to_compressed_pubkey(hex: &str) -> Option { + if hex.len() != 33 * 2 { + return None; + } + let data = match to_vec(&hex[0..33 * 2]) { + Some(bytes) => bytes, + None => return None, + }; + match PublicKey::from_slice(&data) { + Ok(pk) => Some(pk), + Err(_) => None, + } +} diff --git a/src/io.rs b/src/io.rs new file mode 100644 index 000000000..f5a7004ce --- /dev/null +++ b/src/io.rs @@ -0,0 +1,69 @@ +use crate::error::LdkLiteError as Error; + +use crate::{FilesystemLogger, LdkLiteConfig, NetworkGraph, PeerInfo, Scorer}; + +use lightning::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringParameters}; +use lightning::util::ser::ReadableArgs; + +use bitcoin::secp256k1::PublicKey; + +use rand::{thread_rng, RngCore}; + +use std::collections::HashMap; +use std::convert::TryFrom; +use std::fs; +use std::io::{BufRead, BufReader, Write}; +use std::net::SocketAddr; +use std::sync::Arc; + +pub(crate) fn read_or_generate_seed_file(seed_path: String) -> Result<[u8; 64], Error> { + let keys_seed = if let Ok(seed) = fs::read(seed_path.clone()) { + assert_eq!(seed.len(), 64); + let mut key = [0; 64]; + key.copy_from_slice(&seed); + key + } else { + let mut key = [0; 64]; + thread_rng().fill_bytes(&mut key); + + let mut f = fs::File::create(seed_path.clone()).map_err(|e| Error::StdIo(e))?; + 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) +} + +pub(crate) fn read_network_graph( + config: Arc, logger: Arc, +) -> Result { + 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, network_graph: Arc, logger: Arc, +) -> 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) +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 000000000..0572f8e6d --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,1034 @@ +// This file is Copyright its original authors, visible in version contror +// history. +// +// This file is licensed under the Apache License, Version 2.0 or the MIT license +// , at your option. +// You may not use this file except in accordance with one or both of these +// licenses. + +#![crate_name = "ldk_lite"] + +//! A library providing a simplified API for the Lightning Dev Kit. While LDK itself provides a +//! highly configurable and adaptable interface, this API champions simplicity and ease of use over +//! configurability. To this end, it provides an opionated set of design choices and ready-to-go +//! default modules, while still enabling some configurability when dearly needed by the user: +//! - Chain data is accessed through an Esplora client. +//! - Wallet and channel states are persisted to disk. +//! - Gossip is retrieved over the P2P network. + +#![deny(missing_docs)] +#![deny(broken_intra_doc_links)] +#![deny(private_intra_doc_links)] +#![allow(bare_trait_objects)] +#![allow(ellipsis_inclusive_range_patterns)] +#![cfg_attr(docsrs, feature(doc_auto_cfg))] + +mod access; +mod error; +mod event; +mod hex; +mod io; +mod logger; +mod peer_store; + +use access::LdkLiteChainAccess; +pub use error::LdkLiteError as Error; +pub use event::LdkLiteEvent; +use event::{LdkLiteEventHandler, LdkLiteEventQueue}; +use peer_store::{PeerInfo, PeerInfoStorage}; + +#[allow(unused_imports)] +use logger::{ + log_error, log_given_level, log_info, log_internal, log_trace, log_warn, FilesystemLogger, + Logger, +}; + +use lightning::chain::keysinterface::{InMemorySigner, KeysInterface, KeysManager, Recipient}; +use lightning::chain::{chainmonitor, Access, BestBlock, Confirm, Filter, Watch}; +use lightning::ln::channelmanager; +use lightning::ln::channelmanager::{ + ChainParameters, ChannelManagerReadArgs, SimpleArcChannelManager, +}; +use lightning::ln::peer_handler::{IgnoringMessageHandler, MessageHandler, SimpleArcPeerManager}; +use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret}; +use lightning::routing::gossip; +use lightning::routing::gossip::P2PGossipSync; +use lightning::routing::scoring::ProbabilisticScorer; + +use lightning::util::config::{ChannelHandshakeConfig, ChannelHandshakeLimits, UserConfig}; +use lightning::util::ser::ReadableArgs; + +use lightning_background_processor::BackgroundProcessor; +use lightning_background_processor::GossipSync as BPGossipSync; +use lightning_persister::FilesystemPersister; + +use lightning_net_tokio::SocketDescriptor; + +use lightning_invoice::utils::DefaultRouter; +use lightning_invoice::{payment, Currency, Invoice}; + +use bdk::bitcoin::secp256k1::Secp256k1; +use bdk::blockchain::esplora::EsploraBlockchain; +use bdk::blockchain::{GetBlockHash, GetHeight}; +use bdk::sled; +use bdk::template::Bip84; +use bdk::keys::bip39; + +use bitcoin::hashes::sha256::Hash as Sha256; +use bitcoin::hashes::Hash; +use bitcoin::secp256k1::PublicKey; +use bitcoin::BlockHash; + +use rand::Rng; + +use std::collections::HashMap; +use std::convert::TryFrom; +use std::fs; +use std::net::SocketAddr; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::{Arc, Mutex, RwLock}; +use std::time::{Duration, Instant, SystemTime}; + +// The used 'stop gap' parameter used by BDK's wallet sync. This seems to configure the threshold +// number of blocks after which BDK stops looking for scripts belonging to the wallet. +const BDK_CLIENT_STOP_GAP: usize = 20; + +// The number of concurrent requests made against the API provider. +const BDK_CLIENT_CONCURRENCY: u8 = 8; + +// The timeout after which we abandon retrying failed payments. +const LDK_PAYMENT_RETRY_TIMEOUT: Duration = Duration::from_secs(10); + +#[derive(Debug, Clone)] +/// Represents the configuration of an [`LdkLite`] instance. +pub struct LdkLiteConfig { + /// The path where the underlying LDK and BDK persist their data. + pub storage_dir_path: String, + /// The URL of the utilized Esplora server. + pub esplora_server_url: String, + /// The used Bitcoin network. + pub network: bitcoin::Network, + /// The TCP port the network node will listen on. + pub listening_port: u16, + /// The default CLTV expiry delta to be used for payments. + pub default_cltv_expiry_delta: u32, +} + +#[derive(Debug, Clone)] +enum LdkLiteWalletEntropy { + SeedFile(String), + SeedBytes([u8; 64]), + Bip39Mnemonic(bip39::Mnemonic), +} + +/// A builder for an [`LdkLite`] instance, allowing to set some configuration and module choices from +/// the getgo. +#[derive(Debug, Clone)] +pub struct LdkLiteBuilder { + config: LdkLiteConfig, + wallet_entropy: LdkLiteWalletEntropy, +} + +impl LdkLiteBuilder { + /// Creates a new builder instance with the default configuration. + pub fn new() -> Self { + // Set the config defaults + let storage_dir_path = "/tmp/ldk_lite/".to_string(); + let seed_path = format!("{}/keys_seed", storage_dir_path); + let wallet_entropy = LdkLiteWalletEntropy::SeedFile(seed_path); + let esplora_server_url = "https://blockstream.info/api".to_string(); + let network = bitcoin::Network::Testnet; + let listening_port = 9735; + let default_cltv_expiry_delta = 144; + + let config = LdkLiteConfig { + storage_dir_path, + esplora_server_url, + network, + listening_port, + default_cltv_expiry_delta, + }; + + Self { config, wallet_entropy } + } + + /// Creates a new builder instance from an [`LdkLiteConfig`]. + pub fn from_config(config: LdkLiteConfig) -> Self { + let seed_path = format!("{}/keys_seed", config.storage_dir_path); + let wallet_entropy = LdkLiteWalletEntropy::SeedFile(seed_path); + Self { config, wallet_entropy } + } + + /// Configures [`LdkLite`] to source its wallet entropy from a seed file on disk. + pub fn set_entropy_seed_path(&mut self, seed_path: String) -> &mut Self { + self.wallet_entropy = LdkLiteWalletEntropy::SeedFile(seed_path); + self + } + + /// Configures [`LdkLite`] to source its wallet entropy from a [`Bip39`] mnemonic code. + pub fn set_entropy_bip39_mnemonic(&mut self, mnemonic_str: String) -> &mut Self { + let mnemonic = bip39::Mnemonic::from_str(mnemonic_str).unwrap(); + self.wallet_entropy = LdkLiteWalletEntropy::Bip39Mnemonic(mnemonic); + self + } + + /// Configures [`LdkLite`] to source its wallet entropy from the given seed bytes. + pub fn set_entropy_seed_bytes(&mut self, seed_bytes: [u8; 64]) -> &mut Self { + self.wallet_entropy = LdkLiteWalletEntropy::SeedBytes(seed_bytes); + self + } + + /// Sets the used storage directory path. + /// + /// Default: `/tmp/ldk_lite/` + pub fn set_storage_dir_path(&mut self, storage_dir_path: String) -> &mut Self { + self.config.storage_dir_path = storage_dir_path; + self + } + + /// 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 + } + + /// Sets the Bitcoin network used. + /// + /// Options: `mainnet`/`bitcoin`, `testnet`, `regtest`, `signet` + /// + /// Default: `testnet` + pub fn set_network(&mut self, network: &str) -> &mut Self { + self.config.network = match network { + "mainnet" => bitcoin::Network::Bitcoin, + "bitcoin" => bitcoin::Network::Bitcoin, + "testnet" => bitcoin::Network::Testnet, + "regtest" => bitcoin::Network::Regtest, + "signet" => bitcoin::Network::Signet, + _ => bitcoin::Network::Testnet, + }; + self + } + + /// Sets the port on which [`LdkLite`] will listen for incoming network connections. + /// + /// Default: `9735` + pub fn set_listening_port(&mut self, listening_port: u16) -> &mut Self { + self.config.listening_port = listening_port; + self + } + + /// Builds an [`LdkLite`] instance according to the options previously configured. + pub fn build(&self) -> Result { + let config = Arc::new(self.config.clone()); + + let ldk_data_dir = format!("{}/ldk", &config.storage_dir_path.clone()); + fs::create_dir_all(ldk_data_dir.clone())?; + + let bdk_data_dir = format!("{}/bdk", config.storage_dir_path.clone()); + fs::create_dir_all(bdk_data_dir.clone())?; + + // Step 0: Initialize the Logger + let log_file_path = format!("{}/ldk_lite.log", config.storage_dir_path.clone()); + let logger = Arc::new(FilesystemLogger::new(log_file_path)); + + // Step 1: Initialize the on-chain wallet and chain access + let seed_bytes = match self.wallet_entropy { + LdkLiteWalletEntropy::SeedBytes(bytes) => bytes, + LdkLiteWalletEntropy::SeedFile(seed_path) => io::read_or_generate_seed_file(seed_path)?, + LdkLiteWalletEntropy::Bip39Mnemonic(mnemonic) => mnemonic.to_seed(), + }; + + let xprv = bitcoin::util::bip32::ExtendedPrivKey::new_master(config.network, &seed_bytes)?; + + let wallet_name = bdk::wallet::wallet_name_from_descriptor( + Bip84(xprv.clone(), bdk::KeychainKind::External), + Some(Bip84(xprv.clone(), bdk::KeychainKind::Internal)), + config.network, + &Secp256k1::new(), + )?; + let database = sled::open(bdk_data_dir)?; + let database = database.open_tree(wallet_name.clone())?; + + let bdk_wallet = bdk::Wallet::new( + Bip84(xprv.clone(), bdk::KeychainKind::External), + Some(Bip84(xprv.clone(), bdk::KeychainKind::Internal)), + config.network, + database, + )?; + + // TODO: Check that we can be sure that the Esplora client re-connects in case of failure + // and and exits cleanly on drop. Otherwise we need to handle this/move it to the runtime? + let blockchain = EsploraBlockchain::new(&config.esplora_server_url, BDK_CLIENT_STOP_GAP) + .with_concurrency(BDK_CLIENT_CONCURRENCY); + + let chain_access = + Arc::new(LdkLiteChainAccess::new(blockchain, bdk_wallet, Arc::clone(&logger))); + + // Step 3: Initialize Persist + let persister = Arc::new(FilesystemPersister::new(ldk_data_dir.clone())); + + // Step 4: Initialize the ChainMonitor + let chain_monitor: Arc = Arc::new(chainmonitor::ChainMonitor::new( + None, + Arc::clone(&chain_access), + Arc::clone(&logger), + Arc::clone(&chain_access), + Arc::clone(&persister), + )); + + // Step 5: Initialize the KeysManager + let cur = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)?; + let ldk_seed: [u8; 32] = xprv.private_key.secret_bytes(); + let keys_manager = Arc::new(KeysManager::new(&ldk_seed, cur.as_secs(), cur.subsec_nanos())); + + // Step 6: Read ChannelMonitor state from disk + let mut channel_monitors = persister.read_channelmonitors(keys_manager.clone())?; + + // Step 7: Initialize the ChannelManager + let mut user_config = UserConfig::default(); + user_config.channel_handshake_limits.force_announced_channel_preference = false; + let (_channel_manager_blockhash, channel_manager) = { + if let Ok(mut f) = fs::File::open(format!("{}/manager", ldk_data_dir.clone())) { + let mut channel_monitor_mut_references = Vec::new(); + for (_, channel_monitor) in channel_monitors.iter_mut() { + channel_monitor_mut_references.push(channel_monitor); + } + let read_args = ChannelManagerReadArgs::new( + Arc::clone(&keys_manager), + Arc::clone(&chain_access), + Arc::clone(&chain_monitor), + Arc::clone(&chain_access), + Arc::clone(&logger), + user_config, + channel_monitor_mut_references, + ); + <(BlockHash, ChannelManager)>::read(&mut f, read_args)? + } else { + // We're starting a fresh node. + let latest_block_height = chain_access.get_height()?; + let latest_block_hash = chain_access.get_block_hash(latest_block_height as u64)?; + + let chain_params = ChainParameters { + network: config.network, + best_block: BestBlock::new(latest_block_hash, latest_block_height), + }; + let fresh_channel_manager = channelmanager::ChannelManager::new( + Arc::clone(&chain_access), + Arc::clone(&chain_monitor), + Arc::clone(&chain_access), + Arc::clone(&logger), + Arc::clone(&keys_manager), + user_config, + chain_params, + ); + (latest_block_hash, fresh_channel_manager) + } + }; + + let channel_manager = Arc::new(channel_manager); + + // Step 8: Give ChannelMonitors to ChainMonitor + for (_blockhash, channel_monitor) in channel_monitors.drain(..) { + let funding_outpoint = channel_monitor.get_funding_txo().0; + chain_monitor.watch_channel(funding_outpoint, channel_monitor).unwrap(); + } + + // Step 10: Initialize the P2PGossipSync + let network_graph = + Arc::new(io::read_network_graph(Arc::clone(&config), Arc::clone(&logger))?); + let gossip_sync = Arc::new(P2PGossipSync::new( + Arc::clone(&network_graph), + None::>, + Arc::clone(&logger), + )); + + //// Step 11: Initialize the PeerManager + let ephemeral_bytes: [u8; 32] = rand::thread_rng().gen(); + let lightning_msg_handler = MessageHandler { + chan_handler: Arc::clone(&channel_manager), + route_handler: Arc::clone(&gossip_sync), + }; + + let peer_manager: Arc = Arc::new(PeerManager::new( + lightning_msg_handler, + keys_manager.get_node_secret(Recipient::Node).unwrap(), + &ephemeral_bytes, + Arc::clone(&logger), + Arc::new(IgnoringMessageHandler {}), + )); + + // Step 12: Initialize routing ProbabilisticScorer + let scorer = Arc::new(Mutex::new(io::read_scorer( + Arc::clone(&config), + Arc::clone(&network_graph), + Arc::clone(&logger), + ))); + + // Step 13: Init payment info storage + // TODO: persist payment info to disk + let inbound_payments = Arc::new(Mutex::new(HashMap::new())); + let outbound_payments = Arc::new(Mutex::new(HashMap::new())); + + // 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)) + { + Arc::new(LdkLiteEventQueue::read(&mut f, Arc::clone(&persister))?) + } else { + Arc::new(LdkLiteEventQueue::new(Arc::clone(&persister))) + }; + + let event_handler = LdkLiteEventHandler::new( + Arc::clone(&chain_access), + Arc::clone(&event_queue), + Arc::clone(&channel_manager), + Arc::clone(&network_graph), + Arc::clone(&keys_manager), + Arc::clone(&inbound_payments), + Arc::clone(&outbound_payments), + Arc::clone(&logger), + Arc::clone(&config), + ); + + //// Step 16: Create Router and InvoicePayer + let router = DefaultRouter::new( + Arc::clone(&network_graph), + Arc::clone(&logger), + keys_manager.get_secure_random_bytes(), + ); + + let invoice_payer = Arc::new(InvoicePayer::new( + Arc::clone(&channel_manager), + router, + Arc::clone(&scorer), + Arc::clone(&logger), + event_handler, + payment::Retry::Timeout(LDK_PAYMENT_RETRY_TIMEOUT), + )); + + let peer_store = if let Ok(mut f) = fs::File::open(format!( + "{}/{}", + ldk_data_dir.clone(), + peer_store::PEER_INFO_PERSISTENCE_KEY + )) { + Arc::new(PeerInfoStorage::read(&mut f, Arc::clone(&persister))?) + } else { + Arc::new(PeerInfoStorage::new(Arc::clone(&persister))) + }; + + let running = RwLock::new(None); + + Ok(LdkLite { + running, + config, + chain_access, + event_queue, + channel_manager, + chain_monitor, + peer_manager, + keys_manager, + gossip_sync, + persister, + logger, + scorer, + invoice_payer, + inbound_payments, + outbound_payments, + peer_store, + }) + } +} + +/// Wraps all objects that need to be preserved during the run time of [`LdkLite`]. Will be dropped +/// upon [`LdkLite::stop()`]. +struct LdkLiteRuntime { + tokio_runtime: tokio::runtime::Runtime, + _background_processor: BackgroundProcessor, + stop_networking: Arc, + stop_wallet_sync: Arc, +} + +/// The main interface object of the simplified API, wrapping the necessary LDK and BDK functionalities. +/// +/// Needs to be initialized and instantiated through [`LdkLiteBuilder::build`]. +pub struct LdkLite { + running: RwLock>, + config: Arc, + chain_access: Arc>, + event_queue: Arc>, + channel_manager: Arc, + chain_monitor: Arc, + peer_manager: Arc, + keys_manager: Arc, + gossip_sync: Arc, + persister: Arc, + logger: Arc, + scorer: Arc>, + invoice_payer: Arc>, + inbound_payments: Arc, + outbound_payments: Arc, + peer_store: Arc>, +} + +impl LdkLite { + /// Starts the necessary background tasks, such as handling events coming from user input, + /// LDK/BDK, and the peer-to-peer network. After this returns, the [`LdkLite`] instance can be + /// controlled via the provided API methods in a thread-safe manner. + pub fn start(&mut self) -> Result<(), Error> { + // Acquire a run lock and hold it until we're setup. + let mut run_lock = self.running.write().unwrap(); + if run_lock.is_some() { + // We're already running. + return Err(Error::AlreadyRunning); + } + + let runtime = self.setup_runtime()?; + *run_lock = Some(runtime); + Ok(()) + } + + /// Disconnects all peers, stops all running background tasks, and shuts down [`LdkLite`]. + pub fn stop(&mut self) -> Result<(), Error> { + let mut run_lock = self.running.write().unwrap(); + if run_lock.is_none() { + return Err(Error::NotRunning); + } + + let runtime = run_lock.as_ref().unwrap(); + + // Stop wallet sync + runtime.stop_wallet_sync.store(true, Ordering::Release); + + // Stop networking + runtime.stop_networking.store(true, Ordering::Release); + self.peer_manager.disconnect_all_peers(); + + // Drop the runtime, which stops the background processor and any possibly remaining tokio threads. + *run_lock = None; + Ok(()) + } + + fn setup_runtime(&self) -> Result { + let tokio_runtime = + tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap(); + + // Setup wallet sync + let chain_access = Arc::clone(&self.chain_access); + let sync_cman = Arc::clone(&self.channel_manager); + let sync_cmon = Arc::clone(&self.chain_monitor); + let sync_logger = Arc::clone(&self.logger); + let stop_wallet_sync = Arc::new(AtomicBool::new(false)); + let stop_sync = Arc::clone(&stop_wallet_sync); + + tokio_runtime.spawn(async move { + let mut rounds = 0; + loop { + if stop_sync.load(Ordering::Acquire) { + return; + } + // As syncing the on-chain wallet is much more time-intesive, we only sync every + // fifth round. + if rounds == 0 { + let now = Instant::now(); + match chain_access.sync_wallet() { + Ok(()) => log_info!( + sync_logger, + "On-chain wallet sync finished in {}ms.", + now.elapsed().as_millis() + ), + Err(e) => log_error!(sync_logger, "On-chain wallet sync failed: {}", e), + } + } + rounds = (rounds + 1) % 5; + + let confirmables = vec![ + &*sync_cman as &(dyn Confirm + Sync), + &*sync_cmon as &(dyn Confirm + Sync), + ]; + let now = Instant::now(); + match chain_access.sync(confirmables) { + Ok(()) => log_info!( + sync_logger, + "Lightning wallet sync finished in {}ms.", + now.elapsed().as_millis() + ), + Err(e) => log_error!(sync_logger, "Lightning wallet sync failed: {}", e), + } + tokio::time::sleep(Duration::from_secs(5)).await; + } + }); + + // Setup networking + let peer_manager_connection_handler = Arc::clone(&self.peer_manager); + let listening_port = self.config.listening_port; + let stop_networking = Arc::new(AtomicBool::new(false)); + let stop_listen = Arc::clone(&stop_networking); + + tokio_runtime.spawn(async move { + let listener = + tokio::net::TcpListener::bind(format!("0.0.0.0:{}", listening_port)).await.expect( + "Failed to bind to listen port - is something else already listening on it?", + ); + loop { + if stop_listen.load(Ordering::Acquire) { + return; + } + let peer_mgr = Arc::clone(&peer_manager_connection_handler); + let tcp_stream = listener.accept().await.unwrap().0; + tokio::spawn(async move { + lightning_net_tokio::setup_inbound( + Arc::clone(&peer_mgr), + tcp_stream.into_std().unwrap(), + ) + .await; + }); + } + }); + + // Regularly reconnect to channel peers. + let connect_cm = Arc::clone(&self.channel_manager); + let connect_pm = Arc::clone(&self.peer_manager); + let connect_logger = Arc::clone(&self.logger); + let connect_peer_store = Arc::clone(&self.peer_store); + let stop_connect = Arc::clone(&stop_networking); + tokio_runtime.spawn(async move { + let mut interval = tokio::time::interval(Duration::from_secs(1)); + loop { + if stop_connect.load(Ordering::Acquire) { + return; + } + interval.tick().await; + let pm_peers = connect_pm.get_peer_node_ids(); + for node_id in connect_cm + .list_channels() + .iter() + .map(|chan| chan.counterparty.node_id) + .filter(|id| !pm_peers.contains(id)) + { + for peer_info in connect_peer_store.peers() { + if peer_info.pubkey == node_id { + let _ = do_connect_peer( + peer_info.pubkey, + peer_info.address.clone(), + Arc::clone(&connect_pm), + Arc::clone(&connect_logger), + ) + .await; + } + } + } + } + }); + + // Setup background processing + let _background_processor = BackgroundProcessor::start( + Arc::clone(&self.persister), + Arc::clone(&self.invoice_payer), + Arc::clone(&self.chain_monitor), + Arc::clone(&self.channel_manager), + BPGossipSync::p2p(Arc::clone(&self.gossip_sync)), + Arc::clone(&self.peer_manager), + Arc::clone(&self.logger), + Some(Arc::clone(&self.scorer)), + ); + + // TODO: frequently check back on background_processor if there was an error + + Ok(LdkLiteRuntime { + tokio_runtime, + _background_processor, + stop_networking, + stop_wallet_sync, + }) + } + + /// Blocks until the next event is available. + /// + /// Note: this will always return the same event until handling is confirmed via [`LdkLite::event_handled`]. + pub fn next_event(&self) -> LdkLiteEvent { + self.event_queue.next_event() + } + + /// Confirm the last retrieved event handled. + pub fn event_handled(&self) { + self.event_queue.event_handled().unwrap(); + } + + /// Returns our own node id + pub fn my_node_id(&self) -> Result { + if self.running.read().unwrap().is_none() { + return Err(Error::NotRunning); + } + + Ok(self.channel_manager.get_our_node_id()) + } + + /// Retrieve a new on-chain/funding address. + pub fn new_funding_address(&mut self) -> Result { + if self.running.read().unwrap().is_none() { + return Err(Error::NotRunning); + } + + let funding_address = self.chain_access.get_new_address()?; + log_info!(self.logger, "generated new funding address: {}", funding_address); + Ok(funding_address) + } + + /// Connect to a node and open a new channel. Disconnects and re-connects are handled automatically + /// + /// Returns a temporary channel id + pub fn connect_open_channel( + &self, node_pubkey_and_address: &str, channel_amount_sats: u64, announce_channel: bool, + ) -> Result<(), Error> { + let runtime_lock = self.running.read().unwrap(); + if runtime_lock.is_none() { + return Err(Error::NotRunning); + } + + let peer_info = PeerInfo::try_from(node_pubkey_and_address.to_string())?; + + let runtime = runtime_lock.as_ref().unwrap(); + + let con_peer_info = peer_info.clone(); + let con_success = Arc::new(AtomicBool::new(false)); + let con_success_cloned = Arc::clone(&con_success); + let con_logger = Arc::clone(&self.logger); + let con_pm = Arc::clone(&self.peer_manager); + + runtime.tokio_runtime.block_on(async move { + let res = connect_peer_if_necessary( + con_peer_info.pubkey, + con_peer_info.address, + con_pm, + con_logger, + ) + .await; + con_success_cloned.store(res.is_ok(), Ordering::Release); + }); + + if !con_success.load(Ordering::Acquire) { + return Err(Error::ConnectionFailed); + } + + let user_config = UserConfig { + channel_handshake_limits: ChannelHandshakeLimits { + // lnd's max to_self_delay is 2016, so we want to be compatible. + their_to_self_delay: 2016, + ..Default::default() + }, + channel_handshake_config: ChannelHandshakeConfig { + announced_channel: announce_channel, + ..Default::default() + }, + ..Default::default() + }; + + match self.channel_manager.create_channel( + peer_info.pubkey, + channel_amount_sats, + 0, + 0, + Some(user_config), + ) { + Ok(_) => { + self.peer_store.add_peer(peer_info.clone())?; + log_info!(self.logger, "Initiated channel with peer {}. ", peer_info.pubkey); + Ok(()) + } + Err(e) => { + log_error!(self.logger, "failed to open channel: {:?}", e); + Err(Error::LdkApi(e)) + } + } + } + + /// Close a previously opened channel. + pub fn close_channel( + &self, channel_id: &[u8; 32], counterparty_node_id: &PublicKey, + ) -> Result<(), Error> { + self.peer_store.remove_peer(counterparty_node_id)?; + Ok(self.channel_manager.close_channel(channel_id, counterparty_node_id)?) + } + + /// Send a payement given an invoice. + pub fn send_payment(&self, invoice: Invoice) -> Result { + if self.running.read().unwrap().is_none() { + return Err(Error::NotRunning); + } + + // TODO: ensure we never tried paying the given payment hash before + let status = match self.invoice_payer.pay_invoice(&invoice) { + Ok(_payment_id) => { + let payee_pubkey = invoice.recover_payee_pub_key(); + // TODO: is this unwrap safe? Would a payment to an invoice with None amount ever + // succeed? Should we allow to set the amount in the interface or via a dedicated + // method? + let amt_msat = invoice.amount_milli_satoshis().unwrap(); + log_info!(self.logger, "initiated sending {} msats to {}", amt_msat, payee_pubkey); + PaymentStatus::Pending + } + Err(payment::PaymentError::Invoice(e)) => { + log_error!(self.logger, "invalid invoice: {}", e); + return Err(Error::LdkPayment(payment::PaymentError::Invoice(e))); + } + Err(payment::PaymentError::Routing(e)) => { + log_error!(self.logger, "failed to find route: {}", e.err); + return Err(Error::LdkPayment(payment::PaymentError::Routing(e))); + } + Err(payment::PaymentError::Sending(e)) => { + log_error!(self.logger, "failed to send payment: {:?}", e); + PaymentStatus::Failed + } + }; + + let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner()); + let payment_secret = Some(invoice.payment_secret().clone()); + + let mut outbound_payments_lock = self.outbound_payments.lock().unwrap(); + outbound_payments_lock.insert( + payment_hash, + PaymentInfo { + preimage: None, + secret: payment_secret, + status, + amount_msat: invoice.amount_milli_satoshis(), + }, + ); + + Ok(payment_hash) + } + + /// Send a spontaneous, aka. "keysend", payment + pub fn send_spontaneous_payment( + &self, amount_msat: u64, node_id: &str, + ) -> Result { + if self.running.read().unwrap().is_none() { + return Err(Error::NotRunning); + } + + let pubkey = hex::to_compressed_pubkey(node_id) + .ok_or(Error::PeerInfoParse("failed to parse node id"))?; + + let payment_preimage = PaymentPreimage(self.keys_manager.get_secure_random_bytes()); + let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner()); + + let status = match self.invoice_payer.pay_pubkey( + pubkey, + payment_preimage, + amount_msat, + self.config.default_cltv_expiry_delta, + ) { + Ok(_payment_id) => { + log_info!(self.logger, "initiated sending {} msats to {}", amount_msat, node_id); + PaymentStatus::Pending + } + Err(payment::PaymentError::Invoice(e)) => { + log_error!(self.logger, "invalid invoice: {}", e); + return Err(Error::LdkPayment(payment::PaymentError::Invoice(e))); + } + Err(payment::PaymentError::Routing(e)) => { + log_error!(self.logger, "failed to find route: {}", e.err); + return Err(Error::LdkPayment(payment::PaymentError::Routing(e))); + } + Err(payment::PaymentError::Sending(e)) => { + log_error!(self.logger, "failed to send payment: {:?}", e); + PaymentStatus::Failed + } + }; + + let mut outbound_payments_lock = self.outbound_payments.lock().unwrap(); + outbound_payments_lock.insert( + payment_hash, + PaymentInfo { preimage: None, secret: None, status, amount_msat: Some(amount_msat) }, + ); + + Ok(payment_hash) + } + + /// Returns a payable invoice that can be used to request and receive a payment. + pub fn receive_payment( + &self, amount_msat: Option, description: &str, expiry_secs: u32, + ) -> Result { + let mut inbound_payments_lock = self.inbound_payments.lock().unwrap(); + + let currency = match self.config.network { + bitcoin::Network::Bitcoin => Currency::Bitcoin, + bitcoin::Network::Testnet => Currency::BitcoinTestnet, + bitcoin::Network::Regtest => Currency::Regtest, + bitcoin::Network::Signet => Currency::Signet, + }; + let keys_manager = Arc::clone(&self.keys_manager); + let invoice = match lightning_invoice::utils::create_invoice_from_channelmanager( + &self.channel_manager, + keys_manager, + currency, + amount_msat, + description.to_string(), + expiry_secs, + ) { + Ok(inv) => { + log_info!(self.logger, "generated invoice: {}", inv); + inv + } + Err(e) => { + let err_str = &e.to_string(); + log_error!(self.logger, "failed to create invoice: {:?}", err_str); + return Err(Error::LdkInvoiceCreation(e)); + } + }; + + let payment_hash = PaymentHash(invoice.payment_hash().clone().into_inner()); + inbound_payments_lock.insert( + payment_hash, + PaymentInfo { + preimage: None, + secret: Some(invoice.payment_secret().clone()), + status: PaymentStatus::Pending, + amount_msat, + }, + ); + Ok(invoice) + } + + /// Query for information about the status of a specific payment. + pub fn payment_info(&self, payment_hash: &[u8; 32]) -> Option { + let payment_hash = PaymentHash(*payment_hash); + + { + let outbound_payments_lock = self.outbound_payments.lock().unwrap(); + if let Some(payment_info) = outbound_payments_lock.get(&payment_hash) { + return Some((*payment_info).clone()); + } + } + + { + let inbound_payments_lock = self.inbound_payments.lock().unwrap(); + if let Some(payment_info) = inbound_payments_lock.get(&payment_hash) { + return Some((*payment_info).clone()); + } + } + + None + } +} + +async fn connect_peer_if_necessary( + pubkey: PublicKey, peer_addr: SocketAddr, peer_manager: Arc, + logger: Arc, +) -> Result<(), Error> { + for node_pubkey in peer_manager.get_peer_node_ids() { + if node_pubkey == pubkey { + return Ok(()); + } + } + + do_connect_peer(pubkey, peer_addr, peer_manager, logger).await +} + +async fn do_connect_peer( + pubkey: PublicKey, peer_addr: SocketAddr, peer_manager: Arc, + logger: Arc, +) -> Result<(), Error> { + log_info!(logger, "connecting to peer: {}@{}", pubkey, peer_addr); + match lightning_net_tokio::connect_outbound(Arc::clone(&peer_manager), pubkey, peer_addr).await + { + Some(connection_closed_future) => { + let mut connection_closed_future = Box::pin(connection_closed_future); + loop { + match futures::poll!(&mut connection_closed_future) { + std::task::Poll::Ready(_) => { + log_info!(logger, "peer connection closed: {}@{}", pubkey, peer_addr); + return Err(Error::ConnectionFailed); + } + std::task::Poll::Pending => {} + } + // Avoid blocking the tokio context by sleeping a bit + match peer_manager.get_peer_node_ids().iter().find(|id| **id == pubkey) { + Some(_) => return Ok(()), + None => tokio::time::sleep(Duration::from_millis(10)).await, + } + } + } + None => { + log_error!(logger, "failed to connect to peer: {}@{}", pubkey, peer_addr); + Err(Error::ConnectionFailed) + } + } +} + +// +// Structs wrapping the particular information which should easily be +// understandable, parseable, and transformable, i.e., we'll try to avoid +// exposing too many technical detail here. +/// Represents a payment. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct PaymentInfo { + /// The pre-image used by the payment. + pub preimage: Option, + /// The secret used by the payment. + pub secret: Option, + /// The status of the payment. + pub status: PaymentStatus, + /// The amount transferred. + pub amount_msat: Option, +} + +/// Represents the current status of a payment. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum PaymentStatus { + /// The payment is still pending. + Pending, + /// The payment suceeded. + Succeeded, + /// The payment failed. + Failed, +} + +type ChainMonitor = chainmonitor::ChainMonitor< + InMemorySigner, + Arc, + Arc>, + Arc>, + Arc, + Arc, +>; + +type PeerManager = SimpleArcPeerManager< + SocketDescriptor, + ChainMonitor, + LdkLiteChainAccess, + LdkLiteChainAccess, + dyn Access + Send + Sync, + FilesystemLogger, +>; + +pub(crate) type ChannelManager = SimpleArcChannelManager< + ChainMonitor, + LdkLiteChainAccess, + LdkLiteChainAccess, + FilesystemLogger, +>; + +type InvoicePayer = payment::InvoicePayer< + Arc, + Router, + Arc>, + Arc, + F, +>; + +type Router = DefaultRouter, Arc>; +type Scorer = ProbabilisticScorer, Arc>; + +type GossipSync = + P2PGossipSync, Arc, Arc>; + +pub(crate) type NetworkGraph = gossip::NetworkGraph>; + +pub(crate) type PaymentInfoStorage = Mutex>; + +#[cfg(test)] +mod tests {} diff --git a/src/logger.rs b/src/logger.rs new file mode 100644 index 000000000..317f294b4 --- /dev/null +++ b/src/logger.rs @@ -0,0 +1,112 @@ +pub(crate) use lightning::util::logger::Logger; +use lightning::util::logger::Record; +use lightning::util::ser::Writer; + +use chrono::Utc; + +use std::fs; +use std::path::Path; + +pub(crate) struct FilesystemLogger { + file_path: String, +} + +impl FilesystemLogger { + pub(crate) fn new(file_path: String) -> Self { + if let Some(parent_dir) = Path::new(&file_path).parent() { + fs::create_dir_all(parent_dir).unwrap(); + } + Self { file_path } + } +} +impl Logger for FilesystemLogger { + fn log(&self, record: &Record) { + let raw_log = record.args.to_string(); + let log = format!( + "{} {:<5} [{}:{}] {}\n", + Utc::now().format("%Y-%m-%d %H:%M:%S"), + record.level.to_string(), + record.module_path, + record.line, + raw_log + ); + fs::OpenOptions::new() + .create(true) + .append(true) + .open(self.file_path.clone()) + .unwrap() + .write_all(log.as_bytes()) + .unwrap(); + } +} + +macro_rules! log_internal { + ($logger: expr, $lvl:expr, $($arg:tt)+) => ( + $logger.log(&lightning::util::logger::Record::new($lvl, format_args!($($arg)+), module_path!(), file!(), line!())) + ); +} +pub(crate) use log_internal; + +macro_rules! log_given_level { + ($logger: expr, $lvl:expr, $($arg:tt)+) => ( + match $lvl { + #[cfg(not(any(feature = "max_level_off")))] + lightning::util::logger::Level::Error => log_internal!($logger, $lvl, $($arg)*), + #[cfg(not(any(feature = "max_level_off", feature = "max_level_error")))] + lightning::util::logger::Level::Warn => log_internal!($logger, $lvl, $($arg)*), + #[cfg(not(any(feature = "max_level_off", feature = "max_level_error", feature = "max_level_warn")))] + lightning::util::logger::Level::Info => log_internal!($logger, $lvl, $($arg)*), + #[cfg(not(any(feature = "max_level_off", feature = "max_level_error", feature = "max_level_warn", feature = "max_level_info")))] + lightning::util::logger::Level::Debug => log_internal!($logger, $lvl, $($arg)*), + #[cfg(not(any(feature = "max_level_off", feature = "max_level_error", feature = "max_level_warn", feature = "max_level_info", feature = "max_level_debug")))] + lightning::util::logger::Level::Trace => log_internal!($logger, $lvl, $($arg)*), + #[cfg(not(any(feature = "max_level_off", feature = "max_level_error", feature = "max_level_warn", feature = "max_level_info", feature = "max_level_debug", feature = "max_level_trace")))] + lightning::util::logger::Level::Gossip => log_internal!($logger, $lvl, $($arg)*), + + #[cfg(any(feature = "max_level_off", feature = "max_level_error", feature = "max_level_warn", feature = "max_level_info", feature = "max_level_debug", feature = "max_level_trace"))] + _ => { + // The level is disabled at compile-time + }, + } + ); +} +pub(crate) use log_given_level; + +#[allow(unused_macros)] +macro_rules! log_error { + ($logger: expr, $($arg:tt)*) => ( + log_given_level!($logger, lightning::util::logger::Level::Error, $($arg)*) + ) +} +pub(crate) use log_error; + +#[allow(unused_macros)] +macro_rules! log_warn { + ($logger: expr, $($arg:tt)*) => ( + log_given_level!($logger, lightning::util::logger::Level::Warn, $($arg)*) + ) +} +pub(crate) use log_warn; + +#[allow(unused_macros)] +macro_rules! log_info { + ($logger: expr, $($arg:tt)*) => ( + log_given_level!($logger, lightning::util::logger::Level::Info, $($arg)*) + ) +} +pub(crate) use log_info; + +#[allow(unused_macros)] +macro_rules! log_debug { + ($logger: expr, $($arg:tt)*) => ( + log_given_level!($logger, lightning::util::logger::Level::Debug, $($arg)*) + ) +} + +#[allow(unused_macros)] +macro_rules! log_trace { + ($logger: expr, $($arg:tt)*) => ( + log_given_level!($logger, lightning::util::logger::Level::Trace, $($arg)*) + ) +} +pub(crate) use log_trace; diff --git a/src/peer_store.rs b/src/peer_store.rs new file mode 100644 index 000000000..47697cc56 --- /dev/null +++ b/src/peer_store.rs @@ -0,0 +1,172 @@ +use crate::hex; +use crate::Error; + +use lightning::util::persist::KVStorePersister; +use lightning::util::ser::{Readable, ReadableArgs, Writeable, Writer}; + +use bitcoin::secp256k1::PublicKey; + +use std::convert::TryFrom; +use std::net::{IpAddr, SocketAddr, ToSocketAddrs}; +use std::sync::{Arc, RwLock}; + +/// The peer information will be persisted under this key. +pub(crate) const PEER_INFO_PERSISTENCE_KEY: &str = "peers"; + +pub(crate) struct PeerInfoStorage { + peers: RwLock, + persister: Arc, +} + +impl PeerInfoStorage { + pub(crate) fn new(persister: Arc) -> Self { + let peers = RwLock::new(PeerInfoStorageSerWrapper(Vec::new())); + Self { peers, persister } + } + + pub(crate) fn add_peer(&self, peer_info: PeerInfo) -> Result<(), Error> { + let mut locked_peers = self.peers.write().unwrap(); + + // Check if we have the peer. If so, either update it or do nothing. + for stored_info in locked_peers.0.iter_mut() { + if stored_info.pubkey == peer_info.pubkey { + if stored_info.address != peer_info.address { + stored_info.address = peer_info.address; + } + return Ok(()); + } + } + + locked_peers.0.push(peer_info); + self.persister.persist(PEER_INFO_PERSISTENCE_KEY, &*locked_peers)?; + + return Ok(()); + } + + pub(crate) fn remove_peer(&self, peer_pubkey: &PublicKey) -> Result<(), Error> { + let mut locked_peers = self.peers.write().unwrap(); + + locked_peers.0.retain(|info| info.pubkey != *peer_pubkey); + + self.persister.persist(PEER_INFO_PERSISTENCE_KEY, &*locked_peers)?; + + return Ok(()); + } + + pub(crate) fn peers(&self) -> Vec { + self.peers.read().unwrap().0.clone() + } +} + +impl ReadableArgs> for PeerInfoStorage { + #[inline] + fn read( + reader: &mut R, persister: Arc, + ) -> Result { + let peers: RwLock = RwLock::new(Readable::read(reader)?); + Ok(Self { peers, persister }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct PeerInfoStorageSerWrapper(Vec); + +impl Readable for PeerInfoStorageSerWrapper { + fn read( + reader: &mut R, + ) -> Result { + let len: u16 = Readable::read(reader)?; + let mut peers = Vec::with_capacity(len as usize); + for _ in 0..len { + peers.push(Readable::read(reader)?); + } + Ok(PeerInfoStorageSerWrapper(peers)) + } +} + +impl Writeable for PeerInfoStorageSerWrapper { + fn write(&self, writer: &mut W) -> Result<(), lightning::io::Error> { + (self.0.len() as u16).write(writer)?; + for e in self.0.iter() { + e.write(writer)?; + } + Ok(()) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct PeerInfo { + pub pubkey: PublicKey, + pub address: SocketAddr, +} + +impl Readable for PeerInfo { + fn read( + reader: &mut R, + ) -> Result { + let pubkey = Readable::read(reader)?; + + let ip_type: u8 = Readable::read(reader)?; + let ip_addr = if ip_type == 0 { + let octets: [u8; 4] = Readable::read(reader)?; + IpAddr::from(octets) + } else { + let octets: [u8; 16] = Readable::read(reader)?; + IpAddr::from(octets) + }; + + let port: u16 = Readable::read(reader)?; + + let address = SocketAddr::new(ip_addr, port); + + Ok(PeerInfo { pubkey, address }) + } +} + +impl Writeable for PeerInfo { + fn write(&self, writer: &mut W) -> Result<(), lightning::io::Error> { + self.pubkey.write(writer)?; + + let ip_type: u8 = if self.address.ip().is_ipv4() { 0 } else { 1 }; + ip_type.write(writer)?; + + let octets = match self.address.ip() { + IpAddr::V4(ip) => ip.octets().to_vec(), + IpAddr::V6(ip) => ip.octets().to_vec(), + }; + octets.write(writer)?; + + self.address.port().write(writer)?; + + Ok(()) + } +} + +impl TryFrom for PeerInfo { + type Error = Error; + + fn try_from(peer_pubkey_and_ip_addr: String) -> Result { + 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() { + return Err(Error::PeerInfoParse( + "Incorrect format. Should be formatted as: `pubkey@host:port`.", + )); + } + + let peer_addr = peer_addr_str.unwrap().to_socket_addrs().map(|mut r| r.next()); + if peer_addr.is_err() || peer_addr.as_ref().unwrap().is_none() { + return Err(Error::PeerInfoParse( + "Couldn't parse pubkey@host:port into a socket address.", + )); + } + + let pubkey = hex::to_compressed_pubkey(pubkey.unwrap()); + if pubkey.is_none() { + return Err(Error::PeerInfoParse("Unable to parse pubkey for node.")); + } + + Ok(PeerInfo { pubkey: pubkey.unwrap(), address: peer_addr.unwrap().unwrap() }) + } +}