@ensnode/ensnode-sdk 1.9.0 → 1.10.1

package/dist/index.js

@@ -1,228 +1,13 @@
-// src/ens/index.ts
-import { getENSRootChainId } from "@ensnode/datasources";
-
-// src/ens/coin-type.ts
-import {
-  coinTypeToEvmChainId as _coinTypeToEvmChainId,
-  evmChainIdToCoinType as _evmChainIdToCoinType
-} from "@ensdomains/address-encoder/utils";
-var ETH_COIN_TYPE = 60;
-var DEFAULT_EVM_CHAIN_ID = 0;
-var DEFAULT_EVM_COIN_TYPE = 2147483648;
-var coinTypeToEvmChainId = (coinType) => {
-  if (coinType === ETH_COIN_TYPE) return 1;
-  return _coinTypeToEvmChainId(coinType);
-};
-var evmChainIdToCoinType = (chainId) => {
-  if (chainId === 1) return ETH_COIN_TYPE;
-  return _evmChainIdToCoinType(chainId);
-};
-var bigintToCoinType = (value) => {
-  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new Error(`'${value}' cannot represent as CoinType, it is too large.`);
-  }
-  return Number(value);
-};
-
-// src/ens/constants.ts
-import { namehash, zeroHash } from "viem";
-var ROOT_NODE = namehash("");
-var ETH_NODE = namehash("eth");
-var BASENAMES_NODE = namehash("base.eth");
-var LINEANAMES_NODE = namehash("linea.eth");
-var ADDR_REVERSE_NODE = namehash("addr.reverse");
-var NODE_ANY = zeroHash;
-var ROOT_RESOURCE = 0n;
-
-// src/ens/dns-encoded-name.ts
-import { bytesToString, hexToBytes } from "viem";
-function decodeDNSEncodedLiteralName(packet) {
-  return decodeDNSEncodedName(packet);
-}
-function decodeDNSEncodedName(packet) {
-  const segments = [];
-  const bytes = hexToBytes(packet);
-  if (bytes.length === 0) throw new Error(`Packet is empty.`);
-  let offset = 0;
-  while (offset < bytes.length) {
-    const len = bytes[offset];
-    if (len === void 0) {
-      throw new Error(`Invariant: bytes[offset] is undefined after offset < bytes.length check.`);
-    }
-    if (len < 0 || len > 255) {
-      throw new Error(
-        `Invariant: this should be literally impossible, but an unsigned byte was less than zero or greater than 255. The value in question is ${len}`
-      );
-    }
-    if (len === 0) break;
-    const segment = bytesToString(bytes.subarray(offset + 1, offset + len + 1));
-    segments.push(segment);
-    offset += len + 1;
-  }
-  if (offset >= bytes.length) throw new Error(`Overflow, offset >= bytes.length`);
-  if (offset !== bytes.length - 1) throw new Error(`Junk at end of name`);
-  return segments;
-}
-
-// src/ens/labelhash.ts
-import { isHex } from "viem";
-function isLabelHash(maybeLabelHash) {
-  const expectedLength = maybeLabelHash.length === 66;
-  const expectedEncoding = isHex(maybeLabelHash);
-  const expectedCasing = maybeLabelHash === maybeLabelHash.toLowerCase();
-  return expectedLength && expectedEncoding && expectedCasing;
-}
+// src/index.ts
+import { ENSNamespaceIds as ENSNamespaceIds7 } from "@ensnode/datasources";
 
-// src/ens/encode-labelhash.ts
-var encodeLabelHash = (labelHash) => `[${labelHash.slice(2)}]`;
-function isEncodedLabelHash(maybeEncodedLabelHash) {
-  const expectedFormatting = maybeEncodedLabelHash.startsWith("[") && maybeEncodedLabelHash.endsWith("]");
-  const includesLabelHash = isLabelHash(`0x${maybeEncodedLabelHash.slice(1, -1)}`);
-  return expectedFormatting && includesLabelHash;
-}
+// src/ens/index.ts
+import { ENSNamespaceIds, getENSRootChainId } from "@ensnode/datasources";
 
 // src/ens/fuses.ts
 var PARENT_CANNOT_CONTROL = 65536;
 var isPccFuseSet = (fuses) => (fuses & PARENT_CANNOT_CONTROL) === PARENT_CANNOT_CONTROL;
 
-// src/ens/is-normalized.ts
-import { normalize } from "viem/ens";
-function isNormalizedName(name) {
-  try {
-    return name === normalize(name);
-  } catch {
-    return false;
-  }
-}
-function isNormalizedLabel(label) {
-  if (label === "") return false;
-  if (label.includes(".")) return false;
-  try {
-    return label === normalize(label);
-  } catch {
-    return false;
-  }
-}
-
-// src/ens/names.ts
-import { ens_beautify } from "@adraffy/ens-normalize";
-var ENS_ROOT = "";
-var getNameHierarchy = (name) => name.split(".").map((_, i, labels) => labels.slice(i).join("."));
-var getParentNameFQDN = (name) => {
-  if (name === ENS_ROOT) {
-    throw new Error("There is no parent name for ENS Root.");
-  }
-  const labels = name.split(".");
-  if (labels.length === 1) {
-    return ENS_ROOT;
-  }
-  return labels.slice(1).join(".");
-};
-var beautifyName = (name) => {
-  const beautifiedLabels = name.split(".").map((label) => {
-    if (isNormalizedLabel(label)) {
-      return ens_beautify(label);
-    } else {
-      return label;
-    }
-  });
-  return beautifiedLabels.join(".");
-};
-
-// src/ens/parse-labelhash.ts
-import { isHex as isHex2 } from "viem";
-function parseLabelHash(maybeLabelHash) {
-  const hexPart = maybeLabelHash.startsWith("0x") ? maybeLabelHash.slice(2) : maybeLabelHash;
-  if (!isHex2(`0x${hexPart}`, { strict: true })) {
-    throw new Error(`Invalid labelHash: contains non-hex characters: ${maybeLabelHash}`);
-  }
-  const normalizedHexPart = hexPart.length % 2 === 1 ? `0${hexPart}` : hexPart;
-  if (normalizedHexPart.length !== 64) {
-    throw new Error(
-      `Invalid labelHash length: expected 32 bytes (64 hex chars), got ${normalizedHexPart.length / 2} bytes: ${maybeLabelHash}`
-    );
-  }
-  return `0x${normalizedHexPart.toLowerCase()}`;
-}
-function parseEncodedLabelHash(maybeEncodedLabelHash) {
-  if (!maybeEncodedLabelHash.startsWith("[") || !maybeEncodedLabelHash.endsWith("]")) {
-    throw new Error(
-      `Invalid encoded labelHash: must be enclosed in square brackets: ${maybeEncodedLabelHash}`
-    );
-  }
-  return parseLabelHash(maybeEncodedLabelHash.slice(1, -1));
-}
-function parseLabelHashOrEncodedLabelHash(maybeLabelHash) {
-  if (maybeLabelHash.startsWith("[") && maybeLabelHash.endsWith("]")) {
-    return parseEncodedLabelHash(maybeLabelHash);
-  }
-  return parseLabelHash(maybeLabelHash);
-}
-
-// src/ens/parse-reverse-name.ts
-import { hexToBigInt, isAddress } from "viem";
-
-// src/shared/address.ts
-function asLowerCaseAddress(address) {
-  return address.toLowerCase();
-}
-
-// src/ens/parse-reverse-name.ts
-var REVERSE_NAME_REGEX = /^([0-9a-fA-F]+)\.([0-9a-f]{1,64}|addr|default)\.reverse$/;
-var parseAddressLabel = (addressLabel) => {
-  const maybeAddress = `0x${addressLabel}`;
-  if (!isAddress(maybeAddress)) {
-    throw new Error(`Invalid EVM address "${maybeAddress}"`);
-  }
-  return asLowerCaseAddress(maybeAddress);
-};
-var parseCoinTypeLabel = (coinTypeLabel) => {
-  if (coinTypeLabel === "default") return DEFAULT_EVM_COIN_TYPE;
-  if (coinTypeLabel === "addr") return ETH_COIN_TYPE;
-  return bigintToCoinType(hexToBigInt(`0x${coinTypeLabel}`));
-};
-function parseReverseName(name) {
-  const match = name.match(REVERSE_NAME_REGEX);
-  if (!match) return null;
-  try {
-    const [, addressLabel, coinTypeLabel] = match;
-    if (!addressLabel) return null;
-    if (!coinTypeLabel) return null;
-    return {
-      address: parseAddressLabel(addressLabel),
-      coinType: parseCoinTypeLabel(coinTypeLabel)
-    };
-  } catch {
-    return null;
-  }
-}
-
-// src/ens/reverse-name.ts
-var addrReverseLabel = (address) => address.slice(2);
-var coinTypeReverseLabel = (coinType) => coinType.toString(16);
-function reverseName(address, coinType) {
-  const label = addrReverseLabel(address);
-  const middle = (() => {
-    switch (coinType) {
-      case ETH_COIN_TYPE:
-        return "addr";
-      case DEFAULT_EVM_COIN_TYPE:
-        return "default";
-      default:
-        return coinTypeReverseLabel(coinType);
-    }
-  })();
-  return `${label}.${middle}.reverse`;
-}
-
-// src/ens/subname-helpers.ts
-import { concat, keccak256, toHex } from "viem";
-var makeSubdomainNode = (labelHash, node) => keccak256(concat([node, labelHash]));
-var uint256ToHex32 = (num) => toHex(num, { size: 32 });
-
-// src/ens/types.ts
-import { ENSNamespaceIds } from "@ensnode/datasources";
-
 // src/ensapi/config/deserialize.ts
 import { prettifyError as prettifyError2 } from "zod/v4";
 
@@ -237,7 +22,8 @@ import { z as z2 } from "zod/v4";
 
 // src/shared/zod-schemas.ts
 import { AccountId as CaipAccountId } from "caip";
-import { isAddress as isAddress2, isHex as isHex3, size } from "viem";
+import { reinterpretName, toNormalizedAddress } from "enssdk";
+import { isAddress, isHex, size } from "viem";
 import { z } from "zod/v4";
 
 // src/shared/currencies.ts
@@ -354,6 +140,32 @@ function addPrices(...prices) {
     }
   );
 }
+function subtractPrice(a, b) {
+  if (!isPriceCurrencyEqual(a, b)) {
+    throw new Error("All prices must have the same currency to be subtracted.");
+  }
+  const resultAmount = a.amount - b.amount;
+  if (resultAmount < 0n) {
+    throw new Error("subtractPrice result must be non-negative.");
+  }
+  return { amount: resultAmount, currency: a.currency };
+}
+function minPrice(...prices) {
+  const firstPrice = prices[0];
+  const allPricesInSameCurrency = prices.every((price) => isPriceCurrencyEqual(firstPrice, price));
+  if (allPricesInSameCurrency === false) {
+    throw new Error("All prices must have the same currency to be compared.");
+  }
+  return prices.reduce((acc, price) => price.amount < acc.amount ? price : acc);
+}
+function maxPrice(...prices) {
+  const firstPrice = prices[0];
+  const allPricesInSameCurrency = prices.every((price) => isPriceCurrencyEqual(firstPrice, price));
+  if (allPricesInSameCurrency === false) {
+    throw new Error("All prices must have the same currency to be compared.");
+  }
+  return prices.reduce((acc, price) => price.amount > acc.amount ? price : acc);
+}
 function scalePrice(price, scaleFactor) {
   const scaledAmount = scaleBigintByNumber(price.amount, scaleFactor);
   return {
@@ -392,26 +204,6 @@ function parseDai(value) {
   return priceDai(amount);
 }
 
-// src/shared/interpretation/reinterpretation.ts
-import { labelhash as labelToLabelHash } from "viem";
-function reinterpretLabel(label) {
-  if (label === "") {
-    throw new Error(
-      `Cannot reinterpret an empty label that violates the invariants of an InterpretedLabel.`
-    );
-  }
-  if (isEncodedLabelHash(label)) return label;
-  if (isNormalizedLabel(label)) return label;
-  return encodeLabelHash(labelToLabelHash(label));
-}
-function reinterpretName(name) {
-  if (name === "") return name;
-  const interpretedLabels = name.split(".");
-  const reinterpretedLabels = interpretedLabels.map(reinterpretLabel);
-  const reinterpretedName = reinterpretedLabels.join(".");
-  return reinterpretedName;
-}
-
 // src/shared/zod-schemas.ts
 var makeIntegerSchema = (valueLabel = "Value") => z.int({
   error: `${valueLabel} must be an integer.`
@@ -427,15 +219,15 @@ var makeDurationSchema = (valueLabel = "Value") => z.number({
 }).pipe(makeNonNegativeIntegerSchema(valueLabel));
 var makeChainIdSchema = (valueLabel = "Chain ID") => makePositiveIntegerSchema(valueLabel).transform((val) => val);
 var makeChainIdStringSchema = (valueLabel = "Chain ID String") => z.string({ error: `${valueLabel} must be a string representing a chain ID.` }).pipe(z.coerce.number({ error: `${valueLabel} must represent a positive integer (>0).` })).pipe(makeChainIdSchema(`The numeric value represented by ${valueLabel}`));
-var makeLowercaseAddressSchema = (valueLabel = "EVM address") => z.string().check((ctx) => {
-  if (!isAddress2(ctx.value)) {
+var makeNormalizedAddressSchema = (valueLabel = "EVM address") => z.string().check((ctx) => {
+  if (!isAddress(ctx.value, { strict: false })) {
     ctx.issues.push({
       code: "custom",
       message: `${valueLabel} must be a valid EVM address`,
       input: ctx.value
     });
   }
-}).transform((val) => asLowerCaseAddress(val));
+}).transform((val) => toNormalizedAddress(val));
 var makeDatetimeSchema = (valueLabel = "Datetime string") => z.iso.datetime({ error: `${valueLabel} must be a string in ISO 8601 format.` }).transform((v) => new Date(v));
 var makeUnixTimestampSchema = (valueLabel = "Timestamp") => makeIntegerSchema(valueLabel);
 var makeUrlSchema = (valueLabel = "Value") => z.url({
@@ -473,7 +265,7 @@ var makePriceUsdcSchema = (valueLabel = "Price USDC") => makePriceCurrencySchema
 var makePriceDaiSchema = (valueLabel = "Price DAI") => makePriceCurrencySchema(CurrencyIds.DAI, valueLabel).transform((v) => v);
 var makeAccountIdSchema = (valueLabel = "AccountId") => z.strictObject({
   chainId: makeChainIdSchema(`${valueLabel} chain ID`),
-  address: makeLowercaseAddressSchema(`${valueLabel} address`)
+  address: makeNormalizedAddressSchema(`${valueLabel} address`)
 });
 var makeAccountIdStringSchema = (valueLabel = "Account ID String") => z.coerce.string().transform((v) => {
   const result = new CaipAccountId(v);
@@ -483,7 +275,7 @@ var makeAccountIdStringSchema = (valueLabel = "Account ID String") => z.coerce.s
   };
 }).pipe(makeAccountIdSchema(valueLabel));
 var makeHexStringSchema = (options, valueLabel = "String representation of bytes array") => z.string().check(function invariant_isHexEncoded(ctx) {
-  if (!isHex3(ctx.value)) {
+  if (!isHex(ctx.value)) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -522,9 +314,8 @@ var makeLabelSetIdSchema = (valueLabel = "Label set ID") => {
     error: `${valueLabel} can only contain lowercase letters (a-z) and hyphens (-)`
   });
 };
-var makeLabelSetVersionSchema = (valueLabel = "Label set version") => {
-  return z2.coerce.number({ error: `${valueLabel} must be an integer.` }).pipe(makeNonNegativeIntegerSchema(valueLabel));
-};
+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({
@@ -569,7 +360,7 @@ function buildLabelSetId(maybeLabelSetId) {
   return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
 }
 function buildLabelSetVersion(maybeLabelSetVersion) {
-  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
+  return makeLabelSetVersionStringSchema("LabelSetVersion").parse(maybeLabelSetVersion);
 }
 function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
   if (labelSetVersion !== void 0 && labelSetId === void 0) {
@@ -621,7 +412,7 @@ var makePluginsListSchema = (valueLabel = "Plugins") => z3.array(z3.string(), {
 }).refine((arr) => arr.length === uniq(arr).length, {
   error: `${valueLabel} cannot contain duplicate values.`
 });
-var makeDatabaseSchemaNameSchema = (valueLabel = "Database schema name") => z3.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
+var makeEnsIndexerSchemaNameSchema = (valueLabel = "ENS Indexer Schema Name") => z3.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
   error: `${valueLabel} is required and must be a non-empty string.`
 });
 var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
@@ -636,13 +427,12 @@ var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
   }
   return z3.object({
     labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
-    labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
+    labelSetVersion: makeLabelSetVersionStringSchema(valueLabelLabelSetVersion)
   });
 };
 var makeNonEmptyStringSchema = (valueLabel = "Value") => z3.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
 var makeEnsIndexerVersionInfoSchema = (valueLabel = "Value") => z3.object(
   {
-    nodejs: makeNonEmptyStringSchema(),
     ponder: makeNonEmptyStringSchema(),
     ensDb: makeNonEmptyStringSchema(),
     ensIndexer: makeNonEmptyStringSchema(),
@@ -677,7 +467,7 @@ function invariant_ensRainbowSupportedLabelSetAndVersion(ctx) {
   }
 }
 var makeEnsIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => z3.object({
-  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
+  ensIndexerSchemaName: makeEnsIndexerSchemaNameSchema(`${valueLabel}.ensIndexerSchemaName`),
   ensRainbowPublicConfig: makeEnsRainbowPublicConfigSchema(
     `${valueLabel}.ensRainbowPublicConfig`
   ),
@@ -691,7 +481,7 @@ var makeEnsIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") =
   versionInfo: makeEnsIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
 }).check(invariant_isSubgraphCompatibleRequirements).check(invariant_ensRainbowSupportedLabelSetAndVersion);
 var makeSerializedEnsIndexerPublicConfigSchema = (valueLabel = "Serialized ENSIndexerPublicConfig") => z3.object({
-  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
+  ensIndexerSchemaName: makeEnsIndexerSchemaNameSchema(`${valueLabel}.ensIndexerSchemaName`),
   ensRainbowPublicConfig: makeEnsRainbowPublicConfigSchema(
     `${valueLabel}.ensRainbowPublicConfig`
   ),
@@ -745,23 +535,27 @@ var TheGraphFallbackSchema = z4.discriminatedUnion("canFallback", [
 ]);
 
 // src/ensapi/config/zod-schemas.ts
+var makeEnsApiVersionInfoSchema = (valueLabel = "ENS API version info") => z5.object({
+  ensApi: z5.string().nonempty(`${valueLabel}.ensApi must be a non-empty string`),
+  ensNormalize: z5.string().nonempty(`${valueLabel}.ensNormalize must be a non-empty string`)
+});
 function makeEnsApiPublicConfigSchema(valueLabel) {
   const label = valueLabel ?? "ENSApiPublicConfig";
   return z5.object({
-    version: z5.string().min(1, `${label}.version must be a non-empty string`),
     theGraphFallback: TheGraphFallbackSchema,
-    ensIndexerPublicConfig: makeEnsIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
+    ensIndexerPublicConfig: makeEnsIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`),
+    versionInfo: makeEnsApiVersionInfoSchema(`${label}.versionInfo`)
   });
 }
 var makeENSApiPublicConfigSchema = makeEnsApiPublicConfigSchema;
 function makeSerializedEnsApiPublicConfigSchema(valueLabel) {
   const label = valueLabel ?? "ENSApiPublicConfig";
   return z5.object({
-    version: z5.string().min(1, `${label}.version must be a non-empty string`),
-    theGraphFallback: TheGraphFallbackSchema,
     ensIndexerPublicConfig: makeSerializedEnsIndexerPublicConfigSchema(
       `${label}.ensIndexerPublicConfig`
-    )
+    ),
+    theGraphFallback: TheGraphFallbackSchema,
+    versionInfo: makeEnsApiVersionInfoSchema(`${label}.versionInfo`)
   });
 }
 
@@ -785,19 +579,13 @@ ${prettifyError2(parsed.error)}
 }
 var deserializeENSApiPublicConfig = deserializeEnsApiPublicConfig;
 
-// src/ensapi/api/config/deserialize.ts
-function deserializeEnsApiConfigResponse(maybeResponse) {
-  return deserializeEnsApiPublicConfig(maybeResponse);
-}
-var deserializeConfigResponse = deserializeEnsApiConfigResponse;
-
 // src/ensindexer/config/serialize.ts
 function serializeIndexedChainIds(indexedChainIds) {
   return Array.from(indexedChainIds);
 }
 function serializeEnsIndexerPublicConfig(config) {
   const {
-    databaseSchemaName,
+    ensIndexerSchemaName,
     ensRainbowPublicConfig,
     indexedChainIds,
     isSubgraphCompatible: isSubgraphCompatible2,
@@ -807,7 +595,7 @@ function serializeEnsIndexerPublicConfig(config) {
     versionInfo
   } = config;
   return {
-    databaseSchemaName,
+    ensIndexerSchemaName,
     ensRainbowPublicConfig,
     indexedChainIds: serializeIndexedChainIds(indexedChainIds),
     isSubgraphCompatible: isSubgraphCompatible2,
@@ -821,22 +609,26 @@ var serializeENSIndexerPublicConfig = serializeEnsIndexerPublicConfig;
 
 // src/ensapi/config/serialize.ts
 function serializeEnsApiPublicConfig(config) {
-  const { version, theGraphFallback, ensIndexerPublicConfig } = config;
+  const { ensIndexerPublicConfig, theGraphFallback, versionInfo } = config;
   return {
-    version,
+    ensIndexerPublicConfig: serializeEnsIndexerPublicConfig(ensIndexerPublicConfig),
     theGraphFallback,
-    ensIndexerPublicConfig: serializeEnsIndexerPublicConfig(ensIndexerPublicConfig)
+    versionInfo
   };
 }
 var serializeENSApiPublicConfig = serializeEnsApiPublicConfig;
 
-// src/ensapi/api/config/serialize.ts
-function serializeEnsApiConfigResponse(response) {
-  return serializeEnsApiPublicConfig(response);
+// src/ensindexer/api/config/deserialize.ts
+function deserializeEnsIndexerConfigResponse(maybeResponse) {
+  return deserializeEnsIndexerPublicConfig(maybeResponse, "EnsIndexerConfigResponse");
+}
+
+// src/ensindexer/api/config/serialize.ts
+function serializeEnsIndexerConfigResponse(response) {
+  return serializeEnsIndexerPublicConfig(response);
 }
-var serializeConfigResponse = serializeEnsApiConfigResponse;
 
-// src/ensapi/api/indexing-status/deserialize.ts
+// src/ensindexer/api/indexing-status/deserialize.ts
 import { prettifyError as prettifyError8 } from "zod/v4";
 
 // src/indexing-status/deserialize/realtime-indexing-status-projection.ts
@@ -1763,8 +1555,8 @@ ${prettifyError7(parsed.error)}
   return parsed.data;
 }
 
-// src/ensapi/api/indexing-status/response.ts
-var EnsApiIndexingStatusResponseCodes = {
+// src/ensindexer/api/indexing-status/response.ts
+var EnsIndexerIndexingStatusResponseCodes = {
   /**
    * Represents that the indexing status is available.
    */
@@ -1774,33 +1566,32 @@ var EnsApiIndexingStatusResponseCodes = {
    */
   Error: "error"
 };
-var IndexingStatusResponseCodes = EnsApiIndexingStatusResponseCodes;
 
-// src/ensapi/api/indexing-status/zod-schemas.ts
+// src/ensindexer/api/indexing-status/zod-schemas.ts
 import { z as z10 } from "zod/v4";
-var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z10.strictObject({
-  responseCode: z10.literal(EnsApiIndexingStatusResponseCodes.Ok),
+var makeEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z10.strictObject({
+  responseCode: z10.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => z10.strictObject({
-  responseCode: z10.literal(EnsApiIndexingStatusResponseCodes.Error)
+var makeEnsIndexerIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => z10.strictObject({
+  responseCode: z10.literal(EnsIndexerIndexingStatusResponseCodes.Error)
 });
-var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z10.discriminatedUnion("responseCode", [
-  makeEnsApiIndexingStatusResponseOkSchema(valueLabel),
-  makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
+var makeEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z10.discriminatedUnion("responseCode", [
+  makeEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
 ]);
-var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => z10.strictObject({
-  responseCode: z10.literal(EnsApiIndexingStatusResponseCodes.Ok),
+var makeSerializedEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => z10.strictObject({
+  responseCode: z10.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => z10.discriminatedUnion("responseCode", [
-  makeSerializedEnsApiIndexingStatusResponseOkSchema(valueLabel),
-  makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
+var makeSerializedEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => z10.discriminatedUnion("responseCode", [
+  makeSerializedEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
 ]);
 
-// src/ensapi/api/indexing-status/deserialize.ts
-function buildUnvalidatedEnsApiIndexingStatusResponse(serializedResponse) {
-  if (serializedResponse.responseCode !== EnsApiIndexingStatusResponseCodes.Ok) {
+// src/ensindexer/api/indexing-status/deserialize.ts
+function buildUnvalidatedEnsIndexerIndexingStatusResponse(serializedResponse) {
+  if (serializedResponse.responseCode !== EnsIndexerIndexingStatusResponseCodes.Ok) {
     return serializedResponse;
   }
   return {
@@ -1810,21 +1601,19 @@ function buildUnvalidatedEnsApiIndexingStatusResponse(serializedResponse) {
     )
   };
 }
-function deserializeEnsApiIndexingStatusResponse(maybeResponse) {
-  const parsed = makeSerializedEnsApiIndexingStatusResponseSchema().transform(buildUnvalidatedEnsApiIndexingStatusResponse).pipe(makeEnsApiIndexingStatusResponseSchema()).safeParse(maybeResponse);
+function deserializeEnsIndexerIndexingStatusResponse(maybeResponse) {
+  const parsed = makeSerializedEnsIndexerIndexingStatusResponseSchema().transform(buildUnvalidatedEnsIndexerIndexingStatusResponse).pipe(makeEnsIndexerIndexingStatusResponseSchema()).safeParse(maybeResponse);
   if (parsed.error) {
     throw new Error(
-      `Cannot deserialize EnsApiIndexingStatusResponse:
+      `Cannot deserialize EnsIndexerIndexingStatusResponse:
 ${prettifyError8(parsed.error)}
 `
     );
   }
   return parsed.data;
 }
-var deserializeIndexingStatusResponse = deserializeEnsApiIndexingStatusResponse;
 
 // src/shared/serialize.ts
-import { AccountId as CaipAccountId2, AssetId as CaipAssetId } from "caip";
 function serializeChainId(chainId) {
   return chainId.toString();
 }
@@ -1849,23 +1638,6 @@ function serializePriceUsdc(price) {
 function serializePriceDai(price) {
   return serializePrice(price);
 }
-function formatAccountId(accountId) {
-  return CaipAccountId2.format({
-    chainId: { namespace: "eip155", reference: accountId.chainId.toString() },
-    address: accountId.address
-  }).toLowerCase();
-}
-function formatAssetId({
-  assetNamespace,
-  contract: { chainId, address },
-  tokenId
-}) {
-  return CaipAssetId.format({
-    chainId: { namespace: "eip155", reference: chainId.toString() },
-    assetName: { namespace: assetNamespace, reference: address },
-    tokenId: uint256ToHex32(tokenId)
-  }).toLowerCase();
-}
 
 // src/indexing-status/serialize/chain-indexing-status-snapshot.ts
 function serializeChainIndexingSnapshots(chains) {
@@ -1937,160 +1709,532 @@ function serializeRealtimeIndexingStatusProjection(indexingProjection) {
   };
 }
 
-// src/ensapi/api/indexing-status/serialize.ts
-function serializeEnsApiIndexingStatusResponse(response) {
+// src/ensindexer/api/indexing-status/serialize.ts
+function serializeEnsIndexerIndexingStatusResponse(response) {
   switch (response.responseCode) {
-    case EnsApiIndexingStatusResponseCodes.Ok:
+    case EnsIndexerIndexingStatusResponseCodes.Ok:
       return {
         responseCode: response.responseCode,
         realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection)
       };
-    case EnsApiIndexingStatusResponseCodes.Error:
+    case EnsIndexerIndexingStatusResponseCodes.Error:
       return response;
   }
 }
-var serializeIndexingStatusResponse = serializeEnsApiIndexingStatusResponse;
-
-// src/ensapi/api/name-tokens/deserialize.ts
-import { prettifyError as prettifyError10 } from "zod/v4";
-
-// src/ensapi/api/name-tokens/zod-schemas.ts
-import { namehash as namehash2 } from "viem";
-import { z as z13 } from "zod/v4";
-
-// src/tokenscope/name-token.ts
-import { isAddressEqual as isAddressEqual3, zeroAddress as zeroAddress3 } from "viem";
-import { DatasourceNames } from "@ensnode/datasources";
-
-// src/shared/account-id.ts
-import { isAddressEqual } from "viem";
-var accountIdEqual = (a, b) => {
-  return a.chainId === b.chainId && isAddressEqual(a.address, b.address);
-};
-
-// src/shared/datasource-contract.ts
-import {
-  maybeGetDatasource
-} from "@ensnode/datasources";
-var maybeGetDatasourceContract = (namespaceId, datasourceName, contractName) => {
-  const datasource = maybeGetDatasource(namespaceId, datasourceName);
-  if (!datasource) return void 0;
-  const address = datasource.contracts[contractName]?.address;
-  if (address === void 0 || Array.isArray(address)) return void 0;
-  return {
-    chainId: datasource.chain.id,
-    address
-  };
-};
-var getDatasourceContract = (namespaceId, datasourceName, contractName) => {
-  const contract = maybeGetDatasourceContract(namespaceId, datasourceName, contractName);
-  if (!contract) {
-    throw new Error(
-      `Expected contract not found for ${namespaceId} ${datasourceName} ${contractName}`
-    );
-  }
-  return contract;
-};
-var makeContractMatcher = (namespace, b) => (datasourceName, contractName) => {
-  const a = maybeGetDatasourceContract(namespace, datasourceName, contractName);
-  return a && accountIdEqual(a, b);
-};
 
-// src/tokenscope/assets.ts
-import { isAddressEqual as isAddressEqual2, zeroAddress as zeroAddress2 } from "viem";
+// src/ensindexer/api/shared/errors/deserialize.ts
 import { prettifyError as prettifyError9 } from "zod/v4";
 
-// src/tokenscope/zod-schemas.ts
-import { AssetId as CaipAssetId2 } from "caip";
-import { zeroAddress } from "viem";
+// src/ensindexer/api/shared/errors/zod-schemas.ts
 import { z as z11 } from "zod/v4";
+var ErrorResponseSchema = z11.object({
+  message: z11.string(),
+  details: z11.optional(z11.unknown())
+});
 
-// src/shared/types.ts
-var AssetNamespaces = {
-  ERC721: "erc721",
-  ERC1155: "erc1155"
-};
-
-// src/tokenscope/zod-schemas.ts
-var tokenIdSchemaSerializable = z11.string();
-var tokenIdSchemaNative = z11.preprocess(
-  (v) => typeof v === "string" ? BigInt(v) : v,
-  z11.bigint().positive()
-);
-function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false) {
-  if (serializable) {
-    return tokenIdSchemaSerializable;
-  } else {
-    return tokenIdSchemaNative;
+// src/ensindexer/api/shared/errors/deserialize.ts
+function deserializeErrorResponse(maybeErrorResponse) {
+  const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ErrorResponse:
+${prettifyError9(parsed.error)}
+`);
   }
+  return parsed.data;
 }
-var makeAssetIdSchema = (valueLabel = "Asset ID Schema", serializable) => {
-  return z11.object({
-    assetNamespace: z11.enum(AssetNamespaces),
-    contract: makeAccountIdSchema(valueLabel),
-    tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
-  });
-};
-var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => z11.preprocess((v) => {
-  if (typeof v === "string") {
-    const result = new CaipAssetId2(v);
-    return {
-      assetNamespace: result.assetName.namespace,
-      contract: {
-        chainId: Number(result.chainId.reference),
-        address: result.assetName.reference
-      },
-      tokenId: result.tokenId
-    };
-  }
-  return v;
-}, makeAssetIdSchema(valueLabel));
-function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
-  const ownership = ctx.value;
-  if (ctx.value.owner.address === zeroAddress) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: `Name Token Ownership with '${ownership.ownershipType}' must have 'address' other than the zero address.`
-    });
+
+// src/ensindexer/client.ts
+var EnsIndexerClient = class {
+  constructor(options) {
+    this.options = options;
   }
-}
-var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => z11.object({
-  ownershipType: z11.literal(NameTokenOwnershipTypes.NameWrapper),
-  owner: makeAccountIdSchema(`${valueLabel}.owner`)
-}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => z11.object({
-  ownershipType: z11.literal(NameTokenOwnershipTypes.FullyOnchain),
-  owner: makeAccountIdSchema(`${valueLabel}.owner`)
-}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => z11.object({
-  ownershipType: z11.literal(NameTokenOwnershipTypes.Burned),
-  owner: makeAccountIdSchema(`${valueLabel}.owner`)
-}).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
-var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => z11.object({
-  ownershipType: z11.literal(NameTokenOwnershipTypes.Unknown),
-  owner: makeAccountIdSchema(`${valueLabel}.owner`)
-}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
-  const ownership = ctx.value;
-  if (ctx.value.owner.address !== zeroAddress) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: `Name Token Ownership with '${ownership.ownershipType}' must have 'address' set to the zero address.`
+  getOptions() {
+    return Object.freeze({
+      url: new URL(this.options.url.href)
     });
   }
-}
-var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => z11.discriminatedUnion("ownershipType", [
+  /**
+   * Fetch ENSIndexer Config
+   *
+   * Fetch the ENSIndexer's configuration.
+   *
+   * @returns {EnsIndexerConfigResponse}
+   *
+   * @throws if the ENSIndexer request fails
+   * @throws if the ENSIndexer returns a non-ok response
+   * @throws if the ENSIndexer response breaks required invariants
+   */
+  async config() {
+    const url = new URL(`/api/config`, this.options.url);
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    if (!response.ok) {
+      const errorResponse = deserializeErrorResponse(responseData);
+      throw new Error(`Fetching ENSIndexer Config Failed: ${errorResponse.message}`);
+    }
+    return deserializeEnsIndexerConfigResponse(
+      responseData
+    );
+  }
+  /**
+   * Fetch ENSIndexer Indexing Status
+   *
+   * @returns {EnsIndexerIndexingStatusResponse}
+   *
+   * @throws if the ENSIndexer request fails
+   * @throws if the ENSIndexer returns a non-ok response
+   * @throws if the ENSIndexer response breaks required invariants
+   */
+  async indexingStatus() {
+    const url = new URL(`/api/indexing-status`, this.options.url);
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    if (!response.ok) {
+      let errorResponse;
+      try {
+        errorResponse = deserializeErrorResponse(responseData);
+      } catch {
+      }
+      if (typeof errorResponse !== "undefined") {
+        throw new Error(`Fetching ENSIndexer Indexing Status Failed: ${errorResponse.message}`);
+      }
+    }
+    return deserializeEnsIndexerIndexingStatusResponse(
+      responseData
+    );
+  }
+};
+
+// src/ensindexer/config/compatibility.ts
+function validateEnsIndexerPublicConfigCompatibility(configA, configB) {
+  if (configA.indexedChainIds.symmetricDifference(configB.indexedChainIds).size > 0) {
+    throw new Error(
+      [
+        `'indexedChainIds' must be compatible.`,
+        `Stored Config 'indexedChainIds': '${Array.from(configA.indexedChainIds).join(", ")}'.`,
+        `Current Config 'indexedChainIds': '${Array.from(configB.indexedChainIds).join(", ")}'.`
+      ].join(" ")
+    );
+  }
+  if (configA.isSubgraphCompatible !== configB.isSubgraphCompatible) {
+    throw new Error(
+      [
+        `'isSubgraphCompatible' flag must be compatible.`,
+        `Stored Config 'isSubgraphCompatible' flag: '${configA.isSubgraphCompatible}'.`,
+        `Current Config 'isSubgraphCompatible' flag: '${configB.isSubgraphCompatible}'.`
+      ].join(" ")
+    );
+  }
+  if (configA.namespace !== configB.namespace) {
+    throw new Error(
+      [
+        `'namespace' must be compatible.`,
+        `Stored Config 'namespace': '${configA.namespace}'.`,
+        `Current Config 'namespace': '${configB.namespace}'.`
+      ].join(" ")
+    );
+  }
+  if (configA.labelSet.labelSetId !== configB.labelSet.labelSetId) {
+    throw new Error(
+      [
+        `'labelSet.labelSetId' must be compatible.`,
+        `Stored Config 'labelSet.labelSetId': '${configA.labelSet.labelSetId}'.`,
+        `Current Config 'labelSet.labelSetId': '${configB.labelSet.labelSetId}'.`
+      ].join(" ")
+    );
+  }
+  if (configA.labelSet.labelSetVersion !== configB.labelSet.labelSetVersion) {
+    throw new Error(
+      [
+        `'labelSet.labelSetVersion' must be compatible.`,
+        `Stored Config 'labelSet.labelSetVersion': '${configA.labelSet.labelSetVersion}'.`,
+        `Current Config 'labelSet.labelSetVersion': '${configB.labelSet.labelSetVersion}'.`
+      ].join(" ")
+    );
+  }
+  const configAPluginsSet = new Set(configA.plugins);
+  const configBPluginsSet = new Set(configB.plugins);
+  if (configAPluginsSet.symmetricDifference(configBPluginsSet).size > 0) {
+    throw new Error(
+      [
+        `'plugins' must be compatible.`,
+        `Stored Config 'plugins': '${configA.plugins.join(", ")}'.`,
+        `Current Config 'plugins': '${configB.plugins.join(", ")}'.`
+      ].join(" ")
+    );
+  }
+}
+
+// src/ensindexer/config/label-utils.ts
+import { hexToBytes } from "viem";
+function labelHashToBytes(labelHash) {
+  try {
+    if (labelHash.length !== 66) {
+      throw new Error(`Invalid labelHash length ${labelHash.length} characters (expected 66)`);
+    }
+    if (labelHash !== labelHash.toLowerCase()) {
+      throw new Error("Labelhash must be in lowercase");
+    }
+    if (!labelHash.startsWith("0x")) {
+      throw new Error("Labelhash must be 0x-prefixed");
+    }
+    const bytes = hexToBytes(labelHash);
+    if (bytes.length !== 32) {
+      throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
+    }
+    return bytes;
+  } catch (e) {
+    if (e instanceof Error) {
+      throw e;
+    }
+    throw new Error("Invalid hex format");
+  }
+}
+
+// src/ensindexer/config/parsing.ts
+function parseNonNegativeInteger(maybeNumber) {
+  const trimmed = maybeNumber.trim();
+  if (!trimmed) {
+    throw new Error("Input cannot be empty");
+  }
+  if (trimmed === "-0") {
+    throw new Error("Negative zero is not a valid non-negative integer");
+  }
+  const num = Number(maybeNumber);
+  if (Number.isNaN(num)) {
+    throw new Error(`"${maybeNumber}" is not a valid number`);
+  }
+  if (!Number.isFinite(num)) {
+    throw new Error(`"${maybeNumber}" is not a finite number`);
+  }
+  if (!Number.isInteger(num)) {
+    throw new Error(`"${maybeNumber}" is not an integer`);
+  }
+  if (num < 0) {
+    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
+  }
+  return num;
+}
+
+// src/ensindexer/config/validate/ensindexer-public-config.ts
+import { prettifyError as prettifyError10 } from "zod/v4";
+function validateEnsIndexerPublicConfig(unvalidatedConfig) {
+  const schema = makeEnsIndexerPublicConfigSchema();
+  const result = schema.safeParse(unvalidatedConfig);
+  if (!result.success) {
+    throw new Error(`Invalid ENSIndexerPublicConfig: ${prettifyError10(result.error)}`);
+  }
+  return result.data;
+}
+
+// src/ensindexer/config/validate/ensindexer-version-info.ts
+import { prettifyError as prettifyError11 } from "zod/v4";
+function validateEnsIndexerVersionInfo(unvalidatedVersionInfo) {
+  const schema = makeEnsIndexerVersionInfoSchema();
+  const result = schema.safeParse(unvalidatedVersionInfo);
+  if (!result.success) {
+    throw new Error(`Invalid EnsIndexerVersionInfo: ${prettifyError11(result.error)}`);
+  }
+  return result.data;
+}
+
+// src/ensnode/api/indexing-status/deserialize.ts
+import { prettifyError as prettifyError13 } from "zod/v4";
+
+// src/stack-info/deserialize/ensnode-stack-info.ts
+import { prettifyError as prettifyError12 } from "zod/v4";
+
+// src/stack-info/zod-schemas/ensnode-stack-info.ts
+import { z as z13 } from "zod/v4";
+
+// src/ensdb/zod-schemas/config.ts
+import { z as z12 } from "zod/v4";
+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";
+  return z13.object({
+    ensApi: makeSerializedEnsApiPublicConfigSchema(`${label}.ensApi`),
+    ensDb: makeEnsDbPublicConfigSchema(`${label}.ensDb`),
+    ensIndexer: makeSerializedEnsIndexerPublicConfigSchema(`${label}.ensIndexer`),
+    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`).optional()
+  });
+}
+function makeEnsNodeStackInfoSchema(valueLabel) {
+  const label = valueLabel ?? "ENSNodeStackInfo";
+  return z13.object({
+    ensApi: makeEnsApiPublicConfigSchema(`${label}.ensApi`),
+    ensDb: makeEnsDbPublicConfigSchema(`${label}.ensDb`),
+    ensIndexer: makeEnsIndexerPublicConfigSchema(`${label}.ensIndexer`),
+    ensRainbow: makeEnsRainbowPublicConfigSchema(`${label}.ensRainbow`).optional()
+  });
+}
+
+// src/stack-info/deserialize/ensnode-stack-info.ts
+function buildUnvalidatedEnsNodeStackInfo(serializedStackInfo) {
+  const { ensApi, ensIndexer, ...rest } = serializedStackInfo;
+  return {
+    ...rest,
+    ensApi: buildUnvalidatedEnsApiPublicConfig(ensApi),
+    ensIndexer: buildUnvalidatedEnsIndexerPublicConfig(ensIndexer)
+  };
+}
+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)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/ensnode/api/indexing-status/response.ts
+var EnsApiIndexingStatusResponseCodes = {
+  /**
+   * Represents that the indexing status is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that the indexing status is unavailable.
+   */
+  Error: "error"
+};
+var IndexingStatusResponseCodes = EnsApiIndexingStatusResponseCodes;
+
+// src/ensnode/api/indexing-status/zod-schemas.ts
+import { z as z14 } from "zod/v4";
+var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z14.strictObject({
+  responseCode: z14.literal(EnsApiIndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel),
+  stackInfo: makeEnsNodeStackInfoSchema(valueLabel)
+});
+var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => z14.strictObject({
+  responseCode: z14.literal(EnsApiIndexingStatusResponseCodes.Error)
+});
+var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z14.discriminatedUnion("responseCode", [
+  makeEnsApiIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
+]);
+var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => z14.object({
+  responseCode: z14.literal(EnsApiIndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel),
+  stackInfo: makeSerializedEnsNodeStackInfoSchema(valueLabel)
+});
+var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => z14.discriminatedUnion("responseCode", [
+  makeSerializedEnsApiIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
+]);
+
+// src/ensnode/api/indexing-status/deserialize.ts
+function buildUnvalidatedEnsApiIndexingStatusResponse(serializedResponse) {
+  if (serializedResponse.responseCode !== EnsApiIndexingStatusResponseCodes.Ok) {
+    return serializedResponse;
+  }
+  const { realtimeProjection, stackInfo, ...rest } = serializedResponse;
+  return {
+    realtimeProjection: buildUnvalidatedRealtimeIndexingStatusProjection(realtimeProjection),
+    stackInfo: buildUnvalidatedEnsNodeStackInfo(stackInfo),
+    ...rest
+  };
+}
+function deserializeEnsApiIndexingStatusResponse(maybeResponse) {
+  const parsed = makeSerializedEnsApiIndexingStatusResponseSchema().transform(buildUnvalidatedEnsApiIndexingStatusResponse).pipe(makeEnsApiIndexingStatusResponseSchema()).safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize EnsApiIndexingStatusResponse:
+${prettifyError13(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+var deserializeIndexingStatusResponse = deserializeEnsApiIndexingStatusResponse;
+
+// 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
+  };
+}
+
+// src/ensnode/api/indexing-status/serialize.ts
+function serializeEnsApiIndexingStatusResponse(response) {
+  switch (response.responseCode) {
+    case EnsApiIndexingStatusResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection),
+        stackInfo: serializeEnsNodeStackInfo(response.stackInfo)
+      };
+    case EnsApiIndexingStatusResponseCodes.Error:
+      return response;
+  }
+}
+var serializeIndexingStatusResponse = serializeEnsApiIndexingStatusResponse;
+
+// src/ensnode/api/name-tokens/deserialize.ts
+import { prettifyError as prettifyError15 } from "zod/v4";
+
+// src/ensnode/api/name-tokens/zod-schemas.ts
+import { namehashInterpretedName } from "enssdk";
+import { z as z17 } from "zod/v4";
+
+// src/tokenscope/name-token.ts
+import { getParentInterpretedName } from "enssdk";
+import { isAddressEqual as isAddressEqual3, zeroAddress as zeroAddress3 } from "viem";
+import { DatasourceNames } from "@ensnode/datasources";
+
+// src/shared/account-id.ts
+import { isAddressEqual } from "viem";
+var accountIdEqual = (a, b) => {
+  return a.chainId === b.chainId && isAddressEqual(a.address, b.address);
+};
+
+// src/shared/datasource-contract.ts
+import {
+  maybeGetDatasource
+} from "@ensnode/datasources";
+var maybeGetDatasourceContract = (namespaceId, datasourceName, contractName) => {
+  const datasource = maybeGetDatasource(namespaceId, datasourceName);
+  if (!datasource) return void 0;
+  const address = datasource.contracts[contractName]?.address;
+  if (address === void 0 || Array.isArray(address)) return void 0;
+  return {
+    chainId: datasource.chain.id,
+    address
+  };
+};
+var getDatasourceContract = (namespaceId, datasourceName, contractName) => {
+  const contract = maybeGetDatasourceContract(namespaceId, datasourceName, contractName);
+  if (!contract) {
+    throw new Error(
+      `Expected contract not found for ${namespaceId} ${datasourceName} ${contractName}`
+    );
+  }
+  return contract;
+};
+var makeContractMatcher = (namespace, b) => (datasourceName, contractName) => {
+  const a = maybeGetDatasourceContract(namespace, datasourceName, contractName);
+  return a && accountIdEqual(a, b);
+};
+
+// src/tokenscope/assets.ts
+import {
+  stringifyAssetId
+} from "enssdk";
+import { isAddressEqual as isAddressEqual2, zeroAddress as zeroAddress2 } from "viem";
+import { prettifyError as prettifyError14 } from "zod/v4";
+
+// src/tokenscope/zod-schemas.ts
+import { AssetId as CaipAssetId } from "caip";
+import { AssetNamespaces } from "enssdk";
+import { zeroAddress } from "viem";
+import { z as z15 } from "zod/v4";
+var tokenIdSchemaSerializable = z15.string();
+var tokenIdSchemaNative = z15.preprocess(
+  (v) => typeof v === "string" ? BigInt(v) : v,
+  z15.bigint().positive()
+);
+function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false) {
+  if (serializable) {
+    return tokenIdSchemaSerializable;
+  } else {
+    return tokenIdSchemaNative;
+  }
+}
+var makeAssetIdSchema = (valueLabel = "Asset ID Schema", serializable) => {
+  return z15.object({
+    assetNamespace: z15.enum(AssetNamespaces),
+    contract: makeAccountIdSchema(valueLabel),
+    tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
+  });
+};
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => z15.preprocess((v) => {
+  if (typeof v === "string") {
+    const result = new CaipAssetId(v);
+    return {
+      assetNamespace: result.assetName.namespace,
+      contract: {
+        chainId: Number(result.chainId.reference),
+        address: result.assetName.reference
+      },
+      tokenId: result.tokenId
+    };
+  }
+  return v;
+}, makeAssetIdSchema(valueLabel));
+function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
+  const ownership = ctx.value;
+  if (ctx.value.owner.address === zeroAddress) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `Name Token Ownership with '${ownership.ownershipType}' must have 'address' other than the zero address.`
+    });
+  }
+}
+var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => z15.object({
+  ownershipType: z15.literal(NameTokenOwnershipTypes.NameWrapper),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => z15.object({
+  ownershipType: z15.literal(NameTokenOwnershipTypes.FullyOnchain),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => z15.object({
+  ownershipType: z15.literal(NameTokenOwnershipTypes.Burned),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => z15.object({
+  ownershipType: z15.literal(NameTokenOwnershipTypes.Unknown),
+  owner: makeAccountIdSchema(`${valueLabel}.owner`)
+}).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
+function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
+  const ownership = ctx.value;
+  if (ctx.value.owner.address !== zeroAddress) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `Name Token Ownership with '${ownership.ownershipType}' must have 'address' set to the zero address.`
+    });
+  }
+}
+var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => z15.discriminatedUnion("ownershipType", [
   makeNameTokenOwnershipNameWrapperSchema(valueLabel),
   makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
   makeNameTokenOwnershipBurnedSchema(valueLabel),
   makeNameTokenOwnershipUnknownSchema(valueLabel)
 ]);
-var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => z11.object({
+var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => z15.object({
   token: makeAssetIdSchema(`${valueLabel}.token`, serializable),
   ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
-  mintStatus: z11.enum(NFTMintStatuses)
+  mintStatus: z15.enum(NFTMintStatuses)
 });
 
 // src/tokenscope/assets.ts
@@ -2098,7 +2242,7 @@ function serializeAssetId(assetId) {
   return {
     assetNamespace: assetId.assetNamespace,
     contract: assetId.contract,
-    tokenId: uint256ToHex32(assetId.tokenId)
+    tokenId: assetId.tokenId.toString()
   };
 }
 function deserializeAssetId(maybeAssetId, valueLabel) {
@@ -2106,7 +2250,7 @@ function deserializeAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AssetId:
-${prettifyError9(parsed.error)}
+${prettifyError14(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2116,7 +2260,7 @@ function parseAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot parse AssetId:
-${prettifyError9(parsed.error)}
+${prettifyError14(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2139,7 +2283,7 @@ var NFTMintStatuses = {
   Burned: "burned"
 };
 var formatNFTTransferEventMetadata = (metadata) => {
-  const assetIdString = formatAssetId(metadata.nft);
+  const assetIdString = stringifyAssetId(metadata.nft);
   return [
     `Event: ${metadata.eventHandlerName}`,
     `Chain ID: ${metadata.chainId}`,
@@ -2402,7 +2546,8 @@ function getNameTokenOwnership(namespaceId, name, owner) {
       owner
     };
   }
-  const parentName = getParentNameFQDN(name);
+  const parentName = getParentInterpretedName(name);
+  if (parentName === null) throw new Error(`Invariant: '${name}' has no parent Name.`);
   if (parentName === "eth") {
     return {
       ownershipType: NameTokenOwnershipTypes.FullyOnchain,
@@ -2415,14 +2560,14 @@ function getNameTokenOwnership(namespaceId, name, owner) {
   };
 }
 
-// src/ensapi/api/shared/errors/zod-schemas.ts
-import { z as z12 } from "zod/v4";
-var ErrorResponseSchema = z12.object({
-  message: z12.string(),
-  details: z12.optional(z12.unknown())
+// src/ensnode/api/shared/errors/zod-schemas.ts
+import { z as z16 } from "zod/v4";
+var makeErrorResponseSchema = () => z16.object({
+  message: z16.string(),
+  details: z16.optional(z16.unknown())
 });
 
-// src/ensapi/api/name-tokens/response.ts
+// src/ensnode/api/name-tokens/response.ts
 var NameTokensResponseCodes = {
   /**
    * Represents a response when Name Tokens API can respond with requested data.
@@ -2457,16 +2602,16 @@ var NameTokensResponseErrorCodes = {
   IndexingStatusUnsupported: "unsupported-indexing-status"
 };
 
-// src/ensapi/api/name-tokens/zod-schemas.ts
-var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => z13.object({
+// src/ensnode/api/name-tokens/zod-schemas.ts
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => z17.object({
   domainId: makeNodeSchema(`${valueLabel}.domainId`),
   name: makeReinterpretedNameSchema(valueLabel),
-  tokens: z13.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
+  tokens: z17.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
   expiresAt: makeUnixTimestampSchema(`${valueLabel}.expiresAt`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 }).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
   const { name, domainId } = ctx.value;
-  if (namehash2(name) !== domainId) {
+  if (namehashInterpretedName(name) !== domainId) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2503,51 +2648,51 @@ var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", seria
     });
   }
 });
-var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => z13.strictObject({
-  responseCode: z13.literal(NameTokensResponseCodes.Ok),
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => z17.strictObject({
+  responseCode: z17.literal(NameTokensResponseCodes.Ok),
   registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`, serializable)
 });
-var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => z13.strictObject({
-  responseCode: z13.literal(NameTokensResponseCodes.Error),
-  errorCode: z13.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
-  error: ErrorResponseSchema
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => z17.strictObject({
+  responseCode: z17.literal(NameTokensResponseCodes.Error),
+  errorCode: z17.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
+  error: makeErrorResponseSchema()
 });
-var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => z13.strictObject({
-  responseCode: z13.literal(NameTokensResponseCodes.Error),
-  errorCode: z13.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
-  error: ErrorResponseSchema
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => z17.strictObject({
+  responseCode: z17.literal(NameTokensResponseCodes.Error),
+  errorCode: z17.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
+  error: makeErrorResponseSchema()
 });
-var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => z13.strictObject({
-  responseCode: z13.literal(NameTokensResponseCodes.Error),
-  errorCode: z13.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
-  error: ErrorResponseSchema
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => z17.strictObject({
+  responseCode: z17.literal(NameTokensResponseCodes.Error),
+  errorCode: z17.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
+  error: makeErrorResponseSchema()
 });
-var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => z13.discriminatedUnion("errorCode", [
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => z17.discriminatedUnion("errorCode", [
   makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
   makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
   makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
 ]);
 var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response", serializable) => {
-  return z13.discriminatedUnion("responseCode", [
+  return z17.discriminatedUnion("responseCode", [
     makeNameTokensResponseOkSchema(valueLabel, serializable ?? false),
     makeNameTokensResponseErrorSchema(valueLabel)
   ]);
 };
 
-// src/ensapi/api/name-tokens/deserialize.ts
+// src/ensnode/api/name-tokens/deserialize.ts
 function deserializedNameTokensResponse(maybeResponse) {
   const parsed = makeNameTokensResponseSchema("Name Tokens Response", false).safeParse(
     maybeResponse
   );
   if (parsed.error) {
     throw new Error(`Cannot deserialize NameTokensResponse:
-${prettifyError10(parsed.error)}
+${prettifyError15(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
-// src/ensapi/api/name-tokens/prerequisites.ts
+// src/ensnode/api/name-tokens/prerequisites.ts
 var nameTokensPrerequisites = Object.freeze({
   /**
    * Required plugins to enable Name Tokens API routes.
@@ -2586,7 +2731,7 @@ var nameTokensPrerequisites = Object.freeze({
   }
 });
 
-// src/ensapi/api/name-tokens/serialize.ts
+// src/ensnode/api/name-tokens/serialize.ts
 function serializeRegisteredNameTokens({
   domainId,
   name,
@@ -2614,18 +2759,19 @@ function serializeNameTokensResponse(response) {
   }
 }
 
-// src/ensapi/api/registrar-actions/deserialize.ts
-import { prettifyError as prettifyError11 } from "zod/v4";
+// src/ensnode/api/registrar-actions/deserialize.ts
+import { prettifyError as prettifyError16 } from "zod/v4";
 
-// src/ensapi/api/registrar-actions/zod-schemas.ts
-import { namehash as namehash3 } from "viem/ens";
-import { z as z16 } from "zod/v4";
+// src/ensnode/api/registrar-actions/zod-schemas.ts
+import { namehashInterpretedName as namehashInterpretedName2 } from "enssdk";
+import { z as z20 } from "zod/v4";
 
 // src/registrars/zod-schemas.ts
-import { z as z14 } from "zod/v4";
+import { z as z18 } from "zod/v4";
 
 // src/registrars/encoded-referrer.ts
-import { getAddress, pad, size as size2, slice, zeroAddress as zeroAddress4 } from "viem";
+import { isNormalizedAddress, toNormalizedAddress as toNormalizedAddress2 } from "enssdk";
+import { pad, size as size2, slice, zeroAddress as zeroAddress4 } from "viem";
 var ENCODED_REFERRER_BYTE_OFFSET = 12;
 var ENCODED_REFERRER_BYTE_LENGTH = 32;
 var EXPECTED_ENCODED_REFERRER_PADDING = pad("0x", {
@@ -2637,8 +2783,8 @@ var ZERO_ENCODED_REFERRER = pad("0x", {
   dir: "left"
 });
 function buildEncodedReferrer(address) {
-  const lowercaseAddress = address.toLowerCase();
-  return pad(lowercaseAddress, { size: ENCODED_REFERRER_BYTE_LENGTH, dir: "left" });
+  if (!isNormalizedAddress(address)) throw new Error(`Address '${address}' is not normalized.`);
+  return pad(address, { size: ENCODED_REFERRER_BYTE_LENGTH, dir: "left" });
 }
 function decodeEncodedReferrer(encodedReferrer) {
   if (size2(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
@@ -2647,12 +2793,10 @@ function decodeEncodedReferrer(encodedReferrer) {
     );
   }
   const padding = slice(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
-  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
-    return zeroAddress4;
-  }
+  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) return zeroAddress4;
   const decodedReferrer = slice(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
   try {
-    return getAddress(decodedReferrer);
+    return toNormalizedAddress2(decodedReferrer);
   } catch {
     throw new Error(`Decoded referrer value must be a valid EVM address.`);
   }
@@ -2697,11 +2841,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => z14.object({
+var makeSubregistrySchema = (valueLabel = "Subregistry") => z18.object({
   subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
   node: makeNodeSchema(`${valueLabel} Node`)
 });
-var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => z14.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => z18.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -2717,24 +2861,24 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => z14.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => z18.union([
   // pricing available
-  z14.object({
+  z18.object({
     baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
     premium: makePriceEthSchema(`${valueLabel} Premium`),
     total: makePriceEthSchema(`${valueLabel} Total`)
   }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
   // pricing unknown
-  z14.object({
-    baseCost: z14.null(),
-    premium: z14.null(),
-    total: z14.null()
+  z18.object({
+    baseCost: z18.null(),
+    premium: z18.null(),
+    total: z18.null()
   }).transform((v) => v)
 ]);
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
   const { encodedReferrer, decodedReferrer } = ctx.value;
   try {
-    const expectedDecodedReferrer = decodeEncodedReferrer(encodedReferrer).toLowerCase();
+    const expectedDecodedReferrer = decodeEncodedReferrer(encodedReferrer);
     if (decodedReferrer !== expectedDecodedReferrer) {
       ctx.issues.push({
         code: "custom",
@@ -2751,19 +2895,19 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
     });
   }
 }
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => z14.union([
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => z18.union([
   // referral available
-  z14.object({
+  z18.object({
     encodedReferrer: makeHexStringSchema(
       { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
       `${valueLabel} Encoded Referrer`
     ),
-    decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
+    decodedReferrer: makeNormalizedAddressSchema(`${valueLabel} Decoded Referrer`)
   }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
   // referral not applicable
-  z14.object({
-    encodedReferrer: z14.null(),
-    decodedReferrer: z14.null()
+  z18.object({
+    encodedReferrer: z18.null(),
+    decodedReferrer: z18.null()
   })
 ]);
 function invariant_eventIdsInitialElementIsTheActionId(ctx) {
@@ -2776,54 +2920,53 @@ function invariant_eventIdsInitialElementIsTheActionId(ctx) {
     });
   }
 }
-var EventIdSchema = z14.string().nonempty();
-var EventIdsSchema = z14.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => z14.object({
+var EventIdSchema = z18.string().nonempty();
+var EventIdsSchema = z18.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchemaWithoutCheck = (valueLabel = "Base Registrar Action") => z18.object({
   id: EventIdSchema,
   incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
-  registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`),
-  registrationLifecycle: makeRegistrationLifecycleSchema(
-    `${valueLabel} Registration Lifecycle`
-  ),
+  registrant: makeNormalizedAddressSchema(`${valueLabel} Registrant`),
+  registrationLifecycle: makeRegistrationLifecycleSchema(`${valueLabel} Registration Lifecycle`),
   pricing: makeRegistrarActionPricingSchema(`${valueLabel} Pricing`),
   referral: makeRegistrarActionReferralSchema(`${valueLabel} Referral`),
   block: makeBlockRefSchema(`${valueLabel} Block`),
   transactionHash: makeTransactionHashSchema(`${valueLabel} Transaction Hash`),
   eventIds: EventIdsSchema
-}).check(invariant_eventIdsInitialElementIsTheActionId);
+});
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => makeBaseRegistrarActionSchemaWithoutCheck(valueLabel).check(
+  invariant_eventIdsInitialElementIsTheActionId
+);
 var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: z14.literal(RegistrarActionTypes.Registration)
+  type: z18.literal(RegistrarActionTypes.Registration)
 });
 var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: z14.literal(RegistrarActionTypes.Renewal)
+  type: z18.literal(RegistrarActionTypes.Renewal)
 });
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => z14.discriminatedUnion("type", [
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => z18.discriminatedUnion("type", [
   makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
   makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
 ]);
 
-// src/ensapi/api/shared/pagination/zod-schemas.ts
-import { z as z15 } from "zod/v4";
+// src/ensnode/api/shared/pagination/zod-schemas.ts
+import { z as z19 } from "zod/v4";
 
-// src/ensapi/api/shared/pagination/request.ts
+// src/ensnode/api/shared/pagination/request.ts
 var RECORDS_PER_PAGE_DEFAULT = 10;
 var RECORDS_PER_PAGE_MAX = 100;
 
-// src/ensapi/api/shared/pagination/zod-schemas.ts
-var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => z15.object({
+// src/ensnode/api/shared/pagination/zod-schemas.ts
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => z19.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") => z15.object({
-  totalRecords: z15.literal(0),
-  totalPages: z15.literal(1),
-  hasNext: z15.literal(false),
-  hasPrev: z15.literal(false),
-  startIndex: z15.undefined(),
-  endIndex: z15.undefined()
+var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => z19.object({
+  totalRecords: z19.literal(0),
+  totalPages: z19.literal(1),
+  hasNext: z19.literal(false),
+  hasPrev: z19.literal(false)
 }).extend(makeRequestPageParamsSchema(valueLabel).shape);
 function invariant_responsePageWithRecordsIsCorrect(ctx) {
   const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
@@ -2858,20 +3001,20 @@ function invariant_responsePageWithRecordsIsCorrect(ctx) {
     });
   }
 }
-var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => z15.object({
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => z19.object({
   totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: z15.boolean(),
-  hasPrev: z15.boolean(),
+  hasNext: z19.boolean(),
+  hasPrev: z19.boolean(),
   startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
   endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
 }).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
-var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => z15.union([
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => z19.union([
   makeResponsePageContextSchemaWithNoRecords(valueLabel),
   makeResponsePageContextSchemaWithRecords(valueLabel)
 ]);
 
-// src/ensapi/api/registrar-actions/response.ts
+// src/ensnode/api/registrar-actions/response.ts
 var RegistrarActionsResponseCodes = {
   /**
    * Represents that Registrar Actions are available.
@@ -2883,11 +3026,11 @@ var RegistrarActionsResponseCodes = {
   Error: "error"
 };
 
-// src/ensapi/api/registrar-actions/zod-schemas.ts
+// src/ensnode/api/registrar-actions/zod-schemas.ts
 function invariant_registrationLifecycleNodeMatchesName(ctx) {
   const { name, action } = ctx.value;
   const expectedNode = action.registrationLifecycle.node;
-  const actualNode = namehash3(name);
+  const actualNode = namehashInterpretedName2(name);
   if (actualNode !== expectedNode) {
     ctx.issues.push({
       code: "custom",
@@ -2896,39 +3039,39 @@ function invariant_registrationLifecycleNodeMatchesName(ctx) {
     });
   }
 }
-var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => z16.object({
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => z20.object({
   action: makeRegistrarActionSchema(valueLabel),
   name: makeReinterpretedNameSchema(valueLabel)
 }).check(invariant_registrationLifecycleNodeMatchesName);
-var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => z16.object({
-  responseCode: z16.literal(RegistrarActionsResponseCodes.Ok),
-  registrarActions: z16.array(makeNamedRegistrarActionSchema(valueLabel)),
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => z20.object({
+  responseCode: z20.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: z20.array(makeNamedRegistrarActionSchema(valueLabel)),
   pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`),
-  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`).optional()
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
-var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => z16.strictObject({
-  responseCode: z16.literal(RegistrarActionsResponseCodes.Error),
-  error: ErrorResponseSchema
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => z20.strictObject({
+  responseCode: z20.literal(RegistrarActionsResponseCodes.Error),
+  error: makeErrorResponseSchema()
 });
-var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => z16.discriminatedUnion("responseCode", [
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => z20.discriminatedUnion("responseCode", [
   makeRegistrarActionsResponseOkSchema(valueLabel),
   makeRegistrarActionsResponseErrorSchema(valueLabel)
 ]);
 
-// src/ensapi/api/registrar-actions/deserialize.ts
+// src/ensnode/api/registrar-actions/deserialize.ts
 function deserializeRegistrarActionsResponse(maybeResponse) {
   const parsed = makeRegistrarActionsResponseSchema().safeParse(maybeResponse);
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize RegistrarActionsResponse:
-${prettifyError11(parsed.error)}
+${prettifyError16(parsed.error)}
 `
     );
   }
   return parsed.data;
 }
 
-// src/ensapi/api/registrar-actions/request.ts
+// src/ensnode/api/registrar-actions/request.ts
 var RegistrarActionsFilterTypes = {
   BySubregistryNode: "bySubregistryNode",
   WithEncodedReferral: "withEncodedReferral",
@@ -2948,7 +3091,7 @@ var RegistrarActionsOrders = {
   LatestRegistrarActions: "orderBy[timestamp]=desc"
 };
 
-// src/ensapi/api/registrar-actions/filters.ts
+// src/ensnode/api/registrar-actions/filters.ts
 function byParentNode(parentNode) {
   if (typeof parentNode === "undefined") {
     return void 0;
@@ -3001,7 +3144,7 @@ var registrarActionsFilter = {
   endTimestamp
 };
 
-// src/ensapi/api/registrar-actions/prerequisites.ts
+// src/ensnode/api/registrar-actions/prerequisites.ts
 var registrarActionsRequiredPlugins = [
   "subgraph" /* Subgraph */,
   "basenames" /* Basenames */,
@@ -3033,7 +3176,7 @@ function hasRegistrarActionsIndexingStatusSupport(omnichainIndexingStatusId) {
   };
 }
 
-// src/ensapi/api/registrar-actions/serialize.ts
+// src/ensnode/api/registrar-actions/serialize.ts
 function serializeNamedRegistrarAction({
   action,
   name
@@ -3057,19 +3200,19 @@ function serializeRegistrarActionsResponse(response) {
   }
 }
 
-// src/ensapi/api/shared/errors/deserialize.ts
-import { prettifyError as prettifyError12 } from "zod/v4";
-function deserializeErrorResponse(maybeErrorResponse) {
-  const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
+// src/ensnode/api/shared/errors/deserialize.ts
+import { prettifyError as prettifyError17 } from "zod/v4";
+function deserializeErrorResponse2(maybeErrorResponse) {
+  const parsed = makeErrorResponseSchema().safeParse(maybeErrorResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ErrorResponse:
-${prettifyError12(parsed.error)}
+${prettifyError17(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
-// src/ensapi/api/shared/pagination/build-page-context.ts
+// src/ensnode/api/shared/pagination/build-page-context.ts
 function buildPageContext(page, recordsPerPage, totalRecords) {
   const totalPages = Math.max(1, Math.ceil(totalRecords / recordsPerPage));
   if (page > totalPages) {
@@ -3104,7 +3247,7 @@ function buildPageContext(page, recordsPerPage, totalRecords) {
   };
 }
 
-// src/ensapi/client-error.ts
+// src/ensnode/client-error.ts
 var ClientError = class _ClientError extends Error {
   details;
   constructor(message, details) {
@@ -3117,17 +3260,17 @@ var ClientError = class _ClientError extends Error {
   }
 };
 
-// src/ensapi/deployments.ts
+// src/ensnode/deployments.ts
 import { ENSNamespaceIds as ENSNamespaceIds3 } from "@ensnode/datasources";
-var DEFAULT_ENSNODE_API_URL_MAINNET = "https://api.alpha.ensnode.io";
-var DEFAULT_ENSNODE_API_URL_SEPOLIA = "https://api.alpha-sepolia.ensnode.io";
+var DEFAULT_ENSNODE_URL_MAINNET = "https://api.alpha.ensnode.io";
+var DEFAULT_ENSNODE_URL_SEPOLIA = "https://api.alpha-sepolia.ensnode.io";
 var getDefaultEnsNodeUrl = (namespace) => {
   const effectiveNamespace = namespace ?? ENSNamespaceIds3.Mainnet;
   switch (effectiveNamespace) {
     case ENSNamespaceIds3.Mainnet:
-      return new URL(DEFAULT_ENSNODE_API_URL_MAINNET);
+      return new URL(DEFAULT_ENSNODE_URL_MAINNET);
     case ENSNamespaceIds3.Sepolia:
-      return new URL(DEFAULT_ENSNODE_API_URL_SEPOLIA);
+      return new URL(DEFAULT_ENSNODE_URL_SEPOLIA);
     default:
       throw new Error(
         `ENSNamespaceId ${effectiveNamespace} does not have a default ENSNode URL defined`
@@ -3135,8 +3278,8 @@ var getDefaultEnsNodeUrl = (namespace) => {
   }
 };
 
-// src/ensapi/client.ts
-var EnsApiClient = class _EnsApiClient {
+// src/ensnode/client.ts
+var EnsNodeClient = class _EnsNodeClient {
   options;
   static defaultOptions() {
     return {
@@ -3145,7 +3288,7 @@ var EnsApiClient = class _EnsApiClient {
   }
   constructor(options = {}) {
     this.options = {
-      ..._EnsApiClient.defaultOptions(),
+      ..._EnsNodeClient.defaultOptions(),
       ...options
     };
   }
@@ -3189,15 +3332,21 @@ var EnsApiClient = class _EnsApiClient {
    */
   async resolveRecords(name, selection, options) {
     const url = new URL(`/api/resolve/records/${encodeURIComponent(name)}`, this.options.url);
-    if (selection.name) {
-      url.searchParams.set("name", "true");
-    }
+    if (selection.name) url.searchParams.set("name", "true");
+    if (selection.contenthash) url.searchParams.set("contenthash", "true");
+    if (selection.pubkey) url.searchParams.set("pubkey", "true");
+    if (selection.dnszonehash) url.searchParams.set("dnszonehash", "true");
+    if (selection.version) url.searchParams.set("version", "true");
+    if (selection.abi !== void 0) url.searchParams.set("abi", selection.abi.toString());
     if (selection.addresses && selection.addresses.length > 0) {
       url.searchParams.set("addresses", selection.addresses.join(","));
     }
     if (selection.texts && selection.texts.length > 0) {
       url.searchParams.set("texts", selection.texts.join(","));
     }
+    if (selection.interfaces && selection.interfaces.length > 0) {
+      url.searchParams.set("interfaces", selection.interfaces.join(","));
+    }
     if (options?.trace) url.searchParams.set("trace", "true");
     if (options?.accelerate) url.searchParams.set("accelerate", "true");
     const response = await fetch(url);
@@ -3206,6 +3355,11 @@ var EnsApiClient = class _EnsApiClient {
       throw ClientError.fromErrorResponse(error);
     }
     const data = await response.json();
+    const records = data.records;
+    if (typeof records.version === "string") records.version = BigInt(records.version);
+    if (records.abi && typeof records.abi.contentType === "string") {
+      records.abi.contentType = BigInt(records.abi.contentType);
+    }
     return data;
   }
   /**
@@ -3313,32 +3467,6 @@ var EnsApiClient = class _EnsApiClient {
     const data = await response.json();
     return data;
   }
-  /**
-   * Fetch ENSApi Config
-   *
-   * Fetch the ENSApi's configuration.
-   *
-   * @returns {EnsApiConfigResponse}
-   *
-   * @throws if the ENSApi request fails
-   * @throws if the ENSApi returns a non-ok response
-   * @throws if the ENSApi response breaks required invariants
-   */
-  async config() {
-    const url = new URL(`/api/config`, this.options.url);
-    const response = await fetch(url);
-    let responseData;
-    try {
-      responseData = await response.json();
-    } catch {
-      throw new Error("Malformed response data: invalid JSON");
-    }
-    if (!response.ok) {
-      const errorResponse = deserializeErrorResponse(responseData);
-      throw new Error(`Fetching ENSApi Config Failed: ${errorResponse.message}`);
-    }
-    return deserializeEnsApiConfigResponse(responseData);
-  }
   /**
    * Fetch ENSApi Indexing Status
    *
@@ -3360,7 +3488,7 @@ var EnsApiClient = class _EnsApiClient {
     if (!response.ok) {
       let errorResponse;
       try {
-        errorResponse = deserializeErrorResponse(responseData);
+        errorResponse = deserializeErrorResponse2(responseData);
       } catch {
       }
       if (typeof errorResponse !== "undefined") {
@@ -3391,11 +3519,13 @@ var EnsApiClient = class _EnsApiClient {
    * ```ts
    * import {
    *   registrarActionsFilter,
-   *   EnsApiClient,
+   *   EnsNodeClient,
    * } from "@ensnode/ensnode-sdk";
-   * import { namehash } from "viem/ens";
+   * import { ETH_NODE, namehashInterpretedName, asInterpretedName } from "enssdk";
    *
-   * const client: EnsApiClient;
+   * const BASE_NODE = namehashInterpretedName(asInterpretedName("base.eth"));
+   *
+   * const client: EnsNodeClient;
    *
    * // Get first page with default page size (10 records)
    * const response = await client.registrarActions();
@@ -3415,7 +3545,7 @@ var EnsApiClient = class _EnsApiClient {
    * // get latest registrar action records associated with
    * // subregistry managing `eth` name
    * await client.registrarActions({
-   *   filters: [registrarActionsFilter.byParentNode(namehash('eth'))],
+   *   filters: [registrarActionsFilter.byParentNode(ETH_NODE)],
    * });
    *
    * // get latest registrar action records which include referral info
@@ -3431,7 +3561,7 @@ var EnsApiClient = class _EnsApiClient {
    * // get latest 10 registrar action records associated with
    * // subregistry managing `base.eth` name
    * await client.registrarActions({
-   *   filters: [registrarActionsFilter.byParentNode(namehash('base.eth'))],
+   *   filters: [registrarActionsFilter.byParentNode(BASE_NODE)],
    *   recordsPerPage: 10
    * });
    *
@@ -3535,230 +3665,55 @@ var EnsApiClient = class _EnsApiClient {
     if (!response.ok) {
       let errorResponse;
       try {
-        errorResponse = deserializeErrorResponse(responseData);
-      } catch {
-        console.log("Registrar Actions API: handling a known server error.");
-      }
-      if (typeof errorResponse !== "undefined") {
-        throw new Error(`Fetching ENSNode Registrar Actions Failed: ${errorResponse.message}`);
-      }
-    }
-    return deserializeRegistrarActionsResponse(responseData);
-  }
-  /**
-   * Fetch Name Tokens for requested name.
-   *
-   * @param request.name - Name for which Name Tokens will be fetched.
-   * @returns {NameTokensResponse}
-   *
-   * @throws if the ENSNode request fails
-   * @throws if the ENSNode API returns an error response
-   * @throws if the ENSNode response breaks required invariants
-   *
-   * @example
-   * ```ts
-   * import {
-   *   EnsApiClient,
-   * } from "@ensnode/ensnode-sdk";
-   * import { namehash } from "viem/ens";
-   *
-   * const client: EnsApiClient;
-   *
-   * // get latest name token records from the indexed subregistry based on the requested name
-   * const response = await client.nameTokens({
-   *   name: "vitalik.eth"
-   * });
-   *
-   * const response = await client.nameTokens({
-   *   domainId: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835" // namehash('vitalik.eth')
-   * })
-   * ```
-   */
-  async nameTokens(request) {
-    const url = new URL(`/api/name-tokens`, this.options.url);
-    if (request.name !== void 0) {
-      url.searchParams.set("name", request.name);
-    } else if (request.domainId !== void 0) {
-      url.searchParams.set("domainId", request.domainId);
-    }
-    const response = await fetch(url);
-    let responseData;
-    try {
-      responseData = await response.json();
-    } catch {
-      throw new Error("Malformed response data: invalid JSON");
-    }
-    if (!response.ok) {
-      let errorResponse;
-      try {
-        errorResponse = deserializeErrorResponse(responseData);
-      } catch {
-        console.log("Name Tokens API: handling a known server error.");
-      }
-      if (typeof errorResponse !== "undefined") {
-        throw new Error(`Fetching ENSNode Name Tokens Failed: ${errorResponse.message}`);
-      }
-    }
-    return deserializedNameTokensResponse(responseData);
-  }
-};
-var ENSNodeClient = class extends EnsApiClient {
-};
-
-// src/ensindexer/api/config/deserialize.ts
-function deserializeEnsIndexerConfigResponse(maybeResponse) {
-  return deserializeEnsIndexerPublicConfig(maybeResponse, "EnsIndexerConfigResponse");
-}
-
-// src/ensindexer/api/config/serialize.ts
-function serializeEnsIndexerConfigResponse(response) {
-  return serializeEnsIndexerPublicConfig(response);
-}
-
-// src/ensindexer/api/indexing-status/deserialize.ts
-import { prettifyError as prettifyError13 } from "zod/v4";
-
-// src/ensindexer/api/indexing-status/response.ts
-var EnsIndexerIndexingStatusResponseCodes = {
-  /**
-   * Represents that the indexing status is available.
-   */
-  Ok: "ok",
-  /**
-   * Represents that the indexing status is unavailable.
-   */
-  Error: "error"
-};
-
-// src/ensindexer/api/indexing-status/zod-schemas.ts
-import { z as z17 } from "zod/v4";
-var makeEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z17.strictObject({
-  responseCode: z17.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
-  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
-});
-var makeEnsIndexerIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => z17.strictObject({
-  responseCode: z17.literal(EnsIndexerIndexingStatusResponseCodes.Error)
-});
-var makeEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z17.discriminatedUnion("responseCode", [
-  makeEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
-  makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
-]);
-var makeSerializedEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => z17.strictObject({
-  responseCode: z17.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
-  realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel)
-});
-var makeSerializedEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => z17.discriminatedUnion("responseCode", [
-  makeSerializedEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
-  makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
-]);
-
-// src/ensindexer/api/indexing-status/deserialize.ts
-function buildUnvalidatedEnsIndexerIndexingStatusResponse(serializedResponse) {
-  if (serializedResponse.responseCode !== EnsIndexerIndexingStatusResponseCodes.Ok) {
-    return serializedResponse;
-  }
-  return {
-    ...serializedResponse,
-    realtimeProjection: buildUnvalidatedRealtimeIndexingStatusProjection(
-      serializedResponse.realtimeProjection
-    )
-  };
-}
-function deserializeEnsIndexerIndexingStatusResponse(maybeResponse) {
-  const parsed = makeSerializedEnsIndexerIndexingStatusResponseSchema().transform(buildUnvalidatedEnsIndexerIndexingStatusResponse).pipe(makeEnsIndexerIndexingStatusResponseSchema()).safeParse(maybeResponse);
-  if (parsed.error) {
-    throw new Error(
-      `Cannot deserialize EnsIndexerIndexingStatusResponse:
-${prettifyError13(parsed.error)}
-`
-    );
-  }
-  return parsed.data;
-}
-
-// src/ensindexer/api/indexing-status/serialize.ts
-function serializeEnsIndexerIndexingStatusResponse(response) {
-  switch (response.responseCode) {
-    case EnsIndexerIndexingStatusResponseCodes.Ok:
-      return {
-        responseCode: response.responseCode,
-        realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection)
-      };
-    case EnsIndexerIndexingStatusResponseCodes.Error:
-      return response;
-  }
-}
-
-// src/ensindexer/api/shared/errors/deserialize.ts
-import { prettifyError as prettifyError14 } from "zod/v4";
-
-// src/ensindexer/api/shared/errors/zod-schemas.ts
-import { z as z18 } from "zod/v4";
-var ErrorResponseSchema2 = z18.object({
-  message: z18.string(),
-  details: z18.optional(z18.unknown())
-});
-
-// src/ensindexer/api/shared/errors/deserialize.ts
-function deserializeErrorResponse2(maybeErrorResponse) {
-  const parsed = ErrorResponseSchema2.safeParse(maybeErrorResponse);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize ErrorResponse:
-${prettifyError14(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
-
-// src/ensindexer/client.ts
-var EnsIndexerClient = class {
-  constructor(options) {
-    this.options = options;
-  }
-  getOptions() {
-    return Object.freeze({
-      url: new URL(this.options.url.href)
-    });
-  }
-  /**
-   * Fetch ENSIndexer Config
-   *
-   * Fetch the ENSIndexer's configuration.
-   *
-   * @returns {EnsIndexerConfigResponse}
-   *
-   * @throws if the ENSIndexer request fails
-   * @throws if the ENSIndexer returns a non-ok response
-   * @throws if the ENSIndexer response breaks required invariants
-   */
-  async config() {
-    const url = new URL(`/api/config`, this.options.url);
-    const response = await fetch(url);
-    let responseData;
-    try {
-      responseData = await response.json();
-    } catch {
-      throw new Error("Malformed response data: invalid JSON");
-    }
-    if (!response.ok) {
-      const errorResponse = deserializeErrorResponse2(responseData);
-      throw new Error(`Fetching ENSIndexer Config Failed: ${errorResponse.message}`);
+        errorResponse = deserializeErrorResponse2(responseData);
+      } catch {
+        console.log("Registrar Actions API: handling a known server error.");
+      }
+      if (typeof errorResponse !== "undefined") {
+        throw new Error(`Fetching ENSNode Registrar Actions Failed: ${errorResponse.message}`);
+      }
     }
-    return deserializeEnsIndexerConfigResponse(
-      responseData
-    );
+    return deserializeRegistrarActionsResponse(responseData);
   }
   /**
-   * Fetch ENSIndexer Indexing Status
+   * Fetch Name Tokens for requested name.
    *
-   * @returns {EnsIndexerIndexingStatusResponse}
+   * @param request.name - Name for which Name Tokens will be fetched.
+   * @returns {NameTokensResponse}
    *
-   * @throws if the ENSIndexer request fails
-   * @throws if the ENSIndexer returns a non-ok response
-   * @throws if the ENSIndexer response breaks required invariants
+   * @throws if the ENSNode request fails
+   * @throws if the ENSNode API returns an error response
+   * @throws if the ENSNode response breaks required invariants
+   *
+   * @example
+   * ```ts
+   * import {
+   *   EnsNodeClient,
+   * } from "@ensnode/ensnode-sdk";
+   * import { namehashInterpretedName, asInterpretedName } from "enssdk";
+   *
+   * const VITALIK_NAME = asInterpretedName("vitalik.eth");
+   * const VITALIK_DOMAIN_ID = namehashInterpretedName(VITALIK_NAME);
+   *
+   * const client: EnsNodeClient;
+   *
+   * // get latest name token records from the indexed subregistry based on the requested name
+   * const response = await client.nameTokens({
+   *   name: VITALIK_NAME,
+   * });
+   *
+   * const response = await client.nameTokens({
+   *   domainId: VITALIK_DOMAIN_ID,
+   * })
+   * ```
    */
-  async indexingStatus() {
-    const url = new URL(`/api/indexing-status`, this.options.url);
+  async nameTokens(request) {
+    const url = new URL(`/api/name-tokens`, this.options.url);
+    if (request.name !== void 0) {
+      url.searchParams.set("name", request.name);
+    } else if (request.domainId !== void 0) {
+      url.searchParams.set("domainId", request.domainId);
+    }
     const response = await fetch(url);
     let responseData;
     try {
@@ -3771,181 +3726,15 @@ var EnsIndexerClient = class {
       try {
         errorResponse = deserializeErrorResponse2(responseData);
       } catch {
+        console.log("Name Tokens API: handling a known server error.");
       }
       if (typeof errorResponse !== "undefined") {
-        throw new Error(`Fetching ENSIndexer Indexing Status Failed: ${errorResponse.message}`);
+        throw new Error(`Fetching ENSNode Name Tokens Failed: ${errorResponse.message}`);
       }
     }
-    return deserializeEnsIndexerIndexingStatusResponse(
-      responseData
-    );
-  }
-};
-
-// src/ensindexer/config/compatibility.ts
-function validateEnsIndexerPublicConfigCompatibility(configA, configB) {
-  if (configA.indexedChainIds.symmetricDifference(configB.indexedChainIds).size > 0) {
-    throw new Error(
-      [
-        `'indexedChainIds' must be compatible.`,
-        `Stored Config 'indexedChainIds': '${Array.from(configA.indexedChainIds).join(", ")}'.`,
-        `Current Config 'indexedChainIds': '${Array.from(configB.indexedChainIds).join(", ")}'.`
-      ].join(" ")
-    );
-  }
-  if (configA.isSubgraphCompatible !== configB.isSubgraphCompatible) {
-    throw new Error(
-      [
-        `'isSubgraphCompatible' flag must be compatible.`,
-        `Stored Config 'isSubgraphCompatible' flag: '${configA.isSubgraphCompatible}'.`,
-        `Current Config 'isSubgraphCompatible' flag: '${configB.isSubgraphCompatible}'.`
-      ].join(" ")
-    );
-  }
-  if (configA.namespace !== configB.namespace) {
-    throw new Error(
-      [
-        `'namespace' must be compatible.`,
-        `Stored Config 'namespace': '${configA.namespace}'.`,
-        `Current Config 'namespace': '${configB.namespace}'.`
-      ].join(" ")
-    );
-  }
-  if (configA.labelSet.labelSetId !== configB.labelSet.labelSetId) {
-    throw new Error(
-      [
-        `'labelSet.labelSetId' must be compatible.`,
-        `Stored Config 'labelSet.labelSetId': '${configA.labelSet.labelSetId}'.`,
-        `Current Config 'labelSet.labelSetId': '${configB.labelSet.labelSetId}'.`
-      ].join(" ")
-    );
-  }
-  if (configA.labelSet.labelSetVersion !== configB.labelSet.labelSetVersion) {
-    throw new Error(
-      [
-        `'labelSet.labelSetVersion' must be compatible.`,
-        `Stored Config 'labelSet.labelSetVersion': '${configA.labelSet.labelSetVersion}'.`,
-        `Current Config 'labelSet.labelSetVersion': '${configB.labelSet.labelSetVersion}'.`
-      ].join(" ")
-    );
-  }
-  const configAPluginsSet = new Set(configA.plugins);
-  const configBPluginsSet = new Set(configB.plugins);
-  if (configAPluginsSet.symmetricDifference(configBPluginsSet).size > 0) {
-    throw new Error(
-      [
-        `'plugins' must be compatible.`,
-        `Stored Config 'plugins': '${configA.plugins.join(", ")}'.`,
-        `Current Config 'plugins': '${configB.plugins.join(", ")}'.`
-      ].join(" ")
-    );
-  }
-}
-
-// src/ensindexer/config/label-utils.ts
-import { hexToBytes as hexToBytes2 } from "viem";
-function labelHashToBytes(labelHash) {
-  try {
-    if (labelHash.length !== 66) {
-      throw new Error(`Invalid labelHash length ${labelHash.length} characters (expected 66)`);
-    }
-    if (labelHash !== labelHash.toLowerCase()) {
-      throw new Error("Labelhash must be in lowercase");
-    }
-    if (!labelHash.startsWith("0x")) {
-      throw new Error("Labelhash must be 0x-prefixed");
-    }
-    const bytes = hexToBytes2(labelHash);
-    if (bytes.length !== 32) {
-      throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
-    }
-    return bytes;
-  } catch (e) {
-    if (e instanceof Error) {
-      throw e;
-    }
-    throw new Error("Invalid hex format");
-  }
-}
-
-// src/ensindexer/config/parsing.ts
-function parseNonNegativeInteger(maybeNumber) {
-  const trimmed = maybeNumber.trim();
-  if (!trimmed) {
-    throw new Error("Input cannot be empty");
-  }
-  if (trimmed === "-0") {
-    throw new Error("Negative zero is not a valid non-negative integer");
-  }
-  const num = Number(maybeNumber);
-  if (Number.isNaN(num)) {
-    throw new Error(`"${maybeNumber}" is not a valid number`);
-  }
-  if (!Number.isFinite(num)) {
-    throw new Error(`"${maybeNumber}" is not a finite number`);
-  }
-  if (!Number.isInteger(num)) {
-    throw new Error(`"${maybeNumber}" is not an integer`);
-  }
-  if (num < 0) {
-    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
-  }
-  return num;
-}
-
-// src/ensindexer/config/validate/ensindexer-public-config.ts
-import { prettifyError as prettifyError15 } from "zod/v4";
-function validateEnsIndexerPublicConfig(unvalidatedConfig) {
-  const schema = makeEnsIndexerPublicConfigSchema();
-  const result = schema.safeParse(unvalidatedConfig);
-  if (!result.success) {
-    throw new Error(`Invalid ENSIndexerPublicConfig: ${prettifyError15(result.error)}`);
-  }
-  return result.data;
-}
-
-// src/ensindexer/config/validate/ensindexer-version-info.ts
-import { prettifyError as prettifyError16 } from "zod/v4";
-function validateEnsIndexerVersionInfo(unvalidatedVersionInfo) {
-  const schema = makeEnsIndexerVersionInfoSchema();
-  const result = schema.safeParse(unvalidatedVersionInfo);
-  if (!result.success) {
-    throw new Error(`Invalid EnsIndexerVersionInfo: ${prettifyError16(result.error)}`);
+    return deserializedNameTokensResponse(responseData);
   }
-  return result.data;
-}
-
-// src/ensv2/ids-lib.ts
-import { hexToBigInt as hexToBigInt2 } from "viem";
-var makeRegistryId = (accountId) => formatAccountId(accountId);
-var makeENSv1DomainId = (node) => node;
-var makeENSv2DomainId = (registry, canonicalId) => formatAssetId({
-  assetNamespace: AssetNamespaces.ERC1155,
-  contract: registry,
-  tokenId: canonicalId
-});
-var maskLower32Bits = (num) => num ^ num & 0xffffffffn;
-var getCanonicalId = (input) => {
-  if (typeof input === "bigint") return maskLower32Bits(input);
-  return getCanonicalId(hexToBigInt2(input));
 };
-var makePermissionsId = (contract) => formatAccountId(contract);
-var makePermissionsResourceId = (contract, resource) => `${makePermissionsId(contract)}/${resource}`;
-var makePermissionsUserId = (contract, resource, user) => `${makePermissionsId(contract)}/${resource}/${user}`;
-var makeResolverId = (contract) => formatAccountId(contract);
-var makeResolverRecordsId = (resolver, node) => `${makeResolverId(resolver)}/${node}`;
-var makeRegistrationId = (domainId, index) => `${domainId}/${index}`;
-var makeRenewalId = (domainId, registrationIndex, index) => `${makeRegistrationId(domainId, registrationIndex)}/${index}`;
-
-// src/graphql-api/prerequisites.ts
-function hasGraphqlApiConfigSupport(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/identity/identity.ts
 import { getENSRootChainId as getENSRootChainId2 } from "@ensnode/datasources";
@@ -3984,14 +3773,14 @@ function isResolvedIdentity(identity) {
 }
 
 // src/indexing-status/deserialize/chain-indexing-status-snapshot.ts
-import { prettifyError as prettifyError17 } from "zod/v4";
+import { prettifyError as prettifyError18 } 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:
-${prettifyError17(parsed.error)}
+${prettifyError18(parsed.error)}
 `
     );
   }
@@ -4009,32 +3798,43 @@ function createRealtimeIndexingStatusProjection(snapshot, now) {
 }
 
 // src/indexing-status/validate/chain-indexing-status-snapshot.ts
-import { prettifyError as prettifyError18 } from "zod/v4";
+import { prettifyError as prettifyError19 } from "zod/v4";
 function validateChainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid ChainIndexingStatusSnapshot:
-${prettifyError18(parsed.error)}
+${prettifyError19(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
 // src/indexing-status/validate/realtime-indexing-status-projection.ts
-import { prettifyError as prettifyError19 } from "zod/v4";
+import { prettifyError as prettifyError20 } from "zod/v4";
 function validateRealtimeIndexingStatusProjection(unvalidatedProjection, valueLabel) {
   const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedProjection);
   if (parsed.error) {
     throw new Error(`Invalid RealtimeIndexingStatusProjection:
-${prettifyError19(parsed.error)}
+${prettifyError20(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/registrars/basenames-subregistry.ts
+import { asInterpretedName } from "enssdk";
 import {
   DatasourceNames as DatasourceNames2,
   ENSNamespaceIds as ENSNamespaceIds4,
@@ -4049,18 +3849,15 @@ function getBasenamesSubregistryId(namespace) {
   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
-  };
+  return { chainId: datasource.chain.id, address };
 }
 function getBasenamesSubregistryManagedName(namespaceId) {
   switch (namespaceId) {
     case ENSNamespaceIds4.Mainnet:
-      return "base.eth";
+      return asInterpretedName("base.eth");
     case ENSNamespaceIds4.Sepolia:
     case ENSNamespaceIds4.SepoliaV2:
-      return "basetest.eth";
+      return asInterpretedName("basetest.eth");
     case ENSNamespaceIds4.EnsTestEnv:
       throw new Error(
         `No registrar managed name is known for the 'basenames' subregistry within the "${namespaceId}" namespace.`
@@ -4069,6 +3866,7 @@ function getBasenamesSubregistryManagedName(namespaceId) {
 }
 
 // src/registrars/ethnames-subregistry.ts
+import { asInterpretedName as asInterpretedName2 } from "enssdk";
 import {
   DatasourceNames as DatasourceNames3,
   ENSNamespaceIds as ENSNamespaceIds5,
@@ -4083,10 +3881,7 @@ function getEthnamesSubregistryId(namespace) {
   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
-  };
+  return { chainId: datasource.chain.id, address };
 }
 function getEthnamesSubregistryManagedName(namespaceId) {
   switch (namespaceId) {
@@ -4094,11 +3889,12 @@ function getEthnamesSubregistryManagedName(namespaceId) {
     case ENSNamespaceIds5.Sepolia:
     case ENSNamespaceIds5.SepoliaV2:
     case ENSNamespaceIds5.EnsTestEnv:
-      return "eth";
+      return asInterpretedName2("eth");
   }
 }
 
 // src/registrars/lineanames-subregistry.ts
+import { asInterpretedName as asInterpretedName3 } from "enssdk";
 import {
   DatasourceNames as DatasourceNames4,
   ENSNamespaceIds as ENSNamespaceIds6,
@@ -4113,18 +3909,15 @@ function getLineanamesSubregistryId(namespace) {
   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
-  };
+  return { chainId: datasource.chain.id, address };
 }
 function getLineanamesSubregistryManagedName(namespaceId) {
   switch (namespaceId) {
     case ENSNamespaceIds6.Mainnet:
-      return "linea.eth";
+      return asInterpretedName3("linea.eth");
     case ENSNamespaceIds6.Sepolia:
     case ENSNamespaceIds6.SepoliaV2:
-      return "linea-sepolia.eth";
+      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.`
@@ -4148,6 +3941,7 @@ function isRegistrationInGracePeriod(info, now) {
 }
 
 // src/resolution/ensip19-chainid.ts
+import { DEFAULT_EVM_CHAIN_ID } from "enssdk";
 import { mainnet } from "viem/chains";
 import { getENSRootChainId as getENSRootChainId3 } from "@ensnode/datasources";
 var getResolvePrimaryNameChainIdParam = (chainId, namespaceId) => {
@@ -4159,7 +3953,7 @@ var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
 };
 
 // src/resolution/resolver-records-selection.ts
-var isSelectionEmpty = (selection) => !selection.name && !selection.addresses?.length && !selection.texts?.length;
+var isSelectionEmpty = (selection) => !selection.name && !selection.addresses?.length && !selection.texts?.length && !selection.contenthash && !selection.pubkey && !selection.dnszonehash && selection.abi === void 0 && !selection.interfaces?.length && !selection.version;
 
 // src/shared/cache/lru-cache.ts
 var LruCache = class {
@@ -4218,13 +4012,13 @@ import { getUnixTime as getUnixTime2 } from "date-fns/getUnixTime";
 import { getUnixTime } from "date-fns/getUnixTime";
 
 // src/shared/deserialize.ts
-import z19, { prettifyError as prettifyError20 } from "zod/v4";
+import z21, { prettifyError as prettifyError21 } 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:
-${prettifyError20(parsed.error)}
+${prettifyError21(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4234,7 +4028,7 @@ function deserializeDatetime(maybeDatetime, valueLabel) {
   const parsed = schema.safeParse(maybeDatetime);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Datetime:
-${prettifyError20(parsed.error)}
+${prettifyError21(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4244,7 +4038,7 @@ function deserializeUnixTimestamp(maybeTimestamp, valueLabel) {
   const parsed = schema.safeParse(maybeTimestamp);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Unix Timestamp:
-${prettifyError20(parsed.error)}
+${prettifyError21(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4254,7 +4048,7 @@ function deserializeUrl(maybeUrl, valueLabel) {
   const parsed = schema.safeParse(maybeUrl);
   if (parsed.error) {
     throw new Error(`Cannot deserialize URL:
-${prettifyError20(parsed.error)}
+${prettifyError21(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4264,7 +4058,7 @@ function deserializeBlockNumber(maybeBlockNumber, valueLabel) {
   const parsed = schema.safeParse(maybeBlockNumber);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockNumber:
-${prettifyError20(parsed.error)}
+${prettifyError21(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4274,17 +4068,17 @@ function deserializeBlockRef(maybeBlockRef, valueLabel) {
   const parsed = schema.safeParse(maybeBlockRef);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockRef:
-${prettifyError20(parsed.error)}
+${prettifyError21(parsed.error)}
 `);
   }
   return parsed.data;
 }
 function deserializeDuration(maybeDuration, valueLabel) {
-  const schema = z19.coerce.number().pipe(makeDurationSchema(valueLabel));
+  const schema = z21.coerce.number().pipe(makeDurationSchema(valueLabel));
   const parsed = schema.safeParse(maybeDuration);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize Duration:
-${prettifyError20(parsed.error)}
+${prettifyError21(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4294,7 +4088,7 @@ function parseAccountId(maybeAccountId, valueLabel) {
   const parsed = schema.safeParse(maybeAccountId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AccountId:
-${prettifyError20(parsed.error)}
+${prettifyError21(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4304,7 +4098,7 @@ function deserializePriceEth(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceEth:
-${prettifyError20(parsed.error)}
+${prettifyError21(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4314,7 +4108,7 @@ function deserializePriceUsdc(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceUsdc:
-${prettifyError20(parsed.error)}
+${prettifyError21(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4324,7 +4118,7 @@ function deserializePriceDai(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceDai:
-${prettifyError20(parsed.error)}
+${prettifyError21(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4511,7 +4305,8 @@ import { isAddressEqual as isAddressEqual4, zeroAddress as zeroAddress5 } from "
 var interpretAddress = (owner) => isAddressEqual4(zeroAddress5, owner) ? null : owner;
 
 // src/shared/interpretation/interpret-record-values.ts
-import { isAddress as isAddress3, isAddressEqual as isAddressEqual5, zeroAddress as zeroAddress6 } from "viem";
+import { isInterpretedName, toNormalizedAddress as toNormalizedAddress3 } from "enssdk";
+import { isAddress as isAddress2, isAddressEqual as isAddressEqual5, zeroAddress as zeroAddress6 } from "viem";
 
 // src/shared/null-bytes.ts
 var hasNullByte = (value) => value.indexOf("\0") !== -1;
@@ -4520,16 +4315,16 @@ var stripNullBytes = (value) => value.replaceAll("\0", "");
 // src/shared/interpretation/interpret-record-values.ts
 function interpretNameRecordValue(value) {
   if (value === "") return null;
-  if (!isNormalizedName(value)) return null;
+  if (!isInterpretedName(value)) return null;
   return value;
 }
 function interpretAddressRecordValue(value) {
   if (hasNullByte(value)) return null;
   if (value === "") return null;
   if (value === "0x") return null;
-  if (!isAddress3(value)) return value;
+  if (!isAddress2(value, { strict: false })) return value;
   if (isAddressEqual5(value, zeroAddress6)) return null;
-  return asLowerCaseAddress(value);
+  return toNormalizedAddress3(value);
 }
 function interpretTextRecordKey(key) {
   if (hasNullByte(key)) return null;
@@ -4542,83 +4337,19 @@ function interpretTextRecordValue(value) {
   return value;
 }
 
-// src/shared/interpretation/interpret-tokenid.ts
-var interpretTokenIdAsLabelHash = (tokenId) => uint256ToHex32(tokenId);
-var interpretTokenIdAsNode = (tokenId) => uint256ToHex32(tokenId);
-
-// src/shared/interpretation/interpreted-names-and-labels.ts
-import { isHex as isHex4 } from "viem";
-import { labelhash } from "viem/ens";
-
-// src/shared/labelhash.ts
-import { keccak256 as keccak2562, stringToBytes } from "viem";
-var labelhashLiteralLabel = (label) => keccak2562(stringToBytes(label));
-
-// src/shared/interpretation/interpreted-names-and-labels.ts
-function literalLabelToInterpretedLabel(label) {
-  if (isNormalizedLabel(label)) return label;
-  return encodeLabelHash(labelhashLiteralLabel(label));
-}
-function literalLabelsToInterpretedName(labels) {
-  return labels.map(literalLabelToInterpretedLabel).join(".");
-}
-function interpretedLabelsToInterpretedName(labels) {
-  return labels.join(".");
-}
-function literalLabelsToLiteralName(labels) {
-  return labels.join(".");
-}
-function interpretedNameToInterpretedLabels(name) {
-  return name.split(".");
-}
-function encodedLabelToLabelhash(label) {
-  if (label.length !== 66) return null;
-  if (label.indexOf("[") !== 0) return null;
-  if (label.indexOf("]") !== 65) return null;
-  const hash = `0x${label.slice(1, 65)}`;
-  if (!isHex4(hash)) return null;
-  return hash;
-}
-function isInterpetedLabel(label) {
-  if (label.startsWith("[")) {
-    const labelHash = encodedLabelToLabelhash(label);
-    return labelHash != null;
-  }
-  return isNormalizedLabel(label);
+// src/shared/interpretation/interpret-resolver-values.ts
+import { size as size3, zeroHash } from "viem";
+function interpretContenthashValue(value) {
+  if (size3(value) === 0) return null;
+  return value;
 }
-function isInterpretedName(name) {
-  return name.split(".").every(isInterpetedLabel);
+function interpretPubkeyValue(x, y) {
+  if (x === zeroHash && y === zeroHash) return null;
+  return { x, y };
 }
-function interpretedLabelsToLabelHashPath(labels) {
-  return labels.map((label) => {
-    if (!isInterpetedLabel(label)) {
-      throw new Error(
-        `Invariant(interpretedLabelsToLabelHashPath): Expected InterpretedLabel, received '${label}'.`
-      );
-    }
-    const maybeLabelHash = encodedLabelToLabelhash(label);
-    if (maybeLabelHash !== null) return maybeLabelHash;
-    return labelhash(label);
-  }).toReversed();
-}
-function constructSubInterpretedName(label, name) {
-  if (name === void 0 || name === "") return label;
-  return [label, name].join(".");
-}
-function ensureInterpretedLabel(labelHash, label) {
-  return label ?? encodeLabelHash(labelHash);
-}
-function parsePartialInterpretedName(partialInterpretedName) {
-  if (partialInterpretedName === "") return { concrete: [], partial: "" };
-  const concrete = partialInterpretedName.split(".");
-  const partial = concrete.pop();
-  if (!concrete.every(isInterpetedLabel)) {
-    throw new Error(
-      `Invariant(parsePartialInterpretedName): Concrete portion of Partial InterpretedName contains segments that are not InterpretedLabels.
-${JSON.stringify(concrete)}`
-    );
-  }
-  return { concrete, partial };
+function interpretDnszonehashValue(value) {
+  if (size3(value) === 0) return null;
+  return value;
 }
 
 // src/shared/namespace-specific-value.ts
@@ -4627,6 +4358,7 @@ function getNamespaceSpecificValue(namespace, value) {
 }
 
 // src/shared/root-registry.ts
+import { makeRegistryId } from "enssdk";
 import { DatasourceNames as DatasourceNames5 } from "@ensnode/datasources";
 var getENSv1Registry = (namespace) => getDatasourceContract(namespace, DatasourceNames5.ENSRoot, "ENSv1Registry");
 var isENSv1Registry = (namespace, contract) => accountIdEqual(getENSv1Registry(namespace), contract);
@@ -4648,6 +4380,16 @@ 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 */);
@@ -4688,39 +4430,28 @@ var ReverseResolutionProtocolStep = /* @__PURE__ */ ((ReverseResolutionProtocolS
   return ReverseResolutionProtocolStep2;
 })(ReverseResolutionProtocolStep || {});
 export {
-  ADDR_REVERSE_NODE,
   ATTR_PROTOCOL_NAME,
   ATTR_PROTOCOL_STEP,
   ATTR_PROTOCOL_STEP_RESULT,
-  AssetNamespaces,
-  BASENAMES_NODE,
   ChainIndexingStatusIds,
   ClientError,
   CrossChainIndexingStrategyIds,
   CurrencyIds,
-  DEFAULT_ENSNODE_API_URL_MAINNET,
-  DEFAULT_ENSNODE_API_URL_SEPOLIA,
-  DEFAULT_EVM_CHAIN_ID,
-  DEFAULT_EVM_COIN_TYPE,
+  DEFAULT_ENSNODE_URL_MAINNET,
+  DEFAULT_ENSNODE_URL_SEPOLIA,
   ENCODED_REFERRER_BYTE_LENGTH,
   ENCODED_REFERRER_BYTE_OFFSET,
-  ENSNamespaceIds,
-  ENSNodeClient,
-  ENS_ROOT,
-  ETH_COIN_TYPE,
-  ETH_NODE,
+  ENSNamespaceIds7 as ENSNamespaceIds,
   EXPECTED_ENCODED_REFERRER_PADDING,
-  EnsApiClient,
   EnsApiIndexingStatusResponseCodes,
   EnsIndexerClient,
   EnsIndexerIndexingStatusResponseCodes,
+  EnsNodeClient,
   ForwardResolutionProtocolStep,
   IndexingStatusResponseCodes,
-  LINEANAMES_NODE,
   LruCache,
   NFTMintStatuses,
   NFTTransferTypes,
-  NODE_ANY,
   NameTokenOwnershipTypes,
   NameTokensResponseCodes,
   NameTokensResponseErrorCodes,
@@ -4729,8 +4460,6 @@ export {
   PluginName,
   RECORDS_PER_PAGE_DEFAULT,
   RECORDS_PER_PAGE_MAX,
-  ROOT_NODE,
-  ROOT_RESOURCE,
   RangeTypeIds,
   RegistrarActionTypes,
   RegistrarActionsFilterTypes,
@@ -4747,16 +4476,13 @@ export {
   accountIdEqual,
   addDuration,
   addPrices,
-  addrReverseLabel,
-  asLowerCaseAddress,
-  beautifyName,
   bigIntToNumber,
-  bigintToCoinType,
   buildAssetId,
   buildBlockNumberRange,
   buildBlockRefRange,
   buildCrossChainIndexingStatusSnapshotOmnichain,
   buildEncodedReferrer,
+  buildEnsNodeStackInfo,
   buildEnsRainbowClientLabelSet,
   buildIndexedBlockranges,
   buildLabelSetId,
@@ -4765,38 +4491,34 @@ export {
   buildPageContext,
   buildUnresolvedIdentity,
   buildUnvalidatedCrossChainIndexingStatusSnapshot,
+  buildUnvalidatedEnsApiPublicConfig,
   buildUnvalidatedEnsIndexerPublicConfig,
+  buildUnvalidatedEnsNodeStackInfo,
   buildUnvalidatedOmnichainIndexingStatusSnapshot,
   buildUnvalidatedRealtimeIndexingStatusProjection,
   checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill,
   checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted,
   checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing,
   checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted,
-  coinTypeReverseLabel,
-  coinTypeToEvmChainId,
-  constructSubInterpretedName,
   createRealtimeIndexingStatusProjection,
-  decodeDNSEncodedLiteralName,
-  decodeDNSEncodedName,
   decodeEncodedReferrer,
   deserializeAssetId,
   deserializeBlockNumber,
   deserializeBlockRef,
   deserializeChainId,
   deserializeChainIndexingStatusSnapshot,
-  deserializeConfigResponse,
   deserializeCrossChainIndexingStatusSnapshot,
   deserializeDatetime,
   deserializeDuration,
   deserializeENSApiPublicConfig,
   deserializeENSIndexerPublicConfig,
-  deserializeEnsApiConfigResponse,
   deserializeEnsApiIndexingStatusResponse,
   deserializeEnsApiPublicConfig,
   deserializeEnsIndexerConfigResponse,
   deserializeEnsIndexerIndexingStatusResponse,
   deserializeEnsIndexerPublicConfig,
-  deserializeErrorResponse,
+  deserializeEnsNodeStackInfo,
+  deserializeErrorResponse2 as deserializeErrorResponse,
   deserializeIndexingStatusResponse,
   deserializeOmnichainIndexingStatusSnapshot,
   deserializePriceDai,
@@ -4808,16 +4530,9 @@ export {
   deserializeUrl,
   deserializedNameTokensResponse,
   durationBetween,
-  encodeLabelHash,
-  encodedLabelToLabelhash,
-  ensureInterpretedLabel,
-  evmChainIdToCoinType,
-  formatAccountId,
-  formatAssetId,
   formatNFTTransferEventMetadata,
   getBasenamesSubregistryId,
   getBasenamesSubregistryManagedName,
-  getCanonicalId,
   getCurrencyInfo,
   getDatasourceContract,
   getDefaultEnsNodeUrl,
@@ -4832,40 +4547,30 @@ export {
   getLineanamesSubregistryId,
   getLineanamesSubregistryManagedName,
   getNFTTransferType,
-  getNameHierarchy,
   getNameTokenOwnership,
   getNameWrapperAccounts,
   getNamespaceSpecificValue,
   getOmnichainIndexingCursor,
   getOmnichainIndexingStatus,
-  getParentNameFQDN,
   getResolvePrimaryNameChainIdParam,
   getTimestampForHighestOmnichainKnownBlock,
   getTimestampForLowestOmnichainStartBlock,
-  hasGraphqlApiConfigSupport,
   hasNullByte,
+  hasOmnigraphApiConfigSupport,
   hasRegistrarActionsConfigSupport,
   hasRegistrarActionsIndexingStatusSupport,
   hasSubgraphApiConfigSupport,
   interpretAddress,
   interpretAddressRecordValue,
+  interpretContenthashValue,
+  interpretDnszonehashValue,
   interpretNameRecordValue,
+  interpretPubkeyValue,
   interpretTextRecordKey,
   interpretTextRecordValue,
-  interpretTokenIdAsLabelHash,
-  interpretTokenIdAsNode,
-  interpretedLabelsToInterpretedName,
-  interpretedLabelsToLabelHashPath,
-  interpretedNameToInterpretedLabels,
   isENSv1Registry,
   isENSv2RootRegistry,
-  isEncodedLabelHash,
   isHttpProtocol,
-  isInterpetedLabel,
-  isInterpretedName,
-  isLabelHash,
-  isNormalizedLabel,
-  isNormalizedName,
   isPccFuseSet,
   isPriceCurrencyEqual,
   isPriceEqual,
@@ -4879,65 +4584,45 @@ export {
   isSubgraphCompatible,
   isWebSocketProtocol,
   labelHashToBytes,
-  labelhashLiteralLabel,
-  literalLabelToInterpretedLabel,
-  literalLabelsToInterpretedName,
-  literalLabelsToLiteralName,
   makeContractMatcher,
   makeENSApiPublicConfigSchema,
-  makeENSv1DomainId,
-  makeENSv2DomainId,
   makeEnsApiPublicConfigSchema,
-  makePermissionsId,
-  makePermissionsResourceId,
-  makePermissionsUserId,
-  makeRegistrationId,
-  makeRegistryId,
-  makeRenewalId,
-  makeResolverId,
-  makeResolverRecordsId,
   makeSerializedEnsApiPublicConfigSchema,
-  makeSubdomainNode,
+  maxPrice,
   maybeGetDatasourceContract,
   maybeGetENSv2RootRegistry,
   maybeGetENSv2RootRegistryId,
   mergeBlockNumberRanges,
+  minPrice,
   nameTokensPrerequisites,
   parseAccountId,
   parseAssetId,
   parseDai,
-  parseEncodedLabelHash,
   parseEth,
-  parseLabelHash,
-  parseLabelHashOrEncodedLabelHash,
   parseNonNegativeInteger,
-  parsePartialInterpretedName,
-  parseReverseName,
   parseTimestamp,
   parseUsdc,
   priceDai,
   priceEth,
   priceUsdc,
   registrarActionsFilter,
-  reverseName,
   scaleBigintByNumber,
   scalePrice,
   serializeAssetId,
   serializeChainId,
   serializeChainIndexingSnapshots,
-  serializeConfigResponse,
   serializeCrossChainIndexingStatusSnapshot,
   serializeCrossChainIndexingStatusSnapshotOmnichain,
   serializeDatetime,
   serializeDomainAssetId,
   serializeENSApiPublicConfig,
   serializeENSIndexerPublicConfig,
-  serializeEnsApiConfigResponse,
   serializeEnsApiIndexingStatusResponse,
   serializeEnsApiPublicConfig,
   serializeEnsIndexerConfigResponse,
   serializeEnsIndexerIndexingStatusResponse,
   serializeEnsIndexerPublicConfig,
+  serializeEnsNodeStackInfo,
   serializeIndexedChainIds,
   serializeIndexingStatusResponse,
   serializeNameToken,
@@ -4956,8 +4641,8 @@ export {
   serializeUrl,
   sortChainStatusesByStartBlockAsc,
   stripNullBytes,
+  subtractPrice,
   translateDefaultableChainIdToChainId,
-  uint256ToHex32,
   uniq,
   validateChainIndexingStatusSnapshot,
   validateCrossChainIndexingStatusSnapshot,