Best practice to watch huge number of tickers

Is it good practice, in Node.js case, to create one infinite while cycle for each symbol like this:

// !!! Can contain 700+ symbols.
const symbols = [
    '1INCH-PERP',
    'ADA-PERP'
];

// Solution 1
const exchange = new ccxt.ftx();

function start() {
    for (let symbol of symbols) {
        watchTicker(symbol);
    }
}

// One infinite while for each symbol will be created, so 700+ 'while' cycles.
// All processed in async way.
async function watchTicker(symbol) {
    while (true) {
        try {
            let ticker = await exchange.watchTicker(symbol);

           // do magic with ticker ...
        }
        catch (e) {
            console.log(e);
        }
    }
}

start();

Currently, we process all tickets in one while cycle, but considering switching to above solution. Current solution:

// Solution 2
const exchange = new ccxt.ftx();

function subscribeAll() {
    for (let symbol of symbols) {
        subscribe(symbol);
    }
}

async function subscribe(symbol) {
    try {
        await exchange.watchTicker(symbol);
    }
    catch (e) {
        console.log(e);
    }
}

// Contains only one infinite while for all subscribed symbols,
// but each ticker is processed synchronously one by one.
async function process() {
    while(true) {
        for (let symbol in exchange.tickers) {
            let ticker = exchange.tickers[symbol];

            // do magic with ticker ...
        }

        await delay(1000);
    }
}

function delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

subscribeAll();
process();

• OS: Debian (Docker)
• Programming Language version: JavaScript (Node.js)
• CCXT version: pro 0.9.35

[kroitor]

btw, maybe we can even add that as another ‘method’ type variable in fetchticker/s ? (here and here) [Not sure atm, how the parameter should be set, but actually, may apps/use-cases might just want bid/ask data for ‘all-tickers’ and this method will be useful for many users ?

Yeah, we can think of how to better merge the two methods with user-controllable options.

[kroitor]

@kroitor can you mention also 2 words, whether ‘fetchTickers’ is/isn’t suitable in such cases? if latency is not high, in every 500ms they might be obtainable, while seems to be quite enough for OP. (as he makes ‘process’ function to run after every 1000 ms delay, and I don’t see the app is that much untold-critical dependant on 500ms diapason).

Some of the bots I’ve worked with were much closer to real-time, dealing with milliseconds and sub-ms time precision. However, if +/- 500ms is not critical for this specific use-case, then fetchTicker/fetchTickers should be ok. Mind, however, that some exchanges (especially, Binance, the biggest one) will impose higher rate limits on fetchTickers, so you won’t be able to call it with Binance once or twice a second – they will ban you temporarily to cool off.