exchange

package
v1.0.15 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 31, 2024 License: MIT Imports: 37 Imported by: 0

README

GoCryptoTrader package Exchanges

Build Status Software License GoDoc Coverage Status Go Report Card

This exchanges package is part of the GoCryptoTrader codebase.

This is still in active development

You can track ideas, planned features and what's in progress on this Trello board: https://trello.com/b/ZAhMhpOy/gocryptotrader.

Join our slack to discuss all things related to GoCryptoTrader! GoCryptoTrader Slack

Current Features for exchanges

  • This package is used to connect and query data from supported exchanges.

  • Please checkout individual exchange README for more information on implementation

Guide for adding a new exchange

  • A guide on implementing API support for a new exchange can be found here

websocket notes

  • If contributing websocket improvements, please make sure order reports follow these rules.
Please click GoDocs chevron above to view current GoDoc information for this package

Contribution

Please feel free to submit any pull requests or suggest any desired features to be added.

When submitting a PR, please abide by our coding guidelines:

  • Code must adhere to the official Go formatting guidelines (i.e. uses gofmt).
  • Code must be documented adhering to the official Go commentary guidelines.
  • Code must adhere to our coding style.
  • Pull requests need to be based on and opened against the master branch.

Donations

If this framework helped you in any way, or you would like to support the developers working on it, please donate Bitcoin to:

bc1qk0jareu4jytc0cfrhr5wgshsq8282awpavfahc

Documentation

Index

Constants

View Source 
const (

	// DefaultHTTPTimeout is the default HTTP/HTTPS Timeout for exchange requests
	DefaultHTTPTimeout = time.Second * 15
	// DefaultWebsocketResponseCheckTimeout is the default delay in checking for an expected websocket response
	DefaultWebsocketResponseCheckTimeout = time.Millisecond * 50
	// DefaultWebsocketResponseMaxLimit is the default max wait for an expected websocket response before a timeout
	DefaultWebsocketResponseMaxLimit = time.Second * 7
	// DefaultWebsocketOrderbookBufferLimit is the maximum number of orderbook updates that get stored before being applied
	DefaultWebsocketOrderbookBufferLimit = 5
)
View Source 
const (
	// Repeated exchange strings
	// FeeType custom type for calculating fees based on method
	WireTransfer InternationalBankTransactionType = iota
	PerfectMoney
	Neteller
	AdvCash
	Payeer
	Skrill
	Simplex
	SEPA
	Swift
	RapidTransfer
	MisterTangoSEPA
	Qiwi
	VisaMastercard
	WebMoney
	Capitalist
	WesternUnion
	MoneyGram
	Contact
	// Const declarations for fee types
	BankFee FeeType = iota
	InternationalBankDepositFee
	InternationalBankWithdrawalFee
	CryptocurrencyTradeFee
	CryptocurrencyDepositFee
	CryptocurrencyWithdrawalFee
	OfflineTradeFee
	// Definitions for each type of withdrawal method for a given exchange
	NoAPIWithdrawalMethods                  uint32 = 0
	NoAPIWithdrawalMethodsText              string = "NONE, WEBSITE ONLY"
	AutoWithdrawCrypto                      uint32 = (1 << 0)
	AutoWithdrawCryptoWithAPIPermission     uint32 = (1 << 1)
	AutoWithdrawCryptoWithSetup             uint32 = (1 << 2)
	AutoWithdrawCryptoText                  string = "AUTO WITHDRAW CRYPTO"
	AutoWithdrawCryptoWithAPIPermissionText string = "AUTO WITHDRAW CRYPTO WITH API PERMISSION"
	AutoWithdrawCryptoWithSetupText         string = "AUTO WITHDRAW CRYPTO WITH SETUP"
	WithdrawCryptoWith2FA                   uint32 = (1 << 3)
	WithdrawCryptoWithSMS                   uint32 = (1 << 4)
	WithdrawCryptoWithEmail                 uint32 = (1 << 5)
	WithdrawCryptoWithWebsiteApproval       uint32 = (1 << 6)
	WithdrawCryptoWithAPIPermission         uint32 = (1 << 7)
	WithdrawCryptoWith2FAText               string = "WITHDRAW CRYPTO WITH 2FA"
	WithdrawCryptoWithSMSText               string = "WITHDRAW CRYPTO WITH SMS"
	WithdrawCryptoWithEmailText             string = "WITHDRAW CRYPTO WITH EMAIL"
	WithdrawCryptoWithWebsiteApprovalText   string = "WITHDRAW CRYPTO WITH WEBSITE APPROVAL"
	WithdrawCryptoWithAPIPermissionText     string = "WITHDRAW CRYPTO WITH API PERMISSION"
	AutoWithdrawFiat                        uint32 = (1 << 8)
	AutoWithdrawFiatWithAPIPermission       uint32 = (1 << 9)
	AutoWithdrawFiatWithSetup               uint32 = (1 << 10)
	AutoWithdrawFiatText                    string = "AUTO WITHDRAW FIAT"
	AutoWithdrawFiatWithAPIPermissionText   string = "AUTO WITHDRAW FIAT WITH API PERMISSION"
	AutoWithdrawFiatWithSetupText           string = "AUTO WITHDRAW FIAT WITH SETUP"
	WithdrawFiatWith2FA                     uint32 = (1 << 11)
	WithdrawFiatWithSMS                     uint32 = (1 << 12)
	WithdrawFiatWithEmail                   uint32 = (1 << 13)
	WithdrawFiatWithWebsiteApproval         uint32 = (1 << 14)
	WithdrawFiatWithAPIPermission           uint32 = (1 << 15)
	WithdrawFiatWith2FAText                 string = "WITHDRAW FIAT WITH 2FA"
	WithdrawFiatWithSMSText                 string = "WITHDRAW FIAT WITH SMS"
	WithdrawFiatWithEmailText               string = "WITHDRAW FIAT WITH EMAIL"
	WithdrawFiatWithWebsiteApprovalText     string = "WITHDRAW FIAT WITH WEBSITE APPROVAL"
	WithdrawFiatWithAPIPermissionText       string = "WITHDRAW FIAT WITH API PERMISSION"
	WithdrawCryptoViaWebsiteOnly            uint32 = (1 << 16)
	WithdrawFiatViaWebsiteOnly              uint32 = (1 << 17)
	WithdrawCryptoViaWebsiteOnlyText        string = "WITHDRAW CRYPTO VIA WEBSITE ONLY"
	WithdrawFiatViaWebsiteOnlyText          string = "WITHDRAW FIAT VIA WEBSITE ONLY"
	NoFiatWithdrawals                       uint32 = (1 << 18)
	NoFiatWithdrawalsText                   string = "NO FIAT WITHDRAWAL"
	UnknownWithdrawalTypeText               string = "UNKNOWN"
)

Endpoint authentication types

Variables

View Source 
var (
	// ErrAuthenticationSupportNotEnabled defines an error when
	// authenticatedSupport and authenticatedWebsocketApiSupport are set to
	// false in config.json
	ErrAuthenticationSupportNotEnabled = errors.New("REST or Websocket authentication support is not enabled")
	// ErrCredentialsAreEmpty defines an error for when the credentials are
	// completely empty but an attempt at retrieving credentials was made to
	// undertake an authenticated HTTP request.
	ErrCredentialsAreEmpty = errors.New("credentials are empty")
)
View Source 
var (
	// ErrExchangeNameIsEmpty is returned when the exchange name is empty
	ErrExchangeNameIsEmpty = errors.New("exchange name is empty")
)
View Source 
var Exchanges = []string{
	"binance",
	"binanceus",
	"bitfinex",
	"bithumb",
	"bitflyer",
	"bitmex",
	"bitstamp",
	"btc markets",
	"btse",
	"bybit",
	"coinbasepro",
	"coinut",
	"exmo",
	"gateio",
	"gemini",
	"hitbtc",
	"huobi",
	"kraken",
	"kucoin",
	"lbank",
	"okcoin",
	"okx",
	"poloniex",
	"yobit",
}

Exchanges stores a list of supported exchanges

Functions

func Bootstrap 

func Bootstrap(ctx context.Context, b IBotExchange) error

Bootstrap function allows for exchange authors to supplement or override common startup actions If exchange.Bootstrap returns false or error it will not perform any other actions. If it returns true, or is not implemented by the exchange, it will: * Print debug startup information * UpdateOrderExecutionLimits * UpdateTradablePairs

func GetDefaultConfig 

func GetDefaultConfig(ctx context.Context, exch IBotExchange) (*config.Exchange, error)

GetDefaultConfig returns a default exchange config

func IsSupported 

func IsSupported(exchangeName string) bool

IsSupported returns whether or not a specific exchange is supported

Types

type API 

type API struct {
	AuthenticatedSupport          bool
	AuthenticatedWebsocketSupport bool
	PEMKeySupport                 bool

	Endpoints *Endpoints

	CredentialsValidator config.APICredentialsValidatorConfig
	// contains filtered or unexported fields
}

API stores the exchange API settings

func (*API) SetClientID 

func (a *API) SetClientID(clientID string)

SetClientID sets new clientID for the default credentials

func (*API) SetKey 

func (a *API) SetKey(key string)

SetKey sets new key for the default credentials

func (*API) SetPEMKey 

func (a *API) SetPEMKey(pem string)

SetPEMKey sets pem key for the default credentials

func (*API) SetSecret 

func (a *API) SetSecret(secret string)

SetSecret sets new secret for the default credentials

func (*API) SetSubAccount 

func (a *API) SetSubAccount(sub string)

SetSubAccount sets sub account for the default credentials

type AccountManagement 

type AccountManagement interface {
	UpdateAccountInfo(ctx context.Context, a asset.Item) (account.Holdings, error)
	FetchAccountInfo(ctx context.Context, a asset.Item) (account.Holdings, error)
	HasAssetTypeAccountSegregation() bool
}

AccountManagement defines functionality for exchange account management

type AssetWebsocketSupport 

type AssetWebsocketSupport struct {
	// contains filtered or unexported fields
}

AssetWebsocketSupport defines the availability of websocket functionality to the specific asset type. TODO: Deprecate as this is a temp item to address certain limitations quickly.

func (*AssetWebsocketSupport) IsAssetWebsocketSupported 

func (a *AssetWebsocketSupport) IsAssetWebsocketSupported(aType asset.Item) bool

IsAssetWebsocketSupported checks to see if the supplied asset type is supported by websocket.

type Base 

type Base struct {
	Name                          string
	Enabled                       bool
	Verbose                       bool
	LoadedByConfig                bool
	SkipAuthCheck                 bool
	API                           API
	BaseCurrencies                currency.Currencies
	CurrencyPairs                 currency.PairsManager
	Features                      Features
	HTTPTimeout                   time.Duration
	HTTPRecording                 bool
	HTTPDebugging                 bool
	BypassConfigFormatUpgrades    bool
	WebsocketResponseCheckTimeout time.Duration
	WebsocketResponseMaxLimit     time.Duration
	WebsocketOrderbookBufferLimit int64
	Websocket                     *stream.Websocket
	*request.Requester
	Config *config.Exchange

	// CanVerifyOrderbook determines if the orderbook verification can be bypassed,
	// increasing potential update speed but decreasing confidence in orderbook
	// integrity.
	CanVerifyOrderbook bool
	order.ExecutionLimits

	AssetWebsocketSupport
	*currencystate.States
	// contains filtered or unexported fields
}

Base stores the individual exchange information

func (*Base) AddTradesToBuffer 

func (b *Base) AddTradesToBuffer(trades ...trade.Data) error

AddTradesToBuffer is a helper function that will only add trades to the buffer if it is allowed

func (*Base) AreCredentialsValid 

func (b *Base) AreCredentialsValid(ctx context.Context) bool

AreCredentialsValid returns if the supplied credentials are valid.

func (*Base) AuthenticateWebsocket 

func (b *Base) AuthenticateWebsocket(_ context.Context) error

AuthenticateWebsocket sends an authentication message to the websocket

func (*Base) Bootstrap 

func (b *Base) Bootstrap(_ context.Context) (continueBootstrap bool, err error)

Bootstrap is a fallback method for exchange startup actions Exchange authors should override this if they wish to customise startup actions Return true or an error to all default Bootstrap actions to occur afterwards or false to signal that no further bootstrapping should occur

func (*Base) CalculatePNL 

func (b *Base) CalculatePNL(context.Context, *futures.PNLCalculatorRequest) (*futures.PNLResult, error)

CalculatePNL is an overridable function to allow PNL to be calculated on an open position It will also determine whether the position is considered to be liquidated For live trading, an overriding function may wish to confirm the liquidation by requesting the status of the asset

func (*Base) CalculateTotalCollateral 

func (b *Base) CalculateTotalCollateral(_ context.Context, _ *futures.TotalCollateralCalculator) (*futures.TotalCollateralResponse, error)

CalculateTotalCollateral takes in n collateral calculators to determine an overall standing in a singular currency

func (*Base) ChangePositionMargin 

func (b *Base) ChangePositionMargin(_ context.Context, _ *margin.PositionChangeRequest) (*margin.PositionChangeResponse, error)

ChangePositionMargin changes the margin type for a position

func (*Base) CheckCredentials 

func (b *Base) CheckCredentials(creds *account.Credentials, isContext bool) error

CheckCredentials checks to see if the required fields have been set before sending an authenticated API request

func (*Base) CheckTransientError 

func (b *Base) CheckTransientError(err error) error

CheckTransientError catches transient errors and returns nil if found, used for validation of API credentials

func (*Base) DisableAssetWebsocketSupport 

func (b *Base) DisableAssetWebsocketSupport(aType asset.Item) error

DisableAssetWebsocketSupport disables websocket functionality for the supplied asset item. In the case that websocket functionality has not yet been implemented for that specific asset type. This is a base method to check availability of asset type.

func (*Base) DisableRateLimiter 

func (b *Base) DisableRateLimiter() error

DisableRateLimiter disables the rate limiting system for the exchange

func (*Base) EnableRateLimiter 

func (b *Base) EnableRateLimiter() error

EnableRateLimiter enables the rate limiting system for the exchange

func (*Base) EnsureOnePairEnabled 

func (b *Base) EnsureOnePairEnabled() error

EnsureOnePairEnabled not all assets have pairs, eg options search for an asset that does and enable one if none are enabled error if no currency pairs found for an entire exchange

func (*Base) FlushWebsocketChannels 

func (b *Base) FlushWebsocketChannels() error

FlushWebsocketChannels refreshes websocket channel subscriptions based on websocket features. Used in the event of a pair/asset or subscription change.

func (*Base) FormatExchangeCurrencies 

func (b *Base) FormatExchangeCurrencies(pairs []currency.Pair, assetType asset.Item) (string, error)

FormatExchangeCurrencies returns a string containing the exchanges formatted currency pairs

func (*Base) FormatExchangeCurrency 

func (b *Base) FormatExchangeCurrency(p currency.Pair, assetType asset.Item) (currency.Pair, error)

FormatExchangeCurrency is a method that formats and returns a currency pair based on the user currency display preferences

func (*Base) FormatExchangeKlineInterval 

func (b *Base) FormatExchangeKlineInterval(in kline.Interval) string

FormatExchangeKlineInterval returns Interval to string Exchanges can override this if they require custom formatting

func (*Base) FormatSymbol 

func (b *Base) FormatSymbol(pair currency.Pair, assetType asset.Item) (string, error)

FormatSymbol formats the given pair to a string suitable for exchange API requests

func (*Base) FormatWithdrawPermissions 

func (b *Base) FormatWithdrawPermissions() string

FormatWithdrawPermissions will return each of the exchange's compatible withdrawal methods in readable form

func (*Base) GetAssetTypes 

func (b *Base) GetAssetTypes(enabled bool) asset.Items

GetAssetTypes returns the either the enabled or available asset types for an individual exchange

func (*Base) GetAvailablePairs 

func (b *Base) GetAvailablePairs(assetType asset.Item) (currency.Pairs, error)

GetAvailablePairs is a method that returns the available currency pairs of the exchange by asset type

func (*Base) GetAvailableTransferChains 

func (b *Base) GetAvailableTransferChains(_ context.Context, _ currency.Code) ([]string, error)

GetAvailableTransferChains returns a list of supported transfer chains based on the supplied cryptocurrency

func (*Base) GetBase 

func (b *Base) GetBase() *Base

GetBase returns the exchange base

func (*Base) GetCachedOpenInterest 

func (b *Base) GetCachedOpenInterest(_ context.Context, k ...key.PairAsset) ([]futures.OpenInterest, error)

GetCachedOpenInterest returns open interest data if the exchange supports open interest in ticker data

func (*Base) GetClientBankAccounts 

func (b *Base) GetClientBankAccounts(exchangeName, withdrawalCurrency string) (*banking.Account, error)

GetClientBankAccounts returns banking details associated with a client for withdrawal purposes

func (*Base) GetCollateralCurrencyForContract 

func (b *Base) GetCollateralCurrencyForContract(_ asset.Item, _ currency.Pair) (currency.Code, asset.Item, error)

GetCollateralCurrencyForContract returns the collateral currency for an asset and contract pair

func (*Base) GetCollateralMode 

func (b *Base) GetCollateralMode(_ context.Context, _ asset.Item) (collateral.Mode, error)

GetCollateralMode returns the account's collateral mode for the asset type

func (*Base) GetCredentials 

func (b *Base) GetCredentials(ctx context.Context) (*account.Credentials, error)

GetCredentials checks and validates current credentials, context credentials override default credentials, if no credentials found, will return an error.

func (*Base) GetCurrencyForRealisedPNL 

func (b *Base) GetCurrencyForRealisedPNL(_ asset.Item, _ currency.Pair) (currency.Code, asset.Item, error)

GetCurrencyForRealisedPNL returns where to put realised PNL example 1: Bybit universal margin PNL is paid out in USD to your spot wallet example 2: Binance coin margined futures pays returns using the same currency eg BTC

func (*Base) GetCurrencyTradeURL 

func (b *Base) GetCurrencyTradeURL(context.Context, asset.Item, currency.Pair) (string, error)

GetCurrencyTradeURL returns the URL to the exchange's trade page for the given asset and currency pair

func (*Base) GetDefaultCredentials 

func (b *Base) GetDefaultCredentials() *account.Credentials

GetDefaultCredentials returns the exchange.Base api credentials loaded by config.json

func (*Base) GetEnabledFeatures 

func (b *Base) GetEnabledFeatures() FeaturesEnabled

GetEnabledFeatures returns the exchanges enabled features

func (*Base) GetEnabledPairs 

func (b *Base) GetEnabledPairs(a asset.Item) (currency.Pairs, error)

GetEnabledPairs is a method that returns the enabled currency pairs of the exchange by asset type, if the asset type is disabled this will return no enabled pairs

func (*Base) GetExchangeBankAccounts 

func (b *Base) GetExchangeBankAccounts(id, depositCurrency string) (*banking.Account, error)

GetExchangeBankAccounts returns banking details associated with an exchange for funding purposes

func (*Base) GetFuturesPositionOrders 

func (b *Base) GetFuturesPositionOrders(context.Context, *futures.PositionsRequest) ([]futures.PositionResponse, error)

GetFuturesPositionOrders returns futures positions orders

func (*Base) GetFuturesPositionSummary 

func (b *Base) GetFuturesPositionSummary(context.Context, *futures.PositionSummaryRequest) (*futures.PositionSummary, error)

GetFuturesPositionSummary returns stats for a future position

func (*Base) GetFuturesPositions 

func (b *Base) GetFuturesPositions(context.Context, *futures.PositionsRequest) ([]futures.PositionDetails, error)

GetFuturesPositions returns futures positions for all currencies

func (*Base) GetHistoricalFundingRates 

func (b *Base) GetHistoricalFundingRates(context.Context, *fundingrate.HistoricalRatesRequest) (*fundingrate.HistoricalRates, error)

GetHistoricalFundingRates returns historical funding rates for a future

func (*Base) GetKlineExtendedRequest 

func (b *Base) GetKlineExtendedRequest(pair currency.Pair, a asset.Item, interval kline.Interval, start, end time.Time) (*kline.ExtendedRequest, error)

GetKlineExtendedRequest returns a helper for the fetching of candle/kline data for a *multi* request within a pre-determined time window. This has extended functionality to also break down calls to fetch total history.

func (*Base) GetKlineRequest 

func (b *Base) GetKlineRequest(pair currency.Pair, a asset.Item, interval kline.Interval, start, end time.Time, fixedAPICandleLength bool) (*kline.Request, error)

GetKlineRequest returns a helper for the fetching of candle/kline data for a single request within a pre-determined time window.

func (*Base) GetLastPairsUpdateTime 

func (b *Base) GetLastPairsUpdateTime() int64

GetLastPairsUpdateTime returns the unix timestamp of when the exchanges currency pairs were last updated

func (*Base) GetLeverage 

func (b *Base) GetLeverage(_ context.Context, _ asset.Item, _ currency.Pair, _ margin.Type, _ order.Side) (float64, error)

GetLeverage gets the account's initial leverage for the asset type and pair

func (*Base) GetMarginRatesHistory 

func (b *Base) GetMarginRatesHistory(context.Context, *margin.RateHistoryRequest) (*margin.RateHistoryResponse, error)

GetMarginRatesHistory returns the margin rate history for the supplied currency

func (*Base) GetName 

func (b *Base) GetName() string

GetName is a method that returns the name of the exchange base

func (*Base) GetOpenInterest 

func (b *Base) GetOpenInterest(context.Context, ...key.PairAsset) ([]futures.OpenInterest, error)

GetOpenInterest returns the open interest rate for a given asset pair

func (*Base) GetPairAndAssetTypeRequestFormatted 

func (b *Base) GetPairAndAssetTypeRequestFormatted(symbol string) (currency.Pair, asset.Item, error)

GetPairAndAssetTypeRequestFormatted returns the pair and the asset type when there is distinct differentiation between exchange request symbols asset types. e.g. "BTC-USD" Spot and "BTC_USD" PERP request formatted.

func (*Base) GetPairAssetType 

func (b *Base) GetPairAssetType(c currency.Pair) (asset.Item, error)

GetPairAssetType returns the associated asset type for the currency pair This method is only useful for exchanges that have pair names with multiple delimiters (BTC-USD-0626) Helpful if the exchange has only a single asset type but in that case the asset type can be hard coded

func (*Base) GetPairFormat 

func (b *Base) GetPairFormat(assetType asset.Item, requestFormat bool) (currency.PairFormat, error)

GetPairFormat returns the pair format based on the exchange and asset type

func (*Base) GetPositionSummary 

func (b *Base) GetPositionSummary(context.Context, *futures.PositionSummaryRequest) (*futures.PositionSummary, error)

GetPositionSummary returns stats for a future position

func (*Base) GetRequestFormattedPairAndAssetType 

func (b *Base) GetRequestFormattedPairAndAssetType(p string) (currency.Pair, asset.Item, error)

GetRequestFormattedPairAndAssetType is a method that returns the enabled currency pair of along with its asset type. Only use when there is no chance of the same name crossing over

func (*Base) GetStandardConfig 

func (b *Base) GetStandardConfig() (*config.Exchange, error)

GetStandardConfig returns a standard default exchange config. Set defaults must populate base struct with exchange specific defaults before calling this function.

func (*Base) GetSubscriptions 

func (b *Base) GetSubscriptions() ([]subscription.Subscription, error)

GetSubscriptions returns a copied list of subscriptions

func (*Base) GetSupportedFeatures 

func (b *Base) GetSupportedFeatures() FeaturesSupported

GetSupportedFeatures returns the exchanges supported features

func (*Base) GetWebsocket 

func (b *Base) GetWebsocket() (*stream.Websocket, error)

GetWebsocket returns a pointer to the exchange websocket

func (*Base) GetWithdrawPermissions 

func (b *Base) GetWithdrawPermissions() uint32

GetWithdrawPermissions passes through the exchange's withdraw permissions

func (*Base) HasAssetTypeAccountSegregation 

func (b *Base) HasAssetTypeAccountSegregation() bool

HasAssetTypeAccountSegregation returns if the accounts are divided into asset types instead of just being denoted as spot holdings.

func (*Base) IsEnabled 

func (b *Base) IsEnabled() bool

IsEnabled is a method that returns if the current exchange is enabled

func (*Base) IsFillsFeedEnabled 

func (b *Base) IsFillsFeedEnabled() bool

IsFillsFeedEnabled checks the state of FillsFeed in a concurrent-friendly manner

func (*Base) IsPairEnabled 

func (b *Base) IsPairEnabled(pair currency.Pair, a asset.Item) (bool, error)

IsPairEnabled checks if a pair is enabled for an enabled asset type. TODO: Optimisation map for enabled pair matching, instead of linear traversal.

func (*Base) IsPerpetualFutureCurrency 

func (b *Base) IsPerpetualFutureCurrency(asset.Item, currency.Pair) (bool, error)

IsPerpetualFutureCurrency ensures a given asset and currency is a perpetual future differs by exchange

func (*Base) IsRESTAuthenticationSupported 

func (b *Base) IsRESTAuthenticationSupported() bool

IsRESTAuthenticationSupported returns whether the exchange supports REST authenticated API requests

func (*Base) IsSaveTradeDataEnabled 

func (b *Base) IsSaveTradeDataEnabled() bool

IsSaveTradeDataEnabled checks the state of SaveTradeData in a concurrent-friendly manner

func (*Base) IsTradeFeedEnabled 

func (b *Base) IsTradeFeedEnabled() bool

IsTradeFeedEnabled checks the state of TradeFeed in a concurrent-friendly manner

func (*Base) IsVerbose 

func (b *Base) IsVerbose() bool

IsVerbose returns if the exchange is set to verbose

func (*Base) IsWebsocketAuthenticationSupported 

func (b *Base) IsWebsocketAuthenticationSupported() bool

IsWebsocketAuthenticationSupported returns whether the exchange supports websocket authenticated API requests

func (*Base) IsWebsocketEnabled 

func (b *Base) IsWebsocketEnabled() bool

IsWebsocketEnabled returns whether or not the exchange has its websocket client enabled

func (*Base) MatchSymbolCheckEnabled 

func (b *Base) MatchSymbolCheckEnabled(symbol string, a asset.Item, hasDelimiter bool) (pair currency.Pair, enabled bool, err error)

MatchSymbolCheckEnabled returns a currency pair based on the supplied symbol and asset type against the available pairs list. If the string is expected to have a delimiter this will attempt to screen it out. It will also check if the pair is enabled.

func (*Base) MatchSymbolWithAvailablePairs 

func (b *Base) MatchSymbolWithAvailablePairs(symbol string, a asset.Item, hasDelimiter bool) (currency.Pair, error)

MatchSymbolWithAvailablePairs returns a currency pair based on the supplied symbol and asset type. If the string is expected to have a delimiter this will attempt to screen it out.

func (*Base) NewEndpoints 

func (b *Base) NewEndpoints() *Endpoints

NewEndpoints declares default and running URLs maps

func (*Base) ParallelChanOp 

func (b *Base) ParallelChanOp(channels []subscription.Subscription, m func([]subscription.Subscription) error, batchSize int) error

ParallelChanOp performs a single method call in parallel across streams and waits to return any errors

func (*Base) PrintEnabledPairs 

func (b *Base) PrintEnabledPairs()

PrintEnabledPairs prints the exchanges enabled asset pairs

func (*Base) ScaleCollateral 

func (b *Base) ScaleCollateral(context.Context, *futures.CollateralCalculator) (*collateral.ByCurrency, error)

ScaleCollateral is an overridable function to determine how much collateral is usable in futures positions

func (*Base) SetAPICredentialDefaults 

func (b *Base) SetAPICredentialDefaults()

SetAPICredentialDefaults sets the API Credential validator defaults

func (*Base) SetAPIURL 

func (b *Base) SetAPIURL() error

SetAPIURL sets configuration API URL for an exchange

func (*Base) SetClientProxyAddress 

func (b *Base) SetClientProxyAddress(addr string) error

SetClientProxyAddress sets a proxy address for REST and websocket requests

func (*Base) SetCollateralMode 

func (b *Base) SetCollateralMode(_ context.Context, _ asset.Item, _ collateral.Mode) error

SetCollateralMode sets the account's collateral mode for the asset type

func (*Base) SetConfigPairs 

func (b *Base) SetConfigPairs() error

SetConfigPairs sets the exchanges currency pairs to the pairs set in the config

func (*Base) SetCredentials 

func (b *Base) SetCredentials(apiKey, apiSecret, clientID, subaccount, pemKey, oneTimePassword string)

SetCredentials is a method that sets the current API keys for the exchange

func (*Base) SetCurrencyPairFormat 

func (b *Base) SetCurrencyPairFormat() error

SetCurrencyPairFormat checks the exchange request and config currency pair formats and syncs it with the exchanges SetDefault settings

func (*Base) SetEnabled 

func (b *Base) SetEnabled(enabled bool)

SetEnabled is a method that sets if the exchange is enabled

func (*Base) SetFeatureDefaults 

func (b *Base) SetFeatureDefaults()

SetFeatureDefaults sets the exchanges default feature support set

func (*Base) SetFillsFeedStatus 

func (b *Base) SetFillsFeedStatus(enabled bool)

SetFillsFeedStatus locks and sets the status of the config and the exchange's setting for FillsFeed

func (*Base) SetGlobalPairsManager 

func (b *Base) SetGlobalPairsManager(request, config *currency.PairFormat, assets ...asset.Item) error

SetGlobalPairsManager sets defined asset and pairs management system with global formatting

func (*Base) SetLeverage 

func (b *Base) SetLeverage(_ context.Context, _ asset.Item, _ currency.Pair, _ margin.Type, _ float64, _ order.Side) error

SetLeverage sets the account's initial leverage for the asset type and pair

func (*Base) SetMarginType 

func (b *Base) SetMarginType(_ context.Context, _ asset.Item, _ currency.Pair, _ margin.Type) error

SetMarginType sets the account's margin type for the asset type

func (*Base) SetPairs 

func (b *Base) SetPairs(pairs currency.Pairs, assetType asset.Item, enabled bool) error

SetPairs sets the exchange currency pairs for either enabledPairs or availablePairs

func (*Base) SetRequester 

func (b *Base) SetRequester(r *request.Requester) error

SetRequester sets the instance of the requester

func (*Base) SetSaveTradeDataStatus 

func (b *Base) SetSaveTradeDataStatus(enabled bool)

SetSaveTradeDataStatus locks and sets the status of the config and the exchange's setting for SaveTradeData

func (*Base) SetSubscriptionsFromConfig 

func (b *Base) SetSubscriptionsFromConfig()

SetSubscriptionsFromConfig sets the subscriptions from config If the subscriptions config is empty then Config will be updated from the exchange subscriptions, allowing e.SetDefaults to set default subscriptions for an exchange to update user's config Subscriptions not Enabled are skipped, meaning that e.Features.Subscriptions only contains Enabled subscriptions

func (*Base) SetTradeFeedStatus 

func (b *Base) SetTradeFeedStatus(enabled bool)

SetTradeFeedStatus locks and sets the status of the config and the exchange's setting for TradeFeed

func (*Base) SetupDefaults 

func (b *Base) SetupDefaults(exch *config.Exchange) error

SetupDefaults sets the exchange settings based on the supplied config

func (*Base) Shutdown 

func (b *Base) Shutdown() error

Shutdown closes active websocket connections if available and then cleans up a REST requester instance.

func (*Base) StoreAssetPairFormat 

func (b *Base) StoreAssetPairFormat(a asset.Item, f currency.PairStore) error

StoreAssetPairFormat initialises and stores a defined asset format

func (*Base) SubscribeToWebsocketChannels 

func (b *Base) SubscribeToWebsocketChannels(channels []subscription.Subscription) error

SubscribeToWebsocketChannels appends to ChannelsToSubscribe which lets websocket.manageSubscriptions handle subscribing

func (*Base) SupportsAsset 

func (b *Base) SupportsAsset(a asset.Item) bool

SupportsAsset whether or not the supplied asset is supported by the exchange

func (*Base) SupportsAutoPairUpdates 

func (b *Base) SupportsAutoPairUpdates() bool

SupportsAutoPairUpdates returns whether or not the exchange supports auto currency pair updating

func (*Base) SupportsPair 

func (b *Base) SupportsPair(p currency.Pair, enabledPairs bool, assetType asset.Item) error

SupportsPair returns true or not whether a currency pair exists in the exchange available currencies or not

func (*Base) SupportsREST 

func (b *Base) SupportsREST() bool

SupportsREST returns whether or not the exchange supports REST

func (*Base) SupportsRESTTickerBatchUpdates 

func (b *Base) SupportsRESTTickerBatchUpdates() bool

SupportsRESTTickerBatchUpdates returns whether or not the exchange supports REST batch ticker fetching

func (*Base) SupportsWebsocket 

func (b *Base) SupportsWebsocket() bool

SupportsWebsocket returns whether or not the exchange supports websocket

func (*Base) SupportsWithdrawPermissions 

func (b *Base) SupportsWithdrawPermissions(permissions uint32) bool

SupportsWithdrawPermissions compares the supplied permissions with the exchange's to verify they're supported

func (*Base) UnsubscribeToWebsocketChannels 

func (b *Base) UnsubscribeToWebsocketChannels(channels []subscription.Subscription) error

UnsubscribeToWebsocketChannels removes from ChannelsToSubscribe which lets websocket.manageSubscriptions handle unsubscribing

func (*Base) UpdateCurrencyStates 

func (b *Base) UpdateCurrencyStates(_ context.Context, _ asset.Item) error

UpdateCurrencyStates updates currency states

func (*Base) UpdatePairs 

func (b *Base) UpdatePairs(incoming currency.Pairs, a asset.Item, enabled, force bool) error

UpdatePairs updates the exchange currency pairs for either enabledPairs or availablePairs

func (*Base) ValidateKline 

func (b *Base) ValidateKline(pair currency.Pair, a asset.Item, interval kline.Interval) error

ValidateKline confirms that the requested pair, asset & interval are supported and/or enabled by the requested exchange.

func (*Base) VerifyAPICredentials 

func (b *Base) VerifyAPICredentials(creds *account.Credentials) error

VerifyAPICredentials verifies the exchanges API credentials

type CurrencyStateManagement 

type CurrencyStateManagement interface {
	GetCurrencyStateSnapshot() ([]currencystate.Snapshot, error)
	UpdateCurrencyStates(ctx context.Context, a asset.Item) error
	CanTradePair(p currency.Pair, a asset.Item) error
	CanTrade(c currency.Code, a asset.Item) error
	CanWithdraw(c currency.Code, a asset.Item) error
	CanDeposit(c currency.Code, a asset.Item) error
}

CurrencyStateManagement defines functionality for currency state management

type Endpoints 

type Endpoints struct {
	Exchange string
	// contains filtered or unexported fields
}

Endpoints stores running url endpoints for exchanges

func (*Endpoints) GetURL 

func (e *Endpoints) GetURL(key URL) (string, error)

GetURL gets default url from URLs map

func (*Endpoints) GetURLMap 

func (e *Endpoints) GetURLMap() map[string]string

GetURLMap gets all urls for either running or default map based on the bool value supplied

func (*Endpoints) SetDefaultEndpoints 

func (e *Endpoints) SetDefaultEndpoints(m map[URL]string) error

SetDefaultEndpoints declares and sets the default URLs map

func (*Endpoints) SetRunning 

func (e *Endpoints) SetRunning(key, val string) error

SetRunning populates running URLs map

type Features 

type Features struct {
	Supports      FeaturesSupported
	Enabled       FeaturesEnabled
	Subscriptions []*subscription.Subscription
}

Features stores the supported and enabled features for the exchange

type FeaturesEnabled 

type FeaturesEnabled struct {
	AutoPairUpdates bool
	Kline           kline.ExchangeCapabilitiesEnabled
	SaveTradeData   bool
	TradeFeed       bool
	FillsFeed       bool
}

FeaturesEnabled stores the exchange enabled features

type FeaturesSupported 

type FeaturesSupported struct {
	REST                       bool
	RESTCapabilities           protocol.Features
	Websocket                  bool
	WebsocketCapabilities      protocol.Features
	WithdrawPermissions        uint32
	Kline                      kline.ExchangeCapabilitiesSupported
	MaximumOrderHistory        time.Duration
	FuturesCapabilities        FuturesCapabilities
	OfflineFuturesCapabilities FuturesCapabilities
}

FeaturesSupported stores the exchanges supported features

type FeeBuilder 

type FeeBuilder struct {
	FeeType FeeType
	// Used for calculating crypto trading fees, deposits & withdrawals
	Pair    currency.Pair
	IsMaker bool
	// Fiat currency used for bank deposits & withdrawals
	FiatCurrency        currency.Code
	BankTransactionType InternationalBankTransactionType
	// Used to multiply for fee calculations
	PurchasePrice float64
	Amount        float64
}

FeeBuilder is the type which holds all parameters required to calculate a fee for an exchange

type FeeType 

type FeeType uint8

FeeType is the type for holding a custom fee type (International withdrawal fee)

type FunctionalityChecker 

type FunctionalityChecker interface {
	IsEnabled() bool
	IsAssetWebsocketSupported(a asset.Item) bool
	SupportsAsset(assetType asset.Item) bool
	SupportsREST() bool
	SupportsWithdrawPermissions(permissions uint32) bool
	SupportsRESTTickerBatchUpdates() bool
	IsWebsocketEnabled() bool
	SupportsWebsocket() bool
	SupportsAutoPairUpdates() bool
	IsWebsocketAuthenticationSupported() bool
	IsRESTAuthenticationSupported() bool
}

FunctionalityChecker defines functionality for retrieving exchange support/enabled features

type FundingHistory 

type FundingHistory struct {
	ExchangeName      string
	Status            string
	TransferID        string
	Description       string
	Timestamp         time.Time
	Currency          string
	Amount            float64
	Fee               float64
	TransferType      string
	CryptoToAddress   string
	CryptoFromAddress string
	CryptoTxID        string
	CryptoChain       string
	BankTo            string
	BankFrom          string
}

FundingHistory holds exchange funding history data

type FuturesCapabilities 

type FuturesCapabilities struct {
	FundingRates                    bool
	MaximumFundingRateHistory       time.Duration
	FundingRateBatching             map[asset.Item]bool
	SupportedFundingRateFrequencies map[kline.Interval]bool
	Positions                       bool
	OrderManagerPositionTracking    bool
	Collateral                      bool
	CollateralMode                  bool
	Leverage                        bool
	OpenInterest                    OpenInterestSupport
}

FuturesCapabilities stores the exchange's futures capabilities

type FuturesManagement 

type FuturesManagement interface {
	GetOpenInterest(context.Context, ...key.PairAsset) ([]futures.OpenInterest, error)
	ScaleCollateral(ctx context.Context, calculator *futures.CollateralCalculator) (*collateral.ByCurrency, error)
	GetPositionSummary(context.Context, *futures.PositionSummaryRequest) (*futures.PositionSummary, error)
	CalculateTotalCollateral(context.Context, *futures.TotalCollateralCalculator) (*futures.TotalCollateralResponse, error)
	GetFuturesPositions(context.Context, *futures.PositionsRequest) ([]futures.PositionDetails, error)
	GetHistoricalFundingRates(context.Context, *fundingrate.HistoricalRatesRequest) (*fundingrate.HistoricalRates, error)
	GetLatestFundingRates(context.Context, *fundingrate.LatestRateRequest) ([]fundingrate.LatestRateResponse, error)
	IsPerpetualFutureCurrency(asset.Item, currency.Pair) (bool, error)
	GetCollateralCurrencyForContract(asset.Item, currency.Pair) (currency.Code, asset.Item, error)

	GetFuturesPositionSummary(context.Context, *futures.PositionSummaryRequest) (*futures.PositionSummary, error)
	GetFuturesPositionOrders(context.Context, *futures.PositionsRequest) ([]futures.PositionResponse, error)
	SetCollateralMode(ctx context.Context, item asset.Item, mode collateral.Mode) error
	GetCollateralMode(ctx context.Context, item asset.Item) (collateral.Mode, error)
	SetLeverage(ctx context.Context, item asset.Item, pair currency.Pair, marginType margin.Type, amount float64, orderSide order.Side) error
	GetLeverage(ctx context.Context, item asset.Item, pair currency.Pair, marginType margin.Type, orderSide order.Side) (float64, error)
}

FuturesManagement manages futures orders, pnl and collateral calculations

type IBotExchange 

type IBotExchange interface {
	Setup(exch *config.Exchange) error
	Bootstrap(context.Context) (continueBootstrap bool, err error)
	SetDefaults()
	Shutdown() error
	GetName() string
	SetEnabled(bool)
	GetEnabledFeatures() FeaturesEnabled
	GetSupportedFeatures() FeaturesSupported
	FetchTicker(ctx context.Context, p currency.Pair, a asset.Item) (*ticker.Price, error)
	UpdateTicker(ctx context.Context, p currency.Pair, a asset.Item) (*ticker.Price, error)
	UpdateTickers(ctx context.Context, a asset.Item) error
	FetchOrderbook(ctx context.Context, p currency.Pair, a asset.Item) (*orderbook.Base, error)
	UpdateOrderbook(ctx context.Context, p currency.Pair, a asset.Item) (*orderbook.Base, error)
	FetchTradablePairs(ctx context.Context, a asset.Item) (currency.Pairs, error)
	UpdateTradablePairs(ctx context.Context, forceUpdate bool) error
	GetEnabledPairs(a asset.Item) (currency.Pairs, error)
	GetAvailablePairs(a asset.Item) (currency.Pairs, error)
	SetPairs(pairs currency.Pairs, a asset.Item, enabled bool) error
	GetAssetTypes(enabled bool) asset.Items
	GetRecentTrades(ctx context.Context, p currency.Pair, a asset.Item) ([]trade.Data, error)
	GetHistoricTrades(ctx context.Context, p currency.Pair, a asset.Item, startTime, endTime time.Time) ([]trade.Data, error)
	GetFeeByType(ctx context.Context, f *FeeBuilder) (float64, error)
	GetLastPairsUpdateTime() int64
	GetWithdrawPermissions() uint32
	FormatWithdrawPermissions() string
	GetAccountFundingHistory(ctx context.Context) ([]FundingHistory, error)
	GetDepositAddress(ctx context.Context, cryptocurrency currency.Code, accountID, chain string) (*deposit.Address, error)
	GetAvailableTransferChains(ctx context.Context, cryptocurrency currency.Code) ([]string, error)
	GetWithdrawalsHistory(ctx context.Context, code currency.Code, a asset.Item) ([]WithdrawalHistory, error)
	WithdrawCryptocurrencyFunds(ctx context.Context, withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error)
	WithdrawFiatFunds(ctx context.Context, withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error)
	WithdrawFiatFundsToInternationalBank(ctx context.Context, withdrawRequest *withdraw.Request) (*withdraw.ExchangeResponse, error)
	SetHTTPClientUserAgent(ua string) error
	GetHTTPClientUserAgent() (string, error)
	SetClientProxyAddress(addr string) error
	GetBase() *Base
	GetHistoricCandles(ctx context.Context, pair currency.Pair, a asset.Item, interval kline.Interval, start, end time.Time) (*kline.Item, error)
	GetHistoricCandlesExtended(ctx context.Context, pair currency.Pair, a asset.Item, interval kline.Interval, start, end time.Time) (*kline.Item, error)
	DisableRateLimiter() error
	EnableRateLimiter() error
	GetServerTime(ctx context.Context, ai asset.Item) (time.Time, error)
	GetWebsocket() (*stream.Websocket, error)
	SubscribeToWebsocketChannels(channels []subscription.Subscription) error
	UnsubscribeToWebsocketChannels(channels []subscription.Subscription) error
	GetSubscriptions() ([]subscription.Subscription, error)
	FlushWebsocketChannels() error
	AuthenticateWebsocket(ctx context.Context) error
	GetOrderExecutionLimits(a asset.Item, cp currency.Pair) (order.MinMaxLevel, error)
	CheckOrderExecutionLimits(a asset.Item, cp currency.Pair, price, amount float64, orderType order.Type) error
	UpdateOrderExecutionLimits(ctx context.Context, a asset.Item) error
	GetCredentials(ctx context.Context) (*account.Credentials, error)
	EnsureOnePairEnabled() error
	PrintEnabledPairs()
	IsVerbose() bool
	GetCurrencyTradeURL(ctx context.Context, a asset.Item, cp currency.Pair) (string, error)

	// ValidateAPICredentials function validates the API keys by sending an
	// authenticated REST request. See exchange specific wrapper implementation.
	ValidateAPICredentials(ctx context.Context, a asset.Item) error
	// VerifyAPICredentials determines if the credentials supplied have unset
	// required values. See exchanges/credentials.go Base method for
	// implementation.
	VerifyAPICredentials(creds *account.Credentials) error
	// GetDefaultCredentials returns the exchange.Base api credentials loaded by
	// config.json. See exchanges/credentials.go Base method for implementation.
	GetDefaultCredentials() *account.Credentials

	FunctionalityChecker
	AccountManagement
	OrderManagement
	CurrencyStateManagement
	FuturesManagement
	MarginManagement

	// MatchSymbolWithAvailablePairs returns a currency pair based on the supplied
	// symbol and asset type. If the string is expected to have a delimiter this
	// will attempt to screen it out.
	MatchSymbolWithAvailablePairs(symbol string, a asset.Item, hasDelimiter bool) (currency.Pair, error)
	// MatchSymbolCheckEnabled returns a currency pair based on the supplied symbol
	// and asset type against the available pairs list. If the string is expected to
	// have a delimiter this will attempt to screen it out. It will also check if
	// the pair is enabled.
	MatchSymbolCheckEnabled(symbol string, a asset.Item, hasDelimiter bool) (pair currency.Pair, enabled bool, err error)
	// IsPairEnabled checks if a pair is enabled for an enabled asset type
	IsPairEnabled(pair currency.Pair, a asset.Item) (bool, error)
}

IBotExchange enforces standard functions for all exchanges supported in GoCryptoTrader

type InternationalBankTransactionType 

type InternationalBankTransactionType uint8

InternationalBankTransactionType custom type for calculating fees based on fiat transaction types

type MarginCapabilities 

type MarginCapabilities struct {
	SetMarginType        bool
	ChangePositionMargin bool
	GetMarginRateHistory bool
}

MarginCapabilities stores the exchange's margin capabilities

type MarginManagement 

type MarginManagement interface {
	SetMarginType(ctx context.Context, item asset.Item, pair currency.Pair, tp margin.Type) error
	ChangePositionMargin(ctx context.Context, change *margin.PositionChangeRequest) (*margin.PositionChangeResponse, error)
	GetMarginRatesHistory(context.Context, *margin.RateHistoryRequest) (*margin.RateHistoryResponse, error)
	futures.PNLCalculation
	GetFuturesContractDetails(ctx context.Context, item asset.Item) ([]futures.Contract, error)
}

MarginManagement manages margin positions and rates

type OpenInterestSupport 

type OpenInterestSupport struct {
	Supported          bool
	SupportedViaTicker bool
	SupportsRestBatch  bool
}

OpenInterestSupport helps breakdown a feature and how it is supported

type OrderManagement 

type OrderManagement interface {
	SubmitOrder(ctx context.Context, s *order.Submit) (*order.SubmitResponse, error)
	SubmitOrders(ctx context.Context, ss ...*order.Submit) ([]*order.SubmitResponse, error)
	ModifyOrder(ctx context.Context, action *order.Modify) (*order.ModifyResponse, error)
	CancelOrder(ctx context.Context, o *order.Cancel) error
	CancelBatchOrders(ctx context.Context, o []order.Cancel) (*order.CancelBatchResponse, error)
	CancelAllOrders(ctx context.Context, orders *order.Cancel) (order.CancelAllResponse, error)
	GetOrderInfo(ctx context.Context, orderID string, pair currency.Pair, assetType asset.Item) (*order.Detail, error)
	GetActiveOrders(ctx context.Context, getOrdersRequest *order.MultiOrderRequest) (order.FilteredOrders, error)
	GetOrderHistory(ctx context.Context, getOrdersRequest *order.MultiOrderRequest) (order.FilteredOrders, error)
}

OrderManagement defines functionality for order management

type URL 

type URL uint16

URL stores uint conversions 

const (
	Invalid URL = iota
	RestSpot
	RestSpotSupplementary
	RestUSDTMargined
	RestCoinMargined
	RestFutures
	RestFuturesSupplementary
	RestUSDCMargined
	RestSwap
	RestSandbox
	WebsocketSpot
	WebsocketSpotSupplementary
	ChainAnalysis
	EdgeCase1
	EdgeCase2
	EdgeCase3
)

url lookup consts

func (URL) String 

func (u URL) String() string

type WithdrawalHistory 

type WithdrawalHistory struct {
	Status          string
	TransferID      string
	Description     string
	Timestamp       time.Time
	Currency        string
	Amount          float64
	Fee             float64
	TransferType    string
	CryptoToAddress string
	CryptoTxID      string
	CryptoChain     string
	BankTo          string
}

WithdrawalHistory holds exchange Withdrawal history data

Source Files

View all Source files

Directories

Path Synopsis
Package gemini exchange documentation can be found at https://docs.sandbox.gemini.com
 Package gemini exchange documentation can be found at https://docs.sandbox.gemini.com
buffer

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.