Replace ponder.on with addOnchainEventListener

.changeset/bold-bananas-jump.md

@@ -0,0 +1,5 @@
+---
+"ensindexer": minor
+---
+
+Replaced `ponder.on` with `addOnchainEventListener`. This change enables more granular management of the indexing process.

apps/ensindexer/src/lib/ensv2/account-db-helpers.ts

@@ -1,16 +1,20 @@
-import type { Context } from "ponder:registry";
-import schema from "ponder:schema";
+import ensIndexerSchema from "ponder:schema";
 import type { Address } from "viem";
 
 import { interpretAddress } from "@ensnode/ensnode-sdk";
 
+import type { IndexingEngineContext } from "@/lib/indexing-engines/ponder";
+
 /**
  * Ensures that the account identified by `address` exists.
  * If `address` is the zeroAddress, no-op.
  */
-export async function ensureAccount(context: Context, address: Address) {
+export async function ensureAccount(context: IndexingEngineContext, address: Address) {
   const interpreted = interpretAddress(address);
   if (interpreted === null) return;
 
-  await context.db.insert(schema.account).values({ id: interpreted }).onConflictDoNothing();
+  await context.ensDb
+    .insert(ensIndexerSchema.account)
+    .values({ id: interpreted })
+    .onConflictDoNothing();
 }

apps/ensindexer/src/lib/ensv2/domain-db-helpers.ts

@@ -1,22 +1,24 @@
-import type { Context } from "ponder:registry";
-import schema from "ponder:schema";
+import ensIndexerSchema from "ponder:schema";
 import type { Address } from "viem";
 
 import { type ENSv1DomainId, interpretAddress } from "@ensnode/ensnode-sdk";
 
 import { ensureAccount } from "@/lib/ensv2/account-db-helpers";
+import type { IndexingEngineContext } from "@/lib/indexing-engines/ponder";
 
 /**
  * Sets an ENSv1 Domain's effective owner to `owner`.
  */
 export async function materializeENSv1DomainEffectiveOwner(
-  context: Context,
+  context: IndexingEngineContext,
   id: ENSv1DomainId,
   owner: Address,
 ) {
   // ensure owner
   await ensureAccount(context, owner);
 
   // update v1Domain's effective owner
-  await context.db.update(schema.v1Domain, { id }).set({ ownerId: interpretAddress(owner) });
+  await context.ensDb
+    .update(ensIndexerSchema.v1Domain, { id })
+    .set({ ownerId: interpretAddress(owner) });
 }

apps/ensindexer/src/lib/ensv2/event-db-helpers.ts

@@ -1,5 +1,4 @@
-import type { Context } from "ponder:registry";
-import schema from "ponder:schema";
+import ensIndexerSchema from "ponder:schema";
 import type { Hash } from "viem";
 
 import {
@@ -9,6 +8,7 @@ import {
   makeResolverId,
 } from "@ensnode/ensnode-sdk";
 
+import type { IndexingEngineContext } from "@/lib/indexing-engines/ponder";
 import type { LogEventBase } from "@/lib/ponder-helpers";
 
 type Topics = [Hash, ...Hash[]];
@@ -25,7 +25,7 @@ const hasTopics = (topics: LogEventBase["log"]["topics"]): topics is Topics =>
  *
  * @returns event.id
  */
-export async function ensureEvent(context: Context, event: LogEventBase) {
+export async function ensureEvent(context: IndexingEngineContext, event: LogEventBase) {
   // all relevant ENS events obviously have a topic, so we can safely constrain the type of this data
   if (!hasTopics(event.log.topics)) {
     throw new Error(`Invariant: All events indexed via ensureEvent must have at least one topic.`);
@@ -35,8 +35,8 @@ export async function ensureEvent(context: Context, event: LogEventBase) {
   // https://github.com/ponder-sh/ponder/blob/main/packages/core/src/sync-store/encode.ts#L59
   const topics = event.log.topics.filter((topic): topic is Hash => topic !== null) as Topics;
 
-  await context.db
-    .insert(schema.event)
+  await context.ensDb
+    .insert(ensIndexerSchema.event)
     .values({
       id: event.id,
 
@@ -66,31 +66,38 @@ export async function ensureEvent(context: Context, event: LogEventBase) {
   return event.id;
 }
 
-export async function ensureDomainEvent(context: Context, event: LogEventBase, domainId: DomainId) {
+export async function ensureDomainEvent(
+  context: IndexingEngineContext,
+  event: LogEventBase,
+  domainId: DomainId,
+) {
   const eventId = await ensureEvent(context, event);
-  await context.db.insert(schema.domainEvent).values({ domainId, eventId }).onConflictDoNothing();
+  await context.ensDb
+    .insert(ensIndexerSchema.domainEvent)
+    .values({ domainId, eventId })
+    .onConflictDoNothing();
 }
 
 export async function ensureResolverEvent(
-  context: Context,
+  context: IndexingEngineContext,
   event: LogEventBase,
   resolver: AccountId,
 ) {
   const eventId = await ensureEvent(context, event);
-  await context.db
-    .insert(schema.resolverEvent)
+  await context.ensDb
+    .insert(ensIndexerSchema.resolverEvent)
     .values({ resolverId: makeResolverId(resolver), eventId })
     .onConflictDoNothing();
 }
 
 export async function ensurePermissionsEvent(
-  context: Context,
+  context: IndexingEngineContext,
   event: LogEventBase,
   contract: AccountId,
 ) {
   const eventId = await ensureEvent(context, event);
-  await context.db
-    .insert(schema.permissionsEvent)
+  await context.ensDb
+    .insert(ensIndexerSchema.permissionsEvent)
     .values({ permissionsId: makePermissionsId(contract), eventId })
     .onConflictDoNothing();
 }

apps/ensindexer/src/lib/ensv2/label-db-helpers.ts

@@ -1,5 +1,4 @@
-import type { Context } from "ponder:registry";
-import schema from "ponder:schema";
+import ensIndexerSchema from "ponder:schema";
 import { labelhash } from "viem";
 
 import {
@@ -11,16 +10,17 @@ import {
 } from "@ensnode/ensnode-sdk";
 
 import { labelByLabelHash } from "@/lib/graphnode-helpers";
+import type { IndexingEngineContext } from "@/lib/indexing-engines/ponder";
 
 /**
  * Ensures that the LiteralLabel `label` is interpreted and upserted into the Label rainbow table.
  */
-export async function ensureLabel(context: Context, label: LiteralLabel) {
+export async function ensureLabel(context: IndexingEngineContext, label: LiteralLabel) {
   const labelHash = labelhash(label);
   const interpreted = literalLabelToInterpretedLabel(label);
 
-  await context.db
-    .insert(schema.label)
+  await context.ensDb
+    .insert(ensIndexerSchema.label)
     .values({ labelHash, interpreted })
     .onConflictDoUpdate({ interpreted });
 }
@@ -29,9 +29,9 @@ export async function ensureLabel(context: Context, label: LiteralLabel) {
  * Ensures that the LabelHash `labelHash` is available in the Label rainbow table, attempting an
  * ENSRainbow heal if this is the first time it has been encountered.
  */
-export async function ensureUnknownLabel(context: Context, labelHash: LabelHash) {
+export async function ensureUnknownLabel(context: IndexingEngineContext, labelHash: LabelHash) {
   // do nothing for existing labels, they're either healed or we don't know them
-  const exists = await context.db.find(schema.label, { labelHash });
+  const exists = await context.ensDb.find(ensIndexerSchema.label, { labelHash });
   if (exists) return;
 
   // attempt ENSRainbow heal
@@ -42,5 +42,8 @@ export async function ensureUnknownLabel(context: Context, labelHash: LabelHash)
 
   // otherwise upsert label entity
   const interpreted = encodeLabelHash(labelHash) as InterpretedLabel;
-  await context.db.insert(schema.label).values({ labelHash, interpreted }).onConflictDoNothing();
+  await context.ensDb
+    .insert(ensIndexerSchema.label)
+    .values({ labelHash, interpreted })
+    .onConflictDoNothing();
 }

apps/ensindexer/src/lib/ensv2/registration-db-helpers.ts

@@ -1,8 +1,9 @@
-import type { Context } from "ponder:registry";
-import schema from "ponder:schema";
+import ensIndexerSchema from "ponder:schema";
 
 import { type DomainId, makeRegistrationId, makeRenewalId } from "@ensnode/ensnode-sdk";
 
+import type { IndexingEngineContext } from "@/lib/indexing-engines/ponder";
+
 /**
  * Latest Registration & Renewals
  *
@@ -22,19 +23,21 @@ import { type DomainId, makeRegistrationId, makeRenewalId } from "@ensnode/ensno
 /**
  * Gets the latest Registration for the provided `domainId`.
  */
-export async function getLatestRegistration(context: Context, domainId: DomainId) {
-  const pointer = await context.db.find(schema.latestRegistrationIndex, { domainId });
+export async function getLatestRegistration(context: IndexingEngineContext, domainId: DomainId) {
+  const pointer = await context.ensDb.find(ensIndexerSchema.latestRegistrationIndex, { domainId });
   if (!pointer) return null;
 
-  return context.db.find(schema.registration, { id: makeRegistrationId(domainId, pointer.index) });
+  return context.ensDb.find(ensIndexerSchema.registration, {
+    id: makeRegistrationId(domainId, pointer.index),
+  });
 }
 
 /**
  * Inserts a Registration and updates the latestRegistration pointer for its `domainId`.
  */
 export async function insertLatestRegistration(
-  context: Context,
-  values: Omit<typeof schema.registration.$inferInsert, "id" | "index">,
+  context: IndexingEngineContext,
+  values: Omit<typeof ensIndexerSchema.registration.$inferInsert, "id" | "index">,
 ) {
   const { domainId } = values;
 
@@ -43,15 +46,15 @@ export async function insertLatestRegistration(
   const index = previous ? previous.index + 1 : 0;
 
   // insert new Registration
-  await context.db.insert(schema.registration).values({
+  await context.ensDb.insert(ensIndexerSchema.registration).values({
     id: makeRegistrationId(domainId, index),
     index,
     ...values,
   });
 
   // ensure this Registration is the latest
-  await context.db
-    .insert(schema.latestRegistrationIndex)
+  await context.ensDb
+    .insert(ensIndexerSchema.latestRegistrationIndex)
     .values({ domainId, index })
     .onConflictDoUpdate({ index });
 }
@@ -60,17 +63,17 @@ export async function insertLatestRegistration(
  * Gets the latest Renewal for the provided `domainId` and `registrationIndex`.
  */
 export async function getLatestRenewal(
-  context: Context,
+  context: IndexingEngineContext,
   domainId: DomainId,
   registrationIndex: number,
 ) {
-  const pointer = await context.db.find(schema.latestRenewalIndex, {
+  const pointer = await context.ensDb.find(ensIndexerSchema.latestRenewalIndex, {
     domainId,
     registrationIndex,
   });
   if (!pointer) return null;
 
-  return context.db.find(schema.renewal, {
+  return context.ensDb.find(ensIndexerSchema.renewal, {
     id: makeRenewalId(domainId, registrationIndex, pointer.index),
   });
 }
@@ -79,9 +82,9 @@ export async function getLatestRenewal(
  * Inserts a Renewal and updates the latestRenewal pointer for its `domainId` and `registrationIndex`.
  */
 export async function insertLatestRenewal(
-  context: Context,
-  registration: Pick<typeof schema.registration.$inferInsert, "index">,
-  values: Omit<typeof schema.renewal.$inferInsert, "id" | "registrationIndex" | "index">,
+  context: IndexingEngineContext,
+  registration: Pick<typeof ensIndexerSchema.registration.$inferInsert, "index">,
+  values: Omit<typeof ensIndexerSchema.renewal.$inferInsert, "id" | "registrationIndex" | "index">,
 ) {
   const { index: registrationIndex } = registration;
   const { domainId } = values;
@@ -91,16 +94,16 @@ export async function insertLatestRenewal(
   const index = previous ? previous.index + 1 : 0;
 
   // insert new Renewal
-  await context.db.insert(schema.renewal).values({
+  await context.ensDb.insert(ensIndexerSchema.renewal).values({
     id: makeRenewalId(domainId, registrationIndex, index),
     registrationIndex,
     index,
     ...values,
   });
 
   // ensure this Renewal is the latest
-  await context.db
-    .insert(schema.latestRenewalIndex)
+  await context.ensDb
+    .insert(ensIndexerSchema.latestRenewalIndex)
     .values({ domainId, registrationIndex, index })
     .onConflictDoUpdate({ index });
 }

apps/ensindexer/src/lib/get-this-account-id.ts

@@ -1,7 +1,6 @@
-import type { Context } from "ponder:registry";
-
 import type { AccountId } from "@ensnode/ensnode-sdk";
 
+import type { IndexingEngineContext } from "@/lib/indexing-engines/ponder";
 import type { LogEventBase } from "@/lib/ponder-helpers";
 
 /**
@@ -10,5 +9,7 @@ import type { LogEventBase } from "@/lib/ponder-helpers";
  * @example
  * const { chainId, address } = getThisAccountId(context, event);
  */
-export const getThisAccountId = (context: Context, event: Pick<LogEventBase, "log">) =>
-  ({ chainId: context.chain.id, address: event.log.address }) satisfies AccountId;
+export const getThisAccountId = (
+  context: IndexingEngineContext,
+  event: Pick<LogEventBase, "log">,
+) => ({ chainId: context.chain.id, address: event.log.address }) satisfies AccountId;

apps/ensindexer/src/lib/heal-addr-reverse-subname-label.ts

@@ -1,11 +1,11 @@
 import config from "@/config";
 
-import type { Context } from "ponder:registry";
 import type { Address } from "viem";
 
 import { getENSRootChainId } from "@ensnode/datasources";
 import type { LabelHash, LiteralLabel } from "@ensnode/ensnode-sdk";
 
+import type { IndexingEngineContext } from "@/lib/indexing-engines/ponder";
 import { toJson } from "@/lib/json-stringify-with-bigints";
 import { maybeHealLabelByAddrReverseSubname } from "@/lib/maybe-heal-label-by-addr-reverse-subname";
 import type { EventWithArgs } from "@/lib/ponder-helpers";
@@ -21,7 +21,7 @@ import {
  * @throws if unable to heal the addr.reverse subname's label
  */
 export async function healAddrReverseSubnameLabel(
-  context: Context,
+  context: IndexingEngineContext,
   event: EventWithArgs<{ owner: Address }>,
   labelHash: LabelHash,
 ): Promise<LiteralLabel> {