bitcoinrb 1.12.1 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e60d83b48a9f7189cd07c75ee61749ab50a83895f86dd97c7d7fbbd568234067
-  data.tar.gz: 04e39f6f592379617273944009f78d224cf181f1877de15a285665e9b25602b3
+  metadata.gz: cc2fd227e7a25b6fa3bdd88ef6035e7b7f4a76bb1ef501285ccd0f7f5d961c4c
+  data.tar.gz: 0f2557375f3918a5416983dde696cb922be71cf7a7c762c2be2305b6e9edb3d3
 SHA512:
-  metadata.gz: 13046ad4ba44662c2689d13dec7d51bc88e2d80cccaedc0048ee7484136e5cf04600161b5b7ae99faf4e1d7081fb845b403ebc3defb9cf92e46847e500befd65
-  data.tar.gz: 12c68844e79ca382dc774d6d4d6cdad8bbd33064a315098e0a31eecb88ac1369c2bd4ff6b39da49d3d5b2eae9750beff11e5761dbbdbe6221c3ef1100cd8cde2
+  metadata.gz: 9cd9ed6bfca773abf5d25228be6b2a88ef7a17c163e3ddd5bb7de9c6365261d65e51fa8c3e9a6f87304a5bfc48036f87e7b0fb99d8b910c368001f7c5aa78d81
+  data.tar.gz: bec0d5c4ab556984e2fb9fa4da85008c92fb392d4510e41901701626658f8356f20aa5b74d1837ed90c1a35efe86b52f6ea5713b90f4c2caf2112b47a42a1706

data/lib/bitcoin/bip321_uri.rb

@@ -105,7 +105,7 @@ module Bitcoin
                      req_pop = true
                      k = 'pop'
                    end
-                   if %w[bc tb].include?(k.downcase)
+                   if %w[bc tb bcrt].include?(k.downcase)
                      raise ArgumentError, "#{k} not allowed in current network." unless Bitcoin.chain_params.bech32_hrp == k.downcase
                      query_addrs << v
                      nil
@@ -160,12 +160,9 @@ module Bitcoin
       all_params = base_params.merge other_params
       params = all_params.map do |k, v|
         "#{k}=#{CGI.escape(v).gsub('+', '%20')}"
-      end.join('&')
-      uri << "?#{params}" unless params.empty?
-      unless query_addrs.empty?
-        uri << '?' unless uri.include?('?')
-        uri << query_addrs.map {|addr| "#{Bitcoin.chain_params.bech32_hrp}=#{addr}"}.join('&')
       end
+      params += query_addrs.map {|addr| "#{Bitcoin.chain_params.bech32_hrp}=#{addr}"}
+      uri << "?#{params.join('&')}" unless params.empty?
       uri
     end
   end

data/lib/bitcoin/bip324/fs_chacha20.rb

@@ -101,7 +101,7 @@ module Bitcoin
 
       def key_stream_bytes(n_bytes)
         while key_stream.bytesize < n_bytes
-          nonce = [0, (chunk_counter / REKEY_INTERVAL)].pack("VQ<")
+          nonce = [0, (chunk_counter / rekey_interval)].pack("VQ<")
           self.key_stream << ChaCha20.block(key, nonce, block_counter)
           self.block_counter += 1
         end

data/lib/bitcoin/bip324/fs_chacha_poly1305.rb

@@ -65,6 +65,7 @@ module Bitcoin
       # @return [Array] [header, plaintext]
       def decrypt(aad, ciphertext)
         contents = crypt(aad, ciphertext, true)
+        raise Bitcoin::BIP324::Error, 'Decryption failed.' unless contents
         [contents[0], contents[1..-1]]
       end
 

data/lib/bitcoin/bip324.rb

@@ -10,7 +10,9 @@ module Bitcoin
 
     autoload :EllSwiftPubkey, 'bitcoin/bip324/ell_swift_pubkey'
     autoload :Cipher, 'bitcoin/bip324/cipher'
+    autoload :ChaCha20, 'bitcoin/bip324/fs_chacha20'
     autoload :FSChaCha20, 'bitcoin/bip324/fs_chacha20'
+    autoload :Poly1305, 'bitcoin/bip324/fs_chacha_poly1305'
     autoload :FSChaCha20Poly1305, 'bitcoin/bip324/fs_chacha_poly1305'
 
     FIELD_SIZE = 2**256 - 2**32 - 977

data/lib/bitcoin/descriptor/checksum.rb

@@ -18,7 +18,9 @@ module Bitcoin
         s[-8..-1].each_char do |c|
           return false unless CHECKSUM_CHARSET.include?(c)
         end
-        symbols = descsum_expand(s[0...-9]) + s[-8..-1].each_char.map{|c|CHECKSUM_CHARSET.index(c)}
+        expanded = descsum_expand(s[0...-9])
+        return false unless expanded
+        symbols = expanded + s[-8..-1].each_char.map{|c|CHECKSUM_CHARSET.index(c)}
         descsum_polymod(symbols) == 1
       end
 
@@ -26,7 +28,9 @@ module Bitcoin
       # @param [String] s Descriptor string without checksum.
       # @return [String] Descriptor string with checksum.
       def descsum_create(s)
-        symbols = descsum_expand(s) + [0, 0, 0, 0, 0, 0, 0, 0]
+        expanded = descsum_expand(s)
+        raise ArgumentError, 'Descriptor contains a character which is not in the input charset.' unless expanded
+        symbols = expanded + [0, 0, 0, 0, 0, 0, 0, 0]
         checksum = descsum_polymod(symbols) ^ 1
         result = 8.times.map do |i|
           CHECKSUM_CHARSET[(checksum >> (5 * (7 - i))) & 31]

data/lib/bitcoin/ext_key.rb

@@ -114,14 +114,16 @@ module Bitcoin
       child_priv = ECDSA::Format::IntegerOctetString.encode(child_priv, 32)
       new_key.key = Bitcoin::Key.new(priv_key: child_priv.bth, key_type: key_type)
       new_key.chain_code = l[32..-1]
-      new_key.ver = version
+      # A depth 1 key derives its version bytes from the purpose, see #version.
+      new_key.ver = new_key.depth == 1 ? nil : version
       new_key
     end
 
     # get version bytes using serialization format
     def version
+      return ver if ver
       return ExtKey.version_from_purpose(number) if depth == 1
-      ver ? ver : Bitcoin.chain_params.extended_privkey_version
+      Bitcoin.chain_params.extended_privkey_version
     end
 
     # get key type defined by BIP-178 using version.
@@ -286,14 +288,16 @@ module Bitcoin
       p2 = Bitcoin::Key.new(pubkey: pubkey, key_type: key_type).to_point
       new_key.pubkey = (p1 + p2).to_hex
       new_key.chain_code = l[32..-1]
-      new_key.ver = version
+      # A depth 1 key derives its version bytes from the purpose, see #version.
+      new_key.ver = new_key.depth == 1 ? nil : version
       new_key
     end
 
     # get version bytes using serialization format
     def version
+      return ver if ver
       return ExtPubkey.version_from_purpose(number) if depth == 1
-      ver ? ver : Bitcoin.chain_params.extended_pubkey_version
+      Bitcoin.chain_params.extended_pubkey_version
     end
 
     # get key type defined by BIP-178 using version.

data/lib/bitcoin/key.rb

@@ -120,7 +120,7 @@ module Bitcoin
         if low_r && !sig_has_low_r?(sig)
           counter = 1
           until sig_has_low_r?(sig)
-            extra_entropy = [counter].pack('I*').bth.ljust(64, '0').htb
+            extra_entropy = [counter].pack('V').bth.ljust(64, '0').htb
             sig = secp256k1_module.sign_data(data, priv_key, extra_entropy)
             counter += 1
           end

data/lib/bitcoin/message/cf_parser.rb

@@ -3,12 +3,12 @@ module Bitcoin
     module CFParser
 
       def parse_from_payload(payload)
-        type, start, hash = payload.unpack('CLH*')
+        type, start, hash = payload.unpack('CVH*')
         self.new(type, start, hash)
       end
 
       def to_payload
-        [filter_type, start_height, stop_hash].pack('CLH*')
+        [filter_type, start_height, stop_hash].pack('CVH*')
       end
 
     end

data/lib/bitcoin/message/fee_filter.rb

@@ -15,11 +15,11 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
-        new(payload.unpack1('Q'))
+        new(payload.unpack1('Q<'))
       end
 
       def to_payload
-        [fee_rate].pack('Q')
+        [fee_rate].pack('Q<')
       end
 
     end

data/lib/bitcoin/message/header_and_short_ids.rb

@@ -16,13 +16,13 @@ module Bitcoin
         @nonce = nonce
         @short_ids = short_ids
         @prefilled_txn = prefilled_txn
-        @siphash_key = Bitcoin.sha256(header.to_payload << [nonce].pack('q*'))[0...16]
+        @siphash_key = Bitcoin.sha256(header.to_payload << [nonce].pack('q<*'))[0...16]
       end
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
         header = Bitcoin::BlockHeader.parse_from_payload(buf.read(80))
-        nonce = buf.read(8).unpack1('q*')
+        nonce = buf.read(8).unpack1('q<*')
         short_ids_len = Bitcoin.unpack_var_int_from_io(buf)
         short_ids = short_ids_len.times.map do
            buf.read(6).reverse.bth.to_i(16)
@@ -36,9 +36,9 @@ module Bitcoin
 
       def to_payload
         p = header.to_payload
-        p << [nonce].pack('q*')
+        p << [nonce].pack('q<*')
         p << Bitcoin.pack_var_int(short_ids.size)
-        p << short_ids.map{|id|sprintf('%12x', id).htb.reverse}.join
+        p << short_ids.map{|id|sprintf('%012x', id).htb.reverse}.join
         p << Bitcoin.pack_var_int(prefilled_txn.size)
         p << prefilled_txn.map(&:to_payload).join
         p

data/lib/bitcoin/message/inventory.rb

@@ -26,7 +26,7 @@ module Bitcoin
       # parse inventory payload
       def self.parse_from_payload(payload)
         raise Error, 'invalid inventory size.' if payload.bytesize != 36
-        identifier = payload[0..4].unpack1('V')
+        identifier = payload[0..3].unpack1('V')
         hash = payload[4..-1].bth # internal byte order
         new(identifier, hash)
       end

data/lib/bitcoin/message/network_addr.rb

@@ -107,7 +107,7 @@ module Bitcoin
         has_time = buf.size > 26
         addr = NetworkAddr.new(time: nil)
         addr.time = buf.read(4).unpack1('V') if has_time
-        addr.services = buf.read(8).unpack1('Q')
+        addr.services = buf.read(8).unpack1('Q<')
         addr.addr = IPAddr::new_ntoh(buf.read(16))
         addr.port = buf.read(2).unpack1('n')
         addr
@@ -153,7 +153,7 @@ module Bitcoin
         p = ''
         p << [time].pack('V') unless skip_time
         ip = addr.ipv4? ? addr.ipv4_mapped : addr
-        p << [services].pack('Q') << ip.hton << [port].pack('n')
+        p << [services].pack('Q<') << ip.hton << [port].pack('n')
       end
 
       def v2_payload
@@ -163,18 +163,22 @@ module Bitcoin
         case net
         when NETWORK_ID[:ipv4]
           p << Bitcoin.pack_var_int(4)
-          p << addr.to_i.to_s(16).htb
+          p << addr.hton
         when NETWORK_ID[:ipv6]
           p << Bitcoin.pack_var_int(16)
           p << addr.hton
         when NETWORK_ID[:tor_v2]
           p << Bitcoin.pack_var_int(10)
+          p << addr.htb
         when NETWORK_ID[:tor_v3]
           p << Bitcoin.pack_var_int(32)
+          p << addr.htb
         when NETWORK_ID[:i2p]
           p << Bitcoin.pack_var_int(32)
+          p << addr.htb
         when NETWORK_ID[:cjdns]
           p << Bitcoin.pack_var_int(16)
+          p << addr.hton
         end
         p << [port].pack('n')
         p

data/lib/bitcoin/message/ping.rb

@@ -14,11 +14,11 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
-        new(payload.unpack1('Q'))
+        new(payload.unpack1('Q<'))
       end
 
       def to_payload
-        nonce ? [nonce].pack('Q') : ''
+        nonce ? [nonce].pack('Q<') : ''
       end
 
       # Generate pong message as a response. Return nil if the ping has no nonce

data/lib/bitcoin/message/pong.rb

@@ -14,11 +14,11 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
-        new(payload.unpack1('Q'))
+        new(payload.unpack1('Q<'))
       end
 
       def to_payload
-        [nonce].pack('Q')
+        [nonce].pack('Q<')
       end
     end
 

data/lib/bitcoin/message/send_cmpct.rb

@@ -22,12 +22,12 @@ module Bitcoin
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
         mode = buf.read(1).unpack1('c')
-        version = buf.read(8).unpack1('Q')
+        version = buf.read(8).unpack1('Q<')
         new(mode, version)
       end
 
       def to_payload
-        [mode, version].pack('cQ')
+        [mode, version].pack('cQ<')
       end
 
       def high?

data/lib/bitcoin/message/version.rb

@@ -32,7 +32,7 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
-        version, services, timestamp, local_addr, remote_addr, nonce, rest = payload.unpack('VQQa26a26Qa*')
+        version, services, timestamp, local_addr, remote_addr, nonce, rest = payload.unpack('VQ<Q<a26a26Q<a*')
         v = new
         v.version = version
         v.services = services
@@ -50,10 +50,10 @@ module Bitcoin
 
       def to_payload
         [
-          [version, services, timestamp].pack('VQQ'),
+          [version, services, timestamp].pack('VQ<Q<'),
           local_addr.to_payload(true),
           remote_addr.to_payload(true),
-          [nonce].pack('Q'),
+          [nonce].pack('Q<'),
           pack_var_string(user_agent),
           [start_height].pack('V'),
           pack_boolean(relay)

data/lib/bitcoin/message.rb

@@ -1,8 +1,6 @@
 module Bitcoin
   module Message
 
-    class Error < StandardError; end
-
     autoload :Base, 'bitcoin/message/base'
     autoload :Inventory, 'bitcoin/message/inventory'
     autoload :InventoriesParser, 'bitcoin/message/inventories_parser'
@@ -107,6 +105,8 @@ module Bitcoin
         Pong.parse_from_payload(payload)
       when GetHeaders::COMMAND
         GetHeaders.parse_from_payload(payload)
+      when GetBlocks::COMMAND
+        GetBlocks.parse_from_payload(payload)
       when Headers::COMMAND
         Headers.parse_from_payload(payload)
       when Block::COMMAND
@@ -125,8 +125,18 @@ module Bitcoin
         Inv.parse_from_payload(payload)
       when MerkleBlock::COMMAND
         MerkleBlock.parse_from_payload(payload)
+      when FilterLoad::COMMAND
+        FilterLoad.parse_from_payload(payload)
+      when FilterAdd::COMMAND
+        FilterAdd.parse_from_payload(payload)
+      when FilterClear::COMMAND
+        FilterClear.new
       when CmpctBlock::COMMAND
         CmpctBlock.parse_from_payload(payload)
+      when GetBlockTxn::COMMAND
+        GetBlockTxn.parse_from_payload(payload)
+      when BlockTxn::COMMAND
+        BlockTxn.parse_from_payload(payload)
       when GetData::COMMAND
         GetData.parse_from_payload(payload)
       when GetCFHeaders::COMMAND

data/lib/bitcoin/mnemonic.rb

@@ -24,7 +24,7 @@ module Bitcoin
     def to_entropy(words)
       word_master = load_words
       mnemonic = words.map do |w|
-        index = word_master.index(w.downcase)
+        index = word_master.index(normalize(w).downcase)
         raise IndexError, 'word not found in words list.' unless index
         index.to_s(2).rjust(11, '0')
       end.join
@@ -53,8 +53,8 @@ module Bitcoin
     # @return [String] seed
     def to_seed(mnemonic, passphrase: '')
       to_entropy(mnemonic)
-      OpenSSL::PKCS5.pbkdf2_hmac(mnemonic.join(' ').downcase,
-                                 'mnemonic' + passphrase, 2048, 64, OpenSSL::Digest::SHA512.new).bth
+      OpenSSL::PKCS5.pbkdf2_hmac(normalize(mnemonic.join(' ')).downcase,
+                                 'mnemonic' + normalize(passphrase), 2048, 64, OpenSSL::Digest::SHA512.new).bth
     end
 
     # calculate entropy checksum
@@ -69,7 +69,12 @@ module Bitcoin
 
     # load word list contents
     def load_words
-      File.readlines("#{WORD_DIR}/#{language}.txt").map(&:strip)
+      File.readlines("#{WORD_DIR}/#{language}.txt", encoding: Encoding::UTF_8).map{|w| normalize(w.strip)}
+    end
+
+    # BIP-39 requires that mnemonic sentences and passphrases are normalized using NFKD.
+    def normalize(str)
+      str.unicode_normalize(:nfkd)
     end
 
   end

data/lib/bitcoin/psbt/input.rb

@@ -55,8 +55,9 @@ module Bitcoin
             found_sep = true
             break
           end
-          key_type = buf.read(1).unpack1('C')
-          key = buf.read(key_len - 1)
+          key_start = buf.pos
+          key_type = Bitcoin.unpack_var_int_from_io(buf)
+          key = buf.read(key_len - (buf.pos - key_start))
           value = buf.read(Bitcoin.unpack_var_int_from_io(buf))
 
           case key_type
@@ -79,7 +80,8 @@ module Bitcoin
           when PSBT_IN_TYPES[:sighash]
             raise ArgumentError, 'Invalid input sighash type typed key.' unless key_len == 1
             raise ArgumentError, 'Duplicate Key, input sighash type already provided.' if input.sighash_type
-            input.sighash_type = value.unpack1('I')
+            raise ArgumentError, 'Invalid input sighash type value.' unless value.bytesize == 4
+            input.sighash_type = value.unpack1('V')
           when PSBT_IN_TYPES[:redeem_script]
             raise ArgumentError, 'Invalid redeemscript typed key.' unless key_len == 1
             raise ArgumentError, 'Duplicate Key, input redeemScript already provided.' if input.redeem_script
@@ -117,10 +119,12 @@ module Bitcoin
             raise ArgumentError, 'Duplicate Key, input hash256 preimage already provided' if input.hash256_preimages[key.bth]
             input.hash256_preimages[key.bth] = value.bth
           when PSBT_IN_TYPES[:proprietary]
-            raise ArgumentError, 'Duplicate Key, key for proprietary value already provided.' if input.proprietaries.any?{|p| p.key == key}
-            input.proprietaries << Proprietary.new(key, value)
+            proprietary = Proprietary.new(key, value)
+            raise ArgumentError, 'Duplicate Key, key for proprietary value already provided.' if input.proprietaries.any?{|p| p.key == proprietary.key}
+            input.proprietaries << proprietary
           when PSBT_IN_TYPES[:tap_key_sig]
             raise ArgumentError, 'Size of key was not the expected size for the type tap key sig' unless key_len == 1
+            raise ArgumentError, 'Duplicate Key, input tap key sig already provided.' if input.tap_key_sig
             raise ArgumentError, 'Invalid schnorr signature size for the type tap key sig' unless [64, 65].include?(value.bytesize)
             input.tap_key_sig = value.bth
           when PSBT_IN_TYPES[:tap_script_sig]
@@ -142,14 +146,16 @@ module Bitcoin
             input.tap_bip32_derivations[key.bth] = value.bth
           when PSBT_IN_TYPES[:tap_internal_key]
             raise ArgumentError, 'Size of key was not the expected size for the type tap internal key' unless key_len == 1
+            raise ArgumentError, 'Duplicate Key, input tap internal key already provided.' if input.tap_internal_key
             raise ArgumentError, 'Invalid x-only public key size for the type tap internal key' unless value.bytesize == X_ONLY_PUBKEY_SIZE
             input.tap_internal_key = value.bth
           when PSBT_IN_TYPES[:tap_merkle_root]
             raise ArgumentError, 'Size of key was not the expected size for the type tap merkle root' unless key_len == 1
+            raise ArgumentError, 'Duplicate Key, input tap merkle root already provided.' if input.tap_merkle_root
             raise ArgumentError, 'Invalid merkle root hash size for the type tap merkle root' unless value.bytesize == 32
             input.tap_merkle_root = value.bth
           else
-            unknown_key = ([key_type].pack('C') + key).bth
+            unknown_key = (Bitcoin.pack_var_int(key_type) + key).bth
             raise ArgumentError, 'Duplicate Key, key for unknown value already provided.' if input.unknowns[unknown_key]
             input.unknowns[unknown_key] = value
           end
@@ -163,23 +169,21 @@ module Bitcoin
         payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:non_witness_utxo], value:
             (witness_utxo && valid_witness_input?) ? non_witness_utxo.serialize_old_format : 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
-          payload << ripemd160_preimages.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:ripemd160], key: k.htb, value: v.htb)}.join
-          payload << sha256_preimages.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:sha256], key: k.htb, value: v.htb)}.join
-          payload << hash160_preimages.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:hash160], key: k.htb, value: v.htb)}.join
-          payload << hash256_preimages.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:hash256], key: k.htb, value: v.htb)}.join
-          payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_key_sig], value: tap_key_sig.htb) if tap_key_sig
-          payload << tap_script_sigs.map{|k, v| PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_script_sig], key: k.htb, value: v.htb)}.join
-          payload << tap_leaf_scripts.map{|k, v| PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_leaf_script], key: k.to_payload, value: v.htb)}.join
-          payload << tap_bip32_derivations.map{|k, v| PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_bip32_derivation], key: k.htb, value: v.htb)}.join
-          payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_internal_key], value: tap_internal_key.htb) if tap_internal_key
-          payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_merkle_root], value: tap_merkle_root.htb) if tap_merkle_root
-        end
+        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('V')) 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
+        payload << ripemd160_preimages.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:ripemd160], key: k.htb, value: v.htb)}.join
+        payload << sha256_preimages.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:sha256], key: k.htb, value: v.htb)}.join
+        payload << hash160_preimages.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:hash160], key: k.htb, value: v.htb)}.join
+        payload << hash256_preimages.map{|k, v|PSBT.serialize_to_vector(PSBT_IN_TYPES[:hash256], key: k.htb, value: v.htb)}.join
+        payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_key_sig], value: tap_key_sig.htb) if tap_key_sig
+        payload << tap_script_sigs.map{|k, v| PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_script_sig], key: k.htb, value: v.htb)}.join
+        payload << tap_leaf_scripts.map{|k, v| PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_leaf_script], key: k.to_payload, value: v.htb)}.join
+        payload << tap_bip32_derivations.map{|k, v| PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_bip32_derivation], key: k.htb, value: v.htb)}.join
+        payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_internal_key], value: tap_internal_key.htb) if tap_internal_key
+        payload << PSBT.serialize_to_vector(PSBT_IN_TYPES[:tap_merkle_root], value: tap_merkle_root.htb) if tap_merkle_root
         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 << proprietaries.map(&:to_payload).join
@@ -191,10 +195,13 @@ module Bitcoin
       # Check whether input's scriptPubkey is correct witness.
       # @return [Boolean]
       def valid_witness_input?
-        return true if witness_utxo&.script_pubkey.p2wpkh? # P2WPKH
-        return true if witness_utxo&.script_pubkey.p2wsh? && witness_utxo&.script_pubkey == redeem_script.to_p2wsh # P2WSH
+        return false unless witness_utxo
+        return true if witness_utxo.script_pubkey.p2wpkh? # P2WPKH
+        # P2WSH. The scriptPubkey commits to the witness script directly, so a redeem script is not used.
+        return true if witness_utxo.script_pubkey.p2wsh? && witness_script &&
+          Bitcoin::Script.to_p2wsh(witness_script) == witness_utxo.script_pubkey
         # segwit nested in P2SH
-        if witness_utxo&.script_pubkey.p2sh? && redeem_script&.witness_program? && redeem_script.to_p2sh == witness_utxo&.script_pubkey
+        if witness_utxo.script_pubkey.p2sh? && redeem_script&.witness_program? && redeem_script.to_p2sh == witness_utxo.script_pubkey
           return true if redeem_script.p2wpkh?# nested p2wpkh
           return true if witness_script&.to_sha256 == redeem_script.witness_data[1].bth # nested p2wsh
         end
@@ -235,19 +242,19 @@ module Bitcoin
       # @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 non_witness_utxo are different.' unless same_field?(non_witness_utxo, psbi.non_witness_utxo)
+        raise ArgumentError, 'The Partially Signed Input\'s witness_utxo are different.' unless same_field?(witness_utxo, psbi.witness_utxo)
         raise ArgumentError, 'The Partially Signed Input\'s sighash_type are different.' if sighash_type && psbi.sighash_type && 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
+        raise ArgumentError, 'The Partially Signed Input\'s redeem_script are different.' unless same_field?(redeem_script, psbi.redeem_script)
+        raise ArgumentError, 'The Partially Signed Input\'s witness_script are different.' unless same_field?(witness_script, psbi.witness_script)
         combined = Bitcoin::PSBT::Input.new(non_witness_utxo: non_witness_utxo, witness_utxo: witness_utxo)
         combined.unknowns = Hash[unknowns.merge(psbi.unknowns).sort]
         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&.multisig?
-        witness_script.get_multisig_pubkeys.each{|pubkey|combined.partial_sigs[pubkey.bth] = sigs[pubkey.bth]} if witness_script&.multisig?
+        redeem_script.get_multisig_pubkeys.each{|pubkey|combined.partial_sigs[pubkey.bth] = sigs[pubkey.bth] if sigs[pubkey.bth]} if redeem_script&.multisig?
+        witness_script.get_multisig_pubkeys.each{|pubkey|combined.partial_sigs[pubkey.bth] = sigs[pubkey.bth] if sigs[pubkey.bth]} if witness_script&.multisig?
         combined.hd_key_paths = hd_key_paths.merge(psbi.hd_key_paths)
         combined
       end
@@ -288,7 +295,7 @@ module Bitcoin
         h[:non_witness_utxo] = non_witness_utxo.to_h if non_witness_utxo
         h[:witness_utxo] = witness_utxo.to_h if witness_utxo
         h[:redeem_script] = redeem_script.to_h if redeem_script
-        h[:witness_script] = witness_script.to_h if redeem_script
+        h[:witness_script] = witness_script.to_h if witness_script
         h[:final_script_sig] = final_script_sig.to_h if final_script_sig
         h[:final_script_witness] = final_script_witness.to_h if final_script_witness
         h[:bip32_derivs] = hd_key_paths.values.map(&:to_h) unless hd_key_paths.empty?
@@ -309,6 +316,17 @@ module Bitcoin
         h
       end
 
+      private
+
+      # Whether +a+ and +b+ are the same field value. Unlike ==, this does not raise
+      # NoMethodError when only one of them is nil.
+      # @return [Boolean]
+      def same_field?(a, b)
+        return true if a.nil? && b.nil?
+        return false if a.nil? || b.nil?
+        a == b
+      end
+
     end
 
   end

data/lib/bitcoin/psbt/key_origin_info.rb

@@ -15,11 +15,11 @@ module Bitcoin
 
       def self.parse_from_payload(payload)
         buf = StringIO.new(payload)
-        self.new(fingerprint: buf.read(4).bth, key_paths: buf.read.unpack('I*'))
+        self.new(fingerprint: buf.read(4).bth, key_paths: buf.read.unpack('V*'))
       end
 
       def to_payload
-        fingerprint.htb + key_paths.pack('I*')
+        fingerprint.htb + key_paths.pack('V*')
       end
 
       def to_h

data/lib/bitcoin/psbt/output.rb

@@ -32,8 +32,9 @@ module Bitcoin
             found_sep = true
             break
           end
-          key_type = buf.read(1).unpack1('C')
-          key = buf.read(key_len - 1)
+          key_start = buf.pos
+          key_type = Bitcoin.unpack_var_int_from_io(buf)
+          key = buf.read(key_len - (buf.pos - key_start))
           value = buf.read(Bitcoin.unpack_var_int_from_io(buf))
           case key_type
           when PSBT_OUT_TYPES[:redeem_script]
@@ -48,21 +49,24 @@ module Bitcoin
             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.new(key, Bitcoin::PSBT::KeyOriginInfo.parse_from_payload(value))
           when PSBT_OUT_TYPES[:proprietary]
-            raise ArgumentError, 'Duplicate Key, key for proprietary value already provided.' if output.proprietaries.any?{|p| p.key == key}
-            output.proprietaries << Proprietary.new(key, value)
+            proprietary = Proprietary.new(key, value)
+            raise ArgumentError, 'Duplicate Key, key for proprietary value already provided.' if output.proprietaries.any?{|p| p.key == proprietary.key}
+            output.proprietaries << proprietary
           when PSBT_OUT_TYPES[:tap_internal_key]
             raise ArgumentError, 'Invalid output tap internal key typed key.' unless key_len == 1
+            raise ArgumentError, 'Duplicate Key, output tap internal key already provided.' if output.tap_internal_key
             raise ArgumentError, 'Invalid x-only public key size for the type tap internal key' unless value.bytesize == X_ONLY_PUBKEY_SIZE
             output.tap_internal_key = value.bth
           when PSBT_OUT_TYPES[:tap_tree]
             raise ArgumentError, 'Invalid output tap tree typed key.' unless key_len == 1
+            raise ArgumentError, 'Duplicate Key, output tap tree already provided.' if output.tap_tree
             output.tap_tree = value.bth # TODO implement builder.
           when PSBT_OUT_TYPES[:tap_bip32_derivation]
             raise ArgumentError, 'Duplicate Key, key for tap bip32 derivation value already provided.' if output.tap_bip32_derivations[key.bth]
             raise ArgumentError, 'Size of key was not the expected size for the type tap bip32 derivation' unless key.bytesize == X_ONLY_PUBKEY_SIZE
             output.tap_bip32_derivations[key.bth] = value.bth
           else
-            unknown_key = ([key_type].pack('C') + key).bth
+            unknown_key = (Bitcoin.pack_var_int(key_type) + key).bth
             raise ArgumentError, 'Duplicate Key, key for unknown value already provided' if output.unknowns[unknown_key]
             output.unknowns[unknown_key] = value
           end

data/lib/bitcoin/psbt/tx.rb

@@ -68,8 +68,9 @@ module Bitcoin
             found_sep = true
             break
           end
+          key_start = buf.pos
           key_type = Bitcoin.unpack_var_int_from_io(buf)
-          key = buf.read(key_len - 1)
+          key = buf.read(key_len - (buf.pos - key_start))
           value = buf.read(Bitcoin.unpack_var_int_from_io(buf))
 
           case key_type
@@ -89,14 +90,19 @@ module Bitcoin
             raise ArgumentError, "global xpub's depth and the number of indexes not matched." unless xpub.depth == info.key_paths.size
             partial_tx.xpubs << Bitcoin::PSBT::GlobalXpub.new(xpub, info)
           when PSBT_GLOBAL_TYPES[:ver]
+            raise ArgumentError, 'Invalid global version typed key.' unless key_len == 1
+            raise ArgumentError, 'Duplicate Key, global version already provided.' if partial_tx.version_number
+            raise ArgumentError, 'Invalid global version value.' unless value.bytesize == 4
             partial_tx.version_number = value.unpack1('V')
             raise ArgumentError, "An unsupported version was detected." if SUPPORT_VERSION < partial_tx.version_number
           when PSBT_GLOBAL_TYPES[:proprietary]
-            raise ArgumentError, 'Duplicate Key, key for proprietary value already provided.' if partial_tx.proprietaries.any?{|p| p.key == key}
-            partial_tx.proprietaries << Proprietary.new(key, value)
+            proprietary = Proprietary.new(key, value)
+            raise ArgumentError, 'Duplicate Key, key for proprietary value already provided.' if partial_tx.proprietaries.any?{|p| p.key == proprietary.key}
+            partial_tx.proprietaries << proprietary
           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
+            unknown_key = (Bitcoin.pack_var_int(key_type) + key).bth
+            raise ArgumentError, 'Duplicate Key, key for unknown value already provided.' if partial_tx.unknowns[unknown_key]
+            partial_tx.unknowns[unknown_key] = value
           end
         end
 
@@ -206,7 +212,6 @@ module Bitcoin
             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
-            break
           end
         end
       end
@@ -267,20 +272,21 @@ module Bitcoin
       # extract final tx.
       # @return [Bitcoin::Tx] final tx.
       def extract_tx
-        extract_tx = tx.dup
+        extract_tx = Bitcoin::Tx.parse_from_payload(tx.to_payload)
         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|
+        extract_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)
+            raise "input[#{index}]'s signature is invalid.'" unless extract_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)
+            raise ArgumentError, "input[#{index}] does not have utxo." unless utxo
+            raise "input[#{index}]'s signature is invalid.'" unless extract_tx.verify_input_sig(index, utxo.script_pubkey, amount: utxo.value)
           end
         end
         extract_tx

data/lib/bitcoin/psbt.rb

@@ -55,7 +55,7 @@ module Bitcoin
     module_function
 
     def self.serialize_to_vector(key_type, key: nil, value: nil)
-      key_len = key_type.itb.bytesize
+      key_len = Bitcoin.pack_var_int(key_type).bytesize
       key_len += key.bytesize if key
       s = Bitcoin.pack_var_int(key_len) << Bitcoin.pack_var_int(key_type)
       s << key if key

data/lib/bitcoin/script/script.rb

@@ -100,12 +100,22 @@ module Bitcoin
         if opcode
           script << (v =~ /^\d/ && Opcodes.small_int_to_opcode(v.ord) ? v.ord : opcode)
         else
-          script << (v =~ /^[0-9]+$/ ? v.to_i : v)
+          script << (number_token?(v) ? v.to_i : v)
         end
       end
       script
     end
 
+    # Whether +token+ is a script number rather than pushed data with hex format.
+    # A digit only token is ambiguous since #to_s emits pushed data as hex. #to_s never emits
+    # a number with more than 10 digits, so a longer even-length token must be pushed data.
+    # @param [String] token a token of the script string.
+    # @return [Boolean] whether +token+ should be interpreted as a script number.
+    def self.number_token?(token)
+      return false unless token =~ /^[0-9]+$/
+      token.length < 12 || token.length.odd?
+    end
+
     # generate script from addr.
     # @param [String] addr address.
     # @return [Bitcoin::Script] parsed script.
@@ -491,11 +501,11 @@ module Bitcoin
       size = data.bytesize
       header = if size < OP_PUSHDATA1
                  [size].pack('C')
-               elsif size < 0xff
+               elsif size <= 0xff
                  [OP_PUSHDATA1, size].pack('CC')
-               elsif size < 0xffff
+               elsif size <= 0xffff
                  [OP_PUSHDATA2, size].pack('Cv')
-               elsif size < 0xffffffff
+               elsif size <= 0xffffffff
                  [OP_PUSHDATA4, size].pack('CV')
                else
                  raise ArgumentError, 'data size is too big.'

data/lib/bitcoin/secp256k1/rfc6979.rb

@@ -26,10 +26,13 @@ module Bitcoin
         # 3.2.g
         v = Bitcoin.hmac_sha256(k, v)
         # 3.2.h
-        t = ''
         10000.times do
-          v = Bitcoin.hmac_sha256(k, v)
-          t = (t + v)
+          # T is reset for each candidate, otherwise a retry can never produce a value below the order.
+          t = ''
+          while t.bytesize < 32
+            v = Bitcoin.hmac_sha256(k, v)
+            t = (t + v)
+          end
           t_num = t.bth.to_i(16)
           return t_num if 1 <= t_num && t_num < Bitcoin::Secp256k1::GROUP.order
           k = Bitcoin.hmac_sha256(k, v + '00'.htb)

data/lib/bitcoin/sighash_generator.rb

@@ -68,7 +68,7 @@ module Bitcoin
         hash_prevouts = Bitcoin.double_sha256(tx.inputs.map{|i|i.out_point.to_payload}.join)
         hash_sequence = Bitcoin.double_sha256(tx.inputs.map{|i|[i.sequence].pack('V')}.join)
         outpoint = tx.inputs[input_index].out_point.to_payload
-        amount = [amount].pack('Q')
+        amount = [amount].pack('Q<')
         nsequence = [tx.inputs[input_index].sequence].pack('V')
         hash_outputs = Bitcoin.double_sha256(tx.outputs.map{|o|o.to_payload}.join)
         if output_script.p2wsh?
@@ -120,7 +120,7 @@ module Bitcoin
         buf << [hash_type, tx.version, tx.lock_time].pack('CVV')
         unless input_type == SIGHASH_TYPE[:anyonecanpay]
           buf << Bitcoin.sha256(tx.in.map{|i|i.out_point.to_payload}.join) # sha_prevouts
-          buf << Bitcoin.sha256(opts[:prevouts].map(&:value).pack('Q*'))# sha_amounts
+          buf << Bitcoin.sha256(opts[:prevouts].map(&:value).pack('Q<*'))# sha_amounts
           buf << Bitcoin.sha256(opts[:prevouts].map{|o|o.script_pubkey.to_payload(true)}.join) # sha_scriptpubkeys
           buf << Bitcoin.sha256(tx.in.map(&:sequence).pack('V*')) # sha_sequences
         end

data/lib/bitcoin/taproot/control_block.rb

@@ -24,6 +24,7 @@ module Bitcoin
       # @return [Bitcoin::Taproot::ControlBlock]
       def self.parse_from_payload(payload)
         raise Bitcoin::Taproot::Error, 'Invalid data length for Control Block' if payload.bytesize > TAPROOT_CONTROL_MAX_SIZE
+        raise Bitcoin::Taproot::Error, 'Invalid data length for Control Block' if payload.bytesize < TAPROOT_CONTROL_BASE_SIZE
         raise Bitcoin::Taproot::Error, 'Invalid data length for path in Control Block' unless (payload.bytesize - TAPROOT_CONTROL_BASE_SIZE) % TAPROOT_CONTROL_NODE_SIZE == 0
         control, internal_key, paths = payload.unpack('Ca32a*')
         parity = control & 1

data/lib/bitcoin/tx.rb

@@ -89,6 +89,10 @@ module Bitcoin
       to_hex.to_i(16)
     end
 
+    def eql?(other)
+      other.is_a?(Tx) && self == other
+    end
+
     def tx_hash
       Bitcoin.double_sha256(serialize_old_format).bth
     end
@@ -228,7 +232,7 @@ module Bitcoin
     # @param [Integer] input_index
     # @param [Bitcoin::Script] script_pubkey the script pubkey for target input.
     # @param [Integer] amount the amount of bitcoin, require for witness program only.
-    # @param [Array] flags the flags used when execute script interpreter.
+    # @param [Integer] flags the flags used when execute script interpreter.
     # @param [Array[Bitcoin::TxOut]] prevouts Previous outputs referenced by all Tx inputs, required for taproot.
     # @return [Boolean] result
     def verify_input_sig(input_index, script_pubkey, amount: nil, flags: STANDARD_SCRIPT_VERIFY_FLAGS, prevouts: [])
@@ -236,11 +240,9 @@ module Bitcoin
       has_witness = inputs[input_index].has_witness?
       has_witness = true if script_pubkey.witness_program?
 
-      if script_pubkey.p2sh?
-        flags << SCRIPT_VERIFY_P2SH
-        redeem_script = Script.parse_from_payload(script_sig.chunks.last)
-        script_pubkey = redeem_script if redeem_script.p2wpkh?
-      end
+      # The script interpreter resolves the redeem script of P2SH, including a nested witness
+      # program, from the scriptSig, so the scriptPubkey is passed through as it is.
+      flags |= SCRIPT_VERIFY_P2SH if script_pubkey.p2sh?
 
       if has_witness
         verify_input_sig_for_witness(input_index, script_pubkey, amount, flags, prevouts)

data/lib/bitcoin/tx_out.rb

@@ -16,13 +16,13 @@ module Bitcoin
 
     def self.parse_from_payload(payload)
       buf = payload.is_a?(String) ? StringIO.new(payload) : payload
-      value = buf.read(8).unpack1('q')
+      value = buf.read(8).unpack1('Q<')
       script_size = Bitcoin.unpack_var_int_from_io(buf)
       new(value: value, script_pubkey: Script.parse_from_payload(buf.read(script_size)))
     end
 
     def to_payload
-      [value].pack('Q') << script_pubkey.to_payload(true)
+      [value].pack('Q<') << script_pubkey.to_payload(true)
     end
 
     def to_empty_payload

data/lib/bitcoin/util.rb

@@ -25,7 +25,7 @@ module Bitcoin
       elsif i <= 0xffffffff
         [0xfe, i].pack('CV')
       elsif i <= 0xffffffffffffffff
-        [0xff, i].pack('CQ')
+        [0xff, i].pack('CQ<')
       else
         raise "int(#{i}) too large!"
       end
@@ -39,7 +39,7 @@ module Bitcoin
       when 0xfe
         payload.unpack('xVa*')
       when 0xff
-        payload.unpack('xQa*')
+        payload.unpack('xQ<a*')
       else
         payload.unpack('Ca*')
       end
@@ -54,7 +54,7 @@ module Bitcoin
       when 0xfe
         buf.read(4)&.unpack1('V')
       when 0xff
-        buf.read(8)&.unpack1('Q')
+        buf.read(8)&.unpack1('Q<')
       else
         uchar
       end

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "1.12.1"
+  VERSION = "1.13.0"
 end

data/lib/bitcoin/wallet/account.rb

@@ -33,7 +33,7 @@ module Bitcoin
         payload = buf.read
         name, payload = Bitcoin.unpack_var_string(payload)
         name = name.force_encoding('utf-8')
-        purpose, index, receive_depth, change_depth, lookahead = payload.unpack('I*')
+        purpose, index, receive_depth, change_depth, lookahead = payload.unpack('V*')
         a = Account.new(account_key, purpose, index, name)
         a.receive_depth = receive_depth
         a.change_depth = change_depth
@@ -44,7 +44,7 @@ module Bitcoin
       def to_payload
         payload = account_key.to_payload
         payload << Bitcoin.pack_var_string(name.unpack1('H*').htb)
-        payload << [purpose, index, receive_depth, change_depth, lookahead].pack('I*')
+        payload << [purpose, index, receive_depth, change_depth, lookahead].pack('V*')
         payload
       end
 

data/lib/bitcoin/wallet/db.rb

@@ -32,7 +32,7 @@ module Bitcoin
 
       def save_account(account)
         level_db.batch do
-          id = [account.purpose, account.index].pack('I*').bth
+          id = [account.purpose, account.index].pack('V*').bth
           key = KEY_PREFIX[:account] + id
           level_db.put(key, account.to_payload)
         end
@@ -40,14 +40,14 @@ module Bitcoin
 
       def save_key(account, purpose, index, key)
         pubkey = key.pub
-        id = [account.purpose, account.index, purpose, index].pack('I*').bth
+        id = [account.purpose, account.index, purpose, index].pack('V*').bth
         k = KEY_PREFIX[:key] + id
         level_db.put(k, pubkey)
         key
       end
 
       def get_keys(account)
-        id = [account.purpose, account.index].pack('I*').bth
+        id = [account.purpose, account.index].pack('V*').bth
         from = KEY_PREFIX[:key] + id + '00000000'
         to = KEY_PREFIX[:key] + id + 'ffffffff'
         level_db.each(from: from, to: to).map { |k, v| v}

data/lib/bitcoin/wallet/master_key.rb

@@ -81,7 +81,7 @@ module Bitcoin
         encrypted_data = ''
         encrypted_data << enc.update(seed)
         encrypted_data << enc.final
-        @seed = encrypted_data
+        @seed = encrypted_data.bth
         @encrypted = true
       end
 
@@ -92,7 +92,7 @@ module Bitcoin
         dec.decrypt
         dec.key, dec.iv = key_iv(dec, passphrase)
         decrypted_data = ''
-        decrypted_data << dec.update(seed)
+        decrypted_data << dec.update(seed.htb)
         decrypted_data << dec.final
         @seed = decrypted_data
         @encrypted = false

data/lib/bitcoin/wallet/utxo.rb

@@ -18,7 +18,7 @@ module Bitcoin
       def self.parse_from_payload(payload)
         return nil if payload.nil?
 
-        tx_hash, index, block_height, value, payload = payload.unpack('H64VVQa*')
+        tx_hash, index, block_height, value, payload = payload.unpack('H64VVQ<a*')
 
         buf = StringIO.new(payload)
         script_size = Bitcoin.unpack_var_int_from_io(buf)
@@ -27,7 +27,7 @@ module Bitcoin
       end
 
       def to_payload
-        payload = [tx_hash, index, block_height.nil? ? 0 : block_height, value].pack('H64VVQ')
+        payload = [tx_hash, index, block_height.nil? ? 0 : block_height, value].pack('H64VVQ<')
         s = script_pubkey.to_payload
         payload << Bitcoin.pack_var_int(s.length) << s
         payload

data/lib/bitcoin.rb

@@ -4,6 +4,7 @@
 require 'bitcoin/version'
 require 'schnorr'
 require 'securerandom'
+require 'stringio'
 require 'json'
 require 'bech32'
 require 'base64'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitcoinrb
 version: !ruby/object:Gem::Version
-  version: 1.12.1
+  version: 1.13.0
 platform: ruby
 authors:
 - azuchi