Merge branch 'prodstrings'

benma · benma · commit 660fd5d49ed6 · 2025-07-17T10:44:46.000+02:00
diff --git a/CHANGELOG-npm.md b/CHANGELOG-npm.md
@@ -1,7 +1,8 @@
 # Changelog
 
-## [Unreleased]
+## 0.10.0
 - Add `bip85AppBip39()`
+- Add support for BitBox02 Nova
 
 ## 0.9.1
 - WebHID: Automatically connect to a previoulsy connected device
diff --git a/CHANGELOG-rust.md b/CHANGELOG-rust.md
@@ -1,5 +1,8 @@
 # Changelog
 
+## 0.9.0
+- Add support for BitBox02 Nova
+
 ## 0.8.0
 - Add `bip85_app_bip39()`
 - Make the `simulator` feature work with the `multithreaded` feature
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,13 +1,13 @@
 [package]
 name = "bitbox-api"
 authors = ["Marko Bencun <benma@bitbox.swiss>"]
-version = "0.8.0"
+version = "0.9.0"
 homepage = "https://bitbox.swiss/"
 repository = "https://github.com/BitBoxSwiss/bitbox-api-rs/"
 readme = "README-rust.md"
 edition = "2021"
 license = "Apache-2.0"
-description = "A library to interact with the BitBox02 hardware wallet"
+description = "A library to interact with BitBox hardware wallets"
 keywords = ["bitbox", "api", "bitcoin", "wasm"]
 categories = ["api-bindings", "cryptography"]
 
diff --git a/ci.sh b/ci.sh
@@ -12,7 +12,7 @@ features=(
 examples=(
   "--example singlethreaded --features=usb,tokio/rt,tokio/macros"
   "--example multithreaded --features=usb,tokio/rt,tokio/macros,tokio/rt-multi-thread,multithreaded"
-  " --example btc_signtx --features=usb,tokio/rt,tokio/macros"
+  "--example btc_signtx --features=usb,tokio/rt,tokio/macros"
   "--example btc_sign_psbt --features=usb,tokio/rt,tokio/macros"
   "--example btc_sign_msg --features=usb,tokio/rt,tokio/macros"
   "--example btc_miniscript --features=usb,tokio/rt,tokio/macros"
diff --git a/examples/btc_miniscript.rs b/examples/btc_miniscript.rs
@@ -12,7 +12,7 @@ async fn get_bitbox02() -> bitbox_api::PairedBitBox<bitbox_api::runtime::TokioRu
     .unwrap();
     let pairing_bitbox = bitbox.unlock_and_pair().await.unwrap();
     if let Some(pairing_code) = pairing_bitbox.get_pairing_code().as_ref() {
-        println!("Pairing code\n{}", pairing_code);
+        println!("Pairing code\n{pairing_code}");
     }
     pairing_bitbox.wait_confirm().await.unwrap()
 }
diff --git a/examples/btc_sign_msg.rs b/examples/btc_sign_msg.rs
@@ -10,7 +10,7 @@ async fn signmsg<R: bitbox_api::runtime::Runtime>() {
     .unwrap();
     let pairing_bitbox = bitbox.unlock_and_pair().await.unwrap();
     if let Some(pairing_code) = pairing_bitbox.get_pairing_code().as_ref() {
-        println!("Pairing code\n{}", pairing_code);
+        println!("Pairing code\n{pairing_code}");
     }
     let paired_bitbox = pairing_bitbox.wait_confirm().await.unwrap();
 
@@ -27,7 +27,7 @@ async fn signmsg<R: bitbox_api::runtime::Runtime>() {
         .btc_sign_message(pb::BtcCoin::Btc, script_config_sign_msg, b"message")
         .await
         .unwrap();
-    println!("Signature: {:?}", signature);
+    println!("Signature: {signature:?}");
 }
 
 #[tokio::main(flavor = "current_thread")]
diff --git a/examples/btc_sign_psbt.rs b/examples/btc_sign_psbt.rs
@@ -11,7 +11,7 @@ async fn sign_psbt<R: bitbox_api::runtime::Runtime>(psbt: &mut bitcoin::psbt::Ps
     .unwrap();
     let pairing_device = d.unlock_and_pair().await.unwrap();
     if let Some(pairing_code) = pairing_device.get_pairing_code().as_ref() {
-        println!("Pairing code\n{}", pairing_code);
+        println!("Pairing code\n{pairing_code}");
     }
     let paired = pairing_device.wait_confirm().await.unwrap();
     paired
@@ -33,5 +33,5 @@ async fn main() {
     let mut psbt = bitcoin::psbt::Psbt::from_str(buffer.trim()).unwrap();
     sign_psbt::<bitbox_api::runtime::TokioRuntime>(&mut psbt).await;
     println!("signed:");
-    println!("{}", psbt);
+    println!("{psbt}");
 }
diff --git a/examples/btc_signtx.rs b/examples/btc_signtx.rs
@@ -10,7 +10,7 @@ async fn signtx<R: bitbox_api::runtime::Runtime>() {
     .unwrap();
     let pairing_bitbox = bitbox.unlock_and_pair().await.unwrap();
     if let Some(pairing_code) = pairing_bitbox.get_pairing_code().as_ref() {
-        println!("Pairing code\n{}", pairing_code);
+        println!("Pairing code\n{pairing_code}");
     }
     let paired_bitbox = pairing_bitbox.wait_confirm().await.unwrap();
 
diff --git a/examples/cardano.rs b/examples/cardano.rs
@@ -10,7 +10,7 @@ async fn demo<R: bitbox_api::runtime::Runtime>() {
     .unwrap();
     let pairing_bitbox = bitbox.unlock_and_pair().await.unwrap();
     if let Some(pairing_code) = pairing_bitbox.get_pairing_code().as_ref() {
-        println!("Pairing code\n{}", pairing_code);
+        println!("Pairing code\n{pairing_code}");
     }
     let paired_bitbox = pairing_bitbox.wait_confirm().await.unwrap();
 
@@ -22,7 +22,7 @@ async fn demo<R: bitbox_api::runtime::Runtime>() {
         ])
         .await
         .unwrap();
-    println!("Xpubs: {:?}", xpubs);
+    println!("Xpubs: {xpubs:?}");
 
     println!("Getting an address...");
     let address = paired_bitbox
@@ -36,7 +36,7 @@ async fn demo<R: bitbox_api::runtime::Runtime>() {
         )
         .await
         .unwrap();
-    println!("Address: {}", address);
+    println!("Address: {address}");
 
     println!("Signing a transaction with tokens...");
     let change_config = bitbox_api::cardano::make_script_config_pkh_skh(
@@ -101,7 +101,7 @@ async fn demo<R: bitbox_api::runtime::Runtime>() {
         .cardano_sign_transaction(transaction)
         .await
         .unwrap();
-    println!("Witness: {:?}", witness);
+    println!("Witness: {witness:?}");
 
     println!("Delegating to a staking pool...");
     let transaction = pb::CardanoSignTransactionRequest {
@@ -156,7 +156,7 @@ async fn demo<R: bitbox_api::runtime::Runtime>() {
         .cardano_sign_transaction(transaction)
         .await
         .unwrap();
-    println!("Witness: {:?}", witness);
+    println!("Witness: {witness:?}");
 
     println!("Withdrawing staking rewards...");
     let transaction = pb::CardanoSignTransactionRequest {
@@ -194,7 +194,7 @@ async fn demo<R: bitbox_api::runtime::Runtime>() {
         .cardano_sign_transaction(transaction)
         .await
         .unwrap();
-    println!("Witness: {:?}", witness);
+    println!("Witness: {witness:?}");
 }
 
 #[tokio::main(flavor = "current_thread")]
diff --git a/examples/eth.rs b/examples/eth.rs
@@ -56,7 +56,7 @@ async fn eth_demo<R: bitbox_api::runtime::Runtime>() {
     .unwrap();
     let pairing_bitbox = bitbox.unlock_and_pair().await.unwrap();
     if let Some(pairing_code) = pairing_bitbox.get_pairing_code().as_ref() {
-        println!("Pairing code\n{}", pairing_code);
+        println!("Pairing code\n{pairing_code}");
     }
     let paired_bitbox = pairing_bitbox.wait_confirm().await.unwrap();
 
@@ -65,14 +65,14 @@ async fn eth_demo<R: bitbox_api::runtime::Runtime>() {
         .eth_xpub(&"m/44'/60'/0'/0".try_into().unwrap())
         .await
         .unwrap();
-    println!("Xpub: {}", xpub);
+    println!("Xpub: {xpub}");
 
     println!("Verifying address...");
     let address = paired_bitbox
         .eth_address(1, &"m/44'/60'/0'/0/0".try_into().unwrap(), true)
         .await
         .unwrap();
-    println!("Address: {}", address);
+    println!("Address: {address}");
 
     println!("Signing a tx...");
     let raw_tx = hex::decode("f86e821fdc850165a0bc008252089404f264cf34440313b4a0192a352814fbe927b88588075cf1259e9c40008025a015c94c1a3da0abc0a9124d2837809ccc493c41504e4571bcc340eeb68a91f641a03599011d4cda2c33dd3b00071ec145335e5d2dd5ed812d5eebeecba5264ed1bf").unwrap();
diff --git a/examples/multithreaded.rs b/examples/multithreaded.rs
@@ -10,7 +10,7 @@ async fn demo<R: bitbox_api::runtime::Runtime + Sync + Send>() {
     .unwrap();
     let pairing_bitbox = bitbox.unlock_and_pair().await.unwrap();
     if let Some(pairing_code) = pairing_bitbox.get_pairing_code().as_ref() {
-        println!("Pairing code\n{}", pairing_code);
+        println!("Pairing code\n{pairing_code}");
     }
     multithreading_type_check(&pairing_bitbox);
     let paired_bitbox = pairing_bitbox.wait_confirm().await.unwrap();
diff --git a/examples/singlethreaded.rs b/examples/singlethreaded.rs
@@ -8,7 +8,7 @@ async fn demo<R: bitbox_api::runtime::Runtime>() {
     .unwrap();
     let pairing_bitbox = bitbox.unlock_and_pair().await.unwrap();
     if let Some(pairing_code) = pairing_bitbox.get_pairing_code().as_ref() {
-        println!("Pairing code\n{}", pairing_code);
+        println!("Pairing code\n{pairing_code}");
     }
     let paired_bitbox = pairing_bitbox.wait_confirm().await.unwrap();
     println!(
diff --git a/sandbox/package-lock.json b/sandbox/package-lock.json
diff --git a/src/cardano.rs b/src/cardano.rs
@@ -89,7 +89,7 @@ impl<R: Runtime> PairedBitBox<R> {
 
     /// Does this device support Cardano functionality? Currently this means BitBox02 Multi.
     pub fn cardano_supported(&self) -> bool {
-        matches!(self.product(), crate::Product::BitBox02Multi)
+        self.is_multi_edition()
     }
 
     /// Query the device for xpubs. The result contains one xpub per requested keypath. Each xpub is
diff --git a/src/communication.rs b/src/communication.rs
@@ -151,6 +151,8 @@ pub enum Product {
     Unknown,
     BitBox02Multi,
     BitBox02BtcOnly,
+    BitBox02NovaMulti,
+    BitBox02NovaBtcOnly,
 }
 
 #[derive(Debug)]
@@ -187,6 +189,7 @@ async fn get_info(communication: &dyn ReadWrite) -> Result<Info, Error> {
 
     let version = semver::Version::parse(version_str).or(Err(Error::Info))?;
     const PLATFORM_BITBOX02: u8 = 0x00;
+    const PLATFORM_BITBOX02_NOVA: u8 = 0x02;
     const BITBOX02_EDITION_MULTI: u8 = 0x00;
     const BITBOX02_EDITION_BTCONLY: u8 = 0x01;
     let platform_byte = *response.first().ok_or(Error::Info)?;
@@ -198,6 +201,8 @@ async fn get_info(communication: &dyn ReadWrite) -> Result<Info, Error> {
         product: match (platform_byte, edition_byte) {
             (PLATFORM_BITBOX02, BITBOX02_EDITION_MULTI) => Product::BitBox02Multi,
             (PLATFORM_BITBOX02, BITBOX02_EDITION_BTCONLY) => Product::BitBox02BtcOnly,
+            (PLATFORM_BITBOX02_NOVA, BITBOX02_EDITION_MULTI) => Product::BitBox02NovaMulti,
+            (PLATFORM_BITBOX02_NOVA, BITBOX02_EDITION_BTCONLY) => Product::BitBox02NovaBtcOnly,
             _ => Product::Unknown,
         },
         unlocked: match unlocked_byte {
diff --git a/src/eth.rs b/src/eth.rs
@@ -38,7 +38,7 @@ impl<R: Runtime> PairedBitBox<R> {
 
     /// Does this device support ETH functionality? Currently this means BitBox02 Multi.
     pub fn eth_supported(&self) -> bool {
-        matches!(self.product(), crate::Product::BitBox02Multi)
+        self.is_multi_edition()
     }
 
     /// Query the device for an xpub.
@@ -205,10 +205,10 @@ fn parse_type(
     if typ.ends_with(']') {
         let index = typ
             .rfind('[')
-            .ok_or(format!("Invalid type format: {}", typ))?;
+            .ok_or(format!("Invalid type format: {typ}"))?;
         let (rest, size) = (&typ[..index], &typ[index + 1..typ.len() - 1]);
         let size_int = if !size.is_empty() {
-            u32::from_str(size).map_err(|e| format!("Error parsing size: {}", e))?
+            u32::from_str(size).map_err(|e| format!("Error parsing size: {e}"))?
         } else {
             0
         };
@@ -221,7 +221,7 @@ fn parse_type(
         })
     } else if let Some(size) = typ.strip_prefix("bytes") {
         let size_int = if !size.is_empty() {
-            u32::from_str(size).map_err(|e| format!("Error parsing size: {}", e))?
+            u32::from_str(size).map_err(|e| format!("Error parsing size: {e}"))?
         } else {
             0
         };
@@ -235,7 +235,7 @@ fn parse_type(
         if size.is_empty() {
             return Err("uint must be sized".to_string());
         }
-        let size_int = u32::from_str(size).map_err(|e| format!("Error parsing size: {}", e))? / 8;
+        let size_int = u32::from_str(size).map_err(|e| format!("Error parsing size: {e}"))? / 8;
         Ok(MemberType {
             r#type: DataType::Uint.into(),
             size: size_int,
@@ -246,7 +246,7 @@ fn parse_type(
         if size.is_empty() {
             return Err("int must be sized".to_string());
         }
-        let size_int = u32::from_str(size).map_err(|e| format!("Error parsing size: {}", e))? / 8;
+        let size_int = u32::from_str(size).map_err(|e| format!("Error parsing size: {e}"))? / 8;
         Ok(MemberType {
             r#type: DataType::Int.into(),
             size: size_int,
@@ -282,7 +282,7 @@ fn parse_type(
             array_type: None,
         })
     } else {
-        Err(format!("Can't recognize type: {}", typ))
+        Err(format!("Can't recognize type: {typ}"))
     }
 }
 
@@ -303,7 +303,7 @@ fn encode_value(typ: &MemberType, value: &Value) -> Result<Vec<u8>, String> {
             Value::String(v) => {
                 if v.starts_with("0x") || v.starts_with("0X") {
                     Ok(BigUint::parse_bytes(&v.as_bytes()[2..], 16)
-                        .ok_or(format!("could not parse {} as hex", v))?
+                        .ok_or(format!("could not parse {v} as hex"))?
                         .to_bytes_be())
                 } else {
                     Ok(BigUint::from_str(v)
diff --git a/src/lib.rs b/src/lib.rs
@@ -346,6 +346,13 @@ impl<R: Runtime> PairedBitBox<R> {
         self.communication.info.product
     }
 
+    fn is_multi_edition(&self) -> bool {
+        matches!(
+            self.product(),
+            crate::Product::BitBox02Multi | crate::Product::BitBox02NovaMulti
+        )
+    }
+
     /// Returns the firmware version.
     pub fn version(&self) -> &semver::Version {
         &self.communication.info.version
diff --git a/src/u2fframing.rs b/src/u2fframing.rs
@@ -83,11 +83,13 @@ pub fn generate_cid() -> u32 {
 
 // U2FWS (U2F WebSocket framing protocol) writes u2fhid header and payload as single package (up to
 // 7+7609 bytes)
+#[cfg(feature = "wasm")]
 pub struct U2fWs {
     cid: u32,
     cmd: u8,
 }
 
+#[cfg(feature = "wasm")]
 impl U2fWs {
     pub fn new(cmd: u8) -> Self {
         U2fWs {
@@ -102,12 +104,14 @@ impl U2fWs {
     }
 }
 
+#[cfg(feature = "wasm")]
 impl Default for U2fWs {
     fn default() -> Self {
         Self::new(0)
     }
 }
 
+#[cfg(feature = "wasm")]
 impl U2FFraming for U2fWs {
     fn encode(&self, message: &[u8], mut buf: &mut [u8]) -> io::Result<usize> {
         let len = encode_header_init(self.cid, self.cmd, message.len() as u16, buf)?;
@@ -314,6 +318,7 @@ mod tests {
         assert_eq!(&data[..], &payload[..]);
     }
 
+    #[cfg(feature = "wasm")]
     #[test]
     fn test_u2fws_encode_single() {
         let codec = U2fWs::with_cid(0xEEEEEEEE, 0x55);
@@ -326,6 +331,7 @@ mod tests {
         );
     }
 
+    #[cfg(feature = "wasm")]
     #[test]
     fn test_u2fws_encode_multi() {
         let payload: Vec<u8> = (0..65u8).collect();
@@ -339,6 +345,7 @@ mod tests {
         assert_eq!(&data[..len], &expect[..]);
     }
 
+    #[cfg(feature = "wasm")]
     #[test]
     fn test_u2fws_decode_single() {
         let codec = U2fWs::with_cid(0xEEEEEEEE, 0x55);
@@ -349,6 +356,7 @@ mod tests {
         assert_eq!(&data[..], b"\x01\x02\x03\x04");
     }
 
+    #[cfg(feature = "wasm")]
     #[test]
     fn test_u2fws_decode_multi() {
         let payload: Vec<u8> = (0..65u8).collect();
diff --git a/src/usb.rs b/src/usb.rs
diff --git a/src/wasm/mod.rs b/src/wasm/mod.rs
diff --git a/src/wasm/types.rs b/src/wasm/types.rs
diff --git a/tests/simulators.json b/tests/simulators.json
diff --git a/tests/util/mod.rs b/tests/util/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ async fn get_bitbox02() -> bitbox_api::PairedBitBox<bitbox_api::runtime::TokioRu`
`12`	`12`	`.unwrap();`
`13`	`13`	`let pairing_bitbox = bitbox.unlock_and_pair().await.unwrap();`
`14`	`14`	`if let Some(pairing_code) = pairing_bitbox.get_pairing_code().as_ref() {`
`15`		`- println!("Pairing code\n{}", pairing_code);`
	`15`	`+ println!("Pairing code\n{pairing_code}");`
`16`	`16`	`}`
`17`	`17`	`pairing_bitbox.wait_confirm().await.unwrap()`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ async fn signtx<R: bitbox_api::runtime::Runtime>() {`
`10`	`10`	`.unwrap();`
`11`	`11`	`let pairing_bitbox = bitbox.unlock_and_pair().await.unwrap();`
`12`	`12`	`if let Some(pairing_code) = pairing_bitbox.get_pairing_code().as_ref() {`
`13`		`- println!("Pairing code\n{}", pairing_code);`
	`13`	`+ println!("Pairing code\n{pairing_code}");`
`14`	`14`	`}`
`15`	`15`	`let paired_bitbox = pairing_bitbox.wait_confirm().await.unwrap();`
`16`	`16`