block_io 3.0.5 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb185ac520ba882b4acc7a0b9456c9005724279c3b48870ebd2c14ae0f4327e9
-  data.tar.gz: fa7327a6ed20968ed94395dde29a4c693bdcbf0cd800df7a038b98236aca53c9
+  metadata.gz: 890b54dc8511344d1a39cf22e4379dfadc78d60395464a5bd3b5566fe19e775a
+  data.tar.gz: 0c286e1f3ac4d617034b18d621401eb06d243a18a9cef1a4fe19e39b388c72b9
 SHA512:
-  metadata.gz: 943a8bd870a90b3e317a10880d5798cd586c9dbed7d9fdf83f2833a64bf134acf44d3a80be71b6c695de92f50a02584923792efe57f8a2fea76169eb6d638d72
-  data.tar.gz: 6f4e19484ab274871068321022d3d4ea56e8be476930b4efd37761c575f9e7c377ffe36e071a294f061cbdb95e1f14f7d31ae4c8e9986ed92d02ce68bc40940c
+  metadata.gz: 358f8605db3bd1c6a1931384848d6533a3ecdc0dc41dce7a1b4e9799f6ae67d0819bb34a1d0bbbf8a83cc0d655bd8e5bb8bd573666480dbddf38540d7ba1e14a
+  data.tar.gz: 164c8c5e6689657b7535e689a83395edcd917eeade0aa03dbc3dffd03f2a0e732d0d00498a00d3fa879bc058c50ec4345007abe6c2eebe65eefce431f9c3bc61

data/README.md

@@ -6,7 +6,7 @@ This Ruby Gem is the official reference client for the Block.io's infrastructure
 
 Add this line to your application's Gemfile:
 
-    gem 'block_io'
+    gem "block_io"
 
 And then execute:
 
@@ -17,6 +17,7 @@ Or install it yourself as:
     $ gem install block_io
 
 ## Changelog
+*10/28/22*: Version 3.1.0 uses Typhoeus instead of httprb. If using proxy, :url must be provided instead of previous :hostname and :port.  
 *05/30/22*: Version 3.0.5 fixes Litecoin P2SH address version (properly now).  
 *12/26/21*: Version 3.0.4 drops support for EOL Ruby 2.4, 2.5. Supports Ruby 3.1.  
 *09/28/21*: Version 3.0.3 supports witness_v1 outputs (Bech32m).  

data/block_io.gemspec

@@ -18,12 +18,11 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.6.0'
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", ">= 1.16", "< 3.0"
-  spec.add_development_dependency "rake", "~> 13.0", ">= 13.0"
-  spec.add_development_dependency "rspec", "~> 3.6", ">= 3.6"
-  spec.add_development_dependency "webmock", "~> 3.12", "< 4.0"
-  spec.add_runtime_dependency "bitcoinrb", "~> 1.0", "< 1.2.0"
-  spec.add_runtime_dependency "http", ">= 4.4.1", "< 6.0"
-  spec.add_runtime_dependency "oj", "~> 3.0", "< 4.0"
-  spec.add_runtime_dependency "connection_pool", ">= 2.2", "< 3.0"
+  spec.add_development_dependency "bundler", ">= 1.16", "< 3"
+  spec.add_development_dependency "rake", "~> 13.0", "< 14"
+  spec.add_development_dependency "rspec", "~> 3.0", "< 4"
+  spec.add_development_dependency "webmock", "~> 3.0", "< 4"
+  spec.add_runtime_dependency "bitcoinrb", ">= 1.2.1", "< 2"
+  spec.add_runtime_dependency "typhoeus", "~> 1.0", "< 2"
+  spec.add_runtime_dependency "oj", "~> 3.0", "< 4"
 end

data/lib/block_io/client.rb

@@ -2,8 +2,14 @@ module BlockIo
 
   class Client
 
-    attr_reader :api_key, :version, :network
+    attr_reader :api_key, :version, :network, :api_request_headers
 
+    USER_AGENT = 'gem:block_io:' << VERSION.to_s
+    CONTENT_TYPE = 'application/json; charset=UTF-8'
+    ACCEPT_TYPE = 'application/json'
+    KEEP_ALIVE = 'Keep-Alive'
+    TIMEOUT = 60
+    
     def initialize(args = {})
       # api_key
       # pin
@@ -13,21 +19,25 @@ module BlockIo
       # pool_size
       # keys
       
-      raise "Must provide an API Key." unless args.key?(:api_key) and args[:api_key].to_s.size > 0
+      raise 'Must provide an API Key.' unless args.key?(:api_key) and args[:api_key].to_s.size > 0
       
       @api_key = args[:api_key]
       @pin = args[:pin]
       @version = args[:version] || 2
-      @hostname = args[:hostname] || "block.io"
-      @proxy = args[:proxy] || {}
+      @hostname = args[:hostname] || 'block.io'
       @keys = {}
 
-      raise Exception.new("Must specify hostname, port, username, password if using a proxy.") if @proxy.keys.size > 0 and [:hostname, :port, :username, :password].any?{|x| !@proxy.key?(x)}
+      # prepare proxy settings if provided
+      proxy = args[:proxy] || {}
+
+      if proxy.keys.size > 0 then
+        raise Exception.new('Must specify hostname, port, username, password if using a proxy.') if [:url, :username, :password].any?{|x| !proxy.key?(x)}
+        @proxy = {:proxy => proxy[:url], :proxyuserpwd => "#{proxy[:username]}:#{proxy[:password]}"}.freeze
+      else
+        @proxy = {}
+      end
 
-      @conn = ConnectionPool.new(:size => args[:pool_size] || 5) { http = HTTP.headers(:accept => "application/json", :user_agent => "gem:block_io:#{VERSION}");
-        http = http.via(args.dig(:proxy, :hostname), args.dig(:proxy, :port), args.dig(:proxy, :username), args.dig(:proxy, :password)) if @proxy.key?(:hostname);
-        http = http.persistent("https://#{@hostname}");
-        http }
+      @api_request_headers = {'User-Agent' => USER_AGENT, 'Content-Type' => CONTENT_TYPE, 'Accept' => ACCEPT_TYPE, 'Expect' => '', 'Connection' => KEEP_ALIVE, 'Host' => @hostname}.freeze
       
       # this will get populated after a successful API call
       @network = nil
@@ -38,12 +48,12 @@ module BlockIo
       
       method_name = m.to_s
 
-      raise Exception.new("Must provide arguments as a Hash.") unless args.size <= 1 and args.all?{|x| x.is_a?(Hash)}
-      raise Exception.new("Parameter keys must be symbols. For instance: :label => 'default' instead of 'label' => 'default'") unless args[0].nil? or args[0].keys.all?{|x| x.is_a?(Symbol)}
-      raise Exception.new("Cannot pass PINs to any calls. PINs can only be set when initiating this library.") if !args[0].nil? and args[0].key?(:pin)
-      raise Exception.new("Do not specify API Keys here. Initiate a new BlockIo object instead if you need to use another API Key.") if !args[0].nil? and args[0].key?(:api_key)
+      raise Exception.new('Must provide arguments as a Hash.') unless args.size <= 1 and args.all?{|x| x.is_a?(Hash)}
+      raise Exception.new('Parameter keys must be symbols. For instance: :label => "default" instead of "label" => "default"') unless args[0].nil? or args[0].keys.all?{|x| x.is_a?(Symbol)}
+      raise Exception.new('Cannot pass PINs to any calls. PINs can only be set when initiating this library.') if !args[0].nil? and args[0].key?(:pin)
+      raise Exception.new('Do not specify API Keys here. Initiate a new BlockIo object instead if you need to use another API Key.') if !args[0].nil? and args[0].key?(:api_key)
 
-      if method_name.eql?("prepare_sweep_transaction") then
+      if method_name.eql?('prepare_sweep_transaction') then
         # we need to ensure @network is set before we allow this
         # we need to send only the public key, not the given private key
         # we're sweeping from an address
@@ -54,6 +64,13 @@ module BlockIo
       
     end
 
+    def padded_f(d)
+      # returns a padded decimal to 8 decimal places
+      b = BigDecimal(d).to_s('F')
+      b << '0' * (8 - (b.size - b.index('.') - 1))
+      b
+    end
+    
     def summarize_prepared_transaction(data)
       # takes the response from prepare_transaction/prepare_dtrust_transaction/prepare_sweep_transaction
       # returns the network fee being paid, the blockio fee being paid, amounts being sent
@@ -64,10 +81,15 @@ module BlockIo
       blockio_fees = [BigDecimal(0)]
       change_amounts = [BigDecimal(0)]
 
-      data['data']['outputs'].each do |output|
-        if output['output_category'] == 'blockio-fee' then
+      i = 0
+      loop do
+        output = data['data']['outputs'][i]
+        break if output.nil?
+        i += 1
+
+        if output['output_category'].eql?('blockio-fee') then
           blockio_fees << BigDecimal(output['output_value'])
-        elsif output['output_category'] == 'change' then
+        elsif output['output_category'].eql?('change') then
           change_amounts << BigDecimal(output['output_value'])
         else
           # user-specified
@@ -83,9 +105,9 @@ module BlockIo
 
       {
         'network' => data['data']['network'],
-        'network_fee' => '%0.8f' % network_fee,
-        "blockio_fee" => '%0.8f' % blockio_fee,
-        "total_amount_to_send" => '%0.8f' % output_sum
+        'network_fee' => padded_f(network_fee),
+        'blockio_fee' => padded_f(blockio_fee),
+        'total_amount_to_send' => padded_f(output_sum)
       }
       
     end
@@ -97,33 +119,32 @@ module BlockIo
       
       set_network(data['data']['network']) if data['data'].key?('network')
 
-      raise "Data must be contain one or more inputs" unless data['data']['inputs'].size > 0
-      raise "Data must contain one or more outputs" unless data['data']['outputs'].size > 0
-      raise "Data must contain information about addresses" unless data['data']['input_address_data'].size > 0 # TODO make stricter
+      raise 'Data must be contain one or more inputs' unless data['data']['inputs'].size > 0
+      raise 'Data must contain one or more outputs' unless data['data']['outputs'].size > 0
+      raise 'Data must contain information about addresses' unless data['data']['input_address_data'].size > 0 # TODO make stricter
 
       private_keys = keys.map{|x| Key.from_private_key_hex(x)}
 
-      # TODO debug all of this
-      
       inputs = data['data']['inputs']
       outputs = data['data']['outputs']
 
       tx = Bitcoin::Tx.new
 
       # populate the inputs
-      inputs.each do |input|
-        tx.in << Bitcoin::TxIn.new(:out_point => Bitcoin::OutPoint.from_txid(input['previous_txid'], input['previous_output_index']))
+      tx.in << inputs.map do |input|
+        Bitcoin::TxIn.new(:out_point => Bitcoin::OutPoint.from_txid(input['previous_txid'], input['previous_output_index']))
       end
-
+      tx.in.flatten!
+      
       # populate the outputs
-      outputs.each do |output|
-        tx.out << Bitcoin::TxOut.new(:value => (BigDecimal(output['output_value']) * BigDecimal(100000000)).to_i, :script_pubkey => Bitcoin::Script.parse_from_addr(output['receiving_address']))
+      tx.out << outputs.map do |output|
+        Bitcoin::TxOut.new(:value => (BigDecimal(output['output_value']) * BigDecimal(100000000)).to_i, :script_pubkey => Bitcoin::Script.parse_from_addr(output['receiving_address']))
       end
-
-
+      tx.out.flatten!
+      
       # some protection against misbehaving machines and/or code
-      raise Exception.new("Expected unsigned transaction ID mismatch. Please report this error to support@block.io.") unless (data['data']['expected_unsigned_txid'].nil? or
-                                                                                                                        data['data']['expected_unsigned_txid'] == tx.txid)
+      raise Exception.new('Expected unsigned transaction ID mismatch. Please report this error to support@block.io.') unless (data['data']['expected_unsigned_txid'].nil? or
+                                                                                                                              data['data']['expected_unsigned_txid'].eql?(tx.txid))
 
       # extract key
       encrypted_key = data['data']['user_key']
@@ -131,11 +152,11 @@ module BlockIo
       if !encrypted_key.nil? and !@keys.key?(encrypted_key['public_key']) then
         # decrypt the key with PIN
 
-        raise Exception.new("PIN not set and no keys provided. Cannot sign transaction.") unless !@pin.nil? or @keys.size > 0
+        raise Exception.new('PIN not set and no keys provided. Cannot sign transaction.') unless !@pin.nil? or @keys.size > 0
 
         key = Helper.dynamicExtractKey(encrypted_key, @pin)
 
-        raise Exception.new("Public key mismatch for requested signer and ourselves. Invalid Secret PIN detected.") unless key.public_key_hex.eql?(encrypted_key["public_key"])
+        raise Exception.new('Public key mismatch for requested signer and ourselves. Invalid Secret PIN detected.') unless key.public_key_hex.eql?(encrypted_key['public_key'])
 
         # store this key for later use
         @keys[key.public_key_hex] = key
@@ -143,7 +164,7 @@ module BlockIo
       end
 
       # store the provided keys, if any, for later use
-      private_keys.each{|key| @keys[key.public_key_hex] = key}
+      @keys.merge!(private_keys.map{|key| [key.public_key_hex, key]}.to_h)
       
       signatures = []
       
@@ -152,20 +173,22 @@ module BlockIo
         # Block.io will check to see if all signatures are present, or return an error otherwise saying insufficient signatures provided
 
         i = 0
-        while i < inputs.size do
+        loop do
           input = inputs[i]
+          break if input.nil?
 
-          input_address_data = data['data']['input_address_data'].detect{|d| d['address'] == input['spending_address']}
+          input_address_data = data['data']['input_address_data'].detect{|d| d['address'].eql?(input['spending_address'])}
           sighash_for_input = Helper.getSigHashForInput(tx, i, input, input_address_data) # in bytes
 
-          input_address_data['public_keys'].each do |signer_public_key|
+          signatures << input_address_data['public_keys'].map do |signer_public_key|
             # sign what we can and append signatures to the signatures object
-            
             next unless @keys.key?(signer_public_key)
             
-            signature = @keys[signer_public_key].sign(sighash_for_input).unpack("H*")[0] # in hex
-            signatures << {"input_index" => i, "public_key" => signer_public_key, "signature" => signature}
-            
+            {
+              'input_index' => i,
+              'public_key' => signer_public_key,
+              'signature' => @keys[signer_public_key].sign(sighash_for_input).unpack1('H*') # in hex
+            }
           end
 
           i += 1 # go to next input
@@ -173,6 +196,9 @@ module BlockIo
         
       end
 
+      signatures.flatten!
+      signatures.compact!
+      
       # if we have everything we need for this transaction, just finalize the transaction
       if Helper.allSignaturesPresent?(tx, inputs, signatures, data['data']['input_address_data']) then
         Helper.finalizeTransaction(tx, inputs, signatures, data['data']['input_address_data'])
@@ -183,18 +209,18 @@ module BlockIo
       @keys = {}
       
       # the response for submitting the transaction
-      {"tx_type" => data['data']['tx_type'], "tx_hex" => tx.to_hex, "signatures" => (signatures.size == 0 ? nil : signatures)}
+      {'tx_type' => data['data']['tx_type'], 'tx_hex' => tx.to_hex, 'signatures' => (signatures.size.eql?(0) ? nil : signatures)}
       
     end
 
     private
 
-    def internal_prepare_sweep_transaction(args = {}, method_name = "prepare_sweep_transaction")
+    def internal_prepare_sweep_transaction(args = {}, method_name = 'prepare_sweep_transaction')
 
       # set the network first if not already known
-      api_call({:method_name => "get_balance", :params => {}}) if @network.nil?
+      api_call({:method_name => 'get_balance', :params => {}}) if @network.nil?
 
-      raise Exception.new("No private_key provided.") unless args.key?(:private_key) and (args[:private_key] || "").size > 0
+      raise Exception.new('No private_key provided.') unless args.key?(:private_key) and (args[:private_key] || '').size > 0
 
       # ensure the private key never goes to Block.io
       key = Key.from_wif(args[:private_key])
@@ -215,26 +241,36 @@ module BlockIo
     
     def api_call(args)
 
-      raise Exception.new("No connections left to perform API call. Please re-initialize BlockIo::Client with :pool_size greater than #{@conn.size}.") unless @conn.available > 0
-      
-      response = @conn.with {|http| http.post("/api/v#{@version}/#{args[:method_name]}", :json => args[:params].merge({:api_key => @api_key}))}
+      response = Typhoeus.post("https://#{@hostname}/api/v#{@version}/#{args[:method_name]}",
+                               :body => Oj.dump(args[:params].merge({:api_key => @api_key}), :mode => :compat),
+                               :headers => @api_request_headers,
+                               :timeout => TIMEOUT,
+                               **@proxy)
 
-      begin
-        body = Oj.safe_load(response.to_s)
-      rescue
-        body = {"status" => "fail", "data" => {"error_message" => "Unknown error occurred. Please report this to support@block.io. Status #{response.code}."}}
+      body = nil
+      
+      if response.timed_out? then
+        body = {'status' => 'fail', 'data' => {'error_message' => 'Request timed out.'}}
+      elsif response.code.eql?(0) then
+        body = {'status' => 'fail', 'data' => {'error_message' => 'No response received.'}}
+      else
+        begin
+          body = Oj.safe_load(response.body.to_s)
+        rescue Exception => e
+          body = {'status' => 'fail', 'data' => {'error_message' => "Unknown error occurred. Please report this to support@block.io. Status #{response.code}."}}
+        end
       end
-
-      if !body["status"].eql?("success") then
+      
+      if !body['status'].eql?('success') then
         # raise an exception on error for easy handling
         # user can extract raw response using e.raw_data
-        e = APIException.new("#{body["data"]["error_message"]}")
+        e = APIException.new(body['data']['error_message'].to_s)
         e.set_raw_data(body)
         raise e
       end
 
+      # success
       set_network(body['data']['network']) if body['data'].key?('network')
-      
       body
       
     end

data/lib/block_io/extended_bitcoinrb.rb

@@ -61,7 +61,7 @@ module Bitcoin
 
         signature = ECDSA::Signature.new(r, s).to_der
 
-        # comment lines below lead to performance issues
+        # these lines lead to performance issues
         #        public_key = Bitcoin::Key.new(priv_key: privkey.bth, :key_type => Bitcoin::Key::TYPES[:compressed]).pubkey # get rid of the key_type warning
         #        raise 'Creation of signature failed.' unless Bitcoin::Secp256k1::Ruby.verify_sig(data, signature, public_key)
         
@@ -77,7 +77,7 @@ module Bitcoin
       # override so enforce compressed keys
       
       raise "key_type must always be Bitcoin::KEY::TYPES[:compressed]" unless key_type == TYPES[:compressed]
-      puts "[Warning] Use key_type parameter instead of compressed. compressed parameter removed in the future." if key_type.nil? && !compressed.nil? && pubkey.nil?
+      puts '[Warning] Use key_type parameter instead of compressed. compressed parameter removed in the future.' if key_type.nil? && !compressed.nil? && pubkey.nil?
       if key_type
         @key_type = key_type
         compressed = @key_type != TYPES[:uncompressed]
@@ -113,14 +113,16 @@ module Bech32
   # override so we can parse non-Bitcoin Bech32 addresses
   
   class SegwitAddr
+
+    VALID_HRPS = ['bc', 'ltc', 'tb', 'tltc', 'doge', 'tdge'].inject({}){|h,v| h[v] = true; h}
     
     private
     def parse_addr(addr)
       @hrp, data, spec = Bech32.decode(addr)
-      raise 'Invalid address.' if hrp.nil? || data[0].nil? || !['bc', 'ltc', 'tb', 'tltc', 'doge', 'tdge'].include?(hrp) # HRP_MAINNET, HRP_TESTNET, HRP_REGTEST].include?(hrp)
+      raise 'Invalid address.' if hrp.nil? || data[0].nil? || !VALID_HRPS.key?(hrp) # HRP_MAINNET, HRP_TESTNET, HRP_REGTEST].include?(hrp)
       @ver = data[0]
       raise 'Invalid witness version' if @ver > 16
-      @prog = convert_bits(data[1..-1], 5, 8, false)
+      @prog = Bech32.convert_bits(data[1..-1], 5, 8, false)
       raise 'Invalid witness program' if @prog.nil? || @prog.length < 2 || @prog.length > 40
       raise 'Invalid witness program with version 0' if @ver == 0 && (@prog.length != 20 && @prog.length != 32)
       raise 'Witness version and encoding spec do not match' if (@ver == 0 && spec != Bech32::Encoding::BECH32) || (@ver != 0 && spec != Bech32::Encoding::BECH32M)

data/lib/block_io/helper.rb

@@ -3,13 +3,13 @@ module BlockIo
   class Helper
 
     LEGACY_DECRYPTION_ALGORITHM = {
-      :pbkdf2_salt => "",
+      :pbkdf2_salt => '',
       :pbkdf2_iterations => 2048,
-      :pbkdf2_hash_function => "SHA256",
+      :pbkdf2_hash_function => 'SHA256',
       :pbkdf2_phase1_key_length => 16,
       :pbkdf2_phase2_key_length => 32,
       :aes_iv => nil,
-      :aes_cipher => "AES-256-ECB",
+      :aes_cipher => 'AES-256-ECB',
       :aes_auth_tag => nil,
       :aes_auth_data => nil
     }
@@ -19,20 +19,23 @@ module BlockIo
       
       all_signatures_present = false
 
-      inputs.each do |input|
+      i = 0
+      loop do
         # check if each input has its required signatures
+        input = inputs[i]
+        break if input.nil?
+        i += 1
         
         spending_address = input['spending_address']
-        current_input_address_data = input_address_data.detect{|x| x['address'] == spending_address}
+        current_input_address_data = input_address_data.detect{|x| x['address'].eql?(spending_address)}
         required_signatures = current_input_address_data['required_signatures']
         public_keys = current_input_address_data['public_keys']
 
-        signatures_present = signatures.map{|x| x if x['input_index'] == input['input_index']}.compact.inject({}){|h,v| h[v['public_key']] = v['signature']; h}
+        signatures_present = signatures.map{|x| x if x['input_index'].eql?(input['input_index'])}.compact.inject({}){|h,v| h[v['public_key']] = v['signature']; h}
 
         # break the loop if all signatures are not present for this input
-        all_signatures_present = (signatures_present.keys.size >= required_signatures)
-        break unless all_signatures_present
-        
+        all_signatures_present = (signatures_present.size >= required_signatures)
+        break unless all_signatures_present        
       end
 
       all_signatures_present
@@ -56,12 +59,16 @@ module BlockIo
     
     def self.finalizeTransaction(tx, inputs, signatures, input_address_data)
       # append signatures to the transaction and return its hexadecimal representation
-      
-      inputs.each do |input|
+
+      i = 0
+      loop do
         # for each input
+        input = inputs[i]
+        break if input.nil?
+        i += 1
 
-        signatures_present = signatures.map{|x| x if x['input_index'] == input['input_index']}.compact.inject({}){|h,v| h[v['public_key']] = v['signature']; h}
-        address_data = input_address_data.detect{|x| x['address'] == input['spending_address']} # contains public keys (ordered) and the address type
+        signatures_present = signatures.map{|x| x if x['input_index'].eql?(input['input_index'])}.compact.inject({}){|h,v| h[v['public_key']] = v['signature']; h}
+        address_data = input_address_data.detect{|x| x['address'].eql?(input['spending_address'])} # contains public keys (ordered) and the address type
         input_index = input['input_index']
         is_segwit = isSegwitAddressType?(address_data['address_type'])
         script_stack = (is_segwit ? tx.in[input_index].script_witness.stack : tx.in[input_index].script_sig)
@@ -74,16 +81,16 @@ module BlockIo
           current_signature = signatures_present[current_public_key]
 
           # no blank push necessary for P2PKH, P2WPKH, P2WPKH-over-P2SH
-          script_stack << ([current_signature].pack("H*") + [Bitcoin::SIGHASH_TYPE[:all]].pack('C'))
-          script_stack << [current_public_key].pack("H*")
+          script_stack << ([current_signature].pack('H*') + [Bitcoin::SIGHASH_TYPE[:all]].pack('C'))
+          script_stack << [current_public_key].pack('H*')
 
           # P2WPKH-over-P2SH required script_sig still
           tx.in[input_index].script_sig << (
             Bitcoin::Script.to_p2wpkh(
               Bitcoin::Key.new(:pubkey => current_public_key, :key_type => Bitcoin::Key::TYPES[:compressed]).hash160 # hash160 of the compressed pubkey
             ).to_payload
-          ) if address_data['address_type'] == "P2WPKH-over-P2SH"
-                    
+          ) if address_data['address_type'].eql?('P2WPKH-over-P2SH')
+          
         elsif ['P2SH', 'WITNESS_V0', 'P2WSH-over-P2SH'].include?(address_data['address_type']) then
           # P2SH will use script_sig as script_stack
           # P2WSH or P2WSH-over-P2SH input will use script_witness.stack as script_stack
@@ -94,23 +101,27 @@ module BlockIo
 
           signatures_added = 0
 
-          address_data['public_keys'].each do |public_key|
+          j = 0
+          loop do
+            public_key = address_data['public_keys'][j]
+            break if public_key.nil?
+            j += 1
             next unless signatures_present.key?(public_key)
 
             # append signatures, no sighash needed, in correct order of public keys
             current_signature = signatures_present[public_key]
-            script_stack << ([current_signature].pack("H*") + [Bitcoin::SIGHASH_TYPE[:all]].pack('C'))
+            script_stack << ([current_signature].pack('H*') + [Bitcoin::SIGHASH_TYPE[:all]].pack('C'))
 
             signatures_added += 1
 
             # required signatures added? break loop and move on
-            break if signatures_added == address_data['required_signatures']
+            break if signatures_added.eql?(address_data['required_signatures'])
           end
 
           script_stack << script.last.to_payload
 
           # P2WSH-over-P2SH needs script_sig populated still
-          tx.in[input_index].script_sig << Bitcoin::Script.to_p2wsh(script.last).to_payload if address_data['address_type'] == "P2WSH-over-P2SH"
+          tx.in[input_index].script_sig << Bitcoin::Script.to_p2wsh(script.last).to_payload if address_data['address_type'].eql?('P2WSH-over-P2SH')
           
         else
           raise "Unrecognized input address: #{address_data['address_type']}"
@@ -125,35 +136,35 @@ module BlockIo
     def self.getSigHashForInput(tx, input_index, input_data, input_address_data)
       # returns the sighash for the given input in bytes
       
-      address_type = input_address_data["address_type"]
-      input_value = (BigDecimal(input_data['input_value']) * BigDecimal(100000000)).to_i # in sats
+      address_type = input_address_data['address_type']
+      input_value = (BigDecimal(input_data['input_value']) * 100_000_000).to_i # in sats
       sighash = nil
       
-      if address_type == "P2SH" then
+      if address_type.eql?('P2SH') then
         # P2SH addresses
         
-        script = Bitcoin::Script.to_p2sh_multisig_script(input_address_data["required_signatures"], input_address_data["public_keys"])
+        script = Bitcoin::Script.to_p2sh_multisig_script(input_address_data['required_signatures'], input_address_data['public_keys'])
         sighash = tx.sighash_for_input(input_index, script.last)
         
-      elsif address_type == "P2WSH-over-P2SH" or address_type == "WITNESS_V0" then
+      elsif address_type.eql?('P2WSH-over-P2SH') or address_type.eql?('WITNESS_V0') then
         # P2WSH-over-P2SH addresses
         # WITNESS_V0 addresses
 
-        script = Bitcoin::Script.to_p2sh_multisig_script(input_address_data["required_signatures"], input_address_data["public_keys"])
+        script = Bitcoin::Script.to_p2sh_multisig_script(input_address_data['required_signatures'], input_address_data['public_keys'])
         sighash = tx.sighash_for_input(input_index, script.last, amount: input_value, sig_version: :witness_v0)
         
-      elsif address_type == "P2WPKH-over-P2SH" or address_type == "P2WPKH" then
+      elsif address_type.eql?('P2WPKH-over-P2SH') or address_type.eql?('P2WPKH') then
         # P2WPKH-over-P2SH addresses
         # P2WPKH addresses
         
-        pub_key = Bitcoin::Key.new(:pubkey => input_address_data['public_keys'].first, :key_type => Bitcoin::Key::TYPES[:compressed]) # compressed
+        pub_key = Bitcoin::Key.new(:pubkey => input_address_data['public_keys'][0], :key_type => Bitcoin::Key::TYPES[:compressed]) # compressed
         script = Bitcoin::Script.to_p2wpkh(pub_key.hash160)
         sighash = tx.sighash_for_input(input_index, script, amount: input_value, sig_version: :witness_v0)
         
-      elsif address_type == "P2PKH" then
+      elsif address_type.eql?('P2PKH') then
         # P2PKH addresses
 
-        pub_key = Bitcoin::Key.new(:pubkey => input_address_data['public_keys'].first, :key_type => Bitcoin::Key::TYPES[:compressed]) # compressed
+        pub_key = Bitcoin::Key.new(:pubkey => input_address_data['public_keys'][0], :key_type => Bitcoin::Key::TYPES[:compressed]) # compressed
         script = Bitcoin::Script.to_p2pkh(pub_key.hash160)
         sighash = tx.sighash_for_input(input_index, script)
 
@@ -168,7 +179,7 @@ module BlockIo
     def self.getDecryptionAlgorithm(user_key_algorithm = nil)
       # mainly used so existing unit tests do not break
       
-      algorithm = ({}).merge(LEGACY_DECRYPTION_ALGORITHM)
+      algorithm = ({}).merge!(LEGACY_DECRYPTION_ALGORITHM)
 
       if !user_key_algorithm.nil? then
         algorithm[:pbkdf2_salt] = user_key_algorithm['pbkdf2_salt']
@@ -216,14 +227,14 @@ module BlockIo
     
     def self.sha256(value)
       # returns the hex of the hash of the given value
-      OpenSSL::Digest::SHA256.digest(value).unpack("H*")[0]
+      OpenSSL::Digest::SHA256.digest(value).unpack1('H*')
     end
     
-    def self.pinToAesKey(secret_pin, iterations = 2048, salt = "", hash_function = "SHA256", pbkdf2_phase1_key_length = 16, pbkdf2_phase2_key_length = 32)
+    def self.pinToAesKey(secret_pin, iterations = 2048, salt = '', hash_function = 'SHA256', pbkdf2_phase1_key_length = 16, pbkdf2_phase2_key_length = 32)
       # converts the pincode string to PBKDF2
       # returns a base64 version of PBKDF2 pincode
 
-      raise Exception.new("Unknown hash function specified. Are you using current version of this library?") unless hash_function == "SHA256"
+      raise Exception.new('Unknown hash function specified. Are you using current version of this library?') unless hash_function.eql?('SHA256')
       
       part1 = OpenSSL::PKCS5.pbkdf2_hmac(
         secret_pin,
@@ -231,7 +242,7 @@ module BlockIo
         iterations/2,
         pbkdf2_phase1_key_length,
         OpenSSL::Digest::SHA256.new
-      ).unpack("H*")[0]
+      ).unpack1('H*')
       
       part2 = OpenSSL::PKCS5.pbkdf2_hmac(
         part1,
@@ -241,80 +252,78 @@ module BlockIo
         OpenSSL::Digest::SHA256.new
       ) # binary
 
-      [part2].pack("m0") # the base64 encryption key
+      [part2].pack('m0') # the base64 encryption key
 
     end
 
     # Decrypts a block of data (encrypted_data) given an encryption key
-    def self.decrypt(encrypted_data, b64_enc_key, iv = nil, cipher_type = "AES-256-ECB", auth_tag = nil, auth_data = nil)
+    def self.decrypt(encrypted_data, b64_enc_key, iv = nil, cipher_type = 'AES-256-ECB', auth_tag = nil, auth_data = nil)
 
-      raise Exception.new("Auth tag must be 16 bytes exactly.") unless auth_tag.nil? or auth_tag.size == 32
+      raise Exception.new('Auth tag must be 16 bytes exactly.') unless auth_tag.nil? or auth_tag.size.eql?(32)
       
       response = nil
 
       begin
         aes = OpenSSL::Cipher.new(cipher_type.downcase)
         aes.decrypt
-        aes.key = b64_enc_key.unpack("m0")[0]
-        aes.iv = [iv].pack("H*") unless iv.nil?
-        aes.auth_tag = [auth_tag].pack("H*") unless auth_tag.nil?
-        aes.auth_data = [auth_data].pack("H*") unless auth_data.nil?
-        response = aes.update(encrypted_data.unpack("m0")[0]) << aes.final
+        aes.key = b64_enc_key.unpack1('m0')
+        aes.iv = [iv].pack('H*') unless iv.nil?
+        aes.auth_tag = [auth_tag].pack('H*') unless auth_tag.nil?
+        aes.auth_data = [auth_data].pack('H*') unless auth_data.nil?
+        response = aes.update(encrypted_data.unpack1('m0')) << aes.final
       rescue Exception => e
         # decryption failed, must be an invalid Secret PIN
-        raise Exception.new("Invalid Secret PIN provided.")
+        raise Exception.new('Invalid Secret PIN provided.')
       end
 
       response
     end
     
     # Encrypts a block of data given an encryption key
-    def self.encrypt(data, b64_enc_key, iv = nil, cipher_type = "AES-256-ECB", auth_data = nil)
+    def self.encrypt(data, b64_enc_key, iv = nil, cipher_type = 'AES-256-ECB', auth_data = nil)
       aes = OpenSSL::Cipher.new(cipher_type.downcase)
       aes.encrypt
-      aes.key = b64_enc_key.unpack("m0")[0]
-      aes.iv = [iv].pack("H*") unless iv.nil?
-      aes.auth_data = [auth_data].pack("H*") unless auth_data.nil?
-      result = [aes.update(data) << aes.final].pack("m0")
-      auth_tag = (cipher_type.end_with?("-GCM") ? aes.auth_tag.unpack("H*")[0] : nil)
+      aes.key = b64_enc_key.unpack1('m0')
+      aes.iv = [iv].pack('H*') unless iv.nil?
+      aes.auth_data = [auth_data].pack('H*') unless auth_data.nil?
+      result = [aes.update(data) << aes.final].pack('m0')
+      auth_tag = (cipher_type.end_with?('-GCM') ? aes.auth_tag.unpack1('H*') : nil)
 
       {:aes_auth_tag => auth_tag, :aes_cipher_text => result, :aes_iv => iv, :aes_cipher => cipher_type, :aes_auth_data => auth_data}
       
     end
 
     # courtesy bitcoin-ruby
-    
+    BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
     def self.int_to_base58(int_val, leading_zero_bytes=0)
-      alpha = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-      base58_val, base = "", alpha.size
+      base58_val, base = '', BASE58_ALPHABET.size
       while int_val > 0
         int_val, remainder = int_val.divmod(base)
-        base58_val = alpha[remainder] << base58_val
+        base58_val = '' << BASE58_ALPHABET[remainder] << base58_val
       end
       base58_val
     end
     
     def self.base58_to_int(base58_val)
-      alpha = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-      int_val, base = 0, alpha.size
+      int_val, base = 0, BASE58_ALPHABET.size
       base58_val.reverse.each_char.with_index do |char,index|
-        raise ArgumentError, "Value not a valid Base58 String." unless char_index = alpha.index(char)
+        raise ArgumentError, 'Value not a valid Base58 String.' unless char_index = BASE58_ALPHABET.index(char)
         int_val += char_index*(base**index)
       end
       int_val
     end
     
     def self.encode_base58(hex)
-      leading_zero_bytes  = (hex.match(/^([0]+)/) ? $1 : "").size / 2
-      ("1"*leading_zero_bytes) << Helper.int_to_base58( hex.to_i(16) )
+      leading_zero_bytes  = (hex.match(/^([0]+)/) ? $1 : '').size / 2
+      ('1'*leading_zero_bytes) << Helper.int_to_base58(hex.to_i(16))
     end
     
     def self.decode_base58(base58_val)
       s = Helper.base58_to_int(base58_val).to_s(16)
-      s = (s.bytesize.odd? ? ("0" << s) : s)
-      s = "" if s == "00"
-      leading_zero_bytes = (base58_val.match(/^([1]+)/) ? $1 : "").size
-      s = ("00"*leading_zero_bytes) << s  if leading_zero_bytes > 0
+      s = (s.bytesize.odd? ? ('0' << s) : s)
+      s = '' if s.eql?('00')
+      leading_zero_bytes = (base58_val.match(/^([1]+)/) ? $1 : '').size
+      s = ('00'*leading_zero_bytes) << s if leading_zero_bytes > 0
       s
     end
   end

data/lib/block_io/key.rb

@@ -18,9 +18,9 @@ module BlockIo
       # create a private/public key pair from a given passphrase
       # use a long, random passphrase. your security depends on the passphrase's entropy.
       
-      raise Exception.new("Must provide passphrase at least 8 characters long.") if passphrase.nil? or passphrase.length < 8
+      raise Exception.new('Must provide passphrase at least 8 characters long.') if passphrase.nil? or passphrase.length < 8
       
-      hashed_key = Helper.sha256([passphrase].pack("H*")) # must pass bytes to sha256
+      hashed_key = Helper.sha256([passphrase].pack('H*')) # must pass bytes to sha256
       
       # modding is for backward compatibility with legacy bitcoinjs
       BlockIo::Key.from_private_key_hex((hashed_key.to_i(16) % ECDSA::Group::Secp256k1.order).to_s(16))

data/lib/block_io/version.rb

@@ -1,3 +1,3 @@
 module BlockIo
-  VERSION = "3.0.5"
+  VERSION = '3.1.0'
 end

data/lib/block_io.rb

@@ -1,9 +1,8 @@
-require "http"
 require "oj"
 require "bitcoin"
 require "openssl"
 require "securerandom"
-require "connection_pool"
+require "typhoeus"
 
 require_relative "block_io/version"
 require_relative "block_io/helper"

data/spec/client_misc_spec.rb

@@ -5,19 +5,12 @@ describe "Client" do
   before(:each) do
     @api_key = "0000-0000-0000-0000"
     @req_params = {:to_address => "QTLcyTFrH7T6kqUsi1VV2mJVXmX3AmwUNH", :amounts => "0.248"}
-    @headers = {
-      'Accept' => 'application/json',
-      'Connection' => 'Keep-Alive',
-      'Content-Type' => 'application/json; charset=UTF-8',
-      'Host' => 'block.io',
-      'User-Agent' => "gem:block_io:#{BlockIo::VERSION}"
-    }
     
     @prepare_transaction_response = File.new("spec/test-cases/json/prepare_transaction_response_with_blockio_fee_and_expected_unsigned_txid.json").read
     @stub1 = stub_request(:post, "https://block.io/api/v2/prepare_transaction").
                with(
                  body: @req_params.merge({:api_key => @api_key}).to_json,
-                 headers: @headers).
+                 headers: SPEC_REQUEST_HEADERS).
                to_return(status: 200, body: @prepare_transaction_response, headers: {})
 
     @create_and_sign_transaction_response = File.new("spec/test-cases/json/create_and_sign_transaction_response_with_blockio_fee_and_expected_unsigned_txid.json").read

data/spec/client_spec.rb

@@ -3,19 +3,12 @@ describe "Client.prepare_transaction" do
   before(:each) do
     @api_key = "0000-0000-0000-0000"
     @req_params = {:to_address => "QTLcyTFrH7T6kqUsi1VV2mJVXmX3AmwUNH", :amounts => "0.248"}
-    @headers = {
-      'Accept' => 'application/json',
-      'Connection' => 'Keep-Alive',
-      'Content-Type' => 'application/json; charset=UTF-8',
-      'Host' => 'block.io',
-      'User-Agent' => "gem:block_io:#{BlockIo::VERSION}"
-    }
     
     @prepare_transaction_response = File.new("spec/test-cases/json/prepare_transaction_response.json").read
     @stub1 = stub_request(:post, "https://block.io/api/v2/prepare_transaction").
                with(
                  body: @req_params.merge({:api_key => @api_key}).to_json,
-                 headers: @headers).
+                 headers: SPEC_REQUEST_HEADERS).
                to_return(status: 200, body: @prepare_transaction_response, headers: {})
 
     @create_and_sign_transaction_response = File.new("spec/test-cases/json/create_and_sign_transaction_response.json").read

data/spec/dtrust_spec.rb

@@ -8,14 +8,6 @@ describe "Client.prepare_dtrust_transaction" do
                      "6c1cefdfd9187b36b36c3698c1362642083dcc1941dc76d751481d3aa29ca65"]
     @to_address = "QcnYiN3t3foHxHv7CnqXrmRoiMkADhapZw"
     @amount = "0.00020000"
-    @headers = {
-      'Accept' => 'application/json',
-      'Connection' => 'Keep-Alive',
-      'Content-Type' => 'application/json; charset=UTF-8',
-      'Host' => 'block.io',
-      'User-Agent' => "gem:block_io:#{BlockIo::VERSION}"
-    }
-
   end
 
   context "p2sh" do
@@ -29,7 +21,7 @@ describe "Client.prepare_dtrust_transaction" do
       @stub1 = stub_request(:post, "https://block.io/api/v2/prepare_dtrust_transaction").
                  with(
                    body: @req_params.merge({:api_key => @api_key}).to_json,
-                   headers: @headers).
+                   headers: SPEC_REQUEST_HEADERS).
                  to_return(status: 200, body: @prepare_dtrust_transaction_response_p2sh, headers: {})
       
       @create_and_sign_transaction_response_dtrust_p2sh_3_of_5_keys = File.new("spec/test-cases/json/create_and_sign_transaction_response_dtrust_p2sh_3_of_5_keys.json").read
@@ -76,7 +68,7 @@ describe "Client.prepare_dtrust_transaction" do
       @stub1 = stub_request(:post, "https://block.io/api/v2/prepare_dtrust_transaction").
                  with(
                    body: @req_params.merge({:api_key => @api_key}).to_json,
-                   headers: @headers).
+                   headers: SPEC_REQUEST_HEADERS).
                  to_return(status: 200, body: @prepare_dtrust_transaction_response_p2wsh_over_p2sh, headers: {})
       
       @create_and_sign_transaction_response_dtrust_p2wsh_over_p2sh_3_of_5_keys = File.new("spec/test-cases/json/create_and_sign_transaction_response_dtrust_p2wsh_over_p2sh_3_of_5_keys.json").read
@@ -125,7 +117,7 @@ describe "Client.prepare_dtrust_transaction" do
       @stub1 = stub_request(:post, "https://block.io/api/v2/prepare_dtrust_transaction").
                  with(
                    body: @req_params.merge({:api_key => @api_key}).to_json,
-                   headers: @headers).
+                   headers: SPEC_REQUEST_HEADERS).
                  to_return(status: 200, body: @prepare_dtrust_transaction_response_witness_v0, headers: {})
       
       @create_and_sign_transaction_response_dtrust_witness_v0_3_of_5_keys = File.new("spec/test-cases/json/create_and_sign_transaction_response_dtrust_witness_v0_3_of_5_keys.json").read

data/spec/spec_helper.rb

@@ -3,3 +3,5 @@ require_relative '../lib/block_io'
 require 'webmock/rspec'
 
 WebMock.disable_net_connect!
+
+SPEC_REQUEST_HEADERS = BlockIo::Client.new(:api_key => "0000-0000-0000-0000").api_request_headers.freeze

data/spec/sweep_spec.rb

@@ -6,20 +6,12 @@ describe "Client.prepare_sweep_transaction" do
     @req_params = {:to_address => "QTLcyTFrH7T6kqUsi1VV2mJVXmX3AmwUNH", :public_key => "021499295873879c280c31fff94845a6153142e76b84a29afc92128d482857ed93"}
     @req_params_with_wif = {:to_address => "QTLcyTFrH7T6kqUsi1VV2mJVXmX3AmwUNH", :private_key => @wif}
 
-    @headers = {
-      'Accept' => 'application/json',
-      'Connection' => 'Keep-Alive',
-      'Content-Type' => 'application/json; charset=UTF-8',
-      'Host' => 'block.io',
-      'User-Agent' => "gem:block_io:#{BlockIo::VERSION}"
-    }
-
     # since @network won't be set, the library will call get_balance first on prepare_sweep_transaction
     @get_balance_response = File.new("spec/test-cases/json/get_balance_response.json").read
     @stub_network = stub_request(:post, "https://block.io/api/v2/get_balance").
                       with(
                         body: {:api_key => @api_key}.to_json,
-                        headers: @headers).
+                        headers: SPEC_REQUEST_HEADERS).
                       to_return(status: 200, body: @get_balance_response, headers: {})
 
   end
@@ -34,7 +26,7 @@ describe "Client.prepare_sweep_transaction" do
       @stub1 = stub_request(:post, "https://block.io/api/v2/prepare_sweep_transaction").
                  with(
                    body: @req_params.merge({:api_key => @api_key}).to_json,
-                   headers: @headers).
+                   headers: SPEC_REQUEST_HEADERS).
                  to_return(status: 200, body: @prepare_sweep_transaction_response_p2pkh, headers: {})
       
       @create_and_sign_transaction_response_sweep_p2pkh = File.new("spec/test-cases/json/create_and_sign_transaction_response_sweep_p2pkh.json").read
@@ -63,7 +55,7 @@ describe "Client.prepare_sweep_transaction" do
       @stub1 = stub_request(:post, "https://block.io/api/v2/prepare_sweep_transaction").
                  with(
                    body: @req_params.merge({:api_key => @api_key}).to_json,
-                   headers: @headers).
+                   headers: SPEC_REQUEST_HEADERS).
                  to_return(status: 200, body: @prepare_sweep_transaction_response_p2wpkh_over_p2sh, headers: {})
       
       @create_and_sign_transaction_response_sweep_p2wpkh_over_p2sh = File.new("spec/test-cases/json/create_and_sign_transaction_response_sweep_p2wpkh_over_p2sh.json").read
@@ -92,7 +84,7 @@ describe "Client.prepare_sweep_transaction" do
       @stub1 = stub_request(:post, "https://block.io/api/v2/prepare_sweep_transaction").
                  with(
                    body: @req_params.merge({:api_key => @api_key}).to_json,
-                   headers: @headers).
+                   headers: SPEC_REQUEST_HEADERS).
                  to_return(status: 200, body: @prepare_sweep_transaction_response_p2wpkh, headers: {})
       
       @create_and_sign_transaction_response_sweep_p2wpkh = File.new("spec/test-cases/json/create_and_sign_transaction_response_sweep_p2wpkh.json").read

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: block_io
 version: !ruby/object:Gem::Version
-  version: 3.0.5
+  version: 3.1.0
 platform: ruby
 authors:
 - Atif Nazir
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-30 00:00:00.000000000 Z
+date: 2022-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -19,7 +19,7 @@ dependencies:
         version: '1.16'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: '1.16'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -37,9 +37,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -47,89 +47,89 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '14'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
-    - - ">="
+        version: '3.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '3.6'
+        version: '4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
-    - - ">="
+        version: '3.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '3.6'
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: bitcoinrb
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.2.1
     - - "<"
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.2.1
     - - "<"
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: '2'
 - !ruby/object:Gem::Dependency
-  name: http
+  name: typhoeus
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.4.1
+        version: '1.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.4.1
+        version: '1.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
@@ -139,7 +139,7 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -149,27 +149,7 @@ dependencies:
         version: '3.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '4.0'
-- !ruby/object:Gem::Dependency
-  name: connection_pool
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4'
 description: This Ruby Gem is the official reference client for the Block.io payments
   API. To use this, you will need the Dogecoin, Bitcoin, or Litecoin API key(s) from
   Block.io. Go ahead, sign up :)