feat(hwi): Update hwi lib to v0.0.30

Author: tvpeter

Cargo.lock

@@ -25,6 +25,7 @@ tracing = "0.1.41"
 tracing-subscriber = "0.3.20"
 toml = "0.8.23"
 serde= {version = "1.0", features = ["derive"]}
+crossbeam ={ version = "0.8.4"}
 
 # Optional dependencies
 bdk_bitcoind_rpc = { version = "0.21.0", features = ["std"], optional = true }
@@ -36,7 +37,7 @@ shlex = {  version = "1.3.0", optional = true }
 payjoin = { version = "1.0.0-rc.1", features = ["v1", "v2", "io", "_test-utils"], optional = true}
 reqwest = { version = "0.12.23", default-features = false, optional = true }
 url = { version = "2.5.4", optional = true }
-async-hwi ={ version = "0.0.29", optional = true }
+async-hwi ={ version = "0.0.30", features = ["service"], optional = true }
 
 [features]
 default = ["repl", "sqlite"]

Cargo.toml

@@ -1204,7 +1204,7 @@ pub async fn handle_hwi_subcommand(
 ) -> Result<serde_json::Value, Error> {
     match subcommand {
         HwiSubCommand::Devices => {
-            let devices = crate::utils::connect_to_hardware_wallet(network, hwi_opts).await?;
+            let devices = crate::utils::get_hwi_device(network, hwi_opts).await?;
             let device = if let Some(device) = devices {
                 json!({
                     "fingerprint": device.get_master_fingerprint().await?.to_string(),
@@ -1223,7 +1223,7 @@ pub async fn handle_hwi_subcommand(
                 Error::Generic("Wallet name is required for wallet registration".to_string())
             })?;
 
-            let device = crate::utils::connect_to_hardware_wallet(network, hwi_opts).await?;
+            let device = crate::utils::get_hwi_device(network, hwi_opts).await?;
 
             match device {
                 None => Ok(json!({
@@ -1263,7 +1263,7 @@ pub async fn handle_hwi_subcommand(
             let wallet_opts = WalletOpts {
                 wallet: Some(wallet_name),
                 verbose: false,
-                ext_descriptor: ext_descriptor,
+                ext_descriptor,
                 int_descriptor: None,
                 #[cfg(any(
                     feature = "electrum",
@@ -1320,7 +1320,7 @@ pub async fn handle_hwi_subcommand(
         HwiSubCommand::Sign { psbt } => {
             let mut psbt = Psbt::from_str(&psbt)
                 .map_err(|e| Error::Generic(format!("Failed to parse PSBT: {e}")))?;
-            let device = crate::utils::connect_to_hardware_wallet(network, hwi_opts).await?;
+            let device = crate::utils::get_hwi_device(network, hwi_opts).await?;
             let signed_psbt = if let Some(device) = device {
                 device
                     .sign_tx(&mut psbt)
@@ -1569,7 +1569,7 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
             subcommand,
         } => {
             let result = handle_hwi_subcommand(network, &hwi_opts, subcommand).await?;
-            Ok(serde_json::to_string_pretty(&result).map_err(|e| Error::SerdeJson(e))?)
+            Ok(serde_json::to_string_pretty(&result).map_err(Error::SerdeJson)?)
         }
     };
     result

src/handlers.rs

@@ -37,17 +37,7 @@ use bdk_wallet::{
 };
 use cli_table::{Cell, CellStruct, Style, Table};
 #[cfg(feature = "hwi")]
-use {
-    crate::commands::HwiOpts,
-    async_hwi::jade::{self, Jade},
-    async_hwi::ledger::{HidApi, Ledger, LedgerSimulator, TransportHID},
-    async_hwi::specter::{Specter, SpecterSimulator},
-    async_hwi::{HWI, coldcard},
-    async_hwi::{
-        bitbox::api::runtime,
-        bitbox::{BitBox02, PairingBitbox02WithLocalCache},
-    },
-};
+use std::marker::Sync as MarkerSync;
 
 #[cfg(any(
     feature = "electrum",
@@ -661,109 +651,61 @@ pub fn load_wallet_config(
 }
 
 #[cfg(feature = "hwi")]
-pub async fn connect_to_hardware_wallet(
+pub async fn get_hwi_device(
     network: Network,
-    hwi_opts: &HwiOpts,
-) -> Result<Option<Box<dyn HWI + Send>>, Error> {
-    if let Ok(device) = SpecterSimulator::try_connect().await {
-        return Ok(Some(device.into()));
-    }
-
-    if let Ok(devices) = Specter::enumerate().await {
-        if let Some(device) = devices.into_iter().next() {
-            return Ok(Some(device.into()));
-        }
-    }
-
-    match Jade::enumerate().await {
-        Err(e) => {
-            println!("Jade enumeration error: {e:?}");
-        }
-        Ok(devices) => {
-            for device in devices {
-                let device = device.with_network(network);
-                if let Ok(info) = device.get_info().await {
-                    if info.jade_state == jade::api::JadeState::Locked {
-                        if let Err(e) = device.auth().await {
-                            eprintln!("Jade auth error: {:?}", e);
-                            continue;
-                        }
+    hwi_opts: &crate::commands::HwiOpts,
+) -> Result<Option<Arc<dyn async_hwi::HWI + Send + MarkerSync>>, Error> {
+    use async_hwi::ledger::{HidApi, Ledger, TransportHID};
+    use async_hwi::service::{HwiService, SigningDevice, SigningDeviceMsg};
+    use crossbeam::channel;
+    use std::time::{Duration, Instant};
+
+    let (sender, receiver) = channel::unbounded::<SigningDeviceMsg>();
+    let service = HwiService::new(network, Some(tokio::runtime::Handle::current()));
+    service.start(sender);
+
+    let timeout = Duration::from_secs(5);
+    let start = Instant::now();
+
+    while start.elapsed() < timeout {
+        if let Ok(SigningDeviceMsg::Update) = receiver.recv_timeout(Duration::from_millis(200)) {
+            let devices = service.list();
+            for (_, signing_device) in devices {
+                if let SigningDevice::Supported(supported) = signing_device {
+                    let device = supported.device().clone();
+
+                    if device.device_kind() == async_hwi::DeviceKind::Ledger {
+                        let wallet_name = hwi_opts.wallet.clone().ok_or_else(|| {
+                            Error::Generic("Wallet name required for Ledger".to_string())
+                        })?;
+                        let policy = hwi_opts.ext_descriptor.clone().ok_or_else(|| {
+                            Error::Generic("Descriptor required for Ledger policy".to_string())
+                        })?;
+
+                        let api = HidApi::new().map_err(|e| Error::Generic(e.to_string()))?;
+                        let detected = Ledger::<TransportHID>::enumerate(&api)
+                            .next()
+                            .ok_or_else(|| Error::Generic("Ledger lost".to_string()))?;
+
+                        let mut ledger = Ledger::<TransportHID>::connect(&api, detected)
+                            .map_err(|e| Error::Generic(e.to_string()))?;
+
+                        ledger = ledger
+                            .with_wallet(wallet_name, &policy, None)
+                            .map_err(|e| Error::Generic(e.to_string()))?;
+
+                        service.stop();
+                        return Ok(Some(Arc::new(ledger)));
                     }
-                    return Ok(Some(device.into()));
-                }
-            }
-        }
-    }
-
-    if let Ok(device) = LedgerSimulator::try_connect().await {
-        return Ok(Some(device.into()));
-    }
 
-    let api = Box::new(HidApi::new().map_err(|e| Error::Generic(e.to_string()))?);
-
-    for device_info in api.device_list() {
-        let ext_descriptor = hwi_opts.ext_descriptor.clone().ok_or_else(|| {
-                Error::Generic("External descriptor is required for connecting to bitbox  and coldcard hardware devices".to_string())
-            })?;
-        let wallet_name = hwi_opts.wallet.clone().ok_or_else(|| {
-            Error::Generic(
-                "Wallet name is required for connecting to bitbox and coldcard hardware devices"
-                    .to_string(),
-            )
-        })?;
-        if async_hwi::bitbox::is_bitbox02(device_info) {
-            if let Ok(device) = device_info
-                .open_device(&api)
-                .map_err(|e| Error::Generic(e.to_string()))
-            {
-                if let Ok(device) =
-                    PairingBitbox02WithLocalCache::<runtime::TokioRuntime>::connect(device, None)
-                        .await
-                {
-                    if let Ok((device, _)) = device.wait_confirm().await {
-                        let mut bb02 = BitBox02::from(device).with_network(network);
-                        bb02 = bb02
-                            .with_policy(&ext_descriptor.as_str())
-                            .map_err(Error::HwiError)?;
-                        return Ok(Some(bb02.into()));
-                    }
-                }
-            }
-        }
-        if device_info.vendor_id() == coldcard::api::COINKITE_VID
-            && device_info.product_id() == coldcard::api::CKCC_PID
-        {
-            if let Some(sn) = device_info.serial_number() {
-                if let Ok((cc, _)) = coldcard::api::Coldcard::open(&api, sn, None)
-                    .map_err(|e| Error::Generic(e.to_string()))
-                {
-                    let mut hw = coldcard::Coldcard::from(cc);
-                    hw = hw.with_wallet_name(wallet_name.to_string());
-                    return Ok(Some(hw.into()));
+                    service.stop();
+                    return Ok(Some(device));
                 }
             }
         }
+        tokio::task::yield_now().await;
     }
 
-    for detected in Ledger::<TransportHID>::enumerate(&api) {
-        let ext_descriptor = hwi_opts.ext_descriptor.clone().ok_or_else(|| {
-            Error::Generic(
-                "External descriptor required for connecting to ledger hardware device".to_string(),
-            )
-        })?;
-        let wallet_name = hwi_opts.wallet.clone().ok_or_else(|| {
-            Error::Generic(
-                "Wallet name is required for connecting to ledger hardware device".to_string(),
-            )
-        })?;
-
-        if let Ok(mut device) = Ledger::<TransportHID>::connect(&api, detected) {
-            device = device
-                .with_wallet(wallet_name, &ext_descriptor, None)
-                .map_err(Error::HwiError)?;
-            return Ok(Some(device.into()));
-        }
-    }
-
+    service.stop();
     Ok(None)
 }