rust-bitcoin

p2p: Move message_filter module errors to error submodule

At present, some modules in p2p 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 message_filter module into error submodule and
re-export.

p2p: Move bip152 module errors to error submodule

At present, some modules in p2p 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 bip152 module into error submodule and re-export.

p2p: Move merkle_tree module errors to error submodule

At present, some modules in p2p 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 merkle_tree module into error submodule and
re-export.

p2p: Move message_bloom module errors to error submodule

At present, some modules in p2p 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 message_bloom module into error
submodule and re-export.

p2p: Move message_network module errors to error submodule

At present, some modules in p2p 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 message_network module into error submodule and
re-export.

p2p: Convert encoders to ExactSizeEncoder

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.

Replace uses of encoder_newtype with encoder_newtype_exact where
possible.

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.

Deprecate the to_hex implementation on Work and Target

Types in stable crates should not include the to_hex function. Since
this type is coming from bitcoin, this may be unintuitive to users.
For now, we'll keep the to_hex functionality on the types using the
bitcoin extension traits, but label them as deprecated.

Deprecate the Work and Target to_hex implementations.

Move Target and Work to units

With all the prior work complete, the pow types can now be moved to
units. Since units has no hex feature, hex formatting for the U256
(and thus the Target and Work types) is implemented manually.

Move Target and Work to units, using include! to introduce U256.
Move and improve relevant tests to kill mutants.
Fix lint errors to satisfy stricter requirements.

Update API files

Following the move of the pow types to units, the api files for
both units and primitives will be out of date.

Update API files for units and primitives.

Move U256 tests to units

As part of ensuring that the hex parsing on U256 is only needed in
units (to simplify error conversions), the test cases for u256 that
currently rely on the U256Hex trait should be moved to units. This move
also ensures that the type is tested at the most upstream point it is
used, not only in bitcoin, potentially helping to catch bugs earlier.

Move all u256-specific test cases to units.
Remove U256Hex trait from bitcoin.
Fix lint errors in test cases.

Adjust pow impls to remove private access

With the move to units, the use of the Target() and Work() constructors
will no longer be possible, and neither will access to the inner U256.
However, since these types retain the to_/from_le_bytes, we can convert
them to the locally include!d U256 to perform the various complex
operations on them.

Convert all functions in TargetExt and WorkExt to use to_/from_le_bytes
instead of directly constructing or accessing the inner U256.

Split Target and Work in to extension traits

In order to reduce the move to units to a simple type definition, the
existing logic in bitcoin's pow module needs to be moved into
extension traits.

from_compact is required for the From impl for CompactTarget to Target,
and as such, is retained in the Target impl.
to_compact_lossy is retained as the inverse operation for from_compact.

Introduce TargetExt and WorkExt extension traits and move most struct
content into them.

Move U256 to shared include and use include! in pow

As part of stabilising the proof-of-work types, various functionality
needs to be computed in bitcoin without access to the inner type.
Since U256 should not be in the public API, the U256 struct logic
needs to be (at least partially) duplicated. In order to avoid having
multiple direct copies of the same code, we can use the include!
macro with a shared file.

Add include/u256.rs and move U256 struct definition to it. Use
include! to retain the logic in bitcoin's pow module.

Split hex parsing on U256 into a second impl

The hex parsing on U256 is only used for the constructors of the Target
and Work types. Since we want to remove the From impls on the hex
errors, we need to remove the usage of them from outside of units.
Since U256 will be a shared module, we need to break out the hex parsing
into a separate impl that we can eventually move into units.

Introduce a second U256 impl and move hex parsing functionality from
U256 into it.

Remove hex_conservative from U256 serde

The serde implementation for U256 relies on hex_conservative features
for the human readable implementation. Since units won't always have
access to the hex_conservative crate, it's better to change the serde
implementation to function without it.

Replace hex parsing to use units::parse_int module instead of
hex_conservative for U256 serde implementation.

benches: benchmark merkle root computation

benchmark with consecutive odd and even counts to calculate the
cost of adding the last transaction in the odd case

Exclude aarch64-gated merkle code from mutation

the new batched merkle root functions are behind
cfg(target_arch = "aarch64") and are not compiled on the x86_64
CI runner, which cause these mutants to appear

exclude these mutants until x86 SIMD support lands (#5540)

primitives: add test comparing batch and stacked-based merkle root

compare the old stack-based approach to calculate the merkle root
against the new batched level-by-level approach.

primitives: use optimized sha256d for 64-byte in merkle root computation

currently we are using stack-based approach to calculate the root.
instead of that, we can batch all pairs at each tree level into one
`hash_64_many()` call

we gate this for aarch64 to use the new batched algorithm. We will
widen to support x86 once we add a 2-way SHA-NI implementation.

for no-alloc we will always keep using the old stack-based approach

Re-export locktime encoders and decoders

For all `units::foo::Foo` there should exist a `primitives::foo::Foo`
and `bitcoin::foo::Foo`. We forgot about the new locktime encoding
types.

FTR we have issue #5969 to investigate how this happened.

Remove public re-exports of old consenus traits

In the `absolute` module for some reason we publicly re-export the old
consensus encoding traits. This is unusual and wrong.

Uncovered in discussion between Andrew and Nymius on PR 5965

Remove the public re-export but keep the import statement.