@qso-soft/shared/dist/managers/module-manager/module-manager.js

Shared library for QSO-soft

import { NOT_SAVE_FAILED_WALLET_ERRORS, SOMETHING_WENT_WRONG, SUCCESS_MESSAGES_TO_STOP_WALLET } from '../../constants';
import { createRandomProxyAgent, getProxyAgent, initLocalLogger, msgToTemplateTransform, showLogPreparedModules, sleepByRange, } from '../../helpers';
import { clearAllSavedModulesByName } from '../../helpers/modules/save-modules';
import { getGlobalModule } from '../../modules';
import { sendMsgToTG } from '../telegram';
import { getTgMessageByStatus } from '../telegram/helpers';
let walletIndex = 1;
export class ModuleManager {
    constructor({ walletWithModules, walletsTotalCount, baseNetwork, projectName }) {
        this.wallet = walletWithModules.wallet;
        this.modules = walletWithModules.modules;
        this.walletsTotalCount = walletsTotalCount;
        this.projectName = projectName;
        this.baseNetwork = baseNetwork;
    }
    async startModules({ logsFolderName }) {
        const walletId = this.wallet.id;
        const logger = initLocalLogger(logsFolderName, walletId);
        logger.setLoggerMeta({ wallet: this.wallet, moduleName: 'Module Manager' });
        const logTemplate = {
            status: 'in progress',
            action: 'startModules',
        };
        const preparedModules = this.modules;
        showLogPreparedModules(preparedModules, logger);
        let proxyObject;
        let proxyAgent;
        if (QsoGlobal.settings.useProxy) {
            const walletProxy = this.wallet.proxy;
            const walletProxyType = this.wallet.proxy_type;
            const isWalletProxyExist = !!walletProxy && !!walletProxyType;
            const walletProxyData = isWalletProxyExist
                ? await getProxyAgent({
                    proxy: walletProxy,
                    proxy_type: walletProxyType,
                }, logger)
                : null;
            const proxyData = walletProxyData || (await createRandomProxyAgent(logger));
            if (!proxyData) {
                logger.error('You do not use proxy! Fill the _inputs/csv/proxies.csv file');
            }
            else {
                const { proxyAgent: proxyAgentData, ...proxyObjectData } = proxyData;
                proxyAgent = proxyAgentData;
                proxyObject = proxyObjectData;
            }
        }
        await sleepByRange(QsoGlobal.settings.delay.betweenWallets, logTemplate, logger);
        let errorMessage = '';
        const telegramPrefixMsg = `[${walletIndex}/${this.walletsTotalCount}] [${this.wallet.id}]: ${this.wallet.walletAddress} \n`;
        walletIndex++;
        const modulesResult = [];
        for (let moduleIndex = 0; moduleIndex < preparedModules.length; moduleIndex++) {
            const module = preparedModules[moduleIndex];
            const { moduleName } = module;
            logger.setLoggerMeta({ moduleName });
            let currentModuleRunner = getGlobalModule(moduleName);
            if (!currentModuleRunner) {
                currentModuleRunner = this.findModule(moduleName);
            }
            if (!currentModuleRunner) {
                logger.error(`Module [${moduleName}] not found`, logTemplate);
                return;
            }
            const moduleParams = {
                ...module,
                projectName: this.projectName,
                baseNetwork: this.baseNetwork,
                proxyAgent,
                proxyObject,
                wallet: this.wallet,
                logger,
                moduleIndex,
            };
            try {
                const { status, message, logTemplate: moduleLogTemplate } = await currentModuleRunner(moduleParams);
                if (status === 'success') {
                    modulesResult.push(getTgMessageByStatus('success', moduleName));
                }
                if (status === 'warning' || status === 'critical' || status === 'error') {
                    const messageWithModuleTemplate = msgToTemplateTransform(message || SOMETHING_WENT_WRONG, {
                        ...moduleLogTemplate,
                        status: 'failed',
                    });
                    if (status === 'error') {
                        modulesResult.push(getTgMessageByStatus('error', moduleName, message));
                        throw new Error(messageWithModuleTemplate);
                    }
                    logger.error(`${messageWithModuleTemplate}, stop producing current wallet`, {
                        ...logTemplate,
                        status: 'failed',
                    });
                    if (status === 'warning') {
                        modulesResult.push(getTgMessageByStatus('warning', moduleName, message));
                    }
                    if (status === 'critical') {
                        errorMessage = message || SOMETHING_WENT_WRONG;
                        await sendMsgToTG({
                            message: `${telegramPrefixMsg} ${getTgMessageByStatus('critical', moduleName, message)}`,
                            type: 'criticalErrors',
                        });
                        modulesResult.push(getTgMessageByStatus('error', moduleName, message));
                        break;
                    }
                }
            }
            catch (e) {
                const error = e;
                errorMessage = error.message;
                if (module.stopWalletOnError) {
                    const errorMsg = `${errorMessage}, stop producing current wallet${module.stopWalletOnError ? ', because stopWalletOnError is true for current module' : ''}`;
                    await sendMsgToTG({
                        message: `${telegramPrefixMsg} ${getTgMessageByStatus('critical', moduleName, errorMsg)}`,
                        type: 'criticalErrors',
                    });
                    modulesResult.push(getTgMessageByStatus('warning', moduleName, errorMsg));
                    logger.error(errorMsg, {
                        ...logTemplate,
                        status: 'failed',
                    });
                    break;
                }
                const isSuccessMessage = SUCCESS_MESSAGES_TO_STOP_WALLET.find((error) => errorMessage.includes(error));
                if (isSuccessMessage) {
                    clearAllSavedModulesByName({
                        moduleName,
                        wallet: this.wallet,
                        projectName: this.projectName,
                    });
                    logger.success(`${errorMessage}, stop producing current wallet`, {
                        ...logTemplate,
                        status: 'succeeded',
                    });
                    errorMessage = '';
                    break;
                }
                logger.error(`${errorMessage}, stop producing current ${moduleName} module`, {
                    ...logTemplate,
                    status: 'failed',
                });
                const shouldNotSaveFailedWallet = NOT_SAVE_FAILED_WALLET_ERRORS.find((error) => errorMessage.includes(error));
                if (!module.stopWalletOnError && shouldNotSaveFailedWallet) {
                    errorMessage = '';
                }
            }
            finally {
                await sleepByRange(QsoGlobal.settings.delay.betweenModules, { ...logTemplate, status: 'in progress' }, logger);
            }
        }
        if (modulesResult.length) {
            await sendMsgToTG({
                message: `${telegramPrefixMsg}${modulesResult.join('\n')}`,
            });
        }
        logger.success(`There are no more modules for current wallet [${this.wallet.walletAddress}]. Next wallet...`, {
            ...logTemplate,
            status: 'succeeded',
        });
        return errorMessage
            ? {
                wallet: this.wallet,
                errorMessage,
            }
            : { wallet: this.wallet };
    }
}
//# sourceMappingURL=module-manager.js.map