check-bytecode-changes.js

#!/usr/bin/env node

const fs = require("fs");
const path = require("path");
const crypto = require("crypto");

// Contract configuration
// Each contract specifies which other contracts should be bumped when it changes
const CONTRACT_CONFIG = {
  "IthacaAccount.sol/IthacaAccount.json": {
    name: "IthacaAccount",
    bumpsWhenChanged: [], // Account changes don't bump other contracts
  },
  "Orchestrator.sol/Orchestrator.json": {
    name: "Orchestrator",
    bumpsWhenChanged: ["IthacaAccount", "SimpleFunder"], 
  },
  "SimpleFunder.sol/SimpleFunder.json": {
    name: "SimpleFunder",
    bumpsWhenChanged: [], // SimpleFunder changes only bump itself
  },
  "SimpleSettler.sol/SimpleSettler.json": {
    name: "SimpleSettler",
    bumpsWhenChanged: [], // SimpleSettler changes only bump itself
  },
  "Simulator.sol/Simulator.json": {
    name: "Simulator",
    bumpsWhenChanged: [], // Simulator changes only bump itself
  },
  "Escrow.sol/Escrow.json": {
    name: "Escrow",
    bumpsWhenChanged: [], // Escrow changes only bump itself
  },
  "MultiSigSigner.sol/MultiSigSigner.json": {
    name: "MultiSigSigner",
    bumpsWhenChanged: [], // MultiSigSigner changes only bump itself
  },
  "LayerZeroSettler.sol/LayerZeroSettler.json": {
    name: "LayerZeroSettler",
    bumpsWhenChanged: [], // LayerZeroSettler changes only bump itself
  },
};

// All contracts to check for bytecode changes
const CONTRACTS_TO_CHECK = Object.keys(CONTRACT_CONFIG);

function getBytecodeHash(artifactPath) {
  try {
    const artifact = JSON.parse(fs.readFileSync(artifactPath, "utf8"));
    const bytecode = artifact.bytecode?.object || "";

    if (!bytecode || bytecode === "0x") {
      console.warn(`Warning: No bytecode found in ${artifactPath}`);
      return null;
    }

    // Remove metadata hash from bytecode (last 43 bytes for Solidity)
    // This ensures we only compare actual code changes, not metadata
    const cleanBytecode = bytecode.slice(0, -86); // 43 bytes = 86 hex chars

    return crypto.createHash("sha256").update(cleanBytecode).digest("hex");
  } catch (error) {
    console.error(`Error reading artifact ${artifactPath}:`, error.message);
    return null;
  }
}

function compareArtifacts(baseDir, prDir) {
  const changes = {};

  for (const contract of CONTRACTS_TO_CHECK) {
    const basePath = path.join(baseDir, contract);
    const prPath = path.join(prDir, contract);

    const baseHash = getBytecodeHash(basePath);
    const prHash = getBytecodeHash(prPath);

    if (baseHash && prHash && baseHash !== prHash) {
      changes[contract] = true;
      console.log(`Bytecode changed: ${contract}`);
    }
  }

  return changes;
}

function determineContractsToBump(bytecodeChanges) {
  const contractsToBump = new Set();

  for (const [contractPath, changed] of Object.entries(bytecodeChanges)) {
    if (changed) {
      const config = CONTRACT_CONFIG[contractPath];
      
      // The contract itself needs to be bumped
      contractsToBump.add(config.name);
      
      // Also bump any contracts specified in bumpsWhenChanged
      for (const otherContract of config.bumpsWhenChanged) {
        contractsToBump.add(otherContract);
      }
    }
  }

  return Array.from(contractsToBump);
}

function checkManualVersionBumps(contractsToBump) {
  try {
    // Check which specific contracts have already had their versions manually bumped
    const baseRef = process.env.GITHUB_BASE_REF || 'main';
    const alreadyBumpedContracts = [];
    
    // Get the diff for Solidity files
    const gitDiff = require("child_process")
      .execSync(`git diff origin/${baseRef}...HEAD -- src/*.sol`, {
        encoding: "utf8",
      });
    
    // Split diff into file sections
    const fileSections = gitDiff.split(/^diff --git/m).filter(Boolean);
    
    // Check each contract that needs bumping
    for (const contractName of contractsToBump) {
      let foundVersionBump = false;
      
      // Find the file section that contains this contract
      for (const fileSection of fileSections) {
        // Skip if this file section doesn't contain our contract
        if (!fileSection.includes(`contract ${contractName}`)) {
          continue;
        }
        
        // Look for version changes in this file section
        const lines = fileSection.split('\n');
        let currentContract = null;
        let oldVersion = null;
        let newVersion = null;
        
        for (const line of lines) {
          // Track which contract we're currently in based on context lines or added lines
          // Match contract declarations in various diff formats
          const contractMatch = line.match(/^([@\s\+\-])?.*\bcontract\s+(\w+)/);
          if (contractMatch && !line.startsWith('---') && !line.startsWith('+++')) {
            const potentialContract = contractMatch[2];
            // Only update currentContract if it's a contract declaration line
            if (line.includes('{') || line.match(/\bcontract\s+\w+\s*(is|{)/)) {
              currentContract = potentialContract;
            }
          }
          
          // Only look for version changes if we're in the right contract
          if (currentContract === contractName) {
            // Check for removed version line
            const removedVersionMatch = line.match(/^-\s*version = "(\d+\.\d+\.\d+)";/);
            if (removedVersionMatch) {
              oldVersion = removedVersionMatch[1];
            }
            // Check for added version line
            const addedVersionMatch = line.match(/^\+\s*version = "(\d+\.\d+\.\d+)";/);
            if (addedVersionMatch) {
              newVersion = addedVersionMatch[1];
            }
          }
        }
        
        // If we found both old and new versions and they're different, the version was bumped
        if (oldVersion && newVersion && oldVersion !== newVersion) {
          foundVersionBump = true;
          alreadyBumpedContracts.push(contractName);
          console.log(`Contract ${contractName} already manually bumped from ${oldVersion} to ${newVersion}`);
          break;
        }
      }
      
      if (!foundVersionBump) {
        console.log(`Contract ${contractName} needs automatic version bump`);
      }
    }
    
    // Return contracts that still need bumping (not manually bumped)
    return contractsToBump.filter(c => !alreadyBumpedContracts.includes(c));
  } catch (error) {
    console.error("Error checking manual version bumps:", error.message);
    // If there's an error, assume all contracts need bumping
    return contractsToBump;
  }
}

function main() {
  const args = process.argv.slice(2);
  if (args.length !== 2) {
    console.error(
      "Usage: check-bytecode-changes.js <base-artifacts-dir> <pr-artifacts-dir>"
    );
    process.exit(1);
  }

  const [baseDir, prDir] = args;

  console.log("Checking bytecode changes...");
  const bytecodeChanges = compareArtifacts(baseDir, prDir);
  const changedContracts = Object.values(bytecodeChanges).filter(Boolean).length;

  if (changedContracts > 0) {
    console.log(`\nFound bytecode changes in ${changedContracts} contracts`);

    // Determine which contracts need version bumps
    const contractsToBump = determineContractsToBump(bytecodeChanges);
    console.log(`\nContracts that need version bumps: ${contractsToBump.join(", ")}`);

    // Check which contracts have already been manually bumped
    const contractsStillNeedingBump = checkManualVersionBumps(contractsToBump);

    if (contractsStillNeedingBump.length > 0) {
      console.log(`Contracts still needing version bumps: ${contractsStillNeedingBump.join(", ")}`);
      console.log("Automatic bump required for remaining contracts");
      // Use modern GitHub Actions output syntax
      fs.appendFileSync(
        process.env.GITHUB_OUTPUT || "/dev/null",
        `needs_version_bump=true\ncontracts_to_bump=${contractsStillNeedingBump.join(",")}\n`
      );
    } else {
      console.log("All required contract versions have already been updated");
      fs.appendFileSync(
        process.env.GITHUB_OUTPUT || "/dev/null",
        "needs_version_bump=false\n"
      );
    }
  } else {
    console.log("No bytecode changes detected");
    fs.appendFileSync(
      process.env.GITHUB_OUTPUT || "/dev/null",
      "needs_version_bump=false\n"
    );
  }
}

if (require.main === module) {
  main();
}