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/yobit/yobit.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 (y *Yobit) Setup(exch config.ExchangeConfig) {
 		y.RESTPollingDelay = exch.RESTPollingDelay
 		y.Verbose = exch.Verbose
 		y.Websocket.SetWsStatusAndConnection(exch.Websocket)
-		y.BaseCurrencies = common.SplitStrings(exch.BaseCurrencies, ",")
-		y.AvailablePairs = common.SplitStrings(exch.AvailablePairs, ",")
-		y.EnabledPairs = common.SplitStrings(exch.EnabledPairs, ",")
+		y.BaseCurrencies = exch.BaseCurrencies
+		y.AvailablePairs = exch.AvailablePairs
+		y.EnabledPairs = exch.EnabledPairs
 		y.SetHTTPClientTimeout(exch.HTTPTimeout)
 		y.SetHTTPClientUserAgent(exch.HTTPUserAgent)
 		err := y.SetCurrencyPairFormat()
@@ -330,13 +330,20 @@ func (y *Yobit) RedeemCoupon(coupon string) (RedeemCoupon, error) {
 
 // SendHTTPRequest sends an unauthenticated HTTP request
 func (y *Yobit) SendHTTPRequest(path string, result interface{}) error {
-	return y.SendPayload(http.MethodGet, path, nil, nil, result, false, y.Verbose)
+	return y.SendPayload(http.MethodGet,
+		path,
+		nil,
+		nil,
+		result,
+		false,
+		y.Verbose)
 }
 
 // SendAuthenticatedHTTPRequest sends an authenticated HTTP request to Yobit
 func (y *Yobit) SendAuthenticatedHTTPRequest(path string, params url.Values, result interface{}) (err error) {
 	if !y.AuthenticatedAPISupport {
-		return fmt.Errorf(exchange.WarningAuthenticatedRequestWithoutCredentialsSet, y.Name)
+		return fmt.Errorf(exchange.WarningAuthenticatedRequestWithoutCredentialsSet,
+			y.Name)
 	}
 
 	if params == nil {
@@ -352,10 +359,15 @@ func (y *Yobit) SendAuthenticatedHTTPRequest(path string, params url.Values, res
 	params.Set("method", path)
 
 	encoded := params.Encode()
-	hmac := common.GetHMAC(common.HashSHA512, []byte(encoded), []byte(y.APISecret))
+	hmac := common.GetHMAC(common.HashSHA512,
+		[]byte(encoded),
+		[]byte(y.APISecret))
 
 	if y.Verbose {
-		log.Debugf("Sending POST request to %s calling path %s with params %s\n", apiPrivateURL, path, encoded)
+		log.Debugf("Sending POST request to %s calling path %s with params %s\n",
+			apiPrivateURL,
+			path,
+			encoded)
 	}
 
 	headers := make(map[string]string)
@@ -363,7 +375,13 @@ func (y *Yobit) SendAuthenticatedHTTPRequest(path string, params url.Values, res
 	headers["Sign"] = common.HexEncodeToString(hmac)
 	headers["Content-Type"] = "application/x-www-form-urlencoded"
 
-	return y.SendPayload(http.MethodPost, apiPrivateURL, headers, strings.NewReader(encoded), result, true, y.Verbose)
+	return y.SendPayload(http.MethodPost,
+		apiPrivateURL,
+		headers,
+		strings.NewReader(encoded),
+		result,
+		true,
+		y.Verbose)
 }
 
 // GetFee returns an estimate of fee based on type of transaction
@@ -373,11 +391,14 @@ func (y *Yobit) GetFee(feeBuilder exchange.FeeBuilder) (float64, error) {
 	case exchange.CryptocurrencyTradeFee:
 		fee = calculateTradingFee(feeBuilder.PurchasePrice, feeBuilder.Amount)
 	case exchange.CryptocurrencyWithdrawalFee:
-		fee = getWithdrawalFee(feeBuilder.FirstCurrency)
+		fee = getWithdrawalFee(feeBuilder.Pair.Base)
 	case exchange.InternationalBankDepositFee:
-		fee = getInternationalBankDepositFee(feeBuilder.CurrencyItem, feeBuilder.BankTransactionType)
+		fee = getInternationalBankDepositFee(feeBuilder.FiatCurrency,
+			feeBuilder.BankTransactionType)
 	case exchange.InternationalBankWithdrawalFee:
-		fee = getInternationalBankWithdrawalFee(feeBuilder.CurrencyItem, feeBuilder.Amount, feeBuilder.BankTransactionType)
+		fee = getInternationalBankWithdrawalFee(feeBuilder.FiatCurrency,
+			feeBuilder.Amount,
+			feeBuilder.BankTransactionType)
 	}
 	if fee < 0 {
 		fee = 0
@@ -391,38 +412,38 @@ func calculateTradingFee(purchasePrice, amount float64) (fee float64) {
 	return fee * amount * purchasePrice
 }
 
-func getWithdrawalFee(currency string) float64 {
-	return WithdrawalFees[currency]
+func getWithdrawalFee(c currency.Code) float64 {
+	return WithdrawalFees[c]
 }
 
-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.PerfectMoney:
-		if currency == symbol.USD {
+		if c == currency.USD {
 			fee = 0.02 * amount
 		}
 	case exchange.Payeer:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = 0.03 * amount
-		case symbol.RUR:
+		case currency.RUR:
 			fee = 0.006 * amount
 		}
 	case exchange.AdvCash:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = 0.04 * amount
-		case symbol.RUR:
+		case currency.RUR:
 			fee = 0.03 * amount
 		}
 	case exchange.Qiwi:
-		if currency == symbol.RUR {
+		if c == currency.RUR {
 			fee = 0.04 * amount
 		}
 	case exchange.Capitalist:
-		if currency == symbol.USD {
+		if c == currency.USD {
 			fee = 0.06 * amount
 		}
 	}
@@ -431,36 +452,36 @@ func getInternationalBankWithdrawalFee(currency string, amount float64, bankTran
 }
 
 // getInternationalBankDepositFee; No real fees for yobit deposits, but want to be explicit on what each payment type supports
-func getInternationalBankDepositFee(currency string, bankTransactionType exchange.InternationalBankTransactionType) float64 {
+func getInternationalBankDepositFee(c currency.Code, bankTransactionType exchange.InternationalBankTransactionType) float64 {
 	var fee float64
 	switch bankTransactionType {
 	case exchange.PerfectMoney:
-		if currency == symbol.USD {
+		if c == currency.USD {
 			fee = 0
 		}
 	case exchange.Payeer:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = 0
-		case symbol.RUR:
+		case currency.RUR:
 			fee = 0
 		}
 	case exchange.AdvCash:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = 0
-		case symbol.RUR:
+		case currency.RUR:
 			fee = 0
 		}
 	case exchange.Qiwi:
-		if currency == symbol.RUR {
+		if c == currency.RUR {
 			fee = 0
 		}
 	case exchange.Capitalist:
-		switch currency {
-		case symbol.USD:
+		switch c {
+		case currency.USD:
 			fee = 0
-		case symbol.RUR:
+		case currency.RUR:
 			fee = 0
 		}
 	}

exchanges/yobit/yobit_test.go

@@ -7,8 +7,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"
 )
 
@@ -137,14 +136,13 @@ func TestRedeemYobicode(t *testing.T) {
 
 func setFeeBuilder() exchange.FeeBuilder {
 	return exchange.FeeBuilder{
-		Amount:              1,
-		Delimiter:           "-",
-		FeeType:             exchange.CryptocurrencyTradeFee,
-		FirstCurrency:       symbol.LTC,
-		SecondCurrency:      symbol.BTC,
-		IsMaker:             false,
+		Amount:  1,
+		FeeType: exchange.CryptocurrencyTradeFee,
+		Pair: currency.NewPairWithDelimiter(currency.LTC.String(),
+			currency.BTC.String(),
+			"-"),
 		PurchasePrice:       1,
-		CurrencyItem:        symbol.USD,
+		FiatCurrency:        currency.USD,
 		BankTransactionType: exchange.WireTransfer,
 	}
 }
@@ -194,7 +192,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 := y.GetFee(feeBuilder); resp != float64(0) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(0), resp)
@@ -220,7 +218,7 @@ func TestGetFee(t *testing.T) {
 	// InternationalBankWithdrawalFee Basic
 	feeBuilder = setFeeBuilder()
 	feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
-	feeBuilder.CurrencyItem = symbol.USD
+	feeBuilder.FiatCurrency = currency.USD
 	if resp, err := y.GetFee(feeBuilder); resp != float64(0) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(0), resp)
 		t.Error(err)
@@ -229,7 +227,7 @@ func TestGetFee(t *testing.T) {
 	// InternationalBankWithdrawalFee QIWI
 	feeBuilder = setFeeBuilder()
 	feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
-	feeBuilder.CurrencyItem = symbol.USD
+	feeBuilder.FiatCurrency = currency.USD
 	feeBuilder.BankTransactionType = exchange.Qiwi
 	if resp, err := y.GetFee(feeBuilder); resp != float64(0) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(0), resp)
@@ -239,7 +237,7 @@ func TestGetFee(t *testing.T) {
 	// InternationalBankWithdrawalFee Wire
 	feeBuilder = setFeeBuilder()
 	feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
-	feeBuilder.CurrencyItem = symbol.USD
+	feeBuilder.FiatCurrency = currency.USD
 	feeBuilder.BankTransactionType = exchange.WireTransfer
 	if resp, err := y.GetFee(feeBuilder); resp != float64(0) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(0), resp)
@@ -249,7 +247,7 @@ func TestGetFee(t *testing.T) {
 	// InternationalBankWithdrawalFee Payeer
 	feeBuilder = setFeeBuilder()
 	feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
-	feeBuilder.CurrencyItem = symbol.USD
+	feeBuilder.FiatCurrency = currency.USD
 	feeBuilder.BankTransactionType = exchange.Payeer
 	if resp, err := y.GetFee(feeBuilder); resp != float64(0.03) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(0.03), resp)
@@ -259,7 +257,7 @@ func TestGetFee(t *testing.T) {
 	// InternationalBankWithdrawalFee Capitalist
 	feeBuilder = setFeeBuilder()
 	feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
-	feeBuilder.CurrencyItem = symbol.RUR
+	feeBuilder.FiatCurrency = currency.RUR
 	feeBuilder.BankTransactionType = exchange.Capitalist
 	if resp, err := y.GetFee(feeBuilder); resp != float64(0) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(0), resp)
@@ -269,7 +267,7 @@ func TestGetFee(t *testing.T) {
 	// InternationalBankWithdrawalFee AdvCash
 	feeBuilder = setFeeBuilder()
 	feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
-	feeBuilder.CurrencyItem = symbol.USD
+	feeBuilder.FiatCurrency = currency.USD
 	feeBuilder.BankTransactionType = exchange.AdvCash
 	if resp, err := y.GetFee(feeBuilder); resp != float64(0.04) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(0.04), resp)
@@ -279,7 +277,7 @@ func TestGetFee(t *testing.T) {
 	// InternationalBankWithdrawalFee PerfectMoney
 	feeBuilder = setFeeBuilder()
 	feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
-	feeBuilder.CurrencyItem = symbol.RUR
+	feeBuilder.FiatCurrency = currency.RUR
 	feeBuilder.BankTransactionType = exchange.PerfectMoney
 	if resp, err := y.GetFee(feeBuilder); resp != float64(0) || err != nil {
 		t.Errorf("Test Failed - GetFee() error. Expected: %f, Received: %f", float64(0), resp)
@@ -303,8 +301,9 @@ func TestGetActiveOrders(t *testing.T) {
 	TestSetup(t)
 
 	var getOrdersRequest = exchange.GetOrdersRequest{
-		OrderType:  exchange.AnyOrderType,
-		Currencies: []pair.CurrencyPair{pair.NewCurrencyPair(symbol.LTC, symbol.BTC)},
+		OrderType: exchange.AnyOrderType,
+		Currencies: []currency.Pair{currency.NewPair(currency.LTC,
+			currency.BTC)},
 	}
 
 	_, err := y.GetActiveOrders(getOrdersRequest)
@@ -320,8 +319,9 @@ func TestGetOrderHistory(t *testing.T) {
 	TestSetup(t)
 
 	var getOrdersRequest = exchange.GetOrdersRequest{
-		OrderType:  exchange.AnyOrderType,
-		Currencies: []pair.CurrencyPair{pair.NewCurrencyPair(symbol.LTC, symbol.BTC)},
+		OrderType: exchange.AnyOrderType,
+		Currencies: []currency.Pair{currency.NewPair(currency.LTC,
+			currency.BTC)},
 		StartTicks: time.Unix(0, 0),
 		EndTicks:   time.Unix(math.MaxInt64, 0),
 	}
@@ -352,12 +352,12 @@ 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 pair = currency.Pair{
+		Delimiter: "_",
+		Base:      currency.BTC,
+		Quote:     currency.USD,
 	}
-	response, err := y.SubmitOrder(p, exchange.BuyOrderSide, exchange.MarketOrderType, 1, 10, "hi")
+	response, err := y.SubmitOrder(pair, exchange.BuyOrderSide, exchange.MarketOrderType, 1, 10, "hi")
 	if areTestAPIKeysSet() && (err != nil || !response.IsOrderPlaced) {
 		t.Errorf("Order failed to be placed: %v", err)
 	} else if !areTestAPIKeysSet() && err == nil {
@@ -373,7 +373,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",
@@ -399,7 +399,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",
@@ -434,7 +434,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",
 	}
@@ -486,12 +486,12 @@ func TestWithdrawInternationalBank(t *testing.T) {
 
 func TestGetDepositAddress(t *testing.T) {
 	if apiKey != "" || apiSecret != "" {
-		_, err := y.GetDepositAddress(symbol.BTC, "")
+		_, err := y.GetDepositAddress(currency.BTC, "")
 		if err != nil {
 			t.Error("Test Failed - GetDepositAddress() error", err)
 		}
 	} else {
-		_, err := y.GetDepositAddress(symbol.BTC, "")
+		_, err := y.GetDepositAddress(currency.BTC, "")
 		if err == nil {
 			t.Error("Test Failed - GetDepositAddress() error")
 		}

exchanges/yobit/yobit_wrapper.go

@@ -10,7 +10,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"
@@ -36,14 +36,14 @@ func (y *Yobit) Run() {
 }
 
 // UpdateTicker updates and returns the ticker for a currency pair
-func (y *Yobit) UpdateTicker(p pair.CurrencyPair, assetType string) (ticker.Price, error) {
+func (y *Yobit) UpdateTicker(p currency.Pair, assetType string) (ticker.Price, error) {
 	var tickerPrice ticker.Price
 	pairsCollated, err := exchange.GetAndFormatExchangeCurrencies(y.Name, y.GetEnabledCurrencies())
 	if err != nil {
 		return tickerPrice, err
 	}
 
-	result, err := y.GetTicker(pairsCollated.String())
+	result, err := y.GetTicker(pairsCollated)
 	if err != nil {
 		return tickerPrice, err
 	}
@@ -58,13 +58,17 @@ func (y *Yobit) UpdateTicker(p pair.CurrencyPair, assetType string) (ticker.Pric
 		tickerPrice.Last = result[currency].Last
 		tickerPrice.Low = result[currency].Low
 		tickerPrice.Volume = result[currency].VolumeCurrent
-		ticker.ProcessTicker(y.Name, x, tickerPrice, assetType)
+
+		err = ticker.ProcessTicker(y.Name, tickerPrice, assetType)
+		if err != nil {
+			return tickerPrice, err
+		}
 	}
 	return ticker.GetTicker(y.Name, p, assetType)
 }
 
 // GetTickerPrice returns the ticker for a currency pair
-func (y *Yobit) GetTickerPrice(p pair.CurrencyPair, assetType string) (ticker.Price, error) {
+func (y *Yobit) GetTickerPrice(p currency.Pair, assetType string) (ticker.Price, error) {
 	tick, err := ticker.GetTicker(y.GetName(), p, assetType)
 	if err != nil {
 		return y.UpdateTicker(p, assetType)
@@ -73,8 +77,8 @@ func (y *Yobit) GetTickerPrice(p pair.CurrencyPair, assetType string) (ticker.Pr
 }
 
 // GetOrderbookEx returns the orderbook for a currency pair
-func (y *Yobit) GetOrderbookEx(p pair.CurrencyPair, assetType string) (orderbook.Base, error) {
-	ob, err := orderbook.GetOrderbook(y.GetName(), p, assetType)
+func (y *Yobit) GetOrderbookEx(p currency.Pair, assetType string) (orderbook.Base, error) {
+	ob, err := orderbook.Get(y.GetName(), p, assetType)
 	if err != nil {
 		return y.UpdateOrderbook(p, assetType)
 	}
@@ -82,7 +86,7 @@ func (y *Yobit) GetOrderbookEx(p pair.CurrencyPair, assetType string) (orderbook
 }
 
 // UpdateOrderbook updates and returns the orderbook for a currency pair
-func (y *Yobit) UpdateOrderbook(p pair.CurrencyPair, assetType string) (orderbook.Base, error) {
+func (y *Yobit) UpdateOrderbook(p currency.Pair, assetType string) (orderbook.Base, error) {
 	var orderBook orderbook.Base
 	orderbookNew, err := y.GetDepth(exchange.FormatExchangeCurrency(y.Name, p).String())
 	if err != nil {
@@ -99,8 +103,16 @@ func (y *Yobit) UpdateOrderbook(p pair.CurrencyPair, assetType string) (orderboo
 		orderBook.Asks = append(orderBook.Asks, orderbook.Item{Price: data[0], Amount: data[1]})
 	}
 
-	orderbook.ProcessOrderbook(y.GetName(), p, orderBook, assetType)
-	return orderbook.GetOrderbook(y.Name, p, assetType)
+	orderBook.Pair = p
+	orderBook.ExchangeName = y.GetName()
+	orderBook.AssetType = assetType
+
+	err = orderBook.Process()
+	if err != nil {
+		return orderBook, err
+	}
+
+	return orderbook.Get(y.Name, p, assetType)
 }
 
 // GetAccountInfo retrieves balances for all enabled currencies for the
@@ -116,7 +128,7 @@ func (y *Yobit) GetAccountInfo() (exchange.AccountInfo, error) {
 	var currencies []exchange.AccountCurrencyInfo
 	for x, y := range accountBalance.FundsInclOrders {
 		var exchangeCurrency exchange.AccountCurrencyInfo
-		exchangeCurrency.CurrencyName = common.StringToUpper(x)
+		exchangeCurrency.CurrencyName = currency.NewCode(x)
 		exchangeCurrency.TotalValue = y
 		exchangeCurrency.Hold = 0
 		for z, w := range accountBalance.Funds {
@@ -143,7 +155,7 @@ func (y *Yobit) GetFundingHistory() ([]exchange.FundHistory, error) {
 }
 
 // GetExchangeHistory returns historic trade data since exchange opening.
-func (y *Yobit) GetExchangeHistory(p pair.CurrencyPair, assetType string) ([]exchange.TradeHistory, error) {
+func (y *Yobit) GetExchangeHistory(p currency.Pair, assetType string) ([]exchange.TradeHistory, error) {
 	var resp []exchange.TradeHistory
 
 	return resp, common.ErrNotYetImplemented
@@ -151,14 +163,14 @@ func (y *Yobit) GetExchangeHistory(p pair.CurrencyPair, assetType string) ([]exc
 
 // SubmitOrder submits a new order
 // Yobit only supports limit orders
-func (y *Yobit) SubmitOrder(p pair.CurrencyPair, side exchange.OrderSide, orderType exchange.OrderType, amount, price float64, _ string) (exchange.SubmitOrderResponse, error) {
+func (y *Yobit) SubmitOrder(p currency.Pair, side exchange.OrderSide, orderType exchange.OrderType, amount, price float64, _ string) (exchange.SubmitOrderResponse, error) {
 	var submitOrderResponse exchange.SubmitOrderResponse
 
 	if orderType != exchange.LimitOrderType {
 		return submitOrderResponse, errors.New("only limit orders are allowed")
 	}
 
-	response, err := y.Trade(p.Pair().String(), side.ToString(), amount, price)
+	response, err := y.Trade(p.String(), side.ToString(), amount, price)
 	if response > 0 {
 		submitOrderResponse.OrderID = fmt.Sprintf("%v", response)
 	}
@@ -195,7 +207,7 @@ func (y *Yobit) CancelAllOrders(_ exchange.OrderCancellation) (exchange.CancelAl
 	var allActiveOrders []map[string]ActiveOrders
 
 	for _, pair := range y.EnabledPairs {
-		activeOrdersForPair, err := y.GetOpenOrders(pair)
+		activeOrdersForPair, err := y.GetOpenOrders(pair.String())
 		if err != nil {
 			return cancelAllOrdersResponse, err
 		}
@@ -227,7 +239,7 @@ func (y *Yobit) GetOrderInfo(orderID string) (exchange.OrderDetail, error) {
 }
 
 // GetDepositAddress returns a deposit address for a specified currency
-func (y *Yobit) GetDepositAddress(cryptocurrency pair.CurrencyItem, _ string) (string, error) {
+func (y *Yobit) GetDepositAddress(cryptocurrency currency.Code, _ string) (string, error) {
 	a, err := y.GetCryptoDepositAddress(cryptocurrency.String())
 	if err != nil {
 		return "", err
@@ -274,14 +286,16 @@ func (y *Yobit) GetFeeByType(feeBuilder exchange.FeeBuilder) (float64, error) {
 // GetActiveOrders retrieves any orders that are active/open
 func (y *Yobit) GetActiveOrders(getOrdersRequest exchange.GetOrdersRequest) ([]exchange.OrderDetail, error) {
 	var orders []exchange.OrderDetail
-	for _, currency := range getOrdersRequest.Currencies {
-		resp, err := y.GetOpenOrders(exchange.FormatExchangeCurrency(y.Name, currency).String())
+	for _, c := range getOrdersRequest.Currencies {
+		resp, err := y.GetOpenOrders(exchange.FormatExchangeCurrency(y.Name,
+			c).String())
 		if err != nil {
 			return nil, err
 		}
 
 		for ID, order := range resp {
-			symbol := pair.NewCurrencyPairDelimiter(order.Pair, y.ConfigCurrencyPairFormat.Delimiter)
+			symbol := currency.NewPairDelimiter(order.Pair,
+				y.ConfigCurrencyPairFormat.Delimiter)
 			orderDate := time.Unix(int64(order.TimestampCreated), 0)
 			side := exchange.OrderSide(strings.ToUpper(order.Type))
 			orders = append(orders, exchange.OrderDetail{
@@ -296,7 +310,8 @@ func (y *Yobit) GetActiveOrders(getOrdersRequest exchange.GetOrdersRequest) ([]e
 		}
 	}
 
-	exchange.FilterOrdersByTickRange(&orders, getOrdersRequest.StartTicks, getOrdersRequest.EndTicks)
+	exchange.FilterOrdersByTickRange(&orders, getOrdersRequest.StartTicks,
+		getOrdersRequest.EndTicks)
 	exchange.FilterOrdersBySide(&orders, getOrdersRequest.OrderSide)
 
 	return orders, nil
@@ -307,7 +322,13 @@ func (y *Yobit) GetActiveOrders(getOrdersRequest exchange.GetOrdersRequest) ([]e
 func (y *Yobit) GetOrderHistory(getOrdersRequest exchange.GetOrdersRequest) ([]exchange.OrderDetail, error) {
 	var allOrders []TradeHistory
 	for _, currency := range getOrdersRequest.Currencies {
-		resp, err := y.GetTradeHistory(0, 10000, math.MaxInt64, getOrdersRequest.StartTicks.Unix(), getOrdersRequest.EndTicks.Unix(), "DESC", exchange.FormatExchangeCurrency(y.Name, currency).String())
+		resp, err := y.GetTradeHistory(0,
+			10000,
+			math.MaxInt64,
+			getOrdersRequest.StartTicks.Unix(),
+			getOrdersRequest.EndTicks.Unix(),
+			"DESC",
+			exchange.FormatExchangeCurrency(y.Name, currency).String())
 		if err != nil {
 			return nil, err
 		}
@@ -319,7 +340,8 @@ func (y *Yobit) GetOrderHistory(getOrdersRequest exchange.GetOrdersRequest) ([]e
 
 	var orders []exchange.OrderDetail
 	for _, order := range allOrders {
-		symbol := pair.NewCurrencyPairDelimiter(order.Pair, y.ConfigCurrencyPairFormat.Delimiter)
+		symbol := currency.NewPairDelimiter(order.Pair,
+			y.ConfigCurrencyPairFormat.Delimiter)
 		orderDate := time.Unix(int64(order.Timestamp), 0)
 		side := exchange.OrderSide(strings.ToUpper(order.Type))
 		orders = append(orders, exchange.OrderDetail{