bbgo_origin/pkg/exchange/max/maxapi/restapi.go

316 lines
8.0 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package max
import (
"context"
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"fmt"
"math"
"net"
"net/http"
"net/http/httputil"
"net/url"
"regexp"
"strings"
"sync/atomic"
"time"
"github.com/c9s/requestgen"
"github.com/pkg/errors"
log "github.com/sirupsen/logrus"
"github.com/c9s/bbgo/pkg/util"
"github.com/c9s/bbgo/pkg/version"
)
const (
// ProductionAPIURL is the official MAX API v2 Endpoint
ProductionAPIURL = "https://max-api.maicoin.com/api/v2"
UserAgent = "bbgo/" + version.Version
defaultHTTPTimeout = time.Second * 60
// 2018-09-01 08:00:00 +0800 CST
TimestampSince = 1535760000
)
var httpTransportMaxIdleConnsPerHost = http.DefaultMaxIdleConnsPerHost
var httpTransportMaxIdleConns = 100
var httpTransportIdleConnTimeout = 90 * time.Second
var disableUserAgentHeader = false
func init() {
if val, ok := util.GetEnvVarInt("HTTP_TRANSPORT_MAX_IDLE_CONNS_PER_HOST"); ok {
httpTransportMaxIdleConnsPerHost = val
}
if val, ok := util.GetEnvVarInt("HTTP_TRANSPORT_MAX_IDLE_CONNS"); ok {
httpTransportMaxIdleConns = val
}
if val, ok := util.GetEnvVarDuration("HTTP_TRANSPORT_IDLE_CONN_TIMEOUT"); ok {
httpTransportIdleConnTimeout = val
}
if val, ok := util.GetEnvVarBool("DISABLE_MAX_USER_AGENT_HEADER"); ok {
disableUserAgentHeader = val
}
}
var logger = log.WithField("exchange", "max")
var htmlTagPattern = regexp.MustCompile("<[/]?[a-zA-Z-]+.*?>")
// The following variables are used for nonce.
// timeOffset is used for nonce
var timeOffset int64 = 0
// serverTimestamp is used for storing the server timestamp, default to Now
var serverTimestamp = time.Now().Unix()
// reqCount is used for nonce, this variable counts the API request count.
var reqCount int64 = 1
// create an isolated http httpTransport rather than the default one
var httpTransport = &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 10 * time.Second,
KeepAlive: 30 * time.Second,
}).DialContext,
// ForceAttemptHTTP2: true,
// DisableCompression: false,
MaxIdleConns: httpTransportMaxIdleConns,
MaxIdleConnsPerHost: httpTransportMaxIdleConnsPerHost,
IdleConnTimeout: httpTransportIdleConnTimeout,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
var defaultHttpClient = &http.Client{
Timeout: defaultHTTPTimeout,
Transport: httpTransport,
}
type RestClient struct {
requestgen.BaseAPIClient
APIKey, APISecret string
AccountService *AccountService
PublicService *PublicService
TradeService *TradeService
OrderService *OrderService
RewardService *RewardService
WithdrawalService *WithdrawalService
}
func NewRestClient(baseURL string) *RestClient {
u, err := url.Parse(baseURL)
if err != nil {
panic(err)
}
var client = &RestClient{
BaseAPIClient: requestgen.BaseAPIClient{
HttpClient: defaultHttpClient,
BaseURL: u,
},
}
client.AccountService = &AccountService{client}
client.TradeService = &TradeService{client}
client.PublicService = &PublicService{client}
client.OrderService = &OrderService{client}
client.RewardService = &RewardService{client}
client.WithdrawalService = &WithdrawalService{client}
// defaultHttpClient.MaxTokenService = &MaxTokenService{defaultHttpClient}
client.initNonce()
return client
}
// Auth sets api key and secret for usage is requests that requires authentication.
func (c *RestClient) Auth(key string, secret string) *RestClient {
// pragma: allowlist nextline secret
c.APIKey = key
// pragma: allowlist nextline secret
c.APISecret = secret
return c
}
func (c *RestClient) initNonce() {
var clientTime = time.Now()
var err error
serverTimestamp, err = c.PublicService.Timestamp()
if err != nil {
logger.WithError(err).Panic("failed to sync timestamp with max")
}
timeOffset = serverTimestamp - clientTime.Unix()
logger.Infof("loaded max server timestamp: %d offset=%d", serverTimestamp, timeOffset)
}
func (c *RestClient) getNonce() int64 {
// nonce 是以正整數表示的時間戳記,代表了從 Unix epoch 到當前時間所經過的毫秒數(ms)。
// nonce 與伺服器的時間差不得超過正負30秒每個 nonce 只能使用一次。
var seconds = time.Now().Unix()
var rc = atomic.AddInt64(&reqCount, 1)
return (seconds+timeOffset)*1000 - 1 + int64(math.Mod(float64(rc), 1000.0))
}
func (c *RestClient) NewAuthenticatedRequest(ctx context.Context, m string, refURL string, params url.Values, payload interface{}) (*http.Request, error) {
return c.newAuthenticatedRequest(ctx, m, refURL, params, payload, nil)
}
// newAuthenticatedRequest creates new http request for authenticated routes.
func (c *RestClient) newAuthenticatedRequest(ctx context.Context, m string, refURL string, params url.Values, data interface{}, rel *url.URL) (*http.Request, error) {
if len(c.APIKey) == 0 {
return nil, errors.New("empty api key")
}
if len(c.APISecret) == 0 {
return nil, errors.New("empty api secret")
}
var err error
if rel == nil {
rel, err = url.Parse(refURL)
if err != nil {
return nil, err
}
}
var p []byte
var payload = map[string]interface{}{
"nonce": c.getNonce(),
"path": c.BaseURL.ResolveReference(rel).Path,
}
switch d := data.(type) {
case map[string]interface{}:
for k, v := range d {
payload[k] = v
}
}
for k, vs := range params {
k = strings.TrimSuffix(k, "[]")
if len(vs) == 1 {
payload[k] = vs[0]
} else {
payload[k] = vs
}
}
p, err = castPayload(payload)
if err != nil {
return nil, err
}
req, err := c.NewRequest(ctx, m, refURL, params, p)
if err != nil {
return nil, err
}
encoded := base64.StdEncoding.EncodeToString(p)
req.Header.Add("Content-Type", "application/json")
req.Header.Add("X-MAX-ACCESSKEY", c.APIKey)
req.Header.Add("X-MAX-PAYLOAD", encoded)
req.Header.Add("X-MAX-SIGNATURE", signPayload(encoded, c.APISecret))
if disableUserAgentHeader {
req.Header.Set("USER-AGENT", "")
} else {
req.Header.Set("USER-AGENT", UserAgent)
}
if false {
out, _ := httputil.DumpRequestOut(req, true)
fmt.Println(string(out))
}
return req, nil
}
// ErrorResponse is the custom error type that is returned if the API returns an
// error.
type ErrorField struct {
Code int `json:"code"`
Message string `json:"message"`
}
type ErrorResponse struct {
*requestgen.Response
Err ErrorField `json:"error"`
}
func (r *ErrorResponse) Error() string {
return fmt.Sprintf("%s %s: %d %d %s",
r.Response.Response.Request.Method,
r.Response.Response.Request.URL.String(),
r.Response.Response.StatusCode,
r.Err.Code,
r.Err.Message,
)
}
// ToErrorResponse tries to convert/parse the server response to the standard Error interface object
func ToErrorResponse(response *requestgen.Response) (errorResponse *ErrorResponse, err error) {
errorResponse = &ErrorResponse{Response: response}
contentType := response.Header.Get("content-type")
switch contentType {
case "text/json", "application/json", "application/json; charset=utf-8":
var err = response.DecodeJSON(errorResponse)
if err != nil {
return errorResponse, errors.Wrapf(err, "failed to decode json for response: %d %s", response.StatusCode, string(response.Body))
}
return errorResponse, nil
case "text/html":
// convert 5xx error from the HTML page to the ErrorResponse
errorResponse.Err.Message = htmlTagPattern.ReplaceAllLiteralString(string(response.Body), "")
return errorResponse, nil
case "text/plain":
errorResponse.Err.Message = string(response.Body)
return errorResponse, nil
}
return errorResponse, fmt.Errorf("unexpected response content type %s", contentType)
}
func castPayload(payload interface{}) ([]byte, error) {
if payload == nil {
return nil, nil
}
switch v := payload.(type) {
case string:
return []byte(v), nil
case []byte:
return v, nil
}
body, err := json.Marshal(payload)
return body, err
}
func signPayload(payload string, secret string) string {
var sig = hmac.New(sha256.New, []byte(secret))
_, err := sig.Write([]byte(payload))
if err != nil {
return ""
}
return hex.EncodeToString(sig.Sum(nil))
}