Bitcoin Core

This is a routine performance optimization inside Bitcoin Core's transaction clustering code. It precomputes and caches which related transactions a chunk can reach, instead of recalculating that set on demand. The change includes extra assertions to verify the cached values stay correct. There is no security-relevant behavior change and no indication this fixes a vulnerability.

This is a pure code cleanup: a single function was split into three smaller, clearer helper functions with no change to what the code actually does. There is no security issue visible in the commit.

This commit is a straightforward code cleanup inside Bitcoin Core's transaction-cluster linearization logic. It takes one large function, OptimizeStep, and splits it into two smaller helper functions, PickChunkToOptimize and PickDependencyToSplit, without changing what the code actually does. There is no security-relevant change here.

This commit adds extra internal safety checks and test-like assertions to a Bitcoin Core transaction-cluster linearization module. It does not change normal network behavior; it only helps developers catch programming mistakes during testing or debugging. There is no indication it fixes an active security bug or is exploitable by users.

This commit is an internal performance optimization for Bitcoin Core's transaction clustering algorithm. It changes how the code tries to combine groups of related transactions during fee estimation, doing less work upfront while still checking both directions for newly merged groups. The test file updates expected iteration counts accordingly. There is no indication this change affects security, consensus, network behavior, or user funds.

This commit is a performance optimization inside Bitcoin Core's transaction-cluster linearization code. It adds a tracking set so the algorithm does not enqueue the same chunk twice for later improvement. The change is described by the author as an optimization, not a security fix, and the diff shows no behavior change beyond avoiding duplicate work and updating corresponding test iteration limits.

This is a routine code cleanup and performance tweak inside Bitcoin Core's transaction-cluster linearization logic. It rewrites how the algorithm picks which chunk of transactions to merge next, making the code simpler and slightly faster. There is no indication of a security bug being fixed.

This commit is a purely mechanical rename of internal variable names in Bitcoin Core's transaction clustering code. Every occurrence of '_rep' (short for 'representative') is changed to '_idx' (short for 'index') in a single header file. There are no logic changes, no bug fixes, and no security implications. The commit message explicitly says this is a preparatory cleanup to make the next change easier to review.

This is a small internal code cleanup in Bitcoin Core's transaction clustering/linearization logic. It changes a helper function so it returns chunk indexes directly instead of having callers look them up afterward. There is no user-facing behavior change, no network change, and no security fix.

This is a routine internal code cleanup in Bitcoin Core's transaction clustering/linearization logic. It splits one combined counter into two separate counters for clarity, with no functional change intended. There is no security issue visible in the commit.

This is a small internal cleanup in Bitcoin Core's transaction-cluster linearization code. It removes an unnecessary argument from a debugging/self-check function called SanityCheck(), because the object already stores a reference to the same data. There is no user-facing change, no network behavior change, and no security fix.

This commit fixes a variable type mismatch in Bitcoin Core's transaction clustering code. The code counts dependencies between groups of transactions, but was using a transaction-index type for the count. If that count type is smaller than the actual number of dependencies, it could overflow or behave incorrectly when many dependencies exist. The fix changes the count and random-picker variables to a plain unsigned integer, which is the appropriate type for counting.

This is a minor build-system change. It makes a CMake setting called CMAKE_COMPILE_WARNING_AS_ERROR appear in the configuration summary and be toggleable in the ccmake tool. It does not change how Bitcoin Core is compiled, what warnings are treated as errors, or any runtime behavior. There is no security relevance.

This commit only tightens a unit test's error-message check. It does not change production code, network behavior, or wallet logic, so it has no direct security impact on users.

This commit refactors how Bitcoin Core launches external helper programs (used for hardware wallet signing). Previously, commands were passed as a single string that the library split into arguments automatically. Now, callers must provide the command and its arguments as a pre-split list. The change reduces the risk of shell-style injection or mis-parsing when command paths or arguments contain spaces or special characters, but it is a code-quality and hardening change rather than a fix for a known exploitable bug.

This commit only adds a new test to Bitcoin Core. It checks that two optional index features (block filter index and coinstatsindex) cannot be started on a pruned node even if the missing raw blocks are fetched from a peer, because those indexes also need 'undo data' that getblockfrompeer does not provide. There is no product code change and no security fix.

This commit only adds a new test case to Bitcoin Core's test suite. It checks that a node can be stopped and restarted safely even if it has never synced or generated any blocks, including with optional indexes enabled. There is no change to production code, no bug fix, and no security-relevant behavior change.

This commit is a small cleanup following an earlier pull request. It rewrites one boolean condition in a clearer but equivalent way, updates a user-facing help string to describe a value more accurately, and makes some internal variables and function parameters read-only (const). There is no indication it fixes an active security bug or changes behavior in a way attackers could exploit.

This Bitcoin Core commit tightens startup checks for optional indexes (like the block filter and coin stats indexes) when a node is running in pruned mode. Previously, the startup check only verified that raw block data was available on disk. Some indexes, however, also need 'undo' data to catch up from an older block. If a user pruned blocks but kept the index enabled, the index could try to sync past the pruned undo data and fail or behave incorrectly. The fix now separately checks whether both block and undo data are available for indexes that require undo data, and only checks block data for indexes that do not. It is a defensive correctness fix rather than a remote-exploitable vulnerability.

This is a harmless CI (continuous integration) maintenance change. It lets an optional code-style check called IWYU run in environments like git worktrees or archives where a full git history isn't present. It does not touch Bitcoin's network code, wallet, consensus, or any user-facing behavior.

This commit adds safety guards to Bitcoin Core's continuous integration (CI) shell scripts. The scripts install software and change system settings, so they could damage a developer's computer or the source code repository if run directly by mistake. The change makes the scripts refuse to run unless a special safety flag, DANGER_RUN_CI_ON_HOST=1, is set, and it arranges for that flag to be set automatically only inside the intended container environment. It is a hardening improvement, not a fix for an active attack.

This is a trivial build-script cleanup. It removes a duplicate export of the TZ environment variable and moves another environment variable setting earlier in the script. There is no security issue here.

This commit fixes a typo in a comment inside a Guix codesigning helper script. The comment incorrectly named the build script as 'build.sh' when it should read 'codesign.sh'. No executable code was changed, so this has no effect on Bitcoin Core's behavior or security.

This commit changes two user-facing text strings in the Bitcoin Core wallet's PSBT (Partially Signed Bitcoin Transaction) dialog so they correctly use singular/plural forms in different languages. It is a localization/translation fix with no security relevance.

This commit simply moves a set of fixed numeric constants (such as how many buckets addresses are spread across, retry limits, and time windows) from the implementation file to the header file. It does not change any values, logic, or behavior. There is no security issue here.