hk_bot/index.ts

import fs = require('fs');
import { database as db, settings } from './database'
import prompt from 'prompts';
import logger from "./logger"
import * as telegram from 'telegram';
import { LogLevel } from 'telegram/extensions/Logger';
import { AccountInterface } from './interfaces/databaseInterface';
import { sleep } from 'telegram/Helpers';
import findFreePorts from 'find-free-ports';
import { waitNewMessages, startNewTorDocker, getIP, getMessagesByEntity, isBannedByClient, randomAB } from './utils';
import  TorControl from "tor-control";
import Miner from '@ulixee/miner';
import Hero from '@ulixee/hero';
import { portsInterface, usedIPInterface } from "./interfaces/otherInterfaces"
import { doSitesTasks, vertification, doChatsTasks } from './automatization';
import ExecuteJsPlugin from '@ulixee/execute-js-plugin';
import _ from 'lodash';
import Docker from 'dockerode';
import cliProgress from "cli-progress"
import BigInteger from "big-integer";

const addAccounts: () => Promise<void> = async () => {
    let apiId: number = 0
    let apiHash: string = '';
    let accounts = await db.getUsers();
    if (accounts.length != 0) {
        const usePrevData = await prompt({
            type: 'confirm',
            name: 'confirmed',
            message: 'Use apiId and apiHash from last added account?'
        });
        if (usePrevData.confirmed == true) {
            apiId = accounts[accounts.length - 1].apiID;
            apiHash = accounts[accounts.length - 1].apiHash;
        }
    }
    if (apiId == 0 && apiHash == '') {
        const api = await prompt([
            {
                type: 'number',
                name: 'apiId',
                message: 'ApiId?'
            },
            {
                type: 'text',
                name: 'apiHash',
                message: 'ApiHash?'
            }
        ]);
        apiId = Number(api.apiId);
        apiHash = api.apiHash;
    }
    let jsonFiles: prompt.Choice[] = [];
    fs.readdirSync("./").forEach((file) => {
        if (file.search('.json') != -1 && file != 'db.json' && file != 'settings.json') {
            jsonFiles.push(
                {
                    title: file,
                    description: 'json file',
                    value: file,
                }
            );
        }
    });
    const walletsFile = (await prompt({
        type: 'select',
        name: 'file',
        message: 'Choose wallets json file',
        choices: jsonFiles
    })).file
    await db.findWallet(walletsFile);



    mainLoop:
    while (true) {
        accounts = await db.getUsers();
        const answers = await prompt([
            {
                type: 'text',
                name: 'number',
                message: 'Phone number?'
            },
            {
                type: 'text',
                name: 'password',
                message: '2FA Password?'
            }
        ]);
        for (const account of accounts) {
            if (account.phoneNumber == answers.number) {
                logger.warn('You already added this number');
                continue mainLoop;
            }
        }
        const session = new telegram.sessions.StringSession('');
        const client = new telegram.TelegramClient(session, apiId, apiHash, { deviceModel: 'Samsung SM-G980', connectionRetries: 5, systemVersion: '10' });
        client.setLogLevel(LogLevel.ERROR);
        await client.start({
            phoneNumber: async () => answers.number.replace(/ /g, ""),
            password: async () => answers.password.replace(/ /g, ""),
            phoneCode: async () => (await prompt({
                type: 'number',
                name: 'code',
                message: 'Enter recieved code'
            })).code.toString(),
            onError: (err) => {
                logger.error(`Error due singning into telegram account\n${err}`);
                throw err
            },
        });
        if ((await client.isUserAuthorized()) == true) {
            const account: telegram.Api.User | telegram.Api.InputPeerUser = (await client.getMe(false));
            if (account instanceof telegram.Api.User) {
                await db.addUser({
                    password: answers.password,
                    phoneNumber: answers.number,
                    apiHash: apiHash,
                    telegramID: Number(account.id),
                    apiID: apiId,
                    stringSession: String(client.session.save()),
                    refferal: await db.findRefferal(settings.maxRefferals)
                }, walletsFile)
            } else {
                logger.error("Wrong type of account?");
            }

        } else {
            logger.error('Client not authorized');
        }
        if ((await prompt({
            type: 'confirm',
            name: 'continue',
            message: 'continue?'
        })).continue != true) {
            return;
        }
    }

}

const farm: () => Promise<void> = async () => {
    let usedIPs: usedIPInterface[] = [];
    const proccesGroup = async (workersGroups: AccountInterface[], ports: portsInterface) => {


        workersLoop:
        for (const worker of workersGroups) {
            logger.info(`Current worker:${worker.phoneNumber}\nBalance:${worker.balance}`);
            {
                let tor: any
                try{
                     tor=new TorControl({
                        host:'127.0.0.1',
                        port: ports.control,
                        password: 'qwerty',                    // Your password for tor-control
                        persistent: false                         // Keep connection (persistent)
                    });
                } catch( err){
                    logger.error(`Cant connect to tor control via ${ports.control}\n${err}`)
                    continue
                }
                
                function isFree(currentIP: string) {
                    for (const usedIP of usedIPs) {

                        if (usedIP.usedIps.indexOf(currentIP) != -1 || usedIP.current == currentIP) {
                            return false;
                        }

                    }
                    return true;
                }
                while (true) {
                    const currentIP = await getIP(ports.http);
                    if (currentIP != null) {
                        if (isFree(currentIP)) {
                            usedIPs.filter((value) => { return _.isEqual(worker, value.worker) })[0].current = currentIP;
                            usedIPs.filter((value) => { return _.isEqual(worker, value.worker) })[0].usedIps.push(currentIP);
                            break;
                        } else {
                            await tor.signalNewnym();
                            await sleep(3_000);
                        }

                    }
                }

            }
            const fingerprint = worker.browserFingerprint
            let hero: Hero;
            while (true) {

                hero = new Hero({
                    userProfile: {
                        deviceProfile: {
                            deviceMemory: fingerprint.navigator.deviceMemory,
                        }
                    },
                    name: `${worker.telegramID}`,
                    connectionToCore: { host: `ws://127.0.0.1:${ports.minerPort}` },
                    disableDevtools: true, // to bypass hk site
                    showChrome:true, // to debug
                    userAgent: fingerprint.navigator.userAgent,
                    viewport: fingerprint.screen,
                    locale: fingerprint.navigator.language,
                    upstreamProxyUrl: `socks5://127.0.0.1:${ports.socks}`,
                    upstreamProxyIpMask:{
                        ipLookupService:'icanhazip.com',
                        proxyIp:usedIPs.filter((value) => { return _.isEqual(worker, value.worker) })[0].current
                    }

                });
                hero.use(ExecuteJsPlugin);
                try {
                    await hero.goto('https://www.google.com');
                } catch (err) {
                    await hero.close();
                    logger.warn(`Some error due openning Hero. Trying again...\n${err}`);
                    continue
                }
                break;
            }
            const client = new telegram.TelegramClient(
                new telegram.sessions.StringSession(worker.stringSession),
                worker.apiID,
                worker.apiHash,
                { deviceModel: 'Samsung SM-G980', connectionRetries: 5, systemVersion: '10' }
            );
            client.setLogLevel(LogLevel.NONE);
            await client.connect();
            if ((await client.checkAuthorization()) == false) {
                logger.error(`Account ${worker.phoneNumber} is not authorizated`);
                continue workersLoop
            } else {
                logger.debug(`Successfully connected to account ${worker.phoneNumber}`);
                // https://gram.js.org/beta/modules/Api.channels.html
                // https://gram.js.org/beta/classes/Api.messages.DeleteChat.html
                let botEntity: telegram.Api.User;
                try {
                    botEntity = await client.getEntity(settings.telegramLinks.botLink) as telegram.Api.User;
                } catch (err) {
                    if (err instanceof telegram.errors.FloodWaitError) {
                        switch (err.errorMessage) {
                            case 'FLOOD':
                                logger.warn(`Account has flood(${err.seconds} secs timeout) error,skipping`);
                                break;
                            default:
                                logger.error(`Unknown error due getEntity ${err}`)
                                break;
                        }
                    } else {
                        logger.error(`Unknown error due getEntity ${err}`)
                    }
                    usedIPs.filter((value) => { return _.isEqual(worker, value.worker) })[0].current = ''
                    usedIPs.filter((value) => { return _.isEqual(worker, value.worker) })[0].usedIps.pop()
                    await hero.close()
                    continue workersLoop
                }

                // leaving old groups
                {
                    const now = new Date();
                    worker.completedGroupsTasks = worker.completedGroupsTasks.filter(async (oldGroup) => {
                        if (+now > oldGroup.timeToLeave) {
                            const olderGroups = worker.completedGroupsTasks.filter((value) => {
                                if (value.groupID == oldGroup.groupID && value.timeToLeave > oldGroup.timeToLeave) {
                                    return true;
                                } else {
                                    return false;
                                }
                            });
                            if (olderGroups.length == 0) {
                                let peerChannel: string | number | BigInteger.BigInteger | telegram.Api.PeerUser | telegram.Api.PeerChat | telegram.Api.PeerChannel | telegram.Api.InputPeerEmpty | telegram.Api.InputPeerSelf | telegram.Api.InputPeerChat | telegram.Api.InputPeerUser | telegram.Api.InputPeerChannel | telegram.Api.InputPeerUserFromMessage | telegram.Api.InputPeerChannelFromMessage | telegram.Api.User | telegram.Api.Chat | telegram.Api.Channel | telegram.Api.UserEmpty | telegram.Api.ChatEmpty | telegram.Api.ChatForbidden | telegram.Api.ChannelForbidden | telegram.Api.UserFull | telegram.Api.messages.ChatFull | telegram.Api.ChatFull | telegram.Api.ChannelFull | telegram.Api.InputChannelEmpty | telegram.Api.InputChannel | telegram.Api.InputChannelFromMessage | telegram.Api.InputUserEmpty | telegram.Api.InputUserSelf | telegram.Api.InputUser | telegram.Api.InputUserFromMessage;
                                try{
                                    peerChannel = await client.getInputEntity(BigInteger(oldGroup.groupID));
                                }
                                catch (err){
                                    return false
                                }
                                try {
                                    await client.invoke(new telegram.Api.channels.GetParticipant({ channel: peerChannel, participant: 'me' }));
                                } catch (err) {
                                    if (err.code == 400) {
                                        return false
                                    } else {
                                        logger.error(`Unknown error due GetParticipant | ${worker.phoneNumber}`)
                                        return true
                                    }
                                }
                                try {
                                    await client.invoke(
                                        new telegram.Api.channels.LeaveChannel({
                                            channel: peerChannel
                                        })
                                    );
                                } catch (err){
                                    logger.debug(`Cant leave channel | ${worker.phoneNumber}`);
                                    return true;
                                }
                                

                            }
                            return false;
                        } else {
                            return true
                        }
                    })
                }
                //


                for (const chat of settings.telegramLinks.groupsToJoin) {
                    try {
                        await client.invoke(new telegram.Api.channels.GetParticipant({ channel: chat, participant: 'me' }));
                    } catch (err) {
                        if (err.code == 400) {
                            await client.invoke(new telegram.Api.channels.JoinChannel({ channel: chat }));
                        } else {
                            logger.error(`Unknown error due GetParticipant | ${worker.phoneNumber}`)
                            throw err;
                        }
                    }
                }
                {
                    // unblock hkbot
                    if (await isBannedByClient(client, settings.telegramLinks.botLink)) {
                        
                        const result = await client.invoke(
                            new telegram.Api.contacts.Unblock({
                                id: settings.telegramLinks.botLink
                            }));
                        if (result != true) {
                            logger.error(`Cant unblock ${settings.telegramLinks.botLink} | ${worker.phoneNumber}`);
                            continue workersLoop;
                        } else {
                            logger.info(`HK bot unblocked | ${worker.phoneNumber}`)
                        }
                    }

                }
                await sleep(Math.random() * 50_000);
                if ((await getMessagesByEntity(client, botEntity, botEntity)).length == 0) {
                    // sending start message
                    let id: number = -1;
                    if (worker.refferal !== null) {
                        id = (await client.sendMessage(botEntity, { message: `/start ${worker.refferal}` })).id;
                        logger.debug(`First start of ${botEntity.username} via refferal link of ${worker.refferal} | ${worker.phoneNumber}`);
                    } else {
                        id = (await client.sendMessage(botEntity, { message: `/start` })).id;
                        logger.debug(`First start of ${botEntity.username} | ${worker.phoneNumber}`);
                    }
                    await waitNewMessages(client, worker, botEntity, id)
                }
                logger.info(`Sending earn message... | ${worker.phoneNumber}`);
                const requestTasksMessage = await client.sendMessage(botEntity, { message: settings.botButtons.earn });
                await waitNewMessages(client, worker, botEntity, requestTasksMessage.id)
                let tasksSelector: telegram.Api.Message = (await client.getMessages(botEntity, {
                    minId: requestTasksMessage.id,
                }))[0];
                if (tasksSelector.message.includes(settings.botMessages.verification) == true) {
                    // vertification
                    logger.warn(`Account ${worker.phoneNumber} is unvertificated`)
                    const url: string = tasksSelector.buttons![0][0].url!;
                    await vertification(client, worker, hero, url, botEntity, tasksSelector.id);
                    const requestTasksMessage = await client.sendMessage(botEntity, { message: settings.botButtons.earn });
                    await waitNewMessages(client, worker, botEntity, requestTasksMessage.id)
                    tasksSelector = (await client.getMessages(botEntity, {
                        minId: requestTasksMessage.id,
                    }))[0];
                }

                try{
                    await doSitesTasks(client,worker,hero,botEntity,tasksSelector);
                    await doChatsTasks(client, worker, hero, botEntity, tasksSelector);
                } catch (err){
                    logger.error(`Some error due doing tasks\n${err}\n${err.stack}`)
                }
                db.updateUser(worker);
                await hero.close();
                await sleep(randomAB(settings.sleepTime.betweenSessions[0],settings.sleepTime.betweenSessions[1])*1_000);
            }

        }
    }


    const workers = await db.getUsers();
    if (settings.shuffleAccounts){
        workers.sort(() => Math.random() - 0.5)
    }
    let workersGroups: Array<AccountInterface[]> = [];

    for (const worker of workers) {
        usedIPs.push({
            worker: worker,
            usedIps: [],
            current: '',
        })
    }

    for (let i = 0; i != workers.length + 1; i += settings.pararels) {
        const _workers = workers.slice(i, i + settings.pararels);
        if (_workers.length != 0) {
            workersGroups.push(_workers);
        } else {
            break;
        }

    }
    if (workersGroups.length != Math.ceil(workers.length / settings.pararels)) {
        logger.warn(`There is strange thing with workersGroups\n${workersGroups.length} ${Math.ceil(workers.length / settings.pararels)}`);
    }
    let pararels: Promise<void>[] = [];
    
    const miner = new Miner();
    await miner.listen({port:(await findFreePorts(1))[0]});

    const _ports = await findFreePorts(workers.length * 3);
    // logger.debug(`Is there port of miner:${_ports.indexOf(await miner.port)}, ${await miner.port}`)
    let containers: Docker.Container[] = [];

    {
        const multibar = new cliProgress.MultiBar({
            hideCursor: true,
            barsize: 50,
            barCompleteChar: '❌',
            barIncompleteChar: '✔️',
            clearOnComplete: true,
            format: `{status} | {bar} | {value}/{total}sec timeout`,

        });
        let _containers: Promise<Docker.Container>[] = [];
        for (let i = 0; i != workersGroups.length; i++) {
            _containers.push(
                startNewTorDocker(_ports[i * 3], _ports[i * 3 + 1], _ports[i * 3 + 2], multibar)
            );
        }
        containers = (await Promise.allSettled(_containers)).map((value) => { return (value as PromiseFulfilledResult<Docker.Container>).value });
        multibar.stop();
    }



    for (let i = 0; i != workersGroups.length; i++) {

        pararels.push(proccesGroup(workersGroups[i], {
            http: _ports[i * 3],
            socks: _ports[i * 3 + 1],
            control: _ports[i * 3 + 2],
            minerPort: await miner.port

        }
        ));
    }

    const results = await Promise.allSettled(pararels);
    for (const result of results) {
        if (result.status == 'rejected') {
            logger.warn(`Promise is canceled due ${result.reason}`);
        } 
    }
    logger.debug('Closing opened docker containers ')
    for (const container of containers) {
        
        try {
            await container.stop();
        } catch (err) { }

    }
    await db.save()
    await miner.close(true);
}

// menu
(async () => {
        while (true) {

            const answer = await prompt({
                type: 'select',
                name: 'menu',
                message: 'Choose action',
                choices: [
                    ((await db.getUsers()).length > 0) ? { title: 'Start', description: 'Starting farm', value: 'start' } : { title: 'Start', description: 'Add accounts first...', value: 'start', disabled: true },
                    { title: 'Add accounts', description: 'Add accounts to database', value: 'addAccounts' },
                    { title: 'Check balances', value: 'checkBalances', disabled: true },
                    { title: 'Withdraw', value: 'withdraw', disabled: true },
                    { title: 'Exit', description: 'You realy dont know what it mean?' }
                ]
            })
            switch (answer.menu) {
                case 'addAccounts':
                    await addAccounts();
                    break;
                case 'start':
                    while (true) {
                        try {
                            await farm();
                            const sleepTime=randomAB(settings.sleepTime.afterDoing[0],settings.sleepTime.afterDoing[1]);
                            logger.info(`Sleeping for ${sleepTime} secs`);
                            await sleep(sleepTime*1_000);
                        } catch (err) {
                            logger.error(`Unknown error\n${err.stack}\n${typeof err}`);
                            break;
                        }
                    }
                    break;


                default:
                    logger.info('Bye bye');
                    process.exit();

            }

    }
})();

process.on('SIGINT', function () {
    db.save().then(()=>{
        logger.info('Bye bye');
        process.exit();
    })
    
});