feat(hwi): add hwi sign subcommand

- add signing psbt with hardware wallet

Author: tvpeter

src/commands.rs

@@ -109,6 +109,14 @@ pub enum CliSubCommand {
         #[command(flatten)]
         wallet_opts: WalletOpts,
     },
+    /// Hardware wallet interface operations.
+    #[cfg(feature = "hwi")]
+    Hwi {
+        #[command(flatten)]
+        wallet_opts: WalletOpts,
+        #[clap(subcommand)]
+        subcommand: HwiSubCommand,
+    },
 }
 
 /// Wallet operation subcommands.
@@ -380,12 +388,6 @@ pub enum OfflineWalletSubCommand {
         #[arg(env = "BASE64_PSBT", required = true)]
         psbt: Vec<String>,
     },
-    #[cfg(feature = "hwi")]
-    /// Hardware wallet interface operations.
-    Hwi {
-        #[clap(subcommand)]
-        subcommand: HwiSubCommand,
-    },
 }
 
 /// Wallet subcommands that needs a blockchain backend.
@@ -474,6 +476,11 @@ pub enum HwiSubCommand {
     Register,
     /// Generate address
     Address,
+    /// Sign PSBT with hardware wallet
+    Sign {
+        /// The base64-encoded PSBT to sign
+        psbt: String,
+    },
 }
 
 /// Subcommands available in REPL mode.

src/handlers.rs

@@ -77,7 +77,7 @@ use {
 /// Execute an offline wallet sub-command
 ///
 /// Offline wallet sub-commands are described in [`OfflineWalletSubCommand`].
-pub async fn handle_offline_wallet_subcommand(
+pub fn handle_offline_wallet_subcommand(
     wallet: &mut Wallet,
     wallet_opts: &WalletOpts,
     offline_subcommand: OfflineWalletSubCommand,
@@ -330,56 +330,6 @@ pub async fn handle_offline_wallet_subcommand(
             )?;
             Ok(json!({ "psbt": BASE64_STANDARD.encode(final_psbt.serialize()) }))
         }
-        #[cfg(feature = "hwi")]
-        Hwi { subcommand } => match subcommand {
-            HwiSubCommand::Devices => {
-                let device = crate::utils::connect_to_hardware_wallet(
-                    wallet.network(),
-                    wallet_opts,
-                    Some(wallet),
-                )
-                .await?;
-                let device = if let Some(device) = device {
-                    json!({
-                        "type": device.device_kind().to_string(),
-                        "fingerprint": device.get_master_fingerprint().await?.to_string(),
-                        "model": device.device_kind().to_string(),
-                    })
-                } else {
-                    json!(null)
-                };
-                Ok(json!({ "devices": device }))
-            }
-            HwiSubCommand::Register => {
-                let policy = wallet_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(|| {
-                    Error::Generic("Wallet name is required for wallet registration".to_string())
-                })?;
-
-                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
-                };
-                //TODO: return status of wallet registration
-                Ok(json!({ "hmac": hmac }))
-            }
-            HwiSubCommand::Address => {
-                let address = wallet.next_unused_address(KeychainKind::External);
-                Ok(json!({ "address": address.address }))
-            }
-        },
     }
 }
 
@@ -793,6 +743,138 @@ pub(crate) fn handle_compile_subcommand(
     Ok(json!({"descriptor": descriptor.to_string()}))
 }
 
+/// Handle hardware wallet operations
+#[cfg(feature = "hwi")]
+pub async fn handle_hwi_subcommand(
+    network: Network,
+    wallet_opts: &WalletOpts,
+    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 {
+                json!({
+                    "type": device.device_kind().to_string(),
+                    "fingerprint": device.get_master_fingerprint().await?.to_string(),
+                    "model": device.device_kind().to_string(),
+                })
+            } else {
+                json!(null)
+            };
+            Ok(json!({ "devices": device }))
+        }
+        HwiSubCommand::Register => {
+            let policy = wallet_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(|| {
+                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 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 }))
+        }
+        HwiSubCommand::Address => {
+            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 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 signed_psbt = if let Some(device) = device {
+                device
+                    .sign_tx(&mut psbt)
+                    .await
+                    .map_err(|e| Error::Generic(format!("Failed to sign PSBT: {e}")))?;
+                Some(psbt.to_string())
+            } else {
+                None
+            };
+            Ok(json!({ "psbt": signed_psbt }))
+        }
+    }
+}
+
 /// The global top level handler.
 pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
     let network = cli_opts.network;
@@ -837,7 +919,7 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
                 wallet.persist(&mut persister)?;
                 result
             };
-            // #[cfg(not(any(feature = "sqlite")))]
+            #[cfg(not(any(feature = "sqlite")))]
             let result = {
                 let wallet = new_wallet(network, &wallet_opts)?;
                 let blockchain_client =
@@ -870,8 +952,7 @@ pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
 
                 let mut wallet = new_persisted_wallet(network, &mut persister, &wallet_opts)?;
                 let result =
-                    handle_offline_wallet_subcommand(&mut wallet, &wallet_opts, offline_subcommand)
-                        .await?;
+                    handle_offline_wallet_subcommand(&mut wallet, &wallet_opts, offline_subcommand);
                 wallet.persist(&mut persister)?;
                 result
             };
@@ -996,7 +1077,6 @@ async fn respond(
             subcommand: WalletSubCommand::OfflineWalletSubCommand(offline_subcommand),
         } => {
             let value = handle_offline_wallet_subcommand(wallet, wallet_opts, offline_subcommand)
-                .await
                 .map_err(|e| e.to_string())?;
             Some(value)
         }