Merge rust-bitcoin#4928: Make pushnum opcodes more terse

95ea71f Use new OP_x variants (for x in 1-16) (Tobin C. Harding)
85f9b10 Add terse opcodes for 1-16 and neg (Tobin C. Harding)
89795ff opcodes: Fix incorrect docs (Tobin C. Harding)
9b3ebb6 Move opcode aliases to all module (Tobin C. Harding)
74ef48c Change opcodes from static to const (Tobin C. Harding)

Pull request description:

  Use `OP_1` instead of `OP_PUSHNUM_1` (for all values 1-16 inclusive).
  
  This is a breaking change to `serde` serialization since we use the exact letters of the consts when serializin 
  
  Fix rust-bitcoin#4924


ACKs for top commit:
  apoelstra:
    ACK 95ea71f; successfully ran local tests
  shinghim:
    ACK 95ea71f


Tree-SHA512: a190e625d03b28cfb8f7678a40d18cc8cdd10b18bac23b147ea3f63f751a29e49f658f4addf13d8d4d513cae9dfaa3c555f3fba064144b0d0687b151f4f99394

Author: apoelstra

bitcoin/src/blockdata/opcodes.rs

@@ -47,18 +47,70 @@ macro_rules! all_opcodes {
                 #[doc = $doc]
                 pub const $op: Opcode = Opcode { code: $val};
             )*
-        }
 
-        /// Push an empty array onto the stack.
-        pub static OP_0: Opcode = OP_PUSHBYTES_0;
-        /// Empty stack is also FALSE.
-        pub static OP_FALSE: Opcode = OP_PUSHBYTES_0;
-        /// Number 1 is also TRUE.
-        pub static OP_TRUE: Opcode = OP_PUSHNUM_1;
-        /// Previously called OP_NOP2.
-        pub static OP_NOP2: Opcode = OP_CLTV;
-        /// Previously called OP_NOP3.
-        pub static OP_NOP3: Opcode = OP_CSV;
+            /// Push an empty array onto the stack.
+            pub const OP_0: Opcode = OP_PUSHBYTES_0;
+            /// Empty stack is also FALSE.
+            pub const OP_FALSE: Opcode = OP_PUSHBYTES_0;
+            /// Number 1 is also TRUE.
+            pub const OP_TRUE: Opcode = OP_1;
+            /// Previously called OP_NOP2.
+            pub const OP_NOP2: Opcode = OP_CLTV;
+            /// Previously called OP_NOP3.
+            pub const OP_NOP3: Opcode = OP_CSV;
+
+            /// Push the array `0x81` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_1NEGATE instead")]
+            pub const OP_PUSHNUM_NEG1: Opcode = OP_1NEGATE;
+            /// Push the array `0x01` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_1 instead")]
+            pub const OP_PUSHNUM_1: Opcode = OP_1;
+            /// Push the array `0x02` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_2 instead")]
+            pub const OP_PUSHNUM_2: Opcode = OP_2;
+            /// Push the array `0x03` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_3 instead")]
+            pub const OP_PUSHNUM_3: Opcode = OP_3;
+            /// Push the array `0x04` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_4 instead")]
+            pub const OP_PUSHNUM_4: Opcode = OP_4;
+            /// Push the array `0x05` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_5 instead")]
+            pub const OP_PUSHNUM_5: Opcode = OP_5;
+            /// Push the array `0x06` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_6 instead")]
+            pub const OP_PUSHNUM_6: Opcode = OP_6;
+            /// Push the array `0x07` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_7 instead")]
+            pub const OP_PUSHNUM_7: Opcode = OP_7;
+            /// Push the array `0x08` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_8 instead")]
+            pub const OP_PUSHNUM_8: Opcode = OP_8;
+            /// Push the array `0x09` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_9 instead")]
+            pub const OP_PUSHNUM_9: Opcode = OP_9;
+            /// Push the array `0x0a` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_10 instead")]
+            pub const OP_PUSHNUM_10: Opcode = OP_10;
+            /// Push the array `0x0b` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_11 instead")]
+            pub const OP_PUSHNUM_11: Opcode = OP_11;
+            /// Push the array `0x0c` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_12 instead")]
+            pub const OP_PUSHNUM_12: Opcode = OP_12;
+            /// Push the array `0x0d` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_13 instead")]
+            pub const OP_PUSHNUM_13: Opcode = OP_13;
+            /// Push the array `0x0e` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_14 instead")]
+            pub const OP_PUSHNUM_14: Opcode = OP_14;
+            /// Push the array `0x0f` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_15 instead")]
+            pub const OP_PUSHNUM_15: Opcode = OP_15;
+            /// Push the array `0x10` onto the stack.
+            #[deprecated(since = "TBD", note = "use OP_16 instead")]
+            pub const OP_PUSHNUM_16: Opcode = OP_16;
+        }
 
         impl fmt::Display for Opcode {
             fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
@@ -152,24 +204,24 @@ all_opcodes! {
     OP_PUSHDATA1 => 0x4c, "Read the next byte as N; push the next N bytes as an array onto the stack.";
     OP_PUSHDATA2 => 0x4d, "Read the next 2 bytes as N; push the next N bytes as an array onto the stack.";
     OP_PUSHDATA4 => 0x4e, "Read the next 4 bytes as N; push the next N bytes as an array onto the stack.";
-    OP_PUSHNUM_NEG1 => 0x4f, "Push the array `0x81` onto the stack.";
+    OP_1NEGATE => 0x4f, "Push the array `0x81` onto the stack.";
     OP_RESERVED => 0x50, "Synonym for `OP_RETURN`.";
-    OP_PUSHNUM_1 => 0x51, "Push the array `0x01` onto the stack.";
-    OP_PUSHNUM_2 => 0x52, "Push the array `0x02` onto the stack.";
-    OP_PUSHNUM_3 => 0x53, "Push the array `0x03` onto the stack.";
-    OP_PUSHNUM_4 => 0x54, "Push the array `0x04` onto the stack.";
-    OP_PUSHNUM_5 => 0x55, "Push the array `0x05` onto the stack.";
-    OP_PUSHNUM_6 => 0x56, "Push the array `0x06` onto the stack.";
-    OP_PUSHNUM_7 => 0x57, "Push the array `0x07` onto the stack.";
-    OP_PUSHNUM_8 => 0x58, "Push the array `0x08` onto the stack.";
-    OP_PUSHNUM_9 => 0x59, "Push the array `0x09` onto the stack.";
-    OP_PUSHNUM_10 => 0x5a, "Push the array `0x0a` onto the stack.";
-    OP_PUSHNUM_11 => 0x5b, "Push the array `0x0b` onto the stack.";
-    OP_PUSHNUM_12 => 0x5c, "Push the array `0x0c` onto the stack.";
-    OP_PUSHNUM_13 => 0x5d, "Push the array `0x0d` onto the stack.";
-    OP_PUSHNUM_14 => 0x5e, "Push the array `0x0e` onto the stack.";
-    OP_PUSHNUM_15 => 0x5f, "Push the array `0x0f` onto the stack.";
-    OP_PUSHNUM_16 => 0x60, "Push the array `0x10` onto the stack.";
+    OP_1 => 0x51, "Push the array `0x01` onto the stack.";
+    OP_2 => 0x52, "Push the array `0x02` onto the stack.";
+    OP_3 => 0x53, "Push the array `0x03` onto the stack.";
+    OP_4 => 0x54, "Push the array `0x04` onto the stack.";
+    OP_5 => 0x55, "Push the array `0x05` onto the stack.";
+    OP_6 => 0x56, "Push the array `0x06` onto the stack.";
+    OP_7 => 0x57, "Push the array `0x07` onto the stack.";
+    OP_8 => 0x58, "Push the array `0x08` onto the stack.";
+    OP_9 => 0x59, "Push the array `0x09` onto the stack.";
+    OP_10 => 0x5a, "Push the array `0x0a` onto the stack.";
+    OP_11 => 0x5b, "Push the array `0x0b` onto the stack.";
+    OP_12 => 0x5c, "Push the array `0x0c` onto the stack.";
+    OP_13 => 0x5d, "Push the array `0x0d` onto the stack.";
+    OP_14 => 0x5e, "Push the array `0x0e` onto the stack.";
+    OP_15 => 0x5f, "Push the array `0x0f` onto the stack.";
+    OP_16 => 0x60, "Push the array `0x10` onto the stack.";
     OP_NOP => 0x61, "Does nothing.";
     OP_VER => 0x62, "Synonym for `OP_RETURN`.";
     OP_IF => 0x63, "Pop and execute the next statements if a nonzero element was popped.";
@@ -397,11 +449,11 @@ impl Opcode {
             | (OP_CHECKMULTISIGVERIFY, ClassifyContext::TapScript) => Class::ReturnOp,
 
             // 1 opcode of PushNum class
-            (OP_PUSHNUM_NEG1, _) => Class::PushNum(-1),
+            (OP_1NEGATE, _) => Class::PushNum(-1),
 
             // 16 opcodes of PushNum class
-            (op, _) if op.code >= OP_PUSHNUM_1.code && op.code <= OP_PUSHNUM_16.code =>
-                Class::PushNum(1 + self.code as i32 - OP_PUSHNUM_1.code as i32),
+            (op, _) if op.code >= OP_1.code && op.code <= OP_16.code =>
+                Class::PushNum(1 + self.code as i32 - OP_1.code as i32),
 
             // 76 opcodes of PushBytes class
             (op, _) if op.code <= OP_PUSHBYTES_75.code => Class::PushBytes(self.code as u32),
@@ -415,7 +467,7 @@ impl Opcode {
     #[inline]
     pub const fn to_u8(self) -> u8 { self.code }
 
-    /// Encodes PUSHNUM [`Opcode`] as a `u8` representing its number (1-16).
+    /// Decodes PUSHNUM [`Opcode`] as a `u8` representing its number (1-16).
     ///
     /// Does not convert `OP_FALSE` to 0. Only `1` to `OP_PUSHNUM_16` are covered.
     ///
@@ -425,8 +477,8 @@ impl Opcode {
     #[inline]
     #[must_use]
     pub const fn decode_pushnum(self) -> Option<u8> {
-        const START: u8 = OP_PUSHNUM_1.code;
-        const END: u8 = OP_PUSHNUM_16.code;
+        const START: u8 = OP_1.code;
+        const END: u8 = OP_16.code;
         match self.code {
             START..=END => Some(self.code - START + 1),
             _ => None,
@@ -575,11 +627,11 @@ mod tests {
     fn decode_pushnum() {
         // Test all possible opcodes
         // - Sanity check
-        assert_eq!(OP_PUSHNUM_1.code, 0x51_u8);
-        assert_eq!(OP_PUSHNUM_16.code, 0x60_u8);
+        assert_eq!(OP_1.code, 0x51_u8);
+        assert_eq!(OP_16.code, 0x60_u8);
         for i in 0x00..=0xff_u8 {
             let expected = match i {
-                // OP_PUSHNUM_1 ..= OP_PUSHNUM_16
+                // OP_1 ..= OP_16
                 0x51..=0x60 => Some(i - 0x50),
                 _ => None,
             };
@@ -589,22 +641,22 @@ mod tests {
         // Test the named opcode constants
         // - This is the OP right before PUSHNUMs start
         assert!(OP_RESERVED.decode_pushnum().is_none());
-        assert_eq!(OP_PUSHNUM_1.decode_pushnum().expect("pushnum"), 1);
-        assert_eq!(OP_PUSHNUM_2.decode_pushnum().expect("pushnum"), 2);
-        assert_eq!(OP_PUSHNUM_3.decode_pushnum().expect("pushnum"), 3);
-        assert_eq!(OP_PUSHNUM_4.decode_pushnum().expect("pushnum"), 4);
-        assert_eq!(OP_PUSHNUM_5.decode_pushnum().expect("pushnum"), 5);
-        assert_eq!(OP_PUSHNUM_6.decode_pushnum().expect("pushnum"), 6);
-        assert_eq!(OP_PUSHNUM_7.decode_pushnum().expect("pushnum"), 7);
-        assert_eq!(OP_PUSHNUM_8.decode_pushnum().expect("pushnum"), 8);
-        assert_eq!(OP_PUSHNUM_9.decode_pushnum().expect("pushnum"), 9);
-        assert_eq!(OP_PUSHNUM_10.decode_pushnum().expect("pushnum"), 10);
-        assert_eq!(OP_PUSHNUM_11.decode_pushnum().expect("pushnum"), 11);
-        assert_eq!(OP_PUSHNUM_12.decode_pushnum().expect("pushnum"), 12);
-        assert_eq!(OP_PUSHNUM_13.decode_pushnum().expect("pushnum"), 13);
-        assert_eq!(OP_PUSHNUM_14.decode_pushnum().expect("pushnum"), 14);
-        assert_eq!(OP_PUSHNUM_15.decode_pushnum().expect("pushnum"), 15);
-        assert_eq!(OP_PUSHNUM_16.decode_pushnum().expect("pushnum"), 16);
+        assert_eq!(OP_1.decode_pushnum().expect("pushnum"), 1);
+        assert_eq!(OP_2.decode_pushnum().expect("pushnum"), 2);
+        assert_eq!(OP_3.decode_pushnum().expect("pushnum"), 3);
+        assert_eq!(OP_4.decode_pushnum().expect("pushnum"), 4);
+        assert_eq!(OP_5.decode_pushnum().expect("pushnum"), 5);
+        assert_eq!(OP_6.decode_pushnum().expect("pushnum"), 6);
+        assert_eq!(OP_7.decode_pushnum().expect("pushnum"), 7);
+        assert_eq!(OP_8.decode_pushnum().expect("pushnum"), 8);
+        assert_eq!(OP_9.decode_pushnum().expect("pushnum"), 9);
+        assert_eq!(OP_10.decode_pushnum().expect("pushnum"), 10);
+        assert_eq!(OP_11.decode_pushnum().expect("pushnum"), 11);
+        assert_eq!(OP_12.decode_pushnum().expect("pushnum"), 12);
+        assert_eq!(OP_13.decode_pushnum().expect("pushnum"), 13);
+        assert_eq!(OP_14.decode_pushnum().expect("pushnum"), 14);
+        assert_eq!(OP_15.decode_pushnum().expect("pushnum"), 15);
+        assert_eq!(OP_16.decode_pushnum().expect("pushnum"), 16);
         // - This is the OP right after PUSHNUMs end
         assert!(OP_NOP.decode_pushnum().is_none());
     }
@@ -719,24 +771,24 @@ mod tests {
         roundtrip!(unique, OP_PUSHDATA1);
         roundtrip!(unique, OP_PUSHDATA2);
         roundtrip!(unique, OP_PUSHDATA4);
-        roundtrip!(unique, OP_PUSHNUM_NEG1);
+        roundtrip!(unique, OP_1NEGATE);
         roundtrip!(unique, OP_RESERVED);
-        roundtrip!(unique, OP_PUSHNUM_1);
-        roundtrip!(unique, OP_PUSHNUM_2);
-        roundtrip!(unique, OP_PUSHNUM_3);
-        roundtrip!(unique, OP_PUSHNUM_4);
-        roundtrip!(unique, OP_PUSHNUM_5);
-        roundtrip!(unique, OP_PUSHNUM_6);
-        roundtrip!(unique, OP_PUSHNUM_7);
-        roundtrip!(unique, OP_PUSHNUM_8);
-        roundtrip!(unique, OP_PUSHNUM_9);
-        roundtrip!(unique, OP_PUSHNUM_10);
-        roundtrip!(unique, OP_PUSHNUM_11);
-        roundtrip!(unique, OP_PUSHNUM_12);
-        roundtrip!(unique, OP_PUSHNUM_13);
-        roundtrip!(unique, OP_PUSHNUM_14);
-        roundtrip!(unique, OP_PUSHNUM_15);
-        roundtrip!(unique, OP_PUSHNUM_16);
+        roundtrip!(unique, OP_1);
+        roundtrip!(unique, OP_2);
+        roundtrip!(unique, OP_3);
+        roundtrip!(unique, OP_4);
+        roundtrip!(unique, OP_5);
+        roundtrip!(unique, OP_6);
+        roundtrip!(unique, OP_7);
+        roundtrip!(unique, OP_8);
+        roundtrip!(unique, OP_9);
+        roundtrip!(unique, OP_10);
+        roundtrip!(unique, OP_11);
+        roundtrip!(unique, OP_12);
+        roundtrip!(unique, OP_13);
+        roundtrip!(unique, OP_14);
+        roundtrip!(unique, OP_15);
+        roundtrip!(unique, OP_16);
         roundtrip!(unique, OP_NOP);
         roundtrip!(unique, OP_VER);
         roundtrip!(unique, OP_IF);

bitcoin/src/blockdata/script/builder.rs

@@ -78,9 +78,9 @@ impl<T> Builder<T> {
         let bytes = data.as_ref().as_bytes();
         if bytes.len() == 1 && (bytes[0] == 0x81 || bytes[0] <= 16) {
             match bytes[0] {
-                0x81 => self.push_opcode(OP_PUSHNUM_NEG1),
+                0x81 => self.push_opcode(OP_1NEGATE),
                 0 => self.push_opcode(OP_PUSHBYTES_0),
-                1..=16 => self.push_opcode(Opcode::from(bytes[0] + (OP_PUSHNUM_1.to_u8() - 1))),
+                1..=16 => self.push_opcode(Opcode::from(bytes[0] + (OP_1.to_u8() - 1))),
                 _ => self, // unreachable arm
             }
         } else {

bitcoin/src/blockdata/script/owned.rs

@@ -64,9 +64,9 @@ internal_macros::define_extension_trait! {
         /// Does not check whether `n` is in the range of [-2^31 +1...2^31 -1].
         fn push_int_unchecked(&mut self, n: i64) {
             match n {
-                -1 => self.push_opcode(OP_PUSHNUM_NEG1),
+                -1 => self.push_opcode(OP_1NEGATE),
                 0 => self.push_opcode(OP_PUSHBYTES_0),
-                1..=16 => self.push_opcode(Opcode::from(n as u8 + (OP_PUSHNUM_1.to_u8() - 1))),
+                1..=16 => self.push_opcode(Opcode::from(n as u8 + (OP_1.to_u8() - 1))),
                 _ => self.push_int_non_minimal(n),
             }
         }
@@ -79,9 +79,9 @@ internal_macros::define_extension_trait! {
             let bytes = data.as_ref().as_bytes();
             if bytes.len() == 1 && (bytes[0] == 0x81 || bytes[0] <= 16) {
                 match bytes[0] {
-                    0x81 => { self.push_opcode(OP_PUSHNUM_NEG1); },
+                    0x81 => { self.push_opcode(OP_1NEGATE); },
                     0 => { self.push_opcode(OP_PUSHBYTES_0); },
-                    1..=16 => { self.push_opcode(Opcode::from(bytes[0] + (OP_PUSHNUM_1.to_u8() - 1))); },
+                    1..=16 => { self.push_opcode(Opcode::from(bytes[0] + (OP_1.to_u8() - 1))); },
                     _ => {}, // unreachable arm
                 }
             } else {

bitcoin/src/blockdata/script/tests.rs

@@ -747,7 +747,7 @@ fn iterator() {
 
     assert_eq!(
         v_min,
-        vec![(0, Instruction::PushBytes([105].as_ref())), (2, Instruction::Op(opcodes::OP_NOP3))]
+        vec![(0, Instruction::PushBytes([105].as_ref())), (2, Instruction::Op(opcodes::all::OP_NOP3))]
     );
 
     assert_eq!(v_nonmin.unwrap_err(), Error::NonMinimalPush);
@@ -756,7 +756,7 @@ fn iterator() {
         v_nonmin_alt,
         vec![
             (0, Instruction::PushBytes([105, 0].as_ref())),
-            (3, Instruction::Op(opcodes::OP_NOP3))
+            (3, Instruction::Op(opcodes::all::OP_NOP3))
         ]
     );
 
@@ -858,34 +858,34 @@ fn script_get_sigop_count() {
             .push_slice([42; 20])
             .push_opcode(OP_EQUALVERIFY)
             .push_opcode(OP_CHECKSIGVERIFY)
-            .push_opcode(OP_PUSHNUM_1)
+            .push_opcode(OP_1)
             .into_script()
             .count_sigops(),
         1
     );
     let multi = Script::builder()
-        .push_opcode(OP_PUSHNUM_1)
+        .push_opcode(OP_1)
         .push_slice([3; 33])
         .push_slice([3; 33])
         .push_slice([3; 33])
-        .push_opcode(OP_PUSHNUM_3)
+        .push_opcode(OP_3)
         .push_opcode(OP_CHECKMULTISIG)
         .into_script();
     assert_eq!(multi.count_sigops(), 3);
     assert_eq!(multi.count_sigops_legacy(), 20);
     let multi_verify = Script::builder()
-        .push_opcode(OP_PUSHNUM_1)
+        .push_opcode(OP_1)
         .push_slice([3; 33])
         .push_slice([3; 33])
         .push_slice([3; 33])
-        .push_opcode(OP_PUSHNUM_3)
+        .push_opcode(OP_3)
         .push_opcode(OP_CHECKMULTISIGVERIFY)
-        .push_opcode(OP_PUSHNUM_1)
+        .push_opcode(OP_1)
         .into_script();
     assert_eq!(multi_verify.count_sigops(), 3);
     assert_eq!(multi_verify.count_sigops_legacy(), 20);
     let multi_nopushnum_pushdata = Script::builder()
-        .push_opcode(OP_PUSHNUM_1)
+        .push_opcode(OP_1)
         .push_slice([3; 33])
         .push_slice([3; 33])
         .push_slice([3; 33])
@@ -894,7 +894,7 @@ fn script_get_sigop_count() {
     assert_eq!(multi_nopushnum_pushdata.count_sigops(), 20);
     assert_eq!(multi_nopushnum_pushdata.count_sigops_legacy(), 20);
     let multi_nopushnum_op = Script::builder()
-        .push_opcode(OP_PUSHNUM_1)
+        .push_opcode(OP_1)
         .push_slice([3; 33])
         .push_slice([3; 33])
         .push_opcode(OP_DROP)
@@ -1017,10 +1017,10 @@ fn instruction_script_num_parse() {
     ];
     let ops = [
         (Instruction::Op(opcodes::all::OP_PUSHDATA4), None),
-        (Instruction::Op(opcodes::all::OP_PUSHNUM_NEG1), Some(-1)),
+        (Instruction::Op(opcodes::all::OP_1NEGATE), Some(-1)),
         (Instruction::Op(opcodes::all::OP_RESERVED), None),
-        (Instruction::Op(opcodes::all::OP_PUSHNUM_1), Some(1)),
-        (Instruction::Op(opcodes::all::OP_PUSHNUM_16), Some(16)),
+        (Instruction::Op(opcodes::all::OP_1), Some(1)),
+        (Instruction::Op(opcodes::all::OP_16), Some(16)),
         (Instruction::Op(opcodes::all::OP_NOP), None),
     ];
     for (input, expected) in &push_bytes {

bitcoin/src/blockdata/script/witness_version.rs

@@ -122,8 +122,8 @@ impl TryFrom<Opcode> for WitnessVersion {
     fn try_from(opcode: Opcode) -> Result<Self, Self::Error> {
         match opcode.to_u8() {
             0 => Ok(WitnessVersion::V0),
-            version if version >= OP_PUSHNUM_1.to_u8() && version <= OP_PUSHNUM_16.to_u8() =>
-                WitnessVersion::try_from(version - OP_PUSHNUM_1.to_u8() + 1),
+            version if version >= OP_1.to_u8() && version <= OP_16.to_u8() =>
+                WitnessVersion::try_from(version - OP_1.to_u8() + 1),
             invalid => Err(TryFromError { invalid }),
         }
     }
@@ -145,7 +145,7 @@ impl From<WitnessVersion> for Opcode {
     fn from(version: WitnessVersion) -> Opcode {
         match version {
             WitnessVersion::V0 => OP_PUSHBYTES_0,
-            no => Opcode::from(OP_PUSHNUM_1.to_u8() + no.to_num() - 1),
+            no => Opcode::from(OP_1.to_u8() + no.to_num() - 1),
         }
     }
 }