Sparrow Wallet

This commit only changes the wording of an error message shown when a USB security-key feature is not supported. There is no indication it fixes a security flaw or changes program behavior beyond making the message consistent with other similar error messages.

This commit changes where Sparrow Wallet stores its files on macOS and Linux to optionally follow the XDG Base Directory Specification. It is a directory-layout migration, not a fix for a vulnerability. The change could create minor security side effects if old files remain in the previous home directory or if symlink handling during network-folder migration goes wrong, but the commit itself does not introduce an obvious exploit.

This commit fixes a rare threading bug in how Sparrow Wallet names its automatic wallet backups. The old code used a date formatter that is not safe when multiple threads use it at the same time, which could in theory produce a malformed backup filename or throw an exception. The new code uses a modern, thread-safe date formatter. There is no direct evidence this is exploitable by an attacker; it is best described as a robustness fix.

This commit hardens how Sparrow Wallet opens its encrypted wallet files. It blocks several H2 database features that could be abused to run code or read files when a malicious wallet file is opened, and it prevents Java object deserialization. It also adds tests showing that dangerous constructs like linked tables, triggers, and file-read functions are now rejected before they can execute.

This commit adds support for a new hardware wallet called ERA Wallet to the Sparrow desktop Bitcoin wallet. It is a straightforward feature addition: a new import class that reuses existing code for another similar wallet (Keystone), plus icons and menu entries. There is no indication of a security bug, vulnerability, or malicious change in the code shown.

This commit fixes a wallet-import labeling bug. When a user imported a wallet file that had been exported from a hardware-wallet-style source, Sparrow was not correctly updating the keystore's type and model to match the importer. The patch makes the import process consistently set the source and device model, and only overwrites the default label rather than any custom label the user had set. There is no direct evidence this is a security vulnerability, but mislabeling a keystore could confuse users about which device controls their funds.

This is a small follow-up patch to a security check inside Sparrow Wallet's database loader. The change tightens how the app scans a wallet file's internal database schema for dangerous commands that could let an attacker run code or link to outside data. The new version also strips out table names before checking, so attackers can't hide a dangerous command inside a cleverly named table. It appears to be a hardening fix rather than the original security fix.

This commit fixes a spelling mistake in a code comment, changing 'succesful' to 'successful'. It does not change any actual program behavior or fix any security issue.

This commit changes the build configuration for running Sparrow from an IDE (integrated development environment). It adds a JVM argument that exposes an internal Java module called 'jdk.unsupported', which contains non-standard classes like sun.misc. This is needed for some IDE debugging/profiling 'agents' to work. It slightly increases the internal Java attack surface when running in development mode, but does not change the released application that end users download.

This commit adds stronger safety checks when Sparrow Wallet opens its encrypted wallet database files. It tries to detect and block tampered wallet files that contain unusual database objects such as linked tables, triggers, aliases, synonyms, generated columns, custom domains, or unexpected default values. These checks reduce the risk that a maliciously crafted wallet file could trick the application into running harmful database commands or accessing remote data when the wallet is loaded.

This commit changes how Sparrow Wallet handles temporary files when importing or exporting wallets. Previously, temporary wallet files were created in the system's shared temporary directory, where other users or processes on the same computer could potentially read or tamper with them. The new code creates a private, owner-only temporary directory and securely deletes its contents afterward. This reduces the risk that sensitive wallet data briefly exposed during import/export could be accessed by others on the same machine.

This commit hardens how Sparrow Wallet talks to an external Tor proxy's control port. Previously, when asking Tor for a new identity, the app used an older authentication method that could send the contents of a secret cookie file over the local connection. The update switches to Tor's 'SAFECOOKIE' challenge-response authentication, verifies the server before revealing anything, and refuses to open the control connection unless the target address is on the local computer (loopback). This reduces the risk that a malicious or misconfigured remote proxy could steal the Tor cookie or abuse the control port.

This is a one-line bug fix for a NullPointerException (NPE) that occurs when comparing an unresolved silent payment output. A silent payment is a newer Bitcoin privacy feature that lets someone receive payments without publicly revealing their address. An 'unresolved' output likely means the wallet has not yet finished identifying whether the payment belongs to it. The fix prevents the wallet from crashing during that comparison, but the available information does not show whether the crash could be triggered by an attacker or lead to loss of funds.

This commit tightens how Sparrow Wallet checks that a scanned QR code or loaded file matches the transaction the user is currently working on. Previously, the app only compared the new transaction/PSBT against the single currently open tab. Now it checks all open transaction tabs. This reduces the chance that a user accidentally accepts a wrong or maliciously substituted transaction because they had the wrong tab active. It is a defensive hardening fix, not a clear-cut remote exploit.

This commit adds a safety check in the Sparrow Wallet desktop app to make sure a transaction loaded from a file or scanned from a QR code actually matches the PSBT (a partially-signed Bitcoin transaction) that was already open. Before this change, the app would accept any transaction or PSBT from a file/scan and display it, which could mislead a user into thinking a different transaction was the one they intended to sign. The fix shows an error dialog when the loaded or scanned data does not match the original PSBT, and includes a special message for silent-payment transactions that cannot be verified from a final transaction alone.

This commit removes the Windows installer's custom directory chooser. The installer will now always install Sparrow into a standard per-user location instead of letting the user pick a different folder. This is a routine packaging change that reduces user choice but does not, by itself, create a security vulnerability.

This commit updates the Windows installer for Sparrow Wallet so that the app properly advertises itself to Windows as a handler for 'bitcoin:', 'lightning:', and 'auth47:' web-style links. It also fixes the icon path for those link handlers to use the install folder. This is a normal installer improvement, not a security fix for a vulnerability.

This commit updates the Windows installer template used by Sparrow Wallet to match the version that ships with JDK 25. It also keeps Sparrow's custom registry entries that register 'auth47', 'bitcoin', and 'lightning' web link types with Windows. There is no indication in the commit of a security vulnerability being fixed or introduced.

This commit only changes two GitHub workflow files to add a Java compiler option that suppresses a specific category of warning messages ('module' lint warnings). It does not modify application code, dependencies, build logic, or anything that handles user data, keys, or network traffic. There is no security relevance visible in the diff or commit message.

This commit fixes a build-time trust issue and cleans up temporary debugging. It adds the missing cryptographic key for the OpenTelemetry library so Gradle can verify its downloaded files, and removes a one-off debug step that was used to investigate why the build was failing. It does not change the wallet application itself or user funds handling.

This commit only adjusts a temporary debugging step in the project's automated build workflow. It makes the debug script more tolerant of Windows paths and failures, and prints extra diagnostic information. There is no change to the wallet application code, no security fix, and no malicious-looking behavior.

This commit adds temporary debug logging to a GitHub Actions build workflow. It prints file hashes and downloads a public Maven module to help diagnose why Gradle dependency verification is failing. There is no code change to the Sparrow Wallet application itself and no security-relevant behavior.

This commit changes the project's automated build workflow to lock down the exact versions of external GitHub Actions it uses by specifying their cryptographic SHA fingerprints instead of version tags. This is a defensive hardening measure that reduces the risk of a supply-chain attack, where a malicious or compromised update to a third-party action could tamper with the wallet's build artifacts or signing certificates.

This commit adds Gradle's dependency verification files. These files list the public keys and expected checksums for the libraries the project downloads during its build. It is a standard supply-chain hardening step, not a code change that introduces a vulnerability.

This commit adds a GitHub Actions workflow that automatically updates the project's Gradle dependency verification files. These files are a security control that helps ensure downloaded build dependencies have not been tampered with. The change itself is a defensive automation improvement and does not introduce a vulnerability or malicious behavior.