@ensnode/ensnode-sdk 0.0.0-next-20260130072518 → 0.0.0-next-20260131065208

package/dist/index.cjs

@@ -113,6 +113,9 @@ __export(index_exports, {
   deserializeErrorResponse: () => deserializeErrorResponse,
   deserializeIndexingStatusResponse: () => deserializeIndexingStatusResponse,
   deserializeOmnichainIndexingStatusSnapshot: () => deserializeOmnichainIndexingStatusSnapshot,
+  deserializePriceDai: () => deserializePriceDai,
+  deserializePriceEth: () => deserializePriceEth,
+  deserializePriceUsdc: () => deserializePriceUsdc,
   deserializeRealtimeIndexingStatusProjection: () => deserializeRealtimeIndexingStatusProjection,
   deserializeRegistrarActionsResponse: () => deserializeRegistrarActionsResponse,
   deserializeUnixTimestamp: () => deserializeUnixTimestamp,
@@ -206,14 +209,19 @@ __export(index_exports, {
   nameTokensPrerequisites: () => nameTokensPrerequisites,
   parseAccountId: () => parseAccountId,
   parseAssetId: () => parseAssetId,
+  parseDai: () => parseDai,
+  parseEth: () => parseEth,
   parseNonNegativeInteger: () => parseNonNegativeInteger,
   parseReverseName: () => parseReverseName,
+  parseUsdc: () => parseUsdc,
   priceDai: () => priceDai,
   priceEth: () => priceEth,
   priceUsdc: () => priceUsdc,
   registrarActionsFilter: () => registrarActionsFilter,
   registrarActionsPrerequisites: () => registrarActionsPrerequisites,
   reverseName: () => reverseName,
+  scaleBigintByNumber: () => scaleBigintByNumber,
+  scalePrice: () => scalePrice,
   serializeAssetId: () => serializeAssetId,
   serializeChainId: () => serializeChainId,
   serializeChainIndexingSnapshots: () => serializeChainIndexingSnapshots,
@@ -230,7 +238,9 @@ __export(index_exports, {
   serializeNamedRegistrarAction: () => serializeNamedRegistrarAction,
   serializeOmnichainIndexingStatusSnapshot: () => serializeOmnichainIndexingStatusSnapshot,
   serializePrice: () => serializePrice,
+  serializePriceDai: () => serializePriceDai,
   serializePriceEth: () => serializePriceEth,
+  serializePriceUsdc: () => serializePriceUsdc,
   serializeRealtimeIndexingStatusProjection: () => serializeRealtimeIndexingStatusProjection,
   serializeRegisteredNameTokens: () => serializeRegisteredNameTokens,
   serializeRegistrarAction: () => serializeRegistrarAction,
@@ -247,81 +257,17 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/ensapi/config/deserialize.ts
-var import_v46 = require("zod/v4");
+var import_v45 = require("zod/v4");
 
 // src/ensapi/config/zod-schemas.ts
-var import_v45 = require("zod/v4");
+var import_v44 = require("zod/v4");
 
 // src/ensindexer/config/zod-schemas.ts
-var import_v43 = require("zod/v4");
-
-// src/shared/account-id.ts
-var import_viem = require("viem");
-var accountIdEqual = (a, b) => {
-  return a.chainId === b.chainId && (0, import_viem.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
-var import_date_fns = require("date-fns");
-var import_getUnixTime = require("date-fns/getUnixTime");
-
-// src/shared/deserialize.ts
 var import_v42 = require("zod/v4");
 
+// src/shared/collections.ts
+var uniq = (arr) => [...new Set(arr)];
+
 // src/shared/zod-schemas.ts
 var import_caip = require("caip");
 var import_viem8 = require("viem");
@@ -351,23 +297,23 @@ var bigintToCoinType = (value) => {
 };
 
 // src/ens/constants.ts
-var import_viem2 = require("viem");
-var ROOT_NODE = (0, import_viem2.namehash)("");
-var ETH_NODE = (0, import_viem2.namehash)("eth");
-var BASENAMES_NODE = (0, import_viem2.namehash)("base.eth");
-var LINEANAMES_NODE = (0, import_viem2.namehash)("linea.eth");
-var ADDR_REVERSE_NODE = (0, import_viem2.namehash)("addr.reverse");
-var NODE_ANY = import_viem2.zeroHash;
+var import_viem = require("viem");
+var ROOT_NODE = (0, import_viem.namehash)("");
+var ETH_NODE = (0, import_viem.namehash)("eth");
+var BASENAMES_NODE = (0, import_viem.namehash)("base.eth");
+var LINEANAMES_NODE = (0, import_viem.namehash)("linea.eth");
+var ADDR_REVERSE_NODE = (0, import_viem.namehash)("addr.reverse");
+var NODE_ANY = import_viem.zeroHash;
 var ROOT_RESOURCE = 0n;
 
 // src/ens/dns-encoded-name.ts
-var import_viem3 = require("viem");
+var import_viem2 = require("viem");
 function decodeDNSEncodedLiteralName(packet) {
   return decodeDNSEncodedName(packet);
 }
 function decodeDNSEncodedName(packet) {
   const segments = [];
-  const bytes = (0, import_viem3.hexToBytes)(packet);
+  const bytes = (0, import_viem2.hexToBytes)(packet);
   if (bytes.length === 0) throw new Error(`Packet is empty.`);
   let offset = 0;
   while (offset < bytes.length) {
@@ -381,7 +327,7 @@ function decodeDNSEncodedName(packet) {
       );
     }
     if (len === 0) break;
-    const segment = (0, import_viem3.bytesToString)(bytes.subarray(offset + 1, offset + len + 1));
+    const segment = (0, import_viem2.bytesToString)(bytes.subarray(offset + 1, offset + len + 1));
     segments.push(segment);
     offset += len + 1;
   }
@@ -391,10 +337,10 @@ function decodeDNSEncodedName(packet) {
 }
 
 // src/ens/labelhash.ts
-var import_viem4 = require("viem");
+var import_viem3 = require("viem");
 function isLabelHash(maybeLabelHash) {
   const expectedLength = maybeLabelHash.length === 66;
-  const expectedEncoding = (0, import_viem4.isHex)(maybeLabelHash);
+  const expectedEncoding = (0, import_viem3.isHex)(maybeLabelHash);
   const expectedCasing = maybeLabelHash === maybeLabelHash.toLowerCase();
   return expectedLength && expectedEncoding && expectedCasing;
 }
@@ -456,11 +402,18 @@ var beautifyName = (name) => {
 };
 
 // src/ens/parse-reverse-name.ts
-var import_viem5 = require("viem");
+var import_viem4 = require("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 (!(0, import_viem5.isAddress)(maybeAddress)) {
+  if (!(0, import_viem4.isAddress)(maybeAddress)) {
     throw new Error(`Invalid EVM address "${maybeAddress}"`);
   }
   return asLowerCaseAddress(maybeAddress);
@@ -468,7 +421,7 @@ var parseAddressLabel = (addressLabel) => {
 var parseCoinTypeLabel = (coinTypeLabel) => {
   if (coinTypeLabel === "default") return DEFAULT_EVM_COIN_TYPE;
   if (coinTypeLabel === "addr") return ETH_COIN_TYPE;
-  return bigintToCoinType((0, import_viem5.hexToBigInt)(`0x${coinTypeLabel}`));
+  return bigintToCoinType((0, import_viem4.hexToBigInt)(`0x${coinTypeLabel}`));
 };
 function parseReverseName(name) {
   const match = name.match(REVERSE_NAME_REGEX);
@@ -505,13 +458,59 @@ function reverseName(address, coinType) {
 }
 
 // src/ens/subname-helpers.ts
-var import_viem6 = require("viem");
-var makeSubdomainNode = (labelHash, node) => (0, import_viem6.keccak256)((0, import_viem6.concat)([node, labelHash]));
-var uint256ToHex32 = (num) => (0, import_viem6.toHex)(num, { size: 32 });
+var import_viem5 = require("viem");
+var makeSubdomainNode = (labelHash, node) => (0, import_viem5.keccak256)((0, import_viem5.concat)([node, labelHash]));
+var uint256ToHex32 = (num) => (0, import_viem5.toHex)(num, { size: 32 });
 
 // src/ens/types.ts
 var import_datasources = require("@ensnode/datasources");
 
+// src/shared/currencies.ts
+var import_viem6 = require("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",
@@ -580,6 +579,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 = (0, import_viem6.parseUnits)(value, currencyInfo2.decimals);
+  return priceEth(amount);
+}
+function parseUsdc(value) {
+  validateAmountToParse(value);
+  const currencyInfo2 = getCurrencyInfo(CurrencyIds.USDC);
+  const amount = (0, import_viem6.parseUnits)(value, currencyInfo2.decimals);
+  return priceUsdc(amount);
+}
+function parseDai(value) {
+  validateAmountToParse(value);
+  const currencyInfo2 = getCurrencyInfo(CurrencyIds.DAI);
+  const amount = (0, import_viem6.parseUnits)(value, currencyInfo2.decimals);
+  return priceDai(amount);
+}
 
 // src/shared/interpretation/reinterpretation.ts
 var import_viem7 = require("viem");
@@ -675,6 +711,8 @@ var makePriceCurrencySchema = (currency, valueLabel = "Price Currency") => impor
   })
 });
 var makePriceEthSchema = (valueLabel = "Price ETH") => makePriceCurrencySchema(CurrencyIds.ETH, valueLabel).transform((v) => v);
+var makePriceUsdcSchema = (valueLabel = "Price USDC") => makePriceCurrencySchema(CurrencyIds.USDC, valueLabel).transform((v) => v);
+var makePriceDaiSchema = (valueLabel = "Price DAI") => makePriceCurrencySchema(CurrencyIds.DAI, valueLabel).transform((v) => v);
 var makeAccountIdSchema = (valueLabel = "AccountId") => import_v4.z.strictObject({
   chainId: makeChainIdSchema(`${valueLabel} chain ID`),
   address: makeLowercaseAddressSchema(`${valueLabel} address`)
@@ -720,64 +758,341 @@ var makeReinterpretedNameSchema = (valueLabel = "Reinterpreted Name") => import_
   }
 }).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:
-${(0, import_v42.prettifyError)(parsed.error)}
-`);
-  }
-  return parsed.data;
+// src/ensindexer/config/is-subgraph-compatible.ts
+var import_datasources3 = require("@ensnode/datasources");
+
+// src/ensindexer/config/types.ts
+var PluginName = /* @__PURE__ */ ((PluginName2) => {
+  PluginName2["Subgraph"] = "subgraph";
+  PluginName2["Basenames"] = "basenames";
+  PluginName2["Lineanames"] = "lineanames";
+  PluginName2["ThreeDNS"] = "threedns";
+  PluginName2["ProtocolAcceleration"] = "protocol-acceleration";
+  PluginName2["Registrars"] = "registrars";
+  PluginName2["TokenScope"] = "tokenscope";
+  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 === import_datasources3.ENSNamespaceIds.EnsTestEnv && isEnsTestEnvLabelSet;
+  return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
 }
-function deserializeDatetime(maybeDatetime, valueLabel) {
-  const schema = makeDatetimeSchema(valueLabel);
-  const parsed = schema.safeParse(maybeDatetime);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize Datetime:
-${(0, import_v42.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 deserializeUnixTimestamp(maybeTimestamp, valueLabel) {
-  const schema = makeUnixTimestampSchema(valueLabel);
-  const parsed = schema.safeParse(maybeTimestamp);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize Unix Timestamp:
-${(0, import_v42.prettifyError)(parsed.error)}
-`);
+
+// src/ensindexer/config/zod-schemas.ts
+var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => import_v42.z.array(makeChainIdSchema(valueLabel), {
+  error: `${valueLabel} must be an array.`
+}).min(1, { error: `${valueLabel} list must include at least one element.` }).transform((v) => new Set(v));
+var makePluginsListSchema = (valueLabel = "Plugins") => import_v42.z.array(import_v42.z.string(), {
+  error: `${valueLabel} must be a list of strings.`
+}).min(1, {
+  error: `${valueLabel} must be a list of strings with at least one string value`
+}).refine((arr) => arr.length === uniq(arr).length, {
+  error: `${valueLabel} cannot contain duplicate values.`
+});
+var makeDatabaseSchemaNameSchema = (valueLabel = "Database schema name") => import_v42.z.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
+  error: `${valueLabel} is required and must be a non-empty string.`
+});
+var makeLabelSetIdSchema = (valueLabel) => {
+  return import_v42.z.string({ error: `${valueLabel} must be a string` }).min(1, { error: `${valueLabel} must be 1-50 characters long` }).max(50, { error: `${valueLabel} must be 1-50 characters long` }).regex(/^[a-z-]+$/, {
+    error: `${valueLabel} can only contain lowercase letters (a-z) and hyphens (-)`
+  });
+};
+var makeLabelSetVersionSchema = (valueLabel) => {
+  return import_v42.z.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 deserializeUrl(maybeUrl, valueLabel) {
-  const schema = makeUrlSchema(valueLabel);
-  const parsed = schema.safeParse(maybeUrl);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize URL:
-${(0, import_v42.prettifyError)(parsed.error)}
-`);
+  return import_v42.z.object({
+    labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
+    labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
+  });
+};
+var makeNonEmptyStringSchema = (valueLabel = "Value") => import_v42.z.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
+var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => import_v42.z.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 deserializeBlockNumber(maybeBlockNumber, valueLabel) {
-  const schema = makeBlockNumberSchema(valueLabel);
-  const parsed = schema.safeParse(maybeBlockNumber);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize BlockNumber:
-${(0, import_v42.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 deserializeBlockrange(maybeBlockrange, valueLabel) {
-  const schema = makeBlockrangeSchema(valueLabel);
-  const parsed = schema.safeParse(maybeBlockrange);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize Blockrange:
-${(0, import_v42.prettifyError)(parsed.error)}
-`);
+var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => import_v42.z.object({
+  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
+  indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
+  isSubgraphCompatible: import_v42.z.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
+var import_v43 = require("zod/v4");
+var TheGraphCannotFallbackReasonSchema = import_v43.z.enum({
+  NotSubgraphCompatible: "not-subgraph-compatible",
+  NoApiKey: "no-api-key",
+  NoSubgraphUrl: "no-subgraph-url"
+});
+var TheGraphFallbackSchema = import_v43.z.discriminatedUnion("canFallback", [
+  import_v43.z.strictObject({
+    canFallback: import_v43.z.literal(true),
+    url: import_v43.z.string()
+  }),
+  import_v43.z.strictObject({
+    canFallback: import_v43.z.literal(false),
+    reason: TheGraphCannotFallbackReasonSchema
+  })
+]);
+
+// src/ensapi/config/zod-schemas.ts
+function makeENSApiPublicConfigSchema(valueLabel) {
+  const label = valueLabel ?? "ENSApiPublicConfig";
+  return import_v44.z.strictObject({
+    version: import_v44.z.string().min(1, `${label}.version must be a non-empty string`),
+    theGraphFallback: TheGraphFallbackSchema,
+    ensIndexerPublicConfig: makeENSIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
+  });
+}
+
+// src/ensapi/config/deserialize.ts
+function deserializeENSApiPublicConfig(maybeConfig, valueLabel) {
+  const schema = makeENSApiPublicConfigSchema(valueLabel);
+  try {
+    return schema.parse(maybeConfig);
+  } catch (error) {
+    if (error instanceof import_v45.ZodError) {
+      throw new Error(`Cannot deserialize ENSApiPublicConfig:
+${(0, import_v45.prettifyError)(error)}
+`);
+    }
+    throw error;
+  }
+}
+
+// src/ensindexer/config/deserialize.ts
+var import_v46 = require("zod/v4");
+function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
+  const schema = makeENSIndexerPublicConfigSchema(valueLabel);
+  const parsed = schema.safeParse(maybeConfig);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ENSIndexerPublicConfig:
+${(0, import_v46.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/ensindexer/config/label-utils.ts
+var import_viem9 = require("viem");
+function labelHashToBytes(labelHash) {
+  try {
+    if (labelHash.length !== 66) {
+      throw new Error(`Invalid labelHash length ${labelHash.length} characters (expected 66)`);
+    }
+    if (labelHash !== labelHash.toLowerCase()) {
+      throw new Error("Labelhash must be in lowercase");
+    }
+    if (!labelHash.startsWith("0x")) {
+      throw new Error("Labelhash must be 0x-prefixed");
+    }
+    const bytes = (0, import_viem9.hexToBytes)(labelHash);
+    if (bytes.length !== 32) {
+      throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
+    }
+    return bytes;
+  } catch (e) {
+    if (e instanceof Error) {
+      throw e;
+    }
+    throw new Error("Invalid hex format");
+  }
+}
+
+// src/ensindexer/config/labelset-utils.ts
+function buildLabelSetId(maybeLabelSetId) {
+  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
+}
+function buildLabelSetVersion(maybeLabelSetVersion) {
+  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
+}
+function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
+  if (labelSetVersion !== void 0 && labelSetId === void 0) {
+    throw new Error("When a labelSetVersion is defined, labelSetId must also be defined.");
+  }
+  return { labelSetId, labelSetVersion };
+}
+function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
+  if (clientSet.labelSetId === void 0) {
+    return;
+  }
+  if (serverSet.labelSetId !== clientSet.labelSetId) {
+    throw new Error(
+      `Server label set ID "${serverSet.labelSetId}" does not match client's requested label set ID "${clientSet.labelSetId}".`
+    );
+  }
+  if (clientSet.labelSetVersion !== void 0 && serverSet.highestLabelSetVersion < clientSet.labelSetVersion) {
+    throw new Error(
+      `Server highest label set version ${serverSet.highestLabelSetVersion} is less than client's requested version ${clientSet.labelSetVersion} for label set ID "${clientSet.labelSetId}".`
+    );
+  }
+}
+
+// src/ensindexer/config/parsing.ts
+function parseNonNegativeInteger(maybeNumber) {
+  const trimmed = maybeNumber.trim();
+  if (!trimmed) {
+    throw new Error("Input cannot be empty");
+  }
+  if (trimmed === "-0") {
+    throw new Error("Negative zero is not a valid non-negative integer");
+  }
+  const num = Number(maybeNumber);
+  if (Number.isNaN(num)) {
+    throw new Error(`"${maybeNumber}" is not a valid number`);
+  }
+  if (!Number.isFinite(num)) {
+    throw new Error(`"${maybeNumber}" is not a finite number`);
+  }
+  if (!Number.isInteger(num)) {
+    throw new Error(`"${maybeNumber}" is not an integer`);
+  }
+  if (num < 0) {
+    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
+  }
+  return num;
+}
+
+// src/ensindexer/config/serialize.ts
+function serializeIndexedChainIds(indexedChainIds) {
+  return Array.from(indexedChainIds);
+}
+function serializeENSIndexerPublicConfig(config) {
+  const {
+    labelSet,
+    indexedChainIds,
+    databaseSchemaName,
+    isSubgraphCompatible: isSubgraphCompatible2,
+    namespace,
+    plugins,
+    versionInfo
+  } = config;
+  return {
+    labelSet,
+    indexedChainIds: serializeIndexedChainIds(indexedChainIds),
+    databaseSchemaName,
+    isSubgraphCompatible: isSubgraphCompatible2,
+    namespace,
+    plugins,
+    versionInfo
+  };
+}
+
+// src/ensindexer/indexing-status/deserialize.ts
+var import_v49 = require("zod/v4");
+
+// src/ensindexer/indexing-status/zod-schemas.ts
+var import_v48 = require("zod/v4");
+
+// src/shared/deserialize.ts
+var import_v47 = require("zod/v4");
+function deserializeChainId(maybeChainId, valueLabel) {
+  const schema = makeChainIdStringSchema(valueLabel);
+  const parsed = schema.safeParse(maybeChainId);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ChainId:
+${(0, import_v47.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:
+${(0, import_v47.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+function deserializeUnixTimestamp(maybeTimestamp, valueLabel) {
+  const schema = makeUnixTimestampSchema(valueLabel);
+  const parsed = schema.safeParse(maybeTimestamp);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize Unix Timestamp:
+${(0, import_v47.prettifyError)(parsed.error)}
+`);
+  }
+  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:
+${(0, import_v47.prettifyError)(parsed.error)}
+`);
+  }
+  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:
+${(0, import_v47.prettifyError)(parsed.error)}
+`);
+  }
+  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:
+${(0, import_v47.prettifyError)(parsed.error)}
+`);
   }
   return parsed.data;
 }
@@ -786,7 +1101,7 @@ function deserializeBlockRef(maybeBlockRef, valueLabel) {
   const parsed = schema.safeParse(maybeBlockRef);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockRef:
-${(0, import_v42.prettifyError)(parsed.error)}
+${(0, import_v47.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -796,7 +1111,7 @@ function deserializeDuration(maybeDuration, valueLabel) {
   const parsed = schema.safeParse(maybeDuration);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize Duration:
-${(0, import_v42.prettifyError)(parsed.error)}
+${(0, import_v47.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -806,1234 +1121,698 @@ function parseAccountId(maybeAccountId, valueLabel) {
   const parsed = schema.safeParse(maybeAccountId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AccountId:
-${(0, import_v42.prettifyError)(parsed.error)}
+${(0, import_v47.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
-
-// src/shared/datetime.ts
-function durationBetween(start, end) {
-  return deserializeDuration(end - start, "Duration");
+function deserializePriceEth(maybePrice, valueLabel) {
+  const schema = makePriceEthSchema(valueLabel);
+  const parsed = schema.safeParse(maybePrice);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize PriceEth:
+${(0, import_v47.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
 }
-function addDuration(timestamp, duration) {
-  return deserializeUnixTimestamp(timestamp + duration, "UnixTimestamp");
+function deserializePriceUsdc(maybePrice, valueLabel) {
+  const schema = makePriceUsdcSchema(valueLabel);
+  const parsed = schema.safeParse(maybePrice);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize PriceUsdc:
+${(0, import_v47.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
 }
-
-// src/shared/cache/swr-cache.ts
-var SWRCache = class {
-  constructor(options) {
-    this.options = options;
-    if (options.proactiveRevalidationInterval) {
-      this.backgroundInterval = setInterval(
-        () => this.revalidate(),
-        (0, import_date_fns.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: (0, import_getUnixTime.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: (0, import_getUnixTime.getUnixTime)(/* @__PURE__ */ new Date())
-          };
-        }
-      }).finally(() => {
-        this.inProgressRevalidate = null;
-      });
-    }
-    return this.inProgressRevalidate;
+function deserializePriceDai(maybePrice, valueLabel) {
+  const schema = makePriceDaiSchema(valueLabel);
+  const parsed = schema.safeParse(maybePrice);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize PriceDai:
+${(0, import_v47.prettifyError)(parsed.error)}
+`);
   }
+  return parsed.data;
+}
+
+// src/ensindexer/indexing-status/types.ts
+var ChainIndexingConfigTypeIds = {
   /**
-   * 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.
+   * Represents that indexing of the chain should be performed for an indefinite range.
    */
-  async read() {
-    if (!this.cache) await this.revalidate();
-    if (!this.cache) throw new Error("never");
-    if (durationBetween(this.cache.updatedAt, (0, import_getUnixTime.getUnixTime)(/* @__PURE__ */ new Date())) > this.options.ttl) {
-      this.revalidate();
-    }
-    return this.cache.result;
-  }
+  Indefinite: "indefinite",
   /**
-   * Destroys the background revalidation interval, if exists.
+   * Represents that indexing of the chain should be performed for a definite range.
    */
-  destroy() {
-    if (this.backgroundInterval) {
-      clearInterval(this.backgroundInterval);
-      this.backgroundInterval = null;
-    }
-  }
+  Definite: "definite"
 };
-
-// src/shared/cache/ttl-cache.ts
-var import_getUnixTime2 = require("date-fns/getUnixTime");
-var TtlCache = class {
-  _cache = /* @__PURE__ */ new Map();
-  _ttl;
+var ChainIndexingStatusIds = {
   /**
-   * Create a new TTL cache with the given TTL.
+   * Represents that indexing of the chain is not ready to begin yet because:
+   * - ENSIndexer is in its initialization phase and the data to build a
+   *   "true" {@link ChainIndexingSnapshot} for the chain is still being loaded; or
+   * - ENSIndexer is using an omnichain indexing strategy and the
+   *   `omnichainIndexingCursor` is <= `config.startBlock.timestamp` for the chain's
+   *   {@link ChainIndexingSnapshot}.
+   */
+  Queued: "chain-queued",
+  /**
+   * Represents that indexing of the chain is in progress and under a special
+   * "backfill" phase that optimizes for accelerated indexing until reaching the
+   * "fixed target" `backfillEndBlock`.
+   */
+  Backfill: "chain-backfill",
+  /**
+   * Represents that the "backfill" phase of indexing the chain is completed
+   * and that the chain is configured to be indexed for an indefinite range.
+   * Therefore, indexing of the chain remains indefinitely in progress where
+   * ENSIndexer will continuously work to discover and index new blocks as they
+   * are added to the chain across time.
+   */
+  Following: "chain-following",
+  /**
+   * Represents that indexing of the chain is completed as the chain is configured
+   * to be indexed for a definite range and the indexing of all blocks through
+   * that definite range is completed.
+   */
+  Completed: "chain-completed"
+};
+var OmnichainIndexingStatusIds = {
+  /**
+   * Represents that omnichain indexing is not ready to begin yet because
+   * ENSIndexer is in its initialization phase and the data to build a "true"
+   * {@link OmnichainIndexingStatusSnapshot} is still being loaded.
+   */
+  Unstarted: "omnichain-unstarted",
+  /**
+   * Represents that omnichain indexing is in an overall "backfill" status because
+   * - At least one indexed chain has a `chainStatus` of
+   *   {@link ChainIndexingStatusIds.Backfill}; and
+   * - No indexed chain has a `chainStatus` of {@link ChainIndexingStatusIds.Following}.
+   */
+  Backfill: "omnichain-backfill",
+  /**
+   * Represents that omnichain indexing is in an overall "following" status because
+   * at least one indexed chain has a `chainStatus` of
+   * {@link ChainIndexingStatusIds.Following}.
+   */
+  Following: "omnichain-following",
+  /**
+   * Represents that omnichain indexing has completed because all indexed chains have
+   * a `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
+   */
+  Completed: "omnichain-completed"
+};
+var CrossChainIndexingStrategyIds = {
+  /**
+   * Represents that the indexing of events across all indexed chains will
+   * proceed in a deterministic "omnichain" ordering by block timestamp, chain ID,
+   * and block number.
    *
-   * @param ttl Time-to-live duration in seconds. Items expire after this duration.
+   * This strategy is "deterministic" in that the order of processing cross-chain indexed
+   * events and each resulting indexed data state transition recorded in ENSDb is always
+   * the same for each ENSIndexer instance operating with an equivalent
+   * `ENSIndexerConfig` and ENSIndexer version. However it also has the drawbacks of:
+   * - increased indexing latency that must wait for the slowest indexed chain to
+   *   add new blocks or to discover new blocks through the configured RPCs.
+   * - if any indexed chain gets "stuck" due to chain or RPC failures, all indexed chains
+   *   will be affected.
    */
-  constructor(ttl) {
-    this._ttl = ttl;
+  Omnichain: "omnichain"
+};
+
+// src/shared/block-ref.ts
+function isBefore(blockA, blockB) {
+  return blockA.number < blockB.number && blockA.timestamp < blockB.timestamp;
+}
+function isEqualTo(blockA, blockB) {
+  return blockA.number === blockB.number && blockA.timestamp === blockB.timestamp;
+}
+function isBeforeOrEqualTo(blockA, blockB) {
+  return isBefore(blockA, blockB) || isEqualTo(blockA, blockB);
+}
+
+// src/ensindexer/indexing-status/helpers.ts
+function getOmnichainIndexingStatus(chains) {
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains)) {
+    return OmnichainIndexingStatusIds.Following;
   }
-  _cleanup() {
-    const now = (0, import_getUnixTime2.getUnixTime)(/* @__PURE__ */ new Date());
-    for (const [key, entry] of this._cache.entries()) {
-      if (entry.expiresAt <= now) {
-        this._cache.delete(key);
-      }
-    }
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains)) {
+    return OmnichainIndexingStatusIds.Backfill;
   }
-  set(key, value) {
-    this._cleanup();
-    const expiresAt = addDuration((0, import_getUnixTime2.getUnixTime)(/* @__PURE__ */ new Date()), this._ttl);
-    this._cache.set(key, { value, expiresAt });
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains)) {
+    return OmnichainIndexingStatusIds.Unstarted;
   }
-  get(key) {
-    this._cleanup();
-    const entry = this._cache.get(key);
-    if (!entry) {
-      return void 0;
-    }
-    if (entry.expiresAt <= (0, import_getUnixTime2.getUnixTime)(/* @__PURE__ */ new Date())) {
-      this._cache.delete(key);
-      return void 0;
-    }
-    return entry.value;
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains)) {
+    return OmnichainIndexingStatusIds.Completed;
   }
-  clear() {
-    this._cache.clear();
+  throw new Error(`Unable to determine omnichain indexing status for provided chains.`);
+}
+function getTimestampForLowestOmnichainStartBlock(chains) {
+  const earliestKnownBlockTimestamps = chains.map(
+    (chain) => chain.config.startBlock.timestamp
+  );
+  return Math.min(...earliestKnownBlockTimestamps);
+}
+function getTimestampForHighestOmnichainKnownBlock(chains) {
+  const latestKnownBlockTimestamps = [];
+  for (const chain of chains) {
+    switch (chain.chainStatus) {
+      case ChainIndexingStatusIds.Queued:
+        if (chain.config.configType === ChainIndexingConfigTypeIds.Definite && chain.config.endBlock) {
+          latestKnownBlockTimestamps.push(chain.config.endBlock.timestamp);
+        }
+        break;
+      case ChainIndexingStatusIds.Backfill:
+        latestKnownBlockTimestamps.push(chain.backfillEndBlock.timestamp);
+        break;
+      case ChainIndexingStatusIds.Completed:
+        latestKnownBlockTimestamps.push(chain.latestIndexedBlock.timestamp);
+        break;
+      case ChainIndexingStatusIds.Following:
+        latestKnownBlockTimestamps.push(chain.latestKnownBlock.timestamp);
+        break;
+    }
   }
-  get size() {
-    this._cleanup();
-    return this._cache.size;
+  return Math.max(...latestKnownBlockTimestamps);
+}
+function getOmnichainIndexingCursor(chains) {
+  if (chains.length === 0) {
+    throw new Error(`Unable to determine omnichain indexing cursor when no chains were provided.`);
   }
-  get capacity() {
-    return Number.MAX_SAFE_INTEGER;
+  if (getOmnichainIndexingStatus(chains) === OmnichainIndexingStatusIds.Unstarted) {
+    const earliestStartBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
+    return Math.min(...earliestStartBlockTimestamps) - 1;
   }
-  has(key) {
-    this._cleanup();
-    const entry = this._cache.get(key);
-    if (!entry) {
-      return false;
-    }
-    if (entry.expiresAt <= (0, import_getUnixTime2.getUnixTime)(/* @__PURE__ */ new Date())) {
-      this._cache.delete(key);
-      return false;
-    }
-    return true;
+  const latestIndexedBlockTimestamps = chains.filter((chain) => chain.chainStatus !== ChainIndexingStatusIds.Queued).map((chain) => chain.latestIndexedBlock.timestamp);
+  if (latestIndexedBlockTimestamps.length < 1) {
+    throw new Error("latestIndexedBlockTimestamps array must include at least one element");
   }
-  delete(key) {
-    return this._cache.delete(key);
+  return Math.max(...latestIndexedBlockTimestamps);
+}
+function createIndexingConfig(startBlock, endBlock) {
+  if (endBlock) {
+    return {
+      configType: ChainIndexingConfigTypeIds.Definite,
+      startBlock,
+      endBlock
+    };
   }
-};
-
-// src/shared/collections.ts
-var uniq = (arr) => [...new Set(arr)];
-
-// src/shared/datasource-contract.ts
-var import_datasources3 = require("@ensnode/datasources");
-var maybeGetDatasourceContract = (namespaceId, datasourceName, contractName) => {
-  const datasource = (0, import_datasources3.maybeGetDatasource)(namespaceId, datasourceName);
-  if (!datasource) return void 0;
-  const address = datasource.contracts[contractName]?.address;
-  if (address === void 0 || Array.isArray(address)) return void 0;
   return {
-    chainId: datasource.chain.id,
-    address
+    configType: ChainIndexingConfigTypeIds.Indefinite,
+    startBlock
   };
-};
-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
-var import_viem9 = require("viem");
-var interpretAddress = (owner) => (0, import_viem9.isAddressEqual)(import_viem9.zeroAddress, owner) ? null : owner;
-
-// src/shared/interpretation/interpret-record-values.ts
-var import_viem10 = require("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 (!(0, import_viem10.isAddress)(value)) return value;
-  if ((0, import_viem10.isAddressEqual)(value, import_viem10.zeroAddress)) return null;
-  return asLowerCaseAddress(value);
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains) {
+  return chains.every((chain) => chain.chainStatus === ChainIndexingStatusIds.Queued);
 }
-function interpretTextRecordKey(key) {
-  if (hasNullByte(key)) return null;
-  if (key === "") return null;
-  return key;
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains) {
+  const atLeastOneChainInTargetStatus = chains.some(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
+  );
+  const otherChainsHaveValidStatuses = chains.every(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued || chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed
+  );
+  return atLeastOneChainInTargetStatus && otherChainsHaveValidStatuses;
 }
-function interpretTextRecordValue(value) {
-  if (hasNullByte(value)) return null;
-  if (value === "") return null;
-  return value;
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains) {
+  const allChainsHaveValidStatuses = chains.every(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Completed
+  );
+  return allChainsHaveValidStatuses;
 }
-
-// src/shared/interpretation/interpret-tokenid.ts
-var interpretTokenIdAsLabelHash = (tokenId) => uint256ToHex32(tokenId);
-var interpretTokenIdAsNode = (tokenId) => uint256ToHex32(tokenId);
-
-// src/shared/interpretation/interpreted-names-and-labels.ts
-var import_viem12 = require("viem");
-var import_ens5 = require("viem/ens");
-
-// src/shared/labelhash.ts
-var import_viem11 = require("viem");
-var labelhashLiteralLabel = (label) => (0, import_viem11.keccak256)((0, import_viem11.stringToBytes)(label));
-
-// src/shared/interpretation/interpreted-names-and-labels.ts
-function literalLabelToInterpretedLabel(label) {
-  if (isNormalizedLabel(label)) return label;
-  return encodeLabelHash(labelhashLiteralLabel(label));
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains) {
+  const allChainsHaveValidStatuses = chains.some(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Following
+  );
+  return allChainsHaveValidStatuses;
 }
-function literalLabelsToInterpretedName(labels) {
-  return labels.map(literalLabelToInterpretedLabel).join(".");
+function sortChainStatusesByStartBlockAsc(chains) {
+  chains.sort(
+    ([, chainA], [, chainB]) => chainA.config.startBlock.timestamp - chainB.config.startBlock.timestamp
+  );
+  return chains;
 }
-function interpretedLabelsToInterpretedName(labels) {
-  return labels.join(".");
+function getLatestIndexedBlockRef(indexingStatus, chainId) {
+  const chainIndexingStatus = indexingStatus.omnichainSnapshot.chains.get(chainId);
+  if (chainIndexingStatus === void 0) {
+    return null;
+  }
+  if (chainIndexingStatus.chainStatus === ChainIndexingStatusIds.Queued) {
+    return null;
+  }
+  return chainIndexingStatus.latestIndexedBlock;
 }
-function literalLabelsToLiteralName(labels) {
-  return labels.join(".");
+
+// src/ensindexer/indexing-status/validations.ts
+function invariant_chainSnapshotQueuedBlocks(ctx) {
+  const { config } = ctx.value;
+  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
+    return;
+  }
+  if (config.endBlock && isBeforeOrEqualTo(config.startBlock, config.endBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `config.endBlock`."
+    });
+  }
 }
-function interpretedNameToInterpretedLabels(name) {
-  return name.split(".");
+function invariant_chainSnapshotBackfillBlocks(ctx) {
+  const { config, latestIndexedBlock, backfillEndBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, backfillEndBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `backfillEndBlock`."
+    });
+  }
+  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
+    return;
+  }
+  if (config.endBlock && isEqualTo(backfillEndBlock, config.endBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`backfillEndBlock` must be the same as `config.endBlock`."
+    });
+  }
 }
-function 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 (!(0, import_viem12.isHex)(hash)) return null;
-  return hash;
+function invariant_chainSnapshotCompletedBlocks(ctx) {
+  const { config, latestIndexedBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, config.endBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `config.endBlock`."
+    });
+  }
 }
-function isInterpetedLabel(label) {
-  if (label.startsWith("[")) {
-    const labelHash = encodedLabelToLabelhash(label);
-    if (labelHash === null) return false;
+function invariant_chainSnapshotFollowingBlocks(ctx) {
+  const { config, latestIndexedBlock, latestKnownBlock } = ctx.value;
+  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
+    });
+  }
+  if (isBeforeOrEqualTo(latestIndexedBlock, latestKnownBlock) === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: "`latestIndexedBlock` must be before or same as `latestKnownBlock`."
+    });
   }
-  return isNormalizedLabel(label);
 }
-function isInterpretedName(name) {
-  return name.split(".").every(isInterpetedLabel);
+function invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot(ctx) {
+  const snapshot = ctx.value;
+  const chains = Array.from(snapshot.chains.values());
+  const expectedOmnichainStatus = getOmnichainIndexingStatus(chains);
+  const actualOmnichainStatus = snapshot.omnichainStatus;
+  if (expectedOmnichainStatus !== actualOmnichainStatus) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: `'${actualOmnichainStatus}' is an invalid omnichainStatus. Expected '${expectedOmnichainStatus}' based on the statuses of individual chains.`
+    });
+  }
 }
-function 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 (0, import_ens5.labelhash)(label);
-  }).toReversed();
+function invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains(ctx) {
+  const snapshot = ctx.value;
+  const queuedChains = Array.from(snapshot.chains.values()).filter(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued
+  );
+  if (queuedChains.length === 0) {
+    return;
+  }
+  const queuedChainStartBlocks = queuedChains.map((chain) => chain.config.startBlock.timestamp);
+  const queuedChainEarliestStartBlock = Math.min(...queuedChainStartBlocks);
+  if (snapshot.omnichainIndexingCursor >= queuedChainEarliestStartBlock) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: "`omnichainIndexingCursor` must be lower than the earliest start block across all queued chains."
+    });
+  }
 }
-
-// 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 invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains(ctx) {
+  const snapshot = ctx.value;
+  const backfillChains = Array.from(snapshot.chains.values()).filter(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
+  );
+  if (backfillChains.length === 0) {
+    return;
   }
-  if (n > Number.MAX_SAFE_INTEGER) {
-    throw new Error(
-      `The bigint '${n.toString()}' value is too high to be to converted into a number.'`
-    );
+  const backfillEndBlocks = backfillChains.map((chain) => chain.backfillEndBlock.timestamp);
+  const highestBackfillEndBlock = Math.max(...backfillEndBlocks);
+  if (snapshot.omnichainIndexingCursor > highestBackfillEndBlock) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: "`omnichainIndexingCursor` must be lower than or equal to the highest `backfillEndBlock` across all backfill chains."
+    });
   }
-  return Number(n);
 }
-
-// src/shared/root-registry.ts
-var import_datasources4 = require("@ensnode/datasources");
-var getENSv1Registry = (namespace) => getDatasourceContract(namespace, import_datasources4.DatasourceNames.ENSRoot, "ENSv1Registry");
-var isENSv1Registry = (namespace, contract) => accountIdEqual(getENSv1Registry(namespace), contract);
-var getENSv2RootRegistry = (namespace) => getDatasourceContract(namespace, import_datasources4.DatasourceNames.ENSv2Root, "RootRegistry");
-var getENSv2RootRegistryId = (namespace) => makeRegistryId(getENSv2RootRegistry(namespace));
-var isENSv2RootRegistry = (namespace, contract) => accountIdEqual(getENSv2RootRegistry(namespace), contract);
-
-// src/shared/serialize.ts
-var import_caip2 = require("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 formatAccountId(accountId) {
-  return import_caip2.AccountId.format({
-    chainId: { namespace: "eip155", reference: accountId.chainId.toString() },
-    address: accountId.address
-  }).toLowerCase();
-}
-function formatAssetId({
-  assetNamespace,
-  contract: { chainId, address },
-  tokenId
-}) {
-  return import_caip2.AssetId.format({
-    chainId: { namespace: "eip155", reference: chainId.toString() },
-    assetName: { namespace: assetNamespace, reference: address },
-    tokenId: uint256ToHex32(tokenId)
-  }).toLowerCase();
+function invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain(ctx) {
+  const snapshot = ctx.value;
+  const indexedChains = Array.from(snapshot.chains.values()).filter(
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed || chain.chainStatus === ChainIndexingStatusIds.Following
+  );
+  if (indexedChains.length === 0) {
+    return;
+  }
+  const indexedChainLatestIndexedBlocks = indexedChains.map(
+    (chain) => chain.latestIndexedBlock.timestamp
+  );
+  const indexedChainHighestLatestIndexedBlock = Math.max(...indexedChainLatestIndexedBlocks);
+  if (snapshot.omnichainIndexingCursor !== indexedChainHighestLatestIndexedBlock) {
+    ctx.issues.push({
+      code: "custom",
+      input: snapshot,
+      message: "`omnichainIndexingCursor` must be same as the highest `latestIndexedBlock` across all indexed chains."
+    });
+  }
 }
-
-// src/shared/types.ts
-var AssetNamespaces = {
-  ERC721: "erc721",
-  ERC1155: "erc1155"
-};
-
-// src/shared/url.ts
-function isHttpProtocol(url) {
-  return ["http:", "https:"].includes(url.protocol);
+function invariant_omnichainSnapshotUnstartedHasValidChains(ctx) {
+  const chains = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(
+    Array.from(chains.values())
+  );
+  if (hasValidChains === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: chains,
+      message: `For omnichain status snapshot 'unstarted', all chains must have "queued" status.`
+    });
+  }
 }
-function isWebSocketProtocol(url) {
-  return ["ws:", "wss:"].includes(url.protocol);
+function invariant_omnichainStatusSnapshotBackfillHasValidChains(ctx) {
+  const chains = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(
+    Array.from(chains.values())
+  );
+  if (hasValidChains === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: chains,
+      message: `For omnichain status snapshot 'backfill', at least one chain must be in "backfill" status and each chain has to have a status of either "queued", "backfill" or "completed".`
+    });
+  }
 }
-
-// src/ensindexer/config/is-subgraph-compatible.ts
-var import_datasources5 = require("@ensnode/datasources");
-
-// src/ensindexer/config/types.ts
-var PluginName = /* @__PURE__ */ ((PluginName2) => {
-  PluginName2["Subgraph"] = "subgraph";
-  PluginName2["Basenames"] = "basenames";
-  PluginName2["Lineanames"] = "lineanames";
-  PluginName2["ThreeDNS"] = "threedns";
-  PluginName2["ProtocolAcceleration"] = "protocol-acceleration";
-  PluginName2["Registrars"] = "registrars";
-  PluginName2["TokenScope"] = "tokenscope";
-  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 === import_datasources5.ENSNamespaceIds.EnsTestEnv && isEnsTestEnvLabelSet;
-  return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
+function invariant_omnichainStatusSnapshotCompletedHasValidChains(ctx) {
+  const chains = ctx.value;
+  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(
+    Array.from(chains.values())
+  );
+  if (hasValidChains === false) {
+    ctx.issues.push({
+      code: "custom",
+      input: chains,
+      message: `For omnichain status snapshot 'completed', all chains must have "completed" status.`
+    });
+  }
 }
-
-// src/ensindexer/config/validations.ts
-function invariant_ensDbVersionIsSameAsEnsIndexerVersion(ctx) {
-  const versionInfo = ctx.value;
-  if (versionInfo.ensDb !== versionInfo.ensIndexer) {
+function invariant_slowestChainEqualsToOmnichainSnapshotTime(ctx) {
+  const { slowestChainIndexingCursor, omnichainSnapshot } = ctx.value;
+  const { omnichainIndexingCursor } = omnichainSnapshot;
+  if (slowestChainIndexingCursor !== omnichainIndexingCursor) {
+    console.log("invariant_slowestChainEqualsToOmnichainSnapshotTime", {
+      slowestChainIndexingCursor,
+      omnichainIndexingCursor
+    });
     ctx.issues.push({
       code: "custom",
-      input: versionInfo,
-      message: "`ensDb` version must be same as `ensIndexer` version"
+      input: ctx.value,
+      message: `'slowestChainIndexingCursor' must be equal to 'omnichainSnapshot.omnichainIndexingCursor'`
     });
   }
 }
-
-// src/ensindexer/config/zod-schemas.ts
-var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => import_v43.z.array(makeChainIdSchema(valueLabel), {
-  error: `${valueLabel} must be an array.`
-}).min(1, { error: `${valueLabel} list must include at least one element.` }).transform((v) => new Set(v));
-var makePluginsListSchema = (valueLabel = "Plugins") => import_v43.z.array(import_v43.z.string(), {
-  error: `${valueLabel} must be a list of strings.`
-}).min(1, {
-  error: `${valueLabel} must be a list of strings with at least one string value`
-}).refine((arr) => arr.length === uniq(arr).length, {
-  error: `${valueLabel} cannot contain duplicate values.`
-});
-var makeDatabaseSchemaNameSchema = (valueLabel = "Database schema name") => import_v43.z.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
-  error: `${valueLabel} is required and must be a non-empty string.`
-});
-var makeLabelSetIdSchema = (valueLabel) => {
-  return import_v43.z.string({ error: `${valueLabel} must be a string` }).min(1, { error: `${valueLabel} must be 1-50 characters long` }).max(50, { error: `${valueLabel} must be 1-50 characters long` }).regex(/^[a-z-]+$/, {
-    error: `${valueLabel} can only contain lowercase letters (a-z) and hyphens (-)`
-  });
-};
-var makeLabelSetVersionSchema = (valueLabel) => {
-  return import_v43.z.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`;
+function invariant_snapshotTimeIsTheHighestKnownBlockTimestamp(ctx) {
+  const { snapshotTime, omnichainSnapshot } = ctx.value;
+  const chains = Array.from(omnichainSnapshot.chains.values());
+  const startBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
+  const endBlockTimestamps = chains.map((chain) => chain.config).filter((chainConfig) => chainConfig.configType === ChainIndexingConfigTypeIds.Definite).map((chainConfig) => chainConfig.endBlock.timestamp);
+  const backfillEndBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill).map((chain) => chain.backfillEndBlock.timestamp);
+  const latestKnownBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Following).map((chain) => chain.latestKnownBlock.timestamp);
+  const highestKnownBlockTimestamp = Math.max(
+    ...startBlockTimestamps,
+    ...endBlockTimestamps,
+    ...backfillEndBlockTimestamps,
+    ...latestKnownBlockTimestamps
+  );
+  if (snapshotTime < highestKnownBlockTimestamp) {
+    ctx.issues.push({
+      code: "custom",
+      input: ctx.value,
+      message: `'snapshotTime' (${snapshotTime}) must be greater than or equal to the "highest known block timestamp" (${highestKnownBlockTimestamp})`
+    });
   }
-  return import_v43.z.object({
-    labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
-    labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
-  });
-};
-var makeNonEmptyStringSchema = (valueLabel = "Value") => import_v43.z.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
-var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => import_v43.z.strictObject(
-  {
-    nodejs: makeNonEmptyStringSchema(),
-    ponder: makeNonEmptyStringSchema(),
-    ensDb: makeNonEmptyStringSchema(),
-    ensIndexer: makeNonEmptyStringSchema(),
-    ensNormalize: makeNonEmptyStringSchema(),
-    ensRainbow: makeNonEmptyStringSchema(),
-    ensRainbowSchema: makePositiveIntegerSchema()
-  },
-  {
-    error: `${valueLabel} must be a valid ENSIndexerVersionInfo object.`
+}
+function invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime(ctx) {
+  const projection = ctx.value;
+  const { snapshot, projectedAt } = projection;
+  if (snapshot.snapshotTime > projectedAt) {
+    ctx.issues.push({
+      code: "custom",
+      input: projection,
+      message: "`projectedAt` must be after or same as `snapshot.snapshotTime`."
+    });
   }
-).check(invariant_ensDbVersionIsSameAsEnsIndexerVersion);
-function invariant_isSubgraphCompatibleRequirements(ctx) {
-  const { value: config } = ctx;
-  if (config.isSubgraphCompatible && !isSubgraphCompatible(config)) {
+}
+function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ctx) {
+  const projection = ctx.value;
+  const { projectedAt, snapshot, worstCaseDistance } = projection;
+  const { omnichainSnapshot } = snapshot;
+  const expectedWorstCaseDistance = projectedAt - omnichainSnapshot.omnichainIndexingCursor;
+  if (worstCaseDistance !== expectedWorstCaseDistance) {
     ctx.issues.push({
       code: "custom",
-      input: config,
-      message: `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active and labelSet must be {labelSetId: "subgraph", labelSetVersion: 0}`
+      input: projection,
+      message: "`worstCaseDistance` must be the exact difference between `projectedAt` and `snapshot.omnichainIndexingCursor`."
     });
   }
 }
-var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => import_v43.z.object({
-  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
-  indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
-  isSubgraphCompatible: import_v43.z.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
-var import_v44 = require("zod/v4");
-var TheGraphCannotFallbackReasonSchema = import_v44.z.enum({
-  NotSubgraphCompatible: "not-subgraph-compatible",
-  NoApiKey: "no-api-key",
-  NoSubgraphUrl: "no-subgraph-url"
-});
-var TheGraphFallbackSchema = import_v44.z.discriminatedUnion("canFallback", [
-  import_v44.z.strictObject({
-    canFallback: import_v44.z.literal(true),
-    url: import_v44.z.string()
+// src/ensindexer/indexing-status/zod-schemas.ts
+var makeChainIndexingConfigSchema = (valueLabel = "Value") => import_v48.z.discriminatedUnion("configType", [
+  import_v48.z.strictObject({
+    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel)
   }),
-  import_v44.z.strictObject({
-    canFallback: import_v44.z.literal(false),
-    reason: TheGraphCannotFallbackReasonSchema
+  import_v48.z.strictObject({
+    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Definite),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: makeBlockRefSchema(valueLabel)
   })
 ]);
-
-// src/ensapi/config/zod-schemas.ts
-function makeENSApiPublicConfigSchema(valueLabel) {
-  const label = valueLabel ?? "ENSApiPublicConfig";
-  return import_v45.z.strictObject({
-    version: import_v45.z.string().min(1, `${label}.version must be a non-empty string`),
-    theGraphFallback: TheGraphFallbackSchema,
-    ensIndexerPublicConfig: makeENSIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
-  });
-}
-
-// src/ensapi/config/deserialize.ts
-function deserializeENSApiPublicConfig(maybeConfig, valueLabel) {
-  const schema = makeENSApiPublicConfigSchema(valueLabel);
-  try {
-    return schema.parse(maybeConfig);
-  } catch (error) {
-    if (error instanceof import_v46.ZodError) {
-      throw new Error(`Cannot deserialize ENSApiPublicConfig:
-${(0, import_v46.prettifyError)(error)}
-`);
-    }
-    throw error;
+var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v48.z.strictObject({
+  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Queued),
+  config: makeChainIndexingConfigSchema(valueLabel)
+}).check(invariant_chainSnapshotQueuedBlocks);
+var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v48.z.strictObject({
+  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Backfill),
+  config: makeChainIndexingConfigSchema(valueLabel),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  backfillEndBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotBackfillBlocks);
+var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v48.z.strictObject({
+  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Completed),
+  config: import_v48.z.strictObject({
+    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Definite),
+    startBlock: makeBlockRefSchema(valueLabel),
+    endBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotCompletedBlocks);
+var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v48.z.strictObject({
+  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Following),
+  config: import_v48.z.strictObject({
+    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  latestKnownBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotFollowingBlocks);
+var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v48.z.discriminatedUnion("chainStatus", [
+  makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
+  makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
+  makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
+  makeChainIndexingStatusSnapshotFollowingSchema(valueLabel)
+]);
+var makeChainIndexingStatusesSchema = (valueLabel = "Value") => import_v48.z.record(makeChainIdStringSchema(), makeChainIndexingStatusSnapshotSchema(valueLabel), {
+  error: "Chains indexing statuses must be an object mapping valid chain IDs to their indexing status snapshots."
+}).transform((serializedChainsIndexingStatus) => {
+  const chainsIndexingStatus = /* @__PURE__ */ new Map();
+  for (const [chainIdString, chainStatus] of Object.entries(serializedChainsIndexingStatus)) {
+    chainsIndexingStatus.set(deserializeChainId(chainIdString), chainStatus);
   }
-}
+  return chainsIndexingStatus;
+});
+var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v48.z.strictObject({
+  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Unstarted),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainSnapshotUnstartedHasValidChains).transform((chains) => chains),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v48.z.strictObject({
+  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Backfill),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotBackfillHasValidChains).transform(
+    (chains) => chains
+  ),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v48.z.strictObject({
+  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Completed),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotCompletedHasValidChains).transform((chains) => chains),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v48.z.strictObject({
+  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Following),
+  chains: makeChainIndexingStatusesSchema(valueLabel),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v48.z.discriminatedUnion("omnichainStatus", [
+  makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
+  makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
+  makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
+  makeOmnichainIndexingStatusSnapshotFollowingSchema(valueLabel)
+]).check(invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot).check(invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains).check(
+  invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains
+).check(invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain);
+var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => import_v48.z.strictObject({
+  strategy: import_v48.z.literal(CrossChainIndexingStrategyIds.Omnichain),
+  slowestChainIndexingCursor: makeUnixTimestampSchema(valueLabel),
+  snapshotTime: makeUnixTimestampSchema(valueLabel),
+  omnichainSnapshot: makeOmnichainIndexingStatusSnapshotSchema(valueLabel)
+}).check(invariant_slowestChainEqualsToOmnichainSnapshotTime).check(invariant_snapshotTimeIsTheHighestKnownBlockTimestamp);
+var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => import_v48.z.discriminatedUnion("strategy", [
+  makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
+]);
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v48.z.strictObject({
+  projectedAt: makeUnixTimestampSchema(valueLabel),
+  worstCaseDistance: makeDurationSchema(valueLabel),
+  snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
+}).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
 
-// src/ensindexer/config/deserialize.ts
-var import_v47 = require("zod/v4");
-function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
-  const schema = makeENSIndexerPublicConfigSchema(valueLabel);
-  const parsed = schema.safeParse(maybeConfig);
+// src/ensindexer/indexing-status/deserialize.ts
+function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(maybeSnapshot);
   if (parsed.error) {
-    throw new Error(`Cannot deserialize ENSIndexerPublicConfig:
-${(0, import_v47.prettifyError)(parsed.error)}
-`);
+    throw new Error(
+      `Cannot deserialize into ChainIndexingStatusSnapshot:
+${(0, import_v49.prettifyError)(parsed.error)}
+`
+    );
   }
   return parsed.data;
 }
-
-// src/ensindexer/config/label-utils.ts
-var import_viem13 = require("viem");
-function labelHashToBytes(labelHash) {
-  try {
-    if (labelHash.length !== 66) {
-      throw new Error(`Invalid labelHash length ${labelHash.length} characters (expected 66)`);
-    }
-    if (labelHash !== labelHash.toLowerCase()) {
-      throw new Error("Labelhash must be in lowercase");
-    }
-    if (!labelHash.startsWith("0x")) {
-      throw new Error("Labelhash must be 0x-prefixed");
-    }
-    const bytes = (0, import_viem13.hexToBytes)(labelHash);
-    if (bytes.length !== 32) {
-      throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
-    }
-    return bytes;
-  } catch (e) {
-    if (e instanceof Error) {
-      throw e;
-    }
-    throw new Error("Invalid hex format");
-  }
-}
-
-// src/ensindexer/config/labelset-utils.ts
-function buildLabelSetId(maybeLabelSetId) {
-  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
-}
-function buildLabelSetVersion(maybeLabelSetVersion) {
-  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
-}
-function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
-  if (labelSetVersion !== void 0 && labelSetId === void 0) {
-    throw new Error("When a labelSetVersion is defined, labelSetId must also be defined.");
-  }
-  return { labelSetId, labelSetVersion };
-}
-function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
-  if (clientSet.labelSetId === void 0) {
-    return;
-  }
-  if (serverSet.labelSetId !== clientSet.labelSetId) {
+function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeOmnichainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(maybeSnapshot);
+  if (parsed.error) {
     throw new Error(
-      `Server label set ID "${serverSet.labelSetId}" does not match client's requested label set ID "${clientSet.labelSetId}".`
+      `Cannot deserialize into OmnichainIndexingStatusSnapshot:
+${(0, import_v49.prettifyError)(parsed.error)}
+`
     );
   }
-  if (clientSet.labelSetVersion !== void 0 && serverSet.highestLabelSetVersion < clientSet.labelSetVersion) {
+  return parsed.data;
+}
+function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeCrossChainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(maybeSnapshot);
+  if (parsed.error) {
     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}".`
+      `Cannot deserialize into CrossChainIndexingStatusSnapshot:
+${(0, import_v49.prettifyError)(parsed.error)}
+`
     );
   }
+  return parsed.data;
 }
-
-// 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`);
+function deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel) {
+  const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
+  const parsed = schema.safeParse(maybeProjection);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into RealtimeIndexingStatusProjection:
+${(0, import_v49.prettifyError)(parsed.error)}
+`
+    );
   }
-  return num;
+  return parsed.data;
 }
 
-// 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;
+// src/ensindexer/indexing-status/projection.ts
+function createRealtimeIndexingStatusProjection(snapshot, now) {
+  const projectedAt = Math.max(now, snapshot.snapshotTime);
   return {
-    labelSet,
-    indexedChainIds: serializeIndexedChainIds(indexedChainIds),
-    databaseSchemaName,
-    isSubgraphCompatible: isSubgraphCompatible2,
-    namespace,
-    plugins,
-    versionInfo
+    projectedAt,
+    worstCaseDistance: projectedAt - snapshot.slowestChainIndexingCursor,
+    snapshot
   };
 }
 
-// src/ensindexer/indexing-status/deserialize.ts
-var import_v49 = require("zod/v4");
-
-// src/ensindexer/indexing-status/zod-schemas.ts
-var import_v48 = require("zod/v4");
-
-// src/ensindexer/indexing-status/types.ts
-var ChainIndexingConfigTypeIds = {
-  /**
-   * Represents that indexing of the chain should be performed for an indefinite range.
-   */
-  Indefinite: "indefinite",
-  /**
-   * Represents that indexing of the chain should be performed for a definite range.
-   */
-  Definite: "definite"
-};
-var ChainIndexingStatusIds = {
-  /**
-   * Represents that indexing of the chain is not ready to begin yet because:
-   * - ENSIndexer is in its initialization phase and the data to build a
-   *   "true" {@link ChainIndexingSnapshot} for the chain is still being loaded; or
-   * - ENSIndexer is using an omnichain indexing strategy and the
-   *   `omnichainIndexingCursor` is <= `config.startBlock.timestamp` for the chain's
-   *   {@link ChainIndexingSnapshot}.
-   */
-  Queued: "chain-queued",
-  /**
-   * Represents that indexing of the chain is in progress and under a special
-   * "backfill" phase that optimizes for accelerated indexing until reaching the
-   * "fixed target" `backfillEndBlock`.
-   */
-  Backfill: "chain-backfill",
-  /**
-   * Represents that the "backfill" phase of indexing the chain is completed
-   * and that the chain is configured to be indexed for an indefinite range.
-   * Therefore, indexing of the chain remains indefinitely in progress where
-   * ENSIndexer will continuously work to discover and index new blocks as they
-   * are added to the chain across time.
-   */
-  Following: "chain-following",
-  /**
-   * Represents that indexing of the chain is completed as the chain is configured
-   * to be indexed for a definite range and the indexing of all blocks through
-   * that definite range is completed.
-   */
-  Completed: "chain-completed"
-};
-var OmnichainIndexingStatusIds = {
-  /**
-   * Represents that omnichain indexing is not ready to begin yet because
-   * ENSIndexer is in its initialization phase and the data to build a "true"
-   * {@link OmnichainIndexingStatusSnapshot} is still being loaded.
-   */
-  Unstarted: "omnichain-unstarted",
-  /**
-   * Represents that omnichain indexing is in an overall "backfill" status because
-   * - At least one indexed chain has a `chainStatus` of
-   *   {@link ChainIndexingStatusIds.Backfill}; and
-   * - No indexed chain has a `chainStatus` of {@link ChainIndexingStatusIds.Following}.
-   */
-  Backfill: "omnichain-backfill",
-  /**
-   * Represents that omnichain indexing is in an overall "following" status because
-   * at least one indexed chain has a `chainStatus` of
-   * {@link ChainIndexingStatusIds.Following}.
-   */
-  Following: "omnichain-following",
-  /**
-   * Represents that omnichain indexing has completed because all indexed chains have
-   * a `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
-   */
-  Completed: "omnichain-completed"
-};
-var CrossChainIndexingStrategyIds = {
-  /**
-   * Represents that the indexing of events across all indexed chains will
-   * proceed in a deterministic "omnichain" ordering by block timestamp, chain ID,
-   * and block number.
-   *
-   * This strategy is "deterministic" in that the order of processing cross-chain indexed
-   * events and each resulting indexed data state transition recorded in ENSDb is always
-   * the same for each ENSIndexer instance operating with an equivalent
-   * `ENSIndexerConfig` and ENSIndexer version. However it also has the drawbacks of:
-   * - increased indexing latency that must wait for the slowest indexed chain to
-   *   add new blocks or to discover new blocks through the configured RPCs.
-   * - if any indexed chain gets "stuck" due to chain or RPC failures, all indexed chains
-   *   will be affected.
-   */
-  Omnichain: "omnichain"
-};
-
-// src/shared/block-ref.ts
-function isBefore(blockA, blockB) {
-  return blockA.number < blockB.number && blockA.timestamp < blockB.timestamp;
-}
-function isEqualTo(blockA, blockB) {
-  return blockA.number === blockB.number && blockA.timestamp === blockB.timestamp;
-}
-function isBeforeOrEqualTo(blockA, blockB) {
-  return isBefore(blockA, blockB) || isEqualTo(blockA, blockB);
-}
-
-// src/ensindexer/indexing-status/helpers.ts
-function getOmnichainIndexingStatus(chains) {
-  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains)) {
-    return OmnichainIndexingStatusIds.Following;
-  }
-  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains)) {
-    return OmnichainIndexingStatusIds.Backfill;
-  }
-  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains)) {
-    return OmnichainIndexingStatusIds.Unstarted;
-  }
-  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains)) {
-    return OmnichainIndexingStatusIds.Completed;
-  }
-  throw new Error(`Unable to determine omnichain indexing status for provided chains.`);
-}
-function getTimestampForLowestOmnichainStartBlock(chains) {
-  const earliestKnownBlockTimestamps = chains.map(
-    (chain) => chain.config.startBlock.timestamp
-  );
-  return Math.min(...earliestKnownBlockTimestamps);
-}
-function getTimestampForHighestOmnichainKnownBlock(chains) {
-  const latestKnownBlockTimestamps = [];
-  for (const chain of chains) {
-    switch (chain.chainStatus) {
-      case ChainIndexingStatusIds.Queued:
-        if (chain.config.configType === ChainIndexingConfigTypeIds.Definite && chain.config.endBlock) {
-          latestKnownBlockTimestamps.push(chain.config.endBlock.timestamp);
-        }
-        break;
-      case ChainIndexingStatusIds.Backfill:
-        latestKnownBlockTimestamps.push(chain.backfillEndBlock.timestamp);
-        break;
-      case ChainIndexingStatusIds.Completed:
-        latestKnownBlockTimestamps.push(chain.latestIndexedBlock.timestamp);
-        break;
-      case ChainIndexingStatusIds.Following:
-        latestKnownBlockTimestamps.push(chain.latestKnownBlock.timestamp);
-        break;
-    }
-  }
-  return Math.max(...latestKnownBlockTimestamps);
-}
-function getOmnichainIndexingCursor(chains) {
-  if (chains.length === 0) {
-    throw new Error(`Unable to determine omnichain indexing cursor when no chains were provided.`);
-  }
-  if (getOmnichainIndexingStatus(chains) === OmnichainIndexingStatusIds.Unstarted) {
-    const earliestStartBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
-    return Math.min(...earliestStartBlockTimestamps) - 1;
-  }
-  const latestIndexedBlockTimestamps = chains.filter((chain) => chain.chainStatus !== ChainIndexingStatusIds.Queued).map((chain) => chain.latestIndexedBlock.timestamp);
-  if (latestIndexedBlockTimestamps.length < 1) {
-    throw new Error("latestIndexedBlockTimestamps array must include at least one element");
-  }
-  return Math.max(...latestIndexedBlockTimestamps);
-}
-function createIndexingConfig(startBlock, endBlock) {
-  if (endBlock) {
-    return {
-      configType: ChainIndexingConfigTypeIds.Definite,
-      startBlock,
-      endBlock
-    };
-  }
-  return {
-    configType: ChainIndexingConfigTypeIds.Indefinite,
-    startBlock
-  };
-}
-function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains) {
-  return chains.every((chain) => chain.chainStatus === ChainIndexingStatusIds.Queued);
-}
-function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains) {
-  const atLeastOneChainInTargetStatus = chains.some(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
-  );
-  const otherChainsHaveValidStatuses = chains.every(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued || chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed
-  );
-  return atLeastOneChainInTargetStatus && otherChainsHaveValidStatuses;
-}
-function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains) {
-  const allChainsHaveValidStatuses = chains.every(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Completed
-  );
-  return allChainsHaveValidStatuses;
-}
-function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains) {
-  const allChainsHaveValidStatuses = chains.some(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Following
-  );
-  return allChainsHaveValidStatuses;
-}
-function sortChainStatusesByStartBlockAsc(chains) {
-  chains.sort(
-    ([, chainA], [, chainB]) => chainA.config.startBlock.timestamp - chainB.config.startBlock.timestamp
-  );
-  return chains;
-}
-function getLatestIndexedBlockRef(indexingStatus, chainId) {
-  const chainIndexingStatus = indexingStatus.omnichainSnapshot.chains.get(chainId);
-  if (chainIndexingStatus === void 0) {
-    return null;
-  }
-  if (chainIndexingStatus.chainStatus === ChainIndexingStatusIds.Queued) {
-    return null;
-  }
-  return chainIndexingStatus.latestIndexedBlock;
-}
-
-// src/ensindexer/indexing-status/validations.ts
-function invariant_chainSnapshotQueuedBlocks(ctx) {
-  const { config } = ctx.value;
-  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
-    return;
-  }
-  if (config.endBlock && isBeforeOrEqualTo(config.startBlock, config.endBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`config.startBlock` must be before or same as `config.endBlock`."
-    });
-  }
-}
-function invariant_chainSnapshotBackfillBlocks(ctx) {
-  const { config, latestIndexedBlock, backfillEndBlock } = ctx.value;
-  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
-    });
-  }
-  if (isBeforeOrEqualTo(latestIndexedBlock, backfillEndBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`latestIndexedBlock` must be before or same as `backfillEndBlock`."
-    });
-  }
-  if (config.configType === ChainIndexingConfigTypeIds.Indefinite) {
-    return;
-  }
-  if (config.endBlock && isEqualTo(backfillEndBlock, config.endBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`backfillEndBlock` must be the same as `config.endBlock`."
-    });
-  }
-}
-function invariant_chainSnapshotCompletedBlocks(ctx) {
-  const { config, latestIndexedBlock } = ctx.value;
-  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
-    });
-  }
-  if (isBeforeOrEqualTo(latestIndexedBlock, config.endBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`latestIndexedBlock` must be before or same as `config.endBlock`."
-    });
-  }
-}
-function invariant_chainSnapshotFollowingBlocks(ctx) {
-  const { config, latestIndexedBlock, latestKnownBlock } = ctx.value;
-  if (isBeforeOrEqualTo(config.startBlock, latestIndexedBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`config.startBlock` must be before or same as `latestIndexedBlock`."
-    });
-  }
-  if (isBeforeOrEqualTo(latestIndexedBlock, latestKnownBlock) === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: "`latestIndexedBlock` must be before or same as `latestKnownBlock`."
-    });
-  }
-}
-function invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot(ctx) {
-  const snapshot = ctx.value;
-  const chains = Array.from(snapshot.chains.values());
-  const expectedOmnichainStatus = getOmnichainIndexingStatus(chains);
-  const actualOmnichainStatus = snapshot.omnichainStatus;
-  if (expectedOmnichainStatus !== actualOmnichainStatus) {
-    ctx.issues.push({
-      code: "custom",
-      input: snapshot,
-      message: `'${actualOmnichainStatus}' is an invalid omnichainStatus. Expected '${expectedOmnichainStatus}' based on the statuses of individual chains.`
-    });
-  }
-}
-function invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains(ctx) {
-  const snapshot = ctx.value;
-  const queuedChains = Array.from(snapshot.chains.values()).filter(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued
-  );
-  if (queuedChains.length === 0) {
-    return;
-  }
-  const queuedChainStartBlocks = queuedChains.map((chain) => chain.config.startBlock.timestamp);
-  const queuedChainEarliestStartBlock = Math.min(...queuedChainStartBlocks);
-  if (snapshot.omnichainIndexingCursor >= queuedChainEarliestStartBlock) {
-    ctx.issues.push({
-      code: "custom",
-      input: snapshot,
-      message: "`omnichainIndexingCursor` must be lower than the earliest start block across all queued chains."
-    });
-  }
-}
-function invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains(ctx) {
-  const snapshot = ctx.value;
-  const backfillChains = Array.from(snapshot.chains.values()).filter(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
-  );
-  if (backfillChains.length === 0) {
-    return;
-  }
-  const backfillEndBlocks = backfillChains.map((chain) => chain.backfillEndBlock.timestamp);
-  const highestBackfillEndBlock = Math.max(...backfillEndBlocks);
-  if (snapshot.omnichainIndexingCursor > highestBackfillEndBlock) {
-    ctx.issues.push({
-      code: "custom",
-      input: snapshot,
-      message: "`omnichainIndexingCursor` must be lower than or equal to the highest `backfillEndBlock` across all backfill chains."
-    });
-  }
-}
-function invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain(ctx) {
-  const snapshot = ctx.value;
-  const indexedChains = Array.from(snapshot.chains.values()).filter(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed || chain.chainStatus === ChainIndexingStatusIds.Following
-  );
-  if (indexedChains.length === 0) {
-    return;
-  }
-  const indexedChainLatestIndexedBlocks = indexedChains.map(
-    (chain) => chain.latestIndexedBlock.timestamp
-  );
-  const indexedChainHighestLatestIndexedBlock = Math.max(...indexedChainLatestIndexedBlocks);
-  if (snapshot.omnichainIndexingCursor !== indexedChainHighestLatestIndexedBlock) {
-    ctx.issues.push({
-      code: "custom",
-      input: snapshot,
-      message: "`omnichainIndexingCursor` must be same as the highest `latestIndexedBlock` across all indexed chains."
-    });
-  }
-}
-function invariant_omnichainSnapshotUnstartedHasValidChains(ctx) {
-  const chains = ctx.value;
-  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(
-    Array.from(chains.values())
-  );
-  if (hasValidChains === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: chains,
-      message: `For omnichain status snapshot 'unstarted', all chains must have "queued" status.`
-    });
-  }
-}
-function invariant_omnichainStatusSnapshotBackfillHasValidChains(ctx) {
-  const chains = ctx.value;
-  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(
-    Array.from(chains.values())
-  );
-  if (hasValidChains === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: chains,
-      message: `For omnichain status snapshot 'backfill', at least one chain must be in "backfill" status and each chain has to have a status of either "queued", "backfill" or "completed".`
-    });
-  }
-}
-function invariant_omnichainStatusSnapshotCompletedHasValidChains(ctx) {
-  const chains = ctx.value;
-  const hasValidChains = checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(
-    Array.from(chains.values())
-  );
-  if (hasValidChains === false) {
-    ctx.issues.push({
-      code: "custom",
-      input: chains,
-      message: `For omnichain status snapshot 'completed', all chains must have "completed" status.`
-    });
-  }
-}
-function invariant_slowestChainEqualsToOmnichainSnapshotTime(ctx) {
-  const { slowestChainIndexingCursor, omnichainSnapshot } = ctx.value;
-  const { omnichainIndexingCursor } = omnichainSnapshot;
-  if (slowestChainIndexingCursor !== omnichainIndexingCursor) {
-    console.log("invariant_slowestChainEqualsToOmnichainSnapshotTime", {
-      slowestChainIndexingCursor,
-      omnichainIndexingCursor
-    });
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: `'slowestChainIndexingCursor' must be equal to 'omnichainSnapshot.omnichainIndexingCursor'`
-    });
-  }
-}
-function invariant_snapshotTimeIsTheHighestKnownBlockTimestamp(ctx) {
-  const { snapshotTime, omnichainSnapshot } = ctx.value;
-  const chains = Array.from(omnichainSnapshot.chains.values());
-  const startBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
-  const endBlockTimestamps = chains.map((chain) => chain.config).filter((chainConfig) => chainConfig.configType === ChainIndexingConfigTypeIds.Definite).map((chainConfig) => chainConfig.endBlock.timestamp);
-  const backfillEndBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill).map((chain) => chain.backfillEndBlock.timestamp);
-  const latestKnownBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Following).map((chain) => chain.latestKnownBlock.timestamp);
-  const highestKnownBlockTimestamp = Math.max(
-    ...startBlockTimestamps,
-    ...endBlockTimestamps,
-    ...backfillEndBlockTimestamps,
-    ...latestKnownBlockTimestamps
-  );
-  if (snapshotTime < highestKnownBlockTimestamp) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: `'snapshotTime' (${snapshotTime}) must be greater than or equal to the "highest known block timestamp" (${highestKnownBlockTimestamp})`
-    });
-  }
-}
-function invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime(ctx) {
-  const projection = ctx.value;
-  const { snapshot, projectedAt } = projection;
-  if (snapshot.snapshotTime > projectedAt) {
-    ctx.issues.push({
-      code: "custom",
-      input: projection,
-      message: "`projectedAt` must be after or same as `snapshot.snapshotTime`."
-    });
-  }
-}
-function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ctx) {
-  const projection = ctx.value;
-  const { projectedAt, snapshot, worstCaseDistance } = projection;
-  const { omnichainSnapshot } = snapshot;
-  const expectedWorstCaseDistance = projectedAt - omnichainSnapshot.omnichainIndexingCursor;
-  if (worstCaseDistance !== expectedWorstCaseDistance) {
-    ctx.issues.push({
-      code: "custom",
-      input: projection,
-      message: "`worstCaseDistance` must be the exact difference between `projectedAt` and `snapshot.omnichainIndexingCursor`."
-    });
-  }
-}
-
-// src/ensindexer/indexing-status/zod-schemas.ts
-var makeChainIndexingConfigSchema = (valueLabel = "Value") => import_v48.z.discriminatedUnion("configType", [
-  import_v48.z.strictObject({
-    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Indefinite),
-    startBlock: makeBlockRefSchema(valueLabel)
-  }),
-  import_v48.z.strictObject({
-    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Definite),
-    startBlock: makeBlockRefSchema(valueLabel),
-    endBlock: makeBlockRefSchema(valueLabel)
-  })
-]);
-var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v48.z.strictObject({
-  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Queued),
-  config: makeChainIndexingConfigSchema(valueLabel)
-}).check(invariant_chainSnapshotQueuedBlocks);
-var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v48.z.strictObject({
-  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Backfill),
-  config: makeChainIndexingConfigSchema(valueLabel),
-  latestIndexedBlock: makeBlockRefSchema(valueLabel),
-  backfillEndBlock: makeBlockRefSchema(valueLabel)
-}).check(invariant_chainSnapshotBackfillBlocks);
-var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v48.z.strictObject({
-  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Completed),
-  config: import_v48.z.strictObject({
-    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Definite),
-    startBlock: makeBlockRefSchema(valueLabel),
-    endBlock: makeBlockRefSchema(valueLabel)
-  }),
-  latestIndexedBlock: makeBlockRefSchema(valueLabel)
-}).check(invariant_chainSnapshotCompletedBlocks);
-var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v48.z.strictObject({
-  chainStatus: import_v48.z.literal(ChainIndexingStatusIds.Following),
-  config: import_v48.z.strictObject({
-    configType: import_v48.z.literal(ChainIndexingConfigTypeIds.Indefinite),
-    startBlock: makeBlockRefSchema(valueLabel)
-  }),
-  latestIndexedBlock: makeBlockRefSchema(valueLabel),
-  latestKnownBlock: makeBlockRefSchema(valueLabel)
-}).check(invariant_chainSnapshotFollowingBlocks);
-var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v48.z.discriminatedUnion("chainStatus", [
-  makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
-  makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
-  makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
-  makeChainIndexingStatusSnapshotFollowingSchema(valueLabel)
-]);
-var makeChainIndexingStatusesSchema = (valueLabel = "Value") => import_v48.z.record(makeChainIdStringSchema(), makeChainIndexingStatusSnapshotSchema(valueLabel), {
-  error: "Chains indexing statuses must be an object mapping valid chain IDs to their indexing status snapshots."
-}).transform((serializedChainsIndexingStatus) => {
-  const chainsIndexingStatus = /* @__PURE__ */ new Map();
-  for (const [chainIdString, chainStatus] of Object.entries(serializedChainsIndexingStatus)) {
-    chainsIndexingStatus.set(deserializeChainId(chainIdString), chainStatus);
-  }
-  return chainsIndexingStatus;
-});
-var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v48.z.strictObject({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Unstarted),
-  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainSnapshotUnstartedHasValidChains).transform((chains) => chains),
-  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
-});
-var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v48.z.strictObject({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Backfill),
-  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotBackfillHasValidChains).transform(
-    (chains) => chains
-  ),
-  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
-});
-var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v48.z.strictObject({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Completed),
-  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotCompletedHasValidChains).transform((chains) => chains),
-  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
-});
-var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v48.z.strictObject({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Following),
-  chains: makeChainIndexingStatusesSchema(valueLabel),
-  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
-});
-var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v48.z.discriminatedUnion("omnichainStatus", [
-  makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
-  makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
-  makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
-  makeOmnichainIndexingStatusSnapshotFollowingSchema(valueLabel)
-]).check(invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot).check(invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains).check(
-  invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains
-).check(invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain);
-var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => import_v48.z.strictObject({
-  strategy: import_v48.z.literal(CrossChainIndexingStrategyIds.Omnichain),
-  slowestChainIndexingCursor: makeUnixTimestampSchema(valueLabel),
-  snapshotTime: makeUnixTimestampSchema(valueLabel),
-  omnichainSnapshot: makeOmnichainIndexingStatusSnapshotSchema(valueLabel)
-}).check(invariant_slowestChainEqualsToOmnichainSnapshotTime).check(invariant_snapshotTimeIsTheHighestKnownBlockTimestamp);
-var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => import_v48.z.discriminatedUnion("strategy", [
-  makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
-]);
-var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v48.z.strictObject({
-  projectedAt: makeUnixTimestampSchema(valueLabel),
-  worstCaseDistance: makeDurationSchema(valueLabel),
-  snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
-}).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
-
-// src/ensindexer/indexing-status/deserialize.ts
-function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
-  const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
-  const parsed = schema.safeParse(maybeSnapshot);
-  if (parsed.error) {
-    throw new Error(
-      `Cannot deserialize into ChainIndexingStatusSnapshot:
-${(0, import_v49.prettifyError)(parsed.error)}
-`
-    );
-  }
-  return parsed.data;
-}
-function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
-  const schema = makeOmnichainIndexingStatusSnapshotSchema(valueLabel);
-  const parsed = schema.safeParse(maybeSnapshot);
-  if (parsed.error) {
-    throw new Error(
-      `Cannot deserialize into OmnichainIndexingStatusSnapshot:
-${(0, import_v49.prettifyError)(parsed.error)}
-`
-    );
-  }
-  return parsed.data;
+// src/shared/serialize.ts
+var import_caip2 = require("caip");
+function serializeChainId(chainId) {
+  return chainId.toString();
 }
-function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
-  const schema = makeCrossChainIndexingStatusSnapshotSchema(valueLabel);
-  const parsed = schema.safeParse(maybeSnapshot);
-  if (parsed.error) {
-    throw new Error(
-      `Cannot deserialize into CrossChainIndexingStatusSnapshot:
-${(0, import_v49.prettifyError)(parsed.error)}
-`
-    );
-  }
-  return parsed.data;
+function serializeDatetime(datetime) {
+  return datetime.toISOString();
 }
-function deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel) {
-  const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
-  const parsed = schema.safeParse(maybeProjection);
-  if (parsed.error) {
-    throw new Error(
-      `Cannot deserialize into RealtimeIndexingStatusProjection:
-${(0, import_v49.prettifyError)(parsed.error)}
-`
-    );
-  }
-  return parsed.data;
+function serializeUrl(url) {
+  return url.toString();
 }
-
-// src/ensindexer/indexing-status/projection.ts
-function createRealtimeIndexingStatusProjection(snapshot, now) {
-  const projectedAt = Math.max(now, snapshot.snapshotTime);
+function serializePrice(price) {
   return {
-    projectedAt,
-    worstCaseDistance: projectedAt - snapshot.slowestChainIndexingCursor,
-    snapshot
+    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 import_caip2.AccountId.format({
+    chainId: { namespace: "eip155", reference: accountId.chainId.toString() },
+    address: accountId.address
+  }).toLowerCase();
+}
+function formatAssetId({
+  assetNamespace,
+  contract: { chainId, address },
+  tokenId
+}) {
+  return import_caip2.AssetId.format({
+    chainId: { namespace: "eip155", reference: chainId.toString() },
+    assetName: { namespace: assetNamespace, reference: address },
+    tokenId: uint256ToHex32(tokenId)
+  }).toLowerCase();
+}
 
 // src/ensindexer/indexing-status/serialize.ts
 function serializeCrossChainIndexingStatusSnapshotOmnichain({
@@ -2172,21 +1951,61 @@ function serializeIndexingStatusResponse(response) {
 var import_v416 = require("zod/v4");
 
 // src/api/name-tokens/zod-schemas.ts
-var import_viem17 = require("viem");
+var import_viem14 = require("viem");
 var import_v415 = require("zod/v4");
 
 // src/tokenscope/assets.ts
-var import_viem16 = require("viem");
+var import_viem13 = require("viem");
 var import_v413 = require("zod/v4");
 
 // src/tokenscope/zod-schemas.ts
 var import_caip3 = require("caip");
-var import_viem15 = require("viem");
+var import_viem12 = require("viem");
 var import_v412 = require("zod/v4");
 
+// src/shared/types.ts
+var AssetNamespaces = {
+  ERC721: "erc721",
+  ERC1155: "erc1155"
+};
+
+// src/tokenscope/name-token.ts
+var import_viem11 = require("viem");
+var import_datasources5 = require("@ensnode/datasources");
+
+// src/shared/account-id.ts
+var import_viem10 = require("viem");
+var accountIdEqual = (a, b) => {
+  return a.chainId === b.chainId && (0, import_viem10.isAddressEqual)(a.address, b.address);
+};
+
+// src/shared/datasource-contract.ts
+var import_datasources4 = require("@ensnode/datasources");
+var maybeGetDatasourceContract = (namespaceId, datasourceName, contractName) => {
+  const datasource = (0, import_datasources4.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
-var import_viem14 = require("viem");
-var import_datasources6 = require("@ensnode/datasources");
 var NameTokenOwnershipTypes = {
   /**
    * Name Token is owned by NameWrapper account.
@@ -2217,12 +2036,12 @@ function serializeNameToken(nameToken) {
 function getNameWrapperAccounts(namespaceId) {
   const ethnamesNameWrapperAccount = getDatasourceContract(
     namespaceId,
-    import_datasources6.DatasourceNames.ENSRoot,
+    import_datasources5.DatasourceNames.ENSRoot,
     "NameWrapper"
   );
   const lineanamesNameWrapperAccount = maybeGetDatasourceContract(
     namespaceId,
-    import_datasources6.DatasourceNames.Lineanames,
+    import_datasources5.DatasourceNames.Lineanames,
     "NameWrapper"
   );
   const nameWrapperAccounts = [
@@ -2245,7 +2064,7 @@ function getNameTokenOwnership(namespaceId, name, owner) {
       owner
     };
   }
-  if ((0, import_viem14.isAddressEqual)(owner.address, import_viem14.zeroAddress)) {
+  if ((0, import_viem11.isAddressEqual)(owner.address, import_viem11.zeroAddress)) {
     return {
       ownershipType: NameTokenOwnershipTypes.Burned,
       owner
@@ -2300,7 +2119,7 @@ var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_
 }, makeAssetIdSchema(valueLabel));
 function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
   const ownership = ctx.value;
-  if (ctx.value.owner.address === import_viem15.zeroAddress) {
+  if (ctx.value.owner.address === import_viem12.zeroAddress) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2326,7 +2145,7 @@ var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Un
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
 function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
   const ownership = ctx.value;
-  if (ctx.value.owner.address !== import_viem15.zeroAddress) {
+  if (ctx.value.owner.address !== import_viem12.zeroAddress) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2504,11 +2323,11 @@ var NFTTransferTypes = {
 };
 var getNFTTransferType = (from, to, allowMintedRemint, metadata, currentlyIndexedOwner) => {
   const isIndexed = currentlyIndexedOwner !== void 0;
-  const isIndexedAsMinted = isIndexed && !(0, import_viem16.isAddressEqual)(currentlyIndexedOwner, import_viem16.zeroAddress);
-  const isMint = (0, import_viem16.isAddressEqual)(from, import_viem16.zeroAddress);
-  const isBurn = (0, import_viem16.isAddressEqual)(to, import_viem16.zeroAddress);
-  const isSelfTransfer = (0, import_viem16.isAddressEqual)(from, to);
-  if (isIndexed && !(0, import_viem16.isAddressEqual)(currentlyIndexedOwner, from)) {
+  const isIndexedAsMinted = isIndexed && !(0, import_viem13.isAddressEqual)(currentlyIndexedOwner, import_viem13.zeroAddress);
+  const isMint = (0, import_viem13.isAddressEqual)(from, import_viem13.zeroAddress);
+  const isBurn = (0, import_viem13.isAddressEqual)(to, import_viem13.zeroAddress);
+  const isSelfTransfer = (0, import_viem13.isAddressEqual)(from, to);
+  if (isIndexed && !(0, import_viem13.isAddressEqual)(currentlyIndexedOwner, from)) {
     if (isMint && allowMintedRemint) {
     } else {
       throw new Error(
@@ -2641,7 +2460,7 @@ var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", seria
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 }).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
   const { name, domainId } = ctx.value;
-  if ((0, import_viem17.namehash)(name) !== domainId) {
+  if ((0, import_viem14.namehash)(name) !== domainId) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2793,41 +2612,41 @@ function serializeNameTokensResponse(response) {
 var import_v420 = require("zod/v4");
 
 // src/api/registrar-actions/zod-schemas.ts
-var import_ens10 = require("viem/ens");
+var import_ens7 = require("viem/ens");
 var import_v419 = require("zod/v4");
 
 // src/registrars/zod-schemas.ts
 var import_v417 = require("zod/v4");
 
 // src/registrars/encoded-referrer.ts
-var import_viem18 = require("viem");
+var import_viem15 = require("viem");
 var ENCODED_REFERRER_BYTE_OFFSET = 12;
 var ENCODED_REFERRER_BYTE_LENGTH = 32;
-var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem18.pad)("0x", {
+var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem15.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_OFFSET,
   dir: "left"
 });
-var ZERO_ENCODED_REFERRER = (0, import_viem18.pad)("0x", {
+var ZERO_ENCODED_REFERRER = (0, import_viem15.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_LENGTH,
   dir: "left"
 });
 function buildEncodedReferrer(address) {
   const lowercaseAddress = address.toLowerCase();
-  return (0, import_viem18.pad)(lowercaseAddress, { size: ENCODED_REFERRER_BYTE_LENGTH, dir: "left" });
+  return (0, import_viem15.pad)(lowercaseAddress, { size: ENCODED_REFERRER_BYTE_LENGTH, dir: "left" });
 }
 function decodeEncodedReferrer(encodedReferrer) {
-  if ((0, import_viem18.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
+  if ((0, import_viem15.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
     throw new Error(
       `Encoded referrer value must be represented by ${ENCODED_REFERRER_BYTE_LENGTH} bytes.`
     );
   }
-  const padding = (0, import_viem18.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
+  const padding = (0, import_viem15.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
   if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
-    return import_viem18.zeroAddress;
+    return import_viem15.zeroAddress;
   }
-  const decodedReferrer = (0, import_viem18.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
+  const decodedReferrer = (0, import_viem15.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
   try {
-    return (0, import_viem18.getAddress)(decodedReferrer);
+    return (0, import_viem15.getAddress)(decodedReferrer);
   } catch {
     throw new Error(`Decoded referrer value must be a valid EVM address.`);
   }
@@ -3062,7 +2881,7 @@ var RegistrarActionsResponseCodes = {
 function invariant_registrationLifecycleNodeMatchesName(ctx) {
   const { name, action } = ctx.value;
   const expectedNode = action.registrationLifecycle.node;
-  const actualNode = (0, import_ens10.namehash)(name);
+  const actualNode = (0, import_ens7.namehash)(name);
   if (actualNode !== expectedNode) {
     ctx.issues.push({
       code: "custom",
@@ -3219,11 +3038,11 @@ var registrarActionsPrerequisites = Object.freeze({
 });
 
 // src/registrars/basenames-subregistry.ts
-var import_datasources7 = require("@ensnode/datasources");
+var import_datasources6 = require("@ensnode/datasources");
 function getBasenamesSubregistryId(namespace) {
-  const datasource = (0, import_datasources7.maybeGetDatasource)(namespace, import_datasources7.DatasourceNames.Basenames);
+  const datasource = (0, import_datasources6.maybeGetDatasource)(namespace, import_datasources6.DatasourceNames.Basenames);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${import_datasources7.DatasourceNames.Basenames}`);
+    throw new Error(`Datasource not found for ${namespace} ${import_datasources6.DatasourceNames.Basenames}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -3236,12 +3055,12 @@ function getBasenamesSubregistryId(namespace) {
 }
 function getBasenamesSubregistryManagedName(namespaceId) {
   switch (namespaceId) {
-    case import_datasources7.ENSNamespaceIds.Mainnet:
+    case import_datasources6.ENSNamespaceIds.Mainnet:
       return "base.eth";
-    case import_datasources7.ENSNamespaceIds.Sepolia:
-    case import_datasources7.ENSNamespaceIds.SepoliaV2:
+    case import_datasources6.ENSNamespaceIds.Sepolia:
+    case import_datasources6.ENSNamespaceIds.SepoliaV2:
       return "basetest.eth";
-    case import_datasources7.ENSNamespaceIds.EnsTestEnv:
+    case import_datasources6.ENSNamespaceIds.EnsTestEnv:
       throw new Error(
         `No registrar managed name is known for the 'basenames' subregistry within the "${namespaceId}" namespace.`
       );
@@ -3249,11 +3068,11 @@ function getBasenamesSubregistryManagedName(namespaceId) {
 }
 
 // src/registrars/ethnames-subregistry.ts
-var import_datasources8 = require("@ensnode/datasources");
+var import_datasources7 = require("@ensnode/datasources");
 function getEthnamesSubregistryId(namespace) {
-  const datasource = (0, import_datasources8.maybeGetDatasource)(namespace, import_datasources8.DatasourceNames.ENSRoot);
+  const datasource = (0, import_datasources7.maybeGetDatasource)(namespace, import_datasources7.DatasourceNames.ENSRoot);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${import_datasources8.DatasourceNames.ENSRoot}`);
+    throw new Error(`Datasource not found for ${namespace} ${import_datasources7.DatasourceNames.ENSRoot}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -3266,20 +3085,20 @@ function getEthnamesSubregistryId(namespace) {
 }
 function getEthnamesSubregistryManagedName(namespaceId) {
   switch (namespaceId) {
-    case import_datasources8.ENSNamespaceIds.Mainnet:
-    case import_datasources8.ENSNamespaceIds.Sepolia:
-    case import_datasources8.ENSNamespaceIds.SepoliaV2:
-    case import_datasources8.ENSNamespaceIds.EnsTestEnv:
+    case import_datasources7.ENSNamespaceIds.Mainnet:
+    case import_datasources7.ENSNamespaceIds.Sepolia:
+    case import_datasources7.ENSNamespaceIds.SepoliaV2:
+    case import_datasources7.ENSNamespaceIds.EnsTestEnv:
       return "eth";
   }
 }
 
 // src/registrars/lineanames-subregistry.ts
-var import_datasources9 = require("@ensnode/datasources");
+var import_datasources8 = require("@ensnode/datasources");
 function getLineanamesSubregistryId(namespace) {
-  const datasource = (0, import_datasources9.maybeGetDatasource)(namespace, import_datasources9.DatasourceNames.Lineanames);
+  const datasource = (0, import_datasources8.maybeGetDatasource)(namespace, import_datasources8.DatasourceNames.Lineanames);
   if (!datasource) {
-    throw new Error(`Datasource not found for ${namespace} ${import_datasources9.DatasourceNames.Lineanames}`);
+    throw new Error(`Datasource not found for ${namespace} ${import_datasources8.DatasourceNames.Lineanames}`);
   }
   const address = datasource.contracts.BaseRegistrar?.address;
   if (address === void 0 || Array.isArray(address)) {
@@ -3292,12 +3111,12 @@ function getLineanamesSubregistryId(namespace) {
 }
 function getLineanamesSubregistryManagedName(namespaceId) {
   switch (namespaceId) {
-    case import_datasources9.ENSNamespaceIds.Mainnet:
+    case import_datasources8.ENSNamespaceIds.Mainnet:
       return "linea.eth";
-    case import_datasources9.ENSNamespaceIds.Sepolia:
-    case import_datasources9.ENSNamespaceIds.SepoliaV2:
+    case import_datasources8.ENSNamespaceIds.Sepolia:
+    case import_datasources8.ENSNamespaceIds.SepoliaV2:
       return "linea-sepolia.eth";
-    case import_datasources9.ENSNamespaceIds.EnsTestEnv:
+    case import_datasources8.ENSNamespaceIds.EnsTestEnv:
       throw new Error(
         `No registrar managed name is known for the 'Lineanames' subregistry within the "${namespaceId}" namespace.`
       );
@@ -3404,15 +3223,15 @@ var ClientError = class _ClientError extends Error {
 };
 
 // src/deployments.ts
-var import_datasources10 = require("@ensnode/datasources");
+var import_datasources9 = require("@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 getDefaultEnsNodeUrl = (namespace) => {
-  const effectiveNamespace = namespace ?? import_datasources10.ENSNamespaceIds.Mainnet;
+  const effectiveNamespace = namespace ?? import_datasources9.ENSNamespaceIds.Mainnet;
   switch (effectiveNamespace) {
-    case import_datasources10.ENSNamespaceIds.Mainnet:
+    case import_datasources9.ENSNamespaceIds.Mainnet:
       return new URL(DEFAULT_ENSNODE_API_URL_MAINNET);
-    case import_datasources10.ENSNamespaceIds.Sepolia:
+    case import_datasources9.ENSNamespaceIds.Sepolia:
       return new URL(DEFAULT_ENSNODE_API_URL_SEPOLIA);
     default:
       throw new Error(
@@ -3831,136 +3650,435 @@ var ENSNodeClient = class _ENSNodeClient {
     return deserializeRegistrarActionsResponse(responseData);
   }
   /**
-   * Fetch Name Tokens for requested name.
-   *
-   * @param request.name - Name for which Name Tokens will be fetched.
-   * @returns {NameTokensResponse}
-   *
-   * @throws if the ENSNode request fails
-   * @throws if the ENSNode API returns an error response
-   * @throws if the ENSNode response breaks required invariants
-   *
-   * @example
-   * ```ts
-   * import {
-   *   ENSNodeClient,
-   * } from "@ensnode/ensnode-sdk";
-   * import { namehash } from "viem/ens";
-   *
-   * const client: ENSNodeClient;
-   *
-   * // get latest name token records from the indexed subregistry based on the requested name
-   * const response = await client.nameTokens({
-   *   name: "vitalik.eth"
-   * });
+   * 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 Name Tokens Failed: ${errorResponse.message}`);
+      }
+    }
+    return deserializedNameTokensResponse(responseData);
+  }
+};
+
+// src/ensv2/ids-lib.ts
+var import_viem16 = require("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((0, import_viem16.hexToBigInt)(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
+var import_datasources10 = require("@ensnode/datasources");
+
+// src/identity/types.ts
+var ResolutionStatusIds = {
+  /**
+   * Represents that the `Identity` is not resolved yet.
+   */
+  Unresolved: "unresolved",
+  /**
+   * Represents that resolution of the `Identity` resulted in a named identity.
+   */
+  Named: "named",
+  /**
+   * Represents that resolution of the `Identity` resulted in an unnamed identity.
+   */
+  Unnamed: "unnamed",
+  /**
+   * Represents that attempted resolution of the `Identity` resulted in an error
+   * and therefore it is unknown if the `Identity` resolves to a named or unnamed identity.
+   */
+  Unknown: "unknown"
+};
+
+// src/identity/identity.ts
+function buildUnresolvedIdentity(address, namespaceId, chainId) {
+  return {
+    resolutionStatus: ResolutionStatusIds.Unresolved,
+    chainId: chainId ?? (0, import_datasources10.getENSRootChainId)(namespaceId),
+    address
+  };
+}
+function isResolvedIdentity(identity) {
+  return identity.resolutionStatus !== ResolutionStatusIds.Unresolved;
+}
+
+// src/resolution/ensip19-chainid.ts
+var import_chains = require("viem/chains");
+var import_datasources11 = require("@ensnode/datasources");
+var getResolvePrimaryNameChainIdParam = (chainId, namespaceId) => {
+  const ensRootChainId = (0, import_datasources11.getENSRootChainId)(namespaceId);
+  return chainId === ensRootChainId ? import_chains.mainnet.id : chainId;
+};
+var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
+  return chainId === DEFAULT_EVM_CHAIN_ID ? (0, import_datasources11.getENSRootChainId)(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
+var import_date_fns = require("date-fns");
+var import_getUnixTime = require("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(),
+        (0, import_date_fns.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: (0, import_getUnixTime.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: (0, import_getUnixTime.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, (0, import_getUnixTime.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
+var import_getUnixTime2 = require("date-fns/getUnixTime");
+var TtlCache = class {
+  _cache = /* @__PURE__ */ new Map();
+  _ttl;
+  /**
+   * Create a new TTL cache with the given TTL.
    *
-   * const response = await client.nameTokens({
-   *   domainId: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835" // namehash('vitalik.eth')
-   * })
-   * ```
+   * @param ttl Time-to-live duration in seconds. Items expire after this duration.
    */
-  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);
+  constructor(ttl) {
+    this._ttl = ttl;
+  }
+  _cleanup() {
+    const now = (0, import_getUnixTime2.getUnixTime)(/* @__PURE__ */ new Date());
+    for (const [key, entry] of this._cache.entries()) {
+      if (entry.expiresAt <= now) {
+        this._cache.delete(key);
+      }
     }
-    const response = await fetch(url);
-    let responseData;
-    try {
-      responseData = await response.json();
-    } catch {
-      throw new Error("Malformed response data: invalid JSON");
+  }
+  set(key, value) {
+    this._cleanup();
+    const expiresAt = addDuration((0, import_getUnixTime2.getUnixTime)(/* @__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;
     }
-    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}`);
-      }
+    if (entry.expiresAt <= (0, import_getUnixTime2.getUnixTime)(/* @__PURE__ */ new Date())) {
+      this._cache.delete(key);
+      return void 0;
     }
-    return deserializedNameTokensResponse(responseData);
+    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;
+    }
+    if (entry.expiresAt <= (0, import_getUnixTime2.getUnixTime)(/* @__PURE__ */ new Date())) {
+      this._cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  delete(key) {
+    return this._cache.delete(key);
   }
 };
 
-// src/ensv2/ids-lib.ts
-var import_viem19 = require("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((0, import_viem19.hexToBigInt)(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
+var import_viem17 = require("viem");
+var interpretAddress = (owner) => (0, import_viem17.isAddressEqual)(import_viem17.zeroAddress, owner) ? null : owner;
 
-// src/identity/identity.ts
-var import_datasources11 = require("@ensnode/datasources");
+// src/shared/interpretation/interpret-record-values.ts
+var import_viem18 = require("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 ?? (0, import_datasources11.getENSRootChainId)(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 (!(0, import_viem18.isAddress)(value)) return value;
+  if ((0, import_viem18.isAddressEqual)(value, import_viem18.zeroAddress)) 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
-var import_chains = require("viem/chains");
+// src/shared/interpretation/interpret-tokenid.ts
+var interpretTokenIdAsLabelHash = (tokenId) => uint256ToHex32(tokenId);
+var interpretTokenIdAsNode = (tokenId) => uint256ToHex32(tokenId);
+
+// src/shared/interpretation/interpreted-names-and-labels.ts
+var import_viem20 = require("viem");
+var import_ens10 = require("viem/ens");
+
+// src/shared/labelhash.ts
+var import_viem19 = require("viem");
+var labelhashLiteralLabel = (label) => (0, import_viem19.keccak256)((0, import_viem19.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 (!(0, import_viem20.isHex)(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 (0, import_ens10.labelhash)(label);
+  }).toReversed();
+}
+
+// src/shared/root-registry.ts
 var import_datasources12 = require("@ensnode/datasources");
-var getResolvePrimaryNameChainIdParam = (chainId, namespaceId) => {
-  const ensRootChainId = (0, import_datasources12.getENSRootChainId)(namespaceId);
-  return chainId === ensRootChainId ? import_chains.mainnet.id : chainId;
-};
-var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
-  return chainId === DEFAULT_EVM_CHAIN_ID ? (0, import_datasources12.getENSRootChainId)(namespaceId) : chainId;
-};
+var getENSv1Registry = (namespace) => getDatasourceContract(namespace, import_datasources12.DatasourceNames.ENSRoot, "ENSv1Registry");
+var isENSv1Registry = (namespace, contract) => accountIdEqual(getENSv1Registry(namespace), contract);
+var getENSv2RootRegistry = (namespace) => getDatasourceContract(namespace, import_datasources12.DatasourceNames.ENSv2Root, "RootRegistry");
+var getENSv2RootRegistryId = (namespace) => makeRegistryId(getENSv2RootRegistry(namespace));
+var isENSv2RootRegistry = (namespace, contract) => accountIdEqual(getENSv2RootRegistry(namespace), contract);
 
-// src/resolution/resolver-records-selection.ts
-var isSelectionEmpty = (selection) => !selection.name && !selection.addresses?.length && !selection.texts?.length;
+// 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";