Exchanges: Include format pair in wrapper functions and test for formatting issues via tool wrapper issues (#582)

* Adds formatting of pair within binance wrapper, adds return of error from cli.ShowCommmandHelp

* Add formatting function to submit order wrapper functions

* Remove superfluous functionality

* Updated exchange wrapper issues to create a disruptive pair to see which exchanges require attention, updates currency code generation and matching

* reinstated format check, fixed tests

* fixed niterinos

* fix test

* fix spelling mistake

* make html file more aesthetic

* Add missing format pairs

* add formatting to pair for BTC Markets func

* fix spelling

cmd/exchange_wrapper_issues/exchange_wrapper_issues_test.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/thrasher-corp/gocryptotrader/currency"
+)
+
+func TestDisruptFormatting(t *testing.T) {
+	_, err := disruptFormatting(currency.Pair{})
+	if err == nil {
+		t.Fatal("error cannot be nil")
+	}
+
+	_, err = disruptFormatting(currency.Pair{Base: currency.BTC})
+	if err == nil {
+		t.Fatal("error cannot be nil")
+	}
+
+	p := currency.NewPair(currency.BTC, currency.USDT)
+
+	badPair, err := disruptFormatting(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if badPair.String() != "BTC-TEST-DELIM-usdt" {
+		t.Fatal("incorrect disrupted pair")
+	}
+}

cmd/exchange_wrapper_issues/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"encoding/json"
+	"errors"
 	"flag"
 	"fmt"
 	"io/ioutil"
@@ -94,6 +95,7 @@ func main() {
 
 	exchs := bot.GetExchanges()
 	for x := range exchs {
+		exchs[x].SetDefaults()
 		base := exchs[x].GetBase()
 		if !base.Config.Enabled {
 			log.Printf("Exchange %v not enabled, skipping", base.GetName())
@@ -289,12 +291,12 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
 	}
 	for i := range assetTypes {
 		var msg string
-		var p currency.Pair
 		log.Printf("%v %v", base.GetName(), assetTypes[i])
 		if _, ok := base.Config.CurrencyPairs.Pairs[assetTypes[i]]; !ok {
 			continue
 		}
 
+		var p currency.Pair
 		switch {
 		case currencyPairOverride != "":
 			var err error
@@ -314,13 +316,19 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
 			p = base.Config.CurrencyPairs.Pairs[assetTypes[i]].Enabled.GetRandomPair()
 		}
 
+		var err error
+		p, err = disruptFormatting(p)
+		if err != nil {
+			log.Println("failed to disrupt currency pair formatting:", err)
+		}
+
 		responseContainer := ExchangeAssetPairResponses{
 			AssetType: assetTypes[i],
 			Pair:      p,
 		}
 
 		log.Printf("Setup config for %v %v %v", base.GetName(), assetTypes[i], p)
-		err := e.Setup(base.Config)
+		err = e.Setup(base.Config)
 		if err != nil {
 			log.Printf("%v Encountered error reloading config: '%v'", base.GetName(), err)
 		}
@@ -883,3 +891,22 @@ func outputToConsole(exchangeResponses []ExchangeResponses) {
 		log.Println()
 	}
 }
+
+// disruptFormatting adds in an unused delimiter and strange casing features to
+// ensure format currency pair is used throughout the code base.
+func disruptFormatting(p currency.Pair) (currency.Pair, error) {
+	base := p.Base.String()
+	if base == "" {
+		return currency.Pair{}, errors.New("cannot disrupt formatting as base is not populated")
+	}
+	quote := p.Quote.String()
+	if quote == "" {
+		return currency.Pair{}, errors.New("cannot disrupt formatting as quote is not populated")
+	}
+
+	return currency.Pair{
+		Base:      p.Base.Upper(),
+		Quote:     p.Quote.Lower(),
+		Delimiter: "-TEST-DELIM-",
+	}, nil
+}

cmd/exchange_wrapper_issues/wrapperconfig.json

@@ -9,7 +9,7 @@
  "withdrawWalletAddress": "",
  "bankAccount": {
   "bankAccountName": "bankAccountName",
-  "bankAccountNumber": 1337,
+  "bankAccountNumber": "1337",
   "bankAddress": "bankAddress",
   "bankCity": "bankCity",
   "bankCountry": "bankCountry",
@@ -33,7 +33,6 @@
   "intermediaryBankCode": 1337
  },
  "exchanges": {
-  "alphapoint": {},
   "binance": {
    "key": "Key",
    "secret": "Secret",
@@ -101,6 +100,11 @@
    "secret": "Secret",
    "otpSecret": "-"
   },
+  "ftx": {
+   "key": "Key",
+   "secret": "Secret",
+   "otpSecret": "-"
+  },
   "gateio": {
    "key": "Key",
    "secret": "Secret",

cmd/gctcli/commands.go

@@ -88,8 +88,7 @@ var enableSubsystemCommand = cli.Command{
 
 func enableSubsystem(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "enablesubsystem")
-		return nil
+		return cli.ShowCommandHelp(c, "enablesubsystem")
 	}
 
 	var subsystemName string
@@ -139,8 +138,7 @@ var disableSubsystemCommand = cli.Command{
 
 func disableSubsystem(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "disablesubsystem")
-		return nil
+		return cli.ShowCommandHelp(c, "disablesubsystem")
 	}
 
 	var subsystemName string
@@ -282,8 +280,7 @@ var enableExchangeCommand = cli.Command{
 
 func enableExchange(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "enableexchange")
-		return nil
+		return cli.ShowCommandHelp(c, "enableexchange")
 	}
 
 	var exchangeName string
@@ -333,8 +330,7 @@ var disableExchangeCommand = cli.Command{
 
 func disableExchange(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "disableexchange")
-		return nil
+		return cli.ShowCommandHelp(c, "disableexchange")
 	}
 
 	var exchangeName string
@@ -384,8 +380,7 @@ var getExchangeOTPCommand = cli.Command{
 
 func getExchangeOTPCode(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "getexchangeotp")
-		return nil
+		return cli.ShowCommandHelp(c, "getexchangeotp")
 	}
 
 	var exchangeName string
@@ -460,8 +455,7 @@ var getExchangeInfoCommand = cli.Command{
 
 func getExchangeInfo(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "getexchangeinfo")
-		return nil
+		return cli.ShowCommandHelp(c, "getexchangeinfo")
 	}
 
 	var exchangeName string
@@ -519,8 +513,7 @@ var getTickerCommand = cli.Command{
 
 func getTicker(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "getticker")
-		return nil
+		return cli.ShowCommandHelp(c, "getticker")
 	}
 
 	var exchangeName string
@@ -636,8 +629,7 @@ var getOrderbookCommand = cli.Command{
 
 func getOrderbook(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "getorderbook")
-		return nil
+		return cli.ShowCommandHelp(c, "getorderbook")
 	}
 
 	var exchangeName string
@@ -745,8 +737,7 @@ var getAccountInfoCommand = cli.Command{
 
 func getAccountInfo(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "getaccountinfo")
-		return nil
+		return cli.ShowCommandHelp(c, "getaccountinfo")
 	}
 
 	var exchange string
@@ -795,8 +786,7 @@ var getAccountInfoStreamCommand = cli.Command{
 
 func getAccountInfoStream(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "getaccountinfostream")
-		return nil
+		return cli.ShowCommandHelp(c, "getaccountinfostream")
 	}
 
 	var exchangeName string
@@ -945,8 +935,7 @@ var addPortfolioAddressCommand = cli.Command{
 
 func addPortfolioAddress(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "addportfolioaddress")
-		return nil
+		return cli.ShowCommandHelp(c, "addportfolioaddress")
 	}
 
 	conn, err := setupClient()
@@ -1047,8 +1036,7 @@ var removePortfolioAddressCommand = cli.Command{
 
 func removePortfolioAddress(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "removeportfolioaddress")
-		return nil
+		return cli.ShowCommandHelp(c, "removeportfolioaddress")
 	}
 
 	conn, err := setupClient()
@@ -1251,8 +1239,7 @@ var getOrderCommand = cli.Command{
 
 func getOrder(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "getorder")
-		return nil
+		return cli.ShowCommandHelp(c, "getorder")
 	}
 
 	var exchangeName string
@@ -1357,8 +1344,7 @@ var submitOrderCommand = cli.Command{
 
 func submitOrder(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "submitorder")
-		return nil
+		return cli.ShowCommandHelp(c, "submitorder")
 	}
 
 	var exchangeName string
@@ -1513,8 +1499,7 @@ var simulateOrderCommand = cli.Command{
 
 func simulateOrder(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "simulateorder")
-		return nil
+		return cli.ShowCommandHelp(c, "simulateorder")
 	}
 
 	var exchangeName string
@@ -1623,8 +1608,7 @@ var whaleBombCommand = cli.Command{
 
 func whaleBomb(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "whalebomb")
-		return nil
+		return cli.ShowCommandHelp(c, "whalebomb")
 	}
 
 	var exchangeName string
@@ -1741,8 +1725,7 @@ var cancelOrderCommand = cli.Command{
 
 func cancelOrder(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "cancelorder")
-		return nil
+		return cli.ShowCommandHelp(c, "cancelorder")
 	}
 
 	var exchangeName string
@@ -1969,8 +1952,7 @@ var addEventCommand = cli.Command{
 
 func addEvent(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "addevent")
-		return nil
+		return cli.ShowCommandHelp(c, "addevent")
 	}
 
 	var exchangeName string
@@ -2100,8 +2082,7 @@ var removeEventCommand = cli.Command{
 
 func removeEvent(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "removeevent")
-		return nil
+		return cli.ShowCommandHelp(c, "removeevent")
 	}
 
 	var eventID int64
@@ -2151,8 +2132,7 @@ var getCryptocurrencyDepositAddressesCommand = cli.Command{
 
 func getCryptocurrencyDepositAddresses(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "getcryptocurrencydepositaddresses")
-		return nil
+		return cli.ShowCommandHelp(c, "getcryptocurrencydepositaddresses")
 	}
 
 	var exchangeName string
@@ -2202,8 +2182,7 @@ var getCryptocurrencyDepositAddressCommand = cli.Command{
 
 func getCryptocurrencyDepositAddress(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "getcryptocurrencydepositaddresses")
-		return nil
+		return cli.ShowCommandHelp(c, "getcryptocurrencydepositaddresses")
 	}
 
 	var exchangeName string
@@ -2289,8 +2268,7 @@ var withdrawCryptocurrencyFundsCommand = cli.Command{
 
 func withdrawCryptocurrencyFunds(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "withdrawcryptofunds")
-		return nil
+		return cli.ShowCommandHelp(c, "withdrawcryptofunds")
 	}
 
 	var exchange, cur, address, addressTag, description string
@@ -2405,8 +2383,7 @@ var withdrawFiatFundsCommand = cli.Command{
 
 func withdrawFiatFunds(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "withdrawfiatfunds")
-		return nil
+		return cli.ShowCommandHelp(c, "withdrawfiatfunds")
 	}
 
 	var exchange, cur, description, bankAccountID string
@@ -2746,8 +2723,7 @@ var getLoggerDetailsCommand = cli.Command{
 
 func getLoggerDetails(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "getloggerdetails")
-		return nil
+		return cli.ShowCommandHelp(c, "getloggerdetails")
 	}
 
 	var logger string
@@ -2800,8 +2776,7 @@ var setLoggerDetailsCommand = cli.Command{
 
 func setLoggerDetails(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "setloggerdetails")
-		return nil
+		return cli.ShowCommandHelp(c, "setloggerdetails")
 	}
 
 	var logger string
@@ -2871,8 +2846,7 @@ var getOrderbookStreamCommand = cli.Command{
 
 func getOrderbookStream(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "getorderbookstream")
-		return nil
+		return cli.ShowCommandHelp(c, "getorderbookstream")
 	}
 
 	var exchangeName string
@@ -3011,8 +2985,7 @@ var getExchangeOrderbookStreamCommand = cli.Command{
 
 func getExchangeOrderbookStream(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "getexchangeorderbookstream")
-		return nil
+		return cli.ShowCommandHelp(c, "getexchangeorderbookstream")
 	}
 
 	var exchangeName string
@@ -3082,8 +3055,7 @@ var getTickerStreamCommand = cli.Command{
 
 func getTickerStream(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "gettickerstream")
-		return nil
+		return cli.ShowCommandHelp(c, "gettickerstream")
 	}
 
 	var exchangeName string
@@ -3192,8 +3164,7 @@ var getExchangeTickerStreamCommand = cli.Command{
 
 func getExchangeTickerStream(c *cli.Context) error {
 	if c.NArg() == 0 && c.NumFlags() == 0 {
-		cli.ShowCommandHelp(c, "getexchangetickerstream")
-		return nil
+		return cli.ShowCommandHelp(c, "getexchangetickerstream")
 	}
 
 	var exchangeName string

currency/code.go

@@ -144,23 +144,17 @@ func (b *BaseCodes) UpdateCurrency(fullName, symbol, blockchain string, id int,
 
 // Register registers a currency from a string and returns a currency code
 func (b *BaseCodes) Register(c string) Code {
-	NewUpperCode := c
-	lower := true
-	for _, r := range c {
-		if !unicode.IsLower(r) {
-			lower = false
-			break
-		}
+	var format bool
+	if c != "" {
+		format = unicode.IsUpper(rune(c[0]))
 	}
-	if lower {
-		NewUpperCode = strings.ToUpper(c)
-	}
-	format := strings.Contains(c, NewUpperCode)
+	// Force upper string storage and matching
+	c = strings.ToUpper(c)
 
 	b.mtx.Lock()
 	defer b.mtx.Unlock()
 	for i := range b.Items {
-		if b.Items[i].Symbol == NewUpperCode {
+		if b.Items[i].Symbol == c {
 			return Code{
 				Item:      b.Items[i],
 				UpperCase: format,
@@ -168,7 +162,7 @@ func (b *BaseCodes) Register(c string) Code {
 		}
 	}
 
-	newItem := &Item{Symbol: NewUpperCode}
+	newItem := &Item{Symbol: c}
 	b.Items = append(b.Items, newItem)
 
 	return Code{
@@ -240,7 +234,7 @@ func (c Code) String() string {
 	}
 
 	if c.UpperCase {
-		return c.Item.Symbol
+		return strings.ToUpper(c.Item.Symbol)
 	}
 	return strings.ToLower(c.Item.Symbol)
 }

currency/pair_test.go

@@ -397,7 +397,7 @@ func TestNewPairDelimiter(t *testing.T) {
 		t.Fatal(err)
 	}
 	actual = pair.String()
-	expected = "fBTC-USDT"
+	expected = "fbtc-USDT"
 	if actual != expected {
 		t.Errorf(
 			"Pair(): %s was not equal to expected value: %s",

exchanges/alphapoint/alphapoint_wrapper.go

@@ -214,15 +214,17 @@ func (a *Alphapoint) GetExchangeHistory(p currency.Pair, assetType asset.Item, t
 // SubmitOrder submits a new order and returns a true value when
 // successfully submitted
 func (a *Alphapoint) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
-	if err := s.Validate(); err != nil {
-		return order.SubmitResponse{}, err
-	}
 	var submitOrderResponse order.SubmitResponse
 	if err := s.Validate(); err != nil {
 		return submitOrderResponse, err
 	}
 
-	response, err := a.CreateOrder(s.Pair.String(),
+	fPair, err := a.FormatExchangeCurrency(s.Pair, s.AssetType)
+	if err != nil {
+		return submitOrderResponse, err
+	}
+
+	response, err := a.CreateOrder(fPair.String(),
 		s.Side.String(),
 		s.Type.String(),
 		s.Amount,

exchanges/binance/binance.go

@@ -369,7 +369,6 @@ func (b *Binance) newOrder(api string, o *NewOrderRequest, resp *NewOrderRespons
 	if o.NewOrderRespType != "" {
 		params.Set("newOrderRespType", o.NewOrderRespType)
 	}
-
 	return b.SendAuthHTTPRequest(http.MethodPost, path, params, limitOrder, resp)
 }
 

exchanges/binance/binance_wrapper.go

@@ -375,7 +375,12 @@ func (b *Binance) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticker.P
 
 // FetchTicker returns the ticker for a currency pair
 func (b *Binance) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
-	tickerNew, err := ticker.GetTicker(b.Name, p, assetType)
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
+	if err != nil {
+		return nil, err
+	}
+
+	tickerNew, err := ticker.GetTicker(b.Name, fPair, assetType)
 	if err != nil {
 		return b.UpdateTicker(p, assetType)
 	}
@@ -498,10 +503,6 @@ func (b *Binance) GetExchangeHistory(p currency.Pair, assetType asset.Item, time
 
 // SubmitOrder submits a new order
 func (b *Binance) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
-	if err := s.Validate(); err != nil {
-		return order.SubmitResponse{}, err
-	}
-
 	var submitOrderResponse order.SubmitResponse
 	if err := s.Validate(); err != nil {
 		return submitOrderResponse, err
@@ -527,8 +528,13 @@ func (b *Binance) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 		return submitOrderResponse, errors.New("unsupported order type")
 	}
 
+	fPair, err := b.FormatExchangeCurrency(s.Pair, s.AssetType)
+	if err != nil {
+		return submitOrderResponse, err
+	}
+
 	var orderRequest = NewOrderRequest{
-		Symbol:      s.Pair.Base.String() + s.Pair.Quote.String(),
+		Symbol:      fPair.String(),
 		Side:        sideType,
 		Price:       s.Price,
 		Quantity:    s.Amount,

exchanges/bitfinex/bitfinex_wrapper.go

@@ -352,33 +352,47 @@ func (b *Bitfinex) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticker.
 
 // FetchTicker returns the ticker for a currency pair
 func (b *Bitfinex) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
-	b.appendOptionalDelimiter(&p)
-	tick, err := ticker.GetTicker(b.Name, p, asset.Spot)
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return b.UpdateTicker(p, assetType)
+		return nil, err
+	}
+
+	b.appendOptionalDelimiter(&fPair)
+	tick, err := ticker.GetTicker(b.Name, fPair, asset.Spot)
+	if err != nil {
+		return b.UpdateTicker(fPair, assetType)
 	}
 	return tick, nil
 }
 
 // FetchOrderbook returns the orderbook for a currency pair
 func (b *Bitfinex) FetchOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
-	b.appendOptionalDelimiter(&p)
-	ob, err := orderbook.Get(b.Name, p, assetType)
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return b.UpdateOrderbook(p, assetType)
+		return nil, err
+	}
+
+	b.appendOptionalDelimiter(&fPair)
+	ob, err := orderbook.Get(b.Name, fPair, assetType)
+	if err != nil {
+		return b.UpdateOrderbook(fPair, assetType)
 	}
 	return ob, nil
 }
 
 // UpdateOrderbook updates and returns the orderbook for a currency pair
 func (b *Bitfinex) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
-	b.appendOptionalDelimiter(&p)
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
+	if err != nil {
+		return nil, err
+	}
+	b.appendOptionalDelimiter(&fPair)
 	var prefix = "t"
 	if assetType == asset.MarginFunding {
 		prefix = "f"
 	}
 
-	orderbookNew, err := b.GetOrderbook(prefix+p.String(), "P0", 100)
+	orderbookNew, err := b.GetOrderbook(prefix+fPair.String(), "P0", 100)
 	if err != nil {
 		return nil, err
 	}
@@ -398,7 +412,7 @@ func (b *Bitfinex) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orde
 		})
 	}
 
-	o.Pair = p
+	o.Pair = fPair
 	o.ExchangeName = b.Name
 	o.AssetType = assetType
 
@@ -407,7 +421,7 @@ func (b *Bitfinex) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orde
 		return nil, err
 	}
 
-	return orderbook.Get(b.Name, p, assetType)
+	return orderbook.Get(b.Name, fPair, assetType)
 }
 
 // UpdateAccountInfo retrieves balances for all enabled currencies on the
@@ -474,10 +488,6 @@ func (b *Bitfinex) GetExchangeHistory(p currency.Pair, assetType asset.Item, tim
 
 // SubmitOrder submits a new order
 func (b *Bitfinex) SubmitOrder(o *order.Submit) (order.SubmitResponse, error) {
-	if err := o.Validate(); err != nil {
-		return order.SubmitResponse{}, err
-	}
-
 	var submitOrderResponse order.SubmitResponse
 	err := o.Validate()
 	if err != nil {

exchanges/bitflyer/bitflyer_wrapper.go

@@ -183,13 +183,18 @@ func (b *Bitflyer) UpdateTradablePairs(forceUpdate bool) error {
 
 // UpdateTicker updates and returns the ticker for a currency pair
 func (b *Bitflyer) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
-	tickerNew, err := b.GetTicker(b.CheckFXString(p).String())
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
+	if err != nil {
+		return nil, err
+	}
+
+	tickerNew, err := b.GetTicker(b.CheckFXString(fPair).String())
 	if err != nil {
 		return nil, err
 	}
 
 	err = ticker.ProcessTicker(&ticker.Price{
-		Pair:         p,
+		Pair:         fPair,
 		Ask:          tickerNew.BestAsk,
 		Bid:          tickerNew.BestBid,
 		Last:         tickerNew.Last,
@@ -200,14 +205,19 @@ func (b *Bitflyer) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticker.
 		return nil, err
 	}
 
-	return ticker.GetTicker(b.Name, p, assetType)
+	return ticker.GetTicker(b.Name, fPair, assetType)
 }
 
 // FetchTicker returns the ticker for a currency pair
 func (b *Bitflyer) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
-	tick, err := ticker.GetTicker(b.Name, p, assetType)
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return b.UpdateTicker(p, assetType)
+		return nil, err
+	}
+
+	tick, err := ticker.GetTicker(b.Name, fPair, assetType)
+	if err != nil {
+		return b.UpdateTicker(fPair, assetType)
 	}
 	return tick, nil
 }
@@ -223,18 +233,28 @@ func (b *Bitflyer) CheckFXString(p currency.Pair) currency.Pair {
 
 // FetchOrderbook returns the orderbook for a currency pair
 func (b *Bitflyer) FetchOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
-	ob, err := orderbook.Get(b.Name, p, assetType)
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return b.UpdateOrderbook(p, assetType)
+		return nil, err
+	}
+
+	ob, err := orderbook.Get(b.Name, fPair, assetType)
+	if err != nil {
+		return b.UpdateOrderbook(fPair, assetType)
 	}
 	return ob, nil
 }
 
 // UpdateOrderbook updates and returns the orderbook for a currency pair
 func (b *Bitflyer) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
+	if err != nil {
+		return nil, err
+	}
+
 	orderBook := new(orderbook.Base)
 
-	orderbookNew, err := b.GetOrderBook(b.CheckFXString(p).String())
+	orderbookNew, err := b.GetOrderBook(b.CheckFXString(fPair).String())
 	if err != nil {
 		return orderBook, err
 	}
@@ -247,7 +267,7 @@ func (b *Bitflyer) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orde
 		orderBook.Bids = append(orderBook.Bids, orderbook.Item{Price: orderbookNew.Bids[x].Price, Amount: orderbookNew.Bids[x].Size})
 	}
 
-	orderBook.Pair = p
+	orderBook.Pair = fPair
 	orderBook.ExchangeName = b.Name
 	orderBook.AssetType = assetType
 
@@ -256,7 +276,7 @@ func (b *Bitflyer) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orde
 		return orderBook, err
 	}
 
-	return orderbook.Get(b.Name, p, assetType)
+	return orderbook.Get(b.Name, fPair, assetType)
 }
 
 // UpdateAccountInfo retrieves balances for all enabled currencies on the

exchanges/bithumb/bithumb_wrapper.go

@@ -337,27 +337,27 @@ func (b *Bithumb) GetExchangeHistory(p currency.Pair, assetType asset.Item, time
 // SubmitOrder submits a new order
 // TODO: Fill this out to support limit orders
 func (b *Bithumb) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
-	if err := s.Validate(); err != nil {
-		return order.SubmitResponse{}, err
-	}
-
 	var submitOrderResponse order.SubmitResponse
 	if err := s.Validate(); err != nil {
 		return submitOrderResponse, err
 	}
 
+	fPair, err := b.FormatExchangeCurrency(s.Pair, s.AssetType)
+	if err != nil {
+		return submitOrderResponse, err
+	}
+
 	var orderID string
-	var err error
 	if s.Side == order.Buy {
 		var result MarketBuy
-		result, err = b.MarketBuyOrder(s.Pair.Base.String(), s.Amount)
+		result, err = b.MarketBuyOrder(fPair.Base.String(), s.Amount)
 		if err != nil {
 			return submitOrderResponse, err
 		}
 		orderID = result.OrderID
 	} else if s.Side == order.Sell {
 		var result MarketSell
-		result, err = b.MarketSellOrder(s.Pair.Base.String(), s.Amount)
+		result, err = b.MarketSellOrder(fPair.Base.String(), s.Amount)
 		if err != nil {
 			return submitOrderResponse, err
 		}

exchanges/bitmex/bitmex_wrapper.go

@@ -260,6 +260,11 @@ func (b *Bitmex) UpdateTradablePairs(forceUpdate bool) error {
 
 // UpdateTicker updates and returns the ticker for a currency pair
 func (b *Bitmex) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
+	if err != nil {
+		return nil, err
+	}
+
 	tick, err := b.GetActiveAndIndexInstruments()
 	if err != nil {
 		return nil, err
@@ -291,23 +296,33 @@ func (b *Bitmex) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticker.Pr
 			return nil, err
 		}
 	}
-	return ticker.GetTicker(b.Name, p, assetType)
+	return ticker.GetTicker(b.Name, fPair, assetType)
 }
 
 // FetchTicker returns the ticker for a currency pair
 func (b *Bitmex) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
-	tickerNew, err := ticker.GetTicker(b.Name, p, assetType)
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return b.UpdateTicker(p, assetType)
+		return nil, err
+	}
+
+	tickerNew, err := ticker.GetTicker(b.Name, fPair, assetType)
+	if err != nil {
+		return b.UpdateTicker(fPair, assetType)
 	}
 	return tickerNew, nil
 }
 
 // FetchOrderbook returns orderbook base on the currency pair
 func (b *Bitmex) FetchOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
-	ob, err := orderbook.Get(b.Name, p, assetType)
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return b.UpdateOrderbook(p, assetType)
+		return nil, err
+	}
+
+	ob, err := orderbook.Get(b.Name, fPair, assetType)
+	if err != nil {
+		return b.UpdateOrderbook(fPair, assetType)
 	}
 	return ob, nil
 }
@@ -422,9 +437,14 @@ func (b *Bitmex) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 			errors.New("order contract amount can not have decimals")
 	}
 
+	fPair, err := b.FormatExchangeCurrency(s.Pair, s.AssetType)
+	if err != nil {
+		return submitOrderResponse, err
+	}
+
 	var orderNewParams = OrderNewParams{
 		OrderType:     s.Type.Title(),
-		Symbol:        s.Pair.String(),
+		Symbol:        fPair.String(),
 		OrderQuantity: s.Amount,
 		Side:          s.Side.Title(),
 	}

exchanges/bitstamp/bitstamp_wrapper.go

@@ -245,7 +245,12 @@ func (b *Bitstamp) UpdateTradablePairs(forceUpdate bool) error {
 
 // UpdateTicker updates and returns the ticker for a currency pair
 func (b *Bitstamp) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
-	tick, err := b.GetTicker(p.String(), false)
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
+	if err != nil {
+		return nil, err
+	}
+
+	tick, err := b.GetTicker(fPair.String(), false)
 	if err != nil {
 		return nil, err
 	}
@@ -258,7 +263,7 @@ func (b *Bitstamp) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticker.
 		Ask:          tick.Ask,
 		Volume:       tick.Volume,
 		Open:         tick.Open,
-		Pair:         p,
+		Pair:         fPair,
 		LastUpdated:  time.Unix(tick.Timestamp, 0),
 		ExchangeName: b.Name,
 		AssetType:    assetType})
@@ -266,14 +271,19 @@ func (b *Bitstamp) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticker.
 		return nil, err
 	}
 
-	return ticker.GetTicker(b.Name, p, assetType)
+	return ticker.GetTicker(b.Name, fPair, assetType)
 }
 
 // FetchTicker returns the ticker for a currency pair
 func (b *Bitstamp) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
-	tick, err := ticker.GetTicker(b.Name, p, assetType)
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return b.UpdateTicker(p, assetType)
+		return nil, err
+	}
+
+	tick, err := ticker.GetTicker(b.Name, fPair, assetType)
+	if err != nil {
+		return b.UpdateTicker(fPair, assetType)
 	}
 	return tick, nil
 }
@@ -289,17 +299,27 @@ func (b *Bitstamp) GetFeeByType(feeBuilder *exchange.FeeBuilder) (float64, error
 
 // FetchOrderbook returns the orderbook for a currency pair
 func (b *Bitstamp) FetchOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
-	ob, err := orderbook.Get(b.Name, p, assetType)
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return b.UpdateOrderbook(p, assetType)
+		return nil, err
+	}
+
+	ob, err := orderbook.Get(b.Name, fPair, assetType)
+	if err != nil {
+		return b.UpdateOrderbook(fPair, assetType)
 	}
 	return ob, nil
 }
 
 // UpdateOrderbook updates and returns the orderbook for a currency pair
 func (b *Bitstamp) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
+	if err != nil {
+		return nil, err
+	}
+
 	orderBook := new(orderbook.Base)
-	orderbookNew, err := b.GetOrderbook(p.String())
+	orderbookNew, err := b.GetOrderbook(fPair.String())
 	if err != nil {
 		return orderBook, err
 	}
@@ -318,7 +338,7 @@ func (b *Bitstamp) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orde
 		})
 	}
 
-	orderBook.Pair = p
+	orderBook.Pair = fPair
 	orderBook.ExchangeName = b.Name
 	orderBook.AssetType = assetType
 
@@ -327,7 +347,7 @@ func (b *Bitstamp) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orde
 		return orderBook, err
 	}
 
-	return orderbook.Get(b.Name, p, assetType)
+	return orderbook.Get(b.Name, fPair, assetType)
 }
 
 // UpdateAccountInfo retrieves balances for all enabled currencies for the
@@ -388,9 +408,14 @@ func (b *Bitstamp) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 		return submitOrderResponse, err
 	}
 
+	fPair, err := b.FormatExchangeCurrency(s.Pair, s.AssetType)
+	if err != nil {
+		return submitOrderResponse, err
+	}
+
 	buy := s.Side == order.Buy
 	market := s.Type == order.Market
-	response, err := b.PlaceOrder(s.Pair.String(),
+	response, err := b.PlaceOrder(fPair.String(),
 		s.Price,
 		s.Amount,
 		buy,
@@ -567,7 +592,11 @@ func (b *Bitstamp) GetActiveOrders(req *order.GetOrdersRequest) ([]order.Detail,
 	if len(req.Pairs) != 1 {
 		currPair = "all"
 	} else {
-		currPair = req.Pairs[0].String()
+		fPair, err := b.FormatExchangeCurrency(req.Pairs[0], asset.Spot)
+		if err != nil {
+			return nil, err
+		}
+		currPair = fPair.String()
 	}
 
 	resp, err := b.GetOpenOrders(currPair)
@@ -619,7 +648,11 @@ func (b *Bitstamp) GetOrderHistory(req *order.GetOrdersRequest) ([]order.Detail,
 
 	var currPair string
 	if len(req.Pairs) == 1 {
-		currPair = req.Pairs[0].String()
+		fPair, err := b.FormatExchangeCurrency(req.Pairs[0], asset.Spot)
+		if err != nil {
+			return nil, err
+		}
+		currPair = fPair.String()
 	}
 
 	format, err := b.GetPairFormat(asset.Spot, false)

exchanges/bittrex/bittrex_wrapper.go

@@ -390,14 +390,18 @@ func (b *Bittrex) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 			errors.New("limit orders only supported on exchange")
 	}
 
+	fPair, err := b.FormatExchangeCurrency(s.Pair, s.AssetType)
+	if err != nil {
+		return submitOrderResponse, err
+	}
+
 	var response UUID
-	var err error
 	if buy {
-		response, err = b.PlaceBuyLimit(s.Pair.String(),
+		response, err = b.PlaceBuyLimit(fPair.String(),
 			s.Amount,
 			s.Price)
 	} else {
-		response, err = b.PlaceSellLimit(s.Pair.String(),
+		response, err = b.PlaceSellLimit(fPair.String(),
 			s.Amount,
 			s.Price)
 	}
@@ -512,7 +516,11 @@ func (b *Bittrex) GetActiveOrders(req *order.GetOrdersRequest) ([]order.Detail,
 
 	var currPair string
 	if len(req.Pairs) == 1 {
-		currPair = req.Pairs[0].String()
+		fPair, err := b.FormatExchangeCurrency(req.Pairs[0], asset.Spot)
+		if err != nil {
+			return nil, err
+		}
+		currPair = fPair.String()
 	}
 
 	format, err := b.GetPairFormat(asset.Spot, false)
@@ -576,7 +584,11 @@ func (b *Bittrex) GetOrderHistory(req *order.GetOrdersRequest) ([]order.Detail,
 
 	var currPair string
 	if len(req.Pairs) == 1 {
-		currPair = req.Pairs[0].String()
+		fPair, err := b.FormatExchangeCurrency(req.Pairs[0], asset.Spot)
+		if err != nil {
+			return nil, err
+		}
+		currPair = fPair.String()
 	}
 
 	format, err := b.GetPairFormat(asset.Spot, false)

exchanges/btcmarkets/btcmarkets_wrapper.go

@@ -321,7 +321,12 @@ func (b *BTCMarkets) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticke
 
 // FetchTicker returns the ticker for a currency pair
 func (b *BTCMarkets) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
-	tickerNew, err := ticker.GetTicker(b.Name, p, assetType)
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
+	if err != nil {
+		return nil, err
+	}
+
+	tickerNew, err := ticker.GetTicker(b.Name, fPair, assetType)
 	if err != nil {
 		return b.UpdateTicker(p, assetType)
 	}
@@ -330,7 +335,12 @@ func (b *BTCMarkets) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker
 
 // FetchOrderbook returns orderbook base on the currency pair
 func (b *BTCMarkets) FetchOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
-	ob, err := orderbook.Get(b.Name, p, assetType)
+	fPair, err := b.FormatExchangeCurrency(p, assetType)
+	if err != nil {
+		return nil, err
+	}
+
+	ob, err := orderbook.Get(b.Name, fPair, assetType)
 	if err != nil {
 		return b.UpdateOrderbook(p, assetType)
 	}
@@ -889,16 +899,21 @@ func (b *BTCMarkets) GetHistoricCandlesExtended(p currency.Pair, a asset.Item, s
 		return kline.Item{}, err
 	}
 
+	fPair, err := b.FormatExchangeCurrency(p, a)
+	if err != nil {
+		return kline.Item{}, err
+	}
+
 	ret := kline.Item{
 		Exchange: b.Name,
-		Pair:     p,
+		Pair:     fPair,
 		Asset:    a,
 		Interval: interval,
 	}
 
 	dates := kline.CalcDateRanges(start, end, interval, b.Features.Enabled.Kline.ResultLimit)
 	for x := range dates {
-		candles, err := b.GetMarketCandles(p.String(),
+		candles, err := b.GetMarketCandles(fPair.String(),
 			b.FormatExchangeKlineInterval(interval),
 			dates[x].Start, dates[x].End, -1, -1, -1)
 		if err != nil {

exchanges/coinbasepro/coinbasepro_wrapper.go

@@ -443,10 +443,6 @@ func (c *CoinbasePro) GetExchangeHistory(p currency.Pair, assetType asset.Item,
 
 // SubmitOrder submits a new order
 func (c *CoinbasePro) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
-	if err := s.Validate(); err != nil {
-		return order.SubmitResponse{}, err
-	}
-
 	var submitOrderResponse order.SubmitResponse
 	if err := s.Validate(); err != nil {
 		return submitOrderResponse, err

exchanges/coinut/coinut_wrapper.go

@@ -514,11 +514,6 @@ func (c *COINUT) SubmitOrder(o *order.Submit) (order.SubmitResponse, error) {
 	if _, err = strconv.Atoi(o.ClientID); err != nil {
 		return submitOrderResponse, fmt.Errorf("%s - ClientID must be a number, received: %s", c.Name, o.ClientID)
 	}
-	err = o.Validate()
-
-	if err != nil {
-		return submitOrderResponse, err
-	}
 
 	if c.Websocket.CanUseAuthenticatedWebsocketForWrapper() {
 		var response *order.Detail

exchanges/exmo/exmo_wrapper.go

@@ -385,10 +385,12 @@ func (e *EXMO) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 		}
 	}
 
-	response, err := e.CreateOrder(s.Pair.String(),
-		oT,
-		s.Price,
-		s.Amount)
+	fPair, err := e.FormatExchangeCurrency(s.Pair, s.AssetType)
+	if err != nil {
+		return submitOrderResponse, err
+	}
+
+	response, err := e.CreateOrder(fPair.String(), oT, s.Price, s.Amount)
 	if err != nil {
 		return submitOrderResponse, err
 	}

exchanges/ftx/ftx_wrapper.go

@@ -507,12 +507,12 @@ func (f *FTX) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 		s.Side = order.Buy
 	}
 
-	formattedPair, err := f.FormatExchangeCurrency(s.Pair, s.AssetType)
+	fPair, err := f.FormatExchangeCurrency(s.Pair, s.AssetType)
 	if err != nil {
 		return resp, err
 	}
 
-	tempResp, err := f.Order(formattedPair.String(),
+	tempResp, err := f.Order(fPair.String(),
 		s.Side.Lower(),
 		s.Type.Lower(),
 		"",

exchanges/gateio/gateio_wrapper.go

@@ -435,10 +435,15 @@ func (g *Gateio) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 		orderTypeFormat = order.Sell.Lower()
 	}
 
+	fPair, err := g.FormatExchangeCurrency(s.Pair, s.AssetType)
+	if err != nil {
+		return submitOrderResponse, err
+	}
+
 	var spotNewOrderRequestParams = SpotNewOrderRequestParams{
 		Amount: s.Amount,
 		Price:  s.Price,
-		Symbol: s.Pair.String(),
+		Symbol: fPair.String(),
 		Type:   orderTypeFormat,
 	}
 
@@ -607,7 +612,11 @@ func (g *Gateio) GetActiveOrders(req *order.GetOrdersRequest) ([]order.Detail, e
 	var orders []order.Detail
 	var currPair string
 	if len(req.Pairs) == 1 {
-		currPair = req.Pairs[0].String()
+		fPair, err := g.FormatExchangeCurrency(req.Pairs[0], asset.Spot)
+		if err != nil {
+			return nil, err
+		}
+		currPair = fPair.String()
 	}
 	if g.Websocket.CanUseAuthenticatedWebsocketForWrapper() {
 		for i := 0; ; i += 100 {

exchanges/gemini/gemini_wrapper.go

@@ -234,7 +234,12 @@ func (g *Gemini) FetchAccountInfo() (account.Holdings, error) {
 
 // UpdateTicker updates and returns the ticker for a currency pair
 func (g *Gemini) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
-	tick, err := g.GetTicker(p.String())
+	fPair, err := g.FormatExchangeCurrency(p, assetType)
+	if err != nil {
+		return nil, err
+	}
+
+	tick, err := g.GetTicker(fPair.String())
 	if err != nil {
 		return nil, err
 	}
@@ -246,38 +251,53 @@ func (g *Gemini) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticker.Pr
 		Ask:          tick.Ask,
 		Open:         tick.Open,
 		Close:        tick.Close,
-		Pair:         p,
+		Pair:         fPair,
 		ExchangeName: g.Name,
 		AssetType:    assetType})
 	if err != nil {
 		return nil, err
 	}
 
-	return ticker.GetTicker(g.Name, p, assetType)
+	return ticker.GetTicker(g.Name, fPair, assetType)
 }
 
 // FetchTicker returns the ticker for a currency pair
 func (g *Gemini) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
-	tickerNew, err := ticker.GetTicker(g.Name, p, assetType)
+	fPair, err := g.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return g.UpdateTicker(p, assetType)
+		return nil, err
+	}
+
+	tickerNew, err := ticker.GetTicker(g.Name, fPair, assetType)
+	if err != nil {
+		return g.UpdateTicker(fPair, assetType)
 	}
 	return tickerNew, nil
 }
 
 // FetchOrderbook returns orderbook base on the currency pair
 func (g *Gemini) FetchOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
-	ob, err := orderbook.Get(g.Name, p, assetType)
+	fPair, err := g.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return g.UpdateOrderbook(p, assetType)
+		return nil, err
+	}
+
+	ob, err := orderbook.Get(g.Name, fPair, assetType)
+	if err != nil {
+		return g.UpdateOrderbook(fPair, assetType)
 	}
 	return ob, nil
 }
 
 // UpdateOrderbook updates and returns the orderbook for a currency pair
 func (g *Gemini) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
+	fPair, err := g.FormatExchangeCurrency(p, assetType)
+	if err != nil {
+		return nil, err
+	}
+
 	orderBook := new(orderbook.Base)
-	orderbookNew, err := g.GetOrderbook(p.String(), url.Values{})
+	orderbookNew, err := g.GetOrderbook(fPair.String(), url.Values{})
 	if err != nil {
 		return orderBook, err
 	}
@@ -290,7 +310,7 @@ func (g *Gemini) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderb
 		orderBook.Asks = append(orderBook.Asks, orderbook.Item{Amount: orderbookNew.Asks[x].Amount, Price: orderbookNew.Asks[x].Price})
 	}
 
-	orderBook.Pair = p
+	orderBook.Pair = fPair
 	orderBook.ExchangeName = g.Name
 	orderBook.AssetType = assetType
 
@@ -299,7 +319,7 @@ func (g *Gemini) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderb
 		return orderBook, err
 	}
 
-	return orderbook.Get(g.Name, p, assetType)
+	return orderbook.Get(g.Name, fPair, assetType)
 }
 
 // GetFundingHistory returns funding history, deposits and

exchanges/hitbtc/hitbtc_wrapper.go

@@ -471,8 +471,13 @@ func (h *HitBTC) SubmitOrder(o *order.Submit) (order.SubmitResponse, error) {
 			submitOrderResponse.FullyMatched = true
 		}
 	} else {
+		fPair, err := h.FormatExchangeCurrency(o.Pair, o.AssetType)
+		if err != nil {
+			return submitOrderResponse, err
+		}
+
 		var response OrderResponse
-		response, err = h.PlaceOrder(o.Pair.String(),
+		response, err = h.PlaceOrder(fPair.String(),
 			o.Price,
 			o.Amount,
 			strings.ToLower(o.Type.String()),

exchanges/itbit/itbit_wrapper.go

@@ -341,13 +341,18 @@ func (i *ItBit) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 				s.Amount)
 	}
 
+	fPair, err := i.FormatExchangeCurrency(s.Pair, s.AssetType)
+	if err != nil {
+		return submitOrderResponse, err
+	}
+
 	response, err := i.PlaceOrder(wallet,
 		s.Side.String(),
 		s.Type.String(),
-		s.Pair.Base.String(),
+		fPair.Base.String(),
 		s.Amount,
 		s.Price,
-		s.Pair.String(),
+		fPair.String(),
 		"")
 	if err != nil {
 		return submitOrderResponse, err

exchanges/kraken/kraken_wrapper.go

@@ -542,8 +542,12 @@ func (k *Kraken) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 		submitOrderResponse.OrderID = resp
 		submitOrderResponse.IsOrderPlaced = true
 	} else {
+		fPair, err := k.FormatExchangeCurrency(s.Pair, s.AssetType)
+		if err != nil {
+			return submitOrderResponse, err
+		}
 		var response AddOrderResponse
-		response, err = k.AddOrder(s.Pair.String(),
+		response, err = k.AddOrder(fPair.String(),
 			s.Side.String(),
 			s.Type.String(),
 			s.Amount,

exchanges/lakebtc/lakebtc_wrapper.go

@@ -238,26 +238,41 @@ func (l *LakeBTC) UpdateTicker(p currency.Pair, assetType asset.Item) (*ticker.P
 
 // FetchTicker returns the ticker for a currency pair
 func (l *LakeBTC) FetchTicker(p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
-	tickerNew, err := ticker.GetTicker(l.Name, p, assetType)
+	fPair, err := l.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return l.UpdateTicker(p, assetType)
+		return nil, err
+	}
+
+	tickerNew, err := ticker.GetTicker(l.Name, fPair, assetType)
+	if err != nil {
+		return l.UpdateTicker(fPair, assetType)
 	}
 	return tickerNew, nil
 }
 
 // FetchOrderbook returns orderbook base on the currency pair
 func (l *LakeBTC) FetchOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
-	ob, err := orderbook.Get(l.Name, p, assetType)
+	fPair, err := l.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return l.UpdateOrderbook(p, assetType)
+		return nil, err
+	}
+
+	ob, err := orderbook.Get(l.Name, fPair, assetType)
+	if err != nil {
+		return l.UpdateOrderbook(fPair, assetType)
 	}
 	return ob, nil
 }
 
 // UpdateOrderbook updates and returns the orderbook for a currency pair
 func (l *LakeBTC) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
+	fPair, err := l.FormatExchangeCurrency(p, assetType)
+	if err != nil {
+		return nil, err
+	}
+
 	orderBook := new(orderbook.Base)
-	orderbookNew, err := l.GetOrderBook(p.String())
+	orderbookNew, err := l.GetOrderBook(fPair.String())
 	if err != nil {
 		return orderBook, err
 	}
@@ -270,7 +285,7 @@ func (l *LakeBTC) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*order
 		orderBook.Asks = append(orderBook.Asks, orderbook.Item{Amount: orderbookNew.Asks[x].Amount, Price: orderbookNew.Asks[x].Price})
 	}
 
-	orderBook.Pair = p
+	orderBook.Pair = fPair
 	orderBook.ExchangeName = l.Name
 	orderBook.AssetType = assetType
 
@@ -279,7 +294,7 @@ func (l *LakeBTC) UpdateOrderbook(p currency.Pair, assetType asset.Item) (*order
 		return orderBook, err
 	}
 
-	return orderbook.Get(l.Name, p, assetType)
+	return orderbook.Get(l.Name, fPair, assetType)
 }
 
 // UpdateAccountInfo retrieves balances for all enabled currencies for the
@@ -346,9 +361,16 @@ func (l *LakeBTC) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 		return submitOrderResponse, err
 	}
 
+	fPair, err := l.FormatExchangeCurrency(s.Pair, s.AssetType)
+	if err != nil {
+		return submitOrderResponse, err
+	}
+
 	isBuyOrder := s.Side == order.Buy
-	response, err := l.Trade(isBuyOrder, s.Amount, s.Price,
-		s.Pair.Lower().String())
+	response, err := l.Trade(isBuyOrder,
+		s.Amount,
+		s.Price,
+		fPair.Lower().String())
 	if err != nil {
 		return submitOrderResponse, err
 	}

exchanges/localbitcoins/localbitcoins_wrapper.go

@@ -296,6 +296,11 @@ func (l *LocalBitcoins) SubmitOrder(s *order.Submit) (order.SubmitResponse, erro
 		return submitOrderResponse, err
 	}
 
+	fPair, err := l.FormatExchangeCurrency(s.Pair, s.AssetType)
+	if err != nil {
+		return submitOrderResponse, err
+	}
+
 	// These are placeholder details
 	// TODO store a user's localbitcoin details to use here
 	var params = AdCreate{
@@ -305,7 +310,7 @@ func (l *LocalBitcoins) SubmitOrder(s *order.Submit) (order.SubmitResponse, erro
 		City:                       "City",
 		Location:                   "Location",
 		CountryCode:                "US",
-		Currency:                   s.Pair.Quote.String(),
+		Currency:                   fPair.Quote.String(),
 		AccountInfo:                "-",
 		BankName:                   "Bank",
 		MSG:                        s.Side.String(),
@@ -319,7 +324,7 @@ func (l *LocalBitcoins) SubmitOrder(s *order.Submit) (order.SubmitResponse, erro
 	}
 
 	// Does not return any orderID, so create the add, then get the order
-	err := l.CreateAd(&params)
+	err = l.CreateAd(&params)
 	if err != nil {
 		return submitOrderResponse, err
 	}

exchanges/okex/okex_wrapper.go

@@ -534,9 +534,14 @@ func (o *OKEX) FetchTicker(p currency.Pair, assetType asset.Item) (tickerData *t
 	if assetType == asset.Index {
 		return tickerData, errors.New("ticker fetching not supported for index")
 	}
-	tickerData, err = ticker.GetTicker(o.Name, p, assetType)
+	fPair, err := o.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return o.UpdateTicker(p, assetType)
+		return nil, err
+	}
+
+	tickerData, err = ticker.GetTicker(o.Name, fPair, assetType)
+	if err != nil {
+		return o.UpdateTicker(fPair, assetType)
 	}
 	return
 }

exchanges/okgroup/okgroup_wrapper.go

@@ -63,9 +63,13 @@ func (o *OKGroup) Setup(exch *config.ExchangeConfig) error {
 
 // FetchOrderbook returns orderbook base on the currency pair
 func (o *OKGroup) FetchOrderbook(p currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
-	ob, err := orderbook.Get(o.Name, p, assetType)
+	fPair, err := o.FormatExchangeCurrency(p, assetType)
 	if err != nil {
-		return o.UpdateOrderbook(p, assetType)
+		return nil, err
+	}
+	ob, err := orderbook.Get(o.Name, fPair, assetType)
+	if err != nil {
+		return o.UpdateOrderbook(fPair, assetType)
 	}
 	return ob, nil
 }
@@ -77,13 +81,13 @@ func (o *OKGroup) UpdateOrderbook(p currency.Pair, a asset.Item) (*orderbook.Bas
 		return orderBook, errors.New("no orderbooks for index")
 	}
 
-	fpair, err := o.FormatExchangeCurrency(p, a)
+	fPair, err := o.FormatExchangeCurrency(p, a)
 	if err != nil {
 		return nil, err
 	}
 
 	orderbookNew, err := o.GetOrderBook(GetOrderBookRequest{
-		InstrumentID: fpair.String(),
+		InstrumentID: fPair.String(),
 	}, a)
 	if err != nil {
 		return orderBook, err
@@ -162,7 +166,7 @@ func (o *OKGroup) UpdateOrderbook(p currency.Pair, a asset.Item) (*orderbook.Bas
 		return orderBook, err
 	}
 
-	return orderbook.Get(o.Name, p, a)
+	return orderbook.Get(o.Name, fPair, a)
 }
 
 // UpdateAccountInfo retrieves balances for all enabled currencies

exchanges/poloniex/poloniex_wrapper.go

@@ -420,9 +420,14 @@ func (p *Poloniex) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 		return submitOrderResponse, err
 	}
 
+	fPair, err := p.FormatExchangeCurrency(s.Pair, s.AssetType)
+	if err != nil {
+		return submitOrderResponse, err
+	}
+
 	fillOrKill := s.Type == order.Market
 	isBuyOrder := s.Side == order.Buy
-	response, err := p.PlaceOrder(s.Pair.String(),
+	response, err := p.PlaceOrder(fPair.String(),
 		s.Price,
 		s.Amount,
 		false,

exchanges/yobit/yobit_wrapper.go

@@ -342,7 +342,12 @@ func (y *Yobit) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
 		return submitOrderResponse, errors.New("only limit orders are allowed")
 	}
 
-	response, err := y.Trade(s.Pair.String(),
+	fPair, err := y.FormatExchangeCurrency(s.Pair, s.AssetType)
+	if err != nil {
+		return submitOrderResponse, err
+	}
+
+	response, err := y.Trade(fPair.String(),
 		s.Side.String(),
 		s.Amount,
 		s.Price)

exchanges/zb/zb_wrapper.go

@@ -426,10 +426,15 @@ func (z *ZB) SubmitOrder(o *order.Submit) (order.SubmitResponse, error) {
 			oT = SpotNewOrderRequestParamsTypeSell
 		}
 
+		fPair, err := z.FormatExchangeCurrency(o.Pair, o.AssetType)
+		if err != nil {
+			return submitOrderResponse, err
+		}
+
 		var params = SpotNewOrderRequestParams{
 			Amount: o.Amount,
 			Price:  o.Price,
-			Symbol: o.Pair.Lower().String(),
+			Symbol: fPair.Lower().String(),
 			Type:   oT,
 		}
 		var response int64