bdk/crates/hwi/src/signer.rs

use bdk_wallet::bitcoin::bip32::Fingerprint;
use bdk_wallet::bitcoin::secp256k1::{All, Secp256k1};
use bdk_wallet::bitcoin::Psbt;

use hwi::error::Error;
use hwi::types::{HWIChain, HWIDevice};
use hwi::HWIClient;

use bdk_wallet::signer::{SignerCommon, SignerError, SignerId, TransactionSigner};

#[derive(Debug)]
/// Custom signer for Hardware Wallets
///
/// This ignores `sign_options` and leaves the decisions up to the hardware wallet.
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 Psbt,
        _sign_options: &bdk_wallet::SignOptions,
        _secp: &Secp256k1<All>,
    ) -> Result<(), SignerError> {
        psbt.combine(
            self.client
                .sign_tx(psbt)
                .map_err(|e| {
                    SignerError::External(format!("While signing with hardware wallet: {}", e))
                })?
                .psbt,
        )
        .expect("Failed to combine HW signed psbt with passed PSBT");
        Ok(())
    }
}

// TODO: re-enable this once we have the `get_funded_wallet` test util
// #[cfg(test)]
// mod tests {
//     #[test]
//     fn test_hardware_signer() {
//         use std::sync::Arc;
//
//         use bdk_wallet::tests::get_funded_wallet;
//         use bdk_wallet::signer::SignerOrdering;
//         use bdk_wallet::bitcoin::Network;
//         use crate::HWISigner;
//         use hwi::HWIClient;
//
//         let mut devices = HWIClient::enumerate().unwrap();
//         if devices.is_empty() {
//             panic!("No devices found!");
//         }
//         let device = devices.remove(0).unwrap();
//         let client = HWIClient::get_client(&device, true, Network::Regtest.into()).unwrap();
//         let descriptors = client.get_descriptors::<String>(None).unwrap();
//         let custom_signer = HWISigner::from_device(&device, Network::Regtest.into()).unwrap();
//
//         let (mut wallet, _) = get_funded_wallet(&descriptors.internal[0]);
//         wallet.add_signer(
//             bdk_wallet::KeychainKind::External,
//             SignerOrdering(200),
//             Arc::new(custom_signer),
//         );
//
//         let addr = wallet.get_address(bdk_wallet::AddressIndex::LastUnused);
//         let mut builder = wallet.build_tx();
//         builder.drain_to(addr.script_pubkey()).drain_wallet();
//         let (mut psbt, _) = builder.finish().unwrap();
//
//         let finalized = wallet.sign(&mut psbt, Default::default()).unwrap();
//         assert!(finalized);
//     }
// }