Struct hwi::interface::HWIClient

pub struct HWIClient { /* private fields */ }

Implementations

impl HWIClient

pub fn enumerate() -> Result<Vec<HWIDevice>, Error>

Lists all HW devices currently connected.

let devices = HWIClient::enumerate()?;
for device in devices {
    println!("I can see a {} here 😄", device.model);
}

pub fn get_client(
    device: &HWIDevice,
    expert: bool,
    chain: HWIChain
) -> Result<HWIClient, Error>

Returns the HWIClient for a certain device. You can list all the available devices using enumerate.

Setting expert to true will enable additional output for some commands.

let devices = HWIClient::enumerate()?;
for device in devices {
    let client = HWIClient::get_client(&device, false, HWIChain::Test)?;
    let xpub = client.get_master_xpub(HWIAddressType::Tap, 0)?;
    println!(
        "I can see a {} here, and its xpub is {}",
        device.model,
        xpub.to_string()
    );
}

pub fn get_master_xpub(
    &self,
    addrtype: HWIAddressType,
    account: u32
) -> Result<HWIExtendedPubKey, Error>

Returns the master xpub of a device, given the address type and the account number.

pub fn sign_tx(
    &self,
    psbt: &PartiallySignedTransaction
) -> Result<HWIPartiallySignedTransaction, Error>

Signs a PSBT.

pub fn get_xpub(
    &self,
    path: &DerivationPath,
    expert: bool
) -> Result<HWIExtendedPubKey, Error>

Returns the xpub of a device. If expert is set, additional output is returned.

pub fn sign_message(
    &self,
    message: &str,
    path: &DerivationPath
) -> Result<HWISignature, Error>

Signs a message.

pub fn get_keypool(
    &self,
    keypool: bool,
    internal: bool,
    addr_type: HWIAddressType,
    addr_all: bool,
    account: Option<u32>,
    path: Option<&DerivationPath>,
    start: u32,
    end: u32
) -> Result<Vec<HWIKeyPoolElement>, Error>

Returns an array of keys that can be imported in Bitcoin core using importmulti

• keypool - keypool value in result. Check bitcoin core importmulti documentation for further information
• internal - Whether to use internal (change) or external keys
• addr_type - Address type to use
• addr_all - Whether to return a multiple descriptors for every address type
• account - Optional BIP43 account to use
• path - The derivation path to derive the keys.
• start - Keypool start
• end - Keypool end

pub fn get_descriptors(
    &self,
    account: Option<u32>
) -> Result<HWIDescriptor, Error>

Returns device descriptors. You can optionally specify a BIP43 account to use.

pub fn display_address_with_desc(
    &self,
    descriptor: &str
) -> Result<HWIAddress, Error>

Returns an address given a descriptor. Note that HWI doesn’t support descriptors checksums.

pub fn display_address_with_path(
    &self,
    path: &DerivationPath,
    address_type: HWIAddressType
) -> Result<HWIAddress, Error>

Returns an address given path and address type.

pub fn install_udev_rules(
    source: Option<&str>,
    location: Option<&str>
) -> Result<(), Error>

Install the udev rules to the local machine.

The rules will be copied from the source to the location; the default source location is ./udev, the default destination location is /lib/udev/rules.d

pub fn set_log_level(level: LogLevel) -> Result<(), Error>

Set logging level

Arguments

• level - Log level.

pub fn toggle_passphrase(&self) -> Result<(), Error>

Toggle whether the device is using a BIP 39 passphrase.

pub fn wipe_device(&self) -> Result<(), Error>

Wipe a device

pub fn get_version() -> Option<String>

Get the installed version of hwilib. Returns None if hwi is not installed.

pub fn install_hwilib(version: Option<&str>) -> Result<(), Error>

Install hwi for the current user via pip. If no version is specified, the default version from pip will be installed.

Trait Implementations

impl Debug for HWIClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for HWIClient

type Target = Py<PyAny>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.