crypto-bot/lib/bot5-pairs.js

multi-function tools for blockchain automation

const { logger } = require('./utils/logger');
const { sleep } = require('./utils/sleep');

const { ethers } = require("ethers");
const cliProgress = require('cli-progress');
const colors = require('ansi-colors');
const { Contract, Provider } = require('ethcall')
const { Table } = require("console-table-printer");
//const { tokenlist: token } = require('./../data/token');
const tools = require("./utils/tools");
const crypto = require("./utils/crypto");


//const botpairs = require('./bot5-pairs');
const EXCHANGE = require('./bot-exchange');

const fs = require('fs');
//const  { cryptolib: config }  = require(".");
//const botType = require('./core/type');
const   botType   = require('./core/type');


const FactoryJsonFile = "./lib/ABI/factory.json";
const factoryABI = JSON.parse(fs.readFileSync(FactoryJsonFile));
const exchangeJsonFile = "./lib/ABI/exchangePair.json";
const exchangePairABI = JSON.parse(fs.readFileSync(exchangeJsonFile));
const soulswapJsonFile = "./lib/ABI/factory/SoulSwap.json";
const routerABI = new ethers.utils.Interface(require("./ABI/router.json"));
const souswalABI = JSON.parse(fs.readFileSync(soulswapJsonFile));


const { pairlistHeader, exchangeHeader } = require('./utils/tableheader');

module.exports = {
    listPairs: async function (Network, Exchange, Option) {
        const p = new Table(pairlistHeader);
        const x = new Table(exchangeHeader);

        if(Option == undefined){
            Option = 0
        }
                
        logger.debug(`Entering listPairs function:  Options are: ${Option}`)
        //console.log(Exchange)
        if(Option == undefined){
            Option = 1;
        }

        let _list = await botpairs.readExchangeData(Network)

        for(let j = 0 ; j < _list.factory.length; j++ ){
            if(Exchange.factory == undefined){
                Exchange.factory = await this.getFactoryAddress(Network, Exchange.router);
                logger.warn(`Factory for not found in configuration.  Consider adding factory address: ${Exchange.factory} to configuration of ${Exchange.name}.`);
            }

            if( _list.factory[j].address == Exchange.factory ){
                x.addRow({ chain: Network.chainId, name: Exchange.name,  router: _list.factory[j].address, count: _listfactory[j].pairs.length})

                logger.verbose(`${Exchange.name} : ${_list.factory[j].pairs.length} pairs  details option: ${Option}`);        
                logger.debug(`Pair for exchange: ${_list.factory[j].address} `);
                const pairslist = _list.factory[j].pairs;
                if(Option != 0){
                    for(let i = 0 ; i < pairslist.length ; i++)
                    {
                        //logger.info(` ${pairslist[i].address} | token0: ${pairslist[i].token0} token1: ${pairslist[i].token1} lastBlock: ${pairslist[i].reserve[2]} `);
                        p.addRow({ chain: Network.chainId, network: Network.name, pair: pairslist[i].address, token0: pairslist[i].token0 ,token1: pairslist[i].token1, lastBlock: pairslist[i].reserve[2]})
                        //logger.info(` ${pairslist[i].address} | token0: ${pairslist[i].token0} token1: ${pairslist[i].token1} lastBlock: ${pairslist[i].reserve[2]} `);
                    }    
                    p.printTable();
                } 
            }
        }
        x.printTable();
        
        logger.debug("Listing pair for exchange completed...");
        return
    },

    listAllExchangePairs: async function (Network, _Option) {
                
        logger.debug(`Entering listAllExchangePairs:  Options are: ${_Option}`)
        if(_Option == undefined){
            _Option = 1;
        }

        const xList = await EXCHANGE.getExchangeList(Network);

        //console.log(xList)
        
        if(Array.isArray(xList)){
            xList.forEach(xchange => {
                console.log(xchange.factory)
                EXCHANGE.listExchangePairs(Network, xchange)            
            });
            if(xList.length == 0){
                logger.warn(`no exchange found for ${Network.name} (${Network.chainId})`)
            }
        }

        logger.debug("End list pair for all exchange completed...");
        return
    },



    getFactoryAddress: async function (Network, routerAddress) {      
        logger.debug(`Getting factory address for ${routerAddress}`);
        const provider = new ethers.providers.JsonRpcProvider(Network.https[0]);
        const wallet = new ethers.Wallet(process.env.PRIVATE_KEY);
        const account = wallet.connect(provider);

        const router = new ethers.Contract(routerAddress, routerABI, account);
        // const router = new ethers.Contract(routerlist[i].router, uniswapABI, account);  //OTHER ABI
        const routerFactory = await router.factory();

        return routerFactory;
    },


    //updateFactoryCount: async function(Network, Exchange, Option) {      
    //
    //},

    updateFactoryPairs: async function (Network, Exchange, Option) {      

        logger.verbose(`Getting pairs address from (${Network.chainId}) ${Exchange.name}`);
        if(Option == undefined){
            Option = 0
        }

        const provider = new ethers.providers.JsonRpcProvider(Network.https[0]);
        const wallet = new ethers.Wallet(process.env.PRIVATE_KEY);
        const account = wallet.connect(provider);

        if(Exchange.factory == undefined){
            Exchange.factory = await this.getFactoryAddress(Network, Exchange.router);
        }

        
        const routerFactory = Exchange.factory;
        let factoryContract = undefined;

        const PairArray = new Array();
        const PairIndexArray = new Array();
        //const _PairIndexArray = new Array();
        let allPairsLength = undefined
        
        if(routerFactory != '0x1120e150dA9def6Fe930f4fEDeD18ef57c0CA7eF'){
            factoryContract = new ethers.Contract(
                routerFactory,
                factoryABI,
                account
            );
            allPairsLength = await factoryContract.allPairsLength(); 
        }
        else{
            factoryContract = new ethers.Contract(
                routerFactory,
                souswalABI,
                account
            );
            allPairsLength = await factoryContract.totalPairs();     
        }
        logger.info(` (${Network.chainId}) Factory address: ${routerFactory} ${allPairsLength} pairs found in exchange`);

        // pair list
        logger.verbose(` Rebuilding pairs index...`)
        //const _latestCount = allPairsLength;
        await this.rebuildPairIndex(Network, Exchange);
        logger.verbose(` Loading pairs index from data files...`)
        const _pairIndex = await this.getPairIndex(Network, Exchange);
        // pair data
             

        logger.verbose( ` Validating and rebuilding pair data.,,`)
        const _newPairData = await this.rebuildPairData(Network, Exchange, _pairIndex.length )

        logger.info(`Rebuild data has returned ${_newPairData} `)
        await sleep(1000);
        const currentFactoryData = await this.getPairData(Network, Exchange)

        const delta = _pairIndex.length - currentFactoryData.length;
        const newPairCount = allPairsLength - _pairIndex.length

        let startLoad = 0
        let rebuild = false
        let rebuildIndex = false

        if(delta == 0)
        {
            logger.verbose(` No delta found between Pair Index file ${_pairIndex.length} and Pair Data file ${currentFactoryData.length} `)
            startLoad = _pairIndex.length;
        } else if( delta > 0){
            logger.warn(` Delta found between Pair Index ${_pairIndex.length} and Pair Data ${currentFactoryData.length}`)
            rebuild = true
        } else {
            logger.error(` Delta found between Pair Index ${_pairIndex.length} and Pair Data ${currentFactoryData.length}`)
            rebuild = true
        }

        if( allPairsLength > _pairIndex.length){
            if( rebuildIndex){
                startLoad = 0
            }else{
                startLoad = _pairIndex.length
            }
            
        }else{
            if( rebuildIndex){
                startLoad = 0
            }else{
                startLoad = _pairIndex.length
            }
        }
        logger.verbose(` ${newPairCount} new pair to load. rebuildIndex: ${rebuildIndex} rebuildData: ${rebuild}`)

        //************************************************************** */
        let _resize = crypto.resizeMultiCallArray( (allPairsLength-startLoad), botType.MULTI_CALL_PAIRINFO);

        //let _index = 0;
        const title = `(${Exchange.name}) - extracting new pair index |`
        const bar1 = new cliProgress.SingleBar({format: title + colors.green('{bar}') + '| {percentage}% | {value}/{total} pair'}, cliProgress.Presets.shades_classic);

        let toDo = allPairsLength-startLoad

        if(toDo > 0) bar1.start(toDo, 0);
        let _countProgress = 0; 
        for(let pos = startLoad ; pos < allPairsLength; (pos=pos + _resize) ){

            if( (pos + _resize > allPairsLength)) _resize = allPairsLength - pos;
            //console.log(pos)
            //console.log(_resize)
            const _partialdata = await this.multiCallPair(Network, pos, _resize, routerFactory, factoryABI );
            for(let j = 0; j < _partialdata.length ; j++){
                const PairData = new Object(_partialdata[j]);
                PairIndexArray.push(PairData);
                logger.debug(`address: ${PairData.address} index: ${PairData.index}`)
            }
            _countProgress = _countProgress + _partialdata.length;
            bar1.update(_countProgress); 
        }
        bar1.update(_countProgress); 
        bar1.stop();

        if( startLoad != 0 ){
            await this.addPairIndex(Network, PairIndexArray, Exchange);
            logger.verbose(` ${PairIndexArray.length} pairs index added from factory`); 
        }
        else{
            await this.writePairIndex(Network, PairIndexArray, Exchange);
            logger.verbose(` ${PairIndexArray.length} pairs index retreived from factory`);    
        }
        //************************************************************** */
     

        let _splitpairAddress = undefined
        let count = 0
        let _RebuildData = new Array();
        
        let _PairIndexArray = undefined

        const _currentFactoryData = await this.getPairData(Network, Exchange)
        if( rebuild ){
            logger.info(` rebuild ${rebuild} `)
            let currentDataLen = _currentFactoryData.length

            _PairIndexArray = await this.getPairIndex(Network, Exchange)

            if(currentDataLen > _PairIndexArray.length){
                logger.error(` error there's no more data then expected.  Sanity to create`)
            }

            for(let i = 0 ; i < _PairIndexArray.length ; i++){
                let _tempData = new Object(_PairIndexArray[i])
                if( !(i < currentDataLen) ){
                    _RebuildData.push(_tempData)
                }
            }
            _splitpairAddress = crypto.splitMultiCall(_RebuildData, botType.MULTI_CALL_PAIRDATA);
            count = _RebuildData.length  // local
        } else {
            _splitpairAddress = crypto.splitMultiCall(PairIndexArray, botType.MULTI_CALL_PAIRDATA);
            count = PairIndexArray.length
        }

        const title2 = `(${Exchange.name}) - extracting pair information |`
        const bar2 = new cliProgress.SingleBar({format: title2 + colors.green('{bar}') + '| {percentage}% | {value}/{total} pair'}, cliProgress.Presets.shades_classic);

        let _countProgress2 = 0;
        //console.log(count)
        if(count > 0 ) bar2.start(count, 0);
        // open read file in read mode to append.
        // Doesn't work since I need 1 array [{data},],  not []!!!
        // Solution ... build a temp file, then rewrite master file!! :-)
        
        for(let i = 0 ; i < _splitpairAddress.length ; i++){
            
            const _pairdate = await this.multiGetPairData(Network, _splitpairAddress[i], exchangePairABI );
            if( !(_pairdate.length == _splitpairAddress[i].length) ){
                logger.error(` Received data for  ${_pairdate.length} new token.  Expected data for: ${_splitpairAddress[i].length}`)
                //console.log(_splitpairAddress[i])
                //return
            }
            else{
                logger.verbose(` Received data for ${_pairdate.length} new pair...`)
                //console.log(_pairdate)
                let _realTimeArray = new Array();
                for(let j = 0; j < _pairdate.length ; j++){
                    const PairObject = _pairdate[j]
                    PairArray.push(PairObject);
                    _realTimeArray.push(PairObject)
                    logger.verbose(` Address: ${PairObject.address} (${PairObject.symbol}) token0: ${PairObject.token0} token1: ${PairObject.token1} lastBlock: ${PairObject.reserve[2]}`)
                }
                // should call append here instead
                tools.writeFile(Network, botType.PAIRDATA_TEMP_TYPE, Exchange, _realTimeArray )
        
                //await this.addPairData(Network, _realTimeArray, Exchange);
                logger.verbose(` ${_realTimeArray.length} pairs data added to factory file`); 
            }
            _countProgress2 = _countProgress2 + _pairdate.length;
            bar2.update(_countProgress2); 
        }
        bar2.update(_countProgress2); 
        bar2.stop();

        // Now let's reload the tempFile into 1 Big Array
        const _FinalData = new Array()
        //const _newdata = await this.readTempFolderData(Network, Exchange)
        const _newdata = await tools.readFolderData(Network, botType.PAIRDATA_TEMP_TYPE, Exchange);

        if(_newdata.length > 0) logger.info(` ${_newdata.length} pair data found on disk after extraction.`)

        if( _newdata.length > 0 ){
            for(let i = 0 ; i < _newdata.length ; i++ ){
                let _data = new Object(_newdata[i])
                _FinalData.push(_data)     
            }
            logger.verbose(` ${_newdata.length} data found in temp file.  ${_FinalData.length} data added from temp file.`)
    
            if( _FinalData.length > 0 ){
                logger.info(` Adding ${_FinalData.length} pair data to disk.`)
                await this.addPairData(Network, _FinalData, Exchange);
                await tools.deleteFolderData(Network, botType.PAIRDATA_TEMP_TYPE ,Exchange);
            } 
        }        
        return
    },

    rebuildPairData: async function (Network, Exchange, _maxData){
        logger.info(` Rebuilding the Pair Data file...`);
        // Now let's reload the tempFile into 1 Big Array
        const _TempData = new Array()
        const _tempFolderData = await tools.readFolderData(Network, botType.PAIRDATA_TEMP_TYPE, Exchange);

        if(_tempFolderData.length > 0) logger.verbose(` ${_tempFolderData.length} pair data found in temp folder.`)

        if( _tempFolderData.length > 0 ){
            for(let i = 0 ; i < _tempFolderData.length ; i++ ){
                let _data = new Object(_tempFolderData[i])
                _TempData.push(_data)
            }

            if( _TempData.length > 0 ) {
                logger.info(` Adding ${_TempData.length} pair data from temp folder to data files.`)
                await this.addPairData(Network, _TempData, Exchange);
                await tools.deleteFolderData(Network, botType.PAIRDATA_TEMP_TYPE, Exchange)
            }
            await sleep(5000);
        }

        const _pairData = await this.getPairData(Network, Exchange);
        logger.verbose( ` ${_tempFolderData.length} data found in temp files.  ${_TempData.length} data added from temp files. Total record: ${_pairData.length}`)

        let _finalCount = 0;

        let _index = new Array();
        let _rebuildPairData = new Array();
        let _unsyncIndex = new Array();
        // parse all to build index arrayee
 
        let counter = 0;
        for( let k = 0 ; k < _pairData.length ; k++){
            let _data = new Object(_pairData[k])
            if( (_data.index == counter)  ){
                _index.push(_data);
                counter++
            } else{
                //console.log(k)
                _unsyncIndex.push(_data);
                //console.log(_data)
            }
        }

        if( _pairData.length != _index.length){
            logger.info(` Found ${_pairData.length} pair data in data file.  It will be fixed automatically.`);
        }
        
        let _countIndex = 0;
        for(let k = 0 ; k < _index.length ; k++){
            let _data = new Object(_index[k]);
            //let found = false
            if( (_data.index == _countIndex) ){
                // good
                _rebuildPairData.push(_data)
                _countIndex++;            
            } else {
                // CHECK UNSYNC DATA
                let foundInSync = false
                for(let i = 0 ; i < _unsyncIndex; i++ ){
                    let _unsyncData = _unsyncIndex[i]
                    if(_unsyncData.index == _countIndex){
                        // good
                        if(!foundInSync){
                            _rebuildPairData.push(_unsyncData);
                            logger.info(` fixing out of order index. ${_unsyncData.index} for ${_unsyncData.address}`);
                            _countIndex++;
                            foundInSync = true
                            break;    
                        }
                    } 
                }
                if(!foundInSync ){
                    _unsyncIndex.push(_data);
                    //logger.warn(` out of order index. ${_data.index} for ${_data.address}`);
                }
            }
        }

        let _target = _pairData.length
        //logger.info(` Found ${_target} pair data in index file.`)
        let _FinalRebuildPairData = new Array();

        if( (_unsyncIndex.length > 0 )){
            logger.info(` ${_unsyncIndex.length} out-of-sync index.`);
            logger.info(` ${_rebuildPairData.length} record in first pass of rebuild: ${_rebuildPairData.length}`)
    

            for(let k = 0 ; k < _rebuildPairData.length ; k++){
                let currentIndex = k;
    
                let found = false
                if( (currentIndex <= _rebuildPairData.length) ){
                    for(let P = currentIndex ; P < _rebuildPairData.length ; P++){

                        if( !found ){
                            let currentPair = new Object(_rebuildPairData[P]);
        
                            if(currentIndex == currentPair.index){
                                //all good
                                if(!found){
                                    _FinalRebuildPairData.push(currentPair);
                                    found = true;
                                    break;
                                }
                            }
                            else{
                                // how to find quickly in array
                                let _found = false
                                let _maxTry = _unsyncIndex.length
                                let _loop =0
                                while( (!_found && (_loop <_maxTry)) ){
                                    let _dataUnsync = _unsyncIndex.shift();
                                    if( (_dataUnsync.index == currentIndex)){
                                        // good
                                        _FinalRebuildPairData.push(_dataUnsync);
                                        _found = true;
                                        found = true;
                                    } else{
                                        //check for duplicate.
                                        if(_dataUnsync.index > currentIndex){
                                            _unsyncIndex.push(_dataUnsync)
                                        } // else just drop it it's a duplicate.
                                    }
                                    _loop++
                                }
                                if(_loop >= _maxTry){
                                    logger.error(` Unable to find index: ${currentIndex} in un-sync data.`)
                                }    
                            }
                        }else{
                            break;
                        }
                    }
                }
            }           
             
            // here we continue from un sync data.
            // how to find quickly in array
            let _found = false
            
            let _loop = 0
            let _keepRunning = true
            let _startIndex = _FinalRebuildPairData.length;
            let _runningIndex = _startIndex;
            let _iteration = 0
            let _MAXtarget = _startIndex + _unsyncIndex.length
            logger.verbose(` rebuilding from this start index in unsync data: ${_runningIndex} Max record to add: ${_MAXtarget} `)

            const title = `${Exchange.name} | rebuilding from un-sync data |`
            const bar1 = new cliProgress.SingleBar({format: title + colors.green('{bar}') + '| {percentage}% | {value}/{total} pair data '}, cliProgress.Presets.shades_classic);
    
            // sorting array

            bar1.start(_MAXtarget, 0);

            _unsyncIndex.sort(function(a, b){return a.index - b.index});

            let _maxTry = _unsyncIndex.length
            while( _keepRunning ){
                _iteration++
                if( (_loop > _maxTry) && (!_found)){
                    logger.debug(` Unable to find index: ${_runningIndex} in loop ${_loop} `)
                    _keepRunning = false
                } else if (_found) {
                    _found = false;
                    _loop = 0;
                    _runningIndex++
                    
                    if( _runningIndex % 100 ) bar1.update(_runningIndex);
                }
                if( !(_maxTry == 0) ){
                let _dataUnsync = _unsyncIndex.shift();
                _maxTry = _unsyncIndex.length
                    if( (_dataUnsync.index == _runningIndex)){
                        // good
                        _FinalRebuildPairData.push(_dataUnsync);
                        //console.log(_dataUnsync.index)
                        _found = true;
                    } else{
                        //check for duplicate.
                        if(_dataUnsync.index > _runningIndex){
                            //console.log(_dataUnsync.index)
                            _unsyncIndex.push(_dataUnsync)
                        } // else just drop it it's a duplicate.
                    }
                } else{
                    _keepRunning = false;
                }

                _loop++
            } 
            bar1.stop();
            logger.info(` Start index: ${_startIndex} Last index found: ${_runningIndex} Pair data added: ${_runningIndex-_startIndex}.  It took ${_iteration} iteration to complete `)

            
            if( (_FinalRebuildPairData.length > _rebuildPairData.length) || (_FinalRebuildPairData.length <= _maxData) ){
                logger.info(` Successfully re-order and sync pair data. ${_FinalRebuildPairData.length}.`)
                _finalCount = _FinalRebuildPairData.length
                await this.writePairData(Network, _FinalRebuildPairData, Exchange)
            }
            else{
                logger.error(` Final rebuild record: ${_FinalRebuildPairData.length} Original record: ${_target}`)
            }
        }
        else {
            logger.info(` No issue found for ${_rebuildPairData.length} pair data.`)
        }

        logger.info(` Rebuilding of the Pair Data file completed.`);
        return _finalCount
    },

    rebuildPairIndex: async function (Network, Exchange){
        logger.info(` Rebuilding the Pair Index file...`);
        const _pairIndex = await this.getPairIndex(Network, Exchange);

        let _index = new Array();
        let _rebuildPairIndex = new Array();
        let counter = 0;
        // parse all to build index array

        for(let k = 0 ; k < _pairIndex.length ; k++){
            let _tempData = new Object(_pairIndex[k])
            if( _tempData.index == counter ){
                _index.push(_tempData);
                counter++
            } else{
                console.log(k)
                _unsyncIndex.push(_tempData);
                console.log(_tempData)
            }
        }

        if( _pairIndex.length != _index.length){
            logger.warn(` Found ${_pairIndex.length} pair index in file.  Loaded ${_index.length} pair. It will be fixed automatically.`);
        }

        let _countIndex = 0;
        let _unsyncIndex = new Array();

        for(let k = 0 ; k < _index.length ; k++){
            let _data = new Object(_index[k]);
            if(_data.index == _countIndex){
                // good
                _rebuildPairIndex.push(_data)
                _countIndex++;            
            } else {
                // CHECK UNSYNC DATA
                let foundInSync = false
                for(let i = 0 ; i < _unsyncIndex; i++ ){
                    let _unsyncData = _unsyncIndex[i]
                    if(_unsyncData.index == _countIndex){
                        // good
                        _rebuildPairIndex.push(_unsyncData);
                        logger.info(` fixing out of order index. ${_unsyncData.index} for ${_unsyncData.address}`);
                        _countIndex++;
                        foundInSync = true
                    } 
                }
                if(!foundInSync ){
                    _unsyncIndex.push(_data);
                }
            }
        }

        logger.verbose(` Found ${_unsyncIndex.length} un-sync record.`);
        logger.verbose(` Number of record in rebuild pair index: ${_rebuildPairIndex.length}`)

        let _target = (_pairIndex.length)
        let _FinalRebuildPairIndex = new Array();

        if( !(_target == _rebuildPairIndex.length)){

            for(let k = 0 ; k < _target ; k++){
                let currentIndex = k;
    
                let found = false
                for(let P = 0 ; P < _rebuildPairIndex.length ; P++){
                    let currentPair = new Object(_rebuildPairIndex[k]);
                    if(currentIndex == currentPair.index){
                        //all good
                        if(!found){
                            _FinalRebuildPairIndex.push(currentPair);
                            found = true;
                            break;
                        }
                    }
                    else{
                        // index missing here... will add from sync...
                        for(let i = 0 ; i < _unsyncIndex.length ; i++){
                            let _syncIndex = _unsyncIndex[i];
                            if( (_syncIndex.index == currentIndex)){
                                // good
                                if(!found){
                                    _FinalRebuildPairIndex.push(_syncIndex);
                                    found = true;
                                    break;
                                }
                            }
                        }                
                    }
        
                }
            }
            if(_FinalRebuildPairIndex.length == _pairIndex.length ){
                logger.info(` Successfully re-order and sync pair data index. ${_FinalRebuildPairIndex.length}.`)
                await this.writePairIndex(Network, _FinalRebuildPairIndex, Exchange)
            }
            else{
                logger.error(` Final rebuild record: ${_FinalRebuildPairIndex.length} Original record: ${_pairIndex.length}`)
            }
        } else{
            logger.info(` No issue found for pair index. ${_rebuildPairIndex.length}.`)
        }
        logger.verbose(` Rebuilding of the Pair Index file completed.`);
    },

    multiCallPair: async function(Network, _index, pairCount, factory, factoryABI) {

        logger.verbose(`ChainID: ${Network.chainId} - ${Network.name} - ${Network.https[0]}` );
        let provider = Network.https[0];

        let result2 = undefined;
        try {
            result2 = await this.call(provider, _index, pairCount, factory, factoryABI );
        } catch (e) {
            logger.info(`${e}`);
        }

        logger.verbose("Done multiCallPair...")
        return result2
    },

    multiGetPairData: async function(Network, _pairlist, exchangePairABI) {

        logger.verbose(`ChainID: ${Network.chainId} - ${Network.name} - ${Network.https[0]}` );
        let provider = Network.https[0];

        let result = undefined;
        try {
            result = await this.call2(provider, _pairlist, exchangePairABI );
        } catch (e) {
            logger.info(`${e}`);
        }

        //console.log(result)
        logger.verbose(" Done multiGetPairData...")
        return result
    },


    // return list of wallet data object.
    getPairData: async function(Network, Exchange){
        const _data = await tools.readFile(Network, botType.PAIRDATA_TYPE, Exchange)
        return _data
    },

        // return list of wallet data object.
    getAllPairData: async function(Network, Exchange){
        const _data = await tools.readFile(Network, botType.PAIRDATA_TYPE, null)
        return _data
    },
    // return list of wallet data object.
    getPairIndex: async function(Network, Exchange){
        const _data = await tools.readFile(Network, botType.PAIRINDEX_TYPE, Exchange)
        return _data
    },

    addPairIndex: async function (Network, PairIndex, Exchange) {       
        logger.verbose(` Saving ${PairIndex.length} pair index information for router ${Exchange.factory} `);

        let newArray =  new Array()

        const currentData = await this.getPairIndex(Network, Exchange);

        for(let j = 0; j < currentData.length ; j++){
            const PairIndexObject = currentData[j]
            newArray.push(PairIndexObject);
        }
        
        for(let k = 0 ; k < PairIndex.length ; k++)
        {
            const PairIndexObject = PairIndex[k]
            newArray.push(PairIndexObject)
        }

        await tools.writeFile(Network, botType.PAIRINDEX_TYPE, Exchange, newArray)

    }, 

    // TO BE REDONE RE-VISIT
    addPairData: async function (Network, PairArray, Exchange) {       
        logger.verbose(` Saving ${PairArray.length} pair data information for router ${Exchange.factory} `);

        const _currentData = new Object(await this.getPairData(Network, Exchange));

        logger.verbose(` Loaded ${_currentData.length} pair data information for factory ${Exchange.factory} `);

        
        for(let k = 0 ; k < PairArray.length ; k++)
        {
            const PairObject = new Object(PairArray[k])
            //newArray.push(PairObject)
            _currentData.push(PairObject)
        }

        await tools.writeFile(Network, botType.PAIRDATA_TYPE, Exchange, _currentData)
        logger.info(` Final count after merging: ${_currentData.length} pair data information for factory ${Exchange.factory} `);

    },     

    writePairIndex: async function (Network, PairIndex, Exchange) {       
        logger.verbose(` Saving ${PairIndex.length} token information for router ${Exchange.factory} `);

        const _result = await tools.writeFile(Network, botType.PAIRINDEX_TYPE, Exchange, PairIndex)
        if(_result) {
            return true;
        }
        else {
            logger.error(`error while saving record saved. `)
            return false;
        }
    }, 
    
    writePairData: async function (Network, PairArray, Exchange) {       
        logger.verbose(` Saving ${PairArray.length} token information for router ${Exchange.factory} `);

        const _result = await tools.writeFile(Network, botType.PAIRDATA_TYPE, Exchange, PairArray)
        if(_result) {
            return true;
        }
        else {
            logger.error(`error while saving record saved. `)
            return false;
        }
    }, 
       

    // NOT USED 
    getPairs: async function (factory, index, account, exchangePairABI) {       
        logger.debug(`Getting pairs ${index}`);

        const pairAddress = await factory.allPairs(index);
    
        const getTokenName = new ethers.Contract(
            pairAddress, 
            exchangePairABI,
            account)
      
        const token0 = await getTokenName.token0();
        const token1 = await getTokenName.token1();
        const reserves = await getTokenName.getReserves();

        logger.debug(` getPairs: ${pairAddress} : ${token0}  :  ${token1} : ${reserves}`);
        const PairObject = Object({
            "address": pairAddress,
            "token0": token0,
            "token1": token1,
            "reserve": reserves
        })
        return PairObject;
        //logger.info("Pair (" + i +") : "+ pairAddress + " : "+ token0symbol + " : " + token0 +" : "+ token0name +" : "+ reserves[0] + " : " + token1symbol + " : " + token1  +" : "+ token1name +" : "+ reserves[1] + " BlockNumber: " + reserves[2]);

    },

    call: async function(rpc, startIndex, pairCount, _routerFactory, _factoryABI) {

        const exchangePair = new Array();
        const pairArrayResult = new Array();

        const callarray = new Array();
        const ethcallProvider = new Provider();
        const provider = new ethers.providers.JsonRpcProvider(rpc);

        await ethcallProvider.init(provider);


        for (let i = 0; i < (pairCount); i++) {
            const FactoryContract = new Contract(
                    _routerFactory,
                    _factoryABI
                );
            exchangePair[i] = FactoryContract.allPairs(i+startIndex)
            callarray.push(exchangePair[i]);
        }

        
        const data = await ethcallProvider.all(callarray);

        let resultLength = data.length;
        logger.debug(`Number of pairs in result: ${resultLength}`);
        if (resultLength != callarray.length) {
            logger.error(`Error in the result data count | received:  ${resultLength}  vs expected: ${callarray.length} `);
        }

        for(let i = 0 ; i < data.length ; i++)
        {
            const PairObject = Object({
                "index": (i+startIndex),
                "address": data[i]
            }) 
            pairArrayResult.push(PairObject);
            logger.silly(`data received: ${data[i]}`)
        }            
        
        return (pairArrayResult)

    },
    call2: async function(rpc, _pairlist, _exchangePairABI) {
        const pairtoken0 = new Array();
        const pairtoken1 = new Array();
        const pairreserve = new Array();
        const pairAddress = new Array();
        const pairIndex = new Array();
        const pairDataArrayResult = new Array();
        const callarray = new Array();

        const ethcallProvider = new Provider();
        const provider = new ethers.providers.JsonRpcProvider(rpc);

        await ethcallProvider.init(provider);

        let totalCount = _pairlist.length;

        for (let i = 0; i < totalCount; i++) {
            let pairTemp = _pairlist[i]
            const FactoryPairContract = new Contract(
                pairTemp.address,
                    _exchangePairABI
                );
            pairtoken0[i] = FactoryPairContract.token0();
            pairtoken1[i] = FactoryPairContract.token1();
            pairreserve[i] = FactoryPairContract.getReserves();
            pairAddress[i] = pairTemp.address
            pairIndex[i] = pairTemp.index
            callarray.push(pairtoken0[i]);
            callarray.push(pairtoken1[i]);
            callarray.push(pairreserve[i]);
        }

        const data = await ethcallProvider.all(callarray);

        let resultLength = data.length;
        logger.debug(`Number of pairs in result: ${resultLength}`);
        if (resultLength != callarray.length) {
            logger.error(`Error in the result data count | received:  ${resultLength}  vs expected: ${callarray.length} `);
        }

        let count = 0;
        let index_pointer = 0;
        let tokenA = undefined;
        let tokenB = undefined;
        let reserveAB = undefined;
        for(let i = 0 ; i < data.length ; i++)
        {
            if(count == 0){
                tokenA = data[i]
                count++
            }
            else if(count == 1){
                tokenB = data[i]
                count++
            }
            else if(count == 2){
                reserveAB = data[i]
                const PairObject = new Object({
                    "index": pairIndex[index_pointer],
                    "address": pairAddress[index_pointer],
                    "token0": tokenA,
                    "token1": tokenB,
                    "reserve":reserveAB
                }) 
                //console.log(PairObject)
                pairDataArrayResult.push(PairObject);
                index_pointer++;
                count = 0;
            }
            logger.debug(`data received: ${data[i]}`)
        }
        
        return pairDataArrayResult

    },


}