gocryptotrader/tools/exchange_template/main_file.tmpl

{{define "main"}}
package {{.Name}}

import (
	"time"

	"github.com/thrasher-corp/gocryptotrader/common"
	"github.com/thrasher-corp/gocryptotrader/config"
	exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
	"github.com/thrasher-corp/gocryptotrader/exchanges/request"
	"github.com/thrasher-corp/gocryptotrader/exchanges/ticker"
	"github.com/thrasher-corp/gocryptotrader/exchanges/wshandler"
	log "github.com/thrasher-corp/gocryptotrader/logger"
)

// {{.CapitalName}} is the overarching type across this package
type {{.CapitalName}} struct {
	exchange.Base
}

const (
	{{.Name}}APIURL = ""
  {{.Name}}APIVersion = ""

	// Public endpoints

	// Authenticated endpoints

)

// SetDefaults sets the basic defaults for {{.CapitalName}}
func ({{.Variable}} *{{.CapitalName}}) SetDefaults() {
	{{.Variable}}.Name = "{{.CapitalName}}"
	{{.Variable}}.Enabled = false
	{{.Variable}}.Verbose = false
	{{.Variable}}.RESTPollingDelay = 10
	{{.Variable}}.RequestCurrencyPairFormat.Delimiter = ""
	{{.Variable}}.RequestCurrencyPairFormat.Uppercase = true
	{{.Variable}}.ConfigCurrencyPairFormat.Delimiter = ""
	{{.Variable}}.ConfigCurrencyPairFormat.Uppercase = true
	{{.Variable}}.AssetTypes = []string{ticker.Spot}
	{{.Variable}}.SupportsAutoPairUpdating = false
	{{.Variable}}.SupportsRESTTickerBatching = false
	{{.Variable}}.Requester = request.New({{.Variable}}.Name,
		request.NewRateLimit(time.Second, 0),
		request.NewRateLimit(time.Second, 0),
		common.NewHTTPClientWithTimeout(exchange.DefaultHTTPTimeout))
	{{.Variable}}.APIUrlDefault = {{.Name}}APIURL
	{{.Variable}}.APIUrl = {{.Variable}}.APIUrlDefault
	{{.Variable}}.Websocket = monitor.New()
	{{.Variable}}.WebsocketResponseMaxLimit = exchange.DefaultWebsocketResponseMaxLimit
	{{.Variable}}.WebsocketResponseCheckTimeout = exchange.DefaultWebsocketResponseCheckTimeout
}

// Setup takes in the supplied exchange configuration details and sets params
func ({{.Variable}} *{{.CapitalName}}) Setup(exch *config.ExchangeConfig) {
	if !exch.Enabled {
		{{.Variable}}.SetEnabled(false)
	} else {
		{{.Variable}}.Enabled = true
		{{.Variable}}.AuthenticatedAPISupport = exch.AuthenticatedAPISupport
		{{.Variable}}.AuthenticatedWebsocketAPISupport = exch.AuthenticatedWebsocketAPISupport
		{{.Variable}}.SetAPIKeys(exch.APIKey, exch.APISecret, "", false)
		{{.Variable}}.SetHTTPClientTimeout(exch.HTTPTimeout)
		{{.Variable}}.SetHTTPClientUserAgent(exch.HTTPUserAgent)
		{{.Variable}}.RESTPollingDelay = exch.RESTPollingDelay
		{{.Variable}}.Verbose = exch.Verbose
		{{.Variable}}.Websocket.SetWsStatusAndConnection(exch.Websocket)
		{{.Variable}}.BaseCurrencies = common.SplitStrings(exch.BaseCurrencies, ",")
		{{.Variable}}.AvailablePairs = common.SplitStrings(exch.AvailablePairs, ",")
		{{.Variable}}.EnabledPairs = common.SplitStrings(exch.EnabledPairs, ",")
		err := {{.Variable}}.SetCurrencyPairFormat()
		if err != nil {
			log.Fatal(err)
		}
		err = {{.Variable}}.SetAssetTypes()
		if err != nil {
			log.Fatal(err)
		}
		err = {{.Variable}}.SetAutoPairDefaults()
		if err != nil {
			log.Fatal(err)
		}
		err = {{.Variable}}.SetAPIURL(exch)
		if err != nil {
			log.Fatal(err)
		}
		err = {{.Variable}}.SetClientProxyAddress(exch.ProxyAddress)
		if err != nil {
			log.Fatal(err)
		}

		// If the exchange supports websocket, update the below block 
		// err = {{.Variable}}.WebsocketSetup({{.Variable}}.WsConnect,
		//	exch.Name,
		//	exch.Websocket,
		//	{{.Name}}Websocket,
		//	exch.WebsocketURL)
		// if err != nil {
		// 	log.Fatal(err)
		// }
		// {{.Variable}}.WebsocketConn = &wshandler.WebsocketConnection{
		// 		ExchangeName:         {{.Variable}}.Name,
		// 		URL:                  {{.Variable}}.Websocket.GetWebsocketURL(),
		// 		ProxyURL:             {{.Variable}}.Websocket.GetProxyAddress(),
		// 		Verbose:              {{.Variable}}.Verbose,
		// 		ResponseCheckTimeout: exch.WebsocketResponseCheckTimeout,
		// 		ResponseMaxLimit:     exch.WebsocketResponseMaxLimit,
		// }
	}
}
{{end}}