rust-bitcoin

Change format_with to take self by value

The format_with function on ChildNumber acts a wrapper for the type's
various format trait impls. This type currently takes self by ref, as
each of the relevant fmt impls pass self by ref. However, for trivial
Copy types (<= 8 bytes on x86_64), clippy suggests instead passing by
value to avoid the cost of pointer indirection.

Change the format_with function to take self by value, and remove the
deref in the match statement to suit.

Fix lint errors in key-expression

The stricter lint requirements for crates other than bitcoin cause many
lint errors in the bip32 module.

Fix all lint errors in key-expression crate.

Move bip32 module to key-expression crate

With the creation of the key-expression and crypto crates, and the move
of the impl_array_newtype_stringify, the main bip32 module can be
easily moved to the new key-expression crate and used in bitcoin.

Move the bip32 module to key-expression crate.
Re-export the module from the bitcoin crate root.

Replace wildcard import with a single import

Clippy started complaining about the use of `super::*` in the
`taproot::into_iter` module, which seems to make sense since that import
actually only imported a single item and was confusing.

This commit just imports the single item, since there shouldn't be need
for the wildcard.

hashes: fix doc comment on x86 SHA-NI

hashes: process multiple sha256 blocks per call

currently we loop over blocks and call process_block for each
64-byte chunk, which loads/saves state into SIMD registers on each
call. Instead we can move the loop inside the intrinsic function
so that state stays in registers across blocks.

this shows around ~8% improvement for x86 SHA-NI.

2026-05-10 automated rustfmt nightly

Simplify and extend formatting of `Signature`

Because `Signature` is displayed by serializing it and hex-encoding
which is equivalent to displaying `SerializedSignature`, it is simpler
to just create `SerializedSignature` and display that instead. I don't
expect significant performance difference from this.

This commit does so and in addition adds `LowerHex` and `UpperHex` impls
to `Signature` since they are similarly trivial.

p2p: Remove `io` dependency

`io` is no longer required with the introduction of
`bitcoin-consensus-encoding`

Add failing test for `SerializedSignature` fix

This adds a test that fails if ordered before the previous commit and
passes if ordered after.

Fix crash in `SerializedSignature` formatting

The formatting function was calling `fmt_hex_exact!` macro which
requires exact buffer size rather than minimum buffer size causing it to
crash since the length of `SerializedSignature` is conditional.

This fixes it by simply conditionally calling the macro with appropriate
values.

Simplyfy `impl Display for Magic`

The implementation was exactly the same as for `LowerHex`, which is
slightly less clear than just calling into `LowerHex` and makes the
compiler work a bit more.

This commit changes it to simply call into `LowerHex`.

Simplify control flow using Option and Result combinators

Replace imperative 'if let' and 'match' blocks with functional
method chaining.
This refactor:
- Flattens nested logic in hex and validation codepaths.
- Improves readability by using idiomatic methods like 'or_else',
'ok_or', and 'is_ok_and'.

This change prioritizes a declarative style to make the intent of
the data transformations clearer at a glance.

Improve codec methods implementation

Use Rust's Option methods and Pattern matching to collapse if_let_else
constructs in the `read_limit` method implementation, this maintains a
clearer and concise usage of the `Option<T>` API.

Leverage `Option<T>::is_some_and` method for the `advance` method impl,
which proceeds to propagate to `Encoder::advance` if the encoder is
`Some(T)` and returns false if the encoder is `None`.

Remove needless question mark

Replace unwrapping and wrapping of the return value from functions
that return a `Result`, as simply returning the `Result` achieves
the exact same outcome without the extra unwrapping and re-wrapping
steps.

"There’s no reason to use ? to short-circuit when execution of the
body will end there anyway." See:
https://rust-lang.github.io/rust-clippy/rust-1.95.0/index.html#needless_question_mark

Update the security policy to mention repos

Now that we have crate smashed the repository a bunch the security
policy is a bit stale.

Use repositories in the list of things to apply our security policy to
instead of individual crates. Saves us from the long list of crates
now in this repository.

Also remove the mention of cryptography because now we list repos its
not so relevant.

Adds `rust-bech32` because a bug in address generation could lead to
loss of funds which is explicitly defined as a security issue.

Adds `hex-conservative` because we depend on it in `rust-bitcoin` so
bugs there are bugs here.

Remove redundant rust version files

The move to rbmt no longer requires the stable and nightly version
files.

Remove them and update the semver checks workflow to select the
stable version from the workspace metadata.

Move Keypair Drop impl under Keypair impl

Move XOnlyPublicKey serde to the other serde impls

Add #[inline] to all simple functions

Functions that either only call into other functions, or perform a
couple of simple checks can be tagged with #[inline] to tell the
compiler to try and inline them to remove the function call overhead.

Add #[inline] to all simple functions in the key module.

Remove redundant code on Legacy -> XOnly key From

The From<LegacyPublicKey> for XOnlyPublicKey conversion is a duplicate
of the From<secp256k1::PublicKey> impl, with the addition of a to_inner
call.

Simplify From<LegacyPublicKey> for XOnlyPublicKey by calling to
From<secp256k1::PublicKey> for XOnlyPublicKey.

Move From impls on keys

The From impls should always be placed directly underneath the type
they yield. In the keys module, some are placed under the type they
convert from, and others are arbitrarily located.

Move all From<> impls to be located under the impl block for the type
they convert to.y

Shorten fmt calls

Certain calls to fmt() functions within fmt trait impls use the
longform path for the trait + fmt method. These can be simplified to
calling .fmt() on the data type.

Replace full length fmt::Foo::fmt calls with data.fmt().

Drop From<Keypair> for secp256k1::PublicKey

Generally, we want to avoid allowing users to trivially convert to secp
types from the bitcoin types. In the case of Keypair, the implicit
conversion to a secp PublicKey is only used in a single test case. It
should instead be removed.

Drop From<Keypair> for secp256k1::PublicKey and adjust
public_key_constructors test accordingly.

Replace TBD in deprecations with 0.1.0