create-ponder 0.2.0-next.1 → 0.2.0-next.2

package/dist/index.js

@@ -1,22 +1,22 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { writeFileSync as writeFileSync2 } from "node:fs";
-import path3 from "node:path";
+import { writeFileSync as writeFileSync3 } from "node:fs";
+import path4 from "node:path";
 import { fileURLToPath } from "node:url";
 import { cac } from "cac";
 import cpy from "cpy";
 import { execa } from "execa";
 import fs2 from "fs-extra";
 import { oraPromise } from "ora";
-import pico4 from "picocolors";
-import prettier2 from "prettier";
+import pico5 from "picocolors";
+import prettier3 from "prettier";
 import { default as prompts } from "prompts";
 
 // package.json
 var package_default = {
   name: "create-ponder",
-  version: "0.2.0-next.1",
+  version: "0.2.0-next.2",
   type: "module",
   description: "A CLI tool to create Ponder apps",
   license: "MIT",
@@ -44,7 +44,9 @@ var package_default = {
     prettier: "^3.1.0",
     prompts: "^2.4.2",
     "update-check": "^1.5.4",
-    "validate-npm-package-name": "^5.0.0"
+    "validate-npm-package-name": "^5.0.0",
+    viem: "^2.0.10",
+    yaml: "^2.3.4"
   },
   devDependencies: {
     "@types/fs-extra": "^11.0.4",
@@ -54,129 +56,93 @@ var package_default = {
     abitype: "^0.10.2",
     dotenv: "^16.3.1",
     tsup: "^8.0.1",
-    typescript: "^5.3.2",
     vitest: "^1.0.2"
   },
   engines: {
-    node: ">=18"
+    node: ">=18.14"
   }
 };
 
 // src/etherscan.ts
 import { mkdirSync, writeFileSync } from "node:fs";
 import path from "node:path";
-import prettier from "prettier";
-
-// src/helpers/getEtherscanChainId.ts
-var networkByEtherscanHostname = {
-  "etherscan.io": {
-    name: "mainnet",
-    chainId: 1,
-    apiUrl: "https://api.etherscan.io/api"
-  },
-  "ropsten.etherscan.io": {
-    name: "ropsten",
-    chainId: 3,
-    apiUrl: "https://api-ropsten.etherscan.io/api"
-  },
-  "rinkeby.etherscan.io": {
-    name: "rinkeby",
-    chainId: 4,
-    apiUrl: "https://api-rinkeby.etherscan.io/api"
-  },
-  "goerli.etherscan.io": {
-    name: "goerli",
-    chainId: 5,
-    apiUrl: "https://api-goerli.etherscan.io/api"
-  },
-  "kovan.etherscan.io": {
-    name: "kovan",
-    chainId: 42,
-    apiUrl: "https://api-kovan.etherscan.io/api"
-  },
-  "sepolia.etherscan.io": {
-    name: "sepolia",
-    chainId: 11155111,
-    apiUrl: "https://api-sepolia.etherscan.io/api"
-  },
-  "optimistic.etherscan.io": {
-    name: "optimism",
-    chainId: 10,
-    apiUrl: "https://api-optimistic.etherscan.io/api"
-  },
-  "goerli-optimism.etherscan.io": {
-    name: "optimism-goerli",
-    chainId: 420,
-    apiUrl: "https://api-goerli-optimistic.etherscan.io/api"
-  },
-  "polygonscan.com": {
-    name: "polygon",
-    chainId: 137,
-    apiUrl: "https://api.polygonscan.com/api"
-  },
-  "mumbai.polygonscan.com": {
-    name: "polygon-mumbai",
-    chainId: 80001,
-    apiUrl: "https://api-testnet.polygonscan.com/api"
-  },
-  "arbiscan.io": {
-    name: "arbitrum",
-    chainId: 42161,
-    apiUrl: "https://api.arbiscan.io/api"
-  },
-  "goerli.arbiscan.io": {
-    name: "arbitrum-goerli",
-    chainId: 421613,
-    apiUrl: "https://api-goerli.arbiscan.io/api"
-  },
-  "explorer.zora.energy": {
-    name: "zora",
-    chainId: 7777777,
-    apiUrl: "https://explorer.zora.energy/api"
-  },
-  "basescan.org": {
-    name: "base",
-    chainId: 8453,
-    apiUrl: "https://api.basescan.org/api"
-  },
-  "goerli.basescan.org": {
-    name: "base-goerli",
-    chainId: 84531,
-    apiUrl: "https://api-goerli.basescan.org/api"
-  }
-};
-var getNetworkByEtherscanHostname = (hostname) => {
-  return networkByEtherscanHostname[hostname];
-};
 
 // src/helpers/wait.ts
 var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 // src/etherscan.ts
+import pico from "picocolors";
+import prettier from "prettier";
+import * as chains from "viem/chains";
+var chainExplorerByHostname = {};
+for (const [name, chain] of Object.entries(chains)) {
+  for (const explorer of Object.values(chain.blockExplorers ?? {})) {
+    const hostname = new URL(explorer.url).hostname;
+    chainExplorerByHostname[hostname] = {
+      name,
+      id: chain.id,
+      explorer
+    };
+  }
+}
 var fromEtherscan = async ({
   rootDir,
   etherscanLink,
   etherscanApiKey
 }) => {
+  const warnings = [];
   const apiKey = etherscanApiKey || process.env.ETHERSCAN_API_KEY;
-  const url = new URL(etherscanLink);
-  const network = getNetworkByEtherscanHostname(url.hostname);
-  if (!network) {
-    throw new Error(`Unrecognized etherscan hostname: ${url.hostname}`);
+  const explorerUrl = new URL(etherscanLink);
+  const chainExplorer = chainExplorerByHostname[explorerUrl.hostname];
+  if (!chainExplorer)
+    throw new Error(
+      `Block explorer (${explorerUrl.hostname}) is not present in viem/chains.`
+    );
+  const name = chainExplorer.name;
+  const chainId = chainExplorer.id;
+  const apiUrl = chainExplorer.explorer.apiUrl;
+  if (!apiUrl)
+    throw new Error(
+      `${pico.red("\u2717")} Block explorer (${explorerUrl.hostname}) does not have a API URL registered in viem/chains.`
+    );
+  const pathComponents = explorerUrl.pathname.slice(1).split("/");
+  const contractAddress = pathComponents[1];
+  if (pathComponents[0] !== "address" || !(typeof contractAddress === "string") || !contractAddress.startsWith("0x")) {
+    throw new Error(
+      `${pico.red("\u2717")} Invalid block explorer URL (${explorerUrl.href}). Expected path "/address/<contract-address>".`
+    );
   }
-  const { name, chainId, apiUrl } = network;
-  const contractAddress = url.pathname.slice(1).split("/")[1];
+  let abiResult = void 0;
+  try {
+    abiResult = await getContractAbiAndName(contractAddress, apiUrl, apiKey);
+  } catch (e) {
+    const error = e;
+    throw new Error(
+      `${pico.red("\u2717")} Failed to fetch contract ABI from block explorer API: ${error.message}`
+    );
+  }
+  if (typeof abiResult.abi !== "string")
+    throw new Error(
+      `${pico.red(
+        "\u2717"
+      )} Invalid ABI returned from block explorer API. Is the contract verified?`
+    );
+  const baseAbi = JSON.parse(abiResult.abi);
+  let contractName = abiResult.contractName;
+  const abis = [
+    { abi: baseAbi, contractName }
+  ];
   let blockNumber = void 0;
   try {
+    if (!apiKey)
+      await wait(5e3);
     const txHash = await getContractCreationTxn(
       contractAddress,
       apiUrl,
       apiKey
     );
-    if (!apiKey) {
-      console.log("\n(1/n) Waiting 5 seconds for Etherscan API rate limit");
+    if (!apiKey)
       await wait(5e3);
-    }
     const contractCreationBlockNumber = await getTxBlockNumber(
       txHash,
       apiUrl,
@@ -185,47 +151,30 @@ var fromEtherscan = async ({
     blockNumber = contractCreationBlockNumber;
   } catch (error) {
   }
-  if (!apiKey) {
-    console.log("(2/n) Waiting 5 seconds for Etherscan API rate limit");
-    await wait(5e3);
-  }
-  const abis = [];
-  const abiAndName = await getContractAbiAndName(
-    contractAddress,
-    apiUrl,
-    apiKey
-  );
-  const { abi } = abiAndName;
-  let contractName = abiAndName.contractName;
-  abis.push({ abi: JSON.parse(abi), contractName });
-  if (JSON.parse(abi).find(
+  if (baseAbi.find(
     (item) => item.type === "event" && item.name === "Upgraded" && item.inputs[0].name === "implementation"
   )) {
-    console.log(
-      "Detected EIP-1967 proxy, fetching implementation contract ABIs"
-    );
-    if (!apiKey) {
-      console.log("(3/n) Waiting 5 seconds for Etherscan API rate limit");
+    if (!apiKey)
       await wait(5e3);
-    }
     const { implAddresses } = await getProxyImplementationAddresses({
       contractAddress,
       apiUrl,
       fromBlock: blockNumber,
       apiKey
     });
-    for (const [index, implAddress] of implAddresses.entries()) {
-      console.log(`Fetching ABI for implementation contract: ${implAddress}`);
-      if (!apiKey) {
-        console.log(
-          `(${4 + index}/${4 + implAddresses.length - 1}) Waiting 5 seconds for Etherscan API rate limit`
-        );
+    for (const implAddress of implAddresses) {
+      if (!apiKey)
         await wait(5e3);
+      const { abi, contractName: implContractName } = await getContractAbiAndName(implAddress, apiUrl, apiKey);
+      if (typeof abi !== "string") {
+        warnings.push(
+          `Unable to fetch ABI for implementation contract ${implAddress}. Please see the proxy contract documentation for more details: https://ponder.sh/docs/guides/add-contracts#multiple-abis`
+        );
+        continue;
       }
-      const { abi: abi2, contractName: implContractName } = await getContractAbiAndName(implAddress, apiUrl, apiKey);
       contractName = implContractName;
       abis.push({
-        abi: JSON.parse(abi2),
+        abi: JSON.parse(abi),
         contractName: `${contractName}_${implAddress.slice(0, 6)}`
       });
     }
@@ -233,7 +182,7 @@ var fromEtherscan = async ({
   mkdirSync(path.join(rootDir, "abis"), { recursive: true });
   mkdirSync(path.join(rootDir, "src"), { recursive: true });
   let abiConfig;
-  for (const { abi: abi2, contractName: contractName2 } of abis) {
+  for (const { abi, contractName: contractName2 } of abis) {
     const abiRelativePath = `./abis/${contractName2}Abi.ts`;
     const abiAbsolutePath = path.join(
       path.resolve(".", rootDir),
@@ -242,15 +191,13 @@ var fromEtherscan = async ({
     writeFileSync(
       abiAbsolutePath,
       await prettier.format(
-        `export const ${contractName2}Abi = ${JSON.stringify(abi2)} as const`,
-        {
-          parser: "typescript"
-        }
+        `export const ${contractName2}Abi = ${JSON.stringify(abi)} as const`,
+        { parser: "typescript" }
       )
     );
     if (abis.length === 1) {
       abiConfig = {
-        abi: abi2,
+        abi,
         dir: abiRelativePath,
         name: `${contractName2}Abi`
       };
@@ -259,7 +206,7 @@ var fromEtherscan = async ({
         abiConfig = [];
       }
       abiConfig.push({
-        abi: abi2,
+        abi,
         name: `${contractName2}Abi`,
         dir: abiRelativePath
       });
@@ -281,7 +228,7 @@ var fromEtherscan = async ({
       }
     }
   };
-  return config;
+  return { config, warnings };
 };
 var fetchEtherscan = async (url) => {
   const maxRetries = 5;
@@ -290,9 +237,6 @@ var fetchEtherscan = async (url) => {
     try {
       const response = await fetch(url);
       const data = await response.json();
-      if (data.status === "0") {
-        throw new Error(`Etherscan API error: ${data.result}`);
-      }
       return data;
     } catch (error) {
       retryCount++;
@@ -368,7 +312,7 @@ var getProxyImplementationAddresses = async ({
 };
 
 // src/helpers/getPackageManager.ts
-import pico from "picocolors";
+import pico2 from "picocolors";
 var getPackageManager = ({
   options
 }) => {
@@ -393,11 +337,11 @@ var getPackageManager = ({
     if (userAgent.includes("yarn"))
       return "yarn";
   }
-  throw Error(pico.red("Undetectable package manager"));
+  throw Error(pico2.red("Undetectable package manager"));
 };
 
 // src/helpers/notifyUpdate.ts
-import pico2 from "picocolors";
+import pico3 from "picocolors";
 import checkForUpdate from "update-check";
 var log = console.log;
 async function notifyUpdate({ options }) {
@@ -407,11 +351,11 @@ async function notifyUpdate({ options }) {
       const packageManager = getPackageManager({ options });
       const updateMessage = packageManager === "bun" ? "bun install --global create-ponder" : packageManager === "pnpm" ? "pnpm add -g create-ponder" : packageManager === "npm" ? "npm install -g create-ponder" : "yarn global add create-ponder";
       log(
-        pico2.bold(
-          `${pico2.yellow(
+        pico3.bold(
+          `${pico3.yellow(
             "A new version of `create-ponder` is available!"
           )}
-You can update by running: ${pico2.cyan(updateMessage)}
+You can update by running: ${pico3.cyan(updateMessage)}
 `
         )
       );
@@ -424,7 +368,7 @@ You can update by running: ${pico2.cyan(updateMessage)}
 // src/helpers/validate.ts
 import path2 from "path";
 import fs from "fs-extra";
-import pico3 from "picocolors";
+import pico4 from "picocolors";
 import validatePackageName from "validate-npm-package-name";
 async function validateProjectName({
   projectName,
@@ -475,10 +419,147 @@ async function validateTemplateName({
 var ValidationError = class extends Error {
   name = "ValidationError";
   constructor(validation) {
-    super([pico3.red(validation.message), validation.problems].join("\n"));
+    super([pico4.red(validation.message), validation.problems].join("\n"));
   }
 };
 
+// src/subgraph.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import path3 from "node:path";
+import prettier2 from "prettier";
+import { parse } from "yaml";
+
+// src/helpers/getGraphProtocolChainId.ts
+var chainIdByGraphNetwork = {
+  mainnet: 1,
+  kovan: 42,
+  rinkeby: 4,
+  ropsten: 3,
+  goerli: 5,
+  "poa-core": 99,
+  "poa-sokol": 77,
+  xdai: 100,
+  matic: 137,
+  mumbai: 80001,
+  fantom: 250,
+  "fantom-testnet": 4002,
+  bsc: 56,
+  chapel: -1,
+  clover: 0,
+  avalanche: 43114,
+  fuji: 43113,
+  celo: 42220,
+  "celo-alfajores": 44787,
+  fuse: 122,
+  moonbeam: 1284,
+  moonriver: 1285,
+  mbase: -1,
+  "arbitrum-one": 42161,
+  "arbitrum-rinkeby": 421611,
+  optimism: 10,
+  "optimism-kovan": 69,
+  aurora: 1313161554,
+  "aurora-testnet": 1313161555
+};
+var getGraphProtocolChainId = (networkName) => {
+  return chainIdByGraphNetwork[networkName];
+};
+var subgraphYamlFileNames = ["subgraph.yaml"].concat(
+  Object.keys(chainIdByGraphNetwork).map((n) => `subgraph-${n}.yaml`)
+);
+
+// src/helpers/validateGraphProtocolSource.ts
+var validateGraphProtocolSource = (source) => {
+  return source;
+};
+
+// src/subgraph.ts
+var fetchIpfsFile = async (cid) => {
+  const url = `https://ipfs.network.thegraph.com/api/v0/cat?arg=${cid}`;
+  const response = await fetch(url);
+  const contentRaw = await response.text();
+  return contentRaw;
+};
+var fromSubgraphId = async ({
+  rootDir,
+  subgraphId
+}) => {
+  const manifestRaw = await fetchIpfsFile(subgraphId);
+  const manifest = parse(manifestRaw);
+  const contracts = {};
+  manifest.dataSources.forEach((d) => {
+    contracts[d.name] = {
+      network: d.network,
+      address: d.source.address,
+      startBlock: d.source.startBlock
+    };
+  });
+  const dataSources = manifest.dataSources;
+  mkdirSync2(path3.join(rootDir, "abis"), { recursive: true });
+  mkdirSync2(path3.join(rootDir, "src"), { recursive: true });
+  const abiFiles = dataSources.flatMap((source) => validateGraphProtocolSource(source).mapping.abis).filter(
+    (source, idx, arr) => arr.findIndex((s) => s.name === source.name) === idx
+  );
+  const abis = {};
+  await Promise.all(
+    abiFiles.map(async (abi) => {
+      const abiContent = await fetchIpfsFile(abi.file["/"].slice(6));
+      const abiPath = path3.join(rootDir, `./abis/${abi.name}Abi.ts`);
+      writeFileSync2(
+        abiPath,
+        await prettier2.format(
+          `export const ${abi.name}Abi = ${abiContent} as const`,
+          { parser: "typescript" }
+        )
+      );
+      abis[abi.name] = JSON.parse(abiContent);
+    })
+  );
+  const ponderContracts = dataSources.map((sourceInvalid) => {
+    const source = validateGraphProtocolSource(sourceInvalid);
+    const network = source.network || "mainnet";
+    const chainId = getGraphProtocolChainId(network);
+    if (!chainId || chainId === -1) {
+      throw new Error(`Unhandled network name: ${network}`);
+    }
+    const abiRelativePath = `./abis/${source.source.abi}Abi.ts`;
+    return {
+      name: source.name,
+      network,
+      address: source.source.address,
+      abi: {
+        abi: abis[source.source.abi],
+        dir: abiRelativePath,
+        name: `${source.source.abi}Abi`
+      },
+      startBlock: source.source.startBlock
+    };
+  });
+  const contractsObject = {};
+  const networksObject = {};
+  ponderContracts.forEach((pc) => {
+    contractsObject[pc.name] = pc;
+    networksObject[pc.network] = {
+      chainId: getGraphProtocolChainId(pc.network),
+      transport: `http(process.env.PONDER_RPC_URL_${getGraphProtocolChainId(
+        pc.network
+      )})`
+    };
+    contractsObject[pc.name].name = void 0;
+  });
+  const config = {
+    networks: networksObject,
+    contracts: contractsObject
+  };
+  const warnings = [];
+  if (manifest.templates?.length > 0) {
+    warnings.push(
+      "Factory contract detected. Please see the factory contract documentation for more details: https://ponder.sh/docs/guides/add-contracts#factory-contracts"
+    );
+  }
+  return { config, warnings };
+};
+
 // src/index.ts
 var log2 = console.log;
 var templates = [
@@ -486,7 +567,12 @@ var templates = [
   {
     id: "etherscan",
     title: "Etherscan contract link",
-    description: "Bootstrap from an Etherscan contract link"
+    description: "Create from an Etherscan contract link"
+  },
+  {
+    id: "subgraph",
+    title: "Subgraph ID",
+    description: "Create from a deployed subgraph"
   },
   {
     id: "feature-factory",
@@ -540,15 +626,16 @@ async function run({
 }) {
   if (options.help)
     return;
+  const warnings = [];
   log2();
   log2(
-    `Welcome to ${pico4.bold(
-      pico4.blue("create-ponder")
+    `Welcome to ${pico5.bold(
+      pico5.blue("create-ponder")
     )} \u2013 the quickest way to get started with Ponder!`
   );
   log2();
   const __dirname = fileURLToPath(new URL(".", import.meta.url));
-  const templatesPath = path3.join(__dirname, "..", "templates");
+  const templatesPath = path4.join(__dirname, "..", "templates");
   let templateId = options.template || options.t;
   let templateValidation = await validateTemplateName({
     isNameRequired: false,
@@ -563,7 +650,7 @@ async function run({
     projectPath = args[0].trim();
     const splitPath = projectPath.split("/");
     projectName = splitPath[splitPath.length - 1]?.trim() || "";
-    log2(pico4.green("\u2714"), pico4.bold("Using project name:"), projectName);
+    log2(pico5.green("\u2714"), pico5.bold("Using project name:"), projectName);
   } else {
     const res = await prompts({
       initial: "my-app",
@@ -589,8 +676,10 @@ async function run({
   });
   if (!nameValidation.valid)
     throw new ValidationError(nameValidation);
-  if (options.etherscanContractLink && !templateId)
+  if (options.etherscan && !templateId)
     templateId = "etherscan";
+  if (options.subgraph && !templateId)
+    templateId = "subgraph";
   if (!templateId) {
     templateId = (await prompts({
       name: "templateId",
@@ -612,30 +701,69 @@ async function run({
   if (!templateValidation.valid)
     throw new ValidationError(templateValidation);
   let config;
-  const targetPath = path3.join(process.cwd(), projectPath);
+  const targetPath = path4.join(process.cwd(), projectPath);
+  let url = options.etherscan;
   if (templateMeta.id === "etherscan") {
-    let link = options.etherscanContractLink;
-    if (!link) {
+    if (!url) {
       const result = await prompts({
         type: "text",
-        name: "link",
-        message: "Enter an Etherscan contract link",
+        name: "url",
+        message: "Enter a block explorer contract url",
         initial: "https://etherscan.io/address/0x97..."
       });
-      link = result.link;
+      url = result.url;
+    }
+  }
+  let subgraph = options.subgraph;
+  if (templateMeta.id === "subgraph") {
+    if (!subgraph) {
+      const result = await prompts({
+        type: "text",
+        name: "id",
+        message: "Enter a subgraph ID",
+        initial: "Qmb3hd2hYd2nWFgcmRswykF1dUBSrDUrinYCgN1dmE1tNy"
+      });
+      subgraph = result.id;
+    }
+    if (!subgraph) {
+      log2(pico5.red("No subgraph ID provided."));
+      process.exit(0);
     }
-    config = await fromEtherscan({
-      rootDir: targetPath,
-      etherscanLink: link,
-      etherscanApiKey: options.etherscanApiKey
-    });
   }
-  log2(`Creating a repo at: ${pico4.green(targetPath)}`);
-  log2();
-  log2(`Using template: ${pico4.bold(templateMeta.title)}`);
   log2();
-  const templatePath = path3.join(templatesPath, templateMeta.id);
-  await cpy(path3.join(templatePath, "**", "*"), targetPath, {
+  if (templateMeta.id === "etherscan") {
+    const host = new URL(url).host;
+    const result = await oraPromise(
+      fromEtherscan({
+        rootDir: targetPath,
+        etherscanLink: url,
+        etherscanApiKey: options.etherscanApiKey
+      }),
+      {
+        text: `Fetching contract metadata from ${pico5.bold(
+          host
+        )}. This may take a few seconds.`,
+        failText: "Failed to fetch contract metadata.",
+        successText: `Fetched contract metadata from ${pico5.bold(host)}.`
+      }
+    );
+    config = result.config;
+    warnings.push(...result.warnings);
+  }
+  if (templateMeta.id === "subgraph") {
+    const result = await oraPromise(
+      fromSubgraphId({ rootDir: targetPath, subgraphId: subgraph }),
+      {
+        text: "Fetching subgraph metadata. This may take a few seconds.",
+        failText: "Failed to fetch subgraph metadata.",
+        successText: `Fetched subgraph metadata for ${pico5.bold(subgraph)}.`
+      }
+    );
+    config = result.config;
+    warnings.push(...result.warnings);
+  }
+  const templatePath = path4.join(templatesPath, templateMeta.id);
+  await cpy(path4.join(templatePath, "**", "*"), targetPath, {
     rename: (name) => name.replace(/^_dot_/, ".")
   });
   if (config) {
@@ -643,7 +771,9 @@ async function run({
       import { createConfig${Object.values(config.contracts).some((c) => Array.isArray(c.abi)) ? ", mergeAbis" : ""} } from "@ponder/core";
       import { http } from "viem";
 
-      ${Object.values(config.contracts).flatMap((c) => c.abi).map(
+      ${Object.values(config.contracts).flatMap((c) => c.abi).filter(
+      (tag, index, array) => array.findIndex((t) => t.dir === tag.dir) === index
+    ).map(
       (abi) => `import {${abi.name}} from "${abi.dir.slice(
         0,
         abi.dir.length - 3
@@ -669,14 +799,14 @@ async function run({
     ).replaceAll(/"abi":"(.*?)"/g, "abi:$1")},
       });
     `;
-    writeFileSync2(
-      path3.join(targetPath, "ponder.config.ts"),
-      await prettier2.format(configContent, { parser: "typescript" })
+    writeFileSync3(
+      path4.join(targetPath, "ponder.config.ts"),
+      await prettier3.format(configContent, { parser: "typescript" })
     );
     for (const [name, contract] of Object.entries(config.contracts)) {
       const abi = Array.isArray(contract.abi) ? contract.abi[1].abi : contract.abi.abi;
       const abiEvents = abi.filter(
-        (item) => item.type === "event"
+        (item) => item.type === "event" && !item.anonymous
       );
       const eventNamesToWrite = abiEvents.map((event) => event.name).slice(0, 2);
       const indexingFunctionFileContents = `
@@ -689,25 +819,23 @@ async function run({
           })`
       ).join("\n")}
     `;
-      writeFileSync2(
-        path3.join(targetPath, `./src/${name}.ts`),
-        await prettier2.format(indexingFunctionFileContents, {
+      writeFileSync3(
+        path4.join(targetPath, `./src/${name}.ts`),
+        await prettier3.format(indexingFunctionFileContents, {
           parser: "typescript"
         })
       );
     }
   }
-  const packageJson = await fs2.readJSON(path3.join(targetPath, "package.json"));
+  const packageJson = await fs2.readJSON(path4.join(targetPath, "package.json"));
   packageJson.name = projectName;
   packageJson.dependencies["@ponder/core"] = `^${package_default.version}`;
   packageJson.devDependencies["eslint-config-ponder"] = `^${package_default.version}`;
   await fs2.writeFile(
-    path3.join(targetPath, "package.json"),
+    path4.join(targetPath, "package.json"),
     JSON.stringify(packageJson, null, 2)
   );
   const packageManager = getPackageManager({ options });
-  log2(`Installing with: ${pico4.bold(packageManager)}`);
-  log2();
   const installArgs = [
     "install",
     packageManager === "npm" ? "--quiet" : "--silent"
@@ -725,58 +853,80 @@ async function run({
       }
     }),
     {
-      text: "Installing packages. This may take a few seconds.",
+      text: `Installing packages with ${pico5.bold(
+        packageManager
+      )}. This may take a few seconds.`,
       failText: "Failed to install packages.",
-      successText: "Installed packages."
+      successText: `Installed packages with ${pico5.bold(packageManager)}.`
     }
   );
-  log2();
   if (!options.skipGit) {
-    await execa("git", ["init"], { cwd: targetPath });
-    await execa("git", ["add", "."], { cwd: targetPath });
-    await execa(
-      "git",
-      [
-        "commit",
-        "--no-verify",
-        "--message",
-        "chore: initial commit from create-ponder"
-      ],
-      { cwd: targetPath }
+    await oraPromise(
+      async () => {
+        await execa("git", ["init"], { cwd: targetPath });
+        await execa("git", ["add", "."], { cwd: targetPath });
+        await execa(
+          "git",
+          [
+            "commit",
+            "--no-verify",
+            "--message",
+            "chore: initial commit from create-ponder"
+          ],
+          { cwd: targetPath }
+        );
+      },
+      {
+        text: "Initializing git repository.",
+        failText: "Failed to initialize git repository.",
+        successText: "Initialized git repository."
+      }
     );
-    log2(pico4.green("\u2714"), "Initialized git repository.");
+  }
+  for (const warning of warnings) {
     log2();
+    log2(pico5.yellow(warning));
   }
+  log2();
   log2("\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015");
   log2();
   log2(
-    `${pico4.green("Success!")} Created ${pico4.bold(
+    `${pico5.green("Success!")} Created ${pico5.bold(
       projectName
-    )} at ${pico4.green(path3.resolve(projectPath))}`
+    )} at ${pico5.green(path4.resolve(projectPath))}`
   );
   log2();
   log2(
-    `To start your app, run \`${pico4.bold(
-      pico4.cyan(`cd ${projectPath}`)
-    )}\` and then \`${pico4.bold(
-      pico4.cyan(
+    `To start your app, run ${pico5.bold(
+      pico5.cyan(`cd ${projectPath}`)
+    )} and then ${pico5.bold(
+      pico5.cyan(
         `${packageManager}${packageManager === "npm" || packageManager === "bun" ? " run" : ""} dev`
       )
-    )}\``
+    )}`
   );
   log2();
   log2("\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015\u2015");
   log2();
 }
 (async () => {
-  const cli = cac(package_default.name).version(package_default.version).usage(`${pico4.green("<project-directory>")} [options]`).option(
-    "-t, --template [name]",
-    `A template to bootstrap with. Available: ${templates.map(({ id }) => id).join(", ")}`
-  ).option("--etherscan-contract-link [link]", "Etherscan contract link").option("--etherscan-api-key [key]", "Etherscan API key").option("--npm", "Use npm as your package manager").option("--pnpm", "Use pnpm as your package manager").option("--yarn", "Use yarn as your package manager").option("--skip-git", "Skips initializing the project as a git repository").help();
-  if (Number(process.version.split(".")[0].slice(1)) < 18)
+  const cli = cac(package_default.name).version(package_default.version).usage(`${pico5.green("<directory>")} [options]`).option(
+    "-t, --template [id]",
+    `Use a template. Options: ${templates.map(({ id }) => id).join(", ")}`
+  ).option("--etherscan [url]", "Use the Etherscan template").option("--subgraph [id]", "Use the subgraph template").option("--npm", "Use npm as your package manager").option("--pnpm", "Use pnpm as your package manager").option("--yarn", "Use yarn as your package manager").option("--skip-git", "Skip initializing a git repository").option(
+    "--etherscan-api-key [key]",
+    "Etherscan API key for Etherscan template"
+  ).help();
+  const _nodeVersion = process.version.split(".");
+  const nodeVersion = [
+    Number(_nodeVersion[0].slice(1)),
+    Number(_nodeVersion[1]),
+    Number(_nodeVersion[2])
+  ];
+  if (nodeVersion[0] < 18 || nodeVersion[0] === 18 && nodeVersion[1] < 14)
     throw Error(
-      pico4.red(
-        `Node version:${process.version} does not meet the >=18 requirement`
+      pico5.red(
+        `Node version:${process.version} does not meet the >=18.14 requirement`
       )
     );
   const { args, options } = cli.parse(process.argv);
@@ -786,7 +936,7 @@ async function run({
     await notifyUpdate({ options });
   } catch (error) {
     log2(
-      error instanceof ValidationError ? error.message : pico4.red(error.message)
+      error instanceof ValidationError ? error.message : pico5.red(error.message)
     );
     log2();
     await notifyUpdate({ options });