rust-bitcoin

This commit simply renames a function from XOnlyPublicKey::new to XOnlyPublicKey::from_secp because the old name was misleading. The underlying behavior is unchanged. There is no security vulnerability or fix here.

This commit adds a small performance helper method called as_inner() to the XOnlyPublicKey type and switches existing internal code to use it instead of a method that copies the key. There is no security issue here; it is a routine optimization to avoid unnecessary copying.

This commit is a routine automated code-formatting run using the nightly version of rustfmt. It only changes whitespace, line breaks, import ordering, and other stylistic details across 24 files. No program logic, security behavior, or public API was changed.

This commit is a routine housekeeping change that moves lint (code style warning) settings from individual crates to a shared workspace configuration. It does not change any program logic, fix bugs, or alter security behavior.

This commit is a routine internal dependency cleanup. The project had been re-exporting an unstable version of a hex-encoding helper crate, but its policy says the main crate must only re-export stable versions. The change swaps the public re-export to the stable version while keeping the unstable version as a private internal dependency for code that still needs it. There is no security bug being fixed here.

This change lets users of the library who don't use the standard Rust library ('no_std' environments, common in embedded or blockchain hardware) benefit from faster SHA-256 hashing via CPU-specific instructions. It adds an optional helper crate that detects CPU features in 'no_std' mode, similar to how the standard library already does it. There is no direct evidence in the commit that this fixes a security vulnerability; it is a performance and portability improvement.

This commit only adds a new performance benchmark for the SHA256d hashing function. It does not change any production code, cryptographic logic, or user-facing behavior. There is no security issue.

This change only fixes how hash performance is measured in benchmark tests. It does not change any real hashing code that users or applications rely on, so it has no security impact on the library itself.

This commit fixes a bug in how Partially Signed Bitcoin Transactions (PSBTs) read and write their internal 'key' fields. The old code assumed the key's type number always fits in one byte when encoded as a compact size. That assumption is wrong for large type numbers, so the code could misread the key's length and either reject valid PSBTs or, in the worst case, allocate too much memory. The fix makes the encoder and decoder correctly account for the actual number of bytes the type number occupies.

This commit only adds a new test to verify that HMAC hashing still produces the correct result when data is fed in one byte at a time. It does not change any production code, fix a bug, or alter behavior. The existing code already handled incremental input correctly; the change simply adds missing test coverage.

This commit fixes a validation gap in how the library handles Partially Signed Bitcoin Transactions (PSBTs). A PSBT can include a reference to a previous transaction output (the 'non-witness UTXO') that doesn't actually exist. Before this fix, the library would not reject this, which could allow malformed or malicious PSBTs to be processed. The fix adds a bounds check so that if a PSBT input claims an output index that is too high, deserialization returns a clear error instead of silently continuing. The issue was found by differential fuzzing against Bitcoin Core.

This commit is a routine internal code reorganization in the rust-bitcoin library. It moves several key-related wrapper types into a single private 'encapsulate' module and re-exports them, without changing their public behavior or adding any security fixes. There is no indication of a vulnerability being patched.

This commit is a routine code cleanup. It adds a new public constructor method called from_secp for the Keypair type and makes the existing From conversion use that constructor. It also moves an existing inner accessor method to a different spot in the file. There is no security fix or behavior change.

This commit is a code cleanup in the rust-bitcoin library. It replaces direct internal access to cryptographic key data (like reading the hidden `.0` field) with official getter methods and constructors. There is no direct evidence this fixes an active security bug, but it strengthens encapsulation so future mistakes are less likely.

This commit is a routine API cleanup: it renames a method from `into_inner()` to `to_inner()` on a public-key wrapper type and keeps the old name as a deprecated alias. There is no security bug, no behavior change, and no vulnerability introduced or fixed.

This commit is a routine API cleanup, not a security fix. It hides the internal secp256k1 public key inside the CompressedPublicKey type and replaces direct field access with a constructor (from_secp) and a getter (to_inner). That improves encapsulation but does not change how keys are validated or used. There is no evidence this fixes a vulnerability.

This commit is an automated code-formatting run by rustfmt. It only changes whitespace, line breaks, import order, and other stylistic details across 18 files. No program logic, security behavior, or functionality was altered.

This commit fixes a panic (sudden crash) in a Bitcoin transaction-signing helper. The function `spend_utxo` previously assumed that a referenced transaction output always existed, and used unchecked array indexing. If the output was missing, the program would crash instead of returning a proper error. The fix replaces the unchecked lookup with a bounds-checked one that returns a clean error.

This commit fixes a potential integer overflow when calculating how much memory to reserve while decoding Bitcoin transaction witness data. The overflow could only happen on 16-bit machines, which are extremely uncommon today. The fix replaces regular addition with saturating addition, so the value stops growing at the maximum instead of wrapping around. This is a defensive hardening change rather than a confirmed exploitable vulnerability on typical hardware.

This commit only adds a new unit test. It checks that when a SHA-256 hashing engine is paused mid-way through data (at a non-block-aligned point), the error object contains enough information to build a second engine that finishes hashing and produces the same final result. There is no code fix, behavior change, or security patch here.

This change enriches an error type in the SHA-256 hashing code. When a caller asks for the internal 'midstate' snapshot at a non-aligned point, the error now also returns the nearest aligned snapshot and any leftover bytes, so the caller can resume hashing later. It is a feature/API improvement, not a fix for an active security flaw.

This commit is a routine update to the project's automated testing setup. It replaces a set of shell scripts with a new Rust tool called `cargo rbmt` for running tests and lints in CI. There are no changes to the actual Bitcoin library code that users interact with, and no security issue is evident.

This commit only adds Clippy lint-suppression attributes (`#[allow(clippy::too_many_arguments)]`) to three internal cryptographic helper functions in the `rust-bitcoin` hashes crate. It does not change any executable code, logic, or public API. There is no security relevance: it simply tells the Rust linter to stop warning that these functions have many parameters.

This commit only adds new unit tests for an existing Rust type called NumOpResult. It does not change any production code, fix bugs, or alter behavior. There is no security issue here.

This commit is a routine code-quality refactor in the rust-bitcoin library. It wraps the underlying secp256k1 keypair type in a library-specific type so that parsing errors can be more precise and the public API is cleaner. There is no direct security vulnerability being fixed here; it is an interface improvement that may indirectly reduce misuse.