bitex_bot 0.6.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc7c52b5a1df2b0bd97b57321bcab7f3590749ec
-  data.tar.gz: eebb4685c79121101d8432426141cb6f0d011e8d
+  metadata.gz: 8a52c57b2cb3f955ac849623421abc8296b1dc9c
+  data.tar.gz: b1a88154cb71ef5868c510f9316f0e755b161c33
 SHA512:
-  metadata.gz: f281ff61388642e7f5cd810470cf8b2a695deca0306d22ee3fd0f7c5b840f81208df5936c0545a8736c371907d60eb748f5419e08e897c9bdddd83bda2d0ad32
-  data.tar.gz: 3ac028d9b20737a43e142f83352471c4c85b82ac1950cb52b244811434cceb22fb565b9efc1db124aa13d8e204966ce6bc9373ddf390b175bd36a6ae9dc29d00
+  metadata.gz: 1cb5d465e54e321a5d181aa86e988c0183938a70540ffcb5434000abf55627d9e8f875da413d67dd1cfa07892f0198c6be7d7c628d2e46a1a31caed5c6afa17d
+  data.tar.gz: 8cef55c3f44533c9b43c7f82bede8a7fb2777e248ad533845a50ac6cc9006cf59bdb95499d94a5f8a6b509fa0a7bff46347d6020bb765f5cd503358a34512dea

data/.rubocop.yml

@@ -2,16 +2,16 @@ Style/FrozenStringLiteralComment:
   EnforcedStyle: never
 
 Metrics/AbcSize:
-  Max: 16
+  Max: 18
 
 Metrics/ClassLength:
-  Max: 130
+  Enabled: false
 
 Metrics/LineLength:
   Max: 130
 
 Metrics/MethodLength:
-  Max: 25
+  Max: 30
 
 Metrics/ParameterLists:
   Max: 7

data/Gemfile

@@ -2,4 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in bitex_bot.gemspec
 gemspec
-gem 'bitstamp', github: 'bitex-la/bitstamp'
+
+gem 'bitex', github: 'bitex-la/bitex-ruby', branch: 'bitcoin-cash-market'
+gem 'bitstamp', github: 'bitex-la/bitstamp', branch: 'update-lib'

data/bitex_bot.gemspec

@@ -18,14 +18,14 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = %w[lib]
 
-  spec.add_dependency 'activerecord', '~> 4.2'
+  spec.add_dependency 'activerecord'
   spec.add_dependency 'hashie', '~> 3.5.4'
   spec.add_dependency 'mail'
   spec.add_dependency 'sqlite3'
 
   spec.add_dependency 'bitex', '0.6'
   spec.add_dependency 'bitstamp'
-  spec.add_dependency 'itbit', '0.0.6'
+  spec.add_dependency 'itbit'
   spec.add_dependency 'kraken_client', '~> 1.2.1'
 
   spec.add_development_dependency 'bundler'
@@ -34,11 +34,14 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'byebug'
   spec.add_development_dependency 'database_cleaner'
   spec.add_development_dependency 'factory_bot'
+  spec.add_development_dependency 'faker'
   spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec-its'
   spec.add_development_dependency 'rspec-mocks'
   spec.add_development_dependency 'rspec_junit_formatter'
   spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'shoulda-matchers'
   spec.add_development_dependency 'timecop'
+  spec.add_development_dependency 'vcr'
   spec.add_development_dependency 'webmock'
 end

data/lib/bitex_bot/database.rb

@@ -53,7 +53,7 @@ module BitexBot
           t.decimal    :quantity,      precision: 30, scale: 15
           t.decimal    :amount,        precision: 30, scale: 15
           t.boolean    :done,          null: false,   default: false
-          t.decimal    :crypto_profit,    precision: 30, scale: 15
+          t.decimal    :crypto_profit, precision: 30, scale: 15
           t.decimal    :fiat_profit,   precision: 30, scale: 15
           t.decimal    :fx_rate,       precision: 20, scale: 8
           t.timestamps null: true
@@ -64,7 +64,7 @@ module BitexBot
           t.decimal    :quantity,      precision: 30, scale: 15
           t.decimal    :amount,        precision: 30, scale: 15
           t.boolean    :done,          null: false,   default: false
-          t.decimal    :crypto_profit,    precision: 30, scale: 15
+          t.decimal    :crypto_profit, precision: 30, scale: 15
           t.decimal    :fiat_profit,   precision: 30, scale: 15
           t.decimal    :fx_rate,       precision: 20, scale: 8
           t.timestamps null: true

data/lib/bitex_bot/models/api_wrappers/api_wrapper.rb

@@ -1,12 +1,15 @@
 # This class represents the general behaviour for trading platform wrappers.
 class ApiWrapper
+  attr_accessor :currency_pair
+
   MIN_AMOUNT = 5
 
   Transaction = Struct.new(
-    :id,       # Integer
-    :price,    # Decimal
-    :amount,   # Decimal
-    :timestamp # Epoch Integer
+    :id,        # Integer
+    :price,     # Decimal
+    :amount,    # Decimal
+    :timestamp, # Epoch Integer
+    :raw        # Actual transaction
   )
 
   Order = Struct.new(
@@ -15,14 +18,14 @@ class ApiWrapper
     :price,     # Decimal
     :amount,    # Decimal
     :timestamp, # Integer
-    :raw_order  # Actual order object
+    :raw        # Actual order object
   ) do
     def method_missing(method_name, *args, &block)
-      raw_order.respond_to?(method_name) ? raw_order.send(method_name, *args, &block) : super
+      raw.respond_to?(method_name) ? raw.send(method_name, *args, &block) : super
     end
 
     def respond_to_missing?(method_name, include_private = false)
-      raw_order.respond_to?(method_name) || super
+      raw.respond_to?(method_name) || super
     end
   end
 
@@ -50,58 +53,53 @@ class ApiWrapper
   )
 
   UserTransaction = Struct.new(
-    :order_id, # Integer
-    :usd,      # Decimal
-    :btc,      # Decimal
-    :btc_usd,  # Decimal
-    :fee,      # Decimal
-    :type,     # Integer
-    :timestamp # Epoch Integer
+    :order_id,    # Integer
+    :fiat,        # Decimal
+    :crypto,      # Decimal
+    :crypto_fiat, # Decimal
+    :fee,         # Decimal
+    :type,        # Integer
+    :timestamp    # Epoch Integer
   )
 
-  # @return [Void]
-  def self.setup(_settings)
-    raise 'self subclass responsibility'
-  end
-
   # @return [Array<Transaction>]
-  def self.transactions
+  def transactions
     raise 'self subclass responsibility'
   end
 
   # @return [OrderBook]
-  def self.order_book(_retries = 20)
+  def order_book(_retries = 20)
     raise 'self subclass responsibility'
   end
 
   # @return [BalanceSummary]
-  def self.balance
+  def balance
     raise 'self subclass responsibility'
   end
 
   # @return [nil]
-  def self.cancel
+  def cancel
     raise 'self subclass responsibility'
   end
 
   # @return [Array<Order>]
-  def self.orders
+  def orders
     raise 'self subclass responsibility'
   end
 
   # @return [UserTransaction]
-  def self.user_transacitions
+  def user_transactions
     raise 'self subclass responsibility'
   end
 
   # @param type
   # @param price
   # @param quantity
-  def self.place_order(type, price, quantity)
+  def place_order(type, price, quantity)
     order = send_order(type, price, quantity)
     return order unless order.nil? || order.id.nil?
 
-    BitexBot::Robot.log(:debug, "Captured error when placing order on #{self.class.name}")
+    BitexBot::Robot.log(:debug, "Captured error when placing order on #{self.class}")
     # Order may have gone through and be stuck somewhere in Wrapper's pipeline.
     # We just sleep for a bit and then look for the order.
     20.times do
@@ -109,32 +107,46 @@ class ApiWrapper
       order = find_lost(type, price, quantity)
       return order if order.present?
     end
-    raise OrderNotFound, "Closing: #{type} order not found for #{quantity} BTC @ $#{price}. #{order}"
+    raise OrderNotFound, "Closing: #{type} order not found for #{quantity} #{base} @ #{quote} #{price}. #{order}"
   end
 
   # Hook Method - arguments could not be used in their entirety by the subclasses
-  def self.send_order(_type, _price, _quantity)
+  def send_order(_type, _price, _quantity)
     raise 'self subclass responsibility'
   end
 
-  # @param order_method [String] buy|sell
+  # @param order_type [String] buy|sell
   # @param price [Decimal]
+  # @param quantity [Decimal]
   #
   # Hook Method - arguments could not be used in their entirety by the subclasses
-  def self.find_lost(_type, _price, _quantity)
+  def find_lost(_type, _price, _quantity)
     raise 'self subclass responsibility'
   end
 
+  # From an order when you buy or sell, when you place an order and it matches, you can match more than one order.
   # @param order_id
-  # @param transactions
+  # @param transactions: all matches for a purchase or sale order.
   #
   # @return [Array<Decimal, Decimal>]
-  def self.amount_and_quantity(_order_id, _transactions)
+  def amount_and_quantity(_order_id)
     raise 'self subclass responsibility'
   end
 
-  def self.enough_order_size?(quantity, price)
-    (quantity * price) > MIN_AMOUNT
+  def enough_order_size?(quantity, price)
+    quantity * price > MIN_AMOUNT
+  end
+
+  def base_quote
+    "#{base}_#{quote}"
+  end
+
+  def base
+    currency_pair[:base]
+  end
+
+  def quote
+    currency_pair[:quote]
   end
 end
 

data/lib/bitex_bot/models/api_wrappers/bitex/bitex_api_wrapper.rb

@@ -0,0 +1,178 @@
+# Wrapper implementation for Bitex API.
+# https://bitex.la/developers
+class BitexApiWrapper < ApiWrapper
+  Order = Struct.new(
+    :id,        # String
+    :type,      # Symbol
+    :price,     # Decimal
+    :amount,    # Decimal
+    :timestamp, # Integer
+    :raw        # Actual order object
+  ) do
+    def method_missing(method_name, *args, &block)
+      raw.respond_to?(method_name) ? raw.send(method_name, *args, &block) : super
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      raw.respond_to?(method_name) || super
+    end
+  end
+
+  attr_accessor :api_key, :ssl_version, :debug, :sandbox
+
+  def initialize(settings)
+    self.api_key = settings.api_key
+    self.ssl_version = settings.ssl_version
+    self.debug = settings.debug
+    self.sandbox = settings.sandbox
+    currency_pair(settings.order_book)
+    setup
+  end
+
+  def setup
+    Bitex.api_key = api_key
+    Bitex.ssl_version = ssl_version
+    Bitex.debug = debug
+    Bitex.sandbox = sandbox
+  end
+
+  def profile
+    Bitex::Profile.get
+  end
+
+  # rubocop:disable Metrics/AbcSize
+  def amount_and_quantity(order_id)
+    closes = user_transactions.select { |t| t.order_id.to_s == order_id }
+    amount = closes.map { |c| c.send(currency[:quote]).to_d }.sum.abs
+    quantity = closes.map { |c| c.send(currency[:base]).to_d }.sum.abs
+
+    [amount, quantity]
+  end
+  # rubocop:enable Metrics/AbcSize
+
+  def balance
+    balance_summary_parser(profile)
+  end
+
+  def find_lost(type, price, _quantity)
+    orders.find { |o| o.type == type && o.price == price && o.timestamp >= 5.minutes.ago.to_i }
+  end
+
+  def order_book
+    order_book_parser(market.order_book)
+  end
+
+  def orders
+    Bitex::Order.all.map { |o| order_parser(o) }
+  end
+
+  def send_order(type, price, quantity, wait = false)
+    { sell: Bitex::Ask, buy: Bitex::Bid }[type].create!(base_quote.to_sym, quantity, price, wait)
+  end
+
+  def transactions
+    Bitex::Trade.all.map { |t| transaction_parser(t) }
+  end
+
+  def user_transactions
+    Bitex::Trade.all.map { |trade| user_transaction_parser(trade) }
+  end
+
+  # {
+  #   usd_balance:               10000.00, # Total USD balance.
+  #   usd_reserved:               2000.00, # USD reserved in open orders.
+  #   usd_available:              8000.00, # USD available for trading.
+  #   btc_balance:            20.00000000, # Total BTC balance.
+  #   btc_reserved:            5.00000000, # BTC reserved in open orders.
+  #   btc_available:          15.00000000, # BTC available for trading.
+  #   fee:                            0.5, # Your trading fee (0.5 means 0.5%).
+  #   btc_deposit_address: "1XXXXXXXX..."  # Your BTC deposit address.
+  # }
+  def balance_summary_parser(balances)
+    BalanceSummary.new(
+      balance_parser(balances, currency_pair[:base]),
+      balance_parser(balances, currency_pair[:quote]),
+      balances[:fee].to_d
+    )
+  end
+
+  def balance_parser(balances, currency)
+    Balance.new(
+      balances["#{currency}_balance".to_sym].to_d,
+      balances["#{currency}_reserved".to_sym].to_d,
+      balances["#{currency}_available".to_sym].to_d
+    )
+  end
+
+  def last_order_by(price)
+    orders.select { |o| o.price == price && (o.timestamp - 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 order_book_parser(book)
+    OrderBook.new(Time.now.to_i, order_summary_parser(book[:bids]), order_summary_parser(book[:asks]))
+  end
+
+  def order_summary_parser(orders)
+    orders.map { |order| OrderSummary.new(order[0].to_d, order[1].to_d) }
+  end
+
+  # <Bitex::Bid
+  #   @id=12345678, @created_at=1999-12-31 21:10:00 -0300, @order_book=:btc_usd, @price=0.1e4, @status=:executing, @reason=nil,
+  #   @issuer=nil, @amount=0.1e3, @remaining_amount=0.1e2, @produced_quantity=0.0
+  # >
+  def order_parser(order)
+    Order.new(order.id.to_s, order_type(order), order.price, order_amount(order), order.created_at.to_i, order)
+  end
+
+  def order_type(order)
+    order.is_a?(Bitex::Bid) ? :buy : :sell
+  end
+
+  def order_amount(order)
+    order.is_a?(Bitex::Bid) ? order.amount : order.quantity
+  end
+
+  # [
+  #   [1492795215, 80310, 1243.51657154, 4.60321971],
+  #   [UNIX timestamp, Transaction ID, Price Paid, Amound Sold]
+  # ]
+  def transaction_parser(transaction)
+    Transaction.new(transaction.id, transaction.price.to_d, transaction.amount.to_d, transaction.created_at.to_i, transaction)
+  end
+
+  # <Bitex::Buy:0x007ff9a2979390
+  #   @id=12345678, @created_at=1999-12-31 21:10:00 -0300, @order_book=:btc_usd, @quantity=0.2e1, @amount=0.6e3, @fee=0.5e-1,
+  #   @price=0.3e3, @bid_id=123
+  # >
+  #
+  # <Bitex::Sell:0x007ff9a2978710
+  #   @id=12345678, @created_at=1999-12-31 21:10:00 -0300, @order_book=:btc_usd, @quantity=0.2e1, @amount=0.6e3, @fee=0.5e-1,
+  #   @price=0.3e3, @ask_id=456i
+  # >
+  def user_transaction_parser(trade)
+    UserTransaction.new(
+      trade.id, trade.amount, trade.quantity, trade.price, trade.fee, trade_type(trade), trade.created_at.to_i
+    )
+  end
+
+  def trade_type(trade)
+    # ask: 0, bid: 1
+    trade.is_a?(Bitex::Buy) ? 1 : 0
+  end
+
+  def market
+    @market ||= { btc: Bitex::BitcoinMarketData, bch: Bitex::BitcoinCashMarketData }[currency_pair[:base].to_sym]
+  end
+
+  def currency_pair(order_book = '_')
+    @currency_pair ||= {
+      name: order_book,
+      base: order_book.split('_').first,
+      quote: order_book.split('_').last
+    }
+  end
+end

data/lib/bitex_bot/models/api_wrappers/bitstamp/bitstamp_api_wrapper.rb

@@ -1,41 +1,45 @@
 # Wrapper implementation for Bitstamp API.
 # https://www.bitstamp.net/api/
 class BitstampApiWrapper < ApiWrapper
-  def self.setup(settings)
+  attr_accessor :key, :secret, :client_id
+
+  def initialize(settings)
+    self.key = settings.api_key
+    self.secret = settings.secret
+    self.client_id = settings.client_id
+    currency_pair(settings.order_book)
+    setup
+  end
+
+  def setup
     Bitstamp.setup do |config|
-      config.key = settings.api_key
-      config.secret = settings.secret
-      config.client_id = settings.client_id
+      config.key = key
+      config.secret = secret
+      config.client_id = client_id
     end
   end
 
-  def self.amount_and_quantity(order_id, transactions)
-    closes = transactions.select { |t| t.order_id.to_s == order_id }
-    amount = closes.map { |c| c.usd.to_d }.sum.abs
-    quantity = closes.map { |c| c.btc.to_d }.sum.abs
+  def amount_and_quantity(order_id)
+    closes = user_transactions.select { |t| t.order_id.to_s == order_id }
+    amount = closes.sum(&:fiat).abs
+    quantity = closes.sum(&:crypto).abs
 
     [amount, quantity]
   end
 
-  def self.balance
-    balance_summary_parser(Bitstamp.balance.symbolize_keys)
+  def balance
+    balance_summary_parser(Bitstamp.balance(currency_pair[:name]).symbolize_keys)
   rescue StandardError => e
     raise ApiWrapperError, "Bitstamp balance failed: #{e.message}"
   end
 
-  def self.cancel(order)
-    Bitstamp::Order.new(id: order.id).cancel!
-  rescue StandardError => e
-    raise ApiWrapperError, "Bitstamp cancel! failed: #{e.message}"
-  end
-
-  def self.find_lost(type, price, _quantity)
+  def find_lost(type, price, _quantity)
     orders.find { |o| o.type == type && o.price == price && o.timestamp >= 5.minutes.ago.to_i }
   end
 
   # rubocop:disable Metrics/AbcSize
-  def self.order_book(retries = 20)
-    book = Bitstamp.order_book.deep_symbolize_keys
+  def order_book(retries = 20)
+    book = Bitstamp.order_book(currency_pair[:name]).deep_symbolize_keys
     age = Time.now.to_i - book[:timestamp].to_i
     return order_book_parser(book) if age <= 300
 
@@ -50,24 +54,25 @@ class BitstampApiWrapper < ApiWrapper
   end
   # rubocop:enable Metrics/AbcSize
 
-  def self.orders
-    Bitstamp.orders.all.map { |o| order_parser(o) }
+  def orders
+    Bitstamp.orders.all(currency_pair: currency_pair[:name]).map { |o| order_parser(o) }
   rescue StandardError => e
     raise ApiWrapperError, "Bitstamp orders failed: #{e.message}"
   end
 
-  def self.send_order(type, price, quantity)
-    Bitstamp.orders.send(type, amount: quantity.round(4), price: price.round(2))
+  def send_order(type, price, quantity)
+    order = Bitstamp.orders.send(type, currency_pair: currency_pair[:name], amount: quantity.round(4), price: price.round(2))
+    order_parser(order) unless order.error.present?
   end
 
-  def self.transactions
-    Bitstamp.transactions.map { |t| transaction_parser(t) }
+  def transactions
+    Bitstamp.transactions(currency_pair[:name]).map { |t| transaction_parser(t) }
   rescue StandardError => e
     raise ApiWrapperError, "Bitstamp transactions failed: #{e.message}"
   end
 
-  def self.user_transactions
-    Bitstamp.user_transactions.all.map { |ut| user_transaction_parser(ut) }
+  def user_transactions
+    Bitstamp.user_transactions.all(currency_pair: currency_pair[:name]).map { |ut| user_transaction_parser(ut) }
   rescue StandardError => e
     raise ApiWrapperError, "Bitstamp user_transactions failed: #{e.message}"
   end
@@ -77,11 +82,15 @@ class BitstampApiWrapper < ApiWrapper
   #   usd_reserved: '1.02, usd_available: '6952.05', usd_balance: '6953.07',
   #   fee: '0.4000'
   # }
-  def self.balance_summary_parser(balances)
-    BalanceSummary.new(balance_parser(balances, :btc), balance_parser(balances, :usd), balances[:fee].to_d)
+  def balance_summary_parser(balances)
+    BalanceSummary.new(
+      balance_parser(balances, currency_pair[:base]),
+      balance_parser(balances, currency_pair[:quote]),
+      balances[:fee].to_d
+    )
   end
 
-  def self.balance_parser(balances, currency)
+  def balance_parser(balances, currency)
     Balance.new(
       balances["#{currency}_balance".to_sym].to_d,
       balances["#{currency}_reserved".to_sym].to_d,
@@ -94,42 +103,50 @@ class BitstampApiWrapper < ApiWrapper
   #   bids: [['124.55', '1.58057006'], ['124.40', '14.91779125']],
   #   asks: [['124.56', '0.81888247'], ['124.57', '0.81078911']]
   # }
-  def self.order_book_parser(book)
+  def order_book_parser(book)
     OrderBook.new(book[:timestamp].to_i, order_summary_parser(book[:bids]), order_summary_parser(book[:asks]))
   end
 
-  def self.order_is_done?(order)
+  def order_is_done?(order)
     order.nil?
   end
 
-  # <Bitstamp::Order @id=76, @type=0, @price='1.1', @amount='1.0', @datetime='2013-09-26 23:15:04'>
-  def self.order_parser(order)
-    type = order.type.zero? ? :buy : :sell
+  # <Bitstamp::Order @id='76', @type=0, @price='1.1', @amount='1.0', @datetime='2013-09-26 23:15:04'>
+  def order_parser(order)
+    type = order.type == '0' ? :buy : :sell
     Order.new(order.id.to_s, type, order.price.to_d, order.amount.to_d, order.datetime.to_datetime.to_i, order)
   end
 
-  def self.order_summary_parser(orders)
+  def order_summary_parser(orders)
     orders.map { |order| OrderSummary.new(order[0].to_d, order[1].to_d) }
   end
 
-  # <Bitstamp::Transactions: @tid=1469074, @price='126.95', @amount='1.10000000', @date='1380648951'>
-  def self.transaction_parser(transaction)
-    Transaction.new(transaction.tid, transaction.price.to_d, transaction.amount.to_d, transaction.date.to_i)
+  # <Bitstamp::Transactions: @tid='1469074', @price='126.95', @amount='1.10000000', @date='1380648951'>
+  def transaction_parser(transaction)
+    Transaction.new(transaction.tid, transaction.price.to_d, transaction.amount.to_d, transaction.date.to_i, transaction)
   end
 
   # <Bitstamp::UserTransaction:
   #   @usd='-373.51', @btc='3.00781124', @btc_usd='124.18', @order_id=7623942, @fee='1.50', @type=2, @id=1444404,
   #   @datetime='2013-09-26 13:28:55'
   # >
-  def self.user_transaction_parser(user_transaction)
+  def user_transaction_parser(user_transaction)
     UserTransaction.new(
       user_transaction.order_id,
-      user_transaction.usd.to_d,
-      user_transaction.btc.to_d,
-      user_transaction.btc_usd.to_d,
+      user_transaction.send(quote).to_d,
+      user_transaction.send(base).to_d,
+      user_transaction.send(base_quote).to_d,
       user_transaction.fee.to_d,
-      user_transaction.type,
-      Time.new(user_transaction.datetime).to_i
+      user_transaction.type.to_i,
+      Time.parse(user_transaction.datetime).to_i
     )
   end
+
+  def currency_pair(order_book = '')
+    @currency_pair ||= {
+      name: order_book,
+      base: order_book.slice(0..2),
+      quote: order_book.slice(3..5)
+    }
+  end
 end