@ensnode/ensnode-sdk 0.0.0-next-20260130145445 → 0.0.0-next-20260202030222

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/ensapi/config/deserialize.ts
-import { prettifyError as prettifyError2, ZodError } from "zod/v4";
+import { prettifyError, ZodError } from "zod/v4";
 
 // src/ensapi/config/zod-schemas.ts
 import { z as z4 } from "zod/v4";
@@ -7,72 +7,8 @@ import { z as z4 } from "zod/v4";
 // src/ensindexer/config/zod-schemas.ts
 import { z as z2 } from "zod/v4";
 
-// 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/address.ts
-function asLowerCaseAddress(address) {
-  return address.toLowerCase();
-}
-
-// src/shared/cache/lru-cache.ts
-var LruCache = class {
-  _cache = /* @__PURE__ */ new Map();
-  _capacity;
-  /**
-   * Create a new LRU cache with the given capacity.
-   *
-   * @param capacity The maximum number of items in the cache. If set to 0, the cache is effectively disabled.
-   * @throws Error if capacity is not a non-negative integer.
-   */
-  constructor(capacity) {
-    if (!Number.isInteger(capacity)) {
-      throw new Error(
-        `LruCache requires capacity to be an integer but a capacity of ${capacity} was requested.`
-      );
-    }
-    if (capacity < 0) {
-      throw new Error(
-        `LruCache requires a non-negative capacity but a capacity of ${capacity} was requested.`
-      );
-    }
-    this._capacity = capacity;
-  }
-  set(key, value) {
-    this._cache.set(key, value);
-    if (this._cache.size > this._capacity) {
-      const oldestKey = this._cache.keys().next().value;
-      this._cache.delete(oldestKey);
-    }
-  }
-  get(key) {
-    const value = this._cache.get(key);
-    if (value) {
-      this._cache.delete(key);
-      this._cache.set(key, value);
-    }
-    return value;
-  }
-  clear() {
-    this._cache.clear();
-  }
-  get size() {
-    return this._cache.size;
-  }
-  get capacity() {
-    return this._capacity;
-  }
-};
-
-// src/shared/cache/swr-cache.ts
-import { secondsToMilliseconds } from "date-fns";
-import { getUnixTime } from "date-fns/getUnixTime";
-
-// src/shared/deserialize.ts
-import { prettifyError } from "zod/v4";
+// src/shared/collections.ts
+var uniq = (arr) => [...new Set(arr)];
 
 // src/shared/zod-schemas.ts
 import { AccountId as CaipAccountId } from "caip";
@@ -212,6 +148,13 @@ var beautifyName = (name) => {
 
 // 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}`;
@@ -267,6 +210,52 @@ var uint256ToHex32 = (num) => toHex(num, { size: 32 });
 // src/ens/types.ts
 import { ENSNamespaceIds } from "@ensnode/datasources";
 
+// src/shared/currencies.ts
+import { parseUnits } from "viem";
+
+// src/shared/numbers.ts
+function bigIntToNumber(n) {
+  if (n < Number.MIN_SAFE_INTEGER) {
+    throw new Error(
+      `The bigint '${n.toString()}' value is too low to be to converted into a number.'`
+    );
+  }
+  if (n > Number.MAX_SAFE_INTEGER) {
+    throw new Error(
+      `The bigint '${n.toString()}' value is too high to be to converted into a number.'`
+    );
+  }
+  return Number(n);
+}
+function scaleBigintByNumber(value, scaleFactor) {
+  if (value < 0n) {
+    throw new Error(`scaleBigintByNumber: value must be non-negative, got: ${value.toString()}`);
+  }
+  if (!Number.isFinite(scaleFactor)) {
+    throw new Error(
+      `scaleBigintByNumber: scaleFactor must be a finite number, got: ${scaleFactor}`
+    );
+  }
+  if (scaleFactor < 0) {
+    throw new Error(`scaleBigintByNumber: scaleFactor must be non-negative, got: ${scaleFactor}`);
+  }
+  if (scaleFactor >= 1e21) {
+    throw new Error(`scaleBigintByNumber: scaleFactor must be less than 1e21, got: ${scaleFactor}`);
+  }
+  if (value === 0n || scaleFactor === 0) {
+    return 0n;
+  }
+  if (scaleFactor === 1) {
+    return value;
+  }
+  const fixedStr = scaleFactor.toFixed(20);
+  const [integerPart, decimalPart = ""] = fixedStr.split(".");
+  const trimmedDecimal = decimalPart.replace(/0+$/, "") || "0";
+  const numerator = BigInt(integerPart + trimmedDecimal);
+  const denominator = 10n ** BigInt(trimmedDecimal.length);
+  return value * numerator / denominator;
+}
+
 // src/shared/currencies.ts
 var CurrencyIds = {
   ETH: "ETH",
@@ -335,6 +324,43 @@ function addPrices(...prices) {
     }
   );
 }
+function scalePrice(price, scaleFactor) {
+  const scaledAmount = scaleBigintByNumber(price.amount, scaleFactor);
+  return {
+    ...price,
+    amount: scaledAmount
+  };
+}
+function validateAmountToParse(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    throw new Error("amount must be a non-negative decimal string");
+  }
+  if (value !== trimmed) {
+    throw new Error("amount must not have leading or trailing whitespace");
+  }
+  if (trimmed.startsWith("-")) {
+    throw new Error("amount must be a non-negative decimal string");
+  }
+}
+function parseEth(value) {
+  validateAmountToParse(value);
+  const currencyInfo2 = getCurrencyInfo(CurrencyIds.ETH);
+  const amount = parseUnits(value, currencyInfo2.decimals);
+  return priceEth(amount);
+}
+function parseUsdc(value) {
+  validateAmountToParse(value);
+  const currencyInfo2 = getCurrencyInfo(CurrencyIds.USDC);
+  const amount = parseUnits(value, currencyInfo2.decimals);
+  return priceUsdc(amount);
+}
+function parseDai(value) {
+  validateAmountToParse(value);
+  const currencyInfo2 = getCurrencyInfo(CurrencyIds.DAI);
+  const amount = parseUnits(value, currencyInfo2.decimals);
+  return priceDai(amount);
+}
 
 // src/shared/interpretation/reinterpretation.ts
 import { labelhash as labelToLabelHash } from "viem";
@@ -430,6 +456,8 @@ var makePriceCurrencySchema = (currency, valueLabel = "Price Currency") => z.str
   })
 });
 var makePriceEthSchema = (valueLabel = "Price ETH") => makePriceCurrencySchema(CurrencyIds.ETH, valueLabel).transform((v) => v);
+var makePriceUsdcSchema = (valueLabel = "Price USDC") => makePriceCurrencySchema(CurrencyIds.USDC, valueLabel).transform((v) => v);
+var makePriceDaiSchema = (valueLabel = "Price DAI") => makePriceCurrencySchema(CurrencyIds.DAI, valueLabel).transform((v) => v);
 var makeAccountIdSchema = (valueLabel = "AccountId") => z.strictObject({
   chainId: makeChainIdSchema(`${valueLabel} chain ID`),
   address: makeLowercaseAddressSchema(`${valueLabel} address`)
@@ -475,710 +503,405 @@ var makeReinterpretedNameSchema = (valueLabel = "Reinterpreted Name") => z.strin
   }
 }).transform(reinterpretName);
 
-// src/shared/deserialize.ts
-function deserializeChainId(maybeChainId, valueLabel) {
-  const schema = makeChainIdStringSchema(valueLabel);
-  const parsed = schema.safeParse(maybeChainId);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize ChainId:
-${prettifyError(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
-function deserializeDatetime(maybeDatetime, valueLabel) {
-  const schema = makeDatetimeSchema(valueLabel);
-  const parsed = schema.safeParse(maybeDatetime);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize Datetime:
-${prettifyError(parsed.error)}
-`);
-  }
-  return parsed.data;
+// src/ensindexer/config/is-subgraph-compatible.ts
+import { ENSNamespaceIds as ENSNamespaceIds2 } from "@ensnode/datasources";
+
+// src/ensindexer/config/types.ts
+var PluginName = /* @__PURE__ */ ((PluginName2) => {
+  PluginName2["Subgraph"] = "subgraph";
+  PluginName2["Basenames"] = "basenames";
+  PluginName2["Lineanames"] = "lineanames";
+  PluginName2["ThreeDNS"] = "threedns";
+  PluginName2["ProtocolAcceleration"] = "protocol-acceleration";
+  PluginName2["Registrars"] = "registrars";
+  PluginName2["TokenScope"] = "tokenscope";
+  PluginName2["ENSv2"] = "ensv2";
+  return PluginName2;
+})(PluginName || {});
+
+// src/ensindexer/config/is-subgraph-compatible.ts
+function isSubgraphCompatible(config) {
+  const onlySubgraphPluginActivated = config.plugins.length === 1 && config.plugins[0] === "subgraph" /* Subgraph */;
+  const isSubgraphLabelSet = config.labelSet.labelSetId === "subgraph" && config.labelSet.labelSetVersion === 0;
+  const isEnsTestEnvLabelSet = config.labelSet.labelSetId === "ens-test-env" && config.labelSet.labelSetVersion === 0;
+  const labelSetIsSubgraphCompatible = isSubgraphLabelSet || config.namespace === ENSNamespaceIds2.EnsTestEnv && isEnsTestEnvLabelSet;
+  return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
 }
-function deserializeUnixTimestamp(maybeTimestamp, valueLabel) {
-  const schema = makeUnixTimestampSchema(valueLabel);
-  const parsed = schema.safeParse(maybeTimestamp);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize Unix Timestamp:
-${prettifyError(parsed.error)}
-`);
+
+// src/ensindexer/config/validations.ts
+function invariant_ensDbVersionIsSameAsEnsIndexerVersion(ctx) {
+  const versionInfo = ctx.value;
+  if (versionInfo.ensDb !== versionInfo.ensIndexer) {
+    ctx.issues.push({
+      code: "custom",
+      input: versionInfo,
+      message: "`ensDb` version must be same as `ensIndexer` version"
+    });
   }
-  return parsed.data;
 }
-function deserializeUrl(maybeUrl, valueLabel) {
-  const schema = makeUrlSchema(valueLabel);
-  const parsed = schema.safeParse(maybeUrl);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize URL:
-${prettifyError(parsed.error)}
-`);
+
+// src/ensindexer/config/zod-schemas.ts
+var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => z2.array(makeChainIdSchema(valueLabel), {
+  error: `${valueLabel} must be an array.`
+}).min(1, { error: `${valueLabel} list must include at least one element.` }).transform((v) => new Set(v));
+var makePluginsListSchema = (valueLabel = "Plugins") => z2.array(z2.string(), {
+  error: `${valueLabel} must be a list of strings.`
+}).min(1, {
+  error: `${valueLabel} must be a list of strings with at least one string value`
+}).refine((arr) => arr.length === uniq(arr).length, {
+  error: `${valueLabel} cannot contain duplicate values.`
+});
+var makeDatabaseSchemaNameSchema = (valueLabel = "Database schema name") => z2.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
+  error: `${valueLabel} is required and must be a non-empty string.`
+});
+var makeLabelSetIdSchema = (valueLabel) => {
+  return z2.string({ error: `${valueLabel} must be a string` }).min(1, { error: `${valueLabel} must be 1-50 characters long` }).max(50, { error: `${valueLabel} must be 1-50 characters long` }).regex(/^[a-z-]+$/, {
+    error: `${valueLabel} can only contain lowercase letters (a-z) and hyphens (-)`
+  });
+};
+var makeLabelSetVersionSchema = (valueLabel) => {
+  return z2.coerce.number({ error: `${valueLabel} must be an integer.` }).pipe(makeNonNegativeIntegerSchema(valueLabel));
+};
+var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
+  let valueLabelLabelSetId = valueLabel;
+  let valueLabelLabelSetVersion = valueLabel;
+  if (valueLabel === "LABEL_SET") {
+    valueLabelLabelSetId = "LABEL_SET_ID";
+    valueLabelLabelSetVersion = "LABEL_SET_VERSION";
+  } else {
+    valueLabelLabelSetId = `${valueLabel}.labelSetId`;
+    valueLabelLabelSetVersion = `${valueLabel}.labelSetVersion`;
   }
-  return parsed.data;
-}
-function deserializeBlockNumber(maybeBlockNumber, valueLabel) {
-  const schema = makeBlockNumberSchema(valueLabel);
-  const parsed = schema.safeParse(maybeBlockNumber);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize BlockNumber:
-${prettifyError(parsed.error)}
-`);
+  return z2.object({
+    labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
+    labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
+  });
+};
+var makeNonEmptyStringSchema = (valueLabel = "Value") => z2.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
+var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => z2.strictObject(
+  {
+    nodejs: makeNonEmptyStringSchema(),
+    ponder: makeNonEmptyStringSchema(),
+    ensDb: makeNonEmptyStringSchema(),
+    ensIndexer: makeNonEmptyStringSchema(),
+    ensNormalize: makeNonEmptyStringSchema(),
+    ensRainbow: makeNonEmptyStringSchema(),
+    ensRainbowSchema: makePositiveIntegerSchema()
+  },
+  {
+    error: `${valueLabel} must be a valid ENSIndexerVersionInfo object.`
   }
-  return parsed.data;
-}
-function deserializeBlockrange(maybeBlockrange, valueLabel) {
-  const schema = makeBlockrangeSchema(valueLabel);
-  const parsed = schema.safeParse(maybeBlockrange);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize Blockrange:
-${prettifyError(parsed.error)}
-`);
+).check(invariant_ensDbVersionIsSameAsEnsIndexerVersion);
+function invariant_isSubgraphCompatibleRequirements(ctx) {
+  const { value: config } = ctx;
+  if (config.isSubgraphCompatible && !isSubgraphCompatible(config)) {
+    ctx.issues.push({
+      code: "custom",
+      input: config,
+      message: `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active and labelSet must be {labelSetId: "subgraph", labelSetVersion: 0}`
+    });
   }
-  return parsed.data;
 }
-function deserializeBlockRef(maybeBlockRef, valueLabel) {
-  const schema = makeBlockRefSchema(valueLabel);
-  const parsed = schema.safeParse(maybeBlockRef);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize BlockRef:
-${prettifyError(parsed.error)}
-`);
-  }
-  return parsed.data;
+var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => z2.object({
+  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
+  indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
+  isSubgraphCompatible: z2.boolean({ error: `${valueLabel}.isSubgraphCompatible` }),
+  namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
+  plugins: makePluginsListSchema(`${valueLabel}.plugins`),
+  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
+  versionInfo: makeENSIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
+}).check(invariant_isSubgraphCompatibleRequirements);
+
+// src/shared/config/thegraph.ts
+import { z as z3 } from "zod/v4";
+var TheGraphCannotFallbackReasonSchema = z3.enum({
+  NotSubgraphCompatible: "not-subgraph-compatible",
+  NoApiKey: "no-api-key",
+  NoSubgraphUrl: "no-subgraph-url"
+});
+var TheGraphFallbackSchema = z3.discriminatedUnion("canFallback", [
+  z3.strictObject({
+    canFallback: z3.literal(true),
+    url: z3.string()
+  }),
+  z3.strictObject({
+    canFallback: z3.literal(false),
+    reason: TheGraphCannotFallbackReasonSchema
+  })
+]);
+
+// src/ensapi/config/zod-schemas.ts
+function makeENSApiPublicConfigSchema(valueLabel) {
+  const label = valueLabel ?? "ENSApiPublicConfig";
+  return z4.strictObject({
+    version: z4.string().min(1, `${label}.version must be a non-empty string`),
+    theGraphFallback: TheGraphFallbackSchema,
+    ensIndexerPublicConfig: makeENSIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
+  });
 }
-function deserializeDuration(maybeDuration, valueLabel) {
-  const schema = makeDurationSchema(valueLabel);
-  const parsed = schema.safeParse(maybeDuration);
-  if (parsed.error) {
-    throw new RangeError(`Cannot deserialize Duration:
-${prettifyError(parsed.error)}
+
+// src/ensapi/config/deserialize.ts
+function deserializeENSApiPublicConfig(maybeConfig, valueLabel) {
+  const schema = makeENSApiPublicConfigSchema(valueLabel);
+  try {
+    return schema.parse(maybeConfig);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      throw new Error(`Cannot deserialize ENSApiPublicConfig:
+${prettifyError(error)}
 `);
+    }
+    throw error;
   }
-  return parsed.data;
 }
-function parseAccountId(maybeAccountId, valueLabel) {
-  const schema = makeAccountIdStringSchema(valueLabel);
-  const parsed = schema.safeParse(maybeAccountId);
+
+// src/ensindexer/config/deserialize.ts
+import { prettifyError as prettifyError2 } from "zod/v4";
+function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
+  const schema = makeENSIndexerPublicConfigSchema(valueLabel);
+  const parsed = schema.safeParse(maybeConfig);
   if (parsed.error) {
-    throw new RangeError(`Cannot deserialize AccountId:
-${prettifyError(parsed.error)}
+    throw new Error(`Cannot deserialize ENSIndexerPublicConfig:
+${prettifyError2(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
-// src/shared/datetime.ts
-function durationBetween(start, end) {
-  return deserializeDuration(end - start, "Duration");
-}
-function addDuration(timestamp, duration) {
-  return deserializeUnixTimestamp(timestamp + duration, "UnixTimestamp");
-}
-
-// src/shared/cache/swr-cache.ts
-var SWRCache = class {
-  constructor(options) {
-    this.options = options;
-    if (options.proactiveRevalidationInterval) {
-      this.backgroundInterval = setInterval(
-        () => this.revalidate(),
-        secondsToMilliseconds(options.proactiveRevalidationInterval)
-      );
+// 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 (options.proactivelyInitialize) this.revalidate();
-  }
-  cache = null;
-  inProgressRevalidate = null;
-  backgroundInterval = null;
-  async revalidate() {
-    if (!this.inProgressRevalidate) {
-      this.inProgressRevalidate = this.options.fn().then((result) => {
-        this.cache = {
-          result,
-          updatedAt: getUnixTime(/* @__PURE__ */ new Date())
-        };
-      }).catch((error) => {
-        if (!this.cache) {
-          this.cache = {
-            // ensure thrown value is always an Error instance
-            result: error instanceof Error ? error : new Error(String(error)),
-            updatedAt: getUnixTime(/* @__PURE__ */ new Date())
-          };
-        }
-      }).finally(() => {
-        this.inProgressRevalidate = null;
-      });
+    if (labelHash !== labelHash.toLowerCase()) {
+      throw new Error("Labelhash must be in lowercase");
     }
-    return this.inProgressRevalidate;
-  }
-  /**
-   * Read the most recently cached result from the `SWRCache`.
-   *
-   * @returns a `ValueType` that was most recently successfully returned by `fn` or `Error` if `fn`
-   * has never successfully returned.
-   */
-  async read() {
-    if (!this.cache) await this.revalidate();
-    if (!this.cache) throw new Error("never");
-    if (durationBetween(this.cache.updatedAt, getUnixTime(/* @__PURE__ */ new Date())) > this.options.ttl) {
-      this.revalidate();
+    if (!labelHash.startsWith("0x")) {
+      throw new Error("Labelhash must be 0x-prefixed");
     }
-    return this.cache.result;
-  }
-  /**
-   * Destroys the background revalidation interval, if exists.
-   */
-  destroy() {
-    if (this.backgroundInterval) {
-      clearInterval(this.backgroundInterval);
-      this.backgroundInterval = null;
+    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/shared/cache/ttl-cache.ts
-import { getUnixTime as getUnixTime2 } from "date-fns/getUnixTime";
-var TtlCache = class {
-  _cache = /* @__PURE__ */ new Map();
-  _ttl;
-  /**
-   * Create a new TTL cache with the given TTL.
-   *
-   * @param ttl Time-to-live duration in seconds. Items expire after this duration.
-   */
-  constructor(ttl) {
-    this._ttl = ttl;
+// src/ensindexer/config/labelset-utils.ts
+function buildLabelSetId(maybeLabelSetId) {
+  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
+}
+function buildLabelSetVersion(maybeLabelSetVersion) {
+  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
+}
+function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
+  if (labelSetVersion !== void 0 && labelSetId === void 0) {
+    throw new Error("When a labelSetVersion is defined, labelSetId must also be defined.");
   }
-  _cleanup() {
-    const now = getUnixTime2(/* @__PURE__ */ new Date());
-    for (const [key, entry] of this._cache.entries()) {
-      if (entry.expiresAt <= now) {
-        this._cache.delete(key);
-      }
-    }
+  return { labelSetId, labelSetVersion };
+}
+function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
+  if (clientSet.labelSetId === void 0) {
+    return;
   }
-  set(key, value) {
-    this._cleanup();
-    const expiresAt = addDuration(getUnixTime2(/* @__PURE__ */ new Date()), this._ttl);
-    this._cache.set(key, { value, expiresAt });
+  if (serverSet.labelSetId !== clientSet.labelSetId) {
+    throw new Error(
+      `Server label set ID "${serverSet.labelSetId}" does not match client's requested label set ID "${clientSet.labelSetId}".`
+    );
   }
-  get(key) {
-    this._cleanup();
-    const entry = this._cache.get(key);
-    if (!entry) {
-      return void 0;
-    }
-    if (entry.expiresAt <= getUnixTime2(/* @__PURE__ */ new Date())) {
-      this._cache.delete(key);
-      return void 0;
-    }
-    return entry.value;
+  if (clientSet.labelSetVersion !== void 0 && serverSet.highestLabelSetVersion < clientSet.labelSetVersion) {
+    throw new Error(
+      `Server highest label set version ${serverSet.highestLabelSetVersion} is less than client's requested version ${clientSet.labelSetVersion} for label set ID "${clientSet.labelSetId}".`
+    );
   }
-  clear() {
-    this._cache.clear();
+}
+
+// src/ensindexer/config/parsing.ts
+function parseNonNegativeInteger(maybeNumber) {
+  const trimmed = maybeNumber.trim();
+  if (!trimmed) {
+    throw new Error("Input cannot be empty");
   }
-  get size() {
-    this._cleanup();
-    return this._cache.size;
+  if (trimmed === "-0") {
+    throw new Error("Negative zero is not a valid non-negative integer");
   }
-  get capacity() {
-    return Number.MAX_SAFE_INTEGER;
+  const num = Number(maybeNumber);
+  if (Number.isNaN(num)) {
+    throw new Error(`"${maybeNumber}" is not a valid number`);
   }
-  has(key) {
-    this._cleanup();
-    const entry = this._cache.get(key);
-    if (!entry) {
-      return false;
-    }
-    if (entry.expiresAt <= getUnixTime2(/* @__PURE__ */ new Date())) {
-      this._cache.delete(key);
-      return false;
-    }
-    return true;
+  if (!Number.isFinite(num)) {
+    throw new Error(`"${maybeNumber}" is not a finite number`);
   }
-  delete(key) {
-    return this._cache.delete(key);
+  if (!Number.isInteger(num)) {
+    throw new Error(`"${maybeNumber}" is not an integer`);
   }
-};
-
-// src/shared/collections.ts
-var uniq = (arr) => [...new Set(arr)];
+  if (num < 0) {
+    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
+  }
+  return num;
+}
 
-// 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;
+// src/ensindexer/config/serialize.ts
+function serializeIndexedChainIds(indexedChainIds) {
+  return Array.from(indexedChainIds);
+}
+function serializeENSIndexerPublicConfig(config) {
+  const {
+    labelSet,
+    indexedChainIds,
+    databaseSchemaName,
+    isSubgraphCompatible: isSubgraphCompatible2,
+    namespace,
+    plugins,
+    versionInfo
+  } = config;
   return {
-    chainId: datasource.chain.id,
-    address
+    labelSet,
+    indexedChainIds: serializeIndexedChainIds(indexedChainIds),
+    databaseSchemaName,
+    isSubgraphCompatible: isSubgraphCompatible2,
+    namespace,
+    plugins,
+    versionInfo
   };
-};
-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/shared/interpretation/interpret-address.ts
-import { isAddressEqual as isAddressEqual2, zeroAddress } from "viem";
-var interpretAddress = (owner) => isAddressEqual2(zeroAddress, owner) ? null : owner;
-
-// src/shared/interpretation/interpret-record-values.ts
-import { isAddress as isAddress3, isAddressEqual as isAddressEqual3, zeroAddress as zeroAddress2 } from "viem";
-
-// src/shared/null-bytes.ts
-var hasNullByte = (value) => value.indexOf("\0") !== -1;
-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;
-  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 (isAddressEqual3(value, zeroAddress2)) return null;
-  return asLowerCaseAddress(value);
-}
-function interpretTextRecordKey(key) {
-  if (hasNullByte(key)) return null;
-  if (key === "") return null;
-  return key;
-}
-function interpretTextRecordValue(value) {
-  if (hasNullByte(value)) return null;
-  if (value === "") return null;
-  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 isHex3 } from "viem";
-import { labelhash } from "viem/ens";
+// src/ensindexer/indexing-status/deserialize.ts
+import { prettifyError as prettifyError4 } from "zod/v4";
 
-// src/shared/labelhash.ts
-import { keccak256 as keccak2562, stringToBytes } from "viem";
-var labelhashLiteralLabel = (label) => keccak2562(stringToBytes(label));
+// src/ensindexer/indexing-status/zod-schemas.ts
+import { z as z5 } from "zod/v4";
 
-// 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(".");
+// src/shared/deserialize.ts
+import { prettifyError as prettifyError3 } 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:
+${prettifyError3(parsed.error)}
+`);
+  }
+  return parsed.data;
 }
-function interpretedNameToInterpretedLabels(name) {
-  return name.split(".");
+function deserializeDatetime(maybeDatetime, valueLabel) {
+  const schema = makeDatetimeSchema(valueLabel);
+  const parsed = schema.safeParse(maybeDatetime);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize Datetime:
+${prettifyError3(parsed.error)}
+`);
+  }
+  return parsed.data;
 }
-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 (!isHex3(hash)) return null;
-  return hash;
+function deserializeUnixTimestamp(maybeTimestamp, valueLabel) {
+  const schema = makeUnixTimestampSchema(valueLabel);
+  const parsed = schema.safeParse(maybeTimestamp);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize Unix Timestamp:
+${prettifyError3(parsed.error)}
+`);
+  }
+  return parsed.data;
 }
-function isInterpetedLabel(label) {
-  if (label.startsWith("[")) {
-    const labelHash = encodedLabelToLabelhash(label);
-    if (labelHash === null) return false;
+function deserializeUrl(maybeUrl, valueLabel) {
+  const schema = makeUrlSchema(valueLabel);
+  const parsed = schema.safeParse(maybeUrl);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize URL:
+${prettifyError3(parsed.error)}
+`);
   }
-  return isNormalizedLabel(label);
+  return parsed.data;
 }
-function isInterpretedName(name) {
-  return name.split(".").every(isInterpetedLabel);
+function deserializeBlockNumber(maybeBlockNumber, valueLabel) {
+  const schema = makeBlockNumberSchema(valueLabel);
+  const parsed = schema.safeParse(maybeBlockNumber);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize BlockNumber:
+${prettifyError3(parsed.error)}
+`);
+  }
+  return parsed.data;
 }
-function interpretedNameToLabelHashPath(name) {
-  return interpretedNameToInterpretedLabels(name).map((label) => {
-    if (!isInterpetedLabel(label)) {
-      throw new Error(
-        `Invariant(interpretedNameToLabelHashPath): Expected InterpretedLabel, received '${label}'.`
-      );
-    }
-    const maybeLabelHash = encodedLabelToLabelhash(label);
-    if (maybeLabelHash !== null) return maybeLabelHash;
-    return labelhash(label);
-  }).toReversed();
+function deserializeBlockrange(maybeBlockrange, valueLabel) {
+  const schema = makeBlockrangeSchema(valueLabel);
+  const parsed = schema.safeParse(maybeBlockrange);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize Blockrange:
+${prettifyError3(parsed.error)}
+`);
+  }
+  return parsed.data;
 }
-
-// src/shared/numbers.ts
-function bigIntToNumber(n) {
-  if (n < Number.MIN_SAFE_INTEGER) {
-    throw new Error(
-      `The bigint '${n.toString()}' value is too low to be to converted into a number.'`
-    );
+function deserializeBlockRef(maybeBlockRef, valueLabel) {
+  const schema = makeBlockRefSchema(valueLabel);
+  const parsed = schema.safeParse(maybeBlockRef);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize BlockRef:
+${prettifyError3(parsed.error)}
+`);
   }
-  if (n > Number.MAX_SAFE_INTEGER) {
-    throw new Error(
-      `The bigint '${n.toString()}' value is too high to be to converted into a number.'`
-    );
+  return parsed.data;
+}
+function deserializeDuration(maybeDuration, valueLabel) {
+  const schema = makeDurationSchema(valueLabel);
+  const parsed = schema.safeParse(maybeDuration);
+  if (parsed.error) {
+    throw new RangeError(`Cannot deserialize Duration:
+${prettifyError3(parsed.error)}
+`);
   }
-  return Number(n);
+  return parsed.data;
 }
-
-// src/shared/root-registry.ts
-import { DatasourceNames } from "@ensnode/datasources";
-var getENSv1Registry = (namespace) => getDatasourceContract(namespace, DatasourceNames.ENSRoot, "ENSv1Registry");
-var isENSv1Registry = (namespace, contract) => accountIdEqual(getENSv1Registry(namespace), contract);
-var getENSv2RootRegistry = (namespace) => getDatasourceContract(namespace, DatasourceNames.ENSv2Root, "RootRegistry");
-var getENSv2RootRegistryId = (namespace) => makeRegistryId(getENSv2RootRegistry(namespace));
-var isENSv2RootRegistry = (namespace, contract) => accountIdEqual(getENSv2RootRegistry(namespace), contract);
-
-// src/shared/serialize.ts
-import { AccountId as CaipAccountId2, AssetId as CaipAssetId } from "caip";
-function serializeChainId(chainId) {
-  return chainId.toString();
+function parseAccountId(maybeAccountId, valueLabel) {
+  const schema = makeAccountIdStringSchema(valueLabel);
+  const parsed = schema.safeParse(maybeAccountId);
+  if (parsed.error) {
+    throw new RangeError(`Cannot deserialize AccountId:
+${prettifyError3(parsed.error)}
+`);
+  }
+  return parsed.data;
 }
-function serializeDatetime(datetime) {
-  return datetime.toISOString();
+function deserializePriceEth(maybePrice, valueLabel) {
+  const schema = makePriceEthSchema(valueLabel);
+  const parsed = schema.safeParse(maybePrice);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize PriceEth:
+${prettifyError3(parsed.error)}
+`);
+  }
+  return parsed.data;
 }
-function serializeUrl(url) {
-  return url.toString();
+function deserializePriceUsdc(maybePrice, valueLabel) {
+  const schema = makePriceUsdcSchema(valueLabel);
+  const parsed = schema.safeParse(maybePrice);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize PriceUsdc:
+${prettifyError3(parsed.error)}
+`);
+  }
+  return parsed.data;
 }
-function serializePrice(price) {
-  return {
-    currency: price.currency,
-    amount: price.amount.toString()
-  };
-}
-function serializePriceEth(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/shared/types.ts
-var AssetNamespaces = {
-  ERC721: "erc721",
-  ERC1155: "erc1155"
-};
-
-// src/shared/url.ts
-function isHttpProtocol(url) {
-  return ["http:", "https:"].includes(url.protocol);
-}
-function isWebSocketProtocol(url) {
-  return ["ws:", "wss:"].includes(url.protocol);
-}
-
-// src/ensindexer/config/is-subgraph-compatible.ts
-import { ENSNamespaceIds as ENSNamespaceIds2 } from "@ensnode/datasources";
-
-// src/ensindexer/config/types.ts
-var PluginName = /* @__PURE__ */ ((PluginName2) => {
-  PluginName2["Subgraph"] = "subgraph";
-  PluginName2["Basenames"] = "basenames";
-  PluginName2["Lineanames"] = "lineanames";
-  PluginName2["ThreeDNS"] = "threedns";
-  PluginName2["ProtocolAcceleration"] = "protocol-acceleration";
-  PluginName2["Registrars"] = "registrars";
-  PluginName2["TokenScope"] = "tokenscope";
-  PluginName2["ENSv2"] = "ensv2";
-  return PluginName2;
-})(PluginName || {});
-
-// src/ensindexer/config/is-subgraph-compatible.ts
-function isSubgraphCompatible(config) {
-  const onlySubgraphPluginActivated = config.plugins.length === 1 && config.plugins[0] === "subgraph" /* Subgraph */;
-  const isSubgraphLabelSet = config.labelSet.labelSetId === "subgraph" && config.labelSet.labelSetVersion === 0;
-  const isEnsTestEnvLabelSet = config.labelSet.labelSetId === "ens-test-env" && config.labelSet.labelSetVersion === 0;
-  const labelSetIsSubgraphCompatible = isSubgraphLabelSet || config.namespace === ENSNamespaceIds2.EnsTestEnv && isEnsTestEnvLabelSet;
-  return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
-}
-
-// src/ensindexer/config/validations.ts
-function invariant_ensDbVersionIsSameAsEnsIndexerVersion(ctx) {
-  const versionInfo = ctx.value;
-  if (versionInfo.ensDb !== versionInfo.ensIndexer) {
-    ctx.issues.push({
-      code: "custom",
-      input: versionInfo,
-      message: "`ensDb` version must be same as `ensIndexer` version"
-    });
-  }
-}
-
-// src/ensindexer/config/zod-schemas.ts
-var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => z2.array(makeChainIdSchema(valueLabel), {
-  error: `${valueLabel} must be an array.`
-}).min(1, { error: `${valueLabel} list must include at least one element.` }).transform((v) => new Set(v));
-var makePluginsListSchema = (valueLabel = "Plugins") => z2.array(z2.string(), {
-  error: `${valueLabel} must be a list of strings.`
-}).min(1, {
-  error: `${valueLabel} must be a list of strings with at least one string value`
-}).refine((arr) => arr.length === uniq(arr).length, {
-  error: `${valueLabel} cannot contain duplicate values.`
-});
-var makeDatabaseSchemaNameSchema = (valueLabel = "Database schema name") => z2.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
-  error: `${valueLabel} is required and must be a non-empty string.`
-});
-var makeLabelSetIdSchema = (valueLabel) => {
-  return z2.string({ error: `${valueLabel} must be a string` }).min(1, { error: `${valueLabel} must be 1-50 characters long` }).max(50, { error: `${valueLabel} must be 1-50 characters long` }).regex(/^[a-z-]+$/, {
-    error: `${valueLabel} can only contain lowercase letters (a-z) and hyphens (-)`
-  });
-};
-var makeLabelSetVersionSchema = (valueLabel) => {
-  return z2.coerce.number({ error: `${valueLabel} must be an integer.` }).pipe(makeNonNegativeIntegerSchema(valueLabel));
-};
-var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
-  let valueLabelLabelSetId = valueLabel;
-  let valueLabelLabelSetVersion = valueLabel;
-  if (valueLabel === "LABEL_SET") {
-    valueLabelLabelSetId = "LABEL_SET_ID";
-    valueLabelLabelSetVersion = "LABEL_SET_VERSION";
-  } else {
-    valueLabelLabelSetId = `${valueLabel}.labelSetId`;
-    valueLabelLabelSetVersion = `${valueLabel}.labelSetVersion`;
-  }
-  return z2.object({
-    labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
-    labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
-  });
-};
-var makeNonEmptyStringSchema = (valueLabel = "Value") => z2.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
-var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => z2.strictObject(
-  {
-    nodejs: makeNonEmptyStringSchema(),
-    ponder: makeNonEmptyStringSchema(),
-    ensDb: makeNonEmptyStringSchema(),
-    ensIndexer: makeNonEmptyStringSchema(),
-    ensNormalize: makeNonEmptyStringSchema(),
-    ensRainbow: makeNonEmptyStringSchema(),
-    ensRainbowSchema: makePositiveIntegerSchema()
-  },
-  {
-    error: `${valueLabel} must be a valid ENSIndexerVersionInfo object.`
-  }
-).check(invariant_ensDbVersionIsSameAsEnsIndexerVersion);
-function invariant_isSubgraphCompatibleRequirements(ctx) {
-  const { value: config } = ctx;
-  if (config.isSubgraphCompatible && !isSubgraphCompatible(config)) {
-    ctx.issues.push({
-      code: "custom",
-      input: config,
-      message: `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active and labelSet must be {labelSetId: "subgraph", labelSetVersion: 0}`
-    });
-  }
-}
-var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => z2.object({
-  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
-  indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
-  isSubgraphCompatible: z2.boolean({ error: `${valueLabel}.isSubgraphCompatible` }),
-  namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
-  plugins: makePluginsListSchema(`${valueLabel}.plugins`),
-  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
-  versionInfo: makeENSIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
-}).check(invariant_isSubgraphCompatibleRequirements);
-
-// src/shared/config/thegraph.ts
-import { z as z3 } from "zod/v4";
-var TheGraphCannotFallbackReasonSchema = z3.enum({
-  NotSubgraphCompatible: "not-subgraph-compatible",
-  NoApiKey: "no-api-key",
-  NoSubgraphUrl: "no-subgraph-url"
-});
-var TheGraphFallbackSchema = z3.discriminatedUnion("canFallback", [
-  z3.strictObject({
-    canFallback: z3.literal(true),
-    url: z3.string()
-  }),
-  z3.strictObject({
-    canFallback: z3.literal(false),
-    reason: TheGraphCannotFallbackReasonSchema
-  })
-]);
-
-// src/ensapi/config/zod-schemas.ts
-function makeENSApiPublicConfigSchema(valueLabel) {
-  const label = valueLabel ?? "ENSApiPublicConfig";
-  return z4.strictObject({
-    version: z4.string().min(1, `${label}.version must be a non-empty string`),
-    theGraphFallback: TheGraphFallbackSchema,
-    ensIndexerPublicConfig: makeENSIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
-  });
-}
-
-// src/ensapi/config/deserialize.ts
-function deserializeENSApiPublicConfig(maybeConfig, valueLabel) {
-  const schema = makeENSApiPublicConfigSchema(valueLabel);
-  try {
-    return schema.parse(maybeConfig);
-  } catch (error) {
-    if (error instanceof ZodError) {
-      throw new Error(`Cannot deserialize ENSApiPublicConfig:
-${prettifyError2(error)}
-`);
-    }
-    throw error;
-  }
-}
-
-// src/ensindexer/config/deserialize.ts
-import { prettifyError as prettifyError3 } from "zod/v4";
-function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
-  const schema = makeENSIndexerPublicConfigSchema(valueLabel);
-  const parsed = schema.safeParse(maybeConfig);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize ENSIndexerPublicConfig:
-${prettifyError3(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
-
-// 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");
-  }
+function deserializePriceDai(maybePrice, valueLabel) {
+  const schema = makePriceDaiSchema(valueLabel);
+  const parsed = schema.safeParse(maybePrice);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize PriceDai:
+${prettifyError3(parsed.error)}
+`);
+  }
+  return parsed.data;
 }
 
-// src/ensindexer/config/labelset-utils.ts
-function buildLabelSetId(maybeLabelSetId) {
-  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
-}
-function buildLabelSetVersion(maybeLabelSetVersion) {
-  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
-}
-function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
-  if (labelSetVersion !== void 0 && labelSetId === void 0) {
-    throw new Error("When a labelSetVersion is defined, labelSetId must also be defined.");
-  }
-  return { labelSetId, labelSetVersion };
-}
-function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
-  if (clientSet.labelSetId === void 0) {
-    return;
-  }
-  if (serverSet.labelSetId !== clientSet.labelSetId) {
-    throw new Error(
-      `Server label set ID "${serverSet.labelSetId}" does not match client's requested label set ID "${clientSet.labelSetId}".`
-    );
-  }
-  if (clientSet.labelSetVersion !== void 0 && serverSet.highestLabelSetVersion < clientSet.labelSetVersion) {
-    throw new Error(
-      `Server highest label set version ${serverSet.highestLabelSetVersion} is less than client's requested version ${clientSet.labelSetVersion} for label set ID "${clientSet.labelSetId}".`
-    );
-  }
-}
-
-// src/ensindexer/config/parsing.ts
-function parseNonNegativeInteger(maybeNumber) {
-  const trimmed = maybeNumber.trim();
-  if (!trimmed) {
-    throw new Error("Input cannot be empty");
-  }
-  if (trimmed === "-0") {
-    throw new Error("Negative zero is not a valid non-negative integer");
-  }
-  const num = Number(maybeNumber);
-  if (Number.isNaN(num)) {
-    throw new Error(`"${maybeNumber}" is not a valid number`);
-  }
-  if (!Number.isFinite(num)) {
-    throw new Error(`"${maybeNumber}" is not a finite number`);
-  }
-  if (!Number.isInteger(num)) {
-    throw new Error(`"${maybeNumber}" is not an integer`);
-  }
-  if (num < 0) {
-    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
-  }
-  return num;
-}
-
-// src/ensindexer/config/serialize.ts
-function serializeIndexedChainIds(indexedChainIds) {
-  return Array.from(indexedChainIds);
-}
-function serializeENSIndexerPublicConfig(config) {
-  const {
-    labelSet,
-    indexedChainIds,
-    databaseSchemaName,
-    isSubgraphCompatible: isSubgraphCompatible2,
-    namespace,
-    plugins,
-    versionInfo
-  } = config;
-  return {
-    labelSet,
-    indexedChainIds: serializeIndexedChainIds(indexedChainIds),
-    databaseSchemaName,
-    isSubgraphCompatible: isSubgraphCompatible2,
-    namespace,
-    plugins,
-    versionInfo
-  };
-}
-
-// src/ensindexer/indexing-status/deserialize.ts
-import { prettifyError as prettifyError4 } from "zod/v4";
-
-// src/ensindexer/indexing-status/zod-schemas.ts
-import { z as z5 } from "zod/v4";
-
 // src/ensindexer/indexing-status/types.ts
 var ChainIndexingConfigTypeIds = {
   /**
@@ -1792,6 +1515,50 @@ function createRealtimeIndexingStatusProjection(snapshot, now) {
   };
 }
 
+// src/shared/serialize.ts
+import { AccountId as CaipAccountId2, AssetId as CaipAssetId } from "caip";
+function serializeChainId(chainId) {
+  return chainId.toString();
+}
+function serializeDatetime(datetime) {
+  return datetime.toISOString();
+}
+function serializeUrl(url) {
+  return url.toString();
+}
+function serializePrice(price) {
+  return {
+    currency: price.currency,
+    amount: price.amount.toString()
+  };
+}
+function serializePriceEth(price) {
+  return serializePrice(price);
+}
+function serializePriceUsdc(price) {
+  return serializePrice(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/ensindexer/indexing-status/serialize.ts
 function serializeCrossChainIndexingStatusSnapshotOmnichain({
   strategy,
@@ -1933,17 +1700,59 @@ import { namehash as namehash2 } from "viem";
 import { z as z9 } from "zod/v4";
 
 // src/tokenscope/assets.ts
-import { isAddressEqual as isAddressEqual5, zeroAddress as zeroAddress5 } from "viem";
+import { isAddressEqual as isAddressEqual3, zeroAddress as zeroAddress3 } from "viem";
 import { prettifyError as prettifyError6 } from "zod/v4";
 
 // src/tokenscope/zod-schemas.ts
 import { AssetId as CaipAssetId2 } from "caip";
-import { zeroAddress as zeroAddress4 } from "viem";
+import { zeroAddress as zeroAddress2 } from "viem";
 import { z as z7 } from "zod/v4";
 
+// src/shared/types.ts
+var AssetNamespaces = {
+  ERC721: "erc721",
+  ERC1155: "erc1155"
+};
+
+// src/tokenscope/name-token.ts
+import { isAddressEqual as isAddressEqual2, zeroAddress } 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/name-token.ts
-import { isAddressEqual as isAddressEqual4, zeroAddress as zeroAddress3 } from "viem";
-import { DatasourceNames as DatasourceNames2 } from "@ensnode/datasources";
 var NameTokenOwnershipTypes = {
   /**
    * Name Token is owned by NameWrapper account.
@@ -1974,12 +1783,12 @@ function serializeNameToken(nameToken) {
 function getNameWrapperAccounts(namespaceId) {
   const ethnamesNameWrapperAccount = getDatasourceContract(
     namespaceId,
-    DatasourceNames2.ENSRoot,
+    DatasourceNames.ENSRoot,
     "NameWrapper"
   );
   const lineanamesNameWrapperAccount = maybeGetDatasourceContract(
     namespaceId,
-    DatasourceNames2.Lineanames,
+    DatasourceNames.Lineanames,
     "NameWrapper"
   );
   const nameWrapperAccounts = [
@@ -2002,7 +1811,7 @@ function getNameTokenOwnership(namespaceId, name, owner) {
       owner
     };
   }
-  if (isAddressEqual4(owner.address, zeroAddress3)) {
+  if (isAddressEqual2(owner.address, zeroAddress)) {
     return {
       ownershipType: NameTokenOwnershipTypes.Burned,
       owner
@@ -2057,7 +1866,7 @@ var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => z7.prep
 }, makeAssetIdSchema(valueLabel));
 function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
   const ownership = ctx.value;
-  if (ctx.value.owner.address === zeroAddress4) {
+  if (ctx.value.owner.address === zeroAddress2) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2083,7 +1892,7 @@ var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Un
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
 function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
   const ownership = ctx.value;
-  if (ctx.value.owner.address !== zeroAddress4) {
+  if (ctx.value.owner.address !== zeroAddress2) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2261,11 +2070,11 @@ var NFTTransferTypes = {
 };
 var getNFTTransferType = (from, to, allowMintedRemint, metadata, currentlyIndexedOwner) => {
   const isIndexed = currentlyIndexedOwner !== void 0;
-  const isIndexedAsMinted = isIndexed && !isAddressEqual5(currentlyIndexedOwner, zeroAddress5);
-  const isMint = isAddressEqual5(from, zeroAddress5);
-  const isBurn = isAddressEqual5(to, zeroAddress5);
-  const isSelfTransfer = isAddressEqual5(from, to);
-  if (isIndexed && !isAddressEqual5(currentlyIndexedOwner, from)) {
+  const isIndexedAsMinted = isIndexed && !isAddressEqual3(currentlyIndexedOwner, zeroAddress3);
+  const isMint = isAddressEqual3(from, zeroAddress3);
+  const isBurn = isAddressEqual3(to, zeroAddress3);
+  const isSelfTransfer = isAddressEqual3(from, to);
+  if (isIndexed && !isAddressEqual3(currentlyIndexedOwner, from)) {
     if (isMint && allowMintedRemint) {
     } else {
       throw new Error(
@@ -2557,7 +2366,7 @@ import { z as z12 } from "zod/v4";
 import { z as z10 } from "zod/v4";
 
 // src/registrars/encoded-referrer.ts
-import { getAddress, pad, size as size2, slice, zeroAddress as zeroAddress6 } from "viem";
+import { getAddress, 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", {
@@ -2580,7 +2389,7 @@ function decodeEncodedReferrer(encodedReferrer) {
   }
   const padding = slice(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
   if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
-    return zeroAddress6;
+    return zeroAddress4;
   }
   const decodedReferrer = slice(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
   try {
@@ -2977,14 +2786,14 @@ var registrarActionsPrerequisites = Object.freeze({
 
 // src/registrars/basenames-subregistry.ts
 import {
-  DatasourceNames as DatasourceNames3,
+  DatasourceNames as DatasourceNames2,
   ENSNamespaceIds as ENSNamespaceIds3,
   maybeGetDatasource as maybeGetDatasource2
 } from "@ensnode/datasources";
 function getBasenamesSubregistryId(namespace) {
-  const datasource = maybeGetDatasource2(namespace, DatasourceNames3.Basenames);
+  const datasource = maybeGetDatasource2(namespace, DatasourceNames2.Basenames);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames3.Basenames}`);
+    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames2.Basenames}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -3011,14 +2820,14 @@ function getBasenamesSubregistryManagedName(namespaceId) {
 
 // src/registrars/ethnames-subregistry.ts
 import {
-  DatasourceNames as DatasourceNames4,
+  DatasourceNames as DatasourceNames3,
   ENSNamespaceIds as ENSNamespaceIds4,
   maybeGetDatasource as maybeGetDatasource3
 } from "@ensnode/datasources";
 function getEthnamesSubregistryId(namespace) {
-  const datasource = maybeGetDatasource3(namespace, DatasourceNames4.ENSRoot);
+  const datasource = maybeGetDatasource3(namespace, DatasourceNames3.ENSRoot);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames4.ENSRoot}`);
+    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames3.ENSRoot}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -3041,14 +2850,14 @@ function getEthnamesSubregistryManagedName(namespaceId) {
 
 // src/registrars/lineanames-subregistry.ts
 import {
-  DatasourceNames as DatasourceNames5,
+  DatasourceNames as DatasourceNames4,
   ENSNamespaceIds as ENSNamespaceIds5,
   maybeGetDatasource as maybeGetDatasource4
 } from "@ensnode/datasources";
 function getLineanamesSubregistryId(namespace) {
-  const datasource = maybeGetDatasource4(namespace, DatasourceNames5.Lineanames);
+  const datasource = maybeGetDatasource4(namespace, DatasourceNames4.Lineanames);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames5.Lineanames}`);
+    throw new Error(`Datasource not found for ${namespace} ${DatasourceNames4.Lineanames}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -3591,145 +3400,444 @@ var ENSNodeClient = class _ENSNodeClient {
       try {
         errorResponse = deserializeErrorResponse(responseData);
       } catch {
-        console.log("Registrar Actions API: handling a known server error.");
+        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 {
+   *   ENSNodeClient,
+   * } from "@ensnode/ensnode-sdk";
+   * import { namehash } from "viem/ens";
+   *
+   * const client: ENSNodeClient;
+   *
+   * // get latest name token records from the indexed subregistry based on the requested name
+   * const response = await client.nameTokens({
+   *   name: "vitalik.eth"
+   * });
+   *
+   * const response = await client.nameTokens({
+   *   domainId: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835" // namehash('vitalik.eth')
+   * })
+   * ```
+   */
+  async nameTokens(request) {
+    const url = new URL(`/api/name-tokens`, this.options.url);
+    if (request.name !== void 0) {
+      url.searchParams.set("name", request.name);
+    } else 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 Registrar Actions Failed: ${errorResponse.message}`);
+        throw new Error(`Fetching ENSNode Name Tokens Failed: ${errorResponse.message}`);
+      }
+    }
+    return deserializedNameTokensResponse(responseData);
+  }
+};
+
+// 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 makeLatestRegistrationId = (domainId) => `${domainId}/latest`;
+var makeRegistrationId = (domainId, index = 0) => `${domainId}/${index}`;
+var makeLatestRenewalId = (domainId, registrationIndex) => `${makeRegistrationId(domainId, registrationIndex)}/latest`;
+var makeRenewalId = (domainId, registrationIndex, index = 0) => `${makeRegistrationId(domainId, registrationIndex)}/${index}`;
+
+// src/identity/identity.ts
+import { getENSRootChainId as getENSRootChainId2 } from "@ensnode/datasources";
+
+// src/identity/types.ts
+var ResolutionStatusIds = {
+  /**
+   * Represents that the `Identity` is not resolved yet.
+   */
+  Unresolved: "unresolved",
+  /**
+   * Represents that resolution of the `Identity` resulted in a named identity.
+   */
+  Named: "named",
+  /**
+   * Represents that resolution of the `Identity` resulted in an unnamed identity.
+   */
+  Unnamed: "unnamed",
+  /**
+   * Represents that attempted resolution of the `Identity` resulted in an error
+   * and therefore it is unknown if the `Identity` resolves to a named or unnamed identity.
+   */
+  Unknown: "unknown"
+};
+
+// src/identity/identity.ts
+function buildUnresolvedIdentity(address, namespaceId, chainId) {
+  return {
+    resolutionStatus: ResolutionStatusIds.Unresolved,
+    chainId: chainId ?? getENSRootChainId2(namespaceId),
+    address
+  };
+}
+function isResolvedIdentity(identity) {
+  return identity.resolutionStatus !== ResolutionStatusIds.Unresolved;
+}
+
+// src/resolution/ensip19-chainid.ts
+import { mainnet } from "viem/chains";
+import { getENSRootChainId as getENSRootChainId3 } from "@ensnode/datasources";
+var getResolvePrimaryNameChainIdParam = (chainId, namespaceId) => {
+  const ensRootChainId = getENSRootChainId3(namespaceId);
+  return chainId === ensRootChainId ? mainnet.id : chainId;
+};
+var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
+  return chainId === DEFAULT_EVM_CHAIN_ID ? getENSRootChainId3(namespaceId) : chainId;
+};
+
+// src/resolution/resolver-records-selection.ts
+var isSelectionEmpty = (selection) => !selection.name && !selection.addresses?.length && !selection.texts?.length;
+
+// src/shared/cache/lru-cache.ts
+var LruCache = class {
+  _cache = /* @__PURE__ */ new Map();
+  _capacity;
+  /**
+   * Create a new LRU cache with the given capacity.
+   *
+   * @param capacity The maximum number of items in the cache. If set to 0, the cache is effectively disabled.
+   * @throws Error if capacity is not a non-negative integer.
+   */
+  constructor(capacity) {
+    if (!Number.isInteger(capacity)) {
+      throw new Error(
+        `LruCache requires capacity to be an integer but a capacity of ${capacity} was requested.`
+      );
+    }
+    if (capacity < 0) {
+      throw new Error(
+        `LruCache requires a non-negative capacity but a capacity of ${capacity} was requested.`
+      );
+    }
+    this._capacity = capacity;
+  }
+  set(key, value) {
+    this._cache.set(key, value);
+    if (this._cache.size > this._capacity) {
+      const oldestKey = this._cache.keys().next().value;
+      this._cache.delete(oldestKey);
+    }
+  }
+  get(key) {
+    const value = this._cache.get(key);
+    if (value) {
+      this._cache.delete(key);
+      this._cache.set(key, value);
+    }
+    return value;
+  }
+  clear() {
+    this._cache.clear();
+  }
+  get size() {
+    return this._cache.size;
+  }
+  get capacity() {
+    return this._capacity;
+  }
+};
+
+// src/shared/cache/swr-cache.ts
+import { secondsToMilliseconds } from "date-fns";
+import { getUnixTime } from "date-fns/getUnixTime";
+
+// src/shared/datetime.ts
+function durationBetween(start, end) {
+  return deserializeDuration(end - start, "Duration");
+}
+function addDuration(timestamp, duration) {
+  return deserializeUnixTimestamp(timestamp + duration, "UnixTimestamp");
+}
+
+// src/shared/cache/swr-cache.ts
+var SWRCache = class {
+  constructor(options) {
+    this.options = options;
+    if (options.proactiveRevalidationInterval) {
+      this.backgroundInterval = setInterval(
+        () => this.revalidate(),
+        secondsToMilliseconds(options.proactiveRevalidationInterval)
+      );
+    }
+    if (options.proactivelyInitialize) this.revalidate();
+  }
+  cache = null;
+  inProgressRevalidate = null;
+  backgroundInterval = null;
+  async revalidate() {
+    if (!this.inProgressRevalidate) {
+      this.inProgressRevalidate = this.options.fn().then((result) => {
+        this.cache = {
+          result,
+          updatedAt: getUnixTime(/* @__PURE__ */ new Date())
+        };
+      }).catch((error) => {
+        if (!this.cache) {
+          this.cache = {
+            // ensure thrown value is always an Error instance
+            result: error instanceof Error ? error : new Error(String(error)),
+            updatedAt: getUnixTime(/* @__PURE__ */ new Date())
+          };
+        }
+      }).finally(() => {
+        this.inProgressRevalidate = null;
+      });
+    }
+    return this.inProgressRevalidate;
+  }
+  /**
+   * Read the most recently cached result from the `SWRCache`.
+   *
+   * @returns a `ValueType` that was most recently successfully returned by `fn` or `Error` if `fn`
+   * has never successfully returned.
+   */
+  async read() {
+    if (!this.cache) await this.revalidate();
+    if (!this.cache) throw new Error("never");
+    if (durationBetween(this.cache.updatedAt, getUnixTime(/* @__PURE__ */ new Date())) > this.options.ttl) {
+      this.revalidate();
+    }
+    return this.cache.result;
+  }
+  /**
+   * Destroys the background revalidation interval, if exists.
+   */
+  destroy() {
+    if (this.backgroundInterval) {
+      clearInterval(this.backgroundInterval);
+      this.backgroundInterval = null;
+    }
+  }
+};
+
+// src/shared/cache/ttl-cache.ts
+import { getUnixTime as getUnixTime2 } from "date-fns/getUnixTime";
+var TtlCache = class {
+  _cache = /* @__PURE__ */ new Map();
+  _ttl;
+  /**
+   * Create a new TTL cache with the given TTL.
+   *
+   * @param ttl Time-to-live duration in seconds. Items expire after this duration.
+   */
+  constructor(ttl) {
+    this._ttl = ttl;
+  }
+  _cleanup() {
+    const now = getUnixTime2(/* @__PURE__ */ new Date());
+    for (const [key, entry] of this._cache.entries()) {
+      if (entry.expiresAt <= now) {
+        this._cache.delete(key);
       }
     }
-    return deserializeRegistrarActionsResponse(responseData);
   }
-  /**
-   * Fetch Name Tokens for requested name.
-   *
-   * @param request.name - Name for which Name Tokens will be fetched.
-   * @returns {NameTokensResponse}
-   *
-   * @throws if the ENSNode request fails
-   * @throws if the ENSNode API returns an error response
-   * @throws if the ENSNode response breaks required invariants
-   *
-   * @example
-   * ```ts
-   * import {
-   *   ENSNodeClient,
-   * } from "@ensnode/ensnode-sdk";
-   * import { namehash } from "viem/ens";
-   *
-   * const client: ENSNodeClient;
-   *
-   * // get latest name token records from the indexed subregistry based on the requested name
-   * const response = await client.nameTokens({
-   *   name: "vitalik.eth"
-   * });
-   *
-   * const response = await client.nameTokens({
-   *   domainId: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835" // namehash('vitalik.eth')
-   * })
-   * ```
-   */
-  async nameTokens(request) {
-    const url = new URL(`/api/name-tokens`, this.options.url);
-    if (request.name !== void 0) {
-      url.searchParams.set("name", request.name);
-    } else if (request.domainId !== void 0) {
-      url.searchParams.set("domainId", request.domainId);
+  set(key, value) {
+    this._cleanup();
+    const expiresAt = addDuration(getUnixTime2(/* @__PURE__ */ new Date()), this._ttl);
+    this._cache.set(key, { value, expiresAt });
+  }
+  get(key) {
+    this._cleanup();
+    const entry = this._cache.get(key);
+    if (!entry) {
+      return void 0;
     }
-    const response = await fetch(url);
-    let responseData;
-    try {
-      responseData = await response.json();
-    } catch {
-      throw new Error("Malformed response data: invalid JSON");
+    if (entry.expiresAt <= getUnixTime2(/* @__PURE__ */ new Date())) {
+      this._cache.delete(key);
+      return void 0;
     }
-    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 entry.value;
+  }
+  clear() {
+    this._cache.clear();
+  }
+  get size() {
+    this._cleanup();
+    return this._cache.size;
+  }
+  get capacity() {
+    return Number.MAX_SAFE_INTEGER;
+  }
+  has(key) {
+    this._cleanup();
+    const entry = this._cache.get(key);
+    if (!entry) {
+      return false;
     }
-    return deserializedNameTokensResponse(responseData);
+    if (entry.expiresAt <= getUnixTime2(/* @__PURE__ */ new Date())) {
+      this._cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  delete(key) {
+    return this._cache.delete(key);
   }
 };
 
-// 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 makeLatestRegistrationId = (domainId) => `${domainId}/latest`;
-var makeRegistrationId = (domainId, index = 0) => `${domainId}/${index}`;
-var makeLatestRenewalId = (domainId, registrationIndex) => `${makeRegistrationId(domainId, registrationIndex)}/latest`;
-var makeRenewalId = (domainId, registrationIndex, index = 0) => `${makeRegistrationId(domainId, registrationIndex)}/${index}`;
+// src/shared/interpretation/interpret-address.ts
+import { isAddressEqual as isAddressEqual4, zeroAddress as zeroAddress5 } from "viem";
+var interpretAddress = (owner) => isAddressEqual4(zeroAddress5, owner) ? null : owner;
 
-// src/identity/identity.ts
-import { getENSRootChainId as getENSRootChainId2 } from "@ensnode/datasources";
+// src/shared/interpretation/interpret-record-values.ts
+import { isAddress as isAddress3, isAddressEqual as isAddressEqual5, zeroAddress as zeroAddress6 } from "viem";
 
-// src/identity/types.ts
-var ResolutionStatusIds = {
-  /**
-   * Represents that the `Identity` is not resolved yet.
-   */
-  Unresolved: "unresolved",
-  /**
-   * Represents that resolution of the `Identity` resulted in a named identity.
-   */
-  Named: "named",
-  /**
-   * Represents that resolution of the `Identity` resulted in an unnamed identity.
-   */
-  Unnamed: "unnamed",
-  /**
-   * Represents that attempted resolution of the `Identity` resulted in an error
-   * and therefore it is unknown if the `Identity` resolves to a named or unnamed identity.
-   */
-  Unknown: "unknown"
-};
+// src/shared/null-bytes.ts
+var hasNullByte = (value) => value.indexOf("\0") !== -1;
+var stripNullBytes = (value) => value.replaceAll("\0", "");
 
-// src/identity/identity.ts
-function buildUnresolvedIdentity(address, namespaceId, chainId) {
-  return {
-    resolutionStatus: ResolutionStatusIds.Unresolved,
-    chainId: chainId ?? getENSRootChainId2(namespaceId),
-    address
-  };
+// src/shared/interpretation/interpret-record-values.ts
+function interpretNameRecordValue(value) {
+  if (value === "") return null;
+  if (!isNormalizedName(value)) return null;
+  return value;
 }
-function isResolvedIdentity(identity) {
-  return identity.resolutionStatus !== ResolutionStatusIds.Unresolved;
+function interpretAddressRecordValue(value) {
+  if (hasNullByte(value)) return null;
+  if (value === "") return null;
+  if (value === "0x") return null;
+  if (!isAddress3(value)) return value;
+  if (isAddressEqual5(value, zeroAddress6)) return null;
+  return asLowerCaseAddress(value);
+}
+function interpretTextRecordKey(key) {
+  if (hasNullByte(key)) return null;
+  if (key === "") return null;
+  return key;
+}
+function interpretTextRecordValue(value) {
+  if (hasNullByte(value)) return null;
+  if (value === "") return null;
+  return value;
 }
 
-// src/resolution/ensip19-chainid.ts
-import { mainnet } from "viem/chains";
-import { getENSRootChainId as getENSRootChainId3 } from "@ensnode/datasources";
-var getResolvePrimaryNameChainIdParam = (chainId, namespaceId) => {
-  const ensRootChainId = getENSRootChainId3(namespaceId);
-  return chainId === ensRootChainId ? mainnet.id : chainId;
-};
-var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
-  return chainId === DEFAULT_EVM_CHAIN_ID ? getENSRootChainId3(namespaceId) : chainId;
-};
+// src/shared/interpretation/interpret-tokenid.ts
+var interpretTokenIdAsLabelHash = (tokenId) => uint256ToHex32(tokenId);
+var interpretTokenIdAsNode = (tokenId) => uint256ToHex32(tokenId);
 
-// src/resolution/resolver-records-selection.ts
-var isSelectionEmpty = (selection) => !selection.name && !selection.addresses?.length && !selection.texts?.length;
+// src/shared/interpretation/interpreted-names-and-labels.ts
+import { isHex as isHex3 } 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 (!isHex3(hash)) return null;
+  return hash;
+}
+function isInterpetedLabel(label) {
+  if (label.startsWith("[")) {
+    const labelHash = encodedLabelToLabelhash(label);
+    if (labelHash === null) return false;
+  }
+  return isNormalizedLabel(label);
+}
+function isInterpretedName(name) {
+  return name.split(".").every(isInterpetedLabel);
+}
+function interpretedNameToLabelHashPath(name) {
+  return interpretedNameToInterpretedLabels(name).map((label) => {
+    if (!isInterpetedLabel(label)) {
+      throw new Error(
+        `Invariant(interpretedNameToLabelHashPath): Expected InterpretedLabel, received '${label}'.`
+      );
+    }
+    const maybeLabelHash = encodedLabelToLabelhash(label);
+    if (maybeLabelHash !== null) return maybeLabelHash;
+    return labelhash(label);
+  }).toReversed();
+}
+
+// src/shared/root-registry.ts
+import { DatasourceNames as DatasourceNames5 } from "@ensnode/datasources";
+var getENSv1Registry = (namespace) => getDatasourceContract(namespace, DatasourceNames5.ENSRoot, "ENSv1Registry");
+var isENSv1Registry = (namespace, contract) => accountIdEqual(getENSv1Registry(namespace), contract);
+var getENSv2RootRegistry = (namespace) => getDatasourceContract(namespace, DatasourceNames5.ENSv2Root, "RootRegistry");
+var getENSv2RootRegistryId = (namespace) => makeRegistryId(getENSv2RootRegistry(namespace));
+var isENSv2RootRegistry = (namespace, contract) => accountIdEqual(getENSv2RootRegistry(namespace), contract);
+
+// src/shared/url.ts
+function isHttpProtocol(url) {
+  return ["http:", "https:"].includes(url.protocol);
+}
+function isWebSocketProtocol(url) {
+  return ["ws:", "wss:"].includes(url.protocol);
+}
 
 // src/tracing/ens-protocol-tracing.ts
 var PROTOCOL_ATTRIBUTE_PREFIX = "ens";
@@ -3854,6 +3962,9 @@ export {
   deserializeErrorResponse,
   deserializeIndexingStatusResponse,
   deserializeOmnichainIndexingStatusSnapshot,
+  deserializePriceDai,
+  deserializePriceEth,
+  deserializePriceUsdc,
   deserializeRealtimeIndexingStatusProjection,
   deserializeRegistrarActionsResponse,
   deserializeUnixTimestamp,
@@ -3947,14 +4058,19 @@ export {
   nameTokensPrerequisites,
   parseAccountId,
   parseAssetId,
+  parseDai,
+  parseEth,
   parseNonNegativeInteger,
   parseReverseName,
+  parseUsdc,
   priceDai,
   priceEth,
   priceUsdc,
   registrarActionsFilter,
   registrarActionsPrerequisites,
   reverseName,
+  scaleBigintByNumber,
+  scalePrice,
   serializeAssetId,
   serializeChainId,
   serializeChainIndexingSnapshots,
@@ -3971,7 +4087,9 @@ export {
   serializeNamedRegistrarAction,
   serializeOmnichainIndexingStatusSnapshot,
   serializePrice,
+  serializePriceDai,
   serializePriceEth,
+  serializePriceUsdc,
   serializeRealtimeIndexingStatusProjection,
   serializeRegisteredNameTokens,
   serializeRegistrarAction,