Bitcoin Core

This commit removes the on/off checkbox in the Bitcoin Core desktop wallet that let users choose whether a transaction should signal 'Replace-By-Fee' (RBF). After the change, the GUI simply follows the wallet's configuration setting instead. It is a user-interface simplification, not a fix for a software vulnerability.

This Bitcoin Core change removes an unnecessary extra zero byte (OP_0) from newly mined coinbase transactions after block height 16. That byte was originally added to satisfy a minimum coinbase script length rule, but only heights 1-16 actually need it. The change is a cleanup that makes blocks one byte smaller and updates many hardcoded test hashes accordingly. It does not fix a vulnerability and does not appear exploitable.

This commit is a code cleanup: it moves a function that creates MuSig2 cryptographic nonces from the CKey class into a dedicated musig module. The actual logic and security behavior are unchanged; only where the code lives and how callers reference it are modified.

This Bitcoin Core wallet patch fixes a bug where the software underestimated the size (and therefore the required transaction fee) of certain externally provided transaction inputs. The fix passes the actual outpoint being spent into the size-estimation function, so the fee calculation can account for extra data that some inputs require. The included test demonstrates that without the fix, the estimated size is one byte too small.

This commit fixes an off-by-one bug in Bitcoin Core's read-only wallet migration tool. The tool checks whether a Berkeley DB (BDB) wallet file is self-contained before migrating it. Due to a half-open loop, the tool was skipping the very last page of the database when verifying that all pages had their log sequence numbers (LSNs) reset. As a result, it could have accepted a wallet whose final page still depended on separate BDB log files, potentially leading to incomplete or inconsistent migration data. The fix changes the loop to include the last page.

This change refactors how the standalone bitcoin-wallet tool figures out where a wallet file lives. Previously it computed the path itself; now it calls the same internal helper (GetWalletPath) that the main wallet code uses, which includes checks for invalid wallet names. The likely effect is to prevent mistakes or misuse involving odd wallet names/paths, rather than to fix an active remote-exploitable bug.

This Bitcoin Core change prevents users from importing a special 'unused()' wallet descriptor if the private key it refers to is already present in the wallet. The patch adds a check during descriptor import and a test to confirm the new behavior. The commit message does not describe this as a security fix, and no external security references are provided, so its security relevance is uncertain. It appears to be a defensive correctness fix that could prevent confusion or wallet-state inconsistencies rather than a fix for an active exploit.

This change blocks users from importing a special type of Bitcoin wallet descriptor called unused() into wallets that have private keys disabled. Such wallets are watch-only: they can see transactions but cannot spend. The unused() descriptor is meant to reserve a key for future use. Allowing it in a no-private-key wallet could have led to confusion or situations where the wallet believes it controls funds it cannot actually spend, but the patch is a simple guard with no demonstrated exploit.

This commit adds a new wallet RPC command called addhdkey that lets users import a BIP32 extended private key (xprv) into a Bitcoin Core wallet, or generate a fresh random one. It is a feature addition, not a bug fix. The code checks that the wallet stores private keys, requires the wallet to be unlocked, rejects plain xpubs, and refuses duplicate keys. There is no indication in the commit that this fixes a security vulnerability.

This commit only adds new test data (sample PSBT strings) to a JSON file used by Bitcoin Core's automated tests. It does not change any production code, wallet logic, or network behavior. There is no security issue here.

This commit simply removes an unused test helper function called DuplicateMockDatabase and its declaration. It is a code cleanup change with no effect on the live Bitcoin wallet software users run.

This commit adds a new wallet descriptor type called unused(KEY). It lets Bitcoin Core wallets store a key without watching any blockchain addresses for it. The change is a feature addition, not a fix for an active security bug. It includes parsing rules, tests, and a small wallet tweak to skip address labeling for descriptors that do not produce output scripts. There is no evidence in the commit or supplied references of a disclosed vulnerability or exploit.

This commit adds a new automated test to Bitcoin Core that checks the behavior of importing a special 'unused(KEY)' wallet descriptor. It verifies that importing a public-only version is rejected for wallets that have private keys enabled, while importing a private-key version succeeds and registers the expected extended public key. There is no change to production wallet code, no bug fix, and no security-relevant behavior beyond normal test coverage.

This is a small internal cleanup of a Bitcoin Core benchmark test. It moves the creation of a fake legacy wallet from the main benchmark body into a setup() routine so the benchmark can be repeated cleanly. It does not change any production wallet code, network rules, or user-facing behavior, and it introduces no security issue.

This change only modifies a benchmark test file. It swaps a fake/mock database for a real SQLite database when measuring how fast wallet loading runs, and moves wallet setup work outside the timed portion so the benchmark is more accurate. There is no change to production wallet code, network behavior, or user-facing functionality, and no security issue is evident.

This is a benchmark-only code cleanup. It changes how a performance test creates a fresh wallet before each encryption run, replacing a database-copy approach with a setup() function that creates a new wallet each time. There is no change to production wallet encryption behavior and no security issue.

This is a benchmark-only change. It moves a 'mark cache dirty' step out of the timed portion of a wallet balance performance test so the benchmark measures only the balance calculation itself. There is no change to production wallet code, consensus logic, networking, or any user-facing behavior.

This is a small code-quality change to a benchmark test that measures how long it takes to create a Bitcoin wallet. It moves wallet cleanup from inside the timed loop to a setup/teardown phase so the benchmark only measures wallet creation. There is no user-facing behavior change and no security relevance.

This is a routine internal code cleanup in Bitcoin Core's wallet module. It merges several places that set up a wallet's address-generation seed/descriptors into a single helper function called SetupWalletGeneration(). There is no indication this fixes a security bug; it appears intended to make the code easier to maintain and to avoid duplicating logic when creating or encrypting wallets.

This commit adds a new automated test to Bitcoin Core. The test checks that the software correctly refuses to open a wallet that has been corrupted so that it contains both encrypted and unencrypted copies of the same key. It does not change any production wallet code; it only adds a regression test for an already-existing safety check.

This Bitcoin Core commit refactors how descriptor wallets are loaded from disk. Instead of creating an empty wallet key manager and then gradually adding keys and cache data to it, the code now gathers all the data first and creates the key manager in one go. The change also adds a safety check that rejects wallets containing both unencrypted and encrypted keys, which previously could have coexisted during incremental loading. There is no direct evidence in the commit that this fixes an active exploit, but the stricter loading model removes a class of potential consistency bugs.

This Bitcoin Core wallet patch changes how private keys are added when a user imports or migrates to a descriptor-based wallet. Previously, keys were added to the descriptor manager in a separate step after creation. The patch bundles the keys into the manager's constructor or update call so all descriptor data is provided at once. The commit message frames this as a code-quality fix, not a security fix. There is no direct evidence in the diff or commit message that this closes an exploitable vulnerability, but it does reduce a window where the wallet state could be inconsistent.

This is a small internal code cleanup in Bitcoin Core's wallet. It moves the setup of newly generated single-signature descriptors into a dedicated factory-style constructor and tightens some safety checks. There is no obvious user-facing bug or direct exploit here, but the change removes a redundant encryption step and changes when a 'decryption checked' flag is set, which could have subtle wallet-initialization implications.

This is a small internal code cleanup in Bitcoin Core's wallet module. It changes how an external-signer wallet manager object is created so that its descriptor is passed directly through the constructor rather than being set afterward via a separate SetupDescriptor method. There is no user-facing behavior change and no security fix.