Bitcoin Core

This commit refactors how Bitcoin Core's block builder (the miner) handles the maximum block weight setting. It replaces an older signed-size field with a new optional unsigned field and fixes a parsing quirk: a negative command-line value for -blockmaxweight is now treated as 0 before validation rejects it, instead of silently wrapping around to a huge positive number. The change is mostly a cleanup, but it removes a small overflow/underflow footgun in argument parsing.

This commit only adds new regression tests for Bitcoin Core's PSBT (Partially Signed Bitcoin Transaction) combine/merge logic. It checks that custom 'proprietary' data fields are preserved when two PSBTs are merged at global, input, and output levels. There is no production code change, no bug fix, and no security patch in the diff itself.

This commit fixes a bug in Bitcoin Core's handling of PSBTs (Partially Signed Bitcoin Transactions). When two PSBTs were combined, the software correctly kept 'unknown' extra data but accidentally discarded 'proprietary' custom data fields added by wallets or tools. The patch makes sure proprietary fields are preserved during merging, preventing potential loss of transaction metadata that some wallets rely on.

This commit is a simple internal cleanup: it swaps the full logging header file for a smaller, more focused one in many source files. There is no change to program behavior, no bug fix, and no security relevance.

This commit tightens up error messages in Bitcoin Core's I2P (anonymous networking) code. Previously, error messages could accidentally include the full text of a SAM request that may carry the user's I2P private key, or the full raw reply from an I2P router. The patch keeps the error useful by still referencing the redacted request, but stops echoing the sensitive request body and unescaped router replies into logs. It is a defensive information-disclosure fix, not a change to network behavior.

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 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 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 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 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 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.

This commit fixes a memory safety bug in Bitcoin Core's block validation. When checking a new block, the program creates a queue of script checks that may run on multiple threads in the background. It also precomputes some transaction data used by those checks. Previously, the precomputed data was destroyed before the background check queue finished, so the workers could read memory that had already been freed. An attacker could craft a malicious block to trigger this, potentially causing crashes, memory corruption, or worse. The fix simply moves the precomputed data variable so it is created before the queue and destroyed after it, guaranteeing the data stays alive as long as the checks need it.

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 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.