rust-bitcoin

This commit is a purely cosmetic code cleanup. It replaces the longer way of writing Rust's formatting error return type, `Result<(), fmt::Error>`, with the standard shorter alias, `fmt::Result`. The actual behavior of the code does not change at all.

This commit only updates generated API snapshot text files to remove duplicate lines showing an older, more verbose return type for formatting functions. It is a documentation/test-artifact cleanup with no code changes and no security relevance.

This commit only updates automatically-generated API listing files (text snapshots of public functions). It does not change any actual Rust source code, behavior, or fix any bug. There is no security relevance.

This is a small maintenance patch that changes how hex decoding errors are reported during serialization/deserialization. It removes usage of a now-inaccessible error-detail API from the `hex` crate and instead reports the error's display message. There is no indication this fixes an exploitable vulnerability; it is a compatibility and cleanup change.

This commit adds the ability to parse CompactTarget and BlockTime values from strings in the rust-bitcoin library. It is a routine consistency improvement that makes two numeric wrapper types behave like all other similar types in the library. There is no security relevance in the change itself.

This commit removes an unnecessary feature gate so that parsing a Sequence value from a string works in more build configurations. It is a code-cleanup/feature-availability change, not a security fix.

This commit only lowers the minimum required version of a small helper crate called `cpufeatures` in a lockfile used for testing the oldest supported dependency versions. It is a routine housekeeping change with no security relevance.

This commit only updates generated API text files that list what functions and types are publicly visible in the library. It removes entries for some encoder constructors and adds a couple of auto-trait implementations. There is no actual source code change, so it cannot introduce a security vulnerability by itself.

This commit narrows the visibility of a Rust macro-generated constructor from public to internal-only (pub(crate)). It is described by the author as an API-hardening change to avoid exposing a constructor that would effectively let callers bypass the 'newtype' wrapper pattern. There is no direct evidence in the commit of an exploitable security vulnerability; it is a defensive design improvement.

This commit only updates a generated API text file to reflect two newly added auto-derived marker trait implementations (UnsafeUnpin) for internal decoder types. There is no code change, no behavior change, and no security relevance.

This commit only updates a generated API text file to reflect two newly added auto-derived marker trait implementations (UnsafeUnpin) for internal decoder types. There is no code change, no functional change, and no security relevance.

This commit simply updates the Rust nightly compiler version used by the project from one recent date to another (2026-02-21 to 2026-02-27). It is a routine maintenance change with no security relevance visible in the diff or commit message.

This is a minor code cleanup commit. It removes unnecessary `.into_iter()` calls in three places where Rust will automatically handle iteration. The behavior of the code is unchanged, and there is no security issue.

This is a trivial code cleanup: a test was iterating over key-value pairs of a map and ignoring the key, and it was changed to iterate over just the values. The commit explicitly says 'No logic change' and the diff confirms it. There is no security issue.

This commit is a performance optimization for the finalization step of several cryptographic hash functions (RIPEMD-160, SHA-1, SHA-256, SHA-512). It rewrites how padding bytes are added so the code writes directly into an internal buffer instead of calling the general input() function multiple times. The commit message and diff show only speed improvements; there is no indication of a security fix or behavior change in the hash output.

This commit only adds a one-line documentation comment listing the existing `arbitrary` Cargo feature in the crate's documentation. It does not change any code, dependencies, build configuration, or behavior. There is no security relevance.

This commit simply removes unused `cmp` (comparison) imports from five hash algorithm files in the `hashes` crate. It is a cleanup change with no functional effect and no security relevance.

This commit only changes documentation comments for two Rust macros. It rewrites the docstrings to be clearer and adds a cross-reference between related macros. No code logic, behavior, or security properties were modified.

This commit only adds a single space before the opening brace in two Rust macro definitions. It is a purely cosmetic code-style change with no effect on program behavior or security.

This commit is a routine automated code-formatting run by the rustfmt tool. It only changes whitespace, import order, line breaks, and other stylistic details across 23 files. No program logic, algorithms, or security-sensitive behavior was altered.

This commit simply deletes a large block of duplicate test data for the SHA3-256 hashing code. The same test cases are already covered by official NIST test files elsewhere in the project. No production code was changed, so this cannot introduce or fix a security vulnerability.

This commit only adds new test code. It does not change any production hashing logic, fix a bug, or introduce a vulnerability. The new tests verify that feeding data to hash engines in three chunks of varying sizes produces the same result as hashing the same data all at once, which helps catch streaming bugs in the future but is not itself a security change.

This commit only adds new test data and test code. It imports official NIST cryptographic test vectors for several hash algorithms and writes tests that compare the library's output against those known correct answers. There is no change to the actual hashing code, no bug fix, and no security-relevant behavior change.

This commit is a performance optimization for the SHA-256 hashing code in the rust-bitcoin library. It changes how input data is fed into the hashing engine so that complete blocks of data are processed directly from the input slice instead of being copied into an internal buffer first. The commit message and diff show only benchmark improvements and no security-related claims.

This is a routine code cleanup in the project's hash functions. A single-block helper was renamed and adjusted so it can later accept multiple blocks at once. The actual hashing math and behavior are unchanged, and the commit message explicitly says it is only refactoring with no logic changes.