create-ponder 0.6.24 → 0.7.0

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

@@ -1,15 +1,9 @@
 import { ponder } from "@/generated";
+import { account } from "../ponder.schema";
 
 ponder.on("weth9:Deposit", async ({ event, context }) => {
-  const { Account } = context.db;
-
-  await Account.upsert({
-    id: event.args.dst,
-    create: {
-      balance: event.args.wad,
-    },
-    update: ({ current }) => ({
-      balance: current.balance + event.args.wad,
-    }),
-  });
+  await context.db
+    .insert(account)
+    .values({ address: event.args.dst, balance: event.args.wad })
+    .onConflictDoUpdate((row) => ({ balance: row.balance + event.args.wad }));
 });

package/templates/feature-proxy/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-proxy/ponder.schema.ts

@@ -1,12 +1,14 @@
-import { createSchema } from "@ponder/core";
+import { onchainTable } from "@ponder/core";
 
-export default createSchema((p) => ({
-  LiquidationEvent: p.createTable({
-    id: p.string(),
-    liquidator: p.hex(),
-  }),
-  OwnershipTransferredEvent: p.createTable({
-    id: p.string(),
-    newOwner: p.hex(),
-  }),
+export const liquidationEvent = onchainTable("liquidation_event", (t) => ({
+  id: t.text().primaryKey(),
+  liquidator: t.hex().notNull(),
 }));
+
+export const ownershipTransferEvent = onchainTable(
+  "ownership_transfer_event",
+  (t) => ({
+    id: t.text().primaryKey(),
+    newOwner: t.hex().notNull(),
+  }),
+);

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

@@ -1,23 +1,14 @@
 import { ponder } from "@/generated";
+import * as schema from "../ponder.schema";
 
 ponder.on("AstariaRouter:Liquidation", async ({ event, context }) => {
-  const { LiquidationEvent } = context.db;
-
-  await LiquidationEvent.create({
-    id: event.log.id,
-    data: {
-      liquidator: event.args.liquidator,
-    },
-  });
+  await context.db
+    .insert(schema.liquidationEvent)
+    .values({ id: event.log.id, liquidator: event.args.liquidator });
 });
 
 ponder.on("AstariaRouter:OwnershipTransferred", async ({ event, context }) => {
-  const { OwnershipTransferredEvent } = context.db;
-
-  await OwnershipTransferredEvent.create({
-    id: event.log.id,
-    data: {
-      newOwner: event.args.newOwner,
-    },
-  });
+  await context.db
+    .insert(schema.ownershipTransferEvent)
+    .values({ id: event.log.id, newOwner: event.args.newOwner });
 });

package/templates/feature-read-contract/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-read-contract/ponder.schema.ts

@@ -1,14 +1,11 @@
-import { createSchema } from "@ponder/core";
+import { onchainTable } from "@ponder/core";
 
-export default createSchema((p) => ({
-  File: p.createTable({
-    id: p.string(),
-    name: p.string(),
-    size: p.int(),
-    contents: p.string(),
-    createdAt: p.int(),
-    type: p.string().optional(),
-    encoding: p.string().optional(),
-    compression: p.string().optional(),
-  }),
+export const file = onchainTable("file", (t) => ({
+  name: t.text().primaryKey(),
+  size: t.integer().notNull(),
+  contents: t.text().notNull(),
+  createdAt: t.integer().notNull(),
+  type: t.text(),
+  encoding: t.text(),
+  compression: t.text(),
 }));

package/templates/feature-read-contract/src/FileStore.ts

@@ -1,9 +1,8 @@
+import { ponder } from "@/generated";
 import type { Hex } from "viem";
 import { fromHex } from "viem";
-
-import { ponder } from "@/generated";
-
 import { FileStoreFrontendAbi } from "../abis/FileStoreFrontendAbi";
+import * as schema from "../ponder.schema";
 
 const parseJson = (encodedJson: string, defaultValue: any = null) => {
   try {
@@ -18,25 +17,22 @@ ponder.on("FileStore:FileCreated", async ({ event, context }) => {
 
   const metadata = parseJson(fromHex(rawMetadata as Hex, "string"));
 
-  await context.db.File.create({
-    id: filename,
-    data: {
-      name: filename,
-      size: Number(size),
-      contents: await context.client.readContract({
-        abi: FileStoreFrontendAbi,
-        functionName: "readFile",
-        address: "0xBc66C61BCF49Cc3fe4E321aeCEa307F61EC57C0b",
-        args: [event.transaction.to!, filename],
-      }),
-      createdAt: Number(event.block.timestamp),
-      type: metadata?.type,
-      compression: metadata?.compression,
-      encoding: metadata?.encoding,
-    },
+  await context.db.insert(schema.file).values({
+    name: filename,
+    size: Number(size),
+    contents: await context.client.readContract({
+      abi: FileStoreFrontendAbi,
+      functionName: "readFile",
+      address: "0xBc66C61BCF49Cc3fe4E321aeCEa307F61EC57C0b",
+      args: [event.transaction.to!, filename],
+    }),
+    createdAt: Number(event.block.timestamp),
+    type: metadata?.type,
+    compression: metadata?.compression,
+    encoding: metadata?.encoding,
   });
 });
 
 ponder.on("FileStore:FileDeleted", async ({ event, context }) => {
-  await context.db.File.delete({ id: event.args.filename });
+  await context.db.delete(schema.file, { name: event.args.filename });
 });

package/templates/project-friendtech/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/project-friendtech/ponder.schema.ts

@@ -1,62 +1,50 @@
-import { createSchema } from "@ponder/core";
+import { onchainEnum, onchainTable, primaryKey } from "@ponder/core";
 
-export default createSchema((p) => ({
-  TradeType: p.createEnum(["BUY", "SELL"]),
-  Share: p.createTable({
-    id: p.string(),
+export const tradeType = onchainEnum("trade_type", ["BUY", "SELL"]);
 
-    subjectId: p.hex().references("Subject.id"),
-    traderId: p.hex().references("Trader.id"),
-
-    subject: p.one("subjectId"),
-    trader: p.one("traderId"),
-
-    shareAmount: p.bigint(),
+export const share = onchainTable(
+  "share",
+  (t) => ({
+    subject: t.hex().notNull(),
+    trader: t.hex().notNull(),
+    amount: t.bigint().notNull(),
   }),
-  TradeEvent: p.createTable({
-    id: p.string(),
-
-    subjectId: p.hex().references("Subject.id"),
-    traderId: p.hex().references("Trader.id"),
-
-    subject: p.one("subjectId"),
-    trader: p.one("traderId"),
-
-    shareAmount: p.bigint(),
-    tradeType: p.enum("TradeType"),
-    ethAmount: p.bigint(),
-    protocolEthAmount: p.bigint(),
-    subjectEthAmount: p.bigint(),
-    traderAmount: p.bigint(),
-    supply: p.bigint(),
-    timestamp: p.int(),
+  (table) => ({
+    pk: primaryKey({ columns: [table.subject, table.trader] }),
   }),
-  Subject: p.createTable({
-    id: p.hex(),
-    totalShares: p.bigint(),
-    totalTrades: p.bigint(),
-    lastPrice: p.bigint(),
-    earnings: p.bigint(),
-    traderVolume: p.bigint(),
-    protocolFeesGenerated: p.bigint(),
+);
+
+export const tradeEvent = onchainTable("trade_event", (t) => ({
+  id: t.text().primaryKey(),
+  subject: t.hex().notNull(),
+  trader: t.hex().notNull(),
+
+  shareAmount: t.bigint().notNull(),
+  tradeType: tradeType().notNull(),
+  ethAmount: t.bigint().notNull(),
+  protocolEthAmount: t.bigint().notNull(),
+  subjectEthAmount: t.bigint().notNull(),
+  traderAmount: t.bigint().notNull(),
+  supply: t.bigint().notNull(),
+  timestamp: t.integer().notNull(),
+}));
 
-    shares: p.many("Share.subjectId"),
-    trades: p.many("TradeEvent.subjectId"),
-  }),
-  Trader: p.createTable({
-    id: p.hex(),
-    totalTrades: p.bigint(),
-    spend: p.bigint(),
-    earnings: p.bigint(),
-    profit: p.bigint(),
-    subjectFeesPaid: p.bigint(),
-    protocolFeesPaid: p.bigint(),
+export const subject = onchainTable("subject", (t) => ({
+  address: t.hex().primaryKey(),
+  totalShares: t.bigint().notNull(),
+  totalTrades: t.bigint().notNull(),
+  lastPrice: t.bigint().notNull(),
+  earnings: t.bigint().notNull(),
+  traderVolume: t.bigint().notNull(),
+  protocolFeesGenerated: t.bigint().notNull(),
+}));
 
-    shares: p.many("Share.traderId"),
-    trades: p.many("TradeEvent.traderId"),
-  }),
-  Protocol: p.createTable({
-    id: p.int(),
-    earnings: p.bigint(),
-  }),
+export const trader = onchainTable("trader", (t) => ({
+  address: t.hex().primaryKey(),
+  totalTrades: t.bigint().notNull(),
+  spend: t.bigint().notNull(),
+  earnings: t.bigint().notNull(),
+  profit: t.bigint().notNull(),
+  subjectFeesPaid: t.bigint().notNull(),
+  protocolFeesPaid: t.bigint().notNull(),
 }));

package/templates/project-friendtech/src/FriendtechSharesV1.ts

@@ -1,51 +1,44 @@
 import { ponder } from "@/generated";
+import * as schema from "../ponder.schema";
 
 ponder.on("FriendtechSharesV1:Trade", async ({ event, context }) => {
-  const { Share, Subject, TradeEvent, Trader } = context.db;
-
   // Skip phantom events
   if (event.args.shareAmount === 0n) {
     return;
   }
 
-  const subjectId = event.args.subject;
-  const traderId = event.args.trader;
-  const shareId = `${event.args.subject}-${event.args.trader}`;
-  const tradeEventId = `${event.transaction.hash}-${event.log.logIndex.toString()}`;
-
   const feeAmount = event.args.protocolEthAmount + event.args.subjectEthAmount;
 
   const traderAmount = event.args.isBuy
     ? event.args.ethAmount + feeAmount
     : event.args.ethAmount - feeAmount;
 
-  const tradeEvent = await TradeEvent.create({
-    id: tradeEventId,
-    data: {
-      subjectId: subjectId,
-      traderId: traderId,
-      shareAmount: event.args.shareAmount,
-      tradeType: event.args.isBuy ? "BUY" : "SELL",
-      ethAmount: event.args.ethAmount,
-      protocolEthAmount: event.args.protocolEthAmount,
-      subjectEthAmount: event.args.subjectEthAmount,
-      supply: event.args.supply,
-      timestamp: Number(event.block.timestamp),
-      traderAmount: traderAmount,
-    },
+  const tradeEvent = await context.db.insert(schema.tradeEvent).values({
+    id: event.log.id,
+    subject: event.args.subject,
+    trader: event.args.trader,
+    shareAmount: event.args.shareAmount,
+    tradeType: event.args.isBuy ? "BUY" : "SELL",
+    ethAmount: event.args.ethAmount,
+    protocolEthAmount: event.args.protocolEthAmount,
+    subjectEthAmount: event.args.subjectEthAmount,
+    supply: event.args.supply,
+    timestamp: Number(event.block.timestamp),
+    traderAmount: traderAmount,
   });
 
-  await Subject.upsert({
-    id: subjectId,
-    create: {
+  await context.db
+    .insert(schema.subject)
+    .values({
+      address: event.args.subject,
       totalTrades: 0n,
       totalShares: 0n,
       lastPrice: 0n,
       earnings: 0n,
       traderVolume: 0n,
       protocolFeesGenerated: 0n,
-    },
-    update: ({ current }) => {
+    })
+    .onConflictDoUpdate((row) => {
       const shareDelta =
         tradeEvent.tradeType === "BUY"
           ? tradeEvent.shareAmount
@@ -55,71 +48,64 @@ ponder.on("FriendtechSharesV1:Trade", async ({ event, context }) => {
         tradeEvent.tradeType === "BUY" ? traderAmount : tradeEvent.ethAmount;
 
       return {
-        totalTrades: current.totalTrades + 1n,
-        totalShares: current.totalShares + shareDelta,
+        totalTrades: row.totalTrades + 1n,
+        totalShares: row.totalShares + shareDelta,
         lastPrice:
           tradeEvent.shareAmount > 0
             ? traderSpend / tradeEvent.shareAmount
             : 0n,
-        earnings: current.earnings + tradeEvent.subjectEthAmount,
-        traderVolume: current.traderVolume + traderSpend,
+        earnings: row.earnings + tradeEvent.subjectEthAmount,
+        traderVolume: row.traderVolume + traderSpend,
         protocolFeesGenerated:
-          current.protocolFeesGenerated + tradeEvent.protocolEthAmount,
+          row.protocolFeesGenerated + tradeEvent.protocolEthAmount,
       };
-    },
-  });
+    });
 
-  await Trader.upsert({
-    id: traderId,
-    create: {
+  await context.db
+    .insert(schema.trader)
+    .values({
+      address: event.args.trader,
       totalTrades: 0n,
       spend: 0n,
       earnings: 0n,
       profit: 0n,
       subjectFeesPaid: 0n,
       protocolFeesPaid: 0n,
-    },
-    update: ({ current }) => {
+    })
+    .onConflictDoUpdate((row) => {
       const spendDelta = tradeEvent.tradeType === "BUY" ? traderAmount : 0n;
       const earningsDelta = tradeEvent.tradeType === "BUY" ? 0n : traderAmount;
       const profitDelta =
         tradeEvent.tradeType === "BUY" ? -traderAmount : traderAmount;
       return {
-        totalTrades: current.totalTrades + 1n,
-        spend: current.spend + spendDelta,
-        earnings: current.earnings + earningsDelta,
-        profit: current.profit + profitDelta,
-        subjectFeesPaid: current.subjectFeesPaid + tradeEvent.subjectEthAmount,
-        protocolFeesPaid:
-          current.protocolFeesPaid + tradeEvent.protocolEthAmount,
+        totalTrades: row.totalTrades + 1n,
+        spend: row.spend + spendDelta,
+        earnings: row.earnings + earningsDelta,
+        profit: row.profit + profitDelta,
+        subjectFeesPaid: row.subjectFeesPaid + tradeEvent.subjectEthAmount,
+        protocolFeesPaid: row.protocolFeesPaid + tradeEvent.protocolEthAmount,
       };
-    },
-  });
+    });
 
   if (tradeEvent.tradeType === "BUY") {
-    await Share.upsert({
-      id: shareId,
-      create: {
-        subjectId,
-        traderId,
-        shareAmount: tradeEvent.shareAmount,
-      },
-      update: ({ current }) => ({
-        shareAmount: current.shareAmount + tradeEvent.shareAmount,
-      }),
-    });
+    await context.db
+      .insert(schema.share)
+      .values({
+        subject: event.args.subject,
+        trader: event.args.trader,
+        amount: tradeEvent.shareAmount,
+      })
+      .onConflictDoUpdate((row) => ({
+        amount: row.amount + tradeEvent.shareAmount,
+      }));
   } else {
-    const share = await Share.update({
-      id: shareId,
-      data: ({ current }) => ({
-        shareAmount: current.shareAmount - tradeEvent.shareAmount,
-      }),
-    });
-
-    if (share.shareAmount === 0n) {
-      await Share.delete({
-        id: shareId,
-      });
-    }
+    await context.db
+      .update(schema.share, {
+        subject: event.args.subject,
+        trader: event.args.trader,
+      })
+      .set((row) => ({
+        amount: row.amount - tradeEvent.shareAmount,
+      }));
   }
 });

package/templates/project-uniswap-v3-flash/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/project-uniswap-v3-flash/ponder.schema.ts

@@ -1,12 +1,11 @@
-import { createSchema } from "@ponder/core";
+import { onchainTable } from "@ponder/core";
 
-export default createSchema((p) => ({
-  TokenPaid: p.createTable({
-    id: p.hex(),
-    amount: p.bigint(),
-  }),
-  TokenBorrowed: p.createTable({
-    id: p.hex(),
-    amount: p.bigint(),
-  }),
+export const tokenPaid = onchainTable("token_paid", (t) => ({
+  address: t.hex().primaryKey(),
+  amount: t.bigint().notNull(),
+}));
+
+export const tokenBorrowed = onchainTable("token_borrowed", (t) => ({
+  address: t.hex().primaryKey(),
+  amount: t.bigint().notNull(),
 }));

package/templates/project-uniswap-v3-flash/src/index.ts

@@ -1,7 +1,7 @@
 import { ponder } from "@/generated";
+import * as schema from "../ponder.schema";
 
 ponder.on("UniswapV3Pool:Flash", async ({ event, context }) => {
-  const { TokenBorrowed, TokenPaid } = context.db;
   const poolAddress = event.log.address;
 
   const [token0, token1] = await Promise.all([
@@ -19,41 +19,32 @@ ponder.on("UniswapV3Pool:Flash", async ({ event, context }) => {
     }),
   ]);
 
-  await TokenBorrowed.upsert({
-    id: token0,
-    create: {
+  await context.db
+    .insert(schema.tokenBorrowed)
+    .values({
+      address: token0,
       amount: event.args.amount0,
-    },
-    update: ({ current }) => ({
-      amount: current.amount + event.args.amount0,
-    }),
-  });
-  await TokenBorrowed.upsert({
-    id: token1,
-    create: {
+    })
+    .onConflictDoUpdate((row) => ({ amount: row.amount + event.args.amount0 }));
+  await context.db
+    .insert(schema.tokenBorrowed)
+    .values({
+      address: token1,
       amount: event.args.amount1,
-    },
-    update: ({ current }) => ({
-      amount: current.amount + event.args.amount1,
-    }),
-  });
-
-  await TokenPaid.upsert({
-    id: token0,
-    create: {
+    })
+    .onConflictDoUpdate((row) => ({ amount: row.amount + event.args.amount1 }));
+  await context.db
+    .insert(schema.tokenPaid)
+    .values({
+      address: token0,
       amount: event.args.paid0,
-    },
-    update: ({ current }) => ({
-      amount: current.amount + event.args.paid0,
-    }),
-  });
-  await TokenPaid.upsert({
-    id: token1,
-    create: {
+    })
+    .onConflictDoUpdate((row) => ({ amount: row.amount + event.args.amount0 }));
+  await context.db
+    .insert(schema.tokenPaid)
+    .values({
+      address: token1,
       amount: event.args.paid1,
-    },
-    update: ({ current }) => ({
-      amount: current.amount + event.args.paid1,
-    }),
-  });
+    })
+    .onConflictDoUpdate((row) => ({ amount: row.amount + event.args.amount1 }));
 });

package/templates/reference-erc1155/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>;
 }