Feat/bamboo relay

lib/cryptoexchange/exchanges/bamboo_relay/services/market.rb

@@ -9,22 +9,19 @@ def supports_individual_ticker_query?
         end
 
         def fetch
-          outputs = []
-          (1..25).each do |page_id|
-            ticker_output = super(ticker_url(page_id))
-            break if ticker_output.empty?
-            outputs = outputs + ticker_output
+          output = Cryptoexchange::Cache.ticker_cache.fetch(ticker_url()) do
+            HTTP.use(:auto_inflate).headers("Accept-Encoding" => "gzip").get(ticker_url()).parse(:json)
           end
-          adapt_all(outputs)
+          adapt_all(output)
         end
 
-        def ticker_url(page_id)
-          "#{Cryptoexchange::Exchanges::BambooRelay::Market::API_URL}/markets?include=base,stats,ticker&page=#{page_id}&perPage=1000"
+        def ticker_url()
+          "#{Cryptoexchange::Exchanges::BambooRelay::Market::API_URL}/markets?include=base,stats,ticker,realVolume&perPage=1000"
         end
 
         def adapt_all(output)
           output.map do |pair_ticker|
-            base, target = pair_ticker["id"].split("-")
+            base, target = pair_ticker["displayName"].split("/")
             market_pair = Cryptoexchange::Models::MarketPair.new(
               base:   base,
               target: target,

lib/cryptoexchange/exchanges/bamboo_relay/services/order_book.rb

@@ -9,7 +9,9 @@ def supports_individual_ticker_query?
         end
 
         def fetch(market_pair)
-          output = super(ticker_url(market_pair))
+          output = Cryptoexchange::Cache.ticker_cache.fetch(ticker_url(market_pair)) do
+            HTTP.use(:auto_inflate).headers("Accept-Encoding" => "gzip").get(ticker_url(market_pair)).parse(:json)
+          end
           adapt(output, market_pair)
         end
 
@@ -19,7 +21,6 @@ def ticker_url(market_pair)
 
         def adapt(output, market_pair)
           order_book = Cryptoexchange::Models::OrderBook.new
-
           order_book.base      = market_pair.base
           order_book.target    = market_pair.target
           order_book.market    = BambooRelay::Market::NAME

lib/cryptoexchange/exchanges/bamboo_relay/services/pairs.rb

@@ -5,26 +5,18 @@ class Pairs < Cryptoexchange::Services::Pairs
         PAIRS_URL = "#{Cryptoexchange::Exchanges::BambooRelay::Market::API_URL}/markets"
 
         def fetch
-          outputs = []
-          (1..5).each do |page_id|
-            pair_url = PAIRS_URL + "?page=#{page_id}&perPage=1000"
-            puts pair_url
-            output = fetch_via_api(pair_url)
-            break if output.empty?
-            outputs = outputs + output
-          end
-          adapt(outputs)
-        end
-
-        def adapt(output)
-          output.map do |ticker|
+          market_pairs = []
+          raw_output = HTTP.use(:auto_inflate).headers("Accept-Encoding" => "gzip").get(PAIRS_URL + "?perPage=1000")
+          output = JSON.parse(raw_output)
+          output.each do |ticker|
             base, target = ticker['displayName'].split('/')
-            Cryptoexchange::Models::MarketPair.new({
-              base: base,
-              target: target,
-              market: BambooRelay::Market::NAME
-            })
+              market_pairs << Cryptoexchange::Models::MarketPair.new(
+                base:   base,
+                target: target,
+                market: BambooRelay::Market::NAME
+            )
           end
+          market_pairs
         end
       end
     end

lib/cryptoexchange/exchanges/bamboo_relay/services/trades.rb

@@ -0,0 +1,34 @@
+module Cryptoexchange::Exchanges
+  module BambooRelay
+    module Services
+      class Trades < Cryptoexchange::Services::Market
+        def fetch(market_pair)
+          output = Cryptoexchange::Cache.ticker_cache.fetch(ticker_url(market_pair)) do
+            HTTP.use(:auto_inflate).headers("Accept-Encoding" => "gzip").get(ticker_url(market_pair)).parse(:json)
+          end
+          adapt(output, market_pair)
+        end
+
+        def ticker_url(market_pair)
+          "#{Cryptoexchange::Exchanges::BambooRelay::Market::API_URL}/markets/#{market_pair.base}-#{market_pair.target}/fills"
+        end
+
+        def adapt(output, market_pair)
+          output.collect do |trade|
+            tr = Cryptoexchange::Models::Trade.new
+            tr.trade_id  = trade['transactionHash']
+            tr.base      = market_pair.base
+            tr.target    = market_pair.target
+            tr.type      = trade['side'] == "SELL" ? "sell" : "buy"
+            tr.amount    = NumericHelper.to_d(trade['filledBaseTokenAmount'])
+            tr.price     = NumericHelper.to_d(trade['filledQuoteTokenAmount']) / tr.amount
+            tr.timestamp = trade['timestamp']
+            tr.payload   = trade
+            tr.market    = BambooRelay::Market::NAME
+            tr
+          end
+        end
+      end
+    end
+  end
+end

spec/exchanges/bamboo_relay/integration/market_spec.rb

@@ -2,7 +2,7 @@
 
 RSpec.describe 'BambooRelay integration specs' do
   let(:client) { Cryptoexchange::Client.new }
-  let(:zrx_weth_pair) { Cryptoexchange::Models::MarketPair.new(base: 'ZRX', target: 'WETH', market: 'bamboo_relay') }
+  let(:weth_dai_pair) { Cryptoexchange::Models::MarketPair.new(base: 'WETH', target: 'DAI', market: 'bamboo_relay') }
 
   it 'fetch pairs' do
     pairs = client.pairs('bamboo_relay')
@@ -15,18 +15,18 @@
   end
 
   it 'give trade url' do
-    trade_page_url = client.trade_page_url 'bamboo_relay', base: zrx_weth_pair.base, target: zrx_weth_pair.target
-    expect(trade_page_url).to eq "https://bamboorelay.com/trade/ZRX-WETH"
+    trade_page_url = client.trade_page_url 'bamboo_relay', base: weth_dai_pair.base, target: weth_dai_pair.target
+    expect(trade_page_url).to eq "https://bamboorelay.com/trade/WETH-DAI"
   end
 
   it 'fetch ticker' do
-    ticker = client.ticker(zrx_weth_pair)
+    ticker = client.ticker(weth_dai_pair)
 
-    expect(ticker.base).to eq 'ZRX'
-    expect(ticker.target).to eq 'WETH'
+    expect(ticker.base).to eq 'WETH'
+    expect(ticker.target).to eq 'DAI'
     expect(ticker.market).to eq 'bamboo_relay'
     expect(ticker.last).to be_a Numeric
-    expect(ticker.last).to be < 100 # Test if number is reasonable
+    expect(ticker.last).to be < 5000 # Test if number is reasonable
     expect(ticker.bid).to be_a Numeric
     expect(ticker.ask).to be_a Numeric
     expect(ticker.change).to be_a Numeric
@@ -36,10 +36,10 @@
   end
 
   it 'fetch order book' do
-    order_book = client.order_book(zrx_weth_pair)
+    order_book = client.order_book(weth_dai_pair)
 
-    expect(order_book.base).to eq 'ZRX'
-    expect(order_book.target).to eq 'WETH'
+    expect(order_book.base).to eq 'WETH'
+    expect(order_book.target).to eq 'DAI'
     expect(order_book.market).to eq 'bamboo_relay'
 
     expect(order_book.asks).to_not be_empty
@@ -52,4 +52,19 @@
     expect(order_book.timestamp).to be_nil
     expect(order_book.payload).to_not be nil
   end
+
+  it 'fetch trade' do
+    trades = client.trades(weth_dai_pair)
+    trade = trades.sample
+
+    expect(trades).to_not be_empty
+    expect(trade.trade_id).to_not be_nil
+    expect(trade.base).to eq 'WETH'
+    expect(trade.target).to eq 'DAI'
+    expect(trade.market).to eq 'bamboo_relay'
+    expect(trade.price).to_not be_nil
+    expect(trade.amount).to_not be_nil
+    expect(trade.timestamp).to be_a Numeric
+    expect(trade.payload).to_not be nil
+  end
 end