diff --git a/automatization.ts b/automatization.ts
index c966aff..dd1ea1f 100644
--- 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'}});
diff --git a/index.ts b/index.ts
index bfb74f9..326b2dc 100644
--- 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();
 }
diff --git a/interfaces/otherInterfaces.d.ts b/interfaces/otherInterfaces.d.ts
index 1e7c70e..4e10661 100644
--- 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
 
-}
\ No newline at end of file
+}
+
+export interface portsInterface {
+    http: number,
+    socks: number,
+    control:number,
+    minerPort?:number
+}
+
+export interface usedIPInterface{
+    worker: AccountInterface,
+    usedIps: string[],
+    current: string
+}   
diff --git a/package.json b/package.json
index 6b58706..0444918 100644
--- 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"