Sparrow Wallet

This commit fixes a UI display bug in Sparrow Wallet's signature progress bar. When a multi-signature Bitcoin transaction becomes finalized, extra signatures beyond the required threshold are discarded. Previously, the progress bar did not remove the visual segments representing those discarded signatures, which could leave the bar showing more segments than actually exist. The fix cleans up those surplus segments and resets progress to zero for any segment whose signature was removed. There is no direct evidence this affects funds or transaction security.

This commit is a routine version bump from 2.5.5 to 2.5.6. It only changes version strings in four files (build configuration, documentation, macOS app metadata, and a Java source constant). There are no code logic changes, no bug fixes, and no security-related content in the diff.

This commit tweaks two visual animations in the Sparrow Wallet desktop app: the server connection toggle pulse and the wallet loading pulse. It caps how often the screen is redrawn during the pulse and makes sure any already-running pulse is stopped before a new one starts. There is no direct security vulnerability here; it is primarily a performance and robustness improvement for UI animations.

This commit fixes how Sparrow Wallet handles pasted or imported Bitcoin amounts. Previously, very small or oddly formatted amounts (like scientific notation '1e-8' or fractional satoshis) could be misread or silently skipped during CSV imports. The change now cuts pasted amounts to the correct precision and parses CSV amounts more carefully, preventing accidental wrong payment amounts.

This commit adds a new 'System' theme option to the Sparrow Wallet desktop app that automatically follows the operating system's light or dark mode setting, and makes it the default for new installations. It also updates various UI components to use the active theme (which may be derived from the system setting) when choosing icons and stylesheets. There is no security-relevant change here.

This commit tightens how Sparrow Wallet handles BitBox02 hardware wallets when working with older Bitcoin address formats (legacy P2PKH and P2SH). Previously, the app could let a user import or discover a wallet that the BitBox02 cannot actually sign transactions for, which could lead to funds being stuck or user confusion. The fix filters out unsupported script types from device menus and shows a clear error if a user tries to import or discover such a wallet.

This commit tightens how Sparrow Wallet handles command-line arguments. Previously, typos or unexpected values could silently be ignored, causing the wallet to start on the default Bitcoin network instead of the one the user intended. Now, unknown options and values mistakenly attached to on/off flags cause the program to print an error and exit. It also adds support for the common `--option=value` syntax. The main risk is operational: a user or script could accidentally connect to the wrong network and not notice, which in a Bitcoin wallet can lead to using the wrong wallet keys or broadcasting transactions on the wrong network.

This commit fixes a UI bug in the Sparrow Bitcoin wallet where typing or pasting too many decimal digits into amount or fee fields could be silently truncated, potentially causing a user to send a different amount than they saw on screen. The fix now ignores extra digits beyond the selected unit's precision (for example, satoshis have no decimal places) instead of truncating them in the final payment. It is a user-experience and correctness fix rather than a remote-exploitable vulnerability.

This commit changes how Sparrow Wallet restores its own wallet files. Previously, when importing a Sparrow wallet file, the public keys (used to find transactions and addresses) might not be correctly rebuilt from the seed phrase. The fix forces the app to derive public keys from the seed during import, and adds tests to confirm imported wallets pass internal consistency checks. It is a correctness/reliability fix rather than an obvious remote attack vector.

This commit adds the ability to import a Bitcoin wallet's extended public key (xpub) into Sparrow Wallet from a file written by a Blockstream Jade hardware wallet via USB storage. Previously, Jade only supported QR-code import. The change parses a descriptor string from a file, validates it matches the expected script type, and creates a keystore. There is no direct evidence in the commit or supplied references that this is a security fix or vulnerability; it appears to be a normal feature addition.

This commit changes how Sparrow Wallet builds QR codes for partially-signed Bitcoin transactions (PSBTs). For certain hardware wallets (Krux), it now includes extra data (the full previous transaction, called 'non-witness utxo') in the QR code when the transaction has more than one input. This extra data is needed by some devices to verify inputs securely, but it also makes the QR code larger and slower to scan. The change appears to be a correctness/usability fix for hardware signing rather than a traditional software vulnerability.

This commit fixes a UI state bug in Sparrow Wallet's import pane. Previously, when a user scanned or imported a wallet and then imported a non-wallet file, text payload, or unrecognized QR code in the same pane, the previously loaded wallet data was not cleared. This could mislead the user into thinking an old wallet was still active or associated with the new import. The fix explicitly sets the wallet list to null before handling these alternative import paths.

This commit fixes two reliability issues in Sparrow Wallet's built-in Electrum server (Cormorant). First, it makes sure the internal transaction store is locked while being read or updated, and returns a fresh copy of a wallet's history so a slow client doesn't see data change mid-request. Second, it ensures the client network socket is always closed when the handler finishes, even if something goes wrong. These are defensive fixes that prevent data races and resource leaks rather than obvious user-facing exploits.

This commit fixes a race condition in Sparrow Wallet's built-in Electrum server (Cormorant). Previously, a response to a wallet client and an asynchronous notification (like a new block or a balance update) could be written to the same network connection at the same time from different threads, potentially interleaving their bytes and producing garbled JSON. The fix routes all outgoing messages through a single synchronized method so they are sent one at a time per client connection. The included test demonstrates that a notification now waits until an in-progress response finishes writing, and that each message arrives as a complete line.

This commit fixes a bug in Sparrow Wallet's silent-payments scanning cache. If a background scan had already finished, then a later 'widening' request to extend the scan failed and rolled back, any history request that arrived during the failed widening would wait forever instead of being told the scan was already complete. The fix makes the rollback path signal those waiting threads so the wallet history can return promptly. It is a reliability/availability bug, not a direct theft-of-funds vulnerability.

This commit fixes a minor crash bug in Sparrow Wallet's connection-test screens. Previously, if a Bitcoin Electrum server answered the version request with an unusually short response, the wallet would try to read list items that didn't exist and throw an IndexOutOfBoundsException. The patch now checks that the list has at least one element before using it and only appends the protocol version if a second element exists. It is a UI-only hardening change, not a cryptographic or funds-theft issue.

This commit fixes a bug in Sparrow Wallet's PayNym (BIP47 reusable payment code) contact handling. Previously, if a single contact in your PayNym following/followers list had a malformed payment code, the app either kept a broken contact with a null payment code or could fail the entire PayNym response. Now it simply skips that bad contact and keeps the rest. This is a robustness fix that prevents crashes or broken contact lists, but it is not a direct theft-of-funds vulnerability.

This change stops Sparrow Wallet from trying to fetch live fiat-currency exchange rates when the user has explicitly chosen 'offline mode'. Instead of making a network request that is doomed to fail, it now reuses the currency already saved in settings. It also hides the warning that normally appears when the currency list fails to load, because in offline mode that failure is expected. This is a reliability/usability fix, not a security patch.

This commit fixes two related Bitcoin wallet behaviors in Sparrow. First, when you ask for a new receive address, the wallet now skips any address that already has a label, because a label means that address was already given to someone. Previously, the desktop app skipped labeled addresses but the terminal app did not, so the terminal could accidentally hand the same address to two different payers. Second, when you explicitly advance past the normal gap limit, the wallet now widens the gap limit so that a later wallet recovery with the saved gap limit will still find that address. This prevents funds sent to a far-ahead address from being missed during recovery scans.

This commit fixes a bug in Sparrow Wallet's BBQ QR code format. Previously, if a large transaction or data blob needed more than 1,295 QR-code-sized pieces, the app would generate pieces with impossible sequence numbers that could not be reassembled by a scanner. The fix caps the number of pieces at 1,295 and makes each piece bigger instead, so scanning still works. It is a reliability/data-integrity bug rather than a direct theft-of-funds vulnerability, but a malformed or unrecoverable QR sequence could disrupt wallet operations.

This commit fixes how Sparrow Wallet's transaction hex viewer highlights the parts of a SegWit Bitcoin transaction. Previously, if a SegWit transaction contained an input with no witness data, the viewer would skip highlighting that input's witness section entirely, causing the colored segments to fall out of sync with the actual raw transaction bytes. The change now correctly shows an empty witness for such inputs, keeping the display aligned with how the transaction is really serialized.

This change fixes a thread-safety bug in how Bitcoin amounts are formatted for display and export. Previously, the same number-formatting objects were shared between background export tasks and the on-screen transaction table. Because those formatters are not safe for concurrent use, two threads could corrupt each other's output, potentially causing wrong decimal places, separators, or digits to appear in exported data or on screen. The fix gives each thread its own private formatter.

This commit fixes a resource-leak bug in Sparrow Wallet's transaction list. Previously, every temporary transaction object automatically subscribed to blockchain-tip updates when it was created, and many of those temporary objects were never unsubscribed. Over time this left stale 'listeners' piling up in memory, which could slow the wallet down, waste resources, and potentially cause confusing display updates. The change makes subscription explicit: only transaction entries that are actually shown in the wallet's transaction list are registered for updates, and they are cleanly unregistered when removed, when history is cleared, or when a wallet tab is closed.