create-ponder 0.6.24 → 0.7.0

package/templates/reference-erc4626/src/index.ts

@@ -1,95 +1,71 @@
 import { ponder } from "@/generated";
+import * as schema from "../ponder.schema";
 
 ponder.on("ERC4626: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),
-      isOwner: false,
-    },
-    update: ({ current }) => ({
-      balance: current.balance - event.args.amount,
-    }),
-  });
+  await context.db
+    .insert(schema.account)
+    .values({ address: event.args.from, balance: 0n })
+    .onConflictDoUpdate((row) => ({
+      balance: row.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,
-      isOwner: false,
-    },
-    update: ({ current }) => ({
-      balance: current.balance + event.args.amount,
-    }),
-  });
+  await context.db
+    .insert(schema.account)
+    .values({ address: event.args.to, balance: event.args.amount })
+    .onConflictDoUpdate((row) => ({
+      balance: row.balance + event.args.amount,
+    }));
 
   // Create a TransferEvent.
-  await TransferEvent.create({
+  await context.db.insert(schema.transferEvent).values({
     id: event.log.id,
-    data: {
-      fromId: event.args.from,
-      toId: event.args.to,
-      amount: event.args.amount,
-      timestamp: Number(event.block.timestamp),
-    },
+    from: event.args.from,
+    to: event.args.to,
+    amount: event.args.amount,
+    timestamp: Number(event.block.timestamp),
   });
 });
 
 ponder.on("ERC4626: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,
-      amount: event.args.amount,
-    },
-    update: {
+  await context.db
+    .insert(schema.allowance)
+    .values({
+      owner: event.args.owner,
+      spender: event.args.spender,
       amount: event.args.amount,
-    },
-  });
+    })
+    .onConflictDoUpdate({ amount: event.args.amount });
 
   // Create an ApprovalEvent.
-  await ApprovalEvent.create({
+  await context.db.insert(schema.approvalEvent).values({
     id: event.log.id,
-    data: {
-      ownerId: event.args.owner,
-      spenderId: event.args.spender,
-      amount: event.args.amount,
-      timestamp: Number(event.block.timestamp),
-    },
+    owner: event.args.owner,
+    spender: event.args.spender,
+    amount: event.args.amount,
+    timestamp: Number(event.block.timestamp),
   });
 });
 
 ponder.on("ERC4626:Deposit", async ({ event, context }) => {
-  await context.db.DepositEvent.create({
+  await context.db.insert(schema.depositEvent).values({
     id: event.log.id,
-    data: {
-      sender: event.args.caller,
-      receiver: event.args.owner,
-      assets: event.args.assets,
-      shares: event.args.shares,
-    },
+    sender: event.args.caller,
+    receiver: event.args.owner,
+    assets: event.args.assets,
+    shares: event.args.shares,
   });
 });
 
 ponder.on("ERC4626:Withdraw", async ({ event, context }) => {
-  await context.db.WithdrawEvent.create({
+  await context.db.insert(schema.withdrawalEvent).values({
     id: event.log.id,
-    data: {
-      sender: event.args.caller,
-      owner: event.args.owner,
-      receiver: event.args.receiver,
-      assets: event.args.assets,
-      shares: event.args.shares,
-    },
+    sender: event.args.caller,
+    owner: event.args.owner,
+    receiver: event.args.receiver,
+    assets: event.args.assets,
+    shares: event.args.shares,
   });
 });

package/templates/reference-erc721/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/reference-erc721/ponder.schema.ts

@@ -1,29 +1,18 @@
-import { createSchema } from "@ponder/core";
+import { onchainTable } from "@ponder/core";
 
-export default createSchema((p) => ({
-  Account: p.createTable({
-    id: p.hex(),
-    tokens: p.many("Token.ownerId"),
-
-    transferFromEvents: p.many("TransferEvent.fromId"),
-    transferToEvents: p.many("TransferEvent.toId"),
-  }),
-  Token: p.createTable({
-    id: p.bigint(),
-    ownerId: p.hex().references("Account.id"),
+export const account = onchainTable("account", (t) => ({
+  address: t.hex().primaryKey(),
+}));
 
-    owner: p.one("ownerId"),
-    transferEvents: p.many("TransferEvent.tokenId"),
-  }),
-  TransferEvent: p.createTable({
-    id: p.string(),
-    timestamp: p.int(),
-    fromId: p.hex().references("Account.id"),
-    toId: p.hex().references("Account.id"),
-    tokenId: p.bigint().references("Token.id"),
+export const token = onchainTable("token", (t) => ({
+  id: t.bigint().primaryKey(),
+  owner: t.hex().notNull(),
+}));
 
-    from: p.one("fromId"),
-    to: p.one("toId"),
-    token: p.one("tokenId"),
-  }),
+export const transferEvent = onchainTable("transfer_event", (t) => ({
+  id: t.text().primaryKey(),
+  timestamp: t.integer().notNull(),
+  from: t.hex().notNull(),
+  to: t.hex().notNull(),
+  token: t.bigint().notNull(),
 }));

package/templates/reference-erc721/src/index.ts

@@ -1,37 +1,33 @@
 import { ponder } from "@/generated";
+import * as schema from "../ponder.schema";
 
 ponder.on("ERC721:Transfer", async ({ event, context }) => {
-  const { Account, Token, TransferEvent } = context.db;
-
   // Create an Account for the sender, or update the balance if it already exists.
-  await Account.upsert({
-    id: event.args.from,
-  });
-
+  await context.db
+    .insert(schema.account)
+    .values({ address: event.args.from })
+    .onConflictDoNothing();
   // Create an Account for the recipient, or update the balance if it already exists.
-  await Account.upsert({
-    id: event.args.to,
-  });
+  await context.db
+    .insert(schema.account)
+    .values({ address: event.args.to })
+    .onConflictDoNothing();
 
   // Create or update a Token.
-  await Token.upsert({
-    id: event.args.id,
-    create: {
-      ownerId: event.args.to,
-    },
-    update: {
-      ownerId: event.args.to,
-    },
-  });
+  await context.db
+    .insert(schema.token)
+    .values({
+      id: event.args.id,
+      owner: event.args.to,
+    })
+    .onConflictDoUpdate({ owner: event.args.to });
 
   // Create a TransferEvent.
-  await TransferEvent.create({
+  await context.db.insert(schema.transferEvent).values({
     id: event.log.id,
-    data: {
-      fromId: event.args.from,
-      toId: event.args.to,
-      tokenId: event.args.id,
-      timestamp: Number(event.block.timestamp),
-    },
+    from: event.args.from,
+    to: event.args.to,
+    token: event.args.id,
+    timestamp: Number(event.block.timestamp),
   });
 });

package/templates/subgraph/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(),
 }));