Merge #222: Update bdk_kyoto to 0.15.1

70617f9 Update `bdk_kyoto` to `0.15.1` (rustaceanrob)

Pull request description:

  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.

ACKs for top commit:
  tvpeter:
    tACK 70617f9
  notmandatory:
    utACK 70617f9

Tree-SHA512: aa6fa8c9c82ddbe45d262332c7b8bd04deaa183d87c2d7f159330484f643a19246017a163b3feb29ba3707722a9711ee8f314268216b52c04dd27ddaef037ec4

Author: tvpeter

Cargo.lock

@@ -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"

Cargo.toml

@@ -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.

src/commands.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
                 }
             };

src/handlers.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");