bitcoinrb 1.11.0 → 1.12.1

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

data/lib/bitcoin/script/script_error.rb

@@ -1,5 +1,8 @@
 module Bitcoin
 
+  class ScriptNumError < StandardError
+  end
+
   # bitcoin script error
   class ScriptError < Exception
 
@@ -122,6 +125,8 @@ module Bitcoin
         'Signature is found in scriptCode'
       when SCRIPT_ERR_UNKNOWN_ERROR, SCRIPT_ERR_ERROR_COUNT
         'unknown error'
+      when SCRIPT_ERR_SCRIPTNUM
+        'Script number overflowed or is non-minimally encoded'
       else
         extra_msg ? extra_msg : 'unknown error'
       end

data/lib/bitcoin/script/script_interpreter.rb

@@ -258,7 +258,7 @@ module Bitcoin
                 when OP_IF, OP_NOTIF
                   result = false
                   if need_exec
-                    return set_error(SCRIPT_ERR_UNBALANCED_CONDITIONAL) if stack.size < 1
+                    return set_error(SCRIPT_ERR_INVALID_STACK_OPERATION) if stack.size < 1
                     value = pop_string.htb
                     if sig_version == :witness_v0 && flag?(SCRIPT_VERIFY_MINIMALIF) || sig_version == :tapscript
                       # Under witness v0 rules it is only a policy rule, enabled through SCRIPT_VERIFY_MINIMALIF.
@@ -566,6 +566,8 @@ module Bitcoin
           # max stack size check
           return set_error(SCRIPT_ERR_STACK_SIZE) if stack.size + alt_stack.size > MAX_STACK_SIZE
         end
+      rescue ScriptNumError => e
+        return set_error(SCRIPT_ERR_SCRIPTNUM, e.message)
       rescue Exception => e
         return set_error(SCRIPT_ERR_UNKNOWN_ERROR, e.message)
       end
@@ -591,10 +593,10 @@ module Bitcoin
     # cast item to int value.
     def cast_to_int(s, max_num_size = DEFAULT_MAX_NUM_SIZE)
       data = s.htb
-      raise '"script number overflow"' if data.bytesize > max_num_size
+      raise ScriptNumError, '"script number overflow"' if data.bytesize > max_num_size
       if require_minimal && data.bytesize > 0
         if data.bytes[-1] & 0x7f == 0 && (data.bytesize <= 1 || data.bytes[data.bytesize - 2] & 0x80 == 0)
-          raise 'non-minimally encoded script number'
+          raise ScriptNumError, 'non-minimally encoded script number'
         end
       end
       Script.decode_number(s)

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/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)
@@ -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.11.0"
+  VERSION = "1.12.1"
 end

data/lib/bitcoin.rb

@@ -2,13 +2,11 @@
 # https://github.com/lian/bitcoin-ruby/blob/master/COPYING
 
 require 'bitcoin/version'
-require 'eventmachine'
 require 'schnorr'
 require 'securerandom'
 require 'json'
 require 'bech32'
 require 'base64'
-require 'observer'
 require 'tmpdir'
 require 'merkle'
 
@@ -36,13 +34,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 +59,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'