tapyrus 0.2.4 → 0.2.9

data/lib/tapyrus/script/multisig.rb

@@ -1,11 +1,10 @@
 module Tapyrus
-
   # utility for multisig
   module Multisig
     include Tapyrus::Opcodes
 
     def self.prefix
-      [OP_0].pack("C*")
+      [OP_0].pack('C*')
     end
 
     # generate input script sig spending a multisig output script.
@@ -23,7 +22,7 @@ module Tapyrus
     # multiple parties. Signatures must be in the same order as the
     # pubkeys in the output script being redeemed.
     def self.add_sig_to_multisig_script_sig(sig_to_add, script_sig, hash_type = SIGHASH_TYPE[:all])
-      signature = sig_to_add + [hash_type].pack("C*")
+      signature = sig_to_add + [hash_type].pack('C*')
       offset = script_sig.empty? ? 0 : 1
       script_sig.insert(offset, Tapyrus::Script.pack_pushdata(signature))
     end
@@ -49,17 +48,19 @@ module Tapyrus
       pubkeys = redeem_script.get_multisig_pubkeys
 
       # find the pubkey for each signature by trying to verify it
-      sigs = Hash[script.chunks[1...-1].map.with_index do |sig, idx|
-        sig = sig.pushed_data
-        pubkey = pubkeys.map do |key|
-          Tapyrus::Key.new(pubkey: key.bth).verify(sig, sig_hash) ? key : nil
-        end.compact.first
-        raise "Key for signature ##{idx} not found in redeem script!"  unless pubkey
-        [pubkey, sig]
-      end]
+      sigs =
+        Hash[
+          script.chunks[1...-1].map.with_index do |sig, idx|
+            sig = sig.pushed_data
+            pubkey =
+              pubkeys.map { |key| Tapyrus::Key.new(pubkey: key.bth).verify(sig, sig_hash) ? key : nil }.compact.first
+            raise "Key for signature ##{idx} not found in redeem script!" unless pubkey
+            [pubkey, sig]
+          end
+        ]
 
       prefix + pubkeys.map { |k| sigs[k] ? Tapyrus::Script.pack_pushdata(sigs[k]) : nil }.join +
         Tapyrus::Script.pack_pushdata(script.chunks[-1].pushed_data)
     end
   end
-end
+end

data/lib/tapyrus/script/script.rb

@@ -2,7 +2,6 @@
 # https://github.com/lian/bitcoin-ruby/blob/master/COPYING
 
 module Tapyrus
-
   # tapyrus script
   class Script
     include Tapyrus::HexConverter
@@ -75,9 +74,19 @@ module Tapyrus
       end
     end
 
+    # Remove color identifier from cp2pkh or cp2sh
+    # @param [ColorIdentifier] color identifier
+    # @return [Script] P2PKH or P2SH script
+    # @raise [RuntimeError] if script is neither cp2pkh nor cp2sh
+    def remove_color
+      raise RuntimeError, 'Only cp2pkh and cp2sh can remove color' unless cp2pkh? or cp2sh?
+
+      Tapyrus::Script.new.tap { |s| s.chunks = self.chunks[2..-1] }
+    end
+
     def get_multisig_pubkeys
       num = Tapyrus::Opcodes.opcode_to_small_int(chunks[-2].bth.to_i(16))
-      (1..num).map{ |i| chunks[i].pushed_data }
+      (1..num).map { |i| chunks[i].pushed_data }
     end
 
     # generate m of n multisig script
@@ -92,14 +101,16 @@ module Tapyrus
     # generate script from string.
     def self.from_string(string)
       script = new
-      string.split(' ').each do |v|
-        opcode = Opcodes.name_to_opcode(v)
-        if opcode
-          script << (v =~ /^\d/ && Opcodes.small_int_to_opcode(v.ord) ? v.ord : opcode)
-        else
-          script << (v =~ /^[0-9]+$/ ? v.to_i : v)
+      string
+        .split(' ')
+        .each do |v|
+          opcode = Opcodes.name_to_opcode(v)
+          if opcode
+            script << (v =~ /^\d/ && Opcodes.small_int_to_opcode(v.ord) ? v.ord : opcode)
+          else
+            script << (v =~ /^[0-9]+$/ ? v.to_i : v)
+          end
         end
-      end
       script
     end
 
@@ -118,6 +129,12 @@ module Tapyrus
           Tapyrus::Script.to_p2pkh(hex)
         when Tapyrus.chain_params.p2sh_version
           Tapyrus::Script.to_p2sh(hex)
+        when Tapyrus.chain_params.cp2pkh_version
+          color = Tapyrus::Color::ColorIdentifier.parse_from_payload(hex[0..65].htb)
+          Tapyrus::Script.to_cp2pkh(color, hex[66..-1])
+        when Tapyrus.chain_params.cp2sh_version
+          color = Tapyrus::Color::ColorIdentifier.parse_from_payload(hex[0..65].htb)
+          Tapyrus::Script.to_cp2sh(color, hex[66..-1])
         else
           throw e
         end
@@ -132,19 +149,20 @@ module Tapyrus
         if opcode.pushdata?
           pushcode = opcode.ord
           packed_size = nil
-          len = case pushcode
-                  when OP_PUSHDATA1
-                    packed_size = buf.read(1)
-                    packed_size.unpack('C').first
-                  when OP_PUSHDATA2
-                    packed_size = buf.read(2)
-                    packed_size.unpack('v').first
-                  when OP_PUSHDATA4
-                    packed_size = buf.read(4)
-                    packed_size.unpack('V').first
-                  else
-                    pushcode if pushcode < OP_PUSHDATA1
-                end
+          len =
+            case pushcode
+            when OP_PUSHDATA1
+              packed_size = buf.read(1)
+              packed_size.unpack('C').first
+            when OP_PUSHDATA2
+              packed_size = buf.read(2)
+              packed_size.unpack('v').first
+            when OP_PUSHDATA4
+              packed_size = buf.read(4)
+              packed_size.unpack('V').first
+            else
+              pushcode if pushcode < OP_PUSHDATA1
+            end
           if len
             s.chunks << [len].pack('C') if buf.eof?
             unless buf.eof?
@@ -176,7 +194,7 @@ module Tapyrus
       return [p2sh_addr] if p2sh?
       return [cp2pkh_addr] if cp2pkh?
       return [cp2sh_addr] if cp2sh?
-      return get_multisig_pubkeys.map{|pubkey| Tapyrus::Key.new(pubkey: pubkey.bth).to_p2pkh} if multisig?
+      return get_multisig_pubkeys.map { |pubkey| Tapyrus::Key.new(pubkey: pubkey.bth).to_p2pkh } if multisig?
       []
     end
 
@@ -188,8 +206,8 @@ module Tapyrus
     # whether this script is a P2PKH format script.
     def p2pkh?
       return false unless chunks.size == 5
-      [OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG] ==
-          (chunks[0..1]+ chunks[3..4]).map(&:ord) && chunks[2].bytesize == 21
+      [OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG] == (chunks[0..1] + chunks[3..4]).map(&:ord) &&
+        chunks[2].bytesize == 21
     end
 
     def p2sh?
@@ -210,19 +228,22 @@ module Tapyrus
     end
 
     def standard_op_return?
-      op_return? && size <= MAX_OP_RETURN_RELAY &&
-          (chunks.size == 1 || chunks[1].opcode <= OP_16)
+      op_return? && size <= MAX_OP_RETURN_RELAY && (chunks.size == 1 || chunks[1].opcode <= OP_16)
     end
 
+    # Return whether this script is a CP2PKH format script or not.
+    # @return [Boolean] true if this script is cp2pkh, otherwise false.
     def cp2pkh?
       return false unless chunks.size == 7
       return false unless chunks[0].bytesize == 34
       return false unless Tapyrus::Color::ColorIdentifier.parse_from_payload(chunks[0].pushed_data)&.valid?
       return false unless chunks[1].ord == OP_COLOR
-      [OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG] ==
-          (chunks[2..3]+ chunks[5..6]).map(&:ord) && chunks[4].bytesize == 21
+      [OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG] == (chunks[2..3] + chunks[5..6]).map(&:ord) &&
+        chunks[4].bytesize == 21
     end
 
+    # Return whether this script is a CP2SH format script or not.
+    # @return [Boolean] true if this script is cp2pkh, otherwise false.
     def cp2sh?
       return false unless chunks.size == 5
       return false unless chunks[0].bytesize == 34
@@ -231,6 +252,20 @@ module Tapyrus
       OP_HASH160 == chunks[2].ord && OP_EQUAL == chunks[4].ord && chunks[3].bytesize == 21
     end
 
+    # Return whether this script represents colored coin.
+    # @return [Boolean] true if this script is colored, otherwise false.
+    def colored?
+      cp2pkh? || cp2sh?
+    end
+
+    # Return color identifier for this script.
+    # @return [ColorIdentifer] color identifier for this script if this script is colored. return nil if this script is not colored.
+    def color_id
+      return nil unless colored?
+
+      Tapyrus::Color::ColorIdentifier.parse_from_payload(chunks[0].pushed_data)
+    end
+
     def op_return_data
       return nil unless op_return?
       return nil if chunks.size == 1
@@ -239,24 +274,23 @@ module Tapyrus
 
     # whether data push only script which dose not include other opcode
     def push_only?
-      chunks.each do |c|
-        return false if !c.opcode.nil? && c.opcode > OP_16
-      end
+      chunks.each { |c| return false if !c.opcode.nil? && c.opcode > OP_16 }
       true
     end
 
     # get public keys in the stack.
     # @return[Array[String]] an array of the pubkeys with hex format.
     def get_pubkeys
-      chunks.select{|c|c.pushdata? && [33, 65].include?(c.pushed_data.bytesize) && [2, 3, 4, 6, 7].include?(c.pushed_data[0].bth.to_i(16))}.map{|c|c.pushed_data.bth}
+      chunks.select do |c|
+        c.pushdata? && [33, 65].include?(c.pushed_data.bytesize) &&
+          [2, 3, 4, 6, 7].include?(c.pushed_data[0].bth.to_i(16))
+      end.map { |c| c.pushed_data.bth }
     end
 
     # returns the self payload. ScriptInterpreter does not use this.
     def to_script_code(skip_separator_index = 0)
       payload = to_payload
-      if skip_separator_index > 0
-        payload = subscript_codeseparator(skip_separator_index)
-      end
+      payload = subscript_codeseparator(skip_separator_index) if skip_separator_index > 0
       Tapyrus.pack_var_string(payload)
     end
 
@@ -267,7 +301,7 @@ module Tapyrus
       elsif obj.is_a?(String)
         append_data(obj)
       elsif obj.is_a?(Array)
-        obj.each { |o| self.<< o}
+        obj.each { |o| self.<< o }
         self
       end
     end
@@ -303,18 +337,19 @@ module Tapyrus
 
     # Check the item is in the chunk of the script.
     def include?(item)
-      chunk_item = if item.is_a?(Integer)
-                     item.chr
-                   elsif item.is_a?(String)
-                     data = Encoding::ASCII_8BIT == item.encoding ? item : item.htb
-                     Tapyrus::Script.pack_pushdata(data)
-                   end
+      chunk_item =
+        if item.is_a?(Integer)
+          item.chr
+        elsif item.is_a?(String)
+          data = Encoding::ASCII_8BIT == item.encoding ? item : item.htb
+          Tapyrus::Script.pack_pushdata(data)
+        end
       return false unless chunk_item
       chunks.include?(chunk_item)
     end
 
     def to_s
-      chunks.map { |c|
+      chunks.map do |c|
         case c
         when Integer
           opcode_to_name(c)
@@ -337,7 +372,7 @@ module Tapyrus
             opcode ? opcode : 'OP_UNKNOWN [error]'
           end
         end
-      }.join(' ')
+      end.join(' ')
     end
 
     # generate sha-256 hash for payload
@@ -395,17 +430,18 @@ module Tapyrus
     # binary +data+ convert pushdata which contains data length and append PUSHDATA opcode if necessary.
     def self.pack_pushdata(data)
       size = data.bytesize
-      header = if size < OP_PUSHDATA1
-                 [size].pack('C')
-               elsif size < 0xff
-                 [OP_PUSHDATA1, size].pack('CC')
-               elsif size < 0xffff
-                 [OP_PUSHDATA2, size].pack('Cv')
-               elsif size < 0xffffffff
-                 [OP_PUSHDATA4, size].pack('CV')
-               else
-                 raise ArgumentError, 'data size is too big.'
-               end
+      header =
+        if size < OP_PUSHDATA1
+          [size].pack('C')
+        elsif size < 0xff
+          [OP_PUSHDATA1, size].pack('CC')
+        elsif size < 0xffff
+          [OP_PUSHDATA2, size].pack('Cv')
+        elsif size < 0xffffffff
+          [OP_PUSHDATA4, size].pack('CV')
+        else
+          raise ArgumentError, 'data size is too big.'
+        end
       header + data
     end
 
@@ -429,8 +465,12 @@ module Tapyrus
           if chunk == sub_chunk
             buf << chunk
             i += 1
-            (i = 0; buf.clear) if i == subscript.chunks.size # matched the whole subscript
-          else # matched the part of head
+            (
+              i = 0
+              buf.clear
+            ) if i == subscript.chunks.size # matched the whole subscript
+          else
+            # matched the part of head
             i = 0
             tmp = chunk.dup
             tmp.slice!(sub_chunk)
@@ -452,7 +492,7 @@ module Tapyrus
 
     # remove all occurences of opcode. Typically it's OP_CODESEPARATOR.
     def delete_opcode(opcode)
-      @chunks = chunks.select{|chunk| chunk.ord != opcode}
+      @chunks = chunks.select { |chunk| chunk.ord != opcode }
       self
     end
 
@@ -460,12 +500,10 @@ module Tapyrus
     def subscript_codeseparator(separator_index)
       buf = []
       process_separator_index = 0
-      chunks.each{|chunk|
+      chunks.each do |chunk|
         buf << chunk if process_separator_index == separator_index
-        if chunk.ord == OP_CODESEPARATOR && process_separator_index < separator_index
-          process_separator_index += 1
-        end
-      }
+        process_separator_index += 1 if chunk.ord == OP_CODESEPARATOR && process_separator_index < separator_index
+      end
       buf.join
     end
 
@@ -482,10 +520,10 @@ module Tapyrus
     end
 
     def to_h
-      h = {asm: to_s, hex: to_hex, type: type}
+      h = { asm: to_s, hex: to_hex, type: type }
       addrs = addresses
       unless addrs.empty?
-        h[:req_sigs] = multisig? ? Tapyrus::Opcodes.opcode_to_small_int(chunks[0].bth.to_i(16)) :addrs.size
+        h[:req_sigs] = multisig? ? Tapyrus::Opcodes.opcode_to_small_int(chunks[0].bth.to_i(16)) : addrs.size
         h[:addresses] = addrs
       end
       h
@@ -532,5 +570,4 @@ module Tapyrus
       Tapyrus.encode_base58_address(color_id + hash160, Tapyrus.chain_params.cp2sh_version)
     end
   end
-
 end

data/lib/tapyrus/script/script_error.rb

@@ -1,8 +1,6 @@
 module Tapyrus
-
   # tapyrus script error
   class ScriptError < Exception
-
     attr_accessor :code
     attr_accessor :extra_msg
 
@@ -100,6 +98,5 @@ module Tapyrus
     def self.name_to_code(name)
       NAME_MAP[name]
     end
-
   end
-end
+end

data/lib/tapyrus/script/script_interpreter.rb

@@ -1,7 +1,5 @@
 module Tapyrus
-
   class ScriptInterpreter
-
     include Tapyrus::Opcodes
 
     attr_reader :stack
@@ -11,8 +9,23 @@ module Tapyrus
     attr_reader :checker
     attr_reader :require_minimal
 
-    DISABLE_OPCODES = [OP_CAT, OP_SUBSTR, OP_LEFT, OP_RIGHT, OP_INVERT, OP_AND, OP_OR, OP_XOR, OP_2MUL, OP_2DIV, OP_DIV, OP_MUL, OP_MOD, OP_LSHIFT, OP_RSHIFT]
-
+    DISABLE_OPCODES = [
+      OP_CAT,
+      OP_SUBSTR,
+      OP_LEFT,
+      OP_RIGHT,
+      OP_INVERT,
+      OP_AND,
+      OP_OR,
+      OP_XOR,
+      OP_2MUL,
+      OP_2DIV,
+      OP_DIV,
+      OP_MUL,
+      OP_MOD,
+      OP_LSHIFT,
+      OP_RSHIFT
+    ]
 
     # syntax sugar for simple evaluation for script.
     # @param [Tapyrus::Script] script_sig a scriptSig.
@@ -34,7 +47,6 @@ module Tapyrus
     # @param [Tapyrus::Script] script_pubkey a script pubkey (locking script)
     # @return [Boolean] result
     def verify_script(script_sig, script_pubkey)
-
       return set_error(SCRIPT_ERR_SIG_PUSHONLY) if flag?(SCRIPT_VERIFY_SIGPUSHONLY) && !script_sig.push_only?
 
       stack_copy = nil
@@ -97,9 +109,7 @@ module Tapyrus
           opcode = c.opcode
 
           if need_exec && c.pushdata?
-            if require_minimal && !minimal_push?(c.pushed_data, opcode)
-              return set_error(SCRIPT_ERR_MINIMALDATA)
-            end
+            return set_error(SCRIPT_ERR_MINIMALDATA) if require_minimal && !minimal_push?(c.pushed_data, opcode)
             return set_error(SCRIPT_ERR_BAD_OPCODE) unless verify_pushdata_length(c)
             stack << c.pushed_data.bth
           else
@@ -107,385 +117,415 @@ module Tapyrus
               return set_error(SCRIPT_ERR_OP_COUNT)
             end
             return set_error(SCRIPT_ERR_DISABLED_OPCODE) if DISABLE_OPCODES.include?(opcode)
-            return set_error(SCRIPT_ERR_OP_CODESEPARATOR) if opcode == OP_CODESEPARATOR && sig_version == :base && flag?(SCRIPT_VERIFY_CONST_SCRIPTCODE)
+            if opcode == OP_CODESEPARATOR && sig_version == :base && flag?(SCRIPT_VERIFY_CONST_SCRIPTCODE)
+              return set_error(SCRIPT_ERR_OP_CODESEPARATOR)
+            end
             next unless (need_exec || (OP_IF <= opcode && opcode <= OP_ENDIF))
             small_int = Opcodes.opcode_to_small_int(opcode)
             if small_int && opcode != OP_0
               push_int(small_int)
             else
               case opcode
-                when OP_0
-                  stack << ''
-                when OP_DEPTH
-                  push_int(stack.size)
-                when OP_EQUAL, OP_EQUALVERIFY
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  a, b = pop_string(2)
-                  result = a == b
-                  push_int(result ? 1 : 0)
-                  if opcode == OP_EQUALVERIFY
-                    if result
-                      stack.pop
-                    else
-                      return set_error(SCRIPT_ERR_EQUALVERIFY)
-                    end
+              when OP_0
+                stack << ''
+              when OP_DEPTH
+                push_int(stack.size)
+              when OP_EQUAL, OP_EQUALVERIFY
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                a, b = pop_string(2)
+                result = a == b
+                push_int(result ? 1 : 0)
+                if opcode == OP_EQUALVERIFY
+                  if result
+                    stack.pop
+                  else
+                    return set_error(SCRIPT_ERR_EQUALVERIFY)
                   end
-                when OP_0NOTEQUAL
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  push_int(pop_int == 0 ? 0 : 1)
-                when OP_ADD
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  a, b = pop_int(2)
-                  push_int(a + b)
-                when OP_1ADD
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  push_int(pop_int + 1)
-                when OP_SUB
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  a, b = pop_int(2)
-                  push_int(a - b)
-                when OP_1SUB
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  push_int(pop_int - 1)
-                when OP_IF, OP_NOTIF
-                  result = false
-                  if need_exec
-                    return set_error(SCRIPT_ERR_UNBALANCED_CONDITIONAL) if stack.size < 1
-                    value = pop_string.htb
-                    if flag?(SCRIPT_VERIFY_MINIMALIF)
-                      if value.bytesize > 1 || (value.bytesize == 1 && value[0].unpack('C').first != 1)
-                        return set_error(SCRIPT_ERR_MINIMALIF)
-                      end
+                end
+              when OP_0NOTEQUAL
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                push_int(pop_int == 0 ? 0 : 1)
+              when OP_ADD
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                a, b = pop_int(2)
+                push_int(a + b)
+              when OP_1ADD
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                push_int(pop_int + 1)
+              when OP_SUB
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                a, b = pop_int(2)
+                push_int(a - b)
+              when OP_1SUB
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                push_int(pop_int - 1)
+              when OP_IF, OP_NOTIF
+                result = false
+                if need_exec
+                  return set_error(SCRIPT_ERR_UNBALANCED_CONDITIONAL) if stack.size < 1
+                  value = pop_string.htb
+                  if flag?(SCRIPT_VERIFY_MINIMALIF)
+                    if value.bytesize > 1 || (value.bytesize == 1 && value[0].unpack('C').first != 1)
+                      return set_error(SCRIPT_ERR_MINIMALIF)
                     end
-                    result = cast_to_bool(value)
-                    result = !result if opcode == OP_NOTIF
                   end
-                  flow_stack << result
-                when OP_ELSE
-                  return set_error(SCRIPT_ERR_UNBALANCED_CONDITIONAL) if flow_stack.size < 1
-                  flow_stack << !flow_stack.pop
-                when OP_ENDIF
-                  return set_error(SCRIPT_ERR_UNBALANCED_CONDITIONAL) if flow_stack.empty?
-                  flow_stack.pop
-                when OP_NOP
-                when OP_NOP1, OP_NOP4..OP_NOP10
-                  return set_error(SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS) if flag?(SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
-                when OP_CHECKLOCKTIMEVERIFY
-                  next unless flag?(SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY)
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  # Note that elsewhere numeric opcodes are limited to operands in the range -2**31+1 to 2**31-1,
-                  # however it is legal for opcodes to produce results exceeding that range.
-                  # This limitation is implemented by CScriptNum's default 4-byte limit.
-                  # If we kept to that limit we'd have a year 2038 problem,
-                  # even though the nLockTime field in transactions themselves is uint32 which only becomes meaningless after the year 2106.
-                  # Thus as a special case we tell CScriptNum to accept up to 5-byte bignums,
-                  # which are good until 2**39-1, well beyond the 2**32-1 limit of the nLockTime field itself.
-                  locktime = cast_to_int(stack.last, 5)
-                  return set_error(SCRIPT_ERR_NEGATIVE_LOCKTIME) if locktime < 0
-                  return set_error(SCRIPT_ERR_UNSATISFIED_LOCKTIME) unless checker.check_locktime(locktime)
-                when OP_CHECKSEQUENCEVERIFY
-                  next unless flag?(SCRIPT_VERIFY_CHECKSEQUENCEVERIFY)
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-
-                  # nSequence, like nLockTime, is a 32-bit unsigned integer field.
-                  # See the comment in CHECKLOCKTIMEVERIFY regarding 5-byte numeric operands.
-                  sequence = cast_to_int(stack.last, 5)
-
-                  # In the rare event that the argument may be < 0 due to some arithmetic being done first,
-                  # you can always use 0 MAX CHECKSEQUENCEVERIFY.
-                  return set_error(SCRIPT_ERR_NEGATIVE_LOCKTIME) if sequence < 0
-
-                  # To provide for future soft-fork extensibility,
-                  # if the operand has the disabled lock-time flag set, CHECKSEQUENCEVERIFY behaves as a NOP.
-                  next if (sequence & Tapyrus::TxIn::SEQUENCE_LOCKTIME_DISABLE_FLAG) != 0
-
-                  # Compare the specified sequence number with the input.
-                  unless checker.check_sequence(sequence)
-                    return set_error(SCRIPT_ERR_UNSATISFIED_LOCKTIME)
+                  result = cast_to_bool(value)
+                  result = !result if opcode == OP_NOTIF
+                end
+                flow_stack << result
+              when OP_ELSE
+                return set_error(SCRIPT_ERR_UNBALANCED_CONDITIONAL) if flow_stack.size < 1
+                flow_stack << !flow_stack.pop
+              when OP_ENDIF
+                return set_error(SCRIPT_ERR_UNBALANCED_CONDITIONAL) if flow_stack.empty?
+                flow_stack.pop
+              when OP_NOP
+              when OP_NOP1, OP_NOP4..OP_NOP10
+                if flag?(SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
+                  return set_error(SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS)
+                end
+              when OP_CHECKLOCKTIMEVERIFY
+                next unless flag?(SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY)
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+
+                # Note that elsewhere numeric opcodes are limited to operands in the range -2**31+1 to 2**31-1,
+                # however it is legal for opcodes to produce results exceeding that range.
+                # This limitation is implemented by CScriptNum's default 4-byte limit.
+                # If we kept to that limit we'd have a year 2038 problem,
+                # even though the nLockTime field in transactions themselves is uint32 which only becomes meaningless after the year 2106.
+                # Thus as a special case we tell CScriptNum to accept up to 5-byte bignums,
+                # which are good until 2**39-1, well beyond the 2**32-1 limit of the nLockTime field itself.
+                locktime = cast_to_int(stack.last, 5)
+                return set_error(SCRIPT_ERR_NEGATIVE_LOCKTIME) if locktime < 0
+                return set_error(SCRIPT_ERR_UNSATISFIED_LOCKTIME) unless checker.check_locktime(locktime)
+              when OP_CHECKSEQUENCEVERIFY
+                next unless flag?(SCRIPT_VERIFY_CHECKSEQUENCEVERIFY)
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+
+                # nSequence, like nLockTime, is a 32-bit unsigned integer field.
+                # See the comment in CHECKLOCKTIMEVERIFY regarding 5-byte numeric operands.
+                sequence = cast_to_int(stack.last, 5)
+
+                # In the rare event that the argument may be < 0 due to some arithmetic being done first,
+                # you can always use 0 MAX CHECKSEQUENCEVERIFY.
+                return set_error(SCRIPT_ERR_NEGATIVE_LOCKTIME) if sequence < 0
+
+                # To provide for future soft-fork extensibility,
+                # if the operand has the disabled lock-time flag set, CHECKSEQUENCEVERIFY behaves as a NOP.
+                next if (sequence & Tapyrus::TxIn::SEQUENCE_LOCKTIME_DISABLE_FLAG) != 0
+
+                # Compare the specified sequence number with the input.
+                return set_error(SCRIPT_ERR_UNSATISFIED_LOCKTIME) unless checker.check_sequence(sequence)
+              when OP_DUP
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                stack << stack.last
+              when OP_2DUP
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                2.times { stack << stack[-2] }
+              when OP_3DUP
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 3
+                3.times { stack << stack[-3] }
+              when OP_IFDUP
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                stack << stack.last if cast_to_bool(stack.last)
+              when OP_RIPEMD160
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                stack << Digest::RMD160.hexdigest(pop_string.htb)
+              when OP_SHA1
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                stack << Digest::SHA1.hexdigest(pop_string.htb)
+              when OP_SHA256
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                stack << Digest::SHA256.hexdigest(pop_string.htb)
+              when OP_HASH160
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                stack << Tapyrus.hash160(pop_string)
+              when OP_HASH256
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                stack << Tapyrus.double_sha256(pop_string.htb).bth
+              when OP_VERIFY
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                return set_error(SCRIPT_ERR_VERIFY) unless pop_bool
+              when OP_TOALTSTACK
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                alt_stack << stack.pop
+              when OP_FROMALTSTACK
+                return set_error(SCRIPT_ERR_INVALID_ALTSTACK_OPERATION) if alt_stack.size < 1
+                stack << alt_stack.pop
+              when OP_DROP
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                stack.pop
+              when OP_2DROP
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                2.times { stack.pop }
+              when OP_NIP
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                stack.delete_at(-2)
+              when OP_OVER
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                stack << stack[-2]
+              when OP_2OVER
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 4
+                2.times { stack << stack[-4] }
+              when OP_PICK, OP_ROLL
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                pos = pop_int
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if pos < 0 || pos >= stack.size
+                stack << stack[-pos - 1]
+                stack.delete_at(-pos - 2) if opcode == OP_ROLL
+              when OP_ROT
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 3
+                stack << stack[-3]
+                stack.delete_at(-4)
+              when OP_2ROT
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 6
+                2.times { stack << stack[-6] }
+                2.times { stack.delete_at(-7) }
+              when OP_SWAP
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                tmp = stack.last
+                stack[-1] = stack[-2]
+                stack[-2] = tmp
+              when OP_2SWAP
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 4
+                2.times { stack << stack[-4] }
+                2.times { stack.delete_at(-5) }
+              when OP_TUCK
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                stack.insert(-3, stack.last)
+              when OP_ABS
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                v = pop_int
+                push_int(v.abs)
+              when OP_BOOLAND
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                a, b = pop_int(2)
+                push_int((!a.zero? && !b.zero?) ? 1 : 0)
+              when OP_BOOLOR
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                a, b = pop_int(2)
+                push_int((!a.zero? || !b.zero?) ? 1 : 0)
+              when OP_NUMEQUAL, OP_NUMEQUALVERIFY
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                a, b = pop_int(2)
+                result = a == b
+                push_int(result ? 1 : 0)
+                if opcode == OP_NUMEQUALVERIFY
+                  if result
+                    stack.pop
+                  else
+                    return set_error(SCRIPT_ERR_NUMEQUALVERIFY)
                   end
-                when OP_DUP
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  stack << stack.last
-                when OP_2DUP
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  2.times { stack << stack[-2] }
-                when OP_3DUP
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 3
-                  3.times { stack << stack[-3] }
-                when OP_IFDUP
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  stack << stack.last if cast_to_bool(stack.last)
-                when OP_RIPEMD160
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  stack << Digest::RMD160.hexdigest(pop_string.htb)
-                when OP_SHA1
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  stack << Digest::SHA1.hexdigest(pop_string.htb)
-                when OP_SHA256
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  stack << Digest::SHA256.hexdigest(pop_string.htb)
-                when OP_HASH160
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  stack << Tapyrus.hash160(pop_string)
-                when OP_HASH256
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  stack << Tapyrus.double_sha256(pop_string.htb).bth
-                when OP_VERIFY
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  return set_error(SCRIPT_ERR_VERIFY) unless pop_bool
-                when OP_TOALTSTACK
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  alt_stack << stack.pop
-                when OP_FROMALTSTACK
-                  return set_error(SCRIPT_ERR_INVALID_ALTSTACK_OPERATION) if alt_stack.size < 1
-                  stack << alt_stack.pop
-                when OP_DROP
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  stack.pop
-                when OP_2DROP
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  2.times { stack.pop }
-                when OP_NIP
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  stack.delete_at(-2)
-                when OP_OVER
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  stack << stack[-2]
-                when OP_2OVER
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 4
-                  2.times { stack << stack[-4]}
-                when OP_PICK, OP_ROLL
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  pos = pop_int
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if pos < 0 || pos >= stack.size
-                  stack << stack[-pos - 1]
-                  stack.delete_at(-pos - 2) if opcode == OP_ROLL
-                when OP_ROT
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 3
-                  stack << stack[-3]
-                  stack.delete_at(-4)
-                when OP_2ROT
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 6
-                  2.times { stack << stack[-6] }
-                  2.times { stack.delete_at(-7) }
-                when OP_SWAP
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  tmp = stack.last
-                  stack[-1] = stack[-2]
-                  stack[-2] = tmp
-                when OP_2SWAP
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 4
-                  2.times {stack << stack[-4]}
-                  2.times {stack.delete_at(-5)}
-                when OP_TUCK
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  stack.insert(-3, stack.last)
-                when OP_ABS
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  v = pop_int
-                  push_int(v.abs)
-                when OP_BOOLAND
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  a, b = pop_int(2)
-                  push_int((!a.zero? && !b.zero?) ? 1 : 0)
-                when OP_BOOLOR
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  a, b = pop_int(2)
-                  push_int((!a.zero? || !b.zero?) ? 1 : 0)
-                when OP_NUMEQUAL, OP_NUMEQUALVERIFY
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  a, b = pop_int(2)
-                  result = a == b
-                  push_int(result ? 1 : 0)
-                  if opcode == OP_NUMEQUALVERIFY
-                    if result
-                      stack.pop
-                    else
-                      return set_error(SCRIPT_ERR_NUMEQUALVERIFY)
-                    end
+                end
+              when OP_LESSTHAN, OP_LESSTHANOREQUAL
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                a, b = pop_int(2)
+                push_int(a < b ? 1 : 0) if opcode == OP_LESSTHAN
+                push_int(a <= b ? 1 : 0) if opcode == OP_LESSTHANOREQUAL
+              when OP_GREATERTHAN, OP_GREATERTHANOREQUAL
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                a, b = pop_int(2)
+                push_int(a > b ? 1 : 0) if opcode == OP_GREATERTHAN
+                push_int(a >= b ? 1 : 0) if opcode == OP_GREATERTHANOREQUAL
+              when OP_MIN
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                push_int(pop_int(2).min)
+              when OP_MAX
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                push_int(pop_int(2).max)
+              when OP_WITHIN
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 3
+                x, a, b = pop_int(3)
+                push_int((a <= x && x < b) ? 1 : 0)
+              when OP_NOT
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                push_int(pop_int == 0 ? 1 : 0)
+              when OP_SIZE
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                item = stack.last
+                item = Tapyrus::Script.encode_number(item) if item.is_a?(Numeric)
+                size = item.htb.bytesize
+                push_int(size)
+              when OP_NEGATE
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                push_int(-pop_int)
+              when OP_NUMNOTEQUAL
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                a, b = pop_int(2)
+                push_int(a == b ? 0 : 1)
+              when OP_CODESEPARATOR
+                last_code_separator_index = index + 1
+              when OP_CHECKSIG, OP_CHECKSIGVERIFY
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
+                sig, pubkey = pop_string(2)
+
+                subscript = script.subscript(last_code_separator_index..-1)
+                if sig_version == :base
+                  tmp = subscript.find_and_delete(Script.new << sig)
+                  if flag?(SCRIPT_VERIFY_CONST_SCRIPTCODE) && tmp != subscript
+                    return set_error(SCRIPT_ERR_SIG_FINDANDDELETE)
                   end
-                when OP_LESSTHAN, OP_LESSTHANOREQUAL
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  a, b = pop_int(2)
-                  push_int(a < b ? 1 : 0) if opcode == OP_LESSTHAN
-                  push_int(a <= b ? 1 : 0) if opcode == OP_LESSTHANOREQUAL
-                when OP_GREATERTHAN, OP_GREATERTHANOREQUAL
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  a, b = pop_int(2)
-                  push_int(a > b ? 1 : 0) if opcode == OP_GREATERTHAN
-                  push_int(a >= b ? 1 : 0) if opcode == OP_GREATERTHANOREQUAL
-                when OP_MIN
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  push_int(pop_int(2).min)
-                when OP_MAX
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 2
-                  push_int(pop_int(2).max)
-                when OP_WITHIN
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 3
-                  x, a, b = pop_int(3)
-                  push_int((a <= x && x < b) ? 1 : 0)
-                when OP_NOT
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  push_int(pop_int == 0 ? 1 : 0)
-                when OP_SIZE
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  item = stack.last
-                  item = Tapyrus::Script.encode_number(item) if item.is_a?(Numeric)
-                  size = item.htb.bytesize
-                  push_int(size)
-                when OP_NEGATE
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
-                  push_int(-pop_int)
-                when OP_NUMNOTEQUAL
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION)  if stack.size < 2
-                  a, b = pop_int(2)
-                  push_int(a == b ? 0 : 1)
-                when OP_CODESEPARATOR
-                  last_code_separator_index = index + 1
-                when OP_CHECKSIG, OP_CHECKSIGVERIFY
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION)  if stack.size < 2
-                  sig, pubkey = pop_string(2)
-
-                  subscript = script.subscript(last_code_separator_index..-1)
-                  if sig_version == :base
-                    tmp = subscript.find_and_delete(Script.new << sig)
-                    return set_error(SCRIPT_ERR_SIG_FINDANDDELETE) if flag?(SCRIPT_VERIFY_CONST_SCRIPTCODE) && tmp != subscript
-                    subscript = tmp
+                  subscript = tmp
+                end
+                if (
+                     if sig.htb.bytesize == Tapyrus::Key::COMPACT_SIGNATURE_SIZE
+                       !check_schnorr_signature_encoding(sig)
+                     else
+                       !check_ecdsa_signature_encoding(sig)
+                     end
+                   ) || !check_pubkey_encoding(pubkey)
+                  return false
+                end
+
+                success = checker.check_sig(sig, pubkey, subscript, sig_version)
+
+                # https://github.com/bitcoin/bips/blob/master/bip-0146.mediawiki#NULLFAIL
+                if !success && flag?(SCRIPT_VERIFY_NULLFAIL) && sig.bytesize > 0
+                  return set_error(SCRIPT_ERR_SIG_NULLFAIL)
+                end
+
+                push_int(success ? 1 : 0)
+
+                if opcode == OP_CHECKSIGVERIFY
+                  if success
+                    stack.pop
+                  else
+                    return set_error(SCRIPT_ERR_CHECKSIGVERIFY)
                   end
-                  return false if (sig.htb.bytesize == Tapyrus::Key::COMPACT_SIGNATURE_SIZE ?
-                                       !check_schnorr_signature_encoding(sig) : !check_ecdsa_signature_encoding(sig)) || !check_pubkey_encoding(pubkey)
-
-                  success = checker.check_sig(sig, pubkey, subscript, sig_version)
-
-                  # https://github.com/bitcoin/bips/blob/master/bip-0146.mediawiki#NULLFAIL
-                  if !success && flag?(SCRIPT_VERIFY_NULLFAIL) && sig.bytesize > 0
-                    return set_error(SCRIPT_ERR_SIG_NULLFAIL)
-                  end
-
-                  push_int(success ? 1 : 0)
-
-                  if opcode == OP_CHECKSIGVERIFY
-                    if success
-                      stack.pop
-                    else
-                      return set_error(SCRIPT_ERR_CHECKSIGVERIFY)
-                    end
-                  end
-                when OP_CHECKDATASIG, OP_CHECKDATASIGVERIFY
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION)  if stack.size < 3
-                  sig, msg, pubkey = pop_string(3)
-                  # check signature encoding without hashtype byte
-                  return false if (sig.htb.bytesize != (Tapyrus::Key::COMPACT_SIGNATURE_SIZE - 1) && !check_ecdsa_signature_encoding(sig, true)) || !check_pubkey_encoding(pubkey)
-                  digest = Tapyrus.sha256(msg)
-                  success = checker.verify_sig(sig, pubkey, digest)
-                  return set_error(SCRIPT_ERR_SIG_NULLFAIL) if !success && flag?(SCRIPT_VERIFY_NULLFAIL) && sig.bytesize > 0
-                  push_int(success ? 1 : 0)
-                  if opcode == OP_CHECKDATASIGVERIFY
-                    stack.pop if success
-                    return set_error(SCRIPT_ERR_CHECKDATASIGVERIFY) unless success
-                  end
-                when OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION)  if stack.size < 1
-                  pubkey_count = pop_int
-                  unless (0..MAX_PUBKEYS_PER_MULTISIG).include?(pubkey_count)
-                    return set_error(SCRIPT_ERR_PUBKEY_COUNT)
-                  end
-
-                  op_count += pubkey_count
-                  return set_error(SCRIPT_ERR_OP_COUNT) if op_count > MAX_OPS_PER_SCRIPT
-
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < pubkey_count
-
-                  pubkeys = pop_string(pubkey_count)
-                  pubkeys = [pubkeys] if pubkeys.is_a?(String)
-
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION)  if stack.size < 1
-
-                  sig_count = pop_int
-                  return set_error(SCRIPT_ERR_SIG_COUNT) if sig_count < 0 || sig_count > pubkey_count
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < (sig_count)
-
-                  sigs = pop_string(sig_count)
-                  sigs = [sigs] if sigs.is_a?(String)
-                  
-                  subscript = script.subscript(last_code_separator_index..-1)
-
-                  if sig_version == :base
-                    sigs.each do |sig|
-                      tmp = subscript.find_and_delete(Script.new << sig)
-                      return set_error(SCRIPT_ERR_SIG_FINDANDDELETE) if flag?(SCRIPT_VERIFY_CONST_SCRIPTCODE) && tmp != subscript
-                      subscript = tmp
+                end
+              when OP_CHECKDATASIG, OP_CHECKDATASIGVERIFY
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 3
+                sig, msg, pubkey = pop_string(3)
+
+                # check signature encoding without hashtype byte
+                if (
+                     sig.htb.bytesize != (Tapyrus::Key::COMPACT_SIGNATURE_SIZE - 1) &&
+                       !check_ecdsa_signature_encoding(sig, true)
+                   ) || !check_pubkey_encoding(pubkey)
+                  return false
+                end
+                digest = Tapyrus.sha256(msg)
+                success = checker.verify_sig(sig, pubkey, digest)
+                if !success && flag?(SCRIPT_VERIFY_NULLFAIL) && sig.bytesize > 0
+                  return set_error(SCRIPT_ERR_SIG_NULLFAIL)
+                end
+                push_int(success ? 1 : 0)
+                if opcode == OP_CHECKDATASIGVERIFY
+                  stack.pop if success
+                  return set_error(SCRIPT_ERR_CHECKDATASIGVERIFY) unless success
+                end
+              when OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                pubkey_count = pop_int
+                return set_error(SCRIPT_ERR_PUBKEY_COUNT) unless (0..MAX_PUBKEYS_PER_MULTISIG).include?(pubkey_count)
+
+                op_count += pubkey_count
+                return set_error(SCRIPT_ERR_OP_COUNT) if op_count > MAX_OPS_PER_SCRIPT
+
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < pubkey_count
+
+                pubkeys = pop_string(pubkey_count)
+                pubkeys = [pubkeys] if pubkeys.is_a?(String)
+
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+
+                sig_count = pop_int
+                return set_error(SCRIPT_ERR_SIG_COUNT) if sig_count < 0 || sig_count > pubkey_count
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < (sig_count)
+
+                sigs = pop_string(sig_count)
+                sigs = [sigs] if sigs.is_a?(String)
+
+                subscript = script.subscript(last_code_separator_index..-1)
+
+                if sig_version == :base
+                  sigs.each do |sig|
+                    tmp = subscript.find_and_delete(Script.new << sig)
+                    if flag?(SCRIPT_VERIFY_CONST_SCRIPTCODE) && tmp != subscript
+                      return set_error(SCRIPT_ERR_SIG_FINDANDDELETE)
                     end
+                    subscript = tmp
                   end
-
-                  success = true
-                  current_sig_scheme = nil
-                  while success && sig_count > 0
-                    sig = sigs.pop
-                    pubkey = pubkeys.pop
-                    sig_scheme = sig.htb.bytesize == Tapyrus::Key::COMPACT_SIGNATURE_SIZE ? :schnorr : :ecdsa
-                    current_sig_scheme = sig_scheme if current_sig_scheme.nil?
-
-                    return false if (sig_scheme == :schnorr ? !check_schnorr_signature_encoding(sig) : !check_ecdsa_signature_encoding(sig)) || !check_pubkey_encoding(pubkey) # error already set.
-
-                    return set_error(SCRIPT_ERR_MIXED_SCHEME_MULTISIG) unless sig_scheme == current_sig_scheme
-
-                    ok = checker.check_sig(sig, pubkey, subscript, sig_version)
-                    if ok
-                      sig_count -= 1
-                    else
-                      sigs << sig
-                    end
-                    pubkey_count -= 1
-                    success = false if sig_count > pubkey_count
+                end
+
+                success = true
+                current_sig_scheme = nil
+                while success && sig_count > 0
+                  sig = sigs.pop
+                  pubkey = pubkeys.pop
+                  sig_scheme = sig.htb.bytesize == Tapyrus::Key::COMPACT_SIGNATURE_SIZE ? :schnorr : :ecdsa
+                  current_sig_scheme = sig_scheme if current_sig_scheme.nil?
+
+                  if (
+                       if sig_scheme == :schnorr
+                         !check_schnorr_signature_encoding(sig)
+                       else
+                         !check_ecdsa_signature_encoding(sig)
+                       end
+                     ) || !check_pubkey_encoding(pubkey)
+                    return false
+                  end # error already set.
+
+                  return set_error(SCRIPT_ERR_MIXED_SCHEME_MULTISIG) unless sig_scheme == current_sig_scheme
+
+                  ok = checker.check_sig(sig, pubkey, subscript, sig_version)
+                  if ok
+                    sig_count -= 1
+                  else
+                    sigs << sig
                   end
-
-                  if !success && flag?(SCRIPT_VERIFY_NULLFAIL)
-                    sigs.each do |sig|
-                      # If the operation failed, we require that all signatures must be empty vector
-                      return set_error(SCRIPT_ERR_SIG_NULLFAIL) if sig.bytesize > 0
-                    end
+                  pubkey_count -= 1
+                  success = false if sig_count > pubkey_count
+                end
+
+                if !success && flag?(SCRIPT_VERIFY_NULLFAIL)
+                  sigs.each do |sig|
+                    # If the operation failed, we require that all signatures must be empty vector
+                    return set_error(SCRIPT_ERR_SIG_NULLFAIL) if sig.bytesize > 0
                   end
-
-                  # A bug causes CHECKMULTISIG to consume one extra argument whose contents were not checked in any way.
-                  # Unfortunately this is a potential source of mutability,
-                  # so optionally verify it is exactly equal to zero prior to removing it from the stack.
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION)  if stack.size < 1
-                  return set_error(SCRIPT_ERR_SIG_NULLDUMMY) if stack[-1].size > 0
-
-                  stack.pop
-
-                  push_int(success ? 1 : 0)
-                  if opcode == OP_CHECKMULTISIGVERIFY
-                    if success
-                      stack.pop
-                    else
-                      return set_error(SCRIPT_ERR_CHECKMULTISIGVERIFY)
-                    end
+                end
+
+                # A bug causes CHECKMULTISIG to consume one extra argument whose contents were not checked in any way.
+                # Unfortunately this is a potential source of mutability,
+                # so optionally verify it is exactly equal to zero prior to removing it from the stack.
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+                return set_error(SCRIPT_ERR_SIG_NULLDUMMY) if stack[-1].size > 0
+
+                stack.pop
+
+                push_int(success ? 1 : 0)
+                if opcode == OP_CHECKMULTISIGVERIFY
+                  if success
+                    stack.pop
+                  else
+                    return set_error(SCRIPT_ERR_CHECKMULTISIGVERIFY)
                   end
-                when OP_RETURN
-                  return set_error(SCRIPT_ERR_OP_RETURN)
-                when OP_COLOR
-                  # Color id is not permitted in p2sh redeem script
-                  return set_error(SCRIPT_ERR_OP_COLOR_UNEXPECTED) if is_redeem_script
+                end
+              when OP_RETURN
+                return set_error(SCRIPT_ERR_OP_RETURN)
+              when OP_COLOR
+                # Color id is not permitted in p2sh redeem script
+                return set_error(SCRIPT_ERR_OP_COLOR_UNEXPECTED) if is_redeem_script
 
-                  # if Color id is already initialized this must be an extra
-                  return set_error(SCRIPT_ERR_OP_COLOR_MULTIPLE) if color_id && color_id.type != Tapyrus::Color::TokenTypes::NONE
+                # if Color id is already initialized this must be an extra
+                if color_id && color_id.type != Tapyrus::Color::TokenTypes::NONE
+                  return set_error(SCRIPT_ERR_OP_COLOR_MULTIPLE)
+                end
 
-                  # color id is not allowed inside OP_IF
-                  return set_error(SCRIPT_ERR_OP_COLOR_IN_BRANCH) unless flow_stack.empty?
+                # color id is not allowed inside OP_IF
+                return set_error(SCRIPT_ERR_OP_COLOR_IN_BRANCH) unless flow_stack.empty?
 
-                  # pop one stack element and verify that it exists
-                  return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size() < 1
+                # pop one stack element and verify that it exists
+                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
 
-                  color_id = Tapyrus::Color::ColorIdentifier.parse_from_payload(stack.last.htb)
+                color_id = Tapyrus::Color::ColorIdentifier.parse_from_payload(stack.last.htb)
 
-                  # check ColorIdentifier is valid
-                  return set_error(SCRIPT_ERR_OP_COLOR_ID_INVALID) unless color_id.valid?
+                # check ColorIdentifier is valid
+                return set_error(SCRIPT_ERR_OP_COLOR_ID_INVALID) unless color_id.valid?
 
-                  stack.pop
-                else
-                  return set_error(SCRIPT_ERR_BAD_OPCODE)
+                stack.pop
+              else
+                return set_error(SCRIPT_ERR_BAD_OPCODE)
               end
             end
           end
@@ -513,7 +553,7 @@ module Tapyrus
 
     # pop the item with the int value for the number specified by +count+ from the stack.
     def pop_int(count = 1)
-      i = stack.pop(count).map{ |s| cast_to_int(s) }
+      i = stack.pop(count).map { |s| cast_to_int(s) }
       count == 1 ? i.first : i
     end
 
@@ -536,14 +576,17 @@ module Tapyrus
 
     # pop the item with the string(hex) value for the number specified by +count+ from the stack.
     def pop_string(count = 1)
-      s = stack.pop(count).map do |s|
-        case s
-        when Numeric
-          Script.encode_number(s)
-        else
-          s
-        end
-      end
+      s =
+        stack
+          .pop(count)
+          .map do |s|
+            case s
+            when Numeric
+              Script.encode_number(s)
+            else
+              s
+            end
+          end
       count == 1 ? s.first : s
     end
 
@@ -555,15 +598,13 @@ module Tapyrus
     # see https://github.com/bitcoin/bitcoin/blob/master/src/script/interpreter.cpp#L36-L49
     def cast_to_bool(v)
       case v
-        when Numeric
-          return v != 0
-        when String
-          v.each_byte.with_index do |b, i|
-            return !(i == (v.bytesize - 1) && b == 0x80) unless b == 0
-          end
-          false
-        else
-          false
+      when Numeric
+        return v != 0
+      when String
+        v.each_byte.with_index { |b, i| return !(i == (v.bytesize - 1) && b == 0x80) unless b == 0 }
+        false
+      else
+        false
       end
     end
 
@@ -616,7 +657,7 @@ module Tapyrus
         return opcode == data.bytesize
       elsif data.bytesize <= 255
         return opcode == OP_PUSHDATA1
-      elsif data.bytesize <= 65535
+      elsif data.bytesize <= 65_535
         return opcode == OP_PUSHDATA2
       end
       true
@@ -626,22 +667,21 @@ module Tapyrus
       buf = StringIO.new(chunk)
       opcode = buf.read(1).ord
       offset = 1
-      len = case opcode
-              when OP_PUSHDATA1
-                offset += 1
-                buf.read(1).unpack('C').first
-              when OP_PUSHDATA2
-                offset += 2
-                buf.read(2).unpack('v').first
-              when OP_PUSHDATA4
-                offset += 4
-                buf.read(4).unpack('V').first
-              else
-                opcode
-            end
+      len =
+        case opcode
+        when OP_PUSHDATA1
+          offset += 1
+          buf.read(1).unpack('C').first
+        when OP_PUSHDATA2
+          offset += 2
+          buf.read(2).unpack('v').first
+        when OP_PUSHDATA4
+          offset += 4
+          buf.read(4).unpack('V').first
+        else
+          opcode
+        end
       chunk.bytesize == len + offset
     end
-
   end
-
-end
+end