@ensnode/ensnode-sdk 0.0.0-next-20260227190633 → 0.0.0-next-20260301131020

package/dist/index.cjs

@@ -36,7 +36,6 @@ __export(index_exports, {
   ATTR_PROTOCOL_STEP_RESULT: () => ATTR_PROTOCOL_STEP_RESULT,
   AssetNamespaces: () => AssetNamespaces,
   BASENAMES_NODE: () => BASENAMES_NODE,
-  BlockRefRangeTypeIds: () => BlockRefRangeTypeIds,
   ChainIndexingStatusIds: () => ChainIndexingStatusIds,
   ClientError: () => ClientError,
   CrossChainIndexingStrategyIds: () => CrossChainIndexingStrategyIds,
@@ -75,6 +74,7 @@ __export(index_exports, {
   RECORDS_PER_PAGE_MAX: () => RECORDS_PER_PAGE_MAX,
   ROOT_NODE: () => ROOT_NODE,
   ROOT_RESOURCE: () => ROOT_RESOURCE,
+  RangeTypeIds: () => RangeTypeIds,
   RegistrarActionTypes: () => RegistrarActionTypes,
   RegistrarActionsFilterTypes: () => RegistrarActionsFilterTypes,
   RegistrarActionsOrders: () => RegistrarActionsOrders,
@@ -96,10 +96,14 @@ __export(index_exports, {
   bigIntToNumber: () => bigIntToNumber,
   bigintToCoinType: () => bigintToCoinType,
   buildAssetId: () => buildAssetId,
+  buildBlockNumberRange: () => buildBlockNumberRange,
+  buildBlockRefRange: () => buildBlockRefRange,
   buildEncodedReferrer: () => buildEncodedReferrer,
   buildEnsRainbowClientLabelSet: () => buildEnsRainbowClientLabelSet,
+  buildIndexedBlockranges: () => buildIndexedBlockranges,
   buildLabelSetId: () => buildLabelSetId,
   buildLabelSetVersion: () => buildLabelSetVersion,
+  buildOmnichainIndexingStatusSnapshot: () => buildOmnichainIndexingStatusSnapshot,
   buildPageContext: () => buildPageContext,
   buildUnresolvedIdentity: () => buildUnresolvedIdentity,
   buildUnvalidatedCrossChainIndexingStatusSnapshot: () => buildUnvalidatedCrossChainIndexingStatusSnapshot,
@@ -113,7 +117,6 @@ __export(index_exports, {
   coinTypeReverseLabel: () => coinTypeReverseLabel,
   coinTypeToEvmChainId: () => coinTypeToEvmChainId,
   constructSubInterpretedName: () => constructSubInterpretedName,
-  createIndexingConfig: () => createIndexingConfig,
   createRealtimeIndexingStatusProjection: () => createRealtimeIndexingStatusProjection,
   decodeDNSEncodedLiteralName: () => decodeDNSEncodedLiteralName,
   decodeDNSEncodedName: () => decodeDNSEncodedName,
@@ -121,7 +124,6 @@ __export(index_exports, {
   deserializeAssetId: () => deserializeAssetId,
   deserializeBlockNumber: () => deserializeBlockNumber,
   deserializeBlockRef: () => deserializeBlockRef,
-  deserializeBlockrange: () => deserializeBlockrange,
   deserializeChainId: () => deserializeChainId,
   deserializeChainIndexingStatusSnapshot: () => deserializeChainIndexingStatusSnapshot,
   deserializeConfigResponse: () => deserializeConfigResponse,
@@ -233,6 +235,7 @@ __export(index_exports, {
   makeSerializedEnsApiPublicConfigSchema: () => makeSerializedEnsApiPublicConfigSchema,
   makeSubdomainNode: () => makeSubdomainNode,
   maybeGetDatasourceContract: () => maybeGetDatasourceContract,
+  mergeBlockNumberRanges: () => mergeBlockNumberRanges,
   nameTokensPrerequisites: () => nameTokensPrerequisites,
   parseAccountId: () => parseAccountId,
   parseAssetId: () => parseAssetId,
@@ -742,23 +745,6 @@ var makeUrlSchema = (valueLabel = "Value") => import_v4.z.url({
   abort: true
 }).transform((v) => new URL(v));
 var makeBlockNumberSchema = (valueLabel = "Block number") => makeNonNegativeIntegerSchema(valueLabel);
-var makeBlockrangeSchema = (valueLabel = "Value") => import_v4.z.strictObject(
-  {
-    startBlock: makeBlockNumberSchema(`${valueLabel}.startBlock`).optional(),
-    endBlock: makeBlockNumberSchema(`${valueLabel}.endBlock`).optional()
-  },
-  {
-    error: `${valueLabel} must be a valid Blockrange object.`
-  }
-).refine(
-  (v) => {
-    if (v.startBlock && v.endBlock) {
-      return v.startBlock <= v.endBlock;
-    }
-    return true;
-  },
-  { error: `${valueLabel}: startBlock must be before or equal to endBlock` }
-);
 var makeBlockRefSchema = (valueLabel = "Value") => import_v4.z.strictObject(
   {
     timestamp: makeUnixTimestampSchema(`${valueLabel}.timestamp`),
@@ -1089,28 +1075,119 @@ function serializeEnsApiConfigResponse(response) {
 var serializeConfigResponse = serializeEnsApiConfigResponse;
 
 // src/ensapi/api/indexing-status/deserialize.ts
-var import_v415 = require("zod/v4");
+var import_v416 = require("zod/v4");
 
 // src/indexing-status/deserialize/realtime-indexing-status-projection.ts
-var import_v413 = require("zod/v4");
+var import_v414 = require("zod/v4");
 
 // src/indexing-status/zod-schema/realtime-indexing-status-projection.ts
-var import_v410 = require("zod/v4");
+var import_v411 = require("zod/v4");
 
 // src/indexing-status/zod-schema/cross-chain-indexing-status-snapshot.ts
-var import_v49 = require("zod/v4");
+var import_v410 = require("zod/v4");
 
-// src/indexing-status/chain-indexing-status-snapshot.ts
-var BlockRefRangeTypeIds = {
-  /**
-   * Represents that indexing of the chain should be performed for an indefinite range.
-   */
-  Indefinite: "indefinite",
-  /**
-   * Represents that indexing of the chain should be performed for a definite range.
-   */
-  Definite: "definite"
+// src/shared/block-ref.ts
+function isBefore(blockA, blockB) {
+  return blockA.number < blockB.number && blockA.timestamp < blockB.timestamp;
+}
+function isEqualTo(blockA, blockB) {
+  return blockA.number === blockB.number && blockA.timestamp === blockB.timestamp;
+}
+function isBeforeOrEqualTo(blockA, blockB) {
+  return isBefore(blockA, blockB) || isEqualTo(blockA, blockB);
+}
+
+// src/shared/blockrange.ts
+var RangeTypeIds = {
+  Unbounded: "unbounded",
+  LeftBounded: "left-bounded",
+  RightBounded: "right-bounded",
+  Bounded: "bounded"
 };
+function buildBlockNumberRange(startBlock, endBlock) {
+  if (startBlock === void 0 && endBlock === void 0) {
+    return {
+      rangeType: RangeTypeIds.Unbounded
+    };
+  }
+  if (startBlock !== void 0 && endBlock === void 0) {
+    return {
+      rangeType: RangeTypeIds.LeftBounded,
+      startBlock
+    };
+  }
+  if (startBlock === void 0 && endBlock !== void 0) {
+    return {
+      rangeType: RangeTypeIds.RightBounded,
+      endBlock
+    };
+  }
+  if (startBlock !== void 0 && endBlock !== void 0) {
+    if (startBlock > endBlock) {
+      throw new Error(
+        `For a block number range startBlock must be lower than or equal to endBlock.`
+      );
+    }
+    return {
+      rangeType: RangeTypeIds.Bounded,
+      startBlock,
+      endBlock
+    };
+  }
+  throw new Error("Invalid block number range. This should be unreachable.");
+}
+function mergeBlockNumberRanges(...ranges) {
+  if (ranges.length === 0) {
+    return buildBlockNumberRange(void 0, void 0);
+  }
+  let minStartBlock;
+  let maxEndBlock;
+  for (const range of ranges) {
+    if (range.startBlock !== void 0) {
+      if (minStartBlock === void 0 || range.startBlock < minStartBlock) {
+        minStartBlock = range.startBlock;
+      }
+    }
+    if (range.endBlock !== void 0) {
+      if (maxEndBlock === void 0 || range.endBlock > maxEndBlock) {
+        maxEndBlock = range.endBlock;
+      }
+    }
+  }
+  return buildBlockNumberRange(minStartBlock, maxEndBlock);
+}
+function buildBlockRefRange(startBlock, endBlock) {
+  if (startBlock === void 0 && endBlock === void 0) {
+    return {
+      rangeType: RangeTypeIds.Unbounded
+    };
+  }
+  if (startBlock !== void 0 && endBlock === void 0) {
+    return {
+      rangeType: RangeTypeIds.LeftBounded,
+      startBlock
+    };
+  }
+  if (startBlock === void 0 && endBlock !== void 0) {
+    return {
+      rangeType: RangeTypeIds.RightBounded,
+      endBlock
+    };
+  }
+  if (startBlock !== void 0 && endBlock !== void 0) {
+    if (isBeforeOrEqualTo(startBlock, endBlock) === false) {
+      throw new Error(`For a block ref range startBlock must be before or equal to endBlock.`);
+    }
+    return {
+      rangeType: RangeTypeIds.Bounded,
+      startBlock,
+      endBlock
+    };
+  }
+  throw new Error("Invalid block ref range. This should be unreachable.");
+}
+
+// src/indexing-status/chain-indexing-status-snapshot.ts
 var ChainIndexingStatusIds = {
   /**
    * Represents that indexing of the chain is not ready to begin yet because:
@@ -1142,19 +1219,6 @@ var ChainIndexingStatusIds = {
    */
   Completed: "chain-completed"
 };
-function createIndexingConfig(startBlock, endBlock) {
-  if (endBlock) {
-    return {
-      blockRangeType: BlockRefRangeTypeIds.Definite,
-      startBlock,
-      endBlock
-    };
-  }
-  return {
-    blockRangeType: BlockRefRangeTypeIds.Indefinite,
-    startBlock
-  };
-}
 function getTimestampForLowestOmnichainStartBlock(chains) {
   const earliestKnownBlockTimestamps = chains.map(
     (chain) => chain.config.startBlock.timestamp
@@ -1171,7 +1235,7 @@ function getTimestampForHighestOmnichainKnownBlock(chains) {
   for (const chain of chains) {
     switch (chain.chainStatus) {
       case ChainIndexingStatusIds.Queued:
-        if (chain.config.blockRangeType === BlockRefRangeTypeIds.Definite) {
+        if (chain.config.rangeType === RangeTypeIds.Bounded) {
           latestKnownBlockTimestamps.push(chain.config.endBlock.timestamp);
         }
         break;
@@ -1229,7 +1293,20 @@ function getLatestIndexedBlockRef(indexingStatus, chainId) {
 }
 
 // src/indexing-status/zod-schema/omnichain-indexing-status-snapshot.ts
-var import_v48 = require("zod/v4");
+var import_v49 = require("zod/v4");
+
+// src/indexing-status/validate/omnichain-indexing-status-snapshot.ts
+var import_v47 = require("zod/v4");
+function validateOmnichainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
+  const schema = makeOmnichainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(unvalidatedSnapshot);
+  if (parsed.error) {
+    throw new Error(`Invalid OmnichainIndexingStatusSnapshot:
+${(0, import_v47.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
 
 // src/indexing-status/omnichain-indexing-status-snapshot.ts
 var OmnichainIndexingStatusIds = {
@@ -1311,25 +1388,54 @@ function getOmnichainIndexingCursor(chains) {
   }
   return Math.max(...latestIndexedBlockTimestamps);
 }
-
-// src/indexing-status/zod-schema/chain-indexing-status-snapshot.ts
-var import_v47 = require("zod/v4");
-
-// src/shared/block-ref.ts
-function isBefore(blockA, blockB) {
-  return blockA.number < blockB.number && blockA.timestamp < blockB.timestamp;
-}
-function isEqualTo(blockA, blockB) {
-  return blockA.number === blockB.number && blockA.timestamp === blockB.timestamp;
-}
-function isBeforeOrEqualTo(blockA, blockB) {
-  return isBefore(blockA, blockB) || isEqualTo(blockA, blockB);
+function buildOmnichainIndexingStatusSnapshot(chainStatusSnapshots) {
+  if (chainStatusSnapshots.size === 0) {
+    throw new Error(
+      "At least one chain indexing status snapshot is required to build an OmnichainIndexingStatusSnapshot"
+    );
+  }
+  const chains = Array.from(chainStatusSnapshots.values());
+  const omnichainStatus = getOmnichainIndexingStatus(chains);
+  const omnichainIndexingCursor = getOmnichainIndexingCursor(chains);
+  switch (omnichainStatus) {
+    case OmnichainIndexingStatusIds.Unstarted: {
+      return validateOmnichainIndexingStatusSnapshot({
+        omnichainStatus: OmnichainIndexingStatusIds.Unstarted,
+        chains: chainStatusSnapshots,
+        // narrowing the type here, will be validated in the following 'check' step
+        omnichainIndexingCursor
+      });
+    }
+    case OmnichainIndexingStatusIds.Backfill: {
+      return validateOmnichainIndexingStatusSnapshot({
+        omnichainStatus: OmnichainIndexingStatusIds.Backfill,
+        chains: chainStatusSnapshots,
+        // narrowing the type here, will be validated in the following 'check' step
+        omnichainIndexingCursor
+      });
+    }
+    case OmnichainIndexingStatusIds.Completed: {
+      return validateOmnichainIndexingStatusSnapshot({
+        omnichainStatus: OmnichainIndexingStatusIds.Completed,
+        chains: chainStatusSnapshots,
+        // narrowing the type here, will be validated in the following 'check' step
+        omnichainIndexingCursor
+      });
+    }
+    case OmnichainIndexingStatusIds.Following:
+      return validateOmnichainIndexingStatusSnapshot({
+        omnichainStatus: OmnichainIndexingStatusIds.Following,
+        chains: chainStatusSnapshots,
+        omnichainIndexingCursor
+      });
+  }
 }
 
 // src/indexing-status/zod-schema/chain-indexing-status-snapshot.ts
+var import_v48 = require("zod/v4");
 function invariant_chainSnapshotQueuedBlocks(ctx) {
   const { config } = ctx.value;
-  if (config.blockRangeType === BlockRefRangeTypeIds.Indefinite) {
+  if (config.rangeType === RangeTypeIds.LeftBounded) {
     return;
   }
   if (isBeforeOrEqualTo(config.startBlock, config.endBlock) === false) {
@@ -1356,7 +1462,7 @@ function invariant_chainSnapshotBackfillBlocks(ctx) {
       message: "`latestIndexedBlock` must be before or same as `backfillEndBlock`."
     });
   }
-  if (config.blockRangeType === BlockRefRangeTypeIds.Indefinite) {
+  if (config.rangeType === RangeTypeIds.LeftBounded) {
     return;
   }
   if (isEqualTo(backfillEndBlock, config.endBlock) === false) {
@@ -1401,46 +1507,55 @@ function invariant_chainSnapshotFollowingBlocks(ctx) {
     });
   }
 }
-var makeBlockRefRangeSchema = (valueLabel = "Value") => import_v47.z.discriminatedUnion("blockRangeType", [
-  import_v47.z.object({
-    blockRangeType: import_v47.z.literal(BlockRefRangeTypeIds.Indefinite),
-    startBlock: makeBlockRefSchema(valueLabel)
-  }),
-  import_v47.z.object({
-    blockRangeType: import_v47.z.literal(BlockRefRangeTypeIds.Definite),
-    startBlock: makeBlockRefSchema(valueLabel),
-    endBlock: makeBlockRefSchema(valueLabel)
-  })
-]);
-var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v47.z.object({
-  chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Queued),
-  config: makeBlockRefRangeSchema(valueLabel)
+var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v48.z.object({
+  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Queued),
+  config: import_v48.z.discriminatedUnion("rangeType", [
+    import_v48.z.object({
+      rangeType: import_v48.z.literal(RangeTypeIds.LeftBounded),
+      startBlock: makeBlockRefSchema(valueLabel)
+    }),
+    import_v48.z.object({
+      rangeType: import_v48.z.literal(RangeTypeIds.Bounded),
+      startBlock: makeBlockRefSchema(valueLabel),
+      endBlock: makeBlockRefSchema(valueLabel)
+    })
+  ])
 }).check(invariant_chainSnapshotQueuedBlocks);
-var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v47.z.object({
-  chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Backfill),
-  config: makeBlockRefRangeSchema(valueLabel),
+var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v48.z.object({
+  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Backfill),
+  config: import_v48.z.discriminatedUnion("rangeType", [
+    import_v48.z.object({
+      rangeType: import_v48.z.literal(RangeTypeIds.LeftBounded),
+      startBlock: makeBlockRefSchema(valueLabel)
+    }),
+    import_v48.z.object({
+      rangeType: import_v48.z.literal(RangeTypeIds.Bounded),
+      startBlock: makeBlockRefSchema(valueLabel),
+      endBlock: makeBlockRefSchema(valueLabel)
+    })
+  ]),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
   backfillEndBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotBackfillBlocks);
-var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v47.z.object({
-  chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Completed),
-  config: import_v47.z.object({
-    blockRangeType: import_v47.z.literal(BlockRefRangeTypeIds.Definite),
+var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v48.z.object({
+  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Completed),
+  config: import_v48.z.object({
+    rangeType: import_v48.z.literal(RangeTypeIds.Bounded),
     startBlock: makeBlockRefSchema(valueLabel),
     endBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotCompletedBlocks);
-var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v47.z.object({
-  chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Following),
-  config: import_v47.z.object({
-    blockRangeType: import_v47.z.literal(BlockRefRangeTypeIds.Indefinite),
+var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v48.z.object({
+  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Following),
+  config: import_v48.z.object({
+    rangeType: import_v48.z.literal(RangeTypeIds.LeftBounded),
     startBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
   latestKnownBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotFollowingBlocks);
-var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v47.z.discriminatedUnion("chainStatus", [
+var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v48.z.discriminatedUnion("chainStatus", [
   makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
   makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1569,11 +1684,11 @@ function invariant_omnichainStatusSnapshotFollowingHasValidChains(ctx) {
     });
   }
 }
-var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Unstarted),
-  chains: import_v48.z.map(
+var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v49.z.object({
+  omnichainStatus: import_v49.z.literal(OmnichainIndexingStatusIds.Unstarted),
+  chains: import_v49.z.map(
     makeChainIdSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v49.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel)
     ]),
     {
@@ -1582,11 +1697,11 @@ var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 }).check(invariant_omnichainSnapshotUnstartedHasValidChains);
-var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Backfill),
-  chains: import_v48.z.map(
+var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v49.z.object({
+  omnichainStatus: import_v49.z.literal(OmnichainIndexingStatusIds.Backfill),
+  chains: import_v49.z.map(
     makeChainIdSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v49.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
       makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
       makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
@@ -1597,11 +1712,11 @@ var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 }).check(invariant_omnichainStatusSnapshotBackfillHasValidChains);
-var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Completed),
-  chains: import_v48.z.map(
+var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v49.z.object({
+  omnichainStatus: import_v49.z.literal(OmnichainIndexingStatusIds.Completed),
+  chains: import_v49.z.map(
     makeChainIdSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v49.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
     ]),
     {
@@ -1610,11 +1725,11 @@ var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 }).check(invariant_omnichainStatusSnapshotCompletedHasValidChains);
-var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Following),
-  chains: import_v48.z.map(
+var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v49.z.object({
+  omnichainStatus: import_v49.z.literal(OmnichainIndexingStatusIds.Following),
+  chains: import_v49.z.map(
     makeChainIdSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v49.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
       makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
       makeChainIndexingStatusSnapshotFollowingSchema(valueLabel),
@@ -1626,7 +1741,7 @@ var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 }).check(invariant_omnichainStatusSnapshotFollowingHasValidChains);
-var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v48.z.discriminatedUnion("omnichainStatus", [
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v49.z.discriminatedUnion("omnichainStatus", [
   makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1634,21 +1749,21 @@ var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexin
 ]).check(invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot).check(invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains).check(
   invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains
 ).check(invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain);
-var makeSerializedOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Unstarted),
-  chains: import_v48.z.record(
+var makeSerializedOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v49.z.object({
+  omnichainStatus: import_v49.z.literal(OmnichainIndexingStatusIds.Unstarted),
+  chains: import_v49.z.record(
     makeChainIdStringSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v49.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel)
     ])
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Backfill),
-  chains: import_v48.z.record(
+var makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v49.z.object({
+  omnichainStatus: import_v49.z.literal(OmnichainIndexingStatusIds.Backfill),
+  chains: import_v49.z.record(
     makeChainIdStringSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v49.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
       makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
       makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
@@ -1656,21 +1771,21 @@ var makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) =
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeSerializedOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Completed),
-  chains: import_v48.z.record(
+var makeSerializedOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v49.z.object({
+  omnichainStatus: import_v49.z.literal(OmnichainIndexingStatusIds.Completed),
+  chains: import_v49.z.record(
     makeChainIdStringSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v49.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
     ])
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeSerializedOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Following),
-  chains: import_v48.z.record(
+var makeSerializedOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v49.z.object({
+  omnichainStatus: import_v49.z.literal(OmnichainIndexingStatusIds.Following),
+  chains: import_v49.z.record(
     makeChainIdStringSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v49.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
       makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
       makeChainIndexingStatusSnapshotFollowingSchema(valueLabel),
@@ -1679,7 +1794,7 @@ var makeSerializedOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel)
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeSerializedOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v48.z.discriminatedUnion("omnichainStatus", [
+var makeSerializedOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v49.z.discriminatedUnion("omnichainStatus", [
   makeSerializedOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
   makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeSerializedOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1702,7 +1817,7 @@ function invariant_snapshotTimeIsTheHighestKnownBlockTimestamp(ctx) {
   const { snapshotTime, omnichainSnapshot } = ctx.value;
   const chains = Array.from(omnichainSnapshot.chains.values());
   const startBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
-  const endBlockTimestamps = chains.map((chain) => chain.config).filter((chainConfig) => chainConfig.blockRangeType === BlockRefRangeTypeIds.Definite).map((chainConfig) => chainConfig.endBlock.timestamp);
+  const endBlockTimestamps = chains.map((chain) => chain.config).filter((chainConfig) => chainConfig.rangeType === RangeTypeIds.Bounded).map((chainConfig) => chainConfig.endBlock.timestamp);
   const backfillEndBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill).map((chain) => chain.backfillEndBlock.timestamp);
   const latestKnownBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Following).map((chain) => chain.latestKnownBlock.timestamp);
   const highestKnownBlockTimestamp = Math.max(
@@ -1719,17 +1834,17 @@ function invariant_snapshotTimeIsTheHighestKnownBlockTimestamp(ctx) {
     });
   }
 }
-var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => import_v49.z.object({
-  strategy: import_v49.z.literal(CrossChainIndexingStrategyIds.Omnichain),
+var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => import_v410.z.object({
+  strategy: import_v410.z.literal(CrossChainIndexingStrategyIds.Omnichain),
   slowestChainIndexingCursor: makeUnixTimestampSchema(valueLabel),
   snapshotTime: makeUnixTimestampSchema(valueLabel),
   omnichainSnapshot: makeOmnichainIndexingStatusSnapshotSchema(valueLabel)
 }).check(invariant_slowestChainEqualsToOmnichainSnapshotTime).check(invariant_snapshotTimeIsTheHighestKnownBlockTimestamp);
-var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => import_v49.z.discriminatedUnion("strategy", [
+var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => import_v410.z.discriminatedUnion("strategy", [
   makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
 ]);
-var makeSerializedCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Serialized Cross-chain Indexing Status Snapshot") => import_v49.z.object({
-  strategy: import_v49.z.enum(CrossChainIndexingStrategyIds),
+var makeSerializedCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Serialized Cross-chain Indexing Status Snapshot") => import_v410.z.object({
+  strategy: import_v410.z.enum(CrossChainIndexingStrategyIds),
   slowestChainIndexingCursor: makeUnixTimestampSchema(valueLabel),
   snapshotTime: makeUnixTimestampSchema(valueLabel),
   omnichainSnapshot: makeSerializedOmnichainIndexingStatusSnapshotSchema(valueLabel)
@@ -1759,22 +1874,22 @@ function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ct
     });
   }
 }
-var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v410.z.object({
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v411.z.object({
   projectedAt: makeUnixTimestampSchema(valueLabel),
   worstCaseDistance: makeDurationSchema(valueLabel),
   snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
 }).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
-var makeSerializedRealtimeIndexingStatusProjectionSchema = (valueLabel = "Value") => import_v410.z.object({
+var makeSerializedRealtimeIndexingStatusProjectionSchema = (valueLabel = "Value") => import_v411.z.object({
   snapshot: makeSerializedCrossChainIndexingStatusSnapshotSchema(valueLabel),
   projectedAt: makeUnixTimestampSchema(valueLabel),
   worstCaseDistance: makeDurationSchema(valueLabel)
 });
 
 // src/indexing-status/deserialize/cross-chain-indexing-status-snapshot.ts
-var import_v412 = require("zod/v4");
+var import_v413 = require("zod/v4");
 
 // src/indexing-status/deserialize/omnichain-indexing-status-snapshot.ts
-var import_v411 = require("zod/v4");
+var import_v412 = require("zod/v4");
 function buildUnvalidatedOmnichainIndexingStatusSnapshot(serializedSnapshot) {
   const chains = /* @__PURE__ */ new Map();
   for (const [chainIdString, chainIndexingStatusSnapshot] of Object.entries(
@@ -1795,7 +1910,7 @@ function deserializeOmnichainIndexingStatusSnapshot(data, valueLabel) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into OmnichainIndexingStatusSnapshot:
-${(0, import_v411.prettifyError)(parsed.error)}
+${(0, import_v412.prettifyError)(parsed.error)}
 `
     );
   }
@@ -1817,7 +1932,7 @@ function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel)
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into CrossChainIndexingStatusSnapshot:
-${(0, import_v412.prettifyError)(parsed.error)}
+${(0, import_v413.prettifyError)(parsed.error)}
 `
     );
   }
@@ -1837,7 +1952,7 @@ function deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into RealtimeIndexingStatusProjection:
-${(0, import_v413.prettifyError)(parsed.error)}
+${(0, import_v414.prettifyError)(parsed.error)}
 `
     );
   }
@@ -1858,23 +1973,23 @@ var EnsApiIndexingStatusResponseCodes = {
 var IndexingStatusResponseCodes = EnsApiIndexingStatusResponseCodes;
 
 // src/ensapi/api/indexing-status/zod-schemas.ts
-var import_v414 = require("zod/v4");
-var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v414.z.strictObject({
-  responseCode: import_v414.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
+var import_v415 = require("zod/v4");
+var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v415.z.strictObject({
+  responseCode: import_v415.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v414.z.strictObject({
-  responseCode: import_v414.z.literal(EnsApiIndexingStatusResponseCodes.Error)
+var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v415.z.strictObject({
+  responseCode: import_v415.z.literal(EnsApiIndexingStatusResponseCodes.Error)
 });
-var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v414.z.discriminatedUnion("responseCode", [
+var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v415.z.discriminatedUnion("responseCode", [
   makeEnsApiIndexingStatusResponseOkSchema(valueLabel),
   makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
 ]);
-var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v414.z.strictObject({
-  responseCode: import_v414.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
+var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v415.z.strictObject({
+  responseCode: import_v415.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v414.z.discriminatedUnion("responseCode", [
+var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v415.z.discriminatedUnion("responseCode", [
   makeSerializedEnsApiIndexingStatusResponseOkSchema(valueLabel),
   makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
 ]);
@@ -1896,7 +2011,7 @@ function deserializeEnsApiIndexingStatusResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize EnsApiIndexingStatusResponse:
-${(0, import_v415.prettifyError)(parsed.error)}
+${(0, import_v416.prettifyError)(parsed.error)}
 `
     );
   }
@@ -2033,11 +2148,11 @@ function serializeEnsApiIndexingStatusResponse(response) {
 var serializeIndexingStatusResponse = serializeEnsApiIndexingStatusResponse;
 
 // src/ensapi/api/name-tokens/deserialize.ts
-var import_v420 = require("zod/v4");
+var import_v421 = require("zod/v4");
 
 // src/ensapi/api/name-tokens/zod-schemas.ts
 var import_viem14 = require("viem");
-var import_v419 = require("zod/v4");
+var import_v420 = require("zod/v4");
 
 // src/tokenscope/name-token.ts
 var import_viem13 = require("viem");
@@ -2077,12 +2192,12 @@ var makeContractMatcher = (namespace, b) => (datasourceName, contractName) => {
 
 // src/tokenscope/assets.ts
 var import_viem12 = require("viem");
-var import_v417 = require("zod/v4");
+var import_v418 = require("zod/v4");
 
 // src/tokenscope/zod-schemas.ts
 var import_caip3 = require("caip");
 var import_viem11 = require("viem");
-var import_v416 = require("zod/v4");
+var import_v417 = require("zod/v4");
 
 // src/shared/types.ts
 var AssetNamespaces = {
@@ -2091,10 +2206,10 @@ var AssetNamespaces = {
 };
 
 // src/tokenscope/zod-schemas.ts
-var tokenIdSchemaSerializable = import_v416.z.string();
-var tokenIdSchemaNative = import_v416.z.preprocess(
+var tokenIdSchemaSerializable = import_v417.z.string();
+var tokenIdSchemaNative = import_v417.z.preprocess(
   (v) => typeof v === "string" ? BigInt(v) : v,
-  import_v416.z.bigint().positive()
+  import_v417.z.bigint().positive()
 );
 function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false) {
   if (serializable) {
@@ -2104,13 +2219,13 @@ function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false
   }
 }
 var makeAssetIdSchema = (valueLabel = "Asset ID Schema", serializable) => {
-  return import_v416.z.object({
-    assetNamespace: import_v416.z.enum(AssetNamespaces),
+  return import_v417.z.object({
+    assetNamespace: import_v417.z.enum(AssetNamespaces),
     contract: makeAccountIdSchema(valueLabel),
     tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
   });
 };
-var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v416.z.preprocess((v) => {
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v417.z.preprocess((v) => {
   if (typeof v === "string") {
     const result = new import_caip3.AssetId(v);
     return {
@@ -2134,20 +2249,20 @@ function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v416.z.object({
-  ownershipType: import_v416.z.literal(NameTokenOwnershipTypes.NameWrapper),
+var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v417.z.object({
+  ownershipType: import_v417.z.literal(NameTokenOwnershipTypes.NameWrapper),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v416.z.object({
-  ownershipType: import_v416.z.literal(NameTokenOwnershipTypes.FullyOnchain),
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v417.z.object({
+  ownershipType: import_v417.z.literal(NameTokenOwnershipTypes.FullyOnchain),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v416.z.object({
-  ownershipType: import_v416.z.literal(NameTokenOwnershipTypes.Burned),
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v417.z.object({
+  ownershipType: import_v417.z.literal(NameTokenOwnershipTypes.Burned),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
-var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v416.z.object({
-  ownershipType: import_v416.z.literal(NameTokenOwnershipTypes.Unknown),
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v417.z.object({
+  ownershipType: import_v417.z.literal(NameTokenOwnershipTypes.Unknown),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
 function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
@@ -2160,16 +2275,16 @@ function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v416.z.discriminatedUnion("ownershipType", [
+var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v417.z.discriminatedUnion("ownershipType", [
   makeNameTokenOwnershipNameWrapperSchema(valueLabel),
   makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
   makeNameTokenOwnershipBurnedSchema(valueLabel),
   makeNameTokenOwnershipUnknownSchema(valueLabel)
 ]);
-var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v416.z.object({
+var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v417.z.object({
   token: makeAssetIdSchema(`${valueLabel}.token`, serializable),
   ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
-  mintStatus: import_v416.z.enum(NFTMintStatuses)
+  mintStatus: import_v417.z.enum(NFTMintStatuses)
 });
 
 // src/tokenscope/assets.ts
@@ -2185,7 +2300,7 @@ function deserializeAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AssetId:
-${(0, import_v417.prettifyError)(parsed.error)}
+${(0, import_v418.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2195,7 +2310,7 @@ function parseAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot parse AssetId:
-${(0, import_v417.prettifyError)(parsed.error)}
+${(0, import_v418.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2495,10 +2610,10 @@ function getNameTokenOwnership(namespaceId, name, owner) {
 }
 
 // src/ensapi/api/shared/errors/zod-schemas.ts
-var import_v418 = require("zod/v4");
-var ErrorResponseSchema = import_v418.z.object({
-  message: import_v418.z.string(),
-  details: import_v418.z.optional(import_v418.z.unknown())
+var import_v419 = require("zod/v4");
+var ErrorResponseSchema = import_v419.z.object({
+  message: import_v419.z.string(),
+  details: import_v419.z.optional(import_v419.z.unknown())
 });
 
 // src/ensapi/api/name-tokens/response.ts
@@ -2537,10 +2652,10 @@ var NameTokensResponseErrorCodes = {
 };
 
 // src/ensapi/api/name-tokens/zod-schemas.ts
-var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v419.z.object({
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v420.z.object({
   domainId: makeNodeSchema(`${valueLabel}.domainId`),
   name: makeReinterpretedNameSchema(valueLabel),
-  tokens: import_v419.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
+  tokens: import_v420.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
   expiresAt: makeUnixTimestampSchema(`${valueLabel}.expiresAt`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 }).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
@@ -2582,32 +2697,32 @@ var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", seria
     });
   }
 });
-var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v419.z.strictObject({
-  responseCode: import_v419.z.literal(NameTokensResponseCodes.Ok),
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v420.z.strictObject({
+  responseCode: import_v420.z.literal(NameTokensResponseCodes.Ok),
   registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`, serializable)
 });
-var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v419.z.strictObject({
-  responseCode: import_v419.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v419.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v420.z.strictObject({
+  responseCode: import_v420.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v420.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v419.z.strictObject({
-  responseCode: import_v419.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v419.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v420.z.strictObject({
+  responseCode: import_v420.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v420.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v419.z.strictObject({
-  responseCode: import_v419.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v419.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v420.z.strictObject({
+  responseCode: import_v420.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v420.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v419.z.discriminatedUnion("errorCode", [
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v420.z.discriminatedUnion("errorCode", [
   makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
   makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
   makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
 ]);
 var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response", serializable) => {
-  return import_v419.z.discriminatedUnion("responseCode", [
+  return import_v420.z.discriminatedUnion("responseCode", [
     makeNameTokensResponseOkSchema(valueLabel, serializable ?? false),
     makeNameTokensResponseErrorSchema(valueLabel)
   ]);
@@ -2620,7 +2735,7 @@ function deserializedNameTokensResponse(maybeResponse) {
   );
   if (parsed.error) {
     throw new Error(`Cannot deserialize NameTokensResponse:
-${(0, import_v420.prettifyError)(parsed.error)}
+${(0, import_v421.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2694,14 +2809,14 @@ function serializeNameTokensResponse(response) {
 }
 
 // src/ensapi/api/registrar-actions/deserialize.ts
-var import_v424 = require("zod/v4");
+var import_v425 = require("zod/v4");
 
 // src/ensapi/api/registrar-actions/zod-schemas.ts
 var import_ens7 = require("viem/ens");
-var import_v423 = require("zod/v4");
+var import_v424 = require("zod/v4");
 
 // src/registrars/zod-schemas.ts
-var import_v421 = require("zod/v4");
+var import_v422 = require("zod/v4");
 
 // src/registrars/encoded-referrer.ts
 var import_viem15 = require("viem");
@@ -2776,11 +2891,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v421.z.object({
+var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v422.z.object({
   subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
   node: makeNodeSchema(`${valueLabel} Node`)
 });
-var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v421.z.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v422.z.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -2796,18 +2911,18 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v421.z.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v422.z.union([
   // pricing available
-  import_v421.z.object({
+  import_v422.z.object({
     baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
     premium: makePriceEthSchema(`${valueLabel} Premium`),
     total: makePriceEthSchema(`${valueLabel} Total`)
   }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
   // pricing unknown
-  import_v421.z.object({
-    baseCost: import_v421.z.null(),
-    premium: import_v421.z.null(),
-    total: import_v421.z.null()
+  import_v422.z.object({
+    baseCost: import_v422.z.null(),
+    premium: import_v422.z.null(),
+    total: import_v422.z.null()
   }).transform((v) => v)
 ]);
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
@@ -2830,9 +2945,9 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
     });
   }
 }
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v421.z.union([
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v422.z.union([
   // referral available
-  import_v421.z.object({
+  import_v422.z.object({
     encodedReferrer: makeHexStringSchema(
       { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
       `${valueLabel} Encoded Referrer`
@@ -2840,9 +2955,9 @@ var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral
     decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
   }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
   // referral not applicable
-  import_v421.z.object({
-    encodedReferrer: import_v421.z.null(),
-    decodedReferrer: import_v421.z.null()
+  import_v422.z.object({
+    encodedReferrer: import_v422.z.null(),
+    decodedReferrer: import_v422.z.null()
   })
 ]);
 function invariant_eventIdsInitialElementIsTheActionId(ctx) {
@@ -2855,9 +2970,9 @@ function invariant_eventIdsInitialElementIsTheActionId(ctx) {
     });
   }
 }
-var EventIdSchema = import_v421.z.string().nonempty();
-var EventIdsSchema = import_v421.z.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v421.z.object({
+var EventIdSchema = import_v422.z.string().nonempty();
+var EventIdsSchema = import_v422.z.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v422.z.object({
   id: EventIdSchema,
   incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
   registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`),
@@ -2871,38 +2986,38 @@ var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => im
   eventIds: EventIdsSchema
 }).check(invariant_eventIdsInitialElementIsTheActionId);
 var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v421.z.literal(RegistrarActionTypes.Registration)
+  type: import_v422.z.literal(RegistrarActionTypes.Registration)
 });
 var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v421.z.literal(RegistrarActionTypes.Renewal)
+  type: import_v422.z.literal(RegistrarActionTypes.Renewal)
 });
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v421.z.discriminatedUnion("type", [
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v422.z.discriminatedUnion("type", [
   makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
   makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
 ]);
 
 // src/ensapi/api/shared/pagination/zod-schemas.ts
-var import_v422 = require("zod/v4");
+var import_v423 = require("zod/v4");
 
 // src/ensapi/api/shared/pagination/request.ts
 var RECORDS_PER_PAGE_DEFAULT = 10;
 var RECORDS_PER_PAGE_MAX = 100;
 
 // src/ensapi/api/shared/pagination/zod-schemas.ts
-var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v422.z.object({
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v423.z.object({
   page: makePositiveIntegerSchema(`${valueLabel}.page`),
   recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
     RECORDS_PER_PAGE_MAX,
     `${valueLabel}.recordsPerPage must not exceed ${RECORDS_PER_PAGE_MAX}`
   )
 });
-var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v422.z.object({
-  totalRecords: import_v422.z.literal(0),
-  totalPages: import_v422.z.literal(1),
-  hasNext: import_v422.z.literal(false),
-  hasPrev: import_v422.z.literal(false),
-  startIndex: import_v422.z.undefined(),
-  endIndex: import_v422.z.undefined()
+var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v423.z.object({
+  totalRecords: import_v423.z.literal(0),
+  totalPages: import_v423.z.literal(1),
+  hasNext: import_v423.z.literal(false),
+  hasPrev: import_v423.z.literal(false),
+  startIndex: import_v423.z.undefined(),
+  endIndex: import_v423.z.undefined()
 }).extend(makeRequestPageParamsSchema(valueLabel).shape);
 function invariant_responsePageWithRecordsIsCorrect(ctx) {
   const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
@@ -2937,15 +3052,15 @@ function invariant_responsePageWithRecordsIsCorrect(ctx) {
     });
   }
 }
-var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v422.z.object({
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v423.z.object({
   totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: import_v422.z.boolean(),
-  hasPrev: import_v422.z.boolean(),
+  hasNext: import_v423.z.boolean(),
+  hasPrev: import_v423.z.boolean(),
   startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
   endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
 }).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
-var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v422.z.union([
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v423.z.union([
   makeResponsePageContextSchemaWithNoRecords(valueLabel),
   makeResponsePageContextSchemaWithRecords(valueLabel)
 ]);
@@ -2975,21 +3090,21 @@ function invariant_registrationLifecycleNodeMatchesName(ctx) {
     });
   }
 }
-var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v423.z.object({
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v424.z.object({
   action: makeRegistrarActionSchema(valueLabel),
   name: makeReinterpretedNameSchema(valueLabel)
 }).check(invariant_registrationLifecycleNodeMatchesName);
-var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v423.z.object({
-  responseCode: import_v423.z.literal(RegistrarActionsResponseCodes.Ok),
-  registrarActions: import_v423.z.array(makeNamedRegistrarActionSchema(valueLabel)),
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v424.z.object({
+  responseCode: import_v424.z.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: import_v424.z.array(makeNamedRegistrarActionSchema(valueLabel)),
   pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`).optional()
 });
-var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v423.z.strictObject({
-  responseCode: import_v423.z.literal(RegistrarActionsResponseCodes.Error),
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v424.z.strictObject({
+  responseCode: import_v424.z.literal(RegistrarActionsResponseCodes.Error),
   error: ErrorResponseSchema
 });
-var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v423.z.discriminatedUnion("responseCode", [
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v424.z.discriminatedUnion("responseCode", [
   makeRegistrarActionsResponseOkSchema(valueLabel),
   makeRegistrarActionsResponseErrorSchema(valueLabel)
 ]);
@@ -3000,7 +3115,7 @@ function deserializeRegistrarActionsResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize RegistrarActionsResponse:
-${(0, import_v424.prettifyError)(parsed.error)}
+${(0, import_v425.prettifyError)(parsed.error)}
 `
     );
   }
@@ -3147,12 +3262,12 @@ function serializeRegistrarActionsResponse(response) {
 }
 
 // src/ensapi/api/shared/errors/deserialize.ts
-var import_v425 = require("zod/v4");
+var import_v426 = require("zod/v4");
 function deserializeErrorResponse(maybeErrorResponse) {
   const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ErrorResponse:
-${(0, import_v425.prettifyError)(parsed.error)}
+${(0, import_v426.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -3712,7 +3827,7 @@ function serializeEnsIndexerConfigResponse(response) {
 }
 
 // src/ensindexer/api/indexing-status/deserialize.ts
-var import_v427 = require("zod/v4");
+var import_v428 = require("zod/v4");
 
 // src/ensindexer/api/indexing-status/response.ts
 var EnsIndexerIndexingStatusResponseCodes = {
@@ -3727,23 +3842,23 @@ var EnsIndexerIndexingStatusResponseCodes = {
 };
 
 // src/ensindexer/api/indexing-status/zod-schemas.ts
-var import_v426 = require("zod/v4");
-var makeEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v426.z.strictObject({
-  responseCode: import_v426.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
+var import_v427 = require("zod/v4");
+var makeEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v427.z.strictObject({
+  responseCode: import_v427.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeEnsIndexerIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v426.z.strictObject({
-  responseCode: import_v426.z.literal(EnsIndexerIndexingStatusResponseCodes.Error)
+var makeEnsIndexerIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v427.z.strictObject({
+  responseCode: import_v427.z.literal(EnsIndexerIndexingStatusResponseCodes.Error)
 });
-var makeEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v426.z.discriminatedUnion("responseCode", [
+var makeEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v427.z.discriminatedUnion("responseCode", [
   makeEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
   makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
 ]);
-var makeSerializedEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v426.z.strictObject({
-  responseCode: import_v426.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
+var makeSerializedEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v427.z.strictObject({
+  responseCode: import_v427.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeSerializedEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v426.z.discriminatedUnion("responseCode", [
+var makeSerializedEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v427.z.discriminatedUnion("responseCode", [
   makeSerializedEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
   makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
 ]);
@@ -3765,7 +3880,7 @@ function deserializeEnsIndexerIndexingStatusResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize EnsIndexerIndexingStatusResponse:
-${(0, import_v427.prettifyError)(parsed.error)}
+${(0, import_v428.prettifyError)(parsed.error)}
 `
     );
   }
@@ -3786,13 +3901,13 @@ function serializeEnsIndexerIndexingStatusResponse(response) {
 }
 
 // src/ensindexer/api/shared/errors/deserialize.ts
-var import_v429 = require("zod/v4");
+var import_v430 = require("zod/v4");
 
 // src/ensindexer/api/shared/errors/zod-schemas.ts
-var import_v428 = require("zod/v4");
-var ErrorResponseSchema2 = import_v428.z.object({
-  message: import_v428.z.string(),
-  details: import_v428.z.optional(import_v428.z.unknown())
+var import_v429 = require("zod/v4");
+var ErrorResponseSchema2 = import_v429.z.object({
+  message: import_v429.z.string(),
+  details: import_v429.z.optional(import_v429.z.unknown())
 });
 
 // src/ensindexer/api/shared/errors/deserialize.ts
@@ -3800,7 +3915,7 @@ function deserializeErrorResponse2(maybeErrorResponse) {
   const parsed = ErrorResponseSchema2.safeParse(maybeErrorResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ErrorResponse:
-${(0, import_v429.prettifyError)(parsed.error)}
+${(0, import_v430.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4077,14 +4192,14 @@ function isResolvedIdentity(identity) {
 }
 
 // src/indexing-status/deserialize/chain-indexing-status-snapshot.ts
-var import_v430 = require("zod/v4");
+var import_v431 = require("zod/v4");
 function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(maybeSnapshot);
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into ChainIndexingStatusSnapshot:
-${(0, import_v430.prettifyError)(parsed.error)}
+${(0, import_v431.prettifyError)(parsed.error)}
 `
     );
   }
@@ -4102,38 +4217,25 @@ function createRealtimeIndexingStatusProjection(snapshot, now) {
 }
 
 // src/indexing-status/validate/chain-indexing-status-snapshot.ts
-var import_v431 = require("zod/v4");
+var import_v432 = require("zod/v4");
 function validateChainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid ChainIndexingStatusSnapshot:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v432.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
 // src/indexing-status/validate/cross-chain-indexing-status-snapshot.ts
-var import_v432 = require("zod/v4");
+var import_v433 = require("zod/v4");
 function validateCrossChainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeCrossChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid CrossChainIndexingStatusSnapshot:
-${(0, import_v432.prettifyError)(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
-
-// src/indexing-status/validate/omnichain-indexing-status-snapshot.ts
-var import_v433 = require("zod/v4");
-function validateOmnichainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
-  const schema = makeOmnichainIndexingStatusSnapshotSchema(valueLabel);
-  const parsed = schema.safeParse(unvalidatedSnapshot);
-  if (parsed.error) {
-    throw new Error(`Invalid OmnichainIndexingStatusSnapshot:
 ${(0, import_v433.prettifyError)(parsed.error)}
 `);
   }
@@ -4376,16 +4478,6 @@ ${(0, import_v435.prettifyError)(parsed.error)}
   }
   return parsed.data;
 }
-function deserializeBlockrange(maybeBlockrange, valueLabel) {
-  const schema = makeBlockrangeSchema(valueLabel);
-  const parsed = schema.safeParse(maybeBlockrange);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize Blockrange:
-${(0, import_v435.prettifyError)(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
 function deserializeBlockRef(maybeBlockRef, valueLabel) {
   const schema = makeBlockRefSchema(valueLabel);
   const parsed = schema.safeParse(maybeBlockRef);
@@ -4592,6 +4684,39 @@ var TtlCache = class {
   }
 };
 
+// src/shared/config/indexed-blockranges.ts
+var import_datasources12 = require("@ensnode/datasources");
+function buildIndexedBlockranges(namespace, pluginsRequiredDatasourceNames) {
+  const indexedBlockranges = /* @__PURE__ */ new Map();
+  for (const [pluginName, requiredDatasourceNames] of pluginsRequiredDatasourceNames) {
+    for (const requiredDatasourceName of requiredDatasourceNames) {
+      const requiredDatasource = (0, import_datasources12.maybeGetDatasource)(namespace, requiredDatasourceName);
+      if (!requiredDatasource) {
+        throw new Error(
+          `Datasource ${requiredDatasourceName} required by plugin ${pluginName} is not defined in namespace ${namespace}.`
+        );
+      }
+      const datasourceChainId = requiredDatasource.chain.id;
+      const datasourceContracts = Object.values(requiredDatasource.contracts);
+      for (const datasourceContract of datasourceContracts) {
+        const currentChainIndexedBlockrange = indexedBlockranges.get(datasourceChainId);
+        const contractIndexedBlockrange = buildBlockNumberRange(
+          datasourceContract.startBlock,
+          datasourceContract.endBlock
+        );
+        const indexedBlockrange = currentChainIndexedBlockrange ? mergeBlockNumberRanges(currentChainIndexedBlockrange, contractIndexedBlockrange) : contractIndexedBlockrange;
+        if (indexedBlockrange.rangeType !== RangeTypeIds.LeftBounded && indexedBlockrange.rangeType !== RangeTypeIds.Bounded) {
+          throw new Error(
+            `Indexed blockrange for chain ${datasourceChainId} is expected to be left-bounded or bounded, but got ${indexedBlockrange.rangeType}.`
+          );
+        }
+        indexedBlockranges.set(datasourceChainId, indexedBlockrange);
+      }
+    }
+  }
+  return indexedBlockranges;
+}
+
 // src/shared/interpretation/interpret-address.ts
 var import_viem18 = require("viem");
 var interpretAddress = (owner) => (0, import_viem18.isAddressEqual)(import_viem18.zeroAddress, owner) ? null : owner;
@@ -4708,10 +4833,10 @@ ${JSON.stringify(concrete)}`
 }
 
 // src/shared/root-registry.ts
-var import_datasources12 = require("@ensnode/datasources");
-var getENSv1Registry = (namespace) => getDatasourceContract(namespace, import_datasources12.DatasourceNames.ENSRoot, "ENSv1Registry");
+var import_datasources13 = require("@ensnode/datasources");
+var getENSv1Registry = (namespace) => getDatasourceContract(namespace, import_datasources13.DatasourceNames.ENSRoot, "ENSv1Registry");
 var isENSv1Registry = (namespace, contract) => accountIdEqual(getENSv1Registry(namespace), contract);
-var getENSv2RootRegistry = (namespace) => getDatasourceContract(namespace, import_datasources12.DatasourceNames.ENSv2Root, "RootRegistry");
+var getENSv2RootRegistry = (namespace) => getDatasourceContract(namespace, import_datasources13.DatasourceNames.ENSv2Root, "RootRegistry");
 var getENSv2RootRegistryId = (namespace) => makeRegistryId(getENSv2RootRegistry(namespace));
 var isENSv2RootRegistry = (namespace, contract) => accountIdEqual(getENSv2RootRegistry(namespace), contract);