@binance/common 2.1.1 → 2.3.0

package/dist/index.js

@@ -372,16 +372,17 @@ const httpRequestFunction = async function(axiosArgs, configuration) {
 				else if (typeof responseData === "object") data = responseData;
 			}
 			const errorMsg = data.msg;
+			const errorCode = typeof data.code === "number" ? data.code : void 0;
 			switch (status) {
-				case 400: throw new BadRequestError(errorMsg);
-				case 401: throw new UnauthorizedError(errorMsg);
-				case 403: throw new ForbiddenError(errorMsg);
-				case 404: throw new NotFoundError(errorMsg);
-				case 418: throw new RateLimitBanError(errorMsg);
-				case 429: throw new TooManyRequestsError(errorMsg);
+				case 400: throw new BadRequestError(errorMsg, errorCode);
+				case 401: throw new UnauthorizedError(errorMsg, errorCode);
+				case 403: throw new ForbiddenError(errorMsg, errorCode);
+				case 404: throw new NotFoundError(errorMsg, errorCode);
+				case 418: throw new RateLimitBanError(errorMsg, errorCode);
+				case 429: throw new TooManyRequestsError(errorMsg, errorCode);
 				default:
 					if (status >= 500 && status < 600) throw new ServerError(`Server error: ${status}`, status);
-					throw new ConnectorClientError(errorMsg);
+					throw new ConnectorClientError(errorMsg, errorCode);
 			}
 		} else {
 			if (retries > 0 && attempt >= retries) lastError = /* @__PURE__ */ new Error(`Request failed after ${retries} retries`);
@@ -718,7 +719,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";
@@ -756,10 +759,11 @@ const WALLET_REST_API_PROD_URL = "https://api.binance.com";
 * @param msg - An optional error message.
 */
 var ConnectorClientError = class ConnectorClientError extends Error {
-	constructor(msg) {
+	constructor(msg, code) {
 		super(msg || "An unexpected error occurred.");
 		Object.setPrototypeOf(this, ConnectorClientError.prototype);
 		this.name = "ConnectorClientError";
+		this.code = code;
 	}
 };
 /**
@@ -780,10 +784,11 @@ var RequiredError = class RequiredError extends Error {
 * @param msg - An optional error message.
 */
 var UnauthorizedError = class UnauthorizedError extends Error {
-	constructor(msg) {
+	constructor(msg, code) {
 		super(msg || "Unauthorized access. Authentication required.");
 		Object.setPrototypeOf(this, UnauthorizedError.prototype);
 		this.name = "UnauthorizedError";
+		this.code = code;
 	}
 };
 /**
@@ -791,10 +796,11 @@ var UnauthorizedError = class UnauthorizedError extends Error {
 * @param msg - An optional error message.
 */
 var ForbiddenError = class ForbiddenError extends Error {
-	constructor(msg) {
+	constructor(msg, code) {
 		super(msg || "Access to the requested resource is forbidden.");
 		Object.setPrototypeOf(this, ForbiddenError.prototype);
 		this.name = "ForbiddenError";
+		this.code = code;
 	}
 };
 /**
@@ -802,10 +808,11 @@ var ForbiddenError = class ForbiddenError extends Error {
 * @param msg - An optional error message.
 */
 var TooManyRequestsError = class TooManyRequestsError extends Error {
-	constructor(msg) {
+	constructor(msg, code) {
 		super(msg || "Too many requests. You are being rate-limited.");
 		Object.setPrototypeOf(this, TooManyRequestsError.prototype);
 		this.name = "TooManyRequestsError";
+		this.code = code;
 	}
 };
 /**
@@ -813,10 +820,11 @@ var TooManyRequestsError = class TooManyRequestsError extends Error {
 * @param msg - An optional error message.
 */
 var RateLimitBanError = class RateLimitBanError extends Error {
-	constructor(msg) {
+	constructor(msg, code) {
 		super(msg || "The IP address has been banned for exceeding rate limits.");
 		Object.setPrototypeOf(this, RateLimitBanError.prototype);
 		this.name = "RateLimitBanError";
+		this.code = code;
 	}
 };
 /**
@@ -848,10 +856,11 @@ var NetworkError = class NetworkError extends Error {
 * @param msg - An optional error message.
 */
 var NotFoundError = class NotFoundError extends Error {
-	constructor(msg) {
+	constructor(msg, code) {
 		super(msg || "The requested resource was not found.");
 		Object.setPrototypeOf(this, NotFoundError.prototype);
 		this.name = "NotFoundError";
+		this.code = code;
 	}
 };
 /**
@@ -859,10 +868,11 @@ var NotFoundError = class NotFoundError extends Error {
 * @param msg - An optional error message.
 */
 var BadRequestError = class BadRequestError extends Error {
-	constructor(msg) {
+	constructor(msg, code) {
 		super(msg || "The request was invalid or cannot be otherwise served.");
 		Object.setPrototypeOf(this, BadRequestError.prototype);
 		this.name = "BadRequestError";
+		this.code = code;
 	}
 };
 
@@ -980,10 +990,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));
 	}
 	/**
@@ -992,10 +1003,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;
@@ -1193,14 +1208,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);
 	}
@@ -1479,7 +1495,7 @@ 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;
@@ -1487,14 +1503,42 @@ var WebsocketStreamsBase = class extends WebsocketCommon {
 		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}`;
@@ -1510,22 +1554,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);
@@ -1571,7 +1617,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);
 		}
@@ -1589,6 +1638,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.
@@ -1601,7 +1659,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));
 		});
 	}
 	/**
@@ -1618,17 +1684,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);
 		});
 	}
 	/**
@@ -1636,16 +1706,18 @@ 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],
@@ -1653,8 +1725,8 @@ var WebsocketStreamsBase = class extends WebsocketCommon {
 				};
 				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);
 			}
 		});
 	}
@@ -1664,7 +1736,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;
 	}
 };
 /**
@@ -1674,10 +1748,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) => {
@@ -1687,14 +1763,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);
 		}
 	};
 }
@@ -1717,7 +1793,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;