Fetch Balance All Exchanges

import * as fs from 'fs';
import ccxt from '../../js/ccxt.js';

// Fetch balances for all exchanges, all accounts, asynchronously and output a consolidated balance object

interface ExchangeConfig {
   apiKey: string;
   secret: string;
   options?: {
       owner?: string;
       [key: string]: any;
   };
   [key: string]: any;
}

interface KeysConfig {
   [exchangeId: string]: ExchangeConfig;
}

interface Balance {
   [exchangeId: string]: {
       [marketType: string]: {
           [currency: string]: string;
       };
   };
}

interface MarketBalances {
   [marketType: string]: {
       [currency: string]: string
   }
}

/**
* @description Helper function to compare two balance objects
* @param bal1
* @param bal2
* @returns {boolean} true if balances are equal
*/
function balancesEqual (bal1: { [currency: string]: string }, bal2: { [currency: string]: string }): boolean {
   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: [string, KeysConfig][] = 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 as any;
               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: Balance = {};

       results.forEach (({ exchangeId, success, balances }) => {
           if (success && balances) {
               // collect all balances for each market type
               const marketBalances: MarketBalances = {};

               balances.forEach (({ marketType, 'success': balanceSuccess, balance }) => {
                   if (balanceSuccess && balance) {
                       marketBalances[marketType] = {};

                       Object.entries (balance).forEach (([ currency, info ]: [string, any]) => {
                           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: string[] = [];
               const seenBalances: { [key: string]: string }[] = [];

               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);
}