feat(cross-subname-indexing): allow activating multiple plugins together

.env.local.example

@@ -7,13 +7,25 @@ RPC_URL_59144=https://linea-rpc.publicnode.com
 
 # Identify which indexer plugin to activate (see `src/plugins` for available plugins)
 
-ACTIVE_PLUGIN=base.eth
+# ACTIVE_PLUGINS=eth,base.eth,linea.eth
+# ACTIVE_PLUGINS=base.eth,linea.eth
+ACTIVE_PLUGINS=eth
 
 # Database configuration
 
-# This is where the indexer will create the tables defined in ponder.schema.ts
-# No two indexer instances can use the same database schema at the same time. This prevents data corruption.
-# @link https://ponder.sh/docs/api-reference/database#database-schema-rules
-DATABASE_SCHEMA=subname_index_base.eth
-# The indexer will use Postgres with that as the connection string. If not defined, the indexer will use PSlite.
+# This is a namespace for the tables that the indexer will create to store indexed data.
+# It should be a string that is unique to the running indexer instance.
+#
+# Keeping the database schema unique to the indexer instance is important to
+# 1) speed up indexing after a restart
+# 2) prevent data corruption
+#
+# No two indexer instances can use the same database schema at the same time.
+#
+# Read more about database schema rules here:
+# https://ponder.sh/docs/api-reference/database#database-schema-rules
+DATABASE_SCHEMA=ens
+
+# This is the connection string for the database that the indexer will use to store data.
+# It should be in the format of `postgresql://<username>:<password>@<host>:<port>/<database>`
 DATABASE_URL=postgresql://dbuser:abcd1234@localhost:5432/my_database

package.json

@@ -14,7 +14,7 @@
   "dependencies": {
     "@ensdomains/ensjs": "^4.0.2",
     "hono": "^4.6.14",
-    "ponder": "^0.8.17",
+    "ponder": "^0.8.24",
     "viem": "^2.21.57"
   },
   "devDependencies": {

ponder.config.ts

@@ -1,29 +1,32 @@
-import { ACTIVE_PLUGIN } from "./src/lib/plugin-helpers";
+import { deepMergeRecursive } from "./src/lib/helpers";
+import { type IntersectionOf, getActivePlugins } from "./src/lib/plugin-helpers";
 import * as baseEthPlugin from "./src/plugins/base.eth/ponder.config";
 import * as ethPlugin from "./src/plugins/eth/ponder.config";
 import * as lineaEthPlugin from "./src/plugins/linea.eth/ponder.config";
 
+// list of all available plugins
+// any of them can be activated in the runtime
 const plugins = [baseEthPlugin, ethPlugin, lineaEthPlugin] as const;
 
-// here we export only a single 'plugin's config, by type it as every config
-// this makes all of the mapping types happy at typecheck-time, but only the
-// relevant config is run at runtime
-export default ((): AllConfigs => {
-  const pluginToActivate = plugins.find((p) => p.ownedName === ACTIVE_PLUGIN);
+// intersection of all available plugin configs to support correct typechecking
+// of the indexing handlers
+type AllPluginsConfig = IntersectionOf<(typeof plugins)[number]["config"]>;
 
-  if (!pluginToActivate) {
-    throw new Error(`Unsupported ACTIVE_PLUGIN: ${ACTIVE_PLUGIN}`);
-  }
+// Activates the indexing handlers included in selected active plugins and
+// returns and intersection of their combined config.
+function getActivePluginsConfig(): AllPluginsConfig {
+  const activePlugins = getActivePlugins(plugins);
 
-  pluginToActivate.activate();
+  // load indexing handlers from the active plugins into the runtime
+  activePlugins.forEach((plugin) => plugin.activate());
 
-  return pluginToActivate.config as AllConfigs;
-})();
+  const config = activePlugins
+    .map((plugin) => plugin.config)
+    .reduce((acc, val) => deepMergeRecursive(acc, val), {} as AllPluginsConfig);
 
-// Helper type to get the intersection of all config types
-type IntersectionOf<T> = (T extends any ? (x: T) => void : never) extends (x: infer R) => void
-  ? R
-  : never;
-// The type of the exported default is the intersection of all plugin configs to
-// each plugin can be correctly typechecked
-type AllConfigs = IntersectionOf<(typeof plugins)[number]["config"]>;
+  return config as AllPluginsConfig;
+}
+
+// The type of the default export is the intersection of all available plugin
+// configs to each plugin can be correctly typechecked
+export default getActivePluginsConfig();

src/handlers/Registrar.ts

@@ -23,7 +23,7 @@ export const makeRegistrarHandlers = (ownedName: `${string}eth`) => {
     if (domain.labelName !== name) {
       await context.db
         .update(domains, { id: node })
-        .set({ labelName: name, name: `${name}${ownedName}` });
+        .set({ labelName: name, name: `${name}.${ownedName}` });
     }
 
     await context.db.update(registrations, { id: label }).set({ labelName: name, cost });
@@ -79,7 +79,7 @@ export const makeRegistrarHandlers = (ownedName: `${string}eth`) => {
       context: Context;
       args: { name: string; label: Hex; cost: bigint };
     }) {
-      return await setNamePreimage(context, name, label, cost);
+      await setNamePreimage(context, name, label, cost);
     },
 
     async handleNameRenewedByController({
@@ -89,7 +89,7 @@ export const makeRegistrarHandlers = (ownedName: `${string}eth`) => {
       context: Context;
       args: { name: string; label: Hex; cost: bigint };
     }) {
-      return await setNamePreimage(context, name, label, cost);
+      await setNamePreimage(context, name, label, cost);
     },
 
     async handleNameRenewed({
@@ -117,7 +117,7 @@ export const makeRegistrarHandlers = (ownedName: `${string}eth`) => {
 
     async handleNameTransferred({
       context,
-      args: { tokenId, from, to },
+      args: { tokenId, to },
     }: {
       context: Context;
       args: {

src/handlers/Registry.ts

@@ -15,12 +15,15 @@ export async function setupRootNode({ context }: { context: Context }) {
   await upsertAccount(context, zeroAddress);
 
   // initialize the ENS root to be owned by the zeroAddress and not migrated
-  await context.db.insert(domains).values({
-    id: ROOT_NODE,
-    ownerId: zeroAddress,
-    createdAt: 0n,
-    isMigrated: false,
-  });
+  await context.db
+    .insert(domains)
+    .values({
+      id: ROOT_NODE,
+      ownerId: zeroAddress,
+      createdAt: 0n,
+      isMigrated: false,
+    })
+    .onConflictDoNothing();
 }
 
 function isDomainEmpty(domain: typeof domains.$inferSelect) {
@@ -89,36 +92,38 @@ export const handleNewOwner =
   }) => {
     const { label, node, owner } = event.args;
 
+    const parent = await context.db.find(domains, { id: node });
     const subnode = makeSubnodeNamehash(node, label);
 
+    const incrementSubdomainCountOnParent = async () =>
+      // only increment subdomainCount
+      Boolean(
+        // if the parent domain exists and
+        parent !== null &&
+          // the subdomain doesn't exist yet
+          (await context.db.find(domains, { id: subnode })),
+      );
+
     // ensure owner
     await upsertAccount(context, owner);
 
-    // note that we set isMigrated so that if this domain is being interacted with on the new registry, its migration status is set here
-    let domain = await context.db.find(domains, { id: subnode });
-    if (domain) {
-      // if the domain already exists, this is just an update of the owner record (& isMigrated)
-      await context.db.update(domains, { id: domain.id }).set({ ownerId: owner, isMigrated });
-    } else {
-      // otherwise create the domain
-      domain = await context.db.insert(domains).values({
+    const domain = await context.db
+      .insert(domains)
+      .values({
         id: subnode,
         ownerId: owner,
         parentId: node,
         createdAt: event.block.timestamp,
         isMigrated,
-      });
-
-      // and increment parent subdomainCount
-      await context.db
-        .update(domains, { id: node })
-        .set((row) => ({ subdomainCount: row.subdomainCount + 1 }));
-    }
+      })
+      .onConflictDoUpdate(() => ({
+        // if the domain already exists, this is just an update of the owner record (& isMigrated)
+        ownerId: owner,
+        isMigrated,
+      }));
 
     // if the domain doesn't yet have a name, construct it here
     if (!domain.name) {
-      const parent = await context.db.find(domains, { id: node });
-
       // TODO: implement sync rainbow table lookups
       // https://github.com/ensdomains/ens-subgraph/blob/master/src/ensRegistry.ts#L111
       const labelName = encodeLabelhash(label);
@@ -127,6 +132,12 @@ export const handleNewOwner =
       await context.db.update(domains, { id: domain.id }).set({ name, labelName });
     }
 
+    if (await incrementSubdomainCountOnParent()) {
+      await context.db
+        .update(domains, { id: parent!.id })
+        .set((row) => ({ subdomainCount: row.subdomainCount + 1 }));
+    }
+
     // garbage collect newly 'empty' domain iff necessary
     if (owner === zeroAddress) {
       await recursivelyRemoveEmptyDomainFromParentSubdomainCount(context, domain.id);

src/lib/helpers.ts

@@ -16,3 +16,55 @@ export const blockConfig = (
   startBlock: Math.min(Math.max(start || 0, startBlock), end || Number.MAX_SAFE_INTEGER),
   endBlock: end,
 });
+
+type AnyObject = { [key: string]: any };
+
+/**
+ * Deep merge two objects recursively.
+ * @param target The target object to merge into.
+ * @param source The source object to merge from.
+ * @returns The merged object.
+ * @see https://stackoverflow.com/a/48218209
+ * @example
+ * const obj1 = { a: 1, b: 2, c: { d: 3 } };
+ * const obj2 = { a: 4, c: { e: 5 } };
+ * const obj3 = deepMergeRecursive(obj1, obj2);
+ * // { a: 4, b: 2, c: { d: 3, e: 5 } }
+ */
+export function deepMergeRecursive<T extends AnyObject, U extends AnyObject>(
+  target: T,
+  source: U,
+): T & U {
+  const output = { ...target } as T & U;
+
+  function isObject(item: any): item is AnyObject {
+    return item && typeof item === "object" && !Array.isArray(item);
+  }
+
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isObject(source[key])) {
+        if (!(key in target)) {
+          Object.assign(output, { [key]: source[key] });
+        } else {
+          (output as AnyObject)[key] = deepMergeRecursive(
+            (target as AnyObject)[key],
+            (source as AnyObject)[key],
+          );
+        }
+      } else if (Array.isArray(source[key])) {
+        if (!(key in target)) {
+          Object.assign(output, { [key]: source[key] });
+        } else {
+          (output as AnyObject)[key] = Array.isArray((target as AnyObject)[key])
+            ? [...(target as AnyObject)[key], ...source[key]]
+            : source[key];
+        }
+      } else {
+        Object.assign(output, { [key]: source[key] });
+      }
+    });
+  }
+
+  return output;
+}

src/lib/plugin-helpers.ts

@@ -80,4 +80,47 @@ type PluginNamespacePath<T extends PluginNamespacePath = "/"> =
   | `/${string}${T}`;
 
 /** @var the requested active plugin name (see `src/plugins` for available plugins) */
-export const ACTIVE_PLUGIN = process.env.ACTIVE_PLUGIN;
+export const ACTIVE_PLUGINS = process.env.ACTIVE_PLUGINS;
+
+/**
+ * Returns the active plugins list based on the `ACTIVE_PLUGINS` environment variable.
+ *
+ * The `ACTIVE_PLUGINS` environment variable is a comma-separated list of plugin
+ * names. The function returns the plugins that are included in the list.
+ *
+ * @param plugins is a list of available plugins
+ * @returns the active plugins
+ */
+export function getActivePlugins<T extends { ownedName: string }>(plugins: readonly T[]): T[] {
+  const pluginsToActivateByOwnedName = ACTIVE_PLUGINS
+    ? ACTIVE_PLUGINS.split(",").map((p) => p.toLowerCase())
+    : [];
+
+  if (!pluginsToActivateByOwnedName.length) {
+    throw new Error("No active plugins found. Please set the ACTIVE_PLUGINS environment variable.");
+  }
+
+  // Check if the requested plugins are valid and can become active
+  const invalidPlugins = pluginsToActivateByOwnedName.filter(
+    (plugin) => !plugins.some((p) => p.ownedName === plugin),
+  );
+
+  if (invalidPlugins.length) {
+    // Throw an error if there are invalid plugins
+    throw new Error(
+      `Invalid plugin names found: ${invalidPlugins.join(
+        ", ",
+      )}. Please check the ACTIVE_PLUGINS environment variable.`,
+    );
+  }
+
+  // Return the active plugins
+  return plugins.filter((plugin) => pluginsToActivateByOwnedName.includes(plugin.ownedName));
+}
+
+// Helper type to get the intersection of all config types
+export type IntersectionOf<T> = (T extends any ? (x: T) => void : never) extends (
+  x: infer R,
+) => void
+  ? R
+  : never;

src/lib/upserts.ts

@@ -3,16 +3,16 @@ import { accounts, registrations, resolvers } from "ponder:schema";
 import type { Address } from "viem";
 
 export async function upsertAccount(context: Context, address: Address) {
-  return await context.db.insert(accounts).values({ id: address }).onConflictDoNothing();
+  return context.db.insert(accounts).values({ id: address }).onConflictDoNothing();
 }
 
 export async function upsertResolver(context: Context, values: typeof resolvers.$inferInsert) {
-  return await context.db.insert(resolvers).values(values).onConflictDoUpdate(values);
+  return context.db.insert(resolvers).values(values).onConflictDoUpdate(values);
 }
 
 export async function upsertRegistration(
   context: Context,
   values: typeof registrations.$inferInsert,
 ) {
-  return await context.db.insert(registrations).values(values).onConflictDoUpdate(values);
+  return context.db.insert(registrations).values(values).onConflictDoUpdate(values);
 }

src/plugins/README.md

@@ -1,8 +1,8 @@
 # Indexer plugins
 
 This directory contains plugins which allow defining subname-specific processing of blockchain events.
-Only one plugin can be active at a time. Use the `ACTIVE_PLUGIN` env variable to select the active plugin, for example:
+Only one plugin can be active at a time. Use the `ACTIVE_PLUGINS` env variable to select the active plugin, for example:
 
 ```
-ACTIVE_PLUGIN=base.eth
+ACTIVE_PLUGINS=base.eth
 ```