@binance/common 1.1.0 → 1.1.2

package/dist/index.mjs

@@ -248,7 +248,54 @@ var Logger = class _Logger {
 import crypto from "crypto";
 import fs from "fs";
 import https from "https";
+import { platform, arch } from "os";
 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 +322,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 +339,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 +380,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?.baseOptions?.httpsAgent instanceof https.Agent ? configuration.baseOptions.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;
@@ -578,6 +594,9 @@ function replaceWebsocketStreamsPlaceholders(str, variables) {
     return "";
   });
 }
+function buildUserAgent(packageName, packageVersion) {
+  return `${packageName}/${packageVersion} (Node.js/${process.version}; ${platform()}; ${arch()})`;
+}
 
 // src/websocket.ts
 import { EventEmitter } from "events";
@@ -846,10 +865,13 @@ var WebsocketCommon = class _WebsocketCommon extends WebsocketEventEmitter {
    * @returns A new WebSocket client instance.
    */
   createWebSocket(url) {
-    return new WebSocketClient(url, {
+    const wsClientOptions = {
       perMessageDeflate: this.configuration?.compression,
       agent: this.configuration?.agent
-    });
+    };
+    if (this.configuration.userAgent)
+      wsClientOptions.headers = { "User-Agent": this.configuration.userAgent };
+    return new WebSocketClient(url, wsClientOptions);
   }
   /**
    * Initializes a WebSocket connection.
@@ -1448,6 +1470,8 @@ export {
   WebsocketStreamsBase,
   assertParamExists,
   buildQueryString,
+  buildUserAgent,
+  clearSignerCache,
   createStreamHandler,
   delay,
   getSignature,
@@ -1458,6 +1482,7 @@ export {
   removeEmptyValue,
   replaceWebsocketStreamsPlaceholders,
   sendRequest,
+  setFlattenedQueryParams,
   setSearchParams,
   shouldRetryRequest,
   sortObject,