Method futuresSubscribe

src/node-binance-api.ts:1856–1914

* Used to subscribe to a combined futures websocket endpoint * @param {string} streams - streams to connect to * @param {function} callback - the function to call when information is received * @param {object} params - Optional reconnect {boolean} (whether to reconnect on disconnect),

(streams, callback: Callback, params: Dict = {})

     * @return {WebSocket} - websocket reference
     */
    futuresSubscribe(streams, callback: Callback, params: Dict = {}) {
        if (typeof streams === 'string') return this.futuresSubscribeSingle(streams, callback, params);
        if (typeof params === 'boolean') params = { reconnect: params };
        if (!params.reconnect) params.reconnect = false;
        if (!params.openCallback) params.openCallback = false;
        if (!params.id) params.id = false;
        const httpsproxy = this.getHttpsProxy();
        let socksproxy = this.getSocksProxy();
        const queryParams = streams.join('/');
        // Binance routes USDⓈ-M futures streams to separate endpoints by category
        // (/public, /market, /private) and will not push cross-category streams on a
        // single connection. Reject mixed-category combos so they fail loudly instead
        // of silently dropping data — subscribe to each category on its own connection.
        const category = this.classifyFuturesStream(streams[0]);
        const mismatch = streams.find(s => this.classifyFuturesStream(s) !== category);
        if (mismatch !== undefined) {
            const mismatchCategory = this.classifyFuturesStream(mismatch);
            throw new Error(`futuresSubscribe: cannot combine '${category}' stream "${streams[0]}" with '${mismatchCategory}' stream "${mismatch}" on one connection. Binance routes futures streams to separate /public, /market and /private endpoints; subscribe to each category separately.`);
        }
        const baseUrl = this.getFStreamUrl(category);
        let ws: any = undefined;
        if (socksproxy) {
            socksproxy = this.proxyReplacewithIp(socksproxy);
            if (this.Options.verbose) this.Options.log(`futuresSubscribe: using socks proxy server ${socksproxy}`);
            const agent = new SocksProxyAgent({
                protocol: this.parseProxy(socksproxy)[0],
                host: this.parseProxy(socksproxy)[1],
                port: this.parseProxy(socksproxy)[2]
            });
            ws = new WebSocket(baseUrl + queryParams, { agent });
        } else if (httpsproxy) {
            if (this.Options.verbose) this.Options.log(`futuresSubscribe: using proxy server ${httpsproxy}`);
            const config = url.parse(httpsproxy);
            const agent = new HttpsProxyAgent(config);
            ws = new WebSocket(baseUrl + queryParams, { agent });
        } else {
            ws = new WebSocket(baseUrl + queryParams);
        }

        ws.reconnect = this.Options.reconnect;
        ws.endpoint = stringHash(queryParams);
        ws.isAlive = false;
        if (this.Options.verbose) {
            this.Options.log(`futuresSubscribe: Subscribed to [${ws.endpoint}] ${queryParams}`);
        }
        ws.on('open', this.handleFuturesSocketOpen.bind(this, ws, params.openCallback));
        ws.on('pong', this.handleFuturesSocketHeartbeat.bind(this, ws));
        ws.on('error', this.handleFuturesSocketError.bind(this, ws));
        ws.on('close', this.handleFuturesSocketClose.bind(this, ws, params.reconnect));
        ws.on('message', data => {
            try {
                if (this.Options.verbose) this.Options.log('futuresSubscribe: Received data:', data);
                callback(JSONbig.parse(data).data);
            } catch (error) {
                this.Options.log(`futuresSubscribe: Parse error: ${error.message}`);
            }
        });
        return ws;