fetch_contract_code.js

/**
 * Fetch ERC20 contract bytecode from Ethereum RPC
 * Reads addresses from erc20_metadata_failed.json and saves contract code to erc20_for_local_deploy.json
 */

const fs = require('fs');
const path = require('path');

// Configuration
const RPC_URL = process.env.ETHEREUM_RPC_URL || 'https://ethereum.publicnode.com';
const INPUT_FILE = path.join(__dirname, 'erc20_metadata_failed.json');
const OUTPUT_FILE = path.join(__dirname, 'erc20_for_local_deploy.json');
const PROGRESS_FILE = path.join(__dirname, 'erc20_fetch_progress.json');
const BATCH_SIZE = parseInt(process.env.BATCH_SIZE) || 10;
const BATCH_DELAY = parseInt(process.env.BATCH_DELAY) || 3000;

/**
 * Make batch RPC calls
 * @param {Array} addresses - Array of addresses
 * @param {string} rpcUrl - RPC endpoint URL
 * @returns {Promise<Array>} - Array of results
 */
async function fetchCodeBatch(addresses, rpcUrl) {
  const batch = addresses.map((addr, idx) => ({
    jsonrpc: '2.0',
    method: 'eth_getCode',
    params: [addr, 'latest'],
    id: idx + 1,
  }));

  const response = await fetch(rpcUrl, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(batch),
  });

  if (response.status === 429) {
    throw new Error('Rate limited');
  }

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  const data = await response.json();
  
  if (!Array.isArray(data)) {
    throw new Error(`Unexpected response: ${JSON.stringify(data)}`);
  }

  return data;
}

/**
 * Main function
 */
async function main() {
  console.log('Starting ERC20 contract code fetcher...');
  console.log(`RPC URL: ${RPC_URL}`);
  console.log(`Input file: ${INPUT_FILE}`);
  console.log(`Output file: ${OUTPUT_FILE}`);
  console.log(`Batch size: ${BATCH_SIZE}`);
  console.log(`Batch delay: ${BATCH_DELAY}ms`);

  // Read input file
  if (!fs.existsSync(INPUT_FILE)) {
    console.error(`Input file not found: ${INPUT_FILE}`);
    process.exit(1);
  }

  const fileContent = fs.readFileSync(INPUT_FILE, 'utf-8');
  const lines = fileContent.trim().split('\n').filter(line => line.trim());
  
  const contracts = lines.map(line => JSON.parse(line));
  console.log(`Loaded ${contracts.length} contracts from input file`);

  // Load progress if exists
  let progress = [];
  if (fs.existsSync(PROGRESS_FILE)) {
    try {
      progress = JSON.parse(fs.readFileSync(PROGRESS_FILE, 'utf-8'));
      console.log(`Resuming from progress: ${progress.length} contracts already fetched`);
    } catch (e) {
      console.log('Could not load progress, starting fresh');
    }
  }

  // Build result map
  const results = new Map();
  progress.forEach(p => results.set(p.address, p));

  // Process in batches
  let batchNum = 0;
  const totalBatches = Math.ceil(contracts.length / BATCH_SIZE);

  for (let i = 0; i < contracts.length; i += BATCH_SIZE) {
    batchNum++;
    const batch = contracts.slice(i, i + BATCH_SIZE);
    const addresses = batch.map(c => c.address);
    
    console.log(`Processing batch ${batchNum}/${totalBatches} (${addresses.length} addresses)...`);
    
    let success = false;
    let retries = 0;
    const maxRetries = 5;
    
    while (!success && retries < maxRetries) {
      try {
        const responses = await fetchCodeBatch(addresses, RPC_URL);
        
        batch.forEach((contract, idx) => {
          const result = responses[idx];
          if (result && result.result) {
            results.set(contract.address, {
              address: contract.address,
              number: contract.number,
              code: result.result,
            });
          }
        });
        
        success = true;
      } catch (error) {
        retries++;
        console.log(`Batch ${batchNum} failed (attempt ${retries}/${maxRetries}): ${error.message}`);
        if (retries < maxRetries) {
          await new Promise(resolve => setTimeout(resolve, BATCH_DELAY * retries));
        }
      }
    }

    if (!success) {
      // Mark failed addresses
      batch.forEach(contract => {
        if (!results.has(contract.address)) {
          results.set(contract.address, {
            address: contract.address,
            number: contract.number,
            code: null,
            error: 'Failed after retries',
          });
        }
      });
    }

    // Save progress after each batch
    const progressArray = Array.from(results.values());
    fs.writeFileSync(PROGRESS_FILE, JSON.stringify(progressArray, null, 2));
    
    // Delay between batches
    if (i + BATCH_SIZE < contracts.length) {
      await new Promise(resolve => setTimeout(resolve, BATCH_DELAY));
    }
  }

  // Final save
  const finalResults = Array.from(results.values());
  fs.writeFileSync(OUTPUT_FILE, JSON.stringify(finalResults, null, 2));
  console.log(`\nSaved ${finalResults.length} results to ${OUTPUT_FILE}`);

  // Summary
  const successCount = finalResults.filter(r => r.code && r.code !== '0x').length;
  const emptyCount = finalResults.filter(r => r.code === '0x').length;
  const errorCount = finalResults.filter(r => r.error).length;

  console.log('\nSummary:');
  console.log(`  - Contracts with code: ${successCount}`);
  console.log(`  - Empty contracts (0x): ${emptyCount}`);
  console.log(`  - Errors: ${errorCount}`);

  // Clean up progress file
  if (fs.existsSync(PROGRESS_FILE)) {
    fs.unlinkSync(PROGRESS_FILE);
    console.log('Cleaned up progress file');
  }
}

main().catch((error) => {
  console.error('Fatal error:', error);
  process.exit(1);
});