bitex_bot 0.3.7 → 0.4.0

data/lib/bitex_bot/models/order_book_simulator.rb

@@ -1,77 +1,72 @@
-# Simulates hitting an order-book to find a price at which an order can be
-# assumed to get executed completely.
-# It essentially drops the start of the order book, to account for price
-# volatility (assuming those orders may be taken by someone else), and then
-# digs until the given USD amount or BTC quantity are reached, finally returning
-# the last price seen, which is the 'safest' price at which we can expect this
-# order to get executed quickly.
-class BitexBot::OrderBookSimulator
-  
-  # @param volatility [Integer] How many seconds of recent volume we need to
-  #   skip from the start of the order book to be more certain that our order
-  #   will get executed.
-  # @param transactions [Hash] a list of hashes representing
-  #   all transactions in the other exchange. Each hash contains 'date', 'tid',
-  #   'price' and 'amount', where 'amount' is the BTC transacted.
-  # @param order_book [[price, quantity]] a list of lists representing the
-  #   order book to dig in.
-  # @param amount_target [BigDecimal] stop when this amount has been reached,
-  #   leave as nil if looking for a quantity_target.
-  # @param quantity_target [BigDecimal] stop when this quantity has been
-  #   reached, leave as nil if looking for an amount_target.
-  # @return [Decimal] Returns the price that we're more likely to get when
-  #   executing an order for the given amount or quantity.
-  def self.run(volatility, transactions, order_book,
-    amount_target, quantity_target)
+module BitexBot
+  # Simulates hitting an order-book to find a price at which an order can be assumed to get executed completely.
+  # It essentially drops the start of the order book, to account for price volatility (assuming those orders may be taken by
+  # someone else), and then digs until the given USD amount or BTC quantity are reached, finally returning the last price seen,
+  # which is the 'safest' price at which we can expect this order to get executed quickly.
+  #
+  class OrderBookSimulator
+    # @param volatility [Integer] How many seconds of recent volume we need to skip from the start of the order book to be more
+    #   certain that our order will get executed.
+    # @param transactions [Hash] a list of hashes representing all transactions in the other exchange:
+    #    Each hash contains 'date', 'tid', 'price' and 'amount', where 'amount' is the BTC transacted.
+    # @param order_book [[price, quantity]] a list of lists representing the order book to dig in.
+    # @param amount_target [BigDecimal] stop when this amount has been reached, leave as nil if looking for a quantity_target.
+    # @param quantity_target [BigDecimal] stop when this quantity has been reached, leave as nil if looking for an
+    #   amount_target.
+    # @return [Decimal] Returns the price that we're more likely to get when executing an order for the given amount or
+    #   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")
+      seen = 0
 
-    to_skip = estimate_quantity_to_skip(volatility, transactions)
-    BitexBot::Robot.logger.debug("Skipping #{to_skip} BTC")
-    seen = 0
-    safest_price = 0
-    
-    order_book.each do |price, quantity|
-      price = price.to_d
-      quantity = quantity.to_d
-      
-      # An order may be partially or completely skipped due to volatility.
-      if to_skip > 0
-        dropped = [quantity, to_skip].min
-        to_skip -= dropped
-        quantity -= dropped
-        BitexBot::Robot.logger.debug("Skipped #{dropped} BTC @ $#{price}")
-        next if quantity == 0
-      end
-      
-      if quantity_target
-        if quantity >= (quantity_target - seen)
-          BitexBot::Robot.logger.debug("Best price to get "\
-            "#{quantity_target} BTC is $#{price}")
-          return price
-        else
-          seen += quantity
+      order_book.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?
+          dropped = [quantity, to_skip].min
+          to_skip -= dropped
+          quantity -= dropped
+          Robot.log(:debug, "Skipped #{dropped} BTC @ $#{price}")
+          next if quantity.zero?
         end
-      elsif amount_target
-        amount = price * quantity
-        if amount >= (amount_target - seen)
-          BitexBot::Robot.logger.debug("Best price to get "\
-            "$#{amount_target} is $#{price}")
-          return price
-        else
+
+        if quantity_target.present?
+          return best_price('BTC', 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)
           seen += amount
         end
       end
+      order_book.last.price
     end
-    
-    return order_book.last.first.to_d
-  end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-private
+    # private class methods
+
+    def self.estimate_quantity_to_skip(volatility, transactions)
+      threshold = transactions.first.timestamp - volatility
+      transactions
+        .select { |t| t.timestamp > threshold }
+        .map { |t| t.amount.to_d }
+        .sum
+    end
+
+    def self.best_price?(volume, target, seen)
+      volume >= (target - seen)
+    end
+
+    def self.best_price(currency, target, price)
+      Robot.log(:debug, "Best price to get #{currency} #{target} is $#{price}")
+      price
+    end
 
-  def self.estimate_quantity_to_skip(volatility, transactions)
-    threshold = transactions.first.date.to_i - volatility
-    transactions
-      .select{|t| t.date.to_i > threshold}
-      .collect{|t| t.amount.to_d }
-      .sum
+    # end: private class methods
   end
 end

data/lib/bitex_bot/models/sell_closing_flow.rb

@@ -1,36 +1,41 @@
 module BitexBot
+  # It bought at Bitex and needs to close (sell) in the other market.
   class SellClosingFlow < ClosingFlow
     has_many :open_positions, class_name: 'OpenSell', foreign_key: :closing_flow_id
     has_many :close_positions, class_name: 'CloseSell', foreign_key: :closing_flow_id
-    scope :active, lambda { where(done: false) }
-    
+
+    scope :active, -> { where(done: false) }
+
     def self.open_position_class
       OpenSell
     end
 
-    def order_method
-      :buy
-    end
-      
-    # The amount received when selling initially, minus
-    # the amount spent re-buying the sold coins.
-    def get_usd_profit
-      open_positions.sum(:amount) - close_positions.sum(:amount)
+    private
+
+    # create_or_cancel! helpers
+    # The amount received when selling initially, minus the amount spent re-buying the sold coins.
+    def estimate_fiat_profit
+      open_positions.sum(:amount) - positions_balance_amount
     end
-    
-    # The coins we actually bought minus the coins we were supposed
-    # to re-buy
-    def get_btc_profit
+
+    # The coins we actually bought minus the coins we were supposed to re-buy.
+    def estimate_btc_profit
       close_positions.sum(:quantity) - quantity
     end
-    
-    def get_next_price_and_quantity
+
+    def next_price_and_quantity
       closes = close_positions
-      next_price = 
-        desired_price + ((closes.count * (closes.count * 3)) / 100.0)
-      next_quantity =
-        ((quantity * desired_price) - closes.sum(:amount)) / next_price
+      next_price = desired_price + price_variation(closes.count)
+      next_quantity = ((quantity * desired_price) - closes.sum(:amount)) / next_price
+
       [next_price, next_quantity]
     end
+    # end: create_or_cancel! helpers
+
+    # create_order_and_close_position helpers
+    def order_method
+      :buy
+    end
+    # end: create_order_and_close_position helpers
   end
 end

data/lib/bitex_bot/models/sell_opening_flow.rb

@@ -1,83 +1,76 @@
 module BitexBot
-  # A workflow for selling bitcoin in Bitex and buying on another exchange.  The
-  # SellOpeningFlow factory function estimates how much you could buy on the other
-  # exchange and calculates a reasonable price taking into account the remote
-  # orderbook and the recent operated volume.
+  # A workflow for selling bitcoin in Bitex and buying on another exchange. The SellOpeningFlow factory function estimates how
+  # much you could buy on the other exchange and calculates a reasonable price taking into account the remote order book and the
+  # recent operated volume.
   #
-  # When created, a SellOpeningFlow places an Ask on Bitex for the calculated
-  # quantity and price, when the Ask is matched on Bitex an OpenSell is
-  # created to buy the same quantity for a lower price on the other exchange.
+  # When created, a SellOpeningFlow places an Ask on Bitex for the calculated quantity and price, when the Ask is matched on
+  # Bitex an OpenSell is created to buy the same quantity for a lower price on the other exchange.
   #
-  # A SellOpeningFlow can be cancelled at any point, which will cancel the Bitex
-  # order and any orders on the remote exchange created from its OpenSell's
-  # 
-  # @attr order_id The first thing a SellOpeningFlow does is placing an Ask on Bitex,
-  #   this is its unique id. 
+  # A SellOpeningFlow can be cancelled at any point, which will cancel the Bitex order and any orders on the remote exchange
+  # created from its OpenSell's
+  #
+  # @attr order_id The first thing a SellOpeningFlow does is placing an Ask on Bitex, this is its unique id.
   class SellOpeningFlow < OpeningFlow
-    
-    # Start a workflow for selling bitcoin on bitex and buying on the other
-    # exchange. The quantity to be sold on bitex is retrieved from Settings, if
-    # there is not enough BTC on bitex or USD on the other exchange then no
-    # order will be placed and an exception will be raised instead.
-    # The amount a SellOpeningFlow will try to sell and the price it will try to
-    # charge are derived from these parameters:
-    # 
-    # @param usd_balance [BigDecimal] amount of usd available in the other
-    #   exchange that can be spent to balance this sale.
-    # @param order_book [[price, quantity]] a list of lists representing an ask
-    #   order book in the other exchange.
-    # @param transactions [Hash] a list of hashes representing
-    #   all transactions in the other exchange. Each hash contains 'date', 'tid',
-    #   'price' and 'amount', where 'amount' is the BTC transacted.
-    # @param bitex_fee [BigDecimal] the transaction fee to pay on bitex.
-    # @param other_fee [BigDecimal] the transaction fee to pay on the other
-    #   exchange.
+    # Start a workflow for selling bitcoin on bitex and buying on the other exchange. The quantity to be sold on bitex is
+    # retrieved from Settings, if there is not enough BTC on bitex or USD on the other exchange then no order will be placed and
+    # an exception will be raised instead.
+    # The amount a SellOpeningFlow will try to sell and the price it will try to charge are derived from these parameters:
+    #
+    # @param usd_balance [BigDecimal] amount of usd available in the other exchange that can be spent to balance this sale.
+    # @param order_book [[price, quantity]] a list of lists representing an ask order book in the other exchange.
+    # @param transactions [Hash] a list of hashes representing all transactions in the other exchange:
+    #   Each hash contains 'date', 'tid', 'price' and 'amount', where 'amount' is the BTC transacted.
+    # @param maker_fee [BigDecimal] the transaction fee to pay on our maker exchange.
+    # @param taker_fee [BigDecimal] the transaction fee to pay on the taker exchange.
     # @param store [Store] An updated config for this robot, mainly to use for profit.
     #
     # @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,
-      bitex_fee, other_fee, store)
+    # @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)
       super
     end
-    
+
+    # sync_open_positions helpers
+    def self.transaction_order_id(transaction)
+      transaction.ask_id
+    end
+
     def self.open_position_class
       OpenSell
     end
-    
+    # end: sync_open_positions helpers
+
+    # sought_transaction helpers
     def self.transaction_class
       Bitex::Sell
     end
-    
-    def self.transaction_order_id(transaction)
-      transaction.ask_id
+    # end: sought_transaction helpers
+
+    # create_for_market helpers
+    def self.maker_price(usd_to_spend_re_buying)
+      usd_to_spend_re_buying / value_to_use * (1 + profit / 100)
     end
 
     def self.order_class
       Bitex::Ask
     end
 
-    def self.value_to_use
-      store.selling_quantity_to_sell_per_order || Settings.selling.quantity_to_sell_per_order
-    end
-    
-    def self.get_safest_price(transactions, order_book, bitcoins_to_use)
-      OrderBookSimulator.run(Settings.time_to_live, transactions,
-        order_book, nil, bitcoins_to_use)
+    def self.profit
+      store.selling_profit || Settings.selling.profit
     end
-      
-    def self.get_remote_value_to_use(value_to_use_needed, safest_price)
+
+    def self.remote_value_to_use(value_to_use_needed, safest_price)
       value_to_use_needed * safest_price
     end
 
-    def self.profit
-      store.selling_profit || Settings.selling.profit
+    def self.safest_price(transactions, order_book, bitcoins_to_use)
+      OrderBookSimulator.run(Settings.time_to_live, transactions, order_book, nil, bitcoins_to_use)
     end
-    
-    def self.get_bitex_price(btc_to_sell, usd_to_spend_re_buying) 
-     (usd_to_spend_re_buying / btc_to_sell) * (1 + profit / 100.0)
+
+    def self.value_to_use
+      store.selling_quantity_to_sell_per_order || Settings.selling.quantity_to_sell_per_order
     end
+    # end: create_for_market helpers
   end
 end

data/lib/bitex_bot/models/store.rb

@@ -1,2 +1,4 @@
-class BitexBot::Store < ActiveRecord::Base
+module BitexBot
+  class Store < ActiveRecord::Base
+  end
 end