@ensnode/ensnode-sdk 1.10.1 → 1.11.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { ENSNamespaceIds as ENSNamespaceIds7 } from "@ensnode/datasources";
+import { ENSNamespaceIds as ENSNamespaceIds4 } from "@ensnode/datasources";
 
 // src/ens/index.ts
 import { ENSNamespaceIds, getENSRootChainId } from "@ensnode/datasources";
@@ -76,7 +76,8 @@ function scaleBigintByNumber(value, scaleFactor) {
 var CurrencyIds = {
   ETH: "ETH",
   USDC: "USDC",
-  DAI: "DAI"
+  DAI: "DAI",
+  ENSTokens: "ENSTokens"
 };
 var currencyInfo = {
   [CurrencyIds.ETH]: {
@@ -93,6 +94,11 @@ var currencyInfo = {
     id: CurrencyIds.DAI,
     name: "Dai Stablecoin",
     decimals: 18
+  },
+  [CurrencyIds.ENSTokens]: {
+    id: CurrencyIds.ENSTokens,
+    name: "$ENS Tokens",
+    decimals: 18
   }
 };
 function getCurrencyInfo(currencyId) {
@@ -116,6 +122,12 @@ function priceDai(amount) {
     currency: CurrencyIds.DAI
   };
 }
+function priceEnsTokens(amount) {
+  return {
+    amount,
+    currency: CurrencyIds.ENSTokens
+  };
+}
 function isPriceCurrencyEqual(priceA, priceB) {
   return priceA.currency === priceB.currency;
 }
@@ -203,6 +215,12 @@ function parseDai(value) {
   const amount = parseUnits(value, currencyInfo2.decimals);
   return priceDai(amount);
 }
+function parseEnsTokens(value) {
+  validateAmountToParse(value);
+  const currencyInfo2 = getCurrencyInfo(CurrencyIds.ENSTokens);
+  const amount = parseUnits(value, currencyInfo2.decimals);
+  return priceEnsTokens(amount);
+}
 
 // src/shared/zod-schemas.ts
 var makeIntegerSchema = (valueLabel = "Value") => z.int({
@@ -263,6 +281,7 @@ var makePriceCurrencySchema = (currency, valueLabel = "Price Currency") => z.str
 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") => z.strictObject({
   chainId: makeChainIdSchema(`${valueLabel} chain ID`),
   address: makeNormalizedAddressSchema(`${valueLabel} address`)
@@ -317,14 +336,15 @@ var makeLabelSetIdSchema = (valueLabel = "Label set ID") => {
 var makeLabelSetVersionSchema = (valueLabel = "Label set version") => makeNonNegativeIntegerSchema(valueLabel);
 var makeLabelSetVersionStringSchema = (valueLabel = "Label set version") => z2.coerce.number({ error: `${valueLabel} must be a non-negative integer` }).pipe(makeLabelSetVersionSchema(valueLabel));
 var makeEnsRainbowPublicConfigSchema = (valueLabel = "EnsRainbowPublicConfig") => z2.object({
-  version: z2.string().nonempty({ error: `${valueLabel}.version must be a non-empty string.` }),
-  labelSet: z2.object({
-    labelSetId: makeLabelSetIdSchema(`${valueLabel}.labelSet.labelSetId`),
+  serverLabelSet: z2.object({
+    labelSetId: makeLabelSetIdSchema(`${valueLabel}.serverLabelSet.labelSetId`),
     highestLabelSetVersion: makeLabelSetVersionSchema(
-      `${valueLabel}.labelSet.highestLabelSetVersion`
+      `${valueLabel}.serverLabelSet.highestLabelSetVersion`
     )
   }),
-  recordsCount: makeNonNegativeIntegerSchema(`${valueLabel}.recordsCount`)
+  versionInfo: z2.object({
+    ensRainbow: z2.string().nonempty({ error: `${valueLabel}.versionInfo.ensRainbow must be a non-empty string.` })
+  })
 });
 
 // src/shared/collections.ts
@@ -349,8 +369,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 === ENSNamespaceIds2.EnsTestEnv && isEnsTestEnvLabelSet;
   return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
 }
@@ -448,13 +468,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) {
@@ -475,7 +495,7 @@ var makeEnsIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") =
   isSubgraphCompatible: z3.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`)
@@ -489,7 +509,7 @@ var makeSerializedEnsIndexerPublicConfigSchema = (valueLabel = "Serialized ENSIn
   isSubgraphCompatible: z3.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`)
@@ -589,7 +609,7 @@ function serializeEnsIndexerPublicConfig(config) {
     ensRainbowPublicConfig,
     indexedChainIds,
     isSubgraphCompatible: isSubgraphCompatible2,
-    labelSet,
+    clientLabelSet,
     namespace,
     plugins,
     versionInfo
@@ -599,7 +619,7 @@ function serializeEnsIndexerPublicConfig(config) {
     ensRainbowPublicConfig,
     indexedChainIds: serializeIndexedChainIds(indexedChainIds),
     isSubgraphCompatible: isSubgraphCompatible2,
-    labelSet,
+    clientLabelSet,
     namespace,
     plugins,
     versionInfo
@@ -1638,6 +1658,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) {
@@ -1844,21 +1867,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(" ")
     );
   }
@@ -1949,12 +1972,12 @@ function validateEnsIndexerVersionInfo(unvalidatedVersionInfo) {
 }
 
 // src/ensnode/api/indexing-status/deserialize.ts
-import { prettifyError as prettifyError13 } from "zod/v4";
+import { prettifyError as prettifyError14 } from "zod/v4";
 
 // src/stack-info/deserialize/ensnode-stack-info.ts
-import { prettifyError as prettifyError12 } from "zod/v4";
+import { prettifyError as prettifyError13 } from "zod/v4";
 
-// src/stack-info/zod-schemas/ensnode-stack-info.ts
+// src/stack-info/zod-schemas/ensindexer-stack-info.ts
 import { z as z13 } from "zod/v4";
 
 // src/ensdb/zod-schemas/config.ts
@@ -1963,49 +1986,134 @@ var makeEnsDbVersionInfoSchema = (valueLabel) => {
   const label = valueLabel ?? "EnsDbVersionInfo";
   return z12.object({
     postgresql: z12.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 z12.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 z13.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 z13.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
+import { prettifyError as prettifyError12 } from "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:
+${prettifyError12(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:
-${prettifyError12(parsed.error)}
+${prettifyError13(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2065,7 +2173,7 @@ function deserializeEnsApiIndexingStatusResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize EnsApiIndexingStatusResponse:
-${prettifyError13(parsed.error)}
+${prettifyError14(parsed.error)}
 `
     );
   }
@@ -2073,13 +2181,26 @@ ${prettifyError13(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)
   };
 }
 
@@ -2099,7 +2220,7 @@ function serializeEnsApiIndexingStatusResponse(response) {
 var serializeIndexingStatusResponse = serializeEnsApiIndexingStatusResponse;
 
 // src/ensnode/api/name-tokens/deserialize.ts
-import { prettifyError as prettifyError15 } from "zod/v4";
+import { prettifyError as prettifyError16 } from "zod/v4";
 
 // src/ensnode/api/name-tokens/zod-schemas.ts
 import { namehashInterpretedName } from "enssdk";
@@ -2149,7 +2270,7 @@ import {
   stringifyAssetId
 } from "enssdk";
 import { isAddressEqual as isAddressEqual2, zeroAddress as zeroAddress2 } from "viem";
-import { prettifyError as prettifyError14 } from "zod/v4";
+import { prettifyError as prettifyError15 } from "zod/v4";
 
 // src/tokenscope/zod-schemas.ts
 import { AssetId as CaipAssetId } from "caip";
@@ -2250,7 +2371,7 @@ function deserializeAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AssetId:
-${prettifyError14(parsed.error)}
+${prettifyError15(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2260,7 +2381,7 @@ function parseAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot parse AssetId:
-${prettifyError14(parsed.error)}
+${prettifyError15(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2686,7 +2807,7 @@ function deserializedNameTokensResponse(maybeResponse) {
   );
   if (parsed.error) {
     throw new Error(`Cannot deserialize NameTokensResponse:
-${prettifyError15(parsed.error)}
+${prettifyError16(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2760,7 +2881,7 @@ function serializeNameTokensResponse(response) {
 }
 
 // src/ensnode/api/registrar-actions/deserialize.ts
-import { prettifyError as prettifyError16 } from "zod/v4";
+import { prettifyError as prettifyError17 } from "zod/v4";
 
 // src/ensnode/api/registrar-actions/zod-schemas.ts
 import { namehashInterpretedName as namehashInterpretedName2 } from "enssdk";
@@ -3064,7 +3185,7 @@ function deserializeRegistrarActionsResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize RegistrarActionsResponse:
-${prettifyError16(parsed.error)}
+${prettifyError17(parsed.error)}
 `
     );
   }
@@ -3201,12 +3322,12 @@ function serializeRegistrarActionsResponse(response) {
 }
 
 // src/ensnode/api/shared/errors/deserialize.ts
-import { prettifyError as prettifyError17 } from "zod/v4";
+import { prettifyError as prettifyError18 } from "zod/v4";
 function deserializeErrorResponse2(maybeErrorResponse) {
   const parsed = makeErrorResponseSchema().safeParse(maybeErrorResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ErrorResponse:
-${prettifyError17(parsed.error)}
+${prettifyError18(parsed.error)}
 `);
   }
   return parsed.data;
@@ -3736,51 +3857,18 @@ var EnsNodeClient = class _EnsNodeClient {
   }
 };
 
-// src/identity/identity.ts
-import { getENSRootChainId as getENSRootChainId2 } from "@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 ?? getENSRootChainId2(namespaceId),
-    address
-  };
-}
-function isResolvedIdentity(identity) {
-  return identity.resolutionStatus !== ResolutionStatusIds.Unresolved;
-}
+// src/ensnode/metadata/deserialize/indexing-metadata-context.ts
+import { prettifyError as prettifyError25 } from "zod/v4";
 
 // src/indexing-status/deserialize/chain-indexing-status-snapshot.ts
-import { prettifyError as prettifyError18 } from "zod/v4";
+import { prettifyError as prettifyError19 } from "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:
-${prettifyError18(parsed.error)}
+${prettifyError19(parsed.error)}
 `
     );
   }
@@ -3798,133 +3886,256 @@ function createRealtimeIndexingStatusProjection(snapshot, now) {
 }
 
 // src/indexing-status/validate/chain-indexing-status-snapshot.ts
-import { prettifyError as prettifyError19 } from "zod/v4";
+import { prettifyError as prettifyError20 } from "zod/v4";
 function validateChainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid ChainIndexingStatusSnapshot:
-${prettifyError19(parsed.error)}
+${prettifyError20(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
 // src/indexing-status/validate/realtime-indexing-status-projection.ts
-import { prettifyError as prettifyError20 } from "zod/v4";
+import { prettifyError as prettifyError21 } from "zod/v4";
 function validateRealtimeIndexingStatusProjection(unvalidatedProjection, valueLabel) {
   const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedProjection);
   if (parsed.error) {
     throw new Error(`Invalid RealtimeIndexingStatusProjection:
-${prettifyError20(parsed.error)}
+${prettifyError21(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
+import { prettifyError as prettifyError22 } from "zod/v4";
+function validateEnsIndexerStackInfo(maybeStackInfo, valueLabel) {
+  const parsed = makeEnsIndexerStackInfoSchema(valueLabel).safeParse(maybeStackInfo);
+  if (parsed.error) {
+    throw new Error(`Cannot validate EnsIndexerStackInfo:
+${prettifyError22(parsed.error)}
+`);
+  }
+  return parsed.data;
 }
 
-// src/registrars/basenames-subregistry.ts
-import { asInterpretedName } from "enssdk";
-import {
-  DatasourceNames as DatasourceNames2,
-  ENSNamespaceIds as ENSNamespaceIds4,
-  maybeGetDatasource as maybeGetDatasource2
-} from "@ensnode/datasources";
-function getBasenamesSubregistryId(namespace) {
-  const datasource = maybeGetDatasource2(namespace, DatasourceNames2.Basenames);
-  if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames2.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 ENSNamespaceIds4.Mainnet:
-      return asInterpretedName("base.eth");
-    case ENSNamespaceIds4.Sepolia:
-    case ENSNamespaceIds4.SepoliaV2:
-      return asInterpretedName("basetest.eth");
-    case ENSNamespaceIds4.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
+import { prettifyError as prettifyError23 } from "zod/v4";
+function validateEnsNodeStackInfo(maybeStackInfo, valueLabel) {
+  const parsed = makeEnsNodeStackInfoSchema(valueLabel).safeParse(maybeStackInfo);
+  if (parsed.error) {
+    throw new Error(`Cannot validate EnsNodeStackInfo:
+${prettifyError23(parsed.error)}
+`);
   }
+  return parsed.data;
 }
 
-// src/registrars/ethnames-subregistry.ts
-import { asInterpretedName as asInterpretedName2 } from "enssdk";
-import {
-  DatasourceNames as DatasourceNames3,
-  ENSNamespaceIds as ENSNamespaceIds5,
-  maybeGetDatasource as maybeGetDatasource3
-} from "@ensnode/datasources";
-function getEthnamesSubregistryId(namespace) {
-  const datasource = maybeGetDatasource3(namespace, DatasourceNames3.ENSRoot);
-  if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames3.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
+import { prettifyError as prettifyError24 } from "zod/v4";
+
+// src/ensnode/metadata/zod-schemas/indexing-metadata-context.ts
+import { z as z21 } from "zod/v4";
+var makeSerializedIndexingMetadataContextUninitializedSchema = (valueLabel) => {
+  const label = valueLabel ?? "SerializedIndexingMetadataContextUninitialized";
+  return z21.object({
+    statusCode: z21.literal(IndexingMetadataContextStatusCodes.Uninitialized, {
+      error: `${label} must have status code ${IndexingMetadataContextStatusCodes.Uninitialized}`
+    })
+  });
+};
+var makeSerializedIndexingMetadataContextInitializedSchema = (valueLabel) => {
+  const label = valueLabel ?? "SerializedIndexingMetadataContextInitialized";
+  return z21.object({
+    statusCode: z21.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 z21.discriminatedUnion("statusCode", [
+    makeSerializedIndexingMetadataContextUninitializedSchema(label),
+    makeSerializedIndexingMetadataContextInitializedSchema(label)
+  ]);
+};
+var makeIndexingMetadataContextUninitializedSchema = makeSerializedIndexingMetadataContextUninitializedSchema;
+var makeIndexingMetadataContextInitializedSchema = (valueLabel) => {
+  const label = valueLabel ?? "IndexingMetadataContextInitialized";
+  return z21.object({
+    statusCode: z21.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 z21.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}:
+${prettifyError24(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 ENSNamespaceIds5.Mainnet:
-    case ENSNamespaceIds5.Sepolia:
-    case ENSNamespaceIds5.SepoliaV2:
-    case ENSNamespaceIds5.EnsTestEnv:
-      return asInterpretedName2("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:
+${prettifyError25(parsed.error)}
+`
+    );
   }
+  return parsed.data;
 }
 
-// src/registrars/lineanames-subregistry.ts
-import { asInterpretedName as asInterpretedName3 } from "enssdk";
-import {
-  DatasourceNames as DatasourceNames4,
-  ENSNamespaceIds as ENSNamespaceIds6,
-  maybeGetDatasource as maybeGetDatasource4
-} from "@ensnode/datasources";
-function getLineanamesSubregistryId(namespace) {
-  const datasource = maybeGetDatasource4(namespace, DatasourceNames4.Lineanames);
-  if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames4.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 ENSNamespaceIds6.Mainnet:
-      return asInterpretedName3("linea.eth");
-    case ENSNamespaceIds6.Sepolia:
-    case ENSNamespaceIds6.SepoliaV2:
-      return asInterpretedName3("linea-sepolia.eth");
-    case ENSNamespaceIds6.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
+import { getENSRootChainId as getENSRootChainId2 } from "@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 ?? getENSRootChainId2(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;
@@ -4012,13 +4223,13 @@ import { getUnixTime as getUnixTime2 } from "date-fns/getUnixTime";
 import { getUnixTime } from "date-fns/getUnixTime";
 
 // src/shared/deserialize.ts
-import z21, { prettifyError as prettifyError21 } from "zod/v4";
+import z22, { prettifyError as prettifyError26 } from "zod/v4";
 function deserializeChainId(maybeChainId, valueLabel) {
   const schema = makeChainIdStringSchema(valueLabel);
   const parsed = schema.safeParse(maybeChainId);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ChainId:
-${prettifyError21(parsed.error)}
+${prettifyError26(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4028,7 +4239,7 @@ function deserializeDatetime(maybeDatetime, valueLabel) {
   const parsed = schema.safeParse(maybeDatetime);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Datetime:
-${prettifyError21(parsed.error)}
+${prettifyError26(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4038,7 +4249,7 @@ function deserializeUnixTimestamp(maybeTimestamp, valueLabel) {
   const parsed = schema.safeParse(maybeTimestamp);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Unix Timestamp:
-${prettifyError21(parsed.error)}
+${prettifyError26(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4048,7 +4259,7 @@ function deserializeUrl(maybeUrl, valueLabel) {
   const parsed = schema.safeParse(maybeUrl);
   if (parsed.error) {
     throw new Error(`Cannot deserialize URL:
-${prettifyError21(parsed.error)}
+${prettifyError26(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4058,7 +4269,7 @@ function deserializeBlockNumber(maybeBlockNumber, valueLabel) {
   const parsed = schema.safeParse(maybeBlockNumber);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockNumber:
-${prettifyError21(parsed.error)}
+${prettifyError26(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4068,17 +4279,17 @@ function deserializeBlockRef(maybeBlockRef, valueLabel) {
   const parsed = schema.safeParse(maybeBlockRef);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockRef:
-${prettifyError21(parsed.error)}
+${prettifyError26(parsed.error)}
 `);
   }
   return parsed.data;
 }
 function deserializeDuration(maybeDuration, valueLabel) {
-  const schema = z21.coerce.number().pipe(makeDurationSchema(valueLabel));
+  const schema = z22.coerce.number().pipe(makeDurationSchema(valueLabel));
   const parsed = schema.safeParse(maybeDuration);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize Duration:
-${prettifyError21(parsed.error)}
+${prettifyError26(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4088,7 +4299,7 @@ function parseAccountId(maybeAccountId, valueLabel) {
   const parsed = schema.safeParse(maybeAccountId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AccountId:
-${prettifyError21(parsed.error)}
+${prettifyError26(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4098,7 +4309,7 @@ function deserializePriceEth(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceEth:
-${prettifyError21(parsed.error)}
+${prettifyError26(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4108,7 +4319,7 @@ function deserializePriceUsdc(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceUsdc:
-${prettifyError21(parsed.error)}
+${prettifyError26(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4118,7 +4329,17 @@ function deserializePriceDai(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceDai:
-${prettifyError21(parsed.error)}
+${prettifyError26(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:
+${prettifyError26(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4271,13 +4492,13 @@ var TtlCache = class {
 
 // src/shared/config/indexed-blockranges.ts
 import {
-  maybeGetDatasource as maybeGetDatasource5
+  maybeGetDatasource as maybeGetDatasource2
 } from "@ensnode/datasources";
 function buildIndexedBlockranges(namespace, pluginsDatasourceNames) {
   const indexedBlockranges = /* @__PURE__ */ new Map();
   for (const [, datasourceNames] of pluginsDatasourceNames) {
     for (const datasourceName of datasourceNames) {
-      const datasource = maybeGetDatasource5(namespace, datasourceName);
+      const datasource = maybeGetDatasource2(namespace, datasourceName);
       if (!datasource) continue;
       const datasourceChainId = datasource.chain.id;
       const datasourceContracts = Object.values(datasource.contracts);
@@ -4352,24 +4573,225 @@ function interpretDnszonehashValue(value) {
   return value;
 }
 
+// src/shared/managed-names.ts
+import {
+  asInterpretedName,
+  ENS_ROOT_NAME,
+  namehashInterpretedName as namehashInterpretedName3,
+  stringifyAccountId
+} from "enssdk";
+import { DatasourceNames as DatasourceNames2 } from "@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,
+    DatasourceNames2.ENSRoot,
+    "ENSv1Registry"
+  );
+  const ensRootRegistryOld = getDatasourceContract(
+    namespace,
+    DatasourceNames2.ENSRoot,
+    "ENSv1RegistryOld"
+  );
+  const ethnamesNameWrapper = getDatasourceContract(
+    namespace,
+    DatasourceNames2.ENSRoot,
+    "NameWrapper"
+  );
+  const basenamesRegistry = maybeGetDatasourceContract(
+    namespace,
+    DatasourceNames2.Basenames,
+    "Registry"
+  );
+  const lineanamesRegistry = maybeGetDatasourceContract(
+    namespace,
+    DatasourceNames2.Lineanames,
+    "Registry"
+  );
+  const lineanamesNameWrapper = maybeGetDatasourceContract(
+    namespace,
+    DatasourceNames2.Lineanames,
+    "NameWrapper"
+  );
+  return {
+    [ENS_ROOT_NAME]: {
+      registry: ensRootRegistry,
+      contracts: [ensRootRegistry, ensRootRegistryOld]
+    },
+    eth: {
+      registry: ensRootRegistry,
+      contracts: [
+        getDatasourceContract(namespace, DatasourceNames2.ENSRoot, "BaseRegistrar"),
+        getDatasourceContract(
+          namespace,
+          DatasourceNames2.ENSRoot,
+          "UnwrappedEthRegistrarController"
+        ),
+        maybeGetDatasourceContract(
+          namespace,
+          DatasourceNames2.ENSRoot,
+          "LegacyEthRegistrarController"
+        ),
+        maybeGetDatasourceContract(
+          namespace,
+          DatasourceNames2.ENSRoot,
+          "WrappedEthRegistrarController"
+        ),
+        maybeGetDatasourceContract(
+          namespace,
+          DatasourceNames2.ENSRoot,
+          "UniversalRegistrarRenewalWithReferrer"
+        ),
+        ethnamesNameWrapper
+      ].filter((c) => !!c)
+    },
+    ...basenamesRegistry && {
+      "base.eth": {
+        registry: basenamesRegistry,
+        contracts: [
+          basenamesRegistry,
+          maybeGetDatasourceContract(namespace, DatasourceNames2.Basenames, "BaseRegistrar"),
+          maybeGetDatasourceContract(namespace, DatasourceNames2.Basenames, "EARegistrarController"),
+          maybeGetDatasourceContract(namespace, DatasourceNames2.Basenames, "RegistrarController"),
+          maybeGetDatasourceContract(
+            namespace,
+            DatasourceNames2.Basenames,
+            "UpgradeableRegistrarController"
+          )
+        ].filter((c) => !!c)
+      }
+    },
+    ...lineanamesRegistry && {
+      "linea.eth": {
+        registry: lineanamesRegistry,
+        contracts: [
+          lineanamesRegistry,
+          maybeGetDatasourceContract(namespace, DatasourceNames2.Lineanames, "BaseRegistrar"),
+          maybeGetDatasourceContract(
+            namespace,
+            DatasourceNames2.Lineanames,
+            "EthRegistrarController"
+          ),
+          lineanamesNameWrapper
+        ].filter((c) => !!c)
+      }
+    }
+  };
+};
+var cache = /* @__PURE__ */ new Map();
+var getManagedName = (namespace, contract) => {
+  const cacheKey = `${namespace}:${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 = asInterpretedName(namespaceSpecific ?? managedName);
+      const node = namehashInterpretedName3(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,
+    DatasourceNames2.ENSRoot,
+    "NameWrapper"
+  );
+  if (accountIdEqual(ethnamesNameWrapper, contract)) return true;
+  const lineanamesNameWrapper = maybeGetDatasourceContract(
+    namespace,
+    DatasourceNames2.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
-import { makeRegistryId } from "enssdk";
-import { DatasourceNames as DatasourceNames5 } from "@ensnode/datasources";
-var getENSv1Registry = (namespace) => getDatasourceContract(namespace, DatasourceNames5.ENSRoot, "ENSv1Registry");
+import {
+  makeENSv1RegistryId,
+  makeENSv1VirtualRegistryId,
+  makeENSv2RegistryId
+} from "enssdk";
+import { DatasourceNames as DatasourceNames3 } from "@ensnode/datasources";
+var getENSv1Registry = (namespace) => getDatasourceContract(namespace, DatasourceNames3.ENSRoot, "ENSv1Registry");
+var getENSv1RootRegistryId = (namespace) => makeENSv1RegistryId(getENSv1Registry(namespace));
 var isENSv1Registry = (namespace, contract) => accountIdEqual(getENSv1Registry(namespace), contract);
-var getENSv2RootRegistry = (namespace) => getDatasourceContract(namespace, DatasourceNames5.ENSv2Root, "RootRegistry");
-var getENSv2RootRegistryId = (namespace) => makeRegistryId(getENSv2RootRegistry(namespace));
+var getENSv2RootRegistry = (namespace) => getDatasourceContract(namespace, DatasourceNames3.ENSv2Root, "RootRegistry");
+var getENSv2RootRegistryId = (namespace) => makeENSv2RegistryId(getENSv2RootRegistry(namespace));
 var isENSv2RootRegistry = (namespace, contract) => accountIdEqual(getENSv2RootRegistry(namespace), contract);
-var maybeGetENSv2RootRegistry = (namespace) => maybeGetDatasourceContract(namespace, DatasourceNames5.ENSv2Root, "RootRegistry");
+var maybeGetENSv2RootRegistry = (namespace) => maybeGetDatasourceContract(namespace, DatasourceNames3.ENSv2Root, "RootRegistry");
 var maybeGetENSv2RootRegistryId = (namespace) => {
   const root = maybeGetENSv2RootRegistry(namespace);
   if (!root) return void 0;
-  return makeRegistryId(root);
+  return makeENSv2RegistryId(root);
+};
+var getRootRegistryId = (namespace) => maybeGetENSv2RootRegistryId(namespace) ?? getENSv1RootRegistryId(namespace);
+var getRootRegistryIds = (namespace) => {
+  const v1RootRegistryId = getENSv1RootRegistryId(namespace);
+  const v2RootRegistryId = maybeGetENSv2RootRegistryId(namespace);
+  const basenamesRegistry = maybeGetDatasourceContract(
+    namespace,
+    DatasourceNames3.Basenames,
+    "Registry"
+  );
+  const lineanamesRegistry = maybeGetDatasourceContract(
+    namespace,
+    DatasourceNames3.Lineanames,
+    "Registry"
+  );
+  return [
+    v1RootRegistryId,
+    basenamesRegistry && makeENSv1VirtualRegistryId(
+      basenamesRegistry,
+      getManagedName(namespace, basenamesRegistry).node
+    ),
+    lineanamesRegistry && makeENSv1VirtualRegistryId(
+      lineanamesRegistry,
+      getManagedName(namespace, lineanamesRegistry).node
+    ),
+    v2RootRegistryId
+  ].filter((id) => !!id);
 };
 
 // src/shared/url.ts
@@ -4380,16 +4802,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 */);
@@ -4441,13 +4853,14 @@ export {
   DEFAULT_ENSNODE_URL_SEPOLIA,
   ENCODED_REFERRER_BYTE_LENGTH,
   ENCODED_REFERRER_BYTE_OFFSET,
-  ENSNamespaceIds7 as ENSNamespaceIds,
+  ENSNamespaceIds4 as ENSNamespaceIds,
   EXPECTED_ENCODED_REFERRER_PADDING,
   EnsApiIndexingStatusResponseCodes,
   EnsIndexerClient,
   EnsIndexerIndexingStatusResponseCodes,
   EnsNodeClient,
   ForwardResolutionProtocolStep,
+  IndexingMetadataContextStatusCodes,
   IndexingStatusResponseCodes,
   LruCache,
   NFTMintStatuses,
@@ -4482,9 +4895,12 @@ export {
   buildBlockRefRange,
   buildCrossChainIndexingStatusSnapshotOmnichain,
   buildEncodedReferrer,
+  buildEnsIndexerStackInfo,
   buildEnsNodeStackInfo,
   buildEnsRainbowClientLabelSet,
   buildIndexedBlockranges,
+  buildIndexingMetadataContextInitialized,
+  buildIndexingMetadataContextUninitialized,
   buildLabelSetId,
   buildLabelSetVersion,
   buildOmnichainIndexingStatusSnapshot,
@@ -4493,6 +4909,7 @@ export {
   buildUnvalidatedCrossChainIndexingStatusSnapshot,
   buildUnvalidatedEnsApiPublicConfig,
   buildUnvalidatedEnsIndexerPublicConfig,
+  buildUnvalidatedEnsIndexerStackInfo,
   buildUnvalidatedEnsNodeStackInfo,
   buildUnvalidatedOmnichainIndexingStatusSnapshot,
   buildUnvalidatedRealtimeIndexingStatusProjection,
@@ -4517,11 +4934,14 @@ export {
   deserializeEnsIndexerConfigResponse,
   deserializeEnsIndexerIndexingStatusResponse,
   deserializeEnsIndexerPublicConfig,
+  deserializeEnsIndexerStackInfo,
   deserializeEnsNodeStackInfo,
   deserializeErrorResponse2 as deserializeErrorResponse,
+  deserializeIndexingMetadataContext,
   deserializeIndexingStatusResponse,
   deserializeOmnichainIndexingStatusSnapshot,
   deserializePriceDai,
+  deserializePriceEnsTokens,
   deserializePriceEth,
   deserializePriceUsdc,
   deserializeRealtimeIndexingStatusProjection,
@@ -4531,21 +4951,17 @@ export {
   deserializedNameTokensResponse,
   durationBetween,
   formatNFTTransferEventMetadata,
-  getBasenamesSubregistryId,
-  getBasenamesSubregistryManagedName,
   getCurrencyInfo,
   getDatasourceContract,
   getDefaultEnsNodeUrl,
   getENSRootChainId,
   getENSv1Registry,
+  getENSv1RootRegistryId,
   getENSv2RootRegistry,
   getENSv2RootRegistryId,
-  getEthnamesSubregistryId,
-  getEthnamesSubregistryManagedName,
   getHighestKnownBlockTimestamp,
   getLatestIndexedBlockRef,
-  getLineanamesSubregistryId,
-  getLineanamesSubregistryManagedName,
+  getManagedName,
   getNFTTransferType,
   getNameTokenOwnership,
   getNameWrapperAccounts,
@@ -4553,6 +4969,8 @@ export {
   getOmnichainIndexingCursor,
   getOmnichainIndexingStatus,
   getResolvePrimaryNameChainIdParam,
+  getRootRegistryId,
+  getRootRegistryIds,
   getTimestampForHighestOmnichainKnownBlock,
   getTimestampForLowestOmnichainStartBlock,
   hasNullByte,
@@ -4571,6 +4989,7 @@ export {
   isENSv1Registry,
   isENSv2RootRegistry,
   isHttpProtocol,
+  isNameWrapper,
   isPccFuseSet,
   isPriceCurrencyEqual,
   isPriceEqual,
@@ -4598,14 +5017,17 @@ export {
   parseAccountId,
   parseAssetId,
   parseDai,
+  parseEnsTokens,
   parseEth,
   parseNonNegativeInteger,
   parseTimestamp,
   parseUsdc,
   priceDai,
+  priceEnsTokens,
   priceEth,
   priceUsdc,
   registrarActionsFilter,
+  replaceBigInts,
   scaleBigintByNumber,
   scalePrice,
   serializeAssetId,
@@ -4622,8 +5044,11 @@ export {
   serializeEnsIndexerConfigResponse,
   serializeEnsIndexerIndexingStatusResponse,
   serializeEnsIndexerPublicConfig,
+  serializeEnsIndexerStackInfo,
   serializeEnsNodeStackInfo,
   serializeIndexedChainIds,
+  serializeIndexingMetadataContext,
+  serializeIndexingMetadataContextInitialized,
   serializeIndexingStatusResponse,
   serializeNameToken,
   serializeNameTokensResponse,
@@ -4631,6 +5056,7 @@ export {
   serializeOmnichainIndexingStatusSnapshot,
   serializePrice,
   serializePriceDai,
+  serializePriceEnsTokens,
   serializePriceEth,
   serializePriceUsdc,
   serializeRealtimeIndexingStatusProjection,
@@ -4642,13 +5068,17 @@ export {
   sortChainStatusesByStartBlockAsc,
   stripNullBytes,
   subtractPrice,
+  toJson,
   translateDefaultableChainIdToChainId,
   uniq,
   validateChainIndexingStatusSnapshot,
   validateCrossChainIndexingStatusSnapshot,
   validateEnsIndexerPublicConfig,
   validateEnsIndexerPublicConfigCompatibility,
+  validateEnsIndexerStackInfo,
   validateEnsIndexerVersionInfo,
+  validateEnsNodeStackInfo,
+  validateIndexingMetadataContextInitialized,
   validateOmnichainIndexingStatusSnapshot,
   validateRealtimeIndexingStatusProjection,
   validateSupportedLabelSetAndVersion