bitex_bot 0.3.7 → 0.4.0

data/lib/bitex_bot/models/api_wrappers/itbit/itbit_api_wrapper.rb

@@ -0,0 +1,116 @@
+# Wrapper implementation for Itbit API.
+# https://api.itbit.com/docs
+class ItbitApiWrapper < ApiWrapper
+  def self.setup(settings)
+    Itbit.tap do |conf|
+      conf.client_key = settings.client_key
+      conf.secret = settings.secret
+      conf.user_id = settings.user_id
+      conf.default_wallet_id = settings.default_wallet_id
+      conf.sandbox = settings.sandbox
+    end
+  end
+
+  def self.amount_and_quantity(order_id, _transactions)
+    order = Itbit::Order.find(order_id)
+    amount = order.volume_weighted_average_price * order.amount_filled
+    quantity = order.amount_filled
+
+    [amount, quantity]
+  end
+
+  def self.balance
+    balance_summary_parser(wallet[:balances])
+  end
+
+  def self.find_lost(type, price, _quantity)
+    orders.find { |o| o.type == type && o.price == price && o.timestamp >= 5.minutes.ago.to_i }
+  end
+
+  def self.order_book
+    order_book_parser(Itbit::XBTUSDMarketData.orders)
+  end
+
+  def self.orders
+    Itbit::Order.all(status: :open).map { |o| order_parser(o) }
+  end
+
+  def self.place_order(type, price, quantity)
+    Itbit::Order.create!(type, :xbtusd, quantity.round(4), price.round(2), wait: true)
+  rescue RestClient::RequestTimeout => e
+    # On timeout errors, we still look for the latest active closing order that may be available.
+    # We have a magic threshold of 5 minutes and also use the price to recognize an order as the current one.
+    # TODO: Maybe we can identify the order using metadata instead of price.
+    BitexBot::Robot.log(:error, 'Captured Timeout on itbit')
+    latest = last_order_by(price)
+    return latest if latest.present?
+
+    BitexBot::Robot.log(:error, 'Could not find my order')
+    raise e
+  end
+
+  def self.transactions
+    Itbit::XBTUSDMarketData.trades.map { |t| transaction_parser(t.symbolize_keys) }
+  end
+
+  # We don't need to fetch the list of transaction for itbit since we wont actually use them later.
+  def self.user_transactions
+    []
+  end
+
+  private_class_method
+
+  # [
+  #   { total_balance: 0.2e2, currency: :usd, available_balance: 0.1e2 },
+  #   { total_balance: 0.0, currency: :xbt, available_balance: 0.0 },
+  #   { total_balance: 0.0, currency: :eur, available_balance: 0.0 },
+  #   { total_balance: 0.0, currency: :sgd, available_balance: 0.0 }
+  # ]
+  def self.balance_summary_parser(balances)
+    BalanceSummary.new(balance_parser(balances, :xbt), balance_parser(balances, :usd), 0.5.to_d)
+  end
+
+  def self.wallet
+    Itbit::Wallet.all.find { |w| w[:id] == Itbit.default_wallet_id }
+  end
+
+  def self.balance_parser(balances, currency)
+    currency_balance = balances.find { |balance| balance[:currency] == currency }
+    Balance.new(
+      currency_balance[:total_balance].to_d,
+      currency_balance[:total_balance].to_d - currency_balance[:available_balance].to_d,
+      currency_balance[:available_balance].to_d
+    )
+  end
+
+  def self.last_order_by(price)
+    Itbit::Order.all.select { |o| o.price == price && (o.created_time - Time.now.to_i).abs < 500 }.first
+  end
+
+  # {
+  #   bids: [[0.63921e3, 0.195e1], [0.637e3, 0.47e0], [0.63e3, 0.158e1]],
+  #   asks: [[0.6424e3, 0.4e0], [0.6433e3, 0.95e0], [0.6443e3, 0.25e0]]
+  # }
+  def self.order_book_parser(book)
+    OrderBook.new(Time.now.to_i, order_summary_parser(book[:bids]), order_summary_parser(book[:asks]))
+  end
+
+  def self.order_summary_parser(orders)
+    orders.map { |order| OrderSummary.new(order[0], order[1]) }
+  end
+
+  # <Itbit::Order:
+  #   @id='8fd820d3-baff-4d6f-9439-ff03d816c7ce', @wallet_id='b440efce-a83c-4873-8833-802a1022b476', @side=:buy,
+  #   @instrument=:xbtusd, @type=:limit, @amount=0.1005e1, @display_amount=0.1005e1, @price=0.1e3,
+  #   @volume_weighted_average_price=0.0, @amount_filled=0.0, @created_time=1415290187, @status=:open,
+  #   @metadata={foo: 'bar'}, @client_order_identifier='o'
+  # >
+  def self.order_parser(order)
+    Order.new(order.id, order.side, order.price, order.amount, order.created_time, order)
+  end
+
+  # { tid: 601855, price: 0.41814e3, amount: 0.19e-1, date: 1460161126 }
+  def self.transaction_parser(transaction)
+    Transaction.new(transaction[:tid], transaction[:price], transaction[:amount], transaction[:date])
+  end
+end

data/lib/bitex_bot/models/api_wrappers/kraken/kraken_api_wrapper.rb

@@ -0,0 +1,111 @@
+# Wrapper implementation for Kraken API.
+# https://www.kraken.com/en-us/help/api
+class KrakenApiWrapper < ApiWrapper
+  MIN_AMOUNT = 0.002
+
+  def self.setup(settings)
+    HTTParty::Basement.headers('User-Agent' => BitexBot.user_agent)
+    @settings = settings
+  end
+
+  def self.client
+    @client ||= KrakenClient.load(@settings)
+  end
+
+  def self.amount_and_quantity(order_id, _transactions)
+    KrakenOrder.amount_and_quantity(order_id)
+  end
+
+  def self.balance
+    balance_summary_parser(client.private.balance)
+  rescue KrakenClient::ErrorResponse, Net::ReadTimeout
+    retry
+  end
+
+  def self.enough_order_size?(quantity, _price)
+    quantity >= MIN_AMOUNT
+  end
+
+  def self.find_lost(type, price, quantity)
+    KrakenOrder.find_lost(type, price, quantity)
+  end
+
+  def self.order_book
+    order_book_parser(client.public.order_book('XBTUSD')[:XXBTZUSD])
+  rescue NoMethodError
+    retry
+  end
+
+  def self.orders
+    KrakenOrder.open.map { |ko| order_parser(ko) }
+  end
+
+  def self.send_order(type, price, quantity)
+    KrakenOrder.create!(type, price, quantity)
+  end
+
+  def self.transactions
+    client.public.trades('XBTUSD')[:XXBTZUSD].reverse.map { |t| transaction_parser(t) }
+  rescue NoMethodError
+    retry
+  end
+
+  # We don't need to fetch the list of transactions for Kraken
+  def self.user_transactions
+    []
+  end
+
+  private_class_method
+
+  # { ZEUR: '1433.0939', XXBT: '0.0000000000', 'XETH': '99.7497224800' }
+  def self.balance_summary_parser(balances)
+    open_orders = KrakenOrder.open
+    BalanceSummary.new(
+      balance_parser(balances, :XXBT, btc_reserved(open_orders)),
+      balance_parser(balances, :ZUSD, usd_reserved(open_orders)),
+      client.private.trade_volume(pair: 'XBTUSD')[:fees][:XXBTZUSD][:fee].to_d
+    )
+  end
+
+  def self.balance_parser(balances, currency, reserved)
+    Balance.new(balances[currency].to_d, reserved, balances[currency].to_d - reserved)
+  end
+
+  def self.btc_reserved(open_orders)
+    orders_by(open_orders, :sell).map { |o| (o.amount - o.executed_amount).to_d }.sum
+  end
+
+  def self.usd_reserved(open_orders)
+    orders_by(open_orders, :buy).map { |o| (o.amount - o.executed_amount) * o.price.to_d }.sum
+  end
+
+  def self.orders_by(open_orders, order_type)
+    open_orders.select { |o| o.type == order_type }
+  end
+
+  # {
+  #   'asks': [['204.52893', '0.010', 1440291148], ['204.78790', '0.312', 1440291132]],
+  #   'bids': [['204.24000', '0.100', 1440291016], ['204.23010', '0.312', 1440290699]]
+  # }
+  def self.order_book_parser(book)
+    OrderBook.new(Time.now.to_i, order_summary_parser(book[:bids]), order_summary_parser(book[:asks]))
+  end
+
+  def self.order_summary_parser(stock_market)
+    stock_market.map { |stock| OrderSummary.new(stock[0].to_d, stock[1].to_d) }
+  end
+
+  # <KrakenOrder: @id='O5TDV2-WDYB2-6OGJRD', @type=:buy, @price='1.01', @amount='1.00000000', @datetime='2013-09-26 23:15:04'>
+  def self.order_parser(order)
+    Order.new(order.id.to_s, order.type, order.price, order.amount, order.datetime, order)
+  end
+
+  # [
+  #   ['price', 'amount', 'timestamp', 'buy/sell', 'market/limit', 'miscellaneous']
+  #   ['202.51626', '0.01440000', 1440277319.1922, 'b', 'l', ''],
+  #   ['202.54000', '0.10000000', 1440277322.8993, 'b', 'l', '']
+  # ]
+  def self.transaction_parser(transaction)
+    Transaction.new(transaction[2].to_i, transaction[0].to_d, transaction[1].to_d, transaction[2].to_i)
+  end
+end

data/lib/bitex_bot/models/api_wrappers/kraken/kraken_order.rb

@@ -0,0 +1,117 @@
+require 'kraken_client'
+
+# Wrapper for Kraken orders.
+class KrakenOrder
+  cattr_accessor :last_closed_order
+  attr_accessor :id, :amount, :executed_amount, :price, :avg_price, :type, :datetime
+
+  # rubocop:disable Metrics/AbcSize
+  def self.create!(type, price, quantity)
+    self.last_closed_order = closed.first.try(:id) || Time.now.to_i
+    find(order_info_by(type, price.truncate(1), quantity.truncate(8))['txid'].first)
+  rescue KrakenClient::ErrorResponse => e
+    # Order could not be placed
+    if e.message == 'EService:Unavailable'
+      BitexBot::Robot.log(:debug, 'Captured EService:Unavailable error when placing order on Kraken. Retrying...')
+      retry
+    elsif e.message.start_with?('EGeneral:Invalid')
+      BitexBot::Robot.log(:debug, "Captured #{e.message}: type: #{type}, price: #{price}, quantity: #{quantity}")
+      raise OrderArgumentError, e.message
+    elsif e.message != 'error'
+      raise
+    end
+  end
+  # rubocop:enable Metrics/AbcSize
+
+  def self.order_info_by(type, price, quantity)
+    KrakenApiWrapper.client.private.add_order(pair: 'XBTUSD', type: type, ordertype: 'limit', price: price, volume: quantity)
+  end
+
+  def self.find(id)
+    new(*KrakenApiWrapper.client.private.query_orders(txid: id).first)
+  rescue KrakenClient::ErrorResponse
+    retry
+  end
+
+  def self.amount_and_quantity(order_id)
+    order = find(order_id)
+    amount = order.avg_price * order.executed_amount
+    quantity = order.executed_amount
+
+    [amount, quantity]
+  end
+
+  def self.open
+    KrakenApiWrapper.client.private.open_orders['open'].map { |o| new(*o) }
+  rescue KrakenClient::ErrorResponse
+    retry
+  end
+
+  def self.closed(start: 1.hour.ago.to_i)
+    KrakenApiWrapper.client.private.closed_orders(start: start)[:closed].map { |o| new(*o) }
+  rescue KrakenClient::ErrorResponse
+    retry
+  end
+
+  def self.find_lost(type, price, quantity)
+    BitexBot::Robot.log(:debug, "Looking for #{type} order in open orders...")
+    order = open_order_by(type, price, quantity)
+    return log_and_return(order, :open) if order.present?
+
+    BitexBot::Robot.log(:debug, "Looking for #{type} order in closed orders...")
+    order = closed_order_by(type, price, quantity)
+    return log_and_return(order, :closed) if order && order.id != last_closed_order
+  end
+
+  def self.log_and_return(order, status)
+    BitexBot::Robot.log(:debug, "Found open #{status} with ID #{order.id}")
+    order
+  end
+
+  # description: [type, price, quantity]
+  def self.open_order_by(type, price, quantity)
+    open.detect { |o| o == [type, price, quantity] }
+  end
+
+  # description: [type, price, quantity]
+  def self.closed_order_by(type, price, quantity)
+    closed(start: last_closed_order).detect { |o| o == [type, price, quantity] }
+  end
+
+  # id: 'O5TDV2-WDYB2-6OGJRD'
+  # order_data: {
+  #     'refid': nil, 'userref': nil, 'status': 'open', 'opentm': 1440292821.4839, 'starttm': 0, 'expiretm': 0,
+  #     'descr': {
+  #       'pair': 'ETHEUR', 'type': 'buy', 'ordertype': 'limit', 'price': '1.19000', 'price2': '0', 'leverage': 'none',
+  #       'order': 'buy 1204.00000000 ETHEUR @ limit 1.19000'
+  #     },
+  #     'vol': '1204.00000000', 'vol_exec': '0.00000000', 'cost': '0.00000', 'fee': '0.00000', 'price': '0.00000',
+  #     'misc': '', 'oflags': 'fciq'
+  #   }
+  # }
+  def initialize(id, order_data)
+    self.id = id
+    self.type = order_data[:descr][:type].to_sym
+    self.datetime = order_data[:opentm].to_i
+    self.amount = order_data[:vol].to_d
+    self.executed_amount = order_data[:vol_exec].to_d
+    self.price = order_data[:descr][:price].to_d
+    self.avg_price = order_data[:price].to_d
+  end
+
+  def cancel!
+    KrakenApiWrapper.client.private.cancel_order(txid: id)
+  rescue KrakenClient::ErrorResponse => e
+    e.message == 'EService:Unavailable' ? retry : raise
+  end
+
+  def ==(other)
+    if other.is_a?(self.class)
+      other.id == id
+    elsif other.is_a?(Array)
+      other == [type, price, amount]
+    end
+  end
+end
+
+class OrderArgumentError < StandardError; end

data/lib/bitex_bot/models/buy_closing_flow.rb

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

data/lib/bitex_bot/models/buy_opening_flow.rb

@@ -1,83 +1,77 @@
 module BitexBot
-  # A workflow for buying bitcoin in Bitex and selling on another exchange.  The
-  # BuyOpeningFlow factory function estimates how much you could sell on the other
-  # exchange and calculates a reasonable price taking into account the remote
-  # orderbook and the recent operated volume.
+  # A workflow for buying bitcoin in Bitex and selling on another exchange. The BuyOpeningFlow factory function estimates how
+  # much you could sell on the other exchange and calculates a reasonable price taking into account the remote order book and the
+  # recent operated volume.
   #
-  # When created, a BuyOpeningFlow places a Bid on Bitex for the calculated amount and
-  # price, when the Bid is matched on Bitex an OpenBuy is created to sell the
-  # matched amount for a higher price on the other exchange.
+  # When created, a BuyOpeningFlow places a Bid on Bitex for the calculated amount and price, when the Bid is matched on Bitex an
+  # OpenBuy is created to sell the matched amount for a higher price on the other exchange.
   #
-  # A BuyOpeningFlow can be cancelled at any point, which will cancel the Bitex order
-  # and any orders on the remote exchange created from its OpenBuy's
-  # 
-  # @attr order_id The first thing a BuyOpeningFlow does is placing a Bid on Bitex,
-  #   this is its unique id.
+  # A BuyOpeningFlow can be cancelled at any point, which will cancel the Bitex order and any orders on the remote exchange
+  # created from its OpenBuy's
+  #
+  # @attr order_id The first thing a BuyOpeningFlow does is placing a Bid on Bitex, this is its unique id.
   class BuyOpeningFlow < OpeningFlow
-    
-    # Start a workflow for buying bitcoin on bitex and selling on the other
-    # exchange. The amount to be spent on bitex is retrieved from Settings, if
-    # there is not enough USD on bitex or BTC on the other exchange then no
-    # order will be placed and an exception will be raised instead.
-    # The amount a BuyOpeningFlow will try to buy and the price it will try to buy at
-    # are derived from these parameters:
-    # 
-    # @param btc_balance [BigDecimal] amount of btc available in the other
-    #   exchange that can be sold to balance this purchase.
-    # @param order_book [[price, quantity]] a list of lists representing a bid
-    #   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 buying bitcoin on bitex and selling on the other exchange. The amount to be spent on bitex is
+    # retrieved from Settings, if there is not enough USD on bitex or BTC on the other exchange then no order will be placed
+    # and an exception will be raised instead.
+    #
+    # The amount a BuyOpeningFlow will try to buy and the price it will try to buy at are derived from these parameters:
+    #
+    # @param btc_balance [BigDecimal] amount of btc available in the other exchange that can be sold to balance this purchase.
+    # @param order_book [[price, quantity]] a list of lists representing a bid 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 maker exchange.
+    # @param taker_fee [BigDecimal] the transaction fee to pay on taker exchange.
     # @param store [Store] An updated config for this robot, mainly to use for profit.
     #
     # @return [BuyOpeningFlow] The newly created flow.
-    # @raise [CannotCreateFlow] If there's any problem creating this flow, for
-    #   example when you run out of USD on bitex or out of BTC on the other
-    #   exchange.
-    def self.create_for_market(btc_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 USD on bitex or out
+    #   of BTC on the other exchange.
+    def self.create_for_market(btc_balance, order_book, transactions, maker_fee, taker_fee, store)
       super
     end
-    
+
+    # sync_open_positions helpers
+    def self.transaction_order_id(transaction)
+      transaction.bid_id
+    end
+
     def self.open_position_class
       OpenBuy
     end
-    
+    # end: sync_open_positions helpers
+
+    # sought_transaction helpers
     def self.transaction_class
       Bitex::Buy
     end
-    
-    def self.transaction_order_id(transaction)
-      transaction.bid_id
+    # end: sought_transaction helpers
+
+    # create_for_market helpers
+    def self.maker_price(bitcoin_to_resell)
+      value_to_use / bitcoin_to_resell * (1 - profit / 100)
     end
 
     def self.order_class
       Bitex::Bid
     end
-    
-    def self.value_to_use
-      store.buying_amount_to_spend_per_order || Settings.buying.amount_to_spend_per_order
-    end
-    
+
     def self.profit
       store.buying_profit || Settings.buying.profit
     end
-    
-    def self.get_safest_price(transactions, order_book, dollars_to_use)
-      OrderBookSimulator.run(Settings.time_to_live, transactions,
-        order_book, dollars_to_use, nil)
-    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.get_bitex_price(usd_to_spend, bitcoin_to_resell) 
-     (usd_to_spend / bitcoin_to_resell) * (1 - self.profit / 100.0)
+    def self.safest_price(transactions, order_book, dollars_to_use)
+      OrderBookSimulator.run(Settings.time_to_live, transactions, order_book, dollars_to_use, nil)
+    end
+
+    def self.value_to_use
+      store.buying_amount_to_spend_per_order || Settings.buying.amount_to_spend_per_order
     end
+    # end: create_for_market helpers
   end
 end

data/lib/bitex_bot/models/close_buy.rb

@@ -1,7 +1,7 @@
 module BitexBot
-  # A CloseBuy represents an Ask on the remote exchange intended
-  # to close one or several OpenBuy positions.
+  # A CloseBuy represents an Ask on the remote exchange intended to close one or several OpenBuy positions.
   # TODO: document attributes.
+  #
   class CloseBuy < ActiveRecord::Base
   end
 end