quadrigacx 0.10.1 → 0.12.2

data/lib/quadrigacx/request.rb

@@ -1,10 +1,11 @@
 require 'rest-client'
 require 'json'
-require 'hashie'
 require 'openssl'
 require 'date'
 require 'uri'
 require 'digest'
+require 'ostruct'
+require 'quadrigacx/error'
 
 module QuadrigaCX
   module Request
@@ -13,23 +14,19 @@ module QuadrigaCX
     protected
 
     def request *args
-      resp = hmac_request(*args)
-      json = JSON.parse(resp) rescue (return fix_json(resp))
-      json.kind_of?(Array) ? json.map { |i| to_hashie(i) } : to_hashie(json)
+      response = hmac_request(*args)
+      response = JSON.parse(response, object_class: OpenStruct) rescue (return fix_json(response))
+
+      check_error(response)
     end
 
     private
 
     def fix_json response
-      begin
-        JSON.parse(response)
-
       # The `/cancel_order` route returns `"true"` instead of valid JSON.
-      rescue JSON::ParserError
-        return true  if response.strip == '"true"'
-        return false if response.strip == '"false"'
-        response[/"(.*)"/, 1] || response
-      end
+      return true  if response.strip == '"true"'
+      return false if response.strip == '"false"'
+      response[/"(.*)"/, 1] || response
     end
 
     def hmac_request http_method, path, body={}
@@ -39,16 +36,20 @@ module QuadrigaCX
       if http_method == :get
         url += '?' + URI.encode_www_form(body)
       else
-        raise 'API key, API secret and client ID required!' unless @api_key && @api_secret && @client_id
+        client_id  = QuadrigaCX.configuration.client_id
+        api_key    = QuadrigaCX.configuration.api_key
+        api_secret = QuadrigaCX.configuration.api_secret
+        
+        raise 'API key, API secret and client ID required!' unless api_key && api_secret && client_id
 
-        secret    = Digest::MD5.hexdigest(@api_secret)
+        secret    = Digest::MD5.hexdigest(api_secret)
         nonce     = DateTime.now.strftime('%Q')
-        data      = [nonce + @api_key + @client_id].join
+        data      = [nonce + api_key + client_id].join
         digest    = OpenSSL::Digest.new('sha256')
         signature = OpenSSL::HMAC.hexdigest(digest, secret, data)
 
         payload = body.merge({
-          key: @api_key,
+          key: api_key,
           nonce: nonce,
           signature: signature,
         })
@@ -66,27 +67,28 @@ module QuadrigaCX
       )
     end
 
-    def raise_error hash
-      errorClass =
-        case hash.error.code
-        when 21  then ExceedsAvailableBalance
-        when 22  then BelowMinimumOrderValue
-        when 23  then AboveMaximumOrderValue
-        when 106 then NotFound
-        else Error
-        end
-
-      message  = hash.error.code.to_s + ' '
-      message += hash.error.to_s if hash.error
-      message += hash.errors.join(',') if hash.errors
-
-      raise errorClass.new(message)
-    end
+    def check_error responses
+      [responses].flatten.each do |response|
+        
+        next unless response.error
+
+        errorClass =
+          case response.error.code
+          when 21  then ExceedsAvailableBalance
+          when 22  then BelowMinimumOrderValue
+          when 23  then AboveMaximumOrderValue
+          when 106 then NotFound
+          else Error
+          end
+
+        message  = response.error.code.to_s + ' '
+        message += response.error.to_s if response.error
+        message += response.errors.join(',') if response.errors
+
+        raise errorClass.new(message)
+      end
 
-    def to_hashie json
-      hash = Hashie::Mash.new(json)
-      raise_error(hash) if hash.error
-      hash
+      responses
     end
   end
 end

data/lib/quadrigacx/version.rb

@@ -1,5 +1,3 @@
 module QuadrigaCX
-  unless defined?(QuadrigaCX::VERSION)
-    VERSION = '0.10.1'
-  end
+  VERSION = '0.12.2'
 end

data/quadrigacx.gemspec

@@ -1,29 +1,32 @@
-require File.expand_path('../lib/quadrigacx/version', __FILE__)
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'quadrigacx/version'
 
-Gem::Specification.new do |s|
-  s.name        = "quadrigacx"
-  s.version     = QuadrigaCX::VERSION.dup
-  s.summary     = "QuadrigaCX API wrapper"
-  s.description = "Ruby wrapper for the QuadrigaCX API"
-  s.homepage    = "https://github.com/mhluska/quadrigacx"
-  s.authors     = ["Maros Hluska"]
-  s.email       = ["mhluska@gmail.com"]
-  s.homepage    = "http://mhluska.com/"
-  s.license     = "MIT"
+Gem::Specification.new do |spec|
+  spec.name          = 'quadrigacx'
+  spec.version       = QuadrigaCX::VERSION
+  spec.author        = 'Maros Hluska'
+  spec.email         = 'mhluska@gmail.com'
+  spec.summary       = 'QuadrigaCX API wrapper'
+  spec.description   = 'Ruby wrapper for the QuadrigaCX API'
+  spec.homepage      = 'https://github.com/mhluska/quadrigacx'
+  spec.license       = 'MIT'
 
-  s.add_development_dependency 'byebug',      '~> 5.0'
-  s.add_development_dependency 'rspec',       '~> 3.1'
-  s.add_development_dependency 'webmock',     '~> 1.20'
-  s.add_development_dependency 'vcr',         '~> 2.9'
-  s.add_development_dependency 'dotenv',      '~> 1.0'
-  s.add_development_dependency 'gem-release', '~> 0.7'
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
 
-  s.add_runtime_dependency 'json',          '~> 1.8'
-  s.add_runtime_dependency 'rest-client',   '~> 1.7'
-  s.add_runtime_dependency 'hashie',        '~> 3.3'
+  spec.add_runtime_dependency 'json',        '~> 1.8'
+  spec.add_runtime_dependency 'rest-client', '~> 1.7'
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f)}
-  s.require_paths = ["lib"]
+  spec.add_development_dependency 'byebug',      '~> 5.0'
+  spec.add_development_dependency 'rspec',       '~> 3.1'
+  spec.add_development_dependency 'webmock',     '~> 1.20'
+  spec.add_development_dependency 'vcr',         '~> 2.9'
+  spec.add_development_dependency 'dotenv',      '~> 1.0'
+  spec.add_development_dependency 'gem-release', '~> 0.7'
+  spec.add_development_dependency 'bundler',     '~> 1.7'
+  spec.add_development_dependency 'rake',        '~> 10.0'
 end

data/spec/client_spec.rb

@@ -1,71 +1,62 @@
 require 'spec_helper'
 
-describe QuadrigaCX::Client do
-  subject(:client) { QuadrigaCX::Client.new(
-    client_id:  ENV['QUADRIGACX_CLIENT_ID'],
-    api_key:    ENV['QUADRIGACX_API_KEY'],
-    api_secret: ENV['QUADRIGACX_API_SECRET'],
-  )}
-
-  def safe_limit_buy
-    VCR.use_cassette('safe_limit_buy') do
-      worst_price = client.order_book.bids.last[0]
-      client.limit_buy(price: worst_price, amount: 1)
-    end
+describe QuadrigaCX::Client, :vcr do
+  def safe_limit_buy book: :btc_cad
+    worst_price = subject.order_book.bids.last[0]
+    subject.limit_buy(price: worst_price, amount: 1, book: book)
   end
 
-  def safe_limit_sell
-    VCR.use_cassette('safe_limit_sell') do
-      worst_price = client.order_book.asks.last[0]
-      client.limit_sell(price: worst_price, amount: 0.01)
-    end
+  def safe_limit_sell book: :btc_cad
+    worst_price = subject.order_book.asks.last[0]
+    subject.limit_sell(price: worst_price, amount: 0.01, book: book)
   end
 
   describe 'public' do
     describe '#ticker' do
       it 'returns trading information' do
-        VCR.use_cassette('ticker') do
-          ticker = client.ticker
+        ticker = subject.ticker
 
-          expect(ticker.high).not_to be_nil
-          expect(ticker.low).not_to be_nil
-        end
+        expect(ticker.high).not_to be_nil
+        expect(ticker.low).not_to be_nil
       end
     end
 
     describe '#order_book' do
+      let(:order_book_cad) { subject.order_book }
+      let(:order_book_usd) { subject.order_book(book: :btc_usd) }
+
       it 'returns a list of all open orders' do
-        VCR.use_cassette('order_book') do
-          order_book = client.order_book
+        expect(order_book_cad.timestamp).not_to be_nil
+        expect(order_book_cad.bids.first.length).to equal 2
+        expect(order_book_cad.asks.first.length).to equal 2
+      end
 
-          expect(order_book.timestamp).not_to be_nil
-          expect(order_book.bids.first.length).to equal 2
-          expect(order_book.asks.first.length).to equal 2
-        end
+      it 'returns a USD order book' do
+        expect(order_book_usd.bids.first).to_not equal(order_book_cad.bids.first)
       end
 
-      context 'when using the ungrouped option' do
-        order = nil
-        after { VCR.use_cassette('order_book_ungrouped_cancel_order') { client.cancel(id: order.id) if order }}
+      context 'when using the group option' do
+        let!(:order) { safe_limit_buy }
+        after { subject.cancel(id: order.id) }
 
         it 'does not group same price orders' do
-          VCR.use_cassette('order_book_ungrouped') do
-            order = safe_limit_buy
-            ungrouped_bids = client.order_book(group: 0).bids
-            expect(ungrouped_bids[-2][0]).to eq(ungrouped_bids.last[0])
-          end
+          ungrouped_bids = subject.order_book(group: 0).bids
+          expect(ungrouped_bids[-2][0]).to eq(ungrouped_bids.last[0])
         end
       end
     end
 
     describe '#transactions' do
+      let(:transactions_cad) { subject.transactions }
+      let(:transactions_usd) { subject.transactions(book: :btc_usd) }
+
       it 'returns a list of recent trades' do
-        VCR.use_cassette('transactions') do
-          transactions = client.transactions
+        expect(transactions_cad.first.date).not_to be_nil
+        expect(transactions_cad.first.price).not_to be_nil
+      end
 
-          expect(transactions.first.date).not_to be_nil
-          expect(transactions.first.price).not_to be_nil
-        end
+      it 'returns a list of USD trades' do
+        expect(transactions_usd.first.price).not_to equal(transactions_cad.first.price)
       end
     end
   end
@@ -73,77 +64,96 @@ describe QuadrigaCX::Client do
   describe 'private' do
     describe '#balance' do
       it 'returns all account balances' do
-        VCR.use_cassette('balance') do
-          balance = client.balance
+        balance = subject.balance
 
-          expect(balance.cad_balance).not_to be_nil
-          expect(balance.btc_balance).not_to be_nil
-        end
+        expect(balance.cad_balance).not_to be_nil
+        expect(balance.btc_balance).not_to be_nil
       end
     end
 
     describe '#limit_buy' do
-      order = nil
-      after { VCR.use_cassette('limit_buy_cancel_order') { client.cancel(id: order.id) if order }}
-
-      it 'throws an error when no price is provided' do
-        expect { client.limit_buy }.to raise_error(QuadrigaCX::ConfigurationError)
-      end
+      describe 'errors' do
+        it 'throws an error when no price is provided' do
+          expect { subject.limit_buy }.to raise_error(QuadrigaCX::ConfigurationError)
+        end
 
-      it 'places a limit buy order' do
-        VCR.use_cassette('limit_buy') do
-          order = safe_limit_buy
+        it 'throws an error when exceeding balance' do
+          expect { subject.limit_buy(price: 1_000_000, amount: 1) }.to raise_error(QuadrigaCX::AboveMaximumOrderValue)
+        end
 
-          expect(order.datetime).not_to be_nil
-          expect(order.id).not_to be_nil
+        it 'throws an error when the amount is too small' do
+          expect { subject.limit_buy(price: 100, amount: 0.00000001) }.to raise_error(QuadrigaCX::BelowMinimumOrderValue)
         end
-      end
 
-      it 'throws an error when exceeding balance' do
-        VCR.use_cassette('limit_buy_above_maximum_order_value') do
-          expect { client.limit_buy(price: 1_000_000, amount: 1) }.to raise_error(QuadrigaCX::AboveMaximumOrderValue)
+        it 'throws an error when exceeding available balance' do
+          expect { subject.limit_buy(price: 4999, amount: 1) }.to raise_error(QuadrigaCX::ExceedsAvailableBalance)
         end
       end
 
-      it 'throws an error when the amount is too small' do
-        VCR.use_cassette('limit_buy_below_minimum_order_value') do
-          expect { client.limit_buy(price: 100, amount: 0.00000001) }.to raise_error(QuadrigaCX::BelowMinimumOrderValue)
-        end
+      let(:order_cad) { safe_limit_buy }
+      let(:order_usd) { safe_limit_buy(book: :btc_usd) }
+
+      after { subject.cancel(id: order_cad.id) && subject.cancel(id: order_usd.id) }
+
+      it 'places a limit buy order_cad' do
+        expect(order_cad.datetime).not_to be_nil
+        expect(order_cad.id).not_to be_nil
+        expect(order_cad.price).not_to be_nil
       end
 
-      it 'throws an error when exceeding available balance' do
-        VCR.use_cassette('limit_buy_exceeds_available_balance') do
-          expect { client.limit_buy(price: 4999, amount: 1) }.to raise_error(QuadrigaCX::ExceedsAvailableBalance)
-        end
+      it 'places a USD limit buy order' do
+        expect(order_cad.price).not_to equal(order_usd.price)
       end
     end
 
     describe '#limit_sell' do
-      order = nil
-      after { VCR.use_cassette('limit_sell_cancel_order') { client.cancel(id: order.id) if order }}
-
-      it 'throws an error when no price is provided' do
-        expect { client.limit_sell }.to raise_error(QuadrigaCX::ConfigurationError)
+      describe 'errors' do
+        it 'throws an error when no price is provided' do
+          expect { subject.limit_sell }.to raise_error(QuadrigaCX::ConfigurationError)
+        end
       end
 
+      let(:order_cad) { safe_limit_sell }
+      let(:order_usd) { safe_limit_sell(book: :btc_usd) }
+
+      after { subject.cancel(id: order_cad.id) && subject.cancel(id: order_usd.id) }
+
       it 'places a limit sell order' do
-        VCR.use_cassette('limit_sell') do
-          order = safe_limit_sell
+        expect(order_cad.datetime).not_to be_nil
+        expect(order_cad.id).not_to be_nil
+        expect(order_cad.price).not_to be_nil
+      end
 
-          expect(order.datetime).not_to be_nil
-          expect(order.id).not_to be_nil
-        end
+      it 'places a USD limit sell order' do
+        expect(order_cad.price).not_to equal(order_usd.price)
       end
     end
 
     describe '#market_buy' do
+      let(:market_buy_cad) { subject.market_buy(amount: 5.00) }
+      let(:market_buy_usd) { subject.market_buy(amount: 5.00, book: :btc_usd) }
+
       it 'places a market buy order' do
-        VCR.use_cassette('market_buy') do
-          response = client.market_buy(amount: 5.00) # 5 CAD
+        expect(market_buy_cad.amount).not_to be_nil
+        expect(market_buy_cad.orders_matched.first.price).not_to be_nil
+      end
 
-          expect(response.amount).not_to be_nil
-          expect(response.orders_matched.first.price).not_to be_nil
-        end
+      it 'places a USD market buy order' do
+        expect(market_buy_cad.orders_matched.first.price).not_to equal(market_buy_usd.orders_matched.first.price)
+      end
+    end
+
+    describe '#market_sell' do
+      let(:market_sell_cad) { subject.market_sell(amount: 0.01) }
+      let(:market_sell_usd) { subject.market_sell(amount: 0.01, book: :btc_usd) }
+
+      it 'places a market sell order' do
+        expect(market_sell_cad.amount).not_to be_nil
+        expect(market_sell_cad.orders_matched.first.price).not_to be_nil
+      end
+
+      it 'places a USD market sell order' do
+        expect(market_sell_cad.orders_matched.first.price).not_to equal(market_sell_usd.orders_matched.first.price)
       end
     end
 
@@ -151,60 +161,61 @@ describe QuadrigaCX::Client do
       let(:order) { safe_limit_buy }
 
       it 'cancels an order' do
-        VCR.use_cassette('cancel') do
-          response = client.cancel(id: order.id)
-          expect(response).to be true
-        end
+        response = subject.cancel(id: order.id)
+        expect(response).to be true
       end
     end
 
     describe '#withdraw' do
       it 'withdraws bitcoins' do
-        VCR.use_cassette('withdraw') do
-          response = client.withdraw(amount: 0.01, address: '1FAs1ywa3pqS6S5mvypXjCtHAzwCkymNUX')
-          expect(response).to eq('ok')
-        end
+        response = subject.withdraw(amount: 0.01, address: '1DVLFma28jEgTCUjQ32FUYe12bRzvywAfr')
+        expect(response).to eq('ok')
       end
     end
 
     describe '#open_orders' do
+      let(:open_orders_cad) { subject.open_orders }
+      let(:open_orders_usd) { subject.open_orders(book: :btc_usd) }
+      let!(:orders) { [safe_limit_buy, safe_limit_buy(book: :btc_usd)] }
+
+      after { orders.each { |order| subject.cancel(id: order.id) }}
+
       it 'lists open orders' do
-        VCR.use_cassette('open_orders') do
-          response = client.open_orders
+        expect(open_orders_cad.first.datetime).not_to be_nil
+        expect(open_orders_cad.first.type).not_to be_nil
+        expect(open_orders_cad.first.price).not_to be_nil
+      end
 
-          expect(response.first.datetime).not_to be_nil
-          expect(response.first.price).not_to be_nil
-          expect(response.first.type).not_to be_nil
-        end
+      it 'lists USD open orders' do
+        expect(open_orders_cad.first.price).not_to equal open_orders_usd.first.price
       end
     end
 
     describe '#wallet_address' do
       it 'returns a wallet address' do
-        VCR.use_cassette('wallet_address') do
-          response = client.wallet_address
-          expect(response.length).to be_between(26, 35)
-        end
+        response = subject.wallet_address
+        expect(response.length).to be_between(26, 35)
       end
     end
 
     describe '#user_transactions' do
+      let(:user_transactions_cad) { subject.user_transactions }
+      let(:user_transactions_usd) { subject.user_transactions(order_book: :btc_usd) }
+
       it 'returns a list of transactions' do
-        VCR.use_cassette('user_transactions') do
-          response = client.user_transactions
-          expect(response.first.id).to be_kind_of(String)
-          expect(response.first.datetime).not_to be_nil
-        end
+        expect(user_transactions_cad.first.id).to be_kind_of(String)
+        expect(user_transactions_cad.first.datetime).not_to be_nil
+        expect(user_transactions_cad.first.rate).not_to be_nil
       end
 
-      it 'returns a list of limited transactions' do
-        VCR.use_cassette('user_transactions_limited') do
-          limit    = 1
-          response = client.user_transactions(limit: limit)
+      it 'returns a list of USD transactions' do
+        expect(user_transactions_cad.first.rate).not_to equal(user_transactions_usd.first.rate)
+      end
 
-          # For some reason the API is off by one.
-          expect(response.length).to be (limit + 1)
-        end
+      it 'returns a list of limited transactions' do
+        limit    = 5
+        response = subject.user_transactions(limit: limit)
+        expect(response.length).to equal limit
       end
     end
   end