currency-rate 1.5.3 → 2.0.0

data/lib/adapters/crypto/kraken_adapter.rb

@@ -1,8 +1,8 @@
 module CurrencyRate
   class KrakenAdapter < Adapter
     SUPPORTED_CURRENCIES = %w(
-      ADA BCH BSV BTC DASH EOS ETC ETH GNO LTC MLN
-      NMC QTUM REP XDG XLM XMR XRP XTZ ZEC
+      ADA BCH BSV BTC DAI DASH EOS ETC ETH GNO LTC MLN
+      NMC QTUM REP USDC XDG XLM XMR XRP XTZ ZEC
     )
 
     ASSET_MAP = {
@@ -21,14 +21,14 @@ module CurrencyRate
 
     ANCHOR_CURRENCY = "BTC"
 
-    FETCH_URL = "https://api.kraken.com/0/public/Ticker?pair=#{ %w(ADAXBT BCHXBT BSVXBT DASHXBT EOSXBT GNOXBT QTUMXBT XTZXBT XETCXXBT XETHXXBT XLTCXXBT XREPXXBT XXLMXXBT XXMRXXBT XXRPXXBT XZECXXBT XXBTZUSD).join(",") }"
+    FETCH_URL = "https://api.kraken.com/0/public/Ticker?pair=#{ %w(ADAXBT BCHXBT BSVXBT DASHXBT EOSXBT GNOXBT QTUMXBT XTZXBT XETCXXBT XETHXXBT XLTCXXBT XREPXXBT XXLMXXBT XXMRXXBT XXRPXXBT XZECXXBT XXBTZUSD XBTDAI XBTUSDC).join(",") }"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       data["result"].reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, (pair, value)|
         key = ta(pair.sub(ta(ANCHOR_CURRENCY), ""))
 
-        if key == "USD"
+        if %w(USD DAI USDC).include?(key)
           result[key] = BigDecimal(value["c"].first.to_s)
         else
           result[key] = 1 / BigDecimal(value["c"].first.to_s)

data/lib/adapters/crypto/localbitcoins_adapter.rb

@@ -14,7 +14,7 @@ module CurrencyRate
     FETCH_URL = 'https://localbitcoins.com/bitcoinaverage/ticker-all-currencies/'
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       data.reduce({ "anchor" => ANCHOR_CURRENCY }) do |result, (fiat, value)|
         result["#{fiat.upcase}"] = BigDecimal(value["rates"]["last"].to_s)
         result

data/lib/adapters/crypto/okcoin_adapter.rb

@@ -1,16 +1,14 @@
 module CurrencyRate
   class OkcoinAdapter < Adapter
     FETCH_URL = {
-      'LTC_USD' => 'https://www.okcoin.com/api/v1/ticker.do?symbol=ltc_usd',
-      'BTC_USD' => 'https://www.okcoin.com/api/v1/ticker.do?symbol=btc_usd',
-      'LTC_CNY' => 'https://www.okcoin.cn/api/ticker.do?symbol=ltc_cny',
-      'BTC_CNY' => 'https://www.okcoin.cn/api/ticker.do?symbol=btc_cny'
+      'LTC_USD' => 'https://www.okcoin.com/api/spot/v3/instruments/LTC-USD/ticker',
+      'BTC_USD' => 'https://www.okcoin.com/api/spot/v3/instruments/BTC-USD/ticker',
     }
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       data.reduce({}) do |result, (pair, value)|
-        result[pair] = BigDecimal(value["ticker"]["last"].to_s)
+        result[pair] = BigDecimal(value["last"].to_s)
         result
       end
     end

data/lib/adapters/crypto/paxful_adapter.rb

@@ -0,0 +1,18 @@
+module CurrencyRate
+  class PaxfulAdapter < Adapter
+    SUPPORTED_CURRENCIES = %w(USD)
+
+    ANCHOR_CURRENCY = "BTC"
+
+    FETCH_URL = "https://paxful.com/api/currency/btc"
+
+    def normalize(data)
+      return nil unless data = super
+
+      {
+        "anchor" => ANCHOR_CURRENCY,
+        "USD" => BigDecimal(data["price"].to_s)
+      }
+    end
+  end
+end

data/lib/adapters/crypto/poloniex_adapter.rb

@@ -0,0 +1,33 @@
+module CurrencyRate
+  class PoloniexAdapter < Adapter
+    SUPPORTED_CURRENCIES = %w(BTS DASH DOGE LTC NXT STR XEM XMR XRP USDT
+                              ETH SC DCR LSK STEEM ETC REP ARDR ZEC STRAT
+                              GNT ZRX CVC OMG GAS STORJ EOS SNT KNC BAT
+                              LOOM QTUM USDC MANA BNT BCHABC BCHSV FOAM
+                              NMR POLY LPT ATOM TRX ETHBNT LINK XTZ PAX
+                              USDJ SNX MATIC MKR DAI NEO SWFTC FXC AVA
+                              CHR BNB BUSD MDT XFIL LEND REN LRC WRX SXP
+                              STPT SWAP EXE).freeze
+
+    ANCHOR_CURRENCY = "BTC".freeze
+
+    FETCH_URL = "https://poloniex.com/public?command=returnTicker".freeze
+
+    def normalize(data)
+      return nil unless data = super
+
+      data.each_with_object({ "anchor" => ANCHOR_CURRENCY }) do |(pair_name, pair_info), result|
+        next unless pair_name.include?(ANCHOR_CURRENCY)
+
+        key = pair_name.sub(ANCHOR_CURRENCY, "").sub("_", "")
+
+        result[key] =
+          if pair_name.index(ANCHOR_CURRENCY) == 0
+            1 / BigDecimal(pair_info["last"])
+          else
+            BigDecimal(pair_info["last"])
+          end
+      end
+    end
+  end
+end

data/lib/adapters/crypto/yadio_adapter.rb

@@ -7,10 +7,11 @@ module CurrencyRate
     FETCH_URL = "https://api.yadio.io/rate/BTC"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
 
       {
         "anchor" => ANCHOR_CURRENCY,
+        "USD" => BigDecimal(data["usd"].to_s),
         "VES" => BigDecimal(data["rate"].to_s),
       }
     end

data/lib/adapters/fiat/bonbast_adapter.rb

@@ -12,13 +12,11 @@ module CurrencyRate
     end
 
     def request(url)
-
-      http_client = HTTP.timeout(connect:
-        CurrencyRate.configuration.connect_timeout, read:
-        CurrencyRate.configuration.read_timeout
+      http_client = HTTP.timeout(
+        connect: @container.connect_timeout,
+        read:    @container.read_timeout
       )
       http_client.get(url).to_s
-
     end
 
   end

data/lib/adapters/fiat/coinmonitor_adapter.rb

@@ -3,12 +3,11 @@ module CurrencyRate
     # No need to use it for fetching, just additional information about supported currencies
     SUPPORTED_CURRENCIES = %w(ARS)
     ANCHOR_CURRENCY = "USD"
-    FETCH_URL = "https://ar.coinmonitor.info/api/dolar_ar/"
+    FETCH_URL = "https://ar.coinmonitor.info/data_ar.json"
 
     def normalize(data)
-      return nil unless super
-
-      { "anchor" => ANCHOR_CURRENCY }.merge({ SUPPORTED_CURRENCIES.first => BigDecimal(data["DOL_blue"].to_s) })
+      return nil unless data = super
+      { "anchor" => ANCHOR_CURRENCY }.merge({ SUPPORTED_CURRENCIES.first => BigDecimal(data["BTC_avr_ars"].to_s) })
     end
   end
-end
+end

data/lib/adapters/fiat/currency_layer_adapter.rb

@@ -17,11 +17,10 @@ module CurrencyRate
     )
 
     ANCHOR_CURRENCY = "USD"
-    FETCH_URL = "http://www.apilayer.net/api/live"
-    API_KEY_PARAM = "access_key"
+    FETCH_URL = "http://apilayer.net/api/live?access_key=__API_KEY__"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       rates = { "anchor" => self.class::ANCHOR_CURRENCY }
       data["quotes"].each do |key, value|
         rates[key.sub(self.class::ANCHOR_CURRENCY, "")] = BigDecimal(value.to_s)

data/lib/adapters/fiat/fixer_adapter.rb

@@ -2,13 +2,12 @@ module CurrencyRate
   class FixerAdapter < Adapter
     # EUR is the only currency available as a base on free plan
     ANCHOR_CURRENCY = "EUR"
-    FETCH_URL = "http://data.fixer.io/latest"
-    API_KEY_PARAM = "access_key"
+    FETCH_URL = "http://data.fixer.io/api/latest?access_key=__API_KEY__&base=#{ANCHOR_CURRENCY}"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       rates = { "anchor" => ANCHOR_CURRENCY }
-      data["rates"].each do |k, v|
+      data["rates"].each do |k,v|
         rates[k] = BigDecimal(v.to_s)
       end
       rates

data/lib/adapters/fiat/forge_adapter.rb

@@ -1,22 +1,31 @@
 module CurrencyRate
   class ForgeAdapter < Adapter
     SUPPORTED_CURRENCIES = %w(
-      JPY CHF CAD SEK NOK MXN ZAR TRY CNH EUR GBP AUD NZD XAU XAG
+      AED AFN ALL AMD ANG AOA ARE ARS AUD AUN AWG BAM BBD BDT BGN BHD BIF BMD
+      BND BOB BRI BRL BSD BTN BWP BYN BZD CAD CDF CHF CLF CLP CLY CNH CNY COP
+      CRC CUP CVE CYP CZK DJF DKK DOE DOP DZD EGP ETB EUR FJD FRN GBP GEL GHS
+      GMD GNF GTQ GYD HKD HNL HRK HTG HUF IDR ILS INR IQD IRR ISK JMD JOD JPY
+      KES KHR KMF KRU KRW KWD KYD KZT LAK LBP LFX LKR LRD LSL LTL LYD M5P MAD
+      MAL MDL MGA MKD MMK MOP MRU MTL MUR MVR MWK MXN MYR MZN NAD NBL NGN NIO
+      NOK NPR NSO NZD OMR OSO PAB PEN PGK PHP PKR PLN PYG QAR RON RSD RUB RWF
+      SAR SBD SCR SDG SEK SGD SHP SLL SOS SRD STN SVC SZL THB TJS TMT TND TOP
+      TRY TTD TWD TZS UAH UGX USD UYU UZS VES VND VRL VRN XAG XAGK XAU XAUK XCD
+      XDR XOF XPD XPDK XPF XPT XPTK YER ZAR ZMW ZWD
     )
 
     ANCHOR_CURRENCY = "USD"
-    FETCH_URL = "https://forex.1forge.com/1.0.2/quotes?pairs=" + SUPPORTED_CURRENCIES.map { |c| "#{ANCHOR_CURRENCY}#{c}" }.join(",")
-    API_KEY_PARAM = "api_key"
+    currency_pairs_request = SUPPORTED_CURRENCIES.map { |c| "#{ANCHOR_CURRENCY}/#{c}" }.join(",")
+    FETCH_URL = "https://api.1forge.com/quotes?pairs=#{currency_pairs_request}&api_key=__API_KEY__"
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       rates = { "anchor" => self.class::ANCHOR_CURRENCY }
       data.each do |rate|
         if rate["error"]
-          CurrencyRate.logger.error("Forge exchange returned error")
+          @container.logger.error("Forge exchange returned error")
           return nil
         end
-        rates[rate["symbol"].sub(self.class::ANCHOR_CURRENCY, "")] = BigDecimal(rate["price"].to_s)
+        rates[rate["s"].sub("#{self.class::ANCHOR_CURRENCY}/", "")] = BigDecimal(rate["p"].to_s) if rate["p"]
       end
       rates
     end

data/lib/adapters/fiat/free_forex_adapter.rb

@@ -1,4 +1,8 @@
 module CurrencyRate
+
+  # Beware, freeforexapi.com doesn't normally work and you need to place
+  # a small banner on your website so they'd list your websites IP address.
+  # More info here: http://freeforexapi.com/Home/Api
   class FreeForexAdapter < Adapter
     SUPPORTED_CURRENCIES = %w(
       AED AFN ALL AMD ANG AOA ARS ATS AUD AWG AZM AZN BAM BBD BDT
@@ -18,10 +22,10 @@ module CurrencyRate
     )
 
     ANCHOR_CURRENCY = "USD"
-    FETCH_URL = "https://www.freeforexapi.com/api/live?pairs=" + SUPPORTED_CURRENCIES.map{|cur| "USD#{cur}"}.join(",")
+    FETCH_URL = "https://www.freeforexapi.com/api/live?pairs=" + SUPPORTED_CURRENCIES.map { |c| "USD#{c}"}.join(",")
 
     def normalize(data)
-      return nil unless super
+      return nil unless data = super
       rates = { "anchor" => self.class::ANCHOR_CURRENCY }
       data["rates"].each do |pair, payload|
         rates[pair.sub(self.class::ANCHOR_CURRENCY, "")] = BigDecimal(payload["rate"].to_s)
@@ -29,4 +33,4 @@ module CurrencyRate
       rates
     end
   end
-end
+end

data/lib/container.rb

@@ -0,0 +1,203 @@
+class CurrencyRate::Container
+
+  attr_accessor :api_keys
+  attr_accessor :logger
+  attr_accessor :adapters
+  attr_accessor :connect_timeout
+  attr_accessor :read_timeout
+  attr_accessor :storage
+  attr_accessor :logger_callbacks
+  attr_accessor :limit_adapters_for_pairs
+
+  def initialize(
+    api_keys: {},
+    adapter_type: nil,
+    adapter_names: nil,
+    limit_adapters_for_pairs: {},
+    storage_settings: CurrencyRate.default_config[:storage_settings],
+    connect_timeout: CurrencyRate.default_config[:connect_timeout],
+    read_timeout: CurrencyRate.default_config[:read_timeout],
+    logger_settings: CurrencyRate.default_config[:logger_settings],
+    logger_callbacks: CurrencyRate.default_config[:logger_callbacks]
+  )
+
+    logger_settigns = CurrencyRate.default_config[:logger_settings].merge(logger_settings)
+    storage_settigns = CurrencyRate.default_config[:storage_settings].merge(storage_settings)
+
+    method(__method__).parameters.map do |_, name|
+      value = binding.local_variable_get(name)
+      instance_variable_set("@#{name}", value)
+    end
+
+    _logger_callbacks = {}
+    @logger_callbacks.each do |k,v|
+      _logger_callbacks[Logger::Severity.const_get(k.to_s.upcase)] = v
+    end
+    @logger_callbacks = _logger_callbacks
+
+    _limit_adapters_for_pairs = {}
+    @limit_adapters_for_pairs.each do |k,v|
+      _limit_adapters_for_pairs[k] = CurrencyRate.const_get(v.to_s.to_camel_case + "Adapter").instance
+    end
+    @limit_adapters_for_pairs = _limit_adapters_for_pairs
+
+    @storage = CurrencyRate.const_get(storage_settigns[:type].to_s.to_camel_case + "Storage").new(
+      path: storage_settings[:path],
+      container: self,
+      serializer: storage_settings[:serializer]
+    )
+
+    load_adapters!(names: adapter_names, type: adapter_type)
+  end
+
+  def method_missing(m, *args, &block)
+    if m.to_s.end_with? "_adapters"
+      self.send(:adapters, m[0..-10])
+    else
+      super
+    end
+  end
+
+  def logger
+    return @logger if @logger
+    @logger = Logger.new(@logger_settings[:device])
+    @logger.progname  = "CurrencyRate"
+    @logger.level     = @logger_settings[:level]
+    @logger.formatter = @logger_settings[:formatter] if @logger_settings[:formatter]
+    @logger
+  end
+
+  # This method doesn't make any requests. It merely reads normalized data 
+  # from the selected storage. Contrary to what one might assume,
+  # it doesn't call CurrencyRate::Container.sync! if storage for a particular
+  # adapter doesn't exist - that's because those are two separate tasks
+  # and you might not want to make that external http(s) request even if
+  # the rates in storage are not found.
+  #
+  # It also uses a 3 different strategies to calculate rates before they are returned:
+  #
+  # 1. If only one adapter is specified and/or available, it will return the rate for the
+  #    pair using the data from the storage for this particular adapter.
+  #
+  # 2. If two or more adapters are specified and available, it will return the average rate
+  #    based on the the rates from all of those adapters.
+  #
+  # 3. If `strategy: :majority` flag is set and an odd number of adapters (say, 3) 
+  #    is passed and/or available it will look at the rates from all, separate them
+  #    into two groups based on how close their rates are and return the average of the rates
+  #    that are closest in the group that is the largest.
+  #
+  # It will also check @limit_adapters_for_pairs hash for the request pair
+  # and if the key exists it will exclude adapters that are not listed in the array
+  # under that key.
+  def get_rate(from, to, use_adapters=@adapter_names, strategy: :average)
+    adapters_for_pair = @limit_adapters_for_pairs["#{from}/#{to}"]
+    _adapters = adapters.select { |a| use_adapters.include?(a.name(:camel_case))       }
+    _adapters = _adapters.select { |a| adapters_for_pair.include?(a.name(:camel_case)) } if adapters_for_pair
+
+    warning_loggers = []
+    rates = _adapters.map do |a|
+      rate = [a.name(:camel_case), a.get_rate(from, to)]
+      warning_loggers.push -> { self.log(:warn, "No rate for pair #{from}/#{to} found in #{a.name(:camel_case)} adapter") if rate[1].nil? }
+      rate
+    end.select { |r| !r[1].nil? }
+
+    if rates.empty?
+      self.log(:error,
+        "No rate for pair #{from}/#{to} is found in any of the available adapters " +
+        "(#{_adapters.map { |a| a.name(:camel_case) }.join(", ")})"
+      )
+    else
+      warning_loggers.each { |wl| wl.call }
+    end
+
+    if rates.size == 1
+      rates[0][1]
+    else
+      if strategy == :majority && rates.size.odd?
+        rates.sort! { |r1, r2| r1[1] <=> r2[1] }
+
+        largest_discrepancy_rate_index = 0
+        last_discrepancy = 0
+
+        rates.each_with_index do |r,i|
+          if i > 0
+            discrepancy = r[1] - rates[i-1][1]
+            if discrepancy > last_discrepancy
+              last_discrepancy = discrepancy
+              largest_discrepancy_rate_index = i
+            end
+          end
+        end
+
+        rates_group_1 = rates[0...largest_discrepancy_rate_index]
+        rates_group_2 = rates[largest_discrepancy_rate_index..rates.size-1]
+        rates = [rates_group_1, rates_group_2].max { |g1,g2| g1.size <=> g2.size }
+      end
+      rates.inject(BigDecimal(0)) { |sum, i| sum + i[1] } / BigDecimal(rates.size)
+    end
+
+  end
+
+  def sync!
+    successfull = []
+    failed      = []
+    @adapters.each do |adapter|
+      adapter_name = adapter.class.to_s.sub("CurrencyRate::", "")
+      begin
+        rates = adapter.fetch_rates
+        unless rates
+          self.log(:warn, "Trying to sync rates for #{adapter_name}, rates not found, but http(s) request did not return any error.")
+          failed << adapter_name
+          next
+        end
+        @storage.write(adapter_name.to_snake_case.sub("_adapter", ""), rates)
+        successfull << adapter_name
+      rescue StandardError => e
+        failed << adapter_name
+        self.log(:error, e)
+        next
+      end
+    end
+    [successfull, failed]
+  end
+
+  def log(level, message)
+    severity = Logger::Severity.const_get(level.to_s.upcase)
+    logger.send(level, message)
+    if @logger_callbacks[severity]
+      @logger_callbacks[severity].call(level, message)
+    else
+      @logger_callbacks.keys.sort.each do |k|
+        @logger_callbacks[k].call(level, message) && break if k < severity
+      end
+    end
+  end
+
+  private
+
+  def load_adapters!(names: nil, type: :all)
+    if names
+      names = [names] if names.kind_of?(String)
+      @adapters = names.map do |name|
+        CurrencyRate.const_get(name + "Adapter").instance
+      end
+    else
+      crypto_adapter_files = Dir[File.join CurrencyRate.root, "lib/adapters/crypto/*"]
+      fiat_adapter_files   = Dir[File.join CurrencyRate.root, "lib/adapters/fiat/*"]
+      adapter_files = case type
+        when :crypto  then crypto_adapter_files
+        when :fiat    then fiat_adapter_files
+        else               crypto_adapter_files + fiat_adapter_files
+      end
+      @adapters = adapter_files.map do |file|
+        CurrencyRate.const_get(File.basename(file, ".rb").to_camel_case).instance
+      end
+    end
+    @adapters.each { |a| a.container = self; a.api_key = @api_keys[a.name] }
+    @adapter_names = @adapters.map { |a| a.name(:camel_case) }
+    @adapters
+  end
+
+
+end