@binance/common 2.1.0 → 2.2.0

package/dist/index.js

@@ -140,6 +140,42 @@ function randomString() {
 	return crypto.default.randomBytes(16).toString("hex");
 }
 /**
+* Generates a cryptographically secure random 32-bit unsigned integer.
+*
+* Uses the Web Crypto API to generate a random value between 0 and 4,294,967,295 (2^32 - 1).
+*
+* @returns A random 32-bit unsigned integer.
+*/
+function randomInteger() {
+	const array = new Uint32Array(1);
+	crypto.default.getRandomValues(array);
+	return array[0];
+}
+/**
+* Normalizes a stream ID to ensure it is valid, generating a random ID if needed.
+*
+* For string inputs:
+* - Returns the input if it's a valid 32-character hexadecimal string (case-insensitive)
+* - Otherwise, generates a new random hexadecimal string using `randomString()`
+*
+* For number inputs:
+* - Returns the input if it's a finite, non-negative integer within the safe integer range
+* - Otherwise, generates a new random integer using `randomInteger()`
+*
+* For null or undefined inputs:
+* - Generates a new random hexadecimal string using `randomString()`
+*
+* @param id - The stream ID to normalize (string, number, null, or undefined).
+* @param streamIdIsStrictlyNumber - Boolean forcing an id to be a number or not.
+* @returns A valid stream ID as either a 32-character hexadecimal string or a safe integer.
+*/
+function normalizeStreamId(id, streamIdIsStrictlyNumber) {
+	const isValidNumber = typeof id === "number" && Number.isFinite(id) && Number.isInteger(id) && id >= 0 && id <= Number.MAX_SAFE_INTEGER;
+	if (streamIdIsStrictlyNumber || typeof id === "number") return isValidNumber ? id : randomInteger();
+	if (typeof id === "string") return id && /^[0-9a-f]{32}$/i.test(id) ? id : randomString();
+	return randomString();
+}
+/**
 * Validates the provided time unit string and returns it if it is either 'MILLISECOND' or 'MICROSECOND'.
 *
 * @param timeUnit - The time unit string to be validated.
@@ -682,7 +718,9 @@ const DERIVATIVES_TRADING_USDS_FUTURES_WS_API_TESTNET_URL = "wss://testnet.binan
 const DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_PROD_URL = "wss://fstream.binance.com";
 const DERIVATIVES_TRADING_USDS_FUTURES_WS_STREAMS_TESTNET_URL = "wss://stream.binancefuture.com";
 const DERIVATIVES_TRADING_OPTIONS_REST_API_PROD_URL = "https://eapi.binance.com";
-const DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_PROD_URL = "wss://nbstream.binance.com/eoptions";
+const DERIVATIVES_TRADING_OPTIONS_REST_API_TESTNET_URL = "https://testnet.binancefuture.com";
+const DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_PROD_URL = "wss://fstream.binance.com";
+const DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_TESTNET_URL = "wss://fstream.binancefuture.com";
 const DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_PROD_URL = "https://papi.binance.com";
 const DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_TESTNET_URL = "https://testnet.binancefuture.com";
 const DERIVATIVES_TRADING_PORTFOLIO_MARGIN_WS_STREAMS_PROD_URL = "wss://fstream.binance.com/pm";
@@ -944,10 +982,11 @@ var WebsocketCommon = class WebsocketCommon extends WebsocketEventEmitter {
 	* In 'single' mode, returns the first connection in the pool.
 	* In 'pool' mode, filters and returns connections that are ready for use.
 	* @param allowNonEstablishedWebsockets - Optional flag to include non-established WebSocket connections.
+	* @param urlPath - Optional URL path to filter connections.
 	* @returns An array of available WebSocket connections.
 	*/
-	getAvailableConnections(allowNonEstablishedWebsockets = false) {
-		if (this.mode === "single") return [this.connectionPool[0]];
+	getAvailableConnections(allowNonEstablishedWebsockets = false, urlPath) {
+		if (this.mode === "single" && !urlPath) return [this.connectionPool[0]];
 		return this.connectionPool.filter((connection) => this.isConnectionReady(connection, allowNonEstablishedWebsockets));
 	}
 	/**
@@ -956,10 +995,14 @@ var WebsocketCommon = class WebsocketCommon extends WebsocketEventEmitter {
 	* If the connection mode is 'pool', it returns an available connection from the pool,
 	* using a round-robin selection strategy. If no available connections are found, it throws an error.
 	* @param allowNonEstablishedWebsockets - A boolean indicating whether to allow connections that are not established.
+	* @param urlPath - An optional URL path to filter connections.
 	* @returns {WebsocketConnection} The selected WebSocket connection.
 	*/
-	getConnection(allowNonEstablishedWebsockets = false) {
-		const availableConnections = this.getAvailableConnections(allowNonEstablishedWebsockets);
+	getConnection(allowNonEstablishedWebsockets = false, urlPath) {
+		const availableConnections = this.getAvailableConnections(allowNonEstablishedWebsockets, urlPath).filter((connection) => {
+			if (urlPath) return connection.urlPath === urlPath;
+			return true;
+		});
 		if (availableConnections.length === 0) throw new Error("No available Websocket connections are ready.");
 		const selectedConnection = availableConnections[this.roundRobinIndex % availableConnections.length];
 		this.roundRobinIndex = (this.roundRobinIndex + 1) % availableConnections.length;
@@ -1157,14 +1200,15 @@ var WebsocketCommon = class WebsocketCommon extends WebsocketEventEmitter {
 	/**
 	* Connects all WebSocket connections in the pool
 	* @param url - The Websocket server URL.
+	* @param connections - An optional array of WebSocket connections to connect. If not provided, all connections in the pool are connected.
 	* @returns A promise that resolves when all connections are established.
 	*/
-	async connectPool(url) {
-		const connectPromises = this.connectionPool.map((connection) => new Promise((resolve, reject) => {
+	async connectPool(url, connections) {
+		const connectPromises = (connections ?? this.connectionPool).map((connection) => new Promise((resolve, reject) => {
 			this.initConnect(url, false, connection);
-			connection.ws?.on("open", () => resolve());
-			connection.ws?.on("error", (err) => reject(err));
-			connection.ws?.on("close", () => reject(/* @__PURE__ */ new Error("Connection closed unexpectedly.")));
+			connection.ws?.once("open", () => resolve());
+			connection.ws?.once("error", (err) => reject(err));
+			connection.ws?.once("close", () => reject(/* @__PURE__ */ new Error("Connection closed unexpectedly.")));
 		}));
 		await Promise.all(connectPromises);
 	}
@@ -1443,21 +1487,50 @@ var WebsocketAPIBase = class extends WebsocketCommon {
 	}
 };
 var WebsocketStreamsBase = class extends WebsocketCommon {
-	constructor(configuration, connectionPool = []) {
+	constructor(configuration, connectionPool = [], urlPaths = []) {
 		super(configuration, connectionPool);
 		this.streamConnectionMap = /* @__PURE__ */ new Map();
+		this.streamIdIsStrictlyNumber = false;
 		this.streamCallbackMap = /* @__PURE__ */ new Map();
 		this.logger = Logger.getInstance();
 		this.configuration = configuration;
 		this.wsURL = configuration.wsURL;
+		this.urlPaths = urlPaths;
+		this.ensurePoolSizeForUrlPaths();
+	}
+	/**
+	* Ensures the connection pool has the required size based on the configured mode and number of URL paths.
+	*
+	* If no URL paths are configured, the method returns early without modifications.
+	* In 'pool' mode, the pool size is multiplied by the number of URL paths.
+	* In 'single' mode, only one connection per URL path is maintained.
+	*
+	* New connections are initialized with unique IDs and default state flags when the pool
+	* size is less than the expected size.
+	*
+	* @private
+	* @returns {void}
+	*/
+	ensurePoolSizeForUrlPaths() {
+		if (this.urlPaths.length === 0) return;
+		const expected = ((this.configuration?.mode ?? "single") === "pool" && this.configuration?.poolSize ? this.configuration.poolSize : 1) * this.urlPaths.length;
+		while (this.connectionPool.length < expected) this.connectionPool.push({
+			id: randomString(),
+			closeInitiated: false,
+			reconnectionPending: false,
+			renewalPending: false,
+			pendingRequests: /* @__PURE__ */ new Map(),
+			pendingSubscriptions: []
+		});
 	}
 	/**
 	* Formats the WebSocket URL for a given stream or streams.
 	* @param streams - Array of stream names to include in the URL.
+	* @param urlPath - Optional URL path to include in the WebSocket URL.
 	* @returns The formatted WebSocket URL with the provided streams.
 	*/
-	prepareURL(streams = []) {
-		let url = `${this.wsURL}/stream?streams=${streams.join("/")}`;
+	prepareURL(streams = [], urlPath) {
+		let url = `${urlPath ? `${this.wsURL}/${urlPath}` : this.wsURL}/stream?streams=${streams.join("/")}`;
 		if (this.configuration?.timeUnit) try {
 			const _timeUnit = validateTimeUnit(this.configuration.timeUnit);
 			url = `${url}${url.includes("?") ? "&" : "?"}timeUnit=${_timeUnit}`;
@@ -1473,22 +1546,24 @@ var WebsocketStreamsBase = class extends WebsocketCommon {
 	* @returns The formatted WebSocket URL with streams and optional parameters.
 	*/
 	getReconnectURL(url, targetConnection) {
-		const streams = Array.from(this.streamConnectionMap.keys()).filter((stream) => this.streamConnectionMap.get(stream) === targetConnection);
-		return this.prepareURL(streams);
+		const streams = Array.from(this.streamConnectionMap.keys()).filter((stream) => this.streamConnectionMap.get(stream) === targetConnection).map((key) => key.includes("::") ? key.split("::").slice(1).join("::") : key);
+		return this.prepareURL(streams, targetConnection?.urlPath);
 	}
 	/**
 	* Handles subscription to streams and assigns them to specific connections
 	* @param streams Array of stream names to subscribe to
+	* @param urlPath Optional URL path for the streams
 	* @returns Map of connections to streams
 	*/
-	handleStreamAssignment(streams) {
+	handleStreamAssignment(streams, urlPath) {
 		const connectionStreamMap = /* @__PURE__ */ new Map();
 		streams.forEach((stream) => {
-			if (!this.streamCallbackMap.has(stream)) this.streamCallbackMap.set(stream, /* @__PURE__ */ new Set());
-			let connection = this.streamConnectionMap.get(stream);
+			const key = this.streamKey(stream, urlPath);
+			if (!this.streamCallbackMap.has(key)) this.streamCallbackMap.set(key, /* @__PURE__ */ new Set());
+			let connection = this.streamConnectionMap.get(key);
 			if (!connection || connection.closeInitiated || connection.reconnectionPending) {
-				connection = this.getConnection(true);
-				this.streamConnectionMap.set(stream, connection);
+				connection = this.getConnection(true, urlPath);
+				this.streamConnectionMap.set(key, connection);
 			}
 			if (!connectionStreamMap.has(connection)) connectionStreamMap.set(connection, []);
 			connectionStreamMap.get(connection)?.push(stream);
@@ -1505,7 +1580,7 @@ var WebsocketStreamsBase = class extends WebsocketCommon {
 		const payload = {
 			method: "SUBSCRIBE",
 			params: streams,
-			id: id && /^[0-9a-f]{32}$/.test(id) ? id : randomString()
+			id: normalizeStreamId(id, this.streamIdIsStrictlyNumber)
 		};
 		this.logger.debug("SUBSCRIBE", payload);
 		this.send(JSON.stringify(payload), void 0, false, 0, connection);
@@ -1534,7 +1609,10 @@ var WebsocketStreamsBase = class extends WebsocketCommon {
 		try {
 			const parsedData = (0, json_with_bigint.JSONParse)(data);
 			const streamName = parsedData?.stream;
-			if (streamName && this.streamCallbackMap.has(streamName)) this.streamCallbackMap.get(streamName)?.forEach((callback) => callback(parsedData.data));
+			if (streamName) {
+				const key = this.streamKey(streamName, connection?.urlPath);
+				if (this.streamCallbackMap.has(key)) this.streamCallbackMap.get(key)?.forEach((callback) => callback(parsedData.data));
+			}
 		} catch (error) {
 			this.logger.error("Failed to parse WebSocket message:", data, error);
 		}
@@ -1552,6 +1630,15 @@ var WebsocketStreamsBase = class extends WebsocketCommon {
 		super.onOpen(url, targetConnection, oldWSConnection);
 	}
 	/**
+	* Generates a stream key by combining a stream name with an optional URL path.
+	* @param stream - The stream name to use as the key or suffix.
+	* @param urlPath - Optional URL path to prepend to the stream name.
+	* @returns A stream key in the format `urlPath::stream` if urlPath is provided, otherwise just the stream name.
+	*/
+	streamKey(stream, urlPath) {
+		return urlPath ? `${urlPath}::${stream}` : stream;
+	}
+	/**
 	* Connects to the WebSocket server and subscribes to the specified streams.
 	* This method returns a Promise that resolves when the connection is established,
 	* or rejects with an error if the connection fails to be established within 10 seconds.
@@ -1564,7 +1651,15 @@ var WebsocketStreamsBase = class extends WebsocketCommon {
 			const timeout = setTimeout(() => {
 				reject(/* @__PURE__ */ new Error("Websocket connection timed out"));
 			}, 1e4);
-			this.connectPool(this.prepareURL(streams)).then(() => resolve()).catch((error) => reject(error)).finally(() => clearTimeout(timeout));
+			const basePoolSize = (this.configuration?.mode ?? "single") === "pool" && this.configuration?.poolSize ? this.configuration.poolSize : 1;
+			const connections = this.urlPaths.length > 0 ? this.urlPaths.map((path, i) => {
+				const start = i * basePoolSize;
+				const end = start + basePoolSize;
+				const subset = this.connectionPool.slice(start, end);
+				subset.forEach((c) => c.urlPath = path);
+				return this.connectPool(this.prepareURL(streams, path), subset);
+			}) : [this.connectPool(this.prepareURL(streams))];
+			Promise.all(connections).then(() => resolve()).catch((error) => reject(error)).finally(() => clearTimeout(timeout));
 		});
 	}
 	/**
@@ -1581,17 +1676,21 @@ var WebsocketStreamsBase = class extends WebsocketCommon {
 	* Handles both single and pool modes
 	* @param stream Single stream name or array of stream names to subscribe to
 	* @param id Optional subscription ID
+	* @param urlPath Optional URL path for the streams
 	* @returns void
 	*/
-	subscribe(stream, id) {
-		const streams = (Array.isArray(stream) ? stream : [stream]).filter((stream$1) => !this.streamConnectionMap.has(stream$1));
-		this.handleStreamAssignment(streams).forEach((streams$1, connection) => {
+	subscribe(stream, id, urlPath) {
+		const streams = (Array.isArray(stream) ? stream : [stream]).filter((stream$1) => {
+			const key = this.streamKey(stream$1, urlPath);
+			return !this.streamConnectionMap.has(key);
+		});
+		this.handleStreamAssignment(streams, urlPath).forEach((assignedStreams, connection) => {
 			if (!this.isConnected(connection)) {
-				this.logger.info(`Connection ${connection.id} is not ready. Queuing subscription for streams: ${streams$1}`);
-				connection.pendingSubscriptions?.push(...streams$1);
+				this.logger.info(`Connection ${connection.id} is not ready. Queuing subscription for streams: ${assignedStreams}`);
+				connection.pendingSubscriptions?.push(...assignedStreams);
 				return;
 			}
-			this.sendSubscriptionPayload(connection, streams$1, id);
+			this.sendSubscriptionPayload(connection, assignedStreams, id);
 		});
 	}
 	/**
@@ -1599,25 +1698,27 @@ var WebsocketStreamsBase = class extends WebsocketCommon {
 	* Handles both single and pool modes
 	* @param stream Single stream name or array of stream names to unsubscribe from
 	* @param id Optional unsubscription ID
+	* @param urlPath Optional URL path for the streams
 	* @returns void
 	*/
-	unsubscribe(stream, id) {
+	unsubscribe(stream, id, urlPath) {
 		(Array.isArray(stream) ? stream : [stream]).forEach((stream$1) => {
-			const connection = this.streamConnectionMap.get(stream$1);
+			const key = this.streamKey(stream$1, urlPath);
+			const connection = this.streamConnectionMap.get(key);
 			if (!connection || !connection.ws || !this.isConnected(connection)) {
 				this.logger.warn(`Stream ${stream$1} not associated with an active connection.`);
 				return;
 			}
-			if (!this.streamCallbackMap.has(stream$1) || this.streamCallbackMap.get(stream$1)?.size === 0) {
+			if (!this.streamCallbackMap.has(key) || this.streamCallbackMap.get(key)?.size === 0) {
 				const payload = {
 					method: "UNSUBSCRIBE",
 					params: [stream$1],
-					id: id && /^[0-9a-f]{32}$/.test(id) ? id : randomString()
+					id: normalizeStreamId(id, this.streamIdIsStrictlyNumber)
 				};
 				this.logger.debug("UNSUBSCRIBE", payload);
 				this.send(JSON.stringify(payload), void 0, false, 0, connection);
-				this.streamConnectionMap.delete(stream$1);
-				this.streamCallbackMap.delete(stream$1);
+				this.streamConnectionMap.delete(key);
+				this.streamCallbackMap.delete(key);
 			}
 		});
 	}
@@ -1627,7 +1728,9 @@ var WebsocketStreamsBase = class extends WebsocketCommon {
 	* @returns `true` if the stream is currently subscribed, `false` otherwise.
 	*/
 	isSubscribed(stream) {
-		return this.streamConnectionMap.has(stream);
+		if (this.streamConnectionMap.has(stream)) return true;
+		for (const key of this.streamConnectionMap.keys()) if (key.endsWith(`::${stream}`)) return true;
+		return false;
 	}
 };
 /**
@@ -1637,10 +1740,12 @@ var WebsocketStreamsBase = class extends WebsocketCommon {
 * @param {WebsocketAPIBase | WebsocketStreamsBase} websocketBase The WebSocket base instance
 * @param {string} streamOrId The stream identifier
 * @param {string} [id] Optional additional identifier
+* @param {string} [urlPath] Optional URL path for the stream
 * @returns {WebsocketStream<T>} A stream handler with methods to register callbacks and unsubscribe
 */
-function createStreamHandler(websocketBase, streamOrId, id) {
-	if (websocketBase instanceof WebsocketStreamsBase) websocketBase.subscribe(streamOrId, id);
+function createStreamHandler(websocketBase, streamOrId, id, urlPath) {
+	const key = websocketBase instanceof WebsocketStreamsBase ? websocketBase.streamKey(streamOrId, urlPath) : streamOrId;
+	if (websocketBase instanceof WebsocketStreamsBase) websocketBase.subscribe(streamOrId, id, urlPath);
 	let registeredCallback;
 	return {
 		on: (event, callback) => {
@@ -1650,14 +1755,14 @@ function createStreamHandler(websocketBase, streamOrId, id) {
 						websocketBase.logger.error(`Error in stream callback: ${err}`);
 					});
 				};
-				const callbackSet = websocketBase.streamCallbackMap.get(streamOrId) ?? /* @__PURE__ */ new Set();
+				const callbackSet = websocketBase.streamCallbackMap.get(key) ?? /* @__PURE__ */ new Set();
 				callbackSet.add(registeredCallback);
-				websocketBase.streamCallbackMap.set(streamOrId, callbackSet);
+				websocketBase.streamCallbackMap.set(key, callbackSet);
 			}
 		},
 		unsubscribe: () => {
-			if (registeredCallback) websocketBase.streamCallbackMap.get(streamOrId)?.delete(registeredCallback);
-			if (websocketBase instanceof WebsocketStreamsBase) websocketBase.unsubscribe(streamOrId, id);
+			if (registeredCallback) websocketBase.streamCallbackMap.get(key)?.delete(registeredCallback);
+			if (websocketBase instanceof WebsocketStreamsBase) websocketBase.unsubscribe(streamOrId, id, urlPath);
 		}
 	};
 }
@@ -1680,7 +1785,9 @@ exports.DERIVATIVES_TRADING_COIN_FUTURES_WS_API_TESTNET_URL = DERIVATIVES_TRADIN
 exports.DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_PROD_URL = DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_PROD_URL;
 exports.DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_TESTNET_URL = DERIVATIVES_TRADING_COIN_FUTURES_WS_STREAMS_TESTNET_URL;
 exports.DERIVATIVES_TRADING_OPTIONS_REST_API_PROD_URL = DERIVATIVES_TRADING_OPTIONS_REST_API_PROD_URL;
+exports.DERIVATIVES_TRADING_OPTIONS_REST_API_TESTNET_URL = DERIVATIVES_TRADING_OPTIONS_REST_API_TESTNET_URL;
 exports.DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_PROD_URL = DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_PROD_URL;
+exports.DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_TESTNET_URL = DERIVATIVES_TRADING_OPTIONS_WS_STREAMS_TESTNET_URL;
 exports.DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_REST_API_PROD_URL = DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_REST_API_PROD_URL;
 exports.DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_WS_STREAMS_PROD_URL = DERIVATIVES_TRADING_PORTFOLIO_MARGIN_PRO_WS_STREAMS_PROD_URL;
 exports.DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_PROD_URL = DERIVATIVES_TRADING_PORTFOLIO_MARGIN_REST_API_PROD_URL;
@@ -1742,8 +1849,10 @@ exports.getSignature = getSignature;
 exports.getTimestamp = getTimestamp;
 exports.httpRequestFunction = httpRequestFunction;
 exports.normalizeScientificNumbers = normalizeScientificNumbers;
+exports.normalizeStreamId = normalizeStreamId;
 exports.parseCustomHeaders = parseCustomHeaders;
 exports.parseRateLimitHeaders = parseRateLimitHeaders;
+exports.randomInteger = randomInteger;
 exports.randomString = randomString;
 exports.removeEmptyValue = removeEmptyValue;
 exports.replaceWebsocketStreamsPlaceholders = replaceWebsocketStreamsPlaceholders;