diff --git a/apps/ensadmin/src/app/mock/registrar-actions/mocks.ts b/apps/ensadmin/src/app/mock/registrar-actions/mocks.ts
index 28eb8af5d..6abb834b2 100644
--- a/apps/ensadmin/src/app/mock/registrar-actions/mocks.ts
+++ b/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,
   ],
   [
diff --git a/apps/ensadmin/src/components/registrar-actions/display-registrar-actions-panel.tsx b/apps/ensadmin/src/components/registrar-actions/display-registrar-actions-panel.tsx
index 7a176e884..af5587ca8 100644
--- a/apps/ensadmin/src/components/registrar-actions/display-registrar-actions-panel.tsx
+++ b/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>
diff --git a/apps/ensadmin/src/components/registrar-actions/types.ts b/apps/ensadmin/src/components/registrar-actions/types.ts
index b71a68417..cf70c96fa 100644
--- a/apps/ensadmin/src/components/registrar-actions/types.ts
+++ b/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;
 }
 
 /**
diff --git a/apps/ensadmin/src/components/registrar-actions/use-stateful-fetch-registrar-actions.ts b/apps/ensadmin/src/components/registrar-actions/use-stateful-fetch-registrar-actions.ts
index 7e9fd63af..34faa1b4d 100644
--- a/apps/ensadmin/src/components/registrar-actions/use-stateful-fetch-registrar-actions.ts
+++ b/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;
   }
 
diff --git a/apps/ensapi/src/handlers/amirealtime-api.test.ts b/apps/ensapi/src/handlers/amirealtime-api.test.ts
index b49d57b27..2174d09b4 100644
--- a/apps/ensapi/src/handlers/amirealtime-api.test.ts
+++ b/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,7 +93,7 @@ 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");
@@ -69,9 +101,13 @@ describe("amirealtime-api", () => {
 
         // 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,14 +120,18 @@ 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");
@@ -99,14 +139,18 @@ describe("amirealtime-api", () => {
 
         // 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");
@@ -114,14 +158,18 @@ describe("amirealtime-api", () => {
 
         // 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./,
         );
       });
     });
diff --git a/apps/ensapi/src/handlers/amirealtime-api.ts b/apps/ensapi/src/handlers/amirealtime-api.ts
index a9a40ab5f..14704b91c 100644
--- a/apps/ensapi/src/handlers/amirealtime-api.ts
+++ b/apps/ensapi/src/handlers/amirealtime-api.ts
@@ -1,14 +1,32 @@
 import { minutesToSeconds } from "date-fns";
-import { describeRoute } from "hono-openapi";
+import { describeRoute, resolver as responseSchemaResolver } from "hono-openapi";
 import z from "zod/v4";
 
-import type { Duration } from "@ensnode/ensnode-sdk";
-import { makeDurationSchema } from "@ensnode/ensnode-sdk/internal";
+import {
+  buildAmIRealtimeResultOk,
+  buildResultInsufficientIndexingProgress,
+  buildResultInternalServerError,
+  buildResultInvalidRequest,
+  buildResultServiceUnavailable,
+  type Duration,
+  getSufficientIndexingProgressChainCursor,
+  getTimestampForLowestOmnichainStartBlock,
+  OmnichainIndexingStatusIds,
+  ResultCodes,
+} from "@ensnode/ensnode-sdk";
+import {
+  makeAmIRealtimeResultOkSchema,
+  makeDurationSchema,
+  makeResultErrorInsufficientIndexingProgressSchema,
+  makeResultErrorInternalServerErrorSchema,
+  makeResultErrorInvalidRequestSchema,
+  makeResultErrorServiceUnavailableSchema,
+} from "@ensnode/ensnode-sdk/internal";
 
-import { errorResponse } from "@/lib/handlers/error-response";
 import { params } from "@/lib/handlers/params.schema";
 import { validate } from "@/lib/handlers/validate";
 import { factory } from "@/lib/hono-factory";
+import { resultIntoHttpResponse } from "@/lib/result/result-into-http-response";
 
 const app = factory.createApp();
 
@@ -28,10 +46,96 @@ app.get(
       200: {
         description:
           "Indexing progress is guaranteed to be within the requested distance of realtime",
+        content: {
+          "application/json": {
+            schema: responseSchemaResolver(makeAmIRealtimeResultOkSchema()),
+            examples: {
+              [`Result Code: ${ResultCodes.Ok}`]: {
+                summary: '"Am I Realtime?" API indexing progress is within requested distance',
+                value: buildAmIRealtimeResultOk({
+                  maxWorstCaseDistance: 12,
+                  slowestChainIndexingCursor: 1768999701,
+                  worstCaseDistance: 9,
+                }),
+                description:
+                  "The connected ENSIndexer has sufficient omnichain indexing progress to serve this request.",
+              },
+            },
+          },
+        },
+      },
+      400: {
+        description: "Invalid request parameters",
+        content: {
+          "application/json": {
+            schema: responseSchemaResolver(makeResultErrorInvalidRequestSchema()),
+            examples: {
+              [`Result Code: ${ResultCodes.InvalidRequest}`]: {
+                summary: '"Am I Realtime?" API invalid request',
+                value: buildResultInvalidRequest(
+                  "maxWorstCaseDistance query param must be a non-negative integer (>=0)",
+                ),
+                description:
+                  "The provided `maxWorstCaseDistance` query parameter is a negative integer.",
+              },
+            },
+          },
+        },
+      },
+      500: {
+        description: "Indexing progress cannot be determined due to an internal server error",
+        content: {
+          "application/json": {
+            schema: responseSchemaResolver(makeResultErrorInternalServerErrorSchema()),
+            examples: {
+              [`Result Code: ${ResultCodes.InternalServerError}`]: {
+                summary: '"Am I Realtime?" API internal server error',
+                value: buildResultInternalServerError(
+                  '"Am I Realtime?" API is currently experiencing an internal server error.',
+                ),
+                description: "External service or dependency is unavailable.",
+              },
+            },
+          },
+        },
       },
       503: {
         description:
           "Indexing progress is not guaranteed to be within the requested distance of realtime or indexing status unavailable",
+        content: {
+          "application/json": {
+            schema: responseSchemaResolver(
+              z.discriminatedUnion("resultCode", [
+                makeResultErrorServiceUnavailableSchema(),
+                makeResultErrorInsufficientIndexingProgressSchema(),
+              ]),
+            ),
+            examples: {
+              [`Result Code: ${ResultCodes.ServiceUnavailable}`]: {
+                summary: '"Am I Realtime?" API is unavailable',
+                value: buildResultServiceUnavailable(
+                  '"Am I Realtime?" API is currently unavailable.',
+                ),
+                description: "External service or dependency is unavailable.",
+              },
+              [`Result Code: ${ResultCodes.InsufficientIndexingProgress}`]: {
+                summary: '"Am I Realtime?" API has insufficient indexing progress',
+                value: buildResultInsufficientIndexingProgress(
+                  "Indexing Status 'worstCaseDistance' must be below or equal to the requested 'maxWorstCaseDistance'; worstCaseDistance = 12; maxWorstCaseDistance = 10",
+                  {
+                    indexingStatus: "omnichain-following",
+                    slowestChainIndexingCursor: 1768998722,
+                    earliestChainIndexingCursor: 1489165544,
+                    progressSufficientFrom: {
+                      indexingStatus: "omnichain-following",
+                      chainIndexingCursor: 1768998731,
+                    },
+                  },
+                ),
+              },
+            },
+          },
+        },
       },
     },
   }),
@@ -46,41 +150,61 @@ app.get(
     }),
   ),
   async (c) => {
-    // context must be set by the required middleware
     if (c.var.indexingStatus === undefined) {
-      throw new Error(`Invariant(amirealtime-api): indexingStatusMiddleware required.`);
+      const result = buildResultInternalServerError(
+        `Invariant(amirealtime-api): Indexing Status must be available in application context.`,
+      );
+
+      return resultIntoHttpResponse(c, result);
     }
 
-    // return 503 response error with details on prerequisite being unavailable
     if (c.var.indexingStatus instanceof Error) {
-      return errorResponse(
-        c,
-        `Invariant(amirealtime-api): Indexing Status has to be resolved successfully before 'maxWorstCaseDistance' can be applied.`,
-        503,
+      const result = buildResultServiceUnavailable(
+        `Invariant(amirealtime-api): Indexing Status must be resolved successfully before 'maxWorstCaseDistance' can be applied.`,
       );
+
+      return resultIntoHttpResponse(c, result);
     }
 
     const { maxWorstCaseDistance } = c.req.valid("query");
     const { worstCaseDistance, snapshot } = c.var.indexingStatus;
-    const { slowestChainIndexingCursor } = snapshot;
+    const { slowestChainIndexingCursor, omnichainSnapshot } = snapshot;
+    const chains = Array.from(omnichainSnapshot.chains.values());
 
-    // return 503 response error with details on
-    // requested `maxWorstCaseDistance` vs. actual `worstCaseDistance`
+    // Case: worst-case distance exceeds requested maximum
     if (worstCaseDistance > maxWorstCaseDistance) {
-      return errorResponse(
-        c,
+      const earliestChainIndexingCursor = getTimestampForLowestOmnichainStartBlock(chains);
+      const progressSufficientFromChainIndexingCursor = getSufficientIndexingProgressChainCursor(
+        slowestChainIndexingCursor,
+        worstCaseDistance,
+        maxWorstCaseDistance,
+      );
+
+      const result = buildResultInsufficientIndexingProgress(
         `Indexing Status 'worstCaseDistance' must be below or equal to the requested 'maxWorstCaseDistance'; worstCaseDistance = ${worstCaseDistance}; maxWorstCaseDistance = ${maxWorstCaseDistance}`,
-        503,
+        {
+          indexingStatus: omnichainSnapshot.omnichainStatus,
+          slowestChainIndexingCursor,
+          earliestChainIndexingCursor,
+          progressSufficientFrom: {
+            indexingStatus: OmnichainIndexingStatusIds.Following,
+            chainIndexingCursor: progressSufficientFromChainIndexingCursor,
+          },
+        },
       );
+
+      return resultIntoHttpResponse(c, result);
     }
 
-    // return 200 response OK with current details on `maxWorstCaseDistance`,
-    // `slowestChainIndexingCursor`, and `worstCaseDistance`
-    return c.json({
+    // Case: worst-case distance is within requested maximum
+
+    const result = buildAmIRealtimeResultOk({
       maxWorstCaseDistance,
       slowestChainIndexingCursor,
       worstCaseDistance,
     });
+
+    return resultIntoHttpResponse(c, result);
   },
 );
 
diff --git a/apps/ensapi/src/handlers/registrar-actions-api.ts b/apps/ensapi/src/handlers/registrar-actions-api.ts
index f854195a1..f90dfefcc 100644
--- a/apps/ensapi/src/handlers/registrar-actions-api.ts
+++ b/apps/ensapi/src/handlers/registrar-actions-api.ts
@@ -1,23 +1,33 @@
-import { describeRoute } from "hono-openapi";
+import { describeRoute, resolver as responseSchemaResolver } from "hono-openapi";
 import z from "zod/v4";
 
 import {
   buildPageContext,
+  buildRegistrarActionsResultOk,
+  buildResultInsufficientIndexingProgress,
+  buildResultInternalServerError,
+  buildResultInvalidRequest,
+  buildResultServiceUnavailable,
+  type InterpretedName,
   type Node,
   RECORDS_PER_PAGE_DEFAULT,
   RECORDS_PER_PAGE_MAX,
   type RegistrarActionsFilter,
   RegistrarActionsOrders,
-  RegistrarActionsResponseCodes,
-  type RegistrarActionsResponseError,
-  type RegistrarActionsResponseOk,
+  RegistrarActionTypes,
+  ResultCodes,
   registrarActionsFilter,
-  serializeRegistrarActionsResponse,
+  serializeRegistrarActionsResultOk,
 } from "@ensnode/ensnode-sdk";
 import {
   makeLowercaseAddressSchema,
   makeNodeSchema,
   makePositiveIntegerSchema,
+  makeResultErrorInsufficientIndexingProgressSchema,
+  makeResultErrorInternalServerErrorSchema,
+  makeResultErrorInvalidRequestSchema,
+  makeResultErrorServiceUnavailableSchema,
+  makeSerializedRegistrarActionsResultOkSchema,
   makeUnixTimestampSchema,
 } from "@ensnode/ensnode-sdk/internal";
 
@@ -26,6 +36,7 @@ import { validate } from "@/lib/handlers/validate";
 import { factory } from "@/lib/hono-factory";
 import { makeLogger } from "@/lib/logger";
 import { findRegistrarActions } from "@/lib/registrar-actions/find-registrar-actions";
+import { resultIntoHttpResponse } from "@/lib/result/result-into-http-response";
 import { registrarActionsApiMiddleware } from "@/middleware/registrar-actions.middleware";
 
 const app = factory.createApp();
@@ -147,6 +158,150 @@ async function fetchRegistrarActions(
   return { registrarActions, pageContext };
 }
 
+const routeResponsesDescription = {
+  200: {
+    description: "Successfully retrieved registrar actions",
+    content: {
+      "application/json": {
+        schema: responseSchemaResolver(makeSerializedRegistrarActionsResultOkSchema()),
+        examples: {
+          [`Result Code: ${ResultCodes.Ok}`]: {
+            summary: "Successfully retrieved registrar actions",
+            value: serializeRegistrarActionsResultOk(
+              buildRegistrarActionsResultOk(
+                {
+                  registrarActions: [
+                    {
+                      action: {
+                        id: "176901653900000000000000010000000024284662000000000000016650000000000000521",
+                        type: RegistrarActionTypes.Registration,
+                        incrementalDuration: 31536000,
+                        registrant: "0x5438f076431321224969fc258d1c99d340b8af5a",
+                        registrationLifecycle: {
+                          subregistry: {
+                            subregistryId: {
+                              chainId: 1,
+                              address: "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85",
+                            },
+                            node: "0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae",
+                          },
+                          node: "0x286f7fa67d93511310a9f9e21e54b780eb3cf8e4887e20d6e6d6c59e2b1a0213",
+                          expiresAt: 1800552539,
+                        },
+                        pricing: {
+                          baseCost: {
+                            currency: "ETH",
+                            amount: BigInt("1726125951960390"),
+                          },
+                          premium: {
+                            currency: "ETH",
+                            amount: BigInt("591384407687275916"),
+                          },
+                          total: {
+                            currency: "ETH",
+                            amount: BigInt("593110533639236306"),
+                          },
+                        },
+                        referral: {
+                          encodedReferrer:
+                            "0x0000000000000000000000007e491cde0fbf08e51f54c4fb6b9e24afbd18966d",
+                          decodedReferrer: "0x7e491cde0fbf08e51f54c4fb6b9e24afbd18966d",
+                        },
+                        block: {
+                          number: 24284662,
+                          timestamp: 1769016539,
+                        },
+                        transactionHash:
+                          "0xb87a54ebb64e2ebc581127e7f71f7c56090a5c92583ce238644ce3ec23e1c13c",
+                        eventIds: [
+                          "176901653900000000000000010000000024284662000000000000016650000000000000521",
+                          "176901653900000000000000010000000024284662000000000000016650000000000000525",
+                        ],
+                      },
+                      name: "export.eth" as InterpretedName,
+                    },
+                  ],
+                  pageContext: buildPageContext(1, 10, 0),
+                },
+                1700000000,
+              ),
+            ),
+          },
+        },
+      },
+    },
+  },
+  400: {
+    description: "Invalid request parameters",
+    content: {
+      "application/json": {
+        schema: responseSchemaResolver(makeResultErrorInvalidRequestSchema()),
+        examples: {
+          [`Result Code: ${ResultCodes.InvalidRequest}`]: {
+            summary: "Registrar Actions API invalid request",
+            value: buildResultInvalidRequest(
+              "parentNode param must be a hexadecimal value which starts with '0x'",
+            ),
+            description: "The provided `parentNode` query parameter is not a hexadecimal value.",
+          },
+        },
+      },
+    },
+  },
+  500: {
+    description: "An internal server error occurred",
+    content: {
+      "application/json": {
+        schema: responseSchemaResolver(makeResultErrorInternalServerErrorSchema()),
+        examples: {
+          [`Result Code: ${ResultCodes.InternalServerError}`]: {
+            summary: "Registrar Actions API internal server error",
+            value: buildResultInternalServerError(
+              "Internal server error occurred in Registrar Actions API.",
+            ),
+            description: "External service or dependency is unavailable.",
+          },
+        },
+      },
+    },
+  },
+  503: {
+    description: "Registrar Actions API is unavailable",
+    content: {
+      "application/json": {
+        schema: responseSchemaResolver(
+          z.discriminatedUnion("resultCode", [
+            makeResultErrorServiceUnavailableSchema(),
+            makeResultErrorInsufficientIndexingProgressSchema(),
+          ]),
+        ),
+        examples: {
+          [`Result Code: ${ResultCodes.ServiceUnavailable}`]: {
+            summary: "Registrar Actions API is unavailable",
+            value: buildResultServiceUnavailable("Registrar Actions API is currently unavailable."),
+            description: "External service or dependency is unavailable.",
+          },
+          [`Result Code: ${ResultCodes.InsufficientIndexingProgress}`]: {
+            summary: "Registrar Actions API has insufficient indexing progress",
+            value: buildResultInsufficientIndexingProgress(
+              "The connected ENSIndexer has insufficient omnichain indexing progress to serve this request.",
+              {
+                indexingStatus: "omnichain-backfill",
+                slowestChainIndexingCursor: 1700000000,
+                earliestChainIndexingCursor: 1690000000,
+                progressSufficientFrom: {
+                  indexingStatus: "omnichain-following",
+                  chainIndexingCursor: 1705000000,
+                },
+              },
+            ),
+          },
+        },
+      },
+    },
+  },
+};
+
 /**
  * Get Registrar Actions (all records)
  *
@@ -160,46 +315,57 @@ app.get(
     tags: ["Explore"],
     summary: "Get Registrar Actions",
     description: "Returns all registrar actions with optional filtering and pagination",
-    responses: {
-      200: {
-        description: "Successfully retrieved registrar actions",
-      },
-      400: {
-        description: "Invalid query",
-      },
-      500: {
-        description: "Internal server error",
-      },
-    },
+    responses: routeResponsesDescription,
   }),
   validate("query", registrarActionsQuerySchema),
   async (c) => {
+    // Middleware ensures indexingStatus is available and not an Error
+    // This check is for TypeScript type safety, should never occur in
+    // practice.
+    if (c.var.indexingStatus === undefined) {
+      const result = buildResultInternalServerError(
+        `Invariant(registrar-actions-api): Indexing Status must be available in application context.`,
+      );
+
+      return resultIntoHttpResponse(c, result);
+    }
+
+    if (c.var.indexingStatus instanceof Error) {
+      const result = buildResultServiceUnavailable(
+        `Invariant(registrar-actions-api): Indexing Status must be resolved successfully before Registrar Actions API can be served.`,
+      );
+
+      return resultIntoHttpResponse(c, result);
+    }
+
+    const query = c.req.valid("query");
+
     try {
-      const query = c.req.valid("query");
       const { registrarActions, pageContext } = await fetchRegistrarActions(undefined, query);
 
-      // respond with success response
-      return c.json(
-        serializeRegistrarActionsResponse({
-          responseCode: RegistrarActionsResponseCodes.Ok,
+      // Get the accurateAsOf timestamp from the slowest chain indexing cursor
+      const accurateAsOf = c.var.indexingStatus.snapshot.slowestChainIndexingCursor;
+
+      const result = buildRegistrarActionsResultOk(
+        {
           registrarActions,
           pageContext,
-        } satisfies RegistrarActionsResponseOk),
+        },
+        accurateAsOf,
       );
+
+      const serializedResult = serializeRegistrarActionsResultOk(result);
+
+      return resultIntoHttpResponse(c, serializedResult);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
       logger.error(errorMessage);
 
-      // respond with 500 error response
-      return c.json(
-        serializeRegistrarActionsResponse({
-          responseCode: RegistrarActionsResponseCodes.Error,
-          error: {
-            message: `Registrar Actions API Response is unavailable`,
-          },
-        } satisfies RegistrarActionsResponseError),
-        500,
+      const result = buildResultServiceUnavailable(
+        `Registrar Actions API Response is unavailable due to following error: ${errorMessage}`,
       );
+
+      return resultIntoHttpResponse(c, result);
     }
   },
 );
@@ -243,17 +409,7 @@ app.get(
     summary: "Get Registrar Actions by Parent Node",
     description:
       "Returns registrar actions filtered by parent node hash with optional additional filtering and pagination",
-    responses: {
-      200: {
-        description: "Successfully retrieved registrar actions",
-      },
-      400: {
-        description: "Invalid input",
-      },
-      500: {
-        description: "Internal server error",
-      },
-    },
+    responses: routeResponsesDescription,
   }),
   validate(
     "param",
@@ -265,43 +421,54 @@ app.get(
   ),
   validate("query", registrarActionsQuerySchema),
   async (c) => {
-    try {
-      // Middleware ensures indexingStatus is available and not an Error
-      // This check is for TypeScript type safety
-      if (!c.var.indexingStatus || c.var.indexingStatus instanceof Error) {
-        throw new Error("Invariant violation: indexingStatus should be validated by middleware");
-      }
+    // Middleware ensures indexingStatus is available and not an Error
+    // This check is for TypeScript type safety, should never occur in
+    // practice.
+    if (c.var.indexingStatus === undefined) {
+      const result = buildResultInternalServerError(
+        `Invariant(registrar-actions-api): Indexing Status must be available in application context.`,
+      );
+
+      return resultIntoHttpResponse(c, result);
+    }
+
+    if (c.var.indexingStatus instanceof Error) {
+      const result = buildResultServiceUnavailable(
+        `Invariant(registrar-actions-api): Indexing Status must be resolved successfully before Registrar Actions API can be served.`,
+      );
+
+      return resultIntoHttpResponse(c, result);
+    }
+
+    const { parentNode } = c.req.valid("param");
+    const query = c.req.valid("query");
 
-      const { parentNode } = c.req.valid("param");
-      const query = c.req.valid("query");
+    try {
       const { registrarActions, pageContext } = await fetchRegistrarActions(parentNode, query);
 
       // Get the accurateAsOf timestamp from the slowest chain indexing cursor
       const accurateAsOf = c.var.indexingStatus.snapshot.slowestChainIndexingCursor;
 
-      // respond with success response
-      return c.json(
-        serializeRegistrarActionsResponse({
-          responseCode: RegistrarActionsResponseCodes.Ok,
+      const result = buildRegistrarActionsResultOk(
+        {
           registrarActions,
           pageContext,
-          accurateAsOf,
-        } satisfies RegistrarActionsResponseOk),
+        },
+        accurateAsOf,
       );
+
+      const serializedResult = serializeRegistrarActionsResultOk(result);
+
+      return resultIntoHttpResponse(c, serializedResult);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
       logger.error(errorMessage);
 
-      // respond with 500 error response
-      return c.json(
-        serializeRegistrarActionsResponse({
-          responseCode: RegistrarActionsResponseCodes.Error,
-          error: {
-            message: `Registrar Actions API Response is unavailable`,
-          },
-        } satisfies RegistrarActionsResponseError),
-        500,
+      const result = buildResultServiceUnavailable(
+        `Registrar Actions API Response is unavailable due to following error: ${errorMessage}`,
       );
+
+      return resultIntoHttpResponse(c, result);
     }
   },
 );
diff --git a/apps/ensapi/src/index.ts b/apps/ensapi/src/index.ts
index 498d77811..6bef3f37c 100644
--- a/apps/ensapi/src/index.ts
+++ b/apps/ensapi/src/index.ts
@@ -7,13 +7,19 @@ import { cors } from "hono/cors";
 import { html } from "hono/html";
 import { openAPIRouteHandler } from "hono-openapi";
 
+import {
+  buildHealthResultOk,
+  buildResultInternalServerError,
+  buildResultNotFound,
+} from "@ensnode/ensnode-sdk";
+
 import { indexingStatusCache } from "@/cache/indexing-status.cache";
 import { referrerLeaderboardCache } from "@/cache/referrer-leaderboard.cache";
 import { redactEnsApiConfig } from "@/config/redact";
-import { errorResponse } from "@/lib/handlers/error-response";
 import { factory } from "@/lib/hono-factory";
 import { sdk } from "@/lib/instrumentation";
 import logger from "@/lib/logger";
+import { resultIntoHttpResponse } from "@/lib/result/result-into-http-response";
 import { indexingStatusMiddleware } from "@/middleware/indexing-status.middleware";
 
 import amIRealtimeApi from "./handlers/amirealtime-api";
@@ -112,13 +118,24 @@ app.get(
 
 // will automatically 503 if config is not available due to ensIndexerPublicConfigMiddleware
 app.get("/health", async (c) => {
-  return c.json({ message: "fallback ok" });
+  const result = buildHealthResultOk("fallback ok");
+
+  return resultIntoHttpResponse(c, result);
+});
+
+app.notFound((c) => {
+  const result = buildResultNotFound(`Resource not found: ${c.req.path}`);
+
+  return resultIntoHttpResponse(c, result);
 });
 
 // log hono errors to console
 app.onError((error, ctx) => {
   logger.error(error);
-  return errorResponse(ctx, "Internal Server Error");
+
+  const result = buildResultInternalServerError(`Internal Server Error: ${error.message}`);
+
+  return resultIntoHttpResponse(ctx, result);
 });
 
 // start ENSNode API OpenTelemetry SDK
diff --git a/apps/ensapi/src/lib/handlers/error-response.ts b/apps/ensapi/src/lib/handlers/error-response.ts
deleted file mode 100644
index d1f489b04..000000000
--- a/apps/ensapi/src/lib/handlers/error-response.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import { SchemaError } from "@standard-schema/utils";
-import type { Context } from "hono";
-import type { ClientErrorStatusCode, ServerErrorStatusCode } from "hono/utils/http-status";
-import { treeifyError, ZodError } from "zod/v4";
-
-import type { ErrorResponse } from "@ensnode/ensnode-sdk";
-
-/**
- * Creates a standardized error response for the ENSApi.
- *
- * Handles different types of errors and converts them to appropriate HTTP responses
- * with consistent error formatting. ZodErrors and Standard Schema validation errors
- * return 400 status codes with validation details, while other errors return 500
- * status codes.
- *
- * @param c - Hono context object
- * @param input - The error input (ZodError, SchemaError, Error, string, or unknown)
- * @returns JSON error response with appropriate HTTP status code
- */
-export const errorResponse = (
-  c: Context,
-  input: ZodError | SchemaError | Error | string | unknown,
-  statusCode: ClientErrorStatusCode | ServerErrorStatusCode = 500,
-) => {
-  if (input instanceof ZodError) {
-    return c.json(
-      { message: "Invalid Input", details: treeifyError(input) } satisfies ErrorResponse,
-      400,
-    );
-  }
-
-  if (input instanceof SchemaError) {
-    // Convert Standard Schema issues to ZodError for consistent formatting
-    const zodError = new ZodError(input.issues as ZodError["issues"]);
-    return c.json(
-      { message: "Invalid Input", details: treeifyError(zodError) } satisfies ErrorResponse,
-      400,
-    );
-  }
-
-  if (input instanceof Error) {
-    return c.json({ message: input.message } satisfies ErrorResponse, statusCode);
-  }
-
-  if (typeof input === "string") {
-    return c.json({ message: input } satisfies ErrorResponse, statusCode);
-  }
-
-  return c.json({ message: "Internal Server Error" } satisfies ErrorResponse, statusCode);
-};
diff --git a/apps/ensapi/src/lib/handlers/validate.ts b/apps/ensapi/src/lib/handlers/validate.ts
index 4316e07bb..b0c26f117 100644
--- a/apps/ensapi/src/lib/handlers/validate.ts
+++ b/apps/ensapi/src/lib/handlers/validate.ts
@@ -1,15 +1,17 @@
 import { SchemaError } from "@standard-schema/utils";
 import type { ValidationTargets } from "hono";
 import { validator } from "hono-openapi";
-import type { ZodType } from "zod/v4";
+import { prettifyError, ZodError, type ZodType } from "zod/v4";
 
-import { errorResponse } from "./error-response";
+import { buildResultInvalidRequest } from "@ensnode/ensnode-sdk";
+
+import { resultIntoHttpResponse } from "@/lib/result/result-into-http-response";
 
 /**
- * Creates a Hono validation middleware with custom error formatting.
+ * Creates a Hono validation middleware.
  *
- * Wraps the Hono validator with custom error handling that uses the
- * errorResponse function for consistent error formatting across the API.
+ * Wraps the Hono validator with custom error handling that uses standardized
+ * response data model across the API.
  *
  * @param target - The validation target (param, query, json, etc.)
  * @param schema - The Zod schema to validate against
@@ -20,10 +22,13 @@ export const validate = <T extends ZodType, Target extends keyof ValidationTarge
   schema: T,
 ) =>
   validator(target, schema, (result, c) => {
-    // if validation failed, return our custom-formatted ErrorResponse instead of default
+    // Respond with the invalid request result if validation failed.
     if (!result.success) {
-      // Wrap the Standard Schema issues in a SchemaError instance
-      // for consistent error handling in errorResponse
-      return errorResponse(c, new SchemaError(result.error));
+      // Convert Standard Schema issues to ZodError for consistent formatting
+      const schemaError = new SchemaError(result.error);
+      const zodError = new ZodError(schemaError.issues as ZodError["issues"]);
+      const errorMessage = prettifyError(zodError);
+
+      return resultIntoHttpResponse(c, buildResultInvalidRequest(errorMessage));
     }
   });
diff --git a/apps/ensapi/src/lib/result/result-into-http-response.test.ts b/apps/ensapi/src/lib/result/result-into-http-response.test.ts
new file mode 100644
index 000000000..d353b440f
--- /dev/null
+++ b/apps/ensapi/src/lib/result/result-into-http-response.test.ts
@@ -0,0 +1,137 @@
+import type { Context } from "hono";
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  buildResultInsufficientIndexingProgress,
+  buildResultInternalServerError,
+  buildResultInvalidRequest,
+  buildResultNotFound,
+  buildResultServiceUnavailable,
+  ResultCodes,
+} from "@ensnode/ensnode-sdk";
+
+import { resultCodeToHttpStatusCode, resultIntoHttpResponse } from "./result-into-http-response";
+
+describe("resultCodeToHttpStatusCode", () => {
+  it("should return 200 for ResultCodes.Ok", () => {
+    const statusCode = resultCodeToHttpStatusCode(ResultCodes.Ok);
+
+    expect(statusCode).toBe(200);
+  });
+
+  it("should return 400 for ResultCodes.InvalidRequest", () => {
+    const statusCode = resultCodeToHttpStatusCode(ResultCodes.InvalidRequest);
+
+    expect(statusCode).toBe(400);
+  });
+
+  it("should return 404 for ResultCodes.NotFound", () => {
+    const statusCode = resultCodeToHttpStatusCode(ResultCodes.NotFound);
+
+    expect(statusCode).toBe(404);
+  });
+
+  it("should return 500 for ResultCodes.InternalServerError", () => {
+    const statusCode = resultCodeToHttpStatusCode(ResultCodes.InternalServerError);
+
+    expect(statusCode).toBe(500);
+  });
+
+  it("should return 503 for ResultCodes.ServiceUnavailable", () => {
+    const statusCode = resultCodeToHttpStatusCode(ResultCodes.ServiceUnavailable);
+
+    expect(statusCode).toBe(503);
+  });
+
+  it("should return 503 for ResultCodes.InsufficientIndexingProgress", () => {
+    const statusCode = resultCodeToHttpStatusCode(ResultCodes.InsufficientIndexingProgress);
+
+    expect(statusCode).toBe(503);
+  });
+});
+
+describe("resultIntoHttpResponse", () => {
+  let mockContext: Context;
+
+  beforeEach(() => {
+    mockContext = {
+      json: vi.fn((object: Response, status: ContentfulStatusCode) => {
+        return Response.json(object, { status });
+      }),
+    } as unknown as Context;
+  });
+
+  it("should return HTTP response with status 200 for Ok result", async () => {
+    const result = { resultCode: ResultCodes.Ok, data: "test data" };
+
+    const response = resultIntoHttpResponse(mockContext, result);
+
+    expect(response.status).toBe(200);
+    expect(await response.json()).toStrictEqual(result);
+  });
+
+  it("should return HTTP response with status 400 for InvalidRequest result", async () => {
+    const result = buildResultInvalidRequest("Invalid request");
+
+    const response = resultIntoHttpResponse(mockContext, result);
+
+    expect(response.status).toBe(400);
+    expect(await response.json()).toStrictEqual(result);
+  });
+
+  it("should return HTTP response with status 404 for NotFound result", async () => {
+    const result = buildResultNotFound("Resource not found");
+
+    const response = resultIntoHttpResponse(mockContext, result);
+
+    expect(response.status).toBe(404);
+    expect(await response.json()).toStrictEqual(result);
+  });
+
+  it("should return HTTP response with status 500 for InternalServerError result", async () => {
+    const result = buildResultInternalServerError("Internal server error");
+
+    const response = resultIntoHttpResponse(mockContext, result);
+
+    expect(response.status).toBe(500);
+    expect(await response.json()).toStrictEqual(result);
+  });
+
+  it("should return HTTP response with status 503 for ServiceUnavailable result", async () => {
+    const result = buildResultServiceUnavailable("Service unavailable");
+
+    const response = resultIntoHttpResponse(mockContext, result);
+
+    expect(response.status).toBe(503);
+    const responseJson = await response.json();
+    expect(responseJson).toStrictEqual(result);
+  });
+
+  it("should return HTTP response with status 503 for InsufficientIndexingProgress result", async () => {
+    const result = buildResultInsufficientIndexingProgress("Insufficient indexing progress", {
+      indexingStatus: "omnichain-backfill",
+      slowestChainIndexingCursor: 1620003600,
+      earliestChainIndexingCursor: 1620000000,
+      progressSufficientFrom: {
+        indexingStatus: "realtime",
+        chainIndexingCursor: 1620007200,
+      },
+    });
+
+    const response = resultIntoHttpResponse(mockContext, result);
+
+    expect(response.status).toBe(503);
+    const responseJson = await response.json();
+    expect(responseJson).toStrictEqual(result);
+  });
+
+  it("should handle result with complex data object", async () => {
+    const complexData = { id: 1, name: "Test", attributes: { key: "value" } };
+    const result = { resultCode: ResultCodes.Ok, data: complexData };
+
+    const response = resultIntoHttpResponse(mockContext, result);
+    expect(response.status).toBe(200);
+    expect(await response.json()).toStrictEqual(result);
+  });
+});
diff --git a/apps/ensapi/src/lib/result/result-into-http-response.ts b/apps/ensapi/src/lib/result/result-into-http-response.ts
new file mode 100644
index 000000000..f24c1f87c
--- /dev/null
+++ b/apps/ensapi/src/lib/result/result-into-http-response.ts
@@ -0,0 +1,46 @@
+import type { Context } from "hono";
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+
+import { type ResultCodeServerError, ResultCodes } from "@ensnode/ensnode-sdk";
+
+export type ServerResultCode = ResultCodeServerError | typeof ResultCodes.Ok;
+
+/**
+ * Get HTTP status code corresponding to the given operation result code.
+ *
+ * @param resultCode - The operation result code
+ * @returns Corresponding HTTP status code
+ */
+export function resultCodeToHttpStatusCode(resultCode: ServerResultCode): ContentfulStatusCode {
+  switch (resultCode) {
+    case ResultCodes.Ok:
+      return 200;
+    case ResultCodes.InvalidRequest:
+      return 400;
+    case ResultCodes.NotFound:
+      return 404;
+    case ResultCodes.InternalServerError:
+      return 500;
+    case ResultCodes.ServiceUnavailable:
+    case ResultCodes.InsufficientIndexingProgress:
+      return 503;
+  }
+}
+
+/**
+ * Get an HTTP response from the given operation result.
+ *
+ * @param c - Hono context
+ * @param result - The operation result
+ * @returns HTTP response with appropriate status code and JSON body
+ */
+export function resultIntoHttpResponse<TResult extends { resultCode: ServerResultCode }>(
+  c: Context,
+  result: TResult,
+): Response {
+  // Determine HTTP status code from result code
+  const statusCode = resultCodeToHttpStatusCode(result.resultCode);
+
+  // Return JSON response with appropriate status code
+  return c.json(result, statusCode);
+}
diff --git a/apps/ensapi/src/middleware/registrar-actions.middleware.ts b/apps/ensapi/src/middleware/registrar-actions.middleware.ts
index e0dc7a059..cca8eb0e8 100644
--- a/apps/ensapi/src/middleware/registrar-actions.middleware.ts
+++ b/apps/ensapi/src/middleware/registrar-actions.middleware.ts
@@ -1,28 +1,45 @@
 import config from "@/config";
 
 import {
-  RegistrarActionsResponseCodes,
+  buildResultInsufficientIndexingProgress,
+  buildResultInternalServerError,
+  buildResultServiceUnavailable,
+  getChainIndexingConfigTypeId,
+  getSufficientIndexingProgressChainCursor,
+  getTimestampForLowestOmnichainStartBlock,
+  ResultInsufficientIndexingProgress,
+  ResultInternalServerError,
+  ResultServiceUnavailable,
   registrarActionsPrerequisites,
-  serializeRegistrarActionsResponse,
 } from "@ensnode/ensnode-sdk";
 
 import { factory } from "@/lib/hono-factory";
 import { makeLogger } from "@/lib/logger";
+import { resultIntoHttpResponse } from "@/lib/result/result-into-http-response";
 
 const logger = makeLogger("registrar-actions.middleware");
 
 /**
  * Registrar Actions API Middleware
  *
- * This middleware that ensures that all prerequisites of
+ * This middleware ensures that all prerequisites of
  * the Registrar Actions API were met and HTTP requests can be served.
  *
- * Returns a 500 response for any of the following cases:
+ * Returns a response from {@link ResultInternalServerError} for any of
+ * the following cases:
+ * 1) The application context does not have the indexing status set by
+ *   `indexingStatusMiddleware`.
+ *
+ * Returns a response from {@link ResultServiceUnavailable} for any of
+ * the following cases:
  * 1) Not all required plugins are active in the connected ENSIndexer
  *    configuration.
  * 2) ENSApi has not yet successfully cached the Indexing Status in memory from
  *    the connected ENSIndexer.
- * 3) The omnichain indexing status of the connected ENSIndexer that is cached
+ *
+ * Returns a response from {@link ResultInsufficientIndexingProgress} for any of
+ * the following cases:
+ * 1) The omnichain indexing status of the connected ENSIndexer that is cached
  *    in memory is not "completed" or "following".
  *
  * @returns Hono middleware that validates the plugin's HTTP API availability.
@@ -31,20 +48,24 @@ export const registrarActionsApiMiddleware = factory.createMiddleware(
   async function registrarActionsApiMiddleware(c, next) {
     // context must be set by the required middleware
     if (c.var.indexingStatus === undefined) {
-      throw new Error(`Invariant(registrar-actions.middleware): indexingStatusMiddleware required`);
+      const result = buildResultInternalServerError(
+        `Invariant(registrar-actions.middleware): indexingStatusMiddleware required.`,
+      );
+
+      return resultIntoHttpResponse(c, result);
     }
 
     if (!registrarActionsPrerequisites.hasEnsIndexerConfigSupport(config.ensIndexerPublicConfig)) {
-      return c.json(
-        serializeRegistrarActionsResponse({
-          responseCode: RegistrarActionsResponseCodes.Error,
-          error: {
-            message: `Registrar Actions API is not available`,
-            details: `Connected ENSIndexer must have all following plugins active: ${registrarActionsPrerequisites.requiredPlugins.join(", ")}`,
-          },
-        }),
-        500,
-      );
+      const errorMessage = [
+        `Registrar Actions API is not available.`,
+        `Connected ENSIndexer configuration does not have all required plugins active.`,
+        `Current plugins: "${config.ensIndexerPublicConfig.plugins.join(", ")}".`,
+        `Required plugins: "${registrarActionsPrerequisites.requiredPlugins.join(", ")}".`,
+      ].join(" ");
+
+      const result = buildResultServiceUnavailable(errorMessage);
+
+      return resultIntoHttpResponse(c, result);
     }
 
     if (c.var.indexingStatus instanceof Error) {
@@ -54,32 +75,59 @@ export const registrarActionsApiMiddleware = factory.createMiddleware(
         `Registrar Actions API requested but indexing status is not available in context.`,
       );
 
-      return c.json(
-        serializeRegistrarActionsResponse({
-          responseCode: RegistrarActionsResponseCodes.Error,
-          error: {
-            message: `Registrar Actions API is not available`,
-            details: `Indexing status is currently unavailable to this ENSApi instance.`,
-          },
-        }),
-        500,
-      );
+      const errorMessage = [
+        `Registrar Actions API is not available.`,
+        `Indexing status is currently unavailable to this ENSApi instance.`,
+      ].join(" ");
+
+      const result = buildResultServiceUnavailable(errorMessage);
+
+      return resultIntoHttpResponse(c, result);
     }
 
-    const { omnichainSnapshot } = c.var.indexingStatus.snapshot;
-
-    if (!registrarActionsPrerequisites.hasIndexingStatusSupport(omnichainSnapshot.omnichainStatus))
-      return c.json(
-        serializeRegistrarActionsResponse({
-          responseCode: RegistrarActionsResponseCodes.Error,
-          error: {
-            message: `Registrar Actions API is not available`,
-            details: `The cached omnichain indexing status of the Connected ENSIndexer must be one of the following ${registrarActionsPrerequisites.supportedIndexingStatusIds.map((statusId) => `"${statusId}"`).join(", ")}.`,
-          },
-        }),
-        500,
+    const { snapshot, worstCaseDistance } = c.var.indexingStatus;
+    const { omnichainSnapshot, slowestChainIndexingCursor } = snapshot;
+
+    const chains = Array.from(omnichainSnapshot.chains.values());
+    const configTypeId = getChainIndexingConfigTypeId(chains);
+
+    if (
+      !registrarActionsPrerequisites.hasIndexingStatusSupport(
+        configTypeId,
+        omnichainSnapshot.omnichainStatus,
+      )
+    ) {
+      // Registrar Actions API has no particular maximum worst-case distance requirement,
+      // so we simply use the current worst-case distance as the maximum here.
+      const maxWorstCaseDistance = worstCaseDistance;
+      const earliestChainIndexingCursor = getTimestampForLowestOmnichainStartBlock(chains);
+      const progressSufficientFromChainIndexingCursor = getSufficientIndexingProgressChainCursor(
+        slowestChainIndexingCursor,
+        worstCaseDistance,
+        maxWorstCaseDistance,
       );
 
+      const targetIndexingStatus =
+        registrarActionsPrerequisites.getSupportedIndexingStatus(configTypeId);
+
+      const errorMessage = [
+        `Registrar Actions API is not available.`,
+        `The cached omnichain indexing status of the connected ENSIndexer has insufficient progress.`,
+      ].join(" ");
+
+      const result = buildResultInsufficientIndexingProgress(errorMessage, {
+        indexingStatus: omnichainSnapshot.omnichainStatus,
+        slowestChainIndexingCursor,
+        earliestChainIndexingCursor,
+        progressSufficientFrom: {
+          indexingStatus: targetIndexingStatus,
+          chainIndexingCursor: progressSufficientFromChainIndexingCursor,
+        },
+      });
+
+      return resultIntoHttpResponse(c, result);
+    }
+
     await next();
   },
 );
diff --git a/packages/ensnode-sdk/src/api/amirealtime/index.ts b/packages/ensnode-sdk/src/api/amirealtime/index.ts
new file mode 100644
index 000000000..bb162e4c8
--- /dev/null
+++ b/packages/ensnode-sdk/src/api/amirealtime/index.ts
@@ -0,0 +1 @@
+export * from "./result";
diff --git a/packages/ensnode-sdk/src/api/amirealtime/result.ts b/packages/ensnode-sdk/src/api/amirealtime/result.ts
new file mode 100644
index 000000000..28e3750ba
--- /dev/null
+++ b/packages/ensnode-sdk/src/api/amirealtime/result.ts
@@ -0,0 +1,65 @@
+import type { RealtimeIndexingStatusProjection } from "../../ensindexer";
+import {
+  type AbstractResultOk,
+  type Duration,
+  ResultCodes,
+  type ResultInsufficientIndexingProgress,
+  type ResultInternalServerError,
+  type ResultInvalidRequest,
+  type ResultServiceUnavailable,
+  type UnixTimestamp,
+} from "../../shared";
+
+/**
+ * Successful result data for "Am I Realtime?" API requests.
+ */
+export interface AmIRealtimeResultOkData {
+  /**
+   * Represents the maximum worst-case distance from the current "tip" of
+   * all indexed chains. `maxWorstCaseDistance` is defined by the client
+   * making the request.
+   */
+  maxWorstCaseDistance: Duration;
+
+  /**
+   * Worst-case distance in seconds.
+   *
+   * See {@link RealtimeIndexingStatusProjection.worstCaseDistance} for details.
+   *
+   * Guarantees:
+   * - `worstCaseDistance` is always less than or equal to `maxWorstCaseDistance`.
+   */
+  worstCaseDistance: Duration;
+
+  /**
+   * The timestamp of the "slowest" latest indexed block timestamp across all indexed chains.
+   *
+   * See {@link RealtimeIndexingStatusProjection.slowestChainIndexingCursor} for details.
+   */
+  slowestChainIndexingCursor: UnixTimestamp;
+}
+
+/**
+ * Successful result for "Am I Realtime?" API requests.
+ */
+export type AmIRealtimeResultOk = AbstractResultOk<AmIRealtimeResultOkData>;
+
+export function buildAmIRealtimeResultOk(data: AmIRealtimeResultOkData): AmIRealtimeResultOk {
+  return {
+    resultCode: ResultCodes.Ok,
+    data,
+  };
+}
+
+/**
+ * The operation result for "Am I Realtime?" API requests.
+ *
+ * Use the `resultCode` field to determine the specific type interpretation
+ * at runtime.
+ */
+export type AmIRealtimeServerResult =
+  | AmIRealtimeResultOk
+  | ResultInvalidRequest
+  | ResultInternalServerError
+  | ResultServiceUnavailable
+  | ResultInsufficientIndexingProgress;
diff --git a/packages/ensnode-sdk/src/api/amirealtime/zod-schemas.ts b/packages/ensnode-sdk/src/api/amirealtime/zod-schemas.ts
new file mode 100644
index 000000000..b61688914
--- /dev/null
+++ b/packages/ensnode-sdk/src/api/amirealtime/zod-schemas.ts
@@ -0,0 +1,17 @@
+import z from "zod/v4";
+
+import { makeAbstractResultOkSchema } from "../../shared/result/zod-schemas";
+import { makeDurationSchema, makeUnixTimestampSchema } from "../../shared/zod-schemas";
+import type { AmIRealtimeResultOk, AmIRealtimeResultOkData } from "./result";
+
+/**
+ * Schema for {@link AmIRealtimeResultOk}.
+ */
+export const makeAmIRealtimeResultOkSchema = () =>
+  makeAbstractResultOkSchema<AmIRealtimeResultOkData>(
+    z.object({
+      maxWorstCaseDistance: makeDurationSchema("maxWorstCaseDistance"),
+      worstCaseDistance: makeDurationSchema("worstCaseDistance"),
+      slowestChainIndexingCursor: makeUnixTimestampSchema("slowestChainIndexingCursor"),
+    }),
+  );
diff --git a/packages/ensnode-sdk/src/api/health/index.ts b/packages/ensnode-sdk/src/api/health/index.ts
new file mode 100644
index 000000000..bb162e4c8
--- /dev/null
+++ b/packages/ensnode-sdk/src/api/health/index.ts
@@ -0,0 +1 @@
+export * from "./result";
diff --git a/packages/ensnode-sdk/src/api/health/result.ts b/packages/ensnode-sdk/src/api/health/result.ts
new file mode 100644
index 000000000..15cf0ac99
--- /dev/null
+++ b/packages/ensnode-sdk/src/api/health/result.ts
@@ -0,0 +1,23 @@
+import { type AbstractResultOk, ResultCodes } from "../../shared";
+
+/**
+ * Successful result data for Health API requests.
+ */
+export type HealthResultOkData = string;
+
+/**
+ * Successful result for Health API requests.
+ */
+export type HealthResultOk = AbstractResultOk<HealthResultOkData>;
+
+export function buildHealthResultOk(data: HealthResultOkData): HealthResultOk {
+  return {
+    resultCode: ResultCodes.Ok,
+    data,
+  };
+}
+
+/**
+ * The operation result for Health API requests.
+ */
+export type HealthServerResult = HealthResultOk;
diff --git a/packages/ensnode-sdk/src/api/index.ts b/packages/ensnode-sdk/src/api/index.ts
index 661de1ea7..0f8868143 100644
--- a/packages/ensnode-sdk/src/api/index.ts
+++ b/packages/ensnode-sdk/src/api/index.ts
@@ -1,4 +1,6 @@
+export * from "./amirealtime";
 export * from "./config";
+export * from "./health";
 export * from "./indexing-status";
 export * from "./name-tokens";
 export * from "./registrar-actions";
diff --git a/packages/ensnode-sdk/src/api/registrar-actions/index.ts b/packages/ensnode-sdk/src/api/registrar-actions/index.ts
index 8f0b7c3f5..27366182b 100644
--- a/packages/ensnode-sdk/src/api/registrar-actions/index.ts
+++ b/packages/ensnode-sdk/src/api/registrar-actions/index.ts
@@ -3,5 +3,6 @@ export * from "./filters";
 export * from "./prerequisites";
 export * from "./request";
 export * from "./response";
+export * from "./result";
 export * from "./serialize";
 export * from "./serialized-response";
diff --git a/packages/ensnode-sdk/src/api/registrar-actions/prerequisites.ts b/packages/ensnode-sdk/src/api/registrar-actions/prerequisites.ts
index afdc12f11..dd8352290 100644
--- a/packages/ensnode-sdk/src/api/registrar-actions/prerequisites.ts
+++ b/packages/ensnode-sdk/src/api/registrar-actions/prerequisites.ts
@@ -1,10 +1,16 @@
 import {
+  type ChainIndexingConfigTypeId,
+  ChainIndexingConfigTypeIds,
   type ENSIndexerPublicConfig,
   type OmnichainIndexingStatusId,
   OmnichainIndexingStatusIds,
   PluginName,
 } from "../../ensindexer";
 
+export type SupportedOmnichainIndexingStatusId =
+  | typeof OmnichainIndexingStatusIds.Completed
+  | typeof OmnichainIndexingStatusIds.Following;
+
 export const registrarActionsPrerequisites = Object.freeze({
   /**
    * Required plugins to enable Registrar Actions API routes.
@@ -27,6 +33,21 @@ export const registrarActionsPrerequisites = Object.freeze({
     PluginName.Registrars,
   ] as const,
 
+  /**
+   * Gets the omnichain indexing status required to support
+   * the Registrar Actions API for a given indexing config type.
+   */
+  getSupportedIndexingStatus(
+    configType: ChainIndexingConfigTypeId,
+  ): SupportedOmnichainIndexingStatusId {
+    switch (configType) {
+      case ChainIndexingConfigTypeIds.Definite:
+        return OmnichainIndexingStatusIds.Completed;
+      case ChainIndexingConfigTypeIds.Indefinite:
+        return OmnichainIndexingStatusIds.Following;
+    }
+  },
+
   /**
    * Check if provided ENSApiPublicConfig supports the Registrar Actions API.
    */
@@ -35,23 +56,18 @@ export const registrarActionsPrerequisites = Object.freeze({
       config.plugins.includes(plugin),
     );
   },
-  /**
-   * Required Indexing Status IDs
-   *
-   * Database indexes are created by the time the omnichain indexing status
-   * is either `completed` or `following`.
-   */
-  supportedIndexingStatusIds: [
-    OmnichainIndexingStatusIds.Completed,
-    OmnichainIndexingStatusIds.Following,
-  ],
 
   /**
-   * Check if provided indexing status supports the Registrar Actions API.
+   * Check if provided indexing status supports the Registrar Actions API, given
+   * the indexing config type.
    */
-  hasIndexingStatusSupport(omnichainIndexingStatusId: OmnichainIndexingStatusId): boolean {
-    return registrarActionsPrerequisites.supportedIndexingStatusIds.some(
-      (supportedIndexingStatusId) => supportedIndexingStatusId === omnichainIndexingStatusId,
+  hasIndexingStatusSupport(
+    configType: ChainIndexingConfigTypeId,
+    omnichainIndexingStatusId: OmnichainIndexingStatusId,
+  ): boolean {
+    return (
+      registrarActionsPrerequisites.getSupportedIndexingStatus(configType) ===
+      omnichainIndexingStatusId
     );
   },
 });
diff --git a/packages/ensnode-sdk/src/api/registrar-actions/result.ts b/packages/ensnode-sdk/src/api/registrar-actions/result.ts
new file mode 100644
index 000000000..6d9b48b78
--- /dev/null
+++ b/packages/ensnode-sdk/src/api/registrar-actions/result.ts
@@ -0,0 +1,91 @@
+import {
+  type AbstractResultOkTimestamped,
+  ResultCodes,
+  type ResultInsufficientIndexingProgress,
+  type ResultInternalServerError,
+  type ResultInvalidRequest,
+  type ResultServiceUnavailable,
+  type UnixTimestamp,
+} from "../../shared";
+import type { ResponsePageContext } from "../shared";
+import type { NamedRegistrarAction } from "../types";
+import { serializeNamedRegistrarAction } from "./serialize";
+import type { SerializedNamedRegistrarAction } from "./serialized-response";
+
+export interface RegistrarActionsResultOkData {
+  /**
+   * The list of "logical registrar actions" with their associated names.
+   */
+  registrarActions: NamedRegistrarAction[];
+
+  /**
+   * The pagination context for the current page of results.
+   */
+  pageContext: ResponsePageContext;
+}
+
+/**
+ * Serialized representation of {@link RegistrarActionsResultOkData}.
+ */
+export interface SerializedRegistrarActionsResultOkData
+  extends Omit<RegistrarActionsResultOkData, "registrarActions"> {
+  registrarActions: SerializedNamedRegistrarAction[];
+}
+
+/**
+ * Successful result for Registrar Actions API requests.
+ */
+export type RegistrarActionsResultOk = AbstractResultOkTimestamped<RegistrarActionsResultOkData>;
+
+/**
+ * Serialized representation of {@link RegistrarActionsResultOk}.
+ */
+export type SerializedRegistrarActionsResultOk =
+  AbstractResultOkTimestamped<SerializedRegistrarActionsResultOkData>;
+
+/**
+ * Builds a successful result for Registrar Actions API requests.
+ *
+ * @param data - The data for the successful result
+ * @param minIndexingCursor - The minimum indexing cursor timestamp
+ * @returns The successful result object with data guaranteed to be up to
+ *          the specified indexing cursor.
+ */
+export function buildRegistrarActionsResultOk(
+  data: RegistrarActionsResultOkData,
+  minIndexingCursor: UnixTimestamp,
+): RegistrarActionsResultOk {
+  return {
+    resultCode: ResultCodes.Ok,
+    data,
+    minIndexingCursor,
+  };
+}
+
+/**
+ * Serializes a {@link RegistrarActionsResultOk} into a {@link SerializedRegistrarActionsResultOk}.
+ */
+export function serializeRegistrarActionsResultOk(
+  result: RegistrarActionsResultOk,
+): SerializedRegistrarActionsResultOk {
+  return {
+    ...result,
+    data: {
+      ...result.data,
+      registrarActions: result.data.registrarActions.map(serializeNamedRegistrarAction),
+    },
+  };
+}
+
+/**
+ * The server operation result for Registrar Actions API.
+ *
+ * Use the `resultCode` field to determine the specific type interpretation
+ * at runtime.
+ */
+export type RegistrarActionsServerResult =
+  | RegistrarActionsResultOk
+  | ResultInvalidRequest
+  | ResultInternalServerError
+  | ResultServiceUnavailable
+  | ResultInsufficientIndexingProgress;
diff --git a/packages/ensnode-sdk/src/api/registrar-actions/zod-schemas.test.ts b/packages/ensnode-sdk/src/api/registrar-actions/zod-schemas.test.ts
index 88d92b8d3..7de23d853 100644
--- a/packages/ensnode-sdk/src/api/registrar-actions/zod-schemas.test.ts
+++ b/packages/ensnode-sdk/src/api/registrar-actions/zod-schemas.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
 
+import { ChainIndexingConfigTypeIds } from "../..";
 import type { InterpretedName } from "../../ens";
 import { registrarActionsPrerequisites } from "../registrar-actions";
 import { RegistrarActionsResponseCodes, type RegistrarActionsResponseError } from "./response";
@@ -119,7 +120,7 @@ describe("ENSNode API Schema", () => {
       responseCode: RegistrarActionsResponseCodes.Error,
       error: {
         message: "Registrar Actions API is not available",
-        details: `The cached omnichain indexing status of the Connected ENSIndexer must be one of the following ${registrarActionsPrerequisites.supportedIndexingStatusIds.map((statusId) => `"${statusId}"`).join(", ")}.`,
+        details: `The cached omnichain indexing status of the Connected ENSIndexer must be ${registrarActionsPrerequisites.getSupportedIndexingStatus(ChainIndexingConfigTypeIds.Definite)}.`,
       },
     } satisfies SerializedRegistrarActionsResponseError;
 
diff --git a/packages/ensnode-sdk/src/api/registrar-actions/zod-schemas.ts b/packages/ensnode-sdk/src/api/registrar-actions/zod-schemas.ts
index bcb6b4d3c..71b6a4630 100644
--- a/packages/ensnode-sdk/src/api/registrar-actions/zod-schemas.ts
+++ b/packages/ensnode-sdk/src/api/registrar-actions/zod-schemas.ts
@@ -2,13 +2,26 @@ import { namehash } from "viem/ens";
 import z from "zod/v4";
 import type { ParsePayload } from "zod/v4/core";
 
-import { makeRegistrarActionSchema } from "../../registrars/zod-schemas";
+import {
+  makeRegistrarActionSchema,
+  makeSerializedRegistrarActionSchema,
+} from "../../registrars/zod-schemas";
+import { makeAbstractResultOkTimestampedSchema } from "../../shared/result/zod-schemas";
 import { makeReinterpretedNameSchema, makeUnixTimestampSchema } from "../../shared/zod-schemas";
 import { ErrorResponseSchema } from "../shared/errors/zod-schemas";
 import { makeResponsePageContextSchema } from "../shared/pagination/zod-schemas";
 import { type NamedRegistrarAction, RegistrarActionsResponseCodes } from "./response";
+import type {
+  RegistrarActionsResultOk,
+  RegistrarActionsResultOkData,
+  SerializedRegistrarActionsResultOk,
+  SerializedRegistrarActionsResultOkData,
+} from "./result";
+import type { SerializedNamedRegistrarAction } from "./serialized-response";
 
-function invariant_registrationLifecycleNodeMatchesName(ctx: ParsePayload<NamedRegistrarAction>) {
+function invariant_registrationLifecycleNodeMatchesName(
+  ctx: ParsePayload<NamedRegistrarAction | SerializedNamedRegistrarAction>,
+) {
   const { name, action } = ctx.value;
   const expectedNode = action.registrationLifecycle.node;
   const actualNode = namehash(name);
@@ -33,6 +46,26 @@ export const makeNamedRegistrarActionSchema = (valueLabel: string = "Named Regis
     })
     .check(invariant_registrationLifecycleNodeMatchesName);
 
+/**
+ * Schema for {@link SerializedNamedRegistrarAction}.
+ */
+export const makeSerializedNamedRegistrarActionSchema = (
+  valueLabel: string = "Serialized Named Registrar Action",
+) =>
+  z
+    .object({
+      action: makeSerializedRegistrarActionSchema(valueLabel).meta({
+        description: `"Logical registrar action".`,
+      }),
+      name: makeReinterpretedNameSchema(valueLabel).meta({
+        description: `FQDN of the name associated with 'action'.`,
+      }),
+    })
+    .meta({
+      description: `"Logical registrar action" with its associated name.`,
+    })
+    .check(invariant_registrationLifecycleNodeMatchesName);
+
 /**
  * Schema for {@link RegistrarActionsResponseOk}
  */
@@ -67,3 +100,25 @@ export const makeRegistrarActionsResponseSchema = (
     makeRegistrarActionsResponseOkSchema(valueLabel),
     makeRegistrarActionsResponseErrorSchema(valueLabel),
   ]);
+
+/**
+ * Schema for {@link RegistrarActionsResultOk}
+ */
+export const makeRegistrarActionsResultOkSchema = () =>
+  makeAbstractResultOkTimestampedSchema<RegistrarActionsResultOkData>(
+    z.object({
+      registrarActions: z.array(makeNamedRegistrarActionSchema("registrarActions")),
+      pageContext: makeResponsePageContextSchema("pageContext"),
+    }),
+  );
+
+/**
+ * Schema for {@link SerializedRegistrarActionsResultOk}
+ */
+export const makeSerializedRegistrarActionsResultOkSchema = () =>
+  makeAbstractResultOkTimestampedSchema<SerializedRegistrarActionsResultOkData>(
+    z.object({
+      registrarActions: z.array(makeSerializedNamedRegistrarActionSchema("registrarActions")),
+      pageContext: makeResponsePageContextSchema("pageContext"),
+    }),
+  );
diff --git a/packages/ensnode-sdk/src/api/shared/pagination/build-page-context.ts b/packages/ensnode-sdk/src/api/shared/pagination/build-page-context.ts
index 5ba13f57f..b1ab83f98 100644
--- a/packages/ensnode-sdk/src/api/shared/pagination/build-page-context.ts
+++ b/packages/ensnode-sdk/src/api/shared/pagination/build-page-context.ts
@@ -26,8 +26,6 @@ export function buildPageContext(
       totalPages: 1,
       hasNext: false,
       hasPrev: false,
-      startIndex: undefined,
-      endIndex: undefined,
     } satisfies ResponsePageContextWithNoRecords;
   }
 
diff --git a/packages/ensnode-sdk/src/api/shared/pagination/response.ts b/packages/ensnode-sdk/src/api/shared/pagination/response.ts
index 5f48dc4e2..99530fb57 100644
--- a/packages/ensnode-sdk/src/api/shared/pagination/response.ts
+++ b/packages/ensnode-sdk/src/api/shared/pagination/response.ts
@@ -20,16 +20,6 @@ export interface ResponsePageContextWithNoRecords extends Required<RequestPagePa
    * Indicates if there is a previous page available
    */
   hasPrev: false;
-
-  /**
-   * The start index of the records on the page (0-indexed)
-   */
-  startIndex: undefined;
-
-  /**
-   * The end index of the records on the page (0-indexed)
-   */
-  endIndex: undefined;
 }
 
 export interface ResponsePageContextWithRecords extends Required<RequestPageParams> {
diff --git a/packages/ensnode-sdk/src/api/shared/pagination/zod-schemas.ts b/packages/ensnode-sdk/src/api/shared/pagination/zod-schemas.ts
index f1b852ac7..c6aae6543 100644
--- a/packages/ensnode-sdk/src/api/shared/pagination/zod-schemas.ts
+++ b/packages/ensnode-sdk/src/api/shared/pagination/zod-schemas.ts
@@ -36,8 +36,6 @@ export const makeResponsePageContextSchemaWithNoRecords = (
       totalPages: z.literal(1),
       hasNext: z.literal(false),
       hasPrev: z.literal(false),
-      startIndex: z.undefined(),
-      endIndex: z.undefined(),
     })
     .extend(makeRequestPageParamsSchema(valueLabel).shape);
 
@@ -104,6 +102,6 @@ export const makeResponsePageContextSchemaWithRecords = (
  */
 export const makeResponsePageContextSchema = (valueLabel: string = "ResponsePageContext") =>
   z.union([
-    makeResponsePageContextSchemaWithNoRecords(valueLabel),
     makeResponsePageContextSchemaWithRecords(valueLabel),
+    makeResponsePageContextSchemaWithNoRecords(valueLabel),
   ]);
diff --git a/packages/ensnode-sdk/src/ensindexer/indexing-status/helpers.test.ts b/packages/ensnode-sdk/src/ensindexer/indexing-status/helpers.test.ts
index ce62a6aee..393d8471a 100644
--- a/packages/ensnode-sdk/src/ensindexer/indexing-status/helpers.test.ts
+++ b/packages/ensnode-sdk/src/ensindexer/indexing-status/helpers.test.ts
@@ -3,8 +3,10 @@ import { describe, expect, it } from "vitest";
 import type { BlockRef } from "../../shared";
 import {
   createIndexingConfig,
+  getChainIndexingConfigTypeId,
   getOmnichainIndexingCursor,
   getOmnichainIndexingStatus,
+  getSufficientIndexingProgressChainCursor,
 } from "./helpers";
 import { earlierBlockRef, earliestBlockRef, laterBlockRef, latestBlockRef } from "./test-helpers";
 import {
@@ -197,6 +199,94 @@ describe("ENSIndexer: Indexing Snapshot helpers", () => {
       } satisfies ChainIndexingConfigIndefinite);
     });
   });
+
+  describe("getChainIndexingConfigTypeId", () => {
+    it("returns the correct config type id when all chains have the Definite config", () => {
+      // arrange
+      const chainStatuses: ChainIndexingStatusSnapshot[] = [
+        {
+          chainStatus: ChainIndexingStatusIds.Queued,
+          config: {
+            configType: ChainIndexingConfigTypeIds.Definite,
+            startBlock: earliestBlockRef,
+            endBlock: latestBlockRef,
+          },
+        } satisfies ChainIndexingStatusSnapshotQueued,
+        {
+          chainStatus: ChainIndexingStatusIds.Backfill,
+          config: {
+            configType: ChainIndexingConfigTypeIds.Definite,
+            startBlock: earliestBlockRef,
+            endBlock: laterBlockRef,
+          },
+          latestIndexedBlock: laterBlockRef,
+          backfillEndBlock: latestBlockRef,
+        } satisfies ChainIndexingStatusSnapshotBackfill,
+      ];
+
+      // act
+      const configTypeId = getChainIndexingConfigTypeId(chainStatuses);
+
+      // assert
+      expect(configTypeId).toBe(ChainIndexingConfigTypeIds.Definite);
+    });
+
+    it("returns the correct config type id when all chains have the Indefinite config", () => {
+      // arrange
+      const chainStatuses: ChainIndexingStatusSnapshot[] = [
+        {
+          chainStatus: ChainIndexingStatusIds.Queued,
+          config: {
+            configType: ChainIndexingConfigTypeIds.Indefinite,
+            startBlock: earliestBlockRef,
+          },
+        } satisfies ChainIndexingStatusSnapshotQueued,
+        {
+          chainStatus: ChainIndexingStatusIds.Backfill,
+          config: {
+            configType: ChainIndexingConfigTypeIds.Indefinite,
+            startBlock: earliestBlockRef,
+          },
+          latestIndexedBlock: laterBlockRef,
+          backfillEndBlock: latestBlockRef,
+        } satisfies ChainIndexingStatusSnapshotBackfill,
+      ];
+
+      // act
+      const configTypeId = getChainIndexingConfigTypeId(chainStatuses);
+
+      // assert
+      expect(configTypeId).toBe(ChainIndexingConfigTypeIds.Indefinite);
+    });
+
+    it("throws an error when chains have mixed config types", () => {
+      // arrange
+      const chainStatuses: ChainIndexingStatusSnapshot[] = [
+        {
+          chainStatus: ChainIndexingStatusIds.Queued,
+          config: {
+            configType: ChainIndexingConfigTypeIds.Definite,
+            startBlock: earliestBlockRef,
+            endBlock: latestBlockRef,
+          },
+        } satisfies ChainIndexingStatusSnapshotQueued,
+        {
+          chainStatus: ChainIndexingStatusIds.Backfill,
+          config: {
+            configType: ChainIndexingConfigTypeIds.Indefinite,
+            startBlock: earliestBlockRef,
+          },
+          latestIndexedBlock: laterBlockRef,
+          backfillEndBlock: latestBlockRef,
+        } satisfies ChainIndexingStatusSnapshotBackfill,
+      ];
+
+      // act & assert
+      expect(() => getChainIndexingConfigTypeId(chainStatuses)).toThrowError(
+        /All ChainIndexingConfigTypeIds must be the same across indexed chains to determine overall ConfigTypeId/i,
+      );
+    });
+  });
 });
 
 describe("getOmnichainIndexingCursor", () => {
@@ -327,3 +417,22 @@ describe("getOmnichainIndexingCursor", () => {
     );
   });
 });
+
+describe("getSufficientIndexingProgressChainCursor", () => {
+  it("calculates sufficient indexing progress chain cursor correctly", () => {
+    // arrange
+    const slowestChainIndexingCursor = 1500; // example timestamp
+    const worstCaseDistance = 300; // 5 minutes in seconds
+    const maxWorstCaseDistance = 120; // 2 minutes in seconds
+
+    // act
+    const sufficientCursor = getSufficientIndexingProgressChainCursor(
+      slowestChainIndexingCursor,
+      worstCaseDistance,
+      maxWorstCaseDistance,
+    );
+
+    // assert
+    expect(sufficientCursor).toBe(1680);
+  });
+});
diff --git a/packages/ensnode-sdk/src/ensindexer/indexing-status/helpers.ts b/packages/ensnode-sdk/src/ensindexer/indexing-status/helpers.ts
index 1eb58fa9d..3e525fb6f 100644
--- a/packages/ensnode-sdk/src/ensindexer/indexing-status/helpers.ts
+++ b/packages/ensnode-sdk/src/ensindexer/indexing-status/helpers.ts
@@ -1,8 +1,11 @@
+import type { Duration } from "@namehash/ens-referrals";
+
 import type { BlockRef, ChainId, UnixTimestamp } from "../../shared";
 import {
   type ChainIndexingConfig,
   type ChainIndexingConfigDefinite,
   type ChainIndexingConfigIndefinite,
+  type ChainIndexingConfigTypeId,
   ChainIndexingConfigTypeIds,
   ChainIndexingStatusIds,
   type ChainIndexingStatusSnapshot,
@@ -171,6 +174,47 @@ export function createIndexingConfig(
   } satisfies ChainIndexingConfigIndefinite;
 }
 
+/**
+ * Get sufficient indexing progress chain cursor for given Indexing Status
+ * parameters.
+ *
+ * @param slowestChainIndexingCursor Slowest Chain Indexing Cursor
+ * @param worstCaseDistance Worst Case Distance
+ * @param maxWorstCaseDistance Maximum Worst Case Distance
+ * @returns Sufficient Indexing Progress Chain Cursor
+ */
+export function getSufficientIndexingProgressChainCursor(
+  slowestChainIndexingCursor: UnixTimestamp,
+  worstCaseDistance: Duration,
+  maxWorstCaseDistance: Duration,
+): UnixTimestamp {
+  return slowestChainIndexingCursor + worstCaseDistance - maxWorstCaseDistance;
+}
+
+/**
+ * Get Chain Indexing Config Type ID from Chain Indexing Status Snapshots.
+ * @param chains Chain Indexing Status Snapshots
+ * @returns Chain Indexing Config Type ID
+ * @throws Error if Chain Indexing Config Type IDs are mixed across chains
+ */
+export function getChainIndexingConfigTypeId(
+  chains: ChainIndexingStatusSnapshot[],
+): ChainIndexingConfigTypeId {
+  const chainConfigTypeIds = chains.map((chain) => chain.config.configType);
+
+  if (chainConfigTypeIds.every((typeId) => typeId === ChainIndexingConfigTypeIds.Definite)) {
+    return ChainIndexingConfigTypeIds.Definite;
+  }
+
+  if (chainConfigTypeIds.every((typeId) => typeId === ChainIndexingConfigTypeIds.Indefinite)) {
+    return ChainIndexingConfigTypeIds.Indefinite;
+  }
+
+  throw new Error(
+    `Invariant: all ChainIndexingConfigTypeIds must be the same across indexed chains to determine overall ConfigTypeId.`,
+  );
+}
+
 /**
  * Check if Chain Indexing Status Snapshots fit the 'unstarted' overall status
  * snapshot requirements:
diff --git a/packages/ensnode-sdk/src/internal.ts b/packages/ensnode-sdk/src/internal.ts
index 95eec93ca..dc167f8f0 100644
--- a/packages/ensnode-sdk/src/internal.ts
+++ b/packages/ensnode-sdk/src/internal.ts
@@ -12,6 +12,7 @@
  * app/package in the monorepo which requires `@ensnode/ensnode-sdk` dependency.
  */
 
+export * from "./api/amirealtime/zod-schemas";
 export * from "./api/indexing-status/zod-schemas";
 export * from "./api/name-tokens/zod-schemas";
 export * from "./api/registrar-actions/zod-schemas";
@@ -39,6 +40,7 @@ export * from "./shared/log-level";
 export * from "./shared/protocol-acceleration/is-bridged-resolver";
 export * from "./shared/protocol-acceleration/is-ensip-19-reverse-resolver";
 export * from "./shared/protocol-acceleration/is-static-resolver";
+export * from "./shared/result/zod-schemas";
 export * from "./shared/thegraph";
 export * from "./shared/zod-schemas";
 export * from "./shared/zod-types";
diff --git a/packages/ensnode-sdk/src/registrars/zod-schemas.ts b/packages/ensnode-sdk/src/registrars/zod-schemas.ts
index b67615404..9e04b7bdd 100644
--- a/packages/ensnode-sdk/src/registrars/zod-schemas.ts
+++ b/packages/ensnode-sdk/src/registrars/zod-schemas.ts
@@ -12,6 +12,7 @@ import {
   makeLowercaseAddressSchema,
   makeNodeSchema,
   makePriceEthSchema,
+  makeSerializedPriceEthSchema,
   makeTransactionHashSchema,
   makeUnixTimestampSchema,
 } from "../shared/zod-schemas";
@@ -23,6 +24,10 @@ import {
   type RegistrarActionPricingUnknown,
   type RegistrarActionReferralAvailable,
   RegistrarActionTypes,
+  SerializedRegistrarAction,
+  SerializedRegistrarActionPricing,
+  type SerializedRegistrarActionPricingAvailable,
+  type SerializedRegistrarActionPricingUnknown,
 } from "./registrar-action";
 import type { RegistrationLifecycle } from "./registration-lifecycle";
 import { Subregistry } from "./subregistry";
@@ -87,6 +92,43 @@ const makeRegistrarActionPricingSchema = (valueLabel: string = "Registrar Action
       .transform((v) => v as RegistrarActionPricingUnknown),
   ]);
 
+/**
+ * Schema for parsing objects into {@link SerializedRegistrarActionPricing}.
+ */
+const makeSerializedRegistrarActionPricingSchema = (
+  valueLabel: string = "Serialized Registrar Action Pricing",
+) => {
+  const baseCostDescription = `Base cost (before any 'premium') of Ether measured in units of Wei paid to execute the "logical registrar action".`;
+  const premiumDescription = `"premium" cost (in excesses of the 'baseCost') of Ether measured in units of Wei paid to execute the "logical registrar action".`;
+  const totalDescription = `Total cost of Ether measured in units of Wei paid to execute the "logical registrar action".`;
+
+  return z.union([
+    // pricing available
+    z
+      .object({
+        baseCost: makeSerializedPriceEthSchema(`${valueLabel} Base Cost`).meta({
+          description: baseCostDescription,
+        }),
+        premium: makeSerializedPriceEthSchema(`${valueLabel} Premium`).meta({
+          description: premiumDescription,
+        }),
+        total: makeSerializedPriceEthSchema(`${valueLabel} Total`).meta({
+          description: totalDescription,
+        }),
+      })
+      .transform((v) => v as SerializedRegistrarActionPricingAvailable),
+
+    // pricing unknown
+    z
+      .object({
+        baseCost: z.null().meta({ description: baseCostDescription }),
+        premium: z.null().meta({ description: premiumDescription }),
+        total: z.null().meta({ description: totalDescription }),
+      })
+      .transform((v) => v as SerializedRegistrarActionPricingUnknown),
+  ]);
+};
+
 /** Invariant: decodedReferrer is based on encodedReferrer */
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(
   ctx: ParsePayload<RegistrarActionReferralAvailable>,
@@ -159,31 +201,89 @@ const EventIdsSchema = z
   .min(1)
   .transform((v) => v as [RegistrarActionEventId, ...RegistrarActionEventId[]]);
 
+const registrarActionTypeDescription = `The type of "logical registrar action".`;
+
 export const makeBaseRegistrarActionSchema = (valueLabel: string = "Base Registrar Action") =>
   z
     .object({
-      id: EventIdSchema,
-      incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
-      registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`),
+      id: EventIdSchema.meta({
+        description: `The 'id' value is a deterministic and globally unique identifier for the "logical registrar action".`,
+      }),
+      incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`).meta({
+        description: `The duration by which the "logical registrar action" extended the associated 'registrationLifecycle'.`,
+      }),
+      registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`).meta({
+        description: `Identifies the address that initiated the "logical registrar action" and is paying the 'pricing.total' cost (if applicable).`,
+      }),
       registrationLifecycle: makeRegistrationLifecycleSchema(
         `${valueLabel} Registration Lifecycle`,
-      ),
-      pricing: makeRegistrarActionPricingSchema(`${valueLabel} Pricing`),
-      referral: makeRegistrarActionReferralSchema(`${valueLabel} Referral`),
-      block: makeBlockRefSchema(`${valueLabel} Block`),
-      transactionHash: makeTransactionHashSchema(`${valueLabel} Transaction Hash`),
-      eventIds: EventIdsSchema,
+      ).meta({
+        description: `Registration Lifecycle associated with this "logical registrar action".`,
+      }),
+      type: z.string().meta({
+        description: registrarActionTypeDescription,
+      }),
+      referral: makeRegistrarActionReferralSchema(`${valueLabel} Referral`).meta({
+        description: `Referral information associated with this "logical registrar action".`,
+      }),
+      block: makeBlockRefSchema(`${valueLabel} Block`).meta({
+        description: `References the block where the "logical registrar action" was executed.`,
+      }),
+      transactionHash: makeTransactionHashSchema(`${valueLabel} Transaction Hash`).meta({
+        description: `Transaction hash of the transaction associated with the "logical registrar action".`,
+      }),
+      eventIds: EventIdsSchema.meta({
+        description: `Array of the eventIds that have contributed to the state of the "logical registrar action" record.`,
+      }),
     })
     .check(invariant_eventIdsInitialElementIsTheActionId);
 
+const pricingInfoDescription = `Pricing information associated with this "logical registrar action".`;
+
 export const makeRegistrarActionRegistrationSchema = (valueLabel: string = "Registration ") =>
   makeBaseRegistrarActionSchema(valueLabel).extend({
-    type: z.literal(RegistrarActionTypes.Registration),
+    type: z.literal(RegistrarActionTypes.Registration).meta({
+      description: registrarActionTypeDescription,
+    }),
+
+    pricing: makeRegistrarActionPricingSchema(`${valueLabel} Pricing`).meta({
+      description: pricingInfoDescription,
+    }),
+  });
+
+export const makeSerializedRegistrarActionRegistrationSchema = (
+  valueLabel: string = "SerializedRegistration ",
+) =>
+  makeBaseRegistrarActionSchema(valueLabel).extend({
+    type: z.literal(RegistrarActionTypes.Registration).meta({
+      description: registrarActionTypeDescription,
+    }),
+
+    pricing: makeSerializedRegistrarActionPricingSchema(`${valueLabel} Pricing`).meta({
+      description: pricingInfoDescription,
+    }),
   });
 
 export const makeRegistrarActionRenewalSchema = (valueLabel: string = "Renewal") =>
   makeBaseRegistrarActionSchema(valueLabel).extend({
-    type: z.literal(RegistrarActionTypes.Renewal),
+    type: z.literal(RegistrarActionTypes.Renewal).meta({
+      description: registrarActionTypeDescription,
+    }),
+    pricing: makeRegistrarActionPricingSchema(`${valueLabel} Pricing`).meta({
+      description: pricingInfoDescription,
+    }),
+  });
+
+export const makeSerializedRegistrarActionRenewalSchema = (
+  valueLabel: string = "Serialized Renewal",
+) =>
+  makeBaseRegistrarActionSchema(valueLabel).extend({
+    type: z.literal(RegistrarActionTypes.Renewal).meta({
+      description: registrarActionTypeDescription,
+    }),
+    pricing: makeSerializedRegistrarActionPricingSchema(`${valueLabel} Pricing`).meta({
+      description: pricingInfoDescription,
+    }),
   });
 
 /**
@@ -194,3 +294,14 @@ export const makeRegistrarActionSchema = (valueLabel: string = "Registrar Action
     makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
     makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`),
   ]);
+
+/**
+ * Schema for {@link SerializedRegistrarAction}.
+ */
+export const makeSerializedRegistrarActionSchema = (
+  valueLabel: string = "Serialized Registrar Action",
+) =>
+  z.discriminatedUnion("type", [
+    makeSerializedRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
+    makeSerializedRegistrarActionRenewalSchema(`${valueLabel} Renewal`),
+  ]);
diff --git a/packages/ensnode-sdk/src/shared/result/result-base.ts b/packages/ensnode-sdk/src/shared/result/result-base.ts
index 7f0477ef8..f3b4b725c 100644
--- a/packages/ensnode-sdk/src/shared/result/result-base.ts
+++ b/packages/ensnode-sdk/src/shared/result/result-base.ts
@@ -1,3 +1,4 @@
+import type { UnixTimestamp } from "../../shared";
 import type {
   ResultCode,
   ResultCodeClientError,
@@ -32,6 +33,26 @@ export interface AbstractResultOk<TDataType> extends AbstractResult<typeof Resul
   data: TDataType;
 }
 
+/**
+ * Abstract representation of a successful result with data guaranteed to be
+ * at least up to a certain timestamp.
+ */
+export interface AbstractResultOkTimestamped<TDataType> extends AbstractResultOk<TDataType> {
+  /**
+   * The minimum indexing cursor timestamp that the data is
+   * guaranteed to be accurate as of.
+   *
+   * Guarantees:
+   * - `data` is guaranteed to be at least up to `minIndexingCursor`, but
+   *   may be indexed with timestamps higher than `minIndexingCursor`.
+   *   - This guarantee may temporarily be violated during a chain reorg.
+   *     ENSNode automatically recovers from chain reorgs, but during one
+   *     the `minIndexingCursor` may theoretically be some seconds ahead of
+   *     the true state of indexed data.
+   */
+  minIndexingCursor: UnixTimestamp;
+}
+
 /**
  * Abstract representation of an error result.
  */
diff --git a/packages/ensnode-sdk/src/shared/result/result-code.ts b/packages/ensnode-sdk/src/shared/result/result-code.ts
index 52e376ea9..a77aa81b2 100644
--- a/packages/ensnode-sdk/src/shared/result/result-code.ts
+++ b/packages/ensnode-sdk/src/shared/result/result-code.ts
@@ -13,10 +13,22 @@ export const ResultCodes = {
   Ok: "ok",
 
   /**
-   * Server error: the operation failed due to an unexpected error internally within the server.
+   * Server error: the operation failed due to an unexpected error internally
+   * within the server.
    */
   InternalServerError: "internal-server-error",
 
+  /**
+   * Server error: the operation failed due to the requested service being
+   * unavailable at the time of the request.
+   */
+  ServiceUnavailable: "service-unavailable",
+
+  /**
+   * Server error: the operation failed due to insufficient indexing progress.
+   */
+  InsufficientIndexingProgress: "insufficient-indexing-progress",
+
   /**
    * Server error: the requested resource was not found.
    */
@@ -38,7 +50,8 @@ export const ResultCodes = {
   RequestTimeout: "request-timeout",
 
   /**
-   * Client error: received an unrecognized result from the server for an operation.
+   * Client error: received an unrecognized result from the server for
+   * an operation.
    */
   ClientUnrecognizedOperationResult: "client-unrecognized-operation-result",
 } as const;
@@ -48,6 +61,8 @@ export const ResultCodes = {
  */
 export const RESULT_CODE_SERVER_ERROR_CODES = [
   ResultCodes.InternalServerError,
+  ResultCodes.ServiceUnavailable,
+  ResultCodes.InsufficientIndexingProgress,
   ResultCodes.NotFound,
   ResultCodes.InvalidRequest,
 ] as const;
@@ -62,7 +77,8 @@ export const RESULT_CODE_CLIENT_ERROR_CODES = [
 ] as const;
 
 /**
- * List of all error codes the client can return (client-originated + relayed from server).
+ * List of all error codes the client can return
+ * (client-originated + relayed from server).
  */
 export const RESULT_CODE_ALL_ERROR_CODES = [
   ...RESULT_CODE_CLIENT_ERROR_CODES,
diff --git a/packages/ensnode-sdk/src/shared/result/result-common.ts b/packages/ensnode-sdk/src/shared/result/result-common.ts
index d13ab55a9..0f4162482 100644
--- a/packages/ensnode-sdk/src/shared/result/result-common.ts
+++ b/packages/ensnode-sdk/src/shared/result/result-common.ts
@@ -1,10 +1,99 @@
-/************************************************************
- * Internal Server Error
- ************************************************************/
+/**
+ * Common Result Types and Builders
+ *
+ * This module defines specific result data models that might be shared across more than 1 route.
+ */
 
+import type { UnixTimestamp } from "../types";
 import type { AbstractResultError } from "./result-base";
 import { type ResultCode, ResultCodes } from "./result-code";
 
+/************************************************************
+ * Service Unavailable
+ ************************************************************/
+
+export interface ResultServiceUnavailable
+  extends AbstractResultError<typeof ResultCodes.ServiceUnavailable> {}
+
+/**
+ * Builds a result object representing a service unavailable error.
+ */
+export const buildResultServiceUnavailable = (
+  errorMessage?: string,
+  suggestRetry: boolean = true,
+): ResultServiceUnavailable => {
+  return {
+    resultCode: ResultCodes.ServiceUnavailable,
+    errorMessage: errorMessage ?? "The service is currently unavailable.",
+    suggestRetry,
+  };
+};
+
+/************************************************************
+ * Insufficient Indexing Progress
+ ************************************************************/
+
+/**
+ * Data for insufficient indexing progress error result.
+ */
+export interface ResultInsufficientIndexingProgressData {
+  /**
+   * The current omnichain indexing status.
+   */
+  indexingStatus: string;
+
+  /**
+   * The timestamp of the "slowest" latest indexed block timestamp
+   * across all indexed chains.
+   */
+  slowestChainIndexingCursor: UnixTimestamp;
+
+  /**
+   * The timestamp of the earliest indexed block across all indexed chains.
+   */
+  earliestChainIndexingCursor: UnixTimestamp;
+
+  /**
+   * Information about when indexing progress is considered sufficient.
+   */
+  progressSufficientFrom: {
+    /**
+     * The required omnichain indexing status for sufficient progress.
+     */
+    indexingStatus: string;
+
+    /**
+     * The timestamp from which indexing progress is considered sufficient.
+     */
+    chainIndexingCursor: UnixTimestamp;
+  };
+}
+
+export interface ResultInsufficientIndexingProgress
+  extends AbstractResultError<
+    typeof ResultCodes.InsufficientIndexingProgress,
+    ResultInsufficientIndexingProgressData
+  > {}
+
+/**
+ * Builds a result object representing a insufficient indexing progress error.
+ */
+export const buildResultInsufficientIndexingProgress = (
+  errorMessage: string,
+  data: ResultInsufficientIndexingProgressData,
+): ResultInsufficientIndexingProgress => {
+  return {
+    resultCode: ResultCodes.InsufficientIndexingProgress,
+    suggestRetry: true,
+    errorMessage,
+    data,
+  };
+};
+
+/************************************************************
+ * Internal Server Error
+ ************************************************************/
+
 export interface ResultInternalServerError
   extends AbstractResultError<typeof ResultCodes.InternalServerError> {}
 
diff --git a/packages/ensnode-sdk/src/shared/result/zod-schemas.ts b/packages/ensnode-sdk/src/shared/result/zod-schemas.ts
new file mode 100644
index 000000000..9da02c7cd
--- /dev/null
+++ b/packages/ensnode-sdk/src/shared/result/zod-schemas.ts
@@ -0,0 +1,95 @@
+import z from "zod/v4";
+
+import type { AbstractResultError, AbstractResultOk, AbstractResultOkTimestamped } from "../result";
+import { makeUnixTimestampSchema } from "../zod-schemas";
+import { type ResultCode, ResultCodes } from "./result-code";
+import type {
+  ResultInsufficientIndexingProgress,
+  ResultInsufficientIndexingProgressData,
+  ResultInternalServerError,
+  ResultInvalidRequest,
+  ResultServiceUnavailable,
+} from "./result-common";
+
+/**
+ * Schema for {@link AbstractResultOk}.
+ */
+export const makeAbstractResultOkSchema = <TData>(dataSchema: z.ZodType<TData>) =>
+  z.object({
+    resultCode: z.literal(ResultCodes.Ok),
+    data: dataSchema,
+  });
+
+/**
+ * Schema for {@link AbstractResultOkTimestamped}.
+ */
+export const makeAbstractResultOkTimestampedSchema = <TData>(dataSchema: z.ZodType<TData>) =>
+  z.object({
+    resultCode: z.literal(ResultCodes.Ok),
+    data: dataSchema,
+    minIndexingCursor: makeUnixTimestampSchema("minIndexingCursor"),
+  });
+
+/**
+ * Schema for {@link AbstractResultError}.
+ */
+export const makeAbstractResultErrorSchema = <TResultCode extends ResultCode>(
+  resultCode: TResultCode,
+) =>
+  z.object({
+    resultCode: z.literal(resultCode),
+    errorMessage: z.string(),
+    suggestRetry: z.boolean(),
+  });
+
+/**
+ * Schema for {@link AbstractResultError} with data.
+ */
+export const makeAbstractResultErrorWithDataSchema = <TResultCode extends ResultCode, TData>(
+  resultCode: TResultCode,
+  dataSchema: z.ZodType<TData>,
+) =>
+  makeAbstractResultErrorSchema(resultCode).extend({
+    data: dataSchema,
+  });
+
+/**
+ * Schema for {@link ResultInvalidRequest}.
+ */
+export const makeResultErrorInvalidRequestSchema = () =>
+  makeAbstractResultErrorSchema(ResultCodes.InvalidRequest);
+
+/**
+ * Schema for {@link ResultInternalServerError}.
+ */
+export const makeResultErrorInternalServerErrorSchema = () =>
+  makeAbstractResultErrorSchema(ResultCodes.InternalServerError);
+
+/**
+ * Schema for {@link ResultServiceUnavailable}.
+ */
+export const makeResultErrorServiceUnavailableSchema = () =>
+  makeAbstractResultErrorSchema(ResultCodes.ServiceUnavailable);
+
+/**
+ * Schema for {@link ResultInsufficientIndexingProgressData}.
+ */
+export const makeResultErrorInsufficientIndexingProgressDataSchema = () =>
+  z.object({
+    indexingStatus: z.string(),
+    slowestChainIndexingCursor: makeUnixTimestampSchema("slowestChainIndexingCursor"),
+    earliestChainIndexingCursor: makeUnixTimestampSchema("earliestChainIndexingCursor"),
+    progressSufficientFrom: z.object({
+      indexingStatus: z.string(),
+      chainIndexingCursor: makeUnixTimestampSchema("progressSufficientFrom.chainIndexingCursor"),
+    }),
+  });
+
+/**
+ * Schema for {@link ResultInsufficientIndexingProgress}.
+ */
+export const makeResultErrorInsufficientIndexingProgressSchema = () =>
+  makeAbstractResultErrorWithDataSchema(
+    ResultCodes.InsufficientIndexingProgress,
+    makeResultErrorInsufficientIndexingProgressDataSchema(),
+  );
diff --git a/packages/ensnode-sdk/src/shared/zod-schemas.ts b/packages/ensnode-sdk/src/shared/zod-schemas.ts
index ab07a4018..0780e7075 100644
--- a/packages/ensnode-sdk/src/shared/zod-schemas.ts
+++ b/packages/ensnode-sdk/src/shared/zod-schemas.ts
@@ -13,7 +13,14 @@ import { z } from "zod/v4";
 
 import { ENSNamespaceIds, type InterpretedName, Node } from "../ens";
 import { asLowerCaseAddress } from "./address";
-import { type CurrencyId, CurrencyIds, Price, type PriceEth } from "./currencies";
+import {
+  type CurrencyId,
+  CurrencyIds,
+  Price,
+  type PriceEth,
+  SerializedPrice,
+  type SerializedPriceEth,
+} from "./currencies";
 import { reinterpretName } from "./interpretation/reinterpretation";
 import type { AccountIdString } from "./serialized-types";
 import type {
@@ -250,21 +257,38 @@ export const makeENSNamespaceIdSchema = (valueLabel: string = "ENSNamespaceId")
     },
   });
 
-const makePriceAmountSchema = (valueLabel: string = "Amount") =>
-  z.coerce
-    .bigint({
-      error: `${valueLabel} must represent a bigint.`,
-    })
-    .nonnegative({
-      error: `${valueLabel} must not be negative.`,
-    });
+const makeSerializedPriceAmountSchema = (_valueLabel: string = "Serialized Price Amount") =>
+  z.string();
+const makePriceAmountSchemaNative = (valueLabel: string = "Price Amount") =>
+  z.preprocess(
+    (v) => (typeof v === "string" ? BigInt(v) : v),
+    z
+      .bigint({
+        error: `${valueLabel} must represent a bigint.`,
+      })
+      .nonnegative({
+        error: `${valueLabel} must not be negative.`,
+      }),
+  );
 
 export const makePriceCurrencySchema = (
   currency: CurrencyId,
   valueLabel: string = "Price Currency",
 ) =>
   z.strictObject({
-    amount: makePriceAmountSchema(`${valueLabel} amount`),
+    amount: makePriceAmountSchemaNative(`${valueLabel} amount`),
+
+    currency: z.literal(currency, {
+      error: `${valueLabel} currency must be set to '${currency}'.`,
+    }),
+  });
+
+export const makeSerializedPriceCurrencySchema = (
+  currency: CurrencyId,
+  valueLabel: string = "Price Currency",
+) =>
+  z.strictObject({
+    amount: makeSerializedPriceAmountSchema(`${valueLabel} amount`),
 
     currency: z.literal(currency, {
       error: `${valueLabel} currency must be set to '${currency}'.`,
@@ -285,12 +309,34 @@ export const makePriceSchema = (valueLabel: string = "Price") =>
     { error: `${valueLabel} currency must be one of ${Object.values(CurrencyIds).join(", ")}` },
   );
 
+/**
+ * Schema for {@link SerializedPrice} type.
+ */
+export const makeSerializedPriceSchema = (valueLabel: string = "Serialized Price") =>
+  z.discriminatedUnion(
+    "currency",
+    [
+      makeSerializedPriceCurrencySchema(CurrencyIds.ETH, valueLabel),
+      makeSerializedPriceCurrencySchema(CurrencyIds.USDC, valueLabel),
+      makeSerializedPriceCurrencySchema(CurrencyIds.DAI, valueLabel),
+    ],
+    { error: `${valueLabel} currency must be one of ${Object.values(CurrencyIds).join(", ")}` },
+  );
+
 /**
  * Schema for {@link PriceEth} type.
  */
 export const makePriceEthSchema = (valueLabel: string = "Price ETH") =>
   makePriceCurrencySchema(CurrencyIds.ETH, valueLabel).transform((v) => v as PriceEth);
 
+/**
+ * Schema for {@link SerializedPriceEth} type.
+ */
+export const makeSerializedPriceEthSchema = (valueLabel: string = "Serialized Price ETH") =>
+  makeSerializedPriceCurrencySchema(CurrencyIds.ETH, valueLabel).transform(
+    (v) => v as SerializedPriceEth,
+  );
+
 /**
  * Schema for {@link AccountId} type.
  */