bitcoinrb 1.12.0 → 1.13.0

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

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/silent_payment/output.rb

@@ -0,0 +1,46 @@
+module Bitcoin
+  module SilentPayment
+    # Represents a detected silent payment output.
+    class Output
+      # @return [Bitcoin::TxOut] The detected transaction output.
+      attr_reader :tx_out
+
+      # @return [String] The tweak value (t_k) used to derive the output key (32 bytes binary).
+      attr_reader :tweak
+
+      # @return [Integer, nil] The label used for this output, or nil if no label was used.
+      attr_reader :label
+
+      # @param [Bitcoin::TxOut] tx_out The detected transaction output.
+      # @param [String] tweak The tweak value (t_k) as 32 bytes binary.
+      # @param [Integer, nil] label The label integer, or nil if no label was used.
+      # @raise [ArgumentError] If any parameter has an invalid type.
+      def initialize(tx_out, tweak, label = nil)
+        raise ArgumentError, "tx_out must be a Bitcoin::TxOut." unless tx_out.is_a?(Bitcoin::TxOut)
+        raise ArgumentError, "tweak must be a 32-byte String." unless tweak.is_a?(String) && tweak.bytesize == 32
+        raise ArgumentError, "label must be an Integer or nil." unless label.nil? || label.is_a?(Integer)
+        @tx_out = tx_out
+        @tweak = tweak
+        @label = label
+      end
+
+      # Returns the x-only public key of the output.
+      # @return [String] The x-only public key as hex string.
+      def pubkey
+        tx_out.script_pubkey.witness_data[1].bth
+      end
+
+      # Returns the tweak as hex string.
+      # @return [String] The tweak value as hex string.
+      def tweak_hex
+        tweak.bth
+      end
+
+      # Returns whether this output was detected using a label.
+      # @return [Boolean]
+      def labeled?
+        !label.nil?
+      end
+    end
+  end
+end

data/lib/bitcoin/silent_payment.rb

@@ -1,12 +1,22 @@
+require 'set'
+
 module Bitcoin
+  # BIP-352 silent payment module.
+  # @see https://github.com/bitcoin/bips/blob/master/bip-0352.mediawiki
   module SilentPayment
+    autoload :Output, 'bitcoin/silent_payment/output'
 
-
-    # Derive payment
-    # @param [Array] prevouts An array of previous output script(Bitcoin::Script).
-    # @param [Array] private_keys An array of private key corresponding to each public key in prevouts.
-    # @param [Array] recipients
-    # @return [Array]
+    # Maximum number of silent payment addresses that can share the same scan public key
+    # within a single transaction. This is the maximum number of P2TR outputs that can fit
+    # within a 100KB transaction under current standardness rules.
+    K_MAX = 2323
+    
+    # Derive payment point.
+    #
+    # @param [Array<Bitcoin::Script>] prevouts An array of previous output script.
+    # @param [Array<Bitcoin::Key>] private_keys An array of Bitcoin::Key objects corresponding to each public key in prevouts.
+    # @param [Array<Bech32::SilentPaymentAddr>] recipients
+    # @return [Array<ECDSA::Point>] An array of derived points.
     # @raise [ArgumentError]
     def derive_payment_points(prevouts, private_keys, recipients)
       raise ArgumentError, "prevouts must be Array." unless prevouts.is_a? Array
@@ -14,19 +24,19 @@ module Bitcoin
       raise ArgumentError, "prevouts and private_keys must be the same length." unless prevouts.length == private_keys.length
       raise ArgumentError, "recipients must be Array." unless recipients.is_a? Array
 
-      outpoint_l = inputs.map{|i|i.out_point.to_hex}.sort.first
-
       input_pub_keys = []
       field = ECDSA::PrimeField.new(Bitcoin::Secp256k1::GROUP.order)
       sum_priv_keys = 0
       prevouts.each_with_index do |prevout, index|
-        k = Bitcoin::Key.new(priv_key: private_keys[index].to_s(16))
+        key = private_keys[index]
+        raise ArgumentError, "private_keys element must be Bitcoin::Key." unless key.is_a? Bitcoin::Key
+        priv_key_int = key.priv_key.to_i(16)
         public_key = extract_public_key(prevout, inputs[index])
         next if public_key.nil?
-        private_key = if public_key.p2tr? && k.to_point.y.odd?
-                        field.mod(-private_keys[index])
+        private_key = if public_key.p2tr? && key.to_point.y.odd?
+                        field.mod(-priv_key_int)
                       else
-                        private_keys[index]
+                        priv_key_int
                       end
         input_pub_keys << public_key
         sum_priv_keys = field.mod(sum_priv_keys + private_key)
@@ -34,6 +44,8 @@ module Bitcoin
       agg_pubkey = (Bitcoin::Secp256k1::GROUP.generator.to_jacobian * sum_priv_keys).to_affine
       return [] if agg_pubkey.infinity?
 
+      outpoint_l = inputs.map{|i|i.out_point.to_hex}.sort.first
+
       input_hash = Bitcoin.tagged_hash("BIP0352/Inputs", outpoint_l.htb + agg_pubkey.to_hex.htb).bth
 
       destinations = {}
@@ -42,6 +54,12 @@ module Bitcoin
         destinations[sp_addr.scan_key] = [] unless destinations.has_key?(sp_addr.scan_key)
         destinations[sp_addr.scan_key] << sp_addr.spend_key
       end
+
+      # Check K_max limit: fail if any group exceeds the limit
+      destinations.each_value do |spends|
+        raise ArgumentError, "Recipient group exceeds K_max limit (#{K_MAX})." if spends.length > K_MAX
+      end
+
       outputs = []
       destinations.each do |scan_key, spends|
         scan_key = Bitcoin::Key.new(pubkey: scan_key).to_point.to_jacobian
@@ -55,6 +73,89 @@ module Bitcoin
       outputs
     end
 
+
+    # Scan transaction outputs for silent payment outputs belonging to the receiver.
+    #
+    # @param [Array<Bitcoin::Script>] prevouts An array of previous output scripts corresponding to each input.
+    # @param [Bitcoin::Key] scan_private_key The receiver's scan private key (b_scan).
+    # @param [Bitcoin::Key] spend_pubkey The receiver's spend key. Pass a Key initialized with spend_priv_key to derive the public key.
+    # @param [Array<Integer>] labels An array of label integers for labeled addresses (default: []).
+    # @return [Array<Bitcoin::SilentPayment::Output>] An array of detected silent payment outputs.
+    # @raise [ArgumentError] If any of the required parameters are invalid.
+    def scan_sp_outputs(prevouts, scan_private_key, spend_pubkey, labels = [])
+      raise ArgumentError, "prevouts must be Array." unless prevouts.is_a? Array
+      raise ArgumentError, "scan_private_key must be Bitcoin::Key." unless scan_private_key.is_a? Bitcoin::Key
+      raise ArgumentError, "spend_pubkey must be Bitcoin::Key." unless spend_pubkey.is_a? Bitcoin::Key
+
+      has_taproot = !outputs.find{|o| o.script_pubkey.p2tr? }.nil?
+      return [] unless has_taproot
+      sum_pub_keys = Bitcoin::Secp256k1::GROUP.infinity.to_jacobian
+      maximum_witness_version = Bitcoin::Opcodes.opcode_to_small_int(Bitcoin::Opcodes::OP_1)
+      prevouts.each.with_index do |prevout, index|
+        return [] if prevout.witness_program? && prevout.witness_data.first > maximum_witness_version
+
+        public_key = extract_public_key(prevout, inputs[index])
+        next if public_key.nil?
+        sum_pub_keys += public_key.to_point.to_jacobian
+      end
+      return [] if sum_pub_keys.infinity?
+
+      field = ECDSA::PrimeField.new(Bitcoin::Secp256k1::GROUP.order)
+      outpoint_l = inputs.map{|i|i.out_point.to_hex}.sort.first
+      input_hash = Bitcoin.tagged_hash("BIP0352/Inputs", outpoint_l.htb + sum_pub_keys.to_affine.to_hex.htb).bth
+      ecdh_shared_secret = (sum_pub_keys * field.mod(input_hash.to_i(16) * scan_private_key.priv_key.to_i(16))).to_affine.to_hex.htb
+
+      # Pre-compute label tweak points with their label values and scalar tweaks
+      label_tweaks = labels.map do |m|
+        label_tweak = Bitcoin.tagged_hash('BIP0352/Label', scan_private_key.priv_key.htb + [m].pack('N'))
+        label_point = Bitcoin::Secp256k1::GROUP.generator.to_jacobian * label_tweak.bti
+        [m, label_tweak, label_point]
+      end
+
+      k = 0
+      results = []
+      found_outputs = Set.new
+      loop do
+        # Stop scanning if K_max limit is reached
+        break if k == K_MAX
+
+        t_k = Bitcoin.tagged_hash('BIP0352/SharedSecret', ecdh_shared_secret + [k].pack('N'))
+        p_k = Bitcoin::Secp256k1::GROUP.generator.to_jacobian * t_k.bti + spend_pubkey.to_point.to_jacobian
+        found = false
+        outputs.each do |output|
+          next unless output.script_pubkey.p2tr?
+          next if found_outputs.include?(output)
+          output_pubkey = Bitcoin::Key.from_xonly_pubkey(output.script_pubkey.witness_data[1].bth)
+
+          # Check basic match (no label)
+          if p_k.to_affine.x == output_pubkey.to_point.x
+            results << SilentPayment::Output.new(output, t_k)
+            found_outputs << output
+            k += 1
+            found = true
+            break
+          end
+
+          # Check labeled matches
+          label_tweaks.each do |label_value, label_tweak_scalar, label_point|
+            p_k_labeled = p_k + label_point
+            if p_k_labeled.to_affine.x == output_pubkey.to_point.x
+              # Full tweak is t_k + label_tweak (mod order)
+              full_tweak = field.mod(t_k.bti + label_tweak_scalar.bti).to_s(16).rjust(64, '0').htb
+              results << SilentPayment::Output.new(output, full_tweak, label_value)
+              found_outputs << output
+              k += 1
+              found = true
+              break
+            end
+          end
+          break if found
+        end
+        break unless found
+      end
+      results
+    end
+
     # Extract public keys from +prevout+ and input.
     def extract_public_key(prevout, input)
       if prevout.p2pkh?

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

@@ -14,7 +14,7 @@ module Bitcoin
 
     def unpack_var_string(payload)
       size, payload = unpack_var_int(payload)
-      size > 0 ? payload.unpack("a#{size}a*") : [nil, payload]
+      size && size > 0 ? payload.unpack("a#{size}a*") : ['', payload.to_s]
     end
 
     def pack_var_int(i)
@@ -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
@@ -102,7 +102,7 @@ module Bitcoin
     # @return [String] the hash value with binary format.
     def tagged_hash(tag, msg)
       tag_hash = Digest::SHA256.digest(tag)
-      Digest::SHA256.digest(tag_hash + tag_hash + msg)
+      Digest::SHA256.digest(tag_hash + tag_hash + msg.b)
     end
 
     # encode Base58 check address.

data/lib/bitcoin/version.rb

@@ -1,3 +1,3 @@
 module Bitcoin
-  VERSION = "1.12.0"
+  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

@@ -2,13 +2,12 @@
 # https://github.com/lian/bitcoin-ruby/blob/master/COPYING
 
 require 'bitcoin/version'
-require 'eventmachine'
 require 'schnorr'
 require 'securerandom'
+require 'stringio'
 require 'json'
 require 'bech32'
 require 'base64'
-require 'observer'
 require 'tmpdir'
 require 'merkle'
 
@@ -36,13 +35,10 @@ module Bitcoin
   autoload :ExtKey, 'bitcoin/ext_key'
   autoload :ExtPubkey, 'bitcoin/ext_key'
   autoload :Opcodes, 'bitcoin/opcodes'
-  autoload :Node, 'bitcoin/node'
   autoload :Base58, 'bitcoin/base58'
   autoload :Secp256k1, 'bitcoin/secp256k1'
   autoload :Mnemonic, 'bitcoin/mnemonic'
   autoload :ValidationState, 'bitcoin/validation'
-  autoload :Network, 'bitcoin/network'
-  autoload :Store, 'bitcoin/store'
   autoload :RPC, 'bitcoin/rpc'
   autoload :Wallet, 'bitcoin/wallet'
   autoload :BloomFilter, 'bitcoin/bloom_filter'
@@ -64,7 +60,6 @@ module Bitcoin
   autoload :SilentPayment, 'bitcoin/silent_payment'
   autoload :BIP324, 'bitcoin/bip324'
   autoload :BIP321URI, 'bitcoin/bip321_uri'
-  autoload :BIP353, 'bitcoin/bip353'
 
   require_relative 'bitcoin/constants'
   require_relative 'bitcoin/ext/ecdsa'