feat: deprecate request and implement axios. bump ws. cleaning. expose request options for proxy support. resolves #12. resolves #4.

lib/util/requestUtils.js

@@ -0,0 +1,21 @@
+const { createHmac } = require('crypto');
+
+module.exports = {
+  signMessage(message, secret) {
+    return createHmac('sha256', secret)
+      .update(message)
+      .digest('hex');
+  },
+  serializeParams(params, strict_validation) {
+    return Object.keys(params)
+      .sort()
+      .map(key => {
+        const value = params[key];
+        if (strict_validation === true && typeof value === 'undefined') {
+          throw new Error('Failed to sign API request due to undefined parameter');
+        }
+        return `${key}=${value}`;
+      })
+      .join('&');
+  }
+};

lib/util/requestWrapper.js

@@ -0,0 +1,171 @@
+const assert = require('assert');
+const axios = require('axios');
+
+const { signMessage, serializeParams } = require('./requestUtils');
+
+const baseUrls = {
+  livenet: 'https://api.bybit.com',
+  testnet: 'https://api-testnet.bybit.com'
+};
+
+module.exports = class RequestUtil {
+  constructor(key, secret, livenet=false, options={}, requestOptions={}) {
+    this._timeOffset = null;
+    this._syncTimePromise = null;
+
+    this.options = {
+      recv_window: 5000,
+      // how often to sync time drift with bybit servers
+      sync_interval_ms: 3600000,
+      // if true, we'll throw errors if any params are undefined
+      strict_param_validation: false,
+      ...options
+    };
+
+    this.baseUrl = baseUrls[livenet === true ? 'livenet' : 'testnet'];
+    if (options.baseUrl) {
+      this.baseUrl = options.baseUrl
+    }
+
+    this.globalRequestOptions = {
+      // in ms == 5 minutes by default
+      timeout: 1000 * 60 * 5,
+      // custom request options based on axios specs - see: https://github.com/axios/axios#request-config
+      ...requestOptions,
+      headers: {
+        Referer: 'bybitapinode'
+      },
+    }
+
+    if (key) {
+      assert(secret, 'Secret is required for private enpoints');
+    }
+
+    this._syncTime();
+    setInterval(this._syncTime.bind(this), parseInt(this.options.sync_interval_ms));
+
+    this.key = key;
+    this.secret = secret;
+  }
+
+  async get(endpoint, params) {
+    const result = await this._call('GET', endpoint, params);
+    return result;
+  }
+
+  async post(endpoint, params) {
+    const result = await this._call('POST', endpoint, params);
+    return result;
+  }
+
+  async getTimeOffset() {
+    const start = Date.now();
+    const result = await this.get('v2/public/time');
+    const end = Date.now();
+
+    return Math.ceil((result.time_now * 1000) - end + ((end - start) / 2));
+  }
+
+  async _call(method, endpoint, params) {
+    const publicEndpoint = endpoint.startsWith('v2/public');
+
+    if (!publicEndpoint) {
+      if (!this.key || !this.secret) {
+        throw new Error('Private endpoints require api and private keys set');
+      }
+
+      if (this._timeOffset === null) {
+        await this._syncTime();
+      }
+
+      params = this._signRequest(params);
+    }
+
+    const options = {
+      url: [this.baseUrl, endpoint].join('/'),
+      method: method,
+      json: true
+    };
+
+    switch (method) {
+    case 'GET':
+      options.params = params;
+      break;
+    default:
+      options.data = params;
+      break;
+    }
+
+    return axios(options).then(response => {
+      if (response.status == 200) {
+        return response.data;
+      }
+
+      throw {
+        code: response.status,
+        message: response.statusText,
+        body: response.data,
+        requestOptions: options
+      };
+    })
+    .catch(e => {
+      if (!e.response) {
+        // Something happened in setting up the request that triggered an Error
+        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
+      throw {
+        code: e.response.statusCode,
+        message: e.response.message,
+        body: e.response.body,
+        requestOptions: options,
+        headers: e.response.headers
+      };
+    });
+  }
+
+  _signRequest(data) {
+    const params = {
+      ...data,
+      api_key: this.key,
+      timestamp: Date.now() + this._timeOffset
+    };
+
+    // Optional, set to 5000 by default. Increase if timestamp/recv_window errors are seen.
+    if (this.options.recv_window && !params.recv_window) {
+      params.recv_window = this.options.recv_window;
+    }
+
+    if (this.key && this.secret) {
+      const serializedParams = serializeParams(params, this.options.strict_param_validation);
+      params.sign = signMessage(serializedParams, this.secret);
+    }
+
+    return params;
+  }
+
+  _syncTime() {
+    if (this._syncTimePromise !== null) {
+      return this._syncTimePromise;
+    }
+
+    this._syncTimePromise = new Promise(async (resolve, reject) => {
+      try {
+        this._timeOffset = await this.getTimeOffset();
+        this._syncTimePromise = null;
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+
+    return this._syncTimePromise;
+  }
+};