Bitcoin Core

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 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 is a minor code cleanup in a helper script that checks Git commit signatures. It replaces several verbose file-reading instructions with shorter, equivalent ones using Python's pathlib module. There is no security-relevant change.

This commit removes a special exception list that let one specific old commit be verified using the older, weaker SHA-1 algorithm. The exception is no longer needed, so the code now treats all commits consistently under the stronger SHA-512 verification rules. By itself, this is a cleanup that slightly tightens the project's commit-verification script; it is not a fix for an active security bug in Bitcoin Core's network code or wallet.

This commit is a minor code cleanup inside a fuzz test (automated randomized testing) for Bitcoin's header synchronization logic. It replaces a manual check that skipped invalid mock times with a built-in minimum-time option in the test helper. There is no change to production Bitcoin node code, no user-facing behavior change, and no security fix.

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 is a tiny maintenance patch for a code-style checking tool used in Bitcoin Core's continuous integration. It adds one missing line to a patch file that tells the Include What You Use (IWYU) tool to recommend the C++ header <cassert> instead of the C header <assert.h>. It does not change any Bitcoin Core runtime code, consensus rules, networking, wallet logic, or build outputs. There is no security relevance.

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 adds a new C++ language feature to Bitcoin Core's custom Expected helper class: the ability to safely move a value out of a temporary Expected object when using the * operator. It also adds a unit test. There is no security issue here; it is a routine code-quality and standards-conformance improvement.

This commit removes leftover code that unnecessarily shared Bitcoin's dependency source files into the isolated Guix container used for codesigning release binaries. The change is described by the author as a cleanup of copy-pasted build-container options, not a security fix. It slightly reduces the attack surface of the codesigning environment by exposing fewer files, but there is no direct evidence of an exploitable vulnerability.

This commit adds two new ways to access values and errors from a custom 'Expected' helper type in Bitcoin Core: rvalue (move) overloads for value() and error(). It also tightens error() to use an assertion helper instead of a manual assert. The changes are purely internal utility improvements, currently unused elsewhere in the codebase, and do not fix or introduce any security vulnerability.

This is a small internal code cleanup in Bitcoin Core's utility library. It adds a dedicated specialization for 'Expected<void, E>' so that when no return value is needed, the code no longer exposes a placeholder type (std::monostate) through the public value() method. It also adds a couple of unit tests. There is no security fix, behavior change, or externally visible vulnerability addressed.

This commit changes a Bitcoin Core utility class so that a specific programming mistake now throws a catchable exception instead of crashing the program with an assertion failure. It also marks two operators as 'noexcept', meaning misuse of those operators will terminate the program rather than throw. The change is defensive and aligns the custom class with the C++ standard library's std::expected behavior. There is no direct evidence this fixes an exploitable security bug.

This commit only changes Bitcoin Core's internal fuzz testing code (test harnesses that randomly feed network messages to the software to find bugs). It does not alter the live Bitcoin network node code that users run. The change restores a previously dropped test step (calling SendMessages during fuzzing) and fixes how test objects are reset between runs so that memory-sanitizing tools can catch dangling pointers. There is no direct security impact on production Bitcoin nodes.

This is a straightforward internal code cleanup. It changes how CConnman stores its reference to the address manager from a plain C++ reference to std::reference_wrapper, which behaves the same way at runtime but can be reassigned in tests. No behavior of the live Bitcoin node changes, and there is no security fix or vulnerability here.

This Bitcoin Core patch fixes a small inconsistency in how a node tells other nodes about its own network address. Normally, before sharing any address, the code checks whether the receiving peer can actually understand that address type. The very first self-announcement was skipping that check, which could cause a peer to receive an address format it does not support. The patch adds the missing compatibility check so the first announcement follows the same rule as all later ones.

This is a minor test-only change. It updates one Bitcoin Core functional test to let the operating system pick a free network port automatically, instead of the test guessing a port number. This prevents the test from failing when another test is already using the guessed port. It does not change the Bitcoin Core software that users run, and it has no security impact on the live Bitcoin network or user wallets.

This commit is a pure code-style cleanup. It removes unnecessary 'const' keywords from function parameter declarations in header files across the Bitcoin Core codebase and adds a clang-tidy rule to prevent them from being reintroduced. The 'const' on a value parameter in a declaration has no effect on callers and does not change program behavior, security, or runtime semantics. There is no vulnerability here.

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 commit changes a Bitcoin Core fuzz test (an automated testing tool, not production code) to skip inputs that are unusually complex. The goal is to avoid wasting fuzzing time on strings that would be too slow to parse, not to fix a security bug in live Bitcoin software.

This commit is a minor cleanup in Bitcoin Core's non-graphical user interface code. It removes a leftover ': ' prefix that was accidentally added to some log and error messages. There is no security vulnerability here—only a small cosmetic fix that makes error messages display correctly in tests and logs.

This is a minor code cleanup in the Bitcoin Core graphical user interface. It removes an unused function parameter and adds a comment explaining that message titles are empty for messages coming from the network node. The commit message explicitly states it does not change any behavior, and the diff confirms this: the same empty title is still passed, just through a local variable instead of a function argument.

This is a simple code cleanup: a function used to show pop-up messages had an unused 'caption' parameter that was always passed as empty. The commit removes that parameter everywhere. The commit message explicitly says it does not change any user-facing behavior, and the code changes match that claim.