crypto-bot/index.js

multi-function tools for blockchain automation

const { logger } = require('crypto-bot-logger');
const tools = require('crypto-bot-tools');
const { botType } = require('crypto-bot-core');
const { dirname } = require('path');

const {Network} = require('crypto-bot-network')
const {ExchangeList} = require('crypto-bot-exchange')
const {TokenList} = require('./lib//bot-token.js')
const {WalletList} = require('crypto-bot-wallet')
const {CryptoSniper} = require('crypto-bot-sniper')
const {CryptoCleaner} = require('crypto-bot-cleaner')
const {CryptoArbitrage} = require('crypto-bot-arbitrage')
const {CryptoMenu} = require('./lib/bot-menu.js')

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

const appDir = dirname(require.main.filename);
const configpath = appDir + '/config'
const provider = configpath + "/networks/provider.js";

class CryptoBot {
    //networks = new Map()
    constructor(){
        this.menu = undefined
        this.menuStatus = 0
        this.networks = undefined
        this.networksStatus = 0
        this.status = 0  // 0 = init
        this.exchanges = undefined
        this.exchangesStatus = 0
        this.tokens = undefined
        this.tokensStatus = 0
        this.scenario = undefined
        this.scenarioStatus = 0
        this.wallets = undefined
        this.walletStatus = 0
        this.sniper = undefined
        this.sniperStatus = 0
        this.cleaner = undefined
        this.cleanerStatus = 0
        this.arbitrage = undefined
        this.arbitrageStatus = 0
    }

    initCryptoBot = async function(){
        logger.info('Initializing Crypto BOT ... ')
        this.menu = new CryptoMenu()
        this.menuStatus = 1
    }

    initCryptoBotNetwork = async function(){     
      logger.info("Loading network from config...")
      const _result = await tools.readFile(null, botType.NETWORK_TYPE, null)
      //console.log(require.main)
      let _networkFound = false

      if( _result.length > 0){
          _networkFound = true
          const _newNetwork = new Array()
          for(let i = 0 ; i < _result.length ; i++){
              let _res = _result[i]
              let _chain = _res.chainId
              let _endpoints = this.getEndpoints(_chain)
              const _net = new Network(_res.chainId, _res.status, _res.name, _res.shortName, _res.network, _res.symbol, _endpoints)
              
              _newNetwork.push(_net)
          }

          this.networks = new Object(_newNetwork)
          this.networksStatus = 1
      }

      this.status = 1



      if(_networkFound){
          return true
      }
      else{
          return false
      }

    }

    initCryptoBotExchanges = async function(){
        logger.info("Loading exchanges from config...")
        const _newExchange = new Array()
        for(let i = 0 ; i < this.networks.length ; i++){
            const _listExchange = await tools.readFile(this.networks[i], botType.EXCHANGE_CONFIG_TYPE, null)

            let _xchange = undefined
            
            if(_listExchange.length > 0 ){
                // load exchange data
                _xchange = new ExchangeList(this.networks[i], _listExchange)
                await _xchange.initExchangeList(this.networks[i], _listExchange)
            }
            else{
                _xchange = new ExchangeList(this.networks[i], [])
                await _xchange.initExchangeList(this.networks[i], _listExchange)
            }
            _newExchange.push(_xchange)

        }
                
        this.exchanges = new Object(_newExchange)
        this.exchangesStatus = 1

        return true

    }

    initCryptoBotTokens = async function(){
        logger.info("Loading token from config...")
        const _newToken = new Array()
        for(let i = 0 ; i < this.networks.length ; i++){
            const _token = await tools.readFile(this.networks[i], botType.TOKEN_TYPE, null)
            let _tokens = undefined
            const _chain = this.networks[i].chainId
            if(_token.length > 0 ){
                _tokens = new TokenList(_chain, _token)
            }
            else{
                _tokens = new TokenList(_chain, [])
            }
            _newToken.push(_tokens)
        }

        this.tokensStatus = 1      
        this.tokens = new Object(_newToken)

        return true
    }

    initCryptoBotWallets = async function(){
        logger.info("Loading wallets from config...")
        ///const _listWalletData = await tools.readFile(null, botType.WALLET_DB, null)
        
        const source = 0; //JSON
        //const source = 0; //MongoDB
        this.wallets = new WalletList()
        //await this.wallets.loadWalletData()
        while(this.wallets.status == 0){
            await sleep(100);
            logger.info(` Crypto BOT wallets is not loaded yet .. sleeping`);
            //return []            
        }        

        //this.wallets.
        this.walletStatus = 1

        return true
    }

    initCryptoBotSniper = async function(NetworkArray, Wallet){
        logger.info("Preparing Sniper BOT ...")
        this.sniper = new CryptoSniper(NetworkArray, Wallet)
        this.sniperStatus = 1
        return true
    }

    initCryptoBotCleaner = async function(NetworkArray, Wallet){
        logger.info("Preparing Cleaner BOT ...")        
        this.cleaner = new CryptoCleaner(NetworkArray, Wallet)
        this.cleanerStatus = 1
        return true
    }

    initCryptoBotArbitrage = async function(Network, _Oracle, _Option){
        logger.info("Preparing Arbitrage BOT ...")        
        this.arbitrage = new CryptoArbitrage(Network, _Oracle, _Option)
        this.arbitrageStatus = 1
        this.option = _Option
        return true
    }

    getStatus = function() { return this.status }

    getNetworkCount = function() {
        if(this.networksStatus == 0){
            logger.error(` Crypto BOT network is not loaded yet`);
            return false
        }

        return this.networks.length
    }

    getEndpoints = function(_chain){

        const _https = new Array()
        const _httpsProvider = new Array()
        const _wss = new Array()
        const _wssProvider = new Array()
    
        let Provider = require(provider)
        //console.log(Provider.ProviderOrder.length)

        let _defHttps = undefined
        let _defHttpsName = undefined
        let _defWss = undefined        
        let _defWssName = undefined

        // Add provider according to order in provider.js.
        // TODO: be specific for 1 network.
        for(let pIndex = 0 ; pIndex < Provider.ProviderOrder.length ; pIndex++){
            let _providerName = Provider.ProviderOrder[pIndex]
            let _order = _providerName

            let _provider = undefined
            switch(_order) {
                case "moralis":
                  _provider = new Object(Provider.Moralis)
                  break;
                case "chainstack":
                  _provider =  new Object(Provider.ChainStack)
                  break;
                case "quicknode":
                  _provider =  new Object(Provider.Quicknode)
                  break;
                case "infura":
                  _provider =  new Object(Provider.Infura)
                  break;                
                default:
                  _provider =  new Object(Provider.Default)
              }
         
            for(let i = 0 ; i < _provider.length ; i++){
                let _data = new Object(_provider[i])
                if(_data.chainId == _chain){
            
                    if(_data.https.length > 0){
                        if(_defHttps == undefined){
                            _defHttps = _data.https
                            _defHttpsName = _order
                        } 
                        _https.push(_data.https)
                        _httpsProvider.push(_providerName)
                    } 
                    if(_data.wss.length > 0) {
                        if(_defWss == undefined){
                            _defWss = _data.wss
                            _defWssName = _order
                        } 
                        _wss.push(_data.wss)
                        _wssProvider.push(_providerName)
                    }
                }
            }

        }


        if(_defHttps == undefined) _defHttps = ""
        if(_defWss == undefined) _defWss = ""

        let _endpoints = new Object({
            "httpsName" : _defHttpsName,
            "https" : _defHttps,
            "httpsProvider" : _httpsProvider,
            "httpsEndpoints" : _https,

            "wssName" : _defWssName,
            "wss" : _defWss,
            "wssProvider" : _wssProvider,
            "wssEndpoints" : _wss
        })
    
        //console.log(_endpoints)
    
        return _endpoints
        
    }

    getExchangesList = function(_chain){
        if(this.exchangesStatus == 0){
            logger.error(` Crypto BOT exchanges is not loaded yet`);
            return false
        }        
        for(let i = 0 ; i < this.exchanges.length ; i++){
            if(this.exchanges[i].chainId == _chain) return this.exchanges[i]
        }
        return []
        
    }
    getExchangesCount = function(){
        if(this.exchangesStatus == 0){
            logger.error(` Crypto BOT exchanges is not loaded yet`);
            return false
        }
        return this.exchanges.length
    }

    getTokensList = function(_chain){
        if(this.tokensStatus == 0){
            logger.error(` Crypto BOT tokens is not loaded yet`);
            return false
        }

        for(let i = 0 ; i < this.tokens.length ; i++){
            if(this.tokens[i].chainId == _chain) return this.tokens[i]
        }
        return []
    }

    getTokensCount = function(){
        if(this.tokensStatus == 0){
            logger.error(` Crypto BOT tokens is not loaded yet`);
            return false
        }

        return this.tokens.length
    }

    getAllNetworkObject = function (){
        if(this.networksStatus == 0){
            logger.error(` Crypto BOT network is not loaded yet`);
            return false
        }

        return this.networks
    }

    getNetworkObject = function (_chain){
        if(this.networksStatus == 0){
            logger.error(` Crypto BOT network is not loaded yet`);
            return false
        }

        for(let i = 0 ; i < this.networks.length ; i++)
        {
            if(this.networks[i].chainId == _chain) return this.networks[i]
        }
        logger.error(`ChainId ${_chain} cannot be found...`)
        return new Network(_chain, "invalid", 'Unknown network', 'unkwnown', 'unknown', 'unknown', '???')
    }

    listAllNetworkInfo = function() {
            if(this.networksStatus == 0){
                logger.error(` Crypto BOT network is not loaded yet`);
                return false
            }
            //console.log(this.networks.length)
    
            for(let i = 0 ; i < this.networks.length ; i++)
            {
                let Network = this.networks[i];
                logger.info(`  ${Network.name} (${Network.chainId})`);
                //this.listNetworkInfo(Network);
                //console.log(Network)
            }        
            logger.info(`******************************************************************`);
            return true
    }

    getWalletList = function(){
        if(this.walletStatus == 0){
            logger.error(` Crypto BOT wallet is not loaded yet`);
            return []
        }
        //console.log(this.wallets)
        //process.exit()
        return this.wallets.getWalletList()
    }

    getSniper = function(){
        if(this.sniperStatus == 0){
            logger.error(` Crypto BOT sniper is not loaded yet`);
            return false
        }
        return this.sniper
    }

    getCleaner = function(){
        if(this.cleanerStatus == 0){
            logger.error(` Crypto BOT cleaner is not loaded yet`);
            return false
        }
        return this.cleaner
    }

    getArbitrage = function(){
        if(this.arbitrageStatus == 0){
            logger.error(` Crypto BOT arbitrage is not loaded yet`);
            return false
        }
        return this.arbitrage
    }

}

exports.CryptoBot = CryptoBot;

exports.menu = require('./lib/bot-menu')