bitex_bot 0.0.1

data/lib/bitex_bot/models/sell_closing_flow.rb

@@ -0,0 +1,36 @@
+module BitexBot
+  class SellClosingFlow < ClosingFlow
+    has_many :open_positions, class_name: 'OpenSell', foreign_key: :closing_flow_id
+    has_many :close_positions, class_name: 'CloseSell', foreign_key: :closing_flow_id
+    scope :active, lambda { where(done: false) }
+    
+    def self.open_position_class
+      OpenSell
+    end
+
+    def order_method
+      :buy
+    end
+      
+    # The amount received when selling initially, minus
+    # the amount spent re-buying the sold coins.
+    def get_usd_profit
+      open_positions.sum(:amount) - close_positions.sum(:amount)
+    end
+    
+    # The coins we actually bought minus the coins we were supposed
+    # to re-buy
+    def get_btc_profit
+      close_positions.sum(:quantity) - 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 * desired_price) - closes.sum(:amount)) / next_price
+      [next_price, next_quantity]
+    end
+  end
+end

data/lib/bitex_bot/models/sell_opening_flow.rb

@@ -0,0 +1,82 @@
+module BitexBot
+  # A workflow for selling bitcoin in Bitex and buying on another exchange.  The
+  # SellOpeningFlow factory function estimates how much you could buy on the other
+  # exchange and calculates a reasonable price taking into account the remote
+  # orderbook and the recent operated volume.
+  #
+  # When created, a SellOpeningFlow places an Ask on Bitex for the calculated
+  # quantity and price, when the Ask is matched on Bitex an OpenSell is
+  # created to buy the same quantity for a lower price on the other exchange.
+  #
+  # A SellOpeningFlow can be cancelled at any point, which will cancel the Bitex
+  # order and any orders on the remote exchange created from its OpenSell's
+  # 
+  # @attr order_id The first thing a SellOpeningFlow does is placing an Ask on Bitex,
+  #   this is its unique id. 
+  class SellOpeningFlow < OpeningFlow
+    
+    # Start a workflow for selling bitcoin on bitex and buying on the other
+    # exchange. The quantity to be sold on bitex is retrieved from Settings, if
+    # there is not enough BTC on bitex or USD on the other exchange then no
+    # order will be placed and an exception will be raised instead.
+    # The amount a SellOpeningFlow will try to sell and the price it will try to
+    # charge are derived from these parameters:
+    # 
+    # @param usd_balance [BigDecimal] amount of usd available in the other
+    #   exchange that can be spent to balance this sale.
+    # @param order_book [[price, quantity]] a list of lists representing an ask
+    #   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 [SellOpeningFlow] The newly created flow.
+    # @raise [CannotCreateFlow] If there's any problem creating this flow, for
+    #   example when you run out of BTC on bitex or out of USD on the other
+    #   exchange.
+    def self.create_for_market(usd_balance, order_book, transactions,
+      bitex_fee, other_fee)
+      super
+    end
+    
+    def self.open_position_class
+      OpenSell
+    end
+    
+    def self.transaction_class
+      Bitex::Sell
+    end
+    
+    def self.transaction_order_id(transaction)
+      transaction.ask_id
+    end
+
+    def self.order_class
+      Bitex::Ask
+    end
+
+    def self.value_to_use
+      Settings.selling.quantity_to_sell_per_order
+    end
+    
+    def self.get_safest_price(transactions, order_book, bitcoins_to_use)
+      OrderBookSimulator.run(Settings.time_to_live, transactions,
+        order_book, nil, bitcoins_to_use)
+    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_quantity == order.quantity
+    end
+      
+    def self.get_bitex_price(btc_to_sell, usd_to_spend_re_buying) 
+     (usd_to_spend_re_buying / btc_to_sell) * (1 + Settings.selling.profit / 100.0)
+    end
+  end
+end

data/lib/bitex_bot/robot.rb

@@ -0,0 +1,173 @@
+trap "INT" do
+  if BitexBot::Robot.graceful_shutdown
+    print "\b"
+    BitexBot::Robot.logger.info("Ok, ok, I'm out.")
+    exit 1
+  end
+  BitexBot::Robot.graceful_shutdown = true
+  BitexBot::Robot.logger.info("Shutting down as soon as I've cleaned up.")
+end
+
+module BitexBot
+  class Robot
+    cattr_accessor :graceful_shutdown
+    cattr_accessor :cooldown_until
+    cattr_accessor :test_mode
+    cattr_accessor :logger do
+      Logger.new(Settings.log.file || STDOUT, 10, 10240000).tap do |l|
+        l.level = Logger.const_get(Settings.log.level.upcase)
+        l.formatter = proc do |severity, datetime, progname, msg|
+          date = datetime.strftime("%m/%d %H:%M:%S.%L")
+          "#{ '%-6s' % severity } #{date}: #{msg}\n"
+        end
+      end
+    end
+    cattr_accessor :current_cooldowns do 0 end
+
+    # Trade constantly respecting cooldown times so that we don't get
+    # banned by api clients.
+    def self.run!
+      setup
+      logger.info("Loading trading robot, ctrl+c *once* to exit gracefully.")
+      self.cooldown_until = Time.now
+      bot = new
+
+      while true
+        start_time = Time.now
+        return if start_time < cooldown_until
+        self.current_cooldowns = 0
+        bot.trade!
+        self.cooldown_until = start_time + current_cooldowns.seconds
+      end
+    end
+    
+    def self.setup
+      Bitex.api_key = Settings.bitex
+      Bitstamp.setup do |config|
+        config.key = Settings.bitstamp.key
+        config.secret = Settings.bitstamp.secret
+        config.client_id = Settings.bitstamp.client_id.to_s
+      end
+    end
+  
+    def self.with_cooldown(&block)
+      result = block.call
+      return result if test_mode
+      self.current_cooldowns += 1
+      sleep 0.1 
+      return result
+    end
+
+    def with_cooldown(&block)
+      self.class.with_cooldown(&block)
+    end
+
+    def trade!
+      finalise_some_opening_flows
+      if(!active_opening_flows? && !open_positions? &&
+        !active_closing_flows? && self.class.graceful_shutdown)
+        self.class.logger.info("Shutdown completed")
+        exit
+      end
+      sync_opening_flows if active_opening_flows?
+      start_closing_flows if open_positions?
+      sync_closing_flows if active_closing_flows?
+      start_opening_flows_if_needed
+    rescue CannotCreateFlow => e
+      self.notify("#{e.message}:\n\n#{e.backtrace.join("\n")}")
+      BitexBot::Robot.graceful_shutdown = true
+    rescue StandardError => e
+      self.notify("#{e.message}:\n\n#{e.backtrace.join("\n")}")
+      sleep 30 unless self.class.test_mode
+    end
+    
+    def finalise_some_opening_flows
+      [BuyOpeningFlow, SellOpeningFlow].each do |kind|
+        flows = self.class.graceful_shutdown ? kind.active : kind.old_active
+        flows.each{|flow| flow.finalise! }
+      end
+    end
+    
+    def start_closing_flows
+      [BuyClosingFlow, SellClosingFlow].each{|kind| kind.close_open_positions}
+    end
+
+    def open_positions?
+      OpenBuy.open.exists? || OpenSell.open.exists?
+    end
+    
+    def sync_closing_flows
+      orders = with_cooldown{ Bitstamp.orders.all }
+      transactions = with_cooldown{ Bitstamp.user_transactions.all }
+
+      [BuyClosingFlow, SellClosingFlow].each do |kind|
+        kind.active.each do |flow|
+          flow.sync_closed_positions(orders, transactions)
+        end
+      end
+    end
+    
+    def active_closing_flows?
+      BuyClosingFlow.active.exists? || SellClosingFlow.active.exists?
+    end
+    
+    def start_opening_flows_if_needed
+      return if open_positions?
+      return if active_closing_flows?
+      return if self.class.graceful_shutdown
+      
+      
+      recent_buying, recent_selling =
+        [BuyOpeningFlow, SellOpeningFlow].collect do |kind|
+          threshold = (Settings.time_to_live / 2).seconds.ago
+          kind.active.where('created_at > ?', threshold).first
+        end
+
+      return if recent_buying && recent_selling
+      
+      balances = with_cooldown{ Bitstamp.balance }
+      order_book = with_cooldown{ Bitstamp.order_book }
+      transactions = with_cooldown{ Bitstamp.transactions }
+      
+      unless recent_buying
+        BuyOpeningFlow.create_for_market(
+          balances['btc_available'].to_d,
+          order_book['bids'],
+          transactions,
+          Bitex::Profile.get[:fee],
+          balances['fee'].to_d )
+      end
+      unless recent_selling
+        SellOpeningFlow.create_for_market(
+          balances['usd_available'].to_d,
+          order_book['asks'],
+          transactions,
+          Bitex::Profile.get[:fee],
+          balances['fee'].to_d )
+      end
+    end
+    
+    def sync_opening_flows
+      [SellOpeningFlow, BuyOpeningFlow].each{|o| o.sync_open_positions }
+    end
+    
+    def active_opening_flows?
+      BuyOpeningFlow.active.exists? || SellOpeningFlow.active.exists?
+    end
+    
+    def notify(message)
+      self.class.logger.error(message)
+      if Settings.mailer
+        mail = Mail.new do
+          from Settings.mailer.from
+          to Settings.mailer.to
+          subject 'Notice from your robot trader'
+          body message
+        end
+        mail.delivery_method(Settings.mailer.method.to_sym,
+          Settings.mailer.options.symbolize_keys)
+        mail.deliver!
+      end
+    end
+  end
+end

data/lib/bitex_bot/settings.rb

@@ -0,0 +1,13 @@
+require 'settingslogic'
+require 'debugger'
+class BitexBot::Settings < Settingslogic
+  path = File.expand_path('bitex_bot_settings.yml', Dir.pwd)
+  unless FileTest.exists?(path)
+    sample_path = File.expand_path('../../../settings.yml.sample', __FILE__)
+    FileUtils.cp(sample_path, path)
+    puts "No settings found, I've created a new one with sample "\
+      "values at #{path}. Please go ahead and edit it before running this again."
+    exit 1
+  end
+  source path
+end

data/lib/bitex_bot/version.rb

@@ -0,0 +1,3 @@
+module BitexBot
+  VERSION = "0.0.1"
+end

data/lib/bitex_bot.rb

@@ -0,0 +1,18 @@
+require "bitex_bot/version"
+require "active_support"
+require "active_record"
+require "active_model"
+require "mail"
+require "logger"
+require "bitex"
+require "bitstamp"
+require "bitex_bot/settings"
+require "bitex_bot/database"
+require "debugger"
+require "bitex_bot/models/opening_flow.rb"
+require "bitex_bot/models/closing_flow.rb"
+Dir[File.dirname(__FILE__) + '/bitex_bot/models/*.rb'].each {|file| require file }
+require "bitex_bot/robot"
+
+module BitexBot
+end

data/settings.yml.sample

@@ -0,0 +1,84 @@
+log:
+  # File to write log to. The log is rotated every 10240000 bytes, 10 oldest
+  # logs are kept around.
+  # If you want to log to stdout you can comment this line.
+  file: bitex_bot.log
+  # How much information to show in the log, valid values are debug, info, error
+  level: info
+
+# Seconds to keep an order alive before recalculating the price and replacing it.
+# Given the way in which the robot tries to find the safest price to place an
+# order, if the time to live is too long the price is not going to be
+# competitive. About 20 seconds is a good number here.
+time_to_live: 20
+
+# Settings for buying on bitex and selling on bitstamp.
+buying:
+  # Dollars to spend on each initial bitex bid.
+  # Should at least be 10.0 which is the current minimum order size on Bitex.
+  # if it's too large you're taking a higher risk if whatever happens and you
+  # cannot re sell it afterwards. Also, higher amounts result in your bitex
+  # bid price not being competitive.
+  # A number between 10.0 and 1000.0 is reccommended.
+  amount_to_spend_per_order: 10.0
+  
+  # Your profit when buying on bitex, 0.5 means 0.5%.
+  # After calculating the price at which bitcoins can be sold on bitstamp, the
+  # robot deduces your profit from that price, and places a bid on bitex paying
+  # a lower price.
+  profit: 0.5
+
+# Settings for selling on bitex and buying on bitstamp.
+selling:
+  # Quantity to sell on each initial bitex Ask.
+  # It should be at least 10 USD worth of BTC at current market prices, a bit
+  # more just to be safe. Otherwise Bitex will reject your orders for being too
+  # small.
+  # If it's too large then you're taking a risk if whatever happens and you 
+  # If it's too small then the robot is pointless, and if it's too large you're
+  # taking a higher risk if whatever happens ad you cannot re buy afterwards.
+  # Also, higher amounts result in your bitex bid price not being competitive.
+  # A number between 0.05 and 2.0 is recommended.
+  quantity_to_sell_per_order: 0.1
+  
+  # Your profit when selling on bitex, 0.5 means 0.5%.
+  # After calculating the price at which bitcoins can be bought on bitstamp,
+  # the robot deduces your profit from that price and places an ask on bitex
+  # charging a higher price.
+  profit: 0.5
+
+# This is your bitex api key, it's passed in to the
+# bitex gem: https://github.com/bitex-la/bitex-ruby
+bitex: your_bitex_api_key_which_should_be_kept_safe
+
+# These are passed in to the bitstamp gem:
+# see https://github.com/kojnapp/bitstamp for more info.
+bitstamp:
+  key: YOUR_API_KEY
+  secret: YOUR_API_SECRET
+  client_id: YOUR_BITSTAMP_USERNAME
+
+# Settings for the ActiveRecord Database to use.
+# sqlite is just fine. Check this link for more options:
+# http://apidock.com/rails/ActiveRecord/Base/establish_connection/class
+database:
+  adapter: sqlite3
+  database: bitex_bot.db 
+
+# The robot sends you emails whenever a problem occurs.
+# If you do not want to receive emails just remove this 'mailer'
+# key and everything under it.
+# It uses https://github.com/mikel/mail under the hood, so method
+# is any valid delivery_method for teh mail gem.
+# Options is the options hash passed in to delivery_method.
+mailer:
+  from: 'robot@example.com'
+  to: 'you@example.com'
+  method: smtp
+  options:
+    address: "your_smtp_server_address.com"
+    port: 587
+    authentication: "plain"
+    enable_starttls_auto: true
+    user_name: 'your_user_name'
+    password: 'your_smtp_password'

data/spec/factories/bitex_buy.rb

@@ -0,0 +1,12 @@
+FactoryGirl.define do
+  factory :bitex_buy, class: Bitex::Buy do
+    id 12345678
+    created_at{ Time.now }
+    specie :btc
+    quantity 2.0
+    amount 600.0
+    fee 0.05
+    price 300.0
+    bid_id 12345
+  end
+end

data/spec/factories/bitex_sell.rb

@@ -0,0 +1,12 @@
+FactoryGirl.define do
+  factory :bitex_sell, class: Bitex::Sell do
+    id 12345678
+    created_at{ Time.now }
+    specie :btc
+    quantity 2.0
+    amount 600.0
+    fee 0.05
+    price 300.0
+    ask_id 12345
+  end
+end

data/spec/factories/buy_opening_flow.rb

@@ -0,0 +1,17 @@
+FactoryGirl.define do
+  factory :buy_opening_flow, class: BitexBot::BuyOpeningFlow do
+    price 300.0
+    value_to_use 600.0
+    suggested_closing_price 310.0
+    status 'executing'
+    order_id 12345
+  end
+
+  factory :other_buy_opening_flow, class: BitexBot::BuyOpeningFlow do
+    price 400.0
+    value_to_use 400.0
+    suggested_closing_price 410.0
+    status 'executing'
+    order_id 2
+  end
+end

data/spec/factories/open_buy.rb

@@ -0,0 +1,17 @@
+FactoryGirl.define do
+  factory :open_buy, class: BitexBot::OpenBuy do
+    price 300.0
+    amount 600.0
+    quantity 2.0
+    transaction_id 12345678
+    association :opening_flow, factory: :buy_opening_flow 
+  end
+  
+  factory :tiny_open_buy, class: BitexBot::OpenBuy do
+    price 400.0
+    amount 4.0
+    quantity 0.01
+    transaction_id 23456789
+    association :opening_flow, factory: :other_buy_opening_flow 
+  end
+end

data/spec/factories/open_sell.rb

@@ -0,0 +1,17 @@
+FactoryGirl.define do
+  factory :open_sell, class: BitexBot::OpenSell do
+    price 300.0
+    amount 600.0
+    quantity 2.0
+    transaction_id 12345678
+    association :opening_flow, factory: :sell_opening_flow 
+  end
+  
+  factory :tiny_open_sell, class: BitexBot::OpenSell do
+    price 400.0
+    amount 4.0
+    quantity 0.01
+    transaction_id 23456789
+    association :opening_flow, factory: :other_sell_opening_flow 
+  end
+end

data/spec/factories/sell_opening_flow.rb

@@ -0,0 +1,17 @@
+FactoryGirl.define do
+  factory :sell_opening_flow, class: BitexBot::SellOpeningFlow do
+    price 300.0
+    value_to_use 2.0
+    suggested_closing_price 290.0
+    status 'executing'
+    order_id 12345
+  end
+
+  factory :other_sell_opening_flow, class: BitexBot::SellOpeningFlow do
+    price 400.0
+    value_to_use 1.0
+    suggested_closing_price 390.0
+    status 'executing'
+    order_id 2
+  end
+end

data/spec/models/buy_closing_flow_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe BitexBot::BuyClosingFlow do
+  it "closes a single open position completely" do
+    stub_bitstamp_sell
+    open = create :open_buy
+    flow = BitexBot::BuyClosingFlow.close_open_positions
+    open.reload.closing_flow.should == flow
+    flow.open_positions.should == [open]
+    flow.desired_price.should == 310
+    flow.quantity.should == 2
+    flow.btc_profit.should be_nil
+    flow.usd_profit.should be_nil
+    close = flow.close_positions.first
+    close.order_id.should == 1
+    close.amount.should be_nil
+    close.quantity.should be_nil
+  end
+  
+  it "closes an aggregate of several open positions" do
+    stub_bitstamp_sell
+    open_one = create :tiny_open_buy
+    open_two = create :open_buy
+    flow = BitexBot::BuyClosingFlow.close_open_positions
+    close = flow.close_positions.first
+    open_one.reload.closing_flow.should == flow
+    open_two.reload.closing_flow.should == flow
+    flow.open_positions.should == [open_one, open_two]
+    flow.desired_price.should == '310.497512437810945273631840797'.to_d
+    flow.quantity.should == 2.01
+    flow.btc_profit.should be_nil
+    flow.usd_profit.should be_nil
+    close.order_id.should == 1
+    close.amount.should be_nil
+    close.quantity.should be_nil
+  end
+  
+  it "does not try to close if the amount is too low" do
+    open = create :tiny_open_buy
+    expect do
+      BitexBot::BuyClosingFlow.close_open_positions.should be_nil
+    end.not_to change{ BitexBot::BuyClosingFlow.count }
+  end
+  
+  it "does not try to close if there are no open positions" do
+    expect do
+      BitexBot::BuyClosingFlow.close_open_positions.should be_nil
+    end.not_to change{ BitexBot::BuyClosingFlow.count }
+  end
+  
+  describe "when syncinc executed orders" do
+    before(:each) do
+      stub_bitstamp_sell
+      stub_bitstamp_user_transactions
+      create :tiny_open_buy
+      create :open_buy
+    end
+  
+    it "syncs the executed orders, calculates profit" do
+      flow = BitexBot::BuyClosingFlow.close_open_positions
+      stub_bitstamp_orders_into_transactions
+      flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      close = flow.close_positions.last
+      close.amount.should == 624.1
+      close.quantity.should == 2.01
+      flow.should be_done
+      flow.btc_profit.should == 0
+      flow.usd_profit.should == 20.1
+    end
+  
+    it "retries closing at a lower price every minute" do
+      flow = BitexBot::BuyClosingFlow.close_open_positions
+      expect do
+        flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      end.not_to change{ BitexBot::CloseBuy.count }
+      flow.should_not be_done
+
+      # Immediately calling sync again does not try to cancel the ask.
+      flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      Bitstamp.orders.all.size.should == 1
+
+      # Partially executes order, and 61 seconds after that
+      # sync_closed_positions tries to cancel it.
+      stub_bitstamp_orders_into_transactions(ratio: 0.5)
+      Timecop.travel 61.seconds.from_now
+      Bitstamp.orders.all.size.should == 1
+      expect do
+        flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      end.not_to change{ BitexBot::CloseBuy.count }
+      Bitstamp.orders.all.size.should == 0
+      flow.should_not be_done
+      
+      # Next time we try to sync_closed_positions the flow
+      # detects the previous close_buy was cancelled correctly so
+      # it syncs it's total amounts and tries to place a new one.
+      expect do
+        flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      end.to change{ BitexBot::CloseBuy.count }.by(1)
+      flow.close_positions.first.tap do |close|
+        close.amount.should == 312.05
+        close.quantity.should == 1.005
+      end
+
+      # The second ask is executed completely so we can wrap it up and consider
+      # this closing flow done.
+      stub_bitstamp_orders_into_transactions
+      flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      flow.close_positions.last.tap do |close|
+        close.amount.should == 312.0299
+        close.quantity.should == 1.005
+      end
+      flow.should be_done
+      flow.btc_profit.should == 0
+      flow.usd_profit.should == 20.0799
+    end
+    
+    it "does not retry for an amount less than minimum_for_closing" do
+      flow = BitexBot::BuyClosingFlow.close_open_positions
+
+      stub_bitstamp_orders_into_transactions(ratio: 0.999)
+      Bitstamp.orders.all.first.cancel!
+
+      expect do
+        flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      end.not_to change{ BitexBot::CloseBuy.count }
+
+      flow.should be_done
+      flow.btc_profit.should == 0.00201
+      flow.usd_profit.should == 19.4759
+    end
+    
+    it "can lose USD if price had to be dropped dramatically" do
+      # This flow is forced to sell the original BTC quantity for less, thus regaining
+      # less USD than what was spent on bitex.
+      flow = BitexBot::BuyClosingFlow.close_open_positions
+      60.times do 
+        Timecop.travel 60.seconds.from_now
+        flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      end
+
+      stub_bitstamp_orders_into_transactions
+
+      flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+
+      flow.reload.should be_done
+      flow.btc_profit.should == 0
+      flow.usd_profit.should == -16.08
+    end
+  end
+end