Fetch Balance All Exchanges

import * as fs from 'fs';
import ccxt from '../../js/ccxt.js';
/**
 * @description Helper function to compare two balance objects
 * @param bal1
 * @param bal2
 * @returns {boolean} true if balances are equal
 */
function balancesEqual(bal1, bal2) {
    const keys1 = Object.keys(bal1).sort();
    const keys2 = Object.keys(bal2).sort();
    if (JSON.stringify(keys1) !== JSON.stringify(keys2)) {
        return false;
    }
    for (let i = 0; i < keys1.length; i++) {
        const key = keys1[i];
        if (bal1[key] !== bal2[key]) {
            return false;
        }
    }
    return true;
}
async function fetchAllBalances() {
    try {
        const keysData = fs.readFileSync('keys.local.json', 'utf-8');
        const exchanges = Object.entries(JSON.parse(keysData));
        const marketTypes = [
            { 'type': 'spot', 'params': {} },
            { 'type': 'margin', 'params': { 'type': 'margin' } },
            { 'type': 'swap', 'params': { 'type': 'swap' } },
            { 'type': 'swap', 'params': { 'type': 'swap', 'subType': 'linear' } },
            { 'type': 'swap', 'params': { 'type': 'swap', 'subType': 'inverse' } },
            { 'type': 'derivatives', 'params': { 'type': 'derivatives' } },
            { 'type': 'funding', 'params': { 'type': 'funding' } },
            { 'type': 'main', 'params': { 'type': 'main' } },
            { 'type': 'cross', 'params': { 'marginMode': 'cross' } },
            { 'type': 'isolated', 'params': { 'marginMode': 'isolated' } },
            { 'type': 'trading', 'params': { 'marginMode': 'trading' } },
            { 'type': 'cash', 'params': { 'type': 'cash' } },
            { 'type': 'future', 'params': { 'type': 'future' } },
            { 'type': 'account', 'params': { 'type': 'account' } },
            { 'type': 'financial', 'params': { 'type': 'financial' } },
            { 'type': 'wallet', 'params': { 'type': 'wallet' } },
        ];
        // create exchange instances and fetch balances in parallel
        const balancePromises = exchanges.map(async ([exchangeId, config]) => {
            try {
                const CCXT = ccxt;
                const ExchangeClass = CCXT[exchangeId];
                if (!ExchangeClass) {
                    throw new Error(`Exchange ${exchangeId} not found in CCXT`);
                }
                const exchange = new ExchangeClass({
                    'apiKey': config.apiKey,
                    'secret': config.secret,
                    'options': config.options,
                    'enableRateLimit': true,
                    'timeout': 30000,
                });
                // fetch balances for all market types
                const balanceResults = await Promise.allSettled(marketTypes.map(async ({ type, params }) => {
                    try {
                        const balance = await exchange.fetchBalance(params);
                        return {
                            'marketType': type,
                            'success': true,
                            'balance': balance,
                            'error': null,
                        };
                    }
                    catch (error) {
                        return {
                            'marketType': type,
                            'success': false,
                            'balance': null,
                            'error': error instanceof Error ? error.message : String(error),
                        };
                    }
                }));
                const balances = balanceResults.map((result) => (result.status === 'fulfilled' ? result.value : {
                    'marketType': 'unknown',
                    'success': false,
                    'balance': null,
                    'error': 'Promise rejected',
                }));
                return {
                    'exchangeId': exchangeId,
                    'success': true,
                    'balances': balances,
                    'error': null,
                };
            }
            catch (error) {
                return {
                    'exchangeId': exchangeId,
                    'success': false,
                    'balances': null,
                    'error': error instanceof Error ? error.message : String(error),
                };
            }
        });
        const results = await Promise.all(balancePromises);
        const balanceObject = {};
        results.forEach(({ exchangeId, success, balances }) => {
            if (success && balances) {
                // collect all balances for each market type
                const marketBalances = {};
                balances.forEach(({ marketType, 'success': balanceSuccess, balance }) => {
                    if (balanceSuccess && balance) {
                        marketBalances[marketType] = {};
                        Object.entries(balance).forEach(([currency, info]) => {
                            if (typeof info === 'object' && info !== null && parseFloat(info.total || '0') > 0) {
                                marketBalances[marketType][currency] = info.total;
                            }
                        });
                    }
                });
                // Filter out empty market types (no balances > 0)
                const nonEmptyMarketTypes = Object.keys(marketBalances).filter((marketType) => {
                    const balances = marketBalances[marketType];
                    return balances && Object.keys(balances).length > 0;
                });
                // Find unique market types (remove duplicates)
                const uniqueMarketTypes = [];
                const seenBalances = [];
                nonEmptyMarketTypes.forEach((marketType) => {
                    const balances = marketBalances[marketType];
                    const isDuplicate = seenBalances.some((seenBalance) => balancesEqual(seenBalance, balances));
                    if (!isDuplicate) {
                        uniqueMarketTypes.push(marketType);
                        seenBalances.push(balances);
                    }
                });
                balanceObject[exchangeId] = {};
                uniqueMarketTypes.forEach((marketType) => {
                    balanceObject[exchangeId][marketType] = marketBalances[marketType];
                });
            }
        });
        console.log(JSON.stringify(balanceObject, null, 2));
    }
    catch (error) {
        console.error('Error reading keys file:', error);
    }
}
try {
    fetchAllBalances();
}
catch (error) {
    console.error(error);
}