rust-bitcoin

This commit is a routine code reorganization: it moves the BIP-32 (hierarchical deterministic wallet key) module from the main `bitcoin` crate into a new lower-level `key-expression` crate, then re-exports it so existing users of `bitcoin::bip32` see no change. There is no evidence in the commit of any security bug, vulnerability fix, or behavior change.

This is a trivial code cleanup: a developer replaced a wildcard import (`use super::*`) with a single explicit import (`use super::SerializedSignature`) in a small internal module. It has no security relevance; it only makes the code clearer and silences a Clippy lint.

This is a one-word documentation comment fix. It changes an incorrect reference to 'ARM SHA2 intrinsics' to the correct 'x86 SHA-NI intrinsics' in a code comment. No executable code was changed, and there is no security impact.

This commit is a routine performance optimization for SHA-256 hashing on modern CPUs. It rewrites the inner loop so that multiple 64-byte blocks are processed in one go, keeping the calculation state in CPU registers rather than reloading it each time. The change is purely about speed and does not fix or introduce any security-relevant behavior.

This commit is an automated code-formatting run by the rustfmt tool. It only adjusts whitespace and line breaks in four source files, making no changes to program logic, algorithms, or data handling. There is no security relevance.

This is a small code cleanup in how Taproot signatures are printed or formatted as text/hex. It removes a tiny bit of duplicated logic by reusing an existing serialization helper and adds two new formatting traits (LowerHex and UpperHex). There is no security issue visible in the change.

This commit only adds a new unit test for a bug fix that was already applied in the previous commit. It does not change any production code itself. The test verifies that a Taproot signature can be serialized back to the same hex string it was parsed from. Because the actual fix happened earlier, this commit alone does not introduce, fix, or worsen any security issue.

This commit fixes a crash when printing or formatting a Taproot serialized signature. The old code assumed every signature was the maximum possible length, but real signatures can be shorter. When a shorter signature was formatted, the code could panic or crash. The fix checks the actual length and formats with the correct size.

This commit is a routine code cleanup. It removes unnecessary '?' operators in functions that already return a Result. The behavior of the code is unchanged; it just makes the code slightly cleaner and avoids a clippy lint warning.

This commit is a simple code cleanup with no security relevance. It replaces long-form calls like `fmt::Display::fmt(value, formatter)` with shorter `value.fmt(formatter)` calls inside formatting trait implementations. The behavior is identical; only the syntax is shorter.

This commit only adds the #[inline] compiler hint to many small functions in the cryptographic key module. It does not change what any function does, what data it accepts, or how secrets are handled. There is no security bug being fixed or introduced here; it is a routine performance optimization.

This commit removes a convenience conversion that let users turn a Bitcoin-style key pair directly into a lower-level secp256k1 public key. The change is defensive: it makes it slightly harder to accidentally mix the library's own key types with raw secp256k1 types, which can help prevent API misuse. There is no direct bug or exploit being fixed.

This commit is a pure code cleanup: it reorders where certain trait implementations (like FromStr, From, Display, Debug) appear in the source file so all types follow the same consistent pattern. No code behavior is changed, no security bug is fixed, and no vulnerability is introduced.

This commit adds standard Rust helper code that lets several error types be automatically converted from Rust's Infallible type. Infallible is a type that can never actually exist, so these conversions are safe, cannot be triggered by user input, and have no security impact. It is a routine API ergonomics improvement.

This commit simply moves the code that handles serializing and deserializing XOnlyPublicKey values (when the optional serde feature is enabled) from one location in the file to another location alongside similar implementations. The actual behavior of the code is unchanged; it is a pure code organization or cleanup change with no security relevance.

This is a small internal code cleanup in the rust-bitcoin library. It replaces a slightly longer implementation of converting one public key type to another with a shorter one that calls an existing conversion. There is no change in behavior and no security issue.

This commit only changes placeholder version strings ('TBD') in deprecation notices to a concrete version number ('0.1.0'). It does not alter any program logic, cryptographic operations, or security behavior. There is no security impact.

This commit simply moves an existing implementation of the Drop trait for the Keypair type to a different location in the same source file. It does not change what the code does, only where it appears in the file. There is no security impact.

This commit is a pure code reorganization: it moves existing Rust 'From' conversion implementations so they sit directly underneath the type they produce, rather than being scattered near the source type. No logic, behavior, or public API changes are visible in the diff.

This is a one-line fix to a code example so it uses a configurable network parameter instead of always using the regtest network. It is not a security fix and does not change any library behavior.

This commit adds a single formatting directive (`#[rustfmt::skip]`) to tell Rust's automatic code formatter not to reformat a specific SHA-256 hashing function. It does not change any executable code, logic, or behavior. There is no security impact.

This is a small performance improvement in the rust-bitcoin library's SHA256 double-hash code. It replaces a slower fallback code path with a faster, already-existing internal implementation when advanced CPU features are not available. There is no indication of a security bug or vulnerability.

This commit adds a new, highly optimized software-only implementation for computing a double SHA-256 hash on exactly 64 bytes of data. It is intended as a fallback for older CPUs that lack hardware-accelerated hashing instructions. There is no indication in the commit that this fixes a security bug; it appears to be a performance or portability improvement.

This commit is purely a code-formatting cleanup. It runs rustfmt across several files, which only changes whitespace, line breaks, and the order of import statements. No program logic, security checks, or behavior were changed.

This commit fixes a timing attack weakness in the ChaCha20-Poly1305 decryption code. Previously, the code compared the authentication tag using Rust's normal `==` operator, which can stop early when it finds a mismatch. That early-stop behavior can leak information about how much of the tag is correct if an attacker can measure tiny timing differences. The patch replaces it with a constant-time comparison that always scans all 16 bytes, so no timing information about the tag's contents is revealed.