cxtgo

type AccountAPI interface {
	// Balances returns the balances from the exchange
	Balances(ctx context.Context, params ...Params) (Balances, error)
	// MyTrades returns the trades made by that account
	MyTrades(ctx context.Context, params ...Params) ([]Trade, error)
	// FreeBalance returns the free balance in the account
	FreeBalance(ctx context.Context, params ...Params) (PartialBalances, error)
	// UsedBalance returns the used balance (in trade) in the account
	UsedBalance(ctx context.Context, params ...Params) (PartialBalances, error)
	// TotalBalance returns the total used + free balance in the account
	TotalBalance(ctx context.Context, params ...Params) (PartialBalances, error)
	// Currently unused
	Deposit(ctx context.Context, params ...Params) error
	// Currently unused
	Withdraw(ctx context.Context, params ...Params) error
}

type Ask Offer

type Balance struct {
	Asset string
	Free  float64
	Used  float64
	Total float64
}

type Balances map[string]Balance

type Base struct {
	ID           ExchangeID
	Name         ExchangeName
	Raw          bool
	Debug        bool
	DebugLog     io.Writer
	UserAgent    string
	BaseURL      string
	Proxy        string
	APIKEY       string
	APISecret    string
	Ratelimit    ratelimit.Limiter
	Market       MarketInfos
	CustomParams Params
}

type BaseOpt func(*Base)

type Bid Offer

type Currencies map[string]Currency

type Currency struct {
	ID   string
	Code string
}

type Error struct {
	// Exchange is the name of the exchange being used.
	Exchange ExchangeName
	// Op is the operation being performed, usually the name of the method
	Op Op
	// Kind is the class of error, as defined by the error kinds.
	// Other is used if its class is unknown or irrelevant.
	Kind ErrorKind
	// The underlying error that triggered this one, if any.
	Err error
}

type ErrorKind uint8

type Exchange interface {
	Info() Base

	PublicAPI
	AccountAPI
	OrderAPI
}

type ExchangeID string

type ExchangeName string

type MarketInfo struct {
	Symbol    Symbol
	ID        string
	Base      string
	Quote     string
	Active    bool
	Precision MarketPrecision
	Limits    MarketLimit
	Lot       float64
	Taker     float64
	Maker     float64
	Raw       []byte
}

type MarketInfos map[Symbol]MarketInfo

type MarketLimit struct {
	Amount MinMax
	Price  MinMax
	Cost   MinMax
}

type MarketPrecision struct {
	Base   int
	Quote  int
	Amount int
	Price  int
}

type MinMax struct {
	Min float64
	Max float64
}

type Offer struct {
	Price  float64
	Amount float64
}

type Op string

type Order struct {
	Symbol    Symbol
	ID        string
	Timestamp time.Time
	Status    OrderStatus
	Type      OrderType
	Price     float64
	Cost      float64
	Amount    float64
	Filled    float64
	Remaining float64
	Fee       float64
	Raw       []byte
}

type OrderAPI interface {
	// LimitOrder creates a limit order at the exchange.
	LimitOrder(ctx context.Context, symbol Symbol, side Side, offer Offer, params ...Params) error
	// MarketOrder creates an market order at the exchange.
	MarketOrder(ctx context.Context, symbol Symbol, side Side, amount float64, params ...Params) error
	// CancelOrder cancels the order for the given id.
	CancelOrder(ctx context.Context, ID string, symbol *Symbol, params ...Params) error
	// Order returns the order information for the given order id.
	Order(ctx context.Context, params ...Params) (Order, error)
	// Orders returns the order information for all the orders for that symbol.
	Orders(ctx context.Context, params ...Params) ([]Order, error)
	// OpenOrders is like orders but only returning orders which are open.
	OpenOrders(ctx context.Context, params ...Params) ([]Order, error)
	// ClosedOrders is like orders but only returning orders which are closed.
	ClosedOrders(ctx context.Context, params ...Params) ([]Order, error)
}

type OrderStatus uint8

type OrderType uint8

type Orderbook struct {
}

type OrderbookStreamer interface {
	StreamOrderbook(onUpdate func(s Summary), onError func(err error), opts ...StreamOpt) error
}

type Params map[string]interface{}

type PartialBalances map[string]float64

type PublicAPI interface {
	// Markets return the market information for an exchange.
	Markets(ctx context.Context, params ...Params) (MarketInfos, error)
	// Currencies return the currencies used by the exchange.
	Currencies(ctx context.Context, params ...Params) (Currencies, error)
	// Ticker returns the ticker information for a given symbol.
	Ticker(ctx context.Context, symbol Symbol, params ...Params) (Ticker, error)
	// Tickers returns all the ticker information for the given symbols.
	Tickers(ctx context.Context, symbols Symbols, params ...Params) (Tickers, error)
	// Orderbook returns order book information for a given symbol.
	OrderBook(ctx context.Context, symbol Symbol, params ...Params) (Orderbook, error)
	// OHLCV returns the Open high low close volume infromation for a symbol.
	OHLCV(ctx context.Context, params ...Params) error
	// Trades return all the trades for a given symbol.
	Trades(ctx context.Context, params ...Params) ([]Trade, error)
}

type Side uint8

type StreamConfig struct {
	Ctx       context.Context
	Symbol    Symbol
	Params    Params
	Reconnect bool
}

type StreamOpt func(*StreamConfig)

type StreamType int

type StreamingAPI interface {
	OrderbookStreamer
	TickerStreamer
	TradeStreamer
}

type Summary struct {
	Bids []Bid
	Asks []Ask
	// contains filtered or unexported fields
}

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

type Symbols []Symbol

type Ticker struct {
	Symbol      Symbol
	Ask         float64
	Bid         float64
	Basevolume  float64
	Quotevolume float64
	Average     float64
	Change      float64
	Open        float64
	Close       float64
	First       float64
	Last        float64
	High        float64
	Low         float64
	Percentage  float64
	Vwap        float64

	Datetime  time.Time
	Timestamp int64

	Raw []byte
}

type TickerStreamer interface {
	StreamTicker(onUpdate func(t Ticker), onError func(err error), opts ...StreamOpt) error
}

type Tickers map[Symbol]Tickers

type Trade struct {
}

type TradeStreamer interface {
	StreamTrades(onUpdate func(t Trade), onError func(err error), opts ...StreamOpt) error
}