bitcoinrb 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 369e8ba42e13931c345e3ebf13023a0b45433d647ea42849028557bfb9036aad
-  data.tar.gz: 460030a26c3cd367706ebb374efda4ad6c7acc3994daa61fd261195076838079
+  metadata.gz: 5f851cfc67b23f2e481679f9c971c1fa55aa236a9c594d1db27934466218437a
+  data.tar.gz: 58a4772dd01dd72ba2a306fcaaa635d993dee788e08fccbb211fc257edc93a5e
 SHA512:
-  metadata.gz: c741a2415026b02e1760fcd47586fbb8df7219502fbf4223bc6d560b313e765bc916871a4ed87d98f343c48e25f72d9bf49910df17073490a2a96db63304ef43
-  data.tar.gz: 13b72574c4413556d9522bd3825ab818beadf956673f5a3c1ff0d027e736d126176825a7a04bdc4be3d333b96aedb9e9580339a8219937844bd5fd0b9b9d3ba2
+  metadata.gz: 70ab8a795a33371e32d68c49610f521491c3ad9b09bf5dda84b9f21bcc2c8fcf301a3c16d6589587a604cbedd7add37158b1337218a948727617a5fcd00bc149
+  data.tar.gz: 87e4204a69edff47d35e7c0185c48f2c9bc0ac698d11e9f4a1d1c60778cd8ba4fb6c8fc9218bbab2ab3fe219b91ad45385b67b884077185da992b49a1822591a

data/lib/bitcoin/ext_key.rb

@@ -22,7 +22,7 @@ module Bitcoin
       l = Bitcoin.hmac_sha512('Bitcoin seed', seed.htb)
       left = l[0..31].bth.to_i(16)
       raise 'invalid key' if left >= CURVE_ORDER || left == 0
-      ext_key.key = Bitcoin::Key.new(priv_key: l[0..31].bth)
+      ext_key.key = Bitcoin::Key.new(priv_key: l[0..31].bth, key_type: Bitcoin::Key::TYPES[:compressed])
       ext_key.chain_code = l[32..-1]
       ext_key
     end
@@ -106,7 +106,8 @@ module Bitcoin
       raise 'invalid key' if left >= CURVE_ORDER
       child_priv = (left + key.priv_key.to_i(16)) % CURVE_ORDER
       raise 'invalid key ' if child_priv >= CURVE_ORDER
-      new_key.key = Bitcoin::Key.new(priv_key: child_priv.to_even_length_hex.rjust(64, '0'))
+      new_key.key = Bitcoin::Key.new(
+          priv_key: child_priv.to_even_length_hex.rjust(64, '0'), key_type: key_type)
       new_key.chain_code = l[32..-1]
       new_key.ver = version
       new_key
@@ -118,6 +119,19 @@ module Bitcoin
       ver ? ver : Bitcoin.chain_params.extended_privkey_version
     end
 
+    # get key type defined by BIP-178 using version.
+    def key_type
+      v = version
+      case v
+      when Bitcoin.chain_params.bip49_privkey_p2wpkh_p2sh_version
+        Bitcoin::Key::TYPES[:pw2pkh_p2sh]
+      when Bitcoin.chain_params.bip84_privkey_p2wpkh_version
+        Bitcoin::Key::TYPES[:p2wpkh]
+      when Bitcoin.chain_params.extended_privkey_version
+        Bitcoin::Key::TYPES[:compressed]
+      end
+    end
+
     def self.parse_from_payload(payload)
       buf = StringIO.new(payload)
       ext_key = ExtKey.new
@@ -128,7 +142,7 @@ module Bitcoin
       ext_key.number = buf.read(4).unpack('N').first
       ext_key.chain_code = buf.read(32)
       buf.read(1) # 0x00
-      ext_key.key = Bitcoin::Key.new(priv_key: buf.read(32).bth)
+      ext_key.key = Bitcoin::Key.new(priv_key: buf.read(32).bth, key_type: Bitcoin::Key::TYPES[:compressed])
       ext_key
     end
 
@@ -209,7 +223,7 @@ module Bitcoin
     # get key object
     # @return [Bitcoin::Key]
     def key
-      Bitcoin::Key.new(pubkey: pubkey)
+      Bitcoin::Key.new(pubkey: pubkey, key_type: key_type)
     end
 
     # get key identifier
@@ -246,7 +260,7 @@ module Bitcoin
       left = l[0..31].bth.to_i(16)
       raise 'invalid key' if left >= CURVE_ORDER
       p1 = Bitcoin::Secp256k1::GROUP.generator.multiply_by_scalar(left)
-      p2 = Bitcoin::Key.new(pubkey: pubkey).to_point
+      p2 = Bitcoin::Key.new(pubkey: pubkey, key_type: key_type).to_point
       new_key.pubkey = ECDSA::Format::PointOctetString.encode(p1 + p2, compression: true).bth
       new_key.chain_code = l[32..-1]
       new_key.ver = version
@@ -259,6 +273,19 @@ module Bitcoin
       ver ? ver : Bitcoin.chain_params.extended_pubkey_version
     end
 
+    # get key type defined by BIP-178 using version.
+    def key_type
+      v = version
+      case v
+      when Bitcoin.chain_params.bip49_pubkey_p2wpkh_p2sh_version
+        Bitcoin::Key::TYPES[:pw2pkh_p2sh]
+      when Bitcoin.chain_params.bip84_pubkey_p2wpkh_version
+        Bitcoin::Key::TYPES[:p2wpkh]
+      when Bitcoin.chain_params.extended_pubkey_version
+        Bitcoin::Key::TYPES[:compressed]
+      end
+    end
+
     def self.parse_from_payload(payload)
       buf = StringIO.new(payload)
       ext_pubkey = ExtPubkey.new

data/lib/bitcoin/key.rb

@@ -8,14 +8,29 @@ module Bitcoin
 
     attr_accessor :priv_key
     attr_accessor :pubkey
-    attr_accessor :compressed
+    attr_accessor :key_type
     attr_reader :secp256k1_module
 
+    TYPES = {uncompressed: 0x00, compressed: 0x01, p2pkh: 0x10, p2wpkh: 0x11, pw2pkh_p2sh: 0x12}
+
     MIN_PRIV_KEy_MOD_ORDER = 0x01
     # Order of secp256k1's generator minus 1.
     MAX_PRIV_KEY_MOD_ORDER = ECDSA::Group::Secp256k1.order - 1
 
-    def initialize(priv_key: nil, pubkey: nil, compressed: true)
+    # initialize private key
+    # @param [String] priv_key a private key with hex format.
+    # @param [String] pubkey a public key with hex format.
+    # @param [Integer] key_type a key type which determine address type.
+    # @param [Boolean] compressed [Deprecated] whether public key is compressed.
+    # @return [Bitcoin::Key] a key object.
+    def initialize(priv_key: nil, pubkey: nil, key_type: nil, compressed: true)
+      puts "[Warning] Use key_type parameter instead of compressed. compressed parameter removed in the future." if key_type.nil? && !compressed.nil? && pubkey.nil?
+      if key_type
+        @key_type = key_type
+        compressed = @key_type != TYPES[:uncompressed]
+      else
+        @key_type = compressed ? TYPES[:compressed] : TYPES[:uncompressed]
+      end
       @secp256k1_module =  Bitcoin.secp_impl
       @priv_key = priv_key
       if @priv_key
@@ -26,13 +41,12 @@ module Bitcoin
       else
         @pubkey = generate_pubkey(priv_key, compressed: compressed) if priv_key
       end
-      @compressed = compressed
     end
 
     # generate key pair
-    def self.generate
+    def self.generate(key_type = TYPES[:compressed])
       priv_key, pubkey = Bitcoin.secp_impl.generate_key_pair
-      new(priv_key: priv_key, pubkey: pubkey)
+      new(priv_key: priv_key, pubkey: pubkey, key_type: key_type)
     end
 
     # import private key from wif format
@@ -47,14 +61,14 @@ module Bitcoin
       raise ArgumentError, 'invalid checksum' unless Bitcoin.calc_checksum(version + data.bth) == checksum
       key_len = data.bytesize
       if key_len == 33 && data[-1].unpack('C').first == 1
-        compressed = true
+        key_type = TYPES[:compressed]
         data = data[0..-2]
       elsif key_len == 32
-        compressed = false
+        key_type = TYPES[:uncompressed]
       else
         raise ArgumentError, 'Wrong number of bytes for a private key, not 32 or 33'
       end
-      new(priv_key: data.bth, compressed: compressed)
+      new(priv_key: data.bth, key_type: key_type)
     end
 
     # export private key with wif format
@@ -93,22 +107,25 @@ module Bitcoin
     end
 
     # get pay to pubkey hash address
+    # @deprecated
     def to_p2pkh
       Bitcoin::Script.to_p2pkh(hash160).addresses.first
     end
 
     # get pay to witness pubkey hash address
+    # @deprecated
     def to_p2wpkh
       Bitcoin::Script.to_p2wpkh(hash160).addresses.first
     end
 
     # get p2wpkh address nested in p2sh.
+    # @deprecated
     def to_nested_p2wpkh
       Bitcoin::Script.to_p2wpkh(hash160).to_p2sh.addresses.first
     end
 
     def compressed?
-      @compressed
+      key_type != TYPES[:uncompressed]
     end
 
     # generate pubkey ec point
@@ -191,6 +208,13 @@ module Bitcoin
       true
     end
 
+    # fully validate whether this is a valid public key (more expensive than IsValid())
+    def fully_valid_pubkey?
+      return false unless valid_pubkey?
+      point = ECDSA::Format::PointOctetString.decode(pubkey.htb, ECDSA::Group::Secp256k1)
+      ECDSA::Group::Secp256k1.valid_public_key?(point)
+    end
+
     private
 
     def self.compare_big_endian(c1, c2)

data/lib/bitcoin/network/connection.rb

@@ -50,7 +50,6 @@ module Bitcoin
       def close(msg = '')
         logger.info "close connection with #{addr}. #{msg}"
         close_connection_after_writing
-        EM.stop
       end
 
       def handle_error(e)

data/lib/bitcoin/network/message_handler.rb

@@ -94,6 +94,8 @@ module Bitcoin
             on_merkle_block(Bitcoin::Message::MerkleBlock.parse_from_payload(payload))
           when Bitcoin::Message::CmpctBlock::COMMAND
             on_cmpct_block(Bitcoin::Message::CmpctBlock.parse_from_payload(payload))
+          when Bitcoin::Message::GetData::COMMAND
+            on_get_data(Bitcoin::Message::GetData.parse_from_payload(payload))
           else
             logger.warn("unsupported command received. command: #{command}, payload: #{payload.bth}")
             close("with command #{command}")
@@ -230,6 +232,9 @@ module Bitcoin
         logger.info("receive cmpct_block message. #{cmpct_block.build_json}")
       end
 
+      def on_get_data(get_data)
+        logger.info("receive get data message. #{get_data.build_json}")
+      end
     end
   end
 end

data/lib/bitcoin/psbt.rb

@@ -0,0 +1,293 @@
+module Bitcoin
+
+  # constants for PSBT
+  PSBT_MAGIC_BYTES = 0x70736274
+  PSBT_TYPES = {tx_or_non_witness: 0x00, redeem_or_witness_utxo: 0x01,
+                witness_or_partial_sig: 0x02, key_path_or_sighash: 0x03, input_num_or_index: 0x04}
+  PSBT_SEPARATOR = 0x00
+
+  # Partially Signed Bitcoin Transaction
+  class PartiallySignedTx
+
+    attr_accessor :tx
+    attr_accessor :redeem_scripts
+    attr_accessor :witness_scripts
+    attr_accessor :partial_inputs
+    attr_accessor :hd_key_paths
+    attr_accessor :num_input
+    attr_accessor :unknowns
+    attr_accessor :use_in_index
+
+    def initialize(tx = nil)
+      @tx = tx
+      @redeem_scripts = {}
+      @witness_scripts = {}
+      @partial_inputs = []
+      @hd_key_paths = {}
+      @unknowns = {}
+      @use_in_index = false
+    end
+
+    # parse Partially Signed Bitcoin Transaction data.
+    # @param [String] payload a Partially Signed Bitcoin Transaction data with binary format.
+    # @return [Bitcoin::PartiallySignedTx]
+    def self.parse_from_payload(payload)
+      buf = StringIO.new(payload)
+      raise ArgumentError, 'Invalid PSBT magic bytes.' unless buf.read(4).unpack('N').first == PSBT_MAGIC_BYTES
+      raise ArgumentError, 'Invalid PSBT separator.' unless buf.read(1).bth.to_i(16) == 0xff
+      partial_tx = self.new
+      is_global = true
+      separators = 0
+      input = PartiallySignedInput.new
+      until buf.eof?
+        key_len = Bitcoin.unpack_var_int_from_io(buf)
+        if key_len == 0
+          puts "use child"
+          is_global = false
+          if separators > 0
+            if partial_tx.use_in_index
+              raise ArgumentError, 'Input indexes being used but an input was provided without an index' unless input.use_in_index
+              (partial_tx.partial_inputs.size...input.index).each{partial_tx.partial_inputs << PartiallySignedInput.new}
+            end
+            partial_tx.partial_inputs << input
+            input = PartiallySignedInput.new(separators)
+          end
+          separators += 1
+          next
+        end
+
+        key_type = buf.read(1).unpack('C').first
+        key = buf.read(key_len - 1)
+        value = buf.read(Bitcoin.unpack_var_int_from_io(buf))
+        puts "key_len = #{key_len}[#{key_type}] key: #{key.nil? ? key : key.bth}, value: #{value.bth}"
+
+        raise ArgumentError, 'Missing null terminator.' if buf.eof? && (key_type != 0 || !key.empty? || !value.empty?)
+
+        case key_type
+        when PSBT_TYPES[:tx_or_non_witness]
+          tx = Bitcoin::Tx.parse_from_payload(value)
+          if is_global
+            partial_tx.tx = tx
+          else
+            raise ArgumentError, 'Provided non witness utxo does not match the required utxo for input' unless partial_tx.tx.in[input.index].out_point.hash == tx.hash
+            input.non_witness_utxo = tx
+          end
+        when PSBT_TYPES[:redeem_or_witness_utxo]
+          if is_global
+            redeem_hash = key
+            raise ArgumentError, 'Size of key was not the expected size for the type redeem script' unless redeem_hash.bytesize == 20
+            raise ArgumentError, 'Provided hash160 does not match the redeemscript\'s hash160' unless Bitcoin.hash160(value.bth) == redeem_hash.bth
+            partial_tx.redeem_scripts[redeem_hash.bth] = value
+          else
+            input.witness_utxo = Bitcoin::TxOut.parse_from_payload(value)
+          end
+        when PSBT_TYPES[:witness_or_partial_sig]
+          if is_global
+            witness_hash = key
+            raise ArgumentError, 'Size of key was not the expected size for the type witness script' unless witness_hash.bytesize == 32
+            raise ArgumentError, 'Provided sha256 does not match the witnessscript\'s sha256' unless Bitcoin.sha256(value) == witness_hash
+            partial_tx.witness_scripts[witness_hash.bth] = value
+          else
+            raise ArgumentError, 'Size of key was not the expected size for the type partial signature pubkey' unless [33, 65].include?(key.bytesize)
+            pubkey = Bitcoin::Key.new(pubkey: key.bth)
+            raise ArgumentError, 'Invalid pubkey' unless pubkey.fully_valid_pubkey?
+            input.partial_sigs[pubkey.pubkey] = value
+          end
+        when PSBT_TYPES[:key_path_or_sighash]
+          if is_global
+            raise ArgumentError, 'Size of key was not the expected size for the type BIP32 keypath' unless [33, 65].include?(key.bytesize)
+            pubkey = Bitcoin::Key.new(pubkey: key.bth)
+            raise ArgumentError, 'Invalid pubkey' unless pubkey.fully_valid_pubkey?
+            key_paths = []
+            key_paths << value[0...4] # fingerprint
+            key_paths += value[4..-1].unpack('N*')
+            partial_tx.hd_key_paths[pubkey.pubkey] = key_paths
+          else
+            input.sighash_type = value.unpack('N').first
+          end
+        when PSBT_TYPES[:input_num_or_index]
+          if is_global
+            partial_tx.num_input = Bitcoin.unpack_var_int(value).first
+          else
+            input.index = Bitcoin.unpack_var_int(value).first
+            input.use_in_index = true
+            partial_tx.use_in_index = true
+          end
+        else
+          if is_global
+            partial_tx.unknowns[([key_type].pack('C') + key).bth] = value
+          else
+            input.unknowns[([key_type].pack('C') + key).bth] = value
+          end
+        end
+      end
+      raise ArgumentError, 'Inputs provided does not match the number of inputs stated.' if (separators - 1) != partial_tx.num_input && partial_tx.use_in_index
+      raise ArgumentError, 'Inputs provided does not match the number of inputs in transaction.' unless partial_tx.tx.in.size == partial_tx.partial_inputs.size
+      partial_tx
+    end
+
+    # generate payload.
+    # @return [String] a payload with binary format.
+    def to_payload
+      payload = PSBT_MAGIC_BYTES.to_even_length_hex.htb << 0xff.to_even_length_hex.htb
+      payload << serialize_to_vector(PSBT_TYPES[:tx_or_non_witness], value: tx.to_payload) if tx
+
+      redeem_scripts.each do |k, v|
+        payload << serialize_to_vector(PSBT_TYPES[:redeem_or_witness_utxo], key: k.htb, value: v)
+      end
+
+      witness_scripts.each do |k, v|
+        payload << serialize_to_vector(PSBT_TYPES[:witness_or_partial_sig], key: k.htb, value: v)
+      end
+
+      hd_key_paths.each do |k, v|
+        value = v.map.with_index{|v, i| i == 0 ? v : [v].pack('N')}.join
+        payload << serialize_to_vector(PSBT_TYPES[:key_path_or_sighash], key: k.htb, value: value)
+      end
+
+      payload << serialize_to_vector(PSBT_TYPES[:input_num_or_index], value: Bitcoin.pack_var_int(num_input)) if num_input
+
+      unknowns.each do |k,v|
+        puts "key = #{k}, v = #{v.bth}"
+        payload << Bitcoin.pack_var_int(k.htb.bytesize) << k.htb << Bitcoin.pack_var_int(v.bytesize) << v
+      end
+
+      payload << PSBT_SEPARATOR.to_even_length_hex.htb
+
+      tx.inputs.each_with_index do|tx_in, index|
+        partial_input = partial_inputs[index]
+        next if use_in_index && !partial_input.use_in_index
+        if tx_in.script_sig.empty? && tx_in.script_witness.empty?
+          if partial_input.non_witness_utxo
+            payload << serialize_to_vector(PSBT_TYPES[:tx_or_non_witness], value: partial_input.non_witness_utxo.to_payload)
+          elsif partial_input.witness_utxo
+            payload << serialize_to_vector(PSBT_TYPES[:redeem_or_witness_utxo], value: partial_input.witness_utxo.to_payload)
+          end
+          partial_input.partial_sigs.each do |k, v|
+            payload << serialize_to_vector(PSBT_TYPES[:witness_or_partial_sig], key: k.htb, value: v)
+          end
+          payload << serialize_to_vector(PSBT_TYPES[:key_path_or_sighash], value: [partial_input.sighash_type].pack('N')) if partial_input.sighash_type
+          payload << serialize_to_vector(PSBT_TYPES[:input_num_or_index], value: Bitcoin.pack_var_int(partial_input.index)) if partial_input.use_in_index
+          partial_input.unknowns.each do |k,v|
+            payload << Bitcoin.pack_var_int(k.htb.bytesize) << k.htb << Bitcoin.pack_var_int(v.bytesize) << v
+          end
+        end
+        payload << PSBT_SEPARATOR.to_even_length_hex.htb
+      end
+
+      payload
+    end
+
+    # combine two PSBTs to create one PSBT.
+    # TODO This feature is experimental.
+    # @param [Bitcoin::PartiallySignedTx] psbt PSBT to be combined which must have same property in PartiallySignedTx.
+    # @return [Bitcoin::PartiallySignedTx] combined object.
+    def combine(psbt)
+      raise ArgumentError, 'The argument psbt must be an instance of PartiallySignedTx.' unless psbt.is_a?(PartiallySignedTx)
+      raise ArgumentError, 'The combined transactions are different.' unless tx == psbt.tx
+      raise ArgumentError, 'The use_in_index are different.' unless use_in_index == psbt.use_in_index
+      raise ArgumentError, 'The partial_inputs size are different.' unless partial_inputs.size == psbt.partial_inputs.size
+      raise ArgumentError, 'The unknowns are different.' unless unknowns == psbt.unknowns
+      combined = PartiallySignedTx.new(tx)
+      combined.redeem_scripts = redeem_scripts.merge(psbt.redeem_scripts)
+      combined.witness_scripts = witness_scripts.merge(psbt.witness_scripts)
+      combined.hd_key_paths = hd_key_paths.merge(psbt.hd_key_paths)
+      combined.witness_scripts = witness_scripts.merge(psbt.witness_scripts)
+      partial_inputs.each_with_index {|i, index|combined.partial_inputs[index] = i.combine(psbt.partial_inputs[index])}
+      combined
+    end
+
+    # transforms a PSBT into a network serialized transaction.
+    # For any inputs which are not complete, the Finalizer will emplace an empty scriptSig in the network serialized transaction.
+    # For any input which has a complete set of signatures,
+    # the Finalizer must attempt to build the complete scriptSig and encode it into the network serialized transaction.
+    # TODO This feature is experimental and support only multisig.
+    # @return [Bitcoin::Tx] finalized Tx.
+    def finalize
+      finalize_tx = tx.dup
+      finalize_tx.inputs.each_with_index do |tx_in, i|
+        partial_input = partial_inputs[i]
+        if partial_input.non_witness_utxo
+          utxo = partial_input.non_witness_utxo.out[tx_in.out_point.index]
+          redeem_script = Bitcoin::Script.parse_from_payload(redeem_scripts[utxo.script_pubkey.chunks[1].pushed_data.bth])
+          tx_in.script_sig << Bitcoin::Opcodes::OP_0
+          redeem_script.chunks[1..-3].each do |pubkey|
+            tx_in.script_sig << partial_input.partial_sigs[pubkey.pushed_data.bth].bth
+          end
+          tx_in.script_sig << redeem_script.to_payload.bth
+          # tx_in.script_sig = Bitcoin::Script.new unless finalize_tx.verify_input_sig(i, utxo.script_pubkey)
+        elsif partial_input.witness_utxo
+          utxo = partial_input.witness_utxo
+          tx_in.script_witness.stack << ''
+          witness_scripts.each {|k, v|
+            redeem_script = Bitcoin::Script.parse_from_payload(v)
+            p2wsh = Bitcoin::Script.to_p2wsh(redeem_script)
+            if p2wsh.to_p2sh == utxo.script_pubkey
+              redeem_script.chunks[1..-3].each do |pubkey|
+                tx_in.script_witness.stack << partial_input.partial_sigs[pubkey.pushed_data.bth]
+              end
+              tx_in.script_witness.stack << v
+              tx_in.script_sig << p2wsh.to_payload.bth
+              break
+            end
+          }
+          unless finalize_tx.verify_input_sig(i, utxo.script_pubkey, amount: utxo.value)
+            tx_in.script_sig = Bitcoin::Script.new
+            tx_in.script_witness = Bitcoin::ScriptWitness.new
+          end
+        end
+      end
+      finalize_tx
+    end
+
+    private
+
+    def serialize_to_vector(key_type, key: nil, value: nil)
+      key_len = key_type.to_even_length_hex.htb.bytesize
+      key_len += key.bytesize if key
+      s = Bitcoin.pack_var_int(key_len) << Bitcoin.pack_var_int(key_type)
+      s << key if key
+      s << Bitcoin.pack_var_int(value.bytesize) << value
+      s
+    end
+
+  end
+
+  class PartiallySignedInput
+
+    attr_accessor :non_witness_utxo # Bitcoin::Tx
+    attr_accessor :witness_utxo # Bitcoin::TxOut
+    attr_accessor :partial_sigs
+    attr_accessor :sighash_type
+    attr_accessor :index
+    attr_accessor :unknowns
+    attr_accessor :use_in_index
+
+    def initialize(index = 0, non_witness_utxo: nil, witness_utxo: nil)
+      @non_witness_utxo = non_witness_utxo
+      @witness_utxo = witness_utxo
+      @partial_sigs = {}
+      @index = index
+      @unknowns = {}
+      @use_in_index = false
+    end
+
+    # combine two PSBTs to create one PSBT.
+    # @param [Bitcoin::PartiallySignedInput] psbi PSBI to be combined which must have same property in PartiallySignedInput.
+    # @return [Bitcoin::PartiallySignedInput] combined object.
+    def combine(psbi)
+      raise ArgumentError, 'The argument psbt must be an instance of PartiallySignedInput.' unless psbi.is_a?(PartiallySignedInput)
+      raise ArgumentError, 'The Partially Signed Input\'s non_witness_utxo are different.' unless non_witness_utxo == psbi.non_witness_utxo
+      raise ArgumentError, 'The Partially Signed Input\'s witness_utxo are different.' unless witness_utxo == psbi.witness_utxo
+      raise ArgumentError, 'The Partially Signed Input\'s sighash_type are different.' unless sighash_type == psbi.sighash_type
+      raise ArgumentError, 'The Partially Signed Input\'s use_in_index are different.' unless use_in_index == psbi.use_in_index
+      combined = PartiallySignedInput.new(index, non_witness_utxo: non_witness_utxo, witness_utxo: witness_utxo)
+      combined.use_in_index = use_in_index
+      combined.unknowns = unknowns.merge(psbi.unknowns)
+      combined.partial_sigs = Hash[partial_sigs.merge(psbi.partial_sigs).sort]
+      combined
+    end
+
+  end
+
+end

data/lib/bitcoin/script/script.rb

@@ -116,6 +116,10 @@ module Bitcoin
       to_payload.bth
     end
 
+    def empty?
+      chunks.size == 0
+    end
+
     def addresses
       return [p2pkh_addr] if p2pkh?
       return [p2sh_addr] if p2sh?
@@ -157,7 +161,7 @@ module Bitcoin
       pubkey_count = Opcodes.opcode_to_small_int(chunks[-2].opcode)
       sig_count = Opcodes.opcode_to_small_int(chunks[0].opcode)
       return false unless pubkey_count || sig_count
-      sig_count < pubkey_count
+      sig_count <= pubkey_count
     end
 
     def op_return?
@@ -171,6 +175,7 @@ module Bitcoin
 
     def op_return_data
       return nil unless op_return?
+      return nil if chunks.size == 1
       chunks[1].pushed_data
     end
 

data/lib/bitcoin/script/tx_checker.rb

@@ -23,7 +23,8 @@ module Bitcoin
       sig = script_sig[0..-2]
       sighash = tx.sighash_for_input(input_index, script_code, hash_type: hash_type,
                                      amount: amount, sig_version: sig_version)
-      key = Key.new(pubkey: pubkey)
+      key_type = pubkey.start_with?('02') || pubkey.start_with?('03') ? Key::TYPES[:compressed] : Key::TYPES[:uncompressed]
+      key = Key.new(pubkey: pubkey, key_type: key_type)
       key.verify(sig, sighash)
     end
 

data/lib/bitcoin/tx.rb

@@ -28,6 +28,9 @@ module Bitcoin
       @lock_time = 0
     end
 
+    alias_method :in, :inputs
+    alias_method :out, :outputs
+
     def self.parse_from_payload(payload)
       buf = payload.is_a?(String) ? StringIO.new(payload) : payload
       tx = new

data/lib/bitcoin/tx_in.rb

@@ -71,6 +71,10 @@ module Bitcoin
       h
     end
 
+    def ==(other)
+      to_payload == other.to_payload
+    end
+
   end
 
 end

data/lib/bitcoin/tx_out.rb

@@ -41,6 +41,10 @@ module Bitcoin
       {value: value_to_btc, script_pubkey: script_pubkey.to_h}
     end
 
+    def ==(other)
+      to_payload == other.to_payload
+    end
+
   end
 
 end

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

data/lib/bitcoin.rb

@@ -46,6 +46,8 @@ module Bitcoin
   autoload :Wallet, 'bitcoin/wallet'
   autoload :BloomFilter, 'bitcoin/bloom_filter'
   autoload :Payments, 'bitcoin/payments'
+  autoload :PartiallySignedTx, 'bitcoin/psbt'
+  autoload :PartiallySignedInput, 'bitcoin/psbt'
 
   require_relative 'bitcoin/constants'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-08 00:00:00.000000000 Z
+date: 2018-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa
@@ -365,6 +365,7 @@ files:
 - lib/bitcoin/payments/payment_details.pb.rb
 - lib/bitcoin/payments/payment_request.pb.rb
 - lib/bitcoin/payments/x509_certificates.pb.rb
+- lib/bitcoin/psbt.rb
 - lib/bitcoin/rpc.rb
 - lib/bitcoin/rpc/http_server.rb
 - lib/bitcoin/rpc/request_handler.rb