rust-bitcoin

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)

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.

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.

Add psbt fuzz target

p2p: Implement ExactSizeEncoder for AddrV2Encoder

For encoders, the use of the encoder_newtype_exact macro allows for
the implementation of the ExactSizeEncoder trait. This provides users
with the ability to determine the encoding length of types without
needing to perform the entire encoding process. Since the AddrV2Encoder
can do the necessary calculation in constant time, this trait should
be implemented for it too.

Implement ExactSizeEncoder for AddrV2Encoder.
Add test cases to confirm correct encoding + length calculation for
all types of AddrV2.

key: Make as_inner pub(super) for secret key types

As part of the long-term goal to remove the need to access the inner
secp types for all key types, the secret keys can now have their
inner accessor functions made pub(super). These functions are still
needed for functionality in the key module, but are no longer
necessary in the bitcoin crate or in the wider ecosystem.

Make as_inner pub(super) on PrivateKey and Keypair.

key: Add From conversions for references for secret key types

As with the changes to the from_* functions, there should exist From
impls that take references for all From impls that work on secret key
types. This further simplifies working with the non-Copy secret types.

Add From<&TweakedKeypair> for &Keypair, From<&PrivateKey> for Keypair
and From<&TweakedKeypair> for TweakedPublicKey.

key: Adjust all from_* functions to take refs

The secret key types in bitcoin are no longer Copy. Since some
conversions to public key types take the key types by value, this makes
the use of private keys fairly unergonomic. Except where necessary,
conversion constructors for all key types (that is, from_* functions)
should always take references. This can help avoid costly copies.

Change from_keypair on TweakedPublicKey, from_private_key on
CompressedPublicKey and from_secret_bytes on PrivateKey to all take
references instead of values.

Add panics section to docs

Docs cleanup

Add a couple of missing full stops and capital letters.

bitcoin: Move key module errors to error submodule

At present, some modules in bitcoin separate error types into
submodules with re-exports while others simply define the error types
in the module. This inconsistency is confusing and makes the docs vary.
All error types for each top-level module should be moved into a
relevant submodule and re-exported without inline docs.

Move error types from key module into error submodule and re-export.

bitcoin: Move ecdsa module errors to error submodule

At present, some modules in bitcoin separate error types into
submodules with re-exports while others simply define the error types
in the module. This inconsistency is confusing and makes the docs vary.
All error types for each top-level module should be moved into a
relevant submodule and re-exported without inline docs.

Move error types from ecdsa module into error submodule and re-export.

bitcoin: Move sighash module errors to error submodule

At present, some modules in bitcoin separate error types into
submodules with re-exports while others simply define the error types
in the module. This inconsistency is confusing and makes the docs vary.
All error types for each top-level module should be moved into a
relevant submodule and re-exported without inline docs.

Move error types from sighash module into error submodule and re-export.

bitcoin: Move bip32 module errors to error submodule

At present, some modules in bitcoin separate error types into
submodules with re-exports while others simply define the error types
in the module. This inconsistency is confusing and makes the docs vary.
All error types for each top-level module should be moved into a
relevant submodule and re-exported without inline docs.

Move error types from bip32 module into error submodule and re-export.

fuzz: pin cargo-fuzz to 0.12.0

bitcoin: Add explicit None return impl for std::error::Error

The std::error::Error impls on many error types rely on the default
implementation for the trait, which returns None. While these are
correct, explicit return values make the functionality more obvious to
later developers without requiring pre-existing knowledge of the trait
or needing to search documentation.

Replace all default impls of std::error::Error with explicit impls
returning None. For enum errors, also return None for each match arm.

hashes: Add explicit None return impl for std::error::Error

The std::error::Error impls on many error types rely on the default
implementation for the trait, which returns None. While these are
correct, explicit return values make the functionality more obvious to
later developers without requiring pre-existing knowledge of the trait
or needing to search documentation.

Replace all default impls of std::error::Error with explicit impls
returning None.

hashes: Add a full stop to the sha256 error module comment

This was missing from the the original PR, but should be included
because publicly visible doc comments should always be well-formed
English.

Rename PublicKey to LegacyPublicKey

The optionally-compressed PublicKey type is no longer used in Bitcoin
outside of legacy transaction handling. Since the name PublicKey
implies a general purpose public key type, it should be renamed to
clarify the niche use compared to the typical compressed public key
type, FullPublicKey.

Rename PublicKey to LegacyPublicKey.
Deprecate PublicKey.

Rename CompressedPublicKey to FullPublicKey

The CompressedPublicKey represents an always compressed ECDSA public
key. This key type is the standard for almost all transactions in
modern Bitcoin. As such, it should be renamed to better clarify
its purpose.

Rename CompressedPublicKey to FullPublicKey.
Deprecate CompressedPublicKey.

fuzz: Replace Unstructured with auto Arbitrary arg for do_test

With the new libfuzzer backend for the fuzz targets, types that
implement Arbitrary can be directly constructed as arguments to the
fuzz_target! callback, rather than taking a byte slice, running it
through Unstructured and then calling Arbitrary impls manually.

ref:
https://rust-fuzz.github.io/book/cargo-fuzz/structure-aware-fuzzing.html

Replace manual arbitrary use with an automatic Arbitrary argument in
arbitrary_block, arbitrary_transaction, arbitrary_witness,
deserialize_psbt and arbitrary_addrv2 fuzz targets.

hashes: Move errors in sha256 to error submodule

As with the other crates, errors in hashes should be moved to
submodules for each of the top-level modules. Any errors should then
be no_inline re-exported in the top-level module.

Move MidstateError to new error submodule and re-export in sha256.

Add homepage metadata for all crates

Per the Rust API guidelines:
The homepage metadata should only be set if there is a unique website
for the crate other than the source repository or API documentation.

Add "https://rust-bitcoin.org" homepage to all crate manifests.

Move From<Infallible> impls below type

As is customary put the impl below its type. However when there is an
impl block for the error type put the `From` below that. Note the
layout is then

1. Type definition
2. [Type impl block]
3. `From<Infallible>` for type
4. `Display`
5. `std::error::Error`
6. [other `From` impls]

Anal I know. Code move only.