package bybit_connector import ( "bytes" "context" "crypto/hmac" "crypto/sha256" "encoding/hex" "encoding/json" "fmt" "github.com/wuhewuhe/bybit.go.api/handlers" "io" "log" "net/http" "os" "strconv" "time" ) type ServerResponse struct { RetCode int `json:"retCode"` RetMsg string `json:"retMsg"` Result interface{} `json:"result"` RetExtInfo struct{} `json:"retExtInfo"` Time int64 `json:"time"` } // Client define API client type Client struct { APIKey string APISecret string BaseURL string HTTPClient *http.Client Debug bool Logger *log.Logger do doFunc } type doFunc func(req *http.Request) (*http.Response, error) type ClientOption func(*Client) // WithDebug print more details in debug mode func WithDebug(debug bool) ClientOption { return func(c *Client) { c.Debug = debug } } // WithBaseURL is a client option to set the base URL of the Bybit HTTP client. func WithBaseURL(baseURL string) ClientOption { return func(c *Client) { c.BaseURL = baseURL } } func PrettyPrint(i interface{}) string { s, _ := json.MarshalIndent(i, "", "\t") return string(s) } func (c *Client) debug(format string, v ...interface{}) { if c.Debug { c.Logger.Printf(format, v...) } } // FormatTimestamp formats a time into Unix timestamp in milliseconds, as requested by Binance. func FormatTimestamp(t time.Time) int64 { return t.UnixNano() / int64(time.Millisecond) } func GetCurrentTime() int64 { now := time.Now() unixNano := now.UnixNano() timeStamp := unixNano / int64(time.Millisecond) return timeStamp } // NewBybitHttpClient NewClient Create client function for initialising new Bybit client func NewBybitHttpClient(apiKey string, APISecret string, options ...ClientOption) *Client { c := &Client{ APIKey: apiKey, APISecret: APISecret, BaseURL: MAINNET, HTTPClient: http.DefaultClient, Logger: log.New(os.Stderr, Name, log.LstdFlags), } // Apply the provided options for _, opt := range options { opt(c) } return c } func (c *Client) parseRequest(r *request, opts ...RequestOption) (err error) { // set request options from user for _, opt := range opts { opt(r) } err = r.validate() if err != nil { return err } fullURL := fmt.Sprintf("%s%s", c.BaseURL, r.endpoint) queryString := r.query.Encode() header := http.Header{} body := &bytes.Buffer{} if r.params != nil { body = bytes.NewBuffer(r.params) } if r.header != nil { header = r.header.Clone() } header.Set("User-Agent", fmt.Sprintf("%s/%s", Name, Version)) if r.secType == secTypeSigned { timeStamp := GetCurrentTime() header.Set(signTypeKey, "2") header.Set(apiRequestKey, c.APIKey) header.Set(timestampKey, strconv.FormatInt(timeStamp, 10)) if r.recvWindow == "" { r.recvWindow = "5000" } header.Set(recvWindowKey, r.recvWindow) var signatureBase []byte if r.method == "POST" { header.Set("Content-Type", "application/json") signatureBase = []byte(strconv.FormatInt(timeStamp, 10) + c.APIKey + r.recvWindow + string(r.params[:])) } else { signatureBase = []byte(strconv.FormatInt(timeStamp, 10) + c.APIKey + r.recvWindow + queryString) } hmac256 := hmac.New(sha256.New, []byte(c.APISecret)) hmac256.Write(signatureBase) signature := hex.EncodeToString(hmac256.Sum(nil)) header.Set(signatureKey, signature) } if queryString != "" { fullURL = fmt.Sprintf("%s?%s", fullURL, queryString) } c.debug("full url: %s, body: %s", fullURL, body) r.fullURL = fullURL r.body = body r.header = header return nil } func (c *Client) callAPI(ctx context.Context, r *request, opts ...RequestOption) (data []byte, err error) { err = c.parseRequest(r, opts...) req, err := http.NewRequest(r.method, r.fullURL, r.body) if err != nil { return []byte{}, err } req = req.WithContext(ctx) req.Header = r.header c.debug("request: %#v", req) f := c.do if f == nil { f = c.HTTPClient.Do } res, err := f(req) if err != nil { return []byte{}, err } data, err = io.ReadAll(res.Body) if err != nil { return []byte{}, err } defer func() { cerr := res.Body.Close() // Only overwrite the returned error if the original error was nil and an // error occurred while closing the body. if err == nil && cerr != nil { err = cerr } }() c.debug("response: %#v", res) c.debug("response body: %s", string(data)) c.debug("response status code: %d", res.StatusCode) if res.StatusCode >= http.StatusBadRequest { var ( apiErr = new(handlers.APIError) ) e := json.Unmarshal(data, apiErr) if e != nil { c.debug("failed to unmarshal json: %s", e) } return nil, apiErr } return data, nil } // NewMarketKlineService Market Endpoints func (c *Client) NewMarketKlineService(klineType, category, symbol, interval string) *Klines { return &Klines{ c: c, category: category, symbol: symbol, interval: interval, klineType: klineType, } } func (c *Client) NewMarketKLinesService(klineType string, params map[string]interface{}) *MarketClient { return &MarketClient{ c: c, klineType: klineType, params: params, } } func (c *Client) NewMarketInfoServiceNoParams() *MarketClient { return &MarketClient{ c: c, } } func (c *Client) NewMarketInfoService(params map[string]interface{}) *MarketClient { return &MarketClient{ c: c, params: params, } } // NewPlaceOrderService Trade Endpoints func (c *Client) NewPlaceOrderService(category, symbol, side, orderType, qty string) *Order { return &Order{ c: c, category: category, symbol: symbol, side: side, orderType: orderType, qty: qty, } } func (c *Client) NewTradeService(params map[string]interface{}) *TradeClient { return &TradeClient{ c: c, params: params, } } func (c *Client) NewPositionService(params map[string]interface{}) *PositionClient { return &PositionClient{ c: c, params: params, } } func (c *Client) NewPreUpgradeService(params map[string]interface{}) *PreUpgradeClient { return &PreUpgradeClient{ c: c, params: params, } } func (c *Client) NewAccountService(params map[string]interface{}) *AccountClient { return &AccountClient{ c: c, params: params, } } func (c *Client) NewAccountServiceNoParams() *AccountClient { return &AccountClient{ c: c, } } func (c *Client) NewAssetService(params map[string]interface{}) *AssetClient { return &AssetClient{ c: c, params: params, } } func (c *Client) NewUserService(params map[string]interface{}) *UserServiceClient { return &UserServiceClient{ c: c, params: params, } } func (c *Client) NewUserServiceNoParams() *UserServiceClient { return &UserServiceClient{ c: c, } } func (c *Client) NewBrokerService(params map[string]interface{}) *BrokerServiceClient { return &BrokerServiceClient{ c: c, params: params, } } func (c *Client) NewLendingService(params map[string]interface{}) *LendingServiceClient { return &LendingServiceClient{ c: c, params: params, } } func (c *Client) NewLendingServiceNoParams() *LendingServiceClient { return &LendingServiceClient{ c: c, } } func (c *Client) NewSpotLeverageService(params map[string]interface{}) *SpotLeverageClient { return &SpotLeverageClient{ c: c, params: params, } } func (c *Client) NewSpotMarginDataService(params map[string]interface{}, isUta bool) *SpotMarginClient { return &SpotMarginClient{ c: c, isUta: isUta, params: params, } }