airdrop.js

require('dotenv').config();
const { Account, RpcProvider, Contract, uint256, cairo } = require('starknet');
const fs = require('fs');
const path = require('path');
const readline = require('readline');

// Shared readline interface - will be set externally when used as module
let rl = null;

function setReadlineInterface(readlineInterface) {
  rl = readlineInterface;
}

function getReadlineInterface() {
  if (!rl) {
    rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout
    });
  }
  return rl;
}

function question(prompt) {
  return new Promise((resolve) => {
    getReadlineInterface().question(prompt, resolve);
  });
}

// ERC20 ABI minimal pour transfer
const ERC20_ABI = [
  {
    name: 'transfer',
    type: 'function',
    inputs: [
      { name: 'recipient', type: 'felt' },
      { name: 'amount', type: 'Uint256' }
    ],
    outputs: [{ name: 'success', type: 'felt' }],
    stateMutability: 'external'
  },
  {
    name: 'decimals',
    type: 'function',
    inputs: [],
    outputs: [{ name: 'decimals', type: 'felt' }],
    stateMutability: 'view'
  }
];

function listHolderFiles() {
  const holdersDir = path.join(__dirname, 'holders');
  if (!fs.existsSync(holdersDir)) {
    console.log('\nNo holders directory found!');
    return [];
  }

  const files = fs.readdirSync(holdersDir).filter(f => f.endsWith('.json'));

  if (files.length === 0) {
    console.log('\nNo holder files found in holders directory!');
    return [];
  }

  console.log('\n═══════════════════════════════════════');
  console.log('     AVAILABLE HOLDER LISTS');
  console.log('═══════════════════════════════════════');
  files.forEach((file, index) => {
    console.log(`${index + 1}. ${file}`);
  });
  console.log('═══════════════════════════════════════\n');

  return files;
}

async function loadHolders(filename) {
  const filePath = path.join(__dirname, 'holders', filename);
  const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
  return data.items || [];
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

function formatDuration(ms) {
  const totalSeconds = Math.max(0, Math.round(ms / 1000));
  const minutes = Math.floor(totalSeconds / 60);
  const seconds = totalSeconds % 60;
  return `${minutes}m ${seconds.toString().padStart(2, '0')}s`;
}

async function airdropTokens() {
  try {
    // Vérifier les variables d'environnement
    if (!process.env.STARKNET_ADDRESS || !process.env.STARKNET_PRIVATE_KEY) {
      console.log('\n❌ Error: STARKNET_ADDRESS and STARKNET_PRIVATE_KEY must be set in .env file');
      console.log('Copy .env.example to .env and fill in your wallet details.\n');
      return;
    }

    // Liste les fichiers de holders
    const files = listHolderFiles();
    if (files.length === 0) return;

    // Sélection du fichier
    const fileChoice = await question('Select holder list (number): ');
    const fileIndex = parseInt(fileChoice) - 1;

    if (fileIndex < 0 || fileIndex >= files.length) {
      console.log('Invalid selection.');
      return;
    }

    const selectedFile = files[fileIndex];
    console.log(`\nLoading holders from: ${selectedFile}`);

    const holders = await loadHolders(selectedFile);
    console.log(`Found ${holders.length} holders\n`);

    // Adresse du token à envoyer
    const tokenAddress = await question('Enter token address to send: ');
    const normalizedTokenAddress = tokenAddress?.trim();
    if (!normalizedTokenAddress || !normalizedTokenAddress.startsWith('0x')) {
      console.log('Invalid token address.');
      return;
    }

    // Quantité à envoyer par holder
    const amountPerHolder = await question('Enter amount to send per holder (in token units): ');
    const amount = parseFloat(amountPerHolder);

    if (isNaN(amount) || amount <= 0) {
      console.log('Invalid amount.');
      return;
    }

    // Taille des batches pour le multicall
    // Estimer le temps pour chaque option (7s par batch en moyenne)
    const avgTimePerBatch = 7; // secondes

    const estimateTime = (batchSize) => {
      const batches = Math.ceil(holders.length / batchSize);
      const totalSeconds = batches * avgTimePerBatch;
      const minutes = Math.floor(totalSeconds / 60);
      const seconds = totalSeconds % 60;
      return `~${minutes}m ${seconds}s (${batches} batches)`;
    };

    console.log('\nSelect batch size for multicall:');
    console.log(`1. Small (25 transfers/batch) - Safer - ${estimateTime(25)}`);
    console.log(`2. Medium (50 transfers/batch) - Recommended - ${estimateTime(50)}`);
    console.log(`3. Large (75 transfers/batch) - Faster - ${estimateTime(75)}`);
    console.log(`4. Very Large (100 transfers/batch) - Maximum speed - ${estimateTime(100)}`);
    console.log('5. Custom');

    const batchChoice = await question('Choice: ');
    let MULTICALL_BATCH_SIZE;

    switch (batchChoice.trim()) {
      case '1':
        MULTICALL_BATCH_SIZE = 25;
        break;
      case '2':
        MULTICALL_BATCH_SIZE = 50;
        break;
      case '3':
        MULTICALL_BATCH_SIZE = 75;
        break;
      case '4':
        MULTICALL_BATCH_SIZE = 100;
        break;
      case '5':
        const customSize = await question('Enter custom batch size: ');
        MULTICALL_BATCH_SIZE = parseInt(customSize);
        if (isNaN(MULTICALL_BATCH_SIZE) || MULTICALL_BATCH_SIZE <= 0) {
          console.log('Invalid batch size, using default (50)');
          MULTICALL_BATCH_SIZE = 50;
        }
        break;
      default:
        console.log('Invalid choice, using default (50)');
        MULTICALL_BATCH_SIZE = 50;
    }

    // Confirmation
    const totalBatches = Math.ceil(holders.length / MULTICALL_BATCH_SIZE);
    console.log('\n═══════════════════════════════════════');
    console.log('         AIRDROP SUMMARY');
    console.log('═══════════════════════════════════════');
    console.log(`Holders: ${holders.length}`);
    console.log(`Token: ${normalizedTokenAddress}`);
    console.log(`Amount per holder: ${amount}`);
    console.log(`Total to distribute: ${amount * holders.length}`);
    console.log(`Batch size: ${MULTICALL_BATCH_SIZE} transfers`);
    console.log(`Total batches: ${totalBatches}`);
    console.log(`From wallet: ${process.env.STARKNET_ADDRESS}`);
    console.log('═══════════════════════════════════════\n');

    const confirm = await question('Proceed with airdrop? (yes/no): ');
    if (!confirm || confirm.trim().toLowerCase() !== 'yes') {
      console.log('Airdrop cancelled.');
      return;
    }

    // Initialiser le provider et le compte
    const accountAddress = process.env.STARKNET_ADDRESS?.trim();
    const privateKey = process.env.STARKNET_PRIVATE_KEY?.trim();
    const rpcUrl = process.env.STARKNET_RPC_URL?.trim();

    if (!rpcUrl) {
      throw new Error('STARKNET_RPC_URL is not defined in .env');
    }

    if (!accountAddress || !privateKey) {
      throw new Error('STARKNET_ADDRESS or STARKNET_PRIVATE_KEY is not defined in .env');
    }

    // Créer le provider avec la syntaxe v8
    const provider = new RpcProvider({
      nodeUrl: rpcUrl,
      chainId: '0x534e5f4d41494e' // SN_MAIN
    });

    const account = new Account({
      provider,
      address: accountAddress,
      signer: privateKey
    });

    // Initialiser le contrat token
    const tokenContract = new Contract({
      abi: ERC20_ABI,
      address: normalizedTokenAddress,
      providerOrAccount: account
    });

    // Récupérer les decimals du token
    let decimals = 18;
    try {
      const decimalsResult = await tokenContract.decimals();

      // Extraire la valeur si c'est un objet BigInt ou un nombre
      if (typeof decimalsResult === 'bigint') {
        decimals = Number(decimalsResult);
      } else if (typeof decimalsResult === 'object' && decimalsResult !== null) {
        // Si c'est un objet, essayer d'extraire la première propriété ou la valeur
        const keys = Object.keys(decimalsResult);
        if (keys.length > 0) {
          decimals = Number(decimalsResult[keys[0]]);
        } else {
          decimals = Number(decimalsResult.toString());
        }
      } else {
        decimals = Number(decimalsResult);
      }

      // Vérifier que decimals est valide
      if (isNaN(decimals)) {
        console.log('Could not parse decimals, using 18 as default\n');
        decimals = 18;
      }
    } catch (error) {
      console.log('Could not fetch decimals, using 18 as default\n');
      console.log('Error:', error.message);
    }

    // Convertir le montant en wei
    const amountWei = BigInt(Math.floor(amount * (10 ** decimals)));
    const amountUint256 = uint256.bnToUint256(amountWei);

    console.log(`\nStarting airdrop with multicall (${MULTICALL_BATCH_SIZE} transfers per batch)...\n`);

    let successCount = 0;
    let failCount = 0;
    const failedRecipients = new Map(); // Track unique recipients from failed batches

    // Diviser les holders en batches
    const finalTotalBatches = Math.ceil(holders.length / MULTICALL_BATCH_SIZE);
    const batchDurations = [];
    for (let batchIndex = 0; batchIndex < finalTotalBatches; batchIndex++) {
      const start = batchIndex * MULTICALL_BATCH_SIZE;
      const end = Math.min(start + MULTICALL_BATCH_SIZE, holders.length);
      const batchHolders = holders.slice(start, end);

      console.log(`\n[Batch ${batchIndex + 1}/${finalTotalBatches}] Processing ${batchHolders.length} transfers (${start + 1}-${end})...`);

      if (batchDurations.length > 0) {
        const averageDuration = batchDurations.reduce((sum, duration) => sum + duration, 0) / batchDurations.length;
        const remainingBatches = finalTotalBatches - batchIndex;
        const etaMs = averageDuration * remainingBatches;
        console.log(`  Estimated time remaining: ~${formatDuration(etaMs)}`);
      }

      // Créer les calls pour le multicall
      const calls = batchHolders.map(holder => ({
        contractAddress: normalizedTokenAddress,
        entrypoint: 'transfer',
        calldata: [holder.holder, amountUint256.low, amountUint256.high]
      }));

      const batchStart = Date.now();
      try {
        // Exécuter le multicall
        const tx = await account.execute(calls);
        console.log(`  ✓ Multicall transaction hash: ${tx.transaction_hash}`);
        console.log(`  Waiting for confirmation...`);

        // Attendre la confirmation pour ce batch
        await provider.waitForTransaction(tx.transaction_hash);

        console.log(`  ✓ Batch confirmed! ${batchHolders.length} transfers successful`);
        successCount += batchHolders.length;

      } catch (error) {
        console.log(`  ✗ Batch failed: ${error.message}`);

        let newFailures = 0;
        batchHolders.forEach((holder, indexInBatch) => {
          if (holder?.holder && !failedRecipients.has(holder.holder)) {
            failedRecipients.set(holder.holder, {
              address: holder.holder,
              amountTokens: amount,
              amountWei: amountWei.toString(),
              batch: batchIndex + 1,
              position: start + indexInBatch + 1
            });
            newFailures++;
          }
        });

        failCount += newFailures;

        if (newFailures > 0) {
          console.log(`  Logged ${newFailures} recipients for retry (${failCount} total recorded).`);
        } else {
          console.log('  No new recipients added to retry list (possible duplicates).');
        }

        // En cas d'échec du batch, on peut optionnellement continuer avec les suivants
        console.log(`  Continuing with next batch...`);
      }

      const batchDuration = Date.now() - batchStart;
      batchDurations.push(batchDuration);
      const remainingBatchesAfterCurrent = finalTotalBatches - (batchIndex + 1);
      if (remainingBatchesAfterCurrent > 0) {
        const averageDuration = batchDurations.reduce((sum, duration) => sum + duration, 0) / batchDurations.length;
        const etaMs = averageDuration * remainingBatchesAfterCurrent;
        console.log(`  Updated ETA: ~${formatDuration(etaMs)} remaining`);
      }
    }

    let failedReportPath = null;
    if (failedRecipients.size > 0) {
      const failuresDir = path.join(__dirname, 'airdrop-failures');
      if (!fs.existsSync(failuresDir)) {
        fs.mkdirSync(failuresDir, { recursive: true });
      }

      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
      const filename = `${normalizedTokenAddress.slice(0, 10)}_${timestamp}.json`;
      failedReportPath = path.join(failuresDir, filename);

      const failurePayload = {
        generatedAt: new Date().toISOString(),
        tokenAddress: normalizedTokenAddress,
        sourceHoldersFile: selectedFile,
        decimals,
        amountPerHolderTokens: amount,
        amountPerHolderWei: amountWei.toString(),
        failedCount: failedRecipients.size,
        recipients: Array.from(failedRecipients.values())
      };

      fs.writeFileSync(failedReportPath, JSON.stringify(failurePayload, null, 2));
    }

    console.log('\n═══════════════════════════════════════');
    console.log('         AIRDROP COMPLETE');
    console.log('═══════════════════════════════════════');
    console.log(`Successful: ${successCount}`);
    console.log(`Failed (recorded): ${failCount}`);
    if (failedReportPath) {
      const relativePath = path.relative(process.cwd(), failedReportPath);
      console.log(`Failed recipients saved to: ${relativePath}`);
    } else {
      console.log('No failed recipients to retry.');
    }
    console.log('═══════════════════════════════════════\n');

  } catch (error) {
    console.error('\n❌ Airdrop error:', error.message);
  }
}

// Export pour utilisation dans index.js
module.exports = { airdropTokens, setReadlineInterface };

// Permettre l'exécution standalone
if (require.main === module) {
  airdropTokens().then(() => {
    if (rl) rl.close();
    process.exit(0);
  }).catch(error => {
    console.error(error);
    if (rl) rl.close();
    process.exit(1);
  });
}