d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-05-13 15:09:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add demo routines function to fetch all exchange tickers

Browse Source
This commit is contained in:
Adrian Gallagher
2017-08-29 10:24:32 +10:00
parent a1040c8d94
commit a5b3a6b489
18 changed files with 109 additions and 382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
common/common.go
View File

@@ -302,6 +302,7 @@ func SendHTTPGetRequest(url string, jsonDecode bool, result interface{}) error {
if res.StatusCode != 200 {
log.Printf("HTTP status code: %d\n", res.StatusCode)
log.Printf("URL: %s\n", url)
return errors.New("status code was not 200")
}

20
exchanges/bitfinex/bitfinex_wrapper.go
View File

@@ -2,13 +2,11 @@ package bitfinex
import (
"log"
"time"
"github.com/thrasher-/gocryptotrader/common"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -38,24 +36,9 @@ func (b *Bitfinex) Run() {
log.Printf("%s Failed to get config.\n", b.GetName())
}
}
for b.Enabled {
pairs := b.GetEnabledCurrencies()
for x := range pairs {
currency := pairs[x]
go func() {
ticker, err := b.UpdateTicker(currency)
if err != nil {
return
}
log.Printf("Bitfinex %s Last %f High %f Low %f Volume %f\n", exchange.FormatCurrency(currency).String(), ticker.Last, ticker.High, ticker.Low, ticker.Volume)
stats.AddExchangeInfo(b.GetName(), currency.GetFirstCurrency().String(), currency.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
}()
}
time.Sleep(time.Second * b.RESTPollingDelay)
}
}
// UpdateTicker updates and returns the ticker
func (b *Bitfinex) UpdateTicker(p pair.CurrencyPair) (ticker.TickerPrice, error) {
var tickerPrice ticker.TickerPrice
tickerNew, err := b.GetTicker(p.Pair().String(), nil)
@@ -74,6 +57,7 @@ func (b *Bitfinex) UpdateTicker(p pair.CurrencyPair) (ticker.TickerPrice, error)
return tickerPrice, nil
}
// GetTickerPrice returns the ticker
func (b *Bitfinex) GetTickerPrice(p pair.CurrencyPair) (ticker.TickerPrice, error) {
tick, err := ticker.GetTicker(b.GetName(), p)
if err != nil {

19
exchanges/bitstamp/bitstamp_wrapper.go
View File

@@ -2,13 +2,11 @@ package bitstamp
import (
"log"
"time"
"github.com/thrasher-/gocryptotrader/common"
"github.com/thrasher-/gocryptotrader/currency/pair"
exchange "github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -28,23 +26,6 @@ func (b *Bitstamp) Run() {
if b.Websocket {
go b.PusherClient()
}
for b.Enabled {
pairs := b.GetEnabledCurrencies()
for x := range pairs {
currency := pairs[x]
go func() {
ticker, err := b.UpdateTicker(currency)
if err != nil {
log.Println(err)
return
}
log.Printf("Bitstamp %s: Last %f High %f Low %f Volume %f\n", exchange.FormatCurrency(currency).String(), ticker.Last, ticker.High, ticker.Low, ticker.Volume)
stats.AddExchangeInfo(b.GetName(), currency.GetFirstCurrency().String(), currency.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
}()
}
time.Sleep(time.Second * b.RESTPollingDelay)
}
}
func (b *Bitstamp) UpdateTicker(p pair.CurrencyPair) (ticker.TickerPrice, error) {

35
exchanges/bittrex/bittrex_wrapper.go
View File

@@ -2,13 +2,11 @@ package bittrex
import (
"log"
"time"
"github.com/thrasher-/gocryptotrader/common"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -54,23 +52,6 @@ func (b *Bittrex) Run() {
log.Printf("%s Failed to get config.\n", b.GetName())
}
}
for b.Enabled {
pairs := b.GetEnabledCurrencies()
for x := range pairs {
currency := pairs[x]
go func() {
ticker, err := b.GetTickerPrice(currency)
if err != nil {
log.Println(err)
return
}
log.Printf("Bittrex %s Last %f Bid %f Ask %f Volume %f\n", exchange.FormatCurrency(currency).String(), ticker.Last, ticker.Bid, ticker.Ask, ticker.Volume)
stats.AddExchangeInfo(b.GetName(), currency.GetFirstCurrency().String(), currency.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
}()
}
time.Sleep(time.Second * b.RESTPollingDelay)
}
}
//GetExchangeAccountInfo Retrieves balances for all enabled currencies for the Bittrexexchange
@@ -92,13 +73,7 @@ func (b *Bittrex) GetExchangeAccountInfo() (exchange.AccountInfo, error) {
return response, nil
}
// GetTickerPrice returns the ticker for a currencyp pair
func (b *Bittrex) GetTickerPrice(p pair.CurrencyPair) (ticker.TickerPrice, error) {
tickerNew, err := ticker.GetTicker(b.GetName(), p)
if err == nil {
return tickerNew, nil
}
func (b *Bittrex) UpdateTicker(p pair.CurrencyPair) (ticker.TickerPrice, error) {
var tickerPrice ticker.TickerPrice
tick, err := b.GetMarketSummary(exchange.FormatExchangeCurrency(b.GetName(), p).String())
if err != nil {
@@ -113,6 +88,14 @@ func (b *Bittrex) GetTickerPrice(p pair.CurrencyPair) (ticker.TickerPrice, error
return tickerPrice, nil
}
func (b *Bittrex) GetTickerPrice(p pair.CurrencyPair) (ticker.TickerPrice, error) {
tick, err := ticker.GetTicker(b.GetName(), p)
if err != nil {
return b.UpdateTicker(p)
}
return tick, nil
}
// GetOrderbookEx returns the orderbook for a currencyp pair
func (b *Bittrex) GetOrderbookEx(p pair.CurrencyPair) (orderbook.OrderbookBase, error) {
ob, err := orderbook.GetOrderbook(b.GetName(), p)

19
exchanges/btcc/btcc_wrapper.go
View File

@@ -2,13 +2,11 @@ package btcc
import (
"log"
"time"
"github.com/thrasher-/gocryptotrader/common"
"github.com/thrasher-/gocryptotrader/currency/pair"
exchange "github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -26,23 +24,6 @@ func (b *BTCC) Run() {
if b.Websocket {
go b.WebsocketClient()
}
for b.Enabled {
pairs := b.GetEnabledCurrencies()
for x := range pairs {
currency := pairs[x]
go func() {
ticker, err := b.UpdateTicker(currency)
if err != nil {
log.Println(err)
return
}
log.Printf("BTCC %s: Last %f High %f Low %f Volume %f\n", exchange.FormatCurrency(currency).String(), ticker.Last, ticker.High, ticker.Low, ticker.Volume)
stats.AddExchangeInfo(b.GetName(), currency.GetFirstCurrency().String(), currency.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
}()
}
time.Sleep(time.Second * b.RESTPollingDelay)
}
}
func (b *BTCC) UpdateTicker(p pair.CurrencyPair) (ticker.TickerPrice, error) {

23
exchanges/btcmarkets/btcmarkets_wrapper.go
View File

@@ -2,15 +2,12 @@ package btcmarkets
import (
"log"
"time"
"github.com/thrasher-/gocryptotrader/common"
"github.com/thrasher-/gocryptotrader/currency"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -51,26 +48,6 @@ func (b *BTCMarkets) Run() {
return
}
}
for b.Enabled {
pairs := b.GetEnabledCurrencies()
for x := range pairs {
curr := pairs[x]
go func() {
ticker, err := b.UpdateTicker(curr)
if err != nil {
return
}
BTCMarketsLastUSD, _ := currency.ConvertCurrency(ticker.Last, "AUD", "USD")
BTCMarketsBestBidUSD, _ := currency.ConvertCurrency(ticker.Bid, "AUD", "USD")
BTCMarketsBestAskUSD, _ := currency.ConvertCurrency(ticker.Ask, "AUD", "USD")
log.Printf("BTC Markets %s: Last %f (%f) Bid %f (%f) Ask %f (%f)\n", exchange.FormatCurrency(curr).String(), BTCMarketsLastUSD, ticker.Last, BTCMarketsBestBidUSD, ticker.Bid, BTCMarketsBestAskUSD, ticker.Ask)
stats.AddExchangeInfo(b.GetName(), curr.GetFirstCurrency().String(), curr.GetSecondCurrency().String(), ticker.Last, 0)
stats.AddExchangeInfo(b.GetName(), curr.GetFirstCurrency().String(), "USD", BTCMarketsLastUSD, 0)
}()
}
time.Sleep(time.Second * b.RESTPollingDelay)
}
}
func (b *BTCMarkets) UpdateTicker(p pair.CurrencyPair) (ticker.TickerPrice, error) {

19
exchanges/coinut/coinut_wrapper.go
View File

@@ -2,13 +2,11 @@ package coinut
import (
"log"
"time"
"github.com/thrasher-/gocryptotrader/common"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -44,23 +42,6 @@ func (c *COINUT) Run() {
if err != nil {
log.Printf("%s Failed to get config.\n", c.GetName())
}
for c.Enabled {
pairs := c.GetEnabledCurrencies()
for x := range pairs {
currency := pairs[x]
go func() {
ticker, err := c.UpdateTicker(currency)
if err != nil {
log.Println(err)
return
}
log.Printf("COINUT %s: Last %f High %f Low %f Volume %f\n", exchange.FormatCurrency(currency).String(), ticker.Last, ticker.High, ticker.Low, ticker.Volume)
stats.AddExchangeInfo(c.GetName(), currency.GetFirstCurrency().String(), currency.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
}()
}
time.Sleep(time.Second * c.RESTPollingDelay)
}
}
// GetExchangeAccountInfo : Retrieves balances for all enabled currencies for the COINUT exchange

20
exchanges/gdax/gdax_wrapper.go
View File

@@ -2,13 +2,11 @@ package gdax
import (
"log"
"time"
"github.com/thrasher-/gocryptotrader/common"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -42,24 +40,6 @@ func (g *GDAX) Run() {
log.Printf("%s Failed to get config.\n", g.GetName())
}
}
for g.Enabled {
pairs := g.GetEnabledCurrencies()
for x := range pairs {
currency := pairs[x]
go func() {
ticker, err := g.UpdateTicker(currency)
if err != nil {
log.Println(err)
return
}
log.Printf("GDAX %s: Last %f High %f Low %f Volume %f\n", exchange.FormatCurrency(currency).String(), ticker.Last, ticker.High, ticker.Low, ticker.Volume)
stats.AddExchangeInfo(g.GetName(), currency.GetFirstCurrency().String(), currency.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
}()
}
time.Sleep(time.Second * g.RESTPollingDelay)
}
}
//GetExchangeAccountInfo : Retrieves balances for all enabled currencies for the GDAX exchange

19
exchanges/gemini/gemini_wrapper.go
View File

@@ -3,12 +3,10 @@ package gemini
import (
"log"
"net/url"
"time"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -31,23 +29,6 @@ func (g *Gemini) Run() {
log.Printf("%s Failed to get config.\n", g.GetName())
}
}
for g.Enabled {
pairs := g.GetEnabledCurrencies()
for x := range pairs {
currency := pairs[x]
go func() {
ticker, err := g.UpdateTicker(currency)
if err != nil {
log.Println(err)
return
}
log.Printf("Gemini %s Last %f Bid %f Ask %f Volume %f\n", exchange.FormatCurrency(currency).String(), ticker.Last, ticker.Bid, ticker.Ask, ticker.Volume)
stats.AddExchangeInfo(g.GetName(), currency.GetFirstCurrency().String(), currency.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
}()
}
time.Sleep(time.Second * g.RESTPollingDelay)
}
}
//GetExchangeAccountInfo : Retrieves balances for all enabled currencies for the Gemini exchange

24
exchanges/huobi/huobi_wrapper.go
View File

@@ -2,14 +2,11 @@ package huobi
import (
"log"
"time"
"github.com/thrasher-/gocryptotrader/common"
"github.com/thrasher-/gocryptotrader/currency"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -27,27 +24,6 @@ func (h *HUOBI) Run() {
if h.Websocket {
go h.WebsocketClient()
}
for h.Enabled {
pairs := h.GetEnabledCurrencies()
for x := range pairs {
curr := pairs[x]
go func() {
ticker, err := h.UpdateTicker(curr)
if err != nil {
log.Println(err)
return
}
HuobiLastUSD, _ := currency.ConvertCurrency(ticker.Last, "CNY", "USD")
HuobiHighUSD, _ := currency.ConvertCurrency(ticker.High, "CNY", "USD")
HuobiLowUSD, _ := currency.ConvertCurrency(ticker.Low, "CNY", "USD")
log.Printf("Huobi %s: Last %f (%f) High %f (%f) Low %f (%f) Volume %f\n", exchange.FormatCurrency(curr).String(), HuobiLastUSD, ticker.Last, HuobiHighUSD, ticker.High, HuobiLowUSD, ticker.Low, ticker.Volume)
stats.AddExchangeInfo(h.GetName(), curr.GetFirstCurrency().String(), curr.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
stats.AddExchangeInfo(h.GetName(), curr.GetFirstCurrency().String(), "USD", HuobiLastUSD, ticker.Volume)
}()
}
time.Sleep(time.Second * h.RESTPollingDelay)
}
}
func (h *HUOBI) UpdateTicker(p pair.CurrencyPair) (ticker.TickerPrice, error) {

19
exchanges/itbit/itbit_wrapper.go
View File

@@ -3,12 +3,10 @@ package itbit
import (
"log"
"strconv"
"time"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -20,23 +18,6 @@ func (i *ItBit) Run() {
log.Printf("%s polling delay: %ds.\n", i.GetName(), i.RESTPollingDelay)
log.Printf("%s %d currencies enabled: %s.\n", i.GetName(), len(i.EnabledPairs), i.EnabledPairs)
}
for i.Enabled {
pairs := i.GetEnabledCurrencies()
for x := range pairs {
currency := pairs[x]
go func() {
ticker, err := i.UpdateTicker(currency)
if err != nil {
log.Println(err)
return
}
log.Printf("ItBit %s: Last %f High %f Low %f Volume %f\n", exchange.FormatCurrency(currency).String(), ticker.Last, ticker.High, ticker.Low, ticker.Volume)
stats.AddExchangeInfo(i.GetName(), currency.GetFirstCurrency().String(), currency.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
}()
}
time.Sleep(time.Second * i.RESTPollingDelay)
}
}
func (i *ItBit) UpdateTicker(p pair.CurrencyPair) (ticker.TickerPrice, error) {

69
exchanges/kraken/kraken_wrapper.go
View File

@@ -2,12 +2,10 @@ package kraken
import (
"log"
"time"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -34,46 +32,47 @@ func (k *Kraken) Run() {
log.Printf("%s Failed to get config.\n", k.GetName())
}
}
for k.Enabled {
pairs := k.GetEnabledCurrencies()
pairsCollated, err := exchange.GetAndFormatExchangeCurrencies(k.Name, pairs)
if err != nil {
log.Println(err)
continue
}
err = k.GetTicker(pairsCollated.String())
if err != nil {
log.Println(err)
} else {
for _, x := range pairs {
ticker := k.Ticker[x.Pair().String()]
log.Printf("Kraken %s Last %f High %f Low %f Volume %f\n", exchange.FormatCurrency(x).String(), ticker.Last, ticker.High, ticker.Low, ticker.Volume)
stats.AddExchangeInfo(k.GetName(), x.GetFirstCurrency().String(), x.GetSecondCurrency().String(),
ticker.Last, ticker.Volume)
}
}
time.Sleep(time.Second * k.RESTPollingDelay)
}
}
func (k *Kraken) UpdateTicker(p pair.CurrencyPair) (ticker.TickerPrice, error) {
return ticker.TickerPrice{}, nil
var tickerPrice ticker.TickerPrice
pairs := k.GetEnabledCurrencies()
pairsCollated, err := exchange.GetAndFormatExchangeCurrencies(k.Name, pairs)
if err != nil {
return tickerPrice, err
}
err = k.GetTicker(pairsCollated.String())
if err != nil {
return tickerPrice, err
}
for _, x := range pairs {
var tp ticker.TickerPrice
tick, ok := k.Ticker[x.Pair().String()]
if !ok {
continue
}
tp.Pair = x
tp.Last = tick.Last
tp.Ask = tick.Ask
tp.Bid = tick.Bid
tp.High = tick.High
tp.Low = tick.Low
tp.Volume = tick.Volume
ticker.ProcessTicker(k.GetName(), x, tp)
}
return ticker.GetTicker(k.GetName(), p)
}
//This will return the TickerPrice struct when tickers are completed here..
func (k *Kraken) GetTickerPrice(p pair.CurrencyPair) (ticker.TickerPrice, error) {
var tickerPrice ticker.TickerPrice
/*
ticker, err := i.GetTicker(currency)
if err != nil {
log.Println(err)
return tickerPrice
}
tickerPrice.Ask = ticker.Ask
tickerPrice.Bid = ticker.Bid
*/
return tickerPrice, nil
tickerNew, err := ticker.GetTicker(k.GetName(), p)
if err != nil {
return k.UpdateTicker(p)
}
return tickerNew, nil
}
func (k *Kraken) GetOrderbookEx(p pair.CurrencyPair) (orderbook.OrderbookBase, error) {

17
exchanges/lakebtc/lakebtc_wrapper.go
View File

@@ -3,13 +3,11 @@ package lakebtc
import (
"log"
"strconv"
"time"
"github.com/thrasher-/gocryptotrader/common"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -21,21 +19,6 @@ func (l *LakeBTC) Run() {
log.Printf("%s polling delay: %ds.\n", l.GetName(), l.RESTPollingDelay)
log.Printf("%s %d currencies enabled: %s.\n", l.GetName(), len(l.EnabledPairs), l.EnabledPairs)
}
for l.Enabled {
pairs := l.GetEnabledCurrencies()
for x := range pairs {
currency := pairs[x]
ticker, err := l.UpdateTicker(currency)
if err != nil {
log.Println(err)
continue
}
log.Printf("LakeBTC %s: Last %f High %f Low %f Volume %f\n", exchange.FormatCurrency(currency).String(), ticker.Last, ticker.High, ticker.Low, ticker.Volume)
stats.AddExchangeInfo(l.GetName(), currency.GetFirstCurrency().String(), currency.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
}
time.Sleep(time.Second * l.RESTPollingDelay)
}
}
func (l *LakeBTC) UpdateTicker(p pair.CurrencyPair) (ticker.TickerPrice, error) {

72
exchanges/liqui/liqui_wrapper.go
View File

@@ -1,15 +1,12 @@
package liqui
import (
"errors"
"log"
"time"
"github.com/thrasher-/gocryptotrader/common"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -34,52 +31,43 @@ func (l *Liqui) Run() {
log.Printf("%s Failed to get config.\n", l.GetName())
}
}
pairsString, err := exchange.GetAndFormatExchangeCurrencies(l.Name,
l.GetEnabledCurrencies())
if err != nil {
log.Println(err)
l.Enabled = false
return
}
for l.Enabled {
go func() {
ticker, err := l.GetTicker(pairsString.String())
if err != nil {
log.Println(err)
return
}
for x, y := range ticker {
currency := pair.NewCurrencyPairDelimiter(common.StringToUpper(x), "_")
log.Printf("Liqui %s: Last %f High %f Low %f Volume %f\n", exchange.FormatCurrency(currency).String(), y.Last, y.High, y.Low, y.Vol_cur)
l.Ticker[x] = y
stats.AddExchangeInfo(l.GetName(), currency.GetFirstCurrency().String(), currency.GetSecondCurrency().String(), y.Last, y.Vol_cur)
}
}()
time.Sleep(time.Second * l.RESTPollingDelay)
}
}
func (l *Liqui) UpdateTicker(p pair.CurrencyPair) (ticker.TickerPrice, error) {
return ticker.TickerPrice{}, nil
var tickerPrice ticker.TickerPrice
pairsString, err := exchange.GetAndFormatExchangeCurrencies(l.Name,
l.GetEnabledCurrencies())
if err != nil {
return tickerPrice, err
}
result, err := l.GetTicker(pairsString.String())
if err != nil {
return tickerPrice, err
}
for x, y := range result {
var tp ticker.TickerPrice
currency := pair.NewCurrencyPairDelimiter(common.StringToUpper(x), "_")
tp.Pair = currency
tp.Last = y.Last
tp.Ask = y.Sell
tp.Bid = y.Buy
tp.Last = y.Last
tp.Low = y.Low
tp.Volume = y.Vol_cur
ticker.ProcessTicker(l.GetName(), currency, tp)
}
return ticker.GetTicker(l.GetName(), p)
}
func (l *Liqui) GetTickerPrice(p pair.CurrencyPair) (ticker.TickerPrice, error) {
var tickerPrice ticker.TickerPrice
tick, ok := l.Ticker[exchange.FormatExchangeCurrency(l.Name, p).String()]
if !ok {
return tickerPrice, errors.New("unable to get currency")
tickerNew, err := ticker.GetTicker(l.GetName(), p)
if err != nil {
return l.UpdateTicker(p)
}
tickerPrice.Pair = p
tickerPrice.Ask = tick.Buy
tickerPrice.Bid = tick.Sell
tickerPrice.Low = tick.Low
tickerPrice.Last = tick.Last
tickerPrice.Volume = tick.Vol_cur
tickerPrice.High = tick.High
ticker.ProcessTicker(l.GetName(), p, tickerPrice)
return tickerPrice, nil
return tickerNew, nil
}
func (l *Liqui) GetOrderbookEx(p pair.CurrencyPair) (orderbook.OrderbookBase, error) {

56
exchanges/localbitcoins/localbitcoins_wrapper.go
View File

@@ -2,12 +2,12 @@ package localbitcoins
import (
"log"
"time"
"github.com/thrasher-/gocryptotrader/common"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -20,49 +20,33 @@ func (l *LocalBitcoins) Run() {
log.Printf("%s polling delay: %ds.\n", l.GetName(), l.RESTPollingDelay)
log.Printf("%s %d currencies enabled: %s.\n", l.GetName(), len(l.EnabledPairs), l.EnabledPairs)
}
for l.Enabled {
pairs := l.GetEnabledCurrencies()
for x := range pairs {
currency := pairs[x]
ticker, err := l.GetTickerPrice(currency)
if err != nil {
log.Println(err)
return
}
log.Printf("LocalBitcoins BTC %s: Last %f Volume %f\n", exchange.FormatCurrency(currency).String(), ticker.Last, ticker.Volume)
stats.AddExchangeInfo(l.GetName(), currency.GetFirstCurrency().String(), currency.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
}
time.Sleep(time.Second * l.RESTPollingDelay)
}
}
func (l *LocalBitcoins) UpdateTicker(p pair.CurrencyPair) (ticker.TickerPrice, error) {
return ticker.TickerPrice{}, nil
var tickerPrice ticker.TickerPrice
tick, err := l.GetTicker()
if err != nil {
return tickerPrice, err
}
for key, value := range tick {
currency := pair.NewCurrencyPair("BTC", common.StringToUpper(key))
var tp ticker.TickerPrice
tp.Pair = currency
tp.Last = value.Rates.Last
tp.Volume = value.VolumeBTC
ticker.ProcessTicker(l.GetName(), currency, tp)
}
return ticker.GetTicker(l.GetName(), p)
}
func (l *LocalBitcoins) GetTickerPrice(p pair.CurrencyPair) (ticker.TickerPrice, error) {
tickerNew, err := ticker.GetTicker(l.GetName(), p)
if err == nil {
return tickerNew, nil
return l.UpdateTicker(p)
}
tick, err := l.GetTicker()
if err != nil {
return ticker.TickerPrice{}, err
}
var tickerPrice ticker.TickerPrice
for key, value := range tick {
tickerPrice.Pair = p
tickerPrice.Last = value.Rates.Last
tickerPrice.Pair.SecondCurrency = pair.CurrencyItem(key)
tickerPrice.Volume = value.VolumeBTC
ticker.ProcessTicker(l.GetName(), p, tickerPrice)
}
return tickerPrice, nil
return tickerNew, nil
}
func (l *LocalBitcoins) GetOrderbookEx(p pair.CurrencyPair) (orderbook.OrderbookBase, error) {

24
exchanges/okcoin/okcoin_wrapper.go
View File

@@ -5,7 +5,6 @@ import (
"time"
"github.com/thrasher-/gocryptotrader/common"
"github.com/thrasher-/gocryptotrader/currency"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
@@ -45,29 +44,6 @@ func (o *OKCoin) Run() {
stats.AddExchangeInfo(o.GetName(), curr.GetFirstCurrency().String(), curr.GetSecondCurrency().String(), ticker.Last, ticker.Vol)
}()
}
go func() {
ticker, err := o.UpdateTicker(curr)
if err != nil {
log.Println(err)
return
}
log.Printf("OKCoin Intl Spot %s: Last %f High %f Low %f Volume %f\n", exchange.FormatCurrency(curr).String(), ticker.Last, ticker.High, ticker.Low, ticker.Volume)
stats.AddExchangeInfo(o.GetName(), curr.GetFirstCurrency().String(), curr.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
}()
} else {
go func() {
ticker, err := o.UpdateTicker(curr)
if err != nil {
log.Println(err)
return
}
tickerLastUSD, _ := currency.ConvertCurrency(ticker.Last, "CNY", "USD")
tickerHighUSD, _ := currency.ConvertCurrency(ticker.High, "CNY", "USD")
tickerLowUSD, _ := currency.ConvertCurrency(ticker.Low, "CNY", "USD")
log.Printf("OKCoin China %s: Last %f (%f) High %f (%f) Low %f (%f) Volume %f\n", exchange.FormatCurrency(curr).String(), tickerLastUSD, ticker.Last, tickerHighUSD, ticker.High, tickerLowUSD, ticker.Low, ticker.Volume)
stats.AddExchangeInfo(o.GetName(), curr.GetFirstCurrency().String(), curr.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
stats.AddExchangeInfo(o.GetName(), curr.GetFirstCurrency().String(), "USD", tickerLastUSD, ticker.Volume)
}()
}
}
time.Sleep(time.Second * o.RESTPollingDelay)

19
exchanges/poloniex/poloniex_wrapper.go
View File

@@ -2,13 +2,11 @@ package poloniex
import (
"log"
"time"
"github.com/thrasher-/gocryptotrader/common"
"github.com/thrasher-/gocryptotrader/currency/pair"
"github.com/thrasher-/gocryptotrader/exchanges"
"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-/gocryptotrader/exchanges/stats"
"github.com/thrasher-/gocryptotrader/exchanges/ticker"
)
@@ -26,23 +24,6 @@ func (p *Poloniex) Run() {
if p.Websocket {
go p.WebsocketClient()
}
for p.Enabled {
pairs := p.GetEnabledCurrencies()
for x := range pairs {
currency := pairs[x]
go func() {
ticker, err := p.UpdateTicker(currency)
if err != nil {
log.Println(err)
return
}
log.Printf("Poloniex %s Last %f High %f Low %f Volume %f\n", exchange.FormatCurrency(currency).String(), ticker.Last, ticker.High, ticker.Low, ticker.Volume)
stats.AddExchangeInfo(p.GetName(), currency.GetFirstCurrency().String(), currency.GetSecondCurrency().String(), ticker.Last, ticker.Volume)
}()
}
time.Sleep(time.Second * p.RESTPollingDelay)
}
}
func (p *Poloniex) UpdateTicker(currencyPair pair.CurrencyPair) (ticker.TickerPrice, error) {

16
routines.go
View File

@@ -4,7 +4,7 @@ import (
"log"
"time"
"github.com/thrasher-/gocryptotrader/currency/pair"
exchange "github.com/thrasher-/gocryptotrader/exchanges"
)
func TickerUpdaterRoutine() {
@@ -15,14 +15,24 @@ func TickerUpdaterRoutine() {
exchangeName := bot.exchanges[x].GetName()
enabledCurrencies := bot.exchanges[x].GetEnabledCurrencies()
for _, y := range enabledCurrencies {
currency := pair.NewCurrencyPair(y[0:3], y[3:])
for y := range enabledCurrencies {
currency := enabledCurrencies[y]
result, err := bot.exchanges[x].UpdateTicker(currency)
if err != nil {
log.Printf("failed to get %s currency", currency.Pair().String())
continue
}
log.Printf("%s %s: Last %.8f Ask %.8f Bid %.8f High %.8f Low %.8f Volume %.8f",
exchangeName,
exchange.FormatCurrency(currency).String(),
result.Last,
result.Ask,
result.Bid,
result.High,
result.Low,
result.Volume)
evt := WebsocketEvent{
Data: result,
Event: "ticker_update",