rust-bitcoin

Avoid clone in BIP152 decode test

chore: remove `act` references

bip32: validate master key seed length

BIP-32 requires the master seed to be between 16 and 64 bytes, but
new_master accepted any length. bitcoinfuzz flagged this as a
inconsistency on seeds out of range.

Introduce a Bip32Seed type that validates on construction.
new_master now takes a ref to Bip32Seed (a transparent newtype of
&[u8]). Fixed-size arrays go through infallible From<[u8; N]>. Slices
go through TryFrom<&[u8]> returning InvalidSeedLengthError.
`Debug` shows first 4 bytes of seed's sha256. `PartialEq` fixed
time equality comparison based on hashes.

Fix fuzz cache key target name

Move Miri CI to a daily cron job

Miri takes hours and rarely completes on a PR. Run it instead on a daily
schedule like fuzz and kani.

Use the same tool to produce an issue when it fails.

Explicitly don't support ficticious architectures

Currently, no architecture with `usize` exists in stable or unstable
Rust or anywhere in the world that I (or ChatGPT) know of. Notably,
CHERI has 128 bit **pointers**, but **not** `usize`, which is still 64
bits.

Rather then producing garbage on such platforms it is much cleaner to
flat out not support them. This makes reviews easier to reason about and
removes the WTF factor. And while this appears breaking, it really isn't
becuase since no such platforms exist, nobody could've realied on this
behavior.

If such platforms ever arrive, this crate will be most likely EOL for
millenia but even then there exists upgrade path:

1. release 2.0 which has the `new` method behind a feature flag, off by
default
2. semver-trick the entire 2.0 with `*` import and the feature forced on
3. add `try_new` method that returns `Result`

Then downstream crates that want to support crazy-wide architecture will
just upgrade to 2.0 with the feature deactivated and use the new method.

Hard fail semver breaks for 1.0 crates

p2p: refactor: use `take()` instead of `replace()`

The replacement value is not used due to the next state transition being
`ReadPayload`. That is, the value used in replace is never used in the
future since the header_decoder is "ready".

Call low-level `ArrayVec` methods from high-level

The high-level methods on `ArrayVec` should call into the low-level
methods instead of directly accessing the fields so that safety can be
better reasoned about. This modifies the existing high-level methods to
make it so. Notably, it does not modify `from_slice` which is
technically high-level but is also `const` and would require a call into
non-`const` `spare_capacity_mut`.

Move high-level methods out of safety boundary

`ArrayVec` was defined inside a `safety_boundary` module to make
soundness review easier. However, multiple high-level methods that could
be implemented by calling into low-level ones were defined inside
`safety_boundary`. This moves them out into a separate impl block.

Avoid len check in `ArrayVec::spare_capacity_mut`

The `ArrayVec` type already has an `unsafe` invariant and the module has
a bunch of `unsafe` anyway, so it makes sense to also rely on the
invariant when it comes to the length, potentially improving
performance.

Add `ArrayVec::set_len`

Just as `Vec` has `set_len`, this adds an analogous function to
`ArrayVec` allowing the state-manipulating methods to be moved out of
safety boundary.

Add `ArrayVec::spare_capacity_mut`

We'd like to improve tracking of `ArrayVec`'s invariants and, as a first
step, this commit adds `spare_capacity_mut` method which is modeled
after `Vec` and returns the slice pointing to the unused part of the
array vec.

Add `#[track_caller]` to `ArrayVec::push`

When `push` panics because of capacity being exceeded it's the caller's
fault for not taking care of it, so using `#[track_caller]` provides a
better panic message.

Simplify `ArrayVec::push`

Now that `try_push` exists, `push` can just call into it and call
`expect` on the result.

Promote BLOCK_SIZE assertion to hard assert

The debug_assert only fires in debug builds; a downstream HashEngine
implementation with BLOCK_SIZE > 128 would silently produce wrong
outputs in release builds by indexing into fixed-size 128-byte ipad/opad
buffers beyond their length.

Change to assert! so the check is unconditional.

Assisted-by: claude-sonnet-4.6

Introduce signing functions on sighash types

Although the private key types have raw signing functions on them that
allow users to bypass secp, they still present a rough interface for
signing compared to directly signing on the sighash types that result
from the SighashCache.

Introduce signing functions on LegacySighash, SegwitV0Sighash and
TapSighash.

Change TapTweak to take self by ref

The TapTweak trait in bitcoin::key currently consumes the untweaked
key to construct the tweaked key. While this is mostly fine for users
who manually call into it, it prevents clean usage in functions that
take Keypair refs.

Change TapTweak::tap_tweak to take self by ref instead of by value.

docs: Re-run gen-dep-tree script

The doc has gotten a bit stale. Re-run the script (using `just
gen-dep-tree`).

hashes: Bump version to 0.21.0

In preparation for release add a changelog entry, bump the version,
and update the lock files.

One last release before we 1.0 this crate team.

2026-05-24 automated rustfmt nightly

bip158: reject malformed filter counts

Propagate CompactSize decode errors when reading the element count in GCS
filter matching instead of treating malformed input as an empty filter.

Assisted-by: OpenAI GPT-5

bip158: add invalid compact size error

Add a dedicated error variant for invalid CompactSize encoded filter counts.
It will be used in subsequent commit.

Assisted-by: OpenAI GPT-5

bip158: regression test of malformed filter counts

Cover truncated and non-minimal CompactSize prefixes in both
match_any and match_all.

Assisted-by: OpenAI GPT-5

primitives: add minimum allocation size

It's possible to construct witnesses that force our current logic to repeatedly
allocate a single byte, many thousands of times. This is inefficient, and on
some targets (notably: x86 with fuzzer instrumentation) it is slow to the point
of being a DoS vector.

I was not able to construct a unit test which meaningfully demonstrates this
behavior (or even runs slowly enough to notice), but with this patch, a fuzzer
input which previously took several seconds now takes only milliseconds.