BitBox02 firmware

bootloader: avoid snprintf formatting

Replace the extracted bootloader formatting helpers with fixed-size string building.

Add a small Rust decimal formatter for the fixed integer cases.

Remove the remaining production bootloader snprintf pulls from debug copies and UGUI line slicing.

Also replace the Plus BLE random-name formatting.

Extend the unwanted-symbols CI check to cover production bootloader ELFs.

Reject stdio and Rust formatting symbols there.

bootloader: extract formatting helpers

bootloader: render messages directly

Pass bootloader messages directly to UG_PutString instead of copying them through a fixed-size stack buffer first. UG_PutString consumes the string synchronously while drawing to the screen buffer.

Use 9x9 bootloader screen font

The bootloader selects the 9x9 font before rendering text, and Abort does the
same. Use that font as the bootloader UG_Init default so the 11x10 font table is
not linked into bootloader images.

bb02p-bl-multi-production.bin shrinks from 50572 to 48556 bytes.

ci: exclude asf4 headers from clang-tidy

asf4 is excluded already at source level, but headers could still be
linted through includes from other sources.

Check firmware for float helpers

Extend .ci/check-unwanted-symbols with additional checks for linked
floating-point helpers in build/bin/firmware.elf.

Keep the existing float formatting, strftime, and sha2::Sha512 checks,
and add floating-point helper checks for the helpers removed by the
integer fee and progress commits. The f64 check is intentionally
scoped to comparison/conversion helpers because this branch still has
some double arithmetic helpers pulled in by the existing C
snprintf/newlib path.

Use integer progress fractions

Add an integer `set_fraction()` progress path through the HAL and UI layers,
and switch the live Bitcoin-signing and Bluetooth-upgrade progress updates to
use it.

The progress bar ultimately renders whole pixels, so the C progress component
now stores the filled pixel width directly and computes it with integer math.
This keeps the visible behavior intact while removing the Rust-side soft-float
`f32` arithmetic path that was only used for progress updates.

In the final firmware image this drops the live
`compiler_builtins::float::{add,div,mul}::<f32>` helpers together with the
associated `__aeabi_fadd`, `__aeabi_fdiv`, and `__aeabi_fmul` wrappers.

Savings: 1352 bytes

Initialize ugui in component tests

Set up a minimal ugui instance for UI component tests that create
labels. Label sizing now relies on ugui being initialized because ugui
null guards are debug assertions instead of release-time early returns.

Reuse rotated render for logo

Render the orientation screen's reverse logo state by rotating the
existing logo component 180 degrees instead of keeping a second reversed
bitmap and component.

Use debug asserts in ugui

Replace defensive null-check returns in ugui.c with ASSERT() calls.
ASSERT is already compiled as a no-op outside DEBUG builds, so release
behavior no longer carries the extra null-check branches.

Remove transparent putchar API

Drop the unused UG_PutCharTransparent entry point and the now-constant
transparent flag from the private character renderer.

Remove inverted ugui text argument

Replace the text-specific inverted flag with a temporary 180-degree UG
rendering transform. Use the component helper to rotate the orientation
screen top button while keeping normal text drawing APIs.

Update C and Rust call sites and add coverage for pixel and component
rotation.

Enable scope C LTO for firmware

Enable scoped GCC LTO for firmware C code to reduce ROM size while preserving section GC and stack protector support. Build firmware C objects plus the optiga and cryptoauthlib static libraries with -flto -ffat-lto-objects, and link only firmware images with -flto, since useful size savings require LTO IR in the linked static libraries.

Switch the ARM toolchain to the LTO-aware archive utilities (arm-none-eabi-gcc-ar, arm-none-eabi-gcc-nm, arm-none-eabi-gcc-ranlib); plain ar/ranlib can archive LTO objects without the plugin and produce invalid tiny images by failing to extract live objects.

Keep bootloaders, factory-setup, ASF4, samd51a-ds, and embedded-swd
off the LTO path because startup, interrupt, MMIO, vector-table,
linker-script, assembly, callback-table, and section-name interactions
are not cheaply auditable for LTO safety. Mark local stack protector
symbols as kept/visible so late LTO-generated references to
__stack_chk_fail and __stack_chk_guard are retained;
no_stack_protector is intentionally not needed.

cleanup: remove unused crate

lvgl-sys: remove cmake build

Build LVGL directly with cc from an explicit source list and drop the
cmake crate dependency. Use the shared bitbox-lvgl-sys lv_conf.h for the
BB03 graphical simulator and remove the simulator-specific duplicate
config.

Remove cross compilation support in lvgl-sys for now.

tooling: Move rust tools out of dockerfile

It is easier to install the right tools if you aren't using docker.

build: run vendoring script from src/rust

Run rust vendorings script from src/rust so that the correct rust
toolchain is picked up.

payment_request: derive validation addresses once

test: assert payment request securechip counts

keystore: consolidate xpub compute mode

da14531: restore BLE UART backpressure

ListBackups returns one protobuf containing all SD card backups. With many backups, the response spans many 64-byte HWW/U2FHID reports. USB sends those reports directly over HID, but BLE first serial-frames each report for the DA14531 and queues the escaped bytes in the fixed-size UART ByteQueue.

The Rust ByteQueue port kept the panicking single-byte put() API and the BLE poller used it for every framed byte. That removed the previous v9.25 backpressure behavior: da14531_protocol_poll() consumed the pending HWW report before knowing whether the whole framed BLE packet fit in the 2048-byte UART queue. If ListBackups produced data faster than UART drained it, put() eventually hit capacity and panicked with bytequeue overflow. USB does not use this UART queue, which is why the same request worked there.

Add ByteQueue::try_put_slice() plus an extern C wrapper that takes util::Bytes and performs an all-or-nothing enqueue. The BLE HWW path now formats the 64-byte report into a temporary serial frame and only clears hww_data after try_put_slice() succeeds. If the queue is full, it returns without writing any bytes, preserving frame boundaries and leaving the same report pending for the next poll after UART has drained.

Keep the existing panicking put() behavior for the other bytequeue callers so the change stays scoped to the actual backpressure boundary. The separate Rust and extern-wrapper tests cover successful writes and failed overflow attempts being atomic.

AGENTS: run make commands serially

Otherwise the dev-machine can easily lock up.

optiga: fix detached buffer reuse

The Optiga C API keeps raw pointers to the Rust wrapper's static
buffers until the asynchronous callback completes. The Rust wrapper
has a Detached state for futures that were dropped after launching a
command, but the individual wrappers initialized their per-operation
static buffers before calling begin_async_op().

That meant a repeated call to the same wrapper could clear or
overwrite the exact static storage still owned by the detached C
command before begin_async_op() noticed the Detached state and waited
for the old callback.

Move begin_async_op().await before every static buffer or length-cell
mutation. Detached operations are now reclaimed before any static
storage is reused, and live concurrent operations still panic before
their buffers can be corrupted.

bitbox-lvgl-sys/build.rs: remove warning

Agents feel the urge to fix it.

clippy: warn for large futures

Large async state machines keep their captured data alive across await
points. That can silently bloat task allocations and stack usage, which
is especially risky on memory-constrained embedded targets and makes
regressions harder to spot in review.

Add the Clippy lint so oversized futures are flagged early instead of
only showing up later as memory pressure or failures.

Reference: https://rust-lang.github.io/rust-clippy/master/index.html#large_futures