bitex_bot 0.3.7 → 0.4.0

data/lib/bitex_bot/models/closing_flow.rb

@@ -1,106 +1,125 @@
 module BitexBot
+  # Close buy/sell positions.
   class ClosingFlow < ActiveRecord::Base
     self.abstract_class = true
 
-    # Start a new CloseBuy that closes exising OpenBuy's by selling
-    # on another exchange what was just bought on bitex.
+    cattr_reader(:close_time_to_live) { 30 }
+
+    # Start a new CloseBuy that closes exising OpenBuy's by selling on another exchange what was just bought on bitex.
     def self.close_open_positions
       open_positions = open_position_class.open
       return if open_positions.empty?
 
-      quantity = open_positions.collect(&:quantity).sum
-      amount = open_positions.collect(&:amount).sum
-      suggested_amount = open_positions.collect do |open|
-        open.quantity * open.opening_flow.suggested_closing_price
-      end.sum
-      price = suggested_amount / quantity
+      quantity = open_positions.map(&:quantity).sum
+      amount = open_positions.map(&:amount).sum
+      price = suggested_amount(open_positions) / quantity
 
       # Don't even bother trying to close a position that's too small.
-      return if quantity * price < minimum_amount_for_closing
-
-      flow = create!(
-        desired_price: price,
-        quantity: quantity,
-        amount: amount,
-        open_positions: open_positions)
-      
-      flow.create_initial_order_and_close_position
-      
-      return flow
+      return unless Robot.taker.enough_order_size?(quantity, price)
+      create_closing_flow!(price, quantity, amount, open_positions)
     end
-    
-    def create_initial_order_and_close_position
-      create_order_and_close_position(quantity, desired_price)
+
+    # close_open_positions helpers
+    def self.suggested_amount(positions)
+      positions.map { |p| p.quantity * p.opening_flow.suggested_closing_price }.sum
     end
 
-    def create_order_and_close_position(quantity, price)
-      order = BitexBot::Robot.taker.place_order(
-        order_method, price, quantity)
-      if order.nil? || order.id.nil?
-        Robot.logger.error("Closing: Error on #{order_method} for "\
-          "#{self.class.name} ##{id} #{quantity} BTC @ $#{price}."\
-          "#{order.to_s}")
-        return
-      end
-      Robot.logger.info("Closing: Going to #{order_method} ##{order.id} for "\
-        "#{self.class.name} ##{id} #{order.amount} BTC @ $#{order.price}")
-      close_positions.create!(order_id: order.id)
+    def self.create_closing_flow!(price, quantity, amount, open_positions)
+      create!(desired_price: price, quantity: quantity, amount: amount, open_positions: open_positions)
+        .create_initial_order_and_close_position!
+      nil
     end
+    # end: close_open_positions helpers
 
+    def create_initial_order_and_close_position!
+      create_order_and_close_position(quantity, desired_price)
+    end
+
+    # TODO: should receive a order_ids and user_transaccions array, then each Wrapper should know how to search for them.
     def sync_closed_positions(orders, transactions)
-      latest_close = close_positions.last
+      # Maybe we couldn't create the bitstamp order when this flow was created, so we try again when syncing.
+      latest_close.nil? ? create_initial_order_and_close_position! : create_or_cancel!(orders, transactions)
+    end
 
-      # Maybe we couldn't create the bitstamp order when this flow
-      # was created, so we try again when syncing.
-      if latest_close.nil?
-        create_initial_order_and_close_position
-        return
-      end
+    def estimate_fiat_profit
+      raise 'self subclass responsibility'
+    end
+
+    def positions_balance_amount
+      close_positions.sum(:amount) * Settings.fx_rate
+    end
+
+    private
 
+    # sync_closed_positions helpers
+    # rubocop:disable Metrics/AbcSize
+    # Metrics/AbcSize: Assignment Branch Condition size for create_or_cancel! is too high. [17.23/16]
+    def create_or_cancel!(orders, transactions)
       order_id = latest_close.order_id.to_s
-      order = orders.find{|x| x.id.to_s == order_id }
+      order = orders.find { |o| o.id.to_s == order_id }
 
-      # When ask is nil it means the other exchange is done executing it
-      # so we can now have a look of all the sales that were spawned from it.
+      # When order is nil it means the other exchange is done executing it so we can now have a look of all the sales that were
+      # spawned from it.
       if order.nil?
-        latest_close.amount, latest_close.quantity =
-          BitexBot::Robot.taker.amount_and_quantity(order_id, transactions)
-        latest_close.save!
-        
-        next_price, next_quantity = get_next_price_and_quantity
-        if (next_quantity * next_price) > self.class.minimum_amount_for_closing
-          create_order_and_close_position(next_quantity, next_price)
-        else
-          self.btc_profit = get_btc_profit
-          self.usd_profit = get_usd_profit
-          self.done = true
-          Robot.logger.info("Closing: Finished #{self.class.name} ##{id} "\
-            "earned $#{self.usd_profit} and #{self.btc_profit} BTC. ")
-          save!
-        end
-      elsif latest_close.created_at < self.class.close_time_to_live.seconds.ago
-        Robot.with_cooldown do
-          begin
-            Robot.logger.debug("Finalising #{order.class}##{order.id}")
-            order.cancel!
-            Robot.logger.debug("Finalised #{order.class}##{order.id}")
-          rescue StandardError => e
-            nil # just pass, we'll keep on trying until it's not in orders anymore.
-          end
-        end
+        sync_position(order_id, transactions)
+        create_next_position!
+      elsif latest_close.created_at < close_time_to_live.seconds.ago
+        cancel!(order)
       end
     end
-    
-    # When placing a closing order we need to be aware of the smallest order
-    # amount permitted by the other exchange.
-    # If the other order is less than this USD amount then we do not attempt
-    # to close the positions yet.
-    def self.minimum_amount_for_closing
-      5
+    # rubocop:enable Metrics/AbcSize
+
+    def latest_close
+      close_positions.last
+    end
+    # end: sync_closed_positions helpers
+
+    # create_or_cancel! helpers
+    def cancel!(order)
+      Robot.with_cooldown do
+        Robot.log(:debug, "Finalising #{order.class}##{order.id}")
+        order.cancel!
+        Robot.log(:debug, "Finalised #{order.class}##{order.id}")
+      end
+    rescue StandardError => error
+      Robot.log(:debug, error)
+      nil # just pass, we'll keep on trying until it's not in orders anymore.
+    end
+
+    # This use hooks methods, these must be defined in the subclass:
+    #   estimate_btc_profit
+    #   amount_positions_balance
+    #   next_price_and_quantity
+    def create_next_position!
+      next_price, next_quantity = next_price_and_quantity
+      if Robot.taker.enough_order_size?(next_quantity, next_price)
+        create_order_and_close_position(next_quantity, next_price)
+      else
+        update!(btc_profit: estimate_btc_profit, fiat_profit: estimate_fiat_profit, fx_rate: Settings.fx_rate, done: true)
+        Robot.logger.info("Closing: Finished #{self.class.name} ##{id} earned $#{fiat_profit} and #{btc_profit} BTC.")
+      end
     end
-    
-    def self.close_time_to_live
-      30
+
+    def sync_position(order_id, transactions)
+      latest = latest_close
+      latest.amount, latest.quantity = Robot.taker.amount_and_quantity(order_id, transactions)
+      latest.save!
+    end
+    # end: create_or_cancel! helpers
+
+    # next_price_and_quantity helpers
+    def price_variation(closes_count)
+      closes_count**2 * 0.03
+    end
+    # end: next_price_and_quantity helpers
+
+    # This use hooks methods, these must be defined in the subclass:
+    #   order_method
+    def create_order_and_close_position(quantity, price)
+      # TODO: investigate how to generate an ID to insert in the fields of goals where possible.
+      Robot.log(:info, "Closing: Going to place #{order_method} order for #{self.class.name} ##{id} #{quantity} BTC @ $#{price}")
+      order = Robot.taker.place_order(order_method, price, quantity)
+      close_positions.create!(order_id: order.id)
     end
   end
 end

data/lib/bitex_bot/models/open_buy.rb

@@ -1,11 +1,12 @@
-# An OpenBuy represents a Buy transaction on Bitex.
-# OpenBuys are open buy positions that are closed by one or several
-# CloseBuys 
-# TODO: document attributes.
-class BitexBot::OpenBuy < ActiveRecord::Base
-  belongs_to :opening_flow, class_name: 'BuyOpeningFlow',
-    foreign_key: :opening_flow_id
-  belongs_to :closing_flow, class_name: 'BuyClosingFlow',
-    foreign_key: :closing_flow_id
-  scope :open, lambda{ where('closing_flow_id IS NULL') }
+module BitexBot
+  # An OpenBuy represents a Buy transaction on Bitex.
+  # OpenBuys are open buy positions that are closed by one or several CloseBuys.
+  # TODO: document attributes.
+  #
+  class OpenBuy < ActiveRecord::Base
+    belongs_to :opening_flow, class_name: 'BuyOpeningFlow', foreign_key: :opening_flow_id
+    belongs_to :closing_flow, class_name: 'BuyClosingFlow', foreign_key: :closing_flow_id
+
+    scope :open, -> { where('closing_flow_id IS NULL') }
+  end
 end

data/lib/bitex_bot/models/open_sell.rb

@@ -1,11 +1,12 @@
-# An OpenSell represents a Sell transaction on Bitex.
-# OpenSells are open sell positions that are closed by one
-# SellClosingFlow
-# TODO: document attributes.
-class BitexBot::OpenSell < ActiveRecord::Base
-  belongs_to :opening_flow, class_name: 'SellOpeningFlow',
-    foreign_key: :opening_flow_id
-  belongs_to :closing_flow, class_name: 'SellClosingFlow',
-    foreign_key: :closing_flow_id
-  scope :open, lambda{ where('closing_flow_id IS NULL') }
+module BitexBot
+  # An OpenSell represents a Sell transaction on Bitex.
+  # OpenSells are open sell positions that are closed by one SellClosingFlow.
+  # TODO: document attributes.
+  #
+  class OpenSell < ActiveRecord::Base
+    belongs_to :opening_flow, class_name: 'SellOpeningFlow', foreign_key: :opening_flow_id
+    belongs_to :closing_flow, class_name: 'SellClosingFlow', foreign_key: :closing_flow_id
+
+    scope :open, -> { where('closing_flow_id IS NULL') }
+  end
 end

data/lib/bitex_bot/models/opening_flow.rb

@@ -1,127 +1,185 @@
 module BitexBot
   # Any arbitrage workflow has 2 stages, opening positions and then closing them.
-  # The OpeningFlow stage places an order on bitex, detecting and storing all
-  # transactions spawn from that order as Open positions.
+  # The OpeningFlow stage places an order on bitex, detecting and storing all transactions spawn from that order as
+  # Open positions.
   class OpeningFlow < ActiveRecord::Base
     self.abstract_class = true
 
     # The updated config store as passed from the robot
     cattr_accessor :store
-    
+
+    # @!group Statuses
+    # All possible flow statuses
+    # @return [Array<String>]
+    cattr_accessor(:statuses) { %w[executing settling finalised] }
+
     def self.active
-      where('status != "finalised"')
+      where.not(status: :finalised)
     end
-    
+
     def self.old_active
-      where('status != "finalised" AND created_at < ?',
-        Settings.time_to_live.seconds.ago)
+      active.where('created_at < ?', Settings.time_to_live.seconds.ago)
     end
+    # @!endgroup
 
-    # @!group Statuses
+    # This use hooks methods, these must be defined in the subclass:
+    #   #maker_price
+    #   #order_class
+    #   #remote_value_to_use
+    #   #safest_price
+    #   #value_to_use
+    # rubocop:disable Metrics/AbcSize
+    def self.create_for_market(remote_balance, order_book, transactions, maker_fee, taker_fee, store)
+      self.store = store
 
-    # All possible flow statuses
-    # @return [Array<String>]
-    def self.statuses
-      %w(executing settling finalised)
+      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)
+
+      bitex_price = maker_price(remote_value) * Settings.fx_rate
+      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)
+
+      Robot.log(
+        :info,
+        "Opening: Placed #{order_class.name} ##{order.id} #{value_to_use} @ #{Settings.quote.upcase} #{bitex_price}"\
+        " (#{remote_value})"
+      )
+
+      create!(
+        price: bitex_price,
+        value_to_use: value_to_use,
+        suggested_closing_price: safest_price,
+        status: 'executing',
+        order_id: order.id
+      )
+    rescue StandardError => e
+      raise CannotCreateFlow, e.message
     end
+    # rubocop:enable Metrics/AbcSize
 
-    # The Bitex order has been placed, its id stored as order_id.
-    def executing?; status == 'executing'; end
+    # create_for_market helpers
+    def self.calc_remote_value(maker_fee, taker_fee, order_book, 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)
+      remote_value = remote_value_to_use(value_to_use_needed, safest_price)
 
-    # In process of cancelling the Bitex order and any other outstanding order in the
-    # other exchange.
-    def settling?; status == 'settling'; end
+      [remote_value, safest_price]
+    end
 
-    # Successfully settled or finished executing.
-    def finalised?; status == 'finalised'; end
-    # @!endgroup
+    def self.create_order!(bitex_price)
+      order_class.create!(Settings.maker_settings.order_book, value_to_use, bitex_price, true)
+    rescue StandardError => e
+      raise CannotCreateFlow, e.message
+    end
 
-    validates :status, presence: true, inclusion: {in: statuses}
-    validates :order_id, presence: true
-    validates_presence_of :price, :value_to_use
+    def self.enough_funds?(order)
+      !order.reason.to_s.inquiry.not_enough_funds?
+    end
 
-    def self.create_for_market(remote_balance, order_book, transactions,
-      bitex_fee, other_fee, store)
+    def self.enough_remote_funds?(remote_balance, remote_value)
+      remote_balance >= remote_value
+    end
 
-      self.store = store
+    def self.maker_plus(fee)
+      value_to_use * fee / 100
+    end
+    # end: create_for_market helpers
 
-      plus_bitex = value_to_use + (value_to_use * bitex_fee / 100.0)
-      value_to_use_needed = plus_bitex / (1 - other_fee / 100.0)
-      
-      safest_price = get_safest_price(transactions, order_book,
-        value_to_use_needed)
-
-      remote_value_to_use = get_remote_value_to_use(value_to_use_needed, safest_price)
-      
-      if remote_value_to_use > remote_balance
-        raise CannotCreateFlow.new(
-          "Needed #{remote_value_to_use} but you only have #{remote_balance}")
-      end
-
-      bitex_price = get_bitex_price(value_to_use, remote_value_to_use)      
-
-      begin 
-        order = order_class.create!(:btc, value_to_use, bitex_price, true)
-      rescue StandardError => e
-        raise CannotCreateFlow.new(e.message)
-      end
-
-      if order.reason == :not_enough_funds
-        raise CannotCreateFlow.new(
-          "You need to have #{value_to_use} on bitex to place this
-          #{order_class.name}.")
-      end
-
-      Robot.logger.info("Opening: Placed #{order_class.name} ##{order.id} " \
-        "#{value_to_use} @ $#{bitex_price} (#{remote_value_to_use})")
-
-      begin 
-        self.create!(price: bitex_price, value_to_use: value_to_use,
-          suggested_closing_price: safest_price, status: 'executing', order_id: order.id)
-      rescue StandardError => e
-        raise CannotCreateFlow.new(e.message)
-      end
-    end
-
-    # Buys on bitex represent open positions, we mirror them locally
-    # so that we can plan on how to close them.
+    # Buys on bitex represent open positions, we mirror them locally so that we can plan on how to close them.
+    # This use hooks methods, these must be defined in the subclass:
+    #   #transaction_order_id(transaction)
+    #   #open_position_class
     def self.sync_open_positions
-      threshold = open_position_class
-        .order('created_at DESC').first.try(:created_at)
-      Bitex::Trade.all.collect do |transaction|
-        next unless transaction.is_a?(transaction_class)
-        next if threshold && transaction.created_at < (threshold - 30.minutes)
-        next if open_position_class.find_by_transaction_id(transaction.id)
-        next if transaction.specie != :btc
-        next unless flow = find_by_order_id(transaction_order_id(transaction))
-        Robot.logger.info("Opening: #{name} ##{flow.id} "\
-          "was hit for #{transaction.quantity} BTC @ $#{transaction.price}")
-        open_position_class.create!(
-          transaction_id: transaction.id,
-          price: transaction.price,
-          amount: transaction.amount,
-          quantity: transaction.quantity,
-          opening_flow: flow)
+      threshold = open_position_class.order('created_at DESC').first.try(:created_at)
+      Bitex::Trade.all.map do |transaction|
+        next if sought_transaction?(threshold, transaction)
+
+        flow = find_by_order_id(transaction_order_id(transaction))
+        next unless flow.present?
+
+        create_open_position!(transaction, flow)
       end.compact
     end
-    
+
+    # sync_open_positions helpers
+    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}"
+      )
+      open_position_class.create!(
+        transaction_id: transaction.id,
+        price: transaction.price,
+        amount: transaction.amount,
+        quantity: transaction.quantity,
+        opening_flow: flow
+      )
+    end
+
+    # This use hooks methods, these must be defined in the subclass:
+    #   #transaction_class
+    def self.sought_transaction?(threshold, transaction)
+      !transaction.is_a?(transaction_class) ||
+        active_transaction?(transaction, threshold) ||
+        open_position?(transaction) ||
+        !expected_order_book?(transaction)
+    end
+    # end: sync_open_positions helpers
+
+    # sought_transaction helpers
+    def self.active_transaction?(transaction, threshold)
+      threshold && transaction.created_at < (threshold - 30.minutes)
+    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
+    end
+    # end: sought_transaction helpers
+
+    validates :status, presence: true, inclusion: { in: statuses }
+    validates :order_id, presence: true
+    validates_presence_of :price, :value_to_use
+
+    # Statuses:
+    #   executing: The Bitex order has been placed, its id stored as order_id.
+    #   setting: In process of cancelling the Bitex order and any other outstanding order in the other exchange.
+    #   finalised: Successfully settled or finished executing.
+    statuses.each do |status_name|
+      define_method("#{status_name}?") { status == status_name }
+      define_method("#{status_name}!") { update!(status: status_name) }
+    end
+
     def finalise!
       order = self.class.order_class.find(order_id)
-      if order.status == :cancelled || order.status == :completed
-        Robot.logger.info(
-          "Opening: #{self.class.order_class.name} ##{order_id} finalised.")
-        self.status = 'finalised'
-        save!
-      else
-        order.cancel!
-        unless settling?
-          self.status = 'settling'
-          save!
-        end
-      end
-    end
-  end   
-
-  # @visibility private
+      canceled_or_completed?(order) ? do_finalize : do_cancel(order)
+    end
+
+    private
+
+    # finalise! helpers
+    def canceled_or_completed?(order)
+      %i[cancelled completed].any? { |status| order.status == status }
+    end
+
+    def do_finalize
+      Robot.log(:info, "Opening: #{self.class.order_class.name} ##{order_id} finalised.")
+      finalised!
+    end
+
+    def do_cancel(order)
+      Robot.log(:info, "Opening: #{self.class.order_class.name} ##{order_id} canceled.")
+      order.cancel!
+      settling! unless settling?
+    end
+    # end: finalise! helpers
+  end
+
   class CannotCreateFlow < StandardError; end
 end