Bitcoin Core

This commit is a small internal cleanup in Bitcoin Core's memory pool (mempool) data structure. It changes how the mempool tracks which transaction spends a given coin: instead of storing a pointer to the transaction and then looking it up again in another table, it now stores an iterator directly into that table. This removes a few redundant lookups and simplifies some code paths. There is no indication this fixes a security bug or introduces a vulnerability.

This tiny change allows a small internal bookkeeping object (Epoch::Marker) to be moved in memory rather than copied. The commit message gives no security context. By itself this is a routine C++ cleanup; it does not obviously fix or introduce a vulnerability, though it slightly changes object lifetime behavior.

This is a small internal code cleanup in Bitcoin Core's transaction graph code. It swaps one data structure (an ordered set of cluster pointers) for another (an unordered set of cluster sequence numbers). The behavior is unchanged; the change is described by the author as improving fuzz-test stability. There is no security-relevant bug fix here.

This is a one-line change in Bitcoin Core's internal test framework. It adjusts the version number at which the test suite starts passing a '-nologratelimit' option to tested nodes, lowering the gate from an unreleased future version (299900) to the actual current release series (290100). It does not change production node behavior and has no direct security relevance.

This is a one-line build-system warning fix for the Windows MinGW compiler. It changes a preprocessor guard so that the `environ` variable is not re-declared on any Windows build, preventing a harmless compiler warning about inconsistent linkage. There is no functional change to program behavior and no security impact.

This commit fixes a small logic bug in Bitcoin Core's block-template waiting code. When the mempool is empty, the code that decides whether a newly created block template is 'better' than the old one would never finish its comparison loop, so it could fail to return a result or behave unexpectedly. The fix replaces the manual loop with a simple sum of all fees, and adds tests for the empty-mempool case. It is a correctness fix rather than a critical security vulnerability.

This commit simply archives the release notes for Bitcoin Core version 29.2. It adds a documentation file listing bug fixes, performance improvements, and contributor credits. There are no code changes and no security-relevant action in the commit itself.

This commit is a routine subtree update that pulls in the latest minisketch library changes. The visible changes are almost entirely build-system and documentation additions: a new CMake build system, CI configuration files, README updates, and generated field-parameter documentation. There is no indication in the commit message or diff of any bug fix, behavior change, or security patch to the actual sketching code.

This commit fixes an accounting bug in Bitcoin Core's in-memory coin cache. A function called EmplaceCoinInternalDANGER was adding the memory size of a coin to a running total even when the coin was not actually inserted because the same key already existed. That could slowly inflate the cache-size counter. The patch makes the counter increase only on a successful insert and also records the size before the coin is moved. The commit adds tests and fuzzing coverage to prevent the bug from returning. It is a correctness and resource-accounting fix rather than a direct theft or remote-code-execution vulnerability.

This commit fixes an internal accounting bug in Bitcoin Core's coin cache. When adding a coin to a cache slot that was already occupied, the program could subtract memory usage before checking whether the operation was allowed. If the operation then threw an exception, the subtraction had already happened but the coin was not actually replaced, causing the internal memory counter to drift and eventually underflow (wrap around to a huge number). The fix moves the subtraction to after the safety check, and only resets the counter when the cache is successfully flushed. It also removes UBSan suppressions that were hiding the underflow and adds a unit test.

This commit adds a single runtime assertion inside Bitcoin Core's coin cache code. It checks that a newly-created cache entry starts out empty, so the code does not need to adjust its memory-usage bookkeeping before assigning a coin to it. It is a documentation-style safety check, not a fix for a known bug or vulnerability.

This is a code cleanup (refactor) in Bitcoin Core's coin cache bookkeeping. It removes a duplicate subtraction of memory usage that could never actually change the total, because spent coins already report zero memory usage. The change replaces the redundant subtraction with an assertion that documents this invariant. There is no security vulnerability here.

This commit is a memory optimization for Bitcoin Core's transaction graph code. It adds a special lightweight implementation for clusters that contain exactly one transaction, avoiding the overhead of full dependency-graph data structures. There is no security-relevant change here—only a performance and memory-usage improvement.

This is a small internal code cleanup in Bitcoin Core's transaction graph module. It introduces helper functions to create empty cluster objects and replaces three direct object-creation calls with those helpers. There is no change to network behavior, consensus rules, or user-visible functionality.

This is an internal code cleanup and preparation change in Bitcoin Core's transaction graph handling. It adds virtual methods to report how many transactions a Cluster object is designed for, and updates merge/split logic to choose the right internal data structure size. There is no user-facing bug fix or security patch here; it is groundwork for a later change.

This is a pure documentation/comment fix. It updates outdated class names in code comments to match the actual implementation class name (TxGraphImpl instead of Graph). No executable code was changed, so there is no security risk.

This commit is a pure internal code cleanup (refactor) in Bitcoin Core's transaction graph module. It turns the existing Cluster class into an abstract interface and moves the actual implementation into a new GenericClusterImpl subclass. No behavior changes, no bug fixes, and no security-relevant modifications are visible in the diff.

This is a clean internal code refactor in Bitcoin Core's transaction graph module. It adds four helper functions to the Cluster class so that Merge() and Split() no longer peek directly into another Cluster's private data structures. The behavior is unchanged; the change only prepares the code for a future abstraction where Cluster may become a virtual base class. There is no security fix here.

This commit is a straightforward memory optimization for Bitcoin Core's internal transaction graph data structure. It adds a new Compact() method that trims excess capacity from vectors after clusters of transactions are modified, split, or merged. There is no security-relevant change here—only a reduction in memory usage.

This commit adds a new public function that estimates how much memory a transaction graph object is using. It is purely an informational/observability feature and does not change how data is processed, stored, or exposed to the network. There is no security issue visible in the change.

This commit adds internal bookkeeping so Bitcoin Core's new transaction-graph code can track how much memory its clusters of related transactions are using. It does not change user-visible behavior, fix a crash, or close a security hole. It is a preparation step for future memory-limit enforcement.

This commit adds a memory-shrinking helper called Compact() to an internal Bitcoin Core data structure (DepGraph) used when ordering groups of transactions. It also adds a way to report how much memory the structure uses, and updates a fuzz test to exercise both. There is no direct security fix here; it is a memory-usage control feature that may help limit resource consumption during fuzzing or normal operation.

This is a memory-optimization cleanup inside Bitcoin Core's transaction graph code. It ensures internal data structures don't contain unused gaps ('holes'), which reduces memory usage. There is no indication this fixes a security vulnerability or enables attacks.

This is a small internal code cleanup in Bitcoin Core's transaction graph module. It moves several self-consistency checks from one internal helper function to another. The checks themselves remain present and unchanged in effect; only their location in the source code differs. There is no user-facing change and no indication of a security fix.

This commit is a routine internal code cleanup in Bitcoin Core's transaction graph module. It removes a redundant 'level' field stored inside each transaction cluster and instead passes the level as a function argument or looks it up when needed. The stated goal is to reduce memory usage. There is no indication this fixes a security bug or changes externally observable behavior.