rust-bitcoin

This commit is a routine code cleanup: it moves a small test-only helper macro from a shared internal utility crate into the one place it is actually used. There is no change to user-facing behavior, no bug fix, and no security relevance.

This commit simply stops publicly re-exporting a secp256k1 type called `Verification` from two Rust Bitcoin key modules. It is a routine API cleanup: the type is still available directly from the underlying secp256k1 library, so no cryptographic capability is removed, only a convenience shortcut. There is no security bug or vulnerability here.

This commit is a routine internal code cleanup in the rust-bitcoin library. It removes a convenience conversion (a 'From' implementation) between two error types and replaces it with an explicit error mapping. The actual behavior of signature parsing does not change; it is purely about how errors are wired through the code. There is no indication this fixes a security bug.

This commit removes an unused error category from a Bitcoin cryptography library. It is a cleanup change because the underlying signature-parsing code can no longer fail in the way that error category described. There is no direct evidence this fixes an active security bug, but it does slightly reduce the library's public error surface, which can help downstream code handle errors more reliably.

This commit is a straightforward internal cleanup in the rust-bitcoin library. It swaps one error type for another when an ECDSA signature fails to decode from DER format. The behavior of signature parsing does not change; only the name and contents of the error value reported to callers are different. There is no indication this fixes a security bug or introduces a vulnerability.

This commit is a routine code cleanup in the rust-bitcoin library. It replaces generic error types from the underlying secp256k1 cryptographic library with more specific, library-defined error types for key parsing and signature verification functions. There is no indication this fixes a security vulnerability; it is an API-quality improvement.

This commit is a routine code-quality refactor. It introduces new, more specific Rust error types for parsing keys and signatures, replacing a generic underlying library error type. There is no change to cryptographic behavior, validation logic, or security boundaries. It only changes what kind of error message callers receive when parsing fails.

This commit removes a convenience conversion that let users turn a borrowed Taproot signature into an owned, serialized byte form. The change is API-cleanup: the old trait made it look like the serialized form was just a view of the original signature, when it actually copies/owns the bytes. There is no direct security bug fixed here, but removing the misleading conversion reduces the chance that future callers misunderstand ownership and accidentally clone or mishandle signature data.

This commit is purely a housekeeping release step. It bumps the version number of the bitcoin-key-expression crate from 0.0.0 to 0.1.0, updates the changelog, and adjusts the main bitcoin package and lock files to match. There are no code changes, bug fixes, or security patches in the diff.

This commit adds standard Rust trait implementations that allow certain Bitcoin signature-hash error types to be created from the Infallible type. Infallible is a type that can never actually exist, so these conversions can never be invoked at runtime. The change is purely an ergonomic improvement for generic programming and has no security relevance.

This commit reduces the visibility of internal fields on three error types in the crypto/sighash module from public to crate-internal. It is a routine API-hardening change to preserve future flexibility before a 1.0 stable release. There is no security vulnerability here.

This commit reorganizes how an optional hex-encoding helper library is enabled in the bitcoin-crypto crate. It makes the hex-conservative dependency optional and gated behind a new 'hex' feature, instead of being included by default. The main bitcoin crate explicitly enables this feature, so end-user behavior is unchanged. This is a build/configuration cleanup, not a fix for an exploitable vulnerability.

This commit is a code-quality maintenance change. It adds pattern-matching destructuring inside Rust error-type 'source' methods that previously just returned 'None'. The goal is to make the compiler warn future maintainers if the shape of an error type changes, so they remember to update the source() implementation. It does not change runtime behavior, fix a bug, or close a security vulnerability.

This commit is a routine release-preparation change. It bumps the version number of the `bitcoin_hashes` crate from 0.21.0 to 1.0.0, updates the changelog, and updates dependency references in lock files and other crates' configuration files. There are no code changes and no security relevance.

This commit is a routine automated code-formatting run by the rustfmt tool. It only changes whitespace, line breaks, and import grouping in six files. No program logic, security checks, or behavior were altered.

This commit adds compiler hints to three small functions in the rust-bitcoin hashes crate, suggesting the compiler should inline them. It does not change behavior, fix a bug, or address any security issue.

This commit is a pure code cleanup: it renames an internal helper macro from `engine_input_impl!` to `impl_engine_input!` and switches its syntax from parentheses to curly braces. No logic, behavior, or security properties of the hashing code change.

This commit adds a standard Rust trait implementation that lets two error types be automatically converted from the 'Infallible' type (a type that can never actually exist). It is a routine ergonomic improvement and does not fix any security bug or change runtime behavior.

This commit only changes the wording of code comments (documentation) from singular verbs like 'Finalize' to plural verbs like 'Finalizes' to match the project's style convention. No actual program code was modified, so it cannot affect security or behavior.

This commit adds two small Rust trait implementations that allow certain error types to be automatically converted from the 'Infallible' type. 'Infallible' is a type that can never actually exist, so these conversions are purely for making the error types easier to use in generic code. There is no security issue here.

This commit refactors how Bitcoin BIP-32 derivation paths are represented in the rust-bitcoin library. It splits the old single DerivationPath type into two: DerivationPath (relative paths like 0'/1) and AbsoluteDerivationPath (master-prefixed paths like m/0'/1). The goal is to make wallet code more explicit about whether it is deriving from the master key or from an intermediate key. The change is a type-system/API hardening, not a fix for a known exploitable bug. It may prevent future misuse where a relative path is accidentally treated as absolute or vice versa, but the commit itself does not describe any active vulnerability.

This is a routine code cleanup that renames the type `DerivationPath` to `RelativeDerivationPath` throughout the project. The change is purely a refactor: it does not alter how the code behaves, what it computes, or how it handles data. The commit message explicitly says the rename is intended to force other developers to update their code so the maintainers can identify places that may later need a new `AbsoluteDerivationPath` type. There is no security fix or vulnerability here.

This commit is a simple rename of a method from 'extend' to 'join' in a Rust Bitcoin library. It does not change what the code does, only its name. There is no security issue here.

This is a small internal code cleanup in a Bitcoin library. It splits one function into two so the inner logic doesn't have to be repeated, but the public behavior is unchanged. There is no security issue visible in the change.

This is a minor code cleanup for an error type in the BIP-32 (Bitcoin key derivation) module. It adds a standard 'Copy' trait, a conversion from Rust's 'Infallible' type, an explicit 'no underlying cause' implementation, and slightly clarifies an error message. There is no security fix or behavior change.