index.js

const axios = require('axios');
const WebSocket = require('ws');
const { ethers } = require('ethers');
const { HttpsProxyAgent } = require('https-proxy-agent');
const fs = require('fs');
const dotenv = require('dotenv');

dotenv.config();

let TwoCaptcha;
let solver;
if (process.env['2captcha_api']) {
  TwoCaptcha = require('@2captcha/captcha-solver');
  solver = new TwoCaptcha.Solver(process.env['2captcha_api']);
}

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

const logger = {
  info: (msg) => console.log(`${colors.green}[✓] ${msg}${colors.reset}`),
  wallet: (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('   Layer Edge Auto Bot - Airdrop Insiders  ');
    console.log('---------------------------------------------');
    console.log(`${colors.reset}\n`);
  },
  agent: (msg) => console.log(`${colors.white}${msg}${colors.reset}`)
};

const globalWebSocketMessages = [];

let proxies = [];
try {
  proxies = fs.readFileSync('proxies.txt', 'utf8')
    .split('\n')
    .map(line => line.trim())
    .filter(line => line && !line.startsWith('#'));
} catch (error) {
  logger.error('Failed to load proxies.txt, running without proxy');
}

function getRandomProxy() {
  if (proxies.length === 0) return null;
  return proxies[Math.floor(Math.random() * proxies.length)];
}

function getWalletLabel(walletAddress, index) {
  return walletAddress ? `Wallet ${walletAddress.slice(-4)}` : `Wallet-${index}`;
}

async function solveRecaptcha() {
  if (!solver) {
    throw new Error('2Captcha API key not provided in .env');
  }
  try {
    logger.loading('Solving reCAPTCHA...');
    const response = await solver.recaptcha({
      googlekey: '6Ld0UwcrAAAAAAw0Xq8Aytksqiv354zbaBeyBNTM',
      pageurl: 'https://dashboard.layeredge.io'
    });
    logger.success('reCAPTCHA solved successfully');
    return response.data;
  } catch (error) {
    logger.error(`reCAPTCHA solving failed: ${error.message}`);
    throw error;
  }
}

function getWalletAddress(privateKey) {
  try {
    const wallet = new ethers.Wallet(privateKey);
    return wallet.address;
  } catch (error) {
    logger.error(`Invalid private key: ${error.message}`);
    throw error;
  }
}

async function fetchWsToken(userId, walletAddress, proxy, label) {
  try {
    const recaptchaToken = await solveRecaptcha();
    const response = await axios.post(
      'https://websocket.layeredge.io/api/auth/ws-token',
      {
        user_id: userId,
        wallet_address: walletAddress,
        recaptcha_token: recaptchaToken
      },
      {
        headers: {
          'accept': 'application/json, text/plain, */*',
          'content-type': 'application/json',
          'sec-fetch-dest': 'empty',
          'sec-fetch-mode': 'cors',
          'sec-fetch-site': 'same-site',
          'Referer': 'https://dashboard.layeredge.io/',
          'Referrer-Policy': 'strict-origin-when-cross-origin',
          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36',
          'Origin': 'https://dashboard.layeredge.io'
        },
        httpsAgent: proxy ? new HttpsProxyAgent(proxy) : undefined
      }
    );
    logger.success(`WebSocket token fetched for ${label} (${walletAddress})`);
    return response.data.token;
  } catch (error) {
    logger.error(`Failed to fetch WebSocket token for ${label} (${walletAddress}): ${error.message}`);
    throw error;
  }
}

async function fetchNodeStatus(userId, proxy, label, walletAddress, retries = 5, delay = 2000) {
  const epochNames = [process.env['EPOCH_NAME'] || 'epoch 2', 'epoch 3', 'epoch 1']; 
  for (const epochName of epochNames) {
    for (let attempt = 1; attempt <= retries; attempt++) {
      try {
        const response = await axios.get(
          `https://api.layeredge.io/api/epoch/node-status/${userId}?epochName=${encodeURIComponent(epochName)}`,
          {
            headers: {
              'accept': 'application/json, text/plain, */*',
              'accept-language': 'en-US,en;q=0.9',
              'sec-fetch-dest': 'empty',
              'sec-fetch-mode': 'cors',
              'sec-fetch-site': 'same-site',
              'Referer': 'https://dashboard.layeredge.io/',
              'Referrer-Policy': 'strict-origin-when-cross-origin',
              'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36',
              'Origin': 'https://dashboard.layeredge.io'
            },
            httpsAgent: proxy ? new HttpsProxyAgent(proxy) : undefined
          }
        );
        if (!response.data.data) {
          throw new Error('No data field in node status response');
        }
        logger.info(`Total Epoch Points for ${label} (${walletAddress}): ${response.data.data.totalEpochPoints}`);
        return response.data.data;
      } catch (error) {
        if (error.response && [500, 504].includes(error.response.status) && attempt < retries) {
          logger.loading(`Attempt ${attempt} failed with status ${error.response.status} for ${label} (${walletAddress}) with ${epochName}. Retrying in ${delay}ms...`);
          await new Promise(resolve => setTimeout(resolve, delay));
          continue;
        }
        logger.error(`Failed to fetch node status for ${label} (${walletAddress}) with ${epochName}: ${error.message}`);
        if (error.response && error.response.data) {
          logger.error(`Server response: ${error.response.data.message || 'No message provided'}`);
        }
        break; 
      }
    }
  }
  throw new Error('All epoch attempts failed');
}

async function fetchWalletDetails(walletAddress, proxy, label, retry = true) {
  try {
    const response = await axios.get(
      `https://api.layeredge.io/api/referral/wallet-details/${walletAddress}`,
      {
        headers: {
          'accept': 'application/json, text/plain, */*',
          'accept-language': 'en-US,en;q=0.9',
          'sec-fetch-dest': 'empty',
          'sec-fetch-mode': 'cors',
          'sec-fetch-site': 'same-site',
          'Referer': 'https://dashboard.layeredge.io/',
          'Referrer-Policy': 'strict-origin-when-cross-origin',
          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36',
          'Origin': 'https://dashboard.layeredge.io'
        },
        httpsAgent: proxy ? new HttpsProxyAgent(proxy) : undefined
      }
    );

    if (!response.data.data) {
      throw new Error('No data field in wallet details response. Wallet may not be registered.');
    }

    return response.data.data;
  } catch (error) {
    logger.error(`Failed to fetch wallet details for ${label} (${walletAddress}): ${error.message}`);
    if (error.response && error.response.data.message.includes('CORS') && retry && proxies.length > 0) {
      logger.loading(`CORS error detected for ${label} (${walletAddress}). Retrying with a different proxy...`);
      const newProxy = getRandomProxy();
      if (newProxy) {
        logger.agent(`Retrying with proxy: ${newProxy}`);
        return fetchWalletDetails(walletAddress, newProxy, label, false);
      }
    }
    throw error;
  }
}

function updateEnvFile(key, value, index) {
  const envData = fs.readFileSync('.env', 'utf8').split('\n');
  const keyRegex = new RegExp(`^${key}_${index}=.*$`, 'm');
  const newLine = `${key}_${index}=${value}`;
  let updated = false;

  const newEnvData = envData.map(line => {
    if (keyRegex.test(line)) {
      updated = true;
      return newLine;
    }
    return line;
  });

  if (!updated) {
    newEnvData.push(newLine);
  }

  fs.writeFileSync('.env', newEnvData.join('\n'));
}

async function connectWebSocket(walletData) {
  const { wsToken, walletAddress, userId, proxy, index, label } = walletData;
  const wsUrl = `wss://websocket.layeredge.io/ws/node?token=${wsToken}`;
  let reconnectAttempts = 0;
  const maxReconnectAttempts = 5;

  const walletMessages = {
    label,
    walletAddress,
    messages: []
  };
  globalWebSocketMessages.push(walletMessages);

  async function startWebSocket() {
    if (reconnectAttempts >= maxReconnectAttempts) {
      logger.error(`Max reconnect attempts reached for ${label} (${walletAddress}). Stopping.`);
      return;
    }
    reconnectAttempts++;

    return new Promise((resolve, reject) => {
      const ws = new WebSocket(wsUrl, {
        headers: {
          'accept-language': 'en-US,en;q=0.9',
          'cache-control': 'no-cache',
          'pragma': 'no-cache',
          'sec-websocket-extensions': 'permessage-deflate; client_max_window_bits',
          'sec-websocket-version': '13',
          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36'
        }
      });

      let heartbeatInterval;
      let inactivityTimeout;
      let pointsUpdateTimeout;

      ws.on('open', () => {
        reconnectAttempts = 0; 
        logger.success(`WebSocket connected for ${label} (${walletAddress})`);
        logger.step(`Sending NodeStart for ${label} (${walletAddress})`);
        ws.send(JSON.stringify({ type: 'NodeStart' }));

        heartbeatInterval = setInterval(() => {
          if (ws.readyState === WebSocket.OPEN) {
            logger.step(`Sending Heartbeat for ${label} (${walletAddress})`);
            ws.send(JSON.stringify({ type: 'Heartbeat' }));
          }
        }, 15000);

        inactivityTimeout = setTimeout(() => {
          logger.error(`No messages received for 30 seconds for ${label} (${walletAddress}). Reconnecting...`);
          ws.close();
        }, 30000);

        pointsUpdateTimeout = setTimeout(() => {
          logger.step(`No PointsUpdate received for ${label} (${walletAddress}). Resending NodeStart...`);
          if (ws.readyState === WebSocket.OPEN) {
            ws.send(JSON.stringify({ type: 'NodeStart' }));
          }
        }, 30000);

        resolve();
      });

      ws.on('message', (data) => {
        const message = JSON.parse(data);

        walletMessages.messages.push({
          timestamp: new Date().toISOString(),
          message: message
        });
        
        logger.step(`WebSocket message for ${label} (${walletAddress}): ${JSON.stringify(message)}`);

        clearTimeout(inactivityTimeout);
        inactivityTimeout = setTimeout(() => {
          logger.error(`No messages received for 30 seconds for ${label} (${walletAddress}). Reconnecting...`);
          ws.close();
        }, 30000);

        if (message.type === 'PointsUpdate') {
          clearTimeout(pointsUpdateTimeout);
        }
      });

      ws.on('error', (error) => {
        if (error.message.includes('401')) {
          logger.error(`WebSocket 401 error for ${label} (${walletAddress}). Refreshing token...`);
          ws.close();
        } else {
          logger.error(`WebSocket error for ${label} (${walletAddress}): ${error.message}`);
        }
      });

      ws.on('close', async (code, reason) => {
        clearInterval(heartbeatInterval);
        clearTimeout(inactivityTimeout);
        clearTimeout(pointsUpdateTimeout);

        if (code === 1006 || code === 1008 || error?.message?.includes('401')) {
          logger.loading(`Possible token expiry for ${label} (${walletAddress}). Refreshing token...`);
          try {
            const newToken = process.env['2captcha_api']
              ? await fetchWsToken(userId, walletAddress, proxy, label)
              : process.env[`ws_token_${index}`];
            
            if (!newToken) {
              throw new Error('No WebSocket token provided in .env');
            }
            updateEnvFile('ws_token', newToken, index);
            walletData.wsToken = newToken; 
            setTimeout(startWebSocket, 5000);
          } catch (error) {
            logger.error(`Failed to refresh token for ${label} (${walletAddress}): ${error.message}`);
            setTimeout(startWebSocket, 5000);
          }
        } else {
          logger.error(`WebSocket closed for ${label} (${walletAddress}) with code ${code}. Reason: ${reason || 'Unknown'}`);
          setTimeout(startWebSocket, 5000);
        }
      });
    });
  }

  await startWebSocket();
}

async function preprocessWalletsSequentially() {
  logger.step('Starting sequential wallet preprocessing...');
  
  let index = 1;
  const walletDataList = [];
  
  while (process.env[`private_key_${index}`]) {
    const privateKey = process.env[`private_key_${index}`];
    if (!privateKey) {
      logger.error(`Private key for index ${index} not found in .env`);
      index++;
      continue;
    }

    let walletAddress;
    try {
      walletAddress = getWalletAddress(privateKey);
    } catch (error) {
      logger.error(`Invalid private key for index ${index}: ${error.message}`);
      index++;
      continue;
    }

    const label = getWalletLabel(walletAddress, index);
    logger.wallet(`Processing ${label} (${walletAddress}) - Step 1: Captcha Solving`);

    const proxy = getRandomProxy();
    if (proxy) {
      logger.agent(`Using proxy: ${proxy}`);
    } else {
      logger.agent('Running without proxy');
    }

    try {
      logger.step(`Fetching wallet details for ${label}...`);
      const walletDetails = await fetchWalletDetails(walletAddress, proxy, label);
      const userId = walletDetails.id;
      updateEnvFile('id', userId, index);

      let wsToken = process.env[`ws_token_${index}`];
      if (!wsToken && !process.env['2captcha_api']) {
        throw new Error(`No 2Captcha API key or WebSocket token provided for ${label} (${walletAddress}) in .env`);
      }
      if (!wsToken) {
        logger.step(`Solving captcha for ${label}...`);
        wsToken = await fetchWsToken(userId, walletAddress, proxy, label);
        updateEnvFile('ws_token', wsToken, index);
      } else {
        logger.success(`Using manual WebSocket token for ${label} (${walletAddress})`);
      }

      walletDataList.push({ wsToken, walletAddress, userId, proxy, index, label });
    } catch (error) {
      logger.error(`Error preprocessing ${label} (${walletAddress}): ${error.message}`);
    }

    index++;
  }

  return walletDataList;
}

async function fetchNodeStatusForAllWallets(walletDataList) {
  logger.step('Fetching node status for all wallets...');
  
  for (const walletData of walletDataList) {
    const { userId, proxy, label, walletAddress } = walletData;
    try {
      logger.step(`Fetching node status for ${label}...`);
      await fetchNodeStatus(userId, proxy, label, walletAddress);
    } catch (error) {
      logger.error(`Skipping node status fetch for ${label} (${walletAddress}) due to error: ${error.message}`);
    }
  }
}

function displayAllWebSocketMessages() {
  logger.step('\n=== WebSocket Messages Summary ===');
  
  if (globalWebSocketMessages.length === 0) {
    logger.info('No WebSocket messages received yet.');
    return;
  }

  globalWebSocketMessages.forEach((walletData) => {
    logger.wallet(`\n--- Messages for ${walletData.label} (${walletData.walletAddress}) ---`);
    
    if (walletData.messages.length === 0) {
      logger.info('No messages received yet.');
    } else {
      walletData.messages.forEach((msg, index) => {
        logger.step(`[${msg.timestamp}] Message ${index + 1}: ${JSON.stringify(msg.message)}`);
      });
    }
  });
  
  logger.step('=== End of WebSocket Messages Summary ===\n');
}

async function main() {
  logger.banner();

  const walletDataList = await preprocessWalletsSequentially();

  if (walletDataList.length === 0) {
    logger.error('No valid wallets found in .env');
    return;
  }

  await fetchNodeStatusForAllWallets(walletDataList);

  logger.step('Connecting WebSockets for all wallets...');
  await Promise.all(walletDataList.map(walletData => connectWebSocket(walletData)));

  logger.success(`Successfully processed ${walletDataList.length} wallet(s)`);

  setInterval(() => {
    displayAllWebSocketMessages();
  }, 30000);

  setTimeout(() => {
    displayAllWebSocketMessages();
  }, 10000);
}

main().catch(error => logger.error(`Main execution failed: ${error.message}`));