Currency package update (#247)

* Initial currency overhaul before service system implementation

* Remove redundant currency string in orderbook.Base
Unexport lastupdated field in orderbook.Base as it was being instantiated multiple times
Add error handling for process orderbook

*  Remove redundant currency string in ticker.Price
 Unexport lastupdated field in ticker.Price
 Add error handling for process ticker function and fix tests

* Phase Two Update

* Update translations to use map type - thankyou to kempeng for spotting this

* Change pair method name from Display -> Format for better readability

* Fixes misspelling and tests

* Implement requested changes from GloriousCode

* Remove reduntant function and streamlined return in currency_translation.go

* Revert pair method naming conventions

* Change currency naming conventions

* Changed code type to exported Item type with underlying string to reduce complexity

* Added interim orderbook process method to orderbook.Base type

* Changed feebuilder struct field to currency.Pair

* Adds fall over system for backup fx providers

* deprecate function and children and fix linter issue with btcmarkets

* Fixed requested changes

* Fix bug and move mtx for rates

* Fixed after rebase oopsies

* Fix linter issues

* Fixes race conditions in testing functions

* Final phase coinmarketcap update

* fix linter issues

* Implement requested changes

* Adds configuration variables to increase/decrease time durations between updating currency file and fetching new currency rates

* Add a collection of tests to improve codecov

* After rebase oopsy fixes for btse

* Fix requested changes

* fix after rebase oopsies and add more efficient comparison checks within currency pair

* Fix linter issues

exchanges/exmo/exmo.go

@@ -11,7 +11,7 @@ import (
 
 	"github.com/thrasher-/gocryptotrader/common"
 	"github.com/thrasher-/gocryptotrader/config"
-	"github.com/thrasher-/gocryptotrader/currency/symbol"
+	"github.com/thrasher-/gocryptotrader/currency"
 	exchange "github.com/thrasher-/gocryptotrader/exchanges"
 	"github.com/thrasher-/gocryptotrader/exchanges/request"
 	"github.com/thrasher-/gocryptotrader/exchanges/ticker"
@@ -88,9 +88,9 @@ func (e *EXMO) Setup(exch config.ExchangeConfig) {
 		e.SetHTTPClientUserAgent(exch.HTTPUserAgent)
 		e.RESTPollingDelay = exch.RESTPollingDelay
 		e.Verbose = exch.Verbose
-		e.BaseCurrencies = common.SplitStrings(exch.BaseCurrencies, ",")
-		e.AvailablePairs = common.SplitStrings(exch.AvailablePairs, ",")
-		e.EnabledPairs = common.SplitStrings(exch.EnabledPairs, ",")
+		e.BaseCurrencies = exch.BaseCurrencies
+		e.AvailablePairs = exch.AvailablePairs
+		e.EnabledPairs = exch.EnabledPairs
 		err := e.SetCurrencyPairFormat()
 		if err != nil {
 			log.Fatal(err)
@@ -377,7 +377,8 @@ func (e *EXMO) SendHTTPRequest(path string, result interface{}) error {
 // SendAuthenticatedHTTPRequest sends an authenticated HTTP request
 func (e *EXMO) SendAuthenticatedHTTPRequest(method, endpoint string, vals url.Values, result interface{}) error {
 	if !e.AuthenticatedAPISupport {
-		return fmt.Errorf(exchange.WarningAuthenticatedRequestWithoutCredentialsSet, e.Name)
+		return fmt.Errorf(exchange.WarningAuthenticatedRequestWithoutCredentialsSet,
+			e.Name)
 	}
 
 	if e.Nonce.Get() == 0 {
@@ -388,10 +389,15 @@ func (e *EXMO) SendAuthenticatedHTTPRequest(method, endpoint string, vals url.Va
 	vals.Set("nonce", e.Nonce.String())
 
 	payload := vals.Encode()
-	hash := common.GetHMAC(common.HashSHA512, []byte(payload), []byte(e.APISecret))
+	hash := common.GetHMAC(common.HashSHA512,
+		[]byte(payload),
+		[]byte(e.APISecret))
 
 	if e.Verbose {
-		log.Debugf("Sending %s request to %s with params %s\n", method, endpoint, payload)
+		log.Debugf("Sending %s request to %s with params %s\n",
+			method,
+			endpoint,
+			payload)
 	}
 
 	headers := make(map[string]string)
@@ -401,7 +407,13 @@ func (e *EXMO) SendAuthenticatedHTTPRequest(method, endpoint string, vals url.Va
 
 	path := fmt.Sprintf("%s/v%s/%s", e.APIUrl, exmoAPIVersion, endpoint)
 
-	return e.SendPayload(method, path, headers, strings.NewReader(payload), result, true, e.Verbose)
+	return e.SendPayload(method,
+		path,
+		headers,
+		strings.NewReader(payload),
+		result,
+		true,
+		e.Verbose)
 }
 
 // GetFee returns an estimate of fee based on type of transaction
@@ -411,11 +423,15 @@ func (e *EXMO) GetFee(feeBuilder exchange.FeeBuilder) (float64, error) {
 	case exchange.CryptocurrencyTradeFee:
 		fee = e.calculateTradingFee(feeBuilder.PurchasePrice, feeBuilder.Amount)
 	case exchange.CryptocurrencyWithdrawalFee:
-		fee = getCryptocurrencyWithdrawalFee(feeBuilder.FirstCurrency)
+		fee = getCryptocurrencyWithdrawalFee(feeBuilder.Pair.Base)
 	case exchange.InternationalBankWithdrawalFee:
-		fee = getInternationalBankWithdrawalFee(feeBuilder.CurrencyItem, feeBuilder.Amount, feeBuilder.BankTransactionType)
+		fee = getInternationalBankWithdrawalFee(feeBuilder.FiatCurrency,
+			feeBuilder.Amount,
+			feeBuilder.BankTransactionType)
 	case exchange.InternationalBankDepositFee:
-		fee = getInternationalBankDepositFee(feeBuilder.CurrencyItem, feeBuilder.Amount, feeBuilder.BankTransactionType)
+		fee = getInternationalBankDepositFee(feeBuilder.FiatCurrency,
+			feeBuilder.Amount,
+			feeBuilder.BankTransactionType)
 	}
 
 	if fee < 0 {
@@ -425,8 +441,8 @@ func (e *EXMO) GetFee(feeBuilder exchange.FeeBuilder) (float64, error) {
 	return fee, nil
 }
 
-func getCryptocurrencyWithdrawalFee(currency string) float64 {
-	return WithdrawalFees[currency]
+func getCryptocurrencyWithdrawalFee(c currency.Code) float64 {
+	return WithdrawalFees[c]
 }
 
 func (e *EXMO) calculateTradingFee(purchasePrice, amount float64) float64 {
@@ -439,69 +455,69 @@ func calculateTradingFee(purchasePrice, amount float64) float64 {
 	return fee * amount * purchasePrice
 }
 
-func getInternationalBankWithdrawalFee(currency string, amount float64, bankTransactionType exchange.InternationalBankTransactionType) float64 {
+func getInternationalBankWithdrawalFee(c currency.Code, amount float64, bankTransactionType exchange.InternationalBankTransactionType) float64 {
 	var fee float64
 
 	switch bankTransactionType {
 	case exchange.WireTransfer:
-		switch currency {
-		case symbol.RUB:
+		switch c {
+		case currency.RUB:
 			fee = 3200
-		case symbol.PLN:
+		case currency.PLN:
 			fee = 125
-		case symbol.TRY:
+		case currency.TRY:
 			fee = 0
 		}
 	case exchange.PerfectMoney:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = 0.01 * amount
-		case symbol.EUR:
+		case currency.EUR:
 			fee = 0.0195 * amount
 		}
 	case exchange.Neteller:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = 0.0195 * amount
-		case symbol.EUR:
+		case currency.EUR:
 			fee = 0.0195 * amount
 		}
 	case exchange.AdvCash:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = 0.0295 * amount
-		case symbol.EUR:
+		case currency.EUR:
 			fee = 0.03 * amount
-		case symbol.RUB:
+		case currency.RUB:
 			fee = 0.0195 * amount
-		case symbol.UAH:
+		case currency.UAH:
 			fee = 0.0495 * amount
 		}
 	case exchange.Payeer:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = 0.0395 * amount
-		case symbol.EUR:
+		case currency.EUR:
 			fee = 0.01 * amount
-		case symbol.RUB:
+		case currency.RUB:
 			fee = 0.0595 * amount
 		}
 	case exchange.Skrill:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = 0.0145 * amount
-		case symbol.EUR:
+		case currency.EUR:
 			fee = 0.03 * amount
-		case symbol.TRY:
+		case currency.TRY:
 			fee = 0
 		}
 	case exchange.VisaMastercard:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = 0.06 * amount
-		case symbol.EUR:
+		case currency.EUR:
 			fee = 0.06 * amount
-		case symbol.PLN:
+		case currency.PLN:
 			fee = 0.06 * amount
 		}
 	}
@@ -509,54 +525,54 @@ func getInternationalBankWithdrawalFee(currency string, amount float64, bankTran
 	return fee
 }
 
-func getInternationalBankDepositFee(currency string, amount float64, bankTransactionType exchange.InternationalBankTransactionType) float64 {
+func getInternationalBankDepositFee(c currency.Code, amount float64, bankTransactionType exchange.InternationalBankTransactionType) float64 {
 	var fee float64
 	switch bankTransactionType {
 	case exchange.WireTransfer:
-		switch currency {
-		case symbol.RUB:
+		switch c {
+		case currency.RUB:
 			fee = 1600
-		case symbol.PLN:
+		case currency.PLN:
 			fee = 30
-		case symbol.TRY:
+		case currency.TRY:
 			fee = 0
 		}
 	case exchange.Neteller:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = (0.035 * amount) + 0.29
-		case symbol.EUR:
+		case currency.EUR:
 			fee = (0.035 * amount) + 0.25
 		}
 	case exchange.AdvCash:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = 0.0295 * amount
-		case symbol.EUR:
+		case currency.EUR:
 			fee = 0.01 * amount
-		case symbol.RUB:
+		case currency.RUB:
 			fee = 0.0495 * amount
-		case symbol.UAH:
+		case currency.UAH:
 			fee = 0.01 * amount
 		}
 	case exchange.Payeer:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = 0.0195 * amount
-		case symbol.EUR:
+		case currency.EUR:
 			fee = 0.0295 * amount
-		case symbol.RUB:
+		case currency.RUB:
 			fee = 0.0345 * amount
 		}
 	case exchange.Skrill:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = (0.0495 * amount) + 0.36
-		case symbol.EUR:
+		case currency.EUR:
 			fee = (0.0295 * amount) + 0.29
-		case symbol.PLN:
+		case currency.PLN:
 			fee = (0.035 * amount) + 1.21
-		case symbol.TRY:
+		case currency.TRY:
 			fee = 0
 		}
 	}

exchanges/exmo/exmo_test.go

@@ -5,8 +5,7 @@ import (
 
 	"github.com/thrasher-/gocryptotrader/common"
 	"github.com/thrasher-/gocryptotrader/config"
-	"github.com/thrasher-/gocryptotrader/currency/pair"
-	"github.com/thrasher-/gocryptotrader/currency/symbol"
+	"github.com/thrasher-/gocryptotrader/currency"
 	exchange "github.com/thrasher-/gocryptotrader/exchanges"
 )
 
@@ -109,13 +108,10 @@ func TestGetRequiredAmount(t *testing.T) {
 func setFeeBuilder() exchange.FeeBuilder {
 	return exchange.FeeBuilder{
 		Amount:              1,
-		Delimiter:           "",
 		FeeType:             exchange.CryptocurrencyTradeFee,
-		FirstCurrency:       symbol.BTC,
-		SecondCurrency:      symbol.LTC,
-		IsMaker:             false,
+		Pair:                currency.NewPair(currency.BTC, currency.LTC),
 		PurchasePrice:       1,
-		CurrencyItem:        symbol.USD,
+		FiatCurrency:        currency.USD,
 		BankTransactionType: exchange.WireTransfer,
 	}
 }
@@ -168,7 +164,7 @@ func TestGetFee(t *testing.T) {
 
 	// CryptocurrencyWithdrawalFee Invalid currency
 	feeBuilder = setFeeBuilder()
-	feeBuilder.FirstCurrency = "hello"
+	feeBuilder.Pair.Base = currency.NewCode("hello")
 	feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
 	if resp, err := e.GetFee(feeBuilder); resp != float64(0) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(0), resp)
@@ -186,7 +182,7 @@ func TestGetFee(t *testing.T) {
 	// InternationalBankDepositFee Basic
 	feeBuilder = setFeeBuilder()
 	feeBuilder.FeeType = exchange.InternationalBankDepositFee
-	feeBuilder.CurrencyItem = symbol.RUB
+	feeBuilder.FiatCurrency = currency.RUB
 	if resp, err := e.GetFee(feeBuilder); resp != float64(1600) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(1600), resp)
 		t.Error(err)
@@ -195,7 +191,7 @@ func TestGetFee(t *testing.T) {
 	// InternationalBankDepositFee Basic
 	feeBuilder = setFeeBuilder()
 	feeBuilder.FeeType = exchange.InternationalBankDepositFee
-	feeBuilder.CurrencyItem = symbol.PLN
+	feeBuilder.FiatCurrency = currency.PLN
 	if resp, err := e.GetFee(feeBuilder); resp != float64(30) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(30), resp)
 		t.Error(err)
@@ -204,7 +200,7 @@ func TestGetFee(t *testing.T) {
 	// InternationalBankWithdrawalFee Basic
 	feeBuilder = setFeeBuilder()
 	feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
-	feeBuilder.CurrencyItem = symbol.PLN
+	feeBuilder.FiatCurrency = currency.PLN
 	if resp, err := e.GetFee(feeBuilder); resp != float64(125) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(125), resp)
 		t.Error(err)
@@ -213,7 +209,7 @@ func TestGetFee(t *testing.T) {
 	// InternationalBankWithdrawalFee Basic
 	feeBuilder = setFeeBuilder()
 	feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
-	feeBuilder.CurrencyItem = symbol.TRY
+	feeBuilder.FiatCurrency = currency.TRY
 	if resp, err := e.GetFee(feeBuilder); resp != float64(0) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(0), resp)
 		t.Error(err)
@@ -222,7 +218,7 @@ func TestGetFee(t *testing.T) {
 	// InternationalBankWithdrawalFee Basic
 	feeBuilder = setFeeBuilder()
 	feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
-	feeBuilder.CurrencyItem = symbol.EUR
+	feeBuilder.FiatCurrency = currency.EUR
 	if resp, err := e.GetFee(feeBuilder); resp != float64(0) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(0), resp)
 		t.Error(err)
@@ -231,7 +227,7 @@ func TestGetFee(t *testing.T) {
 	// InternationalBankWithdrawalFee Basic
 	feeBuilder = setFeeBuilder()
 	feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
-	feeBuilder.CurrencyItem = symbol.RUB
+	feeBuilder.FiatCurrency = currency.RUB
 	if resp, err := e.GetFee(feeBuilder); resp != float64(3200) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(3200), resp)
 		t.Error(err)
@@ -273,9 +269,9 @@ func TestGetOrderHistory(t *testing.T) {
 	var getOrdersRequest = exchange.GetOrdersRequest{
 		OrderType: exchange.AnyOrderType,
 	}
-	currPair := pair.NewCurrencyPair(symbol.BTC, symbol.USD)
+	currPair := currency.NewPair(currency.BTC, currency.USD)
 	currPair.Delimiter = "_"
-	getOrdersRequest.Currencies = []pair.CurrencyPair{currPair}
+	getOrdersRequest.Currencies = []currency.Pair{currPair}
 
 	_, err := e.GetOrderHistory(getOrdersRequest)
 	if areTestAPIKeysSet() && err != nil {
@@ -302,10 +298,10 @@ func TestSubmitOrder(t *testing.T) {
 		t.Skip("API keys set, canManipulateRealOrders false, skipping test")
 	}
 
-	var p = pair.CurrencyPair{
-		Delimiter:      "_",
-		FirstCurrency:  symbol.BTC,
-		SecondCurrency: symbol.USD,
+	var p = currency.Pair{
+		Delimiter: "_",
+		Base:      currency.BTC,
+		Quote:     currency.USD,
 	}
 	response, err := e.SubmitOrder(p, exchange.BuyOrderSide, exchange.MarketOrderType, 1, 10, "1234234")
 	if areTestAPIKeysSet() && (err != nil || !response.IsOrderPlaced) {
@@ -323,7 +319,7 @@ func TestCancelExchangeOrder(t *testing.T) {
 		t.Skip("API keys set, canManipulateRealOrders false, skipping test")
 	}
 
-	currencyPair := pair.NewCurrencyPair(symbol.LTC, symbol.BTC)
+	currencyPair := currency.NewPair(currency.LTC, currency.BTC)
 
 	var orderCancellation = exchange.OrderCancellation{
 		OrderID:       "1",
@@ -350,7 +346,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
 		t.Skip("API keys set, canManipulateRealOrders false, skipping test")
 	}
 
-	currencyPair := pair.NewCurrencyPair(symbol.LTC, symbol.BTC)
+	currencyPair := currency.NewPair(currency.LTC, currency.BTC)
 	var orderCancellation = exchange.OrderCancellation{
 		OrderID:       "1",
 		WalletAddress: "1F5zVDgNjorJ51oGebSvNCrSAHpwGkUdDB",
@@ -384,7 +380,7 @@ func TestWithdraw(t *testing.T) {
 	TestSetup(t)
 	var withdrawCryptoRequest = exchange.WithdrawRequest{
 		Amount:      100,
-		Currency:    symbol.LTC,
+		Currency:    currency.LTC,
 		Address:     "1F5zVDgNjorJ51oGebSvNCrSAHpwGkUdDB",
 		Description: "WITHDRAW IT ALL",
 	}
@@ -436,12 +432,12 @@ func TestWithdrawInternationalBank(t *testing.T) {
 
 func TestGetDepositAddress(t *testing.T) {
 	if areTestAPIKeysSet() {
-		_, err := e.GetDepositAddress(symbol.LTC, "")
+		_, err := e.GetDepositAddress(currency.LTC, "")
 		if err != nil {
 			t.Error("Test Failed - GetDepositAddress() error", err)
 		}
 	} else {
-		_, err := e.GetDepositAddress(symbol.LTC, "")
+		_, err := e.GetDepositAddress(currency.LTC, "")
 		if err == nil {
 			t.Error("Test Failed - GetDepositAddress() error cannot be nil")
 		}

exchanges/exmo/exmo_types.go

@@ -1,6 +1,6 @@
 package exmo
 
-import "github.com/thrasher-/gocryptotrader/currency/symbol"
+import "github.com/thrasher-/gocryptotrader/currency"
 
 // Trades holds trade data
 type Trades struct {
@@ -148,30 +148,30 @@ type WalletHistory struct {
 
 // WithdrawalFees the large list of predefined withdrawal fees
 // Prone to change
-var WithdrawalFees = map[string]float64{
-	symbol.BTC:   0.0005,
-	symbol.LTC:   0.01,
-	symbol.DOGE:  1,
-	symbol.DASH:  0.01,
-	symbol.ETH:   0.01,
-	symbol.WAVES: 0.001,
-	symbol.ZEC:   0.001,
-	symbol.USDT:  5,
-	symbol.XMR:   0.05,
-	symbol.XRP:   0.02,
-	symbol.KICK:  50,
-	symbol.ETC:   0.01,
-	symbol.BCH:   0.001,
-	symbol.BTG:   0.001,
-	symbol.HBZ:   65,
-	symbol.BTCZ:  5,
-	symbol.DXT:   20,
-	symbol.STQ:   100,
-	symbol.XLM:   0.001,
-	symbol.OMG:   0.5,
-	symbol.TRX:   1,
-	symbol.ADA:   1,
-	symbol.INK:   50,
-	symbol.ZRX:   1,
-	symbol.GNT:   1,
+var WithdrawalFees = map[currency.Code]float64{
+	currency.BTC:   0.0005,
+	currency.LTC:   0.01,
+	currency.DOGE:  1,
+	currency.DASH:  0.01,
+	currency.ETH:   0.01,
+	currency.WAVES: 0.001,
+	currency.ZEC:   0.001,
+	currency.USDT:  5,
+	currency.XMR:   0.05,
+	currency.XRP:   0.02,
+	currency.KICK:  50,
+	currency.ETC:   0.01,
+	currency.BCH:   0.001,
+	currency.BTG:   0.001,
+	currency.HBZ:   65,
+	currency.BTCZ:  5,
+	currency.DXT:   20,
+	currency.STQ:   100,
+	currency.XLM:   0.001,
+	currency.OMG:   0.5,
+	currency.TRX:   1,
+	currency.ADA:   1,
+	currency.INK:   50,
+	currency.ZRX:   1,
+	currency.GNT:   1,
 }

exchanges/exmo/exmo_wrapper.go

@@ -9,7 +9,7 @@ import (
 	"time"
 
 	"github.com/thrasher-/gocryptotrader/common"
-	"github.com/thrasher-/gocryptotrader/currency/pair"
+	"github.com/thrasher-/gocryptotrader/currency"
 	exchange "github.com/thrasher-/gocryptotrader/exchanges"
 	"github.com/thrasher-/gocryptotrader/exchanges/orderbook"
 	"github.com/thrasher-/gocryptotrader/exchanges/ticker"
@@ -40,7 +40,14 @@ func (e *EXMO) Run() {
 		for x := range exchangeProducts {
 			currencies = append(currencies, x)
 		}
-		err = e.UpdateCurrencies(currencies, false, false)
+
+		var newCurrencies currency.Pairs
+		for _, p := range currencies {
+			newCurrencies = append(newCurrencies,
+				currency.NewPairFromString(p))
+		}
+
+		err = e.UpdateCurrencies(newCurrencies, false, false)
 		if err != nil {
 			log.Errorf("%s Failed to update available currencies.\n", e.GetName())
 		}
@@ -48,14 +55,14 @@ func (e *EXMO) Run() {
 }
 
 // UpdateTicker updates and returns the ticker for a currency pair
-func (e *EXMO) UpdateTicker(p pair.CurrencyPair, assetType string) (ticker.Price, error) {
+func (e *EXMO) UpdateTicker(p currency.Pair, assetType string) (ticker.Price, error) {
 	var tickerPrice ticker.Price
 	pairsCollated, err := exchange.GetAndFormatExchangeCurrencies(e.Name, e.GetEnabledCurrencies())
 	if err != nil {
 		return tickerPrice, err
 	}
 
-	result, err := e.GetTicker(pairsCollated.String())
+	result, err := e.GetTicker(pairsCollated)
 	if err != nil {
 		return tickerPrice, err
 	}
@@ -71,13 +78,17 @@ func (e *EXMO) UpdateTicker(p pair.CurrencyPair, assetType string) (ticker.Price
 		tickerPrice.Last = result[currency].Last
 		tickerPrice.Low = result[currency].Low
 		tickerPrice.Volume = result[currency].Volume
-		ticker.ProcessTicker(e.Name, x, tickerPrice, assetType)
+
+		err = ticker.ProcessTicker(e.Name, tickerPrice, assetType)
+		if err != nil {
+			return tickerPrice, err
+		}
 	}
 	return ticker.GetTicker(e.Name, p, assetType)
 }
 
 // GetTickerPrice returns the ticker for a currency pair
-func (e *EXMO) GetTickerPrice(p pair.CurrencyPair, assetType string) (ticker.Price, error) {
+func (e *EXMO) GetTickerPrice(p currency.Pair, assetType string) (ticker.Price, error) {
 	tick, err := ticker.GetTicker(e.GetName(), p, assetType)
 	if err != nil {
 		return e.UpdateTicker(p, assetType)
@@ -86,8 +97,8 @@ func (e *EXMO) GetTickerPrice(p pair.CurrencyPair, assetType string) (ticker.Pri
 }
 
 // GetOrderbookEx returns the orderbook for a currency pair
-func (e *EXMO) GetOrderbookEx(p pair.CurrencyPair, assetType string) (orderbook.Base, error) {
-	ob, err := orderbook.GetOrderbook(e.GetName(), p, assetType)
+func (e *EXMO) GetOrderbookEx(p currency.Pair, assetType string) (orderbook.Base, error) {
+	ob, err := orderbook.Get(e.GetName(), p, assetType)
 	if err != nil {
 		return e.UpdateOrderbook(p, assetType)
 	}
@@ -95,14 +106,14 @@ func (e *EXMO) GetOrderbookEx(p pair.CurrencyPair, assetType string) (orderbook.
 }
 
 // UpdateOrderbook updates and returns the orderbook for a currency pair
-func (e *EXMO) UpdateOrderbook(p pair.CurrencyPair, assetType string) (orderbook.Base, error) {
+func (e *EXMO) UpdateOrderbook(p currency.Pair, assetType string) (orderbook.Base, error) {
 	var orderBook orderbook.Base
 	pairsCollated, err := exchange.GetAndFormatExchangeCurrencies(e.Name, e.GetEnabledCurrencies())
 	if err != nil {
 		return orderBook, err
 	}
 
-	result, err := e.GetOrderbook(pairsCollated.String())
+	result, err := e.GetOrderbook(pairsCollated)
 	if err != nil {
 		return orderBook, err
 	}
@@ -133,9 +144,16 @@ func (e *EXMO) UpdateOrderbook(p pair.CurrencyPair, assetType string) (orderbook
 		}
 
 		orderBook.Bids = obItems
-		orderbook.ProcessOrderbook(e.Name, x, orderBook, assetType)
+		orderBook.Pair = p
+		orderBook.ExchangeName = e.GetName()
+		orderBook.AssetType = assetType
+
+		err = orderBook.Process()
+		if err != nil {
+			return orderBook, err
+		}
 	}
-	return orderbook.GetOrderbook(e.Name, p, assetType)
+	return orderbook.Get(e.Name, p, assetType)
 }
 
 // GetAccountInfo retrieves balances for all enabled currencies for the
@@ -151,7 +169,7 @@ func (e *EXMO) GetAccountInfo() (exchange.AccountInfo, error) {
 	var currencies []exchange.AccountCurrencyInfo
 	for x, y := range result.Balances {
 		var exchangeCurrency exchange.AccountCurrencyInfo
-		exchangeCurrency.CurrencyName = common.StringToUpper(x)
+		exchangeCurrency.CurrencyName = currency.NewCode(x)
 		for z, w := range result.Reserved {
 			if z == x {
 				avail, _ := strconv.ParseFloat(y, 64)
@@ -178,14 +196,14 @@ func (e *EXMO) GetFundingHistory() ([]exchange.FundHistory, error) {
 }
 
 // GetExchangeHistory returns historic trade data since exchange opening.
-func (e *EXMO) GetExchangeHistory(p pair.CurrencyPair, assetType string) ([]exchange.TradeHistory, error) {
+func (e *EXMO) GetExchangeHistory(p currency.Pair, assetType string) ([]exchange.TradeHistory, error) {
 	var resp []exchange.TradeHistory
 
 	return resp, common.ErrNotYetImplemented
 }
 
 // SubmitOrder submits a new order
-func (e *EXMO) SubmitOrder(p pair.CurrencyPair, side exchange.OrderSide, orderType exchange.OrderType, amount, price float64, _ string) (exchange.SubmitOrderResponse, error) {
+func (e *EXMO) SubmitOrder(p currency.Pair, side exchange.OrderSide, orderType exchange.OrderType, amount, price float64, _ string) (exchange.SubmitOrderResponse, error) {
 	var submitOrderResponse exchange.SubmitOrderResponse
 	var oT string
 
@@ -201,7 +219,7 @@ func (e *EXMO) SubmitOrder(p pair.CurrencyPair, side exchange.OrderSide, orderTy
 		return submitOrderResponse, errors.New("unsupported order type")
 	}
 
-	response, err := e.CreateOrder(p.Pair().String(), oT, price, amount)
+	response, err := e.CreateOrder(p.String(), oT, price, amount)
 
 	if response > 0 {
 		submitOrderResponse.OrderID = fmt.Sprintf("%v", response)
@@ -258,7 +276,7 @@ func (e *EXMO) GetOrderInfo(orderID string) (exchange.OrderDetail, error) {
 }
 
 // GetDepositAddress returns a deposit address for a specified currency
-func (e *EXMO) GetDepositAddress(cryptocurrency pair.CurrencyItem, _ string) (string, error) {
+func (e *EXMO) GetDepositAddress(cryptocurrency currency.Code, _ string) (string, error) {
 	fullAddr, err := e.GetCryptoDepositAddress()
 	if err != nil {
 		return "", err
@@ -310,7 +328,7 @@ func (e *EXMO) GetActiveOrders(getOrdersRequest exchange.GetOrdersRequest) ([]ex
 	}
 	var orders []exchange.OrderDetail
 	for _, order := range resp {
-		symbol := pair.NewCurrencyPairDelimiter(order.Pair, "_")
+		symbol := currency.NewPairDelimiter(order.Pair, "_")
 		orderDate := time.Unix(order.Created, 0)
 		orderSide := exchange.OrderSide(strings.ToUpper(order.Type))
 		orders = append(orders, exchange.OrderDetail{
@@ -324,7 +342,8 @@ func (e *EXMO) GetActiveOrders(getOrdersRequest exchange.GetOrdersRequest) ([]ex
 		})
 	}
 
-	exchange.FilterOrdersByTickRange(&orders, getOrdersRequest.StartTicks, getOrdersRequest.EndTicks)
+	exchange.FilterOrdersByTickRange(&orders, getOrdersRequest.StartTicks,
+		getOrdersRequest.EndTicks)
 	exchange.FilterOrdersBySide(&orders, getOrdersRequest.OrderSide)
 
 	return orders, nil
@@ -350,7 +369,7 @@ func (e *EXMO) GetOrderHistory(getOrdersRequest exchange.GetOrdersRequest) ([]ex
 
 	var orders []exchange.OrderDetail
 	for _, order := range allTrades {
-		symbol := pair.NewCurrencyPairDelimiter(order.Pair, "_")
+		symbol := currency.NewPairDelimiter(order.Pair, "_")
 		orderDate := time.Unix(order.Date, 0)
 		orderSide := exchange.OrderSide(strings.ToUpper(order.Type))
 		orders = append(orders, exchange.OrderDetail{
@@ -364,7 +383,8 @@ func (e *EXMO) GetOrderHistory(getOrdersRequest exchange.GetOrdersRequest) ([]ex
 		})
 	}
 
-	exchange.FilterOrdersByTickRange(&orders, getOrdersRequest.StartTicks, getOrdersRequest.EndTicks)
+	exchange.FilterOrdersByTickRange(&orders, getOrdersRequest.StartTicks,
+		getOrdersRequest.EndTicks)
 	exchange.FilterOrdersBySide(&orders, getOrdersRequest.OrderSide)
 
 	return orders, nil