crypto_arbitrer 0.0.2

data/.gitignore

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

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - "1.9.3"
+script: bundle exec rspec spec

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 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,83 @@
+![Travis Build Status](https://secure.travis-ci.org/nubis/crypto_arbitrer.png)
+
+# CryptoArbitrer
+
+Provides currency conversions across several fiat currencies and crypto currencies.
+Exchange rates are fetch (and in some cases scraped)
+from mtgox.com, btc-e.com, eldolarblue.net, rate-exchange.appspot.com and dolarparalelo.org.
+
+Given some particular situations in both Venezuela and Argentina, an unofficial but de-facto exchange rate
+is used for each country's currency (from dolarparalelo.org and eldolarblue.net respectively).
+
+The supported fiat currencies are:
+usd ars uyu brl clp sgd eur vef
+
+The supported crypto currencies are:
+btc ltc nmc nvc trc ppc ftc cnc
+
+If you're just looking to use these rates quickly, they are available as a JSON api at [http://cryptocueva.com](http://cryptocueva.com)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'crypto_arbitrer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install crypto_arbitrer
+
+## Usage
+
+To get the exchange rate from United States Dollars to Argentine Pesos:
+
+    irb > CryptoArbitrer::Base.fetch('usd', 'ars')
+    => {'sell' => 7.9, 'buy' => 8.0}
+
+Prices are returned as 'sell' and 'buy' hashes, where 'sell' is the price at which you can sell the given currency (highest bid price) and 'buy' is the price at which is being offered to you by others (lowest ask price).
+
+If you were to buy 10 Bitcoin paying with US Dollars, this is how much you would spend in US Dollars.
+
+    irb > 10 * CryptoArbitrer::Base.fetch('btc', 'usd')['buy']
+    => 1107.7001 # USD
+      
+
+### Caching and Rails
+
+There is basic support for plugging in your own caching mechanism. Caching in Rails is as easy as creating an initializer
+with the following code:
+
+    CryptoArbitrer::Base.cache_backend = lambda do |from, to, block|
+      Rails.cache.fetch([from, to], &block)
+    end
+
+Essentially, you just make a lambda that would receive the currencies to convert from and to, and a block that would return the
+exchange rate when called.
+
+Keeping an updated cache is also rather simple, I have this short rake task running every 10 minutes:
+
+    namespace :exchange_rates do
+      desc "Recaches the exchange rates"
+      task recache: :environment do
+        CryptoArbitrer::Base.supported_conversions.each do |from, to|
+          # Notice the third argument to 'fetch', it forces the lookup, ignoring the existing cache.
+          rate = CryptoArbitrer::Base.fetch(from, to, true) rescue next
+          Rails.cache.delete([from, to])
+          Rails.cache.write([from, to], rate)
+        end
+      end
+    end
+
+Docs available at: [http://rubydoc.info/github/nubis/crypto_arbitrer/master/frames](http://rubydoc.info/github/nubis/crypto_arbitrer/master/frames)
+
+## 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/crypto_arbitrer.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'crypto_arbitrer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "crypto_arbitrer"
+  spec.version       = CryptoArbitrer::VERSION
+  spec.authors       = ["Nubis"]
+  spec.email         = ["yo@nubis.im"]
+  spec.description   = "Arbitrage calculator for crypto currencies. Currently focused on Argentina moving funds from btc-e to mt.gox, then into an asian bank account and finally into Argentina as USD which may be sold at the unofficial price."
+  spec.summary       = "Argentine arbitrage calculator for crypto currencies"
+  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 "json"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "webmock"
+end

data/lib/crypto_arbitrer.rb

@@ -0,0 +1,174 @@
+require "crypto_arbitrer/version"
+require "json"
+require "open-uri"
+
+module CryptoArbitrer
+  class Base
+    # Quasi constant, all supported fiat currencies.
+    def self.supported_fiat
+      %w(usd ars uyu brl clp sgd eur vef)
+    end
+    
+    # Quasi constant, all supported crypto currencies.
+    def self.supported_cryptos
+      %w(btc ltc nmc nvc trc ppc ftc cnc)
+    end
+    
+    # Quasi constant, all supported currencies.
+    def self.supported_currencies
+      supported_fiat + supported_cryptos
+    end
+    
+    # Quasi constant, a list of iso code pairs representing all supported exchange rates.
+    # [['ars','usd'],['usd','btc'],['ltc','cnc'],...]
+    def self.supported_conversions
+      supported_currencies.product(supported_currencies)
+    end
+
+    class << self
+      # If you want to cache calls done to third party api's you should use this.
+      # Pass in a lambda that will receive the cache key name and the block for fetching it's value.
+      # If you're using rails you can configure CryptoArbitrer in an initializer to use rails caching
+      # just forwarding the cache key and the block to it.
+      # You can set the cache_backend to nil to prevent caching (not recommended, unless you're testing)
+      def cache_backend=(backend)
+        @cache_backend = backend
+      end
+
+      def cache_backend
+        @cache_backend
+      end
+    end
+
+    # For existing known exchange rates, we want to derive the reverse lookup,
+    # for example: We derive ars_usd from usd_ars
+    def self.derive_reversal(from, to)
+      define_method("fetch_#{to}_#{from}") do
+        rate = send("fetch_#{from}_#{to}")
+        {'sell' => 1/rate['sell'], 'buy' => 1/rate['buy']}
+      end
+    end
+
+    # Uses eldolarblue.net API for checking Argentine unofficial US dolar prices.
+    # The returned hash has 'sell' and 'buy' keys for the different prices.
+    # 'buy' is the price at which you can buy USD from agents and 'sell' is the price
+    # at which you can sell USD to agents. Notice this is the opposite to argentina's
+    # convention for 'buy' and 'sell' (where buy is the price in which agents would buy from you)
+    # The ugly regex is to fix the service's response which is
+    # not valid json but a javascript object literal.
+    def fetch_usd_ars
+      response = open('http://www.eldolarblue.net/getDolarBlue.php?as=json').read
+      rate = JSON.parse(response.gsub(/([{,])([^:]*)/, '\1"\2"') )['exchangerate']
+      {'sell' => rate['buy'], 'buy' => rate['sell']}
+    end
+    derive_reversal(:usd, :ars)
+    
+    # Uses mt.gox API for checking latest bitcoin sell and buy prices.
+    # The returned hash has 'sell' and 'buy' keys for the different prices,
+    # the prices mean at which price you could buy and sell from them, respectively.
+    def fetch_btc_usd
+      response = open('http://data.mtgox.com/api/2/BTCUSD/money/ticker_fast').read
+      json = JSON.parse(response)['data']
+      {'sell' => json['sell']['value'].to_f, 'buy' => json['buy']['value'].to_f}
+    end
+    derive_reversal(:btc, :usd)
+    
+    # Goes to dolarparalelo.org to grab the actual price for usd to vef
+    # The returned hash has 'sell' and 'buy' keys for the different prices,
+    # the prices mean at which price you could buy and sell from them, respectively.
+    def fetch_usd_vef
+      response = open('http://www.dolarparalelo.org').read
+      response =~ /<p><font.*?>Dolar:<\/font>.*?<font.*?>(.*?)</
+      rate = $1.to_f
+      {'sell' => rate, 'buy' => rate}
+    end
+    derive_reversal(:usd, :vef)
+    
+    # All prices for non-btc cryptocurrencies are fetch from btc-e, prices are expressed in BTC.
+    # We do that by parsing their pages since they don't provide an API.
+    # The prices returned mean at which price you could buy and sell from them, respectively.
+    # We don't use btc-e pricing for bitcoin since the common arbitrage path is to
+    # move bitcoin from btc-e to mt.gox when converting any cryptocurrency to fiat.
+    non_btc_cryptos = supported_cryptos - ['btc']
+    non_btc_cryptos.each do |currency|
+      define_method("fetch_#{currency}_btc") do
+        response = open("https://btc-e.com/exchange/#{currency}_btc").read
+        response =~ /<span id=.max_price..(.*?)..span./
+        sell = $1.to_f
+        response =~ /<span id=.min_price..(.*?)..span./
+        buy = $1.to_f
+        {'sell' => sell, 'buy' => buy}
+      end
+      derive_reversal(currency, :btc)
+    end
+
+    # Fiat prices are fetch from rate-exchange.appspot.com but there are no buy/sell prices.
+    # We use USD as the common denominator for all fiat currencies.
+    # @returns [{'sell' => Float, 'buy' => Float}]
+    %w(uyu brl clp sgd eur).each do |currency|
+      define_method("fetch_usd_#{currency}") do 
+        response = open("http://rate-exchange.appspot.com/currency?from=usd&to=#{currency}").read
+        json = JSON.parse(response)
+        {'sell' => json['rate'].to_f, 'buy' => json['rate'].to_f}
+      end
+      derive_reversal(:usd, currency)
+    end
+    
+    # All non usd fiat can be converted to btc through their dollar price.
+    non_usd_fiat = supported_fiat - ['usd']
+    non_usd_fiat.each do |currency|
+      define_method("fetch_btc_#{currency}") do
+        btc_rate = fetch_btc_usd
+        usd_rate = fetch('usd', currency)
+        {'sell' => btc_rate['sell'] * usd_rate['sell'], 'buy' => btc_rate['buy'] * usd_rate['buy']}
+      end
+      derive_reversal(:btc, currency)
+    end
+    
+    # All fiat currencies can be converted to any non-btc cryptocurrency by using their
+    # rate to btc as common denominator.
+    non_usd_to_non_btc = (non_usd_fiat + non_btc_cryptos).product(non_usd_fiat + non_btc_cryptos)
+    usd_to_non_btc = (non_btc_cryptos+[:usd]).product(non_btc_cryptos+[:usd])
+    (non_usd_to_non_btc + usd_to_non_btc).each do |from, to|
+      define_method("fetch_#{from}_#{to}") do
+        from_rate = fetch(from, 'btc')
+        to_rate = fetch(to, 'btc')
+        {'sell' => from_rate['sell']/to_rate['sell'], 'buy' => from_rate['buy']/to_rate['buy']}
+      end
+    end
+  
+    # From and to the same currency is always 1, but we include the methods just for robustness
+    supported_currencies.each do |c|
+      define_method("fetch_#{c}_#{c}"){ {'sell' => 1, 'buy' => 1 } }
+    end
+    
+    def fetch(from, to, force = false)
+      if force
+        send("fetch_#{from}_#{to}")
+      else
+        cached(from, to){ send("fetch_#{from}_#{to}") }
+      end
+    end
+    
+    # Fetch a given conversion caching the result if a backend is set.
+    # This should be the preferred way to fetch a conversion by users.
+    # Check {#supported_currencies} for a list of possible values for 'from' and 'to'
+    # @param from [String] a three letter currency code to convert from.
+    # @param to [String] a three letter currency code to convert to.
+    # @param to [String] a three letter currency code to convert to.
+    # @param force [Boolean] Ignore the cache (does not read from it, and does not write to it). Defaults to false.
+    # @return [{'buy' => Float, 'sell' => Float}] The buy and sell prices
+    def self.fetch(from,to, force = false)
+      new.fetch(from, to, force)
+    end
+
+  protected
+    def cached(from, to, &block)
+      if self.class.cache_backend
+        self.class.cache_backend.call(from, to, block)
+      else
+        block.call
+      end
+    end
+  end
+end

data/lib/crypto_arbitrer/version.rb

@@ -0,0 +1,3 @@
+module CryptoArbitrer
+  VERSION = "0.0.2"
+end

data/spec/base_spec.rb

@@ -0,0 +1,172 @@
+require_relative '../lib/crypto_arbitrer.rb'
+require 'webmock/rspec'
+require 'csv'
+
+describe CryptoArbitrer::Base do
+  def stub_get(url, mock_name)
+    stub_request(:get, url)
+      .to_return(body: open(File.expand_path("../mocks/#{mock_name}", __FILE__)).read)
+  end
+
+  describe 'when matching corpus of conversion rates' do
+    before :each do
+      stub_get("http://www.eldolarblue.net/getDolarBlue.php?as=json", 'dolarblue.json')
+      stub_get('http://data.mtgox.com/api/2/BTCUSD/money/ticker_fast', 'mtgox.json')
+      stub_get('http://www.dolarparalelo.org/', 'dolarparalelo.html')
+      %w(ltc nmc nvc trc ppc ftc cnc).each do |crypto|
+        stub_get("https://btc-e.com/exchange/#{crypto}_btc", "btce_#{crypto}_btc.html")
+      end
+      %w(uyu brl clp sgd eur).each do |currency|
+        stub_get("http://rate-exchange.appspot.com/currency?from=usd&to=#{currency}",
+          "rate_exchange_usd_#{currency}.json")
+      end
+    end
+    
+    CSV.read(File.expand_path('../conversions.csv', __FILE__), 'r').each do |from, to, buy, sell|
+      it "converts from #{from} to #{to}" do
+        rate = subject.fetch(from, to)
+        rate['buy'].should == buy.to_f
+        rate['sell'].should == sell.to_f
+      end
+    end
+
+    # As a sanity check, we make sure all conversions advertised as supported at least exists.
+    # You should always increase the conversions.csv corpus when adding a new currency though.
+    CryptoArbitrer::Base.supported_conversions.each do |from, to|
+      it "Conversion from #{from} to #{to} exists" do
+        subject.send("fetch_#{from}_#{to}").tap do |rate|
+          # When adding a new currency, you may want to print out the rates returned by the engine
+          # to check them manually and then add them to the corpus
+          #puts "#{from},#{to},#{rate['buy']},#{rate['sell']}"
+          rate['buy'].should_not be_nil
+          rate['sell'].should_not be_nil
+        end
+      end
+    end
+    
+    it 'supports conversions from and to the same currency' do
+      subject.class.supported_currencies.each do |c|
+        subject.fetch(c,c).should == {'buy' => 1, 'sell' => 1}
+      end
+    end
+  end
+  
+  it 'hits dolarblue for usd to ars rate' do
+    stub = stub_get("http://www.eldolarblue.net/getDolarBlue.php?as=json", 'dolarblue.json')
+    subject.fetch_usd_ars
+    stub.should have_been_requested
+  end
+  
+  it 'hits mt.gox for the btc to usd rate' do
+    stub = stub_get('http://data.mtgox.com/api/2/BTCUSD/money/ticker_fast', 'mtgox.json')
+    subject.fetch_btc_usd
+    stub.should have_been_requested
+  end
+
+  it 'hits dolarparalelo for venezuelan bolivar' do
+    stub = stub_get('http://www.dolarparalelo.org/', 'dolarparalelo.html')
+    subject.fetch_usd_vef
+    stub.should have_been_requested
+  end
+
+  it 'hits mt.gox and dolarblue for the btc to ars rate' do
+    stub_ars = stub_get("http://www.eldolarblue.net/getDolarBlue.php?as=json", 'dolarblue.json')
+    stub_btc = stub_get('http://data.mtgox.com/api/2/BTCUSD/money/ticker_fast', 'mtgox.json')
+    subject.fetch_btc_ars
+    stub_ars.should have_been_requested
+    stub_btc.should have_been_requested
+  end
+  
+  %w(ltc nmc nvc trc ppc ftc cnc).each do |currency|
+    it "hits btc-e for the #{currency} to btc rate" do
+      stub = stub_get("https://btc-e.com/exchange/#{currency}_btc", "btce_#{currency}_btc.html")
+      subject.fetch(currency, 'btc')
+      subject.fetch('btc', currency)
+      stub.should have_been_requested.twice
+    end
+  end
+
+  %w(uyu brl clp sgd eur).each do |currency|
+    it "hits rate-exchange for the #{currency} to usd rate" do
+      stub = stub_get("http://rate-exchange.appspot.com/currency?from=usd&to=#{currency}",
+        "rate_exchange_usd_#{currency}.json")
+      subject.fetch('usd', currency)
+      subject.fetch(currency, 'usd')
+      stub.should have_been_requested.twice
+    end
+  end
+  
+  describe 'when caching remote calls' do
+    it 'does not cache anything by default' do
+      stub = stub_get("http://www.eldolarblue.net/getDolarBlue.php?as=json", 'dolarblue.json')
+      2.times{ subject.fetch('usd', 'ars') }
+      stub.should have_been_requested.twice
+    end
+    
+    it 'caches when a cache_backend has been set, stops caching afterwards' do
+      cache = {}
+      subject.class.cache_backend = lambda {|from, to, block| cache[[from,to]] ||= block.call }
+      stub = stub_get('http://data.mtgox.com/api/2/BTCUSD/money/ticker_fast', 'mtgox.json')
+      subject.fetch('btc', 'usd')
+      cache[['btc','usd']].should be_a(Hash)
+      subject.fetch('btc', 'usd')
+      stub.should have_been_requested.once
+      subject.class.cache_backend = nil
+      subject.fetch('btc', 'usd')
+      stub.should have_been_requested.twice
+    end
+    
+    it 'does not cache for low level calls' do
+      cache = {}
+      subject.class.cache_backend = lambda {|from, to, block| cache[key] ||= block.call }
+      stub = stub_get('http://data.mtgox.com/api/2/BTCUSD/money/ticker_fast', 'mtgox.json')
+      subject.fetch_btc_usd
+      subject.fetch_btc_usd
+      stub.should have_been_requested.twice
+    end
+    
+    it 'does not cache when using a force argument' do
+      cache = {}
+      subject.class.cache_backend = lambda {|from, to, block| cache[key] ||= block.call }
+      stub = stub_get('http://data.mtgox.com/api/2/BTCUSD/money/ticker_fast', 'mtgox.json')
+      subject.fetch('btc', 'usd', true)
+      subject.fetch('btc', 'usd', true)
+      stub.should have_been_requested.twice
+    end
+  end
+
+  describe "Service is either down or changed their API at:", slow: true do
+    before(:all){ WebMock.allow_net_connect! }
+    after(:all){ WebMock.disable_net_connect! }
+
+    def check_service(method)
+      %w(buy sell).each do |price|
+        price = subject.send(method)[price]
+        price.should be_a Float
+        price.should >= 0
+      end
+    end
+
+    it 'eldolarblue' do
+      check_service(:fetch_usd_ars)
+    end
+    
+    it 'mtgox' do
+      check_service(:fetch_btc_usd)
+    end
+    
+    %w(ltc_btc nmc_btc nvc_btc trc_btc ppc_btc ftc_btc cnc_btc).each do |exchange|
+      it "btce #{exchange}" do
+        check_service("fetch_#{exchange}")
+      end
+    end
+    
+    it 'rate-exchange' do
+      check_service('fetch_usd_sgd')
+    end
+    
+    it 'dolarparalelo' do
+      check_service('fetch_usd_vef')
+    end
+  end
+end