bitcoinrb 1.12.0 → 1.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d7be6093f10fa04e688b7106ecc080066e0ec693af6b23bb1e0ddb0dbc2e586
-  data.tar.gz: e3fce6344304e22350cde36a0471d1dd1a0dc5d8c1d8b22309efc20704cd74f5
+  metadata.gz: e60d83b48a9f7189cd07c75ee61749ab50a83895f86dd97c7d7fbbd568234067
+  data.tar.gz: 04e39f6f592379617273944009f78d224cf181f1877de15a285665e9b25602b3
 SHA512:
-  metadata.gz: f65b05a052712bf2186543fbae88222b5e8e753aa201ca00c6997ffad364cab62bfa0b47a091eb998343ffacbcd050c05c9def591d90e28c8a04a3c71286a909
-  data.tar.gz: 47e7fd6c0cb573723523671b2f0002c2d347e4e8187e08157a72326fb91094631c581290356c29fe25d65d9adb5e420b39e3cf22efcbcff24e9d281cef734f3a
+  metadata.gz: 13046ad4ba44662c2689d13dec7d51bc88e2d80cccaedc0048ee7484136e5cf04600161b5b7ae99faf4e1d7081fb845b403ebc3defb9cf92e46847e500befd65
+  data.tar.gz: 12c68844e79ca382dc774d6d4d6cdad8bbd33064a315098e0a31eecb88ac1369c2bd4ff6b39da49d3d5b2eae9750beff11e5761dbbdbe6221c3ef1100cd8cde2

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/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
 
@@ -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

@@ -92,14 +92,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 +111,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

@@ -95,7 +95,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/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,9 +108,9 @@ 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]
@@ -280,7 +280,7 @@ 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

data/lib/bitcoin/message/ping.rb

@@ -18,11 +18,13 @@ module Bitcoin
       end
 
       def to_payload
-        [nonce].pack('Q')
+        nonce ? [nonce].pack('Q') : ''
       end
 
+      # Generate pong message as a response. Return nil if the ping has no nonce
+      # (sent by a node before BIP-31), since such a ping does not expect a pong.
       def to_response
-        Pong.new(nonce)
+        Pong.new(nonce) if nonce
       end
 
     end

data/lib/bitcoin/message/version.rb

@@ -61,7 +61,7 @@ module Bitcoin
       end
 
       def unpack_relay_field(payload)
-        ( version >= 70001 && payload ) ? unpack_boolean(payload) : [ true, nil ]
+        ( version >= 70001 && payload && !payload.empty? ) ? unpack_boolean(payload) : [ true, nil ]
       end
 
       # Check whether +service_flag+ support this version.

data/lib/bitcoin/message_sign.rb

@@ -10,6 +10,22 @@ module Bitcoin
     FORMAT_SIMPLE = :simple
     FORMAT_FULL = :full
 
+    # Prefix
+    SIGNATURE_PREFIX_SIMPLE = 'smp'
+    SIGNATURE_PREFIX_FULL = 'ful'
+    SIGNATURE_PREFIX_POF = 'pof'
+
+    # BIP-322 Required rules
+    BIP322_VERIFY_FLAGS = [
+      SCRIPT_VERIFY_P2SH, SCRIPT_VERIFY_DERSIG, SCRIPT_VERIFY_STRICTENC,
+      SCRIPT_VERIFY_LOW_S, SCRIPT_VERIFY_NULLFAIL, SCRIPT_VERIFY_MINIMALDATA,
+      SCRIPT_VERIFY_CLEANSTACK, SCRIPT_VERIFY_MINIMALIF,
+      SCRIPT_VERIFY_CONST_SCRIPTCODE,
+      SCRIPT_VERIFY_WITNESS, SCRIPT_VERIFY_TAPROOT,
+      SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS,
+      SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
+    ].inject(:|)
+
     # Sign a message.
     # @param [Bitcoin::Key] key Private key to sign.
     # @param [String] message The message to be signed.
@@ -20,28 +36,38 @@ module Bitcoin
     def sign_message(key, message, prefix: Bitcoin.chain_params.message_magic, format: FORMAT_LEGACY, address: nil)
       validate_format!(format)
       digest = message_hash(message, prefix: prefix, legacy: format == FORMAT_LEGACY)
+      prefix_marker = ''
       sig = case format
             when FORMAT_LEGACY
               key.sign_compact(digest)
             else
               validate_address!(address)
               addr = Bitcoin::Script.parse_from_addr(address)
-              sig_ver, algo = if addr.p2wpkh?
+              sig_ver, algo = if addr.p2wpkh? || addr.p2wsh?
                                 [:witness_v0, :ecdsa]
                               elsif addr.p2tr?
                                 [:taproot, :schnorr]
                               else
-                                raise ArgumentError "#{address} dose not supported."
+
                               end
               tx = to_sign_tx(digest, address)
-              prev_out = Bitcoin::TxOut.new(script_pubkey: addr)
-              sighash = tx.sighash_for_input(0, addr, sig_version: sig_ver, amount: 0, prevouts: [prev_out])
-              sig = key.sign(sighash, algo: algo) + [Bitcoin::SIGHASH_TYPE[:all]].pack('C')
-              tx.in[0].script_witness.stack << sig
-              tx.in[0].script_witness.stack << key.pubkey.htb
+              prev_out = Bitcoin::TxOut.new(script_pubkey: addr, value: 0)
+              if addr.p2tr?
+                sighash = tx.sighash_for_input(0, addr, sig_version: :taproot, prevouts: [prev_out], hash_type: Bitcoin::SIGHASH_TYPE[:default])
+                tweaked = Bitcoin::Taproot.tweak_private_key(key, '')
+                tx.in[0].script_witness.stack << tweaked.sign(sighash, algo: :schnorr)
+              elsif addr.p2wpkh? || addr.p2wsh?
+                sighash = tx.sighash_for_input(0, addr, sig_version: :witness_v0, amount: 0, prevouts: [prev_out])
+                ecdsa  = key.sign(sighash, algo: :ecdsa) + [Bitcoin::SIGHASH_TYPE[:all]].pack('C')
+                tx.in[0].script_witness.stack << ecdsa
+                tx.in[0].script_witness.stack << key.pubkey.htb
+              else
+                raise ArgumentError, "#{address} dose not supported."
+              end
+              prefix_marker = format == FORMAT_SIMPLE ? SIGNATURE_PREFIX_SIMPLE : SIGNATURE_PREFIX_FULL
               format == FORMAT_SIMPLE ? tx.in[0].script_witness.to_payload : tx.to_payload
             end
-      Base64.strict_encode64(sig)
+      prefix_marker + Base64.strict_encode64(sig)
     end
 
     # Verify a signed message.
@@ -51,41 +77,41 @@ module Bitcoin
     # @return [Boolean] Verification result.
     def verify_message(address, signature, message, prefix: Bitcoin.chain_params.message_magic)
       addr_script = Bitcoin::Script.parse_from_addr(address)
+      variant, body = case signature
+                      when ''
+                        raise ArgumentError, 'signature too short'
+                      when /\A#{SIGNATURE_PREFIX_SIMPLE}/
+                        [:simple, signature[3..]]
+                      when /\A#{SIGNATURE_PREFIX_FULL}/
+                        [:full, signature[3..]]
+                      when /\A#{SIGNATURE_PREFIX_POF}/
+                        [:pof, signature[3..]]
+                      else
+                        [:fallback, signature]
+                      end
       begin
-        sig = Base64.strict_decode64(signature)
+        payload = Base64.strict_decode64(body)
       rescue ArgumentError
         raise ArgumentError, 'Invalid signature'
       end
-      if addr_script.p2pkh?
-        begin
-          # Legacy verification
-          pubkey = Bitcoin::Key.recover_compact(message_hash(message, prefix: prefix, legacy: true), sig)
-          return false unless pubkey
-          pubkey.to_p2pkh == address
-        rescue Exception
-          false
-        end
-      elsif addr_script.witness_program?
-        # BIP322 verification
-        digest = message_hash(message, prefix: prefix, legacy: false)
+
+      case variant
+      when :simple, :fallback
+        return verify_legacy(address, payload, message, prefix: prefix) if addr_script.p2pkh?
+        raise ArgumentError, 'simple format not supported for this address' unless
+          addr_script.p2wpkh? || addr_script.p2wsh? || addr_script.p2tr?
+        verify_simple(addr_script, payload, message, prefix: prefix)
+      when :full
         begin
-          # Full
-          tx = Bitcoin::Tx.parse_from_payload(sig)
-          validate_to_sign_tx!(tx)
-          to_spend = to_spend_tx(digest, address)
-          return false unless tx.in[0].out_point.tx_hash == to_spend.tx_hash
-        rescue Exception
-          # Simple
-          tx = to_sign_tx(digest, address)
-          tx.in[0].script_witness = Bitcoin::ScriptWitness.parse_from_payload(sig)
+          tx = Bitcoin::Tx.parse_from_payload(payload)
+        rescue StandardError
+          raise ArgumentError, 'error parsing signature as full variant'
         end
-        script_pubkey = Bitcoin::Script.parse_from_addr(address)
-        tx_out = Bitcoin::TxOut.new(script_pubkey: script_pubkey)
-        flags = Bitcoin::STANDARD_SCRIPT_VERIFY_FLAGS
-        interpreter = Bitcoin::ScriptInterpreter.new(flags: flags, checker: Bitcoin::TxChecker.new(tx: tx, input_index: 0, prevouts: [tx_out]))
-        interpreter.verify_script(Bitcoin::Script.new, script_pubkey, tx.in[0].script_witness)
+        verify_full(addr_script, tx, message, prefix: prefix)
+      when :pof
+        raise NotImplementedError, 'proof of funds variant is not supported'
       else
-        raise ArgumentError, "This address unsupported."
+        raise ArgumentError, "unknown signature variant: #{variant.inspect}"
       end
     end
 
@@ -99,8 +125,7 @@ module Bitcoin
     end
 
     def validate_address!(address)
-      script = Bitcoin::Script.parse_from_addr(address)
-      raise ArgumentError, 'This address unsupported' if script.p2sh? || script.p2wsh?
+      Bitcoin::Script.parse_from_addr(address)
     end
 
     def validate_format!(format)
@@ -110,6 +135,7 @@ module Bitcoin
     end
 
     def validate_to_sign_tx!(tx)
+      raise ArgumentError, "Invalid version." unless [0, 2].include?(tx.version)
       raise ArgumentError, "Multiple inputs (proof of funds) are not supported." unless tx.in.length == 1
       raise ArgumentError, "vin[0].prevout.n must be 0." unless tx.in[0].out_point.index == 0
       raise ArgumentError, "Multiple outputs are not supported." unless tx.out.length == 1
@@ -140,8 +166,42 @@ module Bitcoin
       tx
     end
 
+    def verify_simple(addr_script, witness_payload, message, prefix:)
+      digest = message_hash(message, prefix: prefix, legacy: false)
+      tx = to_sign_tx(digest, addr_script.to_addr)
+      tx.in[0].script_witness = Bitcoin::ScriptWitness.parse_from_payload(witness_payload)
+      run_interpreter(tx, addr_script)
+    end
+
+    def verify_full(addr_script, tx, message, prefix:)
+      digest = message_hash(message, prefix: prefix, legacy: false)
+      to_spend = to_spend_tx(digest, addr_script.to_addr)
+      validate_to_sign_tx!(tx)
+      return false unless tx.in[0].out_point.tx_hash == to_spend.tx_hash
+      run_interpreter(tx, addr_script)
+    end
+
+    def run_interpreter(tx, script_pubkey)
+      tx_out = Bitcoin::TxOut.new(script_pubkey: script_pubkey)
+      checker = Bitcoin::TxChecker.new(tx: tx, input_index: 0, prevouts: [tx_out])
+      interpreter = Bitcoin::ScriptInterpreter.new(flags: BIP322_VERIFY_FLAGS, checker: checker)
+      interpreter.verify_script(tx.in[0].script_sig, script_pubkey, tx.in[0].script_witness)
+    end
+
+    def verify_legacy(address, sig_bytes, message, prefix:)
+      pubkey = Bitcoin::Key.recover_compact(message_hash(message, prefix: prefix, legacy: true), sig_bytes)
+      return false unless pubkey
+      pubkey.to_p2pkh == address
+    rescue StandardError
+      false
+    end
+
     private_class_method :validate_address!
     private_class_method :validate_format!
     private_class_method :validate_to_sign_tx!
+    private_class_method :run_interpreter
+    private_class_method :verify_simple
+    private_class_method :verify_full
+    private_class_method :verify_legacy
   end
 end

data/lib/bitcoin/rpc.rb

@@ -1,7 +1,5 @@
 module Bitcoin
   module RPC
-    autoload :HttpServer, 'bitcoin/rpc/http_server'
-    autoload :RequestHandler, 'bitcoin/rpc/request_handler'
     autoload :BitcoinCoreClient, 'bitcoin/rpc/bitcoin_core_client'
   end
 end