bitex_bot 0.3.7 → 0.4.0

data/lib/bitex_bot/robot.rb

@@ -1,241 +1,268 @@
-trap "INT" do
+trap 'INT' do
   if BitexBot::Robot.graceful_shutdown
     print "\b"
-    BitexBot::Robot.logger.info("Ok, ok, I'm out.")
+    BitexBot::Robot.log(:info, "Ok, ok, I'm out.")
     exit 1
   end
   BitexBot::Robot.graceful_shutdown = true
-  BitexBot::Robot.logger.info("Shutting down as soon as I've cleaned up.")
+  BitexBot::Robot.log(:info, "Shutting down as soon as I've cleaned up.")
 end
 
 module BitexBot
+  # Documentation here!
+  # rubocop:disable Metrics/ClassLength
   class Robot
+    extend Forwardable
+
+    cattr_accessor :taker
+
     cattr_accessor :graceful_shutdown
     cattr_accessor :cooldown_until
-    cattr_accessor :test_mode
-    cattr_accessor :taker do
-      case Settings.taker
-      when 'itbit'
-        ItbitApiWrapper
-      when 'bitstamp'
-        BitstampApiWrapper
-      when 'bitfinex'
-        BitfinexApiWrapper
-      when 'kraken'
-        KrakenApiWrapper
-      end
-    end
-    cattr_accessor :logger do
-      STDOUT.sync = true unless logdev = Settings.log.try(:file)
-      Logger.new(logdev || STDOUT, 10, 10240000).tap do |l|
-        l.level = Logger.const_get(Settings.log.level.upcase)
-        l.formatter = proc do |severity, datetime, progname, msg|
-          date = datetime.strftime("%m/%d %H:%M:%S.%L")
-          "#{ '%-6s' % severity } #{date}: #{msg}\n"
+    cattr_accessor(:current_cooldowns) { 0 }
+
+    cattr_accessor(:logger) do
+      logdev = Settings.log.try(:file)
+      STDOUT.sync = true unless logdev.present?
+      Logger.new(logdev || STDOUT, 10, 10_240_000).tap do |log|
+        log.level = Logger.const_get(Settings.log.level.upcase)
+        log.formatter = proc do |severity, datetime, _progname, msg|
+          date = datetime.strftime('%m/%d %H:%M:%S.%L')
+          "#{format('%-6s', severity)} #{date}: #{msg}\n"
         end
       end
     end
-    cattr_accessor :current_cooldowns do 0 end
-    
-    # Trade constantly respecting cooldown times so that we don't get
-    # banned by api clients.
+
+    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) }
+    end
+
+    # Trade constantly respecting cooldown times so that we don't get banned by api clients.
     def self.run!
-      setup
-      logger.info("Loading trading robot, ctrl+c *once* to exit gracefully.")
+      bot = start_robot
       self.cooldown_until = Time.now
-      bot = new
-      
-      while true
+      loop do
         start_time = Time.now
         next if start_time < cooldown_until
+
         self.current_cooldowns = 0
         bot.trade!
-        # This global sleep is so that we don't stress bitex too much.
-        sleep 0.3 unless test_mode
         self.cooldown_until = start_time + current_cooldowns.seconds
       end
     end
-    
-    def self.setup
-      Bitex.api_key = Settings.bitex
-      Bitex.sandbox = Settings.sandbox
-      taker.setup(Settings)
-    end
-  
-    def self.with_cooldown(&block)
-      result = block.call
-      return result if test_mode
+
+    def self.sleep_for(seconds)
+      sleep(seconds)
+    end
+    def_delegator self, :sleep_for
+
+    def self.log(level, message)
+      logger.send(level, message)
+    end
+    def_delegator self, :log
+
+    def self.with_cooldown
+      result = yield
       self.current_cooldowns += 1
-      sleep 0.1 
-      return result
+      sleep_for(0.1)
+      result
     end
 
-    def with_cooldown(&block)
-      self.class.with_cooldown(&block)
+    # private class methods
+
+    def self.start_robot
+      setup
+      log(:info, 'Loading trading robot, ctrl+c *once* to exit gracefully.')
+      new
     end
 
+    # end: private class methods
+
+    # rubocop:disable Metrics/AbcSize
     def trade!
       sync_opening_flows if active_opening_flows?
       finalise_some_opening_flows
-      if(!active_opening_flows? && !open_positions? &&
-        !active_closing_flows? && self.class.graceful_shutdown)
-        self.class.logger.info("Shutdown completed")
-        exit
-      end
+      shutdown! if shutdable?
       start_closing_flows if open_positions?
       sync_closing_flows if active_closing_flows?
       start_opening_flows_if_needed
     rescue CannotCreateFlow => e
-      self.notify("#{e.message}:\n\n#{e.backtrace.join("\n")}")
-      sleep (60 * 3) unless self.class.test_mode
+      notify("#{e.message}:\n\n#{e.backtrace.join("\n")}")
+      sleep_for(60 * 3)
     rescue Curl::Err::TimeoutError => e
-      self.class.logger.error("#{e.class} - #{e.message}:\n\n#{e.backtrace.join("\n")}")
-      sleep 15 unless self.class.test_mode
+      log(:error, "#{e.class} - #{e.message}:\n\n#{e.backtrace.join("\n")}")
+      sleep_for(15)
+    rescue OrderNotFound => e
+      notify("#{e.class} - #{e.message}:\n\n#{e.backtrace.join("\n")}")
+    rescue ApiWrapperError => e
+      notify("#{e.class} - #{e.message}:\n\n#{e.backtrace.join("\n")}")
+    rescue OrderArgumentError => e
+      notify("#{e.class} - #{e.message}:\n\n#{e.backtrace.join("\n")}")
     rescue StandardError => e
-      self.notify("#{e.class} - #{e.message}:\n\n#{e.backtrace.join("\n")}")
-      sleep 120 unless self.class.test_mode
+      notify("#{e.class} - #{e.message}:\n\n#{e.backtrace.join("\n")}")
+      sleep_for(60 * 2)
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def active_closing_flows?
+      [BuyClosingFlow.active, SellClosingFlow.active].any?(&:exists?)
+    end
+
+    def active_opening_flows?
+      [BuyOpeningFlow.active, SellOpeningFlow.active].any?(&:exists?)
+    end
+
+    # The trader has a Store
+    def store
+      @store ||= Store.first || Store.create
+    end
+
+    private
+
+    def with_cooldown(&block)
+      self.class.with_cooldown(&block)
+    end
+
+    def sync_opening_flows
+      [SellOpeningFlow, BuyOpeningFlow].each(&:sync_open_positions)
+    end
+
+    def shutdable?
+      !(active_flows? || open_positions?) && turn_off?
+    end
+
+    def shutdown!
+      log(:info, 'Shutdown completed')
+      exit
+    end
+
+    def active_flows?
+      active_opening_flows? || active_closing_flows?
+    end
+
+    def turn_off?
+      self.class.graceful_shutdown
     end
-    
+
     def finalise_some_opening_flows
-      [BuyOpeningFlow, SellOpeningFlow].each do |kind|
-        flows = self.class.graceful_shutdown ? kind.active : kind.old_active
-        flows.each{|flow| flow.finalise! }
-      end
+      [BuyOpeningFlow, SellOpeningFlow].each { |kind| active_flows(kind).each(&:finalise!) }
+    end
+
+    def active_flows(opening_flow_class)
+      turn_off? ? opening_flow_class.active : opening_flow_class.old_active
     end
-    
+
     def start_closing_flows
-      [BuyClosingFlow, SellClosingFlow].each{|kind| kind.close_open_positions}
+      [BuyClosingFlow, SellClosingFlow].each(&:close_open_positions)
     end
 
     def open_positions?
-      OpenBuy.open.exists? || OpenSell.open.exists?
+      [OpenBuy.open, OpenSell.open].any?(&:exists?)
     end
-    
+
     def sync_closing_flows
-      orders = with_cooldown{ BitexBot::Robot.taker.orders }
-      transactions = with_cooldown{ BitexBot::Robot.taker.user_transactions }
+      orders = with_cooldown { Robot.taker.orders }
+      transactions = with_cooldown { Robot.taker.user_transactions }
 
       [BuyClosingFlow, SellClosingFlow].each do |kind|
-        kind.active.each do |flow|
-          flow.sync_closed_positions(orders, transactions)
-        end
+        kind.active.each { |flow| flow.sync_closed_positions(orders, transactions) }
       end
     end
-    
-    def active_closing_flows?
-      BuyClosingFlow.active.exists? || SellClosingFlow.active.exists?
-    end
-    
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def start_opening_flows_if_needed
-      if store.reload.hold?
-        BitexBot::Robot.logger.debug("Not placing new orders because of hold")
-        return
-      end
-      
-      if active_closing_flows?
-        BitexBot::Robot.logger.debug("Not placing new orders, closing flows.")
-        return
-      end
-      
-      if self.class.graceful_shutdown
-        BitexBot::Robot.logger.debug("Not placing new orders, shutting down.")
-        return
-      end
-      
-      recent_buying, recent_selling =
-        [BuyOpeningFlow, SellOpeningFlow].collect do |kind|
-          threshold = (Settings.time_to_live / 2).seconds.ago
-          kind.active.where('created_at > ?', threshold).first
-        end
+      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, shutting down.') if turn_off?
 
-      if recent_buying && recent_selling
-        BitexBot::Robot.logger.debug("Not placing new orders, recent ones exist.")
-        return
-      end
-      
-      balances = with_cooldown{ BitexBot::Robot.taker.balance }
+      recent_buying, recent_selling = recent_operations
+      return log(:debug, 'Not placing new orders, recent ones exist.') if recent_buying && recent_selling
+
+      taker_balance = with_cooldown { Robot.taker.balance }
       profile = Bitex::Profile.get
-      
-      total_usd = balances['usd_balance'].to_d + profile[:usd_balance]
-      total_btc = balances['btc_balance'].to_d + profile[:btc_balance]
-      
-      last_log = `tail -c 61440 #{Settings.log.try(:file)}` if Settings.log.try(:file)
-  
-      store.update_attributes(taker_usd: balances['usd_balance'],
-        taker_btc: balances['btc_balance'], log: last_log)
-      
-      if store.last_warning.nil? || store.last_warning < 30.minutes.ago 
-        if store.usd_warning && total_usd <= store.usd_warning
-          notify("USD balance is too low, it's #{total_usd},"\
-            "make it #{store.usd_warning} to stop this warning.")
-          store.update_attributes(last_warning: Time.now)
-        end
+      total_fiat, total_btc = balances(taker_balance, profile)
 
-        if store.btc_warning && total_btc <= store.btc_warning
-          notify("BTC balance is too low, it's #{total_btc},"\
-            "make it #{store.btc_warning} to stop this warning.")
-          store.update_attributes(last_warning: Time.now)
-        end
-      end
+      sync_log(taker_balance)
+      check_balance_warning(total_fiat, total_btc) if expired_last_warning?
+      return log(:debug, "Not placing new orders, #{Settings.quote} target not met") if target_met?(:fiat, total_fiat)
+      return log(:debug, 'Not placing new orders, BTC target not met') if target_met?(:btc, total_btc)
 
-      if store.usd_stop && total_usd <= store.usd_stop
-        BitexBot::Robot.logger.debug("Not placing new orders, USD target not met")
-        return
-      end
-      if store.btc_stop && total_btc <= store.btc_stop
-        BitexBot::Robot.logger.debug("Not placing new orders, BTC target not met")
-        return
-      end
+      order_book = with_cooldown { Robot.taker.order_book }
+      transactions = with_cooldown { Robot.taker.transactions }
 
-      order_book = with_cooldown{ BitexBot::Robot.taker.order_book }
-      transactions = with_cooldown{ BitexBot::Robot.taker.transactions }
-      
-      unless recent_buying
-        BuyOpeningFlow.create_for_market(
-          balances['btc_available'].to_d,
-          order_book['bids'],
-          transactions,
-          profile[:fee],
-          balances['fee'].to_d,
-          store)
-      end
-      unless recent_selling
-        SellOpeningFlow.create_for_market(
-          balances['usd_available'].to_d,
-          order_book['asks'],
-          transactions,
-          profile[:fee],
-          balances['fee'].to_d,
-          store)
+      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
+    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
     end
-    
-    def sync_opening_flows
-      [SellOpeningFlow, BuyOpeningFlow].each{|o| o.sync_open_positions }
+
+    def balances(taker_balance, maker_balance)
+      total_fiat = maker_balance[:"#{Settings.quote}_balance"] + taker_balance.usd.total * Settings.fx_rate
+      total_btc = maker_balance[:btc_balance] + taker_balance.btc.total
+
+      [total_fiat, total_btc]
     end
-    
-    def active_opening_flows?
-      BuyOpeningFlow.active.exists? || SellOpeningFlow.active.exists?
-    end
-    
-    def notify(message)
-      self.class.logger.error(message)
-      if Settings.mailer
-        mail = Mail.new do
-          from Settings.mailer.from
-          to Settings.mailer.to
-          subject 'Notice from your robot trader'
-          body message
-        end
-        mail.delivery_method(Settings.mailer.delivery_method.to_sym,
-          Settings.mailer.options.to_hash)
-        mail.deliver!
+
+    def sync_log(taker_balance)
+      file = Settings.log.try(:file)
+      last_log = `tail -c 61440 #{file}` if file.present?
+      store.update(taker_fiat: taker_balance.usd.total * Settings.fx_rate, taker_btc: taker_balance.btc.total, log: last_log)
+    end
+
+    def expired_last_warning?
+      store.last_warning.nil? || store.last_warning < 30.minutes.ago
+    end
+
+    def check_balance_warning(total_fiat, total_btc)
+      notify_balance_warning(Settings.quote, total_fiat, store.fiat_warning) if balance_warning_notify?(:fiat, total_fiat)
+      notify_balance_warning(:btc, total_btc, store.btc_warning) if balance_warning_notify?(:btc, total_btc)
+    end
+
+    def balance_warning_notify?(currency, total)
+      store.send("#{currency}_warning").present? && total <= store.send("#{currency}_warning")
+    end
+
+    def target_met?(currency, total)
+      store.send("#{currency}_stop").present? && total <= store.send("#{currency}_stop")
+    end
+
+    def notify_balance_warning(currency, total, warning_amount)
+      notify("#{currency.upcase} balance is too low, it's #{total}, make it #{warning_amount} to stop this warning.")
+      store.update(last_warning: Time.now)
+    end
+
+    def notify(message, subj = 'Notice from your robot trader')
+      log(:error, message)
+      return unless Settings.mailer.present?
+
+      mail = new_mail(subj, message)
+      mail.delivery_method(Settings.mailer.delivery_method.to_sym, Settings.mailer.options.to_hash)
+      mail.deliver!
+    end
+
+    def new_mail(subj, message)
+      Mail.new do
+        from Settings.mailer.from
+        to Settings.mailer.to
+        subject subj
+        body message
       end
     end
 
-    # The trader has a Store
-    def store
-      @store ||= Store.first || Store.create
+    def create_buy_opening_flow(balance, order_book, transactions, profile)
+      BuyOpeningFlow.create_for_market(balance.btc.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.usd.available, order_book.asks, transactions, profile[:fee], balance.fee, store)
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/bitex_bot/settings.rb

@@ -1,37 +1,96 @@
 require 'hashie'
+require 'bigdecimal'
+require 'bigdecimal/util'
 
 module BitexBot
+  # Documentation here!
   class FileSettings < ::Hashie::Clash
-    def method_missing(name, *args)
-      return super unless args.size == 1 && args.none?
+    def method_missing(name, *args, &block)
+      return super unless args.none? && args.size == 1
       self[name] = args.first
     end
+
+    def respond_to_missing?(method_name, include_private = false)
+      respond_to?(method_name) || super
+    end
   end
 
+  # This class load settings file, else write a sample file.
   class SettingsClass < ::Hashie::Mash
     include ::Hashie::Extensions::Mash::SymbolizeKeys
 
+    def load_test
+      load_settings(sample_path)
+    end
+
     def load_default
       path = ARGV[0] || 'bitex_bot_settings.rb'
-      unless FileTest.exists?(path)
-        sample_path = File.expand_path('../../../settings.rb.sample', __FILE__)
-        FileUtils.cp(sample_path, path)
-        puts "No settings found, I've created a new one with sample "\
-          "values at #{path}. Please go ahead and edit it before running this again."
-        exit 1
-      end
+      show_sample(path) unless FileTest.exists?(path)
       load_settings(path)
     end
-    
-    def load_test
-      load_settings File.expand_path('../../../settings.rb.sample', __FILE__)
+
+    def fx_rate
+      Store.first.try(:fx_rate) || foreign_exchange_rate
+    end
+
+    def base
+      order_book_currencies[:base]
+    end
+
+    def quote
+      order_book_currencies[:quote]
+    end
+
+    def maker_class
+      exchange_class(maker)
+    end
+
+    def taker_class
+      exchange_class(taker)
+    end
+
+    def maker_settings
+      exchange_settings(maker)
+    end
+
+    def taker_settings
+      exchange_settings(taker)
     end
 
+    private
+
     def load_settings(path)
       file_settings = FileSettings.new
       file_settings.instance_eval(File.read(path), path, 1)
       merge!(file_settings)
     end
+
+    def sample_path
+      File.expand_path('../../settings.rb.sample', __dir__)
+    end
+
+    def show_sample(path)
+      FileUtils.cp(sample_path, path)
+      puts "No settings found, I've created a new one with sample values at #{path}. "\
+        'Please go ahead and edit it before running this again.'
+      exit 1
+    end
+
+    def order_book_currencies
+      {}.tap { |currencies| currencies[:base], currencies[:quote] = maker_settings.order_book.to_s.split('_') }
+    end
+
+    def exchange_name(exchange)
+      exchange.keys.pop
+    end
+
+    def exchange_class(exchange)
+      "#{exchange_name(exchange).capitalize}ApiWrapper".constantize
+    end
+
+    def exchange_settings(exchange)
+      exchange.send(exchange_name(exchange))
+    end
   end
 
   Settings = SettingsClass.new

data/lib/bitex_bot/version.rb

@@ -1,3 +1,3 @@
 module BitexBot
-  VERSION = "0.3.7"
+  VERSION = '0.4.0'
 end

data/lib/bitex_bot.rb

@@ -1,19 +1,32 @@
-require "bitex_bot/version"
+require 'bitex_bot/version'
+
+# Utilities
+require 'active_record'
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'forwardable'
 require 'hashie'
-require "active_record"
-require "mail"
-require "logger"
-require "bitex"
-require "bitstamp"
-require "itbit"
-require 'bitfinex'
-require "bitex_bot/settings"
-require "bitex_bot/database"
-require "bitex_bot/models/opening_flow.rb"
-require "bitex_bot/models/closing_flow.rb"
-Dir[File.dirname(__FILE__) + '/bitex_bot/models/*.rb'].each {|file| require file }
-require "bitex_bot/robot"
+require 'logger'
+require 'mail'
+
+# Traders Platforms
+require 'bitex'
+require 'bitstamp'
+require 'itbit'
+
+# BitexBot Models
+require 'bitex_bot/settings'
+require 'bitex_bot/database'
+require 'bitex_bot/models/api_wrappers/api_wrapper.rb'
+Dir[File.dirname(__FILE__) + '/bitex_bot/models/api_wrappers/**/*.rb'].each { |file| require file }
+require 'bitex_bot/models/opening_flow.rb'
+require 'bitex_bot/models/closing_flow.rb'
+Dir[File.dirname(__FILE__) + '/bitex_bot/models/*.rb'].each { |file| require file }
+require 'bitex_bot/robot'
 
+# #
+# Get version and bitex-bot as user-agent
+#
 module BitexBot
   def self.user_agent
     "Bitexbot/#{VERSION} (https://github.com/bitex-la/bitex-bot)"
@@ -21,6 +34,9 @@ module BitexBot
 end
 
 module Bitex
+  # #
+  # Set bitex-bot user-agent on request.
+  #
   module WithUserAgent
     def grab_curl
       super.tap do |curl|
@@ -29,6 +45,9 @@ module Bitex
     end
   end
 
+  ##
+  # Mixing to include request behaviour and set user-agent.
+  #
   class Api
     class << self
       prepend WithUserAgent
@@ -36,14 +55,19 @@ module Bitex
   end
 end
 
-# Itbit and Bitstamp
 module RestClient
+  # #
+  # On Itbit and Bitstamp, the mechanism to set bitex-bot user-agent are different.
+  #
   module WithUserAgent
     def default_headers
-      super.merge(:user_agent => BitexBot.user_agent)
+      super.merge(user_agent: BitexBot.user_agent)
     end
   end
 
+  ##
+  # Mixing to include request behaviour and set user-agent.
+  #
   class Request
     prepend WithUserAgent
   end