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 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 adds two missing data fields to Bitcoin's PSBTv2 format support: the transaction version and the locktime. These values are now stored in the correct global fields when a transaction is converted into a PSBTv2. It appears to be a correctness/completeness fix for the newer PSBT standard rather than a fix for an active security vulnerability.

This commit is a small code cleanup: it adds a helper function called GetOutPoint to PSBTInput and replaces several direct accesses to transaction input data with calls to that helper. There is no change in behavior or security fix visible in the diff. It appears to be a refactoring to make the code easier to maintain.

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 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 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 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 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 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 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 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 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 commit changes a single configuration file used by developers so it only specifies the broad Python version (3.10) instead of an exact patch release (3.10.14). The stated goal is to avoid forcing developers to keep an old, potentially insecure Python patch release installed. It is a tooling/development hygiene change, not a fix for an exploitable vulnerability in Bitcoin Core itself.

This commit fixes a build failure that occurs when compiling Bitcoin Core with Boost version 1.91 or newer. It changes how certain in-memory data structures (used for tracking orphan transactions, mempool entries, and transaction requests) are declared so they compile with both old and new Boost versions. There is no runtime behavior change, no vulnerability fix, and no security impact.

This is a straightforward code cleanup (refactor) that bundles several PSBT signing options into a single structure. It does not change what the software does; it only changes how the options are passed around internally. There is no security vulnerability here.

This commit is a straightforward code cleanup: it replaces a raw integer parameter representing the signature hash type with a small structured options object called SignOptions. All call sites are updated to pass the same value inside the new structure. There is no change to what the program actually does, no bug fix, and no security-relevant behavior change.

This commit only changes Bitcoin Core's internal fuzz testing code. It expands a fuzz harness so that the test can mine fake blocks and send headers for them, improving test coverage for compact block processing. There is no change to production network code, wallets, consensus rules, or RPC interfaces, so it does not introduce a security vulnerability in the software users run.

This commit only changes a fuzz test file (src/test/fuzz/cmpctblock.cpp). It makes the compact-block fuzzing harness create and send fake transactions during testing, and resets internal test state if the mempool changes. There is no change to production Bitcoin Core code, network rules, or wallet behavior. It does not fix or introduce a real security vulnerability.

This commit fixes a bug where Bitcoin Core would refuse to start if the user's system was configured to allow an unlimited number of open files ('ulimit -n unlimited'). The program incorrectly treated 'unlimited' as -1 available file descriptors, then reported 'Not enough file descriptors available' and exited. The fix makes the program recognize 'unlimited' as the maximum integer value instead, so startup succeeds. This is a reliability/availability fix, not a security vulnerability that an attacker can exploit.

This is a code cleanup change that replaces scattered hard-coded byte counts like 1024*1024 with a single named helper, _MiB, and adds unit tests for it. It does not change any user-visible behavior or fix a known security bug. The main safety benefit is making future accidental mistakes (for example, writing the wrong number of zeros) less likely and turning some oversized-value mistakes into compile-time errors.

This commit adds a new code helper for writing byte sizes in gigabytes (GiB) and replaces a few existing hard-coded numbers with the new helper. It is a code cleanup and readability change with no security-relevant behavior change.

This commit removes a debug log line that printed SOCKS5 proxy usernames and passwords in plain text. The change prevents sensitive credentials from being written to log files, which could otherwise expose them to anyone with access to those logs. It is a straightforward cleanup with clear security benefit, though it only affects debug-level logging.

This change fixes a memory safety issue in Bitcoin Core's connection to the Tor control port. A malicious or misbehaving Tor control server could send an endless stream of reply lines, causing Bitcoin Core to keep allocating memory until the system ran out. The patch caps the number of lines accepted in a single reply at 1,000, after which the connection is closed. The commit message explicitly says this is to avoid out-of-memory (OOM) exhaustion.