bitex_bot 0.6.1 → 0.9.0

data/lib/bitex_bot/models/opening_flow.rb

@@ -3,6 +3,8 @@ module BitexBot
   # The OpeningFlow stage places an order on bitex, detecting and storing all transactions spawn from that order as
   # Open positions.
   class OpeningFlow < ActiveRecord::Base
+    extend Forwardable
+
     self.abstract_class = true
 
     # The updated config store as passed from the robot
@@ -29,26 +31,31 @@ module BitexBot
     #   #safest_price
     #   #value_to_use
     # rubocop:disable Metrics/AbcSize
-    def self.create_for_market(remote_balance, order_book, transactions, maker_fee, taker_fee, store)
+    def self.create_for_market(taker_balance, taker_orders, taker_transactions, maker_fee, taker_fee, store)
       self.store = store
 
-      remote_value, safest_price = calc_remote_value(maker_fee, taker_fee, order_book, transactions)
-      raise CannotCreateFlow, "Needed #{remote_value} but you only have #{remote_balance}" unless
-        enough_remote_funds?(remote_balance, remote_value)
+      remote_value, safest_price = calc_remote_value(maker_fee, taker_fee, taker_orders, taker_transactions)
+      unless enough_remote_funds?(taker_balance, remote_value)
+        raise CannotCreateFlow,
+              "Needed #{remote_value} but you only have #{taker_specie_to_spend} #{taker_balance} on your taker market."
+      end
+
+      price = maker_price(remote_value)
 
-      bitex_price = maker_price(remote_value)
-      order = create_order!(bitex_price)
-      raise CannotCreateFlow, "You need to have #{value_to_use} on bitex to place this #{order_class.name}." unless
-        enough_funds?(order)
+      order = create_order!(price)
+      unless enough_funds?(order)
+        raise CannotCreateFlow,
+              "You need to have #{maker_specie_to_spend} #{value_per_order} on Bitex to place this #{order_class}."
+      end
 
       Robot.log(
         :info,
-        "Opening: Placed #{order_class.name} ##{order.id} #{value_to_use} @ #{Settings.quote.upcase} #{bitex_price}"\
-        " (#{remote_value})"
+        "Opening: Placed #{order_class} ##{order.id} #{value_per_order} @ #{Robot.maker.quote.upcase} #{price}"\
+        " (#{maker_specie_to_obtain} #{remote_value})"
       )
 
       create!(
-        price: bitex_price,
+        price: price,
         value_to_use: value_to_use,
         suggested_closing_price: safest_price,
         status: 'executing',
@@ -60,16 +67,16 @@ module BitexBot
     # rubocop:enable Metrics/AbcSize
 
     # create_for_market helpers
-    def self.calc_remote_value(maker_fee, taker_fee, order_book, transactions)
+    def self.calc_remote_value(maker_fee, taker_fee, taker_orders, taker_transactions)
       value_to_use_needed = (value_to_use + maker_plus(maker_fee)) / (1 - taker_fee / 100)
-      safest_price = safest_price(transactions, order_book, value_to_use_needed)
+      safest_price = safest_price(taker_transactions, taker_orders, value_to_use_needed)
       remote_value = remote_value_to_use(value_to_use_needed, safest_price)
 
       [remote_value, safest_price]
     end
 
-    def self.create_order!(bitex_price)
-      order_class.create!(Settings.maker_settings.order_book, value_to_use, bitex_price, true)
+    def self.create_order!(maker_price)
+      Robot.maker.send_order(order_type, maker_price, value_per_order, true)
     rescue StandardError => e
       raise CannotCreateFlow, e.message
     end
@@ -78,8 +85,8 @@ module BitexBot
       !order.reason.to_s.inquiry.not_enough_funds?
     end
 
-    def self.enough_remote_funds?(remote_balance, remote_value)
-      remote_balance >= remote_value
+    def self.enough_remote_funds?(taker_balance, remote_value)
+      taker_balance >= remote_value
     end
 
     def self.maker_plus(fee)
@@ -93,7 +100,7 @@ module BitexBot
     #   #open_position_class
     def self.sync_open_positions
       threshold = open_position_class.order('created_at DESC').first.try(:created_at)
-      Bitex::Trade.all.map do |transaction|
+      Robot.maker.transactions.map do |transaction|
         next unless sought_transaction?(threshold, transaction)
 
         flow = find_by_order_id(transaction_order_id(transaction))
@@ -104,25 +111,28 @@ module BitexBot
     end
 
     # sync_open_positions helpers
+    # rubocop:disable Metrics/AbcSize
     def self.create_open_position!(transaction, flow)
       Robot.log(
         :info,
-        "Opening: #{name} ##{flow.id} was hit for #{transaction.quantity} #{Settings.base.upcase} @ #{Settings.quote.upcase}"\
-        " #{transaction.price}"
+        "Opening: #{name} ##{flow.id} was hit for #{transaction.raw.quantity} #{Robot.maker.base.upcase}"\
+        " @ #{Robot.maker.quote.upcase} #{transaction.price}"
       )
+
       open_position_class.create!(
         transaction_id: transaction.id,
         price: transaction.price,
         amount: transaction.amount,
-        quantity: transaction.quantity,
+        quantity: transaction.raw.quantity,
         opening_flow: flow
       )
     end
+    # rubocop:enable Metrics/AbcSize
 
     # This use hooks methods, these must be defined in the subclass:
     #   #transaction_class
     def self.sought_transaction?(threshold, transaction)
-      transaction.is_a?(transaction_class) &&
+      expected_kind_transaction?(transaction) &&
         !active_transaction?(transaction, threshold) &&
         !open_position?(transaction) &&
         expected_order_book?(transaction)
@@ -130,16 +140,20 @@ module BitexBot
     # end: sync_open_positions helpers
 
     # sought_transaction helpers
+    def self.expected_kind_transaction?(transaction)
+      transaction.raw.is_a?(transaction_class)
+    end
+
     def self.active_transaction?(transaction, threshold)
-      threshold.present? && transaction.created_at < (threshold - 30.minutes)
+      threshold.present? && transaction.timestamp < (threshold - 30.minutes).to_i
     end
 
     def self.open_position?(transaction)
       open_position_class.find_by_transaction_id(transaction.id)
     end
 
-    def self.expected_order_book?(transaction)
-      transaction.order_book == Settings.maker_settings.order_book
+    def self.expected_order_book?(maker_transaction)
+      maker_transaction.raw.order_book.to_s == Robot.maker.base_quote
     end
     # end: sought_transaction helpers
 
@@ -157,7 +171,7 @@ module BitexBot
     end
 
     def finalise!
-      order = self.class.order_class.find(order_id)
+      order = order_class.find(order_id)
       canceled_or_completed?(order) ? do_finalize : do_cancel(order)
     end
 
@@ -169,12 +183,12 @@ module BitexBot
     end
 
     def do_finalize
-      Robot.log(:info, "Opening: #{self.class.order_class.name} ##{order_id} finalised.")
+      Robot.log(:info, "Opening: #{order_class} ##{order_id} finalised.")
       finalised!
     end
 
     def do_cancel(order)
-      Robot.log(:info, "Opening: #{self.class.order_class.name} ##{order_id} canceled.")
+      Robot.log(:info, "Opening: #{order_class} ##{order_id} canceled.")
       order.cancel!
       settling! unless settling?
     end

data/lib/bitex_bot/models/order_book_simulator.rb

@@ -17,35 +17,36 @@ module BitexBot
     #   quantity.
     #
     # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    def self.run(volatility, transactions, order_book, amount_target, quantity_target)
-      to_skip = estimate_quantity_to_skip(volatility, transactions)
-      Robot.log(:debug, "Skipping #{to_skip} BTC")
+    def self.run(volatility, taker_transactions, taker_orderbook, amount_target, quantity_target, fx_rate = 1)
+      to_skip = estimate_quantity_to_skip(volatility, taker_transactions)
+      Robot.log(:debug, "Skipping #{to_skip} #{Robot.taker.base.upcase}")
       seen = 0
 
-      order_book.each do |order_summary|
+      taker_orderbook.each do |order_summary|
         price = order_summary.price
         quantity = order_summary.quantity
 
         # An order may be partially or completely skipped due to volatility.
         if to_skip.positive?
-          [quantity, to_skip].min.tap do |dropped|
-            to_skip -= dropped
-            quantity -= dropped
-            Robot.log(:debug, "Skipped #{dropped} BTC @ $#{price}")
-          end
+          dropped = [quantity, to_skip].min
+          to_skip -= dropped
+          quantity -= dropped
+          Robot.log(:debug, "Skipped #{dropped} #{Robot.taker.base.upcase} @ #{Robot.taker.quote.upcase} #{price}")
           next if quantity.zero?
         end
 
         if quantity_target.present?
-          return best_price('BTC', quantity_target, price) if best_price?(quantity, quantity_target, seen)
+          return best_price(Robot.maker.base.upcase, quantity_target, price) if best_price?(quantity, quantity_target, seen)
+
           seen += quantity
         elsif amount_target.present?
           amount = price * quantity
-          return best_price('$', amount_target, price) if best_price?(amount, amount_target, seen)
+          return best_price(Robot.maker.quote.upcase, amount_target * fx_rate, price) if best_price?(amount, amount_target, seen)
+
           seen += amount
         end
       end
-      order_book.last.price
+      taker_orderbook.last.price
     end
     # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
@@ -64,7 +65,7 @@ module BitexBot
     end
 
     def self.best_price(currency, target, price)
-      price.tap { Robot.log(:debug, "Best price to get #{currency} #{target} is $#{price}") }
+      price.tap { Robot.log(:debug, "Best price to get #{currency} #{target} is #{Robot.taker.quote.upcase} #{price}") }
     end
 
     # end: private class methods

data/lib/bitex_bot/models/sell_closing_flow.rb

@@ -10,9 +10,10 @@ module BitexBot
       OpenSell
     end
 
-    def fx_rate
+    def self.fx_rate
       Settings.selling_fx_rate
     end
+    def_delegator self, :fx_rate
 
     private
 
@@ -37,7 +38,7 @@ module BitexBot
     # end: create_or_cancel! helpers
 
     # create_order_and_close_position helpers
-    def order_method
+    def order_type
       :buy
     end
     # end: create_order_and_close_position helpers

data/lib/bitex_bot/models/sell_opening_flow.rb

@@ -28,13 +28,13 @@ module BitexBot
     # @return [SellOpeningFlow] The newly created flow.
     # @raise [CannotCreateFlow] If there's any problem creating this flow, for example when you run out of BTC on bitex or out
     # of USD on the other exchange.
-    def self.create_for_market(usd_balance, order_book, transactions, maker_fee, taker_fee, store)
+    def self.create_for_market(taker_fiat_balance, taker_asks, taker_transactions, maker_fee, taker_fee, store)
       super
     end
 
     # sync_open_positions helpers
     def self.transaction_order_id(transaction)
-      transaction.ask_id
+      transaction.raw.ask_id
     end
 
     def self.open_position_class
@@ -56,6 +56,11 @@ module BitexBot
     def self.order_class
       Bitex::Ask
     end
+    def_delegator self, :order_class
+
+    def self.order_type
+      :sell
+    end
 
     def self.profit
       store.selling_profit || Settings.selling.profit
@@ -65,8 +70,8 @@ module BitexBot
       value_to_use_needed * safest_price
     end
 
-    def self.safest_price(transactions, order_book, bitcoins_to_use)
-      OrderBookSimulator.run(Settings.time_to_live, transactions, order_book, nil, bitcoins_to_use)
+    def self.safest_price(transactions, taker_asks, bitcoins_to_use)
+      OrderBookSimulator.run(Settings.time_to_live, transactions, taker_asks, nil, bitcoins_to_use, nil)
     end
 
     def self.value_to_use
@@ -77,5 +82,25 @@ module BitexBot
     def self.fx_rate
       Settings.selling_fx_rate
     end
+
+    def self.value_per_order
+      value_to_use
+    end
+
+    def self.maker_specie_to_spend
+      Robot.maker.base.upcase
+    end
+
+    def self.maker_specie_to_obtain
+      Robot.maker.quote.upcase
+    end
+
+    def self.taker_specie_to_spend
+      Robot.taker.quote.upcase
+    end
+
+    def self.taker_specie_to_obtain
+      Robot.taker.base.upcase
+    end
   end
 end

data/lib/bitex_bot/robot.rb

@@ -10,11 +10,11 @@ end
 
 module BitexBot
   # Documentation here!
-  # rubocop:disable Metrics/ClassLength
   class Robot
     extend Forwardable
 
     cattr_accessor :taker
+    cattr_accessor :maker
 
     cattr_accessor :graceful_shutdown
     cattr_accessor :cooldown_until
@@ -33,9 +33,8 @@ module BitexBot
     end
 
     def self.setup
-      Bitex.api_key = Settings.maker_settings.api_key
-      Bitex.sandbox = Settings.maker_settings.sandbox
-      self.taker = Settings.taker_class.tap { |klass| klass.setup(Settings.taker_settings) }
+      self.maker = Settings.maker_class.new(Settings.maker_settings)
+      self.taker = Settings.taker_class.new(Settings.taker_settings)
     end
 
     # Trade constantly respecting cooldown times so that we don't get banned by api clients.
@@ -68,6 +67,7 @@ module BitexBot
         sleep_for(0.1)
       end
     end
+    def_delegator self, :with_cooldown
 
     def self.start_robot
       setup
@@ -116,10 +116,6 @@ module BitexBot
 
     private
 
-    def with_cooldown(&block)
-      self.class.with_cooldown(&block)
-    end
-
     def sync_opening_flows
       [SellOpeningFlow, BuyOpeningFlow].each(&:sync_open_positions)
     end
@@ -158,53 +154,45 @@ module BitexBot
     end
 
     def sync_closing_flows
-      orders = with_cooldown { Robot.taker.orders }
-      transactions = with_cooldown { Robot.taker.user_transactions }
-
-      [BuyClosingFlow, SellClosingFlow].each do |kind|
-        kind.active.each { |flow| flow.sync_closed_positions(orders, transactions) }
-      end
+      [BuyClosingFlow, SellClosingFlow].each { |kind| kind.active.each(&:sync_closed_positions) }
     end
 
     # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def start_opening_flows_if_needed
-      return log(:debug, 'Not placing new orders because of hold') if store.reload.hold?
-      return log(:debug, 'Not placing new orders, closing flows.') if active_closing_flows?
+      return log(:debug, 'Not placing new orders, because Store is held') if store.reload.hold?
+      return log(:debug, 'Not placing new orders, has active closing flows.') if active_closing_flows?
       return log(:debug, 'Not placing new orders, shutting down.') if turn_off?
 
       recent_buying, recent_selling = recent_operations
       return log(:debug, 'Not placing new orders, recent ones exist.') if recent_buying && recent_selling
 
-      profile = Bitex::Profile.get
-      taker_balance = with_cooldown { Robot.taker.balance }
-      sync_log_and_store(taker_balance, profile)
+      maker_balance = with_cooldown { maker.balance }
+      taker_balance = with_cooldown { taker.balance }
+      sync_log_and_store(maker_balance, taker_balance)
 
       check_balance_warning if expired_last_warning?
+      return if stop_opening_flows?
 
-      return log(:debug, "Not placing new orders, #{Settings.quote} target not met") if alert?(:fiat, :stop)
-      return log(:debug, "Not placing new orders, #{Settings.base} target not met") if alert?(:crypto, :stop)
+      order_book = with_cooldown { taker.order_book }
+      transactions = with_cooldown { taker.transactions }
 
-      order_book = with_cooldown { Robot.taker.order_book }
-      transactions = with_cooldown { Robot.taker.transactions }
-
-      create_buy_opening_flow(taker_balance, order_book, transactions, profile) unless recent_buying
-      create_sell_opening_flow(taker_balance, order_book, transactions, profile) unless recent_selling
+      args = [transactions, maker_balance.fee, taker_balance.fee, store]
+      BuyOpeningFlow.create_for_market(*[taker_balance.crypto.available, order_book.bids] + args) unless recent_buying
+      SellOpeningFlow.create_for_market(*[taker_balance.fiat.available, order_book.asks] + args) unless recent_selling
     end
     # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
     def recent_operations
-      [BuyOpeningFlow, SellOpeningFlow].map do |kind|
-        threshold = (Settings.time_to_live / 2).seconds.ago
-        kind.active.where('created_at > ?', threshold).first
-      end
+      threshold = (Settings.time_to_live / 2).seconds.ago
+      [BuyOpeningFlow, SellOpeningFlow].map { |kind| kind.active.where('created_at > ?', threshold).first }
     end
 
-    def sync_log_and_store(taker_balance, maker_balance)
+    def sync_log_and_store(maker_balance, taker_balance)
       file = Settings.log.try(:file)
       last_log = `tail -c 61440 #{file}` if file.present?
 
       store.update(
-        maker_fiat: maker_balance[:"#{Settings.quote}_balance"], maker_crypto: maker_balance[:"#{Settings.base}_balance"],
+        maker_fiat: maker_balance.fiat.total, maker_crypto: maker_balance.crypto.total,
         taker_fiat: taker_balance.fiat.total, taker_crypto: taker_balance.crypto.total,
         log: last_log
       )
@@ -214,13 +202,19 @@ module BitexBot
       store.last_warning.nil? || store.last_warning < 30.minutes.ago
     end
 
+    def stop_opening_flows?
+      (log(:debug, "Not placing new orders, #{maker.quote.upcase} target not met") if alert?(:fiat, :stop)) ||
+        (log(:debug, "Not placing new orders, #{maker.base.upcase} target not met") if alert?(:crypto, :stop))
+    end
+
     def check_balance_warning
-      notify_balance_warning(Settings.base, balance(:crypto), store.crypto_warning) if alert?(:crypto, :warning)
-      notify_balance_warning(Settings.quote, balance(:fiat), store.fiat_warning) if alert?(:fiat, :warning)
+      notify_balance_warning(maker.base, balance(:crypto), store.crypto_warning) if alert?(:crypto, :warning)
+      notify_balance_warning(maker.quote, balance(:fiat), store.fiat_warning) if alert?(:fiat, :warning)
     end
 
     def alert?(currency, flag)
       return unless store.send("#{currency}_#{flag}").present?
+
       balance(currency) <= store.send("#{currency}_#{flag}")
     end
 
@@ -251,14 +245,5 @@ module BitexBot
         body message
       end
     end
-
-    def create_buy_opening_flow(balance, order_book, transactions, profile)
-      BuyOpeningFlow.create_for_market(balance.crypto.available, order_book.bids, transactions, profile[:fee], balance.fee, store)
-    end
-
-    def create_sell_opening_flow(balance, order_book, transactions, profile)
-      SellOpeningFlow.create_for_market(balance.fiat.available, order_book.asks, transactions, profile[:fee], balance.fee, store)
-    end
-    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/bitex_bot/settings.rb

@@ -1,4 +1,5 @@
 require 'hashie'
+require 'fileutils'
 require 'bigdecimal'
 require 'bigdecimal/util'
 
@@ -7,6 +8,7 @@ module BitexBot
   class FileSettings < ::Hashie::Clash
     def method_missing(name, *args, &block)
       return super unless args.none? && args.size == 1
+
       self[name] = args.first
     end
 

data/lib/bitex_bot/version.rb

@@ -1,3 +1,3 @@
 module BitexBot
-  VERSION = '0.6.1'.freeze
+  VERSION = '0.9.0'.freeze
 end

data/settings.rb.sample

@@ -46,19 +46,37 @@ buying_foreign_exchange_rate 1.to_d
 #   api_key: it's passed in to the bitex gem: https://github.com/bitex-la/bitex-ruby.
 #   sandbox: Use sandbox environments instead of live environments.
 #   order_book: order book with which you will operate.
-maker bitex: { api_key: 'your_bitex_api_key_which_should_be_kept_safe', order_book: :btc_usd, sandbox: false }
+maker bitex: { api_key: 'your_bitex_api_key_which_should_be_kept_safe', sandbox: false, ssl_version: nil, debug: false, order_book: 'btc_usd' }
 
 # These are the configurations we need for the markets currently supported.
-# Turn on and off the chosen Bitstamp, Itbit or Kraken market with comments.
+# Turn on and off the chosen Bitex, Bitstamp, Itbit or Kraken market with comments.
 
 # These are passed in to the bitstamp gem: see https://github.com/kojnapp/bitstamp for more info.
-taker bitstamp: { api_key: 'YOUR_API_KEY', secret: 'YOUR_API_SECRET', client_id: 'YOUR_BITSTAMP_USERNAME' }
+# Supported values for order_book: 'btcusd', 'btceur', 'eurusd', 'xrpusd', 'xrpeur', 'xrpbtc', 'ltcusd', 'ltceur', 'ltcbtc',
+# 'ethusd', 'etheur', 'ethbtc', 'bchusd', 'bcheur', 'bchbtc'
+#
+taker bitstamp: { api_key: 'YOUR_API_KEY', secret: 'YOUR_API_SECRET', client_id: 'YOUR_BITSTAMP_USERNAME', order_book: 'btcusd' }
 
 # These are passed in to the itbit gem: see https://github.com/bitex-la/itbit for more info.
-# taker itbit: { client_key: 'client-key', secret: 'secret', user_id: 'user-id',  default_wallet_id: 'wallet-000', sandbox: false }
+# Choices: 'xbtusd', 'xbtsgd', 'xbteur', https://api.itbit.com/docs#market-data-get-order-book-get.
+#
+# taker itbit: { client_key: 'client-key', secret: 'secret', user_id: 'user-id',  default_wallet_id: 'wallet-000', sandbox: false, order_book: 'xbtusd' }
 
 # These are passed in to the kraken gem: see https://github.com/shideneyu/kraken_client for more info.
-# taker kraken: { api_key: 'your_api_key', api_secret: 'your_api_secret' }
+# Supported values for order_book https://api.kraken.com/0/public/AssetPairs:
+#   'bcheur', 'bchusd', 'bchxbt', 'dasheur', 'dashusd', 'dashxbt', 'eoseth', 'eoseur', 'eosusd', 'eosxbt', 'etceth', 'etceur',
+#   'etcusd', 'etcxbt', 'ethcad', '"ethcad.d"', 'etheur', '"etheur.d"', 'ethgbp', ''ethgbp.d'', 'ethjpy', ''ethjpy.d'', 'ethusd',
+#   'ethusd.d', 'ethxbt', ''ethxbt.d'', 'gnoeth', 'gnoeur', 'gnousd', 'gnoxbt', 'icneth', 'icnxbt', 'ltceur', 'ltcusd', 'ltcxbt',
+#   'mlneth', 'mlnxbt', 'repeth', 'repeur', 'repusd', 'repxbt', 'usdtusd', 'xbtcad', ''xbtcad.d'', 'xbteur', ''xbteur.d'', 'xbtgbp',
+#   'xbtgbp.d', 'xbtjpy', ''xbtjpy.d'', 'xbtusd', ''xbtusd.d'', 'xdgxbt', 'xlmeur', 'xlmusd', 'xlmxbt', 'xmreur', 'xmrusd',
+#   'xmrxbt', 'xrpcad', 'xrpeur', 'xrpjpy', 'xrpusd', 'xrpxbt', 'zeceur', 'zecjpy', 'zecusd', 'zecxbt']
+#
+# taker kraken: { api_key: 'your_api_key', api_secret: 'your_api_secret', order_book: 'xbtusd' }
+
+# These are passed in to the Bitex gem: see https://github.com/bitex-la/bitex-ruby.
+# Supported values for order_book: 'btc_usd', 'bch_usd', 'bct_ars', 'bct_clp', 'bct_pyg', 'btc_uyu'
+#
+# taker bitex: { api_key: 'taker_api_key', sandbox: false, ssl_version: nil, debug: false, order_book: 'btc_usd' }
 
 # Settings for the ActiveRecord Database to use.
 # sqlite is just fine. Check this link for more options:

data/spec/bitex_bot/settings_spec.rb

@@ -11,9 +11,16 @@ describe BitexBot::Settings do
         buying_foreign_exchange_rate: 1,
         selling_foreign_exchange_rate: 1,
 
-        maker: { bitex: { api_key: 'your_bitex_api_key_which_should_be_kept_safe', order_book: :btc_usd, sandbox: false } },
+        maker: { bitex: { api_key: 'your_bitex_api_key_which_should_be_kept_safe', order_book: 'btc_usd', sandbox: false, ssl_version: nil, debug: false } },
         # By default Bitstamp is taker market.
-        taker: { bitstamp: { api_key: 'YOUR_API_KEY', secret: 'YOUR_API_SECRET', client_id: 'YOUR_BITSTAMP_USERNAME' } },
+        taker: {
+          bitstamp: {
+            api_key: 'YOUR_API_KEY',
+            secret: 'YOUR_API_SECRET',
+            client_id: 'YOUR_BITSTAMP_USERNAME',
+            order_book: 'btcusd'
+          }
+        },
 
         database: { adapter: :sqlite3, database: 'bitex_bot.db' },
         mailer: {
@@ -32,13 +39,13 @@ describe BitexBot::Settings do
       )
     end
 
-    context 'fx rate' do
-      context 'when Store isn´t loaded, by default' do
+    context 'fx rate, when Store' do
+      context 'isn´t loaded, by default' do
         it { described_class.buying_fx_rate.should eq(1) }
         it { described_class.selling_fx_rate.should eq(1) }
       end
 
-      context 'when Store is loaded, take rate from' do
+      context 'is loaded, take rate from' do
         before(:each) { BitexBot::Store.stub(first: BitexBot::Store.new) }
         let(:fx_rate) { rand(10) }
 
@@ -58,7 +65,7 @@ describe BitexBot::Settings do
 
     context 'maker' do
       {
-        bitex: { api_key: 'your_bitex_api_key_which_should_be_kept_safe', order_book: :btc_usd, sandbox: false }
+        bitex: { api_key: 'your_bitex_api_key_which_should_be_kept_safe', ssl_version: nil, debug: false, sandbox: false, order_book: 'btc_usd' }
       }.each do |market, market_settings|
         before(:each) { described_class.stub(taker: BitexBot::SettingsClass.new(taker_hash)) }
 

data/spec/factories/bitex_ask.rb

@@ -0,0 +1,14 @@
+FactoryBot.define do
+  factory :bitex_ask, class: Bitex::Ask do
+    id                 { 12_345_678 }
+    created_at         { Time.now }
+    order_book         { :btc_usd }
+    price              { 1_000.to_d }
+    status             { :received }
+    reason             { :not_cancelled }
+    issuer             { 'User#1' }
+    quantity           { 100.to_d }
+    remaining_quantity { 100.to_d }
+    produced_amount    { 10.to_d }
+  end
+end

data/spec/factories/bitex_bid.rb

@@ -0,0 +1,14 @@
+FactoryBot.define do
+  factory :bitex_bid, class: Bitex::Bid do
+    id                { 12_345_678 }
+    created_at        { Time.now }
+    order_book        { :btc_usd }
+    price             { 1_000.to_d }
+    status            { :received }
+    reason            { :not_cancelled }
+    issuer            { 'User#1' }
+    amount            { 100.to_d }
+    remaining_amount  { 100.to_d }
+    produced_quantity { 10.to_d }
+  end
+end

data/spec/factories/bitex_buy.rb

@@ -1,12 +1,12 @@
 FactoryBot.define do
   factory :bitex_buy, class: Bitex::Buy do
-    id 12345678
+    id         { 12_345_678 }
     created_at { Time.now }
-    order_book :btc_usd
-    quantity 2.0
-    amount 600.0
-    fee 0.05
-    price 300.0
-    bid_id 12345
+    order_book { :btc_usd }
+    quantity   { 2.0.to_d }
+    amount     { 600.0.to_d }
+    fee        { 0.05.to_d }
+    price      { 300.0.to_d }
+    bid_id     { 12_345 }
   end
 end

data/spec/factories/bitex_sell.rb

@@ -1,12 +1,12 @@
 FactoryBot.define do
   factory :bitex_sell, class: Bitex::Sell do
-    id 12345678
+    id         { 12_345_678 }
     created_at { Time.now }
-    order_book :btc_usd
-    quantity 2.0
-    amount 600.0
-    fee 0.05
-    price 300.0
-    ask_id 12345
+    order_book { :btc_usd }
+    quantity   { 2.0.to_d }
+    amount     { 600.0.to_d }
+    fee        { 0.05.to_d }
+    price      { 300.0.to_d }
+    ask_id     { 12_345 }
   end
 end