rust-bitcoin

bitcoin: add "extreme object size" deserialization unit test

As promised in https://github.com/rust-bitcoin/rust-bitcoin/pull/4762

I am not convinced that our decoding of large transactions and blocks is
properly tested to make sure that we don't accidentally start rejecting
very large objects. Add a unit test specifically for this.

Update CHANGELOG.md

rename GenericScript to Script

Now that Script/ScriptBuf are gone we can re-claim the names for the
generic versions. This means that users of the library, after this PR,
*should* have code that largely continues to work. They will need to
replace Script/ScriptBuf with a specific tagged script type in

* function signatures
* places where type inference can't figure it out (which should be
fairly rare, since all the library methods here use specific tags
now, except a couple sighash ones)

primitives: delete Script and ScriptSig

This commit confirms that there is not a single untouched script instance
across the project; every one has been converted to a tagged script.

This triggers a number of doc changes which should have gone into previous
commits. I apologize for that. But it's a PITA to go back and locate exactly
which commit each doc change was supposed to go into.

In bitcoin/src/network/params.rs I changed the signet example to use a
WitnessScript. I wasn't sure if this script is interpreted as a witness
script or a scriptpubkey on Signet itself so I guessed.

In p2p/src/message.rs there is a "script" that is actually just a blob
of raw bytes (that happens to be a script) used in a "test" of the bloom
filter messages. See https://github.com/rust-bitcoin/rust-bitcoin/pull/580
where this was added for discussion about script vs bytes.

(BTW why did I let a bloom filtering PR into this project? This whole
system was a bad idea and a DoS vector. Is it even used?)

primitives: split TapScript and TapScriptBuf from script

Last one :) next commit deletes ScriptBuf and Script.

primitives: split WitnessScript and WitnessScriptBuf from script

Ok, after the previous huge/ugly commits, this one is pretty cathartic.
I introduced the new type, used it for every field named `witness_script`
and all the constructors for `WScriptHash`, chased through all the
compiler bugs, and everything "just worked".

There is one oddity: in BIP143 there is a special-cased scriptcode construction
used for P2SH-wrapped segwit. We have methods that compute this. To make the
types line up (without introducing new traits and generics) I simply typed
the special-case thing as a WitnessScript, since that's what it's pretending
to be. I added a doccomment to all the methods that compute this.

This is a mild abuse of the `WitnessScript` type, since this special-case
object really isn't a witness script (though you could use it as one, and
trick wallets in mostly-harmless ways by doing so ... but this is a bug
in Bitcoin, not in our library!). But only a mild one, and I think it does
a *way* better job of guiding the user through the script-mangling weirdness
around sighashes and p2sh/p2wsh wrapping.

The final tag is TapScript, which will be done in the next commit. Then I
can throw away the Whatever tag, delete `Script`/`ScriptBuf`, and finally
rename `GenericScript`/`GenericScriptBuf` to those names.

bitcoin: use generic script in script::instructions

primitives: split ScriptPubKey and ScriptPubKeyBuf from generic script

There are a couple places where (in Bitcoin, not just this crate) there
is confusion between scriptPubKeys and redeemScripts. Specifically, in
P2SH-wrapped segwit, we put a segwit scriptpubkey into a redeemScript
slot and then it must be treated as both.

The next commit will introduce the RedeemScript type and a trait that
covers both RedeemScript and ScriptPubKey.

Meanwhile, there are a couple methods that belong in this trait, which
in this commit I just implemented for GenericScript<T> for all T:

* in bitcoin/src/crypto/sighash.rs all the sighash methods
* in primitives/src/script/mod.rs the ScriptHash constructors
* in bitcoin/src/script/mod.rs for new_witness_program_unchecked
* in bitcoin/src/script/borrowed.rs for all the p2sh methods
* in bitcoin/src/script/owned.rs for the new_p2wpkh constructor

In the next commit we will tighten these so that they are only applicable
to the two types RedeemScript and ScriptPubKey. (Really, we want to
tighten them so that they're applicable only to RedeemScript and some
more-specific SegwitV0ScriptPubKey type. But I think that would be a
bridge too far: if we had multiple scriptpubkey types then what would
we put in TxOut::script_pubkey?)

primitives: split RedeemScript and RedeemScriptBuf from script

There were multiple places in bitcoin/src/blockdata/script/tests.rs
where we were being sloppy and reinterpreting redeem scripts as
witness scripts and vice-versa. I am happy to say these no longer
compile :).

This completes the hard part of script tagging -- we still need to
add WitnessScript and TapScript, but these are part of "modern"
Bitcoin and therefore aren't randomly cast to/from other script types.

primitives: split ScriptSig and ScriptSigBuf from Script and ScriptBuf

Adds an extension trait ScriptSigExt with a single method, redeem_script,
which isn't used anywhere (or even tested) but seems useful enough so
we'll keep it.

Regarding extension traits: annoyingly I need to add a new extension trait
for every tagged script. In a sensible language I could just use the
existing trait and stick `where Tag == ScriptSigTag` onto the methods
that were specific to script sigs, but Rust is not sensible. It has a
fractal surface area where there is no part of the syntax that you can
ever understand all the rules of.

Anyway there is an 11-year-old tracking issue for this
https://github.com/rust-lang/rust/issues/20041

bitcoin: move hex and PSBT decoding from ScriptBufExt to GenericScriptBufExt

These things apply to all script buffer types and belong in the generic
trait.

bitcoin: make script::Builder generic

Required updating the extension trait macro to add generics, and splitting
out some methods on the Script/ScriptBuf extension traits into new
GenericScript / GenericScriptBuf extension traits.

I did not do this in a principled way; I just moved the minimum set of
functions I needed to make the generic script builder compile.

put generics onto GenericScript and GenericScriptBuf

...still no visible API changes outside primitives, because outside primitives
we are using Script/ScriptBuf (which are secretly GenericScript{,Buf}<Whatever>)
which are unchanged.

In the following commits we will start using GenericScript{,Buf} directly for
generic script methods, and then start defining new specific script types.

run cargo fmt

primitives: rename Script{Buf,} to GenericScript{Buf,}

...and add type aliases to the old names so that the change is invisible
outside of primitives.

Done by search-and-replace on the three files in the script/ tree, and then
reversing the search-and-replace on the tests module and the stuff related
to scripthashes. (In the next commit we will add generics to these types,
and we will want our tests and API test to continue using specific types.
Changing them to be generic would be a lot of noise, and premature. For
the script hashes, there are specific types these should be implemented
on; we don't want them to be generic even if it were possible in a nice
way.)

At the end of this PR we will undo this rename. But we want to be sure that
every single instance of `Script` and `ScriptBuf` are replaced by a more
specific type, and by using these names for `GenericScript<Whatever>`, a
"specific type" that we'll delete at the end of the PR, we can identify
all of them.

define_extension_trait: allow 'where T: Bound' and `where T = Type` clauses on methods

Later in this PR we are going to gate some script methods on a subtrait of their tag.
In particular, there are some methods related to sighash computation and P2SH-wrapped
segwit which require us to treat redeem scripts and witness scripts as similar things,
even though they will be different types.

define_extension_trait: allow impls on generic types

Update message_network.rs

Fix SerializedSignature iteration stack overflow

Manually print InvalidChecksum error

Currently the `ParseError` is a mess. The correct fix is likely to use
an associated type in `Decodable` for the error but that can wait.

Right now we are using `hex` in the `Display` impl for `ParseError`.
This will cause trouble when we move the error type to
`consenus_encoding` because `hex` is a feature.

Just manually print hex characters by accessing the array. Logic is
already tested with a static string, this patch does not change the
output.

Add regression tests for Display of ParseError

Done in preparation for patching the `Display` impl of `ParseError` to
manually print hex.

Add a regression test.

Do trivial import clean up

Refactor only, no logic changes.

Add dependency policy doc

Add a document for evaluating dependencies vs NIH'ing functionality.
Content pulled out of

https://github.com/rust-bitcoin/rust-bitcoin/discussions/1243

build(deps): bump actions/checkout from 4 to 5

Bumps [actions/checkout](https://github.com/actions/checkout) from 4 to 5.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4...v5)

---
updated-dependencies:
- dependency-name: actions/checkout
dependency-version: '5'
dependency-type: direct:production
update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

primitives: Add Tobin to the authors list

I/we have been directly or indirectly working on the `primitives`
crate for at least two years. Shortly (TM) we will be doing the first
`v1.0` RC release. Take accountability for it and add my name to the
authors list.

"Code is a liability not an asset"