tapyrus 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc2e90197905239fab7d891f05da735cf1fb2df0127abbb1ca38c1299130914d
-  data.tar.gz: 36a9a028b360a238077bd30c2380b3c722983d5dbd7e5f5d9e6e1d2dbd1408c0
+  metadata.gz: bfdff40e4807919098065d5d956383663673f20a264d0eaadaa89124467166f8
+  data.tar.gz: 731e768f37f843fc6a03d337e8aea349d57f23449068356348d2bef171d02a2f
 SHA512:
-  metadata.gz: e336315f9e68a361edf4b0e2dec290a6e37f666375badc13336391289b773084d57ac324fa5e1b3334faa6400d931abd24dda05345901767a29e9f11251200bc
-  data.tar.gz: a1a3df8abf276b794eed62cd7b238d57fa909315f116d5f12c4b472e32b24c8da1ff8cc62e656fb985cf5728e24a7821580b1f24f09613535a2be4b23f3bf1fa
+  metadata.gz: 0360ede886fe0a3512ea68e212270b5d931b8c085ceb04c6790978e325bc98b1d112d74deaa80232c97109c50ad8b1175566cb04ccd5324a218563677d90fbbd
+  data.tar.gz: 3f6f38a994e81c0b1d5157584cf14669ee7f8be612a6e878bf7cc216995ca60255a133b1b318e6210d6328015fdd99434bde021fd124bdc44454da564023ddab

data/README.md

@@ -1,4 +1,4 @@
-# Tapyrusrb [![Build Status](https://travis-ci.org/chaintope/tapyrusrb.svg?branch=master)](https://travis-ci.org/chaintope/tapyrusrb) [![Gem Version](https://badge.fury.io/rb/tapyrus.svg)](https://badge.fury.io/rb/tapyrus) [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE)
+# Tapyrusrb [![Build Status](https://github.com/chaintope/tapyrusrb/actions/workflows/ruby.yml/badge.svg?branch=master)](https://github.com/chaintope/tapyrusrb/actions/workflows/ruby.yml) [![Gem Version](https://badge.fury.io/rb/tapyrus.svg)](https://badge.fury.io/rb/tapyrus) [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE)
 
 Tapyrusrb is a Ruby implementation of [Tapyrus](https://github.com/chaintope/tapyrus-core) Protocol.
 

data/exe/tapyrus-script-debugger

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+
+require 'tapyrus'
+require 'terminal-table'
+
+class EmptyTxChecker
+  def check_sig(script_sig, pubkey, script_code)
+    warn "Signature verification failed. You need to enter tx and input index."
+    exit
+  end
+  def verify_sig(sig, pubkey, digest, allow_hybrid: false)
+    warn "Signature verification failed. You need to enter tx and input index."
+    exit
+  end
+end
+
+def run_step(interpreter, script, chunk, index, is_redeem_script)
+  if chunk.pushdata?
+    puts "PUSH #{chunk.pushed_data.bth}"
+  else
+    puts "APPLY #{Tapyrus::Opcodes.opcode_to_name(chunk.opcode)}"
+  end
+  result = interpreter.next_step(script, chunk, index, is_redeem_script)
+  if result.is_a?(FalseClass)
+    warn "script failed. Reason: #{interpreter.error}"
+    exit
+  end
+  rows = interpreter.stack.map{|s|[s]}.reverse
+  table = Terminal::Table.new(title: 'Current Stack', rows: rows )
+  puts table
+end
+
+print "Enter scriptPubkey: "
+script_pubkey_hex = gets.chomp
+script_pubkey = Tapyrus::Script.parse_from_payload(script_pubkey_hex.htb)
+puts script_pubkey unless script_pubkey_hex.empty?
+
+print "Enter scriptSig: "
+script_sig_hex = gets.chomp
+script_sig = Tapyrus::Script.parse_from_payload(script_sig_hex.htb)
+puts script_sig unless script_sig_hex.empty?
+
+unless script_sig.push_only?
+  warn "scriptSig has non-push opcode."
+  puts
+end
+
+if script_pubkey_hex.empty? && script_sig.empty?
+  puts "Empty script."
+  exit
+end
+
+print "Enter tx: "
+tx_hex = gets.chomp
+if tx_hex.length == 0
+  tx_checker = EmptyTxChecker.new
+else
+  print "Enter index of the input: "
+  input_index = gets.chomp
+  tx_checker = Tapyrus::TxChecker.new
+  begin
+  tx_checker.tx = Tapyrus::Tx.parse_from_payload(tx_hex.htb)
+  rescue StandardError
+    warn "Invalid tx data."
+    exit
+  end
+  if input_index.empty?
+    warn "Index of input missing."
+    exit
+  end
+  tx_checker.input_index = input_index.to_i
+  if (tx_checker.tx.in.size - 1) < tx_checker.input_index
+    warn "Tx does not have #{tx_checker.input_index}-th input."
+    exit
+  end
+end
+
+interpreter = Tapyrus::ScriptInterpreter.new(checker: tx_checker)
+
+target_script = script_sig
+is_redeem = false
+interpreter.reset_params
+chunks = target_script.chunks.each
+chunk_index = 0
+chunks_size = target_script.chunks.length
+stack_copy = nil
+
+puts "The Script is ready to be executed; you can step execution it by putting the Enter key."
+print "> "
+while cmd = gets.chomp
+  if cmd.length == 0
+    if chunks_size == chunk_index
+      if target_script == script_sig
+        stack_copy = interpreter.stack.dup
+        target_script = script_pubkey
+        interpreter.reset_params
+        chunks = target_script.chunks.each
+        chunk_index = 0
+        chunks_size = target_script.chunks.length
+      elsif target_script == script_pubkey
+        if interpreter.stack.empty? || !interpreter.cast_to_bool(interpreter.stack.last.htb)
+          warn "Script evaluated without error but finished with a false/empty top stack element"
+          exit
+        end
+        if script_pubkey.p2sh?
+          interpreter.stack = stack_copy
+          redeem_script = Tapyrus::Script.parse_from_payload(interpreter.stack.pop.htb)
+          puts "APPLY P2SH: #{redeem_script}"
+          rows = interpreter.stack.map{|s|[s]}.reverse
+          table = Terminal::Table.new(title: 'Current Stack', rows: rows )
+          puts table
+          target_script = redeem_script
+          chunks = target_script.chunks.each
+          chunk_index = 0
+          chunks_size = target_script.chunks.length
+        else
+          puts "Execution finished."
+          exit
+        end
+      else
+        puts "Execution finished."
+        exit
+      end
+    end
+    run_step(interpreter, target_script, chunks.next, chunk_index, is_redeem)
+    chunk_index += 1
+  else
+    puts "Put enter key to step execution or Ctrl+D to exit."
+  end
+  print "> "
+end

data/lib/tapyrus/block_header.rb

@@ -104,7 +104,7 @@ module Tapyrus
       end
     end
 
-    # Check this header contains upgrade aggregated publiec key.
+    # Check this header contains upgrade aggregated public key.
     # @return [Boolean] if contains return true, otherwise false.
     def upgrade_agg_pubkey?
       x_field_type == X_FILED_TYPES[:aggregate_pubkey]

data/lib/tapyrus/constants.rb

@@ -94,8 +94,6 @@ module Tapyrus
   # 80 bytes of data, +1 for OP_RETURN, +2 for the pushdata opcodes.
   MAX_OP_RETURN_RELAY = 83
 
-  SIG_VERSION = [:base]
-
   # for script error
   SCRIPT_ERR_OK = 0
   SCRIPT_ERR_UNKNOWN_ERROR = 1

data/lib/tapyrus/script/script_interpreter.rb

@@ -2,13 +2,19 @@ module Tapyrus
   class ScriptInterpreter
     include Tapyrus::Opcodes
 
-    attr_reader :stack
+    attr_accessor :stack
     attr_reader :debug
     attr_reader :flags
     attr_accessor :error
     attr_reader :checker
     attr_reader :require_minimal
 
+    attr_accessor :flow_stack
+    attr_accessor :alt_stack
+    attr_accessor :last_code_separator_index
+    attr_accessor :op_count
+    attr_accessor :color_id
+
     DISABLE_OPCODES = [
       OP_CAT,
       OP_SUBSTR,
@@ -51,11 +57,11 @@ module Tapyrus
 
       stack_copy = nil
 
-      return false unless eval_script(script_sig, :base, false)
+      return false unless eval_script(script_sig, false)
 
       stack_copy = stack.dup if flag?(SCRIPT_VERIFY_P2SH)
 
-      return false unless eval_script(script_pubkey, :base, false)
+      return false unless eval_script(script_pubkey, false)
 
       return set_error(SCRIPT_ERR_EVAL_FALSE) if stack.empty? || !cast_to_bool(stack.last.htb)
 
@@ -70,7 +76,7 @@ module Tapyrus
         rescue Exception => e
           return set_error(SCRIPT_ERR_BAD_OPCODE, "Failed to parse serialized redeem script for P2SH. #{e.message}")
         end
-        return false unless eval_script(redeem_script, :base, true)
+        return false unless eval_script(redeem_script, true)
         return set_error(SCRIPT_ERR_EVAL_FALSE) if stack.empty? || !cast_to_bool(stack.last)
       end
 
@@ -92,457 +98,473 @@ module Tapyrus
       false
     end
 
-    def eval_script(script, sig_version, is_redeem_script)
+    def eval_script(script, is_redeem_script)
       return set_error(SCRIPT_ERR_SCRIPT_SIZE) if script.size > MAX_SCRIPT_SIZE
       begin
-        flow_stack = []
-        alt_stack = []
-        last_code_separator_index = 0
-        op_count = 0
-        color_id = nil
-
-        script.chunks.each_with_index do |c, index|
-          need_exec = !flow_stack.include?(false)
+        reset_params
+        script.chunks.each_with_index do |chunk, index|
+          result = next_step(script, chunk, index, is_redeem_script)
+          return result if result.is_a?(FalseClass)
+        end
+      rescue Exception => e
+        puts e
+        puts e.backtrace
+        return set_error(SCRIPT_ERR_UNKNOWN_ERROR, e.message)
+      end
 
-          return set_error(SCRIPT_ERR_PUSH_SIZE) if c.pushdata? && c.pushed_data.bytesize > MAX_SCRIPT_ELEMENT_SIZE
+      return set_error(SCRIPT_ERR_UNBALANCED_CONDITIONAL) unless @flow_stack.empty?
 
-          opcode = c.opcode
+      set_error(SCRIPT_ERR_OK)
+      true
+    end
 
-          if need_exec && c.pushdata?
-            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
-            if opcode > OP_16 && (op_count += 1) > MAX_OPS_PER_SCRIPT
-              return set_error(SCRIPT_ERR_OP_COUNT)
-            end
-            return set_error(SCRIPT_ERR_DISABLED_OPCODE) if DISABLE_OPCODES.include?(opcode)
-            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
-                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
-                  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
-                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
-                  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
+    def next_step(script, c, index, is_redeem_script)
+      need_exec = !@flow_stack.include?(false)
 
-                success = checker.check_sig(sig, pubkey, subscript, sig_version)
+      return set_error(SCRIPT_ERR_PUSH_SIZE) if c.pushdata? && c.pushed_data.bytesize > MAX_SCRIPT_ELEMENT_SIZE
 
-                # 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
+      opcode = c.opcode
 
-                push_int(success ? 1 : 0)
+      if need_exec && c.pushdata?
+        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
+        if opcode > OP_16 && (@op_count += 1) > MAX_OPS_PER_SCRIPT
+          return set_error(SCRIPT_ERR_OP_COUNT)
+        end
+        return set_error(SCRIPT_ERR_DISABLED_OPCODE) if DISABLE_OPCODES.include?(opcode)
+        if opcode == OP_CODESEPARATOR && flag?(SCRIPT_VERIFY_CONST_SCRIPTCODE)
+          return set_error(SCRIPT_ERR_OP_CODESEPARATOR)
+        end
 
-                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
-                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
+        # next unless (need_exec || (OP_IF <= opcode && opcode <= OP_ENDIF))
+        return 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
+            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
-              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
+              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 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 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
+            return 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
+            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)
+            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
+
+            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
 
-                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < pubkey_count
+            success = checker.check_sig(sig, pubkey, subscript)
 
-                pubkeys = pop_string(pubkey_count)
-                pubkeys = [pubkeys] if pubkeys.is_a?(String)
+            # https://github.com/bitcoin/bips/blob/master/bip-0146.mediawiki#NULLFAIL
+            return set_error(SCRIPT_ERR_SIG_NULLFAIL) if !success && flag?(SCRIPT_VERIFY_NULLFAIL) && sig.bytesize > 0
 
-                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+            push_int(success ? 1 : 0)
 
-                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)
+            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
+            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)
+            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
+            return set_error(SCRIPT_ERR_PUBKEY_COUNT) unless (0..MAX_PUBKEYS_PER_MULTISIG).include?(pubkey_count)
 
-                sigs = pop_string(sig_count)
-                sigs = [sigs] if sigs.is_a?(String)
+            @op_count += pubkey_count
+            return set_error(SCRIPT_ERR_OP_COUNT) if @op_count > MAX_OPS_PER_SCRIPT
 
-                subscript = script.subscript(last_code_separator_index..-1)
+            return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < pubkey_count
 
-                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
-                end
+            pubkeys = pop_string(pubkey_count)
+            pubkeys = [pubkeys] if pubkeys.is_a?(String)
 
-                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
-                  pubkey_count -= 1
-                  success = false if sig_count > pubkey_count
-                end
+            return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
 
-                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
-                end
+            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)
 
-                # 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
+            sigs = pop_string(sig_count)
+            sigs = [sigs] if sigs.is_a?(String)
 
-                stack.pop
+            subscript = script.subscript(@last_code_separator_index..-1)
 
-                push_int(success ? 1 : 0)
-                if opcode == OP_CHECKMULTISIGVERIFY
-                  if success
-                    stack.pop
-                  else
-                    return set_error(SCRIPT_ERR_CHECKMULTISIGVERIFY)
-                  end
-                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
-                if color_id && color_id.type != Tapyrus::Color::TokenTypes::NONE
-                  return set_error(SCRIPT_ERR_OP_COLOR_MULTIPLE)
-                end
+            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
 
-                # color id is not allowed inside OP_IF
-                return set_error(SCRIPT_ERR_OP_COLOR_IN_BRANCH) unless flow_stack.empty?
+            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)
+              if ok
+                sig_count -= 1
+              else
+                sigs << sig
+              end
+              pubkey_count -= 1
+              success = false if sig_count > pubkey_count
+            end
 
-                # pop one stack element and verify that it exists
-                return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
+            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
+            end
 
-                color_id = Tapyrus::Color::ColorIdentifier.parse_from_payload(stack.last.htb)
+            # 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
 
-                # check ColorIdentifier is valid
-                return set_error(SCRIPT_ERR_OP_COLOR_ID_INVALID) unless color_id.valid?
+            stack.pop
 
+            push_int(success ? 1 : 0)
+            if opcode == OP_CHECKMULTISIGVERIFY
+              if success
                 stack.pop
               else
-                return set_error(SCRIPT_ERR_BAD_OPCODE)
+                return set_error(SCRIPT_ERR_CHECKMULTISIGVERIFY)
               end
             end
-          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
+            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?
 
-          # max stack size check
-          return set_error(SCRIPT_ERR_STACK_SIZE) if stack.size + alt_stack.size > MAX_STACK_SIZE
+            # 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)
+
+            # 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)
+          end
         end
-      rescue Exception => e
-        puts e
-        puts e.backtrace
-        return set_error(SCRIPT_ERR_UNKNOWN_ERROR, e.message)
       end
 
-      return set_error(SCRIPT_ERR_UNBALANCED_CONDITIONAL) unless flow_stack.empty?
+      # max stack size check
+      return set_error(SCRIPT_ERR_STACK_SIZE) if stack.size + @alt_stack.size > MAX_STACK_SIZE
+    end
 
-      set_error(SCRIPT_ERR_OK)
-      true
+    def reset_params
+      @flow_stack = []
+      @alt_stack = []
+      @last_code_separator_index = 0
+      @op_count = 0
+      @color_id = nil
+    end
+
+    # 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 { |b, i| return !(i == (v.bytesize - 1) && b == 0x80) unless b == 0 }
+        false
+      else
+        false
+      end
     end
 
     private
@@ -595,19 +617,6 @@ module Tapyrus
       cast_to_bool(pop_string.htb)
     end
 
-    # 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 { |b, i| return !(i == (v.bytesize - 1) && b == 0x80) unless b == 0 }
-        false
-      else
-        false
-      end
-    end
-
     def check_ecdsa_signature_encoding(sig, data_sig = false)
       return true if sig.size.zero?
       if !Key.valid_signature_encoding?(sig.htb, data_sig)

data/lib/tapyrus/script/tx_checker.rb

@@ -1,12 +1,10 @@
 module Tapyrus
   class TxChecker
-    attr_reader :tx
-    attr_reader :input_index
-    attr_reader :amount
+    attr_accessor :tx
+    attr_accessor :input_index
 
-    def initialize(tx: nil, amount: 0, input_index: nil)
+    def initialize(tx: nil, input_index: nil)
       @tx = tx
-      @amount = amount
       @input_index = input_index
     end
 
@@ -14,15 +12,13 @@ module Tapyrus
     # @param [String] script_sig a signature with hex format.
     # @param [String] pubkey a public key with hex format.
     # @param [Tapyrus::Script] script_code
-    # @param [Integer] sig_version
     # @return [Boolean] if check is passed return true, otherwise false.
-    def check_sig(script_sig, pubkey, script_code, sig_version)
+    def check_sig(script_sig, pubkey, script_code)
       return false if script_sig.empty?
       script_sig = script_sig.htb
       hash_type = script_sig[-1].unpack('C').first
       sig = script_sig[0..-2]
-      sighash =
-        tx.sighash_for_input(input_index, script_code, hash_type: hash_type, amount: amount, sig_version: sig_version)
+      sighash = tx.sighash_for_input(input_index, script_code, hash_type: hash_type)
       verify_sig(sig.bth, pubkey, sighash)
     end
 

data/lib/tapyrus/tx.rb

@@ -103,34 +103,23 @@ module Tapyrus
       to_payload.bytesize
     end
 
-    # get signature hash
+    # Generate signature hash
     # @param [Integer] input_index input index.
     # @param [Integer] hash_type signature hash type
-    # @param [Tapyrus::Script] output_script script pubkey or script code. if script pubkey is P2WSH, set witness script to this.
-    # @param [Integer] amount tapyrus amount locked in input. required for witness input only.
-    # @param [Integer] skip_separator_index If output_script is P2WSH and output_script contains any OP_CODESEPARATOR,
-    # the script code needs  is the witnessScript but removing everything up to and including the last executed OP_CODESEPARATOR before the signature checking opcode being executed.
-    def sighash_for_input(
-      input_index,
-      output_script,
-      hash_type: SIGHASH_TYPE[:all],
-      sig_version: :base,
-      amount: nil,
-      skip_separator_index: 0
-    )
+    # @param [Tapyrus::Script] output_script script pubkey or script code. if script pubkey is P2SH, set redeem script to this.
+    # @return [String] sighash
+    def sighash_for_input(input_index, output_script, hash_type: SIGHASH_TYPE[:all])
       raise ArgumentError, 'input_index must be specified.' unless input_index
       raise ArgumentError, 'does not exist input corresponding to input_index.' if input_index >= inputs.size
       raise ArgumentError, 'script_pubkey must be specified.' unless output_script
-      raise ArgumentError, 'unsupported sig version specified.' unless SIG_VERSION.include?(sig_version)
       sighash_for_legacy(input_index, output_script, hash_type)
     end
 
     # verify input signature.
     # @param [Integer] input_index
     # @param [Tapyrus::Script] script_pubkey the script pubkey for target input.
-    # @param [Integer] amount the amount of tapyrus, require for witness program only.
     # @param [Array] flags the flags used when execute script interpreter.
-    def verify_input_sig(input_index, script_pubkey, amount: nil, flags: STANDARD_SCRIPT_VERIFY_FLAGS)
+    def verify_input_sig(input_index, script_pubkey, flags: STANDARD_SCRIPT_VERIFY_FLAGS)
       flags << SCRIPT_VERIFY_P2SH if script_pubkey.p2sh?
       verify_input_sig_for_legacy(input_index, script_pubkey, flags)
     end
@@ -207,7 +196,9 @@ module Tapyrus
       checker = Tapyrus::TxChecker.new(tx: self, input_index: input_index)
       interpreter = Tapyrus::ScriptInterpreter.new(checker: checker, flags: flags)
 
-      interpreter.verify_script(script_sig, script_pubkey)
+      result = interpreter.verify_script(script_sig, script_pubkey)
+      warn("Verify failed. Cause: #{interpreter.error}") unless result
+      result
     end
   end
 end

data/lib/tapyrus/tx_builder.rb

@@ -89,9 +89,11 @@ module Tapyrus
         script_pubkey = script_pubkey.add_color(color_id)
       end
 
+      output = Tapyrus::TxOut.new(script_pubkey: script_pubkey, value: value)
+      raise ArgumentError, 'The transaction amount is too small' if color_id.default? && output.dust?
       @outgoings[color_id] ||= 0
       @outgoings[color_id] += value
-      @outputs << Tapyrus::TxOut.new(script_pubkey: script_pubkey, value: value)
+      @outputs << output
       self
     end
 
@@ -136,13 +138,16 @@ module Tapyrus
     def add_change(tx)
       @incomings.each do |color_id, in_amount|
         out_amount = @outgoings[color_id] || 0
-        change, script_pubkey =
+        output =
           if color_id.default?
-            [in_amount - out_amount - estimated_fee, @change_script_pubkey]
+            change = in_amount - out_amount - estimated_fee
+            change_output = Tapyrus::TxOut.new(script_pubkey: @change_script_pubkey, value: change)
+            change_output unless change_output.dust?
           else
-            [in_amount - out_amount, @change_script_pubkey.add_color(color_id)]
+            change = in_amount - out_amount
+            Tapyrus::TxOut.new(script_pubkey: @change_script_pubkey.add_color(color_id), value: change) if change > 0
           end
-        tx.outputs << Tapyrus::TxOut.new(script_pubkey: script_pubkey, value: change) if change > 0
+        tx.outputs << output if output
       end
     end
 

data/lib/tapyrus/version.rb

@@ -1,3 +1,3 @@
 module Tapyrus
-  VERSION = '0.3.1'
+  VERSION = '0.3.2'
 end

data/tapyrusrb.gemspec

@@ -31,6 +31,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'siphash'
   spec.add_runtime_dependency 'activesupport', '>= 5.2.3'
   spec.add_runtime_dependency 'json_pure', '>= 2.3.1'
+  spec.add_runtime_dependency 'terminal-table', '~> 3.0.2'
 
   # for options
   spec.add_development_dependency 'leveldb-native'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tapyrus
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-05-23 00:00:00.000000000 Z
+date: 2022-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa
@@ -178,6 +178,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.3.1
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.2
 - !ruby/object:Gem::Dependency
   name: leveldb-native
   requirement: !ruby/object:Gem::Requirement
@@ -280,6 +294,7 @@ description: The implementation of Tapyrus Protocol for Ruby.
 email:
 - azuchi@chaintope.com
 executables:
+- tapyrus-script-debugger
 - tapyrusrb-cli
 - tapyrusrbd
 extensions: []
@@ -299,6 +314,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- exe/tapyrus-script-debugger
 - exe/tapyrusrb-cli
 - exe/tapyrusrbd
 - lib/openassets.rb
@@ -440,7 +456,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.21
 signing_key: 
 specification_version: 4
 summary: The implementation of Tapyrus Protocol for Ruby.