bitcoinrb 1.15.0 → 1.16.0

data/lib/bitcoin/psbt/input.rb

@@ -73,8 +73,7 @@ module Bitcoin
             if key.size != Bitcoin::Key::PUBLIC_KEY_SIZE && key.size != Bitcoin::Key::COMPRESSED_PUBLIC_KEY_SIZE
               raise ArgumentError, 'Size of key was not the expected size for the type partial signature pubkey.'
             end
-            pubkey = Bitcoin::Key.new(pubkey: key.bth)
-            raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless pubkey.fully_valid_pubkey?
+            pubkey = PSBT.parse_pubkey(key.bth)
             raise ArgumentError, 'Duplicate Key, input partial signature for pubkey already provided.' if input.partial_sigs[pubkey.pubkey]
             input.partial_sigs[pubkey.pubkey] = value
           when PSBT_IN_TYPES[:sighash]
@@ -136,6 +135,7 @@ module Bitcoin
             begin
               cb = Bitcoin::Taproot::ControlBlock.parse_from_payload(key)
               raise ArgumentError, 'Duplicate Key, key for tap leaf script value already provided.' if input.tap_leaf_scripts[cb]
+              raise ArgumentError, 'Tap leaf script value must have a leaf version.' if value.bytesize < 1
               input.tap_leaf_scripts[cb] = value.bth
             rescue Bitcoin::Taproot::Error => e
               raise ArgumentError, e.message
@@ -143,6 +143,7 @@ module Bitcoin
           when PSBT_IN_TYPES[:tap_bip32_derivation]
             raise ArgumentError, 'Duplicate Key, key for tap bip32 derivation value already provided.' if input.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
+            PSBT.validate_tap_bip32_derivation!(value)
             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
@@ -239,6 +240,7 @@ module Bitcoin
       # @param [String] pubkey a public key with hex format.
       # @param [String] sig a signature.
       def add_sig(pubkey, sig)
+        PSBT.parse_pubkey(pubkey)
         raise ArgumentError, 'The sighash in signature is invalid.' if sighash_type && sig.unpack('C*')[-1] != sighash_type
         raise ArgumentError, 'Duplicate Key, input partial signature for pubkey already provided.' if partial_sigs[pubkey]
         partial_sigs[pubkey] = sig
@@ -249,51 +251,67 @@ 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 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 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 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)
+        field = ->(name) { PSBT.merge_field(send(name), psbi.send(name), "Input's #{name}") }
+        combined = Bitcoin::PSBT::Input.new(non_witness_utxo: field.call(:non_witness_utxo), witness_utxo: field.call(:witness_utxo))
+        # Fields which hold one value: present on one side, or equal on both.
+        %i[redeem_script witness_script sighash_type final_script_sig final_script_witness
+           tap_key_sig tap_internal_key tap_merkle_root].each do |name|
+          combined.send("#{name}=", field.call(name))
+        end
+        # Maps: the union. For a key present on both sides this input's value is kept, as Bitcoin Core's
+        # combiner inserts the other map into its own.
+        combined.partial_sigs = merge_partial_sigs(psbi.partial_sigs)
+        %i[hd_key_paths ripemd160_preimages sha256_preimages hash160_preimages hash256_preimages
+           tap_script_sigs tap_leaf_scripts tap_bip32_derivations].each do |name|
+          combined.send("#{name}=", psbi.send(name).merge(send(name)))
+        end
+        combined.proprietaries = PSBT.merge_proprietaries(proprietaries, psbi.proprietaries)
+        combined.unknowns = Hash[psbi.unknowns.merge(unknowns).sort]
         combined
       end
 
-      # finalize input.
-      # TODO This feature is experimental and support only multisig.
+      # Finalize this input, building the final scriptSig and witness from the partial signatures and scripts.
+      # Supported: P2PKH, P2PK, bare multisig, P2WPKH, P2WSH, P2SH wrapping any of them, and P2TR by the key
+      # path or a pk() or multi_a() leaf script. Anything else,
+      # a missing script or too few signatures raises rather than producing an unspendable input.
+      # @param [Integer] prevout_index The index of the output this input spends, used to look up the scriptPubKey
+      #   in +non_witness_utxo+. Not needed when +witness_utxo+ or a redeem/witness script is present.
       # @return [Bitcoin::PSBT::Input] finalized input.
-      def finalize!
-        if non_witness_utxo
-          self.final_script_sig = Bitcoin::Script.new << Bitcoin::Opcodes::OP_0 if redeem_script.multisig?
-          partial_sigs.values.each {|sig|final_script_sig << sig}
-          final_script_sig << redeem_script.to_hex
-          self.partial_sigs = {}
-          self.hd_key_paths = {}
-          self.redeem_script = nil
-          self.sighash_type = nil
-        else
-          if redeem_script
-            self.final_script_sig = Bitcoin::Script.parse_from_payload(Bitcoin::Script.pack_pushdata(redeem_script.to_payload))
-            self.redeem_script = nil
-          end
-          if witness_script
-            self.final_script_witness = Bitcoin::ScriptWitness.new
-            final_script_witness.stack << '' if witness_script.multisig?
-            partial_sigs.values.each {|sig| final_script_witness.stack << sig}
-            final_script_witness.stack << witness_script.to_payload
-            self.witness_script = nil
+      # @raise [ArgumentError] If the input cannot be finalized.
+      def finalize!(prevout_index = nil)
+        return self if signed?
+        script_pubkey = spent_script_pubkey(prevout_index)
+        if script_pubkey.p2sh?
+          raise ArgumentError, 'The redeem script is missing.' unless redeem_script
+          raise ArgumentError, 'The redeem script does not match the scriptPubKey.' unless redeem_script.to_p2sh == script_pubkey
+          if redeem_script.witness_program?
+            self.final_script_witness = Bitcoin::ScriptWitness.new(witness_stack(redeem_script))
+            self.final_script_sig = Bitcoin::Script.new << redeem_script.to_payload
+          else
+            self.final_script_sig = Bitcoin::Script.new
+            satisfaction(redeem_script).each { |item| final_script_sig << item }
+            final_script_sig << redeem_script.to_payload
           end
-          self.sighash_type = nil
-          self.partial_sigs = {}
-          self.hd_key_paths = {}
+        elsif script_pubkey.p2tr?
+          self.final_script_witness = Bitcoin::ScriptWitness.new(taproot_witness_stack)
+        elsif script_pubkey.witness_program?
+          self.final_script_witness = Bitcoin::ScriptWitness.new(witness_stack(script_pubkey))
+        else
+          self.final_script_sig = Bitcoin::Script.new
+          satisfaction(script_pubkey).each { |item| final_script_sig << item }
         end
+        # A finalized input carries nothing but the final scripts, as Bitcoin Core's finalizer leaves it.
+        self.partial_sigs = {}
+        self.hd_key_paths = {}
+        self.redeem_script = nil
+        self.witness_script = nil
+        self.sighash_type = nil
+        self.tap_key_sig = nil
+        self.tap_script_sigs = {}
+        self.tap_leaf_scripts = {}
+        self.tap_bip32_derivations = {}
+        self.tap_internal_key = nil
+        self.tap_merkle_root = nil
         self
       end
 
@@ -325,13 +343,146 @@ module Bitcoin
 
       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
+      # The union of the partial signatures of this input and +others+. Signatures for the keys of a multisig
+      # redeem or witness script come first in the order of the script, which keeps the serialization stable,
+      # and any other signature follows.
+      # @param [Hash] others partial signatures of the other input.
+      # @return [Hash]
+      def merge_partial_sigs(others)
+        sigs = others.merge(partial_sigs)
+        script = [redeem_script, witness_script].compact.find(&:multisig?)
+        return sigs unless script
+        ordered = {}
+        script.get_multisig_pubkeys.each { |pubkey| ordered[pubkey.bth] = sigs[pubkey.bth] if sigs[pubkey.bth] }
+        ordered.merge(sigs)
+      end
+
+      # The scriptPubKey this input spends.
+      # @param [Integer, nil] prevout_index The index of the output in +non_witness_utxo+.
+      # @return [Bitcoin::Script]
+      # @raise [ArgumentError] If it cannot be determined.
+      def spent_script_pubkey(prevout_index)
+        return witness_utxo.script_pubkey if witness_utxo
+        if non_witness_utxo && prevout_index
+          out = non_witness_utxo.out[prevout_index]
+          raise ArgumentError, "non_witness_utxo does not have output #{prevout_index}." unless out
+          return out.script_pubkey
+        end
+        # Without the utxo the scriptPubKey can still be inferred from the scripts.
+        return redeem_script.to_p2sh if redeem_script
+        return Bitcoin::Script.to_p2wsh(witness_script) if witness_script
+        raise ArgumentError, 'The scriptPubKey of this input cannot be determined. Set witness_utxo, or non_witness_utxo and pass the prevout index.'
+      end
+
+      # The witness stack satisfying the witness program +program+.
+      # @param [Bitcoin::Script] program A P2WPKH or P2WSH script.
+      # @return [Array[String]] stack items with binary format.
+      def witness_stack(program)
+        if program.p2wpkh?
+          satisfaction(program)
+        elsif program.p2wsh?
+          raise ArgumentError, 'The witness script is missing.' unless witness_script
+          raise ArgumentError, 'The witness script does not match the witness program.' unless Bitcoin::Script.to_p2wsh(witness_script) == program
+          satisfaction(witness_script) + [witness_script.to_payload]
+        else
+          raise ArgumentError, "Finalizing a witness program of this type is not supported: #{program}"
+        end
+      end
+
+      # The stack items which satisfy +script+, built from the partial signatures.
+      # @param [Bitcoin::Script] script A P2PKH, P2PK, P2WPKH or bare multisig script.
+      # @return [Array[String]] items with binary format, in the order they are pushed.
+      def satisfaction(script)
+        if script.p2pkh? || script.p2wpkh?
+          hash = (script.p2pkh? ? script.chunks[2] : script.chunks[1]).pushed_data.bth
+          pubkey, sig = partial_sigs.find { |pk, _| Bitcoin.hash160(pk) == hash }
+          raise ArgumentError, 'The partial signature for the key of this input is missing.' unless sig
+          [sig, pubkey.htb]
+        elsif script.p2pk?
+          sig = partial_sigs[script.chunks[0].pushed_data.bth]
+          raise ArgumentError, 'The partial signature for the key of this input is missing.' unless sig
+          [sig]
+        elsif script.multisig?
+          # Signatures are pushed in the order of the keys in the script, which is what OP_CHECKMULTISIG requires,
+          # and only as many as the threshold needs.
+          threshold = Bitcoin::Opcodes.opcode_to_small_int(script.chunks[0].opcode)
+          sigs = script.get_multisig_pubkeys.map { |pubkey| partial_sigs[pubkey.bth] }.compact
+          raise ArgumentError, "Not enough signatures: #{threshold} required, #{sigs.size} present." if sigs.size < threshold
+          [''] + sigs.first(threshold) # The empty item is consumed by the extra pop of OP_CHECKMULTISIG.
+        else
+          raise ArgumentError, "Finalizing a script of this type is not supported: #{script}"
+        end
+      end
+
+      # The witness stack spending a P2TR output, built as Bitcoin Core's SignTaproot does: the key path
+      # signature if there is one, otherwise the smallest witness among the leaf scripts whose signatures are
+      # all present.
+      # @return [Array[String]] stack items with binary format.
+      def taproot_witness_stack
+        return [tap_key_sig.htb] if tap_key_sig
+        stacks = tap_leaf_scripts.map do |control_block, value|
+          payload = value.htb
+          raise ArgumentError, 'Tap leaf script value must have a leaf version.' if payload.empty?
+          leaf_ver = payload[-1].ord # BIP-371: the script followed by its leaf version.
+          next unless leaf_ver == Bitcoin::TAPROOT_LEAF_TAPSCRIPT && leaf_ver == control_block.leaf_ver
+          script = Bitcoin::Script.parse_from_payload(payload[0...-1])
+          leaf_hash = Bitcoin::Taproot::LeafNode.new(script, leaf_ver).leaf_hash.bth
+          sigs = tapscript_satisfaction(script, leaf_hash)
+          sigs + [script.to_payload, control_block.to_payload] if sigs
+        end.compact
+        if stacks.empty?
+          raise ArgumentError, 'Neither the key path signature nor the signatures of a leaf script are present.'
+        end
+        stacks.min_by { |stack| [Bitcoin::ScriptWitness.new(stack).to_payload.bytesize, stack.last] }
+      end
+
+      # The stack items which satisfy the tapscript +script+, built from the tap script signatures.
+      # @param [Bitcoin::Script] script A pk() or multi_a() leaf script.
+      # @param [String] leaf_hash The leaf hash of +script+ with hex format.
+      # @return [Array[String], nil] items with binary format, or nil if the signatures are not all present.
+      def tapscript_satisfaction(script, leaf_hash)
+        chunks = script.chunks
+        # pk(): <32 byte key> OP_CHECKSIG
+        if chunks.size == 2 && xonly_push?(chunks[0]) && chunks[1].opcode == Bitcoin::Opcodes::OP_CHECKSIG
+          sig = tap_script_sigs[chunks[0].pushed_data.bth + leaf_hash]
+          return sig && [sig.htb]
+        end
+        # multi_a(): <key> OP_CHECKSIG (<key> OP_CHECKSIGADD)* <k> OP_NUMEQUAL
+        keys, threshold = multi_a_keys(chunks)
+        return nil unless keys
+        # OP_CHECKSIG takes the top item, so the signature for the first key is the last item pushed. The first
+        # k signatures found are used and every other key gets an empty item, as in Bitcoin Core.
+        good = 0
+        sigs = keys.reverse.map do |key|
+          sig = tap_script_sigs[key + leaf_hash]
+          next '' unless sig && good < threshold
+          good += 1
+          sig.htb
+        end
+        good == threshold ? sigs : nil
+      end
+
+      def xonly_push?(chunk)
+        chunk.pushdata? && chunk.pushed_data.bytesize == Bitcoin::X_ONLY_PUBKEY_SIZE
+      end
+
+      # @param [Array[String]] chunks The chunks of a script.
+      # @return [Array, nil] The x-only keys with hex format and the threshold of a multi_a() script, or nil.
+      def multi_a_keys(chunks)
+        return nil unless chunks.size >= 4 && chunks.size.even? && chunks[-1].opcode == Bitcoin::Opcodes::OP_NUMEQUAL
+        keys = []
+        chunks[0...-2].each_slice(2).with_index do |(key, op), i|
+          return nil unless xonly_push?(key) && op.opcode == (i.zero? ? Bitcoin::Opcodes::OP_CHECKSIG : Bitcoin::Opcodes::OP_CHECKSIGADD)
+          keys << key.pushed_data.bth
+        end
+        k = chunks[-2]
+        threshold = if k.pushdata?
+                      Bitcoin::Script.decode_number(k.pushed_data.bth)
+                    elsif (Bitcoin::Opcodes::OP_1..Bitcoin::Opcodes::OP_16).cover?(k.opcode)
+                      Bitcoin::Opcodes.opcode_to_small_int(k.opcode)
+                    end
+        return nil unless threshold && threshold.between?(1, keys.size)
+        [keys, threshold]
       end
 
     end

data/lib/bitcoin/psbt/key_origin_info.rb

@@ -14,6 +14,8 @@ module Bitcoin
       end
 
       def self.parse_from_payload(payload)
+        # A fingerprint and zero or more 4 byte indexes, as Bitcoin Core requires.
+        raise ArgumentError, 'Invalid length for HD key path.' if payload.bytesize < 4 || (payload.bytesize - 4) % 4 != 0
         buf = StringIO.new(payload)
         self.new(fingerprint: buf.read(4).bth, key_paths: buf.read.unpack('V*'))
       end

data/lib/bitcoin/psbt/output.rb

@@ -64,6 +64,7 @@ module Bitcoin
           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
+            PSBT.validate_tap_bip32_derivation!(value)
             output.tap_bip32_derivations[key.bth] = value.bth
           else
             unknown_key = (Bitcoin.pack_var_int(key_type) + key).bth
@@ -94,13 +95,15 @@ module Bitcoin
       # @return [Bitcoin::PSBT::Output] combined object.
       def merge(psbo)
         raise ArgumentError, 'The argument psbt must be an instance of Bitcoin::PSBT::Output.' unless psbo.is_a?(Bitcoin::PSBT::Output)
-        raise ArgumentError, 'The Partially Signed Output\'s redeem_script are different.' unless redeem_script == psbo.redeem_script
-        raise ArgumentError, 'The Partially Signed Output\'s witness_script are different.' unless witness_script == psbo.witness_script
         combined = Bitcoin::PSBT::Output.new
-        combined.redeem_script = redeem_script
-        combined.witness_script = witness_script
-        combined.unknowns = Hash[unknowns.merge(psbo.unknowns).sort]
-        combined.hd_key_paths = hd_key_paths.merge(psbo.hd_key_paths)
+        %i[redeem_script witness_script tap_internal_key tap_tree].each do |name|
+          combined.send("#{name}=", PSBT.merge_field(send(name), psbo.send(name), "Output's #{name}"))
+        end
+        # Maps: the union, with this output's value kept for a key present on both sides.
+        combined.hd_key_paths = psbo.hd_key_paths.merge(hd_key_paths)
+        combined.tap_bip32_derivations = psbo.tap_bip32_derivations.merge(tap_bip32_derivations)
+        combined.proprietaries = PSBT.merge_proprietaries(proprietaries, psbo.proprietaries)
+        combined.unknowns = Hash[psbo.unknowns.merge(unknowns).sort]
         combined
       end
 

data/lib/bitcoin/psbt/proprietary.rb

@@ -11,9 +11,12 @@ module Bitcoin
       # @param [String] value value with binary format.
       def initialize(key, value)
         buf = StringIO.new(key)
-        id_len = Bitcoin.unpack_var_int_from_io(buf)
-        @identifier = buf.read(id_len)
-        @sub_type = Bitcoin.unpack_var_int_from_io(buf)
+        begin
+          @identifier = Bitcoin.read_exact(buf, Bitcoin.unpack_var_int_from_io(buf))
+          @sub_type = Bitcoin.unpack_var_int_from_io(buf)
+        rescue ArgumentError
+          raise ArgumentError, 'Invalid proprietary key.'
+        end
         @value = value
       end
 

data/lib/bitcoin/psbt/tx.rb

@@ -49,7 +49,7 @@ module Bitcoin
       # @param [String] base64 a Partially Signed Bitcoin Transaction data with Base64 format.
       # @return [Bitcoin::PartiallySignedTx]
       def self.parse_from_base64(base64)
-        self.parse_from_payload(Base64.decode64(base64))
+        self.parse_from_payload(Base64.strict_decode64(base64))
       end
 
       # parse Partially Signed Bitcoin Transaction data.
@@ -130,6 +130,7 @@ module Bitcoin
         end
 
         raise ArgumentError, 'Outputs provided does not match the number of outputs in transaction.' unless partial_tx.outputs.size == partial_tx.tx.out.size
+        raise ArgumentError, 'Extra data after PSBT.' unless buf.eof?
 
         partial_tx
       end
@@ -257,15 +258,19 @@ module Bitcoin
           combined.outputs[index] = o.merge(psbt.outputs[index])
         end
 
-        combined.unknowns = Hash[unknowns.merge(psbt.unknowns).sort]
+        combined.xpubs = (xpubs + psbt.xpubs).uniq { |x| x.xpub.to_payload }
+        combined.version_number = PSBT.merge_field(version_number, psbt.version_number, "Tx's version_number")
+        combined.proprietaries = PSBT.merge_proprietaries(proprietaries, psbt.proprietaries)
+        combined.unknowns = Hash[psbt.unknowns.merge(unknowns).sort]
         combined
       end
 
       # finalize tx.
-      # TODO This feature is experimental and support only multisig.
+      # Finalize every input. See Bitcoin::PSBT::Input#finalize! for the supported script types.
       # @return [Bitcoin::PSBT::Tx] finalized PSBT.
+      # @raise [ArgumentError] If an input cannot be finalized.
       def finalize!
-        inputs.each {|input|input.finalize!}
+        inputs.each_with_index { |input, i| input.finalize!(tx.in[i].out_point.index) }
         self
       end
 

data/lib/bitcoin/psbt.rb

@@ -54,6 +54,52 @@ module Bitcoin
 
     module_function
 
+    # Combine one field of two PSBT maps the way a BIP-174 combiner does: a value present on one side only is
+    # taken, equal values are kept, and different values are a conflict.
+    # @param [Object] a The value of one map, or nil.
+    # @param [Object] b The value of the other map, or nil.
+    # @param [String] name The field, for the error message, e.g. "Input's non_witness_utxo".
+    # @return [Object] the combined value.
+    # @raise [ArgumentError] If both are present and differ.
+    def self.merge_field(a, b, name)
+      return b if a.nil?
+      return a if b.nil?
+      raise ArgumentError, "The Partially Signed #{name} are different." unless a == b
+      a
+    end
+
+    # Parse the public key of a PSBT record, which is 33 bytes compressed or 65 bytes uncompressed.
+    # @param [String] hex The public key with hex format.
+    # @return [Bitcoin::Key]
+    # @raise [ArgumentError] If +hex+ is not a valid public key.
+    def self.parse_pubkey(hex)
+      unless hex.is_a?(String) && hex.valid_hex? && [Bitcoin::Key::COMPRESSED_PUBLIC_KEY_SIZE, Bitcoin::Key::PUBLIC_KEY_SIZE].include?(hex.size / 2)
+        raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY
+      end
+      key_type = hex.size == Bitcoin::Key::PUBLIC_KEY_SIZE * 2 ? Bitcoin::Key::TYPES[:uncompressed] : Bitcoin::Key::TYPES[:compressed]
+      key = Bitcoin::Key.new(pubkey: hex, key_type: key_type)
+      raise ArgumentError, Errors::Messages::INVALID_PUBLIC_KEY unless key.fully_valid_pubkey?
+      key
+    end
+
+    # Combine two lists of proprietary records, keeping the first record for a key which appears in both.
+    # @return [Array[Bitcoin::PSBT::Proprietary]]
+    def self.merge_proprietaries(a, b)
+      (a + b).uniq(&:key)
+    end
+
+    # Check the value of a tap bip32 derivation record (BIP-371): a compact size count of leaf hashes,
+    # the hashes, then a fingerprint and the 4 byte indexes of the path.
+    # @param [String] value the value with binary format.
+    # @raise [ArgumentError]
+    def self.validate_tap_bip32_derivation!(value)
+      buf = StringIO.new(value)
+      count = Bitcoin.unpack_var_int_from_io(buf)
+      raise ArgumentError, 'Invalid tap bip32 derivation value.' if count.nil? || count * 32 > buf.size - buf.pos
+      rest = buf.size - buf.pos - count * 32
+      raise ArgumentError, 'Invalid length for HD key path.' if rest < 4 || (rest - 4) % 4 != 0
+    end
+
     def self.serialize_to_vector(key_type, key: nil, value: nil)
       key_len = Bitcoin.pack_var_int(key_type).bytesize
       key_len += key.bytesize if key

data/lib/bitcoin/rpc/bitcoin_core_client.rb

@@ -14,6 +14,15 @@ module Bitcoin
     # client.listunspent
     # client.getblockchaininfo
     #
+    # An error answered by Bitcoin Core raises Bitcoin::RPC::Error, which carries the error code:
+    #
+    # begin
+    #   client.getblock('00')
+    # rescue Bitcoin::RPC::Error => e
+    #   e.code     # => -8
+    #   e.message  # => "blockhash must be of length 64 (not 2, for '00')"
+    # end
+    #
     class BitcoinCoreClient
 
       attr_reader :config
@@ -37,43 +46,75 @@ module Bitcoin
         end
       end
 
+      # Whether a Ruby-like method name such as get_block_hash maps to an RPC command.
+      def respond_to_missing?(name, include_private = false)
+        (name.to_s.include?('_') && respond_to?(name.to_s.delete('_').to_sym)) || super
+      end
+
       private
 
-      def server_url
-        url = "#{config[:schema]}://#{config[:user]}:#{config[:password]}@#{config[:host]}:#{config[:port]}"
+      # The URL of the RPC endpoint, without the credentials. These go in the Authorization header,
+      # so a password with characters such as '@', '/' or '#' cannot change the host or the path.
+      # @return [URI::HTTP]
+      def server_uri
+        path = '/'
         if !config[:wallet].nil? && !config[:wallet].empty?
-          url += "/wallet/#{config[:wallet]}"
+          path = "/wallet/#{percent_encode(config[:wallet])}"
         end
-        url
+        klass = config[:schema].to_s == 'https' ? URI::HTTPS : URI::HTTP
+        klass.build(host: config[:host], port: config[:port], path: path)
       end
 
+      # Percent-encode every character of +str+ which is not unreserved in a URL path.
+      def percent_encode(str)
+        str.to_s.b.gsub(/[^A-Za-z0-9\-._~]/) { |c| format('%%%02X', c.ord) }
+      end
+
+      # Send +command+ to Bitcoin Core and return the result.
+      # @raise [Bitcoin::RPC::Error] If Bitcoin Core answers an error, or an answer which is not the JSON-RPC
+      # response to this request.
       def request(command, *params)
+        id = SecureRandom.hex(8)
         data = {
             :method => command,
             :params => params,
-            :id => 'jsonrpc'
+            :id => id
         }
-        uri = URI.parse(server_url)
+        uri = server_uri
         http = Net::HTTP.new(uri.hostname, uri.port)
-        http.use_ssl = uri.scheme === "https"
-        request = Net::HTTP::Post.new(uri.path.empty? ? '/' : uri.path)
-        request.basic_auth(uri.user, uri.password)
+        http.use_ssl = uri.scheme == 'https'
+        request = Net::HTTP::Post.new(uri.path)
+        request.basic_auth(config[:user].to_s, config[:password].to_s)
         request.content_type = 'application/json'
         request.body = data.to_json
         response = http.request(request)
+        http_status = response.code.to_i
         # Unescape \uXXXX with JSON.parse itself. Doing it beforehand lets a " contained in
         # a string value close that string and inject arbitrary JSON into the parsed result.
-        json_data = JSON.parse(response.body)
+        begin
+          json_data = JSON.parse(response.body.to_s)
+        rescue JSON::ParserError
+          # Bitcoin Core answers an error as JSON, so this is for example a 401 from the wrong credentials.
+          raise Error.new("Bitcoin Core answered HTTP #{http_status} #{response.message} without a JSON-RPC response.", http_status: http_status)
+        end
+        unless json_data.is_a?(Hash)
+          raise Error.new("Bitcoin Core answered something which is not a JSON-RPC response: #{response.body}", http_status: http_status)
+        end
+        # Bitcoin Core echoes the id of the request, so a different one is the answer to another request.
+        if json_data.key?('id') && !json_data['id'].nil? && json_data['id'] != id
+          raise Error.new("The id of the JSON-RPC response #{json_data['id'].inspect} is not the id of the request #{id.inspect}.", http_status: http_status)
+        end
         response = convert_floats_to_strings(json_data)
-        raise response['error'].to_json if response['error']
+        raise Error.from_response(response['error'], http_status: http_status) if response['error']
         response['result']
       end
       
       # Call CLI command on Ruby-like method names.
       # e.g. generate_to_address, send_to_address, get_wallet_info
       def method_missing(name, *args)
-        if name.to_s.include?('_')
-          send(name.to_s.gsub('_', '').to_sym, args)
+        command = name.to_s.delete('_').to_sym
+        if name.to_s.include?('_') && respond_to?(command)
+          send(command, *args)
         else
           super
         end

data/lib/bitcoin/rpc/error.rb

@@ -0,0 +1,43 @@
+module Bitcoin
+  module RPC
+
+    # An error answered by Bitcoin Core to an RPC request, or an answer which is not a JSON-RPC response.
+    # It is a RuntimeError, as the error raised before it was, so an existing rescue still catches it.
+    class Error < RuntimeError
+
+      # @return [Integer, nil] The JSON-RPC error code answered by Bitcoin Core, such as -8 for an invalid
+      # parameter, or nil if the error is not a JSON-RPC error.
+      attr_reader :code
+      # @return [Integer, nil] The HTTP status of the response.
+      attr_reader :http_status
+      # @return [Hash, nil] The error object of the JSON-RPC response as it was answered.
+      attr_reader :data
+
+      # @param [String] message The error message.
+      # @param [Integer, nil] code The JSON-RPC error code.
+      # @param [Integer, nil] http_status The HTTP status of the response.
+      # @param [Hash, nil] data The error object of the JSON-RPC response.
+      def initialize(message, code: nil, http_status: nil, data: nil)
+        super(message)
+        @code = code
+        @http_status = http_status
+        @data = data
+      end
+
+      # Build the error for the error object +error+ of a JSON-RPC response.
+      # @param [Hash, Object] error The value of the error field of the response.
+      # @param [Integer, nil] http_status The HTTP status of the response.
+      # @return [Bitcoin::RPC::Error]
+      def self.from_response(error, http_status: nil)
+        if error.is_a?(Hash)
+          code = error['code']
+          code = Integer(code, exception: false) || code if code.is_a?(String)
+          new(error['message'].to_s, code: code, http_status: http_status, data: error)
+        else
+          new(error.to_s, http_status: http_status, data: error)
+        end
+      end
+    end
+
+  end
+end

data/lib/bitcoin/rpc.rb

@@ -1,5 +1,6 @@
 module Bitcoin
   module RPC
     autoload :BitcoinCoreClient, 'bitcoin/rpc/bitcoin_core_client'
+    autoload :Error, 'bitcoin/rpc/error'
   end
 end