bitcoinrb 1.12.0 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d7be6093f10fa04e688b7106ecc080066e0ec693af6b23bb1e0ddb0dbc2e586
-  data.tar.gz: e3fce6344304e22350cde36a0471d1dd1a0dc5d8c1d8b22309efc20704cd74f5
+  metadata.gz: cc2fd227e7a25b6fa3bdd88ef6035e7b7f4a76bb1ef501285ccd0f7f5d961c4c
+  data.tar.gz: 0f2557375f3918a5416983dde696cb922be71cf7a7c762c2be2305b6e9edb3d3
 SHA512:
-  metadata.gz: f65b05a052712bf2186543fbae88222b5e8e753aa201ca00c6997ffad364cab62bfa0b47a091eb998343ffacbcd050c05c9def591d90e28c8a04a3c71286a909
-  data.tar.gz: 47e7fd6c0cb573723523671b2f0002c2d347e4e8187e08157a72326fb91094631c581290356c29fe25d65d9adb5e420b39e3cf22efcbcff24e9d281cef734f3a
+  metadata.gz: 9cd9ed6bfca773abf5d25228be6b2a88ef7a17c163e3ddd5bb7de9c6365261d65e51fa8c3e9a6f87304a5bfc48036f87e7b0fb99d8b910c368001f7c5aa78d81
+  data.tar.gz: bec0d5c4ab556984e2fb9fa4da85008c92fb392d4510e41901701626658f8356f20aa5b74d1837ed90c1a35efe86b52f6ea5713b90f4c2caf2112b47a42a1706

data/.github/workflows/ruby.yml

@@ -22,7 +22,7 @@ jobs:
         ruby-version: ['3.2', '3.3', '3.4', '4.0']
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
     - name: Install leveldb
       run: sudo apt-get install libleveldb-dev
     - name: Set up Ruby

data/bitcoinrb.gemspec

@@ -21,19 +21,14 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency 'ecdsa_ext', '~> 0.5.1'
-  spec.add_runtime_dependency 'eventmachine'
   spec.add_runtime_dependency 'murmurhash3', '~> 0.1.7'
   spec.add_runtime_dependency 'bech32', '>= 1.5.0'
-  spec.add_runtime_dependency 'daemon-spawn'
-  spec.add_runtime_dependency 'thor'
-  spec.add_runtime_dependency 'eventmachine_httpserver'
-  spec.add_runtime_dependency 'iniparse'
   spec.add_runtime_dependency 'siphash'
   spec.add_runtime_dependency 'bip-schnorr', '>= 0.7.0'
   spec.add_runtime_dependency 'base32', '>= 0.3.4'
   spec.add_runtime_dependency 'base64', '~> 0.2.0'
-  spec.add_runtime_dependency 'observer', '~> 0.1.2'
   spec.add_runtime_dependency 'secp256k1rb', '0.1.1'
   spec.add_runtime_dependency 'logger'
   spec.add_runtime_dependency 'merkle', '0.3.0'
+  spec.add_runtime_dependency 'dnsruby', '1.73.0'
 end

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

@@ -16,8 +16,6 @@ module Bitcoin
       # @param [Integer] bits
       # @return [Integer]
       def rotl32(v, bits)
-        raise Bitcoin::BIP324::Error, "v must be integer" unless v.is_a?(Integer)
-        raise Bitcoin::BIP324::Error, "bits must be integer" unless bits.is_a?(Integer)
         ((v << bits) & 0xffffffff) | (v >> (32 - bits))
       end
 
@@ -103,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
@@ -117,9 +115,9 @@ module Bitcoin
       # @return [String]
       def crypt(chunk)
         ks = key_stream_bytes(chunk.bytesize)
-        ret = chunk.unpack("C*").zip(ks.unpack("C*")).map do |c, k|
-          c ^ k
-        end.pack("C*")
+        chunk_bytes = chunk.unpack("C*")
+        ks_bytes = ks.unpack("C*")
+        ret = chunk_bytes.each_with_index.map { |c, i| c ^ ks_bytes[i] }.pack("C*")
         if (self.chunk_counter + 1) % rekey_interval == 0
           self.key = key_stream_bytes(32)
           self.block_counter = 0

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
 
@@ -92,14 +93,11 @@ module Bitcoin
       # Encrypt a plaintext using ChaCha20Poly1305.
       def chacha20_poly1305_encrypt(key, nonce, aad, plaintext)
         msg_len = plaintext.bytesize
-        ret = ((msg_len + 63) / 64).times.map do |i|
-          now = [64, msg_len - 64 * i].min
-          keystream = ChaCha20.block(key, nonce, i + 1)
-          now.times.map do |j|
-            plaintext[j + 64 * i].unpack1('C') ^ keystream[j].unpack1('C')
-          end
-        end
-        ret = ret.flatten.pack('C*')
+        num_blocks = (msg_len + 63) / 64
+        keystream = num_blocks.times.map { |i| ChaCha20.block(key, nonce, i + 1) }.join
+        pt_bytes = plaintext.unpack('C*')
+        ks_bytes = keystream.unpack('C*')
+        ret = Array.new(msg_len) { |i| pt_bytes[i] ^ ks_bytes[i] }.pack('C*')
         poly1305 = Poly1305.new(ChaCha20.block(key, nonce, 0)[0...32])
         poly1305.add(aad, padding: true).add(ret, padding: true)
         poly1305.add([aad.bytesize, msg_len].pack("Q<Q<"))
@@ -114,15 +112,20 @@ module Bitcoin
         poly1305.add(aad, padding: true)
         poly1305.add(ciphertext, length: msg_len, padding: true)
         poly1305.add([aad.bytesize, msg_len].pack("Q<Q<"))
-        return nil unless ciphertext[-16..-1] == poly1305.tag
-        ret = ((msg_len + 63) / 64).times.map do |i|
-          now = [64, msg_len - 64 * i].min
-          keystream = ChaCha20.block(key, nonce, i + 1)
-          now.times.map do |j|
-            ciphertext[j + 64 * i].unpack1('C') ^ keystream[j].unpack1('C')
-          end
-        end
-        ret.flatten.pack('C*')
+        return nil unless constant_time_equal?(ciphertext[-16..-1], poly1305.tag)
+        num_blocks = (msg_len + 63) / 64
+        keystream = num_blocks.times.map { |i| ChaCha20.block(key, nonce, i + 1) }.join
+        ct_bytes = ciphertext.unpack('C*')
+        ks_bytes = keystream.unpack('C*')
+        Array.new(msg_len) { |i| ct_bytes[i] ^ ks_bytes[i] }.pack('C*')
+      end
+
+      # Constant-time comparison of two equal-length byte strings.
+      def constant_time_equal?(a, b)
+        return false unless a.bytesize == b.bytesize
+        diff = 0
+        a.bytesize.times { |i| diff |= a.getbyte(i) ^ b.getbyte(i) }
+        diff.zero?
       end
     end
   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
@@ -95,7 +97,7 @@ module Bitcoin
     def xelligatorswift(x)
       loop do
         u = SecureRandom.random_number(1..ECDSA::Group::Secp256k1.order).to_s(16)
-        c = Random.rand(0..8)
+        c = SecureRandom.random_number(9)
         t = xswiftec_inv(x, u, c)
         unless t.nil?
           return (ECDSA::Format::IntegerOctetString.encode(u.hex, 32) +

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/descriptor/expression.rb

@@ -67,10 +67,10 @@ module Bitcoin
 
         raise ArgumentError, "No key provided." unless key
 
-        if key.start_with?('xprv')
+        if key.start_with?('xprv') || key.start_with?('tprv')
           key = Bitcoin::ExtKey.from_base58(key)
           key = derive_path(key, paths) if paths
-        elsif key.start_with?('xpub')
+        elsif key.start_with?('xpub') || key.start_with?('tpub')
           key = Bitcoin::ExtPubkey.from_base58(key)
           key = derive_path(key, paths) if paths
         else

data/lib/bitcoin/descriptor/sp.rb

@@ -0,0 +1,219 @@
+module Bitcoin
+  module Descriptor
+    # sp() expression for Silent Payment descriptor.
+    # Supports both single-argument (spscan/spspend) and two-argument forms.
+    # @see https://github.com/bitcoin/bips/blob/master/bip-0392.mediawiki
+    class Sp < Expression
+
+      # HRP for spscan/spspend encoding
+      SPSCAN_HRP = 'spscan'
+      SPSPEND_HRP = 'spspend'
+      TSPSCAN_HRP = 'tspscan'
+      TSPSPEND_HRP = 'tspspend'
+
+      attr_reader :key_arg
+      attr_reader :scan_key
+      attr_reader :spend_key
+
+      # Constructor.
+      # @param [String] key_or_scan_key Either a spscan/spspend encoded key, or the scan key for two-argument form.
+      # @param [String, Expression, nil] spend_key The spend key (for two-argument form) or nil for single-argument form.
+      # @raise [ArgumentError] If keys are invalid.
+      def initialize(key_or_scan_key, spend_key = nil)
+        raise ArgumentError, "key_or_scan_key must be a String." unless key_or_scan_key.is_a?(String)
+        unless spend_key.nil? || spend_key.is_a?(String) || spend_key.is_a?(Expression)
+          raise ArgumentError, "spend_key must be a String, Expression, or nil."
+        end
+        if spend_key.nil?
+          # Single argument form: spscan or spspend encoded key
+          @key_arg = key_or_scan_key
+          parse_encoded_key(key_or_scan_key)
+        else
+          # Two argument form: separate scan and spend keys
+          @key_arg = nil
+          @scan_key = key_or_scan_key
+          @spend_key = spend_key
+        end
+        validate_keys!
+      end
+
+      def type
+        :sp
+      end
+
+      def top_level?
+        true
+      end
+
+      def args
+        if key_arg
+          # Single argument form
+          key_arg
+        else
+          # Two argument form
+          spend_arg = spend_key.is_a?(Expression) ? spend_key.to_s : spend_key
+          "#{scan_key},#{spend_arg}"
+        end
+      end
+
+      # Check if this is a single-argument form (spscan/spspend).
+      # @return [Boolean]
+      def single_key?
+        !key_arg.nil?
+      end
+
+      # Check if this descriptor has spend private key (spspend form).
+      # @return [Boolean]
+      def has_spend_private_key?
+        return @has_spend_private_key if defined?(@has_spend_private_key)
+        if single_key?
+          @has_spend_private_key
+        else
+          # Check if spend_key is a private key
+          return false if spend_key.is_a?(Expression)
+          begin
+            key = extract_pubkey(spend_key)
+            !key.priv_key.nil?
+          rescue
+            false
+          end
+        end
+      end
+
+      # Generate silent payment address.
+      # @return [Bech32::SilentPaymentAddr] Silent payment address.
+      def to_addr
+        Bech32::SilentPaymentAddr.new(
+          address_hrp,
+          0,
+          extracted_scan_pubkey,
+          extracted_spend_pubkey
+        )
+      end
+
+      # Silent payment descriptors do not produce a single script.
+      # Use to_address to get the silent payment address.
+      # @raise [RuntimeError]
+      def to_script
+        raise RuntimeError, "sp() descriptor does not produce a fixed script. Use to_address instead."
+      end
+
+      private
+
+      # Parse spscan or spspend encoded key.
+      # @param [String] encoded_key The encoded key string.
+      # @raise [ArgumentError] If the key format is invalid.
+      def parse_encoded_key(encoded_key)
+        # Handle key origin (e.g., [fingerprint/path]key)
+        key_str = encoded_key
+        if key_str.start_with?('[')
+          key_str = key_str[(key_str.index(']') + 1)..-1]
+        end
+
+        # Decode Bech32m (max_length increased for longer spscan/spspend strings)
+        hrp, data, spec = Bech32.decode(key_str, 200)
+        raise ArgumentError, "Invalid spscan/spspend encoding." unless hrp
+        raise ArgumentError, "spscan/spspend must use Bech32m encoding." unless spec == Bech32::Encoding::BECH32M
+
+        # Validate HRP
+        valid_hrps = [SPSCAN_HRP, SPSPEND_HRP, TSPSCAN_HRP, TSPSPEND_HRP]
+        raise ArgumentError, "Invalid HRP: #{hrp}. Expected one of: #{valid_hrps.join(', ')}" unless valid_hrps.include?(hrp)
+
+        # Check version (first data element should be 0 for version 0)
+        raise ArgumentError, "Invalid version." unless data[0] == 0
+
+        # Convert from 5-bit to 8-bit
+        payload = Bech32.convert_bits(data[1..-1], 5, 8, false)
+        payload_bytes = payload.pack('C*')
+
+        is_spspend = [SPSPEND_HRP, TSPSPEND_HRP].include?(hrp)
+
+        if is_spspend
+          # spspend: 32 bytes scan + 32 bytes spend
+          raise ArgumentError, "Invalid spspend payload length." unless payload_bytes.bytesize == 64
+          scan_priv = payload_bytes[0, 32].bth
+          spend_priv = payload_bytes[32, 32].bth
+          @scan_key = scan_priv
+          @spend_key = spend_priv
+          @has_spend_private_key = true
+        else
+          # spscan: 32 bytes scan + 33 bytes spend pubkey
+          raise ArgumentError, "Invalid spscan payload length." unless payload_bytes.bytesize == 65
+          scan_priv = payload_bytes[0, 32].bth
+          spend_pub = payload_bytes[32, 33].bth
+          @scan_key = scan_priv
+          @spend_key = spend_pub
+          @has_spend_private_key = false
+        end
+      end
+
+      def validate_keys!
+        # Scan key must be a private key
+        scan = extracted_scan_key
+        raise ArgumentError, "Scan key must be a private key." unless scan.priv_key
+
+        # Validate spend key
+        spend = extracted_spend_key
+        raise ArgumentError, "Uncompressed keys are not allowed." unless spend.compressed?
+      end
+
+      # Get the extracted scan key.
+      # @return [Bitcoin::Key] Extracted scan key.
+      def extracted_scan_key
+        if single_key?
+          # scan_key is already a hex private key from spscan/spspend
+          Bitcoin::Key.new(priv_key: scan_key)
+        else
+          extract_pubkey(scan_key)
+        end
+      end
+
+      # Get the extracted scan public key (compressed, 33 bytes hex).
+      # @return [String] Compressed public key hex.
+      def extracted_scan_pubkey
+        extracted_scan_key.pubkey
+      end
+
+      # Get the extracted spend key.
+      # @return [Bitcoin::Key] Extracted spend key.
+      def extracted_spend_key
+        if spend_key.is_a?(MuSig)
+          # MuSig returns x-only pubkey, convert to full pubkey
+          Bitcoin::Key.from_xonly_pubkey(spend_key.to_hex)
+        elsif spend_key.is_a?(Expression)
+          spend_key.extracted_key
+        elsif single_key? && has_spend_private_key?
+          # spspend: spend_key is hex private key
+          Bitcoin::Key.new(priv_key: spend_key)
+        elsif single_key?
+          # spscan: spend_key is hex public key
+          Bitcoin::Key.new(pubkey: spend_key)
+        else
+          extract_pubkey(spend_key)
+        end
+      end
+
+      # Get the extracted spend public key (compressed, 33 bytes hex).
+      # @return [String] Compressed public key hex.
+      def extracted_spend_pubkey
+        if spend_key.is_a?(MuSig)
+          # MuSig aggregated key as compressed pubkey (even y-coordinate assumed)
+          '02' + spend_key.to_hex
+        else
+          extracted_spend_key.pubkey
+        end
+      end
+
+      # Get HRP for silent payment address based on network.
+      # @return [String] HRP (sp for mainnet, tsp for testnet/signet).
+      def address_hrp
+        case Bitcoin.chain_params.network
+        when 'mainnet'
+          Bech32::SilentPaymentAddr::HRP_MAINNET
+        else
+          Bech32::SilentPaymentAddr::HRP_TESTNET
+        end
+      end
+    end
+  end
+end

data/lib/bitcoin/descriptor.rb

@@ -22,6 +22,7 @@ module Bitcoin
     autoload :RawTr,  'bitcoin/descriptor/raw_tr'
     autoload :Checksum, 'bitcoin/descriptor/checksum'
     autoload :MuSig, 'bitcoin/descriptor/musig'
+    autoload :Sp, 'bitcoin/descriptor/sp'
 
     module_function
 
@@ -137,6 +138,15 @@ module Bitcoin
       MuSig.new(keys, path)
     end
 
+    # Generate sp() descriptor for Silent Payment.
+    # @param [String] key_or_scan_key Either a spscan/spspend encoded key (single-argument form),
+    #   or the scan key for two-argument form.
+    # @param [String, Expression, nil] spend_key The spend key (for two-argument form) or nil for single-argument form.
+    # @return [Bitcoin::Descriptor::Sp]
+    def sp(key_or_scan_key, spend_key = nil)
+      Sp.new(key_or_scan_key, spend_key)
+    end
+
     # Parse descriptor string.
     # @param [String] string Descriptor string.
     # @return [Bitcoin::Descriptor::Expression]
@@ -202,6 +212,16 @@ module Bitcoin
       when 'musig'
         keys = args_str.split(',')
         path.empty? ? musig(*keys) : musig(*keys, path: path)
+      when 'sp'
+        scan_key, spend_key_str = split_two(args_str)
+        if spend_key_str.nil?
+          # Single argument form: spscan or spspend encoded key
+          sp(scan_key)
+        else
+          # Two argument form: separate scan and spend keys
+          spend_key = spend_key_str.include?('(') ? parse(spend_key_str, false) : spend_key_str
+          sp(scan_key, spend_key)
+        end
       else
         raise ArgumentError, "Parse failed: #{string}"
       end

data/lib/bitcoin/ext_key.rb

@@ -108,20 +108,22 @@ module Bitcoin
       end
       l = Bitcoin.hmac_sha512(chain_code, data)
       left = l[0..31].bth.to_i(16)
-      raise 'invalid key' if left >= CURVE_ORDER
+      raise 'invalid key' if left >= CURVE_ORDER || left == 0
       child_priv = (left + key.priv_key.to_i(16)) % CURVE_ORDER
-      raise 'invalid key ' if child_priv >= CURVE_ORDER
+      raise 'invalid key' if child_priv == 0
       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.
@@ -280,20 +282,22 @@ module Bitcoin
       data = pub.htb << [number].pack('N')
       l = Bitcoin.hmac_sha512(chain_code, data)
       left = l[0..31].bth.to_i(16)
-      raise 'invalid key' if left >= CURVE_ORDER
+      raise 'invalid key' if left >= CURVE_ORDER || left == 0
       l_priv = ECDSA::Format::IntegerOctetString.encode(left, 32)
       p1 = Bitcoin::Key.new(priv_key: l_priv.bth, key_type: Bitcoin::Key::TYPES[:uncompressed]).to_point
       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