feat(hwi): set hwi as top level command

- add ledger and coldcard integration
- update hwi as top level command
- update CHANGELOG

Author: tvpeter

CHANGELOG.md

@@ -7,6 +7,7 @@ page. See [DEVELOPMENT_CYCLE.md](DEVELOPMENT_CYCLE.md) for more details.
 
 - Removed MSRV and bumped Rust Edition to 2024
 - Add `--pretty` top level flag for formatting commands output in a tabular format
+- Add `hwi` top level command with subcommands: `devices`, `register`, `address` and `sign` transaction
 
 ## [1.0.0]
 

Cargo.lock

@@ -116,7 +116,7 @@ pub enum CliSubCommand {
     #[cfg(feature = "hwi")]
     Hwi {
         #[command(flatten)]
-        wallet_opts: WalletOpts,
+        hwi_opts: HwiOpts,
         #[clap(subcommand)]
         subcommand: HwiSubCommand,
     },
@@ -227,6 +227,23 @@ pub struct WalletOpts {
     pub compactfilter_opts: CompactFilterOpts,
 }
 
+/// HWI specific options
+#[cfg(feature = "hwi")]
+#[derive(Clone, Debug, PartialEq, Eq, Args)]
+pub struct HwiOpts {
+    /// Wallet name
+    #[arg(env = "WALLET", short = 'w', long = "wallet")]
+    pub wallet: Option<String>,
+
+    /// External descriptor
+    #[arg(env = "EXT_DESCRIPTOR", short = 'e', long = "ext_descriptor")]
+    pub ext_descriptor: Option<String>,
+
+    /// Database type
+    #[arg(short = 'd', long = "database_type")]
+    pub database_type: Option<DatabaseType>,
+}
+
 /// Options to configure a SOCKS5 proxy for a blockchain client connection.
 #[cfg(any(feature = "electrum", feature = "esplora"))]
 #[derive(Debug, Args, Clone, PartialEq, Eq)]

src/commands.rs

@@ -1047,20 +1047,14 @@ pub(crate) fn handle_compile_subcommand(
 #[cfg(feature = "hwi")]
 pub async fn handle_hwi_subcommand(
     network: Network,
-    wallet_opts: &WalletOpts,
+    hwi_opts: &HwiOpts,
     subcommand: HwiSubCommand,
 ) -> Result<serde_json::Value, Error> {
     match subcommand {
         HwiSubCommand::Devices => {
-            let devices = crate::utils::connect_to_hardware_wallet(
-                wallet.network(),
-                wallet_opts,
-                Some(wallet),
-            )
-            .await?;
-            let device = if let Some(device) = device {
+            let devices = crate::utils::connect_to_hardware_wallet(network, hwi_opts).await?;
+            let device = if let Some(device) = devices {
                 json!({
-                    "type": device.device_kind().to_string(),
                     "fingerprint": device.get_master_fingerprint().await?.to_string(),
                     "model": device.device_kind().to_string(),
                 })
@@ -1070,97 +1064,82 @@ pub async fn handle_hwi_subcommand(
             Ok(json!({ "devices": device }))
         }
         HwiSubCommand::Register => {
-            let policy = wallet_opts.ext_descriptor.clone().ok_or_else(|| {
+            let policy = hwi_opts.ext_descriptor.clone().ok_or_else(|| {
                 Error::Generic("External descriptor required for wallet registration".to_string())
             })?;
-            let wallet_name = wallet_opts.wallet.clone().ok_or_else(|| {
+            let wallet_name = hwi_opts.wallet.clone().ok_or_else(|| {
                 Error::Generic("Wallet name is required for wallet registration".to_string())
             })?;
 
-            let home_dir = prepare_home_dir(None)?;
-            let database_path = prepare_wallet_db_dir(&wallet_opts.wallet, &home_dir)?;
-            #[cfg(feature = "sqlite")]
-            let wallet = {
-                let mut persister = match &wallet_opts.database_type {
-                    DatabaseType::Sqlite => {
-                        let db_file = database_path.join("wallet.sqlite");
-                        let connection = Connection::open(db_file)?;
-                        log::debug!("Sqlite database opened successfully");
-                        connection
+            let device = crate::utils::connect_to_hardware_wallet(network, hwi_opts).await?;
+
+            match device {
+                None => Ok(json!({
+                    "success": false,
+                    "error": "No hardware wallet detected"
+                })),
+                Some(device) => match device.register_wallet(&wallet_name, &policy).await {
+                    Ok(hmac_opt) => {
+                        let hmac_hex = hmac_opt.map(|h| {
+                            let bytes: &[u8] = &h;
+                            bytes.to_lower_hex_string()
+                        });
+                        Ok(json!({
+                            "success": true,
+                            "hmac": hmac_hex
+                        }))
                     }
-                };
-                let mut wallet = new_persisted_wallet(network, &mut persister, wallet_opts)?;
-                wallet.persist(&mut persister)?;
-                wallet
-            };
-            #[cfg(not(feature = "sqlite"))]
-            let wallet = new_wallet(network, wallet_opts)?;
-
-            let device = crate::utils::connect_to_hardware_wallet(
-                wallet.network(),
-                wallet_opts,
-                Some(wallet),
-            )
-            .await?;
-            let hmac = if let Some(device) = device {
-                let hmac = device.register_wallet(&wallet_name, &policy).await?;
-                hmac.map(|h| h.to_lower_hex_string())
-            } else {
-                None
-            };
-            Ok(json!({ "hmac": hmac }))
+                    Err(e) => Err(Error::Generic(format!("Wallet registration failed: {e}"))),
+                },
+            }
         }
         HwiSubCommand::Address => {
+            let ext_descriptor = hwi_opts.ext_descriptor.clone().ok_or_else(|| {
+                Error::Generic("External descriptor required for address generation".to_string())
+            })?;
+            let wallet_name = hwi_opts.wallet.clone().ok_or_else(|| {
+                Error::Generic("Wallet name is required for address generation".to_string())
+            })?;
+
+            let database = hwi_opts.database_type.clone().ok_or_else(|| {
+                Error::Generic("Database type is required for address generation".to_string())
+            })?;
+
             let home_dir = prepare_home_dir(None)?;
-            let database_path = prepare_wallet_db_dir(&wallet_opts.wallet, &home_dir)?;
+            let database_path = prepare_wallet_db_dir(&Some(wallet_name.clone()), &home_dir)?;
+
+            let wallet_opts = WalletOpts {
+                wallet: Some(wallet_name),
+                verbose: false,
+                ext_descriptor: Some(ext_descriptor),
+                int_descriptor: None,
+                #[cfg(feature = "sqlite")]
+                database_type: database,
+            };
+
             #[cfg(feature = "sqlite")]
-            let wallet = {
-                let mut persister = match &wallet_opts.database_type {
-                    DatabaseType::Sqlite => {
-                        let db_file = database_path.join("wallet.sqlite");
-                        let connection = Connection::open(db_file)?;
-                        log::debug!("Sqlite database opened successfully");
-                        connection
-                    }
-                };
-                let mut wallet = new_persisted_wallet(network, &mut persister, wallet_opts)?;
+            let mut wallet = if hwi_opts.database_type.is_some() {
+                let db_file = database_path.join("wallet.sqlite");
+                let mut persister = Connection::open(db_file)?;
+                let mut wallet = new_persisted_wallet(network, &mut persister, &wallet_opts)?;
                 wallet.persist(&mut persister)?;
                 wallet
+            } else {
+                return Err(Error::Generic(
+                    "Could not connect to sqlite database".to_string(),
+                ));
             };
+
             #[cfg(not(feature = "sqlite"))]
-            let wallet = new_wallet(network, wallet_opts)?;
+            let mut wallet = new_wallet(network, &wallet_opts)?;
 
             let address = wallet.next_unused_address(KeychainKind::External);
             Ok(json!({ "address": address.address }))
         }
         HwiSubCommand::Sign { psbt } => {
-            let home_dir = prepare_home_dir(None)?;
-            let database_path = prepare_wallet_db_dir(&wallet_opts.wallet, &home_dir)?;
-            #[cfg(feature = "sqlite")]
-            let wallet = {
-                let mut persister = match &wallet_opts.database_type {
-                    DatabaseType::Sqlite => {
-                        let db_file = database_path.join("wallet.sqlite");
-                        let connection = Connection::open(db_file)?;
-                        log::debug!("Sqlite database opened successfully");
-                        connection
-                    }
-                };
-                let mut wallet = new_persisted_wallet(network, &mut persister, wallet_opts)?;
-                wallet.persist(&mut persister)?;
-                wallet
-            };
-            #[cfg(not(feature = "sqlite"))]
-            let wallet = new_wallet(network, wallet_opts)?;
-
             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(
-                wallet.network(),
-                wallet_opts,
-                Some(wallet),
-            )
-            .await?;
+            let device = crate::utils::connect_to_hardware_wallet(network, hwi_opts).await?;
             let signed_psbt = if let Some(device) = device {
                 device
                     .sign_tx(&mut psbt)
@@ -1383,6 +1362,15 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
             }
             Ok("".to_string())
         }
+
+        #[cfg(feature = "hwi")]
+        CliSubCommand::Hwi {
+            hwi_opts,
+            subcommand,
+        } => {
+            let result = handle_hwi_subcommand(network, &hwi_opts, subcommand).await?;
+            Ok(serde_json::to_string_pretty(&result).map_err(|e| Error::SerdeJson(e))?)
+        }
     };
     result
 }

src/handlers.rs

@@ -26,8 +26,9 @@ use bdk_kyoto::{
 use bdk_wallet::bitcoin::{Address, Network, OutPoint, ScriptBuf};
 #[cfg(feature = "hwi")]
 use {
+    crate::commands::HwiOpts,
     async_hwi::jade::{self, Jade},
-    async_hwi::ledger::{HidApi, LedgerSimulator},
+    async_hwi::ledger::{HidApi, Ledger, LedgerSimulator, TransportHID},
     async_hwi::specter::{Specter, SpecterSimulator},
     async_hwi::{
         bitbox::api::runtime,
@@ -394,14 +395,8 @@ pub(crate) fn shorten(displayable: impl Display, start: u8, end: u8) -> String {
 #[cfg(feature="hwi")]
 pub async fn connect_to_hardware_wallet(
     network: Network,
-    wallet_opts: &WalletOpts,
-    wallet: Option<&Wallet>,
+    hwi_opts: &HwiOpts,
 ) -> Result<Option<Box<dyn HWI + Send>>, Error> {
-    let wallet_name = &wallet_opts.wallet;
-    let ext_descriptor = &wallet_opts.ext_descriptor;
-
-    // TODO: add Ledger implementation
-
     if let Ok(device) = SpecterSimulator::try_connect().await {
         return Ok(Some(device.into()));
     }
@@ -414,7 +409,7 @@ pub async fn connect_to_hardware_wallet(
 
     match Jade::enumerate().await {
         Err(e) => {
-            println!("Jade enumeration error: {:?}", e);
+            println!("Jade enumeration error: {e:?}");
         }
         Ok(devices) => {
             for device in devices {
@@ -436,28 +431,32 @@ pub async fn connect_to_hardware_wallet(
         return Ok(Some(device.into()));
     }
 
-    let api = Box::new(
-        HidApi::new().map_err(|e| Error::HwiError(async_hwi::Error::Device(e.to_string())))?,
-    );
+    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::HwiError(async_hwi::Error::Device(e.to_string())))
+                .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);
-                        if let Some(_wallet) = wallet.as_ref() {
-                            if let Some(policy) = ext_descriptor {
-                                bb02 =
-                                    bb02.with_policy(policy.as_str()).map_err(Error::HwiError)?;
-                            }
-                        }
+                        bb02 = bb02
+                            .with_policy(&ext_descriptor.as_str())
+                            .map_err(Error::HwiError)?;
                         return Ok(Some(bb02.into()));
                     }
                 }
@@ -468,26 +467,35 @@ pub async fn connect_to_hardware_wallet(
         {
             if let Some(sn) = device_info.serial_number() {
                 if let Ok((cc, _)) = coldcard::api::Coldcard::open(&api, sn, None)
-                    .map_err(|e| Error::HwiError(async_hwi::Error::Device(e.to_string())))
+                    .map_err(|e| Error::Generic(e.to_string()))
                 {
                     let mut hw = coldcard::Coldcard::from(cc);
-                    if let Some(_wallet) = wallet {
-                        hw = hw.with_wallet_name(
-                            wallet_name
-                                .clone()
-                                .ok_or_else(|| {
-                                    Error::HwiError(async_hwi::Error::Device(
-                                        "coldcard requires a wallet name".into(),
-                                    ))
-                                })?
-                                .to_string(),
-                        );
-                    }
+                    hw = hw.with_wallet_name(wallet_name.to_string());
                     return Ok(Some(hw.into()));
                 }
             }
         }
     }
 
+    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()));
+        }
+    }
+
     Ok(None)
 }