rust-bitcoin

Add with_compressedness to LegacyPublicKey

At present, to convert a compressed LegacyPublicKey to an uncompressed
copy, a user must either to use from_secp_uncompressed(key.to_inner())
or roundtrip serialize-deserialize. Neither of these are ideal. To
avoid users touching the secp types directly, we can copy the pattern
used for parity in XOnlyPublicKey's with_parity.

Introduce with_compressedness method on LegacyPublicKey to set
compressedness.

crypto: Remove with_serialized from LegacyPublicKey

The with_serialized method on LegacyPublicKey has been used for
serialising the legacy public key in an optionally compressed form
without allocating a vec. With the introduction of the
SerialisedLegacyPublicKey type, the to_bytes() method can now trivially
replace this method with a simpler interface.

Replace all uses of with_serialized with to_bytes and remove method
from LegacyPublicKey.

crypto: Move taproot errors into submodule

Now that the taproot module in crypto is publicly visible, it should
be update to follow the patterns of other crates in the workspace
regarding the use of error submodules.

Move error types to error submodule and re-export.

Move taproot signatures to crypto

As part of the move of types to crypto, the taproot signatures should
also be moved to the crypto crate.

Move taproot module to crypto and re-export signatures and errors in
bitcoin.

crypto: Fix lint errors in crypto::taproot

Following the move to crypto, the stricter lint requirements now
trigger various problems with the module that should be fixed.

Fix all lint errors in the crypto::taproot module.

Remove io dependency from crypto taproot

The taproot module in bitcoin's crypto holds only the Signature and
SerializedSignature types. In order to retain the lack of io dep in
crypto, the io based methods on these types should be removed, as they
were on the corresponding ecdsa signature types.

Remove Signature::serialize_to_writer and SerializedSignature::write_to
methods.

Update manifest and github yaml

In order to reduce the diff in the previous patch, the actual changes
generated by the generate-files.sh script should be split into a new
patch.

Run fuzz/generate-files.sh.

crypto: Make trivial types no-alloc

Having just moved from bitcoin, the code in crypto is all written
assuming the presence of alloc. In the new crate, it is better if the
alloc feature can be used correctly, and have most of the functionality
enabled even in a no-alloc environment.

Remove alloc feature from the modules and only alloc gate things which
can't trivially be used no-alloc.

Make unrecognized field of SighashTypeParseError an InputString

At present, the entire SighashTypeParseError type relies on alloc due
to the presence of the String field "unrecognized". The InputString
in internals is designed to replace such fields and conditionally
enables or disables typical string functionality depending on alloc.

Replace the unrecognized field of SighashTypeParseError with
InputString. Adjust Display impl of SighashTypeParseError accordingly.

Move sighashtype FromStr tests to crypto

The EcdsaSighashType and TapSighashType FromStr tests are currently
located in bitcoin. This means testing regressions to the FromStr impl
requires running a significantly larger test set for no reason. These
should be located alongside the impls themselves in crypto.

Move sighashtype_fromstr_display tests to crypto::sighash.

Implement Serde traits for ArrayVec

This implementation is a prerequisite for the serde traits
impl for `WitnessVersion` and `WitnessProgram`.

Add tests covering round-trip serialization, capacity overflow errors,
and wire-format compatibilitywith slices using both JSON and Bincode.

fuzz: remove psbt fuzz targets and document explicit local bitcoin dependency

crypto: Change to_public_key to return FullPublicKey

In general, modern bitcoin code should be using either the compressed
FullPublicKey or the XOnlyPublicKey. Users should try to avoid the
legacy optionally-compressed public key. To this end, the types were
renamed. To further consolidate this, the to_public_key methods
throughout the key module should also return FullPublicKey, with the
existing behaviour relegated to new to_legacy_public_key.

Change all to_public_key functions to return FullPublicKey and
introduce corresponding to_legacy_public_key functions to return
LegacyPublicKey where necessary.

crypto: Remove unused test from ecdsa

In ecdsa, the write_serialized_signature test was used to test the
serialize_to_writer method on the ecdsa::Signature. Since this was
removed as part of the bitcoin-io dep removal, the test should also
be removed.

Remove write_serialized_signature test case from ecdsa tests module.

crypto: Bump version to 0.2.0

Bump the `crypto` version. Update the dep in `bitcoin` and add an
explicit version number in `taproot-primitives`.

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

Delete psbt module

In #6055 we deprecated the `psbt` module on the `0.32.x` branch. Now
we can delete it from master.

### Context

Development of the PSBT has moved to a separate crate. Hosted on the
new Forgejo instance at:

https://git.rust-bitcoin.org/rust-bitcoin/rust-psbt

Crate name is `psbt-v2` because it has initial support for PSBTv2. The
crate also includes all code from the `0.32.x` branch (as well as
miniscript code). In other words the crate is a drop in replacement
for the `Psbt` type and its functionality.

During release of `psbt-v2 v0.3.0` we attempted to ensure feature
parity with `0.32.x` since the actual migration was done a while back.

The road map for dev of `psbt-v2` is loosely:

- Improve PSBTv2 stuff
- Continue work on supporting Silent Payments
- Use crate as a test bed for the process of upgrade of `bitcoin 0.32.x`


Exact strategy of the last point is being worked on. We are
investigating creating a bunch of step-by-step releases to help the
process. To prove (and develop) the process we plan on using:

- miniscript
- psbt-v2
- corepc

hashes: Add x86 AVX2 8-way dispatch

add dispatcher that handles 8-way

hashes: fold 8-way AVX2 SHA256d into round! macro

use a round! macro to cut ~1060 lines from the unrolled version.
each round becomes a single round!(...) call that almost matches
Core's Transform_8way line-by-line, so it's easy to compare and
review against sha256_avx2.cpp.

refactor, no behavior change.

hashes: Add 8-way AVX2 SHA256d for 64-byte input

add the three transforms for sha256(sha256(64_bytes)) using AVX2
SIMD.

AVX2 uses 256-bit registers, so we can pack eight 32-bit words into
each register and compute 8 independent hashes in parallel with a
single SIMD op.

- Transforms 1 & 2 compute the inner `sha256(64_bytes)`.
- Transform 3 computes sha256(output_of_T1_and_T2).

rounds are fully unrolled (we will use a round! macro to fold them
in the next patch).

Run the formatter

Use drain instead of flush

The term 'flush' has meaning already in respect to a std writer thus
impiles that a function with 'flush' in the name would call
`writer.flush()` but we do not.

After debate we reached consensus on the verb 'drain' to replace
'flush'.

Rename all 'flush_to_writer' functions to be `drain_to_writer`
repository wide. To keep our API uniform also re-name `flush_to_vec`
to be `drain_to_vec`.

crypto: Remove bitcoin-io dependency

With the removal of the io-dependent functions from the key and
signature types, the bitcoin-io dependency can be entirely dropped from
the crypto crate.

Remove bitcoin-io dependency from manifest and update lock files.
Remove io re-export from crate root.

Remove io methods on public key types

The read_from and write_into functions on the public key types rely on
the bitcoin-io Read and Write traits. Since we want to remove the
dependence on io for the crypto crate, these methods must also be
removed. With the Serialized* types, the write_into methods are trivial
to replace inline.

Remove read_from and write_into methods from public key types and test
case for them.

hashes: change engine parameter to be mutable reference

Allow engine parameter to be less restrictive in use. By changing the
parameter to `&mut`, the calling function no longer needs give up
ownership of engine.

The return value is removed since the caller can simply use existing
ownership of variable instead of the return value.

hashes: Add 4-way dispatcher

add x86 sha256d dispatcher that handles 4-way SSE4.1