@ensnode/ensnode-sdk 1.1.0 → 1.3.0

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   ATTR_PROTOCOL_NAME: () => ATTR_PROTOCOL_NAME,
   ATTR_PROTOCOL_STEP: () => ATTR_PROTOCOL_STEP,
   ATTR_PROTOCOL_STEP_RESULT: () => ATTR_PROTOCOL_STEP_RESULT,
+  AssetNamespaces: () => AssetNamespaces,
   BASENAMES_NODE: () => BASENAMES_NODE,
   ChainIndexingConfigTypeIds: () => ChainIndexingConfigTypeIds,
   ChainIndexingStatusIds: () => ChainIndexingStatusIds,
@@ -44,16 +45,25 @@ __export(index_exports, {
   DEFAULT_EVM_COIN_TYPE: () => DEFAULT_EVM_COIN_TYPE,
   ENSNamespaceIds: () => import_datasources.ENSNamespaceIds,
   ENSNodeClient: () => ENSNodeClient,
+  ENS_ROOT: () => ENS_ROOT,
   ETH_COIN_TYPE: () => ETH_COIN_TYPE,
   ETH_NODE: () => ETH_NODE,
   ForwardResolutionProtocolStep: () => ForwardResolutionProtocolStep,
   IndexingStatusResponseCodes: () => IndexingStatusResponseCodes,
   LINEANAMES_NODE: () => LINEANAMES_NODE,
   LruCache: () => LruCache,
+  NFTMintStatuses: () => NFTMintStatuses,
+  NFTTransferTypes: () => NFTTransferTypes,
+  NameTokenOwnershipTypes: () => NameTokenOwnershipTypes,
+  NameTokensResponseCodes: () => NameTokensResponseCodes,
+  NameTokensResponseErrorCodes: () => NameTokensResponseErrorCodes,
   OmnichainIndexingStatusIds: () => OmnichainIndexingStatusIds,
   PROTOCOL_ATTRIBUTE_PREFIX: () => PROTOCOL_ATTRIBUTE_PREFIX,
   PluginName: () => PluginName,
+  RECORDS_PER_PAGE_DEFAULT: () => RECORDS_PER_PAGE_DEFAULT,
+  RECORDS_PER_PAGE_MAX: () => RECORDS_PER_PAGE_MAX,
   ROOT_NODE: () => ROOT_NODE,
+  ReferrerDetailResponseCodes: () => ReferrerDetailResponseCodes,
   ReferrerLeaderboardPageResponseCodes: () => ReferrerLeaderboardPageResponseCodes,
   RegistrarActionTypes: () => RegistrarActionTypes,
   RegistrarActionsFilterTypes: () => RegistrarActionsFilterTypes,
@@ -75,9 +85,11 @@ __export(index_exports, {
   beautifyName: () => beautifyName,
   bigIntToNumber: () => bigIntToNumber,
   bigintToCoinType: () => bigintToCoinType,
+  buildAssetId: () => buildAssetId,
   buildEnsRainbowClientLabelSet: () => buildEnsRainbowClientLabelSet,
   buildLabelSetId: () => buildLabelSetId,
   buildLabelSetVersion: () => buildLabelSetVersion,
+  buildPageContext: () => buildPageContext,
   buildUnresolvedIdentity: () => buildUnresolvedIdentity,
   checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill: () => checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill,
   checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted: () => checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted,
@@ -90,12 +102,13 @@ __export(index_exports, {
   decodeDNSEncodedLiteralName: () => decodeDNSEncodedLiteralName,
   decodeDNSEncodedName: () => decodeDNSEncodedName,
   decodeEncodedReferrer: () => decodeEncodedReferrer,
-  deserializeAccountId: () => deserializeAccountId,
+  deserializeAssetId: () => deserializeAssetId,
   deserializeBlockNumber: () => deserializeBlockNumber,
   deserializeBlockRef: () => deserializeBlockRef,
   deserializeBlockrange: () => deserializeBlockrange,
   deserializeChainId: () => deserializeChainId,
   deserializeChainIndexingStatusSnapshot: () => deserializeChainIndexingStatusSnapshot,
+  deserializeConfigResponse: () => deserializeConfigResponse,
   deserializeCrossChainIndexingStatusSnapshot: () => deserializeCrossChainIndexingStatusSnapshot,
   deserializeDatetime: () => deserializeDatetime,
   deserializeDuration: () => deserializeDuration,
@@ -105,20 +118,35 @@ __export(index_exports, {
   deserializeIndexingStatusResponse: () => deserializeIndexingStatusResponse,
   deserializeOmnichainIndexingStatusSnapshot: () => deserializeOmnichainIndexingStatusSnapshot,
   deserializeRealtimeIndexingStatusProjection: () => deserializeRealtimeIndexingStatusProjection,
+  deserializeReferrerDetailResponse: () => deserializeReferrerDetailResponse,
   deserializeReferrerLeaderboardPageResponse: () => deserializeReferrerLeaderboardPageResponse,
   deserializeRegistrarActionsResponse: () => deserializeRegistrarActionsResponse,
   deserializeUnixTimestamp: () => deserializeUnixTimestamp,
   deserializeUrl: () => deserializeUrl,
+  deserializedNameTokensResponse: () => deserializedNameTokensResponse,
   durationBetween: () => durationBetween,
   encodeLabelHash: () => encodeLabelHash,
   evmChainIdToCoinType: () => evmChainIdToCoinType,
+  formatAccountId: () => formatAccountId,
+  formatAssetId: () => formatAssetId,
+  formatNFTTransferEventMetadata: () => formatNFTTransferEventMetadata,
+  getBasenamesSubregistryId: () => getBasenamesSubregistryId,
+  getBasenamesSubregistryManagedName: () => getBasenamesSubregistryManagedName,
   getCurrencyInfo: () => getCurrencyInfo,
+  getDatasourceContract: () => getDatasourceContract,
   getENSRootChainId: () => import_datasources2.getENSRootChainId,
   getEthnamesSubregistryId: () => getEthnamesSubregistryId,
+  getEthnamesSubregistryManagedName: () => getEthnamesSubregistryManagedName,
   getLatestIndexedBlockRef: () => getLatestIndexedBlockRef,
+  getLineanamesSubregistryId: () => getLineanamesSubregistryId,
+  getLineanamesSubregistryManagedName: () => getLineanamesSubregistryManagedName,
+  getNFTTransferType: () => getNFTTransferType,
   getNameHierarchy: () => getNameHierarchy,
+  getNameTokenOwnership: () => getNameTokenOwnership,
+  getNameWrapperAccounts: () => getNameWrapperAccounts,
   getOmnichainIndexingCursor: () => getOmnichainIndexingCursor,
   getOmnichainIndexingStatus: () => getOmnichainIndexingStatus,
+  getParentNameFQDN: () => getParentNameFQDN,
   getResolvePrimaryNameChainIdParam: () => getResolvePrimaryNameChainIdParam,
   getTimestampForHighestOmnichainKnownBlock: () => getTimestampForHighestOmnichainKnownBlock,
   getTimestampForLowestOmnichainStartBlock: () => getTimestampForLowestOmnichainStartBlock,
@@ -144,6 +172,10 @@ __export(index_exports, {
   literalLabelsToLiteralName: () => literalLabelsToLiteralName,
   makeENSApiPublicConfigSchema: () => makeENSApiPublicConfigSchema,
   makeSubdomainNode: () => makeSubdomainNode,
+  maybeGetDatasourceContract: () => maybeGetDatasourceContract,
+  nameTokensPrerequisites: () => nameTokensPrerequisites,
+  parseAccountId: () => parseAccountId,
+  parseAssetId: () => parseAssetId,
   parseNonNegativeInteger: () => parseNonNegativeInteger,
   parseReverseName: () => parseReverseName,
   priceDai: () => priceDai,
@@ -152,26 +184,30 @@ __export(index_exports, {
   registrarActionsFilter: () => registrarActionsFilter,
   registrarActionsPrerequisites: () => registrarActionsPrerequisites,
   reverseName: () => reverseName,
-  serializeAccountId: () => serializeAccountId,
+  serializeAssetId: () => serializeAssetId,
   serializeChainId: () => serializeChainId,
   serializeChainIndexingSnapshots: () => serializeChainIndexingSnapshots,
+  serializeConfigResponse: () => serializeConfigResponse,
   serializeCrossChainIndexingStatusSnapshotOmnichain: () => serializeCrossChainIndexingStatusSnapshotOmnichain,
   serializeDatetime: () => serializeDatetime,
+  serializeDomainAssetId: () => serializeDomainAssetId,
   serializeENSApiPublicConfig: () => serializeENSApiPublicConfig,
   serializeENSIndexerPublicConfig: () => serializeENSIndexerPublicConfig,
   serializeIndexedChainIds: () => serializeIndexedChainIds,
   serializeIndexingStatusResponse: () => serializeIndexingStatusResponse,
+  serializeNameToken: () => serializeNameToken,
+  serializeNameTokensResponse: () => serializeNameTokensResponse,
   serializeNamedRegistrarAction: () => serializeNamedRegistrarAction,
   serializeOmnichainIndexingStatusSnapshot: () => serializeOmnichainIndexingStatusSnapshot,
   serializePrice: () => serializePrice,
   serializePriceEth: () => serializePriceEth,
   serializeRealtimeIndexingStatusProjection: () => serializeRealtimeIndexingStatusProjection,
+  serializeReferrerDetailResponse: () => serializeReferrerDetailResponse,
   serializeReferrerLeaderboardPageResponse: () => serializeReferrerLeaderboardPageResponse,
+  serializeRegisteredNameTokens: () => serializeRegisteredNameTokens,
   serializeRegistrarAction: () => serializeRegistrarAction,
   serializeRegistrarActionPricing: () => serializeRegistrarActionPricing,
   serializeRegistrarActionsResponse: () => serializeRegistrarActionsResponse,
-  serializeRegistrationLifecycle: () => serializeRegistrationLifecycle,
-  serializeSubregistry: () => serializeSubregistry,
   serializeUrl: () => serializeUrl,
   sortChainStatusesByStartBlockAsc: () => sortChainStatusesByStartBlockAsc,
   stripNullBytes: () => stripNullBytes,
@@ -182,35 +218,15 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/api/deserialize.ts
-var import_v49 = require("zod/v4");
+// src/ensapi/config/deserialize.ts
+var import_v45 = require("zod/v4");
 
-// src/api/zod-schemas.ts
-var import_viem14 = require("viem");
-var import_v48 = __toESM(require("zod/v4"), 1);
+// src/ensapi/config/zod-schemas.ts
+var import_v44 = require("zod/v4");
 
-// src/ensindexer/indexing-status/zod-schemas.ts
+// src/ensindexer/config/zod-schemas.ts
 var import_v43 = __toESM(require("zod/v4"), 1);
 
-// src/ens/is-normalized.ts
-var import_ens = require("viem/ens");
-function isNormalizedName(name) {
-  try {
-    return name === (0, import_ens.normalize)(name);
-  } catch {
-    return false;
-  }
-}
-function isNormalizedLabel(label) {
-  if (label === "") return false;
-  if (label.includes(".")) return false;
-  try {
-    return label === (0, import_ens.normalize)(label);
-  } catch {
-    return false;
-  }
-}
-
 // src/shared/account-id.ts
 var import_viem = require("viem");
 var accountIdEqual = (a, b) => {
@@ -361,9 +377,39 @@ function isEncodedLabelHash(maybeEncodedLabelHash) {
   return expectedFormatting && includesLabelHash;
 }
 
+// src/ens/is-normalized.ts
+var import_ens = require("viem/ens");
+function isNormalizedName(name) {
+  try {
+    return name === (0, import_ens.normalize)(name);
+  } catch {
+    return false;
+  }
+}
+function isNormalizedLabel(label) {
+  if (label === "") return false;
+  if (label.includes(".")) return false;
+  try {
+    return label === (0, import_ens.normalize)(label);
+  } catch {
+    return false;
+  }
+}
+
 // src/ens/names.ts
 var import_ens_normalize = require("@adraffy/ens-normalize");
+var ENS_ROOT = "";
 var getNameHierarchy = (name) => name.split(".").map((_, i, labels) => labels.slice(i).join("."));
+var getParentNameFQDN = (name) => {
+  if (name === ENS_ROOT) {
+    throw new Error("There is no parent name for ENS Root.");
+  }
+  const labels = name.split(".");
+  if (labels.length === 1) {
+    return ENS_ROOT;
+  }
+  return labels.slice(1).join(".");
+};
 var beautifyName = (name) => {
   const beautifiedLabels = name.split(".").map((label) => {
     if (isNormalizedLabel(label)) {
@@ -606,7 +652,7 @@ var makeAccountIdSchema = (valueLabel = "AccountId") => import_v4.default.strict
   chainId: makeChainIdSchema(`${valueLabel} chain ID`),
   address: makeLowercaseAddressSchema(`${valueLabel} address`)
 });
-var makeSerializedAccountIdSchema = (valueLabel = "Account ID") => import_v4.default.coerce.string().transform((v) => {
+var makeAccountIdStringSchema = (valueLabel = "Account ID String") => import_v4.default.coerce.string().transform((v) => {
   const result = new import_caip.AccountId(v);
   return {
     chainId: Number(result.chainId.reference),
@@ -618,7 +664,7 @@ var makeHexStringSchema = (options, valueLabel = "String representation of bytes
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
-      message: `${valueLabel} must start with '0x'.`
+      message: `${valueLabel} must be a hexadecimal value which starts with '0x'.`
     });
   }
 }).transform((v) => v).check(function invariant_encodesRequiredBytesCount(ctx) {
@@ -728,8 +774,8 @@ ${(0, import_v42.prettifyError)(parsed.error)}
   }
   return parsed.data;
 }
-function deserializeAccountId(maybeAccountId, valueLabel) {
-  const schema = makeSerializedAccountIdSchema(valueLabel);
+function parseAccountId(maybeAccountId, valueLabel) {
+  const schema = makeAccountIdStringSchema(valueLabel);
   const parsed = schema.safeParse(maybeAccountId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AccountId:
@@ -992,6 +1038,28 @@ var TtlCache = class {
 // src/shared/collections.ts
 var uniq = (arr) => [...new Set(arr)];
 
+// src/shared/datasource-contract.ts
+var import_datasources3 = require("@ensnode/datasources");
+var maybeGetDatasourceContract = (namespaceId, datasourceName, contractName) => {
+  const datasource = (0, import_datasources3.maybeGetDatasource)(namespaceId, datasourceName);
+  if (!datasource) return void 0;
+  const address = datasource.contracts[contractName]?.address;
+  if (address === void 0 || Array.isArray(address)) return void 0;
+  return {
+    chainId: datasource.chain.id,
+    address
+  };
+};
+var getDatasourceContract = (namespaceId, datasourceName, contractName) => {
+  const contract = maybeGetDatasourceContract(namespaceId, datasourceName, contractName);
+  if (!contract) {
+    throw new Error(
+      `Expected contract not found for ${namespaceId} ${datasourceName} ${contractName}`
+    );
+  }
+  return contract;
+};
+
 // src/shared/labelhash.ts
 var import_viem9 = require("viem");
 var labelhashLiteralLabel = (label) => (0, import_viem9.keccak256)((0, import_viem9.stringToBytes)(label));
@@ -1050,7 +1118,7 @@ function serializePrice(price) {
 function serializePriceEth(price) {
   return serializePrice(price);
 }
-function serializeAccountId(accountId) {
+function formatAccountId(accountId) {
   return import_caip2.AccountId.format({
     chainId: { namespace: "eip155", reference: accountId.chainId.toString() },
     address: accountId.address
@@ -1065,776 +1133,1670 @@ function isWebSocketProtocol(url) {
   return ["ws:", "wss:"].includes(url.protocol);
 }
 
-// src/ensindexer/indexing-status/types.ts
-var ChainIndexingConfigTypeIds = {
-  /**
-   * 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"
-};
-var ChainIndexingStatusIds = {
-  /**
-   * Represents that indexing of the chain is not ready to begin yet because:
-   * - ENSIndexer is in its initialization phase and the data to build a
-   *   "true" {@link ChainIndexingSnapshot} for the chain is still being loaded; or
-   * - ENSIndexer is using an omnichain indexing strategy and the
-   *   `omnichainIndexingCursor` is <= `config.startBlock.timestamp` for the chain's
-   *   {@link ChainIndexingSnapshot}.
-   */
-  Queued: "chain-queued",
-  /**
-   * Represents that indexing of the chain is in progress and under a special
-   * "backfill" phase that optimizes for accelerated indexing until reaching the
-   * "fixed target" `backfillEndBlock`.
-   */
-  Backfill: "chain-backfill",
-  /**
-   * Represents that the "backfill" phase of indexing the chain is completed
-   * and that the chain is configured to be indexed for an indefinite range.
-   * Therefore, indexing of the chain remains indefinitely in progress where
-   * ENSIndexer will continuously work to discover and index new blocks as they
-   * are added to the chain across time.
-   */
-  Following: "chain-following",
-  /**
-   * Represents that indexing of the chain is completed as the chain is configured
-   * to be indexed for a definite range and the indexing of all blocks through
-   * that definite range is completed.
-   */
-  Completed: "chain-completed"
-};
-var OmnichainIndexingStatusIds = {
-  /**
-   * Represents that omnichain indexing is not ready to begin yet because
-   * ENSIndexer is in its initialization phase and the data to build a "true"
-   * {@link OmnichainIndexingStatusSnapshot} is still being loaded.
-   */
-  Unstarted: "omnichain-unstarted",
-  /**
-   * Represents that omnichain indexing is in an overall "backfill" status because
-   * - At least one indexed chain has a `chainStatus` of
-   *   {@link ChainIndexingStatusIds.Backfill}; and
-   * - No indexed chain has a `chainStatus` of {@link ChainIndexingStatusIds.Following}.
-   */
-  Backfill: "omnichain-backfill",
-  /**
-   * Represents that omnichain indexing is in an overall "following" status because
-   * at least one indexed chain has a `chainStatus` of
-   * {@link ChainIndexingStatusIds.Following}.
-   */
-  Following: "omnichain-following",
-  /**
-   * Represents that omnichain indexing has completed because all indexed chains have
-   * a `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
-   */
-  Completed: "omnichain-completed"
-};
-var CrossChainIndexingStrategyIds = {
-  /**
-   * Represents that the indexing of events across all indexed chains will
-   * proceed in a deterministic "omnichain" ordering by block timestamp, chain ID,
-   * and block number.
-   *
-   * This strategy is "deterministic" in that the order of processing cross-chain indexed
-   * events and each resulting indexed data state transition recorded in ENSDb is always
-   * the same for each ENSIndexer instance operating with an equivalent
-   * `ENSIndexerConfig` and ENSIndexer version. However it also has the drawbacks of:
-   * - increased indexing latency that must wait for the slowest indexed chain to
-   *   add new blocks or to discover new blocks through the configured RPCs.
-   * - if any indexed chain gets "stuck" due to chain or RPC failures, all indexed chains
-   *   will be affected.
-   */
-  Omnichain: "omnichain"
-};
+// src/ensindexer/config/is-subgraph-compatible.ts
+var import_datasources4 = require("@ensnode/datasources");
 
-// 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/ensindexer/config/types.ts
+var PluginName = /* @__PURE__ */ ((PluginName2) => {
+  PluginName2["Subgraph"] = "subgraph";
+  PluginName2["Basenames"] = "basenames";
+  PluginName2["Lineanames"] = "lineanames";
+  PluginName2["ThreeDNS"] = "threedns";
+  PluginName2["ProtocolAcceleration"] = "protocol-acceleration";
+  PluginName2["Registrars"] = "registrars";
+  PluginName2["TokenScope"] = "tokenscope";
+  return PluginName2;
+})(PluginName || {});
+
+// src/ensindexer/config/is-subgraph-compatible.ts
+function isSubgraphCompatible(config) {
+  const onlySubgraphPluginActivated = config.plugins.length === 1 && config.plugins[0] === "subgraph" /* Subgraph */;
+  const isSubgraphLabelSet = config.labelSet.labelSetId === "subgraph" && config.labelSet.labelSetVersion === 0;
+  const isEnsTestEnvLabelSet = config.labelSet.labelSetId === "ens-test-env" && config.labelSet.labelSetVersion === 0;
+  const labelSetIsSubgraphCompatible = isSubgraphLabelSet || config.namespace === import_datasources4.ENSNamespaceIds.EnsTestEnv && isEnsTestEnvLabelSet;
+  return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
 }
 
-// src/ensindexer/indexing-status/helpers.ts
-function getOmnichainIndexingStatus(chains) {
-  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains)) {
-    return OmnichainIndexingStatusIds.Following;
+// src/ensindexer/config/validations.ts
+function invariant_ensDbVersionIsSameAsEnsIndexerVersion(ctx) {
+  const versionInfo = ctx.value;
+  if (versionInfo.ensDb !== versionInfo.ensIndexer) {
+    ctx.issues.push({
+      code: "custom",
+      input: versionInfo,
+      message: "`ensDb` version must be same as `ensIndexer` version"
+    });
   }
-  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains)) {
-    return OmnichainIndexingStatusIds.Backfill;
+}
+
+// src/ensindexer/config/zod-schemas.ts
+var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => import_v43.default.array(makeChainIdSchema(valueLabel), {
+  error: `${valueLabel} must be an array.`
+}).min(1, { error: `${valueLabel} list must include at least one element.` }).transform((v) => new Set(v));
+var makePluginsListSchema = (valueLabel = "Plugins") => import_v43.default.array(import_v43.default.string(), {
+  error: `${valueLabel} must be a list of strings.`
+}).min(1, {
+  error: `${valueLabel} must be a list of strings with at least one string value`
+}).refine((arr) => arr.length === uniq(arr).length, {
+  error: `${valueLabel} cannot contain duplicate values.`
+});
+var makeDatabaseSchemaNameSchema = (valueLabel = "Database schema name") => import_v43.default.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
+  error: `${valueLabel} is required and must be a non-empty string.`
+});
+var makeLabelSetIdSchema = (valueLabel) => {
+  return import_v43.default.string({ error: `${valueLabel} must be a string` }).min(1, { error: `${valueLabel} must be 1-50 characters long` }).max(50, { error: `${valueLabel} must be 1-50 characters long` }).regex(/^[a-z-]+$/, {
+    error: `${valueLabel} can only contain lowercase letters (a-z) and hyphens (-)`
+  });
+};
+var makeLabelSetVersionSchema = (valueLabel) => {
+  return import_v43.default.coerce.number({ error: `${valueLabel} must be an integer.` }).pipe(makeNonNegativeIntegerSchema(valueLabel));
+};
+var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
+  let valueLabelLabelSetId = valueLabel;
+  let valueLabelLabelSetVersion = valueLabel;
+  if (valueLabel === "LABEL_SET") {
+    valueLabelLabelSetId = "LABEL_SET_ID";
+    valueLabelLabelSetVersion = "LABEL_SET_VERSION";
+  } else {
+    valueLabelLabelSetId = `${valueLabel}.labelSetId`;
+    valueLabelLabelSetVersion = `${valueLabel}.labelSetVersion`;
   }
-  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains)) {
-    return OmnichainIndexingStatusIds.Unstarted;
+  return import_v43.default.object({
+    labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
+    labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
+  });
+};
+var makeNonEmptyStringSchema = (valueLabel = "Value") => import_v43.default.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
+var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => import_v43.default.strictObject(
+  {
+    nodejs: makeNonEmptyStringSchema(),
+    ponder: makeNonEmptyStringSchema(),
+    ensDb: makeNonEmptyStringSchema(),
+    ensIndexer: makeNonEmptyStringSchema(),
+    ensNormalize: makeNonEmptyStringSchema(),
+    ensRainbow: makeNonEmptyStringSchema(),
+    ensRainbowSchema: makePositiveIntegerSchema()
+  },
+  {
+    error: `${valueLabel} must be a valid ENSIndexerVersionInfo object.`
   }
-  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains)) {
-    return OmnichainIndexingStatusIds.Completed;
+).check(invariant_ensDbVersionIsSameAsEnsIndexerVersion);
+function invariant_isSubgraphCompatibleRequirements(ctx) {
+  const { value: config } = ctx;
+  if (config.isSubgraphCompatible && !isSubgraphCompatible(config)) {
+    ctx.issues.push({
+      code: "custom",
+      input: config,
+      message: `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active and labelSet must be {labelSetId: "subgraph", labelSetVersion: 0}`
+    });
   }
-  throw new Error(`Unable to determine omnichain indexing status for provided chains.`);
-}
-function getTimestampForLowestOmnichainStartBlock(chains) {
-  const earliestKnownBlockTimestamps = chains.map(
-    (chain) => chain.config.startBlock.timestamp
-  );
-  return Math.min(...earliestKnownBlockTimestamps);
 }
-function getTimestampForHighestOmnichainKnownBlock(chains) {
-  const latestKnownBlockTimestamps = [];
-  for (const chain of chains) {
-    switch (chain.chainStatus) {
-      case ChainIndexingStatusIds.Queued:
-        if (chain.config.configType === ChainIndexingConfigTypeIds.Definite && chain.config.endBlock) {
-          latestKnownBlockTimestamps.push(chain.config.endBlock.timestamp);
-        }
-        break;
-      case ChainIndexingStatusIds.Backfill:
-        latestKnownBlockTimestamps.push(chain.backfillEndBlock.timestamp);
-        break;
-      case ChainIndexingStatusIds.Completed:
-        latestKnownBlockTimestamps.push(chain.latestIndexedBlock.timestamp);
-        break;
-      case ChainIndexingStatusIds.Following:
-        latestKnownBlockTimestamps.push(chain.latestKnownBlock.timestamp);
-        break;
+var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => import_v43.default.object({
+  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
+  indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
+  isSubgraphCompatible: import_v43.default.boolean({ error: `${valueLabel}.isSubgraphCompatible` }),
+  namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
+  plugins: makePluginsListSchema(`${valueLabel}.plugins`),
+  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
+  versionInfo: makeENSIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
+}).check(invariant_isSubgraphCompatibleRequirements);
+
+// src/ensapi/config/zod-schemas.ts
+var TheGraphCannotFallbackReasonSchema = import_v44.z.enum({
+  NotSubgraphCompatible: "not-subgraph-compatible",
+  NoApiKey: "no-api-key",
+  NoSubgraphUrl: "no-subgraph-url"
+});
+var TheGraphFallbackSchema = import_v44.z.strictObject({
+  canFallback: import_v44.z.boolean(),
+  reason: TheGraphCannotFallbackReasonSchema.nullable()
+});
+function makeENSApiPublicConfigSchema(valueLabel) {
+  const label = valueLabel ?? "ENSApiPublicConfig";
+  return import_v44.z.strictObject({
+    version: import_v44.z.string().min(1, `${label}.version must be a non-empty string`),
+    theGraphFallback: TheGraphFallbackSchema,
+    ensIndexerPublicConfig: makeENSIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
+  });
+}
+
+// src/ensapi/config/deserialize.ts
+function deserializeENSApiPublicConfig(maybeConfig, valueLabel) {
+  const schema = makeENSApiPublicConfigSchema(valueLabel);
+  try {
+    return schema.parse(maybeConfig);
+  } catch (error) {
+    if (error instanceof import_v45.ZodError) {
+      throw new Error(`Cannot deserialize ENSApiPublicConfig:
+${(0, import_v45.prettifyError)(error)}
+`);
+    }
+    throw error;
+  }
+}
+
+// src/ensindexer/config/deserialize.ts
+var import_v46 = require("zod/v4");
+function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
+  const schema = makeENSIndexerPublicConfigSchema(valueLabel);
+  const parsed = schema.safeParse(maybeConfig);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ENSIndexerPublicConfig:
+${(0, import_v46.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/ensindexer/config/label-utils.ts
+var import_viem10 = require("viem");
+function labelHashToBytes(labelHash) {
+  try {
+    if (labelHash.length !== 66) {
+      throw new Error(`Invalid labelHash length ${labelHash.length} characters (expected 66)`);
+    }
+    if (labelHash !== labelHash.toLowerCase()) {
+      throw new Error("Labelhash must be in lowercase");
+    }
+    if (!labelHash.startsWith("0x")) {
+      throw new Error("Labelhash must be 0x-prefixed");
+    }
+    const bytes = (0, import_viem10.hexToBytes)(labelHash);
+    if (bytes.length !== 32) {
+      throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
+    }
+    return bytes;
+  } catch (e) {
+    if (e instanceof Error) {
+      throw e;
     }
+    throw new Error("Invalid hex format");
+  }
+}
+
+// src/ensindexer/config/labelset-utils.ts
+function buildLabelSetId(maybeLabelSetId) {
+  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
+}
+function buildLabelSetVersion(maybeLabelSetVersion) {
+  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
+}
+function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
+  if (labelSetVersion !== void 0 && labelSetId === void 0) {
+    throw new Error("When a labelSetVersion is defined, labelSetId must also be defined.");
+  }
+  return { labelSetId, labelSetVersion };
+}
+function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
+  if (clientSet.labelSetId === void 0) {
+    return;
+  }
+  if (serverSet.labelSetId !== clientSet.labelSetId) {
+    throw new Error(
+      `Server label set ID "${serverSet.labelSetId}" does not match client's requested label set ID "${clientSet.labelSetId}".`
+    );
+  }
+  if (clientSet.labelSetVersion !== void 0 && serverSet.highestLabelSetVersion < clientSet.labelSetVersion) {
+    throw new Error(
+      `Server highest label set version ${serverSet.highestLabelSetVersion} is less than client's requested version ${clientSet.labelSetVersion} for label set ID "${clientSet.labelSetId}".`
+    );
+  }
+}
+
+// src/ensindexer/config/parsing.ts
+function parseNonNegativeInteger(maybeNumber) {
+  const trimmed = maybeNumber.trim();
+  if (!trimmed) {
+    throw new Error("Input cannot be empty");
+  }
+  if (trimmed === "-0") {
+    throw new Error("Negative zero is not a valid non-negative integer");
+  }
+  const num = Number(maybeNumber);
+  if (Number.isNaN(num)) {
+    throw new Error(`"${maybeNumber}" is not a valid number`);
+  }
+  if (!Number.isFinite(num)) {
+    throw new Error(`"${maybeNumber}" is not a finite number`);
+  }
+  if (!Number.isInteger(num)) {
+    throw new Error(`"${maybeNumber}" is not an integer`);
+  }
+  if (num < 0) {
+    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
+  }
+  return num;
+}
+
+// src/ensindexer/config/serialize.ts
+function serializeIndexedChainIds(indexedChainIds) {
+  return Array.from(indexedChainIds);
+}
+function serializeENSIndexerPublicConfig(config) {
+  const {
+    labelSet,
+    indexedChainIds,
+    databaseSchemaName,
+    isSubgraphCompatible: isSubgraphCompatible2,
+    namespace,
+    plugins,
+    versionInfo
+  } = config;
+  return {
+    labelSet,
+    indexedChainIds: serializeIndexedChainIds(indexedChainIds),
+    databaseSchemaName,
+    isSubgraphCompatible: isSubgraphCompatible2,
+    namespace,
+    plugins,
+    versionInfo
+  };
+}
+
+// src/ensindexer/indexing-status/deserialize.ts
+var import_v48 = require("zod/v4");
+
+// src/ensindexer/indexing-status/zod-schemas.ts
+var import_v47 = __toESM(require("zod/v4"), 1);
+
+// src/ensindexer/indexing-status/types.ts
+var ChainIndexingConfigTypeIds = {
+  /**
+   * 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"
+};
+var ChainIndexingStatusIds = {
+  /**
+   * Represents that indexing of the chain is not ready to begin yet because:
+   * - ENSIndexer is in its initialization phase and the data to build a
+   *   "true" {@link ChainIndexingSnapshot} for the chain is still being loaded; or
+   * - ENSIndexer is using an omnichain indexing strategy and the
+   *   `omnichainIndexingCursor` is <= `config.startBlock.timestamp` for the chain's
+   *   {@link ChainIndexingSnapshot}.
+   */
+  Queued: "chain-queued",
+  /**
+   * Represents that indexing of the chain is in progress and under a special
+   * "backfill" phase that optimizes for accelerated indexing until reaching the
+   * "fixed target" `backfillEndBlock`.
+   */
+  Backfill: "chain-backfill",
+  /**
+   * Represents that the "backfill" phase of indexing the chain is completed
+   * and that the chain is configured to be indexed for an indefinite range.
+   * Therefore, indexing of the chain remains indefinitely in progress where
+   * ENSIndexer will continuously work to discover and index new blocks as they
+   * are added to the chain across time.
+   */
+  Following: "chain-following",
+  /**
+   * Represents that indexing of the chain is completed as the chain is configured
+   * to be indexed for a definite range and the indexing of all blocks through
+   * that definite range is completed.
+   */
+  Completed: "chain-completed"
+};
+var OmnichainIndexingStatusIds = {
+  /**
+   * Represents that omnichain indexing is not ready to begin yet because
+   * ENSIndexer is in its initialization phase and the data to build a "true"
+   * {@link OmnichainIndexingStatusSnapshot} is still being loaded.
+   */
+  Unstarted: "omnichain-unstarted",
+  /**
+   * Represents that omnichain indexing is in an overall "backfill" status because
+   * - At least one indexed chain has a `chainStatus` of
+   *   {@link ChainIndexingStatusIds.Backfill}; and
+   * - No indexed chain has a `chainStatus` of {@link ChainIndexingStatusIds.Following}.
+   */
+  Backfill: "omnichain-backfill",
+  /**
+   * Represents that omnichain indexing is in an overall "following" status because
+   * at least one indexed chain has a `chainStatus` of
+   * {@link ChainIndexingStatusIds.Following}.
+   */
+  Following: "omnichain-following",
+  /**
+   * Represents that omnichain indexing has completed because all indexed chains have
+   * a `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
+   */
+  Completed: "omnichain-completed"
+};
+var CrossChainIndexingStrategyIds = {
+  /**
+   * Represents that the indexing of events across all indexed chains will
+   * proceed in a deterministic "omnichain" ordering by block timestamp, chain ID,
+   * and block number.
+   *
+   * This strategy is "deterministic" in that the order of processing cross-chain indexed
+   * events and each resulting indexed data state transition recorded in ENSDb is always
+   * the same for each ENSIndexer instance operating with an equivalent
+   * `ENSIndexerConfig` and ENSIndexer version. However it also has the drawbacks of:
+   * - increased indexing latency that must wait for the slowest indexed chain to
+   *   add new blocks or to discover new blocks through the configured RPCs.
+   * - if any indexed chain gets "stuck" due to chain or RPC failures, all indexed chains
+   *   will be affected.
+   */
+  Omnichain: "omnichain"
+};
+
+// 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/ensindexer/indexing-status/helpers.ts
+function getOmnichainIndexingStatus(chains) {
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains)) {
+    return OmnichainIndexingStatusIds.Following;
+  }
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains)) {
+    return OmnichainIndexingStatusIds.Backfill;
+  }
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains)) {
+    return OmnichainIndexingStatusIds.Unstarted;
+  }
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains)) {
+    return OmnichainIndexingStatusIds.Completed;
+  }
+  throw new Error(`Unable to determine omnichain indexing status for provided chains.`);
+}
+function getTimestampForLowestOmnichainStartBlock(chains) {
+  const earliestKnownBlockTimestamps = chains.map(
+    (chain) => chain.config.startBlock.timestamp
+  );
+  return Math.min(...earliestKnownBlockTimestamps);
+}
+function getTimestampForHighestOmnichainKnownBlock(chains) {
+  const latestKnownBlockTimestamps = [];
+  for (const chain of chains) {
+    switch (chain.chainStatus) {
+      case ChainIndexingStatusIds.Queued:
+        if (chain.config.configType === ChainIndexingConfigTypeIds.Definite && chain.config.endBlock) {
+          latestKnownBlockTimestamps.push(chain.config.endBlock.timestamp);
+        }
+        break;
+      case ChainIndexingStatusIds.Backfill:
+        latestKnownBlockTimestamps.push(chain.backfillEndBlock.timestamp);
+        break;
+      case ChainIndexingStatusIds.Completed:
+        latestKnownBlockTimestamps.push(chain.latestIndexedBlock.timestamp);
+        break;
+      case ChainIndexingStatusIds.Following:
+        latestKnownBlockTimestamps.push(chain.latestKnownBlock.timestamp);
+        break;
+    }
+  }
+  return Math.max(...latestKnownBlockTimestamps);
+}
+function getOmnichainIndexingCursor(chains) {
+  if (chains.length === 0) {
+    throw new Error(`Unable to determine omnichain indexing cursor when no chains were provided.`);
+  }
+  if (getOmnichainIndexingStatus(chains) === OmnichainIndexingStatusIds.Unstarted) {
+    const earliestStartBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
+    return Math.min(...earliestStartBlockTimestamps) - 1;
+  }
+  const latestIndexedBlockTimestamps = chains.filter((chain) => chain.chainStatus !== ChainIndexingStatusIds.Queued).map((chain) => chain.latestIndexedBlock.timestamp);
+  if (latestIndexedBlockTimestamps.length < 1) {
+    throw new Error("latestIndexedBlockTimestamps array must include at least one element");
+  }
+  return Math.max(...latestIndexedBlockTimestamps);
+}
+function createIndexingConfig(startBlock, endBlock) {
+  if (endBlock) {
+    return {
+      configType: ChainIndexingConfigTypeIds.Definite,
+      startBlock,
+      endBlock
+    };
+  }
+  return {
+    configType: ChainIndexingConfigTypeIds.Indefinite,
+    startBlock
+  };
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains) {
+  return chains.every((chain) => chain.chainStatus === ChainIndexingStatusIds.Queued);
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains) {
+  const atLeastOneChainInTargetStatus = chains.some(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
+  );
+  const otherChainsHaveValidStatuses = chains.every(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued || chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed
+  );
+  return atLeastOneChainInTargetStatus && otherChainsHaveValidStatuses;
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains) {
+  const allChainsHaveValidStatuses = chains.every(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Completed
+  );
+  return allChainsHaveValidStatuses;
+}
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains) {
+  const allChainsHaveValidStatuses = chains.some(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Following
+  );
+  return allChainsHaveValidStatuses;
+}
+function sortChainStatusesByStartBlockAsc(chains) {
+  chains.sort(
+    ([, chainA], [, chainB]) => chainA.config.startBlock.timestamp - chainB.config.startBlock.timestamp
+  );
+  return chains;
+}
+function getLatestIndexedBlockRef(indexingStatus, chainId) {
+  const chainIndexingStatus = indexingStatus.omnichainSnapshot.chains.get(chainId);
+  if (chainIndexingStatus === void 0) {
+    return null;
+  }
+  if (chainIndexingStatus.chainStatus === ChainIndexingStatusIds.Queued) {
+    return null;
+  }
+  return chainIndexingStatus.latestIndexedBlock;
+}
+
+// src/ensindexer/indexing-status/validations.ts
+function invariant_chainSnapshotQueuedBlocks(ctx) {
+  const { config } = ctx.value;
+  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
+    return;
+  }
+  if (config.endBlock && isBeforeOrEqualTo(config.startBlock, config.endBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `config.endBlock`."
+    });
+  }
+}
+function invariant_chainSnapshotBackfillBlocks(ctx) {
+  const { config, latestIndexedBlock, backfillEndBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, backfillEndBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `backfillEndBlock`."
+    });
+  }
+  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
+    return;
+  }
+  if (config.endBlock && isEqualTo(backfillEndBlock, config.endBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`backfillEndBlock` must be the same as `config.endBlock`."
+    });
+  }
+}
+function invariant_chainSnapshotCompletedBlocks(ctx) {
+  const { config, latestIndexedBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, config.endBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `config.endBlock`."
+    });
+  }
+}
+function invariant_chainSnapshotFollowingBlocks(ctx) {
+  const { config, latestIndexedBlock, latestKnownBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, latestKnownBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `latestKnownBlock`."
+    });
+  }
+}
+function invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot(ctx) {
+  const snapshot = ctx.value;
+  const chains = Array.from(snapshot.chains.values());
+  const expectedOmnichainStatus = getOmnichainIndexingStatus(chains);
+  const actualOmnichainStatus = snapshot.omnichainStatus;
+  if (expectedOmnichainStatus !== actualOmnichainStatus) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: `'${actualOmnichainStatus}' is an invalid omnichainStatus. Expected '${expectedOmnichainStatus}' based on the statuses of individual chains.`
+    });
+  }
+}
+function invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains(ctx) {
+  const snapshot = ctx.value;
+  const queuedChains = Array.from(snapshot.chains.values()).filter(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued
+  );
+  if (queuedChains.length === 0) {
+    return;
+  }
+  const queuedChainStartBlocks = queuedChains.map((chain) => chain.config.startBlock.timestamp);
+  const queuedChainEarliestStartBlock = Math.min(...queuedChainStartBlocks);
+  if (snapshot.omnichainIndexingCursor >= queuedChainEarliestStartBlock) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: "`omnichainIndexingCursor` must be lower than the earliest start block across all queued chains."
+    });
+  }
+}
+function invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains(ctx) {
+  const snapshot = ctx.value;
+  const backfillChains = Array.from(snapshot.chains.values()).filter(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
+  );
+  if (backfillChains.length === 0) {
+    return;
+  }
+  const backfillEndBlocks = backfillChains.map((chain) => chain.backfillEndBlock.timestamp);
+  const highestBackfillEndBlock = Math.max(...backfillEndBlocks);
+  if (snapshot.omnichainIndexingCursor > highestBackfillEndBlock) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: "`omnichainIndexingCursor` must be lower than or equal to the highest `backfillEndBlock` across all backfill chains."
+    });
+  }
+}
+function invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain(ctx) {
+  const snapshot = ctx.value;
+  const indexedChains = Array.from(snapshot.chains.values()).filter(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed || chain.chainStatus === ChainIndexingStatusIds.Following
+  );
+  if (indexedChains.length === 0) {
+    return;
+  }
+  const indexedChainLatestIndexedBlocks = indexedChains.map(
+    (chain) => chain.latestIndexedBlock.timestamp
+  );
+  const indexedChainHighestLatestIndexedBlock = Math.max(...indexedChainLatestIndexedBlocks);
+  if (snapshot.omnichainIndexingCursor !== indexedChainHighestLatestIndexedBlock) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: "`omnichainIndexingCursor` must be same as the highest `latestIndexedBlock` across all indexed chains."
+    });
+  }
+}
+function invariant_omnichainSnapshotUnstartedHasValidChains(ctx) {
+  const chains = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(
+    Array.from(chains.values())
+  );
+  if (hasValidChains === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: chains,
+      message: `For omnichain status snapshot 'unstarted', all chains must have "queued" status.`
+    });
+  }
+}
+function invariant_omnichainStatusSnapshotBackfillHasValidChains(ctx) {
+  const chains = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(
+    Array.from(chains.values())
+  );
+  if (hasValidChains === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: chains,
+      message: `For omnichain status snapshot 'backfill', at least one chain must be in "backfill" status and each chain has to have a status of either "queued", "backfill" or "completed".`
+    });
+  }
+}
+function invariant_omnichainStatusSnapshotCompletedHasValidChains(ctx) {
+  const chains = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(
+    Array.from(chains.values())
+  );
+  if (hasValidChains === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: chains,
+      message: `For omnichain status snapshot 'completed', all chains must have "completed" status.`
+    });
+  }
+}
+function invariant_slowestChainEqualsToOmnichainSnapshotTime(ctx) {
+  const { slowestChainIndexingCursor, omnichainSnapshot } = ctx.value;
+  const { omnichainIndexingCursor } = omnichainSnapshot;
+  if (slowestChainIndexingCursor !== omnichainIndexingCursor) {
+    console.log("invariant_slowestChainEqualsToOmnichainSnapshotTime", {
+      slowestChainIndexingCursor,
+      omnichainIndexingCursor
+    });
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'slowestChainIndexingCursor' must be equal to 'omnichainSnapshot.omnichainIndexingCursor'`
+    });
+  }
+}
+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.configType === ChainIndexingConfigTypeIds.Definite).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(
+    ...startBlockTimestamps,
+    ...endBlockTimestamps,
+    ...backfillEndBlockTimestamps,
+    ...latestKnownBlockTimestamps
+  );
+  if (snapshotTime < highestKnownBlockTimestamp) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'snapshotTime' must be greater than or equal to  the "highest known block timestamp" (${highestKnownBlockTimestamp})`
+    });
+  }
+}
+function invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime(ctx) {
+  const projection = ctx.value;
+  const { snapshot, projectedAt } = projection;
+  if (snapshot.snapshotTime > projectedAt) {
+    ctx.issues.push({
+      code: "custom",
+      input: projection,
+      message: "`projectedAt` must be after or same as `snapshot.snapshotTime`."
+    });
+  }
+}
+function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ctx) {
+  const projection = ctx.value;
+  const { projectedAt, snapshot, worstCaseDistance } = projection;
+  const { omnichainSnapshot } = snapshot;
+  const expectedWorstCaseDistance = projectedAt - omnichainSnapshot.omnichainIndexingCursor;
+  if (worstCaseDistance !== expectedWorstCaseDistance) {
+    ctx.issues.push({
+      code: "custom",
+      input: projection,
+      message: "`worstCaseDistance` must be the exact difference between `projectedAt` and `snapshot.omnichainIndexingCursor`."
+    });
+  }
+}
+
+// src/ensindexer/indexing-status/zod-schemas.ts
+var makeChainIndexingConfigSchema = (valueLabel = "Value") => import_v47.default.discriminatedUnion("configType", [
+  import_v47.default.strictObject({
+    configType: import_v47.default.literal(ChainIndexingConfigTypeIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel)
+  }),
+  import_v47.default.strictObject({
+    configType: import_v47.default.literal(ChainIndexingConfigTypeIds.Definite),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: makeBlockRefSchema(valueLabel)
+  })
+]);
+var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v47.default.strictObject({
+  chainStatus: import_v47.default.literal(ChainIndexingStatusIds.Queued),
+  config: makeChainIndexingConfigSchema(valueLabel)
+}).check(invariant_chainSnapshotQueuedBlocks);
+var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v47.default.strictObject({
+  chainStatus: import_v47.default.literal(ChainIndexingStatusIds.Backfill),
+  config: makeChainIndexingConfigSchema(valueLabel),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  backfillEndBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotBackfillBlocks);
+var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v47.default.strictObject({
+  chainStatus: import_v47.default.literal(ChainIndexingStatusIds.Completed),
+  config: import_v47.default.strictObject({
+    configType: import_v47.default.literal(ChainIndexingConfigTypeIds.Definite),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotCompletedBlocks);
+var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v47.default.strictObject({
+  chainStatus: import_v47.default.literal(ChainIndexingStatusIds.Following),
+  config: import_v47.default.strictObject({
+    configType: import_v47.default.literal(ChainIndexingConfigTypeIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  latestKnownBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotFollowingBlocks);
+var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v47.default.discriminatedUnion("chainStatus", [
+  makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
+  makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
+  makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
+  makeChainIndexingStatusSnapshotFollowingSchema(valueLabel)
+]);
+var makeChainIndexingStatusesSchema = (valueLabel = "Value") => import_v47.default.record(makeChainIdStringSchema(), makeChainIndexingStatusSnapshotSchema(valueLabel), {
+  error: "Chains indexing statuses must be an object mapping valid chain IDs to their indexing status snapshots."
+}).transform((serializedChainsIndexingStatus) => {
+  const chainsIndexingStatus = /* @__PURE__ */ new Map();
+  for (const [chainIdString, chainStatus] of Object.entries(serializedChainsIndexingStatus)) {
+    chainsIndexingStatus.set(deserializeChainId(chainIdString), chainStatus);
   }
-  return Math.max(...latestKnownBlockTimestamps);
+  return chainsIndexingStatus;
+});
+var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v47.default.strictObject({
+  omnichainStatus: import_v47.default.literal(OmnichainIndexingStatusIds.Unstarted),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainSnapshotUnstartedHasValidChains).transform((chains) => chains),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v47.default.strictObject({
+  omnichainStatus: import_v47.default.literal(OmnichainIndexingStatusIds.Backfill),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotBackfillHasValidChains).transform(
+    (chains) => chains
+  ),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v47.default.strictObject({
+  omnichainStatus: import_v47.default.literal(OmnichainIndexingStatusIds.Completed),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotCompletedHasValidChains).transform((chains) => chains),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v47.default.strictObject({
+  omnichainStatus: import_v47.default.literal(OmnichainIndexingStatusIds.Following),
+  chains: makeChainIndexingStatusesSchema(valueLabel),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v47.default.discriminatedUnion("omnichainStatus", [
+  makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
+  makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
+  makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
+  makeOmnichainIndexingStatusSnapshotFollowingSchema(valueLabel)
+]).check(invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot).check(invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains).check(
+  invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains
+).check(invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain);
+var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => import_v47.default.strictObject({
+  strategy: import_v47.default.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_v47.default.discriminatedUnion("strategy", [
+  makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
+]);
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v47.default.strictObject({
+  projectedAt: makeUnixTimestampSchema(valueLabel),
+  worstCaseDistance: makeDurationSchema(valueLabel),
+  snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
+}).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
+
+// src/ensindexer/indexing-status/deserialize.ts
+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_v48.prettifyError)(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
 }
-function getOmnichainIndexingCursor(chains) {
-  if (chains.length === 0) {
-    throw new Error(`Unable to determine omnichain indexing cursor when no chains were provided.`);
+function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeOmnichainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(maybeSnapshot);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into OmnichainIndexingStatusSnapshot:
+${(0, import_v48.prettifyError)(parsed.error)}
+`
+    );
   }
-  if (getOmnichainIndexingStatus(chains) === OmnichainIndexingStatusIds.Unstarted) {
-    const earliestStartBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
-    return Math.min(...earliestStartBlockTimestamps) - 1;
+  return parsed.data;
+}
+function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeCrossChainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(maybeSnapshot);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into CrossChainIndexingStatusSnapshot:
+${(0, import_v48.prettifyError)(parsed.error)}
+`
+    );
   }
-  const latestIndexedBlockTimestamps = chains.filter((chain) => chain.chainStatus !== ChainIndexingStatusIds.Queued).map((chain) => chain.latestIndexedBlock.timestamp);
-  if (latestIndexedBlockTimestamps.length < 1) {
-    throw new Error("latestIndexedBlockTimestamps array must include at least one element");
+  return parsed.data;
+}
+function deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel) {
+  const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
+  const parsed = schema.safeParse(maybeProjection);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into RealtimeIndexingStatusProjection:
+${(0, import_v48.prettifyError)(parsed.error)}
+`
+    );
   }
-  return Math.max(...latestIndexedBlockTimestamps);
+  return parsed.data;
 }
-function createIndexingConfig(startBlock, endBlock) {
-  if (endBlock) {
-    return {
-      configType: ChainIndexingConfigTypeIds.Definite,
-      startBlock,
-      endBlock
-    };
+
+// src/ensindexer/indexing-status/projection.ts
+function createRealtimeIndexingStatusProjection(snapshot, now) {
+  const projectedAt = Math.max(now, snapshot.snapshotTime);
+  return {
+    projectedAt,
+    worstCaseDistance: projectedAt - snapshot.slowestChainIndexingCursor,
+    snapshot
+  };
+}
+
+// src/ensindexer/indexing-status/serialize.ts
+function serializeCrossChainIndexingStatusSnapshotOmnichain({
+  strategy,
+  slowestChainIndexingCursor,
+  snapshotTime,
+  omnichainSnapshot
+}) {
+  return {
+    strategy,
+    slowestChainIndexingCursor,
+    snapshotTime,
+    omnichainSnapshot: serializeOmnichainIndexingStatusSnapshot(omnichainSnapshot)
+  };
+}
+function serializeRealtimeIndexingStatusProjection(indexingProjection) {
+  return {
+    projectedAt: indexingProjection.projectedAt,
+    worstCaseDistance: indexingProjection.worstCaseDistance,
+    snapshot: serializeCrossChainIndexingStatusSnapshotOmnichain(indexingProjection.snapshot)
+  };
+}
+function serializeChainIndexingSnapshots(chains) {
+  const serializedSnapshots = {};
+  for (const [chainId, snapshot] of chains.entries()) {
+    serializedSnapshots[serializeChainId(chainId)] = snapshot;
+  }
+  return serializedSnapshots;
+}
+function serializeOmnichainIndexingStatusSnapshot(indexingStatus) {
+  switch (indexingStatus.omnichainStatus) {
+    case OmnichainIndexingStatusIds.Unstarted:
+      return {
+        omnichainStatus: OmnichainIndexingStatusIds.Unstarted,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
+      };
+    case OmnichainIndexingStatusIds.Backfill:
+      return {
+        omnichainStatus: OmnichainIndexingStatusIds.Backfill,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
+      };
+    case OmnichainIndexingStatusIds.Completed: {
+      return {
+        omnichainStatus: OmnichainIndexingStatusIds.Completed,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
+      };
+    }
+    case OmnichainIndexingStatusIds.Following:
+      return {
+        omnichainStatus: OmnichainIndexingStatusIds.Following,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
+      };
   }
+}
+
+// src/ensapi/config/serialize.ts
+function serializeENSApiPublicConfig(config) {
+  const { version, theGraphFallback, ensIndexerPublicConfig } = config;
   return {
-    configType: ChainIndexingConfigTypeIds.Indefinite,
-    startBlock
+    version,
+    theGraphFallback,
+    ensIndexerPublicConfig: serializeENSIndexerPublicConfig(ensIndexerPublicConfig)
   };
 }
-function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains) {
-  return chains.every((chain) => chain.chainStatus === ChainIndexingStatusIds.Queued);
+
+// src/api/config/deserialize.ts
+function deserializeConfigResponse(serializedResponse) {
+  return deserializeENSApiPublicConfig(serializedResponse);
 }
-function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains) {
-  const atLeastOneChainInTargetStatus = chains.some(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
-  );
-  const otherChainsHaveValidStatuses = chains.every(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued || chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed
-  );
-  return atLeastOneChainInTargetStatus && otherChainsHaveValidStatuses;
+
+// src/api/config/serialize.ts
+function serializeConfigResponse(response) {
+  return serializeENSApiPublicConfig(response);
 }
-function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains) {
-  const allChainsHaveValidStatuses = chains.every(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Completed
-  );
-  return allChainsHaveValidStatuses;
+
+// src/api/indexing-status/deserialize.ts
+var import_v410 = require("zod/v4");
+
+// src/api/indexing-status/zod-schemas.ts
+var import_v49 = __toESM(require("zod/v4"), 1);
+
+// src/api/indexing-status/response.ts
+var IndexingStatusResponseCodes = {
+  /**
+   * Represents that the indexing status is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that the indexing status is unavailable.
+   */
+  Error: "error"
+};
+
+// src/api/indexing-status/zod-schemas.ts
+var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v49.default.strictObject({
+  responseCode: import_v49.default.literal(IndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
+});
+var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v49.default.strictObject({
+  responseCode: import_v49.default.literal(IndexingStatusResponseCodes.Error)
+});
+var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v49.default.discriminatedUnion("responseCode", [
+  makeIndexingStatusResponseOkSchema(valueLabel),
+  makeIndexingStatusResponseErrorSchema(valueLabel)
+]);
+
+// src/api/indexing-status/deserialize.ts
+function deserializeIndexingStatusResponse(maybeResponse) {
+  const parsed = makeIndexingStatusResponseSchema().safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize IndexingStatusResponse:
+${(0, import_v410.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/api/indexing-status/serialize.ts
+function serializeIndexingStatusResponse(response) {
+  switch (response.responseCode) {
+    case IndexingStatusResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection)
+      };
+    case IndexingStatusResponseCodes.Error:
+      return response;
+  }
+}
+
+// src/api/name-tokens/deserialize.ts
+var import_v415 = require("zod/v4");
+
+// src/api/name-tokens/zod-schemas.ts
+var import_viem14 = require("viem");
+var import_v414 = __toESM(require("zod/v4"), 1);
+
+// src/tokenscope/assets.ts
+var import_caip4 = require("caip");
+var import_viem13 = require("viem");
+var import_v412 = require("zod/v4");
+
+// src/tokenscope/zod-schemas.ts
+var import_caip3 = require("caip");
+var import_viem12 = require("viem");
+var import_v411 = __toESM(require("zod/v4"), 1);
+
+// src/tokenscope/name-token.ts
+var import_viem11 = require("viem");
+var import_datasources5 = require("@ensnode/datasources");
+var NameTokenOwnershipTypes = {
+  /**
+   * Name Token is owned by NameWrapper account.
+   */
+  NameWrapper: "namewrapper",
+  /**
+   * Name Token is owned fully onchain.
+   *
+   * This ownership type can only apply to direct subnames of `.eth`
+   */
+  FullyOnchain: "fully-onchain",
+  /**
+   * Name Token ownership has been transferred to the null address.
+   */
+  Burned: "burned",
+  /**
+   * Name Token ownership is unknown.
+   */
+  Unknown: "unknown"
+};
+function serializeNameToken(nameToken) {
+  return {
+    token: serializeAssetId(nameToken.token),
+    ownership: nameToken.ownership,
+    mintStatus: nameToken.mintStatus
+  };
 }
-function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains) {
-  const allChainsHaveValidStatuses = chains.some(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Following
+function getNameWrapperAccounts(namespaceId) {
+  const ethnamesNameWrapperAccount = getDatasourceContract(
+    namespaceId,
+    import_datasources5.DatasourceNames.ENSRoot,
+    "NameWrapper"
   );
-  return allChainsHaveValidStatuses;
-}
-function sortChainStatusesByStartBlockAsc(chains) {
-  chains.sort(
-    ([, chainA], [, chainB]) => chainA.config.startBlock.timestamp - chainB.config.startBlock.timestamp
+  const lineanamesNameWrapperAccount = maybeGetDatasourceContract(
+    namespaceId,
+    import_datasources5.DatasourceNames.Lineanames,
+    "NameWrapper"
   );
-  return chains;
-}
-function getLatestIndexedBlockRef(indexingStatus, chainId) {
-  const chainIndexingStatus = indexingStatus.omnichainSnapshot.chains.get(chainId);
-  if (chainIndexingStatus === void 0) {
-    return null;
-  }
-  if (chainIndexingStatus.chainStatus === ChainIndexingStatusIds.Queued) {
-    return null;
-  }
-  return chainIndexingStatus.latestIndexedBlock;
-}
-
-// src/ensindexer/indexing-status/validations.ts
-function invariant_chainSnapshotQueuedBlocks(ctx) {
-  const { config } = ctx.value;
-  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
-    return;
-  }
-  if (config.endBlock && isBeforeOrEqualTo(config.startBlock, config.endBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`config.startBlock` must be before or same as `config.endBlock`."
-    });
-  }
+  const nameWrapperAccounts = [
+    // NameWrapper for direct subnames of .eth is defined for all ENS namespaces
+    ethnamesNameWrapperAccount
+  ];
+  if (lineanamesNameWrapperAccount) {
+    nameWrapperAccounts.push(lineanamesNameWrapperAccount);
+  }
+  return nameWrapperAccounts;
 }
-function invariant_chainSnapshotBackfillBlocks(ctx) {
-  const { config, latestIndexedBlock, backfillEndBlock } = ctx.value;
-  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
-    });
-  }
-  if (isBeforeOrEqualTo(latestIndexedBlock, backfillEndBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`latestIndexedBlock` must be before or same as `backfillEndBlock`."
-    });
+function getNameTokenOwnership(namespaceId, name, owner) {
+  const nameWrapperAccounts = getNameWrapperAccounts(namespaceId);
+  const hasNameWrapperOwnership = nameWrapperAccounts.some(
+    (nameWrapperAccount) => accountIdEqual(owner, nameWrapperAccount)
+  );
+  if (hasNameWrapperOwnership) {
+    return {
+      ownershipType: NameTokenOwnershipTypes.NameWrapper,
+      owner
+    };
   }
-  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
-    return;
+  if ((0, import_viem11.isAddressEqual)(owner.address, import_viem11.zeroAddress)) {
+    return {
+      ownershipType: NameTokenOwnershipTypes.Burned,
+      owner
+    };
   }
-  if (config.endBlock && isEqualTo(backfillEndBlock, config.endBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`backfillEndBlock` must be the same as `config.endBlock`."
-    });
+  const parentName = getParentNameFQDN(name);
+  if (parentName === "eth") {
+    return {
+      ownershipType: NameTokenOwnershipTypes.FullyOnchain,
+      owner
+    };
   }
+  return {
+    ownershipType: NameTokenOwnershipTypes.Unknown,
+    owner
+  };
 }
-function invariant_chainSnapshotCompletedBlocks(ctx) {
-  const { config, latestIndexedBlock } = ctx.value;
-  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
-    });
+
+// src/tokenscope/zod-schemas.ts
+var makeAssetIdSchema = (valueLabel = "Asset ID Schema") => import_v411.default.object({
+  assetNamespace: import_v411.default.enum(AssetNamespaces),
+  contract: makeAccountIdSchema(valueLabel),
+  tokenId: import_v411.default.preprocess((v) => typeof v === "string" ? BigInt(v) : v, import_v411.default.bigint().positive())
+});
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v411.default.preprocess((v) => {
+  if (typeof v === "string") {
+    const result = new import_caip3.AssetId(v);
+    return {
+      assetNamespace: result.assetName.namespace,
+      contract: {
+        chainId: Number(result.chainId.reference),
+        address: result.assetName.reference
+      },
+      tokenId: result.tokenId
+    };
   }
-  if (isBeforeOrEqualTo(latestIndexedBlock, config.endBlock) === false) {
+  return v;
+}, makeAssetIdSchema(valueLabel));
+function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
+  const ownership = ctx.value;
+  if (ctx.value.owner.address === import_viem12.zeroAddress) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
-      message: "`latestIndexedBlock` must be before or same as `config.endBlock`."
+      message: `Name Token Ownership with '${ownership.ownershipType}' must have 'address' other than the zero address.`
     });
   }
 }
-function invariant_chainSnapshotFollowingBlocks(ctx) {
-  const { config, latestIndexedBlock, latestKnownBlock } = ctx.value;
-  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
-    });
-  }
-  if (isBeforeOrEqualTo(latestIndexedBlock, latestKnownBlock) === false) {
+var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v411.default.object({
+  ownershipType: import_v411.default.literal(NameTokenOwnershipTypes.NameWrapper),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v411.default.object({
+  ownershipType: import_v411.default.literal(NameTokenOwnershipTypes.FullyOnchain),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v411.default.object({
+  ownershipType: import_v411.default.literal(NameTokenOwnershipTypes.Burned),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v411.default.object({
+  ownershipType: import_v411.default.literal(NameTokenOwnershipTypes.Unknown),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
+  const ownership = ctx.value;
+  if (ctx.value.owner.address !== import_viem12.zeroAddress) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
-      message: "`latestIndexedBlock` must be before or same as `latestKnownBlock`."
+      message: `Name Token Ownership with '${ownership.ownershipType}' must have 'address' set to the zero address.`
     });
   }
 }
-function invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot(ctx) {
-  const snapshot = ctx.value;
-  const chains = Array.from(snapshot.chains.values());
-  const expectedOmnichainStatus = getOmnichainIndexingStatus(chains);
-  const actualOmnichainStatus = snapshot.omnichainStatus;
-  if (expectedOmnichainStatus !== actualOmnichainStatus) {
-    ctx.issues.push({
-      code: "custom",
-      input: snapshot,
-      message: `'${actualOmnichainStatus}' is an invalid omnichainStatus. Expected '${expectedOmnichainStatus}' based on the statuses of individual chains.`
-    });
-  }
+var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v411.default.discriminatedUnion("ownershipType", [
+  makeNameTokenOwnershipNameWrapperSchema(valueLabel),
+  makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
+  makeNameTokenOwnershipBurnedSchema(valueLabel),
+  makeNameTokenOwnershipUnknownSchema(valueLabel)
+]);
+var makeNameTokenSchema = (valueLabel = "Name Token Schema") => import_v411.default.object({
+  token: makeAssetIdSchema(`${valueLabel}.token`),
+  ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
+  mintStatus: import_v411.default.enum(NFTMintStatuses)
+});
+
+// src/tokenscope/assets.ts
+var AssetNamespaces = {
+  ERC721: "erc721",
+  ERC1155: "erc1155"
+};
+function serializeAssetId(assetId) {
+  return {
+    assetNamespace: assetId.assetNamespace,
+    contract: assetId.contract,
+    tokenId: uint256ToHex32(assetId.tokenId)
+  };
 }
-function invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains(ctx) {
-  const snapshot = ctx.value;
-  const queuedChains = Array.from(snapshot.chains.values()).filter(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued
-  );
-  if (queuedChains.length === 0) {
-    return;
-  }
-  const queuedChainStartBlocks = queuedChains.map((chain) => chain.config.startBlock.timestamp);
-  const queuedChainEarliestStartBlock = Math.min(...queuedChainStartBlocks);
-  if (snapshot.omnichainIndexingCursor >= queuedChainEarliestStartBlock) {
-    ctx.issues.push({
-      code: "custom",
-      input: snapshot,
-      message: "`omnichainIndexingCursor` must be lower than the earliest start block across all queued chains."
-    });
+function deserializeAssetId(maybeAssetId, valueLabel) {
+  const schema = makeAssetIdSchema(valueLabel);
+  const parsed = schema.safeParse(maybeAssetId);
+  if (parsed.error) {
+    throw new RangeError(`Cannot deserialize AssetId:
+${(0, import_v412.prettifyError)(parsed.error)}
+`);
   }
+  return parsed.data;
 }
-function invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains(ctx) {
-  const snapshot = ctx.value;
-  const backfillChains = Array.from(snapshot.chains.values()).filter(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
-  );
-  if (backfillChains.length === 0) {
-    return;
-  }
-  const backfillEndBlocks = backfillChains.map((chain) => chain.backfillEndBlock.timestamp);
-  const highestBackfillEndBlock = Math.max(...backfillEndBlocks);
-  if (snapshot.omnichainIndexingCursor > highestBackfillEndBlock) {
-    ctx.issues.push({
-      code: "custom",
-      input: snapshot,
-      message: "`omnichainIndexingCursor` must be lower than or equal to the highest `backfillEndBlock` across all backfill chains."
-    });
-  }
+function formatAssetId(assetId) {
+  const { assetNamespace, contract, tokenId } = serializeAssetId(assetId);
+  return import_caip4.AssetId.format({
+    chainId: { namespace: "eip155", reference: contract.chainId.toString() },
+    assetName: { namespace: assetNamespace, reference: contract.address },
+    tokenId
+  }).toLowerCase();
 }
-function invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain(ctx) {
-  const snapshot = ctx.value;
-  const indexedChains = Array.from(snapshot.chains.values()).filter(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed || chain.chainStatus === ChainIndexingStatusIds.Following
-  );
-  if (indexedChains.length === 0) {
-    return;
-  }
-  const indexedChainLatestIndexedBlocks = indexedChains.map(
-    (chain) => chain.latestIndexedBlock.timestamp
-  );
-  const indexedChainHighestLatestIndexedBlock = Math.max(...indexedChainLatestIndexedBlocks);
-  if (snapshot.omnichainIndexingCursor !== indexedChainHighestLatestIndexedBlock) {
-    ctx.issues.push({
-      code: "custom",
-      input: snapshot,
-      message: "`omnichainIndexingCursor` must be same as the highest `latestIndexedBlock` across all indexed chains."
-    });
+function parseAssetId(maybeAssetId, valueLabel) {
+  const schema = makeAssetIdStringSchema(valueLabel);
+  const parsed = schema.safeParse(maybeAssetId);
+  if (parsed.error) {
+    throw new RangeError(`Cannot parse AssetId:
+${(0, import_v412.prettifyError)(parsed.error)}
+`);
   }
+  return parsed.data;
 }
-function invariant_omnichainSnapshotUnstartedHasValidChains(ctx) {
-  const chains = ctx.value;
-  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(
-    Array.from(chains.values())
-  );
-  if (hasValidChains === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: chains,
-      message: `For omnichain status snapshot 'unstarted', all chains must have "queued" status.`
-    });
-  }
+var buildAssetId = (contract, tokenId, assetNamespace) => {
+  return {
+    assetNamespace,
+    contract,
+    tokenId
+  };
+};
+function serializeDomainAssetId(domainAsset) {
+  return {
+    ...serializeAssetId(domainAsset),
+    domainId: domainAsset.domainId
+  };
 }
-function invariant_omnichainStatusSnapshotBackfillHasValidChains(ctx) {
-  const chains = ctx.value;
-  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(
-    Array.from(chains.values())
-  );
-  if (hasValidChains === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: chains,
-      message: `For omnichain status snapshot 'backfill', at least one chain must be in "backfill" status and each chain has to have a status of either "queued", "backfill" or "completed".`
-    });
+var NFTMintStatuses = {
+  Minted: "minted",
+  Burned: "burned"
+};
+var formatNFTTransferEventMetadata = (metadata) => {
+  const serializedAssetId = serializeAssetId(metadata.nft);
+  return [
+    `Event: ${metadata.eventHandlerName}`,
+    `Chain ID: ${metadata.chainId}`,
+    `Block Number: ${metadata.blockNumber}`,
+    `Transaction Hash: ${metadata.transactionHash}`,
+    `NFT: ${serializedAssetId}`
+  ].map((line) => ` - ${line}`).join("\n");
+};
+var NFTTransferTypes = {
+  /**
+   * Initial transfer from zeroAddress to a non-zeroAddress
+   * Can happen at most once to a NFT AssetId
+   *
+   * Invariants:
+   * - NFT is not indexed and therefore has no previous mint status or owner
+   * - new NFT mint status is `minted`
+   * - new NFT owner is a non-zeroAddress
+   */
+  Mint: "mint",
+  /**
+   * Subsequent transfer from zeroAddress to a non-zeroAddress
+   * Can happen any number of times to a NFT AssetId as it passes in a cycle from
+   * mint -> burn -> remint -> burn -> remint -> ...
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `burned`
+   * - previous NFT owner is the zeroAddress
+   * - new NFT mint status is `minted`
+   * - new NFT owner is a non-zeroAddress
+   */
+  Remint: "remint",
+  /**
+   * Special transfer type for improperly implemented NFT contracts that allow a NFT
+   * that is currently minted to be reminted before an intermediate burn.
+   *
+   * Transfer from zeroAddress to non-zeroAddress for an indexed NFT where the
+   * previously indexed nft had status `minted` with a non-zeroAddress owner.
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `minted`
+   * - previous NFT owner was a non-zeroAddress
+   * - new NFT mint status is `minted`
+   * - new NFT owner is a non-zeroAddress
+   */
+  MintedRemint: "minted-remint",
+  /**
+   * Transfer from a non-zeroAddress to zeroAddress
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `minted`
+   * - previous NFT owner is a non-zeroAddress
+   * - new NFT mint status is `burned`
+   * - new NFT owner is the zeroAddress
+   */
+  Burn: "burn",
+  /**
+   * Transfer from a non-zeroAddress to a distinct non-zeroAddress
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous and new NFT mint status is `minted`
+   * - previous and new NFT owner are distinct non-zeroAddress
+   */
+  Transfer: "transfer",
+  /**
+   * Transfer from a non-zeroAddress to the same non-zeroAddress
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous and new NFT mint status is `minted`
+   * - previous and new NFT owner are equivalent non-zeroAddress
+   */
+  SelfTransfer: "self-transfer",
+  /**
+   * Transfer from zeroAddress to zeroAddress for an indexed NFT
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous and new NFT mint status is `burned`
+   * - previous and new NFT owner are zeroAddress
+   */
+  RemintBurn: "remint-burn",
+  /**
+   * Special transfer type for improperly implemented NFT contracts that allow a NFT
+   * that is currently minted to be reminted again before an intermediate burn.
+   *
+   * Transfer from zeroAddress to zeroAddress for an indexed NFT where the
+   * previously indexed nft had status `minted` with a non-zeroAddress owner.
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `minted`
+   * - previous NFT owner was a non-zeroAddress
+   * - new NFT mint status is `burned`
+   * - new NFT owner is the zeroAddress
+   */
+  MintedRemintBurn: "minted-remint-burn",
+  /**
+   * Transfer from zeroAddress to zeroAddress for an unindexed NFT
+   *
+   * Invariants:
+   * - NFT is not indexed and therefore has no previous mint status or owner
+   * - NFT should remain unindexed and without any mint status or owner
+   */
+  MintBurn: "mint-burn"
+};
+var getNFTTransferType = (from, to, allowMintedRemint, metadata, currentlyIndexedOwner) => {
+  const isIndexed = currentlyIndexedOwner !== void 0;
+  const isIndexedAsMinted = isIndexed && !(0, import_viem13.isAddressEqual)(currentlyIndexedOwner, import_viem13.zeroAddress);
+  const isMint = (0, import_viem13.isAddressEqual)(from, import_viem13.zeroAddress);
+  const isBurn = (0, import_viem13.isAddressEqual)(to, import_viem13.zeroAddress);
+  const isSelfTransfer = (0, import_viem13.isAddressEqual)(from, to);
+  if (isIndexed && !(0, import_viem13.isAddressEqual)(currentlyIndexedOwner, from)) {
+    if (isMint && allowMintedRemint) {
+    } else {
+      throw new Error(
+        `Error: Sending from ${from} conflicts with currently indexed owner ${currentlyIndexedOwner}.
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    }
   }
-}
-function invariant_omnichainStatusSnapshotCompletedHasValidChains(ctx) {
-  const chains = ctx.value;
-  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(
-    Array.from(chains.values())
-  );
-  if (hasValidChains === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: chains,
-      message: `For omnichain status snapshot 'completed', all chains must have "completed" status.`
-    });
+  if (isSelfTransfer) {
+    if (isMint) {
+      if (!isIndexed) {
+        return NFTTransferTypes.MintBurn;
+      } else if (!isIndexedAsMinted) {
+        return NFTTransferTypes.RemintBurn;
+      } else if (allowMintedRemint) {
+        return NFTTransferTypes.MintedRemintBurn;
+      } else {
+        throw new Error(
+          `Error: Invalid state transition from minted -> remint-burn
+${formatNFTTransferEventMetadata(metadata)}`
+        );
+      }
+    } else {
+      if (!isIndexed) {
+        throw new Error(
+          `Error: Invalid state transition from unindexed -> self-transfer
+${formatNFTTransferEventMetadata(metadata)}`
+        );
+      } else if (!isIndexedAsMinted) {
+        throw new Error(
+          `Error: invalid state transition from burned -> self-transfer
+${formatNFTTransferEventMetadata(metadata)}`
+        );
+      } else {
+        return NFTTransferTypes.SelfTransfer;
+      }
+    }
+  } else if (isMint) {
+    if (!isIndexed) {
+      return NFTTransferTypes.Mint;
+    } else if (!isIndexedAsMinted) {
+      return NFTTransferTypes.Remint;
+    } else if (allowMintedRemint) {
+      return NFTTransferTypes.MintedRemint;
+    } else {
+      throw new Error(
+        `Error: Invalid state transition from minted -> mint
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    }
+  } else if (isBurn) {
+    if (!isIndexed) {
+      throw new Error(
+        `Error: Invalid state transition from unindexed -> burn
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else if (!isIndexedAsMinted) {
+      throw new Error(
+        `Error: Invalid state transition from burned -> burn
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else {
+      return NFTTransferTypes.Burn;
+    }
+  } else {
+    if (!isIndexed) {
+      throw new Error(
+        `Error: Invalid state transition from unindexed -> transfer
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else if (!isIndexedAsMinted) {
+      throw new Error(
+        `Error: Invalid state transition from burned -> transfer
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else {
+      return NFTTransferTypes.Transfer;
+    }
   }
-}
-function invariant_slowestChainEqualsToOmnichainSnapshotTime(ctx) {
-  const { slowestChainIndexingCursor, omnichainSnapshot } = ctx.value;
-  const { omnichainIndexingCursor } = omnichainSnapshot;
-  if (slowestChainIndexingCursor !== omnichainIndexingCursor) {
-    console.log("invariant_slowestChainEqualsToOmnichainSnapshotTime", {
-      slowestChainIndexingCursor,
-      omnichainIndexingCursor
-    });
+};
+
+// src/api/shared/errors/zod-schemas.ts
+var import_v413 = __toESM(require("zod/v4"), 1);
+var ErrorResponseSchema = import_v413.default.object({
+  message: import_v413.default.string(),
+  details: import_v413.default.optional(import_v413.default.unknown())
+});
+
+// src/api/name-tokens/response.ts
+var NameTokensResponseCodes = {
+  /**
+   * Represents a response when Name Tokens API can respond with requested data.
+   */
+  Ok: "ok",
+  /**
+   * Represents a response when Name Tokens API could not respond with requested data.
+   */
+  Error: "error"
+};
+var NameTokensResponseErrorCodes = {
+  /**
+   * Name tokens not indexed
+   *
+   * Represents an error when tokens for the requested name are not indexed by
+   * the ENSNode instance's configuration.
+   */
+  NameTokensNotIndexed: "name-tokens-not-indexed",
+  /**
+   * Unsupported ENSIndexer Config
+   *
+   * Represents a prerequisites error when connected ENSIndexer config lacks
+   * params required to enable Name Tokens API.
+   */
+  EnsIndexerConfigUnsupported: "unsupported-ensindexer-config",
+  /**
+   * Unsupported Indexing Status
+   *
+   * Represents a prerequisites error when Indexing Status has not yet reached
+   * status required to enable Name Tokens API.
+   */
+  IndexingStatusUnsupported: "unsupported-indexing-status"
+};
+
+// src/api/name-tokens/zod-schemas.ts
+function invariant_nameIsAssociatedWithDomainId(ctx) {
+  const { name, domainId } = ctx.value;
+  if ((0, import_viem14.namehash)(name) !== domainId) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
-      message: `'slowestChainIndexingCursor' must be equal to 'omnichainSnapshot.omnichainIndexingCursor'`
+      message: `'name' must be associated with 'domainId': ${domainId}`
     });
   }
 }
-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.configType === ChainIndexingConfigTypeIds.Definite).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(
-    ...startBlockTimestamps,
-    ...endBlockTimestamps,
-    ...backfillEndBlockTimestamps,
-    ...latestKnownBlockTimestamps
+function invariant_nameTokensOwnershipTypeNameWrapperRequiresOwnershipTypeFullyOnchainOrUnknown(ctx) {
+  const { tokens } = ctx.value;
+  const containsOwnershipNameWrapper = tokens.some(
+    (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.NameWrapper
   );
-  if (snapshotTime < highestKnownBlockTimestamp) {
+  const containsOwnershipFullyOnchainOrUnknown = tokens.some(
+    (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.FullyOnchain || t.ownership.ownershipType === NameTokenOwnershipTypes.Unknown
+  );
+  if (containsOwnershipNameWrapper && !containsOwnershipFullyOnchainOrUnknown) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
-      message: `'snapshotTime' must be greater than or equal to  the "highest known block timestamp" (${highestKnownBlockTimestamp})`
-    });
-  }
-}
-function invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime(ctx) {
-  const projection = ctx.value;
-  const { snapshot, projectedAt } = projection;
-  if (snapshot.snapshotTime > projectedAt) {
-    ctx.issues.push({
-      code: "custom",
-      input: projection,
-      message: "`projectedAt` must be after or same as `snapshot.snapshotTime`."
+      message: `'tokens' must contain name token with ownership type 'fully-onchain' or 'unknown' when name token with ownership type 'namewrapper' in listed`
     });
   }
 }
-function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ctx) {
-  const projection = ctx.value;
-  const { projectedAt, snapshot, worstCaseDistance } = projection;
-  const { omnichainSnapshot } = snapshot;
-  const expectedWorstCaseDistance = projectedAt - omnichainSnapshot.omnichainIndexingCursor;
-  if (worstCaseDistance !== expectedWorstCaseDistance) {
+function invariant_nameTokensContainAtMostOneWithOwnershipTypeEffective(ctx) {
+  const { tokens } = ctx.value;
+  const tokensCountWithOwnershipFullyOnchain = tokens.filter(
+    (t) => t.ownership.ownershipType === NameTokenOwnershipTypes.FullyOnchain
+  ).length;
+  if (tokensCountWithOwnershipFullyOnchain > 1) {
     ctx.issues.push({
       code: "custom",
-      input: projection,
-      message: "`worstCaseDistance` must be the exact difference between `projectedAt` and `snapshot.omnichainIndexingCursor`."
+      input: ctx.value,
+      message: `'tokens' must contain at most one name token with ownership type 'fully-onchain', current count: ${tokensCountWithOwnershipFullyOnchain}`
     });
   }
 }
-
-// src/ensindexer/indexing-status/zod-schemas.ts
-var makeChainIndexingConfigSchema = (valueLabel = "Value") => import_v43.default.discriminatedUnion("configType", [
-  import_v43.default.strictObject({
-    configType: import_v43.default.literal(ChainIndexingConfigTypeIds.Indefinite),
-    startBlock: makeBlockRefSchema(valueLabel)
-  }),
-  import_v43.default.strictObject({
-    configType: import_v43.default.literal(ChainIndexingConfigTypeIds.Definite),
-    startBlock: makeBlockRefSchema(valueLabel),
-    endBlock: makeBlockRefSchema(valueLabel)
-  })
-]);
-var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v43.default.strictObject({
-  chainStatus: import_v43.default.literal(ChainIndexingStatusIds.Queued),
-  config: makeChainIndexingConfigSchema(valueLabel)
-}).check(invariant_chainSnapshotQueuedBlocks);
-var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v43.default.strictObject({
-  chainStatus: import_v43.default.literal(ChainIndexingStatusIds.Backfill),
-  config: makeChainIndexingConfigSchema(valueLabel),
-  latestIndexedBlock: makeBlockRefSchema(valueLabel),
-  backfillEndBlock: makeBlockRefSchema(valueLabel)
-}).check(invariant_chainSnapshotBackfillBlocks);
-var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v43.default.strictObject({
-  chainStatus: import_v43.default.literal(ChainIndexingStatusIds.Completed),
-  config: import_v43.default.strictObject({
-    configType: import_v43.default.literal(ChainIndexingConfigTypeIds.Definite),
-    startBlock: makeBlockRefSchema(valueLabel),
-    endBlock: makeBlockRefSchema(valueLabel)
-  }),
-  latestIndexedBlock: makeBlockRefSchema(valueLabel)
-}).check(invariant_chainSnapshotCompletedBlocks);
-var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v43.default.strictObject({
-  chainStatus: import_v43.default.literal(ChainIndexingStatusIds.Following),
-  config: import_v43.default.strictObject({
-    configType: import_v43.default.literal(ChainIndexingConfigTypeIds.Indefinite),
-    startBlock: makeBlockRefSchema(valueLabel)
-  }),
-  latestIndexedBlock: makeBlockRefSchema(valueLabel),
-  latestKnownBlock: makeBlockRefSchema(valueLabel)
-}).check(invariant_chainSnapshotFollowingBlocks);
-var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v43.default.discriminatedUnion("chainStatus", [
-  makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
-  makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
-  makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
-  makeChainIndexingStatusSnapshotFollowingSchema(valueLabel)
-]);
-var makeChainIndexingStatusesSchema = (valueLabel = "Value") => import_v43.default.record(makeChainIdStringSchema(), makeChainIndexingStatusSnapshotSchema(valueLabel), {
-  error: "Chains indexing statuses must be an object mapping valid chain IDs to their indexing status snapshots."
-}).transform((serializedChainsIndexingStatus) => {
-  const chainsIndexingStatus = /* @__PURE__ */ new Map();
-  for (const [chainIdString, chainStatus] of Object.entries(serializedChainsIndexingStatus)) {
-    chainsIndexingStatus.set(deserializeChainId(chainIdString), chainStatus);
-  }
-  return chainsIndexingStatus;
-});
-var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v43.default.strictObject({
-  omnichainStatus: import_v43.default.literal(OmnichainIndexingStatusIds.Unstarted),
-  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainSnapshotUnstartedHasValidChains).transform((chains) => chains),
-  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token") => import_v414.default.object({
+  domainId: makeNodeSchema(`${valueLabel}.domainId`),
+  name: makeReinterpretedNameSchema(valueLabel),
+  tokens: import_v414.default.array(makeNameTokenSchema(`${valueLabel}.tokens`)).nonempty(),
+  expiresAt: makeUnixTimestampSchema(`${valueLabel}.expiresAt`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+}).check(invariant_nameIsAssociatedWithDomainId).check(invariant_nameTokensContainAtMostOneWithOwnershipTypeEffective).check(invariant_nameTokensOwnershipTypeNameWrapperRequiresOwnershipTypeFullyOnchainOrUnknown);
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK") => import_v414.default.strictObject({
+  responseCode: import_v414.default.literal(NameTokensResponseCodes.Ok),
+  registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`)
 });
-var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v43.default.strictObject({
-  omnichainStatus: import_v43.default.literal(OmnichainIndexingStatusIds.Backfill),
-  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotBackfillHasValidChains).transform(
-    (chains) => chains
-  ),
-  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v414.default.strictObject({
+  responseCode: import_v414.default.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v414.default.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
+  error: ErrorResponseSchema
 });
-var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v43.default.strictObject({
-  omnichainStatus: import_v43.default.literal(OmnichainIndexingStatusIds.Completed),
-  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotCompletedHasValidChains).transform((chains) => chains),
-  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v414.default.strictObject({
+  responseCode: import_v414.default.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v414.default.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
+  error: ErrorResponseSchema
 });
-var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v43.default.strictObject({
-  omnichainStatus: import_v43.default.literal(OmnichainIndexingStatusIds.Following),
-  chains: makeChainIndexingStatusesSchema(valueLabel),
-  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v414.default.strictObject({
+  responseCode: import_v414.default.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v414.default.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
+  error: ErrorResponseSchema
 });
-var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v43.default.discriminatedUnion("omnichainStatus", [
-  makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
-  makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
-  makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
-  makeOmnichainIndexingStatusSnapshotFollowingSchema(valueLabel)
-]).check(invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot).check(invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains).check(
-  invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains
-).check(invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain);
-var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => import_v43.default.strictObject({
-  strategy: import_v43.default.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_v43.default.discriminatedUnion("strategy", [
-  makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v414.default.discriminatedUnion("errorCode", [
+  makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
+  makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
+  makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
+]);
+var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response") => import_v414.default.discriminatedUnion("responseCode", [
+  makeNameTokensResponseOkSchema(valueLabel),
+  makeNameTokensResponseErrorSchema(valueLabel)
 ]);
-var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v43.default.strictObject({
-  projectedAt: makeUnixTimestampSchema(valueLabel),
-  worstCaseDistance: makeDurationSchema(valueLabel),
-  snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
-}).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
-
-// src/ensindexer/config/zod-schemas.ts
-var import_v44 = __toESM(require("zod/v4"), 1);
-
-// src/ensindexer/config/is-subgraph-compatible.ts
-var import_datasources3 = require("@ensnode/datasources");
-
-// src/ensindexer/config/types.ts
-var PluginName = /* @__PURE__ */ ((PluginName2) => {
-  PluginName2["Subgraph"] = "subgraph";
-  PluginName2["Basenames"] = "basenames";
-  PluginName2["Lineanames"] = "lineanames";
-  PluginName2["ThreeDNS"] = "threedns";
-  PluginName2["ProtocolAcceleration"] = "protocol-acceleration";
-  PluginName2["Registrars"] = "registrars";
-  PluginName2["TokenScope"] = "tokenscope";
-  return PluginName2;
-})(PluginName || {});
-
-// src/ensindexer/config/is-subgraph-compatible.ts
-function isSubgraphCompatible(config) {
-  const onlySubgraphPluginActivated = config.plugins.length === 1 && config.plugins[0] === "subgraph" /* Subgraph */;
-  const isSubgraphLabelSet = config.labelSet.labelSetId === "subgraph" && config.labelSet.labelSetVersion === 0;
-  const isEnsTestEnvLabelSet = config.labelSet.labelSetId === "ens-test-env" && config.labelSet.labelSetVersion === 0;
-  const labelSetIsSubgraphCompatible = isSubgraphLabelSet || config.namespace === import_datasources3.ENSNamespaceIds.EnsTestEnv && isEnsTestEnvLabelSet;
-  return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
-}
 
-// src/ensindexer/config/validations.ts
-function invariant_ensDbVersionIsSameAsEnsIndexerVersion(ctx) {
-  const versionInfo = ctx.value;
-  if (versionInfo.ensDb !== versionInfo.ensIndexer) {
-    ctx.issues.push({
-      code: "custom",
-      input: versionInfo,
-      message: "`ensDb` version must be same as `ensIndexer` version"
-    });
+// src/api/name-tokens/deserialize.ts
+function deserializedNameTokensResponse(maybeResponse) {
+  const parsed = makeNameTokensResponseSchema().safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize NameTokensResponse:
+${(0, import_v415.prettifyError)(parsed.error)}
+`);
   }
+  return parsed.data;
 }
 
-// src/ensindexer/config/zod-schemas.ts
-var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => import_v44.default.array(makeChainIdSchema(valueLabel), {
-  error: `${valueLabel} must be an array.`
-}).min(1, { error: `${valueLabel} list must include at least one element.` }).transform((v) => new Set(v));
-var makePluginsListSchema = (valueLabel = "Plugins") => import_v44.default.array(import_v44.default.string(), {
-  error: `${valueLabel} must be a list of strings.`
-}).min(1, {
-  error: `${valueLabel} must be a list of strings with at least one string value`
-}).refine((arr) => arr.length === uniq(arr).length, {
-  error: `${valueLabel} cannot contain duplicate values.`
-});
-var makeDatabaseSchemaNameSchema = (valueLabel = "Database schema name") => import_v44.default.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
-  error: `${valueLabel} is required and must be a non-empty string.`
-});
-var makeLabelSetIdSchema = (valueLabel) => {
-  return import_v44.default.string({ error: `${valueLabel} must be a string` }).min(1, { error: `${valueLabel} must be 1-50 characters long` }).max(50, { error: `${valueLabel} must be 1-50 characters long` }).regex(/^[a-z-]+$/, {
-    error: `${valueLabel} can only contain lowercase letters (a-z) and hyphens (-)`
-  });
-};
-var makeLabelSetVersionSchema = (valueLabel) => {
-  return import_v44.default.coerce.number({ error: `${valueLabel} must be an integer.` }).pipe(makeNonNegativeIntegerSchema(valueLabel));
-};
-var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
-  let valueLabelLabelSetId = valueLabel;
-  let valueLabelLabelSetVersion = valueLabel;
-  if (valueLabel === "LABEL_SET") {
-    valueLabelLabelSetId = "LABEL_SET_ID";
-    valueLabelLabelSetVersion = "LABEL_SET_VERSION";
-  } else {
-    valueLabelLabelSetId = `${valueLabel}.labelSetId`;
-    valueLabelLabelSetVersion = `${valueLabel}.labelSetVersion`;
-  }
-  return import_v44.default.object({
-    labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
-    labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
-  });
-};
-var makeNonEmptyStringSchema = (valueLabel = "Value") => import_v44.default.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
-var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => import_v44.default.strictObject(
-  {
-    nodejs: makeNonEmptyStringSchema(),
-    ponder: makeNonEmptyStringSchema(),
-    ensDb: makeNonEmptyStringSchema(),
-    ensIndexer: makeNonEmptyStringSchema(),
-    ensNormalize: makeNonEmptyStringSchema(),
-    ensRainbow: makeNonEmptyStringSchema(),
-    ensRainbowSchema: makePositiveIntegerSchema()
+// src/api/name-tokens/prerequisites.ts
+var nameTokensPrerequisites = Object.freeze({
+  /**
+   * Required plugins to enable Name Tokens API routes.
+   *
+   * 1. `registrars` plugin is required so that data in the `registrationLifecycles`
+   *    table is populated.
+   * 2. `tokenscope` plugin is required so that data in the `nameTokens`
+   *    table is populated.
+   */
+  requiredPlugins: ["registrars" /* Registrars */, "tokenscope" /* TokenScope */],
+  /**
+   * Check if provided ENSApiPublicConfig supports the Name Tokens API.
+   */
+  hasEnsIndexerConfigSupport(config) {
+    return nameTokensPrerequisites.requiredPlugins.every(
+      (plugin) => config.plugins.includes(plugin)
+    );
   },
-  {
-    error: `${valueLabel} must be a valid ENSIndexerVersionInfo object.`
-  }
-).check(invariant_ensDbVersionIsSameAsEnsIndexerVersion);
-function invariant_isSubgraphCompatibleRequirements(ctx) {
-  const { value: config } = ctx;
-  if (config.isSubgraphCompatible && !isSubgraphCompatible(config)) {
-    ctx.issues.push({
-      code: "custom",
-      input: config,
-      message: `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active and labelSet must be {labelSetId: "subgraph", labelSetVersion: 0}`
-    });
+  /**
+   * 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 Name Tokens API.
+   */
+  hasIndexingStatusSupport(omnichainIndexingStatusId) {
+    return nameTokensPrerequisites.supportedIndexingStatusIds.some(
+      (supportedIndexingStatusId) => supportedIndexingStatusId === omnichainIndexingStatusId
+    );
   }
-}
-var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => import_v44.default.object({
-  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
-  indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
-  isSubgraphCompatible: import_v44.default.boolean({ error: `${valueLabel}.isSubgraphCompatible` }),
-  namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
-  plugins: makePluginsListSchema(`${valueLabel}.plugins`),
-  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
-  versionInfo: makeENSIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
-}).check(invariant_isSubgraphCompatibleRequirements);
-
-// src/shared/config/build-rpc-urls.ts
-var import_chains = require("viem/chains");
-
-// src/shared/config/rpc-configs-from-env.ts
-var import_datasources4 = require("@ensnode/datasources");
+});
 
-// src/shared/config/validatons.ts
-var import_datasources5 = require("@ensnode/datasources");
-function invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL(ctx) {
-  const endpoints = ctx.value;
-  const httpEndpoints = endpoints.filter(isHttpProtocol);
-  if (httpEndpoints.length < 1) {
-    ctx.issues.push({
-      code: "custom",
-      input: endpoints,
-      message: `RPC endpoint configuration for a chain must include at least one http/https protocol URL.`
-    });
-  }
+// src/api/name-tokens/serialize.ts
+function serializeRegisteredNameTokens({
+  domainId,
+  name,
+  tokens,
+  expiresAt,
+  accurateAsOf
+}) {
+  return {
+    domainId,
+    name,
+    tokens: tokens.map(serializeNameToken),
+    expiresAt,
+    accurateAsOf
+  };
 }
-function invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL(ctx) {
-  const endpoints = ctx.value;
-  const wsEndpoints = endpoints.filter(isWebSocketProtocol);
-  if (wsEndpoints.length > 1) {
-    ctx.issues.push({
-      code: "custom",
-      input: endpoints,
-      message: `RPC endpoint configuration for a chain must include at most one websocket (ws/wss) protocol URL.`
-    });
+function serializeNameTokensResponse(response) {
+  switch (response.responseCode) {
+    case NameTokensResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        registeredNameTokens: serializeRegisteredNameTokens(response.registeredNameTokens)
+      };
+    case NameTokensResponseCodes.Error:
+      return response;
   }
 }
 
-// src/shared/config/zod-schemas.ts
-var import_v45 = require("zod/v4");
-var import_datasources6 = require("@ensnode/datasources");
-var DatabaseSchemaNameSchema = import_v45.z.string({
-  error: "DATABASE_SCHEMA is required."
-}).trim().min(1, {
-  error: "DATABASE_SCHEMA is required and cannot be an empty string."
-});
-var RpcConfigSchema = import_v45.z.string().transform((val) => val.split(",")).pipe(import_v45.z.array(makeUrlSchema("RPC URL"))).check(invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL).check(invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL);
-var RpcConfigsSchema = import_v45.z.record(makeChainIdStringSchema("RPC URL"), RpcConfigSchema, {
-  error: "Chains configuration must be an object mapping valid chain IDs to their configs."
-}).transform((records) => {
-  const rpcConfigs = /* @__PURE__ */ new Map();
-  for (const [chainIdString, rpcConfig] of Object.entries(records)) {
-    const httpRPCs = rpcConfig.filter(isHttpProtocol);
-    const websocketRPC = rpcConfig.find(isWebSocketProtocol);
-    rpcConfigs.set(deserializeChainId(chainIdString), {
-      httpRPCs,
-      websocketRPC
-    });
-  }
-  return rpcConfigs;
-});
-var EnsIndexerUrlSchema = makeUrlSchema("ENSINDEXER_URL");
-var ENSNamespaceSchema = import_v45.z.enum(import_datasources6.ENSNamespaceIds, {
-  error: ({ input }) => `Invalid NAMESPACE. Got '${input}', but supported ENS namespaces are: ${Object.keys(import_datasources6.ENSNamespaceIds).join(", ")}`
-});
-var PortSchema = import_v45.z.coerce.number({ error: "PORT must be a number." }).min(1, { error: "PORT must be greater than 1." }).max(65535, { error: "PORT must be less than 65535" }).optional();
-var TheGraphApiKeySchema = import_v45.z.string().optional();
-
-// src/shared/datasources-with-resolvers.ts
-var import_datasources7 = require("@ensnode/datasources");
-var DATASOURCE_NAMES_WITH_RESOLVERS = [
-  import_datasources7.DatasourceNames.ENSRoot,
-  import_datasources7.DatasourceNames.Basenames,
-  import_datasources7.DatasourceNames.Lineanames,
-  import_datasources7.DatasourceNames.ThreeDNSOptimism,
-  import_datasources7.DatasourceNames.ThreeDNSBase
-];
-
-// src/shared/log-level.ts
-var import_v46 = require("zod/v4");
-var LogLevelSchema = import_v46.z.enum(["fatal", "error", "warn", "info", "debug", "trace", "silent"]);
+// src/api/registrar-actions/deserialize.ts
+var import_v419 = require("zod/v4");
 
-// src/shared/protocol-acceleration/interpret-record-values.ts
-var import_viem10 = require("viem");
+// src/api/registrar-actions/zod-schemas.ts
+var import_ens7 = require("viem/ens");
+var import_v418 = __toESM(require("zod/v4"), 1);
 
 // ../ens-referrals/src/address.ts
-var import_viem11 = require("viem");
+var import_viem15 = require("viem");
 
 // ../ens-referrals/src/encoding.ts
-var import_viem12 = require("viem");
+var import_viem16 = require("viem");
 var ENCODED_REFERRER_BYTE_OFFSET = 12;
 var ENCODED_REFERRER_BYTE_LENGTH = 32;
-var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem12.pad)("0x", {
+var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem16.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_OFFSET,
   dir: "left"
 });
-var ZERO_ENCODED_REFERRER = (0, import_viem12.pad)("0x", {
+var ZERO_ENCODED_REFERRER = (0, import_viem16.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_LENGTH,
   dir: "left"
 });
 function decodeEncodedReferrer(encodedReferrer) {
-  if ((0, import_viem12.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
+  if ((0, import_viem16.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
     throw new Error(
       `Encoded referrer value must be represented by ${ENCODED_REFERRER_BYTE_LENGTH} bytes.`
     );
   }
-  const padding = (0, import_viem12.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
+  const padding = (0, import_viem16.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
   if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
-    return import_viem12.zeroAddress;
+    return import_viem16.zeroAddress;
   }
-  const decodedReferrer = (0, import_viem12.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
+  const decodedReferrer = (0, import_viem16.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
   try {
-    return (0, import_viem12.getAddress)(decodedReferrer);
+    return (0, import_viem16.getAddress)(decodedReferrer);
   } catch {
     throw new Error(`Decoded referrer value must be a valid EVM address.`);
   }
@@ -1844,27 +2806,22 @@ function decodeEncodedReferrer(encodedReferrer) {
 var REFERRERS_PER_LEADERBOARD_PAGE_MAX = 100;
 
 // ../ens-referrals/src/link.ts
-var import_viem13 = require("viem");
-
-// src/registrars/zod-schemas.ts
-var import_v47 = __toESM(require("zod/v4"), 1);
+var import_viem17 = require("viem");
 
-// src/registrars/subregistry.ts
-function serializeSubregistry(subregistry) {
-  return {
-    subregistryId: serializeAccountId(subregistry.subregistryId),
-    node: subregistry.node
-  };
-}
+// ../ens-referrals/src/referrer-detail.ts
+var ReferrerDetailTypeIds = {
+  /**
+   * Represents a referrer who is ranked on the leaderboard.
+   */
+  Ranked: "ranked",
+  /**
+   * Represents a referrer who is not ranked on the leaderboard.
+   */
+  Unranked: "unranked"
+};
 
-// src/registrars/registration-lifecycle.ts
-function serializeRegistrationLifecycle(registrationLifecycle) {
-  return {
-    subregistry: serializeSubregistry(registrationLifecycle.subregistry),
-    node: registrationLifecycle.node,
-    expiresAt: registrationLifecycle.expiresAt
-  };
-}
+// src/registrars/zod-schemas.ts
+var import_v416 = __toESM(require("zod/v4"), 1);
 
 // src/registrars/registrar-action.ts
 var RegistrarActionTypes = {
@@ -1895,7 +2852,7 @@ function serializeRegistrarAction(registrarAction) {
     type: registrarAction.type,
     incrementalDuration: registrarAction.incrementalDuration,
     registrant: registrarAction.registrant,
-    registrationLifecycle: serializeRegistrationLifecycle(registrarAction.registrationLifecycle),
+    registrationLifecycle: registrarAction.registrationLifecycle,
     pricing: serializeRegistrarActionPricing(registrarAction.pricing),
     referral: registrarAction.referral,
     block: registrarAction.block,
@@ -1905,11 +2862,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v47.default.object({
-  subregistryId: makeSerializedAccountIdSchema(`${valueLabel} Subregistry ID`),
+var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v416.default.object({
+  subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
   node: makeNodeSchema(`${valueLabel} Node`)
 });
-var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v47.default.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v416.default.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -1925,18 +2882,18 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v47.default.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v416.default.union([
   // pricing available
-  import_v47.default.object({
+  import_v416.default.object({
     baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
     premium: makePriceEthSchema(`${valueLabel} Premium`),
     total: makePriceEthSchema(`${valueLabel} Total`)
   }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
   // pricing unknown
-  import_v47.default.object({
-    baseCost: import_v47.default.null(),
-    premium: import_v47.default.null(),
-    total: import_v47.default.null()
+  import_v416.default.object({
+    baseCost: import_v416.default.null(),
+    premium: import_v416.default.null(),
+    total: import_v416.default.null()
   }).transform((v) => v)
 ]);
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
@@ -1956,424 +2913,227 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
       code: "custom",
       input: ctx.value,
       message: errorMessage
-    });
-  }
-}
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v47.default.union([
-  // referral available
-  import_v47.default.object({
-    encodedReferrer: makeHexStringSchema(
-      { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
-      `${valueLabel} Encoded Referrer`
-    ),
-    decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
-  }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
-  // referral not applicable
-  import_v47.default.object({
-    encodedReferrer: import_v47.default.null(),
-    decodedReferrer: import_v47.default.null()
-  })
-]);
-function invariant_eventIdsInitialElementIsTheActionId(ctx) {
-  const { id, eventIds } = ctx.value;
-  if (eventIds[0] !== id) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "The initial element of `eventIds` must be the `id` value"
-    });
-  }
-}
-var EventIdSchema = import_v47.default.string().nonempty();
-var EventIdsSchema = import_v47.default.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v47.default.object({
-  id: EventIdSchema,
-  incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
-  registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`),
-  registrationLifecycle: makeRegistrationLifecycleSchema(
-    `${valueLabel} Registration Lifecycle`
-  ),
-  pricing: makeRegistrarActionPricingSchema(`${valueLabel} Pricing`),
-  referral: makeRegistrarActionReferralSchema(`${valueLabel} Referral`),
-  block: makeBlockRefSchema(`${valueLabel} Block`),
-  transactionHash: makeTransactionHashSchema(`${valueLabel} Transaction Hash`),
-  eventIds: EventIdsSchema
-}).check(invariant_eventIdsInitialElementIsTheActionId);
-var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v47.default.literal(RegistrarActionTypes.Registration)
-});
-var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v47.default.literal(RegistrarActionTypes.Renewal)
-});
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v47.default.discriminatedUnion("type", [
-  makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
-  makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
-]);
-
-// src/api/types.ts
-var IndexingStatusResponseCodes = {
-  /**
-   * Represents that the indexing status is available.
-   */
-  Ok: "ok",
-  /**
-   * Represents that the indexing status is unavailable.
-   */
-  Error: "error"
-};
-var RegistrarActionsFilterTypes = {
-  BySubregistryNode: "bySubregistryNode",
-  WithEncodedReferral: "withEncodedReferral"
-};
-var RegistrarActionsOrders = {
-  LatestRegistrarActions: "orderBy[timestamp]=desc"
-};
-var RegistrarActionsResponseCodes = {
-  /**
-   * Represents that Registrar Actions are available.
-   */
-  Ok: "ok",
-  /**
-   * Represents that Registrar Actions are unavailable.
-   */
-  Error: "error"
-};
-
-// src/api/zod-schemas.ts
-var ErrorResponseSchema = import_v48.default.object({
-  message: import_v48.default.string(),
-  details: import_v48.default.optional(import_v48.default.unknown())
-});
-var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v48.default.strictObject({
-  responseCode: import_v48.default.literal(IndexingStatusResponseCodes.Ok),
-  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
-});
-var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v48.default.strictObject({
-  responseCode: import_v48.default.literal(IndexingStatusResponseCodes.Error)
-});
-var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v48.default.discriminatedUnion("responseCode", [
-  makeIndexingStatusResponseOkSchema(valueLabel),
-  makeIndexingStatusResponseErrorSchema(valueLabel)
-]);
-function invariant_registrationLifecycleNodeMatchesName(ctx) {
-  const { name, action } = ctx.value;
-  const expectedNode = action.registrationLifecycle.node;
-  const actualNode = (0, import_viem14.namehash)(name);
-  if (actualNode !== expectedNode) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: `The 'action.registrationLifecycle.node' must match namehash of 'name'`
-    });
-  }
-}
-var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v48.default.object({
-  action: makeRegistrarActionSchema(valueLabel),
-  name: makeReinterpretedNameSchema(valueLabel)
-}).check(invariant_registrationLifecycleNodeMatchesName);
-var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v48.default.strictObject({
-  responseCode: import_v48.default.literal(RegistrarActionsResponseCodes.Ok),
-  registrarActions: import_v48.default.array(makeNamedRegistrarActionSchema(valueLabel))
-});
-var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v48.default.strictObject({
-  responseCode: import_v48.default.literal(RegistrarActionsResponseCodes.Error),
-  error: ErrorResponseSchema
-});
-var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v48.default.discriminatedUnion("responseCode", [
-  makeRegistrarActionsResponseOkSchema(valueLabel),
-  makeRegistrarActionsResponseErrorSchema(valueLabel)
-]);
-
-// src/api/deserialize.ts
-function deserializeErrorResponse(maybeErrorResponse) {
-  const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize ErrorResponse:
-${(0, import_v49.prettifyError)(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
-function deserializeIndexingStatusResponse(maybeResponse) {
-  const parsed = makeIndexingStatusResponseSchema().safeParse(maybeResponse);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize IndexingStatusResponse:
-${(0, import_v49.prettifyError)(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
-function deserializeRegistrarActionsResponse(maybeResponse) {
-  const parsed = makeRegistrarActionsResponseSchema().safeParse(maybeResponse);
-  if (parsed.error) {
-    throw new Error(
-      `Cannot deserialize RegistrarActionsResponse:
-${(0, import_v49.prettifyError)(parsed.error)}
-`
-    );
-  }
-  return parsed.data;
-}
-
-// src/api/registrar-actions/filters.ts
-function byParentNode(parentNode) {
-  if (typeof parentNode === "undefined") {
-    return void 0;
-  }
-  return {
-    filterType: RegistrarActionsFilterTypes.BySubregistryNode,
-    value: parentNode
-  };
-}
-function withReferral(withReferral2) {
-  if (!withReferral2) {
-    return void 0;
-  }
-  return {
-    filterType: RegistrarActionsFilterTypes.WithEncodedReferral
-  };
-}
-var registrarActionsFilter = {
-  byParentNode,
-  withReferral
-};
-
-// src/ensindexer/config/deserialize.ts
-var import_v410 = require("zod/v4");
-function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
-  const schema = makeENSIndexerPublicConfigSchema(valueLabel);
-  const parsed = schema.safeParse(maybeConfig);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize ENSIndexerPublicConfig:
-${(0, import_v410.prettifyError)(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
-
-// src/ensindexer/config/label-utils.ts
-var import_viem15 = require("viem");
-function labelHashToBytes(labelHash) {
-  try {
-    if (labelHash.length !== 66) {
-      throw new Error(`Invalid labelHash length ${labelHash.length} characters (expected 66)`);
-    }
-    if (labelHash !== labelHash.toLowerCase()) {
-      throw new Error("Labelhash must be in lowercase");
-    }
-    if (!labelHash.startsWith("0x")) {
-      throw new Error("Labelhash must be 0x-prefixed");
-    }
-    const bytes = (0, import_viem15.hexToBytes)(labelHash);
-    if (bytes.length !== 32) {
-      throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
-    }
-    return bytes;
-  } catch (e) {
-    if (e instanceof Error) {
-      throw e;
-    }
-    throw new Error("Invalid hex format");
-  }
-}
-
-// src/ensindexer/config/labelset-utils.ts
-function buildLabelSetId(maybeLabelSetId) {
-  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
-}
-function buildLabelSetVersion(maybeLabelSetVersion) {
-  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
-}
-function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
-  if (labelSetVersion !== void 0 && labelSetId === void 0) {
-    throw new Error("When a labelSetVersion is defined, labelSetId must also be defined.");
+    });
   }
-  return { labelSetId, labelSetVersion };
 }
-function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
-  if (clientSet.labelSetId === void 0) {
-    return;
-  }
-  if (serverSet.labelSetId !== clientSet.labelSetId) {
-    throw new Error(
-      `Server label set ID "${serverSet.labelSetId}" does not match client's requested label set ID "${clientSet.labelSetId}".`
-    );
-  }
-  if (clientSet.labelSetVersion !== void 0 && serverSet.highestLabelSetVersion < clientSet.labelSetVersion) {
-    throw new Error(
-      `Server highest label set version ${serverSet.highestLabelSetVersion} is less than client's requested version ${clientSet.labelSetVersion} for label set ID "${clientSet.labelSetId}".`
-    );
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v416.default.union([
+  // referral available
+  import_v416.default.object({
+    encodedReferrer: makeHexStringSchema(
+      { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
+      `${valueLabel} Encoded Referrer`
+    ),
+    decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
+  }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
+  // referral not applicable
+  import_v416.default.object({
+    encodedReferrer: import_v416.default.null(),
+    decodedReferrer: import_v416.default.null()
+  })
+]);
+function invariant_eventIdsInitialElementIsTheActionId(ctx) {
+  const { id, eventIds } = ctx.value;
+  if (eventIds[0] !== id) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "The initial element of `eventIds` must be the `id` value"
+    });
   }
 }
+var EventIdSchema = import_v416.default.string().nonempty();
+var EventIdsSchema = import_v416.default.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v416.default.object({
+  id: EventIdSchema,
+  incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
+  registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`),
+  registrationLifecycle: makeRegistrationLifecycleSchema(
+    `${valueLabel} Registration Lifecycle`
+  ),
+  pricing: makeRegistrarActionPricingSchema(`${valueLabel} Pricing`),
+  referral: makeRegistrarActionReferralSchema(`${valueLabel} Referral`),
+  block: makeBlockRefSchema(`${valueLabel} Block`),
+  transactionHash: makeTransactionHashSchema(`${valueLabel} Transaction Hash`),
+  eventIds: EventIdsSchema
+}).check(invariant_eventIdsInitialElementIsTheActionId);
+var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
+  type: import_v416.default.literal(RegistrarActionTypes.Registration)
+});
+var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
+  type: import_v416.default.literal(RegistrarActionTypes.Renewal)
+});
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v416.default.discriminatedUnion("type", [
+  makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
+  makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
+]);
 
-// src/ensindexer/config/parsing.ts
-function parseNonNegativeInteger(maybeNumber) {
-  const trimmed = maybeNumber.trim();
-  if (!trimmed) {
-    throw new Error("Input cannot be empty");
-  }
-  if (trimmed === "-0") {
-    throw new Error("Negative zero is not a valid non-negative integer");
-  }
-  const num = Number(maybeNumber);
-  if (Number.isNaN(num)) {
-    throw new Error(`"${maybeNumber}" is not a valid number`);
+// src/api/shared/pagination/zod-schemas.ts
+var import_v417 = __toESM(require("zod/v4"), 1);
+
+// src/api/shared/pagination/request.ts
+var RECORDS_PER_PAGE_DEFAULT = 10;
+var RECORDS_PER_PAGE_MAX = 100;
+
+// src/api/shared/pagination/zod-schemas.ts
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v417.default.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_v417.default.object({
+  totalRecords: import_v417.default.literal(0),
+  totalPages: import_v417.default.literal(1),
+  hasNext: import_v417.default.literal(false),
+  hasPrev: import_v417.default.literal(false),
+  startIndex: import_v417.default.undefined(),
+  endIndex: import_v417.default.undefined()
+}).extend(makeRequestPageParamsSchema(valueLabel).shape);
+function invariant_responsePageWithRecordsIsCorrect(ctx) {
+  const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
+  const expectedHasNext = page * recordsPerPage < totalRecords;
+  if (hasNext !== expectedHasNext) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `hasNext must be equal to '${expectedHasNext ? "true" : "false"}'`
+    });
   }
-  if (!Number.isFinite(num)) {
-    throw new Error(`"${maybeNumber}" is not a finite number`);
+  const expectedHasPrev = page > 1;
+  if (hasPrev !== expectedHasPrev) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `hasPrev must be equal to '${expectedHasPrev ? "true" : "false"}'`
+    });
   }
-  if (!Number.isInteger(num)) {
-    throw new Error(`"${maybeNumber}" is not an integer`);
+  if (endIndex < startIndex) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `endIndex must be greater than or equal to startIndex`
+    });
   }
-  if (num < 0) {
-    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
+  if (endIndex >= totalRecords) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `endIndex must be lower than totalRecords`
+    });
   }
-  return num;
 }
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v417.default.object({
+  totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
+  totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
+  hasNext: import_v417.default.boolean(),
+  hasPrev: import_v417.default.boolean(),
+  startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
+  endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
+}).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v417.default.union([
+  makeResponsePageContextSchemaWithNoRecords(valueLabel),
+  makeResponsePageContextSchemaWithRecords(valueLabel)
+]);
 
-// src/ensindexer/config/serialize.ts
-function serializeIndexedChainIds(indexedChainIds) {
-  return Array.from(indexedChainIds);
-}
-function serializeENSIndexerPublicConfig(config) {
-  const {
-    labelSet,
-    indexedChainIds,
-    databaseSchemaName,
-    isSubgraphCompatible: isSubgraphCompatible2,
-    namespace,
-    plugins,
-    versionInfo
-  } = config;
-  return {
-    labelSet,
-    indexedChainIds: serializeIndexedChainIds(indexedChainIds),
-    databaseSchemaName,
-    isSubgraphCompatible: isSubgraphCompatible2,
-    namespace,
-    plugins,
-    versionInfo
-  };
-}
+// src/api/registrar-actions/response.ts
+var RegistrarActionsResponseCodes = {
+  /**
+   * Represents that Registrar Actions are available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that Registrar Actions are unavailable.
+   */
+  Error: "error"
+};
 
-// src/ensindexer/indexing-status/deserialize.ts
-var import_v411 = 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_v411.prettifyError)(parsed.error)}
-`
-    );
-  }
-  return parsed.data;
-}
-function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
-  const schema = makeOmnichainIndexingStatusSnapshotSchema(valueLabel);
-  const parsed = schema.safeParse(maybeSnapshot);
-  if (parsed.error) {
-    throw new Error(
-      `Cannot deserialize into OmnichainIndexingStatusSnapshot:
-${(0, import_v411.prettifyError)(parsed.error)}
-`
-    );
-  }
-  return parsed.data;
-}
-function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
-  const schema = makeCrossChainIndexingStatusSnapshotSchema(valueLabel);
-  const parsed = schema.safeParse(maybeSnapshot);
-  if (parsed.error) {
-    throw new Error(
-      `Cannot deserialize into CrossChainIndexingStatusSnapshot:
-${(0, import_v411.prettifyError)(parsed.error)}
-`
-    );
+// src/api/registrar-actions/zod-schemas.ts
+function invariant_registrationLifecycleNodeMatchesName(ctx) {
+  const { name, action } = ctx.value;
+  const expectedNode = action.registrationLifecycle.node;
+  const actualNode = (0, import_ens7.namehash)(name);
+  if (actualNode !== expectedNode) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `The 'action.registrationLifecycle.node' must match namehash of 'name'`
+    });
   }
-  return parsed.data;
 }
-function deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel) {
-  const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
-  const parsed = schema.safeParse(maybeProjection);
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v418.default.object({
+  action: makeRegistrarActionSchema(valueLabel),
+  name: makeReinterpretedNameSchema(valueLabel)
+}).check(invariant_registrationLifecycleNodeMatchesName);
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v418.default.strictObject({
+  responseCode: import_v418.default.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: import_v418.default.array(makeNamedRegistrarActionSchema(valueLabel)),
+  pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`)
+});
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v418.default.strictObject({
+  responseCode: import_v418.default.literal(RegistrarActionsResponseCodes.Error),
+  error: ErrorResponseSchema
+});
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v418.default.discriminatedUnion("responseCode", [
+  makeRegistrarActionsResponseOkSchema(valueLabel),
+  makeRegistrarActionsResponseErrorSchema(valueLabel)
+]);
+
+// src/api/registrar-actions/deserialize.ts
+function deserializeRegistrarActionsResponse(maybeResponse) {
+  const parsed = makeRegistrarActionsResponseSchema().safeParse(maybeResponse);
   if (parsed.error) {
     throw new Error(
-      `Cannot deserialize into RealtimeIndexingStatusProjection:
-${(0, import_v411.prettifyError)(parsed.error)}
+      `Cannot deserialize RegistrarActionsResponse:
+${(0, import_v419.prettifyError)(parsed.error)}
 `
     );
   }
   return parsed.data;
 }
 
-// src/ensindexer/indexing-status/projection.ts
-function createRealtimeIndexingStatusProjection(snapshot, now) {
-  const projectedAt = Math.max(now, snapshot.snapshotTime);
-  return {
-    projectedAt,
-    worstCaseDistance: projectedAt - snapshot.slowestChainIndexingCursor,
-    snapshot
-  };
-}
+// src/api/registrar-actions/request.ts
+var RegistrarActionsFilterTypes = {
+  BySubregistryNode: "bySubregistryNode",
+  WithEncodedReferral: "withEncodedReferral",
+  ByDecodedReferrer: "byDecodedReferrer"
+};
+var RegistrarActionsOrders = {
+  LatestRegistrarActions: "orderBy[timestamp]=desc"
+};
 
-// src/ensindexer/indexing-status/serialize.ts
-function serializeCrossChainIndexingStatusSnapshotOmnichain({
-  strategy,
-  slowestChainIndexingCursor,
-  snapshotTime,
-  omnichainSnapshot
-}) {
-  return {
-    strategy,
-    slowestChainIndexingCursor,
-    snapshotTime,
-    omnichainSnapshot: serializeOmnichainIndexingStatusSnapshot(omnichainSnapshot)
-  };
-}
-function serializeRealtimeIndexingStatusProjection(indexingProjection) {
-  return {
-    projectedAt: indexingProjection.projectedAt,
-    worstCaseDistance: indexingProjection.worstCaseDistance,
-    snapshot: serializeCrossChainIndexingStatusSnapshotOmnichain(indexingProjection.snapshot)
-  };
-}
-function serializeChainIndexingSnapshots(chains) {
-  const serializedSnapshots = {};
-  for (const [chainId, snapshot] of chains.entries()) {
-    serializedSnapshots[serializeChainId(chainId)] = snapshot;
-  }
-  return serializedSnapshots;
-}
-function serializeOmnichainIndexingStatusSnapshot(indexingStatus) {
-  switch (indexingStatus.omnichainStatus) {
-    case OmnichainIndexingStatusIds.Unstarted:
-      return {
-        omnichainStatus: OmnichainIndexingStatusIds.Unstarted,
-        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
-        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
-      };
-    case OmnichainIndexingStatusIds.Backfill:
-      return {
-        omnichainStatus: OmnichainIndexingStatusIds.Backfill,
-        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
-        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
-      };
-    case OmnichainIndexingStatusIds.Completed: {
-      return {
-        omnichainStatus: OmnichainIndexingStatusIds.Completed,
-        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
-        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
-      };
-    }
-    case OmnichainIndexingStatusIds.Following:
-      return {
-        omnichainStatus: OmnichainIndexingStatusIds.Following,
-        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
-        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
-      };
+// src/api/registrar-actions/filters.ts
+function byParentNode(parentNode) {
+  if (typeof parentNode === "undefined") {
+    return void 0;
+  }
+  return {
+    filterType: RegistrarActionsFilterTypes.BySubregistryNode,
+    value: parentNode
+  };
+}
+function withReferral(withReferral2) {
+  if (!withReferral2) {
+    return void 0;
+  }
+  return {
+    filterType: RegistrarActionsFilterTypes.WithEncodedReferral
+  };
+}
+function byDecodedReferrer(decodedReferrer) {
+  if (typeof decodedReferrer === "undefined") {
+    return void 0;
   }
+  return {
+    filterType: RegistrarActionsFilterTypes.ByDecodedReferrer,
+    value: decodedReferrer
+  };
 }
+var registrarActionsFilter = {
+  byParentNode,
+  withReferral,
+  byDecodedReferrer
+};
 
 // src/api/registrar-actions/prerequisites.ts
 var registrarActionsPrerequisites = Object.freeze({
@@ -2425,12 +3185,42 @@ var registrarActionsPrerequisites = Object.freeze({
   }
 });
 
+// src/registrars/basenames-subregistry.ts
+var import_datasources6 = require("@ensnode/datasources");
+function getBasenamesSubregistryId(namespace) {
+  const datasource = (0, import_datasources6.maybeGetDatasource)(namespace, import_datasources6.DatasourceNames.Basenames);
+  if (!datasource) {
+    throw new Error(`Datasource not found for ${namespace} ${import_datasources6.DatasourceNames.Basenames}`);
+  }
+  const address = datasource.contracts.BaseRegistrar?.address;
+  if (address === void 0 || Array.isArray(address)) {
+    throw new Error(`BaseRegistrar contract not found or has multiple addresses for ${namespace}`);
+  }
+  return {
+    chainId: datasource.chain.id,
+    address
+  };
+}
+function getBasenamesSubregistryManagedName(namespaceId) {
+  switch (namespaceId) {
+    case import_datasources6.ENSNamespaceIds.Mainnet:
+      return "base.eth";
+    case import_datasources6.ENSNamespaceIds.Sepolia:
+      return "basetest.eth";
+    case import_datasources6.ENSNamespaceIds.Holesky:
+    case import_datasources6.ENSNamespaceIds.EnsTestEnv:
+      throw new Error(
+        `No registrar managed name is known for the 'basenames' subregistry within the "${namespaceId}" namespace.`
+      );
+  }
+}
+
 // src/registrars/ethnames-subregistry.ts
-var import_datasources8 = require("@ensnode/datasources");
+var import_datasources7 = require("@ensnode/datasources");
 function getEthnamesSubregistryId(namespace) {
-  const datasource = (0, import_datasources8.maybeGetDatasource)(namespace, import_datasources8.DatasourceNames.ENSRoot);
+  const datasource = (0, import_datasources7.maybeGetDatasource)(namespace, import_datasources7.DatasourceNames.ENSRoot);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${import_datasources8.DatasourceNames.ENSRoot}`);
+    throw new Error(`Datasource not found for ${namespace} ${import_datasources7.DatasourceNames.ENSRoot}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -2441,19 +3231,47 @@ function getEthnamesSubregistryId(namespace) {
     address
   };
 }
+function getEthnamesSubregistryManagedName(namespaceId) {
+  switch (namespaceId) {
+    case import_datasources7.ENSNamespaceIds.Mainnet:
+    case import_datasources7.ENSNamespaceIds.Sepolia:
+    case import_datasources7.ENSNamespaceIds.Holesky:
+    case import_datasources7.ENSNamespaceIds.EnsTestEnv:
+      return "eth";
+  }
+}
 
-// src/api/serialize.ts
-function serializeIndexingStatusResponse(response) {
-  switch (response.responseCode) {
-    case IndexingStatusResponseCodes.Ok:
-      return {
-        responseCode: response.responseCode,
-        realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection)
-      };
-    case IndexingStatusResponseCodes.Error:
-      return response;
+// src/registrars/lineanames-subregistry.ts
+var import_datasources8 = require("@ensnode/datasources");
+function getLineanamesSubregistryId(namespace) {
+  const datasource = (0, import_datasources8.maybeGetDatasource)(namespace, import_datasources8.DatasourceNames.Lineanames);
+  if (!datasource) {
+    throw new Error(`Datasource not found for ${namespace} ${import_datasources8.DatasourceNames.Lineanames}`);
+  }
+  const address = datasource.contracts.BaseRegistrar?.address;
+  if (address === void 0 || Array.isArray(address)) {
+    throw new Error(`BaseRegistrar contract not found or has multiple addresses for ${namespace}`);
+  }
+  return {
+    chainId: datasource.chain.id,
+    address
+  };
+}
+function getLineanamesSubregistryManagedName(namespaceId) {
+  switch (namespaceId) {
+    case import_datasources8.ENSNamespaceIds.Mainnet:
+      return "linea.eth";
+    case import_datasources8.ENSNamespaceIds.Sepolia:
+      return "linea-sepolia.eth";
+    case import_datasources8.ENSNamespaceIds.Holesky:
+    case import_datasources8.ENSNamespaceIds.EnsTestEnv:
+      throw new Error(
+        `No registrar managed name is known for the 'Lineanames' subregistry within the "${namespaceId}" namespace.`
+      );
   }
 }
+
+// src/api/registrar-actions/serialize.ts
 function serializeNamedRegistrarAction({
   action,
   name
@@ -2468,13 +3286,61 @@ function serializeRegistrarActionsResponse(response) {
     case RegistrarActionsResponseCodes.Ok:
       return {
         responseCode: response.responseCode,
-        registrarActions: response.registrarActions.map(serializeNamedRegistrarAction)
+        registrarActions: response.registrarActions.map(serializeNamedRegistrarAction),
+        pageContext: response.pageContext
       };
     case RegistrarActionsResponseCodes.Error:
       return response;
   }
 }
 
+// src/api/shared/errors/deserialize.ts
+var import_v420 = require("zod/v4");
+function deserializeErrorResponse(maybeErrorResponse) {
+  const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ErrorResponse:
+${(0, import_v420.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/api/shared/pagination/build-page-context.ts
+function buildPageContext(page, recordsPerPage, totalRecords) {
+  const totalPages = Math.max(1, Math.ceil(totalRecords / recordsPerPage));
+  if (page > totalPages) {
+    throw new Error(`Invalid page: page ${page} exceeds total pages ${totalPages}.`);
+  }
+  if (totalRecords === 0) {
+    return {
+      page,
+      recordsPerPage,
+      totalRecords: 0,
+      totalPages: 1,
+      hasNext: false,
+      hasPrev: false,
+      startIndex: void 0,
+      endIndex: void 0
+    };
+  }
+  const startIndex = (page - 1) * recordsPerPage;
+  const maxTheoreticalIndexOnPage = startIndex + (recordsPerPage - 1);
+  const endIndex = Math.min(maxTheoreticalIndexOnPage, totalRecords - 1);
+  const hasNext = maxTheoreticalIndexOnPage < totalRecords - 1;
+  const hasPrev = page > 1;
+  return {
+    page,
+    recordsPerPage,
+    totalRecords,
+    totalPages,
+    hasNext,
+    hasPrev,
+    startIndex,
+    endIndex
+  };
+}
+
 // src/client-error.ts
 var ClientError = class _ClientError extends Error {
   details;
@@ -2489,10 +3355,10 @@ var ClientError = class _ClientError extends Error {
 };
 
 // src/ensanalytics/deserialize.ts
-var import_v413 = require("zod/v4");
+var import_v422 = require("zod/v4");
 
 // src/ensanalytics/zod-schemas.ts
-var import_v412 = __toESM(require("zod/v4"), 1);
+var import_v421 = __toESM(require("zod/v4"), 1);
 
 // src/ensanalytics/types.ts
 var ReferrerLeaderboardPageResponseCodes = {
@@ -2505,22 +3371,50 @@ var ReferrerLeaderboardPageResponseCodes = {
    */
   Error: "error"
 };
+var ReferrerDetailResponseCodes = {
+  /**
+   * Represents that the referrer detail data is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that an error occurred while fetching the data.
+   */
+  Error: "error"
+};
 
 // src/ensanalytics/zod-schemas.ts
-var makeReferralProgramRulesSchema = (valueLabel = "ReferralProgramRules") => import_v412.default.object({
+var makeReferralProgramRulesSchema = (valueLabel = "ReferralProgramRules") => import_v421.default.object({
   totalAwardPoolValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.totalAwardPoolValue`),
   maxQualifiedReferrers: makeNonNegativeIntegerSchema(`${valueLabel}.maxQualifiedReferrers`),
   startTime: makeUnixTimestampSchema(`${valueLabel}.startTime`),
   endTime: makeUnixTimestampSchema(`${valueLabel}.endTime`),
   subregistryId: makeAccountIdSchema(`${valueLabel}.subregistryId`)
 });
-var makeAwardedReferrerMetricsSchema = (valueLabel = "AwardedReferrerMetrics") => import_v412.default.object({
+var makeAwardedReferrerMetricsSchema = (valueLabel = "AwardedReferrerMetrics") => import_v421.default.object({
   referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
   totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
   totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
   score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
   rank: makePositiveIntegerSchema(`${valueLabel}.rank`),
-  isQualified: import_v412.default.boolean(),
+  isQualified: import_v421.default.boolean(),
+  finalScoreBoost: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScoreBoost`).max(
+    1,
+    `${valueLabel}.finalScoreBoost must be <= 1`
+  ),
+  finalScore: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScore`),
+  awardPoolShare: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolShare`).max(
+    1,
+    `${valueLabel}.awardPoolShare must be <= 1`
+  ),
+  awardPoolApproxValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolApproxValue`)
+});
+var makeUnrankedReferrerMetricsSchema = (valueLabel = "UnrankedReferrerMetrics") => import_v421.default.object({
+  referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
+  totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
+  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
+  rank: import_v421.default.null(),
+  isQualified: import_v421.default.literal(false),
   finalScoreBoost: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScoreBoost`).max(
     1,
     `${valueLabel}.finalScoreBoost must be <= 1`
@@ -2532,7 +3426,7 @@ var makeAwardedReferrerMetricsSchema = (valueLabel = "AwardedReferrerMetrics") =
   ),
   awardPoolApproxValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolApproxValue`)
 });
-var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetrics") => import_v412.default.object({
+var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetrics") => import_v421.default.object({
   grandTotalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.grandTotalReferrals`),
   grandTotalIncrementalDuration: makeDurationSchema(
     `${valueLabel}.grandTotalIncrementalDuration`
@@ -2544,41 +3438,69 @@ var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetri
     `${valueLabel}.minFinalScoreToQualify`
   )
 });
-var makeReferrerLeaderboardPaginationContextSchema = (valueLabel = "ReferrerLeaderboardPaginationContext") => import_v412.default.object({
+var makeReferrerLeaderboardPageContextSchema = (valueLabel = "ReferrerLeaderboardPageContext") => import_v421.default.object({
   page: makePositiveIntegerSchema(`${valueLabel}.page`),
-  itemsPerPage: makePositiveIntegerSchema(`${valueLabel}.itemsPerPage`).max(
+  recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
     REFERRERS_PER_LEADERBOARD_PAGE_MAX,
-    `${valueLabel}.itemsPerPage must not exceed ${REFERRERS_PER_LEADERBOARD_PAGE_MAX}`
+    `${valueLabel}.recordsPerPage must not exceed ${REFERRERS_PER_LEADERBOARD_PAGE_MAX}`
   ),
   totalRecords: makeNonNegativeIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: import_v412.default.boolean(),
-  hasPrev: import_v412.default.boolean(),
-  startIndex: import_v412.default.optional(makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`)),
-  endIndex: import_v412.default.optional(makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`))
+  hasNext: import_v421.default.boolean(),
+  hasPrev: import_v421.default.boolean(),
+  startIndex: import_v421.default.optional(makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`)),
+  endIndex: import_v421.default.optional(makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`))
 });
-var makeReferrerLeaderboardPageSchema = (valueLabel = "ReferrerLeaderboardPage") => import_v412.default.object({
+var makeReferrerLeaderboardPageSchema = (valueLabel = "ReferrerLeaderboardPage") => import_v421.default.object({
   rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
-  referrers: import_v412.default.array(makeAwardedReferrerMetricsSchema(`${valueLabel}.referrers[item]`)),
+  referrers: import_v421.default.array(makeAwardedReferrerMetricsSchema(`${valueLabel}.referrers[record]`)),
   aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
-  paginationContext: makeReferrerLeaderboardPaginationContextSchema(
-    `${valueLabel}.paginationContext`
-  ),
+  pageContext: makeReferrerLeaderboardPageContextSchema(`${valueLabel}.pageContext`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
-var makeReferrerLeaderboardPageResponseOkSchema = (valueLabel = "ReferrerLeaderboardPageResponseOk") => import_v412.default.object({
-  responseCode: import_v412.default.literal(ReferrerLeaderboardPageResponseCodes.Ok),
+var makeReferrerLeaderboardPageResponseOkSchema = (valueLabel = "ReferrerLeaderboardPageResponseOk") => import_v421.default.object({
+  responseCode: import_v421.default.literal(ReferrerLeaderboardPageResponseCodes.Ok),
   data: makeReferrerLeaderboardPageSchema(`${valueLabel}.data`)
 });
-var makeReferrerLeaderboardPageResponseErrorSchema = (_valueLabel = "ReferrerLeaderboardPageResponseError") => import_v412.default.object({
-  responseCode: import_v412.default.literal(ReferrerLeaderboardPageResponseCodes.Error),
-  error: import_v412.default.string(),
-  errorMessage: import_v412.default.string()
+var makeReferrerLeaderboardPageResponseErrorSchema = (_valueLabel = "ReferrerLeaderboardPageResponseError") => import_v421.default.object({
+  responseCode: import_v421.default.literal(ReferrerLeaderboardPageResponseCodes.Error),
+  error: import_v421.default.string(),
+  errorMessage: import_v421.default.string()
 });
-var makeReferrerLeaderboardPageResponseSchema = (valueLabel = "ReferrerLeaderboardPageResponse") => import_v412.default.union([
+var makeReferrerLeaderboardPageResponseSchema = (valueLabel = "ReferrerLeaderboardPageResponse") => import_v421.default.union([
   makeReferrerLeaderboardPageResponseOkSchema(valueLabel),
   makeReferrerLeaderboardPageResponseErrorSchema(valueLabel)
 ]);
+var makeReferrerDetailRankedSchema = (valueLabel = "ReferrerDetailRanked") => import_v421.default.object({
+  type: import_v421.default.literal(ReferrerDetailTypeIds.Ranked),
+  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
+  referrer: makeAwardedReferrerMetricsSchema(`${valueLabel}.referrer`),
+  aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+});
+var makeReferrerDetailUnrankedSchema = (valueLabel = "ReferrerDetailUnranked") => import_v421.default.object({
+  type: import_v421.default.literal(ReferrerDetailTypeIds.Unranked),
+  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
+  referrer: makeUnrankedReferrerMetricsSchema(`${valueLabel}.referrer`),
+  aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+});
+var makeReferrerDetailResponseOkSchema = (valueLabel = "ReferrerDetailResponse") => import_v421.default.object({
+  responseCode: import_v421.default.literal(ReferrerDetailResponseCodes.Ok),
+  data: import_v421.default.union([
+    makeReferrerDetailRankedSchema(`${valueLabel}.data`),
+    makeReferrerDetailUnrankedSchema(`${valueLabel}.data`)
+  ])
+});
+var makeReferrerDetailResponseErrorSchema = (_valueLabel = "ReferrerDetailResponse") => import_v421.default.object({
+  responseCode: import_v421.default.literal(ReferrerDetailResponseCodes.Error),
+  error: import_v421.default.string(),
+  errorMessage: import_v421.default.string()
+});
+var makeReferrerDetailResponseSchema = (valueLabel = "ReferrerDetailResponse") => import_v421.default.union([
+  makeReferrerDetailResponseOkSchema(valueLabel),
+  makeReferrerDetailResponseErrorSchema(valueLabel)
+]);
 
 // src/ensanalytics/deserialize.ts
 function deserializeReferrerLeaderboardPageResponse(maybeResponse, valueLabel) {
@@ -2587,12 +3509,22 @@ function deserializeReferrerLeaderboardPageResponse(maybeResponse, valueLabel) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize SerializedReferrerLeaderboardPageResponse:
-${(0, import_v413.prettifyError)(parsed.error)}
+${(0, import_v422.prettifyError)(parsed.error)}
 `
     );
   }
   return parsed.data;
 }
+function deserializeReferrerDetailResponse(maybeResponse, valueLabel) {
+  const schema = makeReferrerDetailResponseSchema(valueLabel);
+  const parsed = schema.safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ReferrerDetailResponse:
+${(0, import_v422.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
 
 // src/ensanalytics/serialize.ts
 function serializeReferrerLeaderboardPageResponse(response) {
@@ -2603,55 +3535,15 @@ function serializeReferrerLeaderboardPageResponse(response) {
       return response;
   }
 }
-
-// src/ensapi/config/deserialize.ts
-var import_v415 = require("zod/v4");
-
-// src/ensapi/config/zod-schemas.ts
-var import_v414 = require("zod/v4");
-var TheGraphCannotFallbackReasonSchema = import_v414.z.enum({
-  NotSubgraphCompatible: "not-subgraph-compatible",
-  NoApiKey: "no-api-key",
-  NoSubgraphUrl: "no-subgraph-url"
-});
-var TheGraphFallbackSchema = import_v414.z.strictObject({
-  canFallback: import_v414.z.boolean(),
-  reason: TheGraphCannotFallbackReasonSchema.nullable()
-});
-function makeENSApiPublicConfigSchema(valueLabel) {
-  const label = valueLabel ?? "ENSApiPublicConfig";
-  return import_v414.z.strictObject({
-    version: import_v414.z.string().min(1, `${label}.version must be a non-empty string`),
-    theGraphFallback: TheGraphFallbackSchema,
-    ensIndexerPublicConfig: makeENSIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
-  });
-}
-
-// src/ensapi/config/deserialize.ts
-function deserializeENSApiPublicConfig(maybeConfig, valueLabel) {
-  const schema = makeENSApiPublicConfigSchema(valueLabel);
-  try {
-    return schema.parse(maybeConfig);
-  } catch (error) {
-    if (error instanceof import_v415.ZodError) {
-      throw new Error(`Cannot deserialize ENSApiPublicConfig:
-${(0, import_v415.prettifyError)(error)}
-`);
-    }
-    throw error;
+function serializeReferrerDetailResponse(response) {
+  switch (response.responseCode) {
+    case ReferrerDetailResponseCodes.Ok:
+      return response;
+    case ReferrerDetailResponseCodes.Error:
+      return response;
   }
 }
 
-// src/ensapi/config/serialize.ts
-function serializeENSApiPublicConfig(config) {
-  const { version, theGraphFallback, ensIndexerPublicConfig } = config;
-  return {
-    version,
-    theGraphFallback,
-    ensIndexerPublicConfig: serializeENSIndexerPublicConfig(ensIndexerPublicConfig)
-  };
-}
-
 // src/client.ts
 var DEFAULT_ENSNODE_API_URL = "https://api.alpha.ensnode.io";
 var ENSNodeClient = class _ENSNodeClient {
@@ -2855,7 +3747,7 @@ var ENSNodeClient = class _ENSNodeClient {
       const errorResponse = deserializeErrorResponse(responseData);
       throw new Error(`Fetching ENSNode Config Failed: ${errorResponse.message}`);
     }
-    return deserializeENSApiPublicConfig(responseData);
+    return deserializeConfigResponse(responseData);
   }
   /**
    * Fetch ENSNode Indexing Status
@@ -2896,7 +3788,7 @@ var ENSNodeClient = class _ENSNodeClient {
    *
    * @param request - Pagination parameters
    * @param request.page - The page number to retrieve (1-indexed, default: 1)
-   * @param request.itemsPerPage - Number of items per page (default: 25, max: 100)
+   * @param request.recordsPerPage - Number of records per page (default: 25, max: 100)
    * @returns {ReferrerLeaderboardPageResponse}
    *
    * @throws if the ENSNode request fails
@@ -2905,34 +3797,34 @@ var ENSNodeClient = class _ENSNodeClient {
    *
    * @example
    * ```typescript
-   * // Get first page with default page size (25 items)
-   * const response = await client.getReferrerLeaderboard();
+   * // Get first page with default page size (25 records)
+   * const response = await client.getReferrerLeaderboardPage();
    * if (response.responseCode === ReferrerLeaderboardPageResponseCodes.Ok) {
    *   const {
    *     aggregatedMetrics,
    *     referrers,
    *     rules,
-   *     paginationContext,
+   *     pageContext,
    *     updatedAt
    *   } = response.data;
    *   console.log(aggregatedMetrics);
    *   console.log(referrers);
    *   console.log(rules);
    *   console.log(updatedAt);
-   *   console.log(`Page ${paginationContext.page} of ${paginationContext.totalPages}`);
+   *   console.log(`Page ${pageContext.page} of ${pageContext.totalPages}`);
    * }
    * ```
    *
    * @example
    * ```typescript
-   * // Get second page with 50 items per page
-   * const response = await client.getReferrerLeaderboard({ page: 2, itemsPerPage: 50 });
+   * // Get second page with 50 records per page
+   * const response = await client.getReferrerLeaderboardPage({ page: 2, recordsPerPage: 50 });
    * ```
    *
    * @example
    * ```typescript
    * // Handle error response, ie. when Referrer Leaderboard is not currently available.
-   * const response = await client.getReferrerLeaderboard();
+   * const response = await client.getReferrerLeaderboardPage();
    *
    * if (response.responseCode === ReferrerLeaderboardPageResponseCodes.Error) {
    *   console.error(response.error);
@@ -2940,11 +3832,11 @@ var ENSNodeClient = class _ENSNodeClient {
    * }
    * ```
    */
-  async getReferrerLeaderboard(request) {
+  async getReferrerLeaderboardPage(request) {
     const url = new URL(`/ensanalytics/referrers`, this.options.url);
     if (request?.page) url.searchParams.set("page", request.page.toString());
-    if (request?.itemsPerPage)
-      url.searchParams.set("itemsPerPage", request.itemsPerPage.toString());
+    if (request?.recordsPerPage)
+      url.searchParams.set("recordsPerPage", request.recordsPerPage.toString());
     const response = await fetch(url);
     let responseData;
     try {
@@ -2956,14 +3848,106 @@ var ENSNodeClient = class _ENSNodeClient {
       responseData
     );
   }
+  /**
+   * Fetch Referrer Detail
+   *
+   * Retrieves detailed information about a specific referrer, whether they are on the
+   * leaderboard or not.
+   *
+   * The response data is a discriminated union type with a `type` field:
+   *
+   * **For referrers on the leaderboard** (`ReferrerDetailRanked`):
+   * - `type`: {@link ReferrerDetailTypeIds.Ranked}
+   * - `referrer`: The `AwardedReferrerMetrics` from @namehash/ens-referrals
+   * - `rules`: The referral program rules
+   * - `aggregatedMetrics`: Aggregated metrics for all referrers on the leaderboard
+   * - `accurateAsOf`: Unix timestamp indicating when the data was last updated
+   *
+   * **For referrers NOT on the leaderboard** (`ReferrerDetailUnranked`):
+   * - `type`: {@link ReferrerDetailTypeIds.Unranked}
+   * - `referrer`: The `UnrankedReferrerMetrics` from @namehash/ens-referrals
+   * - `rules`: The referral program rules
+   * - `aggregatedMetrics`: Aggregated metrics for all referrers on the leaderboard
+   * - `accurateAsOf`: Unix timestamp indicating when the data was last updated
+   *
+   * @see {@link https://www.npmjs.com/package/@namehash/ens-referrals|@namehash/ens-referrals} for calculation details
+   *
+   * @param request The referrer address to query
+   * @returns {ReferrerDetailResponse} Returns the referrer detail response
+   *
+   * @throws if the ENSNode request fails
+   * @throws if the response data is malformed
+   *
+   * @example
+   * ```typescript
+   * // Get referrer detail for a specific address
+   * const response = await client.getReferrerDetail({
+   *   referrer: "0x1234567890123456789012345678901234567890"
+   * });
+   * if (response.responseCode === ReferrerDetailResponseCodes.Ok) {
+   *   const { type, referrer, rules, aggregatedMetrics, accurateAsOf } = response.data;
+   *   console.log(type); // ReferrerDetailTypeIds.Ranked or ReferrerDetailTypeIds.Unranked
+   *   console.log(referrer);
+   *   console.log(accurateAsOf);
+   * }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Use discriminated union to check if referrer is ranked
+   * const response = await client.getReferrerDetail({
+   *   referrer: "0x1234567890123456789012345678901234567890"
+   * });
+   * if (response.responseCode === ReferrerDetailResponseCodes.Ok) {
+   *   if (response.data.type === ReferrerDetailTypeIds.Ranked) {
+   *     // TypeScript knows this is ReferrerDetailRanked
+   *     console.log(`Rank: ${response.data.referrer.rank}`);
+   *     console.log(`Qualified: ${response.data.referrer.isQualified}`);
+   *     console.log(`Award Pool Share: ${response.data.referrer.awardPoolShare * 100}%`);
+   *   } else {
+   *     // TypeScript knows this is ReferrerDetailUnranked
+   *     console.log("Referrer is not on the leaderboard (no referrals yet)");
+   *   }
+   * }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Handle error response, ie. when Referrer Detail is not currently available.
+   * const response = await client.getReferrerDetail({
+   *   referrer: "0x1234567890123456789012345678901234567890"
+   * });
+   *
+   * if (response.responseCode === ReferrerDetailResponseCodes.Error) {
+   *   console.error(response.error);
+   *   console.error(response.errorMessage);
+   * }
+   * ```
+   */
+  async getReferrerDetail(request) {
+    const url = new URL(
+      `/api/ensanalytics/referrers/${encodeURIComponent(request.referrer)}`,
+      this.options.url
+    );
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    return deserializeReferrerDetailResponse(responseData);
+  }
   /**
    * Fetch ENSNode Registrar Actions
    *
-   * @param {RegistrarActionsRequestFilter} request.filter is
-   *        an optional request filter configuration.
-   * @param {number} request.limit sets the maximum count of results in the response.
-   * @param {RegistrarActionsRequestOrder} request.order sets the order of
-   *        results in the response by field and direction.
+   * Retrieves a paginated list of registrar actions with optional filters.
+   *
+   * @param request is a request configuration.
+   * @param request.page sets the page number to retrieve (1-indexed, default: 1)
+   * @param request.recordsPerPage sets the number of records per page (default: 10, max: 100)
+   * @param request.filters is an optional request filter configuration.
+   * @param request.order sets the order of results in the response by field and direction.
    * @returns {RegistrarActionsResponse}
    *
    * @throws if the ENSNode request fails
@@ -2973,23 +3957,25 @@ var ENSNodeClient = class _ENSNodeClient {
    * @example
    * ```ts
    * import {
-   *   registrarActionsFilter,,
+   *   registrarActionsFilter,
    *   ENSNodeClient,
    * } from "@ensnode/ensnode-sdk";
    * import { namehash } from "viem/ens";
    *
    * const client: ENSNodeClient;
    *
-   * // get latest registrar action records across all indexed subregistries
-   * // NOTE: when no `limit` value is passed,
-   * //       the default RESPONSE_ITEMS_PER_PAGE_DEFAULT applies.
-   * const registrarActions = await client.registrarActions();
+   * // Get first page with default page size (10 records)
+   * const response = await client.registrarActions();
+   * if (response.responseCode === RegistrarActionsResponseCodes.Ok) {
+   *   const { registrarActions, pageContext } = response;
+   *   console.log(registrarActions);
+   *   console.log(`Page ${pageContext.page} of ${pageContext.totalPages}`);
+   * }
    *
-   * // get latest 5 registrar action records across all indexed subregistries
-   * // NOTE: when a `limit` value is passed, it must be lower than or equal to
-   * //       the RESPONSE_ITEMS_PER_PAGE_MAX value.
-   * const registrarActions = await client.registrarActions({
-   *   limit: 5,
+   * // Get second page with 25 records per page
+   * const response = await client.registrarActions({
+   *   page: 2,
+   *   recordsPerPage: 25,
    * });
    *
    * // get latest registrar action records associated with
@@ -3003,11 +3989,16 @@ var ENSNodeClient = class _ENSNodeClient {
    *   filters: [registrarActionsFilter.withReferral(true)],
    * });
    *
+   * // get latest registrar action records for a specific decoded referrer
+   * await client.registrarActions({
+   *   filters: [registrarActionsFilter.byDecodedReferrer("0x1234567890123456789012345678901234567890")],
+   * });
+   *
    * // get latest 10 registrar action records associated with
    * // subregistry managing `base.eth` name
    * await client.registrarActions({
    *   filters: [registrarActionsFilter.byParentNode(namehash('base.eth'))],
-   *   limit: 10
+   *   recordsPerPage: 10
    * });
    * ```
    */
@@ -3024,6 +4015,12 @@ var ENSNodeClient = class _ENSNodeClient {
       );
       return withReferralFilter ? { key: "withReferral", value: "true" } : null;
     };
+    const buildDecodedReferrerArg = (filters) => {
+      const decodedReferrerFilter = filters?.find(
+        (f) => f.filterType === RegistrarActionsFilterTypes.ByDecodedReferrer
+      );
+      return decodedReferrerFilter ? { key: "decodedReferrer", value: decodedReferrerFilter.value } : null;
+    };
     const buildOrderArg = (order) => {
       switch (order) {
         case RegistrarActionsOrders.LatestRegistrarActions: {
@@ -3040,13 +4037,20 @@ var ENSNodeClient = class _ENSNodeClient {
       const orderArgs = buildOrderArg(request.order);
       url.searchParams.set(orderArgs.key, orderArgs.value);
     }
-    if (request.itemsPerPage) {
-      url.searchParams.set("itemsPerPage", request.itemsPerPage.toString());
+    if (request.page) {
+      url.searchParams.set("page", request.page.toString());
+    }
+    if (request.recordsPerPage) {
+      url.searchParams.set("recordsPerPage", request.recordsPerPage.toString());
     }
     const referralArg = buildWithReferralArg(request.filters);
     if (referralArg) {
       url.searchParams.set(referralArg.key, referralArg.value);
     }
+    const decodedReferrerArg = buildDecodedReferrerArg(request.filters);
+    if (decodedReferrerArg) {
+      url.searchParams.set(decodedReferrerArg.key, decodedReferrerArg.value);
+    }
     const response = await fetch(url);
     let responseData;
     try {
@@ -3067,6 +4071,62 @@ var ENSNodeClient = class _ENSNodeClient {
     }
     return deserializeRegistrarActionsResponse(responseData);
   }
+  /**
+   * Fetch Name Tokens for requested name.
+   *
+   * @param request.name - Name for which Name Tokens will be fetched.
+   * @returns {NameTokensResponse}
+   *
+   * @throws if the ENSNode request fails
+   * @throws if the ENSNode API returns an error response
+   * @throws if the ENSNode response breaks required invariants
+   *
+   * @example
+   * ```ts
+   * import {
+   *   ENSNodeClient,
+   * } from "@ensnode/ensnode-sdk";
+   * import { namehash } from "viem/ens";
+   *
+   * const client: ENSNodeClient;
+   *
+   * // get latest name token records from the indexed subregistry based on the requested name
+   * const response = await client.nameTokens({
+   *   name: "vitalik.eth"
+   * });
+   *
+   * const response = await client.nameTokens({
+   *   domainId: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835" // namehash('vitalik.eth')
+   * })
+   * ```
+   */
+  async nameTokens(request) {
+    const url = new URL(`/api/name-tokens`, this.options.url);
+    if (request.name !== void 0) {
+      url.searchParams.set("name", request.name);
+    } else {
+      url.searchParams.set("domainId", request.domainId);
+    }
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    if (!response.ok) {
+      let errorResponse;
+      try {
+        errorResponse = deserializeErrorResponse(responseData);
+      } catch {
+        console.log("Name Tokens API: handling a known server error.");
+      }
+      if (typeof errorResponse !== "undefined") {
+        throw new Error(`Fetching ENSNode Name Tokens Failed: ${errorResponse.message}`);
+      }
+    }
+    return deserializedNameTokensResponse(responseData);
+  }
 };
 
 // src/identity/identity.ts
@@ -3106,11 +4166,11 @@ function isResolvedIdentity(identity) {
 }
 
 // src/resolution/ensip19-chainid.ts
-var import_chains2 = require("viem/chains");
+var import_chains = require("viem/chains");
 var import_datasources10 = require("@ensnode/datasources");
 var getResolvePrimaryNameChainIdParam = (chainId, namespaceId) => {
   const ensRootChainId = (0, import_datasources10.getENSRootChainId)(namespaceId);
-  return chainId === ensRootChainId ? import_chains2.mainnet.id : chainId;
+  return chainId === ensRootChainId ? import_chains.mainnet.id : chainId;
 };
 var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
   return chainId === DEFAULT_EVM_CHAIN_ID ? (0, import_datasources10.getENSRootChainId)(namespaceId) : chainId;