rust-bitcoin

consensus_encoding: Improve the API test

Go over the API test and try to ensure it covers what we want it to.
Remember these API test files are mainly so devs can look and check
stuff is sane. They also kind of work as documentation of what the
crate does all in one spot.

I did this by looking at the state of `units/test/api.rs` after #5890
is applied (because I reworked that file the other day).

primitives: enable batched merkle root computation for x86

Fix AddrV1 Decoder Typographical Error

Correct the doc comment on `AddrV1MessageDecoder` to correctly mention
the `AddrV1Message` as the message format it is decoding, and not
`AddrV2Message`.

hashes: Add x86 SHA-NI 2-way dispatch

add x86 sha256d dispatcher that handles 2-way SHA-NI

hashes: Interleave two independent hashes for 2-way SHA256d

x86 SHA256RNDS2 has a latency of 4-6 cycles depending on
the architecture. the next SHA256RNDS2 needs the result
of the current one as input, so the CPU has to wait until
it is ready. (in Transform 2 for eg, 3 out of every 4 cycles
are wasted doing nothing)

we fill those wasted cycles by computing a second independent
hash alongside the first.

See https://uops.info/html-instr/SHA256RNDS2_XMM_XMM.html
for per-architecture instruction timings.

hashes: Add optimized x86 SHA256d for 64-byte input

Add the three transforms for sha256(sha256(64_bytes))

Transforms 1 & 2 compute the inner `sha256(64_bytes)`:

- Transform 1: 64 bytes already fill the first block (no
padding needed), so we apply 64 rounds of compression
normally.
After T1: state = state + initial_state

- Transform 2: the message schedule at this step is constant
and known in advance (64 bytes of padding), so
we precompute W[i]+K[i] into MIDS and apply 64 rounds (no
schedule expansion needed).
After T2: state = state + saved_T1_state
(state now contains sha256(64_bytes))

- Transform 3 computes sha256(output_of_T1_and_T2). The output
is 32 bytes, so the block contains 32 bytes and the rest is
known padding. we precompute the message
schedule for the known words (w8-w15) into FINS.
After T3: state = state + initial_state
(state now contains the sha256d result)

units: Re-export all the public amount error types

Now we are adding `errors` modules everywhere we can re-export all the
public `units::amount` errors. In times past we were only going to
re-export the non-niche ones.

This will be tested later in `tests/api.rs`.

units: Correctly feature guard test code

We recently started putting all cfg's on their own lines. Fix one we
missed and also feature gate the `ToString` import correctly clearing
a lint warning when building with `alloc` feature.

hashes: use consistent round numbering in sha256 comments

the 1-way ARM and x86 SHA-NI functions used Rounds 0-3 while
the 2-way ARM function used Rounds 1-4 in the comments.

use this consistently everywhere.

Extend bitcoin re-export script to check against units

The public API files generated by the rbmt check-api command provide a
semi-comprehensive set of public API interfaces. In the case where a
crate pub use's a module from another crate (e.g. primitives pub use
units::absolute), the API files fail to outline all content within the
re-exported module. As such, checking bitcoin's re-exports against
primitives alone, misses many type re-exports.

Adjust bitcoin re-export check script to also compare against units.

Assisted by Claude Opus 4.6

Fix re-exports in bitcoin crate

Due to existing limitations in the re-export check scripts, various
types are not correctly re-exported in bitcoin to satisfy the
bitcoin -> primitives -> units superset requirements.

Re-export all missing types from bitcoin.

p2p: add encoding trait impls to NetworkMessage encoder/decoder

Migrate NetworkMessageEncoder and NetworkMessageDecoder to use
encoding::encode_to_vec and encoding::decode_from_slice rather than
the legacy bitcoin::consensus::encode traits.

hashes: split sha256 crypto int separate files

since we are planning to add other implementations for sha256: 2-way x86 shani,
4-way SSE4.1, and 8-way AVX2, we can split the file so each impl has
its own file without ending up with a single file that is hard to review.

this is just a code move, no logic change.

units: Remove TODO comment

There is a fix in flight for this: #5875

In case we don't want to wait for that PR to land just remove the
comment so the pre-release job on #5891 can pass.

units: Update serde_regression test

The serde_regression test case in units checks for regressions in the
serde implementations for any type in units. Since new types with serde
impls have been added to units, this needs to be updated.

Update the serde_bincode and add Target and Work to Serde test struct
in serde tests.

Move pow serde tests to units

The serde regression tests for the proof-of-work types can and should
be moved to units, rather than remaining in bitcoin to ensure that any
regressions are caught by the crate that implements the serde traits,
rather than one that uses them.

Move regression_target and regression_work serde tests to units, moving
the u256 bincode as necessary.

Replace upper-lower serde parsing with from_unprefixed_hex

The U256 deserialize impl manually splits a known-length string into
upper and lower halves. While this functions correctly, it's a
needless reimplementation of the same functionality present in U256's
from_unprefixed_hex function.

Replace the manual split of strings in U256 deserialize with a single
call to from_unprefixed_hex.

Remove visit_bytes from U256 serde

In the U256 serde deserialize impl, a visitor struct is defined inside
of an is_human_readable() condition block. The visit_bytes function in
this block can't be used as the data is human readable and thus only
visit_str is required. As such, it can be removed.

Remove the visit_bytes from the HexVisitor struct in U256 Deserialize.

Move U256 serde impl to units pow

The U256 serde traits are only used to derive serde traits for Target
and Work. Since these types are defined in units, the serde trait impls
should thus also live only in units.

Move U256 serde traits from u256.rs to pow.rs in units.

Update API files

units: Remove From impls for Un/PrefixedHexError types

The remaining From conversion trait impls for the hex errors can be
removed now that the relevant hex functionality is all co-located in
units and doesn't require any public API surface.

Remove all From impls for UnprefixedHexError and PrefixedHexError.

units: Add U256 hex parsing as pub(crate) in parse_int

By moving u256 hex parsing into parse_int, the error types can be kept
simple and self-contained, at the expense of requiring parts of U256
to be made pub(crate). Since both cases produce no changes to the
public API, the introduction of u256 parsing in parse_int is better,
since it keeps functionality together.

Make U256 constructors and struct pub(crate).
Introduce pub(crate) u256 parsing in parse_int.

Update API files

pow: Move all error types into error submodule and re-export

As part of the move for pow types into units, the error type
definitions were left in the top level of the pow module. Following
existing patterns, they should be defined in the error submodule and
re-exported with #[doc(no_inline)] from the module.

Move ParseTargetError and ParseWorkError definitions from macro into
error submodule.
Adjust Display impl strings to use write_err.

pow: Move error module re-export to the correct place

In the process of moving the pow types to units from bitcoin, the error
module re-export accidentally wound up positioned after the definitions
of the Target and Work types, rather than at the top just below the
type imports.

Move the error submodule re-exports to the top of the file under the
private type use statements.