Update `bdk_kyoto` to `0.15.1`

Checkpoints were removed from Kyoto to minimize trust in the library and
reduce maintence burden. As such, there is no longer the ability to
"skip blocks", at least on test networks. Mainnet offers two
checkpoints, segwit and taproot activation, but these are included from
genesis on test networks.

Broadcasting a transaction now awaits for the transaction to be
gossiped, simplifying the logic here.

diff --git a/Cargo.lock b/Cargo.lock
index 57efe7f8ee8102f0ae4e9f52ad9ec7b74c08b8bc..4ff8e29c74b6445c90ca0b1846205a8ba808a929 100644 (file)
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -259,12 +259,12 @@ dependencies = [
 
 [[package]]
 name = "bdk_kyoto"
-version = "0.13.1"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bb33172976f7fa26115ad6842f7903a2af325544eac6ddf5a17099e3cd9df3c"
+checksum = "91b430c5fc2d28073df2fe122b177e89f67fbcec47824587163ba96499e3d02c"
 dependencies = [
  "bdk_wallet",
- "kyoto-cbf",
+ "bip157",
 ]
 
 [[package]]
@@ -325,6 +325,18 @@ dependencies = [
  "which",
 ]
 
+[[package]]
+name = "bip157"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d10c525b8dc2a9c0aae5d2de384336696023e5201c6bcc22c47ec0fb9d9947cb"
+dependencies = [
+ "bip324",
+ "bitcoin",
+ "bitcoin-address-book",
+ "tokio",
+]
+
 [[package]]
 name = "bip324"
 version = "0.7.0"
@@ -368,6 +380,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "bitcoin-address-book"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16d55a2ccdaa0271ea60355a01fc82e37f33a340df80599d344f9d6e97d46e48"
+dependencies = [
+ "bitcoin",
+]
+
 [[package]]
 name = "bitcoin-internals"
 version = "0.2.0"
@@ -1355,18 +1376,6 @@ dependencies = [
  "serde_json",
 ]
 
-[[package]]
-name = "kyoto-cbf"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "805f16bcf1d4738529f230404e7d0ab6e9ecf9e265920c212d446a291a93297e"
-dependencies = [
- "bip324",
- "bitcoin",
- "rusqlite",
- "tokio",
-]
-
 [[package]]
 name = "lazy_static"
 version = "1.5.0"

diff --git a/Cargo.toml b/Cargo.toml
index e41e37bf74a75387c3dd7f814c7b1790fbe720a7..d5767f31e754de3650df009264315c31c423accc 100644 (file)
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,7 +26,7 @@ cli-table = "0.5.0"
 bdk_bitcoind_rpc = { version = "0.21.0", features = ["std"], optional = true }
 bdk_electrum = { version = "0.23.0", optional = true }
 bdk_esplora = { version = "0.22.1", features = ["async-https", "tokio"], optional = true }
-bdk_kyoto = { version = "0.13.1", optional = true }
+bdk_kyoto = { version = "0.15.1", optional = true }
 bdk_redb = { version = "0.1.0", optional = true }
 shlex = {  version = "1.3.0", optional = true }
 tracing = "0.1.41"

diff --git a/src/commands.rs b/src/commands.rs
index 8130b00411c264aafe93a8e060ecd33758b03c88..62a6a2ddef047c9c96df10ff4a0573ad6f35e5ba 100644 (file)
--- a/src/commands.rs
+++ b/src/commands.rs
@@ -247,10 +247,6 @@ pub struct CompactFilterOpts {
     /// Sets the number of parallel node connections.
     #[clap(name = "CONNECTIONS", long = "cbf-conn-count", default_value = "2", value_parser = value_parser!(u8).range(1..=15))]
     pub conn_count: u8,
-
-    /// Optionally skip initial `skip_blocks` blocks.
-    #[clap(env = "SKIP_BLOCKS", short = 'k', long = "cbf-skip-blocks")]
-    pub skip_blocks: Option<u32>,
 }
 
 /// Wallet subcommands that can be issued without a blockchain backend.

diff --git a/src/handlers.rs b/src/handlers.rs
index 362c45689e76515df4c6a6b571b9f2e54993b9b6..941c550dddbbdd98f9d0c0887ac17dcc2399b0c1 100644 (file)
--- a/src/handlers.rs
+++ b/src/handlers.rs
@@ -58,7 +58,7 @@ use std::sync::Arc;
 #[cfg(feature = "electrum")]
 use crate::utils::BlockchainClient::Electrum;
 #[cfg(feature = "cbf")]
-use bdk_kyoto::{Info, LightClient};
+use bdk_kyoto::LightClient;
 #[cfg(feature = "compiler")]
 use bdk_wallet::bitcoin::XOnlyPublicKey;
 use bdk_wallet::bitcoin::base64::prelude::*;
@@ -809,7 +809,6 @@ pub(crate) async fn handle_online_wallet_subcommand(
                 KyotoClient { client } => {
                     let LightClient {
                         requester,
-                        mut log_subscriber,
                         mut info_subscriber,
                         mut warning_subscriber,
                         update_subscriber: _,
@@ -823,9 +822,9 @@ pub(crate) async fn handle_online_wallet_subcommand(
                     tokio::task::spawn(async move { node.run().await });
                     tokio::task::spawn(async move {
                         select! {
-                            log = log_subscriber.recv() => {
-                                if let Some(log) = log {
-                                    tracing::info!("{log}");
+                            info = info_subscriber.recv() => {
+                                if let Some(info) = info {
+                                    tracing::info!("{info}");
                                 }
                             },
                             warn = warning_subscriber.recv() => {
@@ -836,29 +835,11 @@ pub(crate) async fn handle_online_wallet_subcommand(
                         }
                     });
                     let txid = tx.compute_txid();
-                    requester
-                        .broadcast_random(tx.clone())
-                        .map_err(|e| Error::Generic(format!("{e}")))?;
-                    tokio::time::timeout(tokio::time::Duration::from_secs(30), async move {
-                        while let Some(info) = info_subscriber.recv().await {
-                            match info {
-                                Info::TxGossiped(wtxid) => {
-                                    tracing::info!("Successfully broadcast WTXID: {wtxid}");
-                                    break;
-                                }
-                                Info::ConnectionsMet => {
-                                    tracing::info!("Rebroadcasting to new connections");
-                                    requester.broadcast_random(tx.clone()).unwrap();
-                                }
-                                _ => tracing::info!("{info}"),
-                            }
-                        }
-                    })
-                    .await
-                    .map_err(|_| {
+                    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())
                     })?;
+                    tracing::info!("Successfully broadcast WTXID: {wtxid}");
                     txid
                 }
             };

diff --git a/src/utils.rs b/src/utils.rs
index fc1cec793071c54d849f9eed5478b8c0928ff475..cb81074376544bdb9dc900771d8b7e2b530b1fa1 100644 (file)
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -18,10 +18,8 @@ use std::path::{Path, PathBuf};
 use crate::commands::WalletOpts;
 #[cfg(feature = "cbf")]
 use bdk_kyoto::{
-    Info, LightClient, NodeBuilderExt, Receiver,
-    ScanType::{Recovery, Sync},
-    UnboundedReceiver, Warning,
-    builder::NodeBuilder,
+    BuilderExt, Info, LightClient, Receiver, ScanType::Sync, UnboundedReceiver, Warning,
+    builder::Builder,
 };
 use bdk_wallet::bitcoin::{Address, Network, OutPoint, ScriptBuf};
 
@@ -195,12 +193,8 @@ pub(crate) fn new_blockchain_client(
 
         #[cfg(feature = "cbf")]
         ClientType::Cbf => {
-            let scan_type = match wallet_opts.compactfilter_opts.skip_blocks {
-                Some(from_height) => Recovery { from_height },
-                None => Sync,
-            };
-
-            let builder = NodeBuilder::new(_wallet.network());
+            let scan_type = Sync;
+            let builder = Builder::new(_wallet.network());
 
             let client = builder
                 .required_peers(wallet_opts.compactfilter_opts.conn_count)
@@ -299,17 +293,11 @@ pub(crate) fn new_wallet(network: Network, wallet_opts: &WalletOpts) -> Result<W
 
 #[cfg(feature = "cbf")]
 pub async fn trace_logger(
-    mut log_subscriber: Receiver<String>,
     mut info_subcriber: Receiver<Info>,
     mut warning_subscriber: UnboundedReceiver<Warning>,
 ) {
     loop {
         tokio::select! {
-            log = log_subscriber.recv() => {
-                if let Some(log) = log {
-                    tracing::info!("{log}")
-                }
-            }
             info = info_subcriber.recv() => {
                 if let Some(info) = info {
                     tracing::info!("{info}")
@@ -329,7 +317,6 @@ pub async fn trace_logger(
 pub async fn sync_kyoto_client(wallet: &mut Wallet, client: Box<LightClient>) -> Result<(), Error> {
     let LightClient {
         requester,
-        log_subscriber,
         info_subscriber,
         warning_subscriber,
         mut update_subscriber,
@@ -341,9 +328,7 @@ pub async fn sync_kyoto_client(wallet: &mut Wallet, client: Box<LightClient>) ->
         .map_err(|e| Error::Generic(format!("SetGlobalDefault error: {e}")))?;
 
     tokio::task::spawn(async move { node.run().await });
-    tokio::task::spawn(async move {
-        trace_logger(log_subscriber, info_subscriber, warning_subscriber).await
-    });
+    tokio::task::spawn(async move { trace_logger(info_subscriber, warning_subscriber).await });
 
     if !requester.is_running() {
         tracing::error!("Kyoto node is not running");