refactor(ensapi): apply operation result pattern

apps/ensadmin/src/app/mock/registrar-actions/mocks.ts

@@ -2,6 +2,7 @@ import {
   Duration,
   InterpretedName,
   NamedRegistrarAction,
+  OmnichainIndexingStatusIds,
   registrarActionsPrerequisites,
 } from "@ensnode/ensnode-sdk";
 
@@ -248,7 +249,7 @@ export const variants: Map<StatefulFetchStatusId, StatefulFetchRegistrarActions>
     StatefulFetchStatusIds.NotReady,
     {
       fetchStatus: StatefulFetchStatusIds.NotReady,
-      supportedIndexingStatusIds: registrarActionsPrerequisites.supportedIndexingStatusIds,
+      supportedIndexingStatusId: OmnichainIndexingStatusIds.Following,
     } satisfies StatefulFetchRegistrarActionsNotReady,
   ],
   [

apps/ensadmin/src/components/registrar-actions/display-registrar-actions-panel.tsx

@@ -153,19 +153,12 @@ export function DisplayRegistrarActionsPanel({
           <CardContent className="max-sm:p-3 max-sm:pt-0 flex flex-col gap-4">
             <p>The Registrar Actions API on the connected ENSNode instance is not available yet.</p>
             <p>
-              The Registrar Actions API will be available once the omnichain indexing status reaches
-              one of the following:
+              The Registrar Actions API will be available once the omnichain indexing status becomes{" "}
+              <Badge variant="secondary">
+                {formatOmnichainIndexingStatus(registrarActions.supportedIndexingStatusId)}
+              </Badge>
+              .
             </p>
-
-            <ul>
-              {registrarActions.supportedIndexingStatusIds.map((supportedStatusId) => (
-                <li className="inline" key={supportedStatusId}>
-                  <Badge variant="secondary">
-                    {formatOmnichainIndexingStatus(supportedStatusId)}
-                  </Badge>{" "}
-                </li>
-              ))}
-            </ul>
           </CardContent>
           <CardFooter className="gap-6">
             <Button asChild>

apps/ensadmin/src/components/registrar-actions/types.ts

@@ -1,4 +1,4 @@
-import { NamedRegistrarAction, OmnichainIndexingStatusId } from "@ensnode/ensnode-sdk";
+import { NamedRegistrarAction, OmnichainIndexingStatusIds } from "@ensnode/ensnode-sdk";
 
 export const StatefulFetchStatusIds = {
   /**
@@ -61,7 +61,9 @@ export interface StatefulFetchRegistrarActionsUnsupported {
  */
 export interface StatefulFetchRegistrarActionsNotReady {
   fetchStatus: typeof StatefulFetchStatusIds.NotReady;
-  supportedIndexingStatusIds: ReadonlyArray<OmnichainIndexingStatusId>;
+  supportedIndexingStatusId:
+    | typeof OmnichainIndexingStatusIds.Completed
+    | typeof OmnichainIndexingStatusIds.Following;
 }
 
 /**

apps/ensadmin/src/components/registrar-actions/use-stateful-fetch-registrar-actions.ts

@@ -1,5 +1,6 @@
 import { useENSNodeConfig, useRegistrarActions } from "@ensnode/ensnode-react";
 import {
+  getChainIndexingConfigTypeId,
   IndexingStatusResponseCodes,
   RegistrarActionsOrders,
   RegistrarActionsResponseCodes,
@@ -27,7 +28,7 @@ const {
   hasEnsIndexerConfigSupport,
   hasIndexingStatusSupport,
   requiredPlugins,
-  supportedIndexingStatusIds,
+  getSupportedIndexingStatus,
 } = registrarActionsPrerequisites;
 
 /**
@@ -51,10 +52,12 @@ export function useStatefulRegistrarActions({
   ) {
     const { ensIndexerPublicConfig } = ensNodeConfigQuery.data;
     const { omnichainSnapshot } = indexingStatusQuery.data.realtimeProjection.snapshot;
+    const chains = Array.from(omnichainSnapshot.chains.values());
+    const configTypeId = getChainIndexingConfigTypeId(chains);
 
     isRegistrarActionsApiSupported =
       hasEnsIndexerConfigSupport(ensIndexerPublicConfig) &&
-      hasIndexingStatusSupport(omnichainSnapshot.omnichainStatus);
+      hasIndexingStatusSupport(configTypeId, omnichainSnapshot.omnichainStatus);
   }
 
   // Note: ENSNode Registrar Actions API is available only in certain cases.
@@ -101,12 +104,14 @@ export function useStatefulRegistrarActions({
   }
 
   const { omnichainSnapshot } = indexingStatusQuery.data.realtimeProjection.snapshot;
+  const chains = Array.from(omnichainSnapshot.chains.values());
+  const configTypeId = getChainIndexingConfigTypeId(chains);
 
   // fetching is temporarily not possible due to indexing status being not advanced enough
-  if (!hasIndexingStatusSupport(omnichainSnapshot.omnichainStatus)) {
+  if (!hasIndexingStatusSupport(configTypeId, omnichainSnapshot.omnichainStatus)) {
     return {
       fetchStatus: StatefulFetchStatusIds.NotReady,
-      supportedIndexingStatusIds,
+      supportedIndexingStatusId: getSupportedIndexingStatus(configTypeId),
     } satisfies StatefulFetchRegistrarActionsNotReady;
   }
 

apps/ensapi/src/handlers/amirealtime-api.test.ts

@@ -1,8 +1,13 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import {
+  buildAmIRealtimeResultOk,
+  ChainIndexingConfigTypeIds,
+  ChainIndexingStatusIds,
+  type ChainIndexingStatusSnapshotFollowing,
   type CrossChainIndexingStatusSnapshot,
   createRealtimeIndexingStatusProjection,
+  OmnichainIndexingStatusIds,
   type UnixTimestamp,
 } from "@ensnode/ensnode-sdk";
 
@@ -25,15 +30,42 @@ describe("amirealtime-api", () => {
     slowestChainIndexingCursor,
   }: {
     now: UnixTimestamp;
-    slowestChainIndexingCursor?: UnixTimestamp;
+    slowestChainIndexingCursor: UnixTimestamp;
   }) => {
     indexingStatusMiddlewareMock.mockImplementation(async (c, next) => {
       const indexingStatus = {
-        slowestChainIndexingCursor: slowestChainIndexingCursor ?? now - 10,
+        omnichainSnapshot: {
+          omnichainStatus: OmnichainIndexingStatusIds.Following,
+          omnichainIndexingCursor: slowestChainIndexingCursor,
+          chains: new Map([
+            [
+              1,
+              {
+                chainStatus: ChainIndexingStatusIds.Following,
+                latestIndexedBlock: {
+                  timestamp: now - 10,
+                  number: 150,
+                },
+                latestKnownBlock: {
+                  timestamp: now,
+                  number: 151,
+                },
+                config: {
+                  configType: ChainIndexingConfigTypeIds.Indefinite,
+                  startBlock: {
+                    number: 100,
+                    timestamp: now - 1000,
+                  },
+                },
+              } satisfies ChainIndexingStatusSnapshotFollowing,
+            ],
+          ]),
+        } as CrossChainIndexingStatusSnapshot["omnichainSnapshot"],
         snapshotTime: now,
+        slowestChainIndexingCursor,
       } satisfies Pick<
         CrossChainIndexingStatusSnapshot,
-        "slowestChainIndexingCursor" | "snapshotTime"
+        "omnichainSnapshot" | "slowestChainIndexingCursor" | "snapshotTime"
       > as CrossChainIndexingStatusSnapshot;
 
       const realtimeProjection = createRealtimeIndexingStatusProjection(indexingStatus, now);
@@ -61,17 +93,21 @@ describe("amirealtime-api", () => {
     describe("request", () => {
       it("should accept valid maxWorstCaseDistance query param", async () => {
         // Arrange: set `indexingStatus` context var
-        arrangeMockedIndexingStatusMiddleware({ now });
+        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now - 10 });
 
         // Act
         const response = await app.request("http://localhost/amirealtime?maxWorstCaseDistance=300");
         const responseJson = await response.json();
 
         // Assert
         expect(response.status).toBe(200);
-        expect(responseJson).toMatchObject({
-          maxWorstCaseDistance: 300,
-        });
+        expect(responseJson).toStrictEqual(
+          buildAmIRealtimeResultOk({
+            maxWorstCaseDistance: 300,
+            worstCaseDistance: 10,
+            slowestChainIndexingCursor: now - 10,
+          }),
+        );
       });
 
       it("should accept valid maxWorstCaseDistance query param (set to `0`)", async () => {
@@ -84,44 +120,56 @@ describe("amirealtime-api", () => {
 
         // Assert
         expect(response.status).toBe(200);
-        expect(responseJson).toMatchObject({
-          maxWorstCaseDistance: 0,
-        });
+        expect(responseJson).toStrictEqual(
+          buildAmIRealtimeResultOk({
+            maxWorstCaseDistance: 0,
+            worstCaseDistance: 0,
+            slowestChainIndexingCursor: now,
+          }),
+        );
       });
 
       it("should use default maxWorstCaseDistance when unset", async () => {
         // Arrange: set `indexingStatus` context var
-        arrangeMockedIndexingStatusMiddleware({ now });
+        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now - 10 });
 
         // Act
         const response = await app.request("http://localhost/amirealtime?maxWorstCaseDistance");
         const responseJson = await response.json();
 
         // Assert
         expect(response.status).toBe(200);
-        expect(responseJson).toMatchObject({
-          maxWorstCaseDistance: AMIREALTIME_DEFAULT_MAX_WORST_CASE_DISTANCE,
-        });
+        expect(responseJson).toStrictEqual(
+          buildAmIRealtimeResultOk({
+            maxWorstCaseDistance: AMIREALTIME_DEFAULT_MAX_WORST_CASE_DISTANCE,
+            worstCaseDistance: 10,
+            slowestChainIndexingCursor: now - 10,
+          }),
+        );
       });
 
       it("should use default maxWorstCaseDistance when not provided", async () => {
         // Arrange: set `indexingStatus` context var
-        arrangeMockedIndexingStatusMiddleware({ now });
+        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now - 10 });
 
         // Act
         const response = await app.request("http://localhost/amirealtime");
         const responseJson = await response.json();
 
         // Assert
         expect(response.status).toBe(200);
-        expect(responseJson).toMatchObject({
-          maxWorstCaseDistance: AMIREALTIME_DEFAULT_MAX_WORST_CASE_DISTANCE,
-        });
+        expect(responseJson).toStrictEqual(
+          buildAmIRealtimeResultOk({
+            maxWorstCaseDistance: AMIREALTIME_DEFAULT_MAX_WORST_CASE_DISTANCE,
+            worstCaseDistance: 10,
+            slowestChainIndexingCursor: now - 10,
+          }),
+        );
       });
 
       it("should reject invalid maxWorstCaseDistance (negative number)", async () => {
         // Arrange: set `indexingStatus` context var
-        arrangeMockedIndexingStatusMiddleware({ now });
+        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now - 10 });
 
         // Act
         const response = await app.request("http://localhost/amirealtime?maxWorstCaseDistance=-1");
@@ -135,7 +183,7 @@ describe("amirealtime-api", () => {
 
       it("should reject invalid maxWorstCaseDistance (not a number)", async () => {
         // Arrange: set `indexingStatus` context var
-        arrangeMockedIndexingStatusMiddleware({ now });
+        arrangeMockedIndexingStatusMiddleware({ now, slowestChainIndexingCursor: now - 10 });
 
         // Act
         const response = await app.request(
@@ -161,11 +209,13 @@ describe("amirealtime-api", () => {
 
         // Assert
         expect(response.status).toBe(200);
-        expect(responseJson).toMatchObject({
-          maxWorstCaseDistance: 10,
-          slowestChainIndexingCursor: 1766123720,
-          worstCaseDistance: 9,
-        });
+        expect(responseJson).toStrictEqual(
+          buildAmIRealtimeResultOk({
+            maxWorstCaseDistance: 10,
+            slowestChainIndexingCursor: now - 9,
+            worstCaseDistance: 9,
+          }),
+        );
       });
 
       it("should return 200 when worstCaseDistance equals maxWorstCaseDistance", async () => {
@@ -178,11 +228,13 @@ describe("amirealtime-api", () => {
 
         // Assert
         expect(response.status).toBe(200);
-        expect(responseJson).toMatchObject({
-          maxWorstCaseDistance: 10,
-          slowestChainIndexingCursor: 1766123719,
-          worstCaseDistance: 10,
-        });
+        expect(responseJson).toStrictEqual(
+          buildAmIRealtimeResultOk({
+            maxWorstCaseDistance: 10,
+            slowestChainIndexingCursor: 1766123719,
+            worstCaseDistance: 10,
+          }),
+        );
       });
 
       it("should return 503 when worstCaseDistance exceeds maxWorstCaseDistance", async () => {
@@ -195,13 +247,13 @@ describe("amirealtime-api", () => {
 
         // Assert
         expect(response.status).toBe(503);
-        expect(responseJson).toHaveProperty("message");
-        expect(responseJson.message).toMatch(
+        expect(responseJson).toHaveProperty("errorMessage");
+        expect(responseJson.errorMessage).toMatch(
           /Indexing Status 'worstCaseDistance' must be below or equal to the requested 'maxWorstCaseDistance'; worstCaseDistance = 11; maxWorstCaseDistance = 10/,
         );
       });
 
-      it("should return 500 when indexing status has not been resolved", async () => {
+      it("should return 503 when indexing status has not been resolved", async () => {
         // Arrange: set `indexingStatus` context var
         indexingStatusMiddlewareMock.mockImplementation(async (c, next) => {
           c.set("indexingStatus", new Error("Network error"));
@@ -215,9 +267,9 @@ describe("amirealtime-api", () => {
 
         // Assert
         expect(response.status).toBe(503);
-        expect(responseJson).toHaveProperty("message");
-        expect(responseJson.message).toMatch(
-          /Indexing Status has to be resolved successfully before 'maxWorstCaseDistance' can be applied./,
+        expect(responseJson).toHaveProperty("errorMessage");
+        expect(responseJson.errorMessage).toMatch(
+          /Indexing Status must be resolved successfully before 'maxWorstCaseDistance' can be applied./,
         );
       });
     });