index.js

require('dotenv').config();
const axios = require('axios');
const UserAgent = require('user-agents');
const { ethers } = require('ethers');

const TWOCAPTCHA_API_KEY = process.env['2captchakey'];
const wallets = Object.keys(process.env)
  .filter(key => key.startsWith('PRIVATE_KEY_') && process.env[key].trim())
  .map(key => {
    try {
      const privateKey = process.env[key];
      const wallet = new ethers.Wallet(privateKey);
      return {
        privateKey,
        address: wallet.address
      };
    } catch (error) {
      console.error(`Invalid private key for ${key}: ${error.message}`);
      return null;
    }
  })
  .filter(wallet => wallet !== null);

const LOGIN_URL = 'https://fluxai-backend.up.railway.app/api/login';
const RECAPTCHA_URL = 'https://www.google.com/recaptcha/api2/clr?k=6LeYKVErAAAAAEssdGfwCOF8Dv-85d7jgNmq6kF4';
const GENERATE_IMAGE_URL = 'https://fluxai-backend.up.railway.app/api/generate-image';

const colors = {
  reset: "\x1b[0m",
  cyan: "\x1b[36m",
  green: "\x1b[32m",
  yellow: "\x1b[33m",
  red: "\x1b[31m",
  white: "\x1b[37m",
  bold: "\x1b[1m"
};

const logger = {
  info: (msg) => console.log(`${colors.green}[✓] ${msg}${colors.reset}`),
  warn: (msg) => console.log(`${colors.yellow}[⚠] ${msg}${colors.reset}`),
  error: (msg) => console.log(`${colors.red}[✗] ${msg}${colors.reset}`),
  success: (msg) => console.log(`${colors.green}[✅] ${msg}${colors.reset}`),
  loading: (msg) => console.log(`${colors.cyan}[⟳] ${msg}${colors.reset}`),
  step: (msg) => console.log(`${colors.white}[➤] ${msg}${colors.reset}`),
  banner: () => {
    console.log(`${colors.cyan}${colors.bold}`);
    console.log(`---------------------------------------------`);
    console.log(`  Flux Ai Auto Bot - Airdrop Insiders  `);
    console.log(`---------------------------------------------${colors.reset}`);
    console.log();
  }
};

const prompts = [
  'A futuristic city at sunset with flying cars',
  'A serene beach with bioluminescent waves at night',
  'A majestic dragon soaring over a mountain range',
  'A cozy cabin in a snowy forest under the aurora',
  'A steampunk robot in a Victorian workshop',
  'A vibrant underwater coral reef with exotic fish',
  'A cyberpunk hacker in a neon-lit alley',
  'A medieval knight battling a mythical creature',
  'A surreal dreamscape with floating islands',
  'A colorful abstract painting with geometric shapes',
  'A futuristic space station orbiting a distant planet',
  'A whimsical forest with talking animals',
  'A post-apocalyptic wasteland with overgrown ruins',
  'A magical library with glowing books',
  'A retro 80s arcade with neon lights'
];

const getRandomPrompt = () => {
  return prompts[Math.floor(Math.random() * prompts.length)];
};

const getHeaders = (walletAddress) => {
  const userAgent = new UserAgent();
  return {
    'accept': '*/*',
    'accept-language': 'en-US,en;q=0.5',
    'content-type': 'application/json',
    'priority': 'u=1, i',
    'sec-ch-ua': userAgent.secChUa || '"Brave";v="137", "Chromium";v="137", "Not/A)Brand";v="24"',
    'sec-ch-ua-mobile': userAgent.isMobile ? '?1' : '?0',
    'sec-ch-ua-platform': `"${userAgent.platform || 'Windows'}"`,
    'sec-fetch-dest': 'empty',
    'sec-fetch-mode': 'cors',
    'sec-fetch-site': 'cross-site',
    'sec-gpc': '1',
    'x-wallet-address': walletAddress,
    'Referer': 'https://generate.flux-ai.me/',
    'Referrer-Policy': 'strict-origin-when-cross-origin',
    'User-Agent': userAgent.toString()
  };
};

async function login(walletAddress) {
  try {
    logger.loading(`Attempting login for wallet ${walletAddress.slice(0, 6)}...${walletAddress.slice(-4)}...`);
    const response = await axios.post(LOGIN_URL, {}, {
      headers: getHeaders(walletAddress),
      maxRedirects: 0,
      validateStatus: status => status >= 200 && status < 300
    });
    logger.success('Login successful');
    logger.info(`Credits Left: ${response.data.creditsLeft}`);
    return response.data.creditsLeft;
  } catch (error) {
    logger.error(`Login Error: ${error.response?.data?.message || error.message}`);
    throw error;
  }
}

async function solveRecaptcha(recaptchaVersion = 'v2', maxRetries = 3) {
  const siteKey = '6LeYKVErAAAAAEssdGfwCOF8Dv-85d7jgNmq6kF4';
  const pageUrl = 'https://generate.flux-ai.me/';

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      logger.loading(`Solving reCAPTCHA ${recaptchaVersion} with 2Captcha (Attempt ${attempt}/${maxRetries})`);

      const requestUrl = `http://2captcha.com/in.php?key=${TWOCAPTCHA_API_KEY}&method=userrecaptcha&googlekey=${siteKey}&pageurl=${pageUrl}&json=1${recaptchaVersion === 'v3' ? '&version=v3' : ''}`;
      const requestResponse = await axios.get(requestUrl);

      if (requestResponse.data.status !== 1) {
        logger.error(`Failed to submit reCAPTCHA task: ${requestResponse.data.error_text || 'Unknown error'}`);
        if (attempt === maxRetries) return null;
        await new Promise(resolve => setTimeout(resolve, 5000));
        continue;
      }

      const requestId = requestResponse.data.request;
      logger.step(`reCAPTCHA task submitted, ID: ${requestId}`);

      let pollAttempts = 0;
      const maxPollAttempts = 30;
      const pollInterval = 5000;

      while (pollAttempts < maxPollAttempts) {
        await new Promise(resolve => setTimeout(resolve, pollInterval));
        const resultUrl = `http://2captcha.com/res.php?key=${TWOCAPTCHA_API_KEY}&action=get&id=${requestId}&json=1`;
        const resultResponse = await axios.get(resultUrl);

        if (resultResponse.data.status === 1) {
          logger.success(`reCAPTCHA ${recaptchaVersion} solved successfully`);
          return resultResponse.data.request;
        }

        if (resultResponse.data.request === 'ERROR_CAPTCHA_UNSOLVABLE') {
          logger.error(`reCAPTCHA ${recaptchaVersion} unsolvable`);
          if (attempt === maxRetries) return null;
          break;
        }

        pollAttempts++;
        logger.step(`Waiting for reCAPTCHA ${recaptchaVersion} solution (Attempt ${pollAttempts}/${maxPollAttempts})`);
      }
    } catch (error) {
      logger.error(`reCAPTCHA ${recaptchaVersion} solving error: ${error.message}`);
      if (attempt === maxRetries) return null;
      await new Promise(resolve => setTimeout(resolve, 5000));
    }
  }

  logger.error(`reCAPTCHA ${recaptchaVersion} solving failed after ${maxRetries} attempts`);
  return null;
}

async function generateImage(walletAddress, recaptchaToken) {
  const imageHeaders = {
    ...getHeaders(walletAddress),
    'x-recaptcha-token': recaptchaToken
  };
  const body = {
    prompt: getRandomPrompt()
  };

  try {
    logger.loading(`Generating image with prompt: "${body.prompt}"...`);
    const response = await axios.post(GENERATE_IMAGE_URL, body, {
      headers: imageHeaders,
      maxRedirects: 0,
      validateStatus: status => status >= 200 && status < 300
    });
    logger.success('Image generated successfully');
    logger.info(`Image URL: ${response.data.imageUrl}`);
    return response.data;
  } catch (error) {
    logger.error(`Image Generation Error: ${error.response?.data?.message || error.message}`);
    throw error;
  }
}

const getNextRunTime = () => {
  const now = new Date();
  now.setHours(now.getHours() + 24);
  now.setMinutes(0);
  now.setSeconds(0);
  now.setMilliseconds(0);
  return now;
};

const displayCountdown = (nextRunTime, maxGenerations) => {
  return new Promise((resolve) => {
    const updateCountdown = () => {
      const now = new Date();
      const timeLeft = nextRunTime - now;

      if (timeLeft <= 0) {
        logger.info('Starting new daily image generation...');
        clearInterval(countdownInterval);
        resolve();
        return;
      }

      const hours = Math.floor(timeLeft / (1000 * 60 * 60));
      const minutes = Math.floor((timeLeft % (1000 * 60 * 60)) / (1000 * 60));
      const seconds = Math.floor((timeLeft % (1000 * 60)) / 1000);

      process.stdout.write(`\r${colors.cyan}[⏰] Next run in: ${hours}h ${minutes}m ${seconds}s${colors.reset} `);
    };

    updateCountdown();
    const countdownInterval = setInterval(updateCountdown, 1000);
  });
};

async function processWallet(wallet, maxGenerations) {
  const { address } = wallet;
  logger.info(`Processing wallet: ${address.slice(0, 6)}...${address.slice(-4)}`);
  let creditsLeft;
  try {
    creditsLeft = await login(address);
    if (creditsLeft <= 0) {
      logger.warn('No credits left for this wallet.');
      return false;
    }
  } catch (error) {
    return false;
  }

  let generations = 0;
  while (generations < maxGenerations && creditsLeft > 0) {
    try {
      logger.step(`Image generation attempt ${generations + 1}/${maxGenerations}`);
      let recaptchaToken;
      try {
        logger.step('Trying reCAPTCHA v2...');
        recaptchaToken = await solveRecaptcha('v2');
        if (!recaptchaToken) throw new Error('reCAPTCHA v2 failed to solve');
      } catch (v2Error) {
        logger.error('reCAPTCHA v2 failed, trying v3...');
        recaptchaToken = await solveRecaptcha('v3');
        if (!recaptchaToken) throw new Error('reCAPTCHA v3 failed to solve');
      }

      const result = await generateImage(address, recaptchaToken);
      creditsLeft = result.creditsLeft;
      logger.success(`Image Generated Successfully: ${result.imageUrl}`);
      logger.info(`Credits Left: ${creditsLeft}`);
      generations++;
    } catch (error) {
      logger.error(`Generation failed: ${error.message}`);
      break;
    }
  }

  if (generations === maxGenerations) {
    logger.success(`Completed ${maxGenerations} generations for wallet.`);
  } else if (creditsLeft <= 0) {
    logger.warn('Stopped: No credits remaining.');
  }
  return true;
}

async function runImageGeneration(maxGenerations = 3) {
  logger.banner();

  if (!TWOCAPTCHA_API_KEY) {
    logger.error('2captchakey is not defined in .env file');
    return;
  }
  if (wallets.length === 0) {
    logger.error('No valid private keys found in .env');
    return;
  }

  while (true) {
    logger.info(`Starting image generation process at ${new Date().toLocaleString('en-US', { timeZone: 'Asia/Makassar' })}`);

    for (const wallet of wallets) {
      await processWallet(wallet, maxGenerations);
    }

    const nextRunTime = getNextRunTime();
    logger.info(`Next run scheduled at: ${nextRunTime.toLocaleString('en-US', { timeZone: 'Asia/Makassar' })}`);
    await displayCountdown(nextRunTime, maxGenerations);
  }
}

runImageGeneration().catch(error => logger.error(`Bot error: ${error.message}`));