bhwi-cli: command to enumerate devices

The main goal of this change is to add a command to bhwi-cli that enumerates all
supported devices and displays information (ex. fingerprint) about them so that
the user can interact with a device.

Lots of tangential changes have also been made as I was trying to build out a
decent foundation for adding device enumeration.

Large refactors were done in order to make it possible to have heterogeneous
vectors of devices. It's not a major benefit but it makes the cli code nicer.
This includes the creation of the HWIDevice trait and making error types use
thiserror to implement std::error::Error. This also required the bhwi-wasm
errors to be changed from JsValue to a wrapper error, WasmError, which converts
the errors to strings. Not ideal, but could not find a better solution right
now.

Lots of the Transports from the e2e crates were moved around and changed for
re-usability between the cli crate e2e tests.

The rest of the changes were simply writing the Transports (HID and serial
backends) used for the currently supported devices.

Author: trevarj

Cargo.lock

@@ -21,4 +21,5 @@ reqwest = "0.13.2"
 serde = "1.0.228"
 serde_json = "1.0.149"
 serde_cbor = "0.11.2"
+thiserror = "1"
 tokio = "1.0"

Cargo.toml

@@ -23,5 +23,6 @@ hex = { workspace = true, optional = true}
 serde = { workspace = true, optional = true}
 serde_cbor = { workspace = true, optional = true}
 serde_json = { workspace = true, optional = true}
+thiserror.workspace = true
 
 byteorder = "1.5"

bhwi-async/Cargo.toml

@@ -3,7 +3,7 @@ pub mod jade;
 pub mod ledger;
 pub mod transport;
 
-use std::fmt::Debug;
+use std::{error::Error as StdError, fmt::Debug};
 
 use async_trait::async_trait;
 use bhwi::{
@@ -20,19 +20,19 @@ pub use ledger::Ledger;
 
 #[async_trait(?Send)]
 pub trait Transport {
-    type Error: Debug;
+    type Error: StdError + Send + Sync + Debug + 'static;
     async fn exchange(&mut self, command: &[u8], encrypted: bool) -> Result<Vec<u8>, Self::Error>;
 }
 
 #[async_trait(?Send)]
 pub trait HttpClient {
-    type Error: Debug;
+    type Error: StdError + Send + Sync + Debug + 'static;
     async fn request(&self, url: &str, request: &[u8]) -> Result<Vec<u8>, Self::Error>;
 }
 
 #[async_trait(?Send)]
 pub trait HWI {
-    type Error: Debug;
+    type Error: StdError + Send + Sync + Debug + 'static;
     async fn unlock(&mut self, network: Network) -> Result<(), Self::Error>;
     async fn get_master_fingerprint(&mut self) -> Result<Fingerprint, Self::Error>;
     async fn get_extended_pubkey(
@@ -47,19 +47,51 @@ pub trait HWI {
     ) -> Result<(u8, Signature), Self::Error>;
 }
 
-#[derive(Debug)]
-pub enum Error<E, F> {
-    Transport(E),
-    HttpClient(F),
-    Interpreter(common::Error),
+// TODO: this will become a pain to maintain, but we can have a proc-macro
+// generate this trait by putting it over HWI's definition and then also
+// generate the blanket impl which will map the errors to HWIDeviceError
+#[async_trait(?Send)]
+pub trait HWIDevice {
+    async fn unlock(&mut self, network: Network) -> Result<(), HWIDeviceError>;
+    async fn get_master_fingerprint(&mut self) -> Result<Fingerprint, HWIDeviceError>;
+    async fn get_extended_pubkey(
+        &mut self,
+        path: DerivationPath,
+        display: bool,
+    ) -> Result<Xpub, HWIDeviceError>;
+    async fn sign_message(
+        &mut self,
+        message: &[u8],
+        path: DerivationPath,
+    ) -> Result<(u8, Signature), HWIDeviceError>;
 }
 
-impl<E, F> From<common::Error> for Error<E, F> {
-    fn from(value: common::Error) -> Self {
-        Self::Interpreter(value)
+#[derive(Debug, thiserror::Error)]
+#[error("hwi device error: {0}")]
+pub struct HWIDeviceError(#[from] Box<dyn StdError + Send + Sync + 'static>);
+
+impl HWIDeviceError {
+    pub fn new(error: impl StdError + Send + Sync + 'static) -> Self {
+        Self(Box::new(error))
     }
 }
 
+#[derive(Debug, thiserror::Error)]
+pub enum Error<E, F>
+where
+    E: StdError + Send + Sync + 'static,
+    F: StdError + Send + Sync + 'static,
+{
+    #[error("transport error: {0}")]
+    Transport(E),
+
+    #[error("http client error: {0}")]
+    HttpClient(F),
+
+    #[error("interpreter error: {0}")]
+    Interpreter(#[from] common::Error),
+}
+
 #[async_trait(?Send)]
 impl<D> HWI for D
 where
@@ -126,13 +158,52 @@ where
     }
 }
 
+#[async_trait(?Send)]
+impl<T> HWIDevice for T
+where
+    T: HWI,
+    T::Error: StdError + Send + Sync + 'static,
+{
+    async fn unlock(&mut self, network: Network) -> Result<(), HWIDeviceError> {
+        HWI::unlock(self, network)
+            .await
+            .map_err(HWIDeviceError::new)
+    }
+
+    async fn get_master_fingerprint(&mut self) -> Result<Fingerprint, HWIDeviceError> {
+        HWI::get_master_fingerprint(self)
+            .await
+            .map_err(HWIDeviceError::new)
+    }
+
+    async fn get_extended_pubkey(
+        &mut self,
+        path: DerivationPath,
+        display: bool,
+    ) -> Result<Xpub, HWIDeviceError> {
+        HWI::get_extended_pubkey(self, path, display)
+            .await
+            .map_err(HWIDeviceError::new)
+    }
+
+    async fn sign_message(
+        &mut self,
+        message: &[u8],
+        path: DerivationPath,
+    ) -> Result<(u8, Signature), HWIDeviceError> {
+        HWI::sign_message(self, message, path)
+            .await
+            .map_err(HWIDeviceError::new)
+    }
+}
+
 pub trait OnUnlock {
     fn on_unlock(&mut self, _response: common::Response) -> Result<(), common::Error>;
 }
 
 pub trait CommonInterface<C, T, R, E> {
-    type TransportError: Debug;
-    type HttpClientError: Debug;
+    type TransportError: StdError + Send + Sync + Debug + 'static;
+    type HttpClientError: StdError + Send + Sync + Debug + 'static;
 
     #[allow(clippy::type_complexity)]
     fn components(
@@ -144,13 +215,13 @@ pub trait CommonInterface<C, T, R, E> {
     );
 }
 
-async fn run_command<'a, D, C, E, F>(
-    device: &'a mut D,
+async fn run_command<D, C, E, F>(
+    device: &mut D,
     command: C,
 ) -> Result<common::Response, Error<E, F>>
 where
-    E: std::fmt::Debug + 'a,
-    F: std::fmt::Debug + 'a,
+    E: StdError + Send + Sync + std::fmt::Debug + 'static,
+    F: StdError + Send + Sync + std::fmt::Debug + 'static,
     D: CommonInterface<
             common::Command,
             common::Transmit,

bhwi-async/src/lib.rs

@@ -1,20 +1,18 @@
 use crate::{Transport, transport::Channel};
 use async_trait::async_trait;
 
-pub const COLDCARD_VID: u16 = 0xd13e;
+pub use bhwi::coldcard::COLDCARD_DEVICE_ID;
+
 const COLDCARD_PACKET_WRITE_SIZE: usize = 63;
 const COLDCARD_PACKET_READ_SIZE: usize = 64;
 
-#[derive(Debug)]
+#[derive(Debug, thiserror::Error)]
 pub enum ColdcardHIDError {
+    #[error("communication error: {0}")]
     Comm(&'static str),
-    Hid(std::io::Error),
-}
 
-impl From<std::io::Error> for ColdcardHIDError {
-    fn from(value: std::io::Error) -> Self {
-        ColdcardHIDError::Hid(value)
-    }
+    #[error("HID IO error")]
+    Hid(#[from] std::io::Error),
 }
 
 pub struct ColdcardTransportHID<C> {

bhwi-async/src/transport/coldcard/hid.rs

@@ -1 +1,2 @@
+pub use bhwi::coldcard::DEFAULT_CKCC_SOCKET;
 pub mod hid;

bhwi-async/src/transport/coldcard/mod.rs

@@ -1,2 +1,4 @@
+pub use bhwi::jade::JADE_DEVICE_IDS;
+
 #[cfg(feature = "emulators")]
 pub mod tcp;

bhwi-async/src/transport/jade/mod.rs

@@ -1,5 +1,3 @@
-use std::fmt::Debug;
-
 use async_trait::async_trait;
 use serde_cbor::Value;
 
@@ -17,15 +15,13 @@ impl<C> TcpTransport<C> {
 
 #[async_trait(?Send)]
 pub trait TcpClient {
-    type Error: Debug + From<serde_cbor::Error>;
-
-    async fn write_all(&mut self, command: &[u8]) -> Result<(), Self::Error>;
-    async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>;
+    async fn write_all(&mut self, command: &[u8]) -> Result<(), std::io::Error>;
+    async fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error>;
 }
 
 #[async_trait(?Send)]
 impl<C: TcpClient> Transport for TcpTransport<C> {
-    type Error = <C as TcpClient>::Error;
+    type Error = std::io::Error;
 
     async fn exchange(&mut self, command: &[u8], _encrypted: bool) -> Result<Vec<u8>, Self::Error> {
         self.client.write_all(command).await?;
@@ -47,7 +43,7 @@ impl<C: TcpClient> Transport for TcpTransport<C> {
                     continue; // read more bytes
                 }
                 Err(e) => {
-                    return Err(e.into());
+                    return Err(std::io::Error::other(e));
                 }
             }
         }

bhwi-async/src/transport/jade/tcp.rs

@@ -14,36 +14,32 @@
 *  limitations under the License.
 ********************************************************************************/
 use async_trait::async_trait;
+pub use bhwi::ledger::LEDGER_DEVICE_ID;
 use byteorder::{BigEndian, ReadBytesExt};
 use std::io::Cursor;
 
 use crate::{Transport, transport::Channel};
 
-pub const LEDGER_VID: u16 = 0x2c97;
-pub const LEDGER_USAGE_PAGE: u16 = 0xFFA0;
 pub const LEDGER_CHANNEL: u16 = 0x0101;
 // for Windows compatability, we prepend the buffer with a 0x00
 // so the actual buffer is 64 bytes
 const LEDGER_PACKET_WRITE_SIZE: u8 = 64;
 const LEDGER_PACKET_READ_SIZE: u8 = 64;
 
-#[derive(Debug)]
+#[derive(Debug, thiserror::Error)]
 pub enum LedgerHIDError {
+    #[error("communication error: {0}")]
     Comm(&'static str),
-    Hid(std::io::Error),
-}
 
-impl From<std::io::Error> for LedgerHIDError {
-    fn from(value: std::io::Error) -> Self {
-        LedgerHIDError::Hid(value)
-    }
+    #[error("HID IO error")]
+    Hid(#[from] std::io::Error),
 }
 
-pub struct LedgerTransportHID<C> {
+pub struct LedgerTransportHID<C: Channel> {
     channel: C,
 }
 
-impl<C> LedgerTransportHID<C> {
+impl<C: Channel> LedgerTransportHID<C> {
     pub fn new(channel: C) -> Self {
         Self { channel }
     }