rust-bitcoin

Split raw_ecdsa_sign_recoverable function to PrivateKeyExt

The raw_ecdsa_sign_recoverable function on PrivateKey exists purely to
provide the low level functionality used in the sign_message module of
bitcoin. Since this is not necessary at this early stage in the crypto
crate, it should be moved to a new extension trait prior to the move.

Introduce PrivateKeyExt and move raw_ecdsa_sign_recoverable to the new
extension trait.

Split methods to extension traits on public keys

The p2wpkh_script_code functions on FullPublicKey and LegacyPublicKey
rely on functionality only present in the bitcoin crate. Since this
will not be easy to move out, these functions should be moved to
extension traits prior to the move.

Further, the to_bytes method on LegacyPublicKey relies on
SerializedLegacyPublicKey, a type which itself relies on conversions
to and from PushBytes, a type only available in bitcoin. Since the
serialised type cannot be moved at present, the to_bytes must be left
behind in the extension trait for now.

Introduce FullPublicKeyExt and LegacyPublicKeyExt and move the
corresponding p2wpkh_script_code functions to them from the public
key types. Move to_bytes on LegacyPublicKey to LegacyPublicKeyExt.

Drop use of deprecated methods

In sign-tx-segwit example, the deprecated `public_key` method was
still being used, not reflecting the now recommended `to_public_key`
method.

This patch drops the use of the deprecated method for the now recommended
method by the API.

Improve Arbitrary impl for Xpriv

Remove useless `Option`s in encoders

The `Encoder` contract states that implementors are not obligated to
make the state after `false` was returned defined, however they so far
did so anyway and this was even tested. This was a waste of performance
and complication of the code that would get amplified with multiple such
encoders chained as each would have to track the final state.

This change removes all those `Option`s, associated tests and in
addition replaces `&[]` return with panic in invalid state of a
composite encoder.

p2p: add ping pong example

Run the formatter

Add `SerializedLegacyPublicKey`

The legacy public keys can be serialized as compressed or uncompressed
which was annoying to deal with since serializing them involved either a
heap alloction or branches. A stack-allocated type holding any key was
needed for a long tim.

This commit finally adds `SerializedLegacyPublicKey` which behaves
similarly to `SerializedSignature` - holding `ArrayVec<u8, 65>` to be
able to represent any of the keys. While this could've been more
efficient, taking advantage of the first byte encoding length, let's
stick with something simple at least for now.

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)

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

units: Add #[inline] attributes to simple functions

Where functions merely delegate to other functions, or only perform
trivial operations, they should be annotated with #[inline] to nudge
the compiler towards improving performance by inlining them.

Add #[inline] to trivial functions in all modules.

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: 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: 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: 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 transaction 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 transaction 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.