BitBox02 firmware

This commit fixes a bug in the BitBox02 hardware wallet's Ethereum transaction signing. When signing an Ethereum transaction whose 'data' field is exactly 1 byte long and is streamed from the host computer in chunks, the device could call for the first byte before it had actually been fetched, leading to a crash or failed signing. The fix makes the first-byte lookup asynchronous so it can request the byte from the host on demand, and avoids asking for an extra chunk when the whole payload is just that one byte. New unit tests and regenerated test vectors confirm the 1-byte case now works.

This commit simply removes a software function named delay_is_elapsed that is no longer used anywhere in the code. It is a routine cleanup change with no apparent security relevance.

This commit is a small internal cleanup: it adds a new 'reset' method to the user-interface layer and makes the start of a new secure session call that method instead of calling a lower-level screen-clearing function directly. The behavior is essentially the same as before—clearing leftover screens when a new connection begins—so there is no new security problem. It is a refactoring change, not a fix for a known vulnerability.

This commit only changes how wallet addresses are shown on the BitBox02 screen. It inserts spaces every four characters (for example, a Bitcoin address becomes "bc1q k5f9 em9q ..." instead of one long string). There is no code that changes security logic, cryptography, or how transactions are approved. It is a user-experience improvement to make long addresses easier to read and compare.

This commit refactors how the BitBox02 hardware wallet resets its USB communication watchdog during long-running operations. It introduces a new method in the hardware abstraction layer so Rust code can reset the timeout without directly calling a lower-level USB module. The change itself is a structural cleanup; it does not appear to fix or introduce a security vulnerability, but it touches code that prevents tasks from being cancelled while handling sensitive operations like seed encryption and device reset.

This commit is a small internal code cleanup in the BitBox02 hardware wallet firmware. It moves the creation of an empty on-screen placeholder component into a common hardware-abstraction layer (HAL) so that both real device code and automated test code use the same interface. There is no direct security fix here; it is a refactoring that makes the code easier to test and maintain.

This commit is a small code cleanup in the BitBox02 hardware wallet firmware. It moves a direct call to a low-level screen-switching function into a proper hardware-abstraction trait, making the code more testable and consistent. There is no indication it fixes a security bug or changes user-visible behavior.

This commit is a routine code cleanup: it moves the progress-bar UI code behind a Rust trait (interface) so different parts of the firmware can use it through a common abstraction. It does not change security behavior, fix a bug, or add a new user-facing feature beyond the existing progress bars.

This commit is a routine code cleanup in the BitBox02 firmware's user-interface layer. It removes a convenience method called get_mnemonic from the UI hardware-abstraction trait and makes callers use the underlying workflow function directly. The change also expands unit-test helpers so the existing restore-from-mnemonic test can simulate a 24-word recovery phrase. There is no indication this fixes a security bug or changes user-visible behavior.

This commit is a code cleanup and test improvement. It removes a redundant user-interface method called show_and_confirm_mnemonic from the hardware abstraction layer and makes callers use the underlying workflow directly. It also adds more detailed test helpers so the device screens shown during backup verification can be checked more precisely. There is no indication this fixes a security bug or changes real device behavior in a risky way.

This commit is a routine internal code cleanup. It introduces a new Rust enum called TrinaryChoice inside a hardware abstraction layer (HAL) so that higher-level code no longer directly depends on a lower-level bitbox02 UI type. The actual on-device behavior is unchanged; only the names used in the source code are different. There is no security bug being fixed here.

This commit is a simple internal code reorganization. It moves a small user-cancelled error type (UserAbort) from one Rust module to another so the hardware abstraction layer (HAL) can eventually become its own separate crate. No security behavior changes; only import paths and type references are updated.

This commit is a straightforward internal code cleanup. It replaces one definition of a user-cancellation error type with another identical one so that a hardware abstraction layer can be moved to its own crate. There is no change to user-facing behavior, security logic, or how transaction approvals and rejections are handled.

This commit is a simple internal code cleanup: it removes a thin wrapper function and calls the underlying UI confirmation directly. There is no visible change in behavior, no bug fix, and no security-relevant change.

This commit is a simple code cleanup: it moves the recipient-confirmation logic directly into the user-interface layer and removes a small wrapper function that was no longer needed. There is no change to security behavior, no bug fix, and no new feature.

This commit is a pure code cleanup: it replaces hard-to-read byte-string literals in Ethereum test code with a more readable hex!() macro. The actual byte values are identical, and no production behavior changes. There is no security issue.

This commit refactors how the BitBox02 hardware wallet handles U2F (Universal 2nd Factor) security-key workflows. It replaces an older polling-style task system with a new async executor and swaps several `static mut` global variables for safer building blocks from a vendored Rust crate called `grounded`. The change is mostly a code-quality and safety improvement: it removes deprecated `static mut` references and makes the U2F unlock/confirm workflows run as proper async tasks. There is no direct evidence in the commit message or diff that this fixes an active security vulnerability, but it reduces the risk of memory-unsafety bugs in a security-sensitive code path.

This commit is a routine internal code cleanup. It moves the logic for showing a short status message on the device screen from one Rust function to another and converts it to use the project's async/await pattern. There is no visible change in behavior: the status screen still appears for the same 2-second duration. Nothing in the commit suggests a security fix or vulnerability.

This commit is a code cleanup in the BitBox02 firmware's Ethereum transaction signing module. It replaces a generic/template-based approach with dynamic dispatch (using Rust trait objects) to reduce firmware size by about 1,776 bytes. There is no indication in the commit or supplied references that this fixes a security vulnerability or changes security-relevant behavior.

This commit is a code cleanup in the BitBox02 Ethereum signing code. It merges two separate ways of feeding transaction data into one unified mechanism, with no intended behavior change. The only functional difference visible in the diff is a minor type change in a length check (from `usize` to `u32`), which does not appear to introduce a security issue. There is no indication this is a security fix.

This commit is a routine code cleanup: it moves Ethereum transaction test data out of Rust source files into separate JSON files and adds small helper scripts to generate that data. It also makes minor type-casting fixes in unrelated test code. There is no change to the actual transaction signing logic or to any code that runs on the device in production.

This commit adds support for signing Ethereum transactions with very large 'data' fields by streaming the data in 4 KB chunks instead of loading it all at once. It also adds safety checks: streamed and inline data cannot both be provided, and streamed data is capped at 1 MB. The change is a feature/refactoring with embedded defensive checks, but it is not described by the vendor as a security fix.

This commit refactors how the BitBox02 hardware wallet computes the Ethereum transaction hash (sighash) when the transaction contains a very large 'data' field. Previously, the entire data field had to be held in memory at once, which could fail if it was too large for a single USB message. The change makes the hashing process 'streaming' or 'asynchronous', so the device can receive and hash the data in smaller chunks. The commit itself is a feature/robustness improvement, not a direct security fix, but it touches the core cryptographic hashing path for Ethereum transactions.

This is a routine internal cleanup in the BitBox02 firmware's user-interface code. It removes an artificial lifetime marker (a 'PhantomData' placeholder) from the Rust 'Component' type because the underlying callbacks that once required it have already been removed. There is no change to security logic, user-facing behavior, or how the device handles secrets.

This commit is a routine internal refactoring of the BitBox02 firmware's user-interface code. It rewrites one transaction-fee confirmation screen to use Rust's async/await style instead of a callback style, and removes an unused 'on_drop' cleanup field. There is no indication of a security bug being fixed or introduced.