Bitcoin Core

This commit is a small internal refactor of how Bitcoin Core builds Partially Signed Bitcoin Transactions (PSBTs). It makes each PSBT input and output remember its corresponding transaction details (previous transaction ID, output index, sequence number, amount, and script) directly, instead of only storing them inside the global unsigned transaction. The change prepares the code for a future PSBT version (PSBTv2) where these fields are stored separately. There is no obvious security bug in the diff itself, but it touches serialization and RPC code paths that handle user-provided transaction data.

This commit is a small internal refactor in Bitcoin Core's Partially Signed Bitcoin Transaction (PSBT) handling. It makes each PSBT input and output aware of which PSBT version it belongs to, currently hard-coded to version 0. The change does not fix a known bug or vulnerability by itself; it appears to lay groundwork for future PSBT version support. There is no evidence in the commit or supplied references that this is a security patch.

This commit is a simple code cleanup: it changes three C++ data structures (PSBTInput, PSBTOutput, and PartiallySignedTransaction) from 'struct' to 'class' and adds 'public:' labels so their members remain publicly accessible. It also updates forward declarations in other header files to match. This has no functional or security effect on the Bitcoin Core software.

This commit is a code cleanup in Bitcoin Core's Partially Signed Bitcoin Transaction (PSBT) handling. It changes internal code to read input and output details from the PSBT data structures themselves rather than from the global unsigned transaction. The stated goal is to prepare for a future PSBT version (PSBTv2) where the global unsigned transaction may not exist. There is no direct security fix here, but any inconsistency between the PSBT fields and the global transaction could, in principle, lead to wrong analysis or signing behavior. The patch appears to keep behavior equivalent by using the same data through a different path.

This commit refactors how inputs and outputs are added to Partially Signed Bitcoin Transactions (PSBTs). Previously, callers had to pass both a raw transaction input/output and a PSBT-specific input/output, which could become inconsistent. Now the functions accept only the PSBT-specific object and derive the raw transaction data from it. For PSBT version 2, the code currently just returns false and does not actually add anything, which appears to be intentional but incomplete support. The change reduces the risk of mismatched data and duplicate inputs, but it is primarily a code-quality and API-safety improvement rather than a fix for an active exploit.

This commit is a code-quality refactor for Bitcoin Core's Partially Signed Bitcoin Transaction (PSBT) handling. It removes the ability to create an empty/default PSBT object and changes helper functions so they return a valid PSBT or an explicit failure instead of filling in an empty object. This makes accidental use of an uninitialized PSBT impossible, but it does not fix a known active bug or vulnerability by itself.

This is a small code-quality change in Bitcoin Core's graphical wallet interface. It switches the internal storage of a partially-signed Bitcoin transaction (PSBT) from a plain object to an optional wrapper, so the code no longer keeps a default/empty PSBT sitting around before one is actually loaded. The change itself does not fix a known crash or vulnerability, but it removes a class of potential bugs where an uninitialized PSBT could accidentally be used.

This commit only changes test code for Bitcoin Core's Partially Signed Bitcoin Transaction (PSBT) handling. It removes one hard-coded test vector from a JSON file and adds a helper function so tests can build PSBTs with made-up unknown fields on the fly. There is no change to production wallet or node code, so it cannot directly affect live funds, network behavior, or introduce a runtime vulnerability.

This commit is a code cleanup in Bitcoin Core's Partially Signed Bitcoin Transaction (PSBT) handling. It moves duplicate-key detection and fixed-size checks into shared helpers so the same logic is not repeated dozens of times. The behavior is intended to stay the same; only error messages change in a few test cases. There is no indication this fixes a security bug.

This commit only adds a new automated test to Bitcoin Core. It checks that certain PSBT (Partially Signed Bitcoin Transaction) RPC commands, when called in a way that should make no meaningful change, return the exact same PSBT they were given. There is no change to production code, no bug fix, and no security patch.

This commit fixes a gap in Bitcoin Core's Partially Signed Bitcoin Transaction (PSBT) handling. When converting signature data into a PSBT input or output, several pieces of information—hash preimages for certain script operations and the taproot script tree builder—were not being copied over. Missing preimages could prevent a PSBT from being finalized correctly, and missing the taproot builder could prevent proper analysis or signing of taproot outputs. It is a correctness fix in wallet/transaction code rather than a remote-exploitable vulnerability.

This change only modifies a benchmark test file. It swaps a fake/mock database for a real SQLite database when measuring how fast wallet loading runs, and moves wallet setup work outside the timed portion so the benchmark is more accurate. There is no change to production wallet code, network behavior, or user-facing functionality, and no security issue is evident.

This is a small internal cleanup of a Bitcoin Core benchmark test. It moves the creation of a fake legacy wallet from the main benchmark body into a setup() routine so the benchmark can be repeated cleanly. It does not change any production wallet code, network rules, or user-facing behavior, and it introduces no security issue.

This is a benchmark-only code cleanup. It changes how a performance test creates a fresh wallet before each encryption run, replacing a database-copy approach with a setup() function that creates a new wallet each time. There is no change to production wallet encryption behavior and no security issue.

This is a benchmark-only change. It moves a 'mark cache dirty' step out of the timed portion of a wallet balance performance test so the benchmark measures only the balance calculation itself. There is no change to production wallet code, consensus logic, networking, or any user-facing behavior.

This is a small code-quality change to a benchmark test that measures how long it takes to create a Bitcoin wallet. It moves wallet cleanup from inside the timed loop to a setup/teardown phase so the benchmark only measures wallet creation. There is no user-facing behavior change and no security relevance.

This Bitcoin Core commit refactors how descriptor wallets are loaded from disk. Instead of creating an empty wallet key manager and then gradually adding keys and cache data to it, the code now gathers all the data first and creates the key manager in one go. The change also adds a safety check that rejects wallets containing both unencrypted and encrypted keys, which previously could have coexisted during incremental loading. There is no direct evidence in the commit that this fixes an active exploit, but the stricter loading model removes a class of potential consistency bugs.

This is a small internal code cleanup in Bitcoin Core's wallet. It moves the setup of newly generated single-signature descriptors into a dedicated factory-style constructor and tightens some safety checks. There is no obvious user-facing bug or direct exploit here, but the change removes a redundant encryption step and changes when a 'decryption checked' flag is set, which could have subtle wallet-initialization implications.

This commit adds a new automated test to Bitcoin Core. The test checks that the software correctly refuses to open a wallet that has been corrupted so that it contains both encrypted and unencrypted copies of the same key. It does not change any production wallet code; it only adds a regression test for an already-existing safety check.

This is a routine internal code cleanup in Bitcoin Core's wallet module. It merges several places that set up a wallet's address-generation seed/descriptors into a single helper function called SetupWalletGeneration(). There is no indication this fixes a security bug; it appears intended to make the code easier to maintain and to avoid duplicating logic when creating or encrypting wallets.

This is a small internal code cleanup in Bitcoin Core's wallet module. It changes how an external-signer wallet manager object is created so that its descriptor is passed directly through the constructor rather than being set afterward via a separate SetupDescriptor method. There is no user-facing behavior change and no security fix.

This commit fixes a bug in Bitcoin Core's wallet migration logic where the same HD (hierarchical deterministic) wallet seed could be processed more than once if it appeared in both the active and inactive HD chain lists. The duplicate processing could cause a crash during migration, which was discovered through automated fuzz testing. The fix uses a set data structure to ensure each unique seed is only migrated once. There is no direct evidence in the commit that this is exploitable by an attacker to steal funds or compromise the network; it appears to be a reliability/correctness fix for a fuzz-discovered crash.

This Bitcoin Core wallet patch changes how private keys are added when a user imports or migrates to a descriptor-based wallet. Previously, keys were added to the descriptor manager in a separate step after creation. The patch bundles the keys into the manager's constructor or update call so all descriptor data is provided at once. The commit message frames this as a code-quality fix, not a security fix. There is no direct evidence in the diff or commit message that this closes an exploitable vulnerability, but it does reduce a window where the wallet state could be inconsistent.

This is a small hardening change to a fuzz test (automated randomized testing) for Bitcoin Core's wallet descriptor handling. It adds a check that a parsed wallet descriptor can be 'expanded' (converted into actual output scripts) before the test proceeds to add it to a wallet. This prevents the fuzzer from creating wallet state with descriptors that parse but cannot actually be used, which could cause later test steps to hit unexpected failures or assertions. It is a test-only fix and does not change production wallet behavior.

This is a code cleanup (refactor) in Bitcoin Core's wallet creation logic. Previously, the software temporarily marked encrypted wallets as 'blank' to prevent keys from being generated before encryption, then removed that flag afterward. The change makes the code more explicit by passing a separate 'born_encrypted' parameter instead of reusing the blank-wallet flag. There is no security vulnerability visible in the diff.