create-ponder 0.0.1

package/README.md

@@ -0,0 +1 @@
+# Go to [docs on GitHub](https://github.com/0xOlias/ponder#readme)

package/dist/bin/create-ponder

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var create_ponder_exports = {};
+module.exports = __toCommonJS(create_ponder_exports);
+var import_commander = require("commander");
+var import_node_path = __toESM(require("node:path"));
+const program = new import_commander.Command();
+program.description("Create a Ponder project").option("--dir <string>", "Path to directory for generated Ponder project").option("--from-subgraph <string>", "Path to subgraph directory").option("--from-etherscan <string>", "Link to etherscan contract page").option("--etherscan-api-key <string>", "Etherscan API key");
+program.parse();
+const options = program.opts();
+if (options.fromSubgraph && options.fromEtherscan) {
+  throw new Error(`Cannot specify more than one "--from" option:
+--from-subgraph
+--from-etherscan
+`);
+}
+const validatedOptions = {
+  ponderRootDir: import_node_path.default.resolve(options.dir ? options.dir : "ponder"),
+  fromSubgraph: options.fromSubgraph,
+  fromEtherscan: options.fromEtherscan,
+  etherscanApiKey: options.etherscanApiKey
+};
+require("../index").run(validatedOptions);

package/dist/fromBasic.js

@@ -0,0 +1,102 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (
+  (target = mod != null ? __create(__getProtoOf(mod)) : {}),
+  __copyProps(
+    isNodeMode || !mod || !mod.__esModule
+      ? __defProp(target, "default", { value: mod, enumerable: true })
+      : target,
+    mod
+  )
+);
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fromBasic_exports = {};
+__export(fromBasic_exports, {
+  fromBasic: () => fromBasic,
+});
+module.exports = __toCommonJS(fromBasic_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"));
+var import_prettier = __toESM(require("prettier"));
+const fromBasic = (options) => {
+  const { ponderRootDir } = options;
+  const abiFileContents = `[]`;
+  const abiRelativePath = "./abis/ExampleContract.json";
+  const abiAbsolutePath = import_node_path.default.join(
+    ponderRootDir,
+    abiRelativePath
+  );
+  (0, import_node_fs.writeFileSync)(abiAbsolutePath, abiFileContents);
+  const schemaGraphqlFileContents = `
+    type ExampleToken @entity {
+      id: ID!
+      tokenId: Int!
+      trait: TokenTrait!
+    }
+    enum TokenTrait {
+      GOOD
+      BAD
+    }
+  `;
+  const ponderSchemaFilePath = import_node_path.default.join(
+    ponderRootDir,
+    "schema.graphql"
+  );
+  (0, import_node_fs.writeFileSync)(
+    ponderSchemaFilePath,
+    import_prettier.default.format(schemaGraphqlFileContents, {
+      parser: "graphql",
+    })
+  );
+  const ponderConfig = {
+    plugins: ["graphqlPlugin()"],
+    database: {
+      kind: "sqlite",
+    },
+    networks: [
+      {
+        kind: "evm",
+        name: "mainnet",
+        chainId: 1,
+        rpcUrl: `process.env.PONDER_RPC_URL_1`,
+      },
+    ],
+    sources: [
+      {
+        kind: "evm",
+        name: "ExampleContract",
+        network: "mainnet",
+        address: "0x0",
+        abi: abiRelativePath,
+        startBlock: 1234567,
+      },
+    ],
+  };
+  return ponderConfig;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    fromBasic,
+  });

package/dist/fromEtherscan.js

@@ -0,0 +1,168 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (
+  (target = mod != null ? __create(__getProtoOf(mod)) : {}),
+  __copyProps(
+    isNodeMode || !mod || !mod.__esModule
+      ? __defProp(target, "default", { value: mod, enumerable: true })
+      : target,
+    mod
+  )
+);
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fromEtherscan_exports = {};
+__export(fromEtherscan_exports, {
+  fromEtherscan: () => fromEtherscan,
+});
+module.exports = __toCommonJS(fromEtherscan_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"));
+var import_node_fetch = __toESM(require("node-fetch"));
+var import_prettier = __toESM(require("prettier"));
+var import_getEtherscanChainId = require("./helpers/getEtherscanChainId");
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const fromEtherscan = async (options) => {
+  const { ponderRootDir } = options;
+  if (!options.fromEtherscan) {
+    throw new Error(`Internal error: fromEtherscan undefined`);
+  }
+  const apiKey = options.etherscanApiKey || process.env.ETHERSCAN_API_KEY;
+  const url = new URL(options.fromEtherscan);
+  const network = (0, import_getEtherscanChainId.getNetworkByEtherscanHostname)(
+    url.hostname
+  );
+  if (!network) {
+    throw new Error(`Unrecognized etherscan hostname: ${url.hostname}`);
+  }
+  const apiUrl = `https://api.${url.hostname}/api`;
+  const contractAddress = url.pathname.slice(1).split("/")[1];
+  const txHash = await getContractCreationTxn(contractAddress, apiUrl, apiKey);
+  if (!apiKey) {
+    console.log("(1/2) Waiting 5 seconds for Etherscan API rate limit");
+    await delay(5e3);
+  }
+  const blockNumber = await getTxBlockNumber(txHash, apiUrl, apiKey);
+  if (!apiKey) {
+    console.log("(2/2) Waiting 5 seconds for Etherscan API rate limit");
+    await delay(5e3);
+  }
+  const { abi, contractName } = await getContractAbiAndName(
+    contractAddress,
+    apiUrl,
+    apiKey
+  );
+  const abiRelativePath = `./abis/${contractName}.json`;
+  const abiAbsolutePath = import_node_path.default.join(
+    ponderRootDir,
+    abiRelativePath
+  );
+  (0, import_node_fs.writeFileSync)(abiAbsolutePath, abi);
+  const schemaGraphqlFileContents = `
+    type ExampleEntity @entity {
+      id: ID!
+      name: String!
+    }
+  `;
+  const ponderSchemaFilePath = import_node_path.default.join(
+    ponderRootDir,
+    "schema.graphql"
+  );
+  (0, import_node_fs.writeFileSync)(
+    ponderSchemaFilePath,
+    import_prettier.default.format(schemaGraphqlFileContents, {
+      parser: "graphql",
+    })
+  );
+  const ponderConfig = {
+    plugins: ["graphqlPlugin()"],
+    database: {
+      kind: "sqlite",
+    },
+    networks: [
+      {
+        kind: "evm",
+        name: network.name,
+        chainId: network.chainId,
+        rpcUrl: `process.env.PONDER_RPC_URL_${network.chainId}`,
+      },
+    ],
+    sources: [
+      {
+        kind: "evm",
+        name: contractName,
+        network: network.name,
+        abi: abiRelativePath,
+        address: contractAddress,
+        startBlock: blockNumber,
+      },
+    ],
+  };
+  return ponderConfig;
+};
+const fetchEtherscan = async (url) => {
+  const response = await (0, import_node_fetch.default)(url);
+  const data = await response.json();
+  if (data.status === "0") {
+    throw new Error(`Etherscan API error: ${data.result}`);
+  }
+  return data;
+};
+const 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;
+};
+const 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);
+};
+const 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 };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    fromEtherscan,
+  });

package/dist/fromSubgraph.js

@@ -0,0 +1,145 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (
+  (target = mod != null ? __create(__getProtoOf(mod)) : {}),
+  __copyProps(
+    isNodeMode || !mod || !mod.__esModule
+      ? __defProp(target, "default", { value: mod, enumerable: true })
+      : target,
+    mod
+  )
+);
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fromSubgraph_exports = {};
+__export(fromSubgraph_exports, {
+  fromSubgraph: () => fromSubgraph,
+});
+module.exports = __toCommonJS(fromSubgraph_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"));
+var import_yaml = require("yaml");
+var import_getGraphProtocolChainId = require("./helpers/getGraphProtocolChainId");
+var import_validateGraphProtocolSource = require("./helpers/validateGraphProtocolSource");
+const fromSubgraph = (options) => {
+  if (!options.fromSubgraph) {
+    throw new Error(`Internal error: fromSubgraph undefined`);
+  }
+  const { ponderRootDir } = options;
+  const subgraphRootDir = import_node_path.default.resolve(
+    options.fromSubgraph
+  );
+  const ponderNetworks = [];
+  let ponderSources = [];
+  const subgraphRootDirPath = import_node_path.default.resolve(subgraphRootDir);
+  let subgraphYamlRaw = "";
+  for (const subgraphYamlFileName of import_getGraphProtocolChainId.subgraphYamlFileNames) {
+    try {
+      subgraphYamlRaw = (0, import_node_fs.readFileSync)(
+        import_node_path.default.join(
+          subgraphRootDirPath,
+          subgraphYamlFileName
+        ),
+        {
+          encoding: "utf-8",
+        }
+      );
+      break;
+    } catch (e) {
+      continue;
+    }
+  }
+  if (subgraphYamlRaw === "") {
+    throw new Error(`subgraph.yaml file not found`);
+  }
+  const subgraphYaml = (0, import_yaml.parse)(subgraphYamlRaw);
+  const subgraphSchemaFilePath = import_node_path.default.join(
+    subgraphRootDirPath,
+    subgraphYaml.schema.file
+  );
+  const ponderSchemaFilePath = import_node_path.default.join(
+    ponderRootDir,
+    "schema.graphql"
+  );
+  (0, import_node_fs.copyFileSync)(
+    subgraphSchemaFilePath,
+    ponderSchemaFilePath
+  );
+  ponderSources = subgraphYaml.dataSources
+    .map(import_validateGraphProtocolSource.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 = (0,
+      import_getGraphProtocolChainId.getGraphProtocolChainId)(network);
+      if (!chainId || chainId === -1) {
+        throw new Error(`Unhandled network name: ${network}`);
+      }
+      if (!ponderNetworks.map((n) => n.name).includes(network)) {
+        ponderNetworks.push({
+          kind: "evm",
+          name: network,
+          chainId,
+          rpcUrl: `process.env.PONDER_RPC_URL_${chainId}`,
+        });
+      }
+      const abiAbsolutePath = import_node_path.default.join(
+        subgraphRootDirPath,
+        abiPath
+      );
+      const abiFileName = import_node_path.default.basename(abiPath);
+      const ponderAbiRelativePath = `./abis/${abiFileName}`;
+      const ponderAbiAbsolutePath = import_node_path.default.join(
+        ponderRootDir,
+        ponderAbiRelativePath
+      );
+      (0, import_node_fs.copyFileSync)(abiAbsolutePath, ponderAbiAbsolutePath);
+      return {
+        kind: "evm",
+        name: source.name,
+        network,
+        address: source.source.address,
+        abi: ponderAbiRelativePath,
+        startBlock: source.source.startBlock,
+      };
+    });
+  const ponderConfig = {
+    plugins: ["graphqlPlugin()"],
+    database: {
+      kind: "sqlite",
+    },
+    networks: ponderNetworks,
+    sources: ponderSources,
+  };
+  return ponderConfig;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    fromSubgraph,
+  });

package/dist/helpers/detectPackageManager.js

@@ -0,0 +1,109 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (
+  (target = mod != null ? __create(__getProtoOf(mod)) : {}),
+  __copyProps(
+    isNodeMode || !mod || !mod.__esModule
+      ? __defProp(target, "default", { value: mod, enumerable: true })
+      : target,
+    mod
+  )
+);
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var detectPackageManager_exports = {};
+__export(detectPackageManager_exports, {
+  detect: () => detect,
+});
+module.exports = __toCommonJS(detectPackageManager_exports);
+var import_execa = __toESM(require("execa"));
+var import_fs = require("fs");
+var import_path = require("path");
+async function pathExists(p) {
+  try {
+    await import_fs.promises.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+const cache = /* @__PURE__ */ new Map();
+function hasGlobalInstallation(pm) {
+  const key = `has_global_${pm}`;
+  if (cache.has(key)) {
+    return Promise.resolve(cache.get(key));
+  }
+  return (0, import_execa.default)(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((0, import_path.resolve)(cwd, "yarn.lock")),
+    pathExists((0, import_path.resolve)(cwd, "package-lock.json")),
+    pathExists((0, import_path.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;
+  });
+}
+const 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";
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    detect,
+  });

package/dist/helpers/getEtherscanChainId.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getEtherscanChainId_exports = {};
+__export(getEtherscanChainId_exports, {
+  getNetworkByEtherscanHostname: () => getNetworkByEtherscanHostname,
+});
+module.exports = __toCommonJS(getEtherscanChainId_exports);
+const networkByEtherscanHostname = {
+  "etherscan.io": { name: "mainnet", chainId: 1 },
+  "ropsten.etherscan.io": { name: "ropsten", chainId: 3 },
+  "rinkeby.etherscan.io": { name: "rinkeby", chainId: 4 },
+  "goerli.etherscan.io": { name: "goerli", chainId: 5 },
+  "kovan.etherscan.io": { name: "kovan", chainId: 42 },
+  "sepolia.etherscan.io": { name: "sepolia", chainId: 11155111 },
+  "optimistic.etherscan.io": { name: "optimism", chainId: 10 },
+  "kovan-optimistic.etherscan.io": { name: "optimism-kovan", chainId: 69 },
+  "goerli-optimism.etherscan.io": { name: "optimism-goerli", chainId: 420 },
+  "polygonscan.com": { name: "polygon", chainId: 137 },
+  "mumbai.polygonscan.com": { name: "polygon-mumbai", chainId: 80001 },
+  "arbiscan.io": { name: "arbitrum", chainId: 42161 },
+  "testnet.arbiscan.io": { name: "arbitrum-rinkeby", chainId: 421611 },
+  "goerli.arbiscan.io": { name: "arbitrum-goerli", chainId: 421613 },
+};
+const getNetworkByEtherscanHostname = (hostname) => {
+  return networkByEtherscanHostname[hostname];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    getNetworkByEtherscanHostname,
+  });

package/dist/helpers/getGraphProtocolChainId.js

@@ -0,0 +1,71 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getGraphProtocolChainId_exports = {};
+__export(getGraphProtocolChainId_exports, {
+  getGraphProtocolChainId: () => getGraphProtocolChainId,
+  subgraphYamlFileNames: () => subgraphYamlFileNames,
+});
+module.exports = __toCommonJS(getGraphProtocolChainId_exports);
+const 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,
+};
+const getGraphProtocolChainId = (networkName) => {
+  return chainIdByGraphNetwork[networkName];
+};
+const subgraphYamlFileNames = ["subgraph.yaml"].concat(
+  Object.keys(chainIdByGraphNetwork).map((n) => `subgraph-${n}.yaml`)
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    getGraphProtocolChainId,
+    subgraphYamlFileNames,
+  });

package/dist/helpers/getPackageManager.js

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getPackageManager_exports = {};
+__export(getPackageManager_exports, {
+  getPackageManager: () => getPackageManager,
+});
+module.exports = __toCommonJS(getPackageManager_exports);
+var import_child_process = require("child_process");
+function getPackageManager() {
+  try {
+    const userAgent = process.env.npm_config_user_agent;
+    if (userAgent) {
+      if (userAgent.startsWith("yarn")) {
+        return "yarn";
+      } else if (userAgent.startsWith("pnpm")) {
+        return "pnpm";
+      }
+    }
+    try {
+      (0, import_child_process.execSync)("yarn --version", { stdio: "ignore" });
+      return "yarn";
+    } catch {
+      (0, import_child_process.execSync)("pnpm --version", { stdio: "ignore" });
+      return "pnpm";
+    }
+  } catch {
+    return "npm";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    getPackageManager,
+  });

package/dist/helpers/validateGraphProtocolSource.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validateGraphProtocolSource_exports = {};
+__export(validateGraphProtocolSource_exports, {
+  validateGraphProtocolSource: () => validateGraphProtocolSource,
+});
+module.exports = __toCommonJS(validateGraphProtocolSource_exports);
+const validateGraphProtocolSource = (source) => {
+  return source;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    validateGraphProtocolSource,
+  });

package/dist/index.js

@@ -0,0 +1,281 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (
+  (target = mod != null ? __create(__getProtoOf(mod)) : {}),
+  __copyProps(
+    isNodeMode || !mod || !mod.__esModule
+      ? __defProp(target, "default", { value: mod, enumerable: true })
+      : target,
+    mod
+  )
+);
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  run: () => run,
+});
+module.exports = __toCommonJS(src_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_ethers = require("ethers");
+var import_node_child_process = require("node:child_process");
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"));
+var import_prettier = __toESM(require("prettier"));
+var import_fromBasic = require("./fromBasic");
+var import_fromEtherscan = require("./fromEtherscan");
+var import_fromSubgraph = require("./fromSubgraph");
+var import_detectPackageManager = require("./helpers/detectPackageManager");
+const run = async (options) => {
+  const { ponderRootDir } = options;
+  (0, import_node_fs.mkdirSync)(
+    import_node_path.default.join(ponderRootDir, "abis"),
+    { recursive: true }
+  );
+  (0, import_node_fs.mkdirSync)(
+    import_node_path.default.join(ponderRootDir, "handlers"),
+    { recursive: true }
+  );
+  let ponderConfig;
+  if (options.fromSubgraph) {
+    console.log(
+      import_chalk.default.bold.cyanBright("[create-ponder] ") +
+        `Bootstrapping from subgraph`
+    );
+    ponderConfig = (0, import_fromSubgraph.fromSubgraph)(options);
+  } else if (options.fromEtherscan) {
+    console.log(
+      import_chalk.default.bold.cyanBright("[create-ponder] ") +
+        `Bootstrapping from Etherscan`
+    );
+    ponderConfig = await (0, import_fromEtherscan.fromEtherscan)(options);
+  } else {
+    ponderConfig = (0, import_fromBasic.fromBasic)(options);
+  }
+  ponderConfig.sources.forEach((source) => {
+    const abi = (0, import_node_fs.readFileSync)(
+      import_node_path.default.join(ponderRootDir, source.abi),
+      {
+        encoding: "utf-8",
+      }
+    );
+    const abiInterface = new import_ethers.ethers.utils.Interface(abi);
+    const eventNames = Object.keys(abiInterface.events);
+    const handlers = eventNames.map((eventName) => {
+      const eventBaseName = eventName.split("(")[0];
+      const handlerFunctionType = `${eventBaseName}Handler`;
+      const handlerFunctionName = `handle${eventBaseName}`;
+      return {
+        handlerFunctionType,
+        handlerFunction: `const ${handlerFunctionName}: ${handlerFunctionType} = async (event, context) => { return }
+`,
+        handlerExport: `${eventBaseName}: ${handlerFunctionName}`,
+      };
+    });
+    const handlerFileContents = `
+      import { ${handlers.map((h) => h.handlerFunctionType).join(",")} }
+        from '../generated/handlers'
+
+      ${handlers.map((h) => h.handlerFunction).join("\n")}
+      
+      export const ${source.name} = {
+        ${handlers.map((h) => h.handlerExport).join(",")}
+      }
+    `;
+    (0, import_node_fs.writeFileSync)(
+      import_node_path.default.join(
+        ponderRootDir,
+        `./handlers/${source.name}.ts`
+      ),
+      import_prettier.default.format(handlerFileContents, {
+        parser: "typescript",
+      })
+    );
+  });
+  const handlerIndexFileContents = `
+    ${ponderConfig.sources
+      .map((source) => `import { ${source.name} } from "./${source.name}"`)
+      .join("\n")}
+      
+    export default {
+      ${ponderConfig.sources
+        .map((source) => `${source.name}: ${source.name}`)
+        .join(",")}
+    }
+  `;
+  (0, import_node_fs.writeFileSync)(
+    import_node_path.default.join(ponderRootDir, `./handlers/index.ts`),
+    import_prettier.default.format(handlerIndexFileContents, {
+      parser: "typescript",
+    })
+  );
+  const finalPonderConfig = `const { graphqlPlugin } = require("@ponder/graphql");
+
+/**
+ * @type {import('@ponder/ponder').PonderConfig}
+ */
+const ponderConfig = {
+  plugins: [graphqlPlugin()],
+  database: {
+    kind: "sqlite",
+  },
+  networks: ${JSON.stringify(ponderConfig.networks).replaceAll(
+    /"process.env.PONDER_RPC_URL_(.*?)"/g,
+    "process.env.PONDER_RPC_URL_$1"
+  )},
+  sources: ${JSON.stringify(ponderConfig.sources)},
+};
+
+module.exports = ponderConfig;`;
+  (0, import_node_fs.writeFileSync)(
+    import_node_path.default.join(ponderRootDir, "ponder.config.js"),
+    import_prettier.default.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}=""
+`
+  )}`;
+  (0, import_node_fs.writeFileSync)(
+    import_node_path.default.join(ponderRootDir, ".env.local"),
+    envLocal
+  );
+  const packageJson = `
+    {
+      "version": "0.1.0",
+      "private": true,
+      "scripts": {
+        "dev": "ponder dev",
+        "start": "ponder start",
+        "codegen": "ponder codegen"
+      },
+      "dependencies": {
+        "@ponder/ponder": "latest",
+        "@ponder/graphql": "latest"
+      },
+      "devDependencies": {
+        "ethers": "^5.6.9"
+      },
+      "engines": {
+        "node": "16",
+      }
+    }
+  `;
+  (0, import_node_fs.writeFileSync)(
+    import_node_path.default.join(ponderRootDir, "package.json"),
+    import_prettier.default.format(packageJson, { parser: "json" })
+  );
+  const tsConfig = `
+    {
+      "compilerOptions": {
+        "target": "esnext",
+        "module": "esnext",
+        "esModuleInterop": true,
+        "strict": true,
+        "moduleResolution": "node"
+      },
+      "include": ["./**/*.ts"],
+      "exclude": ["node_modules"]
+    }
+  `;
+  (0, import_node_fs.writeFileSync)(
+    import_node_path.default.join(ponderRootDir, "tsconfig.json"),
+    import_prettier.default.format(tsConfig, { parser: "json" })
+  );
+  (0, import_node_fs.writeFileSync)(
+    import_node_path.default.join(ponderRootDir, ".gitignore"),
+    `node_modules/
+.DS_Store
+
+.env.local
+.ponder/
+generated/`
+  );
+  const packageManager = await (0, import_detectPackageManager.detect)();
+  const renderYaml = `
+# This file was generated by \`create-ponder\`. You can deploy your Ponder app
+# by signing in to https://render.com, connecting this repository, and clicking Deploy.
+
+services:
+  - type: web
+    name: ponder-app
+    env: node
+    buildCommand: ${packageManager} install
+    startCommand: ${packageManager} run start
+    envVars:
+      - key: POSTGRES_URL
+        fromDatabase:
+          name: ponder-db
+          property: connectionString
+${ponderConfig.networks
+  .map(
+    (n) => `      - key: PONDER_RPC_URL_${n.chainId}
+        sync: false`
+  )
+  .join("\n")}
+
+databases:
+  - name: ponder-db
+    postgresMajorVersion: 14
+  `;
+  (0, import_node_fs.writeFileSync)(
+    import_node_path.default.join(ponderRootDir, "render.yaml"),
+    import_prettier.default.format(renderYaml, { parser: "yaml" })
+  );
+  console.log(
+    import_chalk.default.bold.cyanBright("[create-ponder] ") +
+      `Installing using ${packageManager}`
+  );
+  (0, import_node_child_process.execSync)(`${packageManager} install`, {
+    cwd: ponderRootDir,
+    stdio: "inherit",
+  });
+  console.log(
+    import_chalk.default.bold.cyanBright("[create-ponder] ") +
+      `Generating types`
+  );
+  (0, import_node_child_process.execSync)(
+    `${packageManager} run  --silent codegen`,
+    {
+      cwd: ponderRootDir,
+      stdio: "inherit",
+    }
+  );
+  console.log(
+    import_chalk.default.bold.cyanBright("[create-ponder] ") +
+      import_chalk.default.bold.greenBright("Done! ") +
+      `To get started: ${import_chalk.default.bold.yellowBright(
+        `cd ${import_node_path.default.relative(
+          ".",
+          ponderRootDir
+        )} && ${packageManager} run dev`
+      )}`
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    run,
+  });

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "create-ponder",
+  "version": "0.0.1",
+  "description": "Tool to bootstrap a Ponder project",
+  "license": "MIT",
+  "author": "olias.eth",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "create-ponder": "./dist/bin/create-ponder"
+  },
+  "dependencies": {
+    "@ethersproject/abi": "^5.6.4",
+    "@ethersproject/providers": "^5.6.8",
+    "chalk": "4",
+    "commander": "^9.4.0",
+    "ethers": "^5.6.9",
+    "execa": "5",
+    "node-fetch": ">=2.6.7",
+    "prettier": "^2.6.2",
+    "yaml": "^2.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^18.7.8",
+    "@types/node-fetch": "2",
+    "@types/prettier": "^2.7.1",
+    "esbuild": "^0.15.2",
+    "tsconfig-replace-paths": "^0.0.11",
+    "typescript": "^4.5.5"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "lint": "(tsc || exit 0) && eslint src",
+    "format": "prettier src --write",
+    "replace-paths": "tsconfig-replace-paths --src src",
+    "esbuild": "esbuild `find src \\( -name '*.ts' \\)` --platform=node --format=cjs --outdir=dist && $npm_execpath run replace-paths",
+    "build": "$npm_execpath run clean && $npm_execpath run esbuild && mv dist/bin/create-ponder.js dist/bin/create-ponder",
+    "format-dist": "prettier dist --write --loglevel warn",
+    "prerelease": "$npm_execpath run build && $npm_execpath run format-dist",
+    "release": "$npm_execpath run prerelease && VERSION=$($npm_execpath version patch) && $npm_execpath publish && git add ./package.json && git commit -m \"release(create-ponder): $VERSION\""
+  }
+}