create-solana-program/template/base/scripts/program/dump.mjs

#!/usr/bin/env zx
import 'zx/globals';
import {
  getExternalAccountAddresses,
  getExternalProgramAddresses,
  getExternalProgramOutputDir,
} from '../utils.mjs';

// Get input from environment variables.
const rpc = process.env.RPC ?? 'https://api.mainnet-beta.solana.com';
const outputDir = getExternalProgramOutputDir();
await dump();

/** Dump external programs binaries and accounts if needed. */
async function dump() {
  // Ensure we have some external accounts to dump.
  const programs = getExternalProgramAddresses();
  const accounts = getExternalAccountAddresses();
  const external = [
    ...programs.map((program) => [program, 'so']),
    ...accounts.map((account) => [account, 'json']),
  ];

  if (external.length === 0) return;
  echo(`Dumping external accounts to '${outputDir}':`);

  // Create the output directory if needed.
  $`mkdir -p ${outputDir}`.quiet();

  // Copy the binaries from the chain or warn if they are different.
  await Promise.all(
    external.map(async ([address, extension]) => {
      const binary = `${address}.${extension}`;
      const hasBinary = await fs.exists(`${outputDir}/${binary}`);

      if (!hasBinary) {
        await copyFromChain(address, extension);
        echo(`Wrote account data to ${outputDir}/${binary}`);
        return;
      }

      let sha = 'sha256sum';
      let options = [];
      let hasShaChecksum = await which('sha256sum', { nothrow: true });

      // We might not have sha256sum on some systems, so we try shasum as well.
      if (!hasShaChecksum) {
        hasShaChecksum = await which('shasum', { nothrow: true });

        if (hasShaChecksum) {
          sha = 'shasum';
          options = ['-a', '256'];
        }
      }

      if (hasShaChecksum) {
        try {
          await copyFromChain(address, extension, 'onchain-');
          const [onChainHash, localHash] = await Promise.all([
            $`${sha} ${options} -b ${outputDir}/onchain-${binary} | cut -d ' ' -f 1`.quiet(),
            $`${sha} ${options} -b ${outputDir}/${binary} | cut -d ' ' -f 1`.quiet(),
          ]);

          if (onChainHash.toString() !== localHash.toString()) {
            echo(
              chalk.yellow('[ WARNING ]'),
              `on-chain and local binaries are different for '${address}'`
            );
          } else {
            echo(
              chalk.green('[ SKIPPED ]'),
              `on-chain and local binaries are the same for '${address}'`
            );
          }

          await $`rm ${outputDir}/onchain-${binary}`.quiet();
        } catch (error) {
          echo(
            chalk.yellow('[ WARNING ]'),
            `skipped check for '${address}' (error copying data from '${rpc}')`
          );
        }
      } else {
        echo(
          chalk.yellow('[ WARNING ]'),
          `skipped check for '${address}' (missing 'sha256sum' command)`
        );
      }
    })
  );
}

/** Helper function to copy external programs or accounts binaries from the chain. */
async function copyFromChain(address, extension, prefix = '') {
  const binary = `${prefix}${address}.${extension}`;
  switch (extension) {
    case 'json':
      return $`solana account -u ${rpc} ${address} -o ${outputDir}/${binary} --output json >/dev/null`.quiet();
    case 'so':
      return $`solana program dump -u ${rpc} ${address} ${outputDir}/${binary} >/dev/null`.quiet();
    default:
      echo(chalk.red(`[  ERROR  ] unknown account type for '${binary}'`));
      await $`exit 1`;
  }
}