tapyrus 0.1.0 → 0.2.4

data/lib/tapyrus/script/color.rb

@@ -0,0 +1,79 @@
+module Tapyrus
+  module Color
+    module TokenTypes
+      NONE = 0x00
+      REISSUABLE = 0xC1
+      NON_REISSUABLE = 0xC2
+      NFT = 0xC3
+    end
+
+    class ColorIdentifier
+      include Tapyrus::HexConverter
+
+      attr_reader :type, :payload
+
+      def self.reissuable(script_pubkey)
+        new(TokenTypes::REISSUABLE, Tapyrus.sha256(script_pubkey.to_payload))
+      end
+
+      def self.non_reissuable(out_point)
+        new(TokenTypes::NON_REISSUABLE, Tapyrus.sha256(out_point.to_payload))
+      end
+
+      def self.nft(out_point)
+        new(TokenTypes::NFT, Tapyrus.sha256(out_point.to_payload))
+      end
+
+      def to_payload
+        [type, payload].pack('Ca*')
+      end
+
+      def self.parse_from_payload(payload)
+        type, payload = payload.unpack('Ca*')
+        new(type, payload)
+      end
+
+      def ==(other)
+        other && other.to_payload == to_payload
+      end
+
+      def valid?
+        return false unless [TokenTypes::REISSUABLE, TokenTypes::NON_REISSUABLE, TokenTypes::NFT].include?(type)
+        return false unless payload.bytesize == 32
+        true
+      end
+
+      private
+
+      def initialize(type, payload)
+        @type = type
+        @payload = payload
+      end
+    end
+
+    module ColoredOutput
+      def colored?
+        script_pubkey.cp2pkh? || script_pubkey.cp2sh?
+      end
+
+      def color_id
+        @color_id ||= ColorIdentifier.parse_from_payload(script_pubkey.chunks[0].pushed_data)
+      end
+
+      def reissuable?
+        return false unless colored?
+        color_id.type == TokenTypes::REISSUABLE
+      end
+
+      def non_reissuable?
+        return false unless colored?
+        color_id.type == TokenTypes::NON_REISSUABLE
+      end
+
+      def nft?
+        return false unless colored?
+        color_id.type == TokenTypes::NFT
+      end
+    end
+  end
+end

data/lib/tapyrus/script/multisig.rb

@@ -61,32 +61,5 @@ module Tapyrus
       prefix + pubkeys.map { |k| sigs[k] ? Tapyrus::Script.pack_pushdata(sigs[k]) : nil }.join +
         Tapyrus::Script.pack_pushdata(script.chunks[-1].pushed_data)
     end
-
-    def self.add_sig_to_multisig_script_witness(sig_to_add, script_witness, hash_type = SIGHASH_TYPE[:all])
-      signature = sig_to_add + [hash_type].pack("C*")
-      script_witness.stack << signature
-    end
-
-    # Sort signatures in the given +script_witness+ according to the order of pubkeys in
-    # the redeem script. Also needs the +sig_hash+ to match signatures to pubkeys.
-    # @param [ScriptWitness] script_witness for multisig.
-    # @param [String] sig_hash to be signed.
-    def self.sort_witness_multisig_signatures(script_witness, sig_hash)
-      redeem_script = Tapyrus::Script.parse_from_payload(script_witness.stack[-1])
-      pubkeys = redeem_script.get_multisig_pubkeys
-      sigs = Hash[script_witness.stack[1...-1].map.with_index do |sig, idx|
-        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]
-      script_witness.stack.clear
-      script_witness.stack << ''
-      pubkeys.each do |pubkey|
-        script_witness.stack << sigs[pubkey] if sigs[pubkey]
-      end
-      script_witness.stack << redeem_script.to_payload
-    end
   end
 end

data/lib/tapyrus/script/script.rb

@@ -5,6 +5,7 @@ module Tapyrus
 
   # tapyrus script
   class Script
+    include Tapyrus::HexConverter
     include Tapyrus::Opcodes
 
     attr_accessor :chunks
@@ -18,11 +19,6 @@ module Tapyrus
       new << OP_DUP << OP_HASH160 << pubkey_hash << OP_EQUALVERIFY << OP_CHECKSIG
     end
 
-    # generate P2WPKH script
-    def self.to_p2wpkh(pubkey_hash)
-      new << WITNESS_VERSION << pubkey_hash
-    end
-
     # generate m of n multisig p2sh script
     # @param [String] m the number of signatures required for multisig
     # @param [Array] pubkeys array of public keys that compose multisig
@@ -45,6 +41,40 @@ module Tapyrus
       Script.to_p2sh(to_hash160)
     end
 
+    # generate cp2pkh script
+    # @param [ColorIdentifier] color identifier
+    # @param [String] hash160 of pubkey
+    # @return [Script] CP2PKH script
+    # @raise [ArgumentError] if color_id is nil or invalid
+    def self.to_cp2pkh(color_id, pubkey_hash)
+      raise ArgumentError, 'Specified color identifier is invalid' unless color_id&.valid?
+      new << color_id.to_payload << OP_COLOR << OP_DUP << OP_HASH160 << pubkey_hash << OP_EQUALVERIFY << OP_CHECKSIG
+    end
+
+    # generate cp2sh script
+    # @param [ColorIdentifier] color identifier
+    # @param [String] hash160 of script
+    # @return [Script] CP2SH script
+    # @raise [ArgumentError] if color_id is nil or invalid
+    def self.to_cp2sh(color_id, script_hash)
+      raise ArgumentError, 'Specified color identifier is invalid' unless color_id&.valid?
+      new << color_id.to_payload << OP_COLOR << OP_HASH160 << script_hash << OP_EQUAL
+    end
+
+    # Add color identifier to existing p2pkh or p2sh
+    # @param [ColorIdentifier] color identifier
+    # @return [Script] CP2PKH or CP2SH script
+    # @raise [ArgumentError] if color_id is nil or invalid
+    # @raise [RuntimeError] if script is neither p2pkh nor p2sh
+    def add_color(color_id)
+      raise ArgumentError, 'Specified color identifier is invalid' unless color_id&.valid?
+      raise RuntimeError, 'Only p2pkh and p2sh can add color' unless p2pkh? or p2sh?
+      Tapyrus::Script.new.tap do |s|
+        s << color_id.to_payload << OP_COLOR
+        s.chunks += self.chunks
+      end
+    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 }
@@ -59,13 +89,6 @@ module Tapyrus
       new << m << pubkeys << pubkeys.size << OP_CHECKMULTISIG
     end
 
-    # generate p2wsh script for +redeem_script+
-    # @param [Script] redeem_script target redeem script
-    # @param [Script] p2wsh script
-    def self.to_p2wsh(redeem_script)
-      new << WITNESS_VERSION << redeem_script.to_sha256
-    end
-
     # generate script from string.
     def self.from_string(string)
       script = new
@@ -151,14 +174,15 @@ module Tapyrus
     def addresses
       return [p2pkh_addr] if p2pkh?
       return [p2sh_addr] if p2sh?
-      return [bech32_addr] if witness_program?
+      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?
       []
     end
 
     # check whether standard script.
     def standard?
-      p2pkh? | p2sh? | p2wpkh? | p2wsh? | multisig? | standard_op_return?
+      p2pkh? | p2sh? | multisig? | standard_op_return?
     end
 
     # whether this script is a P2PKH format script.
@@ -168,17 +192,6 @@ module Tapyrus
           (chunks[0..1]+ chunks[3..4]).map(&:ord) && chunks[2].bytesize == 21
     end
 
-    # whether this script is a P2WPKH format script.
-    def p2wpkh?
-      return false unless chunks.size == 2
-      chunks[0].ord == WITNESS_VERSION && chunks[1].bytesize == 21
-    end
-
-    def p2wsh?
-      return false unless chunks.size == 2
-      chunks[0].ord == WITNESS_VERSION && chunks[1].bytesize == 33
-    end
-
     def p2sh?
       return false unless chunks.size == 3
       OP_HASH160 == chunks[0].ord && OP_EQUAL == chunks[2].ord && chunks[1].bytesize == 21
@@ -201,6 +214,23 @@ module Tapyrus
           (chunks.size == 1 || chunks[1].opcode <= OP_16)
     end
 
+    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
+    end
+
+    def cp2sh?
+      return false unless chunks.size == 5
+      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_HASH160 == chunks[2].ord && OP_EQUAL == chunks[4].ord && chunks[3].bytesize == 21
+    end
+
     def op_return_data
       return nil unless op_return?
       return nil if chunks.size == 1
@@ -221,50 +251,15 @@ module Tapyrus
       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}
     end
 
-    # A witness program is any valid Script that consists of a 1-byte push opcode followed by a data push between 2 and 40 bytes.
-    def witness_program?
-      return false if size < 4 || size > 42 || chunks.size < 2
-
-      opcode = chunks[0].opcode
-
-      return false if opcode != OP_0 && (opcode < OP_1 || opcode > OP_16)
-      return false unless chunks[1].pushdata?
-
-      if size == (chunks[1][0].unpack('C').first + 2)
-        program_size = chunks[1].pushed_data.bytesize
-        return program_size >= 2 && program_size <= 40
-      end
-
-      false
-    end
-
-    # get witness commitment
-    def witness_commitment
-      return nil if !op_return? || op_return_data.bytesize < 36
-      buf = StringIO.new(op_return_data)
-      return nil unless buf.read(4).bth == WITNESS_COMMITMENT_HEADER
-      buf.read(32).bth
-    end
-
-    # If this script is witness program, return its script code,
-    # otherwise returns the self payload. ScriptInterpreter does not use this.
+    # returns the self payload. ScriptInterpreter does not use this.
     def to_script_code(skip_separator_index = 0)
       payload = to_payload
-      if p2wpkh?
-        payload = Script.to_p2pkh(chunks[1].pushed_data.bth).to_payload
-      elsif skip_separator_index > 0
+      if skip_separator_index > 0
         payload = subscript_codeseparator(skip_separator_index)
       end
       Tapyrus.pack_var_string(payload)
     end
 
-    # get witness version and witness program
-    def witness_data
-      version = opcode_to_small_int(chunks[0].opcode)
-      program = chunks[1].pushed_data
-      [version, program]
-    end
-
     # append object to payload
     def <<(obj)
       if obj.is_a?(Integer)
@@ -324,6 +319,7 @@ module Tapyrus
         when Integer
           opcode_to_name(c)
         when String
+          return c if c.empty?
           if c.pushdata?
             v = Opcodes.opcode_to_small_int(c.ord)
             if v
@@ -351,7 +347,7 @@ module Tapyrus
 
     # generate hash160 hash for payload
     def to_hash160
-      Tapyrus.hash160(to_payload.bth)
+      Tapyrus.hash160(to_hex)
     end
 
     # script size
@@ -482,13 +478,11 @@ module Tapyrus
       return 'pubkeyhash' if p2pkh?
       return 'scripthash' if p2sh?
       return 'multisig' if multisig?
-      return 'witness_v0_keyhash' if p2wpkh?
-      return 'witness_v0_scripthash' if p2wsh?
       'nonstandard'
     end
 
     def to_h
-      h = {asm: to_s, hex: to_payload.bth, 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
@@ -504,48 +498,39 @@ module Tapyrus
       (size > 0 && op_return?) || size > Tapyrus::MAX_SCRIPT_SIZE
     end
 
-    # convert payload to hex data.
-    # @return [String] script with hex format.
-    def to_hex
-      to_payload.bth
-    end
-
     private
 
     # generate p2pkh address. if script dose not p2pkh, return nil.
     def p2pkh_addr
       return nil unless p2pkh?
       hash160 = chunks[2].pushed_data.bth
-      return nil unless hash160.htb.bytesize == 20
       Tapyrus.encode_base58_address(hash160, Tapyrus.chain_params.address_version)
     end
 
-    # generate p2wpkh address. if script dose not p2wpkh, return nil.
-    def p2wpkh_addr
-      p2wpkh? ? bech32_addr : nil
-    end
-
     # generate p2sh address. if script dose not p2sh, return nil.
     def p2sh_addr
       return nil unless p2sh?
       hash160 = chunks[1].pushed_data.bth
-      return nil unless hash160.htb.bytesize == 20
       Tapyrus.encode_base58_address(hash160, Tapyrus.chain_params.p2sh_version)
     end
 
-    # generate p2wsh address. if script dose not p2wsh, return nil.
-    def p2wsh_addr
-      p2wsh? ? bech32_addr : nil
-    end
+    # generate cp2pkh address. if script dose not cp2pkh, return nil.
+    def cp2pkh_addr
+      return nil unless cp2pkh?
 
-    # return bech32 address for payload
-    def bech32_addr
-      segwit_addr = Bech32::SegwitAddr.new
-      segwit_addr.hrp = Tapyrus.chain_params.bech32_hrp
-      segwit_addr.script_pubkey = to_payload.bth
-      segwit_addr.addr
+      color_id = chunks[0].pushed_data.bth
+      hash160 = chunks[4].pushed_data.bth
+      Tapyrus.encode_base58_address(color_id + hash160, Tapyrus.chain_params.cp2pkh_version)
     end
 
+    # generate cp2sh address. if script dose not cp2sh, return nil.
+    def cp2sh_addr
+      return nil unless cp2sh?
+
+      color_id = chunks[0].pushed_data.bth
+      hash160 = chunks[3].pushed_data.bth
+      Tapyrus.encode_base58_address(color_id + hash160, Tapyrus.chain_params.cp2sh_version)
+    end
   end
 
 end

data/lib/tapyrus/script/script_error.rb

@@ -78,24 +78,18 @@ module Tapyrus
         'Witness version reserved for soft-fork upgrades'
       when SCRIPT_ERR_PUBKEYTYPE
         'Public key is neither compressed or uncompressed'
-      when SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH
-        'Witness program has incorrect length'
-      when SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY
-        'Witness program was passed an empty witness'
-      when SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH
-        'Witness program hash mismatch'
-      when SCRIPT_ERR_WITNESS_MALLEATED
-        'Witness requires empty scriptSig'
-      when SCRIPT_ERR_WITNESS_MALLEATED_P2SH
-        'Witness requires only-redeemscript scriptSig'
-      when SCRIPT_ERR_WITNESS_UNEXPECTED
-        'Witness provided for non-witness script'
-      when SCRIPT_ERR_WITNESS_PUBKEYTYPE
-        'Using non-compressed keys in segwit'
       when SCRIPT_ERR_OP_CODESEPARATOR
         'Using OP_CODESEPARATOR in non-witness scrip'
       when SCRIPT_ERR_SIG_FINDANDDELETE
         'Signature is found in scriptCode'
+      when SCRIPT_ERR_OP_COLOR_UNEXPECTED
+        'Unexpected OP_COLOR in script'
+      when SCRIPT_ERR_OP_COLOR_ID_INVALID
+        'Invalid ColorId in script'
+      when SCRIPT_ERR_OP_COLOR_MULTIPLE
+        'Multiple OP_COLOR found in script'
+      when SCRIPT_ERR_OP_COLOR_IN_BRANCH
+        'OP_COLOR is not permitted in a script branch'
       when SCRIPT_ERR_UNKNOWN_ERROR, SCRIPT_ERR_ERROR_COUNT
         'unknown error'
       else

data/lib/tapyrus/script/script_interpreter.rb

@@ -32,32 +32,21 @@ module Tapyrus
     # eval script
     # @param [Tapyrus::Script] script_sig a signature script (unlock script which data push only)
     # @param [Tapyrus::Script] script_pubkey a script pubkey (locking script)
-    # @param [Tapyrus::ScriptWitness] witness a witness script
     # @return [Boolean] result
-    def verify_script(script_sig, script_pubkey, witness = ScriptWitness.new)
+    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
-      had_witness = false
 
-      return false unless eval_script(script_sig, :base)
+      return false unless eval_script(script_sig, :base, false)
 
       stack_copy = stack.dup if flag?(SCRIPT_VERIFY_P2SH)
 
-      return false unless eval_script(script_pubkey, :base)
+      return false unless eval_script(script_pubkey, :base, false)
 
       return set_error(SCRIPT_ERR_EVAL_FALSE) if stack.empty? || !cast_to_bool(stack.last.htb)
 
-      # Bare witness programs
-      if flag?(SCRIPT_VERIFY_WITNESS) && script_pubkey.witness_program?
-        had_witness = true
-        return set_error(SCRIPT_ERR_WITNESS_MALLEATED) unless script_sig.size == 0
-        version, program = script_pubkey.witness_data
-        stack_copy = stack.dup
-        return false unless verify_witness_program(witness, version, program)
-      end
-
       # Additional validation for spend-to-script-hash transactions
       if flag?(SCRIPT_VERIFY_P2SH) && script_pubkey.p2sh?
         return set_error(SCRIPT_ERR_SIG_PUSHONLY) unless script_sig.push_only?
@@ -69,18 +58,8 @@ 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)
+        return false unless eval_script(redeem_script, :base, true)
         return set_error(SCRIPT_ERR_EVAL_FALSE) if stack.empty? || !cast_to_bool(stack.last)
-
-        # P2SH witness program
-        if flag?(SCRIPT_VERIFY_WITNESS) && redeem_script.witness_program?
-          had_witness = true
-          # The scriptSig must be _exactly_ a single push of the redeemScript. Otherwise we reintroduce malleability.
-          return set_error(SCRIPT_ERR_WITNESS_MALLEATED_P2SH) unless script_sig == (Tapyrus::Script.new << redeem_script.to_payload.bth)
-
-          version, program = redeem_script.witness_data
-          return false unless verify_witness_program(witness, version, program)
-        end
       end
 
       # The CLEANSTACK check is only performed after potential P2SH evaluation,
@@ -93,11 +72,6 @@ module Tapyrus
         return set_error(SCRIPT_ERR_CLEANSTACK) unless stack.size == 1
       end
 
-      if flag?(SCRIPT_VERIFY_WITNESS)
-        raise 'assert' unless flag?(SCRIPT_VERIFY_P2SH)
-        return set_error(SCRIPT_ERR_WITNESS_UNEXPECTED) if !had_witness && !witness.empty?
-      end
-
       true
     end
 
@@ -106,45 +80,14 @@ module Tapyrus
       false
     end
 
-    def verify_witness_program(witness, version, program)
-      if version == 0
-        if program.bytesize == 32
-          return set_error(SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY) if witness.stack.size == 0
-          script_pubkey = Tapyrus::Script.parse_from_payload(witness.stack.last)
-          @stack = witness.stack[0..-2].map{|w|w.bth}
-          script_hash = Tapyrus.sha256(script_pubkey.to_payload)
-          return set_error(SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH) unless script_hash == program
-        elsif program.bytesize == 20
-          return set_error(SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH) unless witness.stack.size == 2
-          script_pubkey = Tapyrus::Script.to_p2pkh(program.bth)
-          @stack = witness.stack.map{|w|w.bth}
-        else
-          return set_error(SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH)
-        end
-      elsif flag?(SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM)
-        return set_error(SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM)
-      else
-        return true # Higher version witness scripts return true for future softfork compatibility
-      end
-
-      stack.each do |s| # Disallow stack item size > MAX_SCRIPT_ELEMENT_SIZE in witness stack
-        return set_error(SCRIPT_ERR_PUSH_SIZE) if s.htb.bytesize > MAX_SCRIPT_ELEMENT_SIZE
-      end
-
-      return false unless eval_script(script_pubkey, :witness_v0)
-
-      return set_error(SCRIPT_ERR_EVAL_FALSE) unless stack.size == 1
-      return set_error(SCRIPT_ERR_EVAL_FALSE) unless cast_to_bool(stack.last)
-      true
-    end
-
-    def eval_script(script, sig_version)
+    def eval_script(script, sig_version, 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)
@@ -209,7 +152,7 @@ module Tapyrus
                   if need_exec
                     return set_error(SCRIPT_ERR_UNBALANCED_CONDITIONAL) if stack.size < 1
                     value = pop_string.htb
-                    if sig_version == :witness_v0 && flag?(SCRIPT_VERIFY_MINIMALIF)
+                    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
@@ -409,8 +352,8 @@ module Tapyrus
                     return set_error(SCRIPT_ERR_SIG_FINDANDDELETE) if flag?(SCRIPT_VERIFY_CONST_SCRIPTCODE) && tmp != subscript
                     subscript = tmp
                   end
-
-                  return false if !check_pubkey_encoding(pubkey, sig_version) || !check_signature_encoding(sig) # error already set.
+                  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)
 
@@ -428,6 +371,19 @@ module Tapyrus
                       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
@@ -463,10 +419,17 @@ module Tapyrus
                   end
 
                   success = true
+                  current_sig_scheme = nil
                   while success && sig_count > 0
                     sig = sigs.pop
                     pubkey = pubkeys.pop
-                    return false if !check_pubkey_encoding(pubkey, sig_version) || !check_signature_encoding(sig) # error already set.
+                    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
@@ -488,9 +451,8 @@ module Tapyrus
                   # 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
-                  if flag?(SCRIPT_VERIFY_NULLDUMMY) && stack[-1].size > 0
-                    return set_error(SCRIPT_ERR_SIG_NULLDUMMY)
-                  end
+                  return set_error(SCRIPT_ERR_SIG_NULLDUMMY) if stack[-1].size > 0
+
                   stack.pop
 
                   push_int(success ? 1 : 0)
@@ -503,6 +465,25 @@ module Tapyrus
                   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
+
+                  # 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
+
+                  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
@@ -586,20 +567,26 @@ module Tapyrus
       end
     end
 
-    def check_signature_encoding(sig)
+    def check_ecdsa_signature_encoding(sig, data_sig = false)
       return true if sig.size.zero?
-      if (flag?(SCRIPT_VERIFY_DERSIG) || flag?(SCRIPT_VERIFY_LOW_S) || flag?(SCRIPT_VERIFY_STRICTENC)) && !Key.valid_signature_encoding?(sig.htb)
+      if !Key.valid_signature_encoding?(sig.htb, data_sig)
         return set_error(SCRIPT_ERR_SIG_DER)
-      elsif flag?(SCRIPT_VERIFY_LOW_S) && !low_der_signature?(sig)
+      elsif !low_der_signature?(sig, data_sig)
         return false
-      elsif flag?(SCRIPT_VERIFY_STRICTENC) && !defined_hashtype_signature?(sig)
+      elsif !data_sig && !defined_hashtype_signature?(sig)
         return set_error(SCRIPT_ERR_SIG_HASHTYPE)
       end
       true
     end
 
-    def low_der_signature?(sig)
-      return set_error(SCRIPT_ERR_SIG_DER) unless Key.valid_signature_encoding?(sig.htb)
+    def check_schnorr_signature_encoding(sig, data_sig = false)
+      return false unless sig.htb.bytesize == (data_sig ? 64 : 65)
+      return set_error(SCRIPT_ERR_SIG_HASHTYPE) if !data_sig && !defined_hashtype_signature?(sig)
+      true
+    end
+
+    def low_der_signature?(sig, data_sig = false)
+      return set_error(SCRIPT_ERR_SIG_DER) unless Key.valid_signature_encoding?(sig.htb, data_sig)
       return set_error(SCRIPT_ERR_SIG_HIGH_S) unless Key.low_signature?(sig.htb)
       true
     end
@@ -609,20 +596,12 @@ module Tapyrus
       return false if sig.empty?
       s = sig.unpack('C*')
       hash_type = s[-1] & (~(SIGHASH_TYPE[:anyonecanpay]))
-      hash_type &= (~(Tapyrus::SIGHASH_FORK_ID)) if Tapyrus.chain_params.fork_chain? # for fork coin.
       return false if hash_type < SIGHASH_TYPE[:all] || hash_type > SIGHASH_TYPE[:single]
       true
     end
 
-    def check_pubkey_encoding(pubkey, sig_version)
-      if flag?(SCRIPT_VERIFY_STRICTENC) && !Key.compress_or_uncompress_pubkey?(pubkey)
-        return set_error(SCRIPT_ERR_PUBKEYTYPE)
-      end
-      # Only compressed keys are accepted in segwit
-      if flag?(SCRIPT_VERIFY_WITNESS_PUBKEYTYPE) &&
-          sig_version == :witness_v0 && !Key.compress_pubkey?(pubkey)
-        return set_error(SCRIPT_ERR_WITNESS_PUBKEYTYPE)
-      end
+    def check_pubkey_encoding(pubkey)
+      return set_error(SCRIPT_ERR_PUBKEYTYPE) unless Key.compress_or_uncompress_pubkey?(pubkey)
       true
     end