rust-bitcoin

Make primitives::opcodes pub with pub(crate) content

In preparation for the move of Opcode to primitives, the opcodes module
in primitives will need to be public. Since the existing content is not
supposed to be public, it should all be changed individually to
pub(crate) and gated appropriately.

Make primitives::opcode pub. Make all content of the module pub(crate)
and gate on alloc as needed.

Move as_str outside of all module

The as_str function on Opcode will not be able to be moved to
primitives. As such, it must be modified ahead of time such that it
can be moved to an extension trait.

Introduce pub(super) opcode_to_str in all and move pub as_str
function outside of all module.

Replace all Opcode.code access with to_u8()

The Opcode code field is a private field which holds the u8 value of
the opcode. Since this should not be made public, the functionality
in the OpcodeExt extension trait will need to rely instead on the
public to_u8 function.

Replace all Opcode.code access in OpcodeExt and tests with to_u8().

Remove decoding functionality from HexPrimitive

With all uses of HexPrimitive decoding removed, the ParsePrimitiveError
and decoding functionality on HexPrimitive can be removed.

Delete from_str, and IntoIterator from HexPrimitive and delete
ParsePrimitiveError.

Update API files

Replace HexPrimitive decoding with consensus_encoding

The HexPrimitive type in primitives provides an alloc-less hex str
decoding for types in primitives. Since consensus_encoding now has
the same functionality in decode_from_hex, the entire from_str on
HexPrimitive (and ParsePrimitiveError) can be completely eliminated.

Replace all decoding uses with decode_from_hex in consensus_encoding.
Remove Parse*Error wrappers around ParsePrimitiveError.

Remove HexPrimitive use in ScriptBuf::from_hex_prefixed

Recently, HexPrimitive was used to provide alloc-less decoding of
ScriptBuf in the from_hex_prefixed function on ScriptBuf. With the
stabilisation of consensus_encoding and the alloc-less hex decoding
there, the use of HexPrimitive can be eliminated in favor of a single
call to encoding::decode_from_hex. Further, this eliminates the
single-use error type FromHexError entirely.

Remove script::FromHexError and replace use of HexPrimitive with
consensus_encoding hex decoding for ScriptBuf::from_hex_prefixed.

units: Remove _unchecked parsing function

Remove from the public API the 'unchecked' hex parsing function. This
function is not useful, we proved a prefixed, a non-prefixed, and
'any' (with or without prefix). The 'unchecked' function fails if
there is a prefix so should only be called after first ensuring there
is no prefix. Hence it is a helper function and should not be part of
the public API.

Update the API text files

units: Bump version to 0.5.0

We just removed a set of public functions (parse an integer from hex
`_unchecked` version).

In preparation for release bump the version, upgrade local downstream
crates, add a changelog entry, and update the lock files.

Note on deprecated code:

In #6290 we did the 'final polish before 1.0' including removal of
deprecated code. Hoping that the next release was 1.0 and users could
use `0.4.0` as 1.0 + deprecated stuff.

Now we are going to do `0.5.0` and semver everything possible back
into `0.4.1` so this reasoning still stands. From the changelog it
should be clear also what is going on.

p2p: sequence asserts

The assertion has a needless assignment before it. Move assignment to
be above where the assertion makes sense.

2026-06-14 automated rustfmt nightly

Add #[inline] to all trivial functions in crypto

All functions that are relatively trivial should be annotated with the
inline attribute to hint to the compiler to optimise them by inlining.

Add #[inline] to all small/trivial functions in crypto.

Remove From<Infallible> on inner error types

Inner error types do not appear in the public API, nor does a
From<Infallible> provide any internal purpose.

Remove From<Infallible> from private inner error types in base58 and
units.

primitives: avoid extra reallocation when decoding witness

Decoding a single element larger than ~128 bytes results in 3 allocations.
Instead of reserving the index space in end() we can reserve it at the moement
the last element's data is copied. This reduces the regression we have for the
case of one_element/256 from 42% to 10%.

Ignore reserve() capacity mutant in WitnessDecoder

Only reserves capacity, so no test can catch it

benches: Add witness decode benchmarks

benchmark results compared to master:

- many witness elements: ~45% faster
- one element of diff sizes: 14–27% faster
- chunked input: 6–84% faste

primitives: Simplify and optimize witness decoder

The current logic for the index space in witness decoder lets an
attacker allocate a claimed size without giving any input, which opens
the door to many DoS attacks, some of which we already handle.

But the current code still lets an attacker force a 16 MB allocation
with ~10 bytes of input.

The new logic pushes bytes blindly into `content` without building the
index space in `push_bytes()`, then in `end()` walks through `content`
to build the index space.

This simplifies the code, gives an important speedup, and avoids:

- the 16 MB up-front allocation we currently have for the index space
- `reserve_batch()` is no longer needed, along with the
`MIN_` and `MAX_VECTOR_ALLOCATE` constants

- we can drop the `cursor` field from the decoder
- the DoS vector where an attacker sends a few bytes to force a large
allocation, since the buffer only grows by the bytes actually received

network: Bump version to 1.0.0

In preparation for release add a changelog entry, bump the version
number, update local downstream crates, and update the lock files.

Update the API text files

network: Move serde code down the file

This one is a bit subjective; following the idea that the least
important stuff goes further down the file move `serde` down.

This code move also leaves the `Display` and `FromStr` impls next to
each other, which is nice.

network: Implement From<Infallible> for error type

As is customary add the impl.

network: Put impl block directly under type

As is customary put the impl block for `Network` directly under the
type definition.

Update API files

Remove unused modules from internals

There are two modules, parse and const_tools, that are completely
unused in internals. That is, their defined macros and types are
only ever used within themselves, not even elsewhere within internals.
These modules can be trivially dropped.

Drop parse and const_tools modules from internals.