create-ponder 0.6.24 → 0.7.0

package/templates/reference-erc1155/ponder.schema.ts

@@ -1,29 +1,25 @@
-import { createSchema } from "@ponder/core";
+import { onchainTable, primaryKey } from "@ponder/core";
 
-export default createSchema((p) => ({
-  Account: p.createTable({
-    id: p.hex(),
-    tokens: p.many("TokenBalance.ownerId"),
+export const account = onchainTable("account", (t) => ({
+  address: t.hex().primaryKey(),
+}));
 
-    transferFromEvents: p.many("TransferEvent.fromId"),
-    transferToEvents: p.many("TransferEvent.toId"),
+export const tokenBalance = onchainTable(
+  "token_balance",
+  (t) => ({
+    tokenId: t.bigint().notNull(),
+    owner: t.hex().notNull(),
+    balance: t.bigint().notNull(),
   }),
-  TokenBalance: p.createTable({
-    id: p.string(),
-    tokenId: p.bigint(),
-    balance: p.bigint(),
-
-    ownerId: p.hex().references("Account.id"),
-    owner: p.one("ownerId"),
+  (table) => ({
+    pk: primaryKey({ columns: [table.owner, table.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(),
+);
 
-    from: p.one("fromId"),
-    to: p.one("toId"),
-  }),
+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-erc1155/src/index.ts

@@ -1,109 +1,93 @@
 import { ponder } from "@/generated";
+import * as schema from "../ponder.schema";
 
 ponder.on("ERC1155:TransferSingle", async ({ event, context }) => {
-  const { Account, TokenBalance, 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();
 
-  await TokenBalance.upsert({
-    id: `${event.args.id}-${event.args.from}`,
-    create: {
+  await context.db
+    .insert(schema.tokenBalance)
+    .values({
+      owner: event.args.from,
       tokenId: event.args.id,
-      ownerId: event.args.from,
       balance: -event.args.amount,
-    },
-    update: ({ current }) => ({
-      tokenId: event.args.id,
-      ownerId: event.args.from,
-      balance: current.balance - event.args.amount,
-    }),
-  });
+    })
+    .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,
-  });
+  await context.db
+    .insert(schema.account)
+    .values({ address: event.args.to })
+    .onConflictDoNothing();
 
-  await TokenBalance.upsert({
-    id: `${event.args.id}-${event.args.to}`,
-    create: {
+  await context.db
+    .insert(schema.tokenBalance)
+    .values({
+      owner: event.args.to,
       tokenId: event.args.id,
-      ownerId: event.args.to,
       balance: event.args.amount,
-    },
-    update: ({ current }) => ({
-      tokenId: event.args.id,
-      ownerId: event.args.to,
-      balance: current.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,
-      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),
   });
 });
 
 ponder.on("ERC1155:TransferBatch", async ({ event, context }) => {
-  const { Account, TokenBalance, TransferEvent } = context.db;
-
-  await Account.upsert({
-    id: event.args.from,
-  });
-
-  await Account.upsert({
-    id: event.args.to,
-  });
+  await context.db
+    .insert(schema.account)
+    .values({ address: event.args.from })
+    .onConflictDoNothing();
+  await context.db
+    .insert(schema.account)
+    .values({ address: event.args.to })
+    .onConflictDoNothing();
 
   for (let i = 0; i < event.args.ids.length; i++) {
     const id = event.args.ids[i]!;
     const amount = event.args.amounts[i]!;
 
-    await TokenBalance.upsert({
-      id: `${id}-${event.args.from}`,
-      create: {
+    await context.db
+      .insert(schema.tokenBalance)
+      .values({
+        owner: event.args.from,
         tokenId: id,
-        ownerId: event.args.from,
         balance: -amount,
-      },
-      update: ({ current }) => ({
-        tokenId: id,
-        ownerId: event.args.from,
-        balance: current.balance - amount,
-      }),
-    });
+      })
+      .onConflictDoUpdate((row) => ({
+        balance: row.balance - amount,
+      }));
 
-    await TokenBalance.upsert({
-      id: `${id}-${event.args.to}`,
-      create: {
+    await context.db
+      .insert(schema.tokenBalance)
+      .values({
+        owner: event.args.to,
         tokenId: id,
-        ownerId: event.args.to,
         balance: amount,
-      },
-      update: ({ current }) => ({
-        tokenId: id,
-        ownerId: event.args.to,
-        balance: current.balance + amount,
-      }),
-    });
+      })
+      .onConflictDoUpdate((row) => ({
+        balance: row.balance + amount,
+      }));
 
-    await TransferEvent.create({
-      id: `${event.log.id}-${i}`,
-      data: {
-        fromId: event.args.from,
-        toId: event.args.to,
-        tokenId: id,
-        timestamp: Number(event.block.timestamp),
-      },
+    await context.db.insert(schema.transferEvent).values({
+      id: event.log.id,
+      from: event.args.from,
+      to: event.args.to,
+      token: id,
+      timestamp: Number(event.block.timestamp),
     });
   }
 });

package/templates/reference-erc20/package.json

@@ -12,6 +12,7 @@
   },
   "dependencies": {
     "@ponder/core": "workspace:*",
+    "drizzle-kit": "0.22.8",
     "hono": "^4.5.0",
     "viem": "^2.21.3"
   },

package/templates/reference-erc20/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-erc20/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", (t) => ({
+  address: t.hex().primaryKey(),
+  balance: t.bigint().notNull(),
+  isOwner: t.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",
+  (t) => ({
+    owner: t.hex(),
+    spender: t.hex(),
+    amount: t.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",
+  (t) => ({
+    id: t.text().primaryKey(),
+    amount: t.bigint().notNull(),
+    timestamp: t.integer().notNull(),
+    from: t.hex().notNull(),
+    to: t.hex().notNull(),
+  }),
+  (table) => ({
+    fromIdx: index("from_index").on(table.from),
   }),
+);
+
+export const approvalEvent = onchainTable("approval_event", (t) => ({
+  id: t.text().primaryKey(),
+  amount: t.bigint().notNull(),
+  timestamp: t.integer().notNull(),
+  owner: t.hex().notNull(),
+  spender: t.hex().notNull(),
 }));

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

@@ -1,70 +1,53 @@
 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),
-      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,
-      isOwner: false,
-    },
-    update: ({ current }) => ({
-      balance: current.balance + event.args.amount,
-    }),
-  });
-
-  // Create a TransferEvent.
-  await TransferEvent.create({
+  await context.db
+    .insert(account)
+    .values({ address: event.args.from, balance: 0n, isOwner: false })
+    .onConflictDoUpdate((row) => ({
+      balance: row.balance - event.args.amount,
+    }));
+
+  await context.db
+    .insert(account)
+    .values({ address: event.args.to, balance: 0n, isOwner: false })
+    .onConflictDoUpdate((row) => ({
+      balance: row.balance + event.args.amount,
+    }));
+
+  // 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,
-      amount: event.args.amount,
-    },
-    update: {
+  // upsert "allowance".
+  await context.db
+    .insert(allowance)
+    .values({
+      spender: event.args.spender,
+      owner: event.args.owner,
       amount: event.args.amount,
-    },
-  });
+    })
+    .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/reference-erc4626/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-erc4626/ponder.schema.ts

@@ -1,62 +1,51 @@
-import { createSchema } from "@ponder/core";
+import { 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", (t) => ({
+  address: t.hex().primaryKey(),
+  balance: t.bigint().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",
+  (t) => ({
+    owner: t.hex(),
+    spender: t.hex(),
+    amount: t.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"),
+);
+
+export const transferEvent = onchainTable("transfer_event", (t) => ({
+  id: t.text().primaryKey(),
+  amount: t.bigint().notNull(),
+  timestamp: t.integer().notNull(),
+  from: t.hex().notNull(),
+  to: t.hex().notNull(),
+}));
 
-    from: p.one("fromId"),
-    to: p.one("toId"),
-  }),
-  ApprovalEvent: p.createTable({
-    id: p.string(),
-    amount: p.bigint(),
-    timestamp: p.int(),
+export const approvalEvent = onchainTable("approval_event", (t) => ({
+  id: t.text().primaryKey(),
+  amount: t.bigint().notNull(),
+  timestamp: t.integer().notNull(),
+  owner: t.hex().notNull(),
+  spender: t.hex().notNull(),
+}));
 
-    ownerId: p.hex().references("Account.id"),
-    spenderId: p.hex().references("Account.id"),
+export const depositEvent = onchainTable("deposit_event", (t) => ({
+  id: t.text().primaryKey(),
+  sender: t.hex().notNull(),
+  receiver: t.hex().notNull(),
+  assets: t.bigint().notNull(),
+  shares: t.bigint().notNull(),
+}));
 
-    owner: p.one("ownerId"),
-    spender: p.one("spenderId"),
-  }),
-  DepositEvent: p.createTable({
-    id: p.string(),
-    sender: p.hex().references("Account.id"),
-    receiver: p.hex().references("Account.id"),
-    assets: p.bigint(),
-    shares: p.bigint(),
-  }),
-  WithdrawEvent: p.createTable({
-    id: p.string(),
-    sender: p.hex().references("Account.id"),
-    receiver: p.hex().references("Account.id"),
-    owner: p.hex().references("Account.id"),
-    assets: p.bigint(),
-    shares: p.bigint(),
-  }),
+export const withdrawalEvent = onchainTable("withdrawal_event", (t) => ({
+  id: t.text().primaryKey(),
+  sender: t.hex().notNull(),
+  receiver: t.hex().notNull(),
+  owner: t.hex().notNull(),
+  assets: t.bigint().notNull(),
+  shares: t.bigint().notNull(),
 }));