@binance/common 1.0.6 → 1.1.1

package/dist/index.mjs

@@ -249,6 +249,52 @@ import crypto from "crypto";
 import fs from "fs";
 import https from "https";
 import globalAxios from "axios";
+var signerCache = /* @__PURE__ */ new WeakMap();
+var RequestSigner = class {
+  constructor(configuration) {
+    if (configuration.apiSecret && !configuration.privateKey) {
+      this.apiSecret = configuration.apiSecret;
+      return;
+    }
+    if (configuration.privateKey) {
+      let privateKey = configuration.privateKey;
+      if (typeof privateKey === "string" && fs.existsSync(privateKey)) {
+        privateKey = fs.readFileSync(privateKey, "utf-8");
+      }
+      const keyInput = { key: privateKey };
+      if (configuration.privateKeyPassphrase && typeof configuration.privateKeyPassphrase === "string") {
+        keyInput.passphrase = configuration.privateKeyPassphrase;
+      }
+      try {
+        this.keyObject = crypto.createPrivateKey(keyInput);
+        this.keyType = this.keyObject.asymmetricKeyType;
+      } catch {
+        throw new Error(
+          "Invalid private key. Please provide a valid RSA or ED25519 private key."
+        );
+      }
+      return;
+    }
+    throw new Error("Either 'apiSecret' or 'privateKey' must be provided for signed requests.");
+  }
+  sign(queryParams) {
+    const params = buildQueryString(queryParams);
+    if (this.apiSecret)
+      return crypto.createHmac("sha256", this.apiSecret).update(params).digest("hex");
+    if (this.keyObject && this.keyType) {
+      const data = Buffer.from(params);
+      if (this.keyType === "rsa")
+        return crypto.sign("RSA-SHA256", data, this.keyObject).toString("base64");
+      if (this.keyType === "ed25519")
+        return crypto.sign(null, data, this.keyObject).toString("base64");
+      throw new Error("Unsupported private key type. Must be RSA or ED25519.");
+    }
+    throw new Error("Signer is not properly initialized.");
+  }
+};
+var clearSignerCache = function() {
+  signerCache = /* @__PURE__ */ new WeakMap();
+};
 function buildQueryString(params) {
   if (!params) return "";
   return Object.entries(params).map(stringifyKeyValuePair).join("&");
@@ -275,39 +321,12 @@ function getTimestamp() {
   return Date.now();
 }
 var getSignature = function(configuration, queryParams) {
-  const params = buildQueryString(queryParams);
-  let signature = "";
-  if (configuration?.apiSecret && !configuration?.privateKey) {
-    signature = crypto.createHmac("sha256", configuration.apiSecret).update(params).digest("hex");
-  } else if (configuration?.privateKey) {
-    let privateKey = configuration.privateKey;
-    if (typeof privateKey === "string" && fs.existsSync(privateKey)) {
-      privateKey = fs.readFileSync(privateKey, "utf-8");
-    }
-    let keyObject;
-    try {
-      const privateKeyObj = { key: privateKey };
-      if (configuration.privateKeyPassphrase && typeof configuration.privateKeyPassphrase === "string") {
-        privateKeyObj.passphrase = configuration.privateKeyPassphrase;
-      }
-      keyObject = crypto.createPrivateKey(privateKeyObj);
-    } catch {
-      throw new Error(
-        "Invalid private key. Please provide a valid RSA or ED25519 private key."
-      );
-    }
-    const keyType = keyObject.asymmetricKeyType;
-    if (keyType === "rsa") {
-      signature = crypto.sign("RSA-SHA256", Buffer.from(params), keyObject).toString("base64");
-    } else if (keyType === "ed25519") {
-      signature = crypto.sign(null, Buffer.from(params), keyObject).toString("base64");
-    } else {
-      throw new Error("Unsupported private key type. Must be RSA or ED25519.");
-    }
-  } else {
-    throw new Error("Either 'apiSecret' or 'privateKey' must be provided for signed requests.");
+  let signer = signerCache.get(configuration);
+  if (!signer) {
+    signer = new RequestSigner(configuration);
+    signerCache.set(configuration, signer);
   }
-  return signature;
+  return signer.sign(queryParams);
 };
 var assertParamExists = function(functionName, paramName, paramValue) {
   if (paramValue === null || paramValue === void 0) {
@@ -319,25 +338,26 @@ var assertParamExists = function(functionName, paramName, paramValue) {
 };
 function setFlattenedQueryParams(urlSearchParams, parameter, key = "") {
   if (parameter == null) return;
+  if (Array.isArray(parameter)) {
+    if (key)
+      urlSearchParams.set(key, JSON.stringify(parameter));
+    else
+      for (const item of parameter) {
+        setFlattenedQueryParams(urlSearchParams, item, "");
+      }
+    return;
+  }
   if (typeof parameter === "object") {
-    if (Array.isArray(parameter)) {
-      parameter.forEach((item) => setFlattenedQueryParams(urlSearchParams, item, key));
-    } else {
-      Object.keys(parameter).forEach(
-        (currentKey) => setFlattenedQueryParams(
-          urlSearchParams,
-          parameter[currentKey],
-          `${key}${key !== "" ? "." : ""}${currentKey}`
-        )
-      );
-    }
-  } else {
-    if (urlSearchParams.has(key)) {
-      urlSearchParams.append(key, String(parameter));
-    } else {
-      urlSearchParams.set(key, String(parameter));
+    for (const subKey of Object.keys(parameter)) {
+      const subVal = parameter[subKey];
+      const newKey = key ? `${key}.${subKey}` : subKey;
+      setFlattenedQueryParams(urlSearchParams, subVal, newKey);
     }
+    return;
   }
+  const str = String(parameter);
+  if (urlSearchParams.has(key)) urlSearchParams.append(key, str);
+  else urlSearchParams.set(key, str);
 }
 var setSearchParams = function(url, ...objects) {
   const searchParams = new URLSearchParams(url.search);
@@ -359,18 +379,13 @@ var httpRequestFunction = async function(axiosArgs, configuration) {
     ...axiosArgs.options,
     url: (globalAxios.defaults?.baseURL ? "" : configuration?.basePath ?? "") + axiosArgs.url
   };
-  if (configuration?.keepAlive) {
-    axiosRequestArgs.httpsAgent = new https.Agent({
-      ...configuration?.httpsAgent instanceof https.Agent ? configuration.httpsAgent.options : {},
-      keepAlive: true
-    });
-  }
-  if (configuration?.compression) {
+  if (configuration?.keepAlive && !configuration?.baseOptions?.httpsAgent)
+    axiosRequestArgs.httpsAgent = new https.Agent({ keepAlive: true });
+  if (configuration?.compression)
     axiosRequestArgs.headers = {
       ...axiosRequestArgs.headers,
       "Accept-Encoding": "gzip, deflate, br"
     };
-  }
   const retries = configuration?.retries ?? 0;
   const backoff = configuration?.backoff ?? 0;
   let attempt = 0;
@@ -383,7 +398,13 @@ var httpRequestFunction = async function(axiosArgs, configuration) {
       });
       const rateLimits = parseRateLimitHeaders(response.headers);
       return {
-        data: async () => JSON.parse(response.data),
+        data: async () => {
+          try {
+            return JSON.parse(response.data);
+          } catch (err) {
+            throw new Error(`Failed to parse JSON response: ${err}`);
+          }
+        },
         status: response.status,
         headers: response.headers,
         rateLimits
@@ -404,7 +425,11 @@ var httpRequestFunction = async function(axiosArgs, configuration) {
           let data = {};
           if (responseData && responseData !== null) {
             if (typeof responseData === "string" && responseData !== "")
-              data = JSON.parse(responseData);
+              try {
+                data = JSON.parse(responseData);
+              } catch {
+                data = {};
+              }
             else if (typeof responseData === "object")
               data = responseData;
           }
@@ -1353,7 +1378,11 @@ function createStreamHandler(websocketBase, streamOrId, id) {
   return {
     on: (event, callback) => {
       if (event === "message") {
-        registeredCallback = (data) => callback(data);
+        registeredCallback = (data) => {
+          Promise.resolve(callback(data)).catch((err) => {
+            websocketBase.logger.error(`Error in stream callback: ${err}`);
+          });
+        };
         const callbackSet = websocketBase.streamCallbackMap.get(streamOrId) ?? /* @__PURE__ */ new Set();
         callbackSet.add(registeredCallback);
         websocketBase.streamCallbackMap.set(streamOrId, callbackSet);
@@ -1434,6 +1463,7 @@ export {
   WebsocketStreamsBase,
   assertParamExists,
   buildQueryString,
+  clearSignerCache,
   createStreamHandler,
   delay,
   getSignature,
@@ -1444,6 +1474,7 @@ export {
   removeEmptyValue,
   replaceWebsocketStreamsPlaceholders,
   sendRequest,
+  setFlattenedQueryParams,
   setSearchParams,
   shouldRetryRequest,
   sortObject,