Merge branch 'master' into feat/add-completions-cmd

Author: va-an

.github/workflows/audit.yml

@@ -13,7 +13,8 @@ jobs:
   security_audit:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - uses: actions-rust-lang/audit@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
+          tool-version: 0.22.1

.github/workflows/cont_integration.yml

@@ -2,6 +2,10 @@ on: [push, pull_request]
 
 name: CI
 
+permissions:
+  contents: read
+env:
+  CARGO_TERM_COLOR: always
 jobs:
 
   build-test:
@@ -17,30 +21,41 @@ jobs:
           - --all-features
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
-      - name: Generate cache key
-        run: echo "${{ matrix.rust }} ${{ matrix.features }}" | tee .cache_key
-      - name: Cache
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-${{ hashFiles('.cache_key') }}-${{ hashFiles('**/Cargo.toml','**/Cargo.lock') }}
+        uses: actions/checkout@v6
       - name: Setup Rust Toolchain
-        uses: actions-rs/toolchain@v1
+        uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           toolchain: ${{ matrix.rust }}
           profile: minimal
           override: true
           components: rustfmt, clippy
+          cache: true
       - name: Build
         run: cargo build ${{ matrix.features }}
-      - name: Clippy
-        run: cargo clippy -- -D warnings
       - name: Test
         run: cargo test ${{ matrix.features }}
+  clippy:
+    name: Clippy (${{ matrix.features }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        features:
+          - --no-default-features
+          - --all-features
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+      
+      - name: Install Rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          override: true
+          components: clippy
+          cache: true
+      - name: Run Clippy
+        run: cargo clippy ${{ matrix.features }} --all-targets -- -D warnings
 
 # TODO: fix or remove this
 #  wasm-build:
@@ -82,13 +97,14 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
       - name: Setup Rust Toolchain
-        uses: actions-rs/toolchain@v1
+        uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           toolchain: stable
           profile: minimal
           override: true
           components: rustfmt, clippy
+          cache: true
       - name: Check fmt
         run: cargo fmt --all -- --check

Cargo.lock

@@ -25,6 +25,15 @@ build: fmt
 test:
     cargo test --all-features --tests 
 
+# checks before pushing
+pre-push:
+    cargo test --features default
+    cargo test --no-default-features
+    cargo test --all-features
+    cargo clippy --no-default-features --all-targets -- -D warnings
+    cargo clippy --all-features --all-targets -- -D warnings
+    cargo fmt --all -- --check
+
 # clean the project target directory
 clean:
     cargo clean

Justfile

@@ -59,15 +59,15 @@ pub enum BDKCliError {
 
     #[cfg(feature = "sqlite")]
     #[error("Rusqlite error: {0}")]
-    RusqliteError(#[from] bdk_wallet::rusqlite::Error),
+    RusqliteError(Box<bdk_wallet::rusqlite::Error>),
 
     #[cfg(feature = "redb")]
     #[error("Redb StoreError: {0}")]
     RedbStoreError(Box<bdk_redb::error::StoreError>),
 
     #[cfg(feature = "redb")]
     #[error("Redb dabtabase error: {0}")]
-    RedbDatabaseError(#[from] bdk_redb::redb::DatabaseError),
+    RedbDatabaseError(Box<bdk_redb::redb::DatabaseError>),
 
     #[error("Serde json error: {0}")]
     SerdeJson(#[from] serde_json::Error),
@@ -112,6 +112,34 @@ pub enum BDKCliError {
     ))]
     #[error("Reqwest error: {0}")]
     ReqwestError(#[from] reqwest::Error),
+
+    #[cfg(feature = "payjoin")]
+    #[error("Payjoin URL parse error: {0}")]
+    PayjoinUrlParse(#[from] payjoin::IntoUrlError),
+
+    #[cfg(feature = "payjoin")]
+    #[error("Payjoin send response error: {0}")]
+    PayjoinSendResponse(#[from] payjoin::send::ResponseError),
+
+    #[cfg(feature = "payjoin")]
+    #[error("Payjoin sender build error: {0}")]
+    PayjoinSenderBuild(#[from] payjoin::send::BuildSenderError),
+
+    #[cfg(feature = "payjoin")]
+    #[error("Payjoin receive error: {0}")]
+    PayjoinReceive(#[from] payjoin::receive::Error),
+
+    #[cfg(feature = "payjoin")]
+    #[error("Payjoin selection error: {0}")]
+    PayjoinSelection(#[from] payjoin::receive::SelectionError),
+
+    #[cfg(feature = "payjoin")]
+    #[error("Payjoin input contribution error: {0}")]
+    PayjoinInputContribution(#[from] payjoin::receive::InputContributionError),
+
+    #[cfg(feature = "payjoin")]
+    #[error("Payjoin create request error: {0}")]
+    PayjoinCreateRequest(#[from] payjoin::send::v2::CreateRequestError),
 }
 
 impl From<ExtractTxError> for BDKCliError {
@@ -126,3 +154,17 @@ impl From<bdk_redb::error::StoreError> for BDKCliError {
         BDKCliError::RedbStoreError(Box::new(err))
     }
 }
+
+#[cfg(feature = "redb")]
+impl From<bdk_redb::redb::DatabaseError> for BDKCliError {
+    fn from(err: bdk_redb::redb::DatabaseError) -> Self {
+        BDKCliError::RedbDatabaseError(Box::new(err))
+    }
+}
+
+#[cfg(feature = "sqlite")]
+impl From<bdk_wallet::rusqlite::Error> for BDKCliError {
+    fn from(err: bdk_wallet::rusqlite::Error) -> Self {
+        BDKCliError::RusqliteError(Box::new(err))
+    }
+}

src/error.rs

@@ -15,6 +15,8 @@ use crate::config::{WalletConfig, WalletConfigInner};
 use crate::error::BDKCliError as Error;
 #[cfg(any(feature = "sqlite", feature = "redb"))]
 use crate::persister::Persister;
+#[cfg(feature = "cbf")]
+use crate::utils::BlockchainClient::KyotoClient;
 use crate::utils::*;
 #[cfg(feature = "redb")]
 use bdk_redb::Store as RedbStore;
@@ -47,8 +49,6 @@ use bdk_wallet::{
 use clap::CommandFactory;
 use cli_table::{Cell, CellStruct, Style, Table, format::Justify};
 use serde_json::json;
-#[cfg(feature = "cbf")]
-use {crate::utils::BlockchainClient::KyotoClient, bdk_kyoto::LightClient, tokio::select};
 
 #[cfg(feature = "electrum")]
 use crate::utils::BlockchainClient::Electrum;
@@ -606,7 +606,7 @@ pub fn handle_offline_wallet_subcommand(
 ))]
 pub(crate) async fn handle_online_wallet_subcommand(
     wallet: &mut Wallet,
-    client: BlockchainClient,
+    client: &BlockchainClient,
     online_subcommand: OnlineWalletSubCommand,
 ) -> Result<String, Error> {
     match online_subcommand {
@@ -633,7 +633,7 @@ pub(crate) async fn handle_online_wallet_subcommand(
                     client
                         .populate_tx_cache(wallet.tx_graph().full_txs().map(|tx_node| tx_node.tx));
 
-                    let update = client.full_scan(request, _stop_gap, batch_size, false)?;
+                    let update = client.full_scan(request, _stop_gap, *batch_size, false)?;
                     wallet.apply_update(update)?;
                 }
                 #[cfg(feature = "esplora")]
@@ -642,7 +642,7 @@ pub(crate) async fn handle_online_wallet_subcommand(
                     parallel_requests,
                 } => {
                     let update = client
-                        .full_scan(request, _stop_gap, parallel_requests)
+                        .full_scan(request, _stop_gap, *parallel_requests)
                         .await
                         .map_err(|e| *e)?;
                     wallet.apply_update(update)?;
@@ -659,7 +659,7 @@ pub(crate) async fn handle_online_wallet_subcommand(
                         hash: genesis_block.block_hash(),
                     });
                     let mut emitter = Emitter::new(
-                        &*client,
+                        client.as_ref(),
                         genesis_cp.clone(),
                         genesis_cp.height(),
                         NO_EXPECTED_MEMPOOL_TXS,
@@ -1157,6 +1157,7 @@ pub fn handle_wallets_subcommand(datadir: &Path, pretty: bool) -> Result<String,
             .wallets
             .iter()
             .map(|(name, wallet_config)| {
+                #[allow(unused_mut)]
                 let mut wallet_json = json!({
                     "name": name,
                     "network": wallet_config.network,
@@ -1247,7 +1248,7 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
 
                 let result = handle_online_wallet_subcommand(
                     &mut wallet,
-                    blockchain_client,
+                    &blockchain_client,
                     online_subcommand,
                 )
                 .await?;
@@ -1259,7 +1260,7 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
                 let mut wallet = new_wallet(network, wallet_opts)?;
                 let blockchain_client =
                     crate::utils::new_blockchain_client(wallet_opts, &wallet, database_path)?;
-                handle_online_wallet_subcommand(&mut wallet, blockchain_client, online_subcommand)
+                handle_online_wallet_subcommand(&mut wallet, &blockchain_client, online_subcommand)
                     .await?
             };
             Ok(result)
@@ -1463,7 +1464,7 @@ async fn respond(
         } => {
             let blockchain =
                 new_blockchain_client(wallet_opts, wallet, _datadir).map_err(|e| e.to_string())?;
-            let value = handle_online_wallet_subcommand(wallet, blockchain, online_subcommand)
+            let value = handle_online_wallet_subcommand(wallet, &blockchain, online_subcommand)
                 .await
                 .map_err(|e| e.to_string())?;
             Some(value)
@@ -1519,7 +1520,7 @@ async fn respond(
     feature = "rpc"
 ))]
 /// Syncs a given wallet using the blockchain client.
-pub async fn sync_wallet(client: BlockchainClient, wallet: &mut Wallet) -> Result<(), Error> {
+pub async fn sync_wallet(client: &BlockchainClient, wallet: &mut Wallet) -> Result<(), Error> {
     #[cfg(any(feature = "electrum", feature = "esplora"))]
     let request = wallet
         .start_sync_with_revealed_spks()
@@ -1534,7 +1535,7 @@ pub async fn sync_wallet(client: BlockchainClient, wallet: &mut Wallet) -> Resul
             // already have.
             client.populate_tx_cache(wallet.tx_graph().full_txs().map(|tx_node| tx_node.tx));
 
-            let update = client.sync(request, batch_size, false)?;
+            let update = client.sync(request, *batch_size, false)?;
             wallet
                 .apply_update(update)
                 .map_err(|e| Error::Generic(e.to_string()))
@@ -1545,7 +1546,7 @@ pub async fn sync_wallet(client: BlockchainClient, wallet: &mut Wallet) -> Resul
             parallel_requests,
         } => {
             let update = client
-                .sync(request, parallel_requests)
+                .sync(request, *parallel_requests)
                 .await
                 .map_err(|e| *e)?;
             wallet
@@ -1560,7 +1561,7 @@ pub async fn sync_wallet(client: BlockchainClient, wallet: &mut Wallet) -> Resul
             // reload the last 200 blocks in case of a reorg
             let emitter_height = wallet_cp.height().saturating_sub(200);
             let mut emitter = Emitter::new(
-                &*client,
+                client.as_ref(),
                 wallet_cp,
                 emitter_height,
                 wallet
@@ -1611,7 +1612,7 @@ pub async fn sync_wallet(client: BlockchainClient, wallet: &mut Wallet) -> Resul
 ))]
 /// Broadcasts a given transaction using the blockchain client.
 pub async fn broadcast_transaction(
-    client: BlockchainClient,
+    client: &BlockchainClient,
     tx: Transaction,
 ) -> Result<Txid, Error> {
     match client {
@@ -1638,38 +1639,15 @@ pub async fn broadcast_transaction(
 
         #[cfg(feature = "cbf")]
         KyotoClient { client } => {
-            let LightClient {
-                requester,
-                mut info_subscriber,
-                mut warning_subscriber,
-                update_subscriber: _,
-                node,
-            } = *client;
-
-            let subscriber = tracing_subscriber::FmtSubscriber::new();
-            tracing::subscriber::set_global_default(subscriber)
-                .map_err(|e| Error::Generic(format!("SetGlobalDefault error: {e}")))?;
-
-            tokio::task::spawn(async move { node.run().await });
-            tokio::task::spawn(async move {
-                select! {
-                    info = info_subscriber.recv() => {
-                        if let Some(info) = info {
-                            tracing::info!("{info}");
-                        }
-                    },
-                    warn = warning_subscriber.recv() => {
-                        if let Some(warn) = warn {
-                            tracing::warn!("{warn}");
-                        }
-                    }
-                }
-            });
             let txid = tx.compute_txid();
-            let wtxid = requester.broadcast_random(tx.clone()).await.map_err(|_| {
-                tracing::warn!("Broadcast was unsuccessful");
-                Error::Generic("Transaction broadcast timed out after 30 seconds".into())
-            })?;
+            let wtxid = client
+                .requester
+                .broadcast_random(tx.clone())
+                .await
+                .map_err(|_| {
+                    tracing::warn!("Broadcast was unsuccessful");
+                    Error::Generic("Transaction broadcast timed out after 30 seconds".into())
+                })?;
             tracing::info!("Successfully broadcast WTXID: {wtxid}");
             Ok(txid)
         }