many test changes

2022-12-03 17:43:20 +03:00 · 2022-12-03 17:43:20 +03:00 · 6d5f046b0e
parent 0a9792a598
commit 6d5f046b0e
4 changed files with 69 additions and 30 deletions
--- a/automatization.ts
+++ b/automatization.ts
@ -2,7 +2,7 @@ import Hero from "@ulixee/hero";
 import * as telegram from 'telegram';
 import { sleep } from "telegram/Helpers";
 import { AccountInterface } from "./interfaces/databaseInterface";
-import { prevTask } from "./interfaces/otherInterfaces";
+import { prevTaskInterface } from "./interfaces/otherInterfaces";
 import logger from "./logger";
 import { waitNewMessages } from "./utils";
 import {database as db,settings} from './database'
@ -34,7 +34,7 @@ export const vertification=async function (client: telegram.TelegramClient,worke

 export const do_sites_task=async function (client: telegram.TelegramClient,worker: AccountInterface,hero: Omit<Hero, "then">,botEntity: telegram.Api.Chat | telegram.Api.User,tasksSelector: telegram.Api.Message) {
    const taskSitesButton=tasksSelector.buttons![1][0];
-    let prevTask: prevTask={
+    let prevTask: prevTaskInterface={
        task:tasksSelector,
        lastMessage:tasksSelector
    };
@ -80,7 +80,7 @@ export const do_sites_task=async function (client: telegram.TelegramClient,worke
                    
                while (captchaButton!=null && await hero.activeTab.url==urlButton.url!){
                        const isCaptchaPassed=hero.document.querySelector("input[id='recaptcha-token']");
-                        if ((isCaptchaPassed==null || await isCaptchaPassed.$isVisible==false) && await captchaButton.$isClickable==true){
+                        if ((isCaptchaPassed==null || await isCaptchaPassed.$isVisible==false) ){
        
                            try {
                                await hero.interact({click:{element: captchaButton, verification: 'exactElement'}});
--- a/index.ts
+++ b/index.ts
@ -11,9 +11,10 @@ import { waitNewMessages, startNewTorDocker, getIP,getMessagesByEntity} from './
 import {connect, disconnect, tor} from "node-tor-control";
 import Miner from '@ulixee/miner';
 import Hero from '@ulixee/hero';
-import {ipInterface} from "./interfaces/otherInterfaces"
+import {portsInterface, usedIPInterface} from "./interfaces/otherInterfaces"
 import { do_sites_task, vertification } from './automatization';
 import ExecuteJsPlugin from '@ulixee/execute-js-plugin';
+import _ from 'lodash';

 const addAccounts: ()=>Promise<void>=async ()=>{
    let apiId: number=0
@ -136,25 +137,37 @@ const addAccounts: ()=>Promise<void>=async ()=>{
 }

 const farm: ()=>Promise<void>=async ()=>{
-    const proccesGroup=async (workers_group:AccountInterface[],ports: number[])=>{
-        const container=await startNewTorDocker(ports[0],ports[1],ports[2]);
+    let usedIP:usedIPInterface[]=[]
+    const proccesGroup=async (workersGroups:AccountInterface[],ports: portsInterface)=>{
+        const container=await startNewTorDocker(ports.http,ports.socks,ports.control);
        
-        const ip: ipInterface={
-            prev:[''],
-            current:''
-        }
-        for (const worker of workers_group){
+        
+        for (const worker of workersGroups){
            logger.debug(`Current worker:${worker.phoneNumber}\nBalance:${worker.balance}`);
-            while (ip.prev.indexOf(ip.current)!=-1){
+            
+            
+            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
+                    }
+                }
+                
+            }).length!=0){
                const torConnection = await connect({
                    host: '127.0.0.1',
-                    port:ports[2],
+                    port:ports.control,
                    password: 'qwerty', 
                });
                await tor.signalNewNYM(torConnection);
-                ip.current=(await getIP(ports[0]))!;
+                usedIP.filter((value)=>{return _.isEqual(worker,value.worker)})[0].current=(await getIP(ports.http))!;
            }
-            ip.prev.push(ip.current)
+            usedIP.filter((value)=>{return _.isEqual(worker,value.worker)})[0].usedIps.push(usedIP.filter((value)=>{return _.isEqual(worker,value.worker)})[0].current)
            
            const fingerprint=worker.browserFingerprint
            let hero: Omit<Hero, "then">;
@ -167,13 +180,13 @@ const farm: ()=>Promise<void>=async ()=>{
                            }
                        },
                        name:`${worker.telegramID}`,
-                        connectionToCore: { host:`ws://127.0.0.1:${ports[3]}` },
+                        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[1]}`,
+                        upstreamProxyUrl:`socks5://127.0.0.1:${ports.socks}`,
                        
                    });
                    hero.use(ExecuteJsPlugin);
@ -213,13 +226,15 @@ const farm: ()=>Promise<void>=async ()=>{
                    }
                }
                if ((await getMessagesByEntity(client,botEntity,botEntity)).length==0){
+                    let id: number=-1;
                    if (worker.refferal!==null){
-                        await client.sendMessage(botEntity,{message:`/start ${worker.refferal}`});
+                        id=(await client.sendMessage(botEntity,{message:`/start ${worker.refferal}`})).id;
                        logger.debug(`${worker.phoneNumber} | First start of ${botEntity.username} via refferal link of ${worker.refferal}`);
                    }else {
-                        await client.sendMessage(botEntity,{message:`/start`});
+                        id=(await client.sendMessage(botEntity,{message:`/start`})).id;
                        logger.debug(`${worker.phoneNumber} | First start of ${botEntity.username}`);
                    }
+                    await waitNewMessages(client,worker,botEntity,id)
                }
                logger.info(`${worker.phoneNumber} | Sending earn message...`);
                const requestTasksMessage=await client.sendMessage(botEntity,{message:settings.botButtons.earn});
@ -264,6 +279,14 @@ const farm: ()=>Promise<void>=async ()=>{
    const workers=await db.getUsers();
    let workersGroups: Array<AccountInterface[]>=[];
    
+    for (const worker of workers){
+        usedIP.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){
@ -274,18 +297,21 @@ const farm: ()=>Promise<void>=async ()=>{
            
    }
    if (workersGroups.length!=Math.ceil(workers.length/settings.pararels)){
-        logger.warn(`There is strange thing with workers_group\n${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>[] =[];
    let _ports=await findFreePorts(workers.length*3+1);
    const miner = new Miner();
    await miner.listen({port: _ports[_ports.length-1]});
    for (let i=0;i!=workersGroups.length;i++){
-        let ports=_ports.slice(i*3,i*3+3);
-        ports.push(_ports[_ports.length-1]);
-        pararels.push(proccesGroup(workersGroups[i],ports));
+        pararels.push(proccesGroup(workersGroups[i],{
+            http: _ports[i*3],
+            socks: _ports[i*3+1],
+            control:_ports[i*3+2],
+            minerPort: await miner.port
+
+        }));
    }
-    console.log(_ports);
    await Promise.all(pararels); 
    await miner.close();
 }
--- a/interfaces/otherInterfaces.d.ts
+++ b/interfaces/otherInterfaces.d.ts
@ -1,11 +1,22 @@
 import * as telegram from 'telegram';
-export interface ipInterface {
-    prev: string[],
-    current: string
-}
+import {AccountInterface} from './databaseInterface'

-export interface prevTask {
+
+export interface prevTaskInterface {
    task: telegram.Api.Message,
    lastMessage:telegram.Api.Message

-}
+}
+
+export interface portsInterface {
+    http: number,
+    socks: number,
+    control:number,
+    minerPort?:number
+}
+
+export interface usedIPInterface{
+    worker: AccountInterface,
+    usedIps: string[],
+    current: string
+}   
--- a/package.json
+++ b/package.json
@ -7,6 +7,7 @@
    "dockerode": "^3.3.4",
    "find-free-ports": "^3.0.0",
    "fingerprint-generator": "^2.1.5",
+    "lodash": "^4.17.21",
    "node-json-db": "^2.1.3",
    "node-tor-control": "^0.0.2",
    "progress": "^2.0.3",
@ -22,6 +23,7 @@
  "main": "/build/index.js",
  "devDependencies": {
    "@types/dockerode": "^3.3.14",
+    "@types/lodash": "^4.14.191",
    "@types/node": "^18.11.9",
    "@types/progress": "^2.0.5",
    "@types/prompts": "^2.4.1"