create-ponder 0.6.25 → 0.7.0

package/README.md

@@ -92,15 +92,12 @@ The `ponder.schema.ts` file contains the database schema, and defines the shape
 ```ts
 // ponder.schema.ts
 
-import { createSchema } from "@ponder/core";
-
-export default createSchema((p) => ({
-  EnsName: p.createTable({
-    id: p.string(),
-    name: p.string(),
-    owner: p.string(),
-    registeredAt: p.int(),
-  }),
+import { onchainTable } from "@ponder/core";
+
+export const ensName = onchainTable("ens_name", (t) => ({
+  name: p.text().primaryKey(),
+  owner: p.text().notNull(),
+  registeredAt: p.integer().notNull(),
 }));
 ```
 
@@ -112,18 +109,15 @@ Files in the `src/` directory contain **indexing functions**, which are TypeScri
 // src/BaseRegistrar.ts
 
 import { ponder } from "@/generated";
+import * as schema from "../ponder.schema";
 
 ponder.on("BaseRegistrar:NameRegistered", async ({ event, context }) => {
-  const { EnsName } = context.entities;
   const { name, owner } = event.params;
 
-  await EnsName.create({
-    id: `${name}-${owner}`,
-    data: {
-      name: name,
-      owner: owner,
-      registeredAt: event.block.timestamp,
-    },
+  await context.db.insert(schema.ensName).values({
+    name: name,
+    owner: owner,
+    registeredAt: event.block.timestamp,
   });
 });
 ```

package/dist/index.js

@@ -16,7 +16,7 @@ import { default as prompts } from "prompts";
 // package.json
 var package_default = {
   name: "create-ponder",
-  version: "0.6.25",
+  version: "0.7.0",
   type: "module",
   description: "A CLI tool to create Ponder apps",
   license: "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-ponder",
-  "version": "0.6.25",
+  "version": "0.7.0",
   "type": "module",
   "description": "A CLI tool to create Ponder apps",
   "license": "MIT",

package/templates/empty/ponder.schema.ts

@@ -1,8 +1,6 @@
-import { createSchema } from "@ponder/core";
+import { onchainTable } from "@ponder/core";
 
-export default createSchema((p) => ({
-  Example: p.createTable({
-    id: p.string(),
-    name: p.string().optional(),
-  }),
+export const example = onchainTable("example", (t) => ({
+  id: t.text().primaryKey(),
+  name: t.text(),
 }));

package/templates/etherscan/ponder.schema.ts

@@ -1,8 +1,6 @@
-import { createSchema } from "@ponder/core";
+import { onchainTable } from "@ponder/core";
 
-export default createSchema((p) => ({
-  Example: p.createTable({
-    id: p.string(),
-    name: p.string().optional(),
-  }),
+export const example = onchainTable("example", (t) => ({
+  id: t.text().primaryKey(),
+  name: t.text(),
 }));

package/templates/feature-api-functions/package.json

@@ -7,11 +7,13 @@
     "start": "ponder start",
     "codegen": "ponder codegen",
     "serve": "ponder serve",
+    "generate": "drizzle-kit generate --dialect postgresql --schema ./ponder.schema.ts --out migrations",
     "lint": "eslint .",
     "typecheck": "tsc"
   },
   "dependencies": {
     "@ponder/core": "workspace:*",
+    "drizzle-kit": "0.25.0",
     "hono": "^4.5.0",
     "viem": "^2.21.3"
   },

package/templates/feature-api-functions/ponder-env.d.ts

@@ -7,7 +7,7 @@ declare module "@/generated" {
   import type { Virtual } from "@ponder/core";
 
   type config = typeof import("./ponder.config.ts").default;
-  type schema = typeof import("./ponder.schema.ts").default;
+  type schema = typeof import("./ponder.schema.ts");
 
   export const ponder: Virtual.Registry<config, schema>;
 
@@ -21,8 +21,7 @@ declare module "@/generated" {
     schema,
     name
   >;
-  export type ApiContext = Virtual.Drizzle<schema>;
+  export type ApiContext = Virtual.ApiContext<schema>;
   export type IndexingFunctionArgs<name extends EventNames = EventNames> =
     Virtual.IndexingFunctionArgs<config, schema, name>;
-  export type Schema = Virtual.Schema<schema>;
 }

package/templates/feature-api-functions/ponder.schema.ts

@@ -1,50 +1,41 @@
-import { createSchema } from "@ponder/core";
+import { index, onchainTable, primaryKey } from "@ponder/core";
 
-export default createSchema((p) => ({
-  Account: p.createTable({
-    id: p.hex(),
-    balance: p.bigint(),
-    isOwner: p.boolean(),
+export const account = onchainTable("account", (p) => ({
+  address: p.hex().primaryKey(),
+  balance: p.bigint().notNull(),
+  isOwner: p.boolean().notNull(),
+}));
 
-    allowances: p.many("Allowance.ownerId"),
-    approvalOwnerEvents: p.many("ApprovalEvent.ownerId"),
-    approvalSpenderEvents: p.many("ApprovalEvent.spenderId"),
-    transferFromEvents: p.many("TransferEvent.fromId"),
-    transferToEvents: p.many("TransferEvent.toId"),
+export const allowance = onchainTable(
+  "allowance",
+  (p) => ({
+    owner: p.hex(),
+    spender: p.hex(),
+    amount: p.bigint().notNull(),
   }),
-  Allowance: p.createTable({
-    id: p.string(),
-    amount: p.bigint(),
-
-    ownerId: p.hex().references("Account.id"),
-    spenderId: p.hex().references("Account.id"),
-
-    owner: p.one("ownerId"),
-    spender: p.one("spenderId"),
+  (table) => ({
+    pk: primaryKey({ columns: [table.owner, table.spender] }),
   }),
-  TransferEvent: p.createTable(
-    {
-      id: p.string(),
-      amount: p.bigint(),
-      timestamp: p.int(),
-
-      fromId: p.hex().references("Account.id"),
-      toId: p.hex().references("Account.id"),
-
-      from: p.one("fromId"),
-      to: p.one("toId"),
-    },
-    { fromIdIndex: p.index("fromId") },
-  ),
-  ApprovalEvent: p.createTable({
-    id: p.string(),
-    amount: p.bigint(),
-    timestamp: p.int(),
-
-    ownerId: p.hex().references("Account.id"),
-    spenderId: p.hex().references("Account.id"),
-
-    owner: p.one("ownerId"),
-    spender: p.one("spenderId"),
+);
+
+export const transferEvent = onchainTable(
+  "transfer_event",
+  (p) => ({
+    id: p.text().primaryKey(),
+    amount: p.bigint().notNull(),
+    timestamp: p.integer().notNull(),
+    from: p.hex().notNull(),
+    to: p.hex().notNull(),
+  }),
+  (table) => ({
+    fromIdx: index("from_index").on(table.from),
   }),
+);
+
+export const approvalEvent = onchainTable("approval_event", (p) => ({
+  id: p.text().primaryKey(),
+  amount: p.bigint().notNull(),
+  timestamp: p.integer().notNull(),
+  owner: p.hex().notNull(),
+  spender: p.hex().notNull(),
 }));

package/templates/feature-api-functions/src/api/index.ts

@@ -1,13 +1,12 @@
 import { ponder } from "@/generated";
 import { count, desc, eq, graphql, or, replaceBigInts } from "@ponder/core";
 import { formatEther, getAddress } from "viem";
+import { account, transferEvent } from "../../ponder.schema";
 
 ponder.use("/graphql", graphql());
 
 ponder.get("/count", async (c) => {
-  const result = await c.db
-    .select({ count: count() })
-    .from(c.tables.TransferEvent);
+  const result = await c.db.select({ count: count() }).from(transferEvent);
 
   if (result.length === 0) return c.text("0");
   return c.text(String(result[0]!.count));
@@ -15,31 +14,27 @@ ponder.get("/count", async (c) => {
 
 ponder.get("/count/:address", async (c) => {
   const account = getAddress(c.req.param("address"));
-  const { TransferEvent } = c.tables;
 
   const result = await c.db
     .select({ count: count() })
-    .from(c.tables.TransferEvent)
-    .where(
-      or(eq(TransferEvent.fromId, account), eq(TransferEvent.toId, account)),
-    );
+    .from(transferEvent)
+    .where(or(eq(transferEvent.from, account), eq(transferEvent.to, account)));
 
   if (result.length === 0) return c.text("0");
   return c.text(String(result[0]!.count));
 });
 
 ponder.get("/whale-transfers", async (c) => {
-  const { TransferEvent, Account } = c.tables;
-
   // Top 10 transfers from whale accounts
   const result = await c.db
     .select({
-      amount: TransferEvent.amount,
-      senderBalance: Account.balance,
+      sender: account.address,
+      senderBalance: account.balance,
+      amount: transferEvent.amount,
     })
-    .from(TransferEvent)
-    .innerJoin(Account, eq(TransferEvent.fromId, Account.id))
-    .orderBy(desc(Account.balance))
+    .from(transferEvent)
+    .innerJoin(account, eq(transferEvent.from, account.address))
+    .orderBy(desc(account.balance))
     .limit(10);
 
   if (result.length === 0) return c.text("Not found", 500);

package/templates/feature-api-functions/src/index.ts

@@ -1,70 +1,63 @@
 import { ponder } from "@/generated";
+import {
+  account,
+  allowance,
+  approvalEvent,
+  transferEvent,
+} from "../ponder.schema";
 
 ponder.on("ERC20:Transfer", async ({ event, context }) => {
-  const { Account, TransferEvent } = context.db;
-
-  // Create an Account for the sender, or update the balance if it already exists.
-  await Account.upsert({
-    id: event.args.from,
-    create: {
-      balance: BigInt(0),
+  await context.db
+    .insert(account)
+    .values({
+      address: event.args.from,
+      balance: 0n,
       isOwner: false,
-    },
-    update: ({ current }) => ({
-      balance: current.balance - event.args.amount,
-    }),
-  });
-
-  // Create an Account for the recipient, or update the balance if it already exists.
-  await Account.upsert({
-    id: event.args.to,
-    create: {
-      balance: event.args.amount,
+    })
+    .onConflictDoUpdate((row) => ({
+      balance: row.balance - event.args.amount,
+    }));
+
+  await context.db
+    .insert(account)
+    .values({
+      address: event.args.to,
+      balance: 0n,
       isOwner: false,
-    },
-    update: ({ current }) => ({
-      balance: current.balance + event.args.amount,
-    }),
-  });
+    })
+    .onConflictDoUpdate((row) => ({
+      balance: row.balance + event.args.amount,
+    }));
 
-  // Create a TransferEvent.
-  await TransferEvent.create({
+  // add row to "transfer_event".
+  await context.db.insert(transferEvent).values({
     id: event.log.id,
-    data: {
-      fromId: event.args.from,
-      toId: event.args.to,
-      amount: event.args.amount,
-      timestamp: Number(event.block.timestamp),
-    },
+    amount: event.args.amount,
+    timestamp: Number(event.block.timestamp),
+    from: event.args.from,
+    to: event.args.to,
   });
 });
 
 ponder.on("ERC20:Approval", async ({ event, context }) => {
-  const { Allowance, ApprovalEvent } = context.db;
-
-  const allowanceId = `${event.args.owner}-${event.args.spender}`;
-
-  // Create or update the Allowance.
-  await Allowance.upsert({
-    id: allowanceId,
-    create: {
-      ownerId: event.args.owner,
-      spenderId: event.args.spender,
+  // upsert "allowance".
+  await context.db
+    .insert(allowance)
+    .values({
+      spender: event.args.spender,
+      owner: event.args.owner,
       amount: event.args.amount,
-    },
-    update: {
+    })
+    .onConflictDoUpdate({
       amount: event.args.amount,
-    },
-  });
+    });
 
-  // Create an ApprovalEvent.
-  await ApprovalEvent.create({
+  // add row to "approval_event".
+  await context.db.insert(approvalEvent).values({
     id: event.log.id,
-    data: {
-      ownerId: event.args.owner,
-      spenderId: event.args.spender,
-      amount: event.args.amount,
-      timestamp: Number(event.block.timestamp),
-    },
+    amount: event.args.amount,
+    timestamp: Number(event.block.timestamp),
+    owner: event.args.owner,
+    spender: event.args.spender,
   });
 });

package/templates/feature-blocks/ponder-env.d.ts

@@ -7,7 +7,7 @@ declare module "@/generated" {
   import type { Virtual } from "@ponder/core";
 
   type config = typeof import("./ponder.config.ts").default;
-  type schema = typeof import("./ponder.schema.ts").default;
+  type schema = typeof import("./ponder.schema.ts");
 
   export const ponder: Virtual.Registry<config, schema>;
 
@@ -21,8 +21,7 @@ declare module "@/generated" {
     schema,
     name
   >;
-  export type ApiContext = Virtual.Drizzle<schema>;
+  export type ApiContext = Virtual.ApiContext<schema>;
   export type IndexingFunctionArgs<name extends EventNames = EventNames> =
     Virtual.IndexingFunctionArgs<config, schema, name>;
-  export type Schema = Virtual.Schema<schema>;
 }

package/templates/feature-blocks/ponder.config.ts

@@ -1,5 +1,5 @@
 import { createConfig } from "@ponder/core";
-import { http, Abi } from "viem";
+import { http } from "viem";
 
 export default createConfig({
   networks: {

package/templates/feature-blocks/ponder.schema.ts

@@ -1,8 +1,6 @@
-import { createSchema } from "@ponder/core";
+import { onchainTable } from "@ponder/core";
 
-export default createSchema((p) => ({
-  ChainlinkPrice: p.createTable({
-    id: p.bigint(),
-    price: p.float(),
-  }),
+export const chainlinkPrice = onchainTable("chainlink_price", (t) => ({
+  timestamp: t.bigint().primaryKey(),
+  price: t.doublePrecision().notNull(),
 }));

package/templates/feature-blocks/src/index.ts

@@ -1,5 +1,6 @@
 import { ponder } from "@/generated";
 import { parseAbi } from "viem";
+import * as schema from "../ponder.schema";
 
 ponder.on("ChainlinkPriceOracle:block", async ({ event, context }) => {
   const price = await context.client.readContract({
@@ -8,10 +9,8 @@ ponder.on("ChainlinkPriceOracle:block", async ({ event, context }) => {
     functionName: "latestAnswer",
   });
 
-  await context.db.ChainlinkPrice.create({
-    id: event.block.timestamp,
-    data: {
-      price: Number(price) / 10 ** 8,
-    },
+  await context.db.insert(schema.chainlinkPrice).values({
+    timestamp: event.block.timestamp,
+    price: Number(price) / 10 ** 8,
   });
 });

package/templates/feature-call-traces/ponder-env.d.ts

@@ -7,7 +7,7 @@ declare module "@/generated" {
   import type { Virtual } from "@ponder/core";
 
   type config = typeof import("./ponder.config.ts").default;
-  type schema = typeof import("./ponder.schema.ts").default;
+  type schema = typeof import("./ponder.schema.ts");
 
   export const ponder: Virtual.Registry<config, schema>;
 
@@ -21,8 +21,7 @@ declare module "@/generated" {
     schema,
     name
   >;
-  export type ApiContext = Virtual.Drizzle<schema>;
+  export type ApiContext = Virtual.ApiContext<schema>;
   export type IndexingFunctionArgs<name extends EventNames = EventNames> =
     Virtual.IndexingFunctionArgs<config, schema, name>;
-  export type Schema = Virtual.Schema<schema>;
 }

package/templates/feature-call-traces/ponder.schema.ts

@@ -1,11 +1,9 @@
-import { createSchema } from "@ponder/core";
+import { onchainTable } from "@ponder/core";
 
-export default createSchema((p) => ({
-  multicalls: p.createTable({
-    id: p.hex(),
-    gasUsed: p.bigint(),
-    bytes: p.int(),
-    successfulCalls: p.int(),
-    failedCalls: p.int(),
-  }),
+export const multicall = onchainTable("multicall", (t) => ({
+  from: t.hex().primaryKey(),
+  gasUsed: t.bigint().notNull(),
+  bytes: t.integer().notNull(),
+  successfulCalls: t.integer().notNull(),
+  failedCalls: t.integer().notNull(),
 }));

package/templates/feature-call-traces/src/index.ts

@@ -1,9 +1,11 @@
 import { ponder } from "@/generated";
+import * as schema from "../ponder.schema";
 
 ponder.on("multicall3.aggregate3()", async ({ event, context }) => {
-  await context.db.multicalls.upsert({
-    id: event.trace.from,
-    create: {
+  await context.db
+    .insert(schema.multicall)
+    .values({
+      from: event.trace.from,
       gasUsed: event.trace.gasUsed,
       bytes: event.args[0].reduce<number>(
         (acc, cur) => acc + Math.ceil((cur.callData.length - 2) / 8),
@@ -13,21 +15,20 @@ ponder.on("multicall3.aggregate3()", async ({ event, context }) => {
         .length,
       failedCalls: event.result.filter(({ success }) => success === false)
         .length,
-    },
-    update: ({ current }) => ({
-      gasUsed: current.gasUsed + event.trace.gasUsed,
+    })
+    .onConflictDoUpdate((row) => ({
+      gasUsed: row.gasUsed + event.trace.gasUsed,
       bytes:
-        current.bytes +
+        row.bytes +
         event.args[0].reduce<number>(
           (acc, cur) => acc + Math.ceil((cur.callData.length - 2) / 8),
           0,
         ),
       successfulCalls:
-        current.successfulCalls +
+        row.successfulCalls +
         event.result.filter(({ success }) => success === true).length,
       failedCalls:
-        current.failedCalls +
+        row.failedCalls +
         event.result.filter(({ success }) => success === false).length,
-    }),
-  });
+    }));
 });

package/templates/feature-factory/ponder-env.d.ts

@@ -7,7 +7,7 @@ declare module "@/generated" {
   import type { Virtual } from "@ponder/core";
 
   type config = typeof import("./ponder.config.ts").default;
-  type schema = typeof import("./ponder.schema.ts").default;
+  type schema = typeof import("./ponder.schema.ts");
 
   export const ponder: Virtual.Registry<config, schema>;
 
@@ -21,8 +21,7 @@ declare module "@/generated" {
     schema,
     name
   >;
-  export type ApiContext = Virtual.Drizzle<schema>;
+  export type ApiContext = Virtual.ApiContext<schema>;
   export type IndexingFunctionArgs<name extends EventNames = EventNames> =
     Virtual.IndexingFunctionArgs<config, schema, name>;
-  export type Schema = Virtual.Schema<schema>;
 }

package/templates/feature-factory/ponder.schema.ts

@@ -1,7 +1,5 @@
-import { createSchema } from "@ponder/core";
+import { onchainTable } from "@ponder/core";
 
-export default createSchema((p) => ({
-  LlamaCoreInstance: p.createTable({
-    id: p.string(),
-  }),
+export const llama = onchainTable("llama", (t) => ({
+  id: t.text().primaryKey(),
 }));

package/templates/feature-filter/ponder-env.d.ts

@@ -7,7 +7,7 @@ declare module "@/generated" {
   import type { Virtual } from "@ponder/core";
 
   type config = typeof import("./ponder.config.ts").default;
-  type schema = typeof import("./ponder.schema.ts").default;
+  type schema = typeof import("./ponder.schema.ts");
 
   export const ponder: Virtual.Registry<config, schema>;
 
@@ -21,8 +21,7 @@ declare module "@/generated" {
     schema,
     name
   >;
-  export type ApiContext = Virtual.Drizzle<schema>;
+  export type ApiContext = Virtual.ApiContext<schema>;
   export type IndexingFunctionArgs<name extends EventNames = EventNames> =
     Virtual.IndexingFunctionArgs<config, schema, name>;
-  export type Schema = Virtual.Schema<schema>;
 }

package/templates/feature-filter/ponder.schema.ts

@@ -1,9 +1,7 @@
-import { createSchema } from "@ponder/core";
+import { onchainTable } from "@ponder/core";
 
-export default createSchema((p) => ({
-  SwapEvent: p.createTable({
-    id: p.string(),
-    recipient: p.hex(),
-    payer: p.hex(),
-  }),
+export const swapEvent = onchainTable("swapEvent", (t) => ({
+  id: t.text().primaryKey(),
+  recipient: t.hex().notNull(),
+  payer: t.hex().notNull(),
 }));

package/templates/feature-filter/src/index.ts

@@ -1,13 +1,10 @@
 import { ponder } from "@/generated";
+import * as schema from "../ponder.schema";
 
 ponder.on("PrimitiveManager:Swap", async ({ event, context }) => {
-  const { SwapEvent } = context.db;
-
-  await SwapEvent.create({
+  await context.db.insert(schema.swapEvent).values({
     id: event.log.id,
-    data: {
-      payer: event.args.payer,
-      recipient: event.args.recipient,
-    },
+    payer: event.args.payer,
+    recipient: event.args.recipient,
   });
 });

package/templates/feature-multichain/ponder.schema.ts

@@ -1,8 +1,6 @@
-import { createSchema } from "@ponder/core";
+import { onchainTable } from "@ponder/core";
 
-export default createSchema((p) => ({
-  Account: p.createTable({
-    id: p.hex(),
-    balance: p.bigint(),
-  }),
+export const account = onchainTable("account", (t) => ({
+  address: t.hex().primaryKey(),
+  balance: t.bigint().notNull(),
 }));