bitcoinrb 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f851cfc67b23f2e481679f9c971c1fa55aa236a9c594d1db27934466218437a
-  data.tar.gz: 58a4772dd01dd72ba2a306fcaaa635d993dee788e08fccbb211fc257edc93a5e
+  metadata.gz: 3bff3d97122521e4859ca7dc471eeda350a5156d763731384c1ed8c3e54b7117
+  data.tar.gz: 95a8ef84f38ced9e9f07279eefac81e774a923c0d048593783c4c4c2d5dda49f
 SHA512:
-  metadata.gz: 70ab8a795a33371e32d68c49610f521491c3ad9b09bf5dda84b9f21bcc2c8fcf301a3c16d6589587a604cbedd7add37158b1337218a948727617a5fcd00bc149
-  data.tar.gz: 87e4204a69edff47d35e7c0185c48f2c9bc0ac698d11e9f4a1d1c60778cd8ba4fb6c8fc9218bbab2ab3fe219b91ad45385b67b884077185da992b49a1822591a
+  metadata.gz: 2c493349ad0cb5ac702b88a080cb5880407b5b37fc08171d450454e977874e056fcd21b5022c7aee5ffc4f40f43bfd8f63eabdec2e4ba5c6d5655a950da74cea
+  data.tar.gz: 84d4d0e3c1b93ea90af3414223b5c83a5753d66bc174a101b4e10388d74ba0077431bedc67ab670ada33226c5a73339973afeda87fda97d1877983f318cf5e29

data/lib/bitcoin/key.rb

@@ -6,6 +6,11 @@ module Bitcoin
   # bitcoin key class
   class Key
 
+    PUBLIC_KEY_SIZE = 65
+    COMPRESSED_PUBLIC_KEY_SIZE = 33
+    SIGNATURE_SIZE = 72
+    COMPACT_SIGNATURE_SIZE = 65
+
     attr_accessor :priv_key
     attr_accessor :pubkey
     attr_accessor :key_type
@@ -60,7 +65,7 @@ module Bitcoin
       raise ArgumentError, 'invalid version' unless version == Bitcoin.chain_params.privkey_version
       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
+      if key_len == COMPRESSED_PUBLIC_KEY_SIZE && data[-1].unpack('C').first == 1
         key_type = TYPES[:compressed]
         data = data[0..-2]
       elsif key_len == 32
@@ -139,12 +144,12 @@ module Bitcoin
     # check +pubkey+ (hex) is compress or uncompress pubkey.
     def self.compress_or_uncompress_pubkey?(pubkey)
       p = pubkey.htb
-      return false if p.bytesize < 33
+      return false if p.bytesize < COMPRESSED_PUBLIC_KEY_SIZE
       case p[0]
         when "\x04"
-          return false unless p.bytesize == 65
+          return false unless p.bytesize == PUBLIC_KEY_SIZE
         when "\x02", "\x03"
-          return false unless p.bytesize == 33
+          return false unless p.bytesize == COMPRESSED_PUBLIC_KEY_SIZE
         else
           return false
       end
@@ -154,7 +159,7 @@ module Bitcoin
     # check +pubkey+ (hex) is compress pubkey.
     def self.compress_pubkey?(pubkey)
       p = pubkey.htb
-      p.bytesize == 33 && ["\x02", "\x03"].include?(p[0])
+      p.bytesize == COMPRESSED_PUBLIC_KEY_SIZE && ["\x02", "\x03"].include?(p[0])
     end
 
     # check +sig+ is low.

data/lib/bitcoin/psbt/hd_key_path.rb

@@ -0,0 +1,37 @@
+module Bitcoin
+  module PSBT
+
+    # HD Key path data structure.
+    # see https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki#Specification
+    class HDKeyPath
+
+      attr_reader :pubkey
+      attr_accessor :fingerprint
+      attr_reader :path
+
+      def initialize(pubkey, fingerprint: nil, path: [])
+        @pubkey = pubkey
+        @fingerprint = fingerprint
+        @path = path
+      end
+
+      # parse hd key path from payload.
+      # @param [String] pubkey a public key with binary format.
+      # @param [String] payload hd key path value with binary format.
+      # @return [Bitcoin::PSBT::HDKeyPath]
+      def self.parse_from_payload(pubkey, payload)
+        raise 'Size of key was not the expected size for the type BIP32 keypath' unless [Bitcoin::Key::PUBLIC_KEY_SIZE, Bitcoin::Key::COMPRESSED_PUBLIC_KEY_SIZE].include?(pubkey.bytesize)
+        pubkey = Bitcoin::Key.new(pubkey: pubkey.bth)
+        raise 'Invalid pubkey' unless pubkey.fully_valid_pubkey?
+        self.new(pubkey.pubkey, fingerprint: payload[0...4].bth, path: payload[4..-1].unpack('I*'))
+      end
+
+      # generate payload which consist of pubkey and fingerprint, hd key path payload.
+      # @return [String] a payload
+      def to_payload(type = PSBT_IN_TYPES[:bip32_derivation])
+        PSBT.serialize_to_vector(type, key: pubkey.htb, value: fingerprint.htb + path.pack('I*'))
+      end
+
+    end
+  end
+end

data/lib/bitcoin/psbt/input.rb

@@ -0,0 +1,172 @@
+module Bitcoin
+
+  module PSBT
+
+    # Class for PSBTs which contain per-input information
+    class Input
+
+      attr_accessor :non_witness_utxo # Bitcoin::Tx
+      attr_accessor :witness_utxo # Bitcoin::TxOut
+      attr_accessor :redeem_script
+      attr_accessor :witness_script
+      attr_accessor :final_script_sig
+      attr_accessor :final_script_witness
+      attr_accessor :hd_key_paths
+      attr_accessor :partial_sigs
+      attr_accessor :sighash_type
+      attr_accessor :unknowns
+
+      def initialize(non_witness_utxo: nil, witness_utxo: nil)
+        @non_witness_utxo = non_witness_utxo
+        @witness_utxo = witness_utxo
+        @partial_sigs = {}
+        @hd_key_paths = {}
+        @unknowns = {}
+      end
+
+      # parse PSBT input data form buffer.
+      # @param [StringIO] buf psbt buffer.
+      # @return [Bitcoin::PSBTInput] psbt input.
+      def self.parse_from_buf(buf)
+        input = self.new
+        until buf.eof?
+          key_len = Bitcoin.unpack_var_int_from_io(buf)
+          break if key_len == 0
+          key_type = buf.read(1).unpack('C').first
+          key = buf.read(key_len - 1)
+          value = buf.read(Bitcoin.unpack_var_int_from_io(buf))
+
+          case key_type
+          when PSBT_IN_TYPES[:non_witness_utxo]
+            raise ArgumentError, 'Duplicate Key, input non-witness utxo already provided.' if input.non_witness_utxo
+            input.non_witness_utxo = Bitcoin::Tx.parse_from_payload(value)
+          when PSBT_IN_TYPES[:witness_utxo]
+            raise ArgumentError, 'Duplicate Key, input witness utxo already provided.' if input.witness_utxo
+            input.witness_utxo = Bitcoin::TxOut.parse_from_payload(value)
+          when PSBT_IN_TYPES[:partial_sig]
+            if key.size != Bitcoin::Key::PUBLIC_KEY_SIZE && key.size != Bitcoin::Key::COMPRESSED_PUBLIC_KEY_SIZE
+              raise ArgumentError, 'Size of key was not the expected size for the type partial signature pubkey.'
+            end
+            pubkey = Bitcoin::Key.new(pubkey: key.bth)
+            raise ArgumentError, 'Invalid pubkey.' unless pubkey.fully_valid_pubkey?
+            raise ArgumentError, 'Duplicate Key, input partial signature for pubkey already provided.' if input.partial_sigs[pubkey.pubkey]
+            input.partial_sigs[pubkey.pubkey] = value
+          when PSBT_IN_TYPES[:sighash]
+            raise ArgumentError 'Duplicate Key, input sighash type already provided.' if input.sighash_type
+            input.sighash_type = value.unpack('I').first
+          when PSBT_IN_TYPES[:redeem_script]
+            raise ArgumentError, 'Duplicate Key, input redeemScript already provided.' if input.redeem_script
+            input.redeem_script = Bitcoin::Script.parse_from_payload(value)
+          when PSBT_IN_TYPES[:witness_script]
+            raise ArgumentError, 'Duplicate Key, input witnessScript already provided.' if input.witness_script
+            input.witness_script = Bitcoin::Script.parse_from_payload(value)
+          when PSBT_IN_TYPES[:bip32_derivation]
+            raise ArgumentError, 'Duplicate Key, pubkey derivation path already provided.' if input.hd_key_paths[key.bth]
+            input.hd_key_paths[key.bth] = Bitcoin::PSBT::HDKeyPath.parse_from_payload(key, value)
+          when PSBT_IN_TYPES[:script_sig]
+            raise ArgumentError, 'Duplicate Key, input final scriptSig already provided.' if input.final_script_sig
+            input.final_script_sig = Bitcoin::Script.parse_from_payload(value)
+          when PSBT_IN_TYPES[:script_witness]
+            raise ArgumentError, 'Duplicate Key, input final scriptWitness already provided.' if input.final_script_witness
+            input.final_script_witness = Bitcoin::ScriptWitness.parse_from_payload(value)
+          else
+            unknown_key = ([key_type].pack('C') + key).bth
+            raise ArgumentError, 'Duplicate Key, key for unknown value already provided.' if input.unknowns[unknown_key]
+            input.unknowns[unknown_key] = value
+          end
+        end
+        input
+      end
+
+      def to_payload
+        payload = ''
+        payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:non_witness_utxo], value: non_witness_utxo.to_payload) if non_witness_utxo
+        payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:witness_utxo], value: witness_utxo.to_payload) if witness_utxo
+        if final_script_sig.nil? && final_script_witness.nil?
+          payload << partial_sigs.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:partial_sig], key: k.htb, value: v)}.join
+          payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:sighash], value: [sighash_type].pack('I')) if sighash_type
+          payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:redeem_script], value: redeem_script.to_payload) if redeem_script
+          payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:witness_script], value: witness_script.to_payload) if witness_script
+          payload << hd_key_paths.values.map(&:to_payload).join
+        end
+        payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:script_sig], value: final_script_sig.to_payload) if final_script_sig
+        payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:script_witness], value: final_script_witness.to_payload) if final_script_witness
+        payload << unknowns.map {|k,v|Bitcoin.pack_var_int(k.htb.bytesize) << k.htb << Bitcoin.pack_var_int(v.bytesize) << v}.join
+        payload << PSBT_SEPARATOR.to_even_length_hex.htb
+        payload
+      end
+
+      # Sanity check
+      def sane?
+        return false if non_witness_utxo && witness_utxo
+        return false if witness_script && witness_utxo.nil?
+        return false if final_script_witness && witness_utxo.nil?
+        true
+      end
+
+      # add signature as partial sig.
+      # @param [String] pubkey a public key with hex format.
+      # @param [String] sig a signature.
+      def add_sig(pubkey, sig)
+        raise ArgumentError, 'The sighash in signature is invalid.' unless sig.unpack('C*')[-1] == sighash_type
+        raise ArgumentError, 'Duplicate Key, input partial signature for pubkey already provided.' if partial_sigs[pubkey]
+        partial_sigs[pubkey] = sig
+      end
+
+      # merge two PSBT inputs to create one PSBT.
+      # @param [Bitcoin::PSBT::Input] psbi PSBT input to be combined which must have same property in PSBT Input.
+      # @return [Bitcoin::PSBT::Input] combined object.
+      def merge(psbi)
+        raise ArgumentError, 'The argument psbt must be an instance of Bitcoin::PSBT::Input.' unless psbi.is_a?(Bitcoin::PSBT::Input)
+        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 redeem_script are different.' unless redeem_script == psbi.redeem_script
+        raise ArgumentError, 'The Partially Signed Input\'s witness_script are different.' unless witness_script == psbi.witness_script
+        combined = Bitcoin::PSBT::Input.new(non_witness_utxo: non_witness_utxo, witness_utxo: witness_utxo)
+        combined.unknowns = unknowns.merge(psbi.unknowns)
+        combined.redeem_script = redeem_script
+        combined.witness_script = witness_script
+        combined.sighash_type = sighash_type
+        sigs = Hash[partial_sigs.merge(psbi.partial_sigs)]
+        redeem_script.get_multisig_pubkeys.each{|pubkey|combined.partial_sigs[pubkey.bth] = sigs[pubkey.bth]} if redeem_script && redeem_script.multisig?
+        witness_script.get_multisig_pubkeys.each{|pubkey|combined.partial_sigs[pubkey.bth] = sigs[pubkey.bth]} if witness_script && witness_script.multisig?
+        combined.hd_key_paths = hd_key_paths.merge(psbi.hd_key_paths)
+        combined
+      end
+
+      # finalize input.
+      # TODO This feature is experimental and support only multisig.
+      # @return [Bitcoin::PSBT::Input] finalized input.
+      def finalize!
+        if non_witness_utxo
+          self.final_script_sig = Bitcoin::Script.new << Bitcoin::Opcodes::OP_0 if redeem_script.multisig?
+          partial_sigs.values.each {|sig|final_script_sig << sig.bth}
+          final_script_sig << redeem_script.to_payload.bth
+          self.partial_sigs = {}
+          self.hd_key_paths = {}
+          self.redeem_script = nil
+          self.sighash_type = nil
+        else
+          if redeem_script
+            self.final_script_sig = Bitcoin::Script.parse_from_payload(Bitcoin::Script.pack_pushdata(redeem_script.to_payload))
+            self.redeem_script = nil
+          end
+          if witness_script
+            self.final_script_witness = Bitcoin::ScriptWitness.new
+            final_script_witness.stack << '' if witness_script.multisig?
+            partial_sigs.values.each {|sig| final_script_witness.stack << sig}
+            final_script_witness.stack << witness_script.to_payload
+            self.witness_script = nil
+          end
+          self.sighash_type = nil
+          self.partial_sigs = {}
+          self.hd_key_paths = {}
+        end
+        self
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/psbt/output.rb

@@ -0,0 +1,75 @@
+module Bitcoin
+  module PSBT
+
+    # Class for PSBTs which contains per output information
+    class Output
+
+      attr_accessor :redeem_script
+      attr_accessor :witness_script
+      attr_accessor :hd_key_paths
+      attr_accessor :unknowns
+
+      def initialize
+        @hd_key_paths = {}
+        @unknowns = {}
+      end
+
+      # parse PSBT output data form buffer.
+      # @param [StringIO] buf psbt buffer.
+      # @return [Bitcoin::PSBTOutput] psbt output.
+      def self.parse_from_buf(buf)
+        output = self.new
+        until buf.eof?
+          key_len = Bitcoin.unpack_var_int_from_io(buf)
+          break if key_len == 0
+          key_type = buf.read(1).unpack('C').first
+          key = buf.read(key_len - 1)
+          value = buf.read(Bitcoin.unpack_var_int_from_io(buf))
+          case key_type
+          when PSBT_OUT_TYPES[:redeem_script]
+            raise ArgumentError, 'Duplicate Key, output redeemScript already provided' if output.redeem_script
+            output.redeem_script = value
+          when PSBT_OUT_TYPES[:witness_script]
+            raise ArgumentError, 'Duplicate Key, output witnessScript already provided' if output.witness_script
+            output.witness_script = value
+          when PSBT_OUT_TYPES[:bip32_derivation]
+            raise ArgumentError, 'Duplicate Key, pubkey derivation path already provided' if output.hd_key_paths[key.bth]
+            output.hd_key_paths[key.bth] = Bitcoin::PSBT::HDKeyPath.parse_from_payload(key, value)
+          else
+            unknown_key = ([key_type].pack('C') + key).bth
+            raise ArgumentError, 'Duplicate Key, key for unknown value already provided' if output.unknowns[unknown_key]
+            output.unknowns[unknown_key] = value
+          end
+        end
+        output
+      end
+
+      def to_payload
+        payload = ''
+        payload << PSBT.serialize_to_vector(PSBT_OUT_TYPES[:redeem_script], value: redeem_script) if redeem_script
+        payload << PSBT.serialize_to_vector(PSBT_OUT_TYPES[:witness_script], value: witness_script) if witness_script
+        payload << hd_key_paths.values.map{|v|v.to_payload(PSBT_OUT_TYPES[:bip32_derivation])}.join
+        payload << unknowns.map {|k,v|Bitcoin.pack_var_int(k.htb.bytesize) << k.htb << Bitcoin.pack_var_int(v.bytesize) << v}.join
+        payload << PSBT_SEPARATOR.to_even_length_hex.htb
+        payload
+      end
+
+      # merge two PSBT outputs to create one PSBT.
+      # @param [Bitcoin::PSBT::Output] psbo PSBT output to be combined which must have same property in PSBT Output.
+      # @return [Bitcoin::PSBT::Output] combined object.
+      def merge(psbo)
+        raise ArgumentError, 'The argument psbt must be an instance of Bitcoin::PSBT::Output.' unless psbo.is_a?(Bitcoin::PSBT::Output)
+        raise ArgumentError, 'The Partially Signed Output\'s redeem_script are different.' unless redeem_script == psbo.redeem_script
+        raise ArgumentError, 'The Partially Signed Output\'s witness_script are different.' unless witness_script == psbo.witness_script
+        combined = Bitcoin::PSBT::Output.new
+        combined.redeem_script = redeem_script
+        combined.witness_script = witness_script
+        combined.unknowns = unknowns.merge(psbo.unknowns)
+        combined.hd_key_paths = hd_key_paths.merge(psbo.hd_key_paths)
+        combined
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/psbt/tx.rb

@@ -0,0 +1,197 @@
+module Bitcoin
+  module PSBT
+
+    class Tx
+      attr_accessor :tx
+      attr_reader :inputs
+      attr_reader :outputs
+      attr_accessor :unknowns
+
+      def initialize(tx = nil)
+        @tx = tx
+        @inputs = tx ? tx.in.map{Input.new}: []
+        @outputs = tx ? tx.out.map{Output.new}: []
+        @unknowns = {}
+      end
+
+      # parse Partially Signed Bitcoin Transaction data with Base64 format.
+      # @param [String] base64 a Partially Signed Bitcoin Transaction data with Base64 format.
+      # @return [Bitcoin::PartiallySignedTx]
+      def self.parse_from_base64(base64)
+        self.parse_from_payload(Base64.decode64(base64))
+      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
+
+        # read global data.
+        until buf.eof?
+          key_len = Bitcoin.unpack_var_int_from_io(buf)
+          break if key_len == 0
+          key_type = buf.read(1).unpack('C').first
+          key = buf.read(key_len - 1)
+          value = buf.read(Bitcoin.unpack_var_int_from_io(buf))
+
+          case key_type
+          when PSBT_GLOBAL_TYPES[:unsigned_tx]
+            raise ArgumentError, 'Duplicate Key, unsigned tx already provided' if partial_tx.tx
+            partial_tx.tx = Bitcoin::Tx.parse_from_payload(value)
+            partial_tx.tx.in.each do |tx_in|
+              raise ArgumentError, 'Unsigned tx does not have empty scriptSigs and scriptWitnesses.' if !tx_in.script_sig.empty? || !tx_in.script_witness.empty?
+            end
+          else
+            raise ArgumentError, 'Duplicate Key, key for unknown value already provided' if partial_tx.unknowns[key]
+            partial_tx.unknowns[([key_type].pack('C') + key).bth] = value
+          end
+        end
+
+        raise ArgumentError, 'No unsigned transcation was provided.' unless partial_tx.tx
+
+        # read input data.
+        partial_tx.tx.in.each do |tx_in|
+          break if buf.eof?
+          input = Input.parse_from_buf(buf)
+          partial_tx.inputs << input
+          if input.non_witness_utxo && input.non_witness_utxo.hash != tx_in.prev_hash
+            raise ArgumentError, 'Non-witness UTXO does not match outpoint hash'
+          end
+        end
+
+        raise ArgumentError, 'Inputs provided does not match the number of inputs in transaction.' unless partial_tx.inputs.size == partial_tx.tx.in.size
+
+        # read output data.
+        partial_tx.tx.outputs.each do
+          break if buf.eof?
+          output = Output.parse_from_buf(buf)
+          break unless output
+          partial_tx.outputs << output
+        end
+
+        raise ArgumentError, 'Outputs provided does not match the number of outputs in transaction.' unless partial_tx.outputs.size == partial_tx.tx.out.size
+
+        partial_tx.inputs.each do |input|
+          raise ArgumentError, 'PSBT is not sane.' unless input.sane?
+        end
+
+        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 << PSBT.serialize_to_vector(PSBT_GLOBAL_TYPES[:unsigned_tx], value: tx.to_payload)
+
+        payload << unknowns.map {|k,v|Bitcoin.pack_var_int(k.htb.bytesize) << k.htb << Bitcoin.pack_var_int(v.bytesize) << v}.join
+
+        payload << PSBT_SEPARATOR.to_even_length_hex.htb
+
+        payload << inputs.map(&:to_payload).join
+        payload << outputs.map(&:to_payload).join
+        payload
+      end
+
+      # generate payload with Base64 format.
+      # @return [String] a payload with Base64 format.
+      def to_base64
+        Base64.strict_encode64(to_payload)
+      end
+
+      # update input key-value maps.
+      # @param [Bitcoin::Tx] prev_tx previous tx reference by input.
+      # @param [Bitcoin::Script] redeem_script redeem script to set input.
+      # @param [Bitcoin::Script] witness_script witness script to set input.
+      # @param [Hash] hd_key_paths bip 32 hd key paths to set input.
+      def update!(prev_tx, redeem_script: nil, witness_script: nil, hd_key_paths: [])
+        prev_hash = prev_tx.hash
+        tx.in.each_with_index do|tx_in, i|
+          if tx_in.prev_hash == prev_hash
+            utxo = prev_tx.out[tx_in.out_point.index]
+            raise ArgumentError, 'redeem script does not match utxo.' if redeem_script && !utxo.script_pubkey.include?(redeem_script.to_hash160)
+            raise ArgumentError, 'witness script does not match redeem script.' if redeem_script && witness_script && !redeem_script.include?(witness_script.to_sha256)
+            if utxo.script_pubkey.witness_program? || (redeem_script && redeem_script.witness_program?)
+              inputs[i].witness_utxo = utxo
+            else
+              inputs[i].non_witness_utxo = prev_tx
+            end
+            inputs[i].redeem_script = redeem_script if redeem_script
+            inputs[i].witness_script = witness_script if witness_script
+            inputs[i].hd_key_paths = hd_key_paths.map(&:pubkey).zip(hd_key_paths).to_h
+          end
+        end
+      end
+
+      # get signature script of input specified by +index+
+      # @param [Integer] index input index.
+      # @return [Bitcoin::Script]
+      def signature_script(index)
+        i = inputs[index]
+        if i.non_witness_utxo
+          i.redeem_script ? i.redeem_script : i.non_witness_utxo.out[tx.in[index].out_point.index].script_pubkey
+        else
+          i.witness_script ? i.witness_script : i.witness_utxo
+        end
+      end
+
+      # merge 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 merge(psbt)
+        raise ArgumentError, 'The argument psbt must be an instance of Bitcoin::PSBT::Tx.' unless psbt.is_a?(Bitcoin::PSBT::Tx)
+        raise ArgumentError, 'The combined transactions are different.' unless tx == psbt.tx
+        raise ArgumentError, 'The Partially Signed Input\'s count are different.' unless inputs.size == psbt.inputs.size
+        raise ArgumentError, 'The Partially Signed Output\'s count are different.' unless outputs.size == psbt.outputs.size
+
+        combined = Bitcoin::PSBT::Tx.new(tx)
+        inputs.each_with_index do |i, index|
+          combined.inputs[index] = i.merge(psbt.inputs[index])
+        end
+        outputs.each_with_index do |o, index|
+          combined.outputs[index] = o.merge(psbt.outputs[index])
+        end
+        combined.unknowns = unknowns.merge(psbt.unknowns)
+        combined
+      end
+
+      # finalize tx.
+      # TODO This feature is experimental and support only multisig.
+      # @return [Bitcoin::PSBT::Tx] finalized PSBT.
+      def finalize!
+        inputs.each {|input|input.finalize!}
+        self
+      end
+
+      # extract final tx.
+      # @return [Bitcoin::Tx] final tx.
+      def extract_tx
+        extract_tx = tx.dup
+        inputs.each_with_index do |input, index|
+          extract_tx.in[index].script_sig = input.final_script_sig if input.final_script_sig
+          extract_tx.in[index].script_witness = input.final_script_witness if input.final_script_witness
+        end
+        # validate signature
+        tx.in.each_with_index do |tx_in, index|
+          input = inputs[index]
+          if input.non_witness_utxo
+            utxo = input.non_witness_utxo.out[tx_in.out_point.index]
+            raise "input[#{index}]'s signature is invalid.'" unless tx.verify_input_sig(index, utxo.script_pubkey)
+          else
+            utxo = input.witness_utxo
+            raise "input[#{index}]'s signature is invalid.'" unless tx.verify_input_sig(index, utxo.script_pubkey, amount: input.witness_utxo.value)
+          end
+        end
+        extract_tx
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/psbt.rb

@@ -1,248 +1,26 @@
-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
+require 'base64'
 
-      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
+module Bitcoin
 
-      payload
-    end
+  module PSBT
 
-    # 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
+    autoload :Tx, 'bitcoin/psbt/tx'
+    autoload :Input, 'bitcoin/psbt/input'
+    autoload :Output, 'bitcoin/psbt/output'
+    autoload :HDKeyPath, 'bitcoin/psbt/hd_key_path'
 
-    # 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
+    # constants for PSBT
+    PSBT_MAGIC_BYTES = 0x70736274
+    PSBT_GLOBAL_TYPES = {unsigned_tx: 0x00}
+    PSBT_IN_TYPES = {non_witness_utxo: 0x00, witness_utxo: 0x01, partial_sig: 0x02,
+                     sighash: 0x03, redeem_script: 0x04, witness_script: 0x05,
+                     bip32_derivation: 0x06, script_sig: 0x07, script_witness: 0x08}
+    PSBT_OUT_TYPES = {redeem_script: 0x00, witness_script: 0x01, bip32_derivation: 0x02}
+    PSBT_SEPARATOR = 0x00
 
-    private
+    module_function
 
-    def serialize_to_vector(key_type, key: nil, value: nil)
+    def self.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)
@@ -250,44 +28,6 @@ module Bitcoin
       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

@@ -32,10 +32,17 @@ module Bitcoin
       [redeem_script.to_p2sh, redeem_script]
     end
 
+    # generate p2sh script.
+    # @param [String] script_hash script hash for P2SH
+    # @return [Script] P2SH script
+    def self.to_p2sh(script_hash)
+      Script.new << OP_HASH160 << script_hash << OP_EQUAL
+    end
+
     # generate p2sh script with this as a redeem script
     # @return [Script] P2SH script
     def to_p2sh
-      Script.new << OP_HASH160 << to_hash160 << OP_EQUAL
+      Script.to_p2sh(to_hash160)
     end
 
     def get_multisig_pubkeys
@@ -73,6 +80,27 @@ module Bitcoin
       script
     end
 
+    # generate script from addr.
+    # @param [String] addr address.
+    # @return [Bitcoin::Script] parsed script.
+    def self.parse_from_addr(addr)
+      begin
+        segwit_addr = Bech32::SegwitAddr.new(addr)
+        raise 'Invalid hrp.' unless Bitcoin.chain_params.bech32_hrp == segwit_addr.hrp
+        Bitcoin::Script.parse_from_payload(segwit_addr.to_script_pubkey.htb)
+      rescue Exception => e
+        hex, addr_version = Bitcoin.decode_base58_address(addr)
+        case addr_version
+        when Bitcoin.chain_params.address_version
+          Bitcoin::Script.to_p2pkh(hex)
+        when Bitcoin.chain_params.p2sh_version
+          Bitcoin::Script.to_p2sh(hex)
+        else
+          throw e
+        end
+      end
+    end
+
     def self.parse_from_payload(payload)
       s = new
       buf = StringIO.new(payload)
@@ -271,6 +299,18 @@ module Bitcoin
       self
     end
 
+    # Check the item is in the chunk of the script.
+    def include?(item)
+      chunk_item = if item.is_a?(Integer)
+                     item.chr
+                   elsif item.is_a?(String)
+                     data = Encoding::ASCII_8BIT == item.encoding ? item : item.htb
+                     Bitcoin::Script.pack_pushdata(data)
+                   end
+      return false unless chunk_item
+      chunks.include?(chunk_item)
+    end
+
     def to_s
       chunks.map { |c|
         case c

data/lib/bitcoin/script_witness.rb

@@ -9,6 +9,15 @@ module Bitcoin
       @stack = stack
     end
 
+    def self.parse_from_payload(payload)
+      buf = payload.is_a?(StringIO) ? payload : StringIO.new(payload)
+      size = Bitcoin.unpack_var_int_from_io(buf)
+      stack = size.times.map do
+        buf.read(Bitcoin.unpack_var_int_from_io(buf))
+      end
+      self.new(stack)
+    end
+
     def empty?
       stack.empty?
     end

data/lib/bitcoin/tx.rb

@@ -60,11 +60,7 @@ module Bitcoin
 
       if witness
         in_count.times do |i|
-          witness_count = Bitcoin.unpack_var_int_from_io(buf)
-          witness_count.times do
-            size = Bitcoin.unpack_var_int_from_io(buf)
-            tx.inputs[i].script_witness.stack << buf.read(size)
-          end
+          tx.inputs[i].script_witness = Bitcoin::ScriptWitness.parse_from_payload(buf)
         end
       end
 

data/lib/bitcoin/tx_in.rb

@@ -75,6 +75,12 @@ module Bitcoin
       to_payload == other.to_payload
     end
 
+    # return previous output hash (not txid)
+    def prev_hash
+      return nil unless out_point
+      out_point.hash
+    end
+
   end
 
 end

data/lib/bitcoin/util.rb

@@ -85,11 +85,28 @@ module Bitcoin
       Digest::RMD160.hexdigest(Digest::SHA256.digest(hex.htb))
     end
 
+    # encode Base58 check address.
+    # @param [String] hex the address payload.
+    # @param [String] addr_version the address version for P2PKH and P2SH.
+    # @return [String] Base58 check encoding address.
     def encode_base58_address(hex, addr_version)
       base = addr_version + hex
       Base58.encode(base + calc_checksum(base))
     end
 
+    # decode Base58 check encoding address.
+    # @param [String] addr address.
+    # @return [Array] hex and address version
+    def decode_base58_address(addr)
+      hex = Base58.decode(addr)
+      if hex.size == 50 && calc_checksum(hex[0...-8]) == hex[-8..-1]
+        raise 'Invalid version bytes.' unless [Bitcoin.chain_params.address_version, Bitcoin.chain_params.p2sh_version].include?(hex[0..1])
+        [hex[2...-8], hex[0..1]]
+      else
+        raise 'Invalid address.'
+      end
+    end
+
     def calc_checksum(hex)
       double_sha256(hex.htb).bth[0..7]
     end

data/lib/bitcoin/version.rb

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

data/lib/bitcoin.rb

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

data/lib/openassets/util.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module OpenAssets
+  module Util
+    class << self
+      OA_VERSION_BYTE = '17' # 0x23
+      OA_VERSION_BYTE_TESTNET = '73' # 0x115
+
+      def script_to_asset_id(script)
+        hash_to_asset_id(Bitcoin.hash160(script))
+      end
+
+      private
+
+      def hash_to_asset_id(hash)
+        hash = oa_version_byte + hash
+        Bitcoin::Base58.encode(hash + Bitcoin.calc_checksum(hash))
+      end
+
+      def oa_version_byte
+        case Bitcoin.chain_params.network
+        when 'mainnet' then OA_VERSION_BYTE
+        when 'testnet', 'regtest' then OA_VERSION_BYTE_TESTNET
+        end
+      end
+    end
+  end
+end

data/lib/openassets.rb

@@ -4,5 +4,6 @@ module OpenAssets
 
   autoload :MarkerOutput, 'openassets/marker_output'
   autoload :Payload, 'openassets/payload'
+  autoload :Util, 'openassets/util'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-22 00:00:00.000000000 Z
+date: 2018-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa
@@ -366,6 +366,10 @@ files:
 - lib/bitcoin/payments/payment_request.pb.rb
 - lib/bitcoin/payments/x509_certificates.pb.rb
 - lib/bitcoin/psbt.rb
+- lib/bitcoin/psbt/hd_key_path.rb
+- lib/bitcoin/psbt/input.rb
+- lib/bitcoin/psbt/output.rb
+- lib/bitcoin/psbt/tx.rb
 - lib/bitcoin/rpc.rb
 - lib/bitcoin/rpc/http_server.rb
 - lib/bitcoin/rpc/request_handler.rb
@@ -397,6 +401,7 @@ files:
 - lib/openassets.rb
 - lib/openassets/marker_output.rb
 - lib/openassets/payload.rb
+- lib/openassets/util.rb
 homepage: https://github.com/haw-itn/bitcoinrb
 licenses:
 - MIT