goghostex

type APIConfig struct {
	HttpClient    *http.Client
	LastTimestamp int64
	Endpoint      string
	ApiKey        string
	ApiSecretKey  string
	ApiPassphrase string //for okex.com v3 api
	ClientId      string //for bitstamp.net , huobi.pro
	Location      *time.Location
}

type Account struct {
	Exchange    string
	Asset       float64 //总资产
	NetAsset    float64 //净资产
	SubAccounts map[string]SubAccount
}

type Currency struct {
	Symbol string `json:"symbol"`
	Desc   string `json:"-"`
}

type Depth struct {
	Pair      Pair
	Timestamp int64
	Sequence  int64 // The increasing sequence, cause the http return sequence is not sure.
	Date      string
	AskList   DepthRecords // Ascending order
	BidList   DepthRecords // Descending order
}

type DepthRecord struct {
	Price  float64
	Amount float64
}

type DepthRecords []DepthRecord

type Error interface {
	error
	Code() int
}

type FutureAPIConfig struct {
	APIConfig
	Lever int // lever number , for future
}

type FutureAccount struct {
	SubAccount map[Currency]FutureSubAccount
	Exchange   string
}

type FutureAccountItem struct {
	Pair         Pair
	ContractName string
	Exchange     string
	Subject      string

	SettleMode     int64 // 1: basis 2: counter
	SettleCurrency Currency
	Amount         float64
	Timestamp      int64
	DateTime       string
	Info           string
}

type FutureCandle struct {
	Symbol       string  `json:"symbol"`
	Exchange     string  `json:"exchange"`
	Timestamp    int64   `json:"timestamp"`
	Date         string  `json:"date"`
	Open         float64 `json:"open"`
	Close        float64 `json:"close"`
	High         float64 `json:"high"`
	Low          float64 `json:"low"`
	Vol          float64 `json:"vol"`   // BASE 成交量
	Vol2         float64 `json:"vol_2"` // 张数 OR COUNT 成交量
	Type         string  `json:"type"`
	DueTimestamp int64   `json:"due_timestamp"`
	DueDate      string  `json:"due_date"`
}

type FutureContract struct {
	Pair         Pair   `json:"-"`
	Symbol       string `json:"symbol"`
	Exchange     string `json:"exchange"`
	ContractType string `json:"contract_type"` // eg: this_week next_week quarter next_quarter
	ContractName string `json:"contract_name"` // eg: BTC-USD-201025
	SettleMode   int64  `json:"settle_mode"`   // 1: BASIS 2: COUNTER
	Status       string `json:"status"`
	Type         string `json:"type"` // linear or inverse

	OpenTimestamp int64  `json:"open_timestamp"`
	OpenDate      string `json:"open_date"`
	ListTimestamp int64  `json:"list_timestamp"`
	ListDate      string `json:"list_date"`
	DueTimestamp  int64  `json:"due_timestamp"`
	DueDate       string `json:"due_date"`

	UnitAmount      float64 `json:"unit_amount"`
	TickSize        float64 `json:"tick_size"`
	PricePrecision  int64   `json:"price_precision"`
	AmountPrecision int64   `json:"amount_precision"`

	MaxScalePriceLimit float64 `json:"max_scale_price_limit"`
	MinScalePriceLimit float64 `json:"min_scale_price_limit"`

	RawData string `json:"raw_data"`
}

type FutureContracts struct {
	ContractTypeKV map[string]*FutureContract `json:"contract_type_kv"`
	ContractNameKV map[string]*FutureContract `json:"contract_name_kv"`
	DueTimestampKV map[string]*FutureContract `json:"due_timestamp_kv"`
}

type FutureDepth struct {
	ContractType string // for future
	ContractName string // for future
	Pair         Pair
	Timestamp    int64
	DueTimestamp int64
	// The increasing sequence, cause the http return sequence is not sure.
	Sequence int64
	Date     string
	AskList  DepthRecords // Ascending order
	BidList  DepthRecords // Descending order
}

type FutureKline struct {
	Kline        `json:",-"` // 按照kline中的字段进行解析。
	ContractType string      `json:"contract_type"`
	DueTimestamp int64       `json:"due_timestamp"`
	DueDate      string      `json:"due_date"`
	Vol2         float64     `json:"vol_2"` //个数
}

type FutureOrder struct {
	// cid is important, when the order api return wrong, you can find it in unfinished api
	Cid            string
	OrderId        string
	Price          float64
	Amount         int64
	AvgPrice       float64
	DealAmount     int64
	PlaceTimestamp int64
	PlaceDatetime  string
	DealTimestamp  int64 // unit: ms
	DealDatetime   string
	Status         TradeStatus
	PlaceType      PlaceType  // place order type 0：NORMAL 1：MAKER_ONLY 2：FOK 3：IOC
	Type           FutureType // type 1：OPEN_LONG 2：OPEN_SHORT 3：LIQUIDATE_LONG 4： LIQUIDATE_SHORT
	LeverRate      int64
	Fee            float64
	Pair           Pair
	ContractType   string
	ContractName   string // for future
	Exchange       string
}

type FuturePosition struct {
	BuyAmount           float64
	BuyAvailable        float64
	BuyPriceAvg         float64
	BuyPriceCost        float64
	BuyProfitReal       float64
	CreateDate          int64
	LeverRate           int
	SellAmount          float64
	SellAvailable       float64
	SellPriceAvg        float64
	SellPriceCost       float64
	SellProfitReal      float64
	Symbol              Pair //btc_usd:比特币,ltc_usd:莱特币
	ContractType        string
	ContractId          int64
	ForceLiquidatePrice float64 //预估爆仓价
}

type FutureRestAPI interface {

	// public api
	GetExchangeName() string
	GetContract(pair Pair, contractType string) (*FutureContract, error)
	GetTicker(pair Pair, contractType string) (*FutureTicker, []byte, error)
	GetDepth(pair Pair, contractType string, size int) (*FutureDepth, []byte, error)
	GetLimit(pair Pair, contractType string) (float64, float64, error)
	GetIndex(pair Pair) (float64, []byte, error)
	GetMark(pair Pair, contractType string) (float64, []byte, error)
	GetKlineRecords(contractType string, pair Pair, period, size, since int) ([]*FutureKline, []byte, error)
	GetTrades(pair Pair, contractType string) ([]*Trade, []byte, error)

	// private api
	GetAccount() (*FutureAccount, []byte, error)
	PlaceOrder(order *FutureOrder) ([]byte, error)
	CancelOrder(order *FutureOrder) ([]byte, error)
	GetOrders(pair Pair, contractType string) ([]*FutureOrder, []byte, error)
	GetOrder(order *FutureOrder) ([]byte, error)
	GetPairFlow(pair Pair) ([]*FutureAccountItem, []byte, error)

	// util api
	KeepAlive()
}

type FutureRule struct {
	Rule        `json:",-"` // 按照Rule里面的规则进行。
	ContractVal float64     `json:"contract_val"` //合约一手价格
}

type FutureSubAccount struct {
	Currency Currency
	// The future margin 期货保证金 == marginFilled+ marginUnFilled
	Margin float64
	// The future is filled 已经成交的订单占用的期货保证金
	MarginDealed float64
	// The future is unfilled 未成交的订单占用的保证金
	MarginUnDealed float64
	// 保证金率
	MarginRate float64
	// 总值
	BalanceTotal float64
	// 净值
	// BalanceNet = BalanceTotal + ProfitUnreal + ProfitReal
	BalanceNet float64
	// 可提取
	// BalanceAvail = BalanceNet - Margin
	BalanceAvail float64
	//已实现盈亏
	ProfitReal float64
	// 未实现盈亏
	ProfitUnreal float64
}

type FutureTicker struct {
	Ticker
	ContractType string `json:"contract_type"`
	ContractName string `json:"contract_name"`
}

type FutureType int64

type FutureWebsocketAPI interface {
	Subscribe(v interface{})

	Unsubscribe(v interface{})

	Start() error

	Stop()

	Restart()
}

type Kline struct {
	Pair      Pair    `json:"symbol"`
	Exchange  string  `json:"exchange"`
	Timestamp int64   `json:"timestamp"`
	Date      string  `json:"date"`
	Open      float64 `json:"open"`
	Close     float64 `json:"close"`
	High      float64 `json:"high"`
	Low       float64 `json:"low"`
	Vol       float64 `json:"vol"`
}

type Loan struct {
	Pair              Pair       // The loan currency pair
	Currency          Currency   // Currency
	Amount            float64    // Loan amount
	AmountLoaned      float64    // Loaned amount
	AmountInterest    float64    // Loan interest
	Status            LoanStatus // The loan record status
	LoanId            string     // Remote loan record id
	LoanTimestamp     int64      // Loan timestamp
	LoanDate          string     // Loan date
	RepayId           string     // Remote loan record repay id
	RepayTimestamp    int64      // Repay Timestamp
	RepayDate         string     // Repay Date
	RepayDeadlineDate string     // Repay Deadline Date
}

type LoanStatus int

type MarginAccount struct {
	Pair       Pair
	SubAccount map[string]MarginSubAccount

	LiquidationPrice float64 //预计爆仓价格
	RiskRate         float64
	MarginRatio      float64
}

type MarginRestAPI interface {
	// public api
	GetTicker(pair Pair) (*Ticker, []byte, error)
	GetDepth(pair Pair, size int) (*Depth, []byte, error)
	GetKlineRecords(pair Pair, period, size, since int) ([]*Kline, []byte, error)
	GetExchangeName() string

	// private api
	GetAccount(pair Pair) (*MarginAccount, []byte, error)
	PlaceOrder(order *Order) ([]byte, error)
	CancelOrder(order *Order) ([]byte, error)
	GetOrder(order *Order) ([]byte, error)
	GetOrders(pair Pair) ([]*Order, []byte, error) // all orders desc recently
	GetUnFinishOrders(pair Pair) ([]*Order, []byte, error)
	PlaceLoan(loan *Loan) ([]byte, error)
	GetLoan(loan *Loan) ([]byte, error)
	ReturnLoan(loan *Loan) ([]byte, error)

	// util api
	KeepAlive()
}

type MarginSubAccount struct {
	Currency Currency
	// Amount = AmountNet + AmountLoaned = AmountAvail + AmountFrozen
	Amount float64
	// 可用额度
	AmountAvail float64
	// 冻结额度
	AmountFrozen float64
	// 净值额度
	AmountNet float64
	// 已借贷额度
	AmountLoaned float64
	// 当前借贷费用
	LoaningFee float64
}

type OHLC struct {
	Symbol    string  `json:"symbol"`
	Exchange  string  `json:"exchange"`
	Timestamp int64   `json:"timestamp"`
	Date      string  `json:"date"`
	Open      float64 `json:"open"`
	Close     float64 `json:"close"`
	High      float64 `json:"high"`
	Low       float64 `json:"low"`
	Vol       float64 `json:"vol"`
}

type Order struct {
	// cid is important, when the order api return wrong, you can find it in unfinished api
	Cid            string
	Price          float64
	Amount         float64
	AvgPrice       float64
	DealAmount     float64
	Fee            float64
	OrderId        string
	OrderTimestamp int64
	OrderDate      string
	Status         TradeStatus
	Pair           Pair
	Side           TradeSide
	//0:NORMAL,1:ONLY_MAKER,2:FOK,3:IOC
	OrderType PlaceType
}

type Pair struct {
	//The target currency, you want to buy or long
	//目标货币，你想买或者做多的。
	Basis Currency
	//The counter currency, you use it to buy or to mortgage
	//计数货币，你想用它来购买或者用它来做为抵押物。
	Counter Currency
}

type PlaceType int

type Rule struct {
	Pair    Pair
	Base    Currency
	Counter Currency

	BaseMinSize      float64
	BasePrecision    int
	CounterPrecision int
}

type SpotRestAPI interface {

	// public api
	GetExchangeName() string
	//GetExchangeRule(pair Pair) (*Rule, []byte, error)
	GetTicker(pair Pair) (*Ticker, []byte, error)
	GetDepth(pair Pair, size int) (*Depth, []byte, error)
	GetKlineRecords(pair Pair, period, size, since int) ([]*Kline, []byte, error)
	GetTrades(pair Pair, since int64) ([]*Trade, error)

	// private api
	GetAccount() (*Account, []byte, error)
	PlaceOrder(order *Order) ([]byte, error)
	CancelOrder(order *Order) ([]byte, error)
	GetOrder(order *Order) ([]byte, error)
	GetOrders(pair Pair) ([]*Order, error) // dealed orders
	GetUnFinishOrders(pair Pair) ([]*Order, []byte, error)

	// util api
	KeepAlive()

	// v2 API
	GetOHLCs(symbol string, period, size, since int) ([]*OHLC, []byte, error)
}

type SubAccount struct {
	Currency     Currency
	Amount       float64
	AmountFrozen float64
}

type SwapAccount struct {
	Exchange string
	// In swap, the usdt is default.
	Currency Currency
	// The future margin 期货保证金 == marginFilled+ marginUnFilled
	Margin float64
	// The future is filled 已经成交的订单占用的期货保证金
	MarginPosition float64
	// The future is unfilled 未成交的订单占用的保证金
	MarginOpen float64
	// 保证金率
	MarginRate float64
	// 总值
	BalanceTotal float64
	// 净值
	// BalanceNet = BalanceTotal + ProfitUnreal + ProfitReal
	BalanceNet float64
	// 可提取
	// BalanceAvail = BalanceNet - Margin
	BalanceAvail float64
	//已实现盈亏
	ProfitReal float64
	// 未实现盈亏
	ProfitUnreal float64

	Positions []*SwapPosition
}

type SwapAccountItem struct {
	Pair     Pair
	Exchange string
	Subject  string
	Id       string

	SettleMode     int64 // 1: basis 2: counter
	SettleCurrency Currency
	Amount         float64
	Timestamp      int64
	DateTime       string
	Info           string
}

type SwapContract struct {
	Pair         Pair   `json:"-"`
	Symbol       string `json:"symbol"`
	Exchange     string `json:"exchange"`
	ContractName string `json:"contract_name"` // 标准contract_name和具体交易所无关，以ok的规则为准。
	SettleMode   int64  `json:"settle_mode"`   // 1: BASIS 币本位 2: COUNTER U本位

	UnitAmount      float64 `json:"unit_amount"`
	TickSize        float64 `json:"tick_size"`
	PricePrecision  int64   `json:"price_precision"`
	AmountPrecision int64   `json:"amount_precision"`
}

type SwapContracts struct {
	// 按照合约到期日期查找，以ok的命名规则为准吧 BTC-USD-SWAP BTC-USDT-SWAP
	ContractNameKV map[string]*SwapContract `json:"contract_name_kv"`
}

type SwapDepth struct {
	Pair      Pair
	Timestamp int64
	Sequence  int64 // The increasing sequence, cause the http return sequence is not sure.
	Date      string
	AskList   DepthRecords // Ascending order
	BidList   DepthRecords // Descending order
}

type SwapKline struct {
	Pair      Pair    `json:"-"`
	Exchange  string  `json:"exchange"`
	Timestamp int64   `json:"timestamp"`
	Date      string  `json:"date"`
	Open      float64 `json:"open"`
	Close     float64 `json:"close"`
	High      float64 `json:"high"`
	Low       float64 `json:"low"`
	Vol       float64 `json:"vol"`
}

type SwapOrder struct {
	// cid is important, when the order api return wrong, you can find it in unfinished api
	Cid            string
	OrderId        string
	Price          float64
	Amount         float64
	AvgPrice       float64
	DealAmount     float64
	PlaceTimestamp int64
	PlaceDatetime  string
	DealTimestamp  int64 // unit: ms
	DealDatetime   string
	Status         TradeStatus
	PlaceType      PlaceType  // place_type 0：NORMAL 1：MAKER_ONLY 2：FOK 3：IOC
	Type           FutureType // type 1：OPEN_LONG 2：OPEN_SHORT 3：LIQUIDATE_LONG 4： LIQUIDATE_SHORT
	MarginType     string     // margin_type 全仓：crossed 逐仓：isolated
	LeverRate      int64
	Fee            float64
	Pair           Pair
	Exchange       string
}

type SwapPosition struct {
	Pair           Pair
	Type           FutureType //open_long or open_short
	Amount         float64    // position amount
	Price          float64    // position price
	MarkPrice      float64
	LiquidatePrice float64
	MarginType     string
	MarginAmount   float64
	Leverage       int64
}

type SwapRestAPI interface {
	// public api
	GetExchangeName() string
	GetTicker(pair Pair) (*SwapTicker, []byte, error)
	GetDepth(pair Pair, size int) (*SwapDepth, []byte, error)
	GetContract(pair Pair) *SwapContract
	GetLimit(pair Pair) (float64, float64, error)
	GetKline(pair Pair, period, size, since int) ([]*SwapKline, []byte, error)
	GetOpenAmount(pair Pair) (float64, int64, []byte, error)
	GetFundingFees(pair Pair) ([][]interface{}, []byte, error)
	GetFundingFee(pair Pair) (float64, error)

	// private api
	GetAccount() (*SwapAccount, []byte, error)
	PlaceOrder(order *SwapOrder) ([]byte, error)
	CancelOrder(order *SwapOrder) ([]byte, error)
	GetOrder(order *SwapOrder) ([]byte, error)
	GetOrders(pair Pair) ([]*SwapOrder, []byte, error)
	GetUnFinishOrders(pair Pair) ([]*SwapOrder, []byte, error)
	GetPosition(pair Pair, openType FutureType) (*SwapPosition, []byte, error)
	AddMargin(pair Pair, openType FutureType, marginAmount float64) ([]byte, error)
	ReduceMargin(pair Pair, openType FutureType, marginAmount float64) ([]byte, error)
	GetAccountFlow() ([]*SwapAccountItem, []byte, error)
	GetPairFlow(pair Pair) ([]*SwapAccountItem, []byte, error)

	// util api
	KeepAlive()
}

type SwapTicker struct {
	Pair      Pair    `json:"-"`
	Last      float64 `json:"last"`
	Buy       float64 `json:"buy"`
	Sell      float64 `json:"sell"`
	High      float64 `json:"high"`
	Low       float64 `json:"low"`
	Vol       float64 `json:"vol"`
	Timestamp int64   `json:"timestamp"` // unit:ms
	Date      string  `json:"date"`      // date: format yyyy-mm-dd HH:MM:SS, the timezone define in apiconfig
}

type Ticker struct {
	Pair      Pair    `json:"-"`
	Last      float64 `json:"last"`
	Buy       float64 `json:"buy"`
	Sell      float64 `json:"sell"`
	High      float64 `json:"high"`
	Low       float64 `json:"low"`
	Vol       float64 `json:"vol"`
	Timestamp int64   `json:"timestamp"` // unit:ms
	Date      string  `json:"date"`      // date: format yyyy-mm-dd HH:MM:SS, the timezone define in apiconfig
}

type Trade struct {
	Tid       int64     `json:"tid"`
	Type      TradeSide `json:"type"`
	Amount    float64   `json:"amount,string"`
	Price     float64   `json:"price,string"`
	Timestamp int64     `json:"timestamp"`
	Pair      Pair      `json:"-"`
}

type TradeSide int64

type TradeStatus int64

type WSRestartError struct {
	//Code int
	Msg string
}

type WSStopError struct {
	//Code int
	Msg string
}

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

type WsConfig struct {
	WsUrl                 string              // websocket server url, necessary
	ProxyUrl              string              // proxy url, not necessary
	ReqHeaders            map[string][]string // set the head info ,when connecting, not necessary
	HeartbeatIntervalTime time.Duration       // the heartbeat interval, necessary
	HeartbeatData         []byte              // the raw text of heartbeat data for example: ping, necessary if heartbeatfunc is nil
	HeartbeatDataType     int

	//HeartbeatFunc         func() interface{}           // the json text of heartbeat data , necessary if heartbeatdata is nil
	ReconnectIntervalTime time.Duration                // force reconnect on XXX time duration, not necessary
	ProtoHandleFunc       func([]byte) error           // the message handle func, necessary
	UnCompressFunc        func([]byte) ([]byte, error) // the uncompress func, not necessary
	ErrorHandleFunc       func(err error)              // the error handle func, not necessary
	IsDump                bool                         // is print the connect info, not necessary
}

type WsConn struct {
	*websocket.Conn
	sync.Mutex
	WsConfig
	// contains filtered or unexported fields
}