Bitcoin Core

This commit only changes a code comment explaining why the blockfilterindex gets 5% of the total cache budget. It adds a note that a typical two-week offline gap produces a working set of about 200 kB, which fits comfortably within that 5% allocation. No code behavior, cache sizes, or logic are modified.

This change loosens a security sandbox only for one 32-bit Linux continuous-integration test job. Docker's newer default profile was blocking an old 32-bit system call used for sockets, causing the CI job to fail. The patch tells Docker not to apply its default seccomp filter to that container so the tests can run. It does not change Bitcoin Core code that end users run, and it does not appear to be a fix for a vulnerability in Bitcoin itself.

This is a pure variable-name cleanup in Bitcoin Core's ARM SHA-256 code. The old names (ABEF_SAVE/CDGH_SAVE) were misleading labels; the new names (ABCD_SAVE/EFGH_SAVE) match how ARM's SHA-256 instructions actually order the hash state. No instructions, values, or behavior change.

This commit adds a new public function to Bitcoin Core's libbitcoinkernel library that lets outside programs ask the kernel to perform basic, context-free checks on a transaction (for example, whether it has valid outputs and no duplicate inputs). It is purely an API addition: it exposes an existing internal validation routine through a C interface and adds tests. There is no bug fix, no change to consensus rules, and no indication of a security vulnerability.

This is a minor code hygiene change that adds a missing C++ standard library header (<concepts>) to a utility header file. It does not change program behavior, fix a vulnerability, or introduce any security-relevant functionality. It is an 'include what you use' (IWYU) cleanup.

This commit changes a single internal lock in Bitcoin Core's networking code from a recursive mutex (one that lets the same thread lock it multiple times safely) to a plain non-recursive mutex. It also adds many compile-time and runtime checks to make sure no code path tries to lock it twice. The change is defensive hardening: it makes the locking rules stricter so that accidental deadlocks or re-entrancy bugs are caught earlier, but it does not by itself fix a known, exploitable vulnerability.

This is a small internal cleanup in Bitcoin Core's network code. It removes the only case where a particular network lock (m_nodes_mutex) was acquired twice in a nested/recursive way. The change reorders the logic so the list of high-bandwidth compact-block peers is updated without nested lock calls. There is no direct security vulnerability being fixed; it is a code-quality and future-proofing change that makes the locking simpler and easier to reason about.

This is a one-line build-system change for Bitcoin Core. Previously, when developers built the fuzzing test suite, the code automatically disabled a feature called IPC (inter-process communication). This change removes that automatic disable so the IPC fuzz target gets compiled along with the rest of the fuzzing surface. It is a build/test-coverage fix, not a fix for a runtime vulnerability in the Bitcoin node software itself.

This commit only adds a release note document. It describes a previously made change that blocks certain unusual wallet names (like paths containing '..' or '.', or just '/'). There is no code change here, and the note itself is informational documentation.

This change refactors how the standalone bitcoin-wallet tool figures out where a wallet file lives. Previously it computed the path itself; now it calls the same internal helper (GetWalletPath) that the main wallet code uses, which includes checks for invalid wallet names. The likely effect is to prevent mistakes or misuse involving odd wallet names/paths, rather than to fix an active remote-exploitable bug.

This Bitcoin Core change prevents users from importing a special 'unused()' wallet descriptor if the private key it refers to is already present in the wallet. The patch adds a check during descriptor import and a test to confirm the new behavior. The commit message does not describe this as a security fix, and no external security references are provided, so its security relevance is uncertain. It appears to be a defensive correctness fix that could prevent confusion or wallet-state inconsistencies rather than a fix for an active exploit.

This commit only adds a release note describing a new wallet RPC called addhdkey. It contains no code changes and no security-related content.

This change blocks users from importing a special type of Bitcoin wallet descriptor called unused() into wallets that have private keys disabled. Such wallets are watch-only: they can see transactions but cannot spend. The unused() descriptor is meant to reserve a key for future use. Allowing it in a no-private-key wallet could have led to confusion or situations where the wallet believes it controls funds it cannot actually spend, but the patch is a simple guard with no demonstrated exploit.

This commit adds a new wallet RPC command called addhdkey that lets users import a BIP32 extended private key (xprv) into a Bitcoin Core wallet, or generate a fresh random one. It is a feature addition, not a bug fix. The code checks that the wallet stores private keys, requires the wallet to be unlocked, rejects plain xpubs, and refuses duplicate keys. There is no indication in the commit that this fixes a security vulnerability.

This commit changes a Bitcoin Core internal helper function so that it can now report failure when a PSBT (Partially Signed Bitcoin Transaction) is internally inconsistent. Previously, the helper would build transaction precomputation data without checking whether the underlying unsigned transaction could actually be constructed. Now it returns an optional value that callers must check, and they reject or abort the operation if the transaction cannot be valid. This is a defensive hardening change that prevents the code from continuing with malformed PSBTs.

This commit is a straightforward internal code cleanup in Bitcoin Core. It moves a helper function that looks up the previous transaction output (UTXO) for a PSBT input from the whole-transaction object (PartiallySignedTransaction) into the input object itself (PSBTInput). The behavior is unchanged; only the code organization is simplified.

This commit updates the Bitcoin Core 'decodepsbt' RPC command so it can display the newer PSBT version 2 format. It only changes what information is shown to the user; it does not change how transactions are validated, signed, or broadcast. There is no indication this is a security fix.

This commit finishes implementing the 'AddInput' and 'AddOutput' methods for PSBT version 2 in Bitcoin Core. PSBTs are files used to collaboratively build or sign Bitcoin transactions offline. Previously, adding inputs/outputs to a PSBTv2 would silently fail (return false). The change now properly checks version compatibility, respects the 'modifiable' flags that say whether inputs/outputs may be added, and handles time-lock consistency when new inputs are appended. It is a feature-completion patch with defensive checks, not a fix for an active vulnerability.

This commit adds support for a new version of Partially Signed Bitcoin Transactions (PSBTv2) in Bitcoin Core. It introduces serialization and deserialization code for new PSBTv2 fields, including transaction version, input/output counts, modifiable flags, per-input previous outpoints and locktimes, and per-output amounts and scripts. The commit also adds validation rules to reject malformed or version-inconsistent PSBT data. There is no indication in the commit message or diff that this is a security fix; it appears to be a feature implementation.

This commit updates how Bitcoin Core combines two Partially Signed Bitcoin Transactions (PSBTs). It adds checks to prevent merging PSBTs of different versions, propagates failure if any input or output cannot be merged, and copies new PSBTv2-only fields such as sequence numbers, locktimes, and modifiable flags. The change is a correctness and robustness improvement rather than a clear security fix.

This commit updates Bitcoin Core's Partially Signed Bitcoin Transaction (PSBT) RPC commands so they can produce the newer PSBT version 2 format, and makes version 2 the default. It is a feature and compatibility change, not a fix for an active security vulnerability. The code validates that only versions 0 or 2 can be requested, and updates tests to match the new output structure. There is no indication in the commit that this resolves a disclosed security issue.

This commit only adds release notes documentation. It describes a planned change where several Bitcoin RPC commands will default to creating a newer PSBT format (version 2) and gain an optional version argument. There is no code change, no bug fix, and no security issue in this commit itself.

This commit only adds new automated tests for existing PSBT (Partially Signed Bitcoin Transaction) helper functions called AddInput and AddOutput. It does not change any production wallet, consensus, or networking code. The tests verify that the functions correctly reject mismatched PSBT versions, duplicate inputs, inputs that violate timelock rules, and additions when the transaction is marked as non-modifiable. There is no indication this commit fixes a security bug or introduces a vulnerability.

This commit only adds new test data (sample PSBT strings) to a JSON file used by Bitcoin Core's automated tests. It does not change any production code, wallet logic, or network behavior. There is no security issue here.

This commit only changes test/fuzzing code and adds equality operators to internal data structures so the fuzzer can check round-trip behavior of PSBT (Partially Signed Bitcoin Transaction) data. It does not change production transaction handling, consensus rules, or network code. There is no indication it fixes an exploitable vulnerability.