What's new
By:

👥 Referral GATAXYZ Airdrop with 4M FUNDING + Auto Bot script using playwright

P

Pesh

Honorary Poster
Gataxyz Airdrop with Auto Bot script

=====
Register here:
=====

GATAXYZ AUTO BOT SCRIPT INSTALLATION
Una dapat may nodejs kayo which is here You do not have permission to view the full content of this post. Log in or register now. download that and install and then create kayo folder jan pangalanan nyo GATAXYZ para di kayo malito kakahanap if mag ru-run ulet, tapos open nyu folder naiyan tas create kayo file na index.js tas i pa-paste nyo yung code below na ibibigay ko


Code: 
const fs = require('fs');
const { chromium } = require('playwright');
const path = require('path');

// --- ANSI Color Codes ---
const RESET = "\x1b[0m";
const BRIGHT = "\x1b[1m";
const DIM = "\x1b[2m";
const RED = "\x1b[91m";
const GREEN = "\x1b[92m";
const YELLOW = "\x1b[93m";
const BLUE = "\x1b[94m";
const MAGENTA = "\x1b[95m";
const CYAN = "\x1b[96m";
const GREY = "\x1b[90m";

// --- Logging Helper Functions ---
const logInfo = (message) => console.log(`${CYAN}[INFO] ${message}${RESET}`);
const logSuccess = (message) => console.log(`${GREEN}[OK]   ${message}${RESET}`);
const logWarn = (message) => console.warn(`${YELLOW}[WARN] ${message}${RESET}`);
const logError = (message, error = null) => {
    console.error(`${RED}[ERROR] ${message}${RESET}`);
    if (error) {
        console.error(`${RED}${error.stack || error}${RESET}`);
    }
};
const logHighlight = (message) => console.log(`${MAGENTA}${BRIGHT}✨ ${message} ✨${RESET}`);
const logDebug = (message) => console.log(`${GREY}[DEBUG] ${message}${RESET}`);


// --- Configuration ---
let banner = 'GATAXYZ AUTO BOT - PESH';
let configs;
try {
    banner = fs.readFileSync('banner.js', 'utf8');
} catch (err) {
    logWarn(`Could not read banner.js: ${err.message}. Using default banner.`);
}
try {
    configs = JSON.parse(fs.readFileSync('configs.json', 'utf8'));
    if (!configs.address || !configs.bearer || !configs.data_agent_token || !configs.llm_token || !configs.task_token || !configs.invite_code) {
        throw new Error('One or more essential keys are missing in configs.json');
    }
} catch (err) {
    logError(`Fatal: Could not read/parse configs.json or essential keys missing.`, err);
    process.exit(1);
}

const BASE_URL = 'https://app.gata.xyz/dataAgent';
const ACTIVITY_INTERVAL = 185000; // 3 minutes and 5 seconds

// --- New Configuration for Page Reload Cycle ---
const PAGE_RELOAD_BASE_INTERVAL = 65 * 60 * 1000; // 65 minutes (1 hour and 5 minutes)
const PAGE_RELOAD_VARIANCE = 5 * 60 * 1000; // Additional random time between 0 and 5 minutes
// ---

const PAGE_TIMEOUT = 120000; // 2 minutes
const SCREENSHOT_PATH = 'current_screenshot.png';

console.log(`\n${MAGENTA}${banner}${RESET}\n`);
logHighlight('Starting DVA Automation');

// --- Helper Functions ---

function cleanupScreenshots() {
    const directory = './';
    logInfo(`Cleaning up previous ${SCREENSHOT_PATH} and HTML files...`);
    let cleanedCount = 0;
    try {
        fs.readdirSync(directory).forEach(file => {
            if (file === SCREENSHOT_PATH || file.endsWith('.html')) {
                try {
                    fs.unlinkSync(path.join(directory, file));
                    cleanedCount++;
                } catch (err) {
                    if (err.code !== 'ENOENT') {
                       logWarn(`Error deleting file ${file}: ${err.message}`);
                    }
                }
            }
        });
        if (cleanedCount > 0) {
            logDebug(`Cleanup complete. Removed ${cleanedCount} file(s).`);
        } else {
             logDebug(`No relevant files found for cleanup.`);
        }
    } catch (readErr) {
         logError(`Error reading directory for cleanup`, readErr);
    }
}

async function takeScreenshot(page, description = '') {
    if (!page || page.isClosed()) {
        logWarn(`Skipping screenshot "${description}" - page is closed.`);
        return;
    }
    logDebug(`Taking screenshot (${description})...`);
    try {
        if (fs.existsSync(SCREENSHOT_PATH)) {
            try {
                fs.unlinkSync(SCREENSHOT_PATH);
            } catch (unlinkErr) {
                 if (unlinkErr.code !== 'ENOENT') {
                    logWarn(`Error deleting old ${SCREENSHOT_PATH}: ${unlinkErr.message}`);
                 }
            }
        }
        await page.screenshot({ path: SCREENSHOT_PATH, timeout: 10000 });
        // logDebug(`Screenshot updated: ${SCREENSHOT_PATH} (for: ${description})`);
    } catch (error) {
        logError(`Failed to take screenshot (${description})`, error);
    }
}

async function savePageHTML(page, description = '') {
    if (!page || page.isClosed()) {
        logWarn(`Skipping HTML save "${description}" - page is closed.`);
        return;
    }
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    const sanitizedDescription = description.replace(/[^a-z0-9_\-]/gi, '_').replace(/_+/g, '_');
    const filename = `page-${sanitizedDescription}-${timestamp}.html`;
    logDebug(`Saving page HTML (${description}) to ${filename}...`);
    try {
        const content = await page.content();
        fs.writeFileSync(filename, content);
        logDebug(`Page HTML saved: ${filename}`);
    } catch(error) {
        logError(`Failed to save page HTML (${description})`, error);
    }
}

async function setRequiredLocalStorage(page) {
    logInfo('Setting required LocalStorage items...');
    try {
        await page.evaluate((cfg) => {
            localStorage.clear();
            localStorage.setItem(cfg.address, cfg.bearer);
            localStorage.setItem('AGG_USER_IS_LOGIN', '1');
            localStorage.setItem('Gata_Chat_GotIt', '1');
            localStorage.setItem('aggr_current_address', cfg.address);
            localStorage.setItem(`aggr_data_agent_token_${cfg.address}`, cfg.data_agent_token);
            localStorage.setItem(`aggr_llm_token_${cfg.address}`, cfg.llm_token);
            localStorage.setItem(`aggr_task_token_${cfg.address}`, cfg.task_token);
            localStorage.setItem(`invite_code_${cfg.address}`, cfg.invite_code);
            localStorage.setItem('wagmi.recentConnectorId', '"metaMask"');
            localStorage.setItem('wagmi.store', JSON.stringify({
                state: {
                    connections: {
                        __type: "Map",
                        value: [[
                            "e52bdc16f63",
                            { accounts: [cfg.address], chainId: 1017, connector: { id: "metaMask", name: "MetaMask", type: "injected", uid: "e52bdc16f63" } }
                        ]]
                    }, chainId: 1017, current: "e52bdc16f63"
                }, version: 2
            }));
        }, configs);
        logSuccess('LocalStorage items set.');
    } catch (error) {
         logError('Failed setting LocalStorage.', error);
         await takeScreenshot(page, 'LocalStorageError');
         throw error;
    }
}

async function waitForPageLoad(page) {
    logInfo('Waiting for page to load...');
    try {
        await page.waitForLoadState('domcontentloaded', { timeout: PAGE_TIMEOUT });
        await page.waitForLoadState('load', { timeout: PAGE_TIMEOUT });
        await page.waitForLoadState('networkidle', { timeout: PAGE_TIMEOUT });
        logSuccess('Page loaded and network idle.');
        await page.waitForTimeout(5000);
        return true;
    } catch (error) {
        logWarn(`Page load/idle timeout (${error.message}), continuing...`);
        await takeScreenshot(page, 'PageLoadTimeout');
        return false;
    }
}

async function simulateActivity(page) {
    if (!page || page.isClosed()) {
        logWarn('Skipping activity simulation - page is closed.');
        return;
    }
    const time = new Date().toLocaleTimeString();
    logInfo(`Simulating activity at ${time}...`);
    try {
        await page.evaluate(() => {
            window.scrollTo({ top: 500, behavior: 'smooth' });
            setTimeout(() => window.scrollTo({ top: 0, behavior: 'smooth' }), 1000);
        });
        await takeScreenshot(page, `Activity-${time}`);

    } catch (error) {
        logError(`Error during activity simulation or screenshot`, error);
        await takeScreenshot(page, 'ActivitySimulationError');
    }
}

// Add random variance to activity interval (±30 seconds)
function getNextActivityInterval() {
    const variance = Math.floor(Math.random() * 60000) - 30000; // ±30 seconds
    return ACTIVITY_INTERVAL + variance;
}

// --- Calculate next page reload time with randomness ---
function getNextPageReloadInterval() {
    const randomVariance = Math.floor(Math.random() * PAGE_RELOAD_VARIANCE);
    const nextInterval = PAGE_RELOAD_BASE_INTERVAL + randomVariance;
    const hours = Math.floor(nextInterval / (60 * 60 * 1000));
    const minutes = Math.floor((nextInterval % (60 * 60 * 1000)) / (60 * 1000));
    const seconds = Math.floor((nextInterval % (60 * 1000)) / 1000);
    return {
        interval: nextInterval,
        readableTime: `${hours}h ${minutes}m ${seconds}s`
    };
}

async function keepSessionActive(page) {
    logInfo(`Starting activity simulation loop (base interval: ${ACTIVITY_INTERVAL / 60000} min).`);
    await simulateActivity(page); // Initial simulation

    const scheduleNextActivity = async () => {
        if (!page || page.isClosed()) {
            logWarn('Page closed, stopping activity simulation.');
            return;
        }
      
        const nextInterval = getNextActivityInterval();
        logDebug(`Next activity in ${nextInterval/1000} seconds`);
      
        setTimeout(async () => {
            await simulateActivity(page);
            scheduleNextActivity(); // Schedule the next one
        }, nextInterval);
    };
  
    scheduleNextActivity();
}

// --- Core Logic Functions ---

async function findAndClickStartButton(page) {
    logInfo('Looking for "Start DVA" button...');
    const startButtonLocator = page.locator('button:has-text("Start DVA")');

    try {
        await takeScreenshot(page, 'Before-Click-Start-DVA');
        await startButtonLocator.click({ timeout: 30000 });
        logSuccess('Clicked "Start DVA" button.');
        await takeScreenshot(page, 'After-Click-Start-DVA');
        return true;
    } catch (error) {
        logError(`Failed to find or click "Start DVA" button`, error);
        await takeScreenshot(page, 'Start-DVA-button-Error');
        await savePageHTML(page, 'Start-DVA-button-Error');
        return false;
    }
}

async function isAgentRunning(page) {
    logInfo('Checking agent status...');
    const runningIndicatorSelector = 'div:has(span.bg-success) > span:has-text("Running")';

    try {
        const isVisible = await page.locator(runningIndicatorSelector).isVisible({ timeout: 15000 });
        if (isVisible) {
             logSuccess('Agent detected in "Running" state.');
             await takeScreenshot(page, 'Agent-Detected-Running');
             return true;
        }
        logInfo('Agent "Running" state not found (within timeout).');
        return false;
    } catch (error) {
        logWarn(`Agent "Running" check failed: ${error.message}. Assuming not running.`);
        await takeScreenshot(page, 'Agent-Running-Check-Error');
        return false;
    }
}

// --- New Function for Page Lifecycle Management ---
async function runPageCycle(browser, context) {
    let page = null;
    let cycleTimeoutId = null;
  
    try {
        logInfo('Opening new page...');
        page = await context.newPage();
        logSuccess('Page opened.');

        page.on('crash', () => {
            logError('Page crashed!');
            if (cycleTimeoutId) clearTimeout(cycleTimeoutId);
            runPageCycle(browser, context); // Restart cycle on crash
        });

        logInfo(`Navigating to ${BASE_URL}...`);
        await page.goto(BASE_URL, { waitUntil: 'networkidle', timeout: PAGE_TIMEOUT });
        await takeScreenshot(page, 'Initial-PageLoad');

        await setRequiredLocalStorage(page);

        logInfo('Reloading page with localStorage...');
        await page.reload({ waitUntil: 'networkidle', timeout: PAGE_TIMEOUT });
        await takeScreenshot(page, 'Page-Reloaded-with-LocalStorage');
        await page.waitForTimeout(7000);

        logInfo('Checking initial agent status...');
        let agentIsRunning = await isAgentRunning(page);
        let clickSucceeded = false;

        if (!agentIsRunning) {
            logInfo("Agent not running, attempting start...");
            clickSucceeded = await findAndClickStartButton(page);

            if (clickSucceeded) {
                 logInfo("Start button clicked. Waiting 20s before re-checking status...");
                 await page.waitForTimeout(20000);
                 agentIsRunning = await isAgentRunning(page); // Re-check

                 if (!agentIsRunning) {
                      logWarn("Agent still not detected as 'Running' after extended wait. Proceeding anyway.");
                      await takeScreenshot(page, 'Warning-Agent-Still-Not-Running');
                      agentIsRunning = true; // Assume it's starting and proceed
                 } else {
                    logSuccess("Agent confirmed running after click and wait.");
                 }
            } else {
                 logError("Click attempt on 'Start DVA' button failed.");
                 // agentIsRunning remains false
            }
        } else {
             // Already running from the start
        }

        // --- Session Keeping ---
        if (agentIsRunning) {
            logSuccess('Agent running confirmed or assumed.');
            keepSessionActive(page);

            // Calculate and schedule the next page reload cycle
            const nextReload = getNextPageReloadInterval();
            logHighlight(`Next page reload scheduled in ${nextReload.readableTime}`);
          
            cycleTimeoutId = setTimeout(async () => {
                logHighlight('Scheduled page reload cycle starting now...');
                if (!page.isClosed()) {
                    await takeScreenshot(page, 'Before-Scheduled-Reload');
                    await page.close().catch(err => logError('Error closing page during reload cycle', err));
                }
                runPageCycle(browser, context); // Start a new cycle
            }, nextReload.interval);

        } else {
            // Only reach here if !agentIsRunning initially AND clickSucceeded was false
            logError('Failed to start agent. Could not confirm running state and click attempt failed.', null);
            await takeScreenshot(page, 'Failure-Agent-Not-Started-Final');
            await savePageHTML(page, 'Failure-Agent-Not-Started-Final');
          
            // Even on failure, try again after a delay
            logInfo('Will retry in 2 minutes...');
            cycleTimeoutId = setTimeout(() => {
                if (!page.isClosed()) {
                    page.close().catch(err => logError('Error closing page during failure retry', err));
                }
                runPageCycle(browser, context);
            }, 2 * 60 * 1000);
        }

    } catch (error) {
        logError(`Error in page cycle`, error);
        if (page && !page.isClosed()) {
            await takeScreenshot(page, 'Error-In-Page-Cycle');
            await page.close().catch(() => {});
        }
      
        // Retry after error
        logInfo('Will retry after error in 60 seconds...');
        setTimeout(() => runPageCycle(browser, context), 60 * 1000);
    }
}

// --- Main Execution ---

async function main() {
    cleanupScreenshots();

    let browser = null;
    let context = null;

    // --- Exit Handler ---
    let isExiting = false;
    const handleExit = async (signalOrReason) => {
        if (isExiting) return;
        isExiting = true;
        logHighlight(`Received ${signalOrReason}. Cleaning up...`);

        if (browser && browser.isConnected()) {
            logInfo('Closing browser...');
            await browser.close().catch(err => logError('Error closing browser during cleanup', err));
            logSuccess('Browser closed.');
        } else if (browser && !browser.isConnected()) {
             logWarn('Browser was already disconnected.');
        } else {
            logInfo('Browser not initialized or already cleaned up.');
        }

        // Exit code 0 for planned stops (SIGINT), 1 otherwise
        const exitCode = (signalOrReason === 'SIGINT') ? 0 : 1;
        logHighlight(`Exiting script (Code: ${exitCode}).`);
        process.exit(exitCode);
    };

    process.on('SIGINT', () => handleExit('SIGINT'));
    process.on('SIGTERM', () => handleExit('SIGTERM'));
    process.on('uncaughtException', async (err, origin) => {
        logError(`UNCAUGHT EXCEPTION (Origin: ${origin})`, err);
        process.exitCode = 1;
        await handleExit('uncaughtException');
    });
    process.on('unhandledRejection', async (reason, promise) => {
        logError(`UNHANDLED REJECTION`, reason);
        console.error('Promise:', promise);
        process.exitCode = 1;
        await handleExit('unhandledRejection');
    });
    // --- End Exit Handler ---

    try {
        logInfo('Launching browser...');
        browser = await chromium.launch({
            headless: true,
            args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage', '--disable-gpu']
        });
        logSuccess('Browser launched.');

        browser.on('disconnected', () => {
             logError('Browser disconnected unexpectedly!');
             if (!isExiting) handleExit('browser_disconnected');
        });

        logInfo('Creating browser context...');
        context = await browser.newContext({
            viewport: { width: 1280, height: 800 },
            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
        });
      
        // Start the first page cycle
        runPageCycle(browser, context);
      
        // Keep the script running
        await new Promise(() => {});

    } catch (error) {
        // Errors from inside try block are caught here
        logError(`FATAL ERROR in main execution`, error);
        process.exitCode = 1;
        await handleExit(`main_catch`); // Trigger cleanup/exit
    }
}

// --- Start the script ---
main();


After nyung ma paste yan, open nyu cmd sa folder na nagawa nyo tas type kayo nito

Code: 
npm install playwright


Tas after nyan, type nadin kayo npx playwright install tas pagka tapos nyan gawa kayo configs.json na same folder naiyan tas ito ilalagay nyong code inside the js file naiyan


Code: 
{
    "address": "WALLETADDRESSMOHERE",
    "bearer": "BEARERTOKENMOHERE",
    "llm_token": "LLMTOKENMOHERE",
    "task_token": "TASKTOKENMOHERE",
    "invite_code": "INVCODEMOHERE"
}


tas after nyan punta kayo ulet sa gataxyz dashboard, press nyu F12 sa keyboard nyo or access Developer Tools kung anong browser gamit nyopo and then i sta-start nyulang yung DVA which is START DVA as far as I can remember hahaha, after starting, just do the human thingy verification kay CF and then punta kayo ulet sa Developer Tools and punta kayo Application Tab and fetch the Tokens, below is the token you need to fetch

1746968268169.webp

After mong ma paste lahat lahat dun sa configs.json file then you can start the bot napo hehe,

Start the bot
Code: 
node .

Screenshot when bot run successfully
1746968882537.webp

Bot Feature:?

GATAXYZ Auto Bot Features​


  • DVA (Data/Virtual Agent) Automation: Automatically starts and maintains a running agent
  • Browser Automation: Uses Playwright to control a headless Chrome browser
  • Session Management: Sets up and maintains browser sessions with authentication tokens
  • Periodic Activity Simulation: Scrolls the page at random intervals to mimic human activity
  • Page Reload Cycle: Refreshes the page every ~65-70 minutes to maintain freshness
  • Error Recovery: Automatically detects and recovers from crashes and failures
  • Detailed Logging: Color-coded console output with different severity levels
  • Screenshot Capture: Takes screenshots at key moments for debugging
  • Crash Handling: Detects browser crashes and automatically restarts
  • Cleanup Process: Removes old screenshot file

This script is designed to keep a GATA.xyz DVA (Data Virtual Agent) running continuously, without requiring manual intervention. It handles authentication, monitors the agent's status, and takes actions to ensure it stays active.


The bot uses sophisticated techniques to appear as a legitimate human user by:
  1. Setting proper user agents
  2. Adding randomness to action timing
  3. Simulating natural scrolling behavior
  4. Maintaining proper browser states
Tips:
basta makikita nyu sa current_screenshot.png na hindi na nag ru-run like nasa default ano sya like dinaka start, try nyupong i visit yung gataxyz page again and then click mopo yung Start, since sure akong if may error sa itaas, log out nyulang and then log in ulet tas edit nyolang yung mga TOKENS sa configs.json, and if wala pong error like Start human verification thingy, recommended konalang din po na i log out tas log in ulet, tas if walang job, just off it, wait kalang mga 8pm meron na ulet yan I guess

Enjoy po, you can view your points via current_screenshot.png na file po sa folder, mag u-update yan every 3 mins and 5 seconds hehe, enjoy again and use at your own risk

Funding:
1746968746786.webp
 

About this Thread

  • 9
    Replies
  • 976
    Views
  • 5
    Participants
Last reply from:
PHC-PROXYPIRATE

New Topics

Trending Topics

Online now

Members online
392
Guests online
4,410
Total visitors
4,802

Forum statistics

Threads
2,311,814
Posts
29,164,781
Members
1,186,895
Latest member
INC3
Back
Top