bitex_bot 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+settings.yml

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bitex_bot.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Nubis
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+# BitexBot
+
+A robot to do arbitrage between bitex.la and other exchanges.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bitex_bot'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bitex_bot
+
+## Usage
+
+This software is provided as is, and it serves as an example to the
+https://github.com/bitex-la/bitex-ruby API wrapper for bitex.
+
+With that said, you can use this robot yourself to take advantage of price
+differences between bitex and bitstamp.
+
+Before you can start using this robot you need to have approved accounts in
+https://bitex.la and https://bitstamp.net. Both accounts should have enough
+BTC and USD as the robot will try to sell on bitex and buy on bitstamp
+and to buy on bitex and sell on bitstamp.
+
+This gem provides bitex_bot executable, it will create a config file on the first run.
+
+Edit the config file to include your bitex and bitstmap api_keys, configure your
+trading parameters and desired profit on successfull trades.
+
+Optionally, configure your outgoing email credentials to receive emails when your
+robot needs attention.
+
+Once you're done, run bitex_bot again and it will start placing orders on bitex,
+looking for opportunities to make a profit. Start with low amounts and then
+start trading more as you become more comfortable with how the robot operates. 
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/bitex_bot

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'bitex_bot'
+
+BitexBot::Robot.run!

data/bitex_bot.gemspec

@@ -0,0 +1,41 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bitex_bot/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bitex_bot"
+  spec.version       = BitexBot::VERSION
+  spec.authors       = ["Nubis", "Eromirou"]
+  spec.email         = ["nb@bitex.la", "tr@bitex.la"]
+  spec.description   = %q{Both a trading robot and a library to build trading
+                        robots. The bitex-bot lets you buy cheap on bitex and
+                        sell on another exchange and vice versa.}
+  spec.summary       = %q{A trading robot to do arbitrage between bitex.la and
+                        other exchanges!}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  
+  spec.add_dependency "settingslogic"
+  spec.add_dependency "activerecord"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "sqlite3"
+  spec.add_dependency "bitstamp"
+  spec.add_dependency "bitex"
+  spec.add_dependency "debugger"
+  spec.add_dependency "mail"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-mocks"
+  spec.add_development_dependency "database_cleaner"
+  spec.add_development_dependency "factory_girl"
+  spec.add_development_dependency "timecop"
+  spec.add_development_dependency "shoulda-matchers"
+end

data/lib/bitex_bot/database.rb

@@ -0,0 +1,93 @@
+module BitexBot
+  module Database
+    ActiveRecord::Base.logger = Logger.new(File.open('database.log', 'w'))
+    ActiveRecord::Base.establish_connection(Settings.database)
+
+    if ActiveRecord::Base.connection.tables.empty?
+      ActiveRecord::Schema.define(version: 1) do
+        create_table :buy_opening_flows do |t|
+          t.decimal :price, precision: 30, scale: 15
+          t.decimal :value_to_use, precision: 30, scale: 15
+          t.decimal :suggested_closing_price, precision: 30, scale: 15
+          t.integer :order_id
+          t.string :status, null: false, default: 'executing'
+          t.index :status
+          t.timestamps
+        end
+        add_index :buy_opening_flows, :order_id
+
+        create_table :sell_opening_flows do |t|
+          t.decimal :price, precision: 30, scale: 15
+          t.decimal :value_to_use, precision: 30, scale: 15
+          t.decimal :suggested_closing_price, precision: 30, scale: 15
+          t.integer :order_id
+          t.string :status, null: false, default: 'executing'
+          t.index :status
+          t.timestamps
+        end
+        add_index :sell_opening_flows, :order_id
+        
+        create_table :open_buys do |t|
+          t.belongs_to :opening_flow
+          t.belongs_to :closing_flow
+          t.decimal :price, precision: 30, scale: 15
+          t.decimal :amount, precision: 30, scale: 15
+          t.decimal :quantity, precision: 30, scale: 15
+          t.integer :transaction_id
+          t.timestamps
+        end
+        add_index :open_buys, :transaction_id
+
+        create_table :open_sells do |t|
+          t.belongs_to :opening_flow
+          t.belongs_to :closing_flow
+          t.decimal :price, precision: 30, scale: 15
+          t.decimal :quantity, precision: 30, scale: 15
+          t.decimal :amount, precision: 30, scale: 15
+          t.integer :transaction_id
+          t.timestamps
+        end
+        add_index :open_sells, :transaction_id
+        
+        create_table :buy_closing_flows do |t|
+          t.decimal :desired_price, precision: 30, scale: 15
+          t.decimal :quantity, precision: 30, scale: 15
+          t.decimal :amount, precision: 30, scale: 15
+          t.boolean :done, null: false, default: false
+          t.decimal :btc_profit, precision: 30, scale: 15
+          t.decimal :usd_profit, precision: 30, scale: 15
+          t.timestamps
+        end
+
+        create_table :sell_closing_flows do |t|
+          t.decimal :desired_price, precision: 30, scale: 15
+          t.decimal :quantity, precision: 30, scale: 15
+          t.decimal :amount, precision: 30, scale: 15
+          t.boolean :done, null: false, default: false
+          t.decimal :btc_profit, precision: 30, scale: 15
+          t.decimal :usd_profit, precision: 30, scale: 15
+          t.timestamps
+        end
+        
+        create_table :close_buys do |t|
+          t.belongs_to :closing_flow
+          t.decimal :amount, precision: 30, scale: 15
+          t.decimal :quantity, precision: 30, scale: 15
+          t.integer :order_id
+          t.timestamps
+        end
+        add_index :close_buys, :order_id
+
+        create_table :close_sells do |t|
+          t.belongs_to :closing_flow
+          t.decimal :amount, precision: 30, scale: 15
+          t.decimal :quantity, precision: 30, scale: 15
+          t.integer :order_id
+          t.timestamps
+        end
+        add_index :close_sells, :order_id
+      end
+    end
+  end
+end
+

data/lib/bitex_bot/models/buy_closing_flow.rb

@@ -0,0 +1,34 @@
+module BitexBot
+  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) }
+
+    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
+      quantity - close_positions.sum(:quantity)
+    end
+
+    def get_next_price_and_quantity
+      closes = close_positions
+      next_price = desired_price - ((closes.count * (closes.count * 2)) / 100.0)
+      next_quantity = quantity - closes.sum(:quantity)
+      [next_price, next_quantity]
+    end
+  end
+end

data/lib/bitex_bot/models/buy_opening_flow.rb

@@ -0,0 +1,86 @@
+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.
+  #
+  # 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.
+  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.
+    #
+    # @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)
+      super
+    end
+    
+    def self.open_position_class
+      OpenBuy
+    end
+    
+    def self.transaction_class
+      Bitex::Buy
+    end
+    
+    def self.transaction_order_id(transaction)
+      transaction.bid_id
+    end
+
+    def self.order_class
+      Bitex::Bid
+    end
+    
+    def self.value_to_use
+      Settings.buying.amount_to_spend_per_order
+    end
+    
+    def self.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)
+      value_to_use_needed / safest_price
+    end
+    
+    def self.order_is_executing?(order)
+      order.status != :executing && order.remaining_amount == order.amount
+    end
+
+    def self.get_bitex_price(usd_to_spend, bitcoin_to_resell) 
+     (usd_to_spend / bitcoin_to_resell) * (1 - Settings.buying.profit / 100.0)
+    end
+  end
+end

data/lib/bitex_bot/models/close_buy.rb

@@ -0,0 +1,7 @@
+module BitexBot
+  # 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

data/lib/bitex_bot/models/close_sell.rb

@@ -0,0 +1,4 @@
+module BitexBot
+  class CloseSell < ActiveRecord::Base
+  end
+end

data/lib/bitex_bot/models/closing_flow.rb

@@ -0,0 +1,80 @@
+module BitexBot
+  class ClosingFlow < ActiveRecord::Base
+    self.abstract_class = true
+
+    # Start a new CloseBuy that closes exising 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?
+
+      quantity = open_positions.collect(&:quantity).sum
+      amount = open_positions.collect(&:amount).sum
+      suggested_amount = open_positions.collect do |open|
+        open.quantity * open.opening_flow.suggested_closing_price
+      end.sum
+      price = suggested_amount / quantity
+
+      # Don't even bother trying to close a position that's too small.
+      return if quantity * price < minimum_amount_for_closing
+
+      flow = create!(
+        desired_price: price,
+        quantity: quantity,
+        amount: amount,
+        open_positions: open_positions)
+
+      flow.create_order_and_close_position(quantity, price)
+
+      return flow
+    end
+    
+    def create_order_and_close_position(quantity, price)
+      order = Bitstamp.orders.send(order_method,
+        amount: quantity.round(8), price: price.round(8))
+      Robot.logger.info("Closing: Going to #{order_method} ##{order.id} for"\
+        "#{self.class.name} ##{id} #{quantity} BTC @ $#{price}")
+      close_positions.create!(order_id: order.id.to_i)
+    end
+
+    def sync_closed_positions(orders, transactions)
+      latest_close = close_positions.last
+      order = orders.find{|x| x.id.to_s == latest_close.order_id.to_s }
+      
+      # When ask 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?
+        closes = transactions.select{|t| t.order_id.to_s == latest_close.order_id.to_s}
+        latest_close.amount = closes.collect{|x| x.usd.to_d }.sum.abs
+        latest_close.quantity = closes.collect{|x| x.btc.to_d }.sum.abs
+        latest_close.save!
+        
+        next_price, next_quantity = get_next_price_and_quantity
+        if (next_quantity * next_price) > self.class.minimum_amount_for_closing
+          create_order_and_close_position(next_quantity, next_price)
+        else
+          self.btc_profit = get_btc_profit
+          self.usd_profit = get_usd_profit
+          self.done = true
+          Robot.logger.info("Closing: Finished #{self.class.name} ##{id}"\
+            "earned $#{self.usd_profit} and #{self.btc_profit} BTC. ")
+          save!
+        end
+      elsif latest_close.created_at < self.class.close_time_to_live.seconds.ago
+        Robot.with_cooldown{ order.cancel! }
+      end
+    end
+    
+    # When placing a closing order we need to be aware of the smallest order
+    # amount permitted by the other exchange.
+    # If the other order is less than this USD amount then we do not attempt
+    # to close the positions yet.
+    def self.minimum_amount_for_closing
+      5
+    end
+    
+    def self.close_time_to_live
+      60
+    end
+  end
+end

data/lib/bitex_bot/models/open_buy.rb

@@ -0,0 +1,11 @@
+# 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 BitexBot::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, lambda{ where('closing_flow_id IS NULL') }
+end

data/lib/bitex_bot/models/open_sell.rb

@@ -0,0 +1,11 @@
+# An OpenSell represents a Sell transaction on Bitex.
+# OpenSells are open sell positions that are closed by one
+# SellClosingFlow
+# TODO: document attributes.
+class BitexBot::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, lambda{ where('closing_flow_id IS NULL') }
+end

data/lib/bitex_bot/models/opening_flow.rb

@@ -0,0 +1,114 @@
+module BitexBot
+  # Any arbitrage workflow has 2 stages, opening positions and then closing them.
+  # The OpeningFlow stage places an order on bitex, detecting and storing all
+  # transactions spawn from that order as Open positions.
+  class OpeningFlow < ActiveRecord::Base
+    self.abstract_class = true
+    
+    def self.active
+      where('status != "finalised"')
+    end
+    
+    def self.old_active
+      where('status != "finalised" AND created_at < ?',
+        Settings.time_to_live.seconds.ago)
+    end
+
+    # @!group Statuses
+
+    # All possible flow statuses
+    # @return [Array<String>]
+    def self.statuses
+      %w(executing settling finalised)
+    end
+
+    # The Bitex order has been placed, its id stored as order_id.
+    def executing?; status == 'executing'; end
+
+    # In process of cancelling the Bitex order and any other outstanding order in the
+    # other exchange.
+    def settling?; status == 'settling'; end
+
+    # Successfully settled or finished executing.
+    def finalised?; status == 'finalised'; end
+    # @!endgroup
+
+    validates :status, presence: true, inclusion: {in: statuses}
+    validates :order_id, presence: true
+    validates_presence_of :price, :value_to_use
+
+    def self.create_for_market(remote_balance, order_book, transactions,
+      bitex_fee, other_fee)
+
+      plus_bitex = value_to_use + (value_to_use * bitex_fee / 100.0)
+      value_to_use_needed = plus_bitex / (1 - other_fee / 100.0)
+      
+      safest_price = get_safest_price(transactions, order_book,
+        value_to_use_needed)
+
+      remote_value_to_use = get_remote_value_to_use(value_to_use_needed, safest_price)
+      
+      if remote_value_to_use > remote_balance
+        raise CannotCreateFlow.new(
+          "Needed #{remote_value_to_use} but you only have #{remote_balance}")
+      end
+
+      bitex_price = get_bitex_price(value_to_use, remote_value_to_use)      
+
+      order = order_class.create!(:btc, value_to_use, bitex_price, true)
+      if order_is_executing?(order)
+        raise CannotCreateFlow.new(
+          "You need to have #{value_to_use} on bitex to place this
+          #{order_class.name}.")
+      end
+      Robot.logger.info("Opening: Placed #{order_class.name} ##{order.id} " \
+        "#{value_to_use} @ $#{bitex_price} (#{remote_value_to_use})")
+      begin 
+        self.create!(price: bitex_price, value_to_use: value_to_use,
+          suggested_closing_price: safest_price, status: 'executing', order_id: order.id)
+      rescue StandardError => e
+        raise CannotCreateFlow.new(e.message)
+      end
+    end
+
+    # Buys on bitex represent open positions, we mirror them locally
+    # so that we can plan on how to close them.
+    def self.sync_open_positions
+      threshold = open_position_class.order('created_at DESC').first.try(:created_at)
+      Bitex::Transaction.all.collect do |transaction|
+        next unless transaction.is_a?(transaction_class)
+        next if threshold && transaction.created_at < threshold
+        next if open_position_class.find_by_transaction_id(transaction.id)
+        next if transaction.specie != :btc
+        next unless flow = find_by_order_id(transaction_order_id(transaction))
+        Robot.logger.info("Opening: #{name} ##{flow.id} "\
+          "was hit for #{transaction.quantity} BTC @ $#{transaction.price}")
+        open_position_class.create!(
+          transaction_id: transaction.id,
+          price: transaction.price,
+          amount: transaction.amount,
+          quantity: transaction.quantity,
+          opening_flow: flow)
+      end.compact
+    end
+    
+    def finalise!
+      order = self.class.order_class.find(order_id)
+      if order.nil?
+        Robot.logger.info(
+          "Opening: #{self.class.order_class.name} ##{order_id} was too old.")
+        self.status = 'finalised'
+        save!
+      else
+        order.cancel!
+        unless settling?
+          self.status = 'settling'
+          save!
+        end
+      end
+    end
+  end   
+
+  # @visibility private
+  class CannotCreateFlow < StandardError; end
+end

data/lib/bitex_bot/models/order_book_simulator.rb

@@ -0,0 +1,75 @@
+# 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)
+
+    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
+        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
+          seen += amount
+        end
+      end
+    end
+  end
+
+private
+
+  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
+end