fix!: replace usize with u32 or smaller

notmandatory · notmandatory · commit 078d1e5457b4 · 2026-04-08T10:14:57.000-05:00
BREAKING CHANGE.
diff --git a/cktap-swift/Sources/CKTap/cktap_ffi.swift b/cktap-swift/Sources/CKTap/cktap_ffi.swift
@@ -2680,8 +2680,8 @@ extension DumpError: Foundation.LocalizedError {
 
 public enum KeyError: Swift.Error {
 
-    
-    
+
+
     case Secp256k1(msg: String
     )
     case KeyFromSlice(msg: String
diff --git a/cli/src/main.rs b/cli/src/main.rs
@@ -228,7 +228,7 @@ async fn main() -> Result<(), CliError> {
                     dbg!(response);
                 }
                 TapSignerCommand::Derive { path } => {
-                    // let test_path:Vec<usize> = ts.path.clone().unwrap().iter().map(|p| p ^ (1 << 31)).collect();
+                    // let test_path:Vec<u32> = ts.path.clone().unwrap().iter().map(|p| p ^ (1 << 31)).collect();
                     // dbg!(test_path);
                     dbg!(&ts.derive(path.unwrap_or_default(), &cvc()).await);
                 }
diff --git a/lib/src/apdu.rs b/lib/src/apdu.rs
@@ -97,11 +97,11 @@ impl CommandApdu for StatusCommand {
 #[derive(Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct StatusResponse {
     /// Version of CBOR protocol in use.
-    pub proto: usize,
-    /// Firmware version of card itself.
+    pub proto: u32,
+    /// Firmware version of the card itself.
     pub ver: String,
     /// Card birth block height (int) (fixed after production).
-    pub birth: usize,
+    pub birth: u32,
     /// SATSCARD Only: Tuple of (active_slot, num_slots).
     pub slots: Option<(u8, u8)>,
     /// SATSCARD Only: Payment address, middle chars blanked out with 3 underscores.
@@ -114,9 +114,9 @@ pub struct StatusResponse {
     /// effect. It encodes a BIP-32 derivation path, like m/84h/0h/0h, which is a typical value for
     /// segwit usage, although the value is controlled by the wallet application. The field is only
     /// present if a master key has been picked (i.e., setup is complete).
-    pub path: Option<Vec<usize>>,
+    pub path: Option<Vec<u32>>,
     /// Counts up, when backup command is used.
-    pub num_backups: Option<usize>,
+    pub num_backups: Option<u32>,
     /// Public key unique to this card (fixed for card life) aka: card_pubkey.
     #[serde(with = "serde_bytes")]
     pub pubkey: Vec<u8>,
@@ -836,7 +836,7 @@ impl CommandApdu for DumpCommand {
 pub struct DumpResponse {
     /// slot just made
     #[allow(unused)] // TODO verify this is correct slot
-    pub slot: usize,
+    pub slot: u8,
     /// private key for spending (for addr), 32 bytes
     /// The private keys are encrypted, XORed with the session key
     #[serde(with = "serde_bytes")]
diff --git a/lib/src/error.rs b/lib/src/error.rs
@@ -131,9 +131,9 @@ pub enum ChangeError {
     #[error(transparent)]
     CkTap(#[from] CkTapError),
     #[error("new cvc is too short, must be at least 6 bytes, was only {0} bytes")]
-    TooShort(usize),
+    TooShort(u8),
     #[error("new cvc is too long, must be at most 32 bytes, was {0} bytes")]
-    TooLong(usize),
+    TooLong(u8),
     #[error("new cvc is the same as the old one")]
     SameAsOld,
 }
@@ -228,15 +228,15 @@ pub enum DumpError {
 #[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
 pub enum SignPsbtError {
     #[error("Invalid path at index: {0}")]
-    InvalidPath(usize),
+    InvalidPath(u32),
     #[error("Invalid script at index: {0}")]
-    InvalidScript(usize),
+    InvalidScript(u32),
     #[error("Missing pubkey at index: {0}")]
-    MissingPubkey(usize),
+    MissingPubkey(u32),
     #[error("Missing UTXO at index: {0}")]
-    MissingUtxo(usize),
+    MissingUtxo(u32),
     #[error("Pubkey mismatch at index: {0}")]
-    PubkeyMismatch(usize),
+    PubkeyMismatch(u32),
     #[error("Sighash error: {0}")]
     SighashError(String),
     #[error("Signature error: {0}")]
diff --git a/lib/src/sats_card.rs b/lib/src/sats_card.rs
@@ -25,9 +25,9 @@ use std::sync::Arc;
 pub struct SatsCard {
     pub transport: Arc<dyn CkTransport>,
     pub secp: Secp256k1<All>,
-    pub proto: usize,
+    pub proto: u32,
     pub ver: String,
-    pub birth: usize,
+    pub birth: u32,
     pub slots: (u8, u8),
     pub addr: Option<String>,
     pub pubkey: PublicKey,
@@ -372,25 +372,25 @@ impl SatsCard {
             let witness_utxo = input
                 .witness_utxo
                 .as_ref()
-                .ok_or(Error::MissingUtxo(input_index))?;
+                .ok_or(Error::MissingUtxo(input_index as u32))?;
 
             let amount = witness_utxo.value;
 
             // extract the P2WPKH script from PSBT
             let script_pubkey = &witness_utxo.script_pubkey;
             if !script_pubkey.is_p2wpkh() {
-                return Err(Error::InvalidScript(input_index));
+                return Err(Error::InvalidScript(input_index as u32));
             }
 
             // get the public key from the PSBT
             let key_pairs = &input.bip32_derivation;
             let (psbt_pubkey, (_fingerprint, path)) = key_pairs
                 .iter()
                 .next()
-                .ok_or(Error::MissingPubkey(input_index))?;
+                .ok_or(Error::MissingPubkey(input_index as u32))?;
 
             if !path.is_empty() {
-                return Err(Error::InvalidPath(input_index));
+                return Err(Error::InvalidPath(input_index as u32));
             }
 
             // calculate sighash
@@ -408,7 +408,7 @@ impl SatsCard {
 
             // verify that SATSCARD used the same public key as the PSBT
             if sign_response.pubkey != psbt_pubkey.serialize() {
-                return Err(Error::PubkeyMismatch(input_index));
+                return Err(Error::PubkeyMismatch(input_index as u32));
             }
 
             // update the PSBT input with the signature
diff --git a/lib/src/sats_chip.rs b/lib/src/sats_chip.rs
@@ -20,12 +20,12 @@ use crate::tap_signer::TapSignerShared;
 pub struct SatsChip {
     pub transport: Arc<dyn CkTransport>,
     pub secp: Secp256k1<All>,
-    pub proto: usize,
+    pub proto: u32,
     pub ver: String,
-    pub birth: usize,
-    pub path: Option<Vec<usize>>,
+    pub birth: u32,
+    pub path: Option<Vec<u32>>,
     // [(1<<31)+84, (1<<31), (1<<31)], user-defined, will be omitted if not yet setup
-    pub num_backups: Option<usize>,
+    pub num_backups: Option<u32>,
     pub pubkey: PublicKey,
     pub card_nonce: [u8; 16],
     pub auth_delay: Option<u8>,
diff --git a/lib/src/tap_signer.rs b/lib/src/tap_signer.rs
@@ -20,22 +20,22 @@ use bitcoin::secp256k1::{self, All, Message, Secp256k1, ecdsa::Signature};
 use bitcoin_hashes::sha256;
 use std::sync::Arc;
 
-const BIP84_PATH_LEN: usize = 5;
+const BIP84_PATH_LEN: u32 = 5;
 
 // BIP84 derivation path structure, m / 84' / 0' / account' / change / address_index
 
 // Derivation sub-path indexes that must be hardened
-const BIP84_HARDENED_SUBPATH: [usize; 3] = [0, 1, 2];
+const BIP84_HARDENED_SUBPATH: [u32; 3] = [0, 1, 2];
 
 pub struct TapSigner {
     pub transport: Arc<dyn CkTransport>,
     pub secp: Secp256k1<All>,
-    pub proto: usize,
+    pub proto: u32,
     pub ver: String,
-    pub birth: usize,
-    pub path: Option<Vec<usize>>,
+    pub birth: u32,
+    pub path: Option<Vec<u32>>,
     // [(1<<31)+84, (1<<31), (1<<31)], user-defined, will be omitted if not yet setup
-    pub num_backups: Option<usize>,
+    pub num_backups: Option<u32>,
     pub pubkey: PublicKey,
     pub card_nonce: [u8; 16],
     pub auth_delay: Option<u8>,
@@ -162,32 +162,32 @@ pub trait TapSignerShared: Authentication {
             let witness_utxo = input
                 .witness_utxo
                 .as_ref()
-                .ok_or(SignPsbtError::MissingUtxo(input_index))?;
+                .ok_or(SignPsbtError::MissingUtxo(input_index as u32))?;
 
             let amount = witness_utxo.value;
 
             // extract the P2WPKH script from PSBT
             let script_pubkey = &witness_utxo.script_pubkey;
             if !script_pubkey.is_p2wpkh() {
-                return Err(SignPsbtError::InvalidScript(input_index));
+                return Err(SignPsbtError::InvalidScript(input_index as u32));
             }
 
             // get the public key from the PSBT
             let key_pairs = &input.bip32_derivation;
             let (psbt_pubkey, (_fingerprint, path)) = key_pairs
                 .iter()
                 .next()
-                .ok_or(SignPsbtError::MissingPubkey(input_index))?;
+                .ok_or(SignPsbtError::MissingPubkey(input_index as u32))?;
 
             let path = path.to_u32_vec();
 
-            if path.len() != BIP84_PATH_LEN {
-                return Err(SignPsbtError::InvalidPath(input_index));
+            if path.len() as u32 != BIP84_PATH_LEN {
+                return Err(SignPsbtError::InvalidPath(input_index as u32));
             }
 
-            let sub_path = BIP84_HARDENED_SUBPATH.map(|i| path[i]);
+            let sub_path = BIP84_HARDENED_SUBPATH.map(|i| path[i as usize]);
             if sub_path.iter().any(|p| *p > BIP32_HARDENED_MASK) {
-                return Err(SignPsbtError::InvalidPath(input_index));
+                return Err(SignPsbtError::InvalidPath(input_index as u32));
             }
 
             // calculate sighash
@@ -214,7 +214,7 @@ pub trait TapSignerShared: Authentication {
                     .collect();
                 let derive_response = self.derive(path, cvc).await;
                 if derive_response.is_err() {
-                    return Err(SignPsbtError::PubkeyMismatch(input_index));
+                    return Err(SignPsbtError::PubkeyMismatch(input_index as u32));
                 }
 
                 // update signature to the new one we just derived
@@ -223,7 +223,7 @@ pub trait TapSignerShared: Authentication {
 
                 // if still not matching, return error
                 if sign_response.pubkey != psbt_pubkey.serialize() {
-                    return Err(SignPsbtError::PubkeyMismatch(input_index));
+                    return Err(SignPsbtError::PubkeyMismatch(input_index as u32));
                 }
             }
 
@@ -286,11 +286,11 @@ pub trait TapSignerShared: Authentication {
     /// Change the CVC used for card authentication to a new user provided one
     async fn change(&mut self, new_cvc: &str, cvc: &str) -> Result<(), ChangeError> {
         if new_cvc.len() < 6 {
-            return Err(ChangeError::TooShort(new_cvc.len()));
+            return Err(ChangeError::TooShort(new_cvc.len() as u8));
         }
 
         if new_cvc.len() > 32 {
-            return Err(ChangeError::TooLong(new_cvc.len()));
+            return Err(ChangeError::TooLong(new_cvc.len() as u8));
         }
 
         if new_cvc == cvc {

Original file line number	Diff line number	Diff line change
`@@ -2680,8 +2680,8 @@ extension DumpError: Foundation.LocalizedError {`
`2680`	`2680`
`2681`	`2681`	`public enum KeyError: Swift.Error {`
`2682`	`2682`
`2683`		`-`
`2684`		`-`
	`2683`	`+`
	`2684`	`+`
`2685`	`2685`	`case Secp256k1(msg: String`
`2686`	`2686`	`)`
`2687`	`2687`	`case KeyFromSlice(msg: String`
Original file line number	Diff line number	Diff line change
`@@ -228,7 +228,7 @@ async fn main() -> Result<(), CliError> {`
`228`	`228`	`dbg!(response);`
`229`	`229`	`}`
`230`	`230`	`TapSignerCommand::Derive { path } => {`
`231`		`- // let test_path:Vec<usize> = ts.path.clone().unwrap().iter().map(\|p\| p ^ (1 << 31)).collect();`
	`231`	`+ // let test_path:Vec<u32> = ts.path.clone().unwrap().iter().map(\|p\| p ^ (1 << 31)).collect();`
`232`	`232`	`// dbg!(test_path);`
`233`	`233`	`dbg!(&ts.derive(path.unwrap_or_default(), &cvc()).await);`
`234`	`234`	`}`