Ensure valid ENSRainbow connection before indexing starts

.changeset/whole-lines-smoke.md

@@ -0,0 +1,5 @@
+---
+"@ensnode/ensdb-sdk": minor
+---
+
+Extended the ENSNode Metadata with ENSRainbow Public Config.

apps/ensindexer/src/lib/ensdb-writer-worker/ensdb-writer-worker.test.ts

@@ -263,21 +263,28 @@ describe("EnsDbWriterWorker", () => {
   });
 
   describe("interval behavior - snapshot upserts", () => {
-    it("continues upserting after snapshot validation errors", async () => {
+    it("upserts snapshots across different omnichain statuses", async () => {
       // arrange
       const unstartedSnapshot = createMockOmnichainSnapshot({
         omnichainStatus: OmnichainIndexingStatusIds.Unstarted,
       });
       const validSnapshot = createMockOmnichainSnapshot({
         omnichainIndexingCursor: 200,
       });
-      const crossChainSnapshot = createMockCrossChainSnapshot({
+      const unstartedCrossChainSnapshot = createMockCrossChainSnapshot({
+        slowestChainIndexingCursor: 100,
+        snapshotTime: 200,
+        omnichainSnapshot: unstartedSnapshot,
+      });
+      const validCrossChainSnapshot = createMockCrossChainSnapshot({
         slowestChainIndexingCursor: 200,
         snapshotTime: 300,
         omnichainSnapshot: validSnapshot,
       });
 
-      vi.mocked(buildCrossChainIndexingStatusSnapshotOmnichain).mockReturnValue(crossChainSnapshot);
+      vi.mocked(buildCrossChainIndexingStatusSnapshotOmnichain)
+        .mockReturnValueOnce(unstartedCrossChainSnapshot)
+        .mockReturnValueOnce(validCrossChainSnapshot);
 
       const ensDbClient = createMockEnsDbWriter();
       const indexingStatusBuilder = {
@@ -299,8 +306,15 @@ describe("EnsDbWriterWorker", () => {
 
       // assert
       expect(indexingStatusBuilder.getOmnichainIndexingStatusSnapshot).toHaveBeenCalledTimes(2);
-      expect(ensDbClient.upsertIndexingStatusSnapshot).toHaveBeenCalledTimes(1);
-      expect(ensDbClient.upsertIndexingStatusSnapshot).toHaveBeenCalledWith(crossChainSnapshot);
+      expect(ensDbClient.upsertIndexingStatusSnapshot).toHaveBeenCalledTimes(2);
+      expect(ensDbClient.upsertIndexingStatusSnapshot).toHaveBeenNthCalledWith(
+        1,
+        unstartedCrossChainSnapshot,
+      );
+      expect(ensDbClient.upsertIndexingStatusSnapshot).toHaveBeenNthCalledWith(
+        2,
+        validCrossChainSnapshot,
+      );
 
       // cleanup
       worker.stop();

apps/ensindexer/src/lib/ensdb-writer-worker/ensdb-writer-worker.ts

@@ -7,8 +7,6 @@ import {
   type CrossChainIndexingStatusSnapshot,
   type Duration,
   type EnsIndexerPublicConfig,
-  OmnichainIndexingStatusIds,
-  type OmnichainIndexingStatusSnapshot,
   validateEnsIndexerPublicConfigCompatibility,
 } from "@ensnode/ensnode-sdk";
 import type { LocalPonderClient } from "@ensnode/ponder-sdk";
@@ -260,7 +258,8 @@ export class EnsDbWriterWorker {
       // get system timestamp for the current iteration
       const snapshotTime = getUnixTime(new Date());
 
-      const omnichainSnapshot = await this.getValidatedIndexingStatusSnapshot();
+      const omnichainSnapshot =
+        await this.indexingStatusBuilder.getOmnichainIndexingStatusSnapshot();
 
       const crossChainSnapshot = buildCrossChainIndexingStatusSnapshotOmnichain(
         omnichainSnapshot,
@@ -278,24 +277,4 @@ export class EnsDbWriterWorker {
       // should not cause the ENSDb Writer Worker to stop functioning.
     }
   }
-
-  /**
-   * Get validated Omnichain Indexing Status Snapshot
-   *
-   * @returns Validated Omnichain Indexing Status Snapshot.
-   * @throws Error if the Omnichain Indexing Status is not in expected status yet.
-   */
-  private async getValidatedIndexingStatusSnapshot(): Promise<OmnichainIndexingStatusSnapshot> {
-    const omnichainSnapshot = await this.indexingStatusBuilder.getOmnichainIndexingStatusSnapshot();
-
-    // It only makes sense to write Indexing Status Snapshots into ENSDb once
-    // the indexing process has started, as before that there is no meaningful
-    // status to record.
-    // Invariant: the Omnichain Status must indicate that indexing has started already.
-    if (omnichainSnapshot.omnichainStatus === OmnichainIndexingStatusIds.Unstarted) {
-      throw new Error("Omnichain Status must not be 'Unstarted'.");
-    }
-
-    return omnichainSnapshot;
-  }
 }

apps/ensindexer/src/lib/ensrainbow/singleton.ts

@@ -3,6 +3,7 @@ import config from "@/config";
 import { secondsToMilliseconds } from "date-fns";
 import pRetry from "p-retry";
 
+import type { Duration } from "@ensnode/ensnode-sdk";
 import { EnsRainbowApiClient } from "@ensnode/ensrainbow-sdk";
 
 import { logger } from "@/lib/logger";
@@ -47,28 +48,34 @@ let waitForEnsRainbowToBeReadyPromise: Promise<void> | undefined;
  *         This error will trigger termination of the ENSIndexer process.
  */
 export function waitForEnsRainbowToBeReady(): Promise<void> {
-  if (waitForEnsRainbowToBeReadyPromise) {
-    return waitForEnsRainbowToBeReadyPromise;
-  }
+  if (waitForEnsRainbowToBeReadyPromise) return waitForEnsRainbowToBeReadyPromise;
 
   logger.info({
     msg: `Waiting for ENSRainbow instance to be ready`,
     ensRainbowInstance: ensRainbowUrl.href,
   });
 
+  const retryInterval: Duration = 5;
+  const retryIntervalMs = secondsToMilliseconds(retryInterval);
+  const retriesPerMinute = 60 / retryInterval;
+
   waitForEnsRainbowToBeReadyPromise = pRetry(async () => ensRainbowClient.health(), {
-    retries: 60, // This allows for a total of over 1 hour of retries with 1 minute between attempts.
-    minTimeout: secondsToMilliseconds(60),
-    maxTimeout: secondsToMilliseconds(60),
+    retries: retriesPerMinute * 60, // This allows for a total of over 1 hour of retries with `retryInterval` between attempts.
+    minTimeout: retryIntervalMs,
+    maxTimeout: retryIntervalMs,
     onFailedAttempt: ({ error, attemptNumber, retriesLeft }) => {
-      logger.warn({
-        msg: `ENSRainbow health check failed`,
-        attempt: attemptNumber,
-        retriesLeft,
-        error: retriesLeft === 0 ? error : undefined,
-        ensRainbowInstance: ensRainbowUrl.href,
-        advice: `This might be due to ENSRainbow having a cold start, which can take 30+ minutes.`,
-      });
+      // Log once every minute to avoid excessive logging during ENSRainbow cold start,
+      // while still providing visibility into the retry process.
+      if (attemptNumber % 12 === 0) {
+        logger.warn({
+          msg: `ENSRainbow health check failed`,
+          attempt: attemptNumber,
+          retriesLeft,
+          error: retriesLeft === 0 ? error : undefined,
+          ensRainbowInstance: ensRainbowUrl.href,
+          advice: `This might be due to ENSRainbow having a cold start, which can take 30+ minutes.`,
+        });
+      }
     },
   })
     .then(() => {
@@ -78,18 +85,13 @@ export function waitForEnsRainbowToBeReady(): Promise<void> {
       });
     })
     .catch((error) => {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-
       logger.error({
         msg: `ENSRainbow health check failed after multiple attempts`,
         error,
         ensRainbowInstance: ensRainbowUrl.href,
       });
 
-      // Throw the error to terminate the ENSIndexer process due to the failed health check of a critical dependency
-      throw new Error(errorMessage, {
-        cause: error instanceof Error ? error : undefined,
-      });
+      throw error;
     });
 
   return waitForEnsRainbowToBeReadyPromise;