create-ponder 0.0.37 → 0.0.39

package/dist/create-ponder.mjs

@@ -0,0 +1,839 @@
+#!/usr/bin/env node
+
+// src/bin/create-ponder.ts
+import { cac } from "cac";
+import path7 from "node:path";
+import prompts from "prompts";
+
+// src/index.ts
+import { ethers } from "ethers";
+import { execSync as execSync2 } from "node:child_process";
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import path6 from "node:path";
+import pico from "picocolors";
+import prettier4 from "prettier";
+
+// src/helpers/detectPackageManager.ts
+import execa from "execa";
+import { promises as fs } from "fs";
+import { resolve } from "path";
+async function pathExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var cache = /* @__PURE__ */ new Map();
+function hasGlobalInstallation(pm) {
+  const key = `has_global_${pm}`;
+  if (cache.has(key)) {
+    return Promise.resolve(cache.get(key));
+  }
+  return execa(pm, ["--version"]).then((res) => {
+    return /^\d+.\d+.\d+$/.test(res.stdout);
+  }).then((value) => {
+    cache.set(key, value);
+    return value;
+  }).catch(() => false);
+}
+function getTypeofLockFile(cwd = ".") {
+  const key = `lockfile_${cwd}`;
+  if (cache.has(key)) {
+    return Promise.resolve(cache.get(key));
+  }
+  return Promise.all([
+    pathExists(resolve(cwd, "yarn.lock")),
+    pathExists(resolve(cwd, "package-lock.json")),
+    pathExists(resolve(cwd, "pnpm-lock.yaml"))
+  ]).then(([isYarn, isNpm, isPnpm]) => {
+    let value = null;
+    if (isYarn) {
+      value = "yarn";
+    } else if (isPnpm) {
+      value = "pnpm";
+    } else if (isNpm) {
+      value = "npm";
+    }
+    cache.set(key, value);
+    return value;
+  });
+}
+var detect = async ({ cwd } = {}) => {
+  const type = await getTypeofLockFile(cwd);
+  if (type) {
+    return type;
+  }
+  const [hasYarn, hasPnpm] = await Promise.all([
+    hasGlobalInstallation("yarn"),
+    hasGlobalInstallation("pnpm")
+  ]);
+  if (hasPnpm) {
+    return "pnpm";
+  }
+  if (hasYarn) {
+    return "yarn";
+  }
+  return "npm";
+};
+
+// src/helpers/git.ts
+import { execSync } from "child_process";
+import path from "path";
+import rimraf from "rimraf";
+function isInGitRepository() {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { stdio: "ignore" });
+    return true;
+  } catch (_) {
+  }
+  return false;
+}
+function isInMercurialRepository() {
+  try {
+    execSync("hg --cwd . root", { stdio: "ignore" });
+    return true;
+  } catch (_) {
+  }
+  return false;
+}
+function tryGitInit(root) {
+  let didInit = false;
+  try {
+    execSync("git --version", { stdio: "ignore" });
+    if (isInGitRepository() || isInMercurialRepository()) {
+      return false;
+    }
+    execSync("git init", { stdio: "ignore" });
+    didInit = true;
+    execSync("git checkout -b main", { stdio: "ignore" });
+    execSync("git add -A", { stdio: "ignore" });
+    execSync('git commit -m "chore: initial commit from create-ponder"', {
+      stdio: "ignore"
+    });
+    return true;
+  } catch (e) {
+    if (didInit) {
+      try {
+        rimraf.sync(path.join(root, ".git"));
+      } catch (_) {
+      }
+    }
+    return false;
+  }
+}
+
+// src/templates/basic.ts
+import { writeFileSync } from "node:fs";
+import path2 from "node:path";
+import prettier from "prettier";
+var fromBasic = ({ rootDir }) => {
+  const abiFileContents = `[]`;
+  const abiRelativePath = "./abis/ExampleContract.json";
+  const abiAbsolutePath = path2.join(rootDir, abiRelativePath);
+  writeFileSync(abiAbsolutePath, abiFileContents);
+  const schemaGraphqlFileContents = `
+    type ExampleToken @entity {
+      id: ID!
+      tokenId: Int!
+      trait: TokenTrait!
+    }
+    enum TokenTrait {
+      GOOD
+      BAD
+    }
+  `;
+  const ponderSchemaFilePath = path2.join(rootDir, "schema.graphql");
+  writeFileSync(
+    ponderSchemaFilePath,
+    prettier.format(schemaGraphqlFileContents, { parser: "graphql" })
+  );
+  const ponderConfig = {
+    networks: [
+      {
+        name: "mainnet",
+        chainId: 1,
+        rpcUrl: `process.env.PONDER_RPC_URL_1`
+      }
+    ],
+    contracts: [
+      {
+        name: "ExampleContract",
+        network: "mainnet",
+        address: "0x0",
+        abi: abiRelativePath,
+        startBlock: 1234567
+      }
+    ]
+  };
+  return ponderConfig;
+};
+
+// src/templates/etherscan.ts
+import { writeFileSync as writeFileSync2 } from "node:fs";
+import path3 from "node:path";
+import fetch from "node-fetch";
+import prettier2 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"
+  }
+};
+var getNetworkByEtherscanHostname = (hostname) => {
+  return networkByEtherscanHostname[hostname];
+};
+
+// src/helpers/wait.ts
+var wait = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+
+// src/templates/etherscan.ts
+var fromEtherscan = async ({
+  rootDir,
+  etherscanLink,
+  etherscanApiKey
+}) => {
+  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 { name, chainId, apiUrl } = network;
+  const contractAddress = url.pathname.slice(1).split("/")[1];
+  const txHash = await getContractCreationTxn(contractAddress, apiUrl, apiKey);
+  if (!apiKey) {
+    console.log("\n(1/2) Waiting 5 seconds for Etherscan API rate limit");
+    await wait(5e3);
+  }
+  const blockNumber = await getTxBlockNumber(txHash, apiUrl, apiKey);
+  if (!apiKey) {
+    console.log("(2/2) Waiting 5 seconds for Etherscan API rate limit");
+    await wait(5e3);
+  }
+  const { abi, contractName } = await getContractAbiAndName(
+    contractAddress,
+    apiUrl,
+    apiKey
+  );
+  const abiRelativePath = `./abis/${contractName}.json`;
+  const abiAbsolutePath = path3.join(rootDir, abiRelativePath);
+  writeFileSync2(abiAbsolutePath, prettier2.format(abi, { parser: "json" }));
+  const schemaGraphqlFileContents = `
+    type ExampleEntity @entity {
+      id: ID!
+      name: String!
+    }
+  `;
+  const ponderSchemaFilePath = path3.join(rootDir, "schema.graphql");
+  writeFileSync2(
+    ponderSchemaFilePath,
+    prettier2.format(schemaGraphqlFileContents, { parser: "graphql" })
+  );
+  const ponderConfig = {
+    networks: [
+      {
+        name,
+        chainId,
+        rpcUrl: `process.env.PONDER_RPC_URL_${chainId}`
+      }
+    ],
+    contracts: [
+      {
+        name: contractName,
+        network: name,
+        abi: abiRelativePath,
+        address: contractAddress,
+        startBlock: blockNumber
+      }
+    ]
+  };
+  return ponderConfig;
+};
+var fetchEtherscan = async (url) => {
+  const response = await fetch(url);
+  const data = await response.json();
+  if (data.status === "0") {
+    throw new Error(`Etherscan API error: ${data.result}`);
+  }
+  return data;
+};
+var getContractCreationTxn = async (contractAddress, apiUrl, apiKey) => {
+  const searchParams = new URLSearchParams({
+    module: "contract",
+    action: "getcontractcreation",
+    contractaddresses: contractAddress
+  });
+  if (apiKey)
+    searchParams.append("apikey", apiKey);
+  const data = await fetchEtherscan(`${apiUrl}?${searchParams.toString()}`);
+  return data.result[0].txHash;
+};
+var getTxBlockNumber = async (txHash, apiUrl, apiKey) => {
+  const searchParams = new URLSearchParams({
+    module: "proxy",
+    action: "eth_getTransactionByHash",
+    txhash: txHash
+  });
+  if (apiKey)
+    searchParams.append("apikey", apiKey);
+  const data = await fetchEtherscan(`${apiUrl}?${searchParams.toString()}`);
+  const hexBlockNumber = data.result.blockNumber;
+  return parseInt(hexBlockNumber.slice(2), 16);
+};
+var getContractAbiAndName = async (contractAddress, apiUrl, apiKey) => {
+  const searchParams = new URLSearchParams({
+    module: "contract",
+    action: "getsourcecode",
+    address: contractAddress
+  });
+  if (apiKey)
+    searchParams.append("apikey", apiKey);
+  const data = await fetchEtherscan(`${apiUrl}?${searchParams.toString()}`);
+  const abi = data.result[0].ABI;
+  const contractName = data.result[0].ContractName;
+  return { abi, contractName };
+};
+
+// src/templates/subgraphId.ts
+import { writeFileSync as writeFileSync3 } from "node:fs";
+import path4 from "node:path";
+import fetch2 from "node-fetch";
+import prettier3 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/templates/subgraphId.ts
+var fetchIpfsFile = async (cid) => {
+  const url = `https://ipfs.network.thegraph.com/api/v0/cat?arg=${cid}`;
+  const response = await fetch2(url);
+  const contentRaw = await response.text();
+  return contentRaw;
+};
+var fromSubgraphId = async ({
+  rootDir,
+  subgraphId
+}) => {
+  const ponderNetworks = [];
+  let ponderContracts = [];
+  const manifestRaw = await fetchIpfsFile(subgraphId);
+  const manifest = parse(manifestRaw);
+  const schemaCid = manifest.schema.file["/"].slice(6);
+  const schemaRaw = await fetchIpfsFile(schemaCid);
+  const ponderSchemaFilePath = path4.join(rootDir, "schema.graphql");
+  writeFileSync3(
+    ponderSchemaFilePath,
+    prettier3.format(schemaRaw, { parser: "graphql" })
+  );
+  const dataSources = manifest.dataSources.map(
+    validateGraphProtocolSource
+  );
+  const abiFiles = dataSources.map((source) => source.mapping.abis).flat().filter(
+    (source, idx, arr) => arr.findIndex((s) => s.name === source.name) === idx
+  );
+  await Promise.all(
+    abiFiles.map(async (abi) => {
+      const abiContent = await fetchIpfsFile(abi.file["/"].slice(6));
+      const abiPath = path4.join(rootDir, `./abis/${abi.name}.json`);
+      writeFileSync3(abiPath, prettier3.format(abiContent, { parser: "json" }));
+    })
+  );
+  ponderContracts = dataSources.map((source) => {
+    const network = source.network || "mainnet";
+    const chainId = getGraphProtocolChainId(network);
+    if (!chainId || chainId === -1) {
+      throw new Error(`Unhandled network name: ${network}`);
+    }
+    if (!ponderNetworks.map((n) => n.name).includes(network)) {
+      ponderNetworks.push({
+        name: network,
+        chainId,
+        rpcUrl: `process.env.PONDER_RPC_URL_${chainId}`
+      });
+    }
+    const abiRelativePath = `./abis/${source.source.abi}.json`;
+    return {
+      name: source.name,
+      network,
+      address: source.source.address,
+      abi: abiRelativePath,
+      startBlock: source.source.startBlock
+    };
+  });
+  const ponderConfig = {
+    networks: ponderNetworks,
+    contracts: ponderContracts
+  };
+  return ponderConfig;
+};
+
+// src/templates/subgraphRepo.ts
+import { copyFileSync, readFileSync } from "node:fs";
+import path5 from "node:path";
+import { parse as parse2 } from "yaml";
+var fromSubgraphRepo = ({
+  rootDir,
+  subgraphPath
+}) => {
+  const subgraphRootDir = path5.resolve(subgraphPath);
+  const ponderNetworks = [];
+  let ponderContracts = [];
+  const subgraphRootDirPath = path5.resolve(subgraphRootDir);
+  let subgraphYamlRaw = "";
+  for (const subgraphYamlFileName of subgraphYamlFileNames) {
+    try {
+      subgraphYamlRaw = readFileSync(
+        path5.join(subgraphRootDirPath, subgraphYamlFileName),
+        {
+          encoding: "utf-8"
+        }
+      );
+      break;
+    } catch (e) {
+      continue;
+    }
+  }
+  if (subgraphYamlRaw === "") {
+    throw new Error(`subgraph.yaml file not found`);
+  }
+  const subgraphYaml = parse2(subgraphYamlRaw);
+  const subgraphSchemaFilePath = path5.join(
+    subgraphRootDirPath,
+    subgraphYaml.schema.file
+  );
+  const ponderSchemaFilePath = path5.join(rootDir, "schema.graphql");
+  copyFileSync(subgraphSchemaFilePath, ponderSchemaFilePath);
+  ponderContracts = subgraphYaml.dataSources.map(validateGraphProtocolSource).map((source) => {
+    const abiPath = source.mapping.abis.find(
+      (abi) => abi.name === source.name
+    )?.file;
+    if (!abiPath) {
+      throw new Error(`ABI path not found for source: ${source.name}`);
+    }
+    const network = source.network || "mainnet";
+    const chainId = getGraphProtocolChainId(network);
+    if (!chainId || chainId === -1) {
+      throw new Error(`Unhandled network name: ${network}`);
+    }
+    if (!ponderNetworks.map((n) => n.name).includes(network)) {
+      ponderNetworks.push({
+        name: network,
+        chainId,
+        rpcUrl: `process.env.PONDER_RPC_URL_${chainId}`
+      });
+    }
+    const abiAbsolutePath = path5.join(subgraphRootDirPath, abiPath);
+    const abiFileName = path5.basename(abiPath);
+    const ponderAbiRelativePath = `./abis/${abiFileName}`;
+    const ponderAbiAbsolutePath = path5.join(rootDir, ponderAbiRelativePath);
+    copyFileSync(abiAbsolutePath, ponderAbiAbsolutePath);
+    return {
+      name: source.name,
+      network,
+      address: source.source.address,
+      abi: ponderAbiRelativePath,
+      startBlock: source.source.startBlock
+    };
+  });
+  const ponderConfig = {
+    networks: ponderNetworks,
+    contracts: ponderContracts
+  };
+  return ponderConfig;
+};
+
+// src/index.ts
+var run = async (options, overrides = {}) => {
+  const { rootDir } = options;
+  mkdirSync(path6.join(rootDir, "abis"), { recursive: true });
+  mkdirSync(path6.join(rootDir, "src"), { recursive: true });
+  let ponderConfig;
+  console.log(
+    `
+Creating a new Ponder app in ${pico.bold(pico.green(rootDir))}.`
+  );
+  switch (options.template?.kind) {
+    case 1 /* ETHERSCAN */: {
+      console.log(`
+Using ${pico.cyan("Etherscan contract link")} template.`);
+      ponderConfig = await fromEtherscan({
+        rootDir,
+        etherscanLink: options.template.link,
+        etherscanApiKey: options.etherscanApiKey
+      });
+      break;
+    }
+    case 2 /* SUBGRAPH_ID */: {
+      console.log(`
+Using ${pico.cyan("Subgraph ID")} template.`);
+      ponderConfig = await fromSubgraphId({
+        rootDir,
+        subgraphId: options.template.id
+      });
+      break;
+    }
+    case 3 /* SUBGRAPH_REPO */: {
+      console.log(`
+Using ${pico.cyan("Subgraph repository")} template.`);
+      ponderConfig = fromSubgraphRepo({
+        rootDir,
+        subgraphPath: options.template.path
+      });
+      break;
+    }
+    default: {
+      ponderConfig = fromBasic({ rootDir });
+      break;
+    }
+  }
+  ponderConfig.contracts.forEach((contract) => {
+    const abi = readFileSync2(path6.join(rootDir, contract.abi), {
+      encoding: "utf-8"
+    });
+    const abiInterface = new ethers.utils.Interface(abi);
+    const eventNames = Object.keys(abiInterface.events).map(
+      (signature) => signature.slice(0, signature.indexOf("("))
+    );
+    const eventNamesToWrite = eventNames.slice(0, 2);
+    const handlerFileContents = `
+      import { ponder } from '../generated'
+
+      ${eventNamesToWrite.map(
+      (eventName) => `
+          ponder.on("${contract.name}:${eventName}", async ({ event, context }) => {
+            console.log(event.params)
+          })`
+    ).join("\n")}
+    `;
+    writeFileSync4(
+      path6.join(rootDir, `./src/${contract.name}.ts`),
+      prettier4.format(handlerFileContents, { parser: "typescript" })
+    );
+  });
+  const finalPonderConfig = `
+    import type { PonderConfig } from "@ponder/core";
+
+    export const config: PonderConfig = {
+      networks: ${JSON.stringify(ponderConfig.networks).replaceAll(
+    /"process.env.PONDER_RPC_URL_(.*?)"/g,
+    "process.env.PONDER_RPC_URL_$1"
+  )},
+      contracts: ${JSON.stringify(ponderConfig.contracts)},
+    };
+  `;
+  writeFileSync4(
+    path6.join(rootDir, "ponder.config.ts"),
+    prettier4.format(finalPonderConfig, { parser: "babel" })
+  );
+  const uniqueChainIds = Array.from(
+    new Set(ponderConfig.networks.map((n) => n.chainId))
+  );
+  const envLocal = `${uniqueChainIds.map(
+    (chainId) => `PONDER_RPC_URL_${chainId}=""
+`
+  )}`;
+  writeFileSync4(path6.join(rootDir, ".env.local"), envLocal);
+  const packageJson = `
+    {
+      "private": true,
+      "scripts": {
+        "dev": "ponder dev",
+        "start": "ponder start",
+        "codegen": "ponder codegen"
+      },
+      "dependencies": {
+        "@ponder/core": "latest"
+      },
+      "devDependencies": {
+        "@types/node": "^18.11.18",
+        "ethers": "^5.6.9"
+      },
+      "engines": {
+        "node": ">=16.0.0 <19.0.0"
+      }
+    }
+  `;
+  writeFileSync4(
+    path6.join(rootDir, "package.json"),
+    prettier4.format(packageJson, { parser: "json" })
+  );
+  const tsConfig = `
+    {
+      "compilerOptions": {
+        "target": "esnext",
+        "module": "esnext",
+        "esModuleInterop": true,
+        "strict": true,
+        "moduleResolution": "node"
+      },
+      "include": ["./**/*.ts"],
+      "exclude": ["node_modules"]
+    }
+  `;
+  writeFileSync4(
+    path6.join(rootDir, "tsconfig.json"),
+    prettier4.format(tsConfig, { parser: "json" })
+  );
+  writeFileSync4(
+    path6.join(rootDir, ".gitignore"),
+    `node_modules/
+.DS_Store
+
+.env.local
+.ponder/
+generated/`
+  );
+  const packageManager = await detect();
+  const runCommand = packageManager === "npm" ? `${packageManager} run` : packageManager;
+  console.log(pico.bold(`
+Installing with ${packageManager}.`));
+  const installCommand = overrides.installCommand ? overrides.installCommand : `${packageManager} install`;
+  execSync2(installCommand, {
+    cwd: rootDir,
+    stdio: "inherit"
+  });
+  process.chdir(rootDir);
+  tryGitInit(rootDir);
+  console.log(`
+Initialized a git repository.`);
+  execSync2(`${runCommand} --silent codegen --silent`, {
+    cwd: rootDir,
+    stdio: "inherit"
+  });
+  console.log(`
+Generated types.`);
+  console.log(
+    pico.green("\nSuccess! ") + `Created ${options.projectName} at ${rootDir}`
+  );
+};
+
+// package.json
+var package_default = {
+  name: "create-ponder",
+  version: "0.0.39",
+  description: "Tool to bootstrap a Ponder project",
+  license: "MIT",
+  author: "olias.eth",
+  files: [
+    "dist"
+  ],
+  bin: {
+    "create-ponder": "dist/create-ponder.js"
+  },
+  scripts: {
+    build: "tsup-node",
+    test: "export $(grep -v '^#' .env.local | xargs) && vitest --no-threads",
+    "test:ci": "vitest --no-threads",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {
+    "@ethersproject/abi": "^5.6.4",
+    "@ethersproject/providers": "^5.6.8",
+    cac: "^6.7.14",
+    ethers: "^5.6.9",
+    execa: "5",
+    "node-fetch": "^2.6.7",
+    picocolors: "^1.0.0",
+    prettier: "^2.6.2",
+    prompts: "^2.4.2",
+    rimraf: "^4.1.2",
+    yaml: "^2.1.1"
+  },
+  devDependencies: {
+    "@ponder/core": "workspace:*",
+    "@types/node": "^18.7.8",
+    "@types/node-fetch": "2",
+    "@types/prettier": "^2.7.1",
+    "@types/prompts": "^2.4.2",
+    "tsconfig-replace-paths": "^0.0.11",
+    tsup: "^6.6.3",
+    typescript: "^4.5.5",
+    vitest: "^0.29.2"
+  }
+};
+
+// src/bin/create-ponder.ts
+var createPonder = async () => {
+  const cli = cac(package_default.name).version(package_default.version).usage("[options]").help().option("--dir [path]", "Path to directory for generated project").option("--from-subgraph-id [id]", "Subgraph deployment ID").option("--from-subgraph-repo [path]", "Path to subgraph repository").option("--from-etherscan [url]", "Link to etherscan contract page").option("--etherscan-api-key [key]", "Etherscan API key");
+  const parsed = cli.parse(process.argv);
+  const options = parsed.options;
+  if (options.help) {
+    process.exit(0);
+  }
+  const { fromEtherscan: fromEtherscan2, fromSubgraphId: fromSubgraphId2, fromSubgraphRepo: fromSubgraphRepo2 } = options;
+  if (fromSubgraphId2 && fromSubgraphRepo2 || fromSubgraphId2 && fromEtherscan2 || fromSubgraphRepo2 && fromEtherscan2) {
+    throw new Error(
+      `Cannot specify more than one "--from" option:
+  --from-subgraph
+  --from-etherscan-id
+  --from-etherscan-repo`
+    );
+  }
+  const { projectName } = await prompts({
+    type: "text",
+    name: "projectName",
+    message: "What is your project named?",
+    initial: "my-app"
+  });
+  let template = void 0;
+  if (fromEtherscan2) {
+    template = { kind: 1 /* ETHERSCAN */, link: fromEtherscan2 };
+  }
+  if (fromSubgraphId2) {
+    template = { kind: 2 /* SUBGRAPH_ID */, id: fromSubgraphId2 };
+  }
+  if (fromSubgraphRepo2) {
+    template = { kind: 3 /* SUBGRAPH_REPO */, path: fromSubgraphRepo2 };
+  }
+  if (!fromSubgraphId2 && !fromSubgraphRepo2 && !fromEtherscan2) {
+    const { template: templateKind } = await prompts({
+      type: "select",
+      name: "template",
+      message: "Would you like to use a template for this project?",
+      choices: [
+        { title: "None" },
+        { title: "Etherscan contract link" },
+        { title: "Subgraph ID" },
+        { title: "Subgraph repository" }
+      ]
+    });
+    if (templateKind === 1 /* ETHERSCAN */) {
+      const { link } = await prompts({
+        type: "text",
+        name: "link",
+        message: "Enter an Etherscan contract link",
+        initial: "https://etherscan.io/address/0x97..."
+      });
+      template = { kind: 1 /* ETHERSCAN */, link };
+    }
+    if (templateKind === 2 /* SUBGRAPH_ID */) {
+      const { id } = await prompts({
+        type: "text",
+        name: "id",
+        message: "Enter a subgraph deployment ID",
+        initial: "QmNus..."
+      });
+      template = { kind: 2 /* SUBGRAPH_ID */, id };
+    }
+    if (templateKind === 3 /* SUBGRAPH_REPO */) {
+      const { path: path8 } = await prompts({
+        type: "text",
+        name: "path",
+        message: "Enter a path to a subgraph repository",
+        initial: "../subgraph"
+      });
+      template = { kind: 3 /* SUBGRAPH_REPO */, path: path8 };
+    }
+  }
+  const validatedOptions = {
+    projectName,
+    rootDir: path7.resolve(".", options.dir ? options.dir : projectName),
+    template,
+    etherscanApiKey: options.etherscanApiKey
+  };
+  await run(validatedOptions);
+};
+createPonder();
+//# sourceMappingURL=create-ponder.mjs.map