Bitcoin Core

This commit only changes Bitcoin Core's internal test code. It replaces tests that previously relied on external system commands like 'echo', 'false', and 'cat' with a self-contained mock program. There is no change to the actual Bitcoin node software that users run, and no security issue is introduced or fixed.

This commit is a minor cleanup in the project's automated testing configuration. It replaces a PowerShell script snippet with an equivalent Bash snippet that does the same thing: record the versions of build tools like CMake and MSBuild. There is no security issue here.

This is a routine cleanup of Bitcoin Core's Windows CI (continuous integration) scripts. It moves a PowerShell snippet that imports Visual Studio environment variables into a Python helper, renames a YAML anchor, and simplifies some repetitive code. There is no security-relevant change.

This change refactors Bitcoin Core's internal thread pool so that submitting a task returns an error code instead of throwing an exception. The main practical effect is fixing an unclean shutdown bug (#34573) where an unhandled exception could be thrown from an HTTP event callback. It is a defensive reliability improvement rather than a direct exploit for stealing funds or remote code execution.

This Bitcoin Core commit cleans up an old block-status flag when loading the blockchain database from disk. The old flag (BLOCK_FAILED_CHILD) is no longer used by current code, so the patch converts any leftover occurrences into the newer equivalent flag (BLOCK_FAILED_VALID) and marks the index entries as needing to be saved. This is a defensive data-consistency fix rather than a fix for an active exploit.

This commit is a simple code cleanup: it removes a redundant constant named BLOCK_FAILED_MASK and replaces its uses with BLOCK_FAILED_VALID, because the two had become identical in meaning. There is no functional change to how Bitcoin Core validates blocks or handles invalid chains.

This commit only adds a new automated test to Bitcoin Core. It does not change any production code. The test verifies that when the block index database is reloaded, a chain of three blocks with mixed invalidity flags is all correctly marked as permanently invalid. There is no direct security fix here, only a regression test for existing behavior.

This is a code cleanup change in Bitcoin Core. It removes the use of a separate 'descendant of a failed block' flag and instead marks those blocks with the same 'validation failed' flag used for the block itself. The commit explicitly states the two flags had no functional difference and were only adding unnecessary complexity. There is no indication this fixes a security bug or changes network behavior.

This commit is a straightforward code cleanup in Bitcoin Core's block invalidation logic. It renames a variable from 'invalid_walk_tip' to 'disconnected_tip' and introduces a new variable 'new_tip' to make the code easier to read. There are no functional changes that would affect security.

This commit only changes Bitcoin Core's internal functional test code. It makes the default timeout for a debug-log assertion helper stricter (0 seconds instead of 2 seconds) and updates existing tests to explicitly pass a 2-second timeout where needed. There is no change to the actual Bitcoin node software that users run, so it cannot affect live networks, wallets, or consensus.

This is a straightforward memory-use and performance optimization inside Bitcoin Core's transaction clustering code. It changes an internal index type to the smallest unsigned integer that fits the data, and switches a dynamically-sized vector to a fixed-size array. There is no security-relevant change here—no bug fix, no input validation change, no cryptographic change, and no behavior change visible outside the module.

This is a routine internal code cleanup in Bitcoin Core's transaction-cluster linearization logic. It replaces a separate list of dependency objects with direct parent/child indexes and a per-transaction vector, making the code simpler and slightly faster. There is no user-facing change, no network change, and no security fix.

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 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 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 routine performance improvement inside Bitcoin Core's transaction-cluster linearization code. It replaces an O(number of dependencies) scan with an O(number of transactions) scan by maintaining a smaller 'active children' set. There is no user-visible behavior change, no network-facing change, and no security fix.

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 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 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 commit is a routine code cleanup in Bitcoin Core's transaction-cluster linearization logic. It removes a helper function called UpdateChunk and copies its logic directly into the two places that used it (Activate and Deactivate). The behavior is intended to stay exactly the same; the change is described by the author as an optimization and preparation for future work. There is no indication of a security fix.

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.