Bitcoin Core

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.

This is a straightforward code cleanup: a function that asks the user questions used to accept an unused 'caption' parameter. The only caller always passed an empty caption, so the developer removed the parameter entirely. No behavior changes, no security implications.

This commit is a routine code cleanup in Bitcoin Core's test-only fuzzing utilities. It adjusts which C++ header files are included in two test files and fixes two minor comment typos. There is no change to the actual Bitcoin network code, consensus logic, wallet handling, or any code that runs in production.

This change updates Bitcoin Core's Windows CI workflow to install the Python `pyzmq` package before running functional tests. It is a build/test infrastructure fix with no direct effect on the Bitcoin Core software users run, and no security relevance is apparent from the commit itself.

This commit adds new automated tests to Bitcoin Core that exercise two known bugs in the experimental multiprocess (IPC) interface: one where disconnecting during a long-running call can crash the node, and another where sending too many calls to the same server thread triggers a 'thread busy' error. The tests document current behavior so future library upgrades can be checked against it. The commit does not fix the bugs; it only adds test coverage.

This commit changes Bitcoin Core's build configuration. It removes one compiler flag (-fdebug-prefix-map) from the main CMake build and adds it instead to the Guix reproducible-build script. The change is described by the project as fixing a 'confusing and brittle' build setup, not as a security fix. It primarily affects how source-code paths are embedded in debug information, which can influence build reproducibility and debuggability, but does not by itself create or fix a vulnerability in the running software.

This is a tiny formatting fix in Bitcoin Core's test runner. On Windows, the test output includes a hidden carriage-return character ('\r') that was making the closing parenthesis in log messages appear on a new line. The patch simply trims whitespace from the captured text so the log looks tidy. It does not change any network, wallet, consensus, or node behavior.

This commit only changes a user-facing help string. It corrects the description of the -logips option from saying it controls IP addresses in 'debug output' to saying it controls IP addresses in 'log output' generally. No code behavior changes, no security fix, no vulnerability.

This commit adds a simple informational log message warning users that enabling debug logging may write privacy-sensitive details (like transaction IDs) into log files, so they should be careful when sharing logs. It is a user-awareness/privacy-hardening change, not a fix for an exploitable security flaw.

This commit changes Bitcoin Core's internal test tooling so that self-check warnings always cause test runs to fail, instead of only doing so when a special '--ci' flag was passed. It also removes the now-unused '--ci' flag from CI scripts. This is a testing-hygiene improvement, not a fix for a security vulnerability in the Bitcoin software itself.

This change is a privacy hardening patch for Bitcoin Core's 'private broadcast' feature, which lets users send transactions over anonymity networks like Tor or I2P. Previously, routine log messages about private broadcasts—including transaction identifiers and peer details—were written to the default debug.log file. Because users often share their logs for troubleshooting, this could accidentally reveal which transactions they created. The patch moves those detailed messages behind a special debug logging category, so they only appear when a user explicitly enables it. Warnings stay visible but no longer include sensitive identifiers.

This is a small change to a Bitcoin Core functional test. It adds a check that when the test interrupts (stops) a running node, the node exits with status code 0 (success). Previously the test only waited for the node to stop without checking the exit code. This is a test-hardening improvement, not a fix to the Bitcoin Core software itself.