tapyrus 0.1.0 → 0.2.0

data/lib/tapyrus/message/tx.rb

@@ -17,11 +17,11 @@ module Tapyrus
 
       def self.parse_from_payload(payload)
         tx = Tapyrus::Tx.parse_from_payload(payload)
-        new(tx, tx.witness?)
+        new(tx)
       end
 
       def to_payload
-        use_segwit ? tx.to_payload : tx.serialize_old_format
+        tx.to_payload
       end
 
     end

data/lib/tapyrus/network/peer.rb

@@ -99,21 +99,7 @@ module Tapyrus
 
       # broadcast tx.
       def broadcast_tx(tx)
-        conn.send_message(Tapyrus::Message::Tx.new(tx, support_witness?))
-      end
-
-      # check the remote peer support witness.
-      def support_witness?
-        return false unless remote_version
-        remote_version.services & Tapyrus::Message::SERVICE_FLAGS[:witness] > 0
-      end
-
-      # check the remote peer supports compact block.
-      def support_cmpct?
-        return false if remote_version.version < Tapyrus::Message::VERSION[:compact]
-        return true unless local_version.services & Tapyrus::Message::SERVICE_FLAGS[:witness] > 0
-        return false unless support_witness?
-        remote_version.version >= Tapyrus::Message::VERSION[:compact_witness]
+        conn.send_message(Tapyrus::Message::Tx.new(tx))
       end
 
       # get peer's block type.

data/lib/tapyrus/node/cli.rb

@@ -1,4 +1,4 @@
-require 'rest-client'
+require 'net/http'
 require 'thor'
 require 'json'
 
@@ -7,7 +7,7 @@ module Tapyrus
 
     class CLI < Thor
 
-      class_option :network, aliases: '-n', default: :mainnet
+      class_option :network, aliases: '-n', default: :prod
 
       desc 'getblockchaininfo', 'Returns an object containing various state info regarding blockchain processing.'
       def getblockchaininfo
@@ -92,15 +92,19 @@ module Tapyrus
             :id => 'jsonrpc'
         }
         begin
-          RestClient::Request.execute(method: :post, url: config.server_url, payload: data.to_json,
-                                      headers: {content_type: :json}) do |response, request, result|
-            return false if !result.kind_of?(Net::HTTPSuccess) && response.empty?
-            begin
-              json = JSON.parse(response.to_str)
-              puts JSON.pretty_generate(json)
-            rescue Exception
-              puts response.to_str
-            end
+          uri = URI.parse(config.server_url)
+          http = Net::HTTP.new(uri.hostname, uri.port)
+          http.use_ssl = uri.scheme === "https"
+          request = Net::HTTP::Post.new('/')
+          request.content_type = 'application/json'
+          request.body = data.to_json
+          response = http.request(request)
+          body = response.body
+          begin
+            json = JSON.parse(body.to_str)
+            puts JSON.pretty_generate(json)
+          rescue Exception
+            puts body.to_str
           end
         rescue Exception => e
           puts e.message

data/lib/tapyrus/node/configuration.rb

@@ -8,7 +8,7 @@ module Tapyrus
 
       def initialize(opts = {})
         # TODO apply configuration file.
-        opts[:network] = :mainnet unless opts[:network]
+        opts[:network] = :prod unless opts[:network]
         opts[:relay] = false unless opts[:relay]
         Tapyrus.chain_params = opts[:network]
 

data/lib/tapyrus/node/spv.rb

@@ -45,7 +45,7 @@ module Tapyrus
       # broadcast a transaction
       def broadcast(tx)
         pool.broadcast(tx)
-        logger.debug "broadcast tx: #{tx.to_payload.bth}"
+        logger.debug "broadcast tx: #{tx.to_hex}"
       end
 
       # add filter element to bloom filter.

data/lib/tapyrus/opcodes.rb

@@ -141,6 +141,11 @@ module Tapyrus
     OP_PUBKEY = 0xfe
     OP_INVALIDOPCODE = 0xff
 
+    # tapyrus extension
+    OP_CHECKDATASIG = 0xba
+    OP_CHECKDATASIGVERIFY = 0xbb
+    OP_COLOR = 0xbc
+
     DUPLICATE_KEY = [:OP_NOP2, :OP_NOP3]
     OPCODES_MAP = Hash[*(constants.grep(/^OP_/) - [:OP_NOP2, :OP_NOP3, :OP_CHECKLOCKTIMEVERIFY, :OP_CHECKSEQUENCEVERIFY]).map { |c| [const_get(c), c.to_s] }.flatten]
     NAME_MAP = Hash[*constants.grep(/^OP_/).map { |c| [c.to_s, const_get(c)] }.flatten]

data/lib/tapyrus/out_point.rb

@@ -19,7 +19,7 @@ module Tapyrus
     end
 
     def coinbase?
-      tx_hash == COINBASE_HASH && index == COINBASE_INDEX
+      tx_hash == COINBASE_HASH
     end
 
     def to_payload

data/lib/tapyrus/rpc/request_handler.rb

@@ -31,8 +31,8 @@ module Tapyrus
           {
               hash: block_id,
               height: entry.height,
-              version: entry.header.version,
-              versionHex: entry.header.version.to_even_length_hex,
+              features: entry.header.features,
+              featuresHex: entry.header.features.to_even_length_hex,
               merkleroot: entry.header.merkle_root.rhex,
               time: entry.header.time,
               mediantime: node.chain.mtp(block_hash),
@@ -42,7 +42,7 @@ module Tapyrus
               nextblockhash: node.chain.next_hash(block_hash).rhex
           }
         else
-          entry.header.to_payload.bth
+          entry.header.to_hex
         end
       end
 

data/lib/tapyrus/rpc/tapyrus_core_client.rb

@@ -1,15 +1,16 @@
-require 'rest-client'
+require 'net/http'
+require 'json/pure'
 
 module Tapyrus
   module RPC
 
-    # Client implementation for RPC to Bitcoin Core.
+    # Client implementation for RPC to Tapyrus Core.
     #
     # [Usage]
     # config = {schema: 'http', host: 'localhost', port: 18332, user: 'xxx', password: 'yyy'}
-    # client = Tapyrus::RPC::BitcoinCoreClient.new(config)
+    # client = Tapyrus::RPC::TapyrusCoreClient.new(config)
     #
-    # You can execute the CLI command supported by Bitcoin Core as follows:
+    # You can execute the CLI command supported by Tapyrus Core as follows:
     #
     # client.listunspent
     # client.getblockchaininfo
@@ -53,17 +54,18 @@ module Tapyrus
             :params => params,
             :id => 'jsonrpc'
         }
-        post(server_url, @config[:timeout], @config[:open_timeout], data.to_json, content_type: :json) do |respdata, request, result|
-          raise result.message if !result.kind_of?(Net::HTTPSuccess) && respdata.empty?
-          response = JSON.parse(respdata.gsub(/\\u([\da-fA-F]{4})/) { [$1].pack('H*').unpack('n*').pack('U*').encode('ISO-8859-1').force_encoding('UTF-8') })
-          raise response['error'] if response['error']
-          response['result']
-        end
-      end
-
-      def post(url, timeout, open_timeout, payload, headers={}, &block)
-        RestClient::Request.execute(method: :post, url: url, timeout: timeout,
-                                    open_timeout: open_timeout, payload: payload, headers: headers, &block)
+        uri = URI.parse(server_url)
+        http = Net::HTTP.new(uri.hostname, uri.port)
+        http.use_ssl = uri.scheme === "https"
+        request = Net::HTTP::Post.new('/')
+        request.basic_auth(uri.user, uri.password)
+        request.content_type = 'application/json'
+        request.body = data.to_json
+        response = http.request(request)
+        body = response.body
+        response = Tapyrus::Ext::JsonParser.new(body.gsub(/\\u([\da-fA-F]{4})/) { [$1].pack('H*').unpack('n*').pack('U*').encode('ISO-8859-1').force_encoding('UTF-8') }).parse
+        raise response['error'].to_s if response['error']
+        response['result']
       end
 
     end

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