rust-bitcoin

This commit is purely a code-formatting cleanup. It re-indents lines, breaks long statements across multiple lines, and reorders imports to satisfy Rust style rules. No program logic, behavior, or security properties were changed.

This commit is a straightforward internal refactoring of the rust-bitcoin library's decoding machinery. It replaces a plain true/false return value from decoder methods with a new named DecoderStatus enum (NeedsMore / Ready). The change is purely about making the code easier to read and maintain; it does not alter what data is accepted, rejected, or how it is parsed. There is no indication this fixes a security bug or introduces a vulnerability.

This commit only updates documentation comments in a Rust Bitcoin encoding/decoding library. It rewrites explanations to match a recent API change where methods now return named enum values (like EncoderStatus::Finished) instead of plain true/false booleans. No actual code logic was changed, so there is no security impact.

This commit only updates generated API snapshot files (text listings of public functions/types). It adds two new public enum types, DecoderStatus and EncoderStatus, and changes the return type of several Decoder/Encoder methods from bool to those new enums. There is no source code change shown, no bug fix, and no security-relevant behavior described.

This commit only adds new unit tests and one test-tooling exclusion. It does not change any production code, so it cannot introduce or fix a security vulnerability on its own.

This commit is a routine code cleanup that fixes compiler lint warnings. It rewrites some pattern-matching to use shorter syntax, adds missing semicolons, converts a manual panic into an assertion, and reorganizes imports and test code behind feature flags. There is no functional change that affects security.

This commit is a straightforward code cleanup: it replaces a true/false return value from an encoder's 'advance' method with a clearly-named enum (HasMore/Finished). The behavior of the code is unchanged; it only becomes easier to read and maintain. There is no security fix or vulnerability here.

This commit is a test-only refactor. It changes how encoding is verified in unit tests: instead of checking the exact byte chunks an encoder produces one at a time, tests now only check the final concatenated byte output. It also deletes tests that poked at internal encoder details and updates documentation to say chunk sizes are not guaranteed. There is no change to production code behavior.

This commit refactors how BIP-32 child key indexes are represented in the rust-bitcoin library. Previously, the index was a public enum with separate fields for normal and hardened variants, and the commit message notes a FIXME: because those fields were public, callers could directly create an out-of-range index (for example, a 'normal' index with the high bit set). The change turns the type into a private newtype around a raw u32 and forces construction through checked constructors that validate the range. It is a defensive hardening change that closes a potential invariant violation, but it does not by itself fix a demonstrated exploit.

This commit adds a scheduled GitHub Actions workflow that runs once a week to check for new releases of an internal maintainer tool (cargo-rbmt). If a newer release exists, it automatically opens a pull request updating a version-tracking file. There is no user-facing code change, no bug fix, and no security-sensitive behavior introduced.

This commit only updates generated API listing files (text snapshots of what functions and types are publicly exposed). It adds documentation of a new error type and a new 'try_push' method for an internal array vector, but it does not change any actual source code or behavior. There is no security issue here.

This commit fixes a deserialization bug in an internal array-like data structure. Previously, if untrusted serialized data claimed to contain more items than the structure could hold, the code would panic (crash) instead of returning a proper error. The fix makes deserialization gracefully reject oversized input.

This commit is a routine automated code-formatting run by the rustfmt tool. It only changes whitespace, import order, and brace style in five files. There are no functional code changes, no bug fixes, and no security-related alterations.

This change is a routine code cleanup, not a security fix. It removes an overly broad feature gate so that parts of the Taproot cryptographic module are available even when the optional 'alloc' feature is disabled, while keeping functions that actually need memory allocation behind the gate. There is no indication it fixes a vulnerability.

This commit is a small internal cleanup in the rust-bitcoin library. It changes how a Taproot signature is parsed from a hexadecimal string so that it no longer needs to allocate a temporary byte vector. The change removes an unnecessary memory allocation but does not alter the allowed signature formats or fix any vulnerability. It is a performance and dependency-reduction refactor, not a security fix.

This commit is a routine dependency cleanup. The project previously had to use two different versions of the same hex-encoding helper library (one stable, one unstable preview) because a needed feature was only available in the unstable version. Now that the stable library released version 1.1.0 with that feature, the commit removes the unstable dependency and switches everything to the single stable version. It is not a security fix and does not change how the software behaves to users.

This commit fixes a bug in how Bitcoin peer-to-peer network messages are validated. The software was checking message checksums against a re-encoded version of the message payload rather than the original bytes received over the network. Because the protocol allows some wiggle room in encoding, a re-encoded payload can have a different checksum than the original raw bytes. This meant a malformed message could pass checksum validation when it should have been rejected. The fix computes the checksum directly from the raw bytes as they arrive, removing that ambiguity.