create-ponder 0.0.77 → 0.0.79

package/src/index.ts

@@ -0,0 +1,244 @@
+import type { Abi, AbiEvent } from "abitype";
+import { execSync } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import pico from "picocolors";
+import prettier from "prettier";
+
+import { CreatePonderOptions, TemplateKind } from "@/common";
+import { getPackageManager } from "@/helpers/getPackageManager";
+import { tryGitInit } from "@/helpers/git";
+import { fromBasic } from "@/templates/basic";
+import { fromEtherscan } from "@/templates/etherscan";
+import { fromSubgraphId } from "@/templates/subgraphId";
+import { fromSubgraphRepo } from "@/templates/subgraphRepo";
+
+export type Network = {
+  name: string;
+  chainId: number;
+  rpcUrl: string;
+};
+
+export type Contract = {
+  name: string;
+  network: string;
+  abi: string;
+  address: string;
+  startBlock?: number;
+};
+
+export type PartialConfig = {
+  database?: {
+    kind: string;
+  };
+  networks: Network[];
+  contracts: Contract[];
+};
+
+export const run = async (
+  options: CreatePonderOptions,
+  overrides: { installCommand?: string } = {}
+) => {
+  const { rootDir } = options;
+
+  // Create required directories.
+  mkdirSync(path.join(rootDir, "abis"), { recursive: true });
+  mkdirSync(path.join(rootDir, "src"), { recursive: true });
+
+  let config: PartialConfig;
+
+  console.log(
+    `\nCreating a new Ponder app in ${pico.bold(pico.green(rootDir))}.`
+  );
+
+  switch (options.template?.kind) {
+    case TemplateKind.ETHERSCAN: {
+      console.log(`\nUsing ${pico.cyan("Etherscan contract link")} template.`);
+      config = await fromEtherscan({
+        rootDir,
+        etherscanLink: options.template.link,
+        etherscanApiKey: options.etherscanApiKey,
+      });
+      break;
+    }
+    case TemplateKind.SUBGRAPH_ID: {
+      console.log(`\nUsing ${pico.cyan("Subgraph ID")} template.`);
+      config = await fromSubgraphId({
+        rootDir,
+        subgraphId: options.template.id,
+      });
+      break;
+    }
+    case TemplateKind.SUBGRAPH_REPO: {
+      console.log(`\nUsing ${pico.cyan("Subgraph repository")} template.`);
+
+      config = fromSubgraphRepo({
+        rootDir,
+        subgraphPath: options.template.path,
+      });
+      break;
+    }
+    default: {
+      config = fromBasic({ rootDir });
+      break;
+    }
+  }
+
+  // Write the handler ts files.
+  config.contracts.forEach((contract) => {
+    let abi: Abi;
+    if (Array.isArray(contract.abi)) {
+      // If it's an array of ABIs, use the 2nd one (the implementation ABI).
+      const abiString = readFileSync(path.join(rootDir, contract.abi[1]), {
+        encoding: "utf-8",
+      });
+      abi = JSON.parse(abiString);
+    } else {
+      const abiString = readFileSync(path.join(rootDir, contract.abi), {
+        encoding: "utf-8",
+      });
+      abi = JSON.parse(abiString);
+    }
+
+    const abiEvents = abi.filter(
+      (item): item is AbiEvent => item.type === "event"
+    );
+
+    const eventNamesToWrite = abiEvents.map((event) => event.name).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")}
+    `;
+
+    writeFileSync(
+      path.join(rootDir, `./src/${contract.name}.ts`),
+      prettier.format(handlerFileContents, { parser: "typescript" })
+    );
+  });
+
+  // Write the ponder.config.ts file.
+  const finalConfig = `
+    import type { Config } from "@ponder/core";
+
+    export const config: Config = {
+      networks: ${JSON.stringify(config.networks).replaceAll(
+        /"process.env.PONDER_RPC_URL_(.*?)"/g,
+        "process.env.PONDER_RPC_URL_$1"
+      )},
+      contracts: ${JSON.stringify(config.contracts)},
+    };
+  `;
+
+  writeFileSync(
+    path.join(rootDir, "ponder.config.ts"),
+    prettier.format(finalConfig, { parser: "babel" })
+  );
+
+  // Write the .env.local file.
+  const uniqueChainIds = Array.from(
+    new Set(config.networks.map((n) => n.chainId))
+  );
+  const envLocal = `${uniqueChainIds.map(
+    (chainId) => `PONDER_RPC_URL_${chainId}=""\n`
+  )}`;
+  writeFileSync(path.join(rootDir, ".env.local"), envLocal);
+
+  // Write the package.json file.
+  const packageJson = `
+    {
+      "private": true,
+      "scripts": {
+        "dev": "ponder dev",
+        "start": "ponder start",
+        "codegen": "ponder codegen"
+      },
+      "dependencies": {
+        "@ponder/core": "latest"
+      },
+      "devDependencies": {
+        "@types/node": "^18.11.18",
+        "abitype": "^0.8.11",
+        "typescript": "^5.1.3",
+        "viem": "^1.2.6"
+      }
+    }
+  `;
+  writeFileSync(
+    path.join(rootDir, "package.json"),
+    prettier.format(packageJson, { parser: "json" })
+  );
+
+  // Write the tsconfig.json file.
+  const tsConfig = `
+    {
+      "compilerOptions": {
+        "target": "ESNext",
+        "module": "ESNext",
+        "moduleResolution": "node",
+        "resolveJsonModule": true,
+        "esModuleInterop": true,
+        "strict": true,
+        "rootDir": ".",
+        "paths": {
+          "@/generated": ["./generated/index.ts"]
+        }
+      },
+      "include": ["./**/*.ts"],
+      "exclude": ["node_modules"]
+    }
+  `;
+  writeFileSync(
+    path.join(rootDir, "tsconfig.json"),
+    prettier.format(tsConfig, { parser: "json" })
+  );
+
+  // Write the .gitignore file.
+  writeFileSync(
+    path.join(rootDir, ".gitignore"),
+    `node_modules/\n.DS_Store\n\n.env.local\n.ponder/\ngenerated/`
+  );
+
+  const packageManager = await getPackageManager();
+
+  // Install packages.
+  console.log(pico.bold(`\nInstalling with ${packageManager}.`));
+
+  const installCommand = overrides.installCommand
+    ? overrides.installCommand
+    : `${packageManager} ${
+        packageManager === "npm" ? "--quiet" : "--silent"
+      } install`;
+
+  execSync(installCommand, {
+    cwd: rootDir,
+    stdio: "inherit",
+  });
+
+  // Intialize git repository
+  process.chdir(rootDir);
+  tryGitInit(rootDir);
+  console.log(`\nInitialized a git repository.`);
+
+  // Run codegen.
+  const runCommand = `${
+    packageManager === "npm" ? `npm --quiet run` : `${packageManager} --silent`
+  } codegen`;
+  execSync(runCommand, {
+    cwd: rootDir,
+    stdio: "inherit",
+  });
+  console.log(`\nGenerated types.`);
+
+  console.log(
+    pico.green("\nSuccess! ") + `Created ${options.projectName} at ${rootDir}`
+  );
+};

package/src/templates/basic.ts

@@ -0,0 +1,60 @@
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+import prettier from "prettier";
+
+import type { PartialConfig } from "@/index";
+
+export const fromBasic = ({ rootDir }: { rootDir: string }) => {
+  const abiFileContents = `[]`;
+
+  const abiRelativePath = "./abis/ExampleContract.json";
+  const abiAbsolutePath = path.join(rootDir, abiRelativePath);
+  writeFileSync(abiAbsolutePath, abiFileContents);
+
+  const schemaGraphqlFileContents = `
+    # The entity types defined below map to database tables.
+    # The functions you write as event handlers inside the \`src/\` directory are responsible for creating and updating records in those tables.
+    # Your schema will be more flexible and powerful if it accurately models the logical relationships in your application's domain.
+    # Visit the [documentation](https://ponder.sh/guides/design-your-schema) or the [\`examples/\`](https://github.com/0xOlias/ponder/tree/main/examples) directory for further guidance on designing your schema.
+      
+    type ExampleToken @entity {
+      id: String!
+      tokenId: Int!
+      trait: TokenTrait!
+    }
+    
+    enum TokenTrait {
+      GOOD
+      BAD
+    }
+`;
+
+  // Generate the schema.graphql file.
+  const ponderSchemaFilePath = path.join(rootDir, "schema.graphql");
+  writeFileSync(
+    ponderSchemaFilePath,
+    prettier.format(schemaGraphqlFileContents, { parser: "graphql" })
+  );
+
+  // Build the partial ponder config.
+  const config: PartialConfig = {
+    networks: [
+      {
+        name: "mainnet",
+        chainId: 1,
+        rpcUrl: `process.env.PONDER_RPC_URL_1`,
+      },
+    ],
+    contracts: [
+      {
+        name: "ExampleContract",
+        network: "mainnet",
+        address: "0x0",
+        abi: abiRelativePath,
+        startBlock: 1234567,
+      },
+    ],
+  };
+
+  return config;
+};

package/src/templates/etherscan.ts

@@ -0,0 +1,276 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+import fetch from "node-fetch";
+import prettier from "prettier";
+import type { PartialConfig } from "src/index";
+
+import { getNetworkByEtherscanHostname } from "@/helpers/getEtherscanChainId";
+import { wait } from "@/helpers/wait";
+
+export const fromEtherscan = async ({
+  rootDir,
+  etherscanLink,
+  etherscanApiKey,
+}: {
+  rootDir: string;
+  etherscanLink: string;
+  etherscanApiKey?: string;
+}) => {
+  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];
+
+  let blockNumber: number | undefined = undefined;
+
+  try {
+    const txHash = await getContractCreationTxn(
+      contractAddress,
+      apiUrl,
+      apiKey
+    );
+
+    if (!apiKey) {
+      console.log("\n(1/n) Waiting 5 seconds for Etherscan API rate limit");
+      await wait(5000);
+    }
+    const contractCreationBlockNumber = await getTxBlockNumber(
+      txHash,
+      apiUrl,
+      apiKey
+    );
+
+    blockNumber = contractCreationBlockNumber;
+  } catch (error) {
+    // Do nothing, blockNumber won't be set.
+  }
+
+  if (!apiKey) {
+    console.log("(2/n) Waiting 5 seconds for Etherscan API rate limit");
+    await wait(5000);
+  }
+  const abis: { abi: string; contractName: string }[] = [];
+  const { abi, contractName } = await getContractAbiAndName(
+    contractAddress,
+    apiUrl,
+    apiKey
+  );
+  abis.push({ abi, contractName });
+
+  // If the contract is an EIP-1967 proxy, get the implementation contract ABIs.
+  if (
+    (JSON.parse(abi) as any[]).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");
+      await wait(5000);
+    }
+    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`
+        );
+        await wait(5000);
+      }
+      const { abi, contractName } = await getContractAbiAndName(
+        implAddress,
+        apiUrl,
+        apiKey
+      );
+
+      abis.push({
+        abi,
+        contractName: `${contractName}_${implAddress.slice(0, 6)}`,
+      });
+    }
+  }
+
+  // Write ABI files.
+  let abiConfig: any;
+  abis.forEach(({ abi, contractName }) => {
+    const abiRelativePath = `./abis/${contractName}.json`;
+    const abiAbsolutePath = path.join(rootDir, abiRelativePath);
+    writeFileSync(abiAbsolutePath, prettier.format(abi, { parser: "json" }));
+
+    if (abis.length === 1) {
+      abiConfig = abiRelativePath;
+    } else {
+      abiConfig ||= [];
+      abiConfig.push(abiRelativePath);
+    }
+  });
+
+  const schemaGraphqlFileContents = `
+    type ExampleEntity @entity {
+      id: String!
+      name: String!
+    }
+  `;
+
+  // Generate the schema.graphql file.
+  const ponderSchemaFilePath = path.join(rootDir, "schema.graphql");
+  writeFileSync(
+    ponderSchemaFilePath,
+    prettier.format(schemaGraphqlFileContents, { parser: "graphql" })
+  );
+
+  // Build and return the partial ponder config.
+  const config: PartialConfig = {
+    networks: [
+      {
+        name: name,
+        chainId: chainId,
+        rpcUrl: `process.env.PONDER_RPC_URL_${chainId}`,
+      },
+    ],
+    contracts: [
+      {
+        name: contractName,
+        network: name,
+        abi: abiConfig,
+        address: contractAddress,
+        startBlock: blockNumber ?? undefined,
+      },
+    ],
+  };
+
+  return config;
+};
+
+const fetchEtherscan = async (url: string) => {
+  const maxRetries = 5;
+  let retryCount = 0;
+
+  while (retryCount <= maxRetries) {
+    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++;
+      if (retryCount > maxRetries) {
+        throw new Error(`Max retries reached: ${(error as Error).message}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+};
+
+const getContractCreationTxn = async (
+  contractAddress: string,
+  apiUrl: string,
+  apiKey?: string
+) => {
+  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 as string;
+};
+
+const getTxBlockNumber = async (
+  txHash: string,
+  apiUrl: string,
+  apiKey?: string
+) => {
+  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 as string;
+  return parseInt(hexBlockNumber.slice(2), 16);
+};
+
+const getContractAbiAndName = async (
+  contractAddress: string,
+  apiUrl: string,
+  apiKey?: string
+) => {
+  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 as string;
+  const contractName = data.result[0].ContractName as string;
+
+  return { abi, contractName };
+};
+
+const getProxyImplementationAddresses = async ({
+  contractAddress,
+  apiUrl,
+  fromBlock,
+  apiKey,
+}: {
+  contractAddress: string;
+  apiUrl: string;
+  fromBlock?: number;
+  apiKey?: string;
+}) => {
+  const searchParams = new URLSearchParams({
+    module: "logs",
+    action: "getLogs",
+    address: contractAddress,
+    fromBlock: fromBlock ? String(fromBlock) : "0",
+    toBlock: "latest",
+    topic0:
+      "0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b",
+  });
+  if (apiKey) searchParams.append("apikey", apiKey);
+  const data = await fetchEtherscan(`${apiUrl}?${searchParams.toString()}`);
+
+  const logs = data.result;
+
+  const implAddresses = logs.map((log: any) => {
+    if (log.topics[0] && log.topics[1]) {
+      // If there are two topics, this is a compliant EIP-1967 proxy and the address is indexed.
+      return `0x${log.topics[1].slice(26)}`;
+    } else {
+      // If there's only one topic, this might be a non-compliant proxy and the address is not indexed.
+      // USDC is an example of this: https://etherscan.io/address/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48#code#L118
+      return `0x${log.data.slice(26)}`;
+    }
+  }) as string[];
+
+  return { implAddresses };
+};

package/src/templates/subgraphId.ts

@@ -0,0 +1,97 @@
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+import fetch from "node-fetch";
+import prettier from "prettier";
+import type { Contract, Network, PartialConfig } from "src/index";
+import { parse } from "yaml";
+
+import { getGraphProtocolChainId } from "@/helpers/getGraphProtocolChainId";
+import { validateGraphProtocolSource } from "@/helpers/validateGraphProtocolSource";
+
+const fetchIpfsFile = async (cid: string) => {
+  const url = `https://ipfs.network.thegraph.com/api/v0/cat?arg=${cid}`;
+  const response = await fetch(url);
+  const contentRaw = await response.text();
+  return contentRaw;
+};
+
+export const fromSubgraphId = async ({
+  rootDir,
+  subgraphId,
+}: {
+  rootDir: string;
+  subgraphId: string;
+}) => {
+  const ponderNetworks: Network[] = [];
+  let ponderContracts: Contract[] = [];
+
+  // Fetch the manifest file.
+  const manifestRaw = await fetchIpfsFile(subgraphId);
+  const manifest = parse(manifestRaw);
+
+  // Fetch and write the schema.graphql file.
+  const schemaCid = manifest.schema.file["/"].slice(6);
+  const schemaRaw = await fetchIpfsFile(schemaCid);
+  const schemaCleaned = schemaRaw
+    .replaceAll(": ID!", ": String!")
+    .replaceAll("BigDecimal", "Float");
+  const ponderSchemaFilePath = path.join(rootDir, "schema.graphql");
+  writeFileSync(
+    ponderSchemaFilePath,
+    prettier.format(schemaCleaned, { parser: "graphql" })
+  );
+
+  const dataSources = (manifest.dataSources as unknown[]).map(
+    validateGraphProtocolSource
+  );
+
+  // Fetch and write all referenced ABIs.
+  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 = path.join(rootDir, `./abis/${abi.name}.json`);
+      writeFileSync(abiPath, prettier.format(abiContent, { parser: "json" }));
+    })
+  );
+
+  // Build the ponder sources.
+  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: chainId,
+        rpcUrl: `process.env.PONDER_RPC_URL_${chainId}`,
+      });
+    }
+
+    const abiRelativePath = `./abis/${source.source.abi}.json`;
+
+    return <Contract>{
+      name: source.name,
+      network: network,
+      address: source.source.address,
+      abi: abiRelativePath,
+      startBlock: source.source.startBlock,
+    };
+  });
+
+  // Build the partial ponder config.
+  const config: PartialConfig = {
+    networks: ponderNetworks,
+    contracts: ponderContracts,
+  };
+
+  return config;
+};