Electrum

This commit fixes a performance weakness in Electrum's handling of large Bitcoin transactions encoded in 'base43'. The base43 encoding and decoding functions run in quadratic time, meaning the work grows much faster than the input size. An attacker could send or feed Electrum a very large base43 transaction string and cause the program to freeze or become unresponsive for a noticeable period (a denial-of-service effect). The patch limits how large a base43 string Electrum will try to decode and also makes the encoder slightly faster. It does not fix the underlying quadratic algorithm.

This update tightens a privacy feature on Electrum's Android app that prevents the screen from being captured while sensitive Bitcoin private keys or seed phrases are visible. Before, the protection could be accidentally turned off when multiple wallet windows overlapped, potentially letting malware or a malicious screenshot grab secret key material. The fix makes sure protection stays active whenever any sensitive screen is actually visible.

This commit tightens screen-shot protection for private Bitcoin wallet keys (WIF keys and seed phrases) in Electrum's Android/QML user interface. It also fixes a bug where one screen (AddressDetails) was leaving the 'secure window' flag permanently on, which could leave the app in a protected state at the wrong time. The change makes sure the secure flag follows whether the dialog is actually visible, and adds the same protection to two more dialogs that handle private keys.

This change moves the trimming of leading/trailing spaces in message-signing fields from the user-interface code into the shared wallet code. For the graphical interfaces (Qt and QML), spaces are still stripped automatically for convenience. For the command-line interface, a new option disables that stripping so that exact user input is preserved. It is a usability/behavior consistency fix, not a fix for an active security vulnerability.

This commit improves the error handling in Electrum's message decryption feature. Previously, if a user tried to decrypt a message using a public key that did not belong to their wallet, the code could proceed and likely fail with a confusing internal error. Now it explicitly checks whether the public key is wallet-related and shows a clear, user-friendly error message ('Pubkey unrelated to wallet.'). This is a defensive hardening change, not a fix for an active security vulnerability.

This commit changes how Electrum's message-signing function is called so that callers must explicitly name each argument (address, message, password) rather than passing them by position. The main practical effect is to prevent accidental mix-ups of argument order, which could lead to signing the wrong message or using the wrong credentials. There is no direct evidence in the commit that this fixes an active security bug or reported vulnerability.

This commit moves input-validation checks for signing, verifying, encrypting, and decrypting messages out of the user-interface code and into the shared wallet logic. It also adds type checks so that non-text inputs are rejected earlier. The change is a defensive hardening/refactoring patch: it reduces the chance that different Electrum interfaces (command line, desktop Qt, mobile QML) handle errors inconsistently or skip checks, and it makes the code easier to maintain safely. There is no direct evidence in the commit of an active vulnerability being fixed, but consolidating security checks is a security-relevant improvement.

This commit moves input-validation and wallet-type checks for message decryption out of the user-interface and command-line layers and into the core wallet code. It also removes a faster, separate decryption path for imported wallets so all wallet types now go through the same central check. The change is a defensive consolidation: it makes it harder for future user interfaces or scripts to accidentally skip the watching-only, multisig, type, and hex-pubkey checks. There is no direct evidence in the diff of an exploitable bug being fixed, but the consolidation reduces the chance that a missing check in one UI could lead to a confusing error or unexpected behavior.

This commit is a simple code cleanup: it moves the message-encryption logic from two separate places (the command-line tool and the Qt graphical interface) into a single shared method on the wallet class. The actual encryption behavior is unchanged, and no security vulnerability is introduced or fixed.

This commit is a routine code cleanup: it moves message-signature verification out of three user-interface files into a single shared helper method in the wallet module. There is no security-relevant behavior change visible in the diff. The new helper behaves the same as the old inline code, and the remaining edits only tighten some unrelated error messages.

This change fixes how Electrum's Lightning wallet reacts when a payment route fails but the failing node no longer provides a channel update message, as now allowed by the Lightning protocol spec. Previously, Electrum would permanently blacklist the channel, which could make payments fail unnecessarily and degrade routing reliability. Now it records a liquidity hint and retries with a smaller amount instead, but only for liquidity-related failures. For other failure types without an update, it still blacklists the channel.

This commit simply renames an internal variable from `dialog_label` to `_dialog_label` to mark it as private. It is a minor code cleanup with no visible behavior change and no security relevance.

This commit only adds a new unit test to Electrum's Lightning wallet test suite. It checks that when a payment fails due to a temporary lack of liquidity (TEMPORARY_CHANNEL_FAILURE) and the accompanying channel policy update is identical to what the wallet already knows, the channel is not blacklisted. Instead, only a 'liquidity hint' is recorded so smaller retry amounts can still use the channel. For other failure types, even an unchanged update still causes blacklisting. There is no production code change here.

This commit adds a new automated test to the Electrum project. It does not change any production wallet or Lightning code. The test verifies that when Electrum splits a multi-part payment across a single channel, all payment parts actually use that chosen channel rather than letting the pathfinder pick a different cheaper route. It is purely a test-case addition.

This commit fixes a bug in Electrum's wallet storage recovery. If a wallet file was partially corrupted (a 'patch' was cut off mid-write), the app could recover the old data but then fail to mark the wallet as changed. As a result, later updates might be appended to the still-corrupted file instead of replacing it, and those updates could be lost the next time the wallet was opened. The fix marks the wallet as modified after recovery so it gets rewritten cleanly. This is a data-loss bug, not a remote attack.

This commit fixes a bug in Electrum's Lightning wallet database handling. After a wallet restart, a specific type of encryption key used in Lightning payments was being loaded as a text string instead of raw bytes. This mismatch could cause payment error decoding to fail or behave incorrectly, potentially leading to misleading error reports or degraded handling of failed Lightning transactions. The patch registers a proper converter so the keys are loaded as bytes, and adds a warning log when decoding fails.

This change is a performance cleanup in Electrum's mobile/QML user interface. When the wallet learns that the Bitcoin blockchain has grown taller, it now refreshes the transaction list with a single 'everything changed' signal instead of sending one signal per transaction. That reduces UI lag and log noise, but it does not fix a security vulnerability.

This commit is a performance fix, not a security patch. It stops the Electrum mobile/QML wallet from calculating the total balance change when more than 20 new transactions arrive at once, because that calculation could freeze the user interface for several seconds. The change simply shows a generic message like '25 new transactions' instead of a detailed balance delta.

This commit simply changes two logging messages from 'info' level to 'debug' level in the mobile/QML wallet interface. It reduces routine log output when many transactions occur. There is no security-relevant change.

This is a performance and responsiveness fix for the Electrum mobile/QML wallet. It stops the app from doing heavy work (building the address coin list) every time a new transaction arrives, which was causing the user interface to freeze. Instead, the list is only built when the user actually opens it. There is no security vulnerability being fixed here.

This commit is a performance optimization for Electrum's mobile/QML user interface. It prevents the wallet balance from being recalculated and redrawn on every incoming transaction during synchronization, because the balance isn't shown during sync anyway. It is not a security fix and does not change how transactions are validated or stored.

This commit is a performance improvement for the Electrum mobile/QML wallet. It replaces repeated scanning of the transaction history list with a simple dictionary lookup (txid -> row index). There is no security-relevant change visible in the diff.

This commit tweaks the Android on-screen keyboard behavior in Electrum's QML wallet search screen. It sets the Enter key to 'Done' and hides the 'Create Wallet' button while the user is typing a search. There is no clear security problem here; it appears to be a minor user-interface fix to prevent accidental wallet creation while searching.

This commit adds a search box to Electrum's mobile-style QML wallet list. It also changes how 'hidden' wallets (those whose filenames begin with a dot) are handled: previously they were blocked entirely, now they are allowed but kept out of the normal list. A user can load a hidden wallet only by typing its exact name into the search box. The change appears to be a deliberate feature, not a fix for an active security bug, but it slightly widens what wallet files the GUI will load.

This commit fixes a crash that could happen when closing an Electrum wallet that uses a hardware device (like a Trezor). If the device was unplugged before closing, the wallet's cleanup step could fail and leave a background Qt thread running. At shutdown, Qt would then forcefully abort the whole program. The fix stops the thread first and treats device-close failures as harmless during cleanup.