@ensnode/ensnode-sdk 0.34.0 → 0.36.0

package/dist/index.js

@@ -4,11 +4,12 @@ var ROOT_NODE = namehash("");
 var ETH_NODE = namehash("eth");
 var BASENAMES_NODE = namehash("base.eth");
 var LINEANAMES_NODE = namehash("linea.eth");
-var REVERSE_ROOT_NODES = /* @__PURE__ */ new Set([namehash("addr.reverse")]);
+var ADDR_REVERSE_NODE = namehash("addr.reverse");
 
 // src/ens/subname-helpers.ts
-import { concat, isAddress, isHash, keccak256, toHex } from "viem";
-import { labelhash } from "viem/ens";
+import { concat, keccak256, toHex } from "viem";
+var makeSubdomainNode = (labelHash, node) => keccak256(concat([node, labelHash]));
+var uint256ToHex32 = (num) => toHex(num, { size: 32 });
 
 // src/ens/coin-type.ts
 import {
@@ -33,8 +34,43 @@ var bigintToCoinType = (value) => {
   return Number(value);
 };
 
+// src/ens/names.ts
+import { ens_beautify } from "@adraffy/ens-normalize";
+
+// src/ens/is-normalized.ts
+import { normalize } from "viem/ens";
+function isNormalizedName(name) {
+  try {
+    return name === normalize(name);
+  } catch {
+    return false;
+  }
+}
+function isNormalizedLabel(label) {
+  if (label === "") return false;
+  if (label.includes(".")) return false;
+  try {
+    return label === normalize(label);
+  } catch {
+    return false;
+  }
+}
+
+// src/ens/names.ts
+var getNameHierarchy = (name) => name.split(".").map((_, i, labels) => labels.slice(i).join("."));
+var beautifyName = (name) => {
+  const beautifiedLabels = name.split(".").map((label) => {
+    if (isNormalizedLabel(label)) {
+      return ens_beautify(label);
+    } else {
+      return label;
+    }
+  });
+  return beautifiedLabels.join(".");
+};
+
 // src/ens/reverse-name.ts
-var addrReverseLabel = (address) => address.slice(2).toLowerCase();
+var addrReverseLabel = (address) => address.slice(2);
 var coinTypeReverseLabel = (coinType) => coinType.toString(16);
 function reverseName(address, coinType) {
   const label = addrReverseLabel(address);
@@ -51,84 +87,16 @@ function reverseName(address, coinType) {
   return `${label}.${middle}.reverse`;
 }
 
-// src/ens/subname-helpers.ts
-var makeSubdomainNode = (labelHash, node) => keccak256(concat([node, labelHash]));
-var maybeHealLabelByReverseAddress = ({
-  maybeReverseAddress,
-  labelHash
-}) => {
-  if (!isAddress(maybeReverseAddress)) {
-    throw new Error(
-      `Invalid reverse address: '${maybeReverseAddress}'. Must be a valid EVM Address.`
-    );
-  }
-  if (!isHash(labelHash)) {
-    throw new Error(
-      `Invalid labelHash: '${labelHash}'. Must start with '0x' and represent 32 bytes.`
-    );
-  }
-  const assumedLabel = addrReverseLabel(maybeReverseAddress);
-  if (labelhash(assumedLabel) === labelHash) return assumedLabel;
-  return null;
-};
-var uint256ToHex32 = (num) => toHex(num, { size: 32 });
-var UNINDEXABLE_LABEL_CHARACTERS = [
-  "\0",
-  // null byte: PostgreSQL does not allow storing this character in text fields.
-  ".",
-  // conflicts with ENS label separator logic.
-  "[",
-  // conflicts with "unknown label" representations.
-  "]"
-  // conflicts with "unknown label" representations.
-];
-var UNINDEXABLE_LABEL_CHARACTER_CODES = new Set(
-  UNINDEXABLE_LABEL_CHARACTERS.map((char) => char.charCodeAt(0))
-);
-var isLabelIndexable = (label) => {
-  if (!label) return false;
-  for (let i = 0; i < label.length; i++) {
-    if (UNINDEXABLE_LABEL_CHARACTER_CODES.has(label.charCodeAt(i))) return false;
-  }
-  return true;
-};
-
-// src/ens/names.ts
-var getNameHierarchy = (name) => name.split(".").map((_, i, labels) => labels.slice(i).join("."));
-
 // src/ens/types.ts
 import { ENSNamespaceIds } from "@ensnode/datasources";
 
 // src/ens/parse-reverse-name.ts
-import { getAddress, hexToBigInt } from "viem";
-var REVERSE_NAME_REGEX = /^([0-9a-fA-F]+)\.([0-9a-f]{1,64}|addr|default)\.reverse$/;
-var parseAddressLabel = (addressLabel) => getAddress(`0x${addressLabel}`);
-var parseCoinTypeLabel = (coinTypeLabel) => {
-  if (coinTypeLabel === "default") return DEFAULT_EVM_COIN_TYPE;
-  if (coinTypeLabel === "addr") return ETH_COIN_TYPE;
-  return bigintToCoinType(hexToBigInt(`0x${coinTypeLabel}`));
-};
-function parseReverseName(name) {
-  const match = name.match(REVERSE_NAME_REGEX);
-  if (!match) return null;
-  try {
-    const [, addressLabel, coinTypeLabel] = match;
-    if (!addressLabel) return null;
-    if (!coinTypeLabel) return null;
-    return {
-      address: parseAddressLabel(addressLabel),
-      coinType: parseCoinTypeLabel(coinTypeLabel)
-    };
-  } catch {
-    return null;
-  }
-}
-
-// src/ensindexer/config/deserialize.ts
-import { prettifyError as prettifyError2 } from "zod/v4";
+import { hexToBigInt, isAddress as isAddress2 } from "viem";
 
-// src/ensindexer/config/zod-schemas.ts
-import z2 from "zod/v4";
+// src/shared/address.ts
+function asLowerCaseAddress(address) {
+  return address.toLowerCase();
+}
 
 // src/shared/cache.ts
 var LruCache = class {
@@ -197,6 +165,7 @@ function serializeUrl(url) {
 import { prettifyError } from "zod/v4";
 
 // src/shared/zod-schemas.ts
+import { isAddress } from "viem";
 import z from "zod/v4";
 var makeIntegerSchema = (valueLabel = "Value") => z.int({
   error: `${valueLabel} must be an integer.`
@@ -210,7 +179,7 @@ var makeNonNegativeIntegerSchema = (valueLabel = "Value") => makeIntegerSchema(v
 var makeDurationSchema = (valueLabel = "Value") => z.coerce.number({
   error: `${valueLabel} must be a number.`
 }).pipe(makeNonNegativeIntegerSchema(valueLabel));
-var makeChainIdSchema = (valueLabel = "Chain ID") => makePositiveIntegerSchema(valueLabel);
+var makeChainIdSchema = (valueLabel = "Chain ID") => makePositiveIntegerSchema(valueLabel).transform((val) => val);
 var makeChainIdStringSchema = (valueLabel = "Chain ID String") => z.string({ error: `${valueLabel} must be a string representing a chain ID.` }).pipe(z.coerce.number({ error: `${valueLabel} must represent a positive integer (>0).` })).pipe(makeChainIdSchema(`The numeric value represented by ${valueLabel}`));
 var makeDatetimeSchema = (valueLabel = "Datetime string") => z.iso.datetime({ error: `${valueLabel} must be a string in ISO 8601 format.` }).transform((v) => new Date(v));
 var makeUnixTimestampSchema = (valueLabel = "Timestamp") => makeIntegerSchema(valueLabel);
@@ -271,6 +240,16 @@ ${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:
+${prettifyError(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
 function deserializeUrl(maybeUrl, valueLabel) {
   const schema = makeUrlSchema(valueLabel);
   const parsed = schema.safeParse(maybeUrl);
@@ -322,29 +301,121 @@ ${prettifyError(parsed.error)}
   return parsed.data;
 }
 
-// src/shared/is-normalized.ts
-import { normalize } from "viem/ens";
-function isNormalized(name) {
-  try {
-    return name === normalize(name);
-  } catch {
-    return false;
-  }
-}
-
 // src/shared/account-id.ts
 import { isAddressEqual } from "viem";
 var accountIdEqual = (a, b) => {
   return a.chainId === b.chainId && isAddressEqual(a.address, b.address);
 };
 
+// src/shared/labelhash.ts
+import { keccak256 as keccak2562, stringToBytes } from "viem";
+var labelhashLiteralLabel = (label) => keccak2562(stringToBytes(label));
+
+// src/shared/interpretation.ts
+function literalLabelToInterpretedLabel(label) {
+  if (isNormalizedLabel(label)) return label;
+  return encodeLabelHash(labelhashLiteralLabel(label));
+}
+function literalLabelsToInterpretedName(labels) {
+  return labels.map(literalLabelToInterpretedLabel).join(".");
+}
+function interpretedLabelsToInterpretedName(labels) {
+  return labels.join(".");
+}
+function literalLabelsToLiteralName(labels) {
+  return labels.join(".");
+}
+
+// src/shared/url.ts
+function isHttpProtocol(url) {
+  return ["http:", "https:"].includes(url.protocol);
+}
+function isWebSocketProtocol(url) {
+  return ["ws:", "wss:"].includes(url.protocol);
+}
+
+// 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 (!isAddress2(maybeAddress)) {
+    throw new Error(`Invalid EVM address "${maybeAddress}"`);
+  }
+  return asLowerCaseAddress(maybeAddress);
+};
+var parseCoinTypeLabel = (coinTypeLabel) => {
+  if (coinTypeLabel === "default") return DEFAULT_EVM_COIN_TYPE;
+  if (coinTypeLabel === "addr") return ETH_COIN_TYPE;
+  return bigintToCoinType(hexToBigInt(`0x${coinTypeLabel}`));
+};
+function parseReverseName(name) {
+  const match = name.match(REVERSE_NAME_REGEX);
+  if (!match) return null;
+  try {
+    const [, addressLabel, coinTypeLabel] = match;
+    if (!addressLabel) return null;
+    if (!coinTypeLabel) return null;
+    return {
+      address: parseAddressLabel(addressLabel),
+      coinType: parseCoinTypeLabel(coinTypeLabel)
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/ens/encode-labelhash.ts
+var encodeLabelHash = (labelHash) => `[${labelHash.slice(2)}]`;
+
+// src/ens/dns-encoded-name.ts
+import { bytesToString, hexToBytes } from "viem";
+function decodeDNSEncodedLiteralName(packet) {
+  return decodeDNSEncodedName(packet);
+}
+function decodeDNSEncodedName(packet) {
+  const segments = [];
+  const bytes = hexToBytes(packet);
+  if (bytes.length === 0) throw new Error(`Packet is empty.`);
+  let offset = 0;
+  while (offset < bytes.length) {
+    const len = bytes[offset];
+    if (len === void 0) {
+      throw new Error(`Invariant: bytes[offset] is undefined after offset < bytes.length check.`);
+    }
+    if (len < 0 || len > 255) {
+      throw new Error(
+        `Invariant: this should be literally impossible, but an unsigned byte was less than zero or greater than 255. The value in question is ${len}`
+      );
+    }
+    if (len === 0) break;
+    const segment = bytesToString(bytes.subarray(offset + 1, offset + len + 1));
+    segments.push(segment);
+    offset += len + 1;
+  }
+  if (offset >= bytes.length) throw new Error(`Overflow, offset >= bytes.length`);
+  if (offset !== bytes.length - 1) throw new Error(`Junk at end of name`);
+  return segments;
+}
+
+// src/ens/index.ts
+import { getENSRootChainId } from "@ensnode/datasources";
+
+// src/ensindexer/config/deserialize.ts
+import { prettifyError as prettifyError2 } from "zod/v4";
+
+// src/ensindexer/config/zod-schemas.ts
+import z2 from "zod/v4";
+
+// src/ensindexer/config/helpers.ts
+import { ENSNamespaceIds as ENSNamespaceIds2 } from "@ensnode/datasources";
+
 // src/ensindexer/config/types.ts
 var PluginName = /* @__PURE__ */ ((PluginName2) => {
   PluginName2["Subgraph"] = "subgraph";
   PluginName2["Basenames"] = "basenames";
   PluginName2["Lineanames"] = "lineanames";
   PluginName2["ThreeDNS"] = "threedns";
-  PluginName2["ReverseResolvers"] = "reverse-resolvers";
+  PluginName2["ProtocolAcceleration"] = "protocol-acceleration";
   PluginName2["Referrals"] = "referrals";
   PluginName2["TokenScope"] = "tokenscope";
   return PluginName2;
@@ -353,25 +424,32 @@ var PluginName = /* @__PURE__ */ ((PluginName2) => {
 // src/ensindexer/config/helpers.ts
 function isSubgraphCompatible(config) {
   const onlySubgraphPluginActivated = config.plugins.length === 1 && config.plugins[0] === "subgraph" /* Subgraph */;
-  const indexingBehaviorIsSubgraphCompatible = !config.healReverseAddresses && !config.indexAdditionalResolverRecords;
-  const labelSetIsSubgraphCompatible = config.labelSet.labelSetId === "subgraph" && config.labelSet.labelSetVersion === 0;
-  return onlySubgraphPluginActivated && indexingBehaviorIsSubgraphCompatible && labelSetIsSubgraphCompatible;
+  const isSubgraphLabelSet = config.labelSet.labelSetId === "subgraph" && config.labelSet.labelSetVersion === 0;
+  const isEnsTestEnvLabelSet = config.labelSet.labelSetId === "ens-test-env" && config.labelSet.labelSetVersion === 0;
+  const labelSetIsSubgraphCompatible = isSubgraphLabelSet || config.namespace === ENSNamespaceIds2.EnsTestEnv && isEnsTestEnvLabelSet;
+  return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
+}
+
+// src/ensindexer/config/validations.ts
+function invariant_ensDbVersionIsSameAsEnsIndexerVersion(ctx) {
+  const versionInfo = ctx.value;
+  if (versionInfo.ensDb !== versionInfo.ensIndexer) {
+    ctx.issues.push({
+      code: "custom",
+      input: versionInfo,
+      message: "`ensDb` version must be same as `ensIndexer` version"
+    });
+  }
 }
 
 // src/ensindexer/config/zod-schemas.ts
 var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => z2.array(makeChainIdSchema(valueLabel), {
   error: `${valueLabel} must be an array.`
 }).min(1, { error: `${valueLabel} list must include at least one element.` }).transform((v) => new Set(v));
-var makePluginsListSchema = (valueLabel = "Plugins") => z2.array(
-  z2.enum(PluginName, {
-    error: `${valueLabel} must be a list with at least one valid plugin name. Valid plugins are: ${Object.values(
-      PluginName
-    ).join(", ")}`
-  })
-).min(1, {
-  error: `${valueLabel} must be a list with at least one valid plugin name. Valid plugins are: ${Object.values(
-    PluginName
-  ).join(", ")}`
+var makePluginsListSchema = (valueLabel = "Plugins") => z2.array(z2.string(), {
+  error: `${valueLabel} must be a list of strings.`
+}).min(1, {
+  error: `${valueLabel} must be a list of strings with at least one string value`
 }).refine((arr) => arr.length === uniq(arr).length, {
   error: `${valueLabel} cannot contain duplicate values.`
 });
@@ -402,54 +480,39 @@ var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
   });
 };
 var makeNonEmptyStringSchema = (valueLabel = "Value") => z2.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
-var makeDependencyInfoSchema = (valueLabel = "Value") => z2.strictObject(
+var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => z2.strictObject(
   {
     nodejs: makeNonEmptyStringSchema(),
     ponder: makeNonEmptyStringSchema(),
+    ensDb: makeNonEmptyStringSchema(),
+    ensIndexer: makeNonEmptyStringSchema(),
+    ensNormalize: makeNonEmptyStringSchema(),
     ensRainbow: makeNonEmptyStringSchema(),
     ensRainbowSchema: makePositiveIntegerSchema()
   },
   {
-    error: `${valueLabel} must be a valid DependencyInfo object.`
+    error: `${valueLabel} must be a valid ENSIndexerVersionInfo object.`
   }
-);
-function invariant_reverseResolversPluginNeedsResolverRecords(ctx) {
-  const { value: config } = ctx;
-  const reverseResolversPluginActive = config.plugins.includes("reverse-resolvers" /* ReverseResolvers */);
-  if (reverseResolversPluginActive && !config.indexAdditionalResolverRecords) {
-    ctx.issues.push({
-      code: "custom",
-      input: config,
-      message: `The '${"reverse-resolvers" /* ReverseResolvers */}' plugin requires 'indexAdditionalResolverRecords' to be 'true'.`
-    });
-  }
-}
+).check(invariant_ensDbVersionIsSameAsEnsIndexerVersion);
 function invariant_isSubgraphCompatibleRequirements(ctx) {
   const { value: config } = ctx;
-  if (config.isSubgraphCompatible !== isSubgraphCompatible(config)) {
-    const message = config.isSubgraphCompatible ? `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active, both 'indexAdditionalResolverRecords' and 'healReverseAddresses' must be set to 'false', and labelSet must be {labelSetId: "subgraph", labelSetVersion: 0}` : `Both 'indexAdditionalResolverRecords' and 'healReverseAddresses' were set to 'false', the only active plugin was the '${"subgraph" /* Subgraph */}' plugin, and labelSet was {labelSetId: "subgraph", labelSetVersion: 0}. The 'isSubgraphCompatible' must be set to 'true'`;
+  if (config.isSubgraphCompatible && !isSubgraphCompatible(config)) {
     ctx.issues.push({
       code: "custom",
       input: config,
-      message
+      message: `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active and labelSet must be {labelSetId: "subgraph", labelSetVersion: 0}`
     });
   }
 }
 var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => z2.object({
-  ensAdminUrl: makeUrlSchema(`${valueLabel}.ensAdminUrl`),
-  ensNodePublicUrl: makeUrlSchema(`${valueLabel}.ensNodePublicUrl`),
   labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
-  healReverseAddresses: z2.boolean({ error: `${valueLabel}.healReverseAddresses` }),
-  indexAdditionalResolverRecords: z2.boolean({
-    error: `${valueLabel}.indexAdditionalResolverRecords`
-  }),
   indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
   isSubgraphCompatible: z2.boolean({ error: `${valueLabel}.isSubgraphCompatible` }),
   namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
   plugins: makePluginsListSchema(`${valueLabel}.plugins`),
   databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
-  dependencyInfo: makeDependencyInfoSchema(`${valueLabel}.dependencyInfo`)
-}).check(invariant_reverseResolversPluginNeedsResolverRecords).check(invariant_isSubgraphCompatibleRequirements);
+  versionInfo: makeENSIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
+}).check(invariant_isSubgraphCompatibleRequirements);
 
 // src/ensindexer/config/deserialize.ts
 function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
@@ -469,30 +532,22 @@ function serializeIndexedChainIds(indexedChainIds) {
 }
 function serializeENSIndexerPublicConfig(config) {
   const {
-    ensAdminUrl,
-    ensNodePublicUrl,
     labelSet,
     indexedChainIds,
     databaseSchemaName,
-    healReverseAddresses,
-    indexAdditionalResolverRecords,
     isSubgraphCompatible: isSubgraphCompatible2,
     namespace,
     plugins,
-    dependencyInfo
+    versionInfo
   } = config;
   return {
-    ensAdminUrl: serializeUrl(ensAdminUrl),
-    ensNodePublicUrl: serializeUrl(ensNodePublicUrl),
     labelSet,
     indexedChainIds: serializeIndexedChainIds(indexedChainIds),
     databaseSchemaName,
-    healReverseAddresses,
-    indexAdditionalResolverRecords,
     isSubgraphCompatible: isSubgraphCompatible2,
     namespace,
     plugins,
-    dependencyInfo
+    versionInfo
   };
 }
 
@@ -526,7 +581,7 @@ function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
 }
 
 // src/ensindexer/config/label-utils.ts
-import { hexToBytes } from "viem";
+import { hexToBytes as hexToBytes2 } from "viem";
 function labelHashToBytes(labelHash) {
   try {
     if (labelHash.length !== 66) {
@@ -538,7 +593,7 @@ function labelHashToBytes(labelHash) {
     if (!labelHash.startsWith("0x")) {
       throw new Error("Labelhash must be 0x-prefixed");
     }
-    const bytes = hexToBytes(labelHash);
+    const bytes = hexToBytes2(labelHash);
     if (bytes.length !== 32) {
       throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
     }
@@ -582,6 +637,92 @@ import { prettifyError as prettifyError3 } from "zod/v4";
 // src/ensindexer/indexing-status/zod-schemas.ts
 import z3 from "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;
@@ -593,49 +734,21 @@ function isBeforeOrEqualTo(blockA, blockB) {
   return isBefore(blockA, blockB) || isEqualTo(blockA, blockB);
 }
 
-// src/ensindexer/indexing-status/types.ts
-var ChainIndexingStatusIds = {
-  Unstarted: "unstarted",
-  Backfill: "backfill",
-  Following: "following",
-  Completed: "completed"
-};
-var OverallIndexingStatusIds = {
-  Unstarted: "unstarted",
-  Backfill: "backfill",
-  Following: "following",
-  Completed: "completed",
-  IndexerError: "indexer-error"
-};
-var ChainIndexingStrategyIds = {
-  Indefinite: "indefinite",
-  Definite: "definite"
-};
-
 // src/ensindexer/indexing-status/helpers.ts
-function getOverallIndexingStatus(chains) {
-  const chainStatuses = chains.map((chain) => chain.status);
-  let overallStatus;
-  if (chainStatuses.some((chainStatus) => chainStatus === ChainIndexingStatusIds.Following)) {
-    overallStatus = OverallIndexingStatusIds.Following;
-  } else if (chainStatuses.some((chainStatus) => chainStatus === ChainIndexingStatusIds.Backfill)) {
-    overallStatus = OverallIndexingStatusIds.Backfill;
-  } else if (chainStatuses.some((chainStatus) => chainStatus === ChainIndexingStatusIds.Unstarted)) {
-    overallStatus = OverallIndexingStatusIds.Unstarted;
-  } else {
-    overallStatus = OverallIndexingStatusIds.Completed;
+function getOmnichainIndexingStatus(chains) {
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains)) {
+    return OmnichainIndexingStatusIds.Following;
   }
-  return overallStatus;
-}
-function getOverallApproxRealtimeDistance(chains) {
-  const chainApproxRealtimeDistances = chains.filter((chain) => chain.status === ChainIndexingStatusIds.Following).map((chain) => chain.approxRealtimeDistance);
-  if (chainApproxRealtimeDistances.length === 0) {
-    throw new Error(
-      `The overall approximate realtime distance value is undefined if no indexed chain is in the '${OverallIndexingStatusIds.Following}' status`
-    );
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains)) {
+    return OmnichainIndexingStatusIds.Backfill;
+  }
+  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains)) {
+    return OmnichainIndexingStatusIds.Unstarted;
   }
-  const approxRealtimeDistance = Math.max(...chainApproxRealtimeDistances);
-  return approxRealtimeDistance;
+  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(
@@ -646,8 +759,8 @@ function getTimestampForLowestOmnichainStartBlock(chains) {
 function getTimestampForHighestOmnichainKnownBlock(chains) {
   const latestKnownBlockTimestamps = [];
   for (const chain of chains) {
-    switch (chain.status) {
-      case ChainIndexingStatusIds.Unstarted:
+    switch (chain.chainStatus) {
+      case ChainIndexingStatusIds.Queued:
         if (chain.config.endBlock) {
           latestKnownBlockTimestamps.push(chain.config.endBlock.timestamp);
         }
@@ -666,159 +779,349 @@ function getTimestampForHighestOmnichainKnownBlock(chains) {
   return Math.max(...latestKnownBlockTimestamps);
 }
 function getOmnichainIndexingCursor(chains) {
-  return Math.min(...chains.map((chain) => chain.latestIndexedBlock.timestamp));
-}
-function getActiveChains(chains) {
-  return chains.filter(
-    (chain) => chain.status === ChainIndexingStatusIds.Backfill || chain.status === ChainIndexingStatusIds.Following
-  );
-}
-function getStandbyChains(chains) {
-  return chains.filter(
-    (chain) => chain.status === ChainIndexingStatusIds.Unstarted || chain.status === ChainIndexingStatusIds.Completed
-  );
+  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 {
-      strategy: ChainIndexingStrategyIds.Definite,
+      configType: ChainIndexingConfigTypeIds.Definite,
       startBlock,
       endBlock
     };
   }
   return {
-    strategy: ChainIndexingStrategyIds.Indefinite,
-    startBlock,
-    endBlock: null
+    configType: ChainIndexingConfigTypeIds.Indefinite,
+    startBlock
   };
 }
-function checkChainIndexingStatusesForUnstartedOverallStatus(chains) {
-  return chains.every((chain) => chain.status === ChainIndexingStatusIds.Unstarted);
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains) {
+  return chains.every((chain) => chain.chainStatus === ChainIndexingStatusIds.Queued);
 }
-function checkChainIndexingStatusesForBackfillOverallStatus(chains) {
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains) {
   const atLeastOneChainInTargetStatus = chains.some(
-    (chain) => chain.status === ChainIndexingStatusIds.Backfill
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
   );
   const otherChainsHaveValidStatuses = chains.every(
-    (chain) => chain.status === ChainIndexingStatusIds.Unstarted || chain.status === ChainIndexingStatusIds.Backfill || chain.status === ChainIndexingStatusIds.Completed
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued || chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed
   );
   return atLeastOneChainInTargetStatus && otherChainsHaveValidStatuses;
 }
-function checkChainIndexingStatusesForCompletedOverallStatus(chains) {
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains) {
   const allChainsHaveValidStatuses = chains.every(
-    (chain) => chain.status === ChainIndexingStatusIds.Completed
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Completed
   );
   return allChainsHaveValidStatuses;
 }
-function checkChainIndexingStatusesForFollowingOverallStatus(chains) {
+function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains) {
   const allChainsHaveValidStatuses = chains.some(
-    (chain) => chain.status === ChainIndexingStatusIds.Following
+    (chain) => chain.chainStatus === ChainIndexingStatusIds.Following
   );
   return allChainsHaveValidStatuses;
 }
-function sortAscChainStatusesByStartBlock(chains) {
+function sortChainStatusesByStartBlockAsc(chains) {
   chains.sort(
     ([, chainA], [, chainB]) => chainA.config.startBlock.timestamp - chainB.config.startBlock.timestamp
   );
   return chains;
 }
 
+// src/ensindexer/indexing-status/validations.ts
+function invariant_chainSnapshotQueuedBlocks(ctx) {
+  const { config } = ctx.value;
+  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.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.filter((chain) => chain.config.configType === ChainIndexingConfigTypeIds.Definite).map((chain) => chain.config.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' 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") => z3.discriminatedUnion("strategy", [
+var makeChainIndexingConfigSchema = (valueLabel = "Value") => z3.discriminatedUnion("configType", [
   z3.strictObject({
-    strategy: z3.literal(ChainIndexingStrategyIds.Indefinite),
-    startBlock: makeBlockRefSchema(valueLabel),
-    endBlock: z3.null()
+    configType: z3.literal(ChainIndexingConfigTypeIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel)
   }),
   z3.strictObject({
-    strategy: z3.literal(ChainIndexingStrategyIds.Definite),
+    configType: z3.literal(ChainIndexingConfigTypeIds.Definite),
     startBlock: makeBlockRefSchema(valueLabel),
     endBlock: makeBlockRefSchema(valueLabel)
   })
 ]);
-var makeChainIndexingUnstartedStatusSchema = (valueLabel = "Value") => z3.strictObject({
-  status: z3.literal(ChainIndexingStatusIds.Unstarted),
+var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => z3.strictObject({
+  chainStatus: z3.literal(ChainIndexingStatusIds.Queued),
   config: makeChainIndexingConfigSchema(valueLabel)
-}).refine(
-  ({ config }) => config.endBlock === null || isBeforeOrEqualTo(config.startBlock, config.endBlock),
-  {
-    error: `config.startBlock must be before or same as config.endBlock.`
-  }
-);
-var makeChainIndexingBackfillStatusSchema = (valueLabel = "Value") => z3.strictObject({
-  status: z3.literal(ChainIndexingStatusIds.Backfill),
+}).check(invariant_chainSnapshotQueuedBlocks);
+var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => z3.strictObject({
+  chainStatus: z3.literal(ChainIndexingStatusIds.Backfill),
   config: makeChainIndexingConfigSchema(valueLabel),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
-  latestSyncedBlock: makeBlockRefSchema(valueLabel),
   backfillEndBlock: makeBlockRefSchema(valueLabel)
-}).refine(
-  ({ config, latestIndexedBlock }) => isBeforeOrEqualTo(config.startBlock, latestIndexedBlock),
-  {
-    error: `config.startBlock must be before or same as latestIndexedBlock.`
-  }
-).refine(
-  ({ latestIndexedBlock, latestSyncedBlock }) => isBeforeOrEqualTo(latestIndexedBlock, latestSyncedBlock),
-  {
-    error: `latestIndexedBlock must be before or same as latestSyncedBlock.`
-  }
-).refine(
-  ({ latestSyncedBlock, backfillEndBlock }) => isBeforeOrEqualTo(latestSyncedBlock, backfillEndBlock),
-  {
-    error: `latestSyncedBlock must be before or same as backfillEndBlock.`
-  }
-).refine(
-  ({ config, backfillEndBlock }) => config.endBlock === null || isEqualTo(backfillEndBlock, config.endBlock),
-  {
-    error: `backfillEndBlock must be the same as config.endBlock.`
-  }
-);
-var makeChainIndexingFollowingStatusSchema = (valueLabel = "Value") => z3.strictObject({
-  status: z3.literal(ChainIndexingStatusIds.Following),
+}).check(invariant_chainSnapshotBackfillBlocks);
+var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => z3.strictObject({
+  chainStatus: z3.literal(ChainIndexingStatusIds.Completed),
   config: z3.strictObject({
-    strategy: z3.literal(ChainIndexingStrategyIds.Indefinite),
-    startBlock: makeBlockRefSchema(valueLabel)
-  }),
-  latestIndexedBlock: makeBlockRefSchema(valueLabel),
-  latestKnownBlock: makeBlockRefSchema(valueLabel),
-  approxRealtimeDistance: makeDurationSchema(valueLabel)
-}).refine(
-  ({ config, latestIndexedBlock }) => isBeforeOrEqualTo(config.startBlock, latestIndexedBlock),
-  {
-    error: `config.startBlock must be before or same as latestIndexedBlock.`
-  }
-).refine(
-  ({ latestIndexedBlock, latestKnownBlock }) => isBeforeOrEqualTo(latestIndexedBlock, latestKnownBlock),
-  {
-    error: `latestIndexedBlock must be before or same as latestKnownBlock.`
-  }
-);
-var makeChainIndexingCompletedStatusSchema = (valueLabel = "Value") => z3.strictObject({
-  status: z3.literal(ChainIndexingStatusIds.Completed),
-  config: z3.strictObject({
-    strategy: z3.literal(ChainIndexingStrategyIds.Definite),
+    configType: z3.literal(ChainIndexingConfigTypeIds.Definite),
     startBlock: makeBlockRefSchema(valueLabel),
     endBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel)
-}).refine(
-  ({ config, latestIndexedBlock }) => isBeforeOrEqualTo(config.startBlock, latestIndexedBlock),
-  {
-    error: `config.startBlock must be before or same as latestIndexedBlock.`
-  }
-).refine(
-  ({ config, latestIndexedBlock }) => isBeforeOrEqualTo(latestIndexedBlock, config.endBlock),
-  {
-    error: `latestIndexedBlock must be before or same as config.endBlock.`
-  }
-);
-var makeChainIndexingStatusSchema = (valueLabel = "Value") => z3.discriminatedUnion("status", [
-  makeChainIndexingUnstartedStatusSchema(valueLabel),
-  makeChainIndexingBackfillStatusSchema(valueLabel),
-  makeChainIndexingFollowingStatusSchema(valueLabel),
-  makeChainIndexingCompletedStatusSchema(valueLabel)
+}).check(invariant_chainSnapshotCompletedBlocks);
+var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => z3.strictObject({
+  chainStatus: z3.literal(ChainIndexingStatusIds.Following),
+  config: z3.strictObject({
+    configType: z3.literal(ChainIndexingConfigTypeIds.Indefinite),
+    startBlock: makeBlockRefSchema(valueLabel)
+  }),
+  latestIndexedBlock: makeBlockRefSchema(valueLabel),
+  latestKnownBlock: makeBlockRefSchema(valueLabel)
+}).check(invariant_chainSnapshotFollowingBlocks);
+var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => z3.discriminatedUnion("chainStatus", [
+  makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
+  makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
+  makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
+  makeChainIndexingStatusSnapshotFollowingSchema(valueLabel)
 ]);
-var makeChainIndexingStatusesSchema = (valueLabel = "Value") => z3.record(makeChainIdStringSchema(), makeChainIndexingStatusSchema(valueLabel), {
-  error: "Chains configuration must be an object mapping valid chain IDs to their configs."
+var makeChainIndexingStatusesSchema = (valueLabel = "Value") => z3.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)) {
@@ -826,164 +1129,164 @@ var makeChainIndexingStatusesSchema = (valueLabel = "Value") => z3.record(makeCh
   }
   return chainsIndexingStatus;
 });
-var makeUnstartedOverallStatusSchema = (valueLabel) => z3.strictObject({
-  overallStatus: z3.literal(OverallIndexingStatusIds.Unstarted),
-  chains: makeChainIndexingStatusesSchema(valueLabel).refine(
-    (chains) => checkChainIndexingStatusesForUnstartedOverallStatus(Array.from(chains.values())),
-    {
-      error: `${valueLabel} at least one chain must be in "unstarted" status and
-each chain has to have a status of either "unstarted", or "completed"`
-    }
-  ).transform((chains) => chains)
-}).refine(
-  (indexingStatus) => {
-    const chains = Array.from(indexingStatus.chains.values());
-    return getOverallIndexingStatus(chains) === indexingStatus.overallStatus;
-  },
-  { error: `${valueLabel} is an invalid overallStatus.` }
-);
-var makeBackfillOverallStatusSchema = (valueLabel) => z3.strictObject({
-  overallStatus: z3.literal(OverallIndexingStatusIds.Backfill),
-  chains: makeChainIndexingStatusesSchema(valueLabel).refine(
-    (chains) => checkChainIndexingStatusesForBackfillOverallStatus(Array.from(chains.values())),
-    {
-      error: `${valueLabel} at least one chain must be in "backfill" status and
-each chain has to have a status of either "unstarted", "backfill" or "completed"`
-    }
-  ).transform((chains) => chains),
+var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => z3.strictObject({
+  omnichainStatus: z3.literal(OmnichainIndexingStatusIds.Unstarted),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainSnapshotUnstartedHasValidChains).transform((chains) => chains),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
-}).refine(
-  (indexingStatus) => {
-    const chains = Array.from(indexingStatus.chains.values());
-    return getOverallIndexingStatus(chains) === indexingStatus.overallStatus;
-  },
-  { error: `${valueLabel} is an invalid overallStatus.` }
-).refine(
-  (indexingStatus) => {
-    const chains = Array.from(indexingStatus.chains.values());
-    const standbyChainStartBlocks = getStandbyChains(chains).map(
-      (chain) => chain.config.startBlock.timestamp
-    );
-    const standbyChainEarliestStartBlocks = Math.min(...standbyChainStartBlocks);
-    return indexingStatus.omnichainIndexingCursor <= standbyChainEarliestStartBlocks;
-  },
-  {
-    error: "omnichainIndexingCursor must be lower than or equal to the earliest config.startBlock across all standby chains"
-  }
-);
-var makeCompletedOverallStatusSchema = (valueLabel) => z3.strictObject({
-  overallStatus: z3.literal(OverallIndexingStatusIds.Completed),
-  chains: makeChainIndexingStatusesSchema(valueLabel).refine(
-    (chains) => checkChainIndexingStatusesForCompletedOverallStatus(Array.from(chains.values())),
-    {
-      error: `${valueLabel} all chains must have "completed" status`
-    }
-  ).transform((chains) => chains)
-}).refine(
-  (indexingStatus) => {
-    const chains = Array.from(indexingStatus.chains.values());
-    return getOverallIndexingStatus(chains) === indexingStatus.overallStatus;
-  },
-  { error: `${valueLabel} is an invalid overallStatus.` }
-);
-var makeFollowingOverallStatusSchema = (valueLabel) => z3.strictObject({
-  overallStatus: z3.literal(OverallIndexingStatusIds.Following),
+});
+var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => z3.strictObject({
+  omnichainStatus: z3.literal(OmnichainIndexingStatusIds.Backfill),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotBackfillHasValidChains).transform(
+    (chains) => chains
+  ),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => z3.strictObject({
+  omnichainStatus: z3.literal(OmnichainIndexingStatusIds.Completed),
+  chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotCompletedHasValidChains).transform((chains) => chains),
+  omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
+});
+var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => z3.strictObject({
+  omnichainStatus: z3.literal(OmnichainIndexingStatusIds.Following),
   chains: makeChainIndexingStatusesSchema(valueLabel),
-  overallApproxRealtimeDistance: makeDurationSchema(valueLabel),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
-}).refine(
-  (indexingStatus) => {
-    const chains = Array.from(indexingStatus.chains.values());
-    return getOverallIndexingStatus(chains) === indexingStatus.overallStatus;
-  },
-  { error: `${valueLabel} is an invalid overallStatus.` }
-).refine(
-  (indexingStatus) => checkChainIndexingStatusesForFollowingOverallStatus(
-    Array.from(indexingStatus.chains.values())
-  ),
-  {
-    error: `${valueLabel} at least one chain must be in "following" status`
-  }
-).refine(
-  (indexingStatus) => {
-    const chains = Array.from(indexingStatus.chains.values());
-    return getOverallApproxRealtimeDistance(chains) === indexingStatus.overallApproxRealtimeDistance;
-  },
-  { error: `${valueLabel} is an invalid overallApproxRealtimeDistance.` }
-).refine(
-  (indexingStatus) => {
-    const chains = Array.from(indexingStatus.chains.values());
-    const standbyChainStartBlocks = getStandbyChains(chains).map(
-      (chain) => chain.config.startBlock.timestamp
-    );
-    const standbyChainEarliestStartBlocks = Math.min(...standbyChainStartBlocks);
-    return indexingStatus.omnichainIndexingCursor <= standbyChainEarliestStartBlocks;
-  },
-  {
-    error: "omnichainIndexingCursor must be lower than or equal to the earliest config.startBlock across all standby chains"
-  }
-);
-var makeErrorSchemaOverallStatusSchema = (valueLabel) => z3.strictObject({
-  overallStatus: z3.literal(OverallIndexingStatusIds.IndexerError)
 });
-var makeENSIndexerIndexingStatusSchema = (valueLabel = "ENSIndexerIndexingStatus") => z3.discriminatedUnion("overallStatus", [
-  makeUnstartedOverallStatusSchema(valueLabel),
-  makeBackfillOverallStatusSchema(valueLabel),
-  makeCompletedOverallStatusSchema(valueLabel),
-  makeFollowingOverallStatusSchema(valueLabel),
-  makeErrorSchemaOverallStatusSchema(valueLabel)
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => z3.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") => z3.strictObject({
+  strategy: z3.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") => z3.discriminatedUnion("strategy", [
+  makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
 ]);
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => z3.strictObject({
+  projectedAt: makeUnixTimestampSchema(valueLabel),
+  worstCaseDistance: makeDurationSchema(valueLabel),
+  snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
+}).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
 
 // src/ensindexer/indexing-status/deserialize.ts
-function deserializeENSIndexerIndexingStatus(maybeStatus, valueLabel) {
-  const schema = makeENSIndexerIndexingStatusSchema(valueLabel);
-  const parsed = schema.safeParse(maybeStatus);
+function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(maybeSnapshot);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into ChainIndexingStatusSnapshot:
+${prettifyError3(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 ENSIndexerIndexingStatus:
+      `Cannot deserialize into OmnichainIndexingStatusSnapshot:
 ${prettifyError3(parsed.error)}
 `
     );
   }
   return parsed.data;
 }
+function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeCrossChainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(maybeSnapshot);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into CrossChainIndexingStatusSnapshot:
+${prettifyError3(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+function deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel) {
+  const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
+  const parsed = schema.safeParse(maybeProjection);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into RealtimeIndexingStatusProjection:
+${prettifyError3(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+
+// src/ensindexer/indexing-status/projection.ts
+function createRealtimeIndexingStatusProjection(snapshot, now) {
+  const projectedAt = Math.max(now, snapshot.snapshotTime);
+  return {
+    projectedAt,
+    worstCaseDistance: projectedAt - snapshot.slowestChainIndexingCursor,
+    snapshot
+  };
+}
 
 // src/ensindexer/indexing-status/serialize.ts
-function serializeChainIndexingStatuses(chainIndexingStatuses) {
-  const serializedChainsIndexingStatuses = {};
-  for (const [chainId, chainIndexingStatus] of chainIndexingStatuses.entries()) {
-    serializedChainsIndexingStatuses[serializeChainId(chainId)] = chainIndexingStatus;
+function serializeCrossChainIndexingStatusSnapshotOmnichain({
+  strategy,
+  slowestChainIndexingCursor,
+  snapshotTime,
+  omnichainSnapshot
+}) {
+  return {
+    strategy,
+    slowestChainIndexingCursor,
+    snapshotTime,
+    omnichainSnapshot: serializeOmnichainIndexingStatusSnapshot(omnichainSnapshot)
+  };
+}
+function serializeRealtimeIndexingStatusProjection(indexingProjection) {
+  return {
+    projectedAt: indexingProjection.projectedAt,
+    worstCaseDistance: indexingProjection.worstCaseDistance,
+    snapshot: serializeCrossChainIndexingStatusSnapshotOmnichain(indexingProjection.snapshot)
+  };
+}
+function serializeChainIndexingSnapshots(chains) {
+  const serializedSnapshots = {};
+  for (const [chainId, snapshot] of chains.entries()) {
+    serializedSnapshots[serializeChainId(chainId)] = snapshot;
   }
-  return serializedChainsIndexingStatuses;
+  return serializedSnapshots;
 }
-function serializeENSIndexerIndexingStatus(indexingStatus) {
-  switch (indexingStatus.overallStatus) {
-    case OverallIndexingStatusIds.IndexerError:
+function serializeOmnichainIndexingStatusSnapshot(indexingStatus) {
+  switch (indexingStatus.omnichainStatus) {
+    case OmnichainIndexingStatusIds.Unstarted:
       return {
-        overallStatus: OverallIndexingStatusIds.IndexerError
-      };
-    case OverallIndexingStatusIds.Unstarted:
-      return {
-        overallStatus: OverallIndexingStatusIds.Unstarted,
-        chains: serializeChainIndexingStatuses(indexingStatus.chains)
+        omnichainStatus: OmnichainIndexingStatusIds.Unstarted,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
       };
-    case OverallIndexingStatusIds.Backfill:
+    case OmnichainIndexingStatusIds.Backfill:
       return {
-        overallStatus: OverallIndexingStatusIds.Backfill,
-        chains: serializeChainIndexingStatuses(indexingStatus.chains),
+        omnichainStatus: OmnichainIndexingStatusIds.Backfill,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
         omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
       };
-    case OverallIndexingStatusIds.Completed: {
+    case OmnichainIndexingStatusIds.Completed: {
       return {
-        overallStatus: OverallIndexingStatusIds.Completed,
-        chains: serializeChainIndexingStatuses(indexingStatus.chains)
+        omnichainStatus: OmnichainIndexingStatusIds.Completed,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
       };
     }
-    case OverallIndexingStatusIds.Following:
+    case OmnichainIndexingStatusIds.Following:
       return {
-        overallStatus: OverallIndexingStatusIds.Following,
-        chains: serializeChainIndexingStatuses(indexingStatus.chains),
-        overallApproxRealtimeDistance: indexingStatus.overallApproxRealtimeDistance,
+        omnichainStatus: OmnichainIndexingStatusIds.Following,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
         omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
       };
   }
@@ -1019,17 +1322,42 @@ var ATTR_PROTOCOL_NAME = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol`;
 var ATTR_PROTOCOL_STEP = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol.step`;
 var ATTR_PROTOCOL_STEP_RESULT = `${PROTOCOL_ATTRIBUTE_PREFIX}.protocol.step.result`;
 
-// src/api/helpers.ts
+// src/api/deserialize.ts
 import { prettifyError as prettifyError4 } from "zod/v4";
 
 // src/api/zod-schemas.ts
 import z4 from "zod/v4";
+
+// src/api/types.ts
+var IndexingStatusResponseCodes = {
+  /**
+   * Represents that the indexing status is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that the indexing status is unavailable.
+   */
+  Error: "error"
+};
+
+// src/api/zod-schemas.ts
 var ErrorResponseSchema = z4.object({
   message: z4.string(),
   details: z4.optional(z4.unknown())
 });
+var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z4.strictObject({
+  responseCode: z4.literal(IndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
+});
+var makeIndexingStatusResponseErrorSchema = (valueLabel = "Indexing Status Response Error") => z4.strictObject({
+  responseCode: z4.literal(IndexingStatusResponseCodes.Error)
+});
+var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z4.discriminatedUnion("responseCode", [
+  makeIndexingStatusResponseOkSchema(valueLabel),
+  makeIndexingStatusResponseErrorSchema(valueLabel)
+]);
 
-// src/api/helpers.ts
+// src/api/deserialize.ts
 function deserializeErrorResponse(maybeErrorResponse) {
   const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
   if (parsed.error) {
@@ -1039,12 +1367,28 @@ ${prettifyError4(parsed.error)}
   }
   return parsed.data;
 }
+function deserializeIndexingStatusResponse(maybeResponse) {
+  const parsed = makeIndexingStatusResponseSchema().safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize IndexingStatusResponse:
+${prettifyError4(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
 
-// src/api/types.ts
-var IndexingStatusResponseCodes = {
-  IndexerError: 512,
-  RequestedDistanceNotAchievedError: 513
-};
+// src/api/serialize.ts
+function serializeIndexingStatusResponse(response) {
+  switch (response.responseCode) {
+    case IndexingStatusResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection)
+      };
+    case IndexingStatusResponseCodes.Error:
+      return response;
+  }
+}
 
 // src/client-error.ts
 var ClientError = class _ClientError extends Error {
@@ -1082,6 +1426,9 @@ var ENSNodeClient = class _ENSNodeClient {
   /**
    * Resolves records for an ENS name (Forward Resolution).
    *
+   * The returned `name` field, if set, is guaranteed to be a [Normalized Name](https://ensnode.io/docs/reference/terminology#normalized-name).
+   * If the name record returned by the resolver is not normalized, `null` is returned as if no name record was set.
+   *
    * @param name The ENS Name whose records to resolve
    * @param selection selection of Resolver records
    * @param options additional options
@@ -1133,9 +1480,13 @@ var ENSNodeClient = class _ENSNodeClient {
   /**
    * Resolves the primary name of a specified address (Reverse Resolution) on a specific chain.
    *
-   * If the `address` specifies a valid [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name),
-   * the Default Name will be returned. You _may_ query the Default EVM Chain Id (`0`) in order to
-   * determine the `address`'s Default Name directly.
+   * If the chainId-specific Primary Name is not defined, but the `address` specifies a valid
+   * [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name), the Default
+   * Name will be returned. You _may_ query the Default EVM Chain Id (`0`) in order to determine the
+   * `address`'s Default Name directly.
+   *
+   * The returned Primary Name, if set, is guaranteed to be a [Normalized Name](https://ensnode.io/docs/reference/terminology#normalized-name).
+   * If the primary name set for the address is not normalized, `null` is returned as if no primary name was set.
    *
    * @param address The Address whose Primary Name to resolve
    * @param chainId The chain id within which to query the address' ENSIP-19 Multichain Primary Name
@@ -1175,10 +1526,14 @@ var ENSNodeClient = class _ENSNodeClient {
   /**
    * Resolves the primary names of a specified address across multiple chains.
    *
-   * If the `address` specifies a valid [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name),
-   * the Default Name will be returned for all chainIds for which there is not a chain-specific
-   * Primary Name. To avoid misuse, you _may not_ query the Default EVM Chain Id (`0`) directly, and
-   * should rely on the aforementioned per-chain defaulting behavior.
+   * For each Primary Name, if the chainId-specific Primary Name is not defined, but the `address`
+   * specifies a valid [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name),
+   * the Default Name will be returned. You _may not_ query the Default EVM Chain Id (`0`) directly,
+   * and should rely on the aforementioned per-chain defaulting behavior.
+   *
+   * Each returned Primary Name, if set, is guaranteed to be a [Normalized Name](https://ensnode.io/docs/reference/terminology#normalized-name).
+   * If the primary name set for the address on any chain is not normalized, `null` is returned for
+   * that chain as if no primary name was set.
    *
    * @param address The Address whose Primary Names to resolve
    * @param options additional options
@@ -1196,12 +1551,12 @@ var ENSNodeClient = class _ENSNodeClient {
    *
    * console.log(names);
    * // {
-   * //   "1": "gregskril.eth",
-   * //   "10": "gregskril.eth",
-   * //   "8453": "greg.base.eth", // base-specific Primary Name!
-   * //   "42161": "gregskril.eth",
-   * //   "59144": "gregskril.eth",
-   * //   "534352": "gregskril.eth"
+   * //   "1": "gregskril.eth", // Default Primary Name
+   * //   "10": "gregskril.eth", // Default Primary Name
+   * //   "8453": "greg.base.eth", // Base-specific Primary Name!
+   * //   "42161": "gregskril.eth", // Default Primary Name
+   * //   "59144": "gregskril.eth", // Default Primary Name
+   * //   "534352": "gregskril.eth" // Default Primary Name
    * // }
    *
    * // Resolve the address' Primary Names on specific chain Ids
@@ -1256,28 +1611,14 @@ var ENSNodeClient = class _ENSNodeClient {
   /**
    * Fetch ENSNode Indexing Status
    *
-   * Fetch the ENSNode's multichain indexing status.
-   *
-   * @param options additional options
-   * @param options.maxRealtimeDistance the max allowed distance between the
-   *  latest indexed block of each chain and the "tip" of all indexed chains.
-   *  Setting this parameter influences the HTTP response code as follows:
-   *  - Success (200 OK): The latest indexed block of each chain is within the
-   *    requested distance from realtime.
-   *  - Service Unavailable (503): The latest indexed block of each chain is NOT
-   *    within the requested distance from realtime.
-   *
    * @returns {IndexingStatusResponse}
    *
    * @throws if the ENSNode request fails
    * @throws if the ENSNode API returns an error response
    * @throws if the ENSNode response breaks required invariants
    */
-  async indexingStatus(options) {
+  async indexingStatus() {
     const url = new URL(`/api/indexing-status`, this.options.url);
-    if (typeof options?.maxRealtimeDistance !== "undefined") {
-      url.searchParams.set("maxRealtimeDistance", `${options.maxRealtimeDistance}`);
-    }
     const response = await fetch(url);
     let responseData;
     try {
@@ -1286,40 +1627,48 @@ var ENSNodeClient = class _ENSNodeClient {
       throw new Error("Malformed response data: invalid JSON");
     }
     if (!response.ok) {
-      switch (response.status) {
-        case IndexingStatusResponseCodes.IndexerError: {
-          console.error("Indexing Status API: indexer error");
-          return deserializeENSIndexerIndexingStatus(
-            responseData
-          );
-        }
-        case IndexingStatusResponseCodes.RequestedDistanceNotAchievedError: {
-          console.error(
-            "Indexing Status API: Requested realtime indexing distance not achieved error"
-          );
-          return deserializeENSIndexerIndexingStatus(
-            responseData
-          );
-        }
-        default: {
-          const errorResponse = deserializeErrorResponse(responseData);
-          throw new Error(`Fetching ENSNode Indexing Status Failed: ${errorResponse.message}`);
-        }
+      let errorResponse;
+      try {
+        errorResponse = deserializeErrorResponse(responseData);
+      } catch {
+        console.log("Indexing Status API: handling a known indexing status server error.");
+      }
+      if (typeof errorResponse !== "undefined") {
+        throw new Error(`Fetching ENSNode Indexing Status Failed: ${errorResponse.message}`);
       }
     }
-    return deserializeENSIndexerIndexingStatus(
-      responseData
-    );
+    return deserializeIndexingStatusResponse(responseData);
   }
 };
 
 // src/resolution/resolver-records-selection.ts
 var isSelectionEmpty = (selection) => !selection.name && !selection.addresses?.length && !selection.texts?.length;
 
+// src/resolution/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/resolution/default-records-selection.ts
 import {
   DatasourceNames,
-  ENSNamespaceIds as ENSNamespaceIds2,
+  ENSNamespaceIds as ENSNamespaceIds3,
   maybeGetDatasource
 } from "@ensnode/datasources";
 var getENSIP19SupportedCoinTypes = (namespace) => uniq(
@@ -1331,6 +1680,9 @@ var getENSIP19SupportedCoinTypes = (namespace) => uniq(
     maybeGetDatasource(namespace, DatasourceNames.ReverseResolverScroll)
   ].filter((ds) => ds !== void 0).map((ds) => ds.chain.id)
 ).map(evmChainIdToCoinType);
+var getCommonCoinTypes = (namespace) => {
+  return [ETH_COIN_TYPE, ...getENSIP19SupportedCoinTypes(namespace)];
+};
 var TEXTS = [
   "url",
   "avatar",
@@ -1342,31 +1694,57 @@ var TEXTS = [
   "com.github"
 ];
 var DefaultRecordsSelection = {
-  [ENSNamespaceIds2.Mainnet]: {
-    addresses: [ETH_COIN_TYPE, ...getENSIP19SupportedCoinTypes(ENSNamespaceIds2.Mainnet)],
+  [ENSNamespaceIds3.Mainnet]: {
+    addresses: getCommonCoinTypes(ENSNamespaceIds3.Mainnet),
     texts: TEXTS
   },
-  [ENSNamespaceIds2.Sepolia]: {
-    addresses: [ETH_COIN_TYPE, ...getENSIP19SupportedCoinTypes(ENSNamespaceIds2.Sepolia)],
+  [ENSNamespaceIds3.Sepolia]: {
+    addresses: getCommonCoinTypes(ENSNamespaceIds3.Sepolia),
     texts: TEXTS
   },
-  [ENSNamespaceIds2.Holesky]: {
-    addresses: [ETH_COIN_TYPE, ...getENSIP19SupportedCoinTypes(ENSNamespaceIds2.Holesky)],
+  [ENSNamespaceIds3.Holesky]: {
+    addresses: getCommonCoinTypes(ENSNamespaceIds3.Holesky),
     texts: TEXTS
   },
-  [ENSNamespaceIds2.EnsTestEnv]: {
-    addresses: [ETH_COIN_TYPE, ...getENSIP19SupportedCoinTypes(ENSNamespaceIds2.EnsTestEnv)],
+  [ENSNamespaceIds3.EnsTestEnv]: {
+    addresses: getCommonCoinTypes(ENSNamespaceIds3.EnsTestEnv),
     texts: TEXTS
   }
 };
+
+// src/resolution/ensip19-chainid.ts
+import { getENSRootChainId as getENSRootChainId2 } from "@ensnode/datasources";
+import { mainnet } from "viem/chains";
+var getResolvePrimaryNameChainIdParam = (chainId, namespaceId) => {
+  const ensRootChainId = getENSRootChainId2(namespaceId);
+  return chainId === ensRootChainId ? mainnet.id : chainId;
+};
+var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
+  return chainId === DEFAULT_EVM_CHAIN_ID ? getENSRootChainId2(namespaceId) : chainId;
+};
+
+// src/resolution/identity.ts
+import { getENSRootChainId as getENSRootChainId3 } from "@ensnode/datasources";
+function buildUnresolvedIdentity(address, namespaceId, chainId) {
+  return {
+    resolutionStatus: ResolutionStatusIds.Unresolved,
+    chainId: chainId ?? getENSRootChainId3(namespaceId),
+    address
+  };
+}
+function isResolvedIdentity(identity) {
+  return identity.resolutionStatus !== ResolutionStatusIds.Unresolved;
+}
 export {
+  ADDR_REVERSE_NODE,
   ATTR_PROTOCOL_NAME,
   ATTR_PROTOCOL_STEP,
   ATTR_PROTOCOL_STEP_RESULT,
   BASENAMES_NODE,
+  ChainIndexingConfigTypeIds,
   ChainIndexingStatusIds,
-  ChainIndexingStrategyIds,
   ClientError,
+  CrossChainIndexingStrategyIds,
   DEFAULT_ENSNODE_API_URL,
   DEFAULT_EVM_CHAIN_ID,
   DEFAULT_EVM_COIN_TYPE,
@@ -1379,73 +1757,86 @@ export {
   IndexingStatusResponseCodes,
   LINEANAMES_NODE,
   LruCache,
-  OverallIndexingStatusIds,
+  OmnichainIndexingStatusIds,
   PROTOCOL_ATTRIBUTE_PREFIX,
   PluginName,
-  REVERSE_ROOT_NODES,
   ROOT_NODE,
+  ResolutionStatusIds,
   ReverseResolutionProtocolStep,
   TraceableENSProtocol,
   accountIdEqual,
   addrReverseLabel,
+  asLowerCaseAddress,
+  beautifyName,
   bigintToCoinType,
   buildEnsRainbowClientLabelSet,
   buildLabelSetId,
   buildLabelSetVersion,
-  checkChainIndexingStatusesForBackfillOverallStatus,
-  checkChainIndexingStatusesForCompletedOverallStatus,
-  checkChainIndexingStatusesForFollowingOverallStatus,
-  checkChainIndexingStatusesForUnstartedOverallStatus,
+  buildUnresolvedIdentity,
+  checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill,
+  checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted,
+  checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing,
+  checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted,
   coinTypeReverseLabel,
   coinTypeToEvmChainId,
   createIndexingConfig,
+  createRealtimeIndexingStatusProjection,
+  decodeDNSEncodedLiteralName,
+  decodeDNSEncodedName,
   deserializeBlockNumber,
   deserializeBlockRef,
   deserializeBlockrange,
   deserializeChainId,
+  deserializeChainIndexingStatusSnapshot,
+  deserializeCrossChainIndexingStatusSnapshot,
   deserializeDatetime,
   deserializeDuration,
-  deserializeENSIndexerIndexingStatus,
   deserializeENSIndexerPublicConfig,
   deserializeErrorResponse,
+  deserializeIndexingStatusResponse,
+  deserializeOmnichainIndexingStatusSnapshot,
+  deserializeRealtimeIndexingStatusProjection,
+  deserializeUnixTimestamp,
   deserializeUrl,
+  encodeLabelHash,
   evmChainIdToCoinType,
-  getActiveChains,
+  getCommonCoinTypes,
+  getENSRootChainId,
   getNameHierarchy,
   getOmnichainIndexingCursor,
-  getOverallApproxRealtimeDistance,
-  getOverallIndexingStatus,
-  getStandbyChains,
+  getOmnichainIndexingStatus,
+  getResolvePrimaryNameChainIdParam,
   getTimestampForHighestOmnichainKnownBlock,
   getTimestampForLowestOmnichainStartBlock,
-  invariant_isSubgraphCompatibleRequirements,
-  invariant_reverseResolversPluginNeedsResolverRecords,
-  isLabelIndexable,
-  isNormalized,
+  interpretedLabelsToInterpretedName,
+  isHttpProtocol,
+  isNormalizedLabel,
+  isNormalizedName,
+  isResolvedIdentity,
   isSelectionEmpty,
   isSubgraphCompatible,
+  isWebSocketProtocol,
   labelHashToBytes,
-  makeDatabaseSchemaNameSchema,
-  makeDependencyInfoSchema,
-  makeENSIndexerPublicConfigSchema,
-  makeFullyPinnedLabelSetSchema,
-  makeIndexedChainIdsSchema,
-  makeLabelSetIdSchema,
-  makeLabelSetVersionSchema,
-  makePluginsListSchema,
+  labelhashLiteralLabel,
+  literalLabelToInterpretedLabel,
+  literalLabelsToInterpretedName,
+  literalLabelsToLiteralName,
   makeSubdomainNode,
-  maybeHealLabelByReverseAddress,
   parseNonNegativeInteger,
   parseReverseName,
   reverseName,
   serializeChainId,
-  serializeChainIndexingStatuses,
+  serializeChainIndexingSnapshots,
+  serializeCrossChainIndexingStatusSnapshotOmnichain,
   serializeDatetime,
-  serializeENSIndexerIndexingStatus,
   serializeENSIndexerPublicConfig,
   serializeIndexedChainIds,
+  serializeIndexingStatusResponse,
+  serializeOmnichainIndexingStatusSnapshot,
+  serializeRealtimeIndexingStatusProjection,
   serializeUrl,
-  sortAscChainStatusesByStartBlock,
+  sortChainStatusesByStartBlockAsc,
+  translateDefaultableChainIdToChainId,
   uint256ToHex32,
   uniq,
   validateSupportedLabelSetAndVersion