Bitcoin Core

This is a minor improvement to Bitcoin Core's internal continuous integration (CI) script. It makes the script fail earlier and with a clearer error message if a required environment variable is missing. It does not change how Bitcoin nodes run, how wallets work, or how transactions are validated. There is no security vulnerability being fixed here.

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 commit only updates documentation and build error messages to state the minimum supported versions of Apple's Xcode Command Line Tools (16.2) and Microsoft's Visual C++ compiler (18.3). It does not change any executable code, cryptographic logic, network behavior, or security-sensitive functionality. There is no security issue here.

This commit only adds a new test to Bitcoin Core's functional test suite. It runs each MuSig2 signing operation twice and checks that different nonces and partial signatures are produced each time. There is no change to wallet or consensus code, so it does not fix or introduce a vulnerability by itself. It is a defensive regression test aimed at catching nonce-reuse bugs in the future.

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 routine cleanup: it removes an option called include_dummy_extranonce that no longer does anything. The previous commit already made the block-building code ignore this flag, so this change only deletes leftover references in tests, benchmarks, RPC code, and fuzz targets. There is no security-relevant behavior change.

This commit fixes a bug in Bitcoin Core's block-template creation for new blocks at very low chain heights (blocks 1-16). Since a recent earlier change, the software stopped adding a harmless placeholder byte to the coinbase transaction, causing block creation to fail an internal validity check with a 'bad-cb-length' error. The fix re-adds that placeholder byte for low-height blocks, but only inside the node's own template, not in the data handed to external mining clients. Those clients are now documented as needing to supply their own extra byte. It is a correctness/reliability fix for mining interfaces, not a vulnerability that lets an attacker steal funds or break consensus.

This change only affects an internal fuzzing test harness (a tool used to automatically find bugs in Bitcoin Core). It swaps the task runner used during fuzz testing so that lock-order debugging warnings no longer report a false alarm. There is no change to production code, no real deadlock is being fixed, and no user funds or network behavior are affected.

This commit only updates three documentation files for FreeBSD, NetBSD, and OpenBSD build guides. It corrects the instructions for enabling ZeroMQ support by adding the required CMake option `-DWITH_ZMQ=ON`. No code, build system, or runtime behavior is changed.

This commit only adds a new automated test that demonstrates an existing bug in Bitcoin Core's mining IPC interface. The bug causes block creation to fail on brand-new test chains for the first 16 blocks. The commit does not fix the bug; it documents it and works around it in the test by using an RPC call instead. There is no direct security risk to users here, but it highlights a reliability issue in an experimental IPC feature.

This is a test-only code cleanup. It changes how a test helper builds the special coinbase script prefix for low block heights, adding an option to skip a padding byte. No production Bitcoin Core code is modified, so it cannot affect real users, funds, or network consensus.

This commit is a pure code move: it takes the CreateMuSig2PartialSig function out of the CKey class in key.cpp/key.h and places it in the musig.cpp/musig.h module. The function's logic is unchanged, and the only caller is updated to use the new free-function name. There is no security fix or behavior change.

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 commit simply adds a public accessor function that returns an internal cryptographic context object. It does not change how keys are created, signed, or verified, and it introduces no new behavior that could be exploited. It is a routine code-organization change to support future work.

This is a documentation-only change that adds a clarifying note to the fuzzing quickstart guide. It explains that using the libfuzzer-nosan preset creates binaries in a different directory (build_fuzz_nosan) than the regular libfuzzer preset (build_fuzz). There is no code change and no security issue.

This is a minor test-only cleanup. It removes a TODO comment and two command-line flags that forced a specific address type in one of Bitcoin Core's automated functional tests. The change has no effect on production code, user wallets, or network behavior.

This commit is a pure cleanup of the project's Python linter configuration file (ruff.toml). It replaces a long explicit list of individual style/error checks with shorter category codes and a small 'ignore' list. There is no change to Bitcoin Core's actual code, behavior, or security.

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 only turns on three new lint checks in the project's Python code style tool (ruff). These checks warn when text contains Unicode characters that look like ordinary ASCII letters but are actually different characters, which can be confusing or misleading. There is no code behavior change, no bug fix, and no security patch.

This commit is a defensive hardening change for Bitcoin Core's handling of BIP32 'chain codes'—secret-derived values used when creating child keys from a master key. Previously these values were stored as ordinary 256-bit numbers that could remain in memory after use. The change makes ChainCode a dedicated type that securely wipes its own memory when it goes out of scope, similar to how private keys are already handled. It is a preventive security improvement rather than a fix for an active exploit.

This change tweaks how Bitcoin Core's MuSig2 multi-signature code keeps track of active signing sessions. Previously, the session identifier was based only on the public keys and the transaction hash. Now it also includes each participant's public nonce. This matters because the same keys and transaction can legitimately be signed more than once, and without the nonce in the identifier the code could confuse two different signing sessions and risk reusing or misplacing secret nonce data. The commit itself is framed as a safety improvement, not a fix for a known active bug or exploit.

This commit only adds a new automated test to Bitcoin Core. It does not change any production code. The test checks that when a node restarts after pruning a stale side-chain block, the internal block-tracking data structure does not incorrectly mark the block as 'unlinked.' There is no fix or vulnerability patch here—just extra test coverage for an existing invariant.

This commit fixes a bug in Bitcoin Core's descriptorprocesspsbt RPC command. Previously, the command could mark a partially-signed Bitcoin transaction (PSBT) as 'complete' and return a finalized transaction hex even when one of the signatures was actually invalid. The fix makes the command verify signatures cryptographically, not just check that signature data is present. The new test deliberately corrupts a signature and confirms the command now correctly reports the PSBT as incomplete.

This is a small documentation-only change to Bitcoin Core release notes. It clarifies how developers should check for Taproot support after the 'taproot' field was removed from the getdeploymentinfo RPC. No code behavior changed, and there is no security vulnerability in the commit itself.

This commit is a defensive hardening patch for Bitcoin Core's HMAC code. It wipes two temporary memory buffers that previously held sensitive key-derived data after the HMAC operation finishes. The change reduces the risk that leftover key material could leak through memory dumps, core dumps, or side-channel attacks, but it does not fix an active bug or known exploit.