Add a custom signer for hardware wallets

Author: wszdexdrf

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add `Excess` enum to handle remaining amount after coin selection.
 - Move change creation from `Wallet::create_tx` to `CoinSelectionAlgorithm::coin_select`.
 - Change the interface of `SqliteDatabase::new` to accept any type that implement AsRef<Path>
+- Add a custom Signer for Hardware Wallets.
 
 ## [v0.20.0] - [v0.19.0]
 

Cargo.toml

@@ -33,6 +33,7 @@ rocksdb = { version = "0.14", default-features = false, features = ["snappy"], o
 cc = { version = ">=1.0.64", optional = true }
 socks = { version = "0.3", optional = true }
 lazy_static = { version = "1.4", optional = true }
+hwi = { git = "https://github.com/bitcoindevkit/rust-hwi.git", optional = true }
 
 bip39 = { version = "1.0.1", optional = true }
 bitcoinconsensus = { version = "0.19.0-3", optional = true }
@@ -61,6 +62,7 @@ key-value-db = ["sled"]
 all-keys = ["keys-bip39"]
 keys-bip39 = ["bip39"]
 rpc = ["bitcoincore-rpc"]
+hardware-signer = ["hwi"]
 
 # We currently provide mulitple implementations of `Blockchain`, all are
 # blocking except for the `EsploraBlockchain` which can be either async or

src/hardwaresigner/mod.rs

@@ -0,0 +1,69 @@
+//! Hardware wallets
+//!
+//! This module contains modules required for working with Hardware Wallets
+
+pub mod signer;
+
+#[cfg(test)]
+mod tests {
+    use std::{str::FromStr, sync::Arc};
+
+    use bitcoin::{Address, Network};
+    use hwi::{types, HWIClient};
+
+    use crate::{
+        database::MemoryDatabase, hardwaresigner::signer::HWISigner, signer::SignerOrdering,
+        KeychainKind, SignOptions, Wallet,
+    };
+
+    fn get_first_device() -> HWIClient {
+        HWIClient::get_client(
+            HWIClient::enumerate().unwrap().first().expect(
+                "No devices found. Either plug in a hardware wallet, or start a simulator.",
+            ),
+            true,
+            types::HWIChain::Test,
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn test_create_signer() {
+        let descriptors = get_first_device().get_descriptors(None).unwrap();
+        let devices = HWIClient::enumerate().unwrap();
+        let custom_signer =
+            HWISigner::from_device(devices.first().unwrap(), types::HWIChain::Test).unwrap();
+
+        let mut wallet = Wallet::new(
+            &descriptors.internal[0],
+            Some(&descriptors.receive[0]),
+            Network::Testnet,
+            MemoryDatabase::default(),
+        )
+        .unwrap();
+        wallet.add_signer(
+            KeychainKind::External,
+            SignerOrdering(200),
+            Arc::new(custom_signer),
+        );
+
+        let client =
+            crate::electrum_client::Client::new("ssl://electrum.blockstream.info:60002").unwrap();
+        let blockchain = crate::blockchain::ElectrumBlockchain::from(client);
+        wallet
+            .sync(&blockchain, crate::SyncOptions::default())
+            .unwrap();
+
+        let balance = wallet.get_balance().unwrap();
+        let faucet_address = Address::from_str("mv4rnyY3Su5gjcDNzbMLKBQkBicCtHUtFB").unwrap();
+
+        let mut tx_builder = wallet.build_tx();
+        tx_builder
+            .add_recipient(faucet_address.script_pubkey(), balance / 2)
+            .enable_rbf();
+        let (mut psbt, _tx_details) = tx_builder.finish().unwrap();
+        let finalized = wallet.sign(&mut psbt, SignOptions::default()).unwrap();
+
+        assert!(finalized, "Tx has not been finalized");
+    }
+}

src/hardwaresigner/signer.rs

@@ -0,0 +1,52 @@
+//! HWI Signer
+//!
+//! This module contains a implementation of a Custom Signer for rust-hwi
+
+use bitcoin::{
+    psbt::PartiallySignedTransaction,
+    secp256k1::{All, Secp256k1},
+    util::bip32::Fingerprint,
+};
+use hwi::{
+    error::Error,
+    types::{HWIChain, HWIDevice},
+    HWIClient,
+};
+
+use crate::signer::{SignerCommon, SignerError, SignerId, TransactionSigner};
+
+#[derive(Debug)]
+/// Custom Signer for Hardware Wallets
+pub struct HWISigner {
+    fingerprint: Fingerprint,
+    client: HWIClient,
+}
+
+impl HWISigner {
+    /// Create a instance from the specified device and chain
+    pub fn from_device(device: &HWIDevice, chain: HWIChain) -> Result<HWISigner, Error> {
+        let client = HWIClient::get_client(device, false, chain)?;
+        Ok(HWISigner {
+            fingerprint: device.fingerprint,
+            client,
+        })
+    }
+}
+
+impl SignerCommon for HWISigner {
+    fn id(&self, _secp: &Secp256k1<All>) -> SignerId {
+        SignerId::Fingerprint(self.fingerprint)
+    }
+}
+
+impl TransactionSigner for HWISigner {
+    fn sign_transaction(
+        &self,
+        psbt: &mut PartiallySignedTransaction,
+        _secp: &Secp256k1<All>,
+    ) -> Result<(), SignerError> {
+        psbt.combine(self.client.sign_tx(psbt)?.psbt)
+            .expect("Failed to combine HW signed psbt with passed PSBT");
+        Ok(())
+    }
+}

src/lib.rs

@@ -265,6 +265,8 @@ pub mod database;
 pub mod descriptor;
 #[cfg(feature = "test-md-docs")]
 mod doctest;
+#[cfg(feature = "hardware-signer")]
+pub mod hardwaresigner;
 pub mod keys;
 pub(crate) mod psbt;
 pub(crate) mod types;

src/wallet/signer.rs

@@ -128,7 +128,7 @@ impl From<Fingerprint> for SignerId {
 }
 
 /// Signing error
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug)]
 pub enum SignerError {
     /// The private key is missing for the required public key
     MissingKey,
@@ -158,6 +158,16 @@ pub enum SignerError {
     InvalidSighash,
     /// Error while computing the hash to sign
     SighashError(sighash::Error),
+    /// Error while signing using hardware wallets
+    #[cfg(feature = "hardware-signer")]
+    HWIError(hwi::error::Error),
+}
+
+#[cfg(feature = "hardware-signer")]
+impl From<hwi::error::Error> for SignerError {
+    fn from(e: hwi::error::Error) -> Self {
+        SignerError::HWIError(e)
+    }
 }
 
 impl From<sighash::Error> for SignerError {