Bitcoin Core

This commit is a routine code-quality cleanup. It adjusts which C++ header files are included in several source files under src/primitives and tells the automated 'Include What You Use' (IWYU) checker to treat those files as strictly checked. There is no change to program logic, no bug fix, and no security-relevant behavior.

This commit is a straightforward code cleanup that replaces older-style std::bind calls with the newer C++20 std::bind_front. It does not change what the program does, only how the code is written. There is no security issue here.

This commit is a simple rename-only code cleanup. It changes the name of a transaction size method from GetTotalSize to ComputeTotalSize to make it clear the size is recalculated each time rather than stored. No behavior, logic, or security properties change.

This commit tightens the bitcoin-wallet command-line tool so it can no longer create a wallet without an explicit name. Previously, the tool allowed creating an unnamed wallet in some situations, which could lead to confusion or accidental wallet files being placed in unexpected locations. The change adds clear error messages and tests to ensure the tool refuses to create unnamed wallets for both regular creation and creation from a dump file.

This Bitcoin Core change stops users from creating or restoring wallets with an empty name through the normal RPC commands. Empty wallet names could cause confusion or unexpected behavior, so the patch now rejects them with a clear error. The only exception is during wallet migration, where an existing unnamed wallet is allowed to be restored. The change is a hardening fix, not a response to an active exploit.

This commit only adds a comment explaining why a particular code header must be kept. It does not change any program logic, data handling, or security behavior. There is no security issue here.

This commit only adds new test cases to an existing Bitcoin Core functional test file. It checks that sending multiple transactions to the same address correctly sums the received amount, and that an invalid address string produces a proper error. There is no change to production wallet code, no bug fix, and no security-relevant behavior change.

This is a simple code cleanup change. It moves where a wallet setting called -walletbroadcast is read from the command-line/config into the wallet object. Previously it happened inside a locked section; now it happens earlier with other similar settings. The commit message explicitly says this does not require locks and is just relocating initialization. There is no security issue visible in the change.

This commit is a straightforward code cleanup in Bitcoin Core's wallet loading logic. It replaces a long chain of 'if/else if' checks with a 'switch' statement that handles the same set of wallet database error codes. No behavior changes are visible in the diff, and no security issue is introduced or fixed.

This commit is a straightforward internal code cleanup in Bitcoin Core's wallet module. It moves the code that translates database load errors into user-facing error and warning messages from two separate callers into the single function that actually loads the wallet data. There is no change to what errors are detected, what messages are shown, or how the wallet behaves when problems occur.

This commit is a routine code-quality cleanup. It adjusts which C++ header files are included in several source files under src/kernel and tells the continuous-integration system to treat missing-header warnings in that directory as errors. There is no change to program logic, no bug fix, and no security-relevant behavior.

This commit removes calls to a database-loading helper in three places where they were unnecessary. In two test files and one wallet dump/import tool, the code was calling PopulateWalletFromDB() on a freshly created, empty wallet database before immediately writing new data into it. The change is a code cleanup: it deletes redundant work and, in the dump tool, removes an error check that could never fail meaningfully because the wallet had just been created. There is no direct evidence this fixes a security vulnerability.

This commit is a simple rename of one internal wallet function from LoadWallet() to PopulateWalletFromDB(). It does not change what the code does, only its name. There is no security impact.

This commit adds a standard swap() method to a small utility helper class (Expected) used to represent either a successful value or an error. It also adds a unit test. There is no security relevance in the change itself.

This commit is a routine code cleanup that avoids unnecessary copying of strings and objects by using references or moving values instead. It does not change program behavior or fix any security bug.

This is a small code cleanup in Bitcoin Core's wallet creation RPC. It replaces a local error-handling block with an existing shared helper function, and adds one missing error code (encryption failure) to that helper. There is no direct evidence this fixes a security vulnerability; it is best characterized as a maintainability/refactoring change that incidentally makes error reporting more consistent.

This commit updates the libmultiprocess library inside Bitcoin Core. The most important change fixes a classic multi-threaded 'fork safety' bug in the process-spawning code. Before the fix, the code could run a callback inside the child process after fork(), which can cause the child to deadlock forever if the parent happened to be holding a lock at the exact moment of fork. The patch moves that callback work into the parent before fork(), and also makes the child process use simple, non-throwing error handling after fork. Other changes are mostly documentation, CI build setup, and version tracking.

This is a minor code cleanup in Bitcoin Core's internal benchmarking test code. It changes how a macro is written so callers must add a semicolon, and it updates a type alias style. It does not affect the live Bitcoin network, wallets, or consensus rules.

This commit only adds a new regression test to Bitcoin Core. It does not change any production wallet, consensus, or mempool code. The test exercises a scenario involving v2 and v3 (TRUC) transactions across a blockchain reorganization, likely to ensure a previously reported issue stays fixed. There is no patch to runtime behavior here, so it does not introduce or fix an exploitable vulnerability by itself.

This commit simply deletes unused helper code from two Python scripts in the contrib/ directory. No security vulnerability is introduced or fixed; it is a routine cleanup change.

This commit removes a single internal safety check (an 'Assume' assertion) in Bitcoin Core's wallet code. The assertion could incorrectly fail during a blockchain reorganization, causing the wallet process to abort unexpectedly. Removing it prevents a potential crash, but does not by itself fix any underlying logic bug in how transactions are handled.

This commit only changes a test file. It refactors an existing test for failed wallet migration and adds more test cases for wallets with relative and absolute paths. There is no change to production wallet code, so it does not introduce or fix a security issue in the software users run.

This change adds a safety check to a Bitcoin Core fuzz test (an automated testing harness, not production wallet code). It rejects fuzz inputs that would create descriptor strings with unusually long 'leaf' segments before feeding them to the wallet's descriptor parser. The goal is to prevent the fuzzer from wasting time or hitting limits on pathologically large inputs, not to fix a user-facing security bug.

This is a small change to a Bitcoin Core fuzz test (a developer testing tool that feeds random data to code to find bugs). It makes the test skip more kinds of unusually complex descriptor strings so the fuzzer spends time on realistic inputs instead of wasting compute on pathological ones. It does not change any production wallet or network code, so it has no direct effect on real users' funds or node security.

This is a fix to a Bitcoin Core functional test, not to production wallet code. The test was predicting a backup filename based on a cached mock time, but the helper it called also changed mock time internally, which could make the predicted filename wrong and cause the test to fail. The fix calls the migration RPC directly and copies a wallet file explicitly. There is no security issue in the Bitcoin Core software itself.