devilicious 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 86c8535c1f1dc7924d4344803a1490359657c349
+  data.tar.gz: 0de03730367cbca3c56fb8c66f1c7a05d32663c0
+SHA512:
+  metadata.gz: 559c597ff4ff70c7e6057016a8d47b73f7eb227f4a60e9cffff8792ecf83fc669ce8df6a45edbba9f68d3a0aa9762a8919397dca93ed7c40b8f12244ca5aeb43
+  data.tar.gz: 976cbe3219761aef3e78bef22e994eb50a29fb3a9367881dcab241ffcada2870f6ed4b249b667f522371924bf663758a249a8f641bb27f8315bb8285c252cb83

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,15 @@
+Devilicious
+Copyright (C) 2014 Cédric Félizard
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/README.md

@@ -0,0 +1,52 @@
+# Devilicious
+
+**Disclaimer: Do not expect to make money with this program.**
+
+This RubyGem is just an experiment to find out whether or not there are (still) arbitrage opportunities across Bitcoin markets (as of August 2014).
+
+Spoiler: Meh, not really.
+
+Supported exchanges are:
+
+- Kraken (EUR)
+- BitcoinDe (EUR)
+- BTCE (EUR)
+- HitBTC (EUR)
+- Bitcurex (EUR)
+- Bitstamp (USD)
+- BitNZ (NZD)
+- ANXBTC (CHF)
+
+I've been running it for a couple of days and my findings are:
+
+- the best volume to trade is usually in the 1 to 5 bitcoins range
+- you won't make more than €30/$40 even trading when the price is on a rollercoaster (specifically mid August 2014)
+- you'll need to trade 3+ bitcoins to make those 40 bucks
+- in order to trade across a bunch of markets, you'll need to have a lot of funds in every exchanges (since you want to buy/sell at the same time)
+- high frequency trading might work out better but fuck that, it just adds noise to the blockchain
+
+**Disclaimer #2: This code is quite crappy.**
+
+This is a just-for-fun quick-and-dirty not-optimized-at-all pretty-dumb program.
+Worst of all, it doesn't even have tests!
+
+**Disclaimer #3: Obviously, use this program at your own risks!**
+
+## Installation
+
+`gem install devilicious`
+
+## Usage
+
+`devilicious --help` is your friend.
+
+Example: `devilicious -f Table -m 2 -b 30`
+
+## License
+
+AGPLv3
+
+## Bonus link
+
+http://www.reddit.com/r/Bitcoin/comments/2dqhiy/8month_high/cjs416y
+

data/Rakefile

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

data/bin/devilicious

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+begin
+  require "devilicious"
+rescue LoadError
+  $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+  Dir[File.expand_path("../lib/**/*.rb", __dir__)].each { |file| require file }
+end
+
+
+arbitrer = Devilicious::Arbitrer.new
+arbitrer.run!
+

data/devilicious.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "devilicious"
+  spec.version       = "1.0.0"
+  spec.authors       = ["Cédric Félizard"]
+  spec.email         = ["cedric@felizard.fr"]
+  spec.summary       = %q{Multi-currency Bitcoin arbitrage bot}
+  spec.description   = spec.summary
+  spec.homepage      = ""
+  spec.license       = "AGPLv3"
+
+  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 "retryable"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+end

data/lib/devilicious.rb

@@ -0,0 +1,6 @@
+module Devilicious
+  def self.config
+    @config ||= Config.parse(ARGV)
+  end
+end
+

data/lib/devilicious/arbitrer.rb

@@ -0,0 +1,160 @@
+module Devilicious
+  class Arbitrer
+    def markets
+      @markets ||= [
+
+        Market::Kraken,
+        Market::BitcoinDe,
+        Market::BtcE,
+        Market::HitBtc,
+        Market::Bitcurex,
+        Market::Bitstamp,
+        Market::BitNz,
+        Market::AnxBtc,
+
+      ].map { |market| market.new }
+    end
+
+    def run!
+      @market_queue = []
+      spawn_observers!
+
+      loop do
+        sleep 1 while @market_queue.empty?
+
+        market_1 = @market_queue.shift
+
+        markets.each do |market_2|
+          next if market_1 == market_2
+
+          if market_2.order_book.nil?
+            Log.debug "Order book for #{market_2} not available yet, skipping"
+            next
+          end
+
+          # dup everything to avoid race conditions while calculating opportunities
+          order_book_1 = market_1.order_book.dup
+          order_book_2 = market_2.order_book.dup
+          order_book_1.market = market_1.dup
+          order_book_2.market = market_2.dup
+
+          check_for_opportunity(order_book_1, order_book_2)
+          check_for_opportunity(order_book_2, order_book_1)
+        end
+      end
+    end
+
+  private
+
+    def spawn_observers!
+      Thread.abort_on_exception = true
+      trap("EXIT", -> { Thread.list.each(&:kill) } )
+
+      Thread.new do
+        timeout = Devilicious.config.market_refresh_rate
+
+        loop do
+          threads = markets.map do |market|
+            Log.debug "Refreshing order book for #{market}..."
+            Thread.new { market.refresh_order_book!; @market_queue << market }
+          end
+
+          sleep timeout
+
+          alive_threads = threads.select(&:alive?)
+          unless alive_threads.empty?
+            Log.warn "Timeout after #{timeout} seconds for #{alive_threads.size} observer threads"
+          end
+
+          threads.each do |thread|
+            thread.abort_on_exception = false
+            thread.kill
+          end
+
+          threads.each(&:join)
+        end
+      end
+    end
+
+    def check_for_opportunity(order_book_1, order_book_2)
+      Log.debug "Checking opportunity buying from #{order_book_1.market} and selling at #{order_book_2.market}... "
+      if opportunity = find_best_opportunity(order_book_1, order_book_2)
+        threshold = Money.new(Devilicious.config.beep_profit_threshold, Devilicious.config.default_fiat_currency)
+        if threshold > 0 && opportunity.profit >= threshold
+          Thread.new do
+            3.times { system "/usr/bin/aplay", "-q", "#{__dir__}/sounds/boom.wav" }
+          end
+        end
+
+        formatter = Formatter.list[Devilicious.config.formatter]
+        formatter.output(opportunity)
+      end
+    end
+
+    def find_best_opportunity(order_book_1, order_book_2)
+      return unless order_book_1.lowest_ask.price < order_book_2.highest_bid.price
+
+      initial_ask_offer = order_book_1.weighted_asks_up_to(order_book_2.highest_bid.price)
+      initial_bid_offer = order_book_2.weighted_bids_down_to(order_book_1.lowest_ask.price)
+
+      _dummy = initial_ask_offer.price + initial_bid_offer.price # NOTE: will raise if currency mismatch
+
+      max_volume = [initial_ask_offer.volume, initial_bid_offer.volume].min
+
+      best_offer_limited_volume = find_best_volume(
+        order_book_1, order_book_2,
+        [max_volume, Devilicious.config.max_volume].min
+      )
+
+      best_offer_unlimited_volume = find_best_volume(
+        order_book_1, order_book_2,
+        [max_volume, BigDecimal.new("22E6")].min
+      )
+
+      best_volume = if best_offer_limited_volume.profit > best_offer_unlimited_volume.profit
+        best_offer_limited_volume
+      else
+        best_offer_unlimited_volume
+      end.volume
+
+      return if best_offer_limited_volume.profit <= 0
+
+      best_offer_limited_volume.best_volume = best_volume
+
+      best_offer_limited_volume
+    end
+
+    def find_best_volume(order_book_1, order_book_2, max_volume)
+      volume = best_volume = BigDecimal.new(Devilicious.config.min_volume)
+      best_profit = 0
+
+      while volume <= max_volume
+        ask_offer = order_book_1.min_ask_price_for_volume(order_book_2.highest_bid.price, volume)
+        bid_offer = order_book_2.max_bid_price_for_volume(order_book_1.lowest_ask.price, volume)
+
+        fee = (
+          ask_offer.price * order_book_1.market.trade_fee +
+          bid_offer.price * order_book_2.market.trade_fee
+        ) * volume
+
+        profit = (bid_offer.price - ask_offer.price) * volume - fee
+
+        if profit > best_profit
+          best_profit, best_volume, best_profit_fee = profit, volume, fee
+        end
+
+        volume += BigDecimal.new("0.1")
+      end
+
+      OpenStruct.new(
+        order_book_1: order_book_1,
+        order_book_2: order_book_2,
+        ask_offer: order_book_1.min_ask_price_for_volume(order_book_2.highest_bid.price, best_volume),
+        bid_offer: order_book_2.max_bid_price_for_volume(order_book_1.lowest_ask.price, best_volume),
+        volume: best_volume,
+        profit: best_profit,
+        fee: best_profit_fee,
+      )
+    end
+  end
+end

data/lib/devilicious/config.rb

@@ -0,0 +1,54 @@
+require "optparse"
+require "ostruct"
+
+module Devilicious
+  class Config
+    def self.parse(args)
+      config = OpenStruct.new
+      config.debug = false
+      config.verbose = false
+      config.formatter = "Verbose"
+      config.max_volume = BigDecimal.new("10")
+      config.min_volume = BigDecimal.new("0.1")
+      config.beep_profit_threshold = BigDecimal.new("-1") # negative means disabled
+      config.default_fiat_currency = "EUR" # ideally the most used currency so we do as little conversions as possible
+      config.market_refresh_rate = 30 # order books expire delay in seconds
+
+      opt_parser = OptionParser.new do |opts|
+        opts.banner = "Usage: devilicious [config]"
+
+        opts.separator ""
+
+        opts.on("-f", "--formatter TYPE", Formatter.list.keys,
+                "Select formatter (#{Formatter.list.keys.sort.join(", ")})") do |f|
+          config.formatter = f
+        end
+
+        opts.on("-m", "--max-volume N", "Maximum volume to trade") do |m|
+          config.max_volume = BigDecimal.new(m)
+        end
+
+        opts.on("-b", "--beep-profit-threshold N", "Beep the fuck out of the speakers when profit threshold is reached") do |t|
+          config.beep_profit_threshold = BigDecimal.new(t)
+        end
+
+        opts.on("-v", "--verbose", "Run verbosely") do |v|
+          config.verbose = v
+        end
+
+        opts.on("-d", "--debug", "Debug mode") do |d|
+          config.debug = d
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end
+
+      opt_parser.parse!(args)
+      config.freeze
+    end
+  end
+end
+

data/lib/devilicious/currency_converter.rb

@@ -0,0 +1,81 @@
+require "retryable"
+
+module Devilicious
+  class CurrencyConverter
+    @rates = {}
+
+    def self.convert(amount, from, to)
+      amount * rate(from, to)
+    end
+
+    def self.rate from, to
+      pair = [from, to].join
+
+      if @rates[pair].nil? || @rates[pair].updated_at < Time.now - 10*60
+
+        Log.debug "Refreshing #{pair} rate..."
+
+        rate = begin
+          RateExchange.get_rate(from, to)
+        rescue => exception
+          Log.warn "Could not retrieve exchange rate from RateExchange: #{exception.inspect}"
+
+          YahooExchange.get_rate(from, to)
+        end
+
+        @rates[pair] = OpenStruct.new(
+          rate: rate,
+          updated_at: Time.now
+        ).freeze
+
+      end
+
+      @rates[pair].rate
+    end
+
+    class RateExchange
+      URL = "http://rate-exchange.appspot.com/currency?from=%s&to=%s".freeze
+
+      def self.get_rate(from, to)
+        url = URL % [from, to]
+        json = get_json(url)
+        rate = json["rate"].to_s
+        BigDecimal.new(rate)
+      end
+
+      def self.get_json(url)
+        retryable(tries: 3, sleep: 1) do
+          json = open(url).read
+          JSON.parse(json)
+        end
+      end
+    end
+
+    class YahooExchange
+      URL = "http://download.finance.yahoo.com/d/quotes.csv?s=%s%s=X&f=sl1d1&e=.csv".freeze
+
+      def self.get_rate(from, to)
+        url = URL % [from, to]
+        csv = get_csv(url)
+        rate = BigDecimal.new(csv[1].to_s)
+
+        if rate <= 1E-3
+          Log.warn "Cannot retrieve exchange rate for #{from}#{to}, not enough precision, using the opposite pair"
+
+          url = URL % [to, from]
+          csv = get_csv(url)
+          rate = BigDecimal.new(1) / BigDecimal.new(csv[1].to_s)
+        end
+
+        rate
+      end
+
+      def self.get_csv(url)
+        retryable(tries: 3, sleep: 1) do
+          csv = open(url).read
+          csv.split(",")
+        end
+      end
+    end
+  end
+end

data/lib/devilicious/formatters/base.rb

@@ -0,0 +1,22 @@
+module Devilicious
+  module Formatter
+    def self.list
+      @list ||= {}
+    end
+
+    class Base
+      def self.inherited(child)
+        formatter = child.new
+        Formatter.list[formatter.to_s] = formatter
+      end
+
+      def to_s
+        self.class.to_s.gsub(/.*::/, "")
+      end
+    end
+  end
+end
+
+# Dir["#{__dir__}/**/*.rb"].each do |formatter|
+#   require formatter
+# end

data/lib/devilicious/formatters/summary.rb

@@ -0,0 +1,17 @@
+module Devilicious
+  module Formatter
+    class Summary < Base
+      def output(opportunity)
+        pair = [opportunity.order_book_1.market, " to ", opportunity.order_book_2.market, " " * 3].map(&:to_s).join
+        @best_trades ||= {}
+        @best_trades[pair] = opportunity
+
+        Log.info "", timestamp: false
+        @best_trades.sort_by { |_, opportunity| opportunity.profit }.each do |pair, opportunity|
+          Log.info "#{pair} \t#{opportunity.profit} with #{opportunity.volume.to_f} XBT", timestamp: false
+        end
+      end
+    end
+  end
+end
+

data/lib/devilicious/formatters/table.rb

@@ -0,0 +1,20 @@
+module Devilicious
+  module Formatter
+    class Table < Base
+      def output(opportunity)
+        pair = [opportunity.order_book_1.market, " to ", opportunity.order_book_2.market, " " * 4].map(&:to_s).join
+        @best_trades ||= {}
+        @best_trades[pair] = opportunity
+
+        Log.info "", timestamp: false
+        Log.info "PAIR                    \tPROFIT       \tVOLUME \tBUY          \tSELL", timestamp: false
+        @best_trades.sort_by { |_, opportunity| opportunity.profit }.each do |pair, opportunity|
+          pair = pair.dup << " " * [30 - pair.size, 0].max # padding
+          Log.info [pair, opportunity.profit, opportunity.volume.to_f, opportunity.ask_offer.price, opportunity.bid_offer.price].join(" \t"), timestamp: false
+        end
+      end
+    end
+  end
+end
+
+

data/lib/devilicious/formatters/verbose.rb

@@ -0,0 +1,26 @@
+module Devilicious
+  module Formatter
+    class Verbose < Base
+      def output(opportunity)
+        fiat_out = opportunity.ask_offer.price * opportunity.volume
+        fiat_in = opportunity.bid_offer.price * opportunity.volume
+
+        opportunity.ask_offer.price = opportunity.ask_offer.price.exchange_to(opportunity.order_book_1.market.fiat_currency)
+        opportunity.bid_offer.price = opportunity.bid_offer.price.exchange_to(opportunity.order_book_2.market.fiat_currency)
+
+        volume = "#{opportunity.volume.to_f} XBT "
+        volume << if opportunity.volume == opportunity.best_volume
+          "(BEST VOLUME!)"
+        else
+          "(best #{opportunity.best_volume.to_f})"
+        end
+
+        Log.info \
+          "BUY \e[1m#{volume}\e[m from \e[1m#{opportunity.order_book_1.market}\e[m for #{fiat_out} at \e[1m#{opportunity.ask_offer.price}\e[m (#{opportunity.ask_offer.weighted_price} weighted average)" <<
+          " and SELL at \e[1m#{opportunity.order_book_2.market}\e[m for #{fiat_in} at \e[1m#{opportunity.bid_offer.price}\e[m (#{opportunity.bid_offer.weighted_price})" <<
+          " - PROFIT = \e[1m#{opportunity.profit}\e[m (including #{opportunity.fee} fee)"
+      end
+    end
+  end
+end
+

data/lib/devilicious/log.rb

@@ -0,0 +1,29 @@
+module Devilicious
+  module Log
+    @semaphore ||= Mutex.new
+
+  module_function
+
+    def info message, options = {}
+      options = {
+        output: $stdout,
+        timestamp: true
+      }.merge(options)
+
+      message = "#{Time.now} #{message}" if options.fetch(:timestamp)
+
+      @semaphore.synchronize { options.fetch(:output).puts message }
+    end
+
+    def debug message, options = {}
+      info message, options if Devilicious.config.debug
+    end
+
+    def warn message, options = {}
+      options = {output: $stderr}.merge(options)
+
+      info "[WARN] #{message}", options
+    end
+  end
+end
+

data/lib/devilicious/markets/anx_btc.rb

@@ -0,0 +1,42 @@
+require "devilicious/markets/base"
+
+module Devilicious
+  module Market
+    class AnxBtc < Base
+      def fiat_currency
+        "CHF"
+      end
+
+      def trade_fee
+        BigDecimal.new("0.005").freeze # 0.5%??? - see https://anxbtc.com/faq#tab1
+      end
+
+      def refresh_order_book!
+        json = get_json("https://anxpro.com/api/2/BTC#{fiat_currency}/money/depth/full")
+
+        asks = format_asks_bids(json["data"]["asks"])
+        bids = format_asks_bids(json["data"]["bids"])
+
+        mark_as_refreshed
+        @order_book = OrderBook.new(asks: asks, bids: bids)
+      end
+
+    private
+
+      def format_asks_bids(json)
+        json.map do |tuple|
+          price, volume = tuple["price"], tuple["amount"]
+          price_chf = Money.new(price, fiat_currency)
+          price_normalized = price_chf.exchange_to(Devilicious.config.default_fiat_currency)
+
+          Offer.new(
+            price: price_normalized,
+            volume: volume
+          ).freeze
+        end
+      end
+    end
+  end
+end
+
+

data/lib/devilicious/markets/base.rb

@@ -0,0 +1,37 @@
+require "open-uri"
+require "json"
+require "retryable"
+
+module Devilicious
+  module Market
+    class Base
+      attr_reader :order_book
+
+      def to_s
+        self.class.to_s.gsub(/.*::/, "")
+      end
+
+      def trade_fee
+        raise NotImplementedError
+      end
+
+    private
+
+      def get_html(url)
+        retryable(tries: 5, sleep: 1) do
+          open(url).read
+        end
+      end
+
+      def get_json(url)
+        html = get_html(url)
+        JSON.parse(html)
+      end
+
+      def mark_as_refreshed
+        Log.debug "Order book for #{self} has been refreshed"
+      end
+    end
+  end
+end
+

data/lib/devilicious/markets/bit_nz.rb

@@ -0,0 +1,43 @@
+require "devilicious/markets/base"
+
+module Devilicious
+  module Market
+    class BitNz < Base
+      # NOTE: https://bitnz.com/
+
+      def fiat_currency
+        "NZD"
+      end
+
+      def trade_fee
+        BigDecimal.new("0.005").freeze # 0.5% - see https://bitnz.com/fees
+      end
+
+      def refresh_order_book!
+        json = get_json("https://bitnz.com/api/0/orderbook")
+
+        asks = format_asks_bids(json["asks"])
+        bids = format_asks_bids(json["bids"])
+
+        mark_as_refreshed
+        @order_book = OrderBook.new(asks: asks, bids: bids)
+      end
+
+    private
+
+      def format_asks_bids(json)
+        json.map do |price, volume|
+          price_nzd = Money.new(price.to_s, fiat_currency)
+          price_normalized = price_nzd.exchange_to(Devilicious.config.default_fiat_currency)
+
+          Offer.new(
+            price: price_normalized,
+            volume: volume.to_s
+          ).freeze
+        end
+      end
+    end
+  end
+end
+
+

data/lib/devilicious/markets/bitcoin_de.rb

@@ -0,0 +1,43 @@
+require "devilicious/markets/base"
+
+module Devilicious
+  module Market
+    class BitcoinDe < Base
+      ScrappingError = Class.new(Exception)
+
+      def fiat_currency
+        "EUR"
+      end
+
+      def trade_fee
+        BigDecimal.new("0.005").freeze # 0.5% - see https://www.bitcoin.de/en/infos#gebuehren
+      end
+
+      def refresh_order_book!
+        retryable(tries: 2, sleep: 0, on: ScrappingError) do
+          html = get_html("https://www.bitcoin.de/en/market")
+
+          asks = format_asks_bids(html, "offer")
+          bids = format_asks_bids(html, "order")
+
+          raise ScrappingError if asks.empty? || asks.size != bids.size
+
+          mark_as_refreshed
+          @order_book = OrderBook.new(asks: asks, bids: bids)
+        end
+      end
+
+    private
+
+      def format_asks_bids(html, type)
+        raise ScrappingError unless html.match(/<tbody id="trade_#{type}_results_table_body"(.+?)<\/tbody>/m)
+
+        $1.each_line.select { |line| line.include?("data-critical-price") }.map do |line|
+          raise ScrappingError unless line.match(/<tr[^>]+data-critical-price="([\d\.]+)" data-amount="([\d\.]+)">/)
+
+          Offer.new(price: Money.new($1, fiat_currency), volume: $2).freeze
+        end
+      end
+    end
+  end
+end

data/lib/devilicious/markets/bitcurex.rb

@@ -0,0 +1,39 @@
+require "devilicious/markets/base"
+
+module Devilicious
+  module Market
+    class Bitcurex < Base
+      # NOTE: https://eur.bitcurex.com/
+
+      def fiat_currency
+        "EUR"
+      end
+
+      def trade_fee
+        BigDecimal.new("0.004").freeze # 0.4% - see https://eur.bitcurex.com/op%C5%82aty-i-limity
+      end
+
+      def refresh_order_book!
+        json = get_json("https://#{fiat_currency.downcase}.bitcurex.com/data/orderbook.json")
+
+        asks = format_asks_bids(json["asks"])
+        bids = format_asks_bids(json["bids"])
+
+        mark_as_refreshed
+        @order_book = OrderBook.new(asks: asks, bids: bids)
+      end
+
+    private
+
+      def format_asks_bids(json)
+        json.map do |price, volume|
+          Offer.new(
+            price: Money.new(price, fiat_currency),
+            volume: volume
+          ).freeze
+        end
+      end
+    end
+  end
+end
+

data/lib/devilicious/markets/bitstamp.rb

@@ -0,0 +1,42 @@
+require "devilicious/markets/base"
+
+module Devilicious
+  module Market
+    class Bitstamp < Base
+      # NOTE: https://www.bitstamp.net/
+
+      def fiat_currency
+        "USD"
+      end
+
+      def trade_fee
+        BigDecimal.new("0.005").freeze # 0.5% - see https://www.bitstamp.net/fee_schedule/
+      end
+
+      def refresh_order_book!
+        json = get_json("https://www.bitstamp.net/api/order_book/")
+
+        asks = format_asks_bids(json["asks"])
+        bids = format_asks_bids(json["bids"])
+
+        mark_as_refreshed
+        @order_book = OrderBook.new(asks: asks, bids: bids)
+      end
+
+    private
+
+      def format_asks_bids(json)
+        json.map do |price, volume|
+          price_usd = Money.new(price, fiat_currency)
+          price_normalized = price_usd.exchange_to(Devilicious.config.default_fiat_currency)
+
+          Offer.new(
+            price: price_normalized,
+            volume: volume
+          ).freeze
+        end
+      end
+    end
+  end
+end
+

data/lib/devilicious/markets/btc_e.rb

@@ -0,0 +1,37 @@
+require "devilicious/markets/base"
+
+module Devilicious
+  module Market
+    class BtcE < Base
+      def fiat_currency
+        "EUR"
+      end
+
+      def trade_fee
+        BigDecimal.new("0.002").freeze # 0.2%
+      end
+
+      def refresh_order_book!
+        json = get_json("https://btc-e.com/api/2/btc_#{fiat_currency.downcase}/depth")
+
+        asks = format_asks_bids(json["asks"])
+        bids = format_asks_bids(json["bids"])
+
+        mark_as_refreshed
+        @order_book = OrderBook.new(asks: asks, bids: bids)
+      end
+
+    private
+
+      def format_asks_bids(json)
+        json.map do |price, volume|
+          Offer.new(
+            price: Money.new(price.to_s, fiat_currency),
+            volume: volume.to_s
+          ).freeze
+        end
+      end
+    end
+  end
+end
+

data/lib/devilicious/markets/hit_btc.rb

@@ -0,0 +1,40 @@
+require "devilicious/markets/base"
+
+module Devilicious
+  module Market
+    class HitBtc < Base
+      # NOTE: https://hitbtc-com.github.io/hitbtc-api/
+
+      def fiat_currency
+        "EUR"
+      end
+
+      def trade_fee
+        BigDecimal.new("0.001").freeze # 0.1% - see https://hitbtc.com/fees-and-limits
+      end
+
+      def refresh_order_book!
+        json = get_json("https://api.hitbtc.com/api/1/public/BTC#{fiat_currency}/orderbook")
+
+        asks = format_asks_bids(json["asks"])
+        bids = format_asks_bids(json["bids"])
+
+        mark_as_refreshed
+        @order_book = OrderBook.new(asks: asks, bids: bids)
+      end
+
+    private
+
+      def format_asks_bids(json)
+        json.map do |price, volume|
+          Offer.new(
+            price: Money.new(price, fiat_currency),
+            volume: volume
+          ).freeze
+        end
+      end
+    end
+  end
+end
+
+

data/lib/devilicious/markets/kraken.rb

@@ -0,0 +1,35 @@
+require "devilicious/markets/base"
+
+module Devilicious
+  module Market
+    class Kraken < Base
+      def fiat_currency
+        "EUR"
+      end
+
+      def trade_fee
+        BigDecimal.new("0.002").freeze # 0.2%
+      end
+
+      def refresh_order_book!
+        json = get_json("https://api.kraken.com/0/public/Depth?pair=XBT#{fiat_currency}")
+
+        asks = format_asks_bids(json["result"]["XXBTZ#{fiat_currency}"]["asks"])
+        bids = format_asks_bids(json["result"]["XXBTZ#{fiat_currency}"]["bids"])
+
+        mark_as_refreshed
+        @order_book = OrderBook.new(asks: asks, bids: bids)
+      end
+    private
+
+      def format_asks_bids(json)
+        json.map do |price, volume|
+          Offer.new(
+            price: Money.new(price, fiat_currency),
+            volume: volume
+          ).freeze
+        end
+      end
+    end
+  end
+end

data/lib/devilicious/money.rb

@@ -0,0 +1,64 @@
+require "bigdecimal"
+
+module Devilicious
+  class Money < BigDecimal
+    attr_reader :currency
+
+    def initialize(amount, currency)
+      @currency = currency
+
+      super(amount)
+    end
+
+    def exchange_to new_currency
+      new_amount = CurrencyConverter.convert(self, currency, new_currency)
+
+      self.class.new new_amount, new_currency
+    end
+
+    def to_s
+      sprintf("%.#{decimal_places}f", self) << " " << currency
+    end
+
+    def inspect
+      "#<Devilicious::Money amount=#{to_s}>"
+    end
+
+    def +(other)
+      assert_currency! other
+      self.class.new super, currency
+    end
+
+    def -(other)
+      assert_currency! other
+      self.class.new super, currency
+    end
+
+    def *(other)
+      assert_currency! other
+      self.class.new super, currency
+    end
+
+    def /(other)
+      assert_currency! other
+      self.class.new super, currency
+    end
+
+  private
+
+    def decimal_places
+      max = 6 # NOTE: don't care about extra decimals
+
+      2.upto(max) do |i|
+        return i if self == self.round(i)
+      end
+
+      max
+    end
+
+    def assert_currency!(other)
+      raise "Currency mismatch: #{self.inspect} #{other.inspect}" if other.is_a?(self.class) && other.currency != currency
+    end
+  end
+end
+

data/lib/devilicious/offer.rb

@@ -0,0 +1,35 @@
+require "bigdecimal"
+
+module Devilicious
+  class Offer
+    attr_reader :price, :weighted_price, :volume
+
+    def initialize(hash)
+      self.price = hash.delete(:price)
+      self.weighted_price = hash.delete(:weighted_price)
+      self.volume = BigDecimal.new(hash.delete(:volume))
+
+      raise ArgumentError unless hash.empty?
+      raise ArgumentError, "#{price.class} is not Money" unless price.is_a? Money
+    end
+
+    def inspect
+      "#<Devilicious::Offer price=#{price} volume=#{volume.to_f}>"
+    end
+
+    def price=(price)
+      raise ArgumentError if price < 0
+      @price = price
+    end
+
+    def weighted_price=(weighted_price)
+      raise ArgumentError if weighted_price && weighted_price < 0
+      @weighted_price = weighted_price
+    end
+
+    def volume=(volume)
+      raise ArgumentError if volume < 0
+      @volume = volume
+    end
+  end
+end

data/lib/devilicious/order_book.rb

@@ -0,0 +1,89 @@
+module Devilicious
+  class OrderBook
+    attr_reader :asks, :bids
+    attr_accessor :market
+
+    def initialize(hash)
+      @asks = hash.delete(:asks).sort_by(&:price).freeze # buy
+      @bids = hash.delete(:bids).sort_by(&:price).freeze # sell
+
+      raise ArgumentError unless hash.empty?
+    end
+
+    def highest_bid
+      bids.last
+    end
+
+    def lowest_ask
+      asks.first
+    end
+
+    def weighted_asks_up_to(max_price)
+      weighted_offers(asks, ->(price) { price <= max_price })
+    end
+
+    def weighted_bids_down_to(min_price)
+      weighted_offers(bids, ->(price) { price >= min_price })
+    end
+
+    def min_ask_price_for_volume(max_price, max_volume)
+      interesting_asks = interesting_offers(asks, ->(price) { price <= max_price })
+      best_offer_price_for_volume(interesting_asks, max_volume)
+    end
+
+    def max_bid_price_for_volume(min_price, max_volume)
+      interesting_bids = interesting_offers(bids, ->(price) { price >= min_price }).reverse # reverse to start from most expensive
+      best_offer_price_for_volume(interesting_bids, max_volume)
+    end
+
+  private
+
+    def interesting_offers(offers, condition)
+      offers.select { |offer| condition.call(offer.price) }
+    end
+
+    def weighted_offers(offers, condition)
+      interesting_offers = interesting_offers(offers, condition)
+
+      total_volume = interesting_offers.map(&:volume).inject(:+) || 0
+      total_weight_price = interesting_offers.map { |offer| offer.price * offer.volume }.inject(:+) || 0
+      weighted_price = total_weight_price / total_volume
+
+      Offer.new(
+        price: Money.new(weighted_price, currency),
+        volume: total_volume
+      )
+    end
+
+    def best_offer_price_for_volume(offers, max_volume)
+      total_volume = 0
+      good_offers = []
+
+      offers.each do |offer|
+        if total_volume <= max_volume
+          good_offers << offer.dup # NOTE: dup because we're gonna mess with its volume below
+          total_volume += offer.volume
+        end
+      end
+
+      if total_volume > max_volume
+        substract_volume = total_volume - max_volume
+        good_offers.last.volume -= substract_volume
+        total_volume -= substract_volume
+      end
+
+      total_weight_price = good_offers.map { |offer| offer.price * offer.volume }.inject(:+) || 0
+      weighted_price = total_weight_price / total_volume
+
+      Offer.new(
+        price: good_offers.last.price,
+        volume: total_volume,
+        weighted_price: weighted_price,
+      )
+    end
+
+    def currency
+      lowest_ask.price.currency
+    end
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: devilicious
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Cédric Félizard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: retryable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Multi-currency Bitcoin arbitrage bot
+email:
+- cedric@felizard.fr
+executables:
+- devilicious
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/devilicious
+- devilicious.gemspec
+- lib/devilicious.rb
+- lib/devilicious/arbitrer.rb
+- lib/devilicious/config.rb
+- lib/devilicious/currency_converter.rb
+- lib/devilicious/formatters/base.rb
+- lib/devilicious/formatters/summary.rb
+- lib/devilicious/formatters/table.rb
+- lib/devilicious/formatters/verbose.rb
+- lib/devilicious/log.rb
+- lib/devilicious/markets/anx_btc.rb
+- lib/devilicious/markets/base.rb
+- lib/devilicious/markets/bit_nz.rb
+- lib/devilicious/markets/bitcoin_de.rb
+- lib/devilicious/markets/bitcurex.rb
+- lib/devilicious/markets/bitstamp.rb
+- lib/devilicious/markets/btc_e.rb
+- lib/devilicious/markets/hit_btc.rb
+- lib/devilicious/markets/kraken.rb
+- lib/devilicious/money.rb
+- lib/devilicious/offer.rb
+- lib/devilicious/order_book.rb
+- lib/devilicious/sounds/boom.wav
+homepage: ''
+licenses:
+- AGPLv3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Multi-currency Bitcoin arbitrage bot
+test_files: []