2022-11-30 16:43:49 +01:00
|
|
|
import fs = require('fs');
|
2022-12-05 19:07:39 +01:00
|
|
|
import {database, database as db,settings} from './database'
|
2022-12-01 21:53:29 +01:00
|
|
|
import prompt from 'prompts';
|
2022-11-30 15:04:45 +01:00
|
|
|
import logger from "./logger"
|
2022-11-30 16:43:49 +01:00
|
|
|
import * as telegram from 'telegram';
|
|
|
|
import { LogLevel } from 'telegram/extensions/Logger';
|
2022-11-30 19:23:04 +01:00
|
|
|
import { AccountInterface } from './interfaces/databaseInterface';
|
|
|
|
import { sleep } from 'telegram/Helpers';
|
|
|
|
import findFreePorts from 'find-free-ports';
|
2022-12-04 16:52:54 +01:00
|
|
|
import { waitNewMessages, startNewTorDocker, getIP,getMessagesByEntity,isBannedByClient} from './utils';
|
2022-12-02 13:07:07 +01:00
|
|
|
import {connect, disconnect, tor} from "node-tor-control";
|
|
|
|
import Miner from '@ulixee/miner';
|
|
|
|
import Hero from '@ulixee/hero';
|
2022-12-03 15:43:20 +01:00
|
|
|
import {portsInterface, usedIPInterface} from "./interfaces/otherInterfaces"
|
2022-12-05 19:07:39 +01:00
|
|
|
import { doSitesTasks, vertification, doChatsTasks } from './automatization';
|
2022-12-03 06:37:20 +01:00
|
|
|
import ExecuteJsPlugin from '@ulixee/execute-js-plugin';
|
2022-12-03 15:43:20 +01:00
|
|
|
import _ from 'lodash';
|
2022-12-04 16:52:54 +01:00
|
|
|
import Docker from 'dockerode';
|
|
|
|
import cliProgress from "cli-progress"
|
2022-12-05 19:27:27 +01:00
|
|
|
import { isAxiosError } from 'axios';
|
|
|
|
import BigInteger from "big-integer";
|
2022-11-30 15:04:45 +01:00
|
|
|
|
2022-11-30 16:43:49 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2022-11-30 15:04:45 +01:00
|
|
|
|
2022-11-30 16:43:49 +01:00
|
|
|
}
|
2022-11-30 15:04:45 +01:00
|
|
|
|
2022-11-30 19:23:04 +01:00
|
|
|
const farm: ()=>Promise<void>=async ()=>{
|
2022-12-04 16:52:54 +01:00
|
|
|
let usedIP:usedIPInterface[]=[];
|
2022-12-06 10:36:50 +01:00
|
|
|
const proccesGroup=async (workersGroups:AccountInterface[],ports: portsInterface)=>{
|
2022-12-02 13:07:07 +01:00
|
|
|
|
2022-12-03 15:43:20 +01:00
|
|
|
|
2022-12-04 16:52:54 +01:00
|
|
|
workersLoop:
|
2022-12-03 15:43:20 +01:00
|
|
|
for (const worker of workersGroups){
|
2022-11-30 19:23:04 +01:00
|
|
|
logger.debug(`Current worker:${worker.phoneNumber}\nBalance:${worker.balance}`);
|
2022-12-03 15:43:20 +01:00
|
|
|
|
2022-12-05 19:07:39 +01:00
|
|
|
{
|
|
|
|
let pause:number=2_000;
|
|
|
|
while (usedIP.filter((value:usedIPInterface)=>{
|
|
|
|
if (_.isEqual(worker,value.worker)){
|
|
|
|
if (value.usedIps.indexOf(value.current)!=-1 || value.current==''){
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
const _ip=usedIP.filter((value)=>{return _.isEqual(worker,value.worker)});
|
|
|
|
if (value.usedIps.indexOf(_ip[0].current)!=-1 || value.current==_ip[0].current){
|
|
|
|
return true
|
|
|
|
}
|
2022-12-03 15:43:20 +01:00
|
|
|
}
|
2022-12-05 19:07:39 +01:00
|
|
|
|
|
|
|
}).length!=0){
|
|
|
|
const torConnection = await connect({
|
|
|
|
host: '127.0.0.1',
|
|
|
|
port:ports.control,
|
|
|
|
password: 'qwerty',
|
|
|
|
});
|
|
|
|
await tor.signalNewNYM(torConnection);
|
|
|
|
await sleep(pause);
|
|
|
|
try{
|
|
|
|
usedIP.filter((value)=>{return _.isEqual(worker,value.worker)})[0].current=(await getIP(ports.http))!;
|
|
|
|
} catch (err){
|
|
|
|
if (isAxiosError(err)){
|
|
|
|
pause*=3;
|
|
|
|
}
|
|
|
|
continue;
|
2022-12-03 15:43:20 +01:00
|
|
|
}
|
2022-12-05 19:07:39 +01:00
|
|
|
|
2022-12-03 15:43:20 +01:00
|
|
|
}
|
2022-12-02 13:07:07 +01:00
|
|
|
}
|
2022-12-05 19:07:39 +01:00
|
|
|
|
2022-12-03 15:43:20 +01:00
|
|
|
usedIP.filter((value)=>{return _.isEqual(worker,value.worker)})[0].usedIps.push(usedIP.filter((value)=>{return _.isEqual(worker,value.worker)})[0].current)
|
2022-12-03 06:37:20 +01:00
|
|
|
|
2022-12-02 13:07:07 +01:00
|
|
|
const fingerprint=worker.browserFingerprint
|
2022-12-04 16:52:54 +01:00
|
|
|
let hero: Hero;
|
2022-12-02 13:07:07 +01:00
|
|
|
while (true){
|
|
|
|
try {
|
2022-12-03 06:37:20 +01:00
|
|
|
hero = new Hero({
|
2022-12-02 13:07:07 +01:00
|
|
|
userProfile:{
|
|
|
|
deviceProfile: {
|
|
|
|
deviceMemory:fingerprint.navigator.deviceMemory,
|
|
|
|
}
|
|
|
|
},
|
|
|
|
name:`${worker.telegramID}`,
|
2022-12-03 15:43:20 +01:00
|
|
|
connectionToCore: { host:`ws://127.0.0.1:${ports.minerPort}` },
|
2022-12-02 13:07:07 +01:00
|
|
|
disableDevtools: true, // to bypass hk site
|
|
|
|
showChrome:true, // to debug
|
|
|
|
userAgent:fingerprint.navigator.userAgent,
|
|
|
|
viewport:fingerprint.screen,
|
|
|
|
locale:fingerprint.navigator.language,
|
2022-12-03 15:43:20 +01:00
|
|
|
upstreamProxyUrl:`socks5://127.0.0.1:${ports.socks}`,
|
2022-12-02 13:07:07 +01:00
|
|
|
|
|
|
|
});
|
2022-12-03 06:37:20 +01:00
|
|
|
hero.use(ExecuteJsPlugin);
|
2022-12-02 16:41:38 +01:00
|
|
|
break;
|
2022-12-02 13:07:07 +01:00
|
|
|
} catch (err){
|
|
|
|
logger.warn(`Some error due openning Hero. Trying again...\n${err}`);
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2022-12-02 16:41:38 +01:00
|
|
|
}
|
|
|
|
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.ERROR);
|
|
|
|
await client.connect();
|
|
|
|
if ((await client.checkAuthorization())==false){
|
|
|
|
logger.error(`Account ${worker.phoneNumber} is not authorizated`);
|
|
|
|
continue
|
|
|
|
} 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
|
2022-12-05 19:27:27 +01:00
|
|
|
|
|
|
|
// leaving old groups
|
|
|
|
{
|
|
|
|
const now=new Date();
|
2022-12-05 19:45:44 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
});
|
2022-12-05 19:27:27 +01:00
|
|
|
if (olderGroups.length==0){
|
|
|
|
await client.invoke(
|
|
|
|
new telegram.Api.channels.LeaveChannel({
|
|
|
|
channel: BigInteger(oldGroup.groupID)
|
|
|
|
})
|
2022-12-05 19:45:44 +01:00
|
|
|
);
|
|
|
|
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
return true
|
2022-12-05 19:27:27 +01:00
|
|
|
}
|
2022-12-05 19:45:44 +01:00
|
|
|
})
|
2022-12-05 19:27:27 +01:00
|
|
|
}
|
|
|
|
//
|
2022-12-05 19:45:44 +01:00
|
|
|
|
2022-12-02 16:41:38 +01:00
|
|
|
const botEntity=await client.getEntity(settings.telegramLinks.botLink) as telegram.Api.User;
|
|
|
|
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{
|
2022-12-04 16:52:54 +01:00
|
|
|
logger.error(`Unknown error due GetParticipant | ${worker.phoneNumber}`)
|
2022-12-02 16:41:38 +01:00
|
|
|
throw err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-12-04 16:52:54 +01:00
|
|
|
{
|
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
await sleep(Math.random()*1000);
|
2022-12-02 16:41:38 +01:00
|
|
|
if ((await getMessagesByEntity(client,botEntity,botEntity)).length==0){
|
2022-12-04 16:52:54 +01:00
|
|
|
// sending start message
|
2022-12-03 15:43:20 +01:00
|
|
|
let id: number=-1;
|
2022-12-02 16:41:38 +01:00
|
|
|
if (worker.refferal!==null){
|
2022-12-03 15:43:20 +01:00
|
|
|
id=(await client.sendMessage(botEntity,{message:`/start ${worker.refferal}`})).id;
|
2022-12-04 16:52:54 +01:00
|
|
|
logger.debug(`First start of ${botEntity.username} via refferal link of ${worker.refferal} | ${worker.phoneNumber}`);
|
2022-12-02 16:41:38 +01:00
|
|
|
}else {
|
2022-12-03 15:43:20 +01:00
|
|
|
id=(await client.sendMessage(botEntity,{message:`/start`})).id;
|
2022-12-04 16:52:54 +01:00
|
|
|
logger.debug(`First start of ${botEntity.username} | ${worker.phoneNumber}`);
|
2022-12-02 16:41:38 +01:00
|
|
|
}
|
2022-12-03 15:43:20 +01:00
|
|
|
await waitNewMessages(client,worker,botEntity,id)
|
2022-12-02 18:38:40 +01:00
|
|
|
}
|
2022-12-04 16:52:54 +01:00
|
|
|
logger.info(`Sending earn message... | ${worker.phoneNumber}`);
|
2022-12-02 18:38:40 +01:00
|
|
|
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){
|
2022-12-04 16:52:54 +01:00
|
|
|
// vertification
|
2022-12-03 06:37:20 +01:00
|
|
|
logger.warn(`Account ${worker.phoneNumber} is unvertificated`)
|
2022-12-02 18:38:40 +01:00
|
|
|
const url: string=tasksSelector.buttons![0][0].url!;
|
|
|
|
await vertification(client,worker,hero,url,botEntity,tasksSelector.id);
|
2022-12-02 16:41:38 +01:00
|
|
|
const requestTasksMessage=await client.sendMessage(botEntity,{message:settings.botButtons.earn});
|
|
|
|
await waitNewMessages(client,worker,botEntity,requestTasksMessage.id)
|
2022-12-02 18:38:40 +01:00
|
|
|
tasksSelector=(await client.getMessages(botEntity,{
|
|
|
|
minId:requestTasksMessage.id,
|
|
|
|
}))[0];
|
|
|
|
}
|
2022-12-02 16:41:38 +01:00
|
|
|
|
2022-12-02 19:42:03 +01:00
|
|
|
|
2022-12-05 19:09:35 +01:00
|
|
|
await doSitesTasks(client,worker,hero,botEntity,tasksSelector);
|
2022-12-05 19:07:39 +01:00
|
|
|
await doChatsTasks(client,worker,hero,botEntity,tasksSelector);
|
2022-12-02 16:41:38 +01:00
|
|
|
|
2022-12-05 19:09:35 +01:00
|
|
|
|
2022-12-05 19:07:39 +01:00
|
|
|
await database.updateUser(worker);
|
2022-12-02 16:41:38 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
2022-12-02 18:38:40 +01:00
|
|
|
|
|
|
|
await hero.close();
|
|
|
|
|
2022-12-02 13:07:07 +01:00
|
|
|
}
|
2022-11-30 19:23:04 +01:00
|
|
|
|
|
|
|
}
|
2022-12-02 18:38:40 +01:00
|
|
|
|
2022-11-30 19:23:04 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const workers=await db.getUsers();
|
2022-12-03 06:37:20 +01:00
|
|
|
let workersGroups: Array<AccountInterface[]>=[];
|
2022-11-30 19:23:04 +01:00
|
|
|
|
2022-12-03 15:43:20 +01:00
|
|
|
for (const worker of workers){
|
|
|
|
usedIP.push({
|
|
|
|
worker: worker,
|
|
|
|
usedIps: [],
|
|
|
|
current: '',
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2022-12-03 06:37:20 +01:00
|
|
|
for (let i=0;i!=workers.length+1;i+=settings.pararels){
|
2022-11-30 19:23:04 +01:00
|
|
|
const _workers=workers.slice(i,i+settings.pararels);
|
|
|
|
if (_workers.length!=0){
|
2022-12-03 06:37:20 +01:00
|
|
|
workersGroups.push(_workers);
|
2022-11-30 19:23:04 +01:00
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2022-12-03 06:37:20 +01:00
|
|
|
if (workersGroups.length!=Math.ceil(workers.length/settings.pararels)){
|
2022-12-03 15:43:20 +01:00
|
|
|
logger.warn(`There is strange thing with workersGroups\n${workersGroups.length} ${Math.ceil(workers.length/settings.pararels)}`);
|
2022-11-30 19:23:04 +01:00
|
|
|
}
|
2022-12-03 06:37:20 +01:00
|
|
|
let pararels: Promise<void>[] =[];
|
|
|
|
let _ports=await findFreePorts(workers.length*3+1);
|
|
|
|
const miner = new Miner();
|
|
|
|
await miner.listen({port: _ports[_ports.length-1]});
|
2022-12-04 16:52:54 +01:00
|
|
|
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-12-03 06:37:20 +01:00
|
|
|
for (let i=0;i!=workersGroups.length;i++){
|
2022-12-04 16:52:54 +01:00
|
|
|
|
2022-12-03 15:43:20 +01:00
|
|
|
pararels.push(proccesGroup(workersGroups[i],{
|
|
|
|
http: _ports[i*3],
|
|
|
|
socks: _ports[i*3+1],
|
|
|
|
control:_ports[i*3+2],
|
|
|
|
minerPort: await miner.port
|
|
|
|
|
2022-12-06 10:36:50 +01:00
|
|
|
}
|
2022-12-04 16:52:54 +01:00
|
|
|
));
|
2022-11-30 19:23:04 +01:00
|
|
|
}
|
2022-12-03 16:10:47 +01:00
|
|
|
|
2022-12-04 16:52:54 +01:00
|
|
|
const results=await Promise.allSettled(pararels);
|
|
|
|
for (const result of results){
|
|
|
|
if (result.status=='rejected'){
|
|
|
|
logger.warn(result.reason);
|
|
|
|
}
|
|
|
|
}
|
2022-12-05 19:07:39 +01:00
|
|
|
for (const container of containers){
|
|
|
|
try{
|
|
|
|
container.kill();
|
|
|
|
} catch (err){}
|
|
|
|
|
|
|
|
}
|
2022-12-03 06:37:20 +01:00
|
|
|
await miner.close();
|
2022-11-30 19:23:04 +01:00
|
|
|
}
|
2022-11-30 15:04:45 +01:00
|
|
|
|
|
|
|
// menu
|
|
|
|
(async ()=> {
|
2022-11-30 16:43:49 +01:00
|
|
|
mainLoop:
|
2022-11-30 15:04:45 +01:00
|
|
|
while (true){
|
|
|
|
|
|
|
|
const answer=await prompt({
|
|
|
|
type: 'select',
|
|
|
|
name: 'menu',
|
|
|
|
message: 'Choose action',
|
|
|
|
choices: [
|
2022-11-30 16:43:49 +01:00
|
|
|
((await db.getUsers()).length>0) ? { title: 'Start',description: 'Starting farm', value: 'start' } : { title: 'Start',description: 'Add accounts first...', value: 'start' ,disabled: true},
|
2022-12-02 12:44:14 +01:00
|
|
|
{ title: 'Add accounts', description: 'Adds accounts', value: 'addAccounts' },
|
2022-11-30 15:04:45 +01:00
|
|
|
{ title: 'Check balances', value: 'checkBalances', disabled: true },
|
|
|
|
{ title: 'Withdraw', value: 'withdraw', disabled: true },
|
2022-11-30 16:43:49 +01:00
|
|
|
{ title: 'Exit',description: 'You realy dont know what it mean?'}
|
2022-11-30 15:04:45 +01:00
|
|
|
]
|
|
|
|
})
|
|
|
|
switch (answer.menu) {
|
|
|
|
case 'addAccounts':
|
2022-11-30 16:43:49 +01:00
|
|
|
await addAccounts();
|
2022-11-30 15:04:45 +01:00
|
|
|
break;
|
|
|
|
case 'start':
|
2022-11-30 19:23:04 +01:00
|
|
|
while (true){
|
|
|
|
try{
|
|
|
|
await farm();
|
|
|
|
} catch (err){
|
2022-12-06 10:36:50 +01:00
|
|
|
logger.error(`Unknown error\n${err.stack}\n${typeof err}`);
|
2022-11-30 19:23:04 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2022-11-30 15:04:45 +01:00
|
|
|
break;
|
2022-11-30 19:23:04 +01:00
|
|
|
|
2022-11-30 15:04:45 +01:00
|
|
|
|
|
|
|
default:
|
2022-11-30 16:43:49 +01:00
|
|
|
logger.info('Bye bye');
|
2022-12-03 16:10:47 +01:00
|
|
|
process.exit();
|
|
|
|
|
2022-11-30 15:04:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
})();
|
2022-12-03 16:10:47 +01:00
|
|
|
|
|
|
|
process.on('SIGINT', function() {
|
|
|
|
logger.info('Bye bye');
|
|
|
|
process.exit();
|
|
|
|
});
|