bitget-api 2.3.6 → 3.0.0

package/dist/mjs/types/websockets/ws-api-request.d.ts

@@ -0,0 +1,20 @@
+export interface WSAPIPlaceOrderRequestV3 {
+    symbol: string;
+    orderType: 'limit' | 'market';
+    qty: string;
+    price?: string;
+    side: 'buy' | 'sell';
+    posSide?: 'long' | 'short';
+    timeInForce?: 'gtc' | 'ioc' | 'fok' | 'post_only';
+    reduceOnly?: 'YES' | 'NO';
+    clientOid?: string;
+    stpMode?: 'none' | 'cancel_taker' | 'cancel_maker' | 'cancel_both';
+    tpTriggerBy?: 'market' | 'mark';
+    slTriggerBy?: 'market' | 'mark';
+    takeProfit?: string;
+    stopLoss?: string;
+    tpOrderType?: 'limit' | 'market';
+    slOrderType?: 'limit' | 'market';
+    tpLimitPrice?: string;
+    slLimitPrice?: string;
+}

package/dist/mjs/types/websockets/ws-api-request.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ws-api-request.js.map

package/dist/mjs/types/websockets/ws-api-request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-api-request.js","sourceRoot":"","sources":["../../../../src/types/websockets/ws-api-request.ts"],"names":[],"mappings":""}

package/dist/mjs/types/websockets/ws-api-response.d.ts

@@ -0,0 +1,6 @@
+export interface WSAPIPlaceOrderResponseV3 {
+    symbol: string;
+    orderId: string;
+    clientOid: string;
+    cTime: string;
+}

package/dist/mjs/types/websockets/ws-api-response.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ws-api-response.js.map

package/dist/mjs/types/websockets/ws-api-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-api-response.js","sourceRoot":"","sources":["../../../../src/types/websockets/ws-api-response.ts"],"names":[],"mappings":""}

package/dist/mjs/types/websockets/ws-api.d.ts

@@ -0,0 +1,91 @@
+import { WS_KEY_MAP } from '../../util/websocket-util.js';
+import { CancelOrderRequestV3 } from '../request/v3/trade.js';
+import { CancelOrderResponseV3 } from '../response/v3/trade.js';
+import { WSAPIPlaceOrderRequestV3 } from './ws-api-request.js';
+import { WSAPIPlaceOrderResponseV3 } from './ws-api-response.js';
+import { BitgetInstTypeV3, WsKey } from './ws-general.js';
+export type WSOperation = 'subscribe' | 'unsubscribe' | 'login';
+export type WSAPIOperation = 'place-order' | 'batch-place' | 'cancel-order' | 'batch-cancel';
+export declare const WS_API_Operations: WSAPIOperation[];
+export interface WSOperationLoginParams {
+    apiKey: string;
+    passphrase: string;
+    timestamp: number;
+    sign: string;
+}
+export interface WSAPIRequestBitgetV3<TWSParams> {
+    op: 'trade';
+    id: string;
+    category: BitgetInstTypeV3;
+    topic: WSAPIOperation;
+    args: TWSParams | TWSParams[];
+}
+export interface WSAPIRequestFlags {
+    /** If true, will skip auth requirement for WS API connection */
+    authIsOptional?: boolean | undefined;
+}
+export type Exact<T> = {
+    [K: string]: never;
+} & {
+    [K in keyof T]: T[K];
+};
+/**
+
+/**
+ * V2 request looks like this:
+{
+  "op":"subscribe",
+  "args":[
+      {
+          "instType":"SPOT",
+          "channel":"ticker",
+          "instId":"BTCUSDT"
+      },
+      {
+          "instType":"SPOT",
+          "channel":"candle5m",
+          "instId":"BTCUSDT"
+      }
+  ]
+}
+ */
+export interface WsRequestOperationBitget<TWSRequestArg> {
+    op: WSOperation;
+    args?: (TWSRequestArg | string | number)[];
+}
+export interface WSAPIResponse<TResponseData extends object = object, TOperation extends WSAPIOperation = WSAPIOperation> {
+    wsKey: WsKey;
+    /** Auto-generated */
+    id: string;
+    event: 'trade';
+    category: BitgetInstTypeV3;
+    topic: TOperation;
+    args: TResponseData;
+    code: '0' | string;
+    msg: 'success' | string;
+    ts: string;
+}
+/**
+ * List of operations supported for this WsKey (connection)
+ */
+export interface WsAPIWsKeyTopicMap {
+    [WS_KEY_MAP.v3Private]: WSAPIOperation;
+}
+/**
+ * Request parameters expected per operation
+ */
+export interface WsAPITopicRequestParamMap {
+    'place-order': WSAPIPlaceOrderRequestV3;
+    'batch-place': WSAPIPlaceOrderRequestV3[];
+    'cancel-order': CancelOrderRequestV3;
+    'batch-cancel': CancelOrderRequestV3[];
+}
+/**
+ * Response structure expected for each operation
+ */
+export interface WsAPIOperationResponseMap {
+    'place-order': WSAPIResponse<[WSAPIPlaceOrderResponseV3], 'place-order'>;
+    'batch-place': WSAPIResponse<WSAPIPlaceOrderResponseV3[], 'batch-place'>;
+    'cancel-order': WSAPIResponse<[CancelOrderResponseV3], 'cancel-order'>;
+    'batch-cancel': WSAPIResponse<CancelOrderResponseV3[], 'batch-cancel'>;
+}

package/dist/mjs/types/websockets/ws-api.js

@@ -0,0 +1,8 @@
+import { WS_KEY_MAP } from '../../util/websocket-util.js';
+export const WS_API_Operations = [
+    'place-order',
+    'batch-place',
+    'cancel-order',
+    'batch-cancel',
+];
+//# sourceMappingURL=ws-api.js.map

package/dist/mjs/types/websockets/ws-api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-api.js","sourceRoot":"","sources":["../../../../src/types/websockets/ws-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAgB1D,MAAM,CAAC,MAAM,iBAAiB,GAAqB;IACjD,aAAa;IACb,aAAa;IACb,cAAc;IACd,cAAc;CACf,CAAC"}

package/dist/mjs/types/websockets/ws-events.d.ts

@@ -0,0 +1,81 @@
+export interface MessageEventLike {
+    target: WebSocket;
+    type: 'message';
+    data: string;
+}
+export declare function isMessageEvent(msg: unknown): msg is MessageEventLike;
+export interface WsBaseEvent<TAction = 'snapshot' | string, TData = unknown> {
+    action: TAction;
+    arg: unknown;
+    data: TData[];
+}
+export interface WsSnapshotChannelEvent extends WsBaseEvent<'snapshot'> {
+    arg: {
+        instType: string;
+        channel: string;
+        instId: string;
+    };
+}
+export interface WsSnapshotAccountEvent extends WsBaseEvent<'snapshot'> {
+    arg: {
+        instType: string;
+        channel: 'account';
+        instId: string;
+    };
+}
+export interface WsSnapshotPositionsEvent extends WsBaseEvent<'snapshot'> {
+    arg: {
+        instType: string;
+        channel: 'positions';
+        instId: string;
+    };
+}
+export interface WsAccountSnapshotDataUMCBL {
+    marginCoin: string;
+    locked: string;
+    available: string;
+    maxOpenPosAvailable: string;
+    maxTransferOut: string;
+    equity: string;
+    usdtEquity: string;
+}
+export interface WsAccountSnapshotUMCBL extends WsBaseEvent<'snapshot'> {
+    arg: {
+        instType: 'umcbl';
+        channel: 'account';
+        instId: string;
+    };
+    data: WsAccountSnapshotDataUMCBL[];
+}
+export interface WsPositionSnapshotDataUMCBL {
+    posId: string;
+    instId: string;
+    instName: string;
+    marginCoin: string;
+    margin: string;
+    marginMode: string;
+    holdSide: string;
+    holdMode: string;
+    total: string;
+    available: string;
+    locked: string;
+    averageOpenPrice: string;
+    leverage: number;
+    achievedProfits: string;
+    upl: string;
+    uplRate: string;
+    liqPx: string;
+    keepMarginRate: string;
+    marginRate: string;
+    cTime: string;
+    uTime: string;
+    markPrice: string;
+}
+export interface WSPositionSnapshotUMCBL extends WsBaseEvent<'snapshot'> {
+    arg: {
+        instType: 'umcbl';
+        channel: 'positions';
+        instId: string;
+    };
+    data: WsPositionSnapshotDataUMCBL[];
+}

package/dist/mjs/types/websockets/ws-events.js

@@ -0,0 +1,8 @@
+export function isMessageEvent(msg) {
+    if (typeof msg !== 'object' || !msg) {
+        return false;
+    }
+    const message = msg;
+    return message['type'] === 'message' && typeof message['data'] === 'string';
+}
+//# sourceMappingURL=ws-events.js.map

package/dist/mjs/types/websockets/ws-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-events.js","sourceRoot":"","sources":["../../../../src/types/websockets/ws-events.ts"],"names":[],"mappings":"AAMA,MAAM,UAAU,cAAc,CAAC,GAAY;IACzC,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,GAAG,EAAE,CAAC;QACpC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,OAAO,GAAG,GAAuB,CAAC;IACxC,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,SAAS,IAAI,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,QAAQ,CAAC;AAC9E,CAAC"}

package/dist/mjs/types/websockets/ws-general.d.ts

@@ -0,0 +1,112 @@
+import { RestClientOptions } from '../../util/requestUtils.js';
+import { WS_KEY_MAP } from '../../util/websocket-util.js';
+import { FuturesProductTypeV2 } from '../request/shared.js';
+export type BitgetInstType = 'SP' | 'SPBL' | 'MC' | 'UMCBL' | 'DMCBL';
+export type BitgetInstTypeV2 = 'SPOT' | FuturesProductTypeV2;
+export type BitgetInstTypeV3 = 'UTA' | 'spot' | 'usdt-futures' | 'coin-futures' | 'usdc-futures';
+/**
+ *
+ * V1  list of topics for WebSocket consumers
+ *
+ */
+export type WsPublicSpotTopic = 'ticker' | 'candle1W' | 'candle1D' | 'candle12H' | 'candle4H' | 'candle1H' | 'candle30m' | 'candle15m' | 'candle5m' | 'candle1m' | 'books' | 'books5' | 'trade';
+export type WsPublicFuturesTopic = WsPublicSpotTopic;
+export type WsPrivateSpotTopic = 'account' | 'orders';
+export type WsPrivateFuturesTopic = 'account' | 'positions' | 'orders' | 'ordersAlgo';
+export type WsPublicTopic = WsPublicSpotTopic | WsPublicFuturesTopic;
+export type WsPrivateTopic = WsPrivateSpotTopic | WsPrivateFuturesTopic;
+export type WsTopic = WsPublicTopic | WsPrivateTopic;
+/**
+ *
+ * V2 list of topics for WebSocket consumers
+ *
+ */
+export type WsPublicTopicV2 = 'index-price' | 'ticker' | 'candle1m' | 'candle5m' | 'candle15m' | 'candle30m' | 'candle1H' | 'candle4H' | 'candle6H' | 'candle12H' | 'candle1D' | 'candle3D' | 'candle1W' | 'candle1M' | 'candle6Hutc' | 'candle12Hutc' | 'candle1Dutc' | 'candle3Dutc' | 'candle1Wutc' | 'candle1Mutc' | 'trade' | 'books' | 'books1' | 'books5' | 'books15';
+export type WSPrivateTopicFuturesV2 = 'positions' | 'orders-algo' | 'positions-history';
+export type WSPrivateTopicMarginV2 = 'orders-crossed' | 'account-crossed' | 'account-isolated' | 'orders-isolated';
+export type WsPrivateTopicV2 = 'account' | 'orders' | WSPrivateTopicFuturesV2 | WSPrivateTopicMarginV2;
+export type WsTopicV2 = WsPublicTopicV2 | WsPrivateTopicV2;
+/**
+ *
+ * V3 / UTA list of topics for WebSocket consumers
+ *
+ */
+export type WsPublicTopicV3 = 'ticker' | 'kline' | 'books' | 'publicTrade';
+export type WsPrivateTopicV3 = 'account' | 'position' | 'fill' | 'order';
+export type WsTopicV3 = WsPublicTopicV3 | WsPrivateTopicV3;
+/** This is used to differentiate between each of the available websocket streams */
+export type WsKey = (typeof WS_KEY_MAP)[keyof typeof WS_KEY_MAP];
+/**
+ * Event args for subscribing/unsubscribing
+ */
+export interface WsTopicSubscribeEventArgs {
+    instType: BitgetInstType;
+    channel: WsTopic;
+    instId?: string;
+}
+export type WsTopicSubscribePublicArgsV2 = {
+    instType: BitgetInstTypeV2;
+    channel: WsPublicTopicV2;
+    /** The symbol, e.g. "BTCUSDT" */
+    instId: string;
+};
+export type WsInstIdChannelsV2 = 'orders' | WSPrivateTopicFuturesV2 | 'orders-crossed' | 'orders-isolated';
+export type WsTopicSubscribePrivateInstIdArgsV2 = {
+    instType: BitgetInstTypeV2;
+    channel: WsInstIdChannelsV2;
+    /** The symbol, e.g. "BTCUSDT" */
+    instId?: string;
+};
+export type WsCoinChannelsV2 = 'account' | 'account-crossed' | 'account-isolated';
+export type WsTopicSubscribePrivateCoinArgsV2 = {
+    instType: BitgetInstTypeV2;
+    channel: WsCoinChannelsV2;
+    coin: 'default' | string;
+};
+export type WsTopicSubscribePrivateArgsV2 = WsTopicSubscribePrivateInstIdArgsV2 | WsTopicSubscribePrivateCoinArgsV2;
+export type WsTopicSubscribeEventArgsV2 = WsTopicSubscribePublicArgsV2 | WsTopicSubscribePrivateArgsV2;
+/** General configuration for the WebsocketClient */
+export interface WSClientConfigurableOptions {
+    /** Your API key */
+    apiKey?: string;
+    /** Your API secret */
+    apiSecret?: string;
+    /** The passphrase you set when creating the API Key (NOT your account password) */
+    apiPass?: string;
+    /**
+     * Set to `true` to connect to Bitget's demo trading WebSockets:
+     *
+     * - V2: https://www.bitget.com/api-doc/common/demotrading/websocket
+     * - V3/UTA: https://www.bitget.com/api-doc/uta/guide#demo-trading
+     */
+    demoTrading?: boolean;
+    /** Define a recv window when preparing a private websocket signature. This is in milliseconds, so 5000 == 5 seconds */
+    recvWindow?: number;
+    disableHeartbeat?: boolean;
+    /** How often to check if the connection is alive */
+    pingInterval?: number;
+    /** How long to wait for a pong (heartbeat reply) before assuming the connection is dead */
+    pongTimeout?: number;
+    /** Delay in milliseconds before respawning the connection */
+    reconnectTimeout?: number;
+    requestOptions?: RestClientOptions;
+    wsOptions?: {
+        protocols?: string[];
+        agent?: any;
+    };
+    wsUrl?: string;
+    /**
+     * Allows you to provide a custom "signMessage" function, e.g. to use node's much faster createHmac method
+     *
+     * Look in the examples folder for a demonstration on using node's createHmac instead.
+     */
+    customSignMessageFn?: (message: string, secret: string) => Promise<string>;
+}
+export interface WebsocketClientOptions extends WSClientConfigurableOptions {
+    pingInterval: number;
+    pongTimeout: number;
+    reconnectTimeout: number;
+    recvWindow: number;
+    authPrivateConnectionsOnConnect: boolean;
+    authPrivateRequests: boolean;
+}

package/dist/mjs/types/websockets/ws-general.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ws-general.js.map

package/dist/mjs/types/websockets/ws-general.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-general.js","sourceRoot":"","sources":["../../../../src/types/websockets/ws-general.ts"],"names":[],"mappings":""}

package/dist/mjs/util/BaseRestClient.d.ts

@@ -0,0 +1,40 @@
+import { AxiosRequestConfig } from 'axios';
+import { RestClientType } from '../types/shared.js';
+import { RestClientOptions } from './requestUtils.js';
+export default abstract class BaseRestClient {
+    private options;
+    private baseUrl;
+    private globalRequestOptions;
+    private apiKey;
+    private apiSecret;
+    private apiPass;
+    /** Defines the client type (affecting how requests & signatures behave) */
+    abstract getClientType(): RestClientType;
+    /**
+     * Create an instance of the REST client. Pass API credentials in the object in the first parameter.
+     * @param {RestClientOptions} [restClientOptions={}] options to configure REST API connectivity
+     * @param {AxiosRequestConfig} [networkOptions={}] HTTP networking options for axios
+     */
+    constructor(restOptions?: RestClientOptions, networkOptions?: AxiosRequestConfig);
+    get(endpoint: string, params?: any): Promise<any>;
+    getPrivate(endpoint: string, params?: any): Promise<any>;
+    post(endpoint: string, params?: any): Promise<any>;
+    postPrivate(endpoint: string, params?: any): Promise<any>;
+    deletePrivate(endpoint: string, params?: any): Promise<any>;
+    /**
+     * @private Make a HTTP request to a specific endpoint. Private endpoint API calls are automatically signed.
+     */
+    private _call;
+    /**
+     * @private generic handler to parse request exceptions
+     */
+    parseException(e: any): unknown;
+    private signMessage;
+    /**
+     * @private sign request and set recv window
+     */
+    private signRequest;
+    private prepareSignParams;
+    /** Returns an axios request object. Handles signing process automatically if this is a private API call */
+    private buildRequest;
+}

package/dist/mjs/util/BaseRestClient.js

@@ -0,0 +1,268 @@
+import axios from 'axios';
+import https from 'https';
+import { getRestBaseUrl, serializeParams, } from './requestUtils.js';
+import { signMessage, } from './webCryptoAPI.js';
+import { neverGuard } from './websocket-util.js';
+const ENABLE_HTTP_TRACE = typeof process === 'object' &&
+    typeof process.env === 'object' &&
+    process.env.BITGETTRACE;
+if (ENABLE_HTTP_TRACE) {
+    axios.interceptors.request.use((request) => {
+        console.log(new Date(), 'Starting Request', JSON.stringify({
+            url: request.url,
+            method: request.method,
+            params: request.params,
+            data: request.data,
+        }, null, 2));
+        return request;
+    });
+    axios.interceptors.response.use((response) => {
+        console.log(new Date(), 'Response:', {
+            // request: {
+            //   url: response.config.url,
+            //   method: response.config.method,
+            //   data: response.config.data,
+            //   headers: response.config.headers,
+            // },
+            response: {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                data: response.data,
+            },
+        });
+        return response;
+    });
+}
+export default class BaseRestClient {
+    options;
+    baseUrl;
+    globalRequestOptions;
+    apiKey;
+    apiSecret;
+    apiPass;
+    /**
+     * Create an instance of the REST client. Pass API credentials in the object in the first parameter.
+     * @param {RestClientOptions} [restClientOptions={}] options to configure REST API connectivity
+     * @param {AxiosRequestConfig} [networkOptions={}] HTTP networking options for axios
+     */
+    constructor(restOptions = {}, networkOptions = {}) {
+        this.options = {
+            recvWindow: 5000,
+            /** Throw errors if any request params are empty */
+            strictParamValidation: false,
+            encodeQueryStringValues: true,
+            ...restOptions,
+        };
+        this.globalRequestOptions = {
+            /** in ms == 5 minutes by default */
+            timeout: 1000 * 60 * 5,
+            /** inject custom rquest options based on axios specs - see axios docs for more guidance on AxiosRequestConfig: https://github.com/axios/axios#request-config */
+            ...networkOptions,
+            headers: {
+                'X-CHANNEL-API-CODE': 'hbnni',
+                'Content-Type': 'application/json',
+                locale: 'en-US',
+            },
+        };
+        if (this.options.demoTrading) {
+            this.globalRequestOptions.headers = {
+                ...this.globalRequestOptions.headers,
+                // Header to enable paper trading with provided demo API keys
+                paptrading: '1',
+            };
+        }
+        // If enabled, configure a https agent with keepAlive enabled
+        if (this.options.keepAlive) {
+            // Extract existing https agent parameters, if provided, to prevent the keepAlive flag from overwriting an existing https agent completely
+            const existingHttpsAgent = this.globalRequestOptions.httpsAgent;
+            const existingAgentOptions = existingHttpsAgent?.options || {};
+            // For more advanced configuration, raise an issue on GitHub or use the "networkOptions"
+            // parameter to define a custom httpsAgent with the desired properties
+            this.globalRequestOptions.httpsAgent = new https.Agent({
+                ...existingAgentOptions,
+                keepAlive: true,
+                keepAliveMsecs: this.options.keepAliveMsecs,
+            });
+        }
+        this.baseUrl = getRestBaseUrl(false, restOptions);
+        this.apiKey = this.options.apiKey;
+        this.apiSecret = this.options.apiSecret;
+        this.apiPass = this.options.apiPass;
+        // Throw if one of the 3 values is missing, but at least one of them is set
+        const credentials = [this.apiKey, this.apiSecret, this.apiPass];
+        if (credentials.includes(undefined) &&
+            credentials.some((v) => typeof v === 'string')) {
+            throw new Error('API Key, Secret & Passphrase are ALL required to use the authenticated REST client');
+        }
+    }
+    get(endpoint, params) {
+        return this._call('GET', endpoint, params, true);
+    }
+    getPrivate(endpoint, params) {
+        return this._call('GET', endpoint, params, false);
+    }
+    post(endpoint, params) {
+        return this._call('POST', endpoint, params, true);
+    }
+    postPrivate(endpoint, params) {
+        return this._call('POST', endpoint, params, false);
+    }
+    deletePrivate(endpoint, params) {
+        return this._call('DELETE', endpoint, params, false);
+    }
+    /**
+     * @private Make a HTTP request to a specific endpoint. Private endpoint API calls are automatically signed.
+     */
+    async _call(method, endpoint, params, isPublicApi) {
+        // Sanity check to make sure it's only ever prefixed by one forward slash
+        const requestUrl = [this.baseUrl, endpoint].join(endpoint.startsWith('/') ? '' : '/');
+        // Build a request and handle signature process
+        const options = await this.buildRequest(method, endpoint, requestUrl, params, isPublicApi);
+        if (ENABLE_HTTP_TRACE) {
+            console.log('full request: ', options);
+        }
+        // Dispatch request
+        return axios(options)
+            .then((response) => {
+            if (response.status == 200) {
+                if (typeof response.data?.code === 'string' &&
+                    response.data?.code !== '00000') {
+                    throw { response };
+                }
+                return response.data;
+            }
+            throw { response };
+        })
+            .catch((e) => this.parseException(e));
+    }
+    /**
+     * @private generic handler to parse request exceptions
+     */
+    parseException(e) {
+        if (this.options.parseExceptions === false) {
+            throw e;
+        }
+        // Something happened in setting up the request that triggered an error
+        if (!e.response) {
+            if (!e.request) {
+                throw e.message;
+            }
+            // request made but no response received
+            throw e;
+        }
+        // The request was made and the server responded with a status code
+        // that falls out of the range of 2xx
+        const response = e.response;
+        // console.error('err: ', response?.data);
+        throw {
+            code: response.status,
+            message: response.statusText,
+            body: response.data,
+            headers: response.headers,
+            requestOptions: {
+                ...this.options,
+                // Prevent credentials from leaking into error messages
+                apiPass: 'omittedFromError',
+                apiSecret: 'omittedFromError',
+            },
+        };
+    }
+    async signMessage(paramsStr, secret, method, algorithm) {
+        if (typeof this.options.customSignMessageFn === 'function') {
+            return this.options.customSignMessageFn(paramsStr, secret);
+        }
+        return await signMessage(paramsStr, secret, method, algorithm);
+    }
+    /**
+     * @private sign request and set recv window
+     */
+    async signRequest(data, endpoint, method, signMethod) {
+        const timestamp = Date.now();
+        const res = {
+            originalParams: {
+                ...data,
+            },
+            sign: '',
+            timestamp,
+            recvWindow: 0,
+            serializedParams: '',
+            queryParamsWithSign: '',
+        };
+        if (!this.apiKey || !this.apiSecret) {
+            return res;
+        }
+        // It's possible to override the recv window on a per rquest level
+        const strictParamValidation = this.options.strictParamValidation;
+        const encodeQueryStringValues = this.options.encodeQueryStringValues;
+        if (signMethod === 'bitget') {
+            const signRequestParams = method === 'GET'
+                ? serializeParams(data, strictParamValidation, encodeQueryStringValues, '?')
+                : JSON.stringify(data) || '';
+            const paramsStr = timestamp + method.toUpperCase() + endpoint + signRequestParams;
+            // console.log('sign params: ', paramsStr);
+            res.sign = await this.signMessage(paramsStr, this.apiSecret, 'base64', 'SHA-256');
+            res.queryParamsWithSign = signRequestParams;
+            return res;
+        }
+        console.error(new Date(), neverGuard(signMethod, `Unhandled sign method: "${signMessage}"`));
+        return res;
+    }
+    async prepareSignParams(method, endpoint, signMethod, params, isPublicApi) {
+        if (isPublicApi) {
+            return {
+                originalParams: params,
+                paramsWithSign: params,
+            };
+        }
+        if (!this.apiKey || !this.apiSecret) {
+            throw new Error('Private endpoints require api and private keys set');
+        }
+        return this.signRequest(params, endpoint, method, signMethod);
+    }
+    /** Returns an axios request object. Handles signing process automatically if this is a private API call */
+    async buildRequest(method, endpoint, url, params, isPublicApi) {
+        const options = {
+            ...this.globalRequestOptions,
+            url: url,
+            method: method,
+        };
+        for (const key in params) {
+            if (typeof params[key] === 'undefined') {
+                delete params[key];
+            }
+        }
+        if (isPublicApi || !this.apiKey || !this.apiPass) {
+            return {
+                ...options,
+                params: params,
+            };
+        }
+        const signResult = await this.prepareSignParams(method, endpoint, 'bitget', params, isPublicApi);
+        const authHeaders = {
+            'ACCESS-KEY': this.apiKey,
+            'ACCESS-PASSPHRASE': this.apiPass,
+            'ACCESS-TIMESTAMP': signResult.timestamp,
+            'ACCESS-SIGN': signResult.sign,
+        };
+        if (method === 'GET') {
+            return {
+                ...options,
+                headers: {
+                    ...authHeaders,
+                    ...options.headers,
+                },
+                url: options.url + signResult.queryParamsWithSign,
+            };
+        }
+        return {
+            ...options,
+            headers: {
+                ...authHeaders,
+                ...options.headers,
+            },
+            data: params,
+        };
+    }
+}
+//# sourceMappingURL=BaseRestClient.js.map