bitex_bot 0.3.7 → 0.4.0

data/lib/bitex_bot/models/kraken_api_wrapper.rb

@@ -1,188 +0,0 @@
-require 'kraken_client'
-
-class KrakenApiWrapper
-  def self.setup(settings)
-    HTTParty::Basement.headers('User-Agent' => BitexBot.user_agent)
-    @settings = settings.kraken
-  end
-
-  def self.client
-    @client ||= KrakenClient.load(@settings)
-  end
-
-  #{
-  #  tid:i,
-  #  date: (i+1).seconds.ago.to_i.to_s,
-  #  price: price.to_s,
-  #  amount: amount.to_s
-  #}
-  def self.transactions
-    client.public.trades('XBTUSD')[:XXBTZUSD].reverse.collect do |t|
-      Hashie::Mash.new({
-        tid: t[2].to_s,
-        price: t[0],
-        amount: t[1],
-        date: t[2]
-      })
-    end
-  rescue NoMethodError => e
-    retry
-  end
-
-  #  { 'timestamp' => DateTime.now.to_i.to_s,
-  #    'bids' =>
-  #      [['30', '3'], ['25', '2'], ['20', '1.5'], ['15', '4'], ['10', '5']],
-  #    'asks' =>
-  #      [['10', '2'], ['15', '3'], ['20', '1.5'], ['25', '3'], ['30', '3']]
-  #  }
-  def self.order_book(retries = 20)
-    book = client.public.order_book('XBTUSD')[:XXBTZUSD]
-    { 'bids' => book[:bids].collect { |b| [ b[0], b[1] ] },
-      'asks' => book[:asks].collect { |a| [ a[0], a[1] ] } }
-  rescue NoMethodError => e
-    retry
-  end
-
-  # {"btc_balance"=> "10.0", "btc_reserved"=> "0", "btc_available"=> "10.0",
-  # "usd_balance"=> "100.0", "usd_reserved"=>"0", "usd_available"=> "100.0",
-  # "fee"=> "0.5000"}
-  def self.balance
-    balances = client.private.balance
-    open_orders = KrakenOrder.open
-    sell_orders = open_orders.select { |o| o.type == :sell }
-    btc_reserved = sell_orders.collect { |o| o.amount - o.executed_amount }.sum
-    buy_orders = open_orders - sell_orders
-    usd_reserved = buy_orders.collect { |o| (o.amount - o.executed_amount) * o.price }.sum
-    { 'btc_balance' => balances['XXBT'].to_d,
-      'btc_reserved' => btc_reserved,
-      'btc_available' => balances['XXBT'].to_d - btc_reserved,
-      'usd_balance' => balances['ZUSD'].to_d,
-      'usd_reserved' => usd_reserved,
-      'usd_available' => balances['ZUSD'].to_d - usd_reserved,
-      'fee' => client.private.trade_volume(pair: 'XBTUSD')[:fees][:XXBTZUSD][:fee].to_d
-    }
-  rescue KrakenClient::ErrorResponse, Net::ReadTimeout => e
-    retry
-  end
-
-  # ask = double(amount: args[:amount], price: args[:price],
-  #   type: 1, id: remote_id, datetime: DateTime.now.to_s)
-  # ask.stub(:cancel!) do
-  def self.orders
-    KrakenOrder.open
-  end
-
-  # We don't need to fetch the list of transactions
-  # for Kraken
-  def self.user_transactions
-    [ ]
-  end
-
-  def self.amount_and_quantity(order_id, transactions)
-    KrakenOrder.amount_and_quantity(order_id, transactions)
-  end
-
-  def self.place_order(type, price, quantity)
-    KrakenOrder.create(type, price, quantity)
-  end
-end
-
-class KrakenOrder
-  attr_accessor :id, :amount, :executed_amount, :price, :avg_price, :type, :datetime
-  def initialize(id, order_data)
-    self.id = id
-    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
-    self.type = order_data['descr']['type'].to_sym
-    self.datetime = order_data['opentm'].to_i
-  end
-
-  def cancel!
-    self.class.client.private.cancel_order(txid: id)
-  rescue KrakenClient::ErrorResponse => e
-    retry if e.message == 'EService:Unavailable'
-    raise
-  end
-
-  def ==(order)
-    if order.is_a?(self.class)
-      id == order.id
-    elsif order.is_a?(Array)
-      [ type, price, amount ] == order
-    end
-  end
-
-  def self.client
-    KrakenApiWrapper.client
-  end
-
-  def self.find(id)
-    new(*client.private.query_orders(txid: id).first)
-  rescue KrakenClient::ErrorResponse => e
-    retry
-  end
-
-  def self.amount_and_quantity(order_id, transactions)
-    order = find(order_id)
-    [ order.avg_price * order.executed_amount, order.executed_amount ]
-  end
-
-  def self.open
-    client.private.open_orders['open'].collect { |o| new(*o) }
-  rescue KrakenClient::ErrorResponse => e
-    retry
-  end
-
-  def self.closed(start: 1.hour.ago.to_i)
-    client.private.closed_orders(start: start)[:closed].collect { |o| new(*o) }
-  rescue KrakenClient::ErrorResponse => e
-    retry
-  end
-
-  def self.find_lost(type, price, quantity, last_closed_order)
-    order_descr = [ type, price, quantity ]
-
-    BitexBot::Robot.logger.debug("Looking for #{type} order in open orders...")
-    if order = self.open.detect { |o| o == order_descr }
-      BitexBot::Robot.logger.debug("Found open order with ID #{order.id}")
-      return order
-    end
-
-    BitexBot::Robot.logger.debug("Looking for #{type} order in closed orders...")
-    order = closed(start: last_closed_order).detect { |o| o == order_descr }
-    if order && order.id != last_closed_order
-      BitexBot::Robot.logger.debug("Found closed order with ID #{order.id}")
-      return order
-    end
-  end
-
-  def self.create(type, price, quantity)
-    last_closed_order = closed.first.try(:id) || Time.now.to_i
-    price = price.truncate(1)
-    quantity = quantity.truncate(8)
-    order_info = client.private.add_order(pair: 'XBTUSD', type: type, ordertype: 'limit',
-                                          price: price, volume: quantity)
-    find(order_info['txid'].first)
-  rescue KrakenClient::ErrorResponse => e
-    # Order could not be placed
-    if e.message == 'EService:Unavailable'
-      BitexBot::Robot.logger.debug('Captured EService:Unavailable error when placing order on Kraken. Retrying...')
-      retry
-    elsif e.message.start_with?('EGeneral:Invalid')
-      BitexBot::Robot.logger.debug("Captured #{e.message}: type: #{type}, price: #{price}, quantity: #{quantity}")
-      return
-    end
-    raise unless e.message == 'error'
-    BitexBot::Robot.logger.debug('Captured error when placing order on Kraken')
-    # Order may have gone through and be stuck somewhere in Kraken's
-    # pipeline. We just sleep for a bit and then look for the order.
-    8.times do
-      sleep 15
-      order = find_lost(type, price, quantity, last_closed_order)
-      return order if order
-    end
-    raise
-  end
-end

data/spec/models/bitfinex_api_wrapper_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe BitfinexApiWrapper do
-  before(:each) do
-    BitexBot::Robot.stub(taker: 'bitfinex')
-    BitexBot::Robot.stub(taker: BitfinexApiWrapper)
-    BitexBot::Robot.setup
-  end
-
-  it 'Sends User-Agent header' do
-    stub_request(:post, "https://api.bitfinex.com/v1/balances")
-      .with(headers: { 'User-Agent': BitexBot.user_agent })
-    stub_request(:post, "https://api.bitfinex.com/v1/account_infos")
-      .with(headers: { 'User-Agent': BitexBot.user_agent })
-    BitfinexApiWrapper.balance rescue nil # we don't care about the response
-  end
-end

data/spec/models/bitstamp_api_wrapper_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe BitstampApiWrapper do
-  before(:each) do
-    BitexBot::Robot.stub(taker: 'bitstamp')
-    BitexBot::Robot.stub(taker: BitstampApiWrapper)
-    BitexBot::Robot.setup
-  end
-
-  it 'Sends User-Agent header' do
-    stub_request(:post, "https://www.bitstamp.net/api/v2/balance/btcusd/")
-      .with(headers: { 'User-Agent': BitexBot.user_agent })
-    BitstampApiWrapper.balance rescue nil # we don't care about the response
-  end
-end

data/spec/models/itbit_api_wrapper_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe ItbitApiWrapper do
-  before(:each) do
-    BitexBot::Robot.stub(taker: 'itbit')
-    BitexBot::Robot.stub(taker: ItbitApiWrapper)
-    BitexBot::Robot.setup
-  end
-
-  it 'Sends User-Agent header' do
-    stub_request(:get, "https://api.itbit.com/v1/wallets?userId=the-user-id")
-      .with(headers: { 'User-Agent': BitexBot.user_agent })
-    ItbitApiWrapper.balance rescue nil # we don't care about the response
-  end
-end

data/spec/support/bitstamp_stubs.rb

@@ -1,110 +0,0 @@
-module BitstampStubs
-  def stub_bitstamp_balance(usd = nil, coin = nil, fee = nil)
-    Bitstamp.stub(balance: bitstamp_balance_stub(usd, coin, fee))
-  end
-  
-  def bitstamp_balance_stub(usd = nil, coin = nil, fee = nil)
-    {"btc_balance"=> coin || "10.0", "btc_reserved"=> "0", "btc_available"=> coin || "10.0",
-     "usd_balance"=> usd || "100.0", "usd_reserved"=>"0", "usd_available"=> usd || "100.0",
-     "fee"=> fee || "0.5000"}
-  end
-
-  def stub_bitstamp_order_book
-    Bitstamp.stub(order_book: bitstamp_order_book_stub)
-  end
-  
-  def bitstamp_order_book_stub
-    { 'timestamp' => Time.now.to_i.to_s,
-      'bids' =>
-        [['30', '3'], ['25', '2'], ['20', '1.5'], ['15', '4'], ['10', '5']],
-      'asks' =>
-        [['10', '2'], ['15', '3'], ['20', '1.5'], ['25', '3'], ['30', '3']]
-    }
-  end
-  
-  def stub_bitstamp_transactions(volume = 0.2)
-    Bitstamp.stub(transactions: bitstamp_transactions_stub(volume))
-  end
-  
-  def bitstamp_transactions_stub(price = 30, amount = 1)
-    transactions = 5.times.collect do |i|
-      double(
-        tid:i,
-        date: (i+1).seconds.ago.to_i.to_s,
-        price: price.to_s,
-        amount: amount.to_s
-      )
-    end
-  end
-
-  def stub_bitstamp_user_transactions
-    Bitstamp.stub(user_transactions: double(all: []))
-  end
-  
-  # Takes all active orders and mockes them as executed in a single transaction.
-  # If a ratio is provided then each order is only partially executed and added
-  # as a transaction and the order itself is kept in the order list.
-  def stub_bitstamp_orders_into_transactions(options={})
-    ratio = options[:ratio] || 1
-    orders = Bitstamp.orders.all
-    transactions = orders.collect do |o|
-      usd = o.amount * o.price
-      usd, btc = o.type == 0 ? [-usd, o.amount] : [usd, -o.amount]
-      double(usd: (usd * ratio).to_s, btc: (btc * ratio).to_s,
-        btc_usd: o.price.to_s, order_id: o.id, fee: "0.5", type: 2,
-        datetime: DateTime.now.to_s)
-    end
-    Bitstamp.stub(user_transactions: double(all: transactions))
-
-    if ratio == 1
-      stub_bitstamp_sell
-      stub_bitstamp_buy
-    end
-  end
-  
-  def ensure_bitstamp_orders_stub
-    begin
-      Bitstamp.orders
-    rescue Exception => e
-      Bitstamp.stub(orders: double) 
-    end
-  end
-  
-  def stub_bitstamp_sell(remote_id=nil, orders = [])
-    ensure_bitstamp_orders_stub
-    Bitstamp.orders.stub(all: orders)
-    Bitstamp.orders.stub(:sell) do |args|
-      remote_id = Bitstamp.orders.all.size + 1 if remote_id.nil?
-      ask = double(amount: args[:amount], price: args[:price],
-        type: 1, id: remote_id, datetime: DateTime.now.to_s)
-      ask.stub(:cancel!) do
-        orders = Bitstamp.orders.all.reject do |x|
-          x.id.to_s == ask.id.to_s && x.type == 1
-        end
-        stub_bitstamp_sell(remote_id + 1, orders)
-      end
-      stub_bitstamp_sell(remote_id + 1, Bitstamp.orders.all + [ask])
-      ask
-    end
-  end
-
-  def stub_bitstamp_buy(remote_id=nil, orders = [])
-    ensure_bitstamp_orders_stub
-    Bitstamp.orders.stub(all: orders)
-    Bitstamp.orders.stub(:buy) do |args|
-      remote_id = Bitstamp.orders.all.size + 1 if remote_id.nil?
-      bid = double(amount: args[:amount], price: args[:price],
-        type: 0, id: remote_id, datetime: DateTime.now.to_s)
-      bid.stub(:cancel!) do
-        orders = Bitstamp.orders.all.reject do |x|
-          x.id.to_s == bid.id.to_s && x.type == 0
-        end
-        stub_bitstamp_buy(remote_id + 1, orders)
-      end
-      stub_bitstamp_buy(remote_id + 1, Bitstamp.orders.all + [bid])
-      bid
-    end
-  end
-end
-
-RSpec.configuration.include BitstampStubs