@ensnode/ensnode-sdk 1.10.1 → 1.11.0

package/dist/index.cjs

@@ -41,13 +41,14 @@ __export(index_exports, {
   DEFAULT_ENSNODE_URL_SEPOLIA: () => DEFAULT_ENSNODE_URL_SEPOLIA,
   ENCODED_REFERRER_BYTE_LENGTH: () => ENCODED_REFERRER_BYTE_LENGTH,
   ENCODED_REFERRER_BYTE_OFFSET: () => ENCODED_REFERRER_BYTE_OFFSET,
-  ENSNamespaceIds: () => import_datasources13.ENSNamespaceIds,
+  ENSNamespaceIds: () => import_datasources11.ENSNamespaceIds,
   EXPECTED_ENCODED_REFERRER_PADDING: () => EXPECTED_ENCODED_REFERRER_PADDING,
   EnsApiIndexingStatusResponseCodes: () => EnsApiIndexingStatusResponseCodes,
   EnsIndexerClient: () => EnsIndexerClient,
   EnsIndexerIndexingStatusResponseCodes: () => EnsIndexerIndexingStatusResponseCodes,
   EnsNodeClient: () => EnsNodeClient,
   ForwardResolutionProtocolStep: () => ForwardResolutionProtocolStep,
+  IndexingMetadataContextStatusCodes: () => IndexingMetadataContextStatusCodes,
   IndexingStatusResponseCodes: () => IndexingStatusResponseCodes,
   LruCache: () => LruCache,
   NFTMintStatuses: () => NFTMintStatuses,
@@ -82,9 +83,12 @@ __export(index_exports, {
   buildBlockRefRange: () => buildBlockRefRange,
   buildCrossChainIndexingStatusSnapshotOmnichain: () => buildCrossChainIndexingStatusSnapshotOmnichain,
   buildEncodedReferrer: () => buildEncodedReferrer,
+  buildEnsIndexerStackInfo: () => buildEnsIndexerStackInfo,
   buildEnsNodeStackInfo: () => buildEnsNodeStackInfo,
   buildEnsRainbowClientLabelSet: () => buildEnsRainbowClientLabelSet,
   buildIndexedBlockranges: () => buildIndexedBlockranges,
+  buildIndexingMetadataContextInitialized: () => buildIndexingMetadataContextInitialized,
+  buildIndexingMetadataContextUninitialized: () => buildIndexingMetadataContextUninitialized,
   buildLabelSetId: () => buildLabelSetId,
   buildLabelSetVersion: () => buildLabelSetVersion,
   buildOmnichainIndexingStatusSnapshot: () => buildOmnichainIndexingStatusSnapshot,
@@ -93,6 +97,7 @@ __export(index_exports, {
   buildUnvalidatedCrossChainIndexingStatusSnapshot: () => buildUnvalidatedCrossChainIndexingStatusSnapshot,
   buildUnvalidatedEnsApiPublicConfig: () => buildUnvalidatedEnsApiPublicConfig,
   buildUnvalidatedEnsIndexerPublicConfig: () => buildUnvalidatedEnsIndexerPublicConfig,
+  buildUnvalidatedEnsIndexerStackInfo: () => buildUnvalidatedEnsIndexerStackInfo,
   buildUnvalidatedEnsNodeStackInfo: () => buildUnvalidatedEnsNodeStackInfo,
   buildUnvalidatedOmnichainIndexingStatusSnapshot: () => buildUnvalidatedOmnichainIndexingStatusSnapshot,
   buildUnvalidatedRealtimeIndexingStatusProjection: () => buildUnvalidatedRealtimeIndexingStatusProjection,
@@ -117,11 +122,14 @@ __export(index_exports, {
   deserializeEnsIndexerConfigResponse: () => deserializeEnsIndexerConfigResponse,
   deserializeEnsIndexerIndexingStatusResponse: () => deserializeEnsIndexerIndexingStatusResponse,
   deserializeEnsIndexerPublicConfig: () => deserializeEnsIndexerPublicConfig,
+  deserializeEnsIndexerStackInfo: () => deserializeEnsIndexerStackInfo,
   deserializeEnsNodeStackInfo: () => deserializeEnsNodeStackInfo,
   deserializeErrorResponse: () => deserializeErrorResponse2,
+  deserializeIndexingMetadataContext: () => deserializeIndexingMetadataContext,
   deserializeIndexingStatusResponse: () => deserializeIndexingStatusResponse,
   deserializeOmnichainIndexingStatusSnapshot: () => deserializeOmnichainIndexingStatusSnapshot,
   deserializePriceDai: () => deserializePriceDai,
+  deserializePriceEnsTokens: () => deserializePriceEnsTokens,
   deserializePriceEth: () => deserializePriceEth,
   deserializePriceUsdc: () => deserializePriceUsdc,
   deserializeRealtimeIndexingStatusProjection: () => deserializeRealtimeIndexingStatusProjection,
@@ -131,21 +139,17 @@ __export(index_exports, {
   deserializedNameTokensResponse: () => deserializedNameTokensResponse,
   durationBetween: () => durationBetween,
   formatNFTTransferEventMetadata: () => formatNFTTransferEventMetadata,
-  getBasenamesSubregistryId: () => getBasenamesSubregistryId,
-  getBasenamesSubregistryManagedName: () => getBasenamesSubregistryManagedName,
   getCurrencyInfo: () => getCurrencyInfo,
   getDatasourceContract: () => getDatasourceContract,
   getDefaultEnsNodeUrl: () => getDefaultEnsNodeUrl,
   getENSRootChainId: () => import_datasources.getENSRootChainId,
   getENSv1Registry: () => getENSv1Registry,
+  getENSv1RootRegistryId: () => getENSv1RootRegistryId,
   getENSv2RootRegistry: () => getENSv2RootRegistry,
   getENSv2RootRegistryId: () => getENSv2RootRegistryId,
-  getEthnamesSubregistryId: () => getEthnamesSubregistryId,
-  getEthnamesSubregistryManagedName: () => getEthnamesSubregistryManagedName,
   getHighestKnownBlockTimestamp: () => getHighestKnownBlockTimestamp,
   getLatestIndexedBlockRef: () => getLatestIndexedBlockRef,
-  getLineanamesSubregistryId: () => getLineanamesSubregistryId,
-  getLineanamesSubregistryManagedName: () => getLineanamesSubregistryManagedName,
+  getManagedName: () => getManagedName,
   getNFTTransferType: () => getNFTTransferType,
   getNameTokenOwnership: () => getNameTokenOwnership,
   getNameWrapperAccounts: () => getNameWrapperAccounts,
@@ -153,6 +157,8 @@ __export(index_exports, {
   getOmnichainIndexingCursor: () => getOmnichainIndexingCursor,
   getOmnichainIndexingStatus: () => getOmnichainIndexingStatus,
   getResolvePrimaryNameChainIdParam: () => getResolvePrimaryNameChainIdParam,
+  getRootRegistryId: () => getRootRegistryId,
+  getRootRegistryIds: () => getRootRegistryIds,
   getTimestampForHighestOmnichainKnownBlock: () => getTimestampForHighestOmnichainKnownBlock,
   getTimestampForLowestOmnichainStartBlock: () => getTimestampForLowestOmnichainStartBlock,
   hasNullByte: () => hasNullByte,
@@ -171,6 +177,7 @@ __export(index_exports, {
   isENSv1Registry: () => isENSv1Registry,
   isENSv2RootRegistry: () => isENSv2RootRegistry,
   isHttpProtocol: () => isHttpProtocol,
+  isNameWrapper: () => isNameWrapper,
   isPccFuseSet: () => isPccFuseSet,
   isPriceCurrencyEqual: () => isPriceCurrencyEqual,
   isPriceEqual: () => isPriceEqual,
@@ -198,14 +205,17 @@ __export(index_exports, {
   parseAccountId: () => parseAccountId,
   parseAssetId: () => parseAssetId,
   parseDai: () => parseDai,
+  parseEnsTokens: () => parseEnsTokens,
   parseEth: () => parseEth,
   parseNonNegativeInteger: () => parseNonNegativeInteger,
   parseTimestamp: () => parseTimestamp,
   parseUsdc: () => parseUsdc,
   priceDai: () => priceDai,
+  priceEnsTokens: () => priceEnsTokens,
   priceEth: () => priceEth,
   priceUsdc: () => priceUsdc,
   registrarActionsFilter: () => registrarActionsFilter,
+  replaceBigInts: () => replaceBigInts,
   scaleBigintByNumber: () => scaleBigintByNumber,
   scalePrice: () => scalePrice,
   serializeAssetId: () => serializeAssetId,
@@ -222,8 +232,11 @@ __export(index_exports, {
   serializeEnsIndexerConfigResponse: () => serializeEnsIndexerConfigResponse,
   serializeEnsIndexerIndexingStatusResponse: () => serializeEnsIndexerIndexingStatusResponse,
   serializeEnsIndexerPublicConfig: () => serializeEnsIndexerPublicConfig,
+  serializeEnsIndexerStackInfo: () => serializeEnsIndexerStackInfo,
   serializeEnsNodeStackInfo: () => serializeEnsNodeStackInfo,
   serializeIndexedChainIds: () => serializeIndexedChainIds,
+  serializeIndexingMetadataContext: () => serializeIndexingMetadataContext,
+  serializeIndexingMetadataContextInitialized: () => serializeIndexingMetadataContextInitialized,
   serializeIndexingStatusResponse: () => serializeIndexingStatusResponse,
   serializeNameToken: () => serializeNameToken,
   serializeNameTokensResponse: () => serializeNameTokensResponse,
@@ -231,6 +244,7 @@ __export(index_exports, {
   serializeOmnichainIndexingStatusSnapshot: () => serializeOmnichainIndexingStatusSnapshot,
   serializePrice: () => serializePrice,
   serializePriceDai: () => serializePriceDai,
+  serializePriceEnsTokens: () => serializePriceEnsTokens,
   serializePriceEth: () => serializePriceEth,
   serializePriceUsdc: () => serializePriceUsdc,
   serializeRealtimeIndexingStatusProjection: () => serializeRealtimeIndexingStatusProjection,
@@ -242,19 +256,23 @@ __export(index_exports, {
   sortChainStatusesByStartBlockAsc: () => sortChainStatusesByStartBlockAsc,
   stripNullBytes: () => stripNullBytes,
   subtractPrice: () => subtractPrice,
+  toJson: () => toJson,
   translateDefaultableChainIdToChainId: () => translateDefaultableChainIdToChainId,
   uniq: () => uniq,
   validateChainIndexingStatusSnapshot: () => validateChainIndexingStatusSnapshot,
   validateCrossChainIndexingStatusSnapshot: () => validateCrossChainIndexingStatusSnapshot,
   validateEnsIndexerPublicConfig: () => validateEnsIndexerPublicConfig,
   validateEnsIndexerPublicConfigCompatibility: () => validateEnsIndexerPublicConfigCompatibility,
+  validateEnsIndexerStackInfo: () => validateEnsIndexerStackInfo,
   validateEnsIndexerVersionInfo: () => validateEnsIndexerVersionInfo,
+  validateEnsNodeStackInfo: () => validateEnsNodeStackInfo,
+  validateIndexingMetadataContextInitialized: () => validateIndexingMetadataContextInitialized,
   validateOmnichainIndexingStatusSnapshot: () => validateOmnichainIndexingStatusSnapshot,
   validateRealtimeIndexingStatusProjection: () => validateRealtimeIndexingStatusProjection,
   validateSupportedLabelSetAndVersion: () => validateSupportedLabelSetAndVersion
 });
 module.exports = __toCommonJS(index_exports);
-var import_datasources13 = require("@ensnode/datasources");
+var import_datasources11 = require("@ensnode/datasources");
 
 // src/ens/index.ts
 var import_datasources = require("@ensnode/datasources");
@@ -331,7 +349,8 @@ function scaleBigintByNumber(value, scaleFactor) {
 var CurrencyIds = {
   ETH: "ETH",
   USDC: "USDC",
-  DAI: "DAI"
+  DAI: "DAI",
+  ENSTokens: "ENSTokens"
 };
 var currencyInfo = {
   [CurrencyIds.ETH]: {
@@ -348,6 +367,11 @@ var currencyInfo = {
     id: CurrencyIds.DAI,
     name: "Dai Stablecoin",
     decimals: 18
+  },
+  [CurrencyIds.ENSTokens]: {
+    id: CurrencyIds.ENSTokens,
+    name: "$ENS Tokens",
+    decimals: 18
   }
 };
 function getCurrencyInfo(currencyId) {
@@ -371,6 +395,12 @@ function priceDai(amount) {
     currency: CurrencyIds.DAI
   };
 }
+function priceEnsTokens(amount) {
+  return {
+    amount,
+    currency: CurrencyIds.ENSTokens
+  };
+}
 function isPriceCurrencyEqual(priceA, priceB) {
   return priceA.currency === priceB.currency;
 }
@@ -458,6 +488,12 @@ function parseDai(value) {
   const amount = (0, import_viem.parseUnits)(value, currencyInfo2.decimals);
   return priceDai(amount);
 }
+function parseEnsTokens(value) {
+  validateAmountToParse(value);
+  const currencyInfo2 = getCurrencyInfo(CurrencyIds.ENSTokens);
+  const amount = (0, import_viem.parseUnits)(value, currencyInfo2.decimals);
+  return priceEnsTokens(amount);
+}
 
 // src/shared/zod-schemas.ts
 var makeIntegerSchema = (valueLabel = "Value") => import_v4.z.int({
@@ -518,6 +554,7 @@ var makePriceCurrencySchema = (currency, valueLabel = "Price Currency") => impor
 var makePriceEthSchema = (valueLabel = "Price ETH") => makePriceCurrencySchema(CurrencyIds.ETH, valueLabel).transform((v) => v);
 var makePriceUsdcSchema = (valueLabel = "Price USDC") => makePriceCurrencySchema(CurrencyIds.USDC, valueLabel).transform((v) => v);
 var makePriceDaiSchema = (valueLabel = "Price DAI") => makePriceCurrencySchema(CurrencyIds.DAI, valueLabel).transform((v) => v);
+var makePriceEnsTokensSchema = (valueLabel = "Price ENSTokens") => makePriceCurrencySchema(CurrencyIds.ENSTokens, valueLabel).transform((v) => v);
 var makeAccountIdSchema = (valueLabel = "AccountId") => import_v4.z.strictObject({
   chainId: makeChainIdSchema(`${valueLabel} chain ID`),
   address: makeNormalizedAddressSchema(`${valueLabel} address`)
@@ -572,14 +609,15 @@ var makeLabelSetIdSchema = (valueLabel = "Label set ID") => {
 var makeLabelSetVersionSchema = (valueLabel = "Label set version") => makeNonNegativeIntegerSchema(valueLabel);
 var makeLabelSetVersionStringSchema = (valueLabel = "Label set version") => import_v42.z.coerce.number({ error: `${valueLabel} must be a non-negative integer` }).pipe(makeLabelSetVersionSchema(valueLabel));
 var makeEnsRainbowPublicConfigSchema = (valueLabel = "EnsRainbowPublicConfig") => import_v42.z.object({
-  version: import_v42.z.string().nonempty({ error: `${valueLabel}.version must be a non-empty string.` }),
-  labelSet: import_v42.z.object({
-    labelSetId: makeLabelSetIdSchema(`${valueLabel}.labelSet.labelSetId`),
+  serverLabelSet: import_v42.z.object({
+    labelSetId: makeLabelSetIdSchema(`${valueLabel}.serverLabelSet.labelSetId`),
     highestLabelSetVersion: makeLabelSetVersionSchema(
-      `${valueLabel}.labelSet.highestLabelSetVersion`
+      `${valueLabel}.serverLabelSet.highestLabelSetVersion`
     )
   }),
-  recordsCount: makeNonNegativeIntegerSchema(`${valueLabel}.recordsCount`)
+  versionInfo: import_v42.z.object({
+    ensRainbow: import_v42.z.string().nonempty({ error: `${valueLabel}.versionInfo.ensRainbow must be a non-empty string.` })
+  })
 });
 
 // src/shared/collections.ts
@@ -604,8 +642,8 @@ var PluginName = /* @__PURE__ */ ((PluginName2) => {
 // 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 isSubgraphLabelSet = config.clientLabelSet.labelSetId === "subgraph" && config.clientLabelSet.labelSetVersion === 0;
+  const isEnsTestEnvLabelSet = config.clientLabelSet.labelSetId === "ens-test-env" && config.clientLabelSet.labelSetVersion === 0;
   const labelSetIsSubgraphCompatible = isSubgraphLabelSet || config.namespace === import_datasources2.ENSNamespaceIds.EnsTestEnv && isEnsTestEnvLabelSet;
   return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
 }
@@ -703,13 +741,13 @@ function invariant_isSubgraphCompatibleRequirements(ctx) {
     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}`
+      message: `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active and 'clientLabelSet' must be {labelSetId: "subgraph", labelSetVersion: 0}`
     });
   }
 }
 function invariant_ensRainbowSupportedLabelSetAndVersion(ctx) {
-  const clientLabelSet = ctx.value.labelSet;
-  const serverLabelSet = ctx.value.ensRainbowPublicConfig.labelSet;
+  const { clientLabelSet } = ctx.value;
+  const { serverLabelSet } = ctx.value.ensRainbowPublicConfig;
   try {
     validateSupportedLabelSetAndVersion(serverLabelSet, clientLabelSet);
   } catch (error) {
@@ -730,7 +768,7 @@ var makeEnsIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") =
   isSubgraphCompatible: import_v43.z.boolean({
     error: `${valueLabel}.isSubgraphCompatible must be a boolean value.`
   }),
-  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
+  clientLabelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.clientLabelSet`),
   namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
   plugins: makePluginsListSchema(`${valueLabel}.plugins`),
   versionInfo: makeEnsIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
@@ -744,7 +782,7 @@ var makeSerializedEnsIndexerPublicConfigSchema = (valueLabel = "Serialized ENSIn
   isSubgraphCompatible: import_v43.z.boolean({
     error: `${valueLabel}.isSubgraphCompatible must be a boolean value.`
   }),
-  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
+  clientLabelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.clientLabelSet`),
   namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
   plugins: makePluginsListSchema(`${valueLabel}.plugins`),
   versionInfo: makeEnsIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
@@ -844,7 +882,7 @@ function serializeEnsIndexerPublicConfig(config) {
     ensRainbowPublicConfig,
     indexedChainIds,
     isSubgraphCompatible: isSubgraphCompatible2,
-    labelSet,
+    clientLabelSet,
     namespace,
     plugins,
     versionInfo
@@ -854,7 +892,7 @@ function serializeEnsIndexerPublicConfig(config) {
     ensRainbowPublicConfig,
     indexedChainIds: serializeIndexedChainIds(indexedChainIds),
     isSubgraphCompatible: isSubgraphCompatible2,
-    labelSet,
+    clientLabelSet,
     namespace,
     plugins,
     versionInfo
@@ -1893,6 +1931,9 @@ function serializePriceUsdc(price) {
 function serializePriceDai(price) {
   return serializePrice(price);
 }
+function serializePriceEnsTokens(price) {
+  return serializePrice(price);
+}
 
 // src/indexing-status/serialize/chain-indexing-status-snapshot.ts
 function serializeChainIndexingSnapshots(chains) {
@@ -2099,21 +2140,21 @@ function validateEnsIndexerPublicConfigCompatibility(configA, configB) {
       ].join(" ")
     );
   }
-  if (configA.labelSet.labelSetId !== configB.labelSet.labelSetId) {
+  if (configA.clientLabelSet.labelSetId !== configB.clientLabelSet.labelSetId) {
     throw new Error(
       [
-        `'labelSet.labelSetId' must be compatible.`,
-        `Stored Config 'labelSet.labelSetId': '${configA.labelSet.labelSetId}'.`,
-        `Current Config 'labelSet.labelSetId': '${configB.labelSet.labelSetId}'.`
+        `'clientLabelSet.labelSetId' must be compatible.`,
+        `Stored Config 'clientLabelSet.labelSetId': '${configA.clientLabelSet.labelSetId}'.`,
+        `Current Config 'clientLabelSet.labelSetId': '${configB.clientLabelSet.labelSetId}'.`
       ].join(" ")
     );
   }
-  if (configA.labelSet.labelSetVersion !== configB.labelSet.labelSetVersion) {
+  if (configA.clientLabelSet.labelSetVersion !== configB.clientLabelSet.labelSetVersion) {
     throw new Error(
       [
-        `'labelSet.labelSetVersion' must be compatible.`,
-        `Stored Config 'labelSet.labelSetVersion': '${configA.labelSet.labelSetVersion}'.`,
-        `Current Config 'labelSet.labelSetVersion': '${configB.labelSet.labelSetVersion}'.`
+        `'clientLabelSet.labelSetVersion' must be compatible.`,
+        `Stored Config 'clientLabelSet.labelSetVersion': '${configA.clientLabelSet.labelSetVersion}'.`,
+        `Current Config 'clientLabelSet.labelSetVersion': '${configB.clientLabelSet.labelSetVersion}'.`
       ].join(" ")
     );
   }
@@ -2204,12 +2245,12 @@ function validateEnsIndexerVersionInfo(unvalidatedVersionInfo) {
 }
 
 // src/ensnode/api/indexing-status/deserialize.ts
-var import_v427 = require("zod/v4");
+var import_v428 = require("zod/v4");
 
 // src/stack-info/deserialize/ensnode-stack-info.ts
-var import_v425 = require("zod/v4");
+var import_v426 = require("zod/v4");
 
-// src/stack-info/zod-schemas/ensnode-stack-info.ts
+// src/stack-info/zod-schemas/ensindexer-stack-info.ts
 var import_v424 = require("zod/v4");
 
 // src/ensdb/zod-schemas/config.ts
@@ -2218,49 +2259,134 @@ var makeEnsDbVersionInfoSchema = (valueLabel) => {
   const label = valueLabel ?? "EnsDbVersionInfo";
   return import_v423.z.object({
     postgresql: import_v423.z.string().nonempty(`${label}.postgresql must be a non-empty string`).describe("Version of the PostgreSQL server hosting the ENSDb instance.")
-  }).describe(label);
+  });
 };
 var makeEnsDbPublicConfigSchema = (valueLabel) => {
   const label = valueLabel ?? "EnsDbPublicConfig";
   return import_v423.z.object({
     versionInfo: makeEnsDbVersionInfoSchema(`${label}.versionInfo`)
-  }).describe(label);
+  });
 };
 
-// src/stack-info/zod-schemas/ensnode-stack-info.ts
-function makeSerializedEnsNodeStackInfoSchema(valueLabel) {
-  const label = valueLabel ?? "ENSNodeStackInfo";
+// src/stack-info/zod-schemas/ensindexer-stack-info.ts
+function makeSerializedEnsIndexerStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSIndexerStackInfo";
   return import_v424.z.object({
-    ensApi: makeSerializedEnsApiPublicConfigSchema(`${label}.ensApi`),
     ensDb: makeEnsDbPublicConfigSchema(`${label}.ensDb`),
     ensIndexer: makeSerializedEnsIndexerPublicConfigSchema(`${label}.ensIndexer`),
-    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`).optional()
+    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`)
   });
 }
-function makeEnsNodeStackInfoSchema(valueLabel) {
-  const label = valueLabel ?? "ENSNodeStackInfo";
+function invariant_ensRainbowCompatibilityWithEnsIndexer(ctx) {
+  const { ensIndexer, ensRainbow } = ctx.value;
+  const { clientLabelSet } = ensIndexer;
+  const { serverLabelSet } = ensRainbow;
+  if (clientLabelSet.labelSetId !== serverLabelSet.labelSetId) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `ENSRainbow's label set (id: ${serverLabelSet.labelSetId}) must be the same as ENSIndexer's label set (id: ${clientLabelSet.labelSetId}).`
+    });
+  }
+  if (clientLabelSet.labelSetVersion > serverLabelSet.highestLabelSetVersion) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `ENSRainbow's server label set version (highest: ${serverLabelSet.highestLabelSetVersion}) must be greater than or equal to ENSIndexer's client label set version (current: ${clientLabelSet.labelSetVersion}).`
+    });
+  }
+}
+function makeEnsIndexerStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSIndexerStackInfo";
   return import_v424.z.object({
-    ensApi: makeEnsApiPublicConfigSchema(`${label}.ensApi`),
     ensDb: makeEnsDbPublicConfigSchema(`${label}.ensDb`),
     ensIndexer: makeEnsIndexerPublicConfigSchema(`${label}.ensIndexer`),
-    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`).optional()
+    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`)
+  }).check(invariant_ensRainbowCompatibilityWithEnsIndexer);
+}
+
+// src/stack-info/zod-schemas/ensnode-stack-info.ts
+function invariant_ensApiCompatibilityWithEnsIndexerAndEnsRainbow(ctx) {
+  const { ensApi, ensIndexer, ensRainbow } = ctx.value;
+  if (ensIndexer.versionInfo.ensDb !== ensApi.versionInfo.ensApi) {
+    ctx.issues.push({
+      code: "custom",
+      path: ["ensIndexer", "versionInfo", "ensDb"],
+      input: ensIndexer.versionInfo.ensDb,
+      message: `Version Mismatch: ENSDB@${ensIndexer.versionInfo.ensDb} !== ENSApi@${ensApi.versionInfo.ensApi}`
+    });
+  }
+  if (ensIndexer.versionInfo.ensIndexer !== ensApi.versionInfo.ensApi) {
+    ctx.issues.push({
+      code: "custom",
+      path: ["ensIndexer", "versionInfo", "ensIndexer"],
+      input: ensIndexer.versionInfo.ensIndexer,
+      message: `Version Mismatch: ENSIndexer@${ensIndexer.versionInfo.ensIndexer} !== ENSApi@${ensApi.versionInfo.ensApi}`
+    });
+  }
+  if (ensRainbow.versionInfo.ensRainbow !== ensApi.versionInfo.ensApi) {
+    ctx.issues.push({
+      code: "custom",
+      path: ["ensRainbow", "versionInfo", "ensRainbow"],
+      input: ensRainbow.versionInfo.ensRainbow,
+      message: `Version Mismatch: ENSRainbow@${ensRainbow.versionInfo.ensRainbow} !== ENSApi@${ensApi.versionInfo.ensApi}`
+    });
+  }
+  if (ensIndexer.versionInfo.ensNormalize !== ensApi.versionInfo.ensNormalize) {
+    ctx.issues.push({
+      code: "custom",
+      path: ["ensIndexer", "versionInfo", "ensNormalize"],
+      input: ensIndexer.versionInfo.ensNormalize,
+      message: `Dependency Version Mismatch: '@adraffy/ens-normalize' version must be the same between ENSIndexer and ENSApi. Found ENSApi@${ensApi.versionInfo.ensNormalize} and ENSIndexer@${ensIndexer.versionInfo.ensNormalize}`
+    });
+  }
+}
+function makeSerializedEnsNodeStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSNodeStackInfo";
+  return makeSerializedEnsIndexerStackInfoSchema(label).extend({
+    ensApi: makeSerializedEnsApiPublicConfigSchema(`${label}.ensApi`)
   });
 }
+function makeEnsNodeStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSNodeStackInfo";
+  return makeEnsIndexerStackInfoSchema(label).extend({
+    ensApi: makeEnsApiPublicConfigSchema(`${label}.ensApi`)
+  }).check(invariant_ensApiCompatibilityWithEnsIndexerAndEnsRainbow).check(invariant_ensRainbowCompatibilityWithEnsIndexer);
+}
+
+// src/stack-info/deserialize/ensindexer-stack-info.ts
+var import_v425 = require("zod/v4");
+function buildUnvalidatedEnsIndexerStackInfo(serializedStackInfo) {
+  const { ensDb, ensRainbow } = serializedStackInfo;
+  const ensIndexer = buildUnvalidatedEnsIndexerPublicConfig(serializedStackInfo.ensIndexer);
+  return {
+    ensDb,
+    ensIndexer,
+    ensRainbow
+  };
+}
+function deserializeEnsIndexerStackInfo(maybeStackInfo, valueLabel) {
+  const parsed = makeSerializedEnsIndexerStackInfoSchema(valueLabel).transform(buildUnvalidatedEnsIndexerStackInfo).pipe(makeEnsIndexerStackInfoSchema(valueLabel)).safeParse(maybeStackInfo);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize EnsIndexerStackInfo:
+${(0, import_v425.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
 
 // src/stack-info/deserialize/ensnode-stack-info.ts
 function buildUnvalidatedEnsNodeStackInfo(serializedStackInfo) {
-  const { ensApi, ensIndexer, ...rest } = serializedStackInfo;
   return {
-    ...rest,
-    ensApi: buildUnvalidatedEnsApiPublicConfig(ensApi),
-    ensIndexer: buildUnvalidatedEnsIndexerPublicConfig(ensIndexer)
+    ...buildUnvalidatedEnsIndexerStackInfo(serializedStackInfo),
+    ensApi: buildUnvalidatedEnsApiPublicConfig(serializedStackInfo.ensApi)
   };
 }
 function deserializeEnsNodeStackInfo(maybeStackInfo, valueLabel) {
   const parsed = makeSerializedEnsNodeStackInfoSchema(valueLabel).transform(buildUnvalidatedEnsNodeStackInfo).pipe(makeEnsNodeStackInfoSchema(valueLabel)).safeParse(maybeStackInfo);
   if (parsed.error) {
     throw new Error(`Cannot deserialize EnsNodeStackInfo:
-${(0, import_v425.prettifyError)(parsed.error)}
+${(0, import_v426.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2280,25 +2406,25 @@ var EnsApiIndexingStatusResponseCodes = {
 var IndexingStatusResponseCodes = EnsApiIndexingStatusResponseCodes;
 
 // src/ensnode/api/indexing-status/zod-schemas.ts
-var import_v426 = require("zod/v4");
-var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v426.z.strictObject({
-  responseCode: import_v426.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
+var import_v427 = require("zod/v4");
+var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v427.z.strictObject({
+  responseCode: import_v427.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel),
   stackInfo: makeEnsNodeStackInfoSchema(valueLabel)
 });
-var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v426.z.strictObject({
-  responseCode: import_v426.z.literal(EnsApiIndexingStatusResponseCodes.Error)
+var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v427.z.strictObject({
+  responseCode: import_v427.z.literal(EnsApiIndexingStatusResponseCodes.Error)
 });
-var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v426.z.discriminatedUnion("responseCode", [
+var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v427.z.discriminatedUnion("responseCode", [
   makeEnsApiIndexingStatusResponseOkSchema(valueLabel),
   makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
 ]);
-var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v426.z.object({
-  responseCode: import_v426.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
+var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v427.z.object({
+  responseCode: import_v427.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel),
   stackInfo: makeSerializedEnsNodeStackInfoSchema(valueLabel)
 });
-var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v426.z.discriminatedUnion("responseCode", [
+var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v427.z.discriminatedUnion("responseCode", [
   makeSerializedEnsApiIndexingStatusResponseOkSchema(valueLabel),
   makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
 ]);
@@ -2320,7 +2446,7 @@ function deserializeEnsApiIndexingStatusResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize EnsApiIndexingStatusResponse:
-${(0, import_v427.prettifyError)(parsed.error)}
+${(0, import_v428.prettifyError)(parsed.error)}
 `
     );
   }
@@ -2328,13 +2454,26 @@ ${(0, import_v427.prettifyError)(parsed.error)}
 }
 var deserializeIndexingStatusResponse = deserializeEnsApiIndexingStatusResponse;
 
+// src/stack-info/serialize/ensindexer-stack-info.ts
+function serializeEnsIndexerStackInfo(stackInfo) {
+  const {
+    ensDb: serializedEnsDbPublicConfig,
+    ensRainbow: serializedEnsRainbowPublicConfig,
+    ensIndexer
+  } = stackInfo;
+  const serializedEnsIndexerPublicConfig = serializeEnsIndexerPublicConfig(ensIndexer);
+  return {
+    ensDb: serializedEnsDbPublicConfig,
+    ensIndexer: serializedEnsIndexerPublicConfig,
+    ensRainbow: serializedEnsRainbowPublicConfig
+  };
+}
+
 // src/stack-info/serialize/ensnode-stack-info.ts
 function serializeEnsNodeStackInfo(stackInfo) {
   return {
-    ensApi: serializeEnsApiPublicConfig(stackInfo.ensApi),
-    ensDb: stackInfo.ensDb,
-    ensIndexer: serializeEnsIndexerPublicConfig(stackInfo.ensIndexer),
-    ensRainbow: stackInfo.ensRainbow
+    ...serializeEnsIndexerStackInfo(stackInfo),
+    ensApi: serializeEnsApiPublicConfig(stackInfo.ensApi)
   };
 }
 
@@ -2354,11 +2493,11 @@ function serializeEnsApiIndexingStatusResponse(response) {
 var serializeIndexingStatusResponse = serializeEnsApiIndexingStatusResponse;
 
 // src/ensnode/api/name-tokens/deserialize.ts
-var import_v432 = require("zod/v4");
+var import_v433 = require("zod/v4");
 
 // src/ensnode/api/name-tokens/zod-schemas.ts
 var import_enssdk5 = require("enssdk");
-var import_v431 = require("zod/v4");
+var import_v432 = require("zod/v4");
 
 // src/tokenscope/name-token.ts
 var import_enssdk4 = require("enssdk");
@@ -2400,17 +2539,17 @@ var makeContractMatcher = (namespace, b) => (datasourceName, contractName) => {
 // src/tokenscope/assets.ts
 var import_enssdk3 = require("enssdk");
 var import_viem6 = require("viem");
-var import_v429 = require("zod/v4");
+var import_v430 = require("zod/v4");
 
 // src/tokenscope/zod-schemas.ts
 var import_caip2 = require("caip");
 var import_enssdk2 = require("enssdk");
 var import_viem5 = require("viem");
-var import_v428 = require("zod/v4");
-var tokenIdSchemaSerializable = import_v428.z.string();
-var tokenIdSchemaNative = import_v428.z.preprocess(
+var import_v429 = require("zod/v4");
+var tokenIdSchemaSerializable = import_v429.z.string();
+var tokenIdSchemaNative = import_v429.z.preprocess(
   (v) => typeof v === "string" ? BigInt(v) : v,
-  import_v428.z.bigint().positive()
+  import_v429.z.bigint().positive()
 );
 function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false) {
   if (serializable) {
@@ -2420,13 +2559,13 @@ function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false
   }
 }
 var makeAssetIdSchema = (valueLabel = "Asset ID Schema", serializable) => {
-  return import_v428.z.object({
-    assetNamespace: import_v428.z.enum(import_enssdk2.AssetNamespaces),
+  return import_v429.z.object({
+    assetNamespace: import_v429.z.enum(import_enssdk2.AssetNamespaces),
     contract: makeAccountIdSchema(valueLabel),
     tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
   });
 };
-var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v428.z.preprocess((v) => {
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v429.z.preprocess((v) => {
   if (typeof v === "string") {
     const result = new import_caip2.AssetId(v);
     return {
@@ -2450,20 +2589,20 @@ function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v428.z.object({
-  ownershipType: import_v428.z.literal(NameTokenOwnershipTypes.NameWrapper),
+var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v429.z.object({
+  ownershipType: import_v429.z.literal(NameTokenOwnershipTypes.NameWrapper),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v428.z.object({
-  ownershipType: import_v428.z.literal(NameTokenOwnershipTypes.FullyOnchain),
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v429.z.object({
+  ownershipType: import_v429.z.literal(NameTokenOwnershipTypes.FullyOnchain),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v428.z.object({
-  ownershipType: import_v428.z.literal(NameTokenOwnershipTypes.Burned),
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v429.z.object({
+  ownershipType: import_v429.z.literal(NameTokenOwnershipTypes.Burned),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
-var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v428.z.object({
-  ownershipType: import_v428.z.literal(NameTokenOwnershipTypes.Unknown),
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v429.z.object({
+  ownershipType: import_v429.z.literal(NameTokenOwnershipTypes.Unknown),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
 function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
@@ -2476,16 +2615,16 @@ function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v428.z.discriminatedUnion("ownershipType", [
+var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v429.z.discriminatedUnion("ownershipType", [
   makeNameTokenOwnershipNameWrapperSchema(valueLabel),
   makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
   makeNameTokenOwnershipBurnedSchema(valueLabel),
   makeNameTokenOwnershipUnknownSchema(valueLabel)
 ]);
-var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v428.z.object({
+var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v429.z.object({
   token: makeAssetIdSchema(`${valueLabel}.token`, serializable),
   ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
-  mintStatus: import_v428.z.enum(NFTMintStatuses)
+  mintStatus: import_v429.z.enum(NFTMintStatuses)
 });
 
 // src/tokenscope/assets.ts
@@ -2501,7 +2640,7 @@ function deserializeAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AssetId:
-${(0, import_v429.prettifyError)(parsed.error)}
+${(0, import_v430.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2511,7 +2650,7 @@ function parseAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot parse AssetId:
-${(0, import_v429.prettifyError)(parsed.error)}
+${(0, import_v430.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2812,10 +2951,10 @@ function getNameTokenOwnership(namespaceId, name, owner) {
 }
 
 // src/ensnode/api/shared/errors/zod-schemas.ts
-var import_v430 = require("zod/v4");
-var makeErrorResponseSchema = () => import_v430.z.object({
-  message: import_v430.z.string(),
-  details: import_v430.z.optional(import_v430.z.unknown())
+var import_v431 = require("zod/v4");
+var makeErrorResponseSchema = () => import_v431.z.object({
+  message: import_v431.z.string(),
+  details: import_v431.z.optional(import_v431.z.unknown())
 });
 
 // src/ensnode/api/name-tokens/response.ts
@@ -2854,10 +2993,10 @@ var NameTokensResponseErrorCodes = {
 };
 
 // src/ensnode/api/name-tokens/zod-schemas.ts
-var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v431.z.object({
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v432.z.object({
   domainId: makeNodeSchema(`${valueLabel}.domainId`),
   name: makeReinterpretedNameSchema(valueLabel),
-  tokens: import_v431.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
+  tokens: import_v432.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
   expiresAt: makeUnixTimestampSchema(`${valueLabel}.expiresAt`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 }).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
@@ -2899,32 +3038,32 @@ var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", seria
     });
   }
 });
-var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v431.z.strictObject({
-  responseCode: import_v431.z.literal(NameTokensResponseCodes.Ok),
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v432.z.strictObject({
+  responseCode: import_v432.z.literal(NameTokensResponseCodes.Ok),
   registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`, serializable)
 });
-var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v431.z.strictObject({
-  responseCode: import_v431.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v431.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v432.z.strictObject({
+  responseCode: import_v432.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v432.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
   error: makeErrorResponseSchema()
 });
-var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v431.z.strictObject({
-  responseCode: import_v431.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v431.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v432.z.strictObject({
+  responseCode: import_v432.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v432.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
   error: makeErrorResponseSchema()
 });
-var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v431.z.strictObject({
-  responseCode: import_v431.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v431.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v432.z.strictObject({
+  responseCode: import_v432.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v432.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
   error: makeErrorResponseSchema()
 });
-var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v431.z.discriminatedUnion("errorCode", [
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v432.z.discriminatedUnion("errorCode", [
   makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
   makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
   makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
 ]);
 var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response", serializable) => {
-  return import_v431.z.discriminatedUnion("responseCode", [
+  return import_v432.z.discriminatedUnion("responseCode", [
     makeNameTokensResponseOkSchema(valueLabel, serializable ?? false),
     makeNameTokensResponseErrorSchema(valueLabel)
   ]);
@@ -2937,7 +3076,7 @@ function deserializedNameTokensResponse(maybeResponse) {
   );
   if (parsed.error) {
     throw new Error(`Cannot deserialize NameTokensResponse:
-${(0, import_v432.prettifyError)(parsed.error)}
+${(0, import_v433.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -3011,14 +3150,14 @@ function serializeNameTokensResponse(response) {
 }
 
 // src/ensnode/api/registrar-actions/deserialize.ts
-var import_v436 = require("zod/v4");
+var import_v437 = require("zod/v4");
 
 // src/ensnode/api/registrar-actions/zod-schemas.ts
 var import_enssdk7 = require("enssdk");
-var import_v435 = require("zod/v4");
+var import_v436 = require("zod/v4");
 
 // src/registrars/zod-schemas.ts
-var import_v433 = require("zod/v4");
+var import_v434 = require("zod/v4");
 
 // src/registrars/encoded-referrer.ts
 var import_enssdk6 = require("enssdk");
@@ -3092,11 +3231,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v433.z.object({
+var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v434.z.object({
   subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
   node: makeNodeSchema(`${valueLabel} Node`)
 });
-var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v433.z.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v434.z.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -3112,18 +3251,18 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v433.z.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v434.z.union([
   // pricing available
-  import_v433.z.object({
+  import_v434.z.object({
     baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
     premium: makePriceEthSchema(`${valueLabel} Premium`),
     total: makePriceEthSchema(`${valueLabel} Total`)
   }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
   // pricing unknown
-  import_v433.z.object({
-    baseCost: import_v433.z.null(),
-    premium: import_v433.z.null(),
-    total: import_v433.z.null()
+  import_v434.z.object({
+    baseCost: import_v434.z.null(),
+    premium: import_v434.z.null(),
+    total: import_v434.z.null()
   }).transform((v) => v)
 ]);
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
@@ -3146,9 +3285,9 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
     });
   }
 }
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v433.z.union([
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v434.z.union([
   // referral available
-  import_v433.z.object({
+  import_v434.z.object({
     encodedReferrer: makeHexStringSchema(
       { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
       `${valueLabel} Encoded Referrer`
@@ -3156,9 +3295,9 @@ var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral
     decodedReferrer: makeNormalizedAddressSchema(`${valueLabel} Decoded Referrer`)
   }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
   // referral not applicable
-  import_v433.z.object({
-    encodedReferrer: import_v433.z.null(),
-    decodedReferrer: import_v433.z.null()
+  import_v434.z.object({
+    encodedReferrer: import_v434.z.null(),
+    decodedReferrer: import_v434.z.null()
   })
 ]);
 function invariant_eventIdsInitialElementIsTheActionId(ctx) {
@@ -3171,9 +3310,9 @@ function invariant_eventIdsInitialElementIsTheActionId(ctx) {
     });
   }
 }
-var EventIdSchema = import_v433.z.string().nonempty();
-var EventIdsSchema = import_v433.z.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchemaWithoutCheck = (valueLabel = "Base Registrar Action") => import_v433.z.object({
+var EventIdSchema = import_v434.z.string().nonempty();
+var EventIdsSchema = import_v434.z.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchemaWithoutCheck = (valueLabel = "Base Registrar Action") => import_v434.z.object({
   id: EventIdSchema,
   incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
   registrant: makeNormalizedAddressSchema(`${valueLabel} Registrant`),
@@ -3188,36 +3327,36 @@ var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => ma
   invariant_eventIdsInitialElementIsTheActionId
 );
 var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v433.z.literal(RegistrarActionTypes.Registration)
+  type: import_v434.z.literal(RegistrarActionTypes.Registration)
 });
 var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v433.z.literal(RegistrarActionTypes.Renewal)
+  type: import_v434.z.literal(RegistrarActionTypes.Renewal)
 });
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v433.z.discriminatedUnion("type", [
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v434.z.discriminatedUnion("type", [
   makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
   makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
 ]);
 
 // src/ensnode/api/shared/pagination/zod-schemas.ts
-var import_v434 = require("zod/v4");
+var import_v435 = require("zod/v4");
 
 // src/ensnode/api/shared/pagination/request.ts
 var RECORDS_PER_PAGE_DEFAULT = 10;
 var RECORDS_PER_PAGE_MAX = 100;
 
 // src/ensnode/api/shared/pagination/zod-schemas.ts
-var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v434.z.object({
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v435.z.object({
   page: makePositiveIntegerSchema(`${valueLabel}.page`),
   recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
     RECORDS_PER_PAGE_MAX,
     `${valueLabel}.recordsPerPage must not exceed ${RECORDS_PER_PAGE_MAX}`
   )
 });
-var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v434.z.object({
-  totalRecords: import_v434.z.literal(0),
-  totalPages: import_v434.z.literal(1),
-  hasNext: import_v434.z.literal(false),
-  hasPrev: import_v434.z.literal(false)
+var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v435.z.object({
+  totalRecords: import_v435.z.literal(0),
+  totalPages: import_v435.z.literal(1),
+  hasNext: import_v435.z.literal(false),
+  hasPrev: import_v435.z.literal(false)
 }).extend(makeRequestPageParamsSchema(valueLabel).shape);
 function invariant_responsePageWithRecordsIsCorrect(ctx) {
   const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
@@ -3252,15 +3391,15 @@ function invariant_responsePageWithRecordsIsCorrect(ctx) {
     });
   }
 }
-var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v434.z.object({
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v435.z.object({
   totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: import_v434.z.boolean(),
-  hasPrev: import_v434.z.boolean(),
+  hasNext: import_v435.z.boolean(),
+  hasPrev: import_v435.z.boolean(),
   startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
   endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
 }).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
-var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v434.z.union([
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v435.z.union([
   makeResponsePageContextSchemaWithNoRecords(valueLabel),
   makeResponsePageContextSchemaWithRecords(valueLabel)
 ]);
@@ -3290,21 +3429,21 @@ function invariant_registrationLifecycleNodeMatchesName(ctx) {
     });
   }
 }
-var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v435.z.object({
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v436.z.object({
   action: makeRegistrarActionSchema(valueLabel),
   name: makeReinterpretedNameSchema(valueLabel)
 }).check(invariant_registrationLifecycleNodeMatchesName);
-var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v435.z.object({
-  responseCode: import_v435.z.literal(RegistrarActionsResponseCodes.Ok),
-  registrarActions: import_v435.z.array(makeNamedRegistrarActionSchema(valueLabel)),
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v436.z.object({
+  responseCode: import_v436.z.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: import_v436.z.array(makeNamedRegistrarActionSchema(valueLabel)),
   pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
-var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v435.z.strictObject({
-  responseCode: import_v435.z.literal(RegistrarActionsResponseCodes.Error),
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v436.z.strictObject({
+  responseCode: import_v436.z.literal(RegistrarActionsResponseCodes.Error),
   error: makeErrorResponseSchema()
 });
-var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v435.z.discriminatedUnion("responseCode", [
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v436.z.discriminatedUnion("responseCode", [
   makeRegistrarActionsResponseOkSchema(valueLabel),
   makeRegistrarActionsResponseErrorSchema(valueLabel)
 ]);
@@ -3315,7 +3454,7 @@ function deserializeRegistrarActionsResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize RegistrarActionsResponse:
-${(0, import_v436.prettifyError)(parsed.error)}
+${(0, import_v437.prettifyError)(parsed.error)}
 `
     );
   }
@@ -3452,12 +3591,12 @@ function serializeRegistrarActionsResponse(response) {
 }
 
 // src/ensnode/api/shared/errors/deserialize.ts
-var import_v437 = require("zod/v4");
+var import_v438 = require("zod/v4");
 function deserializeErrorResponse2(maybeErrorResponse) {
   const parsed = makeErrorResponseSchema().safeParse(maybeErrorResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ErrorResponse:
-${(0, import_v437.prettifyError)(parsed.error)}
+${(0, import_v438.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -3987,51 +4126,18 @@ var EnsNodeClient = class _EnsNodeClient {
   }
 };
 
-// src/identity/identity.ts
-var import_datasources6 = require("@ensnode/datasources");
-
-// src/identity/types.ts
-var ResolutionStatusIds = {
-  /**
-   * Represents that the `Identity` is not resolved yet.
-   */
-  Unresolved: "unresolved",
-  /**
-   * Represents that resolution of the `Identity` resulted in a named identity.
-   */
-  Named: "named",
-  /**
-   * Represents that resolution of the `Identity` resulted in an unnamed identity.
-   */
-  Unnamed: "unnamed",
-  /**
-   * Represents that attempted resolution of the `Identity` resulted in an error
-   * and therefore it is unknown if the `Identity` resolves to a named or unnamed identity.
-   */
-  Unknown: "unknown"
-};
-
-// src/identity/identity.ts
-function buildUnresolvedIdentity(address, namespaceId, chainId) {
-  return {
-    resolutionStatus: ResolutionStatusIds.Unresolved,
-    chainId: chainId ?? (0, import_datasources6.getENSRootChainId)(namespaceId),
-    address
-  };
-}
-function isResolvedIdentity(identity) {
-  return identity.resolutionStatus !== ResolutionStatusIds.Unresolved;
-}
+// src/ensnode/metadata/deserialize/indexing-metadata-context.ts
+var import_v446 = require("zod/v4");
 
 // src/indexing-status/deserialize/chain-indexing-status-snapshot.ts
-var import_v438 = require("zod/v4");
+var import_v439 = 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_v438.prettifyError)(parsed.error)}
+${(0, import_v439.prettifyError)(parsed.error)}
 `
     );
   }
@@ -4049,121 +4155,256 @@ function createRealtimeIndexingStatusProjection(snapshot, now) {
 }
 
 // src/indexing-status/validate/chain-indexing-status-snapshot.ts
-var import_v439 = require("zod/v4");
+var import_v440 = require("zod/v4");
 function validateChainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid ChainIndexingStatusSnapshot:
-${(0, import_v439.prettifyError)(parsed.error)}
+${(0, import_v440.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
 // src/indexing-status/validate/realtime-indexing-status-projection.ts
-var import_v440 = require("zod/v4");
+var import_v441 = require("zod/v4");
 function validateRealtimeIndexingStatusProjection(unvalidatedProjection, valueLabel) {
   const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedProjection);
   if (parsed.error) {
     throw new Error(`Invalid RealtimeIndexingStatusProjection:
-${(0, import_v440.prettifyError)(parsed.error)}
+${(0, import_v441.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
-// src/omnigraph-api/prerequisites.ts
-function hasOmnigraphApiConfigSupport(config) {
-  const supported = config.plugins.includes("ensv2" /* ENSv2 */);
-  if (supported) return { supported };
-  return {
-    supported: false,
-    reason: `The connected ENSNode's Config must have the '${"ensv2" /* ENSv2 */}' plugin enabled.`
-  };
+// src/stack-info/validate/ensindexer-stack-info.ts
+var import_v442 = require("zod/v4");
+function validateEnsIndexerStackInfo(maybeStackInfo, valueLabel) {
+  const parsed = makeEnsIndexerStackInfoSchema(valueLabel).safeParse(maybeStackInfo);
+  if (parsed.error) {
+    throw new Error(`Cannot validate EnsIndexerStackInfo:
+${(0, import_v442.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
 }
 
-// src/registrars/basenames-subregistry.ts
-var import_enssdk8 = require("enssdk");
-var import_datasources7 = require("@ensnode/datasources");
-function getBasenamesSubregistryId(namespace) {
-  const datasource = (0, import_datasources7.maybeGetDatasource)(namespace, import_datasources7.DatasourceNames.Basenames);
-  if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${import_datasources7.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_datasources7.ENSNamespaceIds.Mainnet:
-      return (0, import_enssdk8.asInterpretedName)("base.eth");
-    case import_datasources7.ENSNamespaceIds.Sepolia:
-    case import_datasources7.ENSNamespaceIds.SepoliaV2:
-      return (0, import_enssdk8.asInterpretedName)("basetest.eth");
-    case import_datasources7.ENSNamespaceIds.EnsTestEnv:
-      throw new Error(
-        `No registrar managed name is known for the 'basenames' subregistry within the "${namespaceId}" namespace.`
-      );
+// src/stack-info/ensindexer-stack-info.ts
+function buildEnsIndexerStackInfo(ensDbPublicConfig, ensIndexerPublicConfig, ensRainbowPublicConfig) {
+  return validateEnsIndexerStackInfo({
+    ensDb: ensDbPublicConfig,
+    ensIndexer: ensIndexerPublicConfig,
+    ensRainbow: ensRainbowPublicConfig
+  });
+}
+
+// src/stack-info/validate/ensnode-stack-info.ts
+var import_v443 = require("zod/v4");
+function validateEnsNodeStackInfo(maybeStackInfo, valueLabel) {
+  const parsed = makeEnsNodeStackInfoSchema(valueLabel).safeParse(maybeStackInfo);
+  if (parsed.error) {
+    throw new Error(`Cannot validate EnsNodeStackInfo:
+${(0, import_v443.prettifyError)(parsed.error)}
+`);
   }
+  return parsed.data;
 }
 
-// src/registrars/ethnames-subregistry.ts
-var import_enssdk9 = require("enssdk");
-var import_datasources8 = require("@ensnode/datasources");
-function getEthnamesSubregistryId(namespace) {
-  const datasource = (0, import_datasources8.maybeGetDatasource)(namespace, import_datasources8.DatasourceNames.ENSRoot);
-  if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${import_datasources8.DatasourceNames.ENSRoot}`);
+// src/stack-info/ensnode-stack-info.ts
+function buildEnsNodeStackInfo(ensApiPublicConfig, ensDbPublicConfig, ensIndexerPublicConfig, ensRainbowPublicConfig) {
+  return validateEnsNodeStackInfo({
+    ...buildEnsIndexerStackInfo(ensDbPublicConfig, ensIndexerPublicConfig, ensRainbowPublicConfig),
+    ensApi: ensApiPublicConfig
+  });
+}
+
+// src/ensnode/metadata/validate/indexing-metadata-context.ts
+var import_v445 = require("zod/v4");
+
+// src/ensnode/metadata/zod-schemas/indexing-metadata-context.ts
+var import_v444 = require("zod/v4");
+var makeSerializedIndexingMetadataContextUninitializedSchema = (valueLabel) => {
+  const label = valueLabel ?? "SerializedIndexingMetadataContextUninitialized";
+  return import_v444.z.object({
+    statusCode: import_v444.z.literal(IndexingMetadataContextStatusCodes.Uninitialized, {
+      error: `${label} must have status code ${IndexingMetadataContextStatusCodes.Uninitialized}`
+    })
+  });
+};
+var makeSerializedIndexingMetadataContextInitializedSchema = (valueLabel) => {
+  const label = valueLabel ?? "SerializedIndexingMetadataContextInitialized";
+  return import_v444.z.object({
+    statusCode: import_v444.z.literal(IndexingMetadataContextStatusCodes.Initialized, {
+      error: `${label} must have status code ${IndexingMetadataContextStatusCodes.Initialized}`
+    }),
+    indexingStatus: makeSerializedCrossChainIndexingStatusSnapshotSchema(`${label}.indexingStatus`),
+    stackInfo: makeSerializedEnsIndexerStackInfoSchema(`${label}.stackInfo`)
+  });
+};
+var makeSerializedIndexingMetadataContextSchema = (valueLabel) => {
+  const label = valueLabel ?? "SerializedIndexingMetadataContext";
+  return import_v444.z.discriminatedUnion("statusCode", [
+    makeSerializedIndexingMetadataContextUninitializedSchema(label),
+    makeSerializedIndexingMetadataContextInitializedSchema(label)
+  ]);
+};
+var makeIndexingMetadataContextUninitializedSchema = makeSerializedIndexingMetadataContextUninitializedSchema;
+var makeIndexingMetadataContextInitializedSchema = (valueLabel) => {
+  const label = valueLabel ?? "IndexingMetadataContextInitialized";
+  return import_v444.z.object({
+    statusCode: import_v444.z.literal(IndexingMetadataContextStatusCodes.Initialized, {
+      error: `${label} must have status code ${IndexingMetadataContextStatusCodes.Initialized}`
+    }),
+    indexingStatus: makeCrossChainIndexingStatusSnapshotSchema(`${label}.indexingStatus`),
+    stackInfo: makeEnsIndexerStackInfoSchema(`${label}.stackInfo`)
+  });
+};
+var makeIndexingMetadataContextSchema = (valueLabel) => {
+  const label = valueLabel ?? "IndexingMetadataContext";
+  return import_v444.z.discriminatedUnion("statusCode", [
+    makeIndexingMetadataContextUninitializedSchema(label),
+    makeIndexingMetadataContextInitializedSchema(label)
+  ]);
+};
+
+// src/ensnode/metadata/validate/indexing-metadata-context.ts
+function validateIndexingMetadataContextInitialized(maybeIndexingMetadataContext, valueLabel) {
+  const label = valueLabel ?? "IndexingMetadataContextInitialized";
+  const result = makeIndexingMetadataContextInitializedSchema(label).safeParse(
+    maybeIndexingMetadataContext
+  );
+  if (result.error) {
+    throw new Error(`Cannot validate ${label}:
+${(0, import_v445.prettifyError)(result.error)}
+`);
   }
-  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 result.data;
+}
+
+// src/ensnode/metadata/indexing-metadata-context.ts
+var IndexingMetadataContextStatusCodes = {
+  /**
+   * Represents that no indexing metadata context has been initialized
+   * for the ENSIndexer Schema Name in the ENSNode Metadata table in ENSDb.
+   */
+  Uninitialized: "uninitialized",
+  /**
+   * Represents that the indexing metadata context has been initialized
+   * for the ENSIndexer Schema Name in the ENSNode Metadata table in ENSDb.
+   */
+  Initialized: "initialized"
+};
+function buildIndexingMetadataContextUninitialized() {
+  return {
+    statusCode: IndexingMetadataContextStatusCodes.Uninitialized
+  };
+}
+function buildIndexingMetadataContextInitialized(indexingStatus, stackInfo) {
+  return validateIndexingMetadataContextInitialized({
+    statusCode: IndexingMetadataContextStatusCodes.Initialized,
+    indexingStatus,
+    stackInfo
+  });
+}
+
+// src/ensnode/metadata/deserialize/indexing-metadata-context.ts
+function buildUnvalidatedIndexingMetadataContextInitialized(serializedIndexingMetadataContext) {
+  return {
+    statusCode: serializedIndexingMetadataContext.statusCode,
+    indexingStatus: buildUnvalidatedCrossChainIndexingStatusSnapshot(
+      serializedIndexingMetadataContext.indexingStatus
+    ),
+    stackInfo: buildUnvalidatedEnsIndexerStackInfo(serializedIndexingMetadataContext.stackInfo)
+  };
+}
+function buildUnvalidatedIndexingMetadataContext(serializedIndexingMetadataContext) {
+  switch (serializedIndexingMetadataContext.statusCode) {
+    case IndexingMetadataContextStatusCodes.Uninitialized:
+      return serializedIndexingMetadataContext;
+    case IndexingMetadataContextStatusCodes.Initialized:
+      return buildUnvalidatedIndexingMetadataContextInitialized(serializedIndexingMetadataContext);
   }
-  return { chainId: datasource.chain.id, address };
 }
-function getEthnamesSubregistryManagedName(namespaceId) {
-  switch (namespaceId) {
-    case import_datasources8.ENSNamespaceIds.Mainnet:
-    case import_datasources8.ENSNamespaceIds.Sepolia:
-    case import_datasources8.ENSNamespaceIds.SepoliaV2:
-    case import_datasources8.ENSNamespaceIds.EnsTestEnv:
-      return (0, import_enssdk9.asInterpretedName)("eth");
+function deserializeIndexingMetadataContext(serializedIndexingMetadataContext, valueLabel) {
+  const label = valueLabel ?? "IndexingMetadataContext";
+  const parsed = makeSerializedIndexingMetadataContextSchema(label).transform(buildUnvalidatedIndexingMetadataContext).pipe(makeIndexingMetadataContextSchema(label)).safeParse(serializedIndexingMetadataContext);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize IndexingMetadataContext:
+${(0, import_v446.prettifyError)(parsed.error)}
+`
+    );
   }
+  return parsed.data;
 }
 
-// src/registrars/lineanames-subregistry.ts
-var import_enssdk10 = require("enssdk");
-var import_datasources9 = require("@ensnode/datasources");
-function getLineanamesSubregistryId(namespace) {
-  const datasource = (0, import_datasources9.maybeGetDatasource)(namespace, import_datasources9.DatasourceNames.Lineanames);
-  if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${import_datasources9.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_datasources9.ENSNamespaceIds.Mainnet:
-      return (0, import_enssdk10.asInterpretedName)("linea.eth");
-    case import_datasources9.ENSNamespaceIds.Sepolia:
-    case import_datasources9.ENSNamespaceIds.SepoliaV2:
-      return (0, import_enssdk10.asInterpretedName)("linea-sepolia.eth");
-    case import_datasources9.ENSNamespaceIds.EnsTestEnv:
-      throw new Error(
-        `No registrar managed name is known for the 'Lineanames' subregistry within the "${namespaceId}" namespace.`
-      );
+// src/ensnode/metadata/serialize/indexing-metadata-context.ts
+function serializeIndexingMetadataContextInitialized(context) {
+  const { statusCode, indexingStatus, stackInfo } = context;
+  return {
+    statusCode,
+    indexingStatus: serializeCrossChainIndexingStatusSnapshot(indexingStatus),
+    stackInfo: serializeEnsIndexerStackInfo(stackInfo)
+  };
+}
+function serializeIndexingMetadataContext(context) {
+  switch (context.statusCode) {
+    case IndexingMetadataContextStatusCodes.Uninitialized:
+      return context;
+    case IndexingMetadataContextStatusCodes.Initialized:
+      return serializeIndexingMetadataContextInitialized(context);
   }
 }
 
+// src/identity/identity.ts
+var import_datasources6 = require("@ensnode/datasources");
+
+// src/identity/types.ts
+var ResolutionStatusIds = {
+  /**
+   * Represents that the `Identity` is not resolved yet.
+   */
+  Unresolved: "unresolved",
+  /**
+   * Represents that resolution of the `Identity` resulted in a named identity.
+   */
+  Named: "named",
+  /**
+   * Represents that resolution of the `Identity` resulted in an unnamed identity.
+   */
+  Unnamed: "unnamed",
+  /**
+   * Represents that attempted resolution of the `Identity` resulted in an error
+   * and therefore it is unknown if the `Identity` resolves to a named or unnamed identity.
+   */
+  Unknown: "unknown"
+};
+
+// src/identity/identity.ts
+function buildUnresolvedIdentity(address, namespaceId, chainId) {
+  return {
+    resolutionStatus: ResolutionStatusIds.Unresolved,
+    chainId: chainId ?? (0, import_datasources6.getENSRootChainId)(namespaceId),
+    address
+  };
+}
+function isResolvedIdentity(identity) {
+  return identity.resolutionStatus !== ResolutionStatusIds.Unresolved;
+}
+
+// src/omnigraph-api/prerequisites.ts
+function hasOmnigraphApiConfigSupport(config) {
+  const supported = config.plugins.includes("ensv2" /* ENSv2 */);
+  if (supported) return { supported };
+  return {
+    supported: false,
+    reason: `The connected ENSNode's Config must have the '${"ensv2" /* ENSv2 */}' plugin enabled.`
+  };
+}
+
 // src/registrars/registration-expiration.ts
 function isRegistrationExpired(info, now) {
   if (info.expiry == null) return false;
@@ -4180,15 +4421,15 @@ function isRegistrationInGracePeriod(info, now) {
 }
 
 // src/resolution/ensip19-chainid.ts
-var import_enssdk11 = require("enssdk");
+var import_enssdk8 = require("enssdk");
 var import_chains = require("viem/chains");
-var import_datasources10 = require("@ensnode/datasources");
+var import_datasources7 = require("@ensnode/datasources");
 var getResolvePrimaryNameChainIdParam = (chainId, namespaceId) => {
-  const ensRootChainId = (0, import_datasources10.getENSRootChainId)(namespaceId);
+  const ensRootChainId = (0, import_datasources7.getENSRootChainId)(namespaceId);
   return chainId === ensRootChainId ? import_chains.mainnet.id : chainId;
 };
 var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
-  return chainId === import_enssdk11.DEFAULT_EVM_CHAIN_ID ? (0, import_datasources10.getENSRootChainId)(namespaceId) : chainId;
+  return chainId === import_enssdk8.DEFAULT_EVM_CHAIN_ID ? (0, import_datasources7.getENSRootChainId)(namespaceId) : chainId;
 };
 
 // src/resolution/resolver-records-selection.ts
@@ -4251,13 +4492,13 @@ var import_getUnixTime2 = require("date-fns/getUnixTime");
 var import_getUnixTime = require("date-fns/getUnixTime");
 
 // src/shared/deserialize.ts
-var import_v441 = __toESM(require("zod/v4"), 1);
+var import_v447 = __toESM(require("zod/v4"), 1);
 function deserializeChainId(maybeChainId, valueLabel) {
   const schema = makeChainIdStringSchema(valueLabel);
   const parsed = schema.safeParse(maybeChainId);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ChainId:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v447.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4267,7 +4508,7 @@ function deserializeDatetime(maybeDatetime, valueLabel) {
   const parsed = schema.safeParse(maybeDatetime);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Datetime:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v447.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4277,7 +4518,7 @@ function deserializeUnixTimestamp(maybeTimestamp, valueLabel) {
   const parsed = schema.safeParse(maybeTimestamp);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Unix Timestamp:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v447.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4287,7 +4528,7 @@ function deserializeUrl(maybeUrl, valueLabel) {
   const parsed = schema.safeParse(maybeUrl);
   if (parsed.error) {
     throw new Error(`Cannot deserialize URL:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v447.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4297,7 +4538,7 @@ function deserializeBlockNumber(maybeBlockNumber, valueLabel) {
   const parsed = schema.safeParse(maybeBlockNumber);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockNumber:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v447.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4307,17 +4548,17 @@ function deserializeBlockRef(maybeBlockRef, valueLabel) {
   const parsed = schema.safeParse(maybeBlockRef);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockRef:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v447.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 function deserializeDuration(maybeDuration, valueLabel) {
-  const schema = import_v441.default.coerce.number().pipe(makeDurationSchema(valueLabel));
+  const schema = import_v447.default.coerce.number().pipe(makeDurationSchema(valueLabel));
   const parsed = schema.safeParse(maybeDuration);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize Duration:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v447.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4327,7 +4568,7 @@ function parseAccountId(maybeAccountId, valueLabel) {
   const parsed = schema.safeParse(maybeAccountId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AccountId:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v447.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4337,7 +4578,7 @@ function deserializePriceEth(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceEth:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v447.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4347,7 +4588,7 @@ function deserializePriceUsdc(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceUsdc:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v447.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4357,7 +4598,17 @@ function deserializePriceDai(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceDai:
-${(0, import_v441.prettifyError)(parsed.error)}
+${(0, import_v447.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializePriceEnsTokens(maybePrice, valueLabel) {
+  const schema = makePriceEnsTokensSchema(valueLabel);
+  const parsed = schema.safeParse(maybePrice);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize PriceEnsTokens:
+${(0, import_v447.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4509,12 +4760,12 @@ var TtlCache = class {
 };
 
 // src/shared/config/indexed-blockranges.ts
-var import_datasources11 = require("@ensnode/datasources");
+var import_datasources8 = require("@ensnode/datasources");
 function buildIndexedBlockranges(namespace, pluginsDatasourceNames) {
   const indexedBlockranges = /* @__PURE__ */ new Map();
   for (const [, datasourceNames] of pluginsDatasourceNames) {
     for (const datasourceName of datasourceNames) {
-      const datasource = (0, import_datasources11.maybeGetDatasource)(namespace, datasourceName);
+      const datasource = (0, import_datasources8.maybeGetDatasource)(namespace, datasourceName);
       if (!datasource) continue;
       const datasourceChainId = datasource.chain.id;
       const datasourceContracts = Object.values(datasource.contracts);
@@ -4542,7 +4793,7 @@ var import_viem9 = require("viem");
 var interpretAddress = (owner) => (0, import_viem9.isAddressEqual)(import_viem9.zeroAddress, owner) ? null : owner;
 
 // src/shared/interpretation/interpret-record-values.ts
-var import_enssdk12 = require("enssdk");
+var import_enssdk9 = require("enssdk");
 var import_viem10 = require("viem");
 
 // src/shared/null-bytes.ts
@@ -4552,7 +4803,7 @@ var stripNullBytes = (value) => value.replaceAll("\0", "");
 // src/shared/interpretation/interpret-record-values.ts
 function interpretNameRecordValue(value) {
   if (value === "") return null;
-  if (!(0, import_enssdk12.isInterpretedName)(value)) return null;
+  if (!(0, import_enssdk9.isInterpretedName)(value)) return null;
   return value;
 }
 function interpretAddressRecordValue(value) {
@@ -4561,7 +4812,7 @@ function interpretAddressRecordValue(value) {
   if (value === "0x") return null;
   if (!(0, import_viem10.isAddress)(value, { strict: false })) return value;
   if ((0, import_viem10.isAddressEqual)(value, import_viem10.zeroAddress)) return null;
-  return (0, import_enssdk12.toNormalizedAddress)(value);
+  return (0, import_enssdk9.toNormalizedAddress)(value);
 }
 function interpretTextRecordKey(key) {
   if (hasNullByte(key)) return null;
@@ -4589,24 +4840,216 @@ function interpretDnszonehashValue(value) {
   return value;
 }
 
+// src/shared/managed-names.ts
+var import_enssdk10 = require("enssdk");
+var import_datasources9 = require("@ensnode/datasources");
+
+// src/shared/to-json.ts
+var toJson = (value, options) => JSON.stringify(
+  value,
+  (_key, val) => typeof val === "bigint" ? String(val) : val,
+  options?.pretty ? 2 : void 0
+);
+
+// src/shared/managed-names.ts
+var MANAGED_NAME_BY_NAMESPACE = {
+  sepolia: {
+    "base.eth": "basetest.eth",
+    "linea.eth": "linea-sepolia.eth"
+  }
+};
+var getContractsByManagedName = (namespace) => {
+  const ensRootRegistry = getDatasourceContract(
+    namespace,
+    import_datasources9.DatasourceNames.ENSRoot,
+    "ENSv1Registry"
+  );
+  const ensRootRegistryOld = getDatasourceContract(
+    namespace,
+    import_datasources9.DatasourceNames.ENSRoot,
+    "ENSv1RegistryOld"
+  );
+  const ethnamesNameWrapper = getDatasourceContract(
+    namespace,
+    import_datasources9.DatasourceNames.ENSRoot,
+    "NameWrapper"
+  );
+  const basenamesRegistry = maybeGetDatasourceContract(
+    namespace,
+    import_datasources9.DatasourceNames.Basenames,
+    "Registry"
+  );
+  const lineanamesRegistry = maybeGetDatasourceContract(
+    namespace,
+    import_datasources9.DatasourceNames.Lineanames,
+    "Registry"
+  );
+  const lineanamesNameWrapper = maybeGetDatasourceContract(
+    namespace,
+    import_datasources9.DatasourceNames.Lineanames,
+    "NameWrapper"
+  );
+  return {
+    [import_enssdk10.ENS_ROOT_NAME]: {
+      registry: ensRootRegistry,
+      contracts: [ensRootRegistry, ensRootRegistryOld]
+    },
+    eth: {
+      registry: ensRootRegistry,
+      contracts: [
+        getDatasourceContract(namespace, import_datasources9.DatasourceNames.ENSRoot, "BaseRegistrar"),
+        getDatasourceContract(
+          namespace,
+          import_datasources9.DatasourceNames.ENSRoot,
+          "UnwrappedEthRegistrarController"
+        ),
+        maybeGetDatasourceContract(
+          namespace,
+          import_datasources9.DatasourceNames.ENSRoot,
+          "LegacyEthRegistrarController"
+        ),
+        maybeGetDatasourceContract(
+          namespace,
+          import_datasources9.DatasourceNames.ENSRoot,
+          "WrappedEthRegistrarController"
+        ),
+        maybeGetDatasourceContract(
+          namespace,
+          import_datasources9.DatasourceNames.ENSRoot,
+          "UniversalRegistrarRenewalWithReferrer"
+        ),
+        ethnamesNameWrapper
+      ].filter((c) => !!c)
+    },
+    ...basenamesRegistry && {
+      "base.eth": {
+        registry: basenamesRegistry,
+        contracts: [
+          basenamesRegistry,
+          maybeGetDatasourceContract(namespace, import_datasources9.DatasourceNames.Basenames, "BaseRegistrar"),
+          maybeGetDatasourceContract(namespace, import_datasources9.DatasourceNames.Basenames, "EARegistrarController"),
+          maybeGetDatasourceContract(namespace, import_datasources9.DatasourceNames.Basenames, "RegistrarController"),
+          maybeGetDatasourceContract(
+            namespace,
+            import_datasources9.DatasourceNames.Basenames,
+            "UpgradeableRegistrarController"
+          )
+        ].filter((c) => !!c)
+      }
+    },
+    ...lineanamesRegistry && {
+      "linea.eth": {
+        registry: lineanamesRegistry,
+        contracts: [
+          lineanamesRegistry,
+          maybeGetDatasourceContract(namespace, import_datasources9.DatasourceNames.Lineanames, "BaseRegistrar"),
+          maybeGetDatasourceContract(
+            namespace,
+            import_datasources9.DatasourceNames.Lineanames,
+            "EthRegistrarController"
+          ),
+          lineanamesNameWrapper
+        ].filter((c) => !!c)
+      }
+    }
+  };
+};
+var cache = /* @__PURE__ */ new Map();
+var getManagedName = (namespace, contract) => {
+  const cacheKey = `${namespace}:${(0, import_enssdk10.stringifyAccountId)(contract)}`;
+  const cached = cache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  for (const [managedName, group] of Object.entries(getContractsByManagedName(namespace))) {
+    const isAnyOfTheContracts = group.contracts.some(
+      (_contract) => accountIdEqual(_contract, contract)
+    );
+    if (isAnyOfTheContracts) {
+      const namespaceSpecific = MANAGED_NAME_BY_NAMESPACE[namespace]?.[managedName];
+      const name = (0, import_enssdk10.asInterpretedName)(namespaceSpecific ?? managedName);
+      const node = (0, import_enssdk10.namehashInterpretedName)(name);
+      const result = { name, node, registry: group.registry };
+      cache.set(cacheKey, result);
+      return result;
+    }
+  }
+  throw new Error(
+    `The following contract ${toJson(contract, { pretty: true })} does not have a configured Managed Name in namespace '${namespace}'.`
+  );
+};
+var isNameWrapper = (namespace, contract) => {
+  const ethnamesNameWrapper = getDatasourceContract(
+    namespace,
+    import_datasources9.DatasourceNames.ENSRoot,
+    "NameWrapper"
+  );
+  if (accountIdEqual(ethnamesNameWrapper, contract)) return true;
+  const lineanamesNameWrapper = maybeGetDatasourceContract(
+    namespace,
+    import_datasources9.DatasourceNames.Lineanames,
+    "NameWrapper"
+  );
+  if (lineanamesNameWrapper && accountIdEqual(lineanamesNameWrapper, contract)) return true;
+  return false;
+};
+
 // src/shared/namespace-specific-value.ts
 function getNamespaceSpecificValue(namespace, value) {
   return value[namespace] ?? value.default;
 }
 
+// src/shared/replace-bigints.ts
+var replaceBigInts = (obj, replacer) => {
+  if (typeof obj === "bigint") return replacer(obj);
+  if (Array.isArray(obj))
+    return obj.map((x) => replaceBigInts(x, replacer));
+  if (obj && typeof obj === "object")
+    return Object.fromEntries(
+      Object.entries(obj).map(([k, v]) => [k, replaceBigInts(v, replacer)])
+    );
+  return obj;
+};
+
 // src/shared/root-registry.ts
-var import_enssdk13 = require("enssdk");
-var import_datasources12 = require("@ensnode/datasources");
-var getENSv1Registry = (namespace) => getDatasourceContract(namespace, import_datasources12.DatasourceNames.ENSRoot, "ENSv1Registry");
+var import_enssdk11 = require("enssdk");
+var import_datasources10 = require("@ensnode/datasources");
+var getENSv1Registry = (namespace) => getDatasourceContract(namespace, import_datasources10.DatasourceNames.ENSRoot, "ENSv1Registry");
+var getENSv1RootRegistryId = (namespace) => (0, import_enssdk11.makeENSv1RegistryId)(getENSv1Registry(namespace));
 var isENSv1Registry = (namespace, contract) => accountIdEqual(getENSv1Registry(namespace), contract);
-var getENSv2RootRegistry = (namespace) => getDatasourceContract(namespace, import_datasources12.DatasourceNames.ENSv2Root, "RootRegistry");
-var getENSv2RootRegistryId = (namespace) => (0, import_enssdk13.makeRegistryId)(getENSv2RootRegistry(namespace));
+var getENSv2RootRegistry = (namespace) => getDatasourceContract(namespace, import_datasources10.DatasourceNames.ENSv2Root, "RootRegistry");
+var getENSv2RootRegistryId = (namespace) => (0, import_enssdk11.makeENSv2RegistryId)(getENSv2RootRegistry(namespace));
 var isENSv2RootRegistry = (namespace, contract) => accountIdEqual(getENSv2RootRegistry(namespace), contract);
-var maybeGetENSv2RootRegistry = (namespace) => maybeGetDatasourceContract(namespace, import_datasources12.DatasourceNames.ENSv2Root, "RootRegistry");
+var maybeGetENSv2RootRegistry = (namespace) => maybeGetDatasourceContract(namespace, import_datasources10.DatasourceNames.ENSv2Root, "RootRegistry");
 var maybeGetENSv2RootRegistryId = (namespace) => {
   const root = maybeGetENSv2RootRegistry(namespace);
   if (!root) return void 0;
-  return (0, import_enssdk13.makeRegistryId)(root);
+  return (0, import_enssdk11.makeENSv2RegistryId)(root);
+};
+var getRootRegistryId = (namespace) => maybeGetENSv2RootRegistryId(namespace) ?? getENSv1RootRegistryId(namespace);
+var getRootRegistryIds = (namespace) => {
+  const v1RootRegistryId = getENSv1RootRegistryId(namespace);
+  const v2RootRegistryId = maybeGetENSv2RootRegistryId(namespace);
+  const basenamesRegistry = maybeGetDatasourceContract(
+    namespace,
+    import_datasources10.DatasourceNames.Basenames,
+    "Registry"
+  );
+  const lineanamesRegistry = maybeGetDatasourceContract(
+    namespace,
+    import_datasources10.DatasourceNames.Lineanames,
+    "Registry"
+  );
+  return [
+    v1RootRegistryId,
+    basenamesRegistry && (0, import_enssdk11.makeENSv1VirtualRegistryId)(
+      basenamesRegistry,
+      getManagedName(namespace, basenamesRegistry).node
+    ),
+    lineanamesRegistry && (0, import_enssdk11.makeENSv1VirtualRegistryId)(
+      lineanamesRegistry,
+      getManagedName(namespace, lineanamesRegistry).node
+    ),
+    v2RootRegistryId
+  ].filter((id) => !!id);
 };
 
 // src/shared/url.ts
@@ -4617,16 +5060,6 @@ function isWebSocketProtocol(url) {
   return ["ws:", "wss:"].includes(url.protocol);
 }
 
-// src/stack-info/ensnode-stack-info.ts
-function buildEnsNodeStackInfo(ensApiPublicConfig, ensDbPublicConfig) {
-  return {
-    ensApi: ensApiPublicConfig,
-    ensDb: ensDbPublicConfig,
-    ensIndexer: ensApiPublicConfig.ensIndexerPublicConfig,
-    ensRainbow: ensApiPublicConfig.ensIndexerPublicConfig.ensRainbowPublicConfig
-  };
-}
-
 // src/subgraph-api/prerequisites.ts
 function hasSubgraphApiConfigSupport(config) {
   const supported = config.plugins.includes("subgraph" /* Subgraph */);