bitex_bot 0.6.1 → 0.9.0

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

@@ -1,17 +1,29 @@
 # Wrapper implementation for Itbit API.
 # https://api.itbit.com/docs
 class ItbitApiWrapper < ApiWrapper
-  def self.setup(settings)
+  attr_accessor :client_key, :secret, :user_id, :default_wallet_id, :sandbox
+
+  def initialize(settings)
+    self.client_key = settings.client_key
+    self.secret = settings.secret
+    self.user_id = settings.user_id
+    self.default_wallet_id = settings.default_wallet_id
+    self.sandbox = settings.sandbox
+    currency_pair(settings.order_book)
+    setup
+  end
+
+  def setup
     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
+      conf.client_key = client_key
+      conf.secret = secret
+      conf.user_id = user_id
+      conf.default_wallet_id = default_wallet_id
+      conf.sandbox = sandbox
     end
   end
 
-  def self.amount_and_quantity(order_id, _transactions)
+  def amount_and_quantity(order_id)
     order = Itbit::Order.find(order_id)
     amount = order.volume_weighted_average_price * order.amount_filled
     quantity = order.amount_filled
@@ -19,24 +31,24 @@ class ItbitApiWrapper < ApiWrapper
     [amount, quantity]
   end
 
-  def self.balance
+  def balance
     balance_summary_parser(wallet[:balances])
   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
 
-  def self.order_book
-    order_book_parser(Itbit::XBTUSDMarketData.orders)
+  def order_book
+    order_book_parser(market.orders)
   end
 
-  def self.orders
-    Itbit::Order.all(status: :open).map { |o| order_parser(o) }
+  def orders
+    Itbit::Order.all(instrument: currency_pair, 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)
+  def place_order(type, price, quantity)
+    Itbit::Order.create!(type, currency_pair, quantity.round(4), price.round(2), wait: true, currency: currency_base)
   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.
@@ -49,12 +61,12 @@ class ItbitApiWrapper < ApiWrapper
     raise e
   end
 
-  def self.transactions
-    Itbit::XBTUSDMarketData.trades.map { |t| transaction_parser(t.symbolize_keys) }
+  def transactions
+    market.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
+  def user_transactions
     []
   end
 
@@ -64,15 +76,15 @@ class ItbitApiWrapper < ApiWrapper
   #   { 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)
+  def balance_summary_parser(balances)
+    BalanceSummary.new(balance_parser(balances, base.to_sym), balance_parser(balances, quote.to_sym), 0.5.to_d)
   end
 
-  def self.wallet
+  def wallet
     Itbit::Wallet.all.find { |w| w[:id] == Itbit.default_wallet_id }
   end
 
-  def self.balance_parser(balances, currency)
+  def balance_parser(balances, currency)
     currency_balance = balances.find { |balance| balance[:currency] == currency }
     Balance.new(
       currency_balance[:total_balance].to_d,
@@ -81,7 +93,7 @@ class ItbitApiWrapper < ApiWrapper
     )
   end
 
-  def self.last_order_by(price)
+  def last_order_by(price)
     Itbit::Order.all.select { |o| o.price == price && (o.created_time - Time.now.to_i).abs < 500 }.first
   end
 
@@ -89,11 +101,11 @@ class ItbitApiWrapper < ApiWrapper
   #   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)
+  def 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)
+  def order_summary_parser(orders)
     orders.map { |order| OrderSummary.new(order[0], order[1]) }
   end
 
@@ -103,12 +115,24 @@ class ItbitApiWrapper < ApiWrapper
   #   @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)
+  def 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])
+  def transaction_parser(transaction)
+    Transaction.new(transaction[:tid], transaction[:price], transaction[:amount], transaction[:date], transaction)
+  end
+
+  def market
+    "Itbit::#{currency_pair[:name].upcase}MarketData".constantize
+  end
+
+  def currency_pair(order_book = '')
+    @currency_pair ||= {
+      name: order_book,
+      base: order_book.slice(0..2),
+      quote: order_book.slice(3..6)
+    }
   end
 end

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

@@ -1,83 +1,90 @@
 # Wrapper implementation for Kraken API.
 # https://www.kraken.com/en-us/help/api
 class KrakenApiWrapper < ApiWrapper
+  attr_accessor :api_key, :api_secret, :client
+
   MIN_AMOUNT = 0.002
 
-  def self.setup(settings)
-    HTTParty::Basement.headers('User-Agent' => BitexBot.user_agent)
-    @settings = settings
+  def initialize(settings)
+    self.api_key = settings.api_key
+    self.api_secret = settings.api_secret
+    setup
   end
 
-  def self.client
-    @client ||= KrakenClient.load(@settings)
+  def setup
+    KrakenOrder.api_wrapper = self
+    self.client ||= KrakenClient.load(api_key: api_key, api_secret: api_secret)
+    HTTParty::Basement.headers('User-Agent' => BitexBot.user_agent)
   end
 
-  def self.amount_and_quantity(order_id, _transactions)
+  def amount_and_quantity(order_id)
     KrakenOrder.amount_and_quantity(order_id)
   end
 
-  def self.balance
+  def balance
     balance_summary_parser(client.private.balance)
   rescue KrakenClient::ErrorResponse, Net::ReadTimeout
     retry
   end
 
-  def self.enough_order_size?(quantity, _price)
+  def enough_order_size?(quantity, _price)
     quantity >= MIN_AMOUNT
   end
 
-  def self.find_lost(type, price, quantity)
+  def 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])
+  def order_book
+    order_book_parser(client.public.order_book(currency_pair[:altname])[currency_pair[:name]])
   rescue NoMethodError
     retry
   end
 
-  def self.orders
+  def orders
     KrakenOrder.open.map { |ko| order_parser(ko) }
   end
 
-  def self.send_order(type, price, quantity)
+  def 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) }
+  def transactions
+    client.public.trades(currency_pair[:altname])[currency_pair[:name]].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
+  def user_transactions
     []
   end
 
   # { ZEUR: '1433.0939', XXBT: '0.0000000000', 'XETH': '99.7497224800' }
-  def self.balance_summary_parser(balances)
+  # rubocop:disable Metrics/AbcSize
+  def 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
+      balance_parser(balances, currency_pair[:base], btc_reserved(open_orders)),
+      balance_parser(balances, currency_pair[:quote], usd_reserved(open_orders)),
+      client.private.trade_volume(pair: currency_pair[:altname])[:fees][currency_pair[:name]][:fee].to_d
     )
   end
+  # rubocop:enable Metrics/AbcSize
 
-  def self.balance_parser(balances, currency, reserved)
+  def balance_parser(balances, currency, reserved)
     Balance.new(balances[currency].to_d, reserved, balances[currency].to_d - reserved)
   end
 
-  def self.btc_reserved(open_orders)
+  def 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)
+  def 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)
+  def orders_by(open_orders, order_type)
     open_orders.select { |o| o.type == order_type }
   end
 
@@ -85,16 +92,16 @@ class KrakenApiWrapper < ApiWrapper
   #   '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)
+  def 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)
+  def 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)
+  def order_parser(order)
     Order.new(order.id.to_s, order.type, order.price, order.amount, order.datetime, order)
   end
 
@@ -103,7 +110,33 @@ class KrakenApiWrapper < ApiWrapper
   #   ['202.51626', '0.01440000', 1440277319.1922, 'b', 'l', ''],
   #   ['202.54000', '0.10000000', 1440277322.8993, 'b', 'l', '']
   # ]
-  def self.transaction_parser(transaction)
+  def transaction_parser(transaction)
     Transaction.new(transaction[2].to_i, transaction[0].to_d, transaction[1].to_d, transaction[2].to_i)
   end
+
+  # {
+  #   'XBTUSD' => {
+  #     'altname' => 'XBTUSD',
+  #     'aclass_base' => 'currency',
+  #     'base' => 'XXBT',
+  #     'aclass_quote' => 'currency',
+  #     'quote' => 'ZUSD',
+  #     'lot' => 'unit',
+  #     'pair_decimals' => 1,
+  #     'lot_decimals' => 8,
+  #     'lot_multiplier' => 1,
+  #     'leverage_buy' => [2, 3, 4, 5],
+  #     'leverage_sell' => [2, 3, 4, 5],
+  #     'fees' => [[0, 0.26], .., [250_000, 0.2]],
+  #     'fees_maker' => [[0, 0.16], .., [250_000, 0.1]],
+  #     'fee_volume_currency' => 'ZUSD',
+  #     'margin_call' => 80,
+  #     'margin_stop' => 40
+  #   }
+  # }
+  def currency_pair
+    @currency_pair ||= client.public.asset_pairs.map do |currency_pair, data|
+      [data['altname'], data.merge(name: currency_pair).with_indifferent_access]
+    end.to_h[BitexBot::Settings.taker_settings.order_book.upcase]
+  end
 end

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

@@ -2,7 +2,7 @@ require 'kraken_client'
 
 # Wrapper for Kraken orders.
 class KrakenOrder
-  cattr_accessor :last_closed_order
+  cattr_accessor :last_closed_order, :api_wrapper
   attr_accessor :id, :amount, :executed_amount, :price, :avg_price, :type, :datetime
 
   # rubocop:disable Metrics/AbcSize
@@ -24,11 +24,17 @@ class KrakenOrder
   # 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)
+    api_wrapper.client.private.add_order(
+      pair: KrakenApiWrapper.currency_pair[:altname],
+      type: type,
+      ordertype: 'limit',
+      price: price,
+      volume: quantity
+    )
   end
 
   def self.find(id)
-    new(*KrakenApiWrapper.client.private.query_orders(txid: id).first)
+    new(*api_wrapper.client.private.query_orders(txid: id).first)
   rescue KrakenClient::ErrorResponse
     retry
   end
@@ -42,13 +48,13 @@ class KrakenOrder
   end
 
   def self.open
-    KrakenApiWrapper.client.private.open_orders['open'].map { |o| new(*o) }
+    api_wrapper.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) }
+    api_wrapper.client.private.closed_orders(start: start)[:closed].map { |o| new(*o) }
   rescue KrakenClient::ErrorResponse
     retry
   end
@@ -100,7 +106,7 @@ class KrakenOrder
   end
 
   def cancel!
-    KrakenApiWrapper.client.private.cancel_order(txid: id)
+    api_wrapper.client.private.cancel_order(txid: id)
   rescue KrakenClient::ErrorResponse => e
     e.message == 'EService:Unavailable' ? retry : raise
   end

data/lib/bitex_bot/models/buy_closing_flow.rb

@@ -10,9 +10,10 @@ module BitexBot
       OpenBuy
     end
 
-    def fx_rate
+    def self.fx_rate
       Settings.buying_fx_rate
     end
+    def_delegator self, :fx_rate
 
     private
 
@@ -37,7 +38,7 @@ module BitexBot
     # end: create_or_cancel! hookers
 
     # create_order_and_close_position hookers
-    def order_method
+    def order_type
       :sell
     end
     # end: create_order_and_close_position hookers

data/lib/bitex_bot/models/buy_opening_flow.rb

@@ -28,13 +28,13 @@ module BitexBot
     # @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, maker_fee, taker_fee, store)
+    def self.create_for_market(taker_crypto_balance, taker_bids, taker_transactions, maker_fee, taker_fee, store)
       super
     end
 
     # sync_open_positions helpers
     def self.transaction_order_id(transaction)
-      transaction.bid_id
+      transaction.raw.bid_id
     end
 
     def self.open_position_class
@@ -50,23 +50,28 @@ module BitexBot
 
     # create_for_market helpers
     def self.maker_price(crypto_to_resell)
-      value_to_use / crypto_to_resell * (1 - profit / 100)
+      value_to_use * fx_rate / crypto_to_resell * (1 - profit / 100)
     end
 
     def self.order_class
       Bitex::Bid
     end
+    def_delegator self, :order_class
+
+    def self.order_type
+      :buy
+    end
 
     def self.profit
       store.buying_profit || Settings.buying.profit
     end
 
     def self.remote_value_to_use(value_to_use_needed, safest_price)
-      (value_to_use_needed / fx_rate) / safest_price
+      value_to_use_needed / safest_price
     end
 
-    def self.safest_price(transactions, order_book, amount_to_use)
-      OrderBookSimulator.run(Settings.time_to_live, transactions, order_book, amount_to_use / fx_rate, nil)
+    def self.safest_price(transactions, taker_bids, amount_to_use)
+      OrderBookSimulator.run(Settings.time_to_live, transactions, taker_bids, amount_to_use, nil, fx_rate)
     end
 
     def self.value_to_use
@@ -77,5 +82,25 @@ module BitexBot
     def self.fx_rate
       Settings.buying_fx_rate
     end
+
+    def self.value_per_order
+      value_to_use * fx_rate
+    end
+
+    def self.maker_specie_to_spend
+      Robot.maker.quote.upcase
+    end
+
+    def self.maker_specie_to_obtain
+      Robot.maker.base.upcase
+    end
+
+    def self.taker_specie_to_spend
+      Robot.taker.base.upcase
+    end
+
+    def self.taker_specie_to_obtain
+      Robot.taker.quote.upcase
+    end
   end
 end

data/lib/bitex_bot/models/closing_flow.rb

@@ -1,22 +1,28 @@
 module BitexBot
   # Close buy/sell positions.
   class ClosingFlow < ActiveRecord::Base
+    extend Forwardable
+
     self.abstract_class = true
 
     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.
+    # Start a new CloseBuy that closes existing 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?
+      return unless open_positions.any?
 
-      quantity = open_positions.map(&:quantity).sum
-      amount = open_positions.map(&:amount).sum
-      price = suggested_amount(open_positions) / quantity
+      positions = open_positions
+      quantity = positions.sum(&:quantity)
+      amount = positions.sum(&:amount) / fx_rate
+      price = suggested_amount(positions) / quantity
 
-      # Don't even bother trying to close a position that's too small.
       return unless Robot.taker.enough_order_size?(quantity, price)
-      create_closing_flow!(price, quantity, amount, open_positions)
+
+      create_closing_flow!(price, quantity, amount, positions)
+    end
+
+    def self.open_positions
+      open_position_class.open
     end
 
     # close_open_positions helpers
@@ -36,9 +42,9 @@ module BitexBot
     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)
+    def sync_closed_positions
       # 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)
+      latest_close.nil? ? create_initial_order_and_close_position! : create_or_cancel!
     end
 
     def estimate_fiat_profit
@@ -53,15 +59,14 @@ module BitexBot
 
     # 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)
+    def create_or_cancel!
       order_id = latest_close.order_id.to_s
-      order = orders.find { |o| o.id.to_s == order_id }
+      order = Robot.with_cooldown { Robot.taker.orders.find { |o| o.id.to_s == order_id } }
 
       # 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?
-        sync_position(order_id, transactions)
+        sync_position(order_id)
         create_next_position!
       elsif latest_close.created_at < close_time_to_live.seconds.ago
         cancel!(order)
@@ -77,9 +82,9 @@ module BitexBot
     # create_or_cancel! helpers
     def cancel!(order)
       Robot.with_cooldown do
-        Robot.log(:debug, "Finalising #{order.class}##{order.id}")
+        Robot.log(:debug, "Finalising #{order.raw.class}##{order.id}")
         order.cancel!
-        Robot.log(:debug, "Finalised #{order.class}##{order.id}")
+        Robot.log(:debug, "Finalised #{order.raw.class}##{order.id}")
       end
     rescue StandardError => error
       Robot.log(:debug, error)
@@ -90,19 +95,25 @@ module BitexBot
     #   estimate_crypto_profit
     #   amount_positions_balance
     #   next_price_and_quantity
+    # rubocop:disable Metrics/AbcSize
     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!(crypto_profit: estimate_crypto_profit, fiat_profit: estimate_fiat_profit, fx_rate: fx_rate, done: true)
-        Robot.logger.info("Closing: Finished #{self.class.name} ##{id} earned $#{fiat_profit} and #{crypto_profit} BTC.")
+        Robot.log(
+          :info,
+          "Closing: Finished #{self.class} ##{id} earned"\
+          "#{Robot.maker.quote.upcase} #{fiat_profit} and #{Robot.maker.base.upcase} #{crypto_profit}."
+        )
       end
     end
+    # rubocop:enable Metrics/AbcSize
 
-    def sync_position(order_id, transactions)
+    def sync_position(order_id)
       latest = latest_close
-      latest.amount, latest.quantity = Robot.taker.amount_and_quantity(order_id, transactions)
+      latest.amount, latest.quantity = Robot.taker.amount_and_quantity(order_id)
       latest.save!
     end
     # end: create_or_cancel! helpers
@@ -114,11 +125,15 @@ module BitexBot
     # end: next_price_and_quantity helpers
 
     # This use hooks methods, these must be defined in the subclass:
-    #   order_method
+    #   order_type
     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)
+      Robot.log(
+        :info,
+        "Closing: Going to place #{order_type} order for #{self.class} ##{id}"\
+        " #{Robot.taker.base.upcase} #{quantity} @ #{Robot.taker.quote.upcase} #{price}"
+      )
+      order = Robot.taker.place_order(order_type, price, quantity)
       close_positions.create!(order_id: order.id)
     end
   end

data/lib/bitex_bot/models/open_buy.rb

@@ -1,12 +1,10 @@
 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') }
+    scope :open, -> { where(closing_flow: nil) }
   end
 end

data/lib/bitex_bot/models/open_sell.rb

@@ -1,12 +1,10 @@
 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') }
+    scope :open, -> { where(closing_flow: nil) }
   end
 end