rust-bitcoin

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 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 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 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.

This is a routine internal code cleanup in the project's hash-function code. It changes how a low-level helper function is called so it takes the hash state and data block as explicit arguments, rather than reading them from a surrounding object. The commit message and diff show no change to the actual hashing math or results. There is no security issue here.

This commit only adds and improves documentation comments for error conditions in the cryptographic key module. No code behavior, logic, or security properties were changed. It is a documentation-only change.

This commit fixes a bug in how the library reads Bitcoin public keys from raw bytes. Previously, when a caller said the key was 'compressed', the code did not verify that the first byte was a valid compressed-key prefix (2 or 3). That meant invalid or even attacker-chosen prefix bytes could be accepted for compressed keys, while uncompressed keys were already checked. The fix now rejects any compressed key whose first byte is not 2 or 3, matching the Bitcoin protocol rules.

This commit simply bumps the version number used by the project's GitHub CI from Rust 1.93.0 to 1.93.1. It is a routine automated maintenance change to the continuous integration configuration and does not alter any source code, dependencies, or runtime behavior of the library.

This commit simply moves existing unit tests from inside the source file to a separate integration test file. No production code behavior was changed, and nothing about how the library works in real use was modified. It is a routine test reorganization with no security relevance.

This commit simply moves existing unit tests from inside the source file to a separate integration test file. No production code behavior was changed, so there is no security risk or fix.

This commit simply moves existing unit tests from inside the source file to a separate integration test file. No production code behavior was changed, so there is no security impact.