Bitcoin Core

This Bitcoin Core wallet change lets the wallet remember multiple valid versions of the same transaction that look identical on-chain by transaction ID (txid) but differ by witness transaction ID (wtxid). For example, a Taproot spend can be signed in two different valid ways. Previously the wallet only kept one witness version, which could cause it to lose track of the actual confirmed version or show wrong balances/labels. The fix stores all variants and picks a canonical one, with older wallet software still able to read the main record safely.

This commit removes an unused explicit copy helper and strengthens a safety guard in Bitcoin Core's wallet code. Previously, copying a wallet transaction object was allowed through a private default copy constructor and an explicit CopyFrom() method. The change deletes both, so the object can no longer be accidentally duplicated. The commit message and code comment explain this is meant to prevent bugs where updates happen on the wrong copy of a transaction, not to fix an active security vulnerability.

This is a routine internal code cleanup in Bitcoin Core's wallet module. It makes the transaction pointer inside a wallet transaction object private and forces the rest of the code to read it through a getter function. There is no security fix here; the change prepares the code for a future feature where a wallet transaction might hold more than one transaction.

This commit changes how Bitcoin Core wallet transactions are loaded from disk or copied between wallets. Previously, a wallet transaction object could be created with no actual transaction inside it, and later filled in. The patch makes the transaction data mandatory from the start using a constructor that deserializes directly from a data stream. The stated goal is to prevent crashes (segfaults) caused by accidentally using a null transaction pointer, especially as more transaction types are stored in the wallet. It also improves error handling for corrupt wallet records.

This is a small code cleanup in a fuzz test file. It removes a helper function and changes one call site to use the standard serialization pattern instead. There is no security issue here.

This commit simply removes an unused helper function inside Bitcoin Core's fuzz testing code. Fuzz tests are internal developer tools used to find bugs, not code that runs on live Bitcoin nodes or wallets. There is no security-relevant change to production behavior.

This commit is a code cleanup that changes the way some Python test helper functions are written so that a linting tool (Ruff) can enforce a style rule. It does not change what the software does, only how the test code is formatted. There is no security issue here.

This is a code-quality cleanup, not a security fix. It changes two test-only comparisons from '== False' to 'is False' and removes a linter exception. The commit message says this preserves RPC semantics, but the change is inside Bitcoin's own functional test suite and does not alter the production Bitcoin node software that users run.

This commit is a build-system and test-file reorganization. It merges two test files into one and adjusts CMake rules so the combined test compiles with the required library paths. There is no change to Bitcoin Core's runtime code, consensus rules, wallet handling, or network behavior. It fixes a CI compile error where a test header could not be found, but it does not fix any security vulnerability.

This is a small defensive code change in Bitcoin Core's inter-process communication (IPC) code. It reorders two class member variables so that the event loop is destroyed before the background thread that runs it. The commit message says there is no behavior change and the goal is to clarify intent and avoid potential future bugs. The change itself does not fix a known exploitable vulnerability, but it addresses a real C++ object lifetime risk.

This is a small test-only cleanup that changes hardcoded Unix-style forward slashes in a test file to use the operating system's native path separator. It does not change any production code or fix a security bug.

This commit fixes a Windows build problem. The code included a Unix-only header file ('unistd.h') unconditionally, which caused Microsoft Visual C++ (MSVC) compilation to fail because that header does not exist on Windows. The fix wraps the include so it is only used on non-Windows builds. There is no security issue here—just a portability fix to make the project compile on Windows.

This is a straightforward code cleanup that renames the type used for process IDs from plain 'int' to a new 'ProcessId' alias. It makes the code compatible with a future library update that will support Windows, but does not change any actual behavior or fix any security issue.

This is a purely cosmetic code cleanup that reorders #include lines in a single source file. It moves two standard C++ library headers (<utility> and <vector>) to sit with the other standard headers, separate from POSIX system headers. There is no functional change, no bug fix, and no security relevance.

This commit is a straightforward code cleanup: it replaces the plain 'int' type with a new 'SocketId' type alias when referring to socket identifiers throughout Bitcoin Core's inter-process communication (IPC) code. The change is described by the author as preparation for a future version of the libmultiprocess library that will add Windows support. There is no security fix here and no change to program logic—only type names and a constant for the error value were updated.

This is a straightforward internal code cleanup in Bitcoin Core's inter-process communication (IPC) layer. It replaces direct use of raw socket identifiers with a new 'Stream' type alias so the code can work with an upcoming version of a supporting library that adds Windows support. No security bug is fixed or introduced in the visible changes.

This is a straightforward internal code cleanup in Bitcoin Core's inter-process communication (IPC) layer. It moves the executable name parameter from individual connect/listen/serve methods into the protocol object's constructor. The executable name is only used for logging and debugging to tell different processes apart. There is no change to security-sensitive behavior, no bug fix, and no externally reported issue.

This commit removes unnecessary mutexes (simple locking mechanisms) from two internal Bitcoin Core fuzz test files. Fuzz tests are automated testing tools, not part of the live Bitcoin network software. The change is a code cleanup: the developers concluded the locks were not needed because fuzz targets run one at a time within a single process. There is no indication this fixes a security vulnerability or affects real users.

This is a routine performance optimization in Bitcoin Core's transaction-cluster linearization code. It replaces dynamically-allocated vectors with fixed-size stack arrays to avoid repeated heap memory allocations. There is no security-relevant change: the algorithm, ordering logic, and dependency handling remain identical.

This is a routine performance improvement, not a security fix. It pre-allocates memory for an internal queue so the program doesn't waste time repeatedly resizing it while building a data structure. There is no user-facing or security-relevant change.

This is a small internal performance improvement in Bitcoin Core's transaction clustering code. It avoids doing the same bit-set intersection twice by saving the result of the first pass. There is no security-relevant change: no new behavior, no bounds check changes, no memory safety changes, and no externally reachable input handling.

This commit updates the Qt graphical toolkit used by Bitcoin Core from version 6.8.3 to 6.8.4 in the project's dependency build system. It also refreshes Bitcoin-specific patches, removes one now-unneeded build patch, and disables a new RISC-V vector optimization in the bundled libpng to avoid cross-compilation link failures. Qt 6.8.4 is a routine patch release by Qt, and the commit message frames this as a standard dependency update rather than a security fix. There is no direct evidence in the commit or supplied references that this resolves a known vulnerability in Bitcoin Core.

This commit is purely a code-style cleanup. It adds a space between the macro name LIMITED_WHILE and its opening parenthesis across many fuzz test files, plus a few tiny formatting fixes like removing a redundant semicolon and fixing indentation. No program behavior changes, no security fixes, and no production code is touched.

This commit only changes a code-formatting configuration file. It tells the project's automatic formatting tool (clang-format) to treat the custom LIMITED_WHILE macro the same way it treats a normal 'while' loop when laying out code. There is no change to program logic, no bug fix, and no security relevance.

This commit removes a temporary safety check in a fuzz test (automated randomized testing code) for Bitcoin Core's inter-process communication. The check avoided sending empty byte arrays because an external library had a bug that triggered undefined-behavior sanitizer warnings. The library bug is now fixed, so the workaround is no longer needed. This is a cleanup of test code, not a fix to production Bitcoin Core code, and it does not change how real users' transactions or wallets are handled.