rust-bitcoin

This commit only changes test code in the rust-bitcoin library. It removes old-style serialization tests and switches them to use a newer encoding API. No production code is modified, and there is no security fix or vulnerability introduced.

This commit only removes old test cases from the codebase. It deletes duplicate roundtrip tests that used a legacy encoding path, keeping only the tests for the new encoding path. No production code was changed, and no security vulnerability is present in the diff.

This commit fixes a missing security check in the Bitcoin peer-to-peer message decoder. Previously, when receiving v1 Bitcoin network messages, the code decoded the payload but did not verify the 4-byte checksum in the message header against the actual payload data. That meant corrupted or tampered messages could be accepted as valid. The change makes the decoder compute the expected checksum and reject messages where the checksum does not match.

This commit is a small convenience improvement, not a security fix. It lets several common Bitcoin hash types be directly used as 'pushable bytes' in Bitcoin scripts, so developers can write slightly cleaner code when building transactions. There is no vulnerability being patched.

This commit is a straightforward API cleanup: it adds missing re-exports of existing extension traits to a central 'ext' module so users can import them from one place. No code behavior changes, no bug fixes, and no security relevance.

This commit is purely a code-formatting cleanup. It only changes whitespace, line breaks, and import order to match the project's style rules. No program logic, behavior, or security properties were changed.

This commit is a simple rename of internal functions from 'flush_to_writer' and 'flush_to_vec' to 'drain_to_writer' and 'drain_to_vec'. The word 'flush' was confusing because it normally means something specific in I/O code, so the team chose 'drain' instead. No behavior changed, and there is no security issue.

This commit only updates generated API text files that list public function names. It renames two functions from 'flush_to_*' to 'drain_to_*' in the documentation snapshots. There is no actual code change, no bug fix, and no security relevance visible in the diff.

This commit is a minor code cleanup: it moves a Rust import statement (`use core::fmt;`) from one feature-gated code block to another. The change fixes a compiler lint warning and does not alter any program behavior or security logic.

This is a small test-only change that swaps one set of encoding helper functions for another inside unit tests. It does not touch production code, network behavior, or any security-sensitive logic.

This is a small test-only change that swaps one internal encoding helper for another inside the BIP152 test module. It does not touch production code, network handling, or consensus logic, and there is no indication it fixes or introduces a security issue.

This is a small test-only change that swaps out one internal encoding helper for another equivalent one inside unit tests. It does not touch production code, network handling, or any behavior visible to users.

This commit is a routine Rust crate maintenance change. It makes several underlying libraries publicly visible from the taproot-primitives crate root so that downstream users can refer to those types more conveniently. There is no security issue here.

This commit is a routine cleanup that removes an unused dependency called bitcoin-io from the crypto crate. It only touches package metadata and lock files, not any code that handles keys, signatures, or user data. There is no security issue visible in this change.

This commit removes convenience methods for reading and writing public keys from/to byte streams in the rust-bitcoin crypto crate. It is a routine API cleanup to reduce dependency on the bitcoin-io crate, not a security fix. There is no evidence in the commit or supplied references that this change addresses a vulnerability.

This commit only updates three generated API text snapshot files to reflect that a function now takes a mutable reference to its engine argument instead of taking ownership. There is no actual source code change in the commit, and nothing in the commit message or diff indicates a security issue.

This is a routine internal API cleanup in the rust-bitcoin hashing library. A helper function that feeds data into a hash calculator is changed so callers pass in the calculator by mutable reference instead of handing it over and getting it back. No security vulnerability is present in the diff; it is a usability and ownership-style refactor.

This commit fixes a spelling mistake in an error message: 'emoty' was corrected to 'empty'. It does not change any program logic, behavior, or security properties.

This change only updates the project's mutation-testing configuration file. It tells the cargo-mutants tool to skip generating certain test mutants for encoding/decoding methods because those artificial mutations would make the test suite hang. It does not change any production code, protocol behavior, or security-relevant logic.

This commit only adds new test code. It introduces a fake test-only Merkle node type so the project's mutation-testing tool can exercise a default trait method that real node types override on common CPU platforms. There is no change to production code, no bug fix, and no security-relevant behavior change.

This commit adds a new performance optimization for SHA-256 hashing on modern x86 processors. It introduces a code path that processes four blocks at once using SSE4.1 instructions when available. There is no indication in the commit that this fixes a security vulnerability; it appears to be a routine performance improvement.

This commit is a code cleanup in the Bitcoin library's SHA-256 hashing code. It replaces roughly 1,000 lines of manually repeated calculation steps with a few short macros that generate the same steps automatically. The author explicitly calls it a refactor with no behavior change, and the constants and arithmetic operations appear unchanged.

This commit adds a new, faster way to calculate SHA256d hashes for 64-byte inputs on modern Intel/AMD processors using SSE4.1 CPU instructions. It is a pure performance optimization and does not appear to fix or introduce a security vulnerability based on the code shown. However, because it is new cryptographic code, any bug in it could in principle produce wrong hash results, which would be a correctness issue rather than a direct security flaw.

This is a build-system fix for a Rust crate that supports both memory-allocator and no-allocator environments. The crate was always pulling in the standard memory allocator even when a user explicitly requested a no-allocator build, which would cause compilation to fail on platforms without an allocator. The patch simply adds the correct on/off switch so the allocator is only used when the corresponding feature is enabled. There is no runtime security vulnerability or exploit here.

This commit is a feature-gating cleanup, not a fix for an active security flaw. The taproot-primitives crate was always enabling hex (base-16 string) support for its hash types, even when downstream users did not ask for it. The change adds an explicit 'hex' feature, turns it off by default, and makes the bitcoin crate request it explicitly. This gives users more control and avoids pulling in unneeded functionality, but it does not patch a vulnerability that can be directly exploited.