Merge rust-bitcoin#3155: Extension trait for Script

0857697 Replace impl blocks with extension traits (Martin Habovstiak)
b99bdcf Format `Script` blocks (Martin Habovstiak)
b027edf Wrap `Script` impl blocks in temporary modules (Martin Habovstiak)
5a46154 Separate private `Script` methods (Martin Habovstiak)
27adc09 Generalize fn params in `define_extension_trait` (Martin Habovstiak)
fcc3cb0 Support non-doc attrs in extension trait macro (Martin Habovstiak)
ca1735f Separate POD methods (Tobin C. Harding)

Pull request description:

  This moves methods from `Script` to extension traits in steps that should be easy to follow.

  Moving to `primitives` requires doing the same with `ScriptBuf` so I'm holding off until this approach gets concept ACK (or alternatively someone else can do it :))

  Closes rust-bitcoin#3161

ACKs for top commit:
  tcharding:
    ACK 0857697
  apoelstra:
    ACK 0857697 successfully ran local tests

Tree-SHA512: 3768d879e36139cf971c1921d3236141cbe87d707fd4bab7852f6ed8857b7867fa4146dfe720bd54e3d8cc50ecdc93886a10254cf9a82246358253f0312ffb47

Author: apoelstra

bitcoin/examples/sighash.rs

@@ -1,4 +1,5 @@
 use bitcoin::address::script_pubkey::ScriptBufExt as _;
+use bitcoin::script::ScriptExt as _;
 use bitcoin::{
     consensus, ecdsa, sighash, Amount, CompressedPublicKey, Script, ScriptBuf, Transaction,
 };

bitcoin/examples/taproot-psbt.rs

@@ -84,6 +84,7 @@ use bitcoin::consensus::encode;
 use bitcoin::key::{TapTweak, XOnlyPublicKey};
 use bitcoin::opcodes::all::{OP_CHECKSIG, OP_CLTV, OP_DROP};
 use bitcoin::psbt::{self, Input, Output, Psbt, PsbtSighashType};
+use bitcoin::script::ScriptExt as _;
 use bitcoin::secp256k1::Secp256k1;
 use bitcoin::sighash::{self, SighashCache, TapSighash, TapSighashType};
 use bitcoin::taproot::{self, LeafVersion, TapLeafHash, TaprootBuilder, TaprootSpendInfo};

bitcoin/src/address/mod.rs

@@ -51,7 +51,8 @@ use crate::prelude::{String, ToOwned};
 use crate::script::witness_program::WitnessProgram;
 use crate::script::witness_version::WitnessVersion;
 use crate::script::{
-    self, RedeemScriptSizeError, Script, ScriptBuf, ScriptHash, WScriptHash, WitnessScriptSizeError,
+    self, RedeemScriptSizeError, Script, ScriptBuf, ScriptExt as _, ScriptHash, WScriptHash,
+    WitnessScriptSizeError,
 };
 use crate::taproot::TapNodeHash;
 

bitcoin/src/address/script_pubkey.rs

@@ -13,16 +13,16 @@ use crate::opcodes::all::*;
 use crate::script::witness_program::WitnessProgram;
 use crate::script::witness_version::WitnessVersion;
 use crate::script::{
-    self, Builder, PushBytes, RedeemScriptSizeError, Script, ScriptBuf, ScriptHash, WScriptHash,
-    WitnessScriptSizeError,
+    self, Builder, PushBytes, RedeemScriptSizeError, Script, ScriptBuf, ScriptExt as _, ScriptHash,
+    WScriptHash, WitnessScriptSizeError,
 };
 use crate::taproot::TapNodeHash;
 
 define_extension_trait! {
     /// Extension functionality to add scriptPubkey support to the [`Builder`] type.
     pub trait BuilderExt impl for Builder {
         /// Adds instructions to push a public key onto the stack.
-        fn push_key(self: Self, key: PublicKey) -> Builder {
+        fn push_key(self, key: PublicKey) -> Builder {
             if key.compressed {
                 self.push_slice(key.inner.serialize())
             } else {
@@ -31,7 +31,7 @@ define_extension_trait! {
         }
 
         /// Adds instructions to push an XOnly public key onto the stack.
-        fn push_x_only_key(self: Self, x_only_key: XOnlyPublicKey) -> Builder {
+        fn push_x_only_key(self, x_only_key: XOnlyPublicKey) -> Builder {
             self.push_slice(x_only_key.serialize())
         }
     }
@@ -42,14 +42,14 @@ define_extension_trait! {
     pub trait ScriptExt impl for Script {
         /// Computes the P2WSH output corresponding to this witnessScript (aka the "witness redeem
         /// script").
-        fn to_p2wsh(self: &Self) -> Result<ScriptBuf, WitnessScriptSizeError> {
+        fn to_p2wsh(&self) -> Result<ScriptBuf, WitnessScriptSizeError> {
             self.wscript_hash().map(ScriptBuf::new_p2wsh)
         }
 
         /// Computes P2TR output with a given internal key and a single script spending path equal to
         /// the current script, assuming that the script is a Tapscript.
         fn to_p2tr<C: Verification>(
-            self: &Self,
+            &self,
             secp: &Secp256k1<C>,
             internal_key: UntweakedPublicKey,
         ) -> ScriptBuf {
@@ -59,15 +59,15 @@ define_extension_trait! {
         }
 
         /// Computes the P2SH output corresponding to this redeem script.
-        fn to_p2sh(self: &Self) -> Result<ScriptBuf, RedeemScriptSizeError> {
+        fn to_p2sh(&self) -> Result<ScriptBuf, RedeemScriptSizeError> {
             self.script_hash().map(ScriptBuf::new_p2sh)
         }
 
         /// Returns the script code used for spending a P2WPKH output if this script is a script pubkey
         /// for a P2WPKH output. The `scriptCode` is described in [BIP143].
         ///
         /// [BIP143]: <https://github.com/bitcoin/bips/blob/99701f68a88ce33b2d0838eb84e115cef505b4c2/bip-0143.mediawiki>
-        fn p2wpkh_script_code(self: &Self) -> Option<ScriptBuf> {
+        fn p2wpkh_script_code(&self) -> Option<ScriptBuf> {
             if self.is_p2wpkh() {
                 // The `self` script is 0x00, 0x14, <pubkey_hash>
                 let bytes = &self.as_bytes()[2..];
@@ -82,14 +82,14 @@ define_extension_trait! {
         ///
         /// You can obtain the public key, if its valid,
         /// by calling [`p2pk_public_key()`](Self::p2pk_public_key)
-        fn is_p2pk(self: &Self) -> bool { self.p2pk_pubkey_bytes().is_some() }
+        fn is_p2pk(&self) -> bool { self.p2pk_pubkey_bytes().is_some() }
 
         /// Returns the public key if this script is P2PK with a **valid** public key.
         ///
         /// This may return `None` even when [`is_p2pk()`](Self::is_p2pk) returns true.
         /// This happens when the public key is invalid (e.g. the point not being on the curve).
         /// In this situation the script is unspendable.
-        fn p2pk_public_key(self: &Self) -> Option<PublicKey> {
+        fn p2pk_public_key(&self) -> Option<PublicKey> {
             PublicKey::from_slice(self.p2pk_pubkey_bytes()?).ok()
         }
     }
@@ -98,7 +98,7 @@ define_extension_trait! {
 define_extension_trait! {
     pub(crate) trait ScriptExtPrivate impl for Script {
         /// Returns the bytes of the (possibly invalid) public key if this script is P2PK.
-        fn p2pk_pubkey_bytes(self: &Self) -> Option<&[u8]> {
+        fn p2pk_pubkey_bytes(&self) -> Option<&[u8]> {
             match self.len() {
                 67 if self.as_bytes()[0] == OP_PUSHBYTES_65.to_u8()
                     && self.as_bytes()[66] == OP_CHECKSIG.to_u8() =>

bitcoin/src/bip158.rs

@@ -49,7 +49,7 @@ use crate::consensus::encode::VarInt;
 use crate::consensus::{Decodable, Encodable};
 use crate::internal_macros::impl_hashencode;
 use crate::prelude::{BTreeSet, Borrow, Vec};
-use crate::script::Script;
+use crate::script::{Script, ScriptExt as _};
 use crate::transaction::OutPoint;
 
 /// Golomb encoding parameter as in BIP-158, see also https://gist.github.com/sipa/576d5f09c3b86c3b1b75598d799fc845

bitcoin/src/blockdata/block.rs

@@ -19,8 +19,9 @@ use crate::merkle_tree::{MerkleNode as _, TxMerkleNode, WitnessMerkleNode};
 use crate::network::Params;
 use crate::pow::{CompactTarget, Target, Work};
 use crate::prelude::Vec;
+use crate::script::{self, ScriptExt as _};
 use crate::transaction::{Transaction, Wtxid};
-use crate::{script, VarInt};
+use crate::VarInt;
 
 hashes::hash_newtype! {
     /// A bitcoin block hash.