From b368384317ba32f8714b92262d9091e4b0d25604 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 13 Aug 2024 06:23:28 +1000
Subject: [PATCH 1/8] Separate ScriptBuf POD methods

In preparation for moving the `ScriptBuf` as a plain old datatype to
`primitives`; separate the POD methods into their own impl block.

Refactor only, no logic changes.
---
 bitcoin/src/blockdata/script/owned.rs | 50 ++++++++++++++-------------
 1 file changed, 26 insertions(+), 24 deletions(-)

diff --git a/bitcoin/src/blockdata/script/owned.rs b/bitcoin/src/blockdata/script/owned.rs
index a6d283729..43f645e40 100644
--- a/bitcoin/src/blockdata/script/owned.rs
+++ b/bitcoin/src/blockdata/script/owned.rs
@@ -64,6 +64,32 @@ impl ScriptBuf {
     /// Returns a mutable reference to unsized script.
     pub fn as_mut_script(&mut self) -> &mut Script { Script::from_bytes_mut(&mut self.0) }
 
+    /// Converts byte vector into script.
+    ///
+    /// This method doesn't (re)allocate.
+    pub fn from_bytes(bytes: Vec<u8>) -> Self { ScriptBuf(bytes) }
+
+    /// Converts the script into a byte vector.
+    ///
+    /// This method doesn't (re)allocate.
+    pub fn into_bytes(self) -> Vec<u8> { self.0 }
+
+    /// Converts this `ScriptBuf` into a [boxed](Box) [`Script`].
+    ///
+    /// This method reallocates if the capacity is greater than length of the script but should not
+    /// when they are equal. If you know beforehand that you need to create a script of exact size
+    /// use [`reserve_exact`](Self::reserve_exact) before adding data to the script so that the
+    /// reallocation can be avoided.
+    #[must_use = "`self` will be dropped if the result is not used"]
+    #[inline]
+    pub fn into_boxed_script(self) -> Box<Script> {
+        // Copied from PathBuf::into_boxed_path
+        let rw = Box::into_raw(self.0.into_boxed_slice()) as *mut Script;
+        unsafe { Box::from_raw(rw) }
+    }
+}
+
+impl ScriptBuf {
     /// Creates a new script builder
     pub fn builder() -> Builder { Builder::new() }
 
@@ -78,16 +104,6 @@ impl ScriptBuf {
         Ok(ScriptBuf::from_bytes(v))
     }
 
-    /// Converts byte vector into script.
-    ///
-    /// This method doesn't (re)allocate.
-    pub fn from_bytes(bytes: Vec<u8>) -> Self { ScriptBuf(bytes) }
-
-    /// Converts the script into a byte vector.
-    ///
-    /// This method doesn't (re)allocate.
-    pub fn into_bytes(self) -> Vec<u8> { self.0 }
-
     /// Adds a single opcode to the script.
     pub fn push_opcode(&mut self, data: Opcode) { self.0.push(data.to_u8()); }
 
@@ -188,20 +204,6 @@ impl ScriptBuf {
             None => self.push_opcode(OP_VERIFY),
         }
     }
-
-    /// Converts this `ScriptBuf` into a [boxed](Box) [`Script`].
-    ///
-    /// This method reallocates if the capacity is greater than length of the script but should not
-    /// when they are equal. If you know beforehand that you need to create a script of exact size
-    /// use [`reserve_exact`](Self::reserve_exact) before adding data to the script so that the
-    /// reallocation can be avoided.
-    #[must_use = "`self` will be dropped if the result is not used"]
-    #[inline]
-    pub fn into_boxed_script(self) -> Box<Script> {
-        // Copied from PathBuf::into_boxed_path
-        let rw = Box::into_raw(self.0.into_boxed_slice()) as *mut Script;
-        unsafe { Box::from_raw(rw) }
-    }
 }
 
 impl<'a> core::iter::FromIterator<Instruction<'a>> for ScriptBuf {

From 3625d74e8bf564842230b008b1428d1e274a919c Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 18 Aug 2024 07:24:55 +1000
Subject: [PATCH 2/8] Make pub in crate functions pub crate

In preparation for adding a private extension trait change the scope to
`pub(crate)` because the more specific `pub(in ...)` is not currently
supported by our `define_extension_trait` macro.
---
 bitcoin/src/blockdata/script/owned.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bitcoin/src/blockdata/script/owned.rs b/bitcoin/src/blockdata/script/owned.rs
index 43f645e40..2679d5ae2 100644
--- a/bitcoin/src/blockdata/script/owned.rs
+++ b/bitcoin/src/blockdata/script/owned.rs
@@ -144,7 +144,7 @@ impl ScriptBuf {
     }
 
     /// Computes the sum of `len` and the length of an appropriate push opcode.
-    pub(in crate::blockdata::script) fn reserved_len_for_slice(len: usize) -> usize {
+    pub(crate) fn reserved_len_for_slice(len: usize) -> usize {
         len + match len {
             0..=0x4b => 1,
             0x4c..=0xff => 2,
@@ -195,7 +195,7 @@ impl ScriptBuf {
     /// alternative.
     ///
     /// See the public fn [`Self::scan_and_push_verify`] to learn more.
-    pub(in crate::blockdata::script) fn push_verify(&mut self, last_opcode: Option<Opcode>) {
+    pub(crate) fn push_verify(&mut self, last_opcode: Option<Opcode>) {
         match opcode_to_verify(last_opcode) {
             Some(opcode) => {
                 self.0.pop();

From 1001a33f19c9d78c274fbac8f6c4de7d850c16ee Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 18 Aug 2024 07:30:11 +1000
Subject: [PATCH 3/8] Add second ScriptBuf impl block

In preparation for adding two script buf extension traits; move the
private `ScriptBuf` functions into a separate impl block.

Code move only.
---
 bitcoin/src/blockdata/script/owned.rs | 76 ++++++++++++++-------------
 1 file changed, 39 insertions(+), 37 deletions(-)

diff --git a/bitcoin/src/blockdata/script/owned.rs b/bitcoin/src/blockdata/script/owned.rs
index 2679d5ae2..49613a25d 100644
--- a/bitcoin/src/blockdata/script/owned.rs
+++ b/bitcoin/src/blockdata/script/owned.rs
@@ -114,6 +114,45 @@ impl ScriptBuf {
         self.push_slice_no_opt(data);
     }
 
+    /// Add a single instruction to the script.
+    ///
+    /// # Panics
+    ///
+    /// The method panics if the instruction is a data push with length greater or equal to
+    /// 0x100000000.
+    pub fn push_instruction(&mut self, instruction: Instruction<'_>) {
+        match instruction {
+            Instruction::Op(opcode) => self.push_opcode(opcode),
+            Instruction::PushBytes(bytes) => self.push_slice(bytes),
+        }
+    }
+
+    /// Like push_instruction, but avoids calling `reserve` to not re-check the length.
+    pub fn push_instruction_no_opt(&mut self, instruction: Instruction<'_>) {
+        match instruction {
+            Instruction::Op(opcode) => self.push_opcode(opcode),
+            Instruction::PushBytes(bytes) => self.push_slice_no_opt(bytes),
+        }
+    }
+
+    /// Adds an `OP_VERIFY` to the script or replaces the last opcode with VERIFY form.
+    ///
+    /// Some opcodes such as `OP_CHECKSIG` have a verify variant that works as if `VERIFY` was
+    /// in the script right after. To save space this function appends `VERIFY` only if
+    /// the most-recently-added opcode *does not* have an alternate `VERIFY` form. If it does
+    /// the last opcode is replaced. E.g., `OP_CHECKSIG` will become `OP_CHECKSIGVERIFY`.
+    ///
+    /// Note that existing `OP_*VERIFY` opcodes do not lead to the instruction being ignored
+    /// because `OP_VERIFY` consumes an item from the stack so ignoring them would change the
+    /// semantics.
+    ///
+    /// This function needs to iterate over the script to find the last instruction. Prefer
+    /// `Builder` if you're creating the script from scratch or if you want to push `OP_VERIFY`
+    /// multiple times.
+    pub fn scan_and_push_verify(&mut self) { self.push_verify(self.last_opcode()); }
+}
+
+impl ScriptBuf {
     /// Pushes the slice without reserving
     fn push_slice_no_opt(&mut self, data: &PushBytes) {
         // Start with a PUSH opcode
@@ -154,43 +193,6 @@ impl ScriptBuf {
         }
     }
 
-    /// Add a single instruction to the script.
-    ///
-    /// # Panics
-    ///
-    /// The method panics if the instruction is a data push with length greater or equal to
-    /// 0x100000000.
-    pub fn push_instruction(&mut self, instruction: Instruction<'_>) {
-        match instruction {
-            Instruction::Op(opcode) => self.push_opcode(opcode),
-            Instruction::PushBytes(bytes) => self.push_slice(bytes),
-        }
-    }
-
-    /// Like push_instruction, but avoids calling `reserve` to not re-check the length.
-    pub fn push_instruction_no_opt(&mut self, instruction: Instruction<'_>) {
-        match instruction {
-            Instruction::Op(opcode) => self.push_opcode(opcode),
-            Instruction::PushBytes(bytes) => self.push_slice_no_opt(bytes),
-        }
-    }
-
-    /// Adds an `OP_VERIFY` to the script or replaces the last opcode with VERIFY form.
-    ///
-    /// Some opcodes such as `OP_CHECKSIG` have a verify variant that works as if `VERIFY` was
-    /// in the script right after. To save space this function appends `VERIFY` only if
-    /// the most-recently-added opcode *does not* have an alternate `VERIFY` form. If it does
-    /// the last opcode is replaced. E.g., `OP_CHECKSIG` will become `OP_CHECKSIGVERIFY`.
-    ///
-    /// Note that existing `OP_*VERIFY` opcodes do not lead to the instruction being ignored
-    /// because `OP_VERIFY` consumes an item from the stack so ignoring them would change the
-    /// semantics.
-    ///
-    /// This function needs to iterate over the script to find the last instruction. Prefer
-    /// `Builder` if you're creating the script from scratch or if you want to push `OP_VERIFY`
-    /// multiple times.
-    pub fn scan_and_push_verify(&mut self) { self.push_verify(self.last_opcode()); }
-
     /// Adds an `OP_VERIFY` to the script or changes the most-recently-added opcode to `VERIFY`
     /// alternative.
     ///

From c81fb933595d707204cff22603c659e62b016793 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 18 Aug 2024 07:40:01 +1000
Subject: [PATCH 4/8] Make push_slice_no_opt pub(crate)

In preparation for adding script buf extension make the
`push_slice_no_opt` have the same scope as the other private functions,
this will be the scope of the private extension trait.
---
 bitcoin/src/blockdata/script/owned.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/blockdata/script/owned.rs b/bitcoin/src/blockdata/script/owned.rs
index 49613a25d..1bce8a28d 100644
--- a/bitcoin/src/blockdata/script/owned.rs
+++ b/bitcoin/src/blockdata/script/owned.rs
@@ -154,7 +154,7 @@ impl ScriptBuf {
 
 impl ScriptBuf {
     /// Pushes the slice without reserving
-    fn push_slice_no_opt(&mut self, data: &PushBytes) {
+    pub(crate) fn push_slice_no_opt(&mut self, data: &PushBytes) {
         // Start with a PUSH opcode
         match data.len().to_u64() {
             n if n < opcodes::Ordinary::OP_PUSHDATA1 as u64 => {

From 4ff5d6886bc955ce8c14cbdea318656ce7e821ca Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 18 Aug 2024 07:45:49 +1000
Subject: [PATCH 5/8] Add private ScriptBufAsVec type

Add a private type that allows us to mutate the inner vector of a
`ScriptBuf` only using public functions and never touching the inner
field.

Done in preparation for moving the `ScriptBuf` to `primitives`.

Mad hackery by Kix!
---
 bitcoin/src/blockdata/script/owned.rs | 65 +++++++++++++++++++++------
 1 file changed, 51 insertions(+), 14 deletions(-)

diff --git a/bitcoin/src/blockdata/script/owned.rs b/bitcoin/src/blockdata/script/owned.rs
index 1bce8a28d..abfcc2529 100644
--- a/bitcoin/src/blockdata/script/owned.rs
+++ b/bitcoin/src/blockdata/script/owned.rs
@@ -105,7 +105,7 @@ impl ScriptBuf {
     }
 
     /// Adds a single opcode to the script.
-    pub fn push_opcode(&mut self, data: Opcode) { self.0.push(data.to_u8()); }
+    pub fn push_opcode(&mut self, data: Opcode) { self.as_byte_vec().push(data.to_u8()); }
 
     /// Adds instructions to push some arbitrary data onto the stack.
     pub fn push_slice<T: AsRef<PushBytes>>(&mut self, data: T) {
@@ -153,33 +153,42 @@ impl ScriptBuf {
 }
 
 impl ScriptBuf {
+    /// Pretends to convert `&mut ScriptBuf` to `&mut Vec<u8>` so that it can be modified.
+    ///
+    /// Note: if the returned value leaks the original `ScriptBuf` will become empty.
+    pub(crate) fn as_byte_vec(&mut self) -> ScriptBufAsVec<'_> {
+        let vec = core::mem::take(self).into_bytes();
+        ScriptBufAsVec(self, vec)
+    }
+
     /// Pushes the slice without reserving
     pub(crate) fn push_slice_no_opt(&mut self, data: &PushBytes) {
+        let mut this = self.as_byte_vec();
         // Start with a PUSH opcode
         match data.len().to_u64() {
             n if n < opcodes::Ordinary::OP_PUSHDATA1 as u64 => {
-                self.0.push(n as u8);
+                this.push(n as u8);
             }
             n if n < 0x100 => {
-                self.0.push(opcodes::Ordinary::OP_PUSHDATA1.to_u8());
-                self.0.push(n as u8);
+                this.push(opcodes::Ordinary::OP_PUSHDATA1.to_u8());
+                this.push(n as u8);
             }
             n if n < 0x10000 => {
-                self.0.push(opcodes::Ordinary::OP_PUSHDATA2.to_u8());
-                self.0.push((n % 0x100) as u8);
-                self.0.push((n / 0x100) as u8);
+                this.push(opcodes::Ordinary::OP_PUSHDATA2.to_u8());
+                this.push((n % 0x100) as u8);
+                this.push((n / 0x100) as u8);
             }
             // `PushBytes` enforces len < 0x100000000
             n => {
-                self.0.push(opcodes::Ordinary::OP_PUSHDATA4.to_u8());
-                self.0.push((n % 0x100) as u8);
-                self.0.push(((n / 0x100) % 0x100) as u8);
-                self.0.push(((n / 0x10000) % 0x100) as u8);
-                self.0.push((n / 0x1000000) as u8);
+                this.push(opcodes::Ordinary::OP_PUSHDATA4.to_u8());
+                this.push((n % 0x100) as u8);
+                this.push(((n / 0x100) % 0x100) as u8);
+                this.push(((n / 0x10000) % 0x100) as u8);
+                this.push((n / 0x1000000) as u8);
             }
         }
         // Then push the raw bytes
-        self.0.extend_from_slice(data.as_bytes());
+        this.extend_from_slice(data.as_bytes());
     }
 
     /// Computes the sum of `len` and the length of an appropriate push opcode.
@@ -200,7 +209,7 @@ impl ScriptBuf {
     pub(crate) fn push_verify(&mut self, last_opcode: Option<Opcode>) {
         match opcode_to_verify(last_opcode) {
             Some(opcode) => {
-                self.0.pop();
+                self.as_byte_vec().pop();
                 self.push_opcode(opcode);
             }
             None => self.push_opcode(OP_VERIFY),
@@ -254,3 +263,31 @@ impl<'a> Extend<Instruction<'a>> for ScriptBuf {
         }
     }
 }
+
+/// Pretends that this is a mutable reference to [`ScriptBuf`]'s internal buffer.
+///
+/// In reality the backing `Vec<u8>` is swapped with an empty one and this is holding both the
+/// reference and the vec. The vec is put back when this drops so it also covers paics. (But not
+/// leaks, which is OK since we never leak.)
+pub(crate) struct ScriptBufAsVec<'a>(&'a mut ScriptBuf, Vec<u8>);
+
+impl<'a> core::ops::Deref for ScriptBufAsVec<'a> {
+    type Target = Vec<u8>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.1
+    }
+}
+
+impl<'a> core::ops::DerefMut for ScriptBufAsVec<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.1
+    }
+}
+
+impl<'a> Drop for ScriptBufAsVec<'a> {
+    fn drop(&mut self) {
+        let vec = core::mem::take(&mut self.1);
+        *(self.0) = ScriptBuf::from_bytes(vec);
+    }
+}

From 3fdc574851314b6d50f103ac1f499e3fa9e77d49 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 18 Aug 2024 07:50:06 +1000
Subject: [PATCH 6/8] Add temporary script buf modules

In order to use the formatter to mechanically indent code ready for
adding two extension traits; add two temporary modules.
---
 bitcoin/src/blockdata/script/owned.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/bitcoin/src/blockdata/script/owned.rs b/bitcoin/src/blockdata/script/owned.rs
index abfcc2529..bf1e59a6b 100644
--- a/bitcoin/src/blockdata/script/owned.rs
+++ b/bitcoin/src/blockdata/script/owned.rs
@@ -89,6 +89,8 @@ impl ScriptBuf {
     }
 }
 
+mod tmp_pub {
+    use super::*;
 impl ScriptBuf {
     /// Creates a new script builder
     pub fn builder() -> Builder { Builder::new() }
@@ -151,7 +153,10 @@ impl ScriptBuf {
     /// multiple times.
     pub fn scan_and_push_verify(&mut self) { self.push_verify(self.last_opcode()); }
 }
+}
 
+mod tmp_priv {
+    use super::*;
 impl ScriptBuf {
     /// Pretends to convert `&mut ScriptBuf` to `&mut Vec<u8>` so that it can be modified.
     ///
@@ -216,6 +221,7 @@ impl ScriptBuf {
         }
     }
 }
+}
 
 impl<'a> core::iter::FromIterator<Instruction<'a>> for ScriptBuf {
     fn from_iter<T>(iter: T) -> Self

From ae0a5bd64aa0acf7226276bad04202cd0d94f7dd Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 18 Aug 2024 07:51:09 +1000
Subject: [PATCH 7/8] Run cargo fmt

Run the formatter and commit only the changes to `owned`, no other
changes.
---
 bitcoin/src/blockdata/script/owned.rs | 234 +++++++++++++-------------
 1 file changed, 115 insertions(+), 119 deletions(-)

diff --git a/bitcoin/src/blockdata/script/owned.rs b/bitcoin/src/blockdata/script/owned.rs
index bf1e59a6b..4026581e3 100644
--- a/bitcoin/src/blockdata/script/owned.rs
+++ b/bitcoin/src/blockdata/script/owned.rs
@@ -91,137 +91,137 @@ impl ScriptBuf {
 
 mod tmp_pub {
     use super::*;
-impl ScriptBuf {
-    /// Creates a new script builder
-    pub fn builder() -> Builder { Builder::new() }
+    impl ScriptBuf {
+        /// Creates a new script builder
+        pub fn builder() -> Builder { Builder::new() }
 
-    /// Generates OP_RETURN-type of scriptPubkey for the given data.
-    pub fn new_op_return<T: AsRef<PushBytes>>(data: T) -> Self {
-        Builder::new().push_opcode(OP_RETURN).push_slice(data).into_script()
-    }
-
-    /// Creates a [`ScriptBuf`] from a hex string.
-    pub fn from_hex(s: &str) -> Result<Self, hex::HexToBytesError> {
-        let v = Vec::from_hex(s)?;
-        Ok(ScriptBuf::from_bytes(v))
-    }
-
-    /// Adds a single opcode to the script.
-    pub fn push_opcode(&mut self, data: Opcode) { self.as_byte_vec().push(data.to_u8()); }
-
-    /// Adds instructions to push some arbitrary data onto the stack.
-    pub fn push_slice<T: AsRef<PushBytes>>(&mut self, data: T) {
-        let data = data.as_ref();
-        self.reserve(Self::reserved_len_for_slice(data.len()));
-        self.push_slice_no_opt(data);
-    }
-
-    /// Add a single instruction to the script.
-    ///
-    /// # Panics
-    ///
-    /// The method panics if the instruction is a data push with length greater or equal to
-    /// 0x100000000.
-    pub fn push_instruction(&mut self, instruction: Instruction<'_>) {
-        match instruction {
-            Instruction::Op(opcode) => self.push_opcode(opcode),
-            Instruction::PushBytes(bytes) => self.push_slice(bytes),
+        /// Generates OP_RETURN-type of scriptPubkey for the given data.
+        pub fn new_op_return<T: AsRef<PushBytes>>(data: T) -> Self {
+            Builder::new().push_opcode(OP_RETURN).push_slice(data).into_script()
         }
-    }
 
-    /// Like push_instruction, but avoids calling `reserve` to not re-check the length.
-    pub fn push_instruction_no_opt(&mut self, instruction: Instruction<'_>) {
-        match instruction {
-            Instruction::Op(opcode) => self.push_opcode(opcode),
-            Instruction::PushBytes(bytes) => self.push_slice_no_opt(bytes),
+        /// Creates a [`ScriptBuf`] from a hex string.
+        pub fn from_hex(s: &str) -> Result<Self, hex::HexToBytesError> {
+            let v = Vec::from_hex(s)?;
+            Ok(ScriptBuf::from_bytes(v))
         }
-    }
 
-    /// Adds an `OP_VERIFY` to the script or replaces the last opcode with VERIFY form.
-    ///
-    /// Some opcodes such as `OP_CHECKSIG` have a verify variant that works as if `VERIFY` was
-    /// in the script right after. To save space this function appends `VERIFY` only if
-    /// the most-recently-added opcode *does not* have an alternate `VERIFY` form. If it does
-    /// the last opcode is replaced. E.g., `OP_CHECKSIG` will become `OP_CHECKSIGVERIFY`.
-    ///
-    /// Note that existing `OP_*VERIFY` opcodes do not lead to the instruction being ignored
-    /// because `OP_VERIFY` consumes an item from the stack so ignoring them would change the
-    /// semantics.
-    ///
-    /// This function needs to iterate over the script to find the last instruction. Prefer
-    /// `Builder` if you're creating the script from scratch or if you want to push `OP_VERIFY`
-    /// multiple times.
-    pub fn scan_and_push_verify(&mut self) { self.push_verify(self.last_opcode()); }
-}
+        /// Adds a single opcode to the script.
+        pub fn push_opcode(&mut self, data: Opcode) { self.as_byte_vec().push(data.to_u8()); }
+
+        /// Adds instructions to push some arbitrary data onto the stack.
+        pub fn push_slice<T: AsRef<PushBytes>>(&mut self, data: T) {
+            let data = data.as_ref();
+            self.reserve(Self::reserved_len_for_slice(data.len()));
+            self.push_slice_no_opt(data);
+        }
+
+        /// Add a single instruction to the script.
+        ///
+        /// # Panics
+        ///
+        /// The method panics if the instruction is a data push with length greater or equal to
+        /// 0x100000000.
+        pub fn push_instruction(&mut self, instruction: Instruction<'_>) {
+            match instruction {
+                Instruction::Op(opcode) => self.push_opcode(opcode),
+                Instruction::PushBytes(bytes) => self.push_slice(bytes),
+            }
+        }
+
+        /// Like push_instruction, but avoids calling `reserve` to not re-check the length.
+        pub fn push_instruction_no_opt(&mut self, instruction: Instruction<'_>) {
+            match instruction {
+                Instruction::Op(opcode) => self.push_opcode(opcode),
+                Instruction::PushBytes(bytes) => self.push_slice_no_opt(bytes),
+            }
+        }
+
+        /// Adds an `OP_VERIFY` to the script or replaces the last opcode with VERIFY form.
+        ///
+        /// Some opcodes such as `OP_CHECKSIG` have a verify variant that works as if `VERIFY` was
+        /// in the script right after. To save space this function appends `VERIFY` only if
+        /// the most-recently-added opcode *does not* have an alternate `VERIFY` form. If it does
+        /// the last opcode is replaced. E.g., `OP_CHECKSIG` will become `OP_CHECKSIGVERIFY`.
+        ///
+        /// Note that existing `OP_*VERIFY` opcodes do not lead to the instruction being ignored
+        /// because `OP_VERIFY` consumes an item from the stack so ignoring them would change the
+        /// semantics.
+        ///
+        /// This function needs to iterate over the script to find the last instruction. Prefer
+        /// `Builder` if you're creating the script from scratch or if you want to push `OP_VERIFY`
+        /// multiple times.
+        pub fn scan_and_push_verify(&mut self) { self.push_verify(self.last_opcode()); }
+    }
 }
 
 mod tmp_priv {
     use super::*;
-impl ScriptBuf {
-    /// Pretends to convert `&mut ScriptBuf` to `&mut Vec<u8>` so that it can be modified.
-    ///
-    /// Note: if the returned value leaks the original `ScriptBuf` will become empty.
-    pub(crate) fn as_byte_vec(&mut self) -> ScriptBufAsVec<'_> {
-        let vec = core::mem::take(self).into_bytes();
-        ScriptBufAsVec(self, vec)
-    }
+    impl ScriptBuf {
+        /// Pretends to convert `&mut ScriptBuf` to `&mut Vec<u8>` so that it can be modified.
+        ///
+        /// Note: if the returned value leaks the original `ScriptBuf` will become empty.
+        pub(crate) fn as_byte_vec(&mut self) -> ScriptBufAsVec<'_> {
+            let vec = core::mem::take(self).into_bytes();
+            ScriptBufAsVec(self, vec)
+        }
 
-    /// Pushes the slice without reserving
-    pub(crate) fn push_slice_no_opt(&mut self, data: &PushBytes) {
-        let mut this = self.as_byte_vec();
-        // Start with a PUSH opcode
-        match data.len().to_u64() {
-            n if n < opcodes::Ordinary::OP_PUSHDATA1 as u64 => {
-                this.push(n as u8);
+        /// Pushes the slice without reserving
+        pub(crate) fn push_slice_no_opt(&mut self, data: &PushBytes) {
+            let mut this = self.as_byte_vec();
+            // Start with a PUSH opcode
+            match data.len().to_u64() {
+                n if n < opcodes::Ordinary::OP_PUSHDATA1 as u64 => {
+                    this.push(n as u8);
+                }
+                n if n < 0x100 => {
+                    this.push(opcodes::Ordinary::OP_PUSHDATA1.to_u8());
+                    this.push(n as u8);
+                }
+                n if n < 0x10000 => {
+                    this.push(opcodes::Ordinary::OP_PUSHDATA2.to_u8());
+                    this.push((n % 0x100) as u8);
+                    this.push((n / 0x100) as u8);
+                }
+                // `PushBytes` enforces len < 0x100000000
+                n => {
+                    this.push(opcodes::Ordinary::OP_PUSHDATA4.to_u8());
+                    this.push((n % 0x100) as u8);
+                    this.push(((n / 0x100) % 0x100) as u8);
+                    this.push(((n / 0x10000) % 0x100) as u8);
+                    this.push((n / 0x1000000) as u8);
+                }
             }
-            n if n < 0x100 => {
-                this.push(opcodes::Ordinary::OP_PUSHDATA1.to_u8());
-                this.push(n as u8);
-            }
-            n if n < 0x10000 => {
-                this.push(opcodes::Ordinary::OP_PUSHDATA2.to_u8());
-                this.push((n % 0x100) as u8);
-                this.push((n / 0x100) as u8);
-            }
-            // `PushBytes` enforces len < 0x100000000
-            n => {
-                this.push(opcodes::Ordinary::OP_PUSHDATA4.to_u8());
-                this.push((n % 0x100) as u8);
-                this.push(((n / 0x100) % 0x100) as u8);
-                this.push(((n / 0x10000) % 0x100) as u8);
-                this.push((n / 0x1000000) as u8);
+            // Then push the raw bytes
+            this.extend_from_slice(data.as_bytes());
+        }
+
+        /// Computes the sum of `len` and the length of an appropriate push opcode.
+        pub(crate) fn reserved_len_for_slice(len: usize) -> usize {
+            len + match len {
+                0..=0x4b => 1,
+                0x4c..=0xff => 2,
+                0x100..=0xffff => 3,
+                // we don't care about oversized, the other fn will panic anyway
+                _ => 5,
             }
         }
-        // Then push the raw bytes
-        this.extend_from_slice(data.as_bytes());
-    }
 
-    /// Computes the sum of `len` and the length of an appropriate push opcode.
-    pub(crate) fn reserved_len_for_slice(len: usize) -> usize {
-        len + match len {
-            0..=0x4b => 1,
-            0x4c..=0xff => 2,
-            0x100..=0xffff => 3,
-            // we don't care about oversized, the other fn will panic anyway
-            _ => 5,
-        }
-    }
-
-    /// Adds an `OP_VERIFY` to the script or changes the most-recently-added opcode to `VERIFY`
-    /// alternative.
-    ///
-    /// See the public fn [`Self::scan_and_push_verify`] to learn more.
-    pub(crate) fn push_verify(&mut self, last_opcode: Option<Opcode>) {
-        match opcode_to_verify(last_opcode) {
-            Some(opcode) => {
-                self.as_byte_vec().pop();
-                self.push_opcode(opcode);
+        /// Adds an `OP_VERIFY` to the script or changes the most-recently-added opcode to `VERIFY`
+        /// alternative.
+        ///
+        /// See the public fn [`Self::scan_and_push_verify`] to learn more.
+        pub(crate) fn push_verify(&mut self, last_opcode: Option<Opcode>) {
+            match opcode_to_verify(last_opcode) {
+                Some(opcode) => {
+                    self.as_byte_vec().pop();
+                    self.push_opcode(opcode);
+                }
+                None => self.push_opcode(OP_VERIFY),
             }
-            None => self.push_opcode(OP_VERIFY),
         }
     }
 }
-}
 
 impl<'a> core::iter::FromIterator<Instruction<'a>> for ScriptBuf {
     fn from_iter<T>(iter: T) -> Self
@@ -280,15 +280,11 @@ pub(crate) struct ScriptBufAsVec<'a>(&'a mut ScriptBuf, Vec<u8>);
 impl<'a> core::ops::Deref for ScriptBufAsVec<'a> {
     type Target = Vec<u8>;
 
-    fn deref(&self) -> &Self::Target {
-        &self.1
-    }
+    fn deref(&self) -> &Self::Target { &self.1 }
 }
 
 impl<'a> core::ops::DerefMut for ScriptBufAsVec<'a> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.1
-    }
+    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.1 }
 }
 
 impl<'a> Drop for ScriptBufAsVec<'a> {

From 2bb90b82036cf2a90093e6e90398302aa7d3fc81 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 19 Aug 2024 10:37:45 +1000
Subject: [PATCH 8/8] Introduce two extensions traits for ScriptBuf

In preparation for moving the `ScritpBuf` type to `primitives` add a
public and private extension trait for the functions we want to leave
here in `bitcoin`.

Note, includes a change to the `difine_extension_trait` metavariable
used on `$gent` from `ident` to `path` to support the generic
`AsRef<PushBytes>`.
---
 bitcoin/examples/ecdsa-psbt.rs              |  1 +
 bitcoin/examples/taproot-psbt.rs            |  2 +-
 bitcoin/src/address/mod.rs                  |  1 +
 bitcoin/src/blockdata/script/builder.rs     |  2 +-
 bitcoin/src/blockdata/script/instruction.rs |  4 ++-
 bitcoin/src/blockdata/script/owned.rs       | 37 ++++++++++-----------
 bitcoin/src/crypto/ecdsa.rs                 |  2 ++
 bitcoin/src/crypto/sighash.rs               |  1 +
 bitcoin/src/internal_macros.rs              |  2 +-
 bitcoin/src/psbt/mod.rs                     |  2 +-
 bitcoin/src/psbt/serialize.rs               |  1 +
 bitcoin/src/taproot/mod.rs                  |  1 +
 bitcoin/tests/bip_174.rs                    |  2 +-
 bitcoin/tests/serde.rs                      |  1 +
 14 files changed, 34 insertions(+), 25 deletions(-)

diff --git a/bitcoin/examples/ecdsa-psbt.rs b/bitcoin/examples/ecdsa-psbt.rs
index bff17d181..943e0dab9 100644
--- a/bitcoin/examples/ecdsa-psbt.rs
+++ b/bitcoin/examples/ecdsa-psbt.rs
@@ -37,6 +37,7 @@ use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, IntoDerivationPat
 use bitcoin::consensus::encode;
 use bitcoin::locktime::absolute;
 use bitcoin::psbt::{self, Input, Psbt, PsbtSighashType};
+use bitcoin::script::ScriptBufExt as _;
 use bitcoin::secp256k1::{Secp256k1, Signing, Verification};
 use bitcoin::{
     transaction, Address, Amount, CompressedPublicKey, Network, OutPoint, ScriptBuf, Sequence,
diff --git a/bitcoin/examples/taproot-psbt.rs b/bitcoin/examples/taproot-psbt.rs
index 734c096eb..be43816c6 100644
--- a/bitcoin/examples/taproot-psbt.rs
+++ b/bitcoin/examples/taproot-psbt.rs
@@ -84,7 +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::script::{ScriptBufExt as _, ScriptExt as _};
 use bitcoin::secp256k1::Secp256k1;
 use bitcoin::sighash::{self, SighashCache, TapSighash, TapSighashType};
 use bitcoin::taproot::{self, LeafVersion, TapLeafHash, TaprootBuilder, TaprootSpendInfo};
diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index e2495b70e..b41952e7d 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -894,6 +894,7 @@ mod tests {
     use super::*;
     use crate::network::params;
     use crate::network::Network::{Bitcoin, Testnet};
+    use crate::script::ScriptBufExt as _;
 
     fn roundtrips(addr: &Address, network: Network) {
         assert_eq!(
diff --git a/bitcoin/src/blockdata/script/builder.rs b/bitcoin/src/blockdata/script/builder.rs
index 1261266d6..5303d37ef 100644
--- a/bitcoin/src/blockdata/script/builder.rs
+++ b/bitcoin/src/blockdata/script/builder.rs
@@ -7,7 +7,7 @@ use crate::locktime::absolute;
 use crate::opcodes::all::*;
 use crate::opcodes::{self, Opcode};
 use crate::prelude::Vec;
-use crate::script::{ScriptExt as _, ScriptExtPriv as _};
+use crate::script::{ScriptBufExt as _, ScriptExt as _, ScriptExtPriv as _};
 use crate::Sequence;
 
 /// An Object which can be used to construct a script piece by piece.
diff --git a/bitcoin/src/blockdata/script/instruction.rs b/bitcoin/src/blockdata/script/instruction.rs
index 7898d6a7e..8a1865a2b 100644
--- a/bitcoin/src/blockdata/script/instruction.rs
+++ b/bitcoin/src/blockdata/script/instruction.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: CC0-1.0
 
-use super::{read_uint_iter, Error, PushBytes, Script, ScriptBuf, UintError};
+use super::{
+    read_uint_iter, Error, PushBytes, Script, ScriptBuf, ScriptBufExtPriv as _, UintError,
+};
 use crate::opcodes::{self, Opcode};
 
 /// A "parsed opcode" which allows iterating over a [`Script`] in a more sensible way.
diff --git a/bitcoin/src/blockdata/script/owned.rs b/bitcoin/src/blockdata/script/owned.rs
index 4026581e3..3f001818c 100644
--- a/bitcoin/src/blockdata/script/owned.rs
+++ b/bitcoin/src/blockdata/script/owned.rs
@@ -89,30 +89,30 @@ impl ScriptBuf {
     }
 }
 
-mod tmp_pub {
-    use super::*;
-    impl ScriptBuf {
+crate::internal_macros::define_extension_trait! {
+    /// Extension functionality for the [`ScriptBuf`] type.
+    pub trait ScriptBufExt impl for ScriptBuf {
         /// Creates a new script builder
-        pub fn builder() -> Builder { Builder::new() }
+        fn builder() -> Builder { Builder::new() }
 
         /// Generates OP_RETURN-type of scriptPubkey for the given data.
-        pub fn new_op_return<T: AsRef<PushBytes>>(data: T) -> Self {
+        fn new_op_return<T: AsRef<PushBytes>>(data: T) -> Self {
             Builder::new().push_opcode(OP_RETURN).push_slice(data).into_script()
         }
 
         /// Creates a [`ScriptBuf`] from a hex string.
-        pub fn from_hex(s: &str) -> Result<Self, hex::HexToBytesError> {
+        fn from_hex(s: &str) -> Result<ScriptBuf, hex::HexToBytesError> {
             let v = Vec::from_hex(s)?;
             Ok(ScriptBuf::from_bytes(v))
         }
 
         /// Adds a single opcode to the script.
-        pub fn push_opcode(&mut self, data: Opcode) { self.as_byte_vec().push(data.to_u8()); }
+        fn push_opcode(&mut self, data: Opcode) { self.as_byte_vec().push(data.to_u8()); }
 
         /// Adds instructions to push some arbitrary data onto the stack.
-        pub fn push_slice<T: AsRef<PushBytes>>(&mut self, data: T) {
+        fn push_slice<T: AsRef<PushBytes>>(&mut self, data: T) {
             let data = data.as_ref();
-            self.reserve(Self::reserved_len_for_slice(data.len()));
+            self.reserve(ScriptBuf::reserved_len_for_slice(data.len()));
             self.push_slice_no_opt(data);
         }
 
@@ -122,7 +122,7 @@ mod tmp_pub {
         ///
         /// The method panics if the instruction is a data push with length greater or equal to
         /// 0x100000000.
-        pub fn push_instruction(&mut self, instruction: Instruction<'_>) {
+        fn push_instruction(&mut self, instruction: Instruction<'_>) {
             match instruction {
                 Instruction::Op(opcode) => self.push_opcode(opcode),
                 Instruction::PushBytes(bytes) => self.push_slice(bytes),
@@ -130,7 +130,7 @@ mod tmp_pub {
         }
 
         /// Like push_instruction, but avoids calling `reserve` to not re-check the length.
-        pub fn push_instruction_no_opt(&mut self, instruction: Instruction<'_>) {
+        fn push_instruction_no_opt(&mut self, instruction: Instruction<'_>) {
             match instruction {
                 Instruction::Op(opcode) => self.push_opcode(opcode),
                 Instruction::PushBytes(bytes) => self.push_slice_no_opt(bytes),
@@ -151,23 +151,22 @@ mod tmp_pub {
         /// This function needs to iterate over the script to find the last instruction. Prefer
         /// `Builder` if you're creating the script from scratch or if you want to push `OP_VERIFY`
         /// multiple times.
-        pub fn scan_and_push_verify(&mut self) { self.push_verify(self.last_opcode()); }
+        fn scan_and_push_verify(&mut self) { self.push_verify(self.last_opcode()); }
     }
 }
 
-mod tmp_priv {
-    use super::*;
-    impl ScriptBuf {
+crate::internal_macros::define_extension_trait! {
+    pub(crate) trait ScriptBufExtPriv impl for ScriptBuf {
         /// Pretends to convert `&mut ScriptBuf` to `&mut Vec<u8>` so that it can be modified.
         ///
         /// Note: if the returned value leaks the original `ScriptBuf` will become empty.
-        pub(crate) fn as_byte_vec(&mut self) -> ScriptBufAsVec<'_> {
+        fn as_byte_vec(&mut self) -> ScriptBufAsVec<'_> {
             let vec = core::mem::take(self).into_bytes();
             ScriptBufAsVec(self, vec)
         }
 
         /// Pushes the slice without reserving
-        pub(crate) fn push_slice_no_opt(&mut self, data: &PushBytes) {
+        fn push_slice_no_opt(&mut self, data: &PushBytes) {
             let mut this = self.as_byte_vec();
             // Start with a PUSH opcode
             match data.len().to_u64() {
@@ -197,7 +196,7 @@ mod tmp_priv {
         }
 
         /// Computes the sum of `len` and the length of an appropriate push opcode.
-        pub(crate) fn reserved_len_for_slice(len: usize) -> usize {
+        fn reserved_len_for_slice(len: usize) -> usize {
             len + match len {
                 0..=0x4b => 1,
                 0x4c..=0xff => 2,
@@ -211,7 +210,7 @@ mod tmp_priv {
         /// alternative.
         ///
         /// See the public fn [`Self::scan_and_push_verify`] to learn more.
-        pub(crate) fn push_verify(&mut self, last_opcode: Option<Opcode>) {
+        fn push_verify(&mut self, last_opcode: Option<Opcode>) {
             match opcode_to_verify(last_opcode) {
                 Some(opcode) => {
                     self.as_byte_vec().pop();
diff --git a/bitcoin/src/crypto/ecdsa.rs b/bitcoin/src/crypto/ecdsa.rs
index 3731739f4..cd5e8e110 100644
--- a/bitcoin/src/crypto/ecdsa.rs
+++ b/bitcoin/src/crypto/ecdsa.rs
@@ -13,6 +13,8 @@ use io::Write;
 
 use crate::prelude::{DisplayHex, Vec};
 use crate::script::PushBytes;
+#[cfg(doc)]
+use crate::script::ScriptBufExt as _;
 use crate::sighash::{EcdsaSighashType, NonStandardSighashTypeError};
 
 const MAX_SIG_LEN: usize = 73;
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 16a9f63c2..e64d10922 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -1470,6 +1470,7 @@ mod tests {
     use super::*;
     use crate::consensus::deserialize;
     use crate::locktime::absolute;
+    use crate::script::ScriptBufExt as _;
 
     extern crate serde_json;
 
diff --git a/bitcoin/src/internal_macros.rs b/bitcoin/src/internal_macros.rs
index 8dbeab0fd..e59f2f4e1 100644
--- a/bitcoin/src/internal_macros.rs
+++ b/bitcoin/src/internal_macros.rs
@@ -251,7 +251,7 @@ macro_rules! define_extension_trait {
     ($(#[$($trait_attrs:tt)*])* $trait_vis:vis trait $trait_name:ident impl for $ty:ident {
         $(
             $(#[$($fn_attrs:tt)*])*
-            fn $fn:ident$(<$($gen:ident: $gent:ident),*>)?($($params:tt)*) $( -> $ret:ty )? $body:block
+            fn $fn:ident$(<$($gen:ident: $gent:path),*>)?($($params:tt)*) $( -> $ret:ty )? $body:block
         )*
     }) => {
         $(#[$($trait_attrs)*])* $trait_vis trait $trait_name {
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 61efaec40..d64f94852 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -1216,7 +1216,7 @@ mod tests {
     use crate::locktime::absolute;
     use crate::network::NetworkKind;
     use crate::psbt::serialize::{Deserialize, Serialize};
-    use crate::script::ScriptBuf;
+    use crate::script::{ScriptBuf, ScriptBufExt as _};
     use crate::transaction::{self, OutPoint, TxIn};
     use crate::witness::Witness;
     use crate::Sequence;
diff --git a/bitcoin/src/psbt/serialize.rs b/bitcoin/src/psbt/serialize.rs
index 26c4c3126..6523e0c29 100644
--- a/bitcoin/src/psbt/serialize.rs
+++ b/bitcoin/src/psbt/serialize.rs
@@ -383,6 +383,7 @@ fn key_source_len(key_source: &KeySource) -> usize { 4 + 4 * (key_source.1).as_r
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::script::ScriptBufExt as _;
 
     // Composes tree matching a given depth map, filled with dumb script leafs,
     // each of which consists of a single push-int op code, with int value
diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index e2aeeb4cc..6d49a4e4f 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -1544,6 +1544,7 @@ mod test {
     use secp256k1::VerifyOnly;
 
     use super::*;
+    use crate::script::ScriptBufExt as _;
     use crate::sighash::{TapSighash, TapSighashTag};
     use crate::{Address, KnownHrp};
     extern crate serde_json;
diff --git a/bitcoin/tests/bip_174.rs b/bitcoin/tests/bip_174.rs
index 321d20acb..4055bb0eb 100644
--- a/bitcoin/tests/bip_174.rs
+++ b/bitcoin/tests/bip_174.rs
@@ -9,7 +9,7 @@ use bitcoin::consensus::encode::{deserialize, serialize_hex};
 use bitcoin::hex::FromHex;
 use bitcoin::opcodes::OP_0;
 use bitcoin::psbt::{Psbt, PsbtSighashType};
-use bitcoin::script::PushBytes;
+use bitcoin::script::{PushBytes, ScriptBufExt as _};
 use bitcoin::secp256k1::Secp256k1;
 use bitcoin::{
     absolute, script, transaction, Amount, Denomination, NetworkKind, OutPoint, PrivateKey,
diff --git a/bitcoin/tests/serde.rs b/bitcoin/tests/serde.rs
index 59de0009f..9b6cd0c6b 100644
--- a/bitcoin/tests/serde.rs
+++ b/bitcoin/tests/serde.rs
@@ -33,6 +33,7 @@ use bitcoin::hex::FromHex;
 use bitcoin::locktime::{absolute, relative};
 use bitcoin::psbt::raw::{self, Key, Pair, ProprietaryKey};
 use bitcoin::psbt::{Input, Output, Psbt, PsbtSighashType};
+use bitcoin::script::ScriptBufExt as _;
 use bitcoin::sighash::{EcdsaSighashType, TapSighashType};
 use bitcoin::taproot::{self, ControlBlock, LeafVersion, TapTree, TaprootBuilder};
 use bitcoin::witness::Witness;