@ensnode/ensnode-sdk 1.0.3 → 1.2.0

package/dist/index.js

@@ -1,11 +1,10 @@
-// src/api/deserialize.ts
-import { prettifyError as prettifyError2 } from "zod/v4";
+// src/ensapi/config/deserialize.ts
+import { prettifyError as prettifyError2, ZodError } from "zod/v4";
 
-// src/api/zod-schemas.ts
-import { namehash as namehash2 } from "viem";
-import z7 from "zod/v4";
+// src/ensapi/config/zod-schemas.ts
+import { z as z3 } from "zod/v4";
 
-// src/ensindexer/indexing-status/zod-schemas.ts
+// src/ensindexer/config/zod-schemas.ts
 import z2 from "zod/v4";
 
 // src/ens/is-normalized.ts
@@ -38,8 +37,58 @@ function asLowerCaseAddress(address) {
   return address.toLowerCase();
 }
 
-// src/shared/cache.ts
-import { getUnixTime } from "date-fns";
+// src/shared/cache/lru-cache.ts
+var LruCache = class {
+  _cache = /* @__PURE__ */ new Map();
+  _capacity;
+  /**
+   * Create a new LRU cache with the given capacity.
+   *
+   * @param capacity The maximum number of items in the cache. If set to 0, the cache is effectively disabled.
+   * @throws Error if capacity is not a non-negative integer.
+   */
+  constructor(capacity) {
+    if (!Number.isInteger(capacity)) {
+      throw new Error(
+        `LruCache requires capacity to be an integer but a capacity of ${capacity} was requested.`
+      );
+    }
+    if (capacity < 0) {
+      throw new Error(
+        `LruCache requires a non-negative capacity but a capacity of ${capacity} was requested.`
+      );
+    }
+    this._capacity = capacity;
+  }
+  set(key, value) {
+    this._cache.set(key, value);
+    if (this._cache.size > this._capacity) {
+      const oldestKey = this._cache.keys().next().value;
+      this._cache.delete(oldestKey);
+    }
+  }
+  get(key) {
+    const value = this._cache.get(key);
+    if (value) {
+      this._cache.delete(key);
+      this._cache.set(key, value);
+    }
+    return value;
+  }
+  clear() {
+    this._cache.clear();
+  }
+  get size() {
+    return this._cache.size;
+  }
+  get capacity() {
+    return this._capacity;
+  }
+};
+
+// src/shared/cache/swr-cache.ts
+import { secondsToMilliseconds } from "date-fns";
+import { getUnixTime } from "date-fns/getUnixTime";
 
 // src/shared/deserialize.ts
 import { prettifyError } from "zod/v4";
@@ -291,6 +340,13 @@ function reinterpretName(name) {
 }
 
 // src/shared/zod-schemas.ts
+var makeFiniteNonNegativeNumberSchema = (valueLabel = "Value") => z.number({
+  // NOTE: Zod's implementation of `number` automatically rejects NaN and Infinity values.
+  // and therefore the finite check is implicit.
+  error: `${valueLabel} must be a finite number.`
+}).nonnegative({
+  error: `${valueLabel} must be a non-negative number (>=0).`
+});
 var makeIntegerSchema = (valueLabel = "Value") => z.int({
   error: `${valueLabel} must be an integer.`
 });
@@ -365,13 +421,13 @@ var makePriceCurrencySchema = (currency, valueLabel = "Price Currency") => z.str
 });
 var makePriceEthSchema = (valueLabel = "Price ETH") => makePriceCurrencySchema(CurrencyIds.ETH, valueLabel).transform((v) => v);
 var makeAccountIdSchema = (valueLabel = "AccountId") => z.strictObject({
-  chainId: makeChainIdStringSchema(`${valueLabel} chain ID`),
+  chainId: makeChainIdSchema(`${valueLabel} chain ID`),
   address: makeLowercaseAddressSchema(`${valueLabel} address`)
 });
 var makeSerializedAccountIdSchema = (valueLabel = "Account ID") => z.coerce.string().transform((v) => {
   const result = new CaipAccountId(v);
   return {
-    chainId: result.chainId.reference,
+    chainId: Number(result.chainId.reference),
     address: result.address
   };
 }).pipe(makeAccountIdSchema(valueLabel));
@@ -509,54 +565,185 @@ function addDuration(timestamp, duration) {
   return deserializeUnixTimestamp(timestamp + duration, "UnixTimestamp");
 }
 
-// src/shared/cache.ts
-var LruCache = class {
-  _cache = /* @__PURE__ */ new Map();
-  _capacity;
+// src/shared/cache/background-revalidation-scheduler.ts
+var BackgroundRevalidationScheduler = class {
+  activeSchedules = /* @__PURE__ */ new Map();
   /**
-   * Create a new LRU cache with the given capacity.
+   * Schedule a revalidation function to run on a recurring interval.
    *
-   * @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.
+   * @param config Configuration object for the schedule
+   * @returns The revalidate function that can be passed to `cancel()` to stop the schedule
    */
-  constructor(capacity) {
-    if (!Number.isInteger(capacity)) {
-      throw new Error(
-        `LruCache requires capacity to be an integer but a capacity of ${capacity} was requested.`
-      );
+  schedule(config) {
+    const { revalidate, interval, initialDelay = 0, onError } = config;
+    if (this.activeSchedules.has(revalidate)) {
+      return revalidate;
     }
-    if (capacity < 0) {
-      throw new Error(
-        `LruCache requires a non-negative capacity but a capacity of ${capacity} was requested.`
-      );
+    const metadata = {
+      config,
+      timeoutId: null,
+      inProgress: false
+    };
+    this.activeSchedules.set(revalidate, metadata);
+    const executeRevalidation = async () => {
+      if (metadata.inProgress) return;
+      metadata.inProgress = true;
+      try {
+        await revalidate();
+      } catch (error) {
+        onError?.(error);
+      } finally {
+        metadata.inProgress = false;
+      }
+    };
+    const scheduleNext = () => {
+      if (!this.activeSchedules.has(revalidate)) return;
+      metadata.timeoutId = setTimeout(() => {
+        if (this.activeSchedules.has(revalidate)) {
+          executeRevalidation().then(() => scheduleNext());
+        }
+      }, interval);
+    };
+    if (initialDelay > 0) {
+      metadata.timeoutId = setTimeout(() => {
+        if (this.activeSchedules.has(revalidate)) {
+          executeRevalidation().then(() => scheduleNext());
+        }
+      }, initialDelay);
+    } else {
+      scheduleNext();
     }
-    this._capacity = capacity;
+    return revalidate;
   }
-  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);
+  /**
+   * Cancel a scheduled revalidation by its revalidate function.
+   *
+   * @param revalidate The revalidation function returned from `schedule()`
+   */
+  cancel(revalidate) {
+    const metadata = this.activeSchedules.get(revalidate);
+    if (!metadata) return;
+    if (metadata.timeoutId !== null) {
+      clearTimeout(metadata.timeoutId);
     }
+    this.activeSchedules.delete(revalidate);
   }
-  get(key) {
-    const value = this._cache.get(key);
-    if (value) {
-      this._cache.delete(key);
-      this._cache.set(key, value);
+  /**
+   * Cancel all active schedules.
+   */
+  cancelAll() {
+    for (const [, metadata] of this.activeSchedules) {
+      if (metadata.timeoutId !== null) {
+        clearTimeout(metadata.timeoutId);
+      }
     }
-    return value;
+    this.activeSchedules.clear();
   }
-  clear() {
-    this._cache.clear();
+  /**
+   * Get the count of active schedules.
+   * Useful for debugging and monitoring.
+   *
+   * @returns The number of currently active schedules
+   */
+  getActiveScheduleCount() {
+    return this.activeSchedules.size;
   }
-  get size() {
-    return this._cache.size;
+};
+
+// src/shared/cache/swr-cache.ts
+var bgRevalidationScheduler = new BackgroundRevalidationScheduler();
+var SWRCache = class _SWRCache {
+  options;
+  cache;
+  /**
+   * Optional promise of the current in-progress attempt to revalidate the `cache`.
+   *
+   * If null, no revalidation attempt is currently in progress.
+   * If not null, identifies the revalidation attempt that is currently in progress.
+   *
+   * Used to enforce no concurrent revalidation attempts.
+   */
+  inProgressRevalidate;
+  /**
+   * The callback function being managed by `BackgroundRevalidationScheduler`.
+   *
+   * If null, no background revalidation is scheduled.
+   * If not null, identifies the background revalidation that is currently scheduled.
+   *
+   * Used to enforce no concurrent background revalidation attempts.
+   */
+  scheduledBackgroundRevalidate;
+  constructor(options) {
+    this.cache = null;
+    this.inProgressRevalidate = null;
+    this.scheduledBackgroundRevalidate = null;
+    this.options = options;
   }
-  get capacity() {
-    return this._capacity;
+  /**
+   * Asynchronously create a new `SWRCache` instance.
+   *
+   * @param options - The {@link SWRCacheOptions} for the SWR cache.
+   * @returns a new `SWRCache` instance.
+   */
+  static async create(options) {
+    const cache = new _SWRCache(options);
+    if (cache.options.proactivelyInitialize) {
+      cache.readCache();
+    }
+    return cache;
   }
+  revalidate = async () => {
+    if (this.inProgressRevalidate) {
+      return this.inProgressRevalidate;
+    }
+    return this.options.fn().then((value) => {
+      this.cache = {
+        value,
+        updatedAt: getUnixTime(/* @__PURE__ */ new Date())
+      };
+      return this.cache;
+    }).catch(() => {
+      return null;
+    }).finally(() => {
+      this.inProgressRevalidate = null;
+      if (this.options.revalidationInterval === void 0) {
+        return;
+      }
+      if (this.scheduledBackgroundRevalidate) {
+        bgRevalidationScheduler.cancel(this.scheduledBackgroundRevalidate);
+      }
+      const backgroundRevalidate = async () => {
+        this.revalidate();
+      };
+      this.scheduledBackgroundRevalidate = bgRevalidationScheduler.schedule({
+        revalidate: backgroundRevalidate,
+        interval: secondsToMilliseconds(this.options.revalidationInterval)
+      });
+    });
+  };
+  /**
+   * Read the most recently cached `CachedValue` from the `SWRCache`.
+   *
+   * @returns a `CachedValue` holding a `value` of `ValueType` that was most recently successfully returned by `fn`
+   *          or `null` if `fn` has never successfully returned and has always thrown an error,
+   */
+  readCache = async () => {
+    if (!this.cache) {
+      this.inProgressRevalidate = this.revalidate();
+      return this.inProgressRevalidate;
+    }
+    if (durationBetween(this.cache.updatedAt, getUnixTime(/* @__PURE__ */ new Date())) <= this.options.ttl) {
+      return this.cache;
+    }
+    if (!this.inProgressRevalidate) {
+      this.inProgressRevalidate = this.revalidate();
+    }
+    return this.cache;
+  };
 };
+
+// src/shared/cache/ttl-cache.ts
+import { getUnixTime as getUnixTime2 } from "date-fns/getUnixTime";
 var TtlCache = class {
   _cache = /* @__PURE__ */ new Map();
   _ttl;
@@ -569,7 +756,7 @@ var TtlCache = class {
     this._ttl = ttl;
   }
   _cleanup() {
-    const now = getUnixTime(/* @__PURE__ */ new Date());
+    const now = getUnixTime2(/* @__PURE__ */ new Date());
     for (const [key, entry] of this._cache.entries()) {
       if (entry.expiresAt <= now) {
         this._cache.delete(key);
@@ -578,7 +765,7 @@ var TtlCache = class {
   }
   set(key, value) {
     this._cleanup();
-    const expiresAt = addDuration(getUnixTime(/* @__PURE__ */ new Date()), this._ttl);
+    const expiresAt = addDuration(getUnixTime2(/* @__PURE__ */ new Date()), this._ttl);
     this._cache.set(key, { value, expiresAt });
   }
   get(key) {
@@ -587,7 +774,7 @@ var TtlCache = class {
     if (!entry) {
       return void 0;
     }
-    if (entry.expiresAt <= getUnixTime(/* @__PURE__ */ new Date())) {
+    if (entry.expiresAt <= getUnixTime2(/* @__PURE__ */ new Date())) {
       this._cache.delete(key);
       return void 0;
     }
@@ -609,7 +796,7 @@ var TtlCache = class {
     if (!entry) {
       return false;
     }
-    if (entry.expiresAt <= getUnixTime(/* @__PURE__ */ new Date())) {
+    if (entry.expiresAt <= getUnixTime2(/* @__PURE__ */ new Date())) {
       this._cache.delete(key);
       return false;
     }
@@ -619,39 +806,6 @@ var TtlCache = class {
     return this._cache.delete(key);
   }
 };
-function staleWhileRevalidate(options) {
-  const { fn, ttl } = options;
-  let cache = null;
-  let cacheInitializer = null;
-  return async () => {
-    if (!cache) {
-      if (cacheInitializer) {
-        return cacheInitializer;
-      }
-      cacheInitializer = fn().then((value) => {
-        cache = { value, updatedAt: getUnixTime(/* @__PURE__ */ new Date()) };
-        cacheInitializer = null;
-        return value;
-      }).catch(() => {
-        cacheInitializer = null;
-        return null;
-      });
-      return cacheInitializer;
-    }
-    const isStale = durationBetween(cache.updatedAt, getUnixTime(/* @__PURE__ */ new Date())) > ttl;
-    if (!isStale) return cache.value;
-    if (cache.inProgressRevalidation) return cache.value;
-    const revalidationPromise = fn().then((value) => {
-      cache = { value, updatedAt: getUnixTime(/* @__PURE__ */ new Date()) };
-    }).catch(() => {
-      if (cache) {
-        cache.inProgressRevalidation = void 0;
-      }
-    });
-    cache.inProgressRevalidation = revalidationPromise;
-    return cache.value;
-  };
-}
 
 // src/shared/collections.ts
 var uniq = (arr) => [...new Set(arr)];
@@ -729,106 +883,372 @@ function isWebSocketProtocol(url) {
   return ["ws:", "wss:"].includes(url.protocol);
 }
 
-// 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/ensindexer/config/is-subgraph-compatible.ts
+import { ENSNamespaceIds as ENSNamespaceIds2 } from "@ensnode/datasources";
 
-// 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/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";
+  return PluginName2;
+})(PluginName || {});
 
-// src/ensindexer/indexing-status/helpers.ts
-function getOmnichainIndexingStatus(chains) {
-  if (checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains)) {
+// src/ensindexer/config/is-subgraph-compatible.ts
+function isSubgraphCompatible(config) {
+  const onlySubgraphPluginActivated = config.plugins.length === 1 && config.plugins[0] === "subgraph" /* Subgraph */;
+  const isSubgraphLabelSet = config.labelSet.labelSetId === "subgraph" && config.labelSet.labelSetVersion === 0;
+  const isEnsTestEnvLabelSet = config.labelSet.labelSetId === "ens-test-env" && config.labelSet.labelSetVersion === 0;
+  const labelSetIsSubgraphCompatible = isSubgraphLabelSet || config.namespace === ENSNamespaceIds2.EnsTestEnv && isEnsTestEnvLabelSet;
+  return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
+}
+
+// src/ensindexer/config/validations.ts
+function invariant_ensDbVersionIsSameAsEnsIndexerVersion(ctx) {
+  const versionInfo = ctx.value;
+  if (versionInfo.ensDb !== versionInfo.ensIndexer) {
+    ctx.issues.push({
+      code: "custom",
+      input: versionInfo,
+      message: "`ensDb` version must be same as `ensIndexer` version"
+    });
+  }
+}
+
+// src/ensindexer/config/zod-schemas.ts
+var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => z2.array(makeChainIdSchema(valueLabel), {
+  error: `${valueLabel} must be an array.`
+}).min(1, { error: `${valueLabel} list must include at least one element.` }).transform((v) => new Set(v));
+var makePluginsListSchema = (valueLabel = "Plugins") => z2.array(z2.string(), {
+  error: `${valueLabel} must be a list of strings.`
+}).min(1, {
+  error: `${valueLabel} must be a list of strings with at least one string value`
+}).refine((arr) => arr.length === uniq(arr).length, {
+  error: `${valueLabel} cannot contain duplicate values.`
+});
+var makeDatabaseSchemaNameSchema = (valueLabel = "Database schema name") => z2.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
+  error: `${valueLabel} is required and must be a non-empty string.`
+});
+var makeLabelSetIdSchema = (valueLabel) => {
+  return z2.string({ error: `${valueLabel} must be a string` }).min(1, { error: `${valueLabel} must be 1-50 characters long` }).max(50, { error: `${valueLabel} must be 1-50 characters long` }).regex(/^[a-z-]+$/, {
+    error: `${valueLabel} can only contain lowercase letters (a-z) and hyphens (-)`
+  });
+};
+var makeLabelSetVersionSchema = (valueLabel) => {
+  return z2.coerce.number({ error: `${valueLabel} must be an integer.` }).pipe(makeNonNegativeIntegerSchema(valueLabel));
+};
+var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
+  let valueLabelLabelSetId = valueLabel;
+  let valueLabelLabelSetVersion = valueLabel;
+  if (valueLabel === "LABEL_SET") {
+    valueLabelLabelSetId = "LABEL_SET_ID";
+    valueLabelLabelSetVersion = "LABEL_SET_VERSION";
+  } else {
+    valueLabelLabelSetId = `${valueLabel}.labelSetId`;
+    valueLabelLabelSetVersion = `${valueLabel}.labelSetVersion`;
+  }
+  return z2.object({
+    labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
+    labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
+  });
+};
+var makeNonEmptyStringSchema = (valueLabel = "Value") => z2.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
+var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => z2.strictObject(
+  {
+    nodejs: makeNonEmptyStringSchema(),
+    ponder: makeNonEmptyStringSchema(),
+    ensDb: makeNonEmptyStringSchema(),
+    ensIndexer: makeNonEmptyStringSchema(),
+    ensNormalize: makeNonEmptyStringSchema(),
+    ensRainbow: makeNonEmptyStringSchema(),
+    ensRainbowSchema: makePositiveIntegerSchema()
+  },
+  {
+    error: `${valueLabel} must be a valid ENSIndexerVersionInfo object.`
+  }
+).check(invariant_ensDbVersionIsSameAsEnsIndexerVersion);
+function invariant_isSubgraphCompatibleRequirements(ctx) {
+  const { value: config } = ctx;
+  if (config.isSubgraphCompatible && !isSubgraphCompatible(config)) {
+    ctx.issues.push({
+      code: "custom",
+      input: config,
+      message: `'isSubgraphCompatible' requires only the '${"subgraph" /* Subgraph */}' plugin to be active and labelSet must be {labelSetId: "subgraph", labelSetVersion: 0}`
+    });
+  }
+}
+var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => z2.object({
+  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
+  indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
+  isSubgraphCompatible: z2.boolean({ error: `${valueLabel}.isSubgraphCompatible` }),
+  namespace: makeENSNamespaceIdSchema(`${valueLabel}.namespace`),
+  plugins: makePluginsListSchema(`${valueLabel}.plugins`),
+  databaseSchemaName: makeDatabaseSchemaNameSchema(`${valueLabel}.databaseSchemaName`),
+  versionInfo: makeENSIndexerVersionInfoSchema(`${valueLabel}.versionInfo`)
+}).check(invariant_isSubgraphCompatibleRequirements);
+
+// src/ensapi/config/zod-schemas.ts
+var TheGraphCannotFallbackReasonSchema = z3.enum({
+  NotSubgraphCompatible: "not-subgraph-compatible",
+  NoApiKey: "no-api-key",
+  NoSubgraphUrl: "no-subgraph-url"
+});
+var TheGraphFallbackSchema = z3.strictObject({
+  canFallback: z3.boolean(),
+  reason: TheGraphCannotFallbackReasonSchema.nullable()
+});
+function makeENSApiPublicConfigSchema(valueLabel) {
+  const label = valueLabel ?? "ENSApiPublicConfig";
+  return z3.strictObject({
+    version: z3.string().min(1, `${label}.version must be a non-empty string`),
+    theGraphFallback: TheGraphFallbackSchema,
+    ensIndexerPublicConfig: makeENSIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
+  });
+}
+
+// src/ensapi/config/deserialize.ts
+function deserializeENSApiPublicConfig(maybeConfig, valueLabel) {
+  const schema = makeENSApiPublicConfigSchema(valueLabel);
+  try {
+    return schema.parse(maybeConfig);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      throw new Error(`Cannot deserialize ENSApiPublicConfig:
+${prettifyError2(error)}
+`);
+    }
+    throw error;
+  }
+}
+
+// src/ensindexer/config/deserialize.ts
+import { prettifyError as prettifyError3 } from "zod/v4";
+function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
+  const schema = makeENSIndexerPublicConfigSchema(valueLabel);
+  const parsed = schema.safeParse(maybeConfig);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ENSIndexerPublicConfig:
+${prettifyError3(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/ensindexer/config/label-utils.ts
+import { hexToBytes as hexToBytes2 } from "viem";
+function labelHashToBytes(labelHash) {
+  try {
+    if (labelHash.length !== 66) {
+      throw new Error(`Invalid labelHash length ${labelHash.length} characters (expected 66)`);
+    }
+    if (labelHash !== labelHash.toLowerCase()) {
+      throw new Error("Labelhash must be in lowercase");
+    }
+    if (!labelHash.startsWith("0x")) {
+      throw new Error("Labelhash must be 0x-prefixed");
+    }
+    const bytes = hexToBytes2(labelHash);
+    if (bytes.length !== 32) {
+      throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
+    }
+    return bytes;
+  } catch (e) {
+    if (e instanceof Error) {
+      throw e;
+    }
+    throw new Error("Invalid hex format");
+  }
+}
+
+// src/ensindexer/config/labelset-utils.ts
+function buildLabelSetId(maybeLabelSetId) {
+  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
+}
+function buildLabelSetVersion(maybeLabelSetVersion) {
+  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
+}
+function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
+  if (labelSetVersion !== void 0 && labelSetId === void 0) {
+    throw new Error("When a labelSetVersion is defined, labelSetId must also be defined.");
+  }
+  return { labelSetId, labelSetVersion };
+}
+function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
+  if (clientSet.labelSetId === void 0) {
+    return;
+  }
+  if (serverSet.labelSetId !== clientSet.labelSetId) {
+    throw new Error(
+      `Server label set ID "${serverSet.labelSetId}" does not match client's requested label set ID "${clientSet.labelSetId}".`
+    );
+  }
+  if (clientSet.labelSetVersion !== void 0 && serverSet.highestLabelSetVersion < clientSet.labelSetVersion) {
+    throw new Error(
+      `Server highest label set version ${serverSet.highestLabelSetVersion} is less than client's requested version ${clientSet.labelSetVersion} for label set ID "${clientSet.labelSetId}".`
+    );
+  }
+}
+
+// src/ensindexer/config/parsing.ts
+function parseNonNegativeInteger(maybeNumber) {
+  const trimmed = maybeNumber.trim();
+  if (!trimmed) {
+    throw new Error("Input cannot be empty");
+  }
+  if (trimmed === "-0") {
+    throw new Error("Negative zero is not a valid non-negative integer");
+  }
+  const num = Number(maybeNumber);
+  if (Number.isNaN(num)) {
+    throw new Error(`"${maybeNumber}" is not a valid number`);
+  }
+  if (!Number.isFinite(num)) {
+    throw new Error(`"${maybeNumber}" is not a finite number`);
+  }
+  if (!Number.isInteger(num)) {
+    throw new Error(`"${maybeNumber}" is not an integer`);
+  }
+  if (num < 0) {
+    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
+  }
+  return num;
+}
+
+// src/ensindexer/config/serialize.ts
+function serializeIndexedChainIds(indexedChainIds) {
+  return Array.from(indexedChainIds);
+}
+function serializeENSIndexerPublicConfig(config) {
+  const {
+    labelSet,
+    indexedChainIds,
+    databaseSchemaName,
+    isSubgraphCompatible: isSubgraphCompatible2,
+    namespace,
+    plugins,
+    versionInfo
+  } = config;
+  return {
+    labelSet,
+    indexedChainIds: serializeIndexedChainIds(indexedChainIds),
+    databaseSchemaName,
+    isSubgraphCompatible: isSubgraphCompatible2,
+    namespace,
+    plugins,
+    versionInfo
+  };
+}
+
+// src/ensindexer/indexing-status/deserialize.ts
+import { prettifyError as prettifyError4 } from "zod/v4";
+
+// src/ensindexer/indexing-status/zod-schemas.ts
+import z4 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;
+}
+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)) {
@@ -927,6 +1347,16 @@ function sortChainStatusesByStartBlockAsc(chains) {
   );
   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) {
@@ -1173,52 +1603,52 @@ function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ct
 }
 
 // src/ensindexer/indexing-status/zod-schemas.ts
-var makeChainIndexingConfigSchema = (valueLabel = "Value") => z2.discriminatedUnion("configType", [
-  z2.strictObject({
-    configType: z2.literal(ChainIndexingConfigTypeIds.Indefinite),
+var makeChainIndexingConfigSchema = (valueLabel = "Value") => z4.discriminatedUnion("configType", [
+  z4.strictObject({
+    configType: z4.literal(ChainIndexingConfigTypeIds.Indefinite),
     startBlock: makeBlockRefSchema(valueLabel)
   }),
-  z2.strictObject({
-    configType: z2.literal(ChainIndexingConfigTypeIds.Definite),
+  z4.strictObject({
+    configType: z4.literal(ChainIndexingConfigTypeIds.Definite),
     startBlock: makeBlockRefSchema(valueLabel),
     endBlock: makeBlockRefSchema(valueLabel)
   })
 ]);
-var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => z2.strictObject({
-  chainStatus: z2.literal(ChainIndexingStatusIds.Queued),
+var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => z4.strictObject({
+  chainStatus: z4.literal(ChainIndexingStatusIds.Queued),
   config: makeChainIndexingConfigSchema(valueLabel)
 }).check(invariant_chainSnapshotQueuedBlocks);
-var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => z2.strictObject({
-  chainStatus: z2.literal(ChainIndexingStatusIds.Backfill),
+var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => z4.strictObject({
+  chainStatus: z4.literal(ChainIndexingStatusIds.Backfill),
   config: makeChainIndexingConfigSchema(valueLabel),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
   backfillEndBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotBackfillBlocks);
-var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => z2.strictObject({
-  chainStatus: z2.literal(ChainIndexingStatusIds.Completed),
-  config: z2.strictObject({
-    configType: z2.literal(ChainIndexingConfigTypeIds.Definite),
+var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => z4.strictObject({
+  chainStatus: z4.literal(ChainIndexingStatusIds.Completed),
+  config: z4.strictObject({
+    configType: z4.literal(ChainIndexingConfigTypeIds.Definite),
     startBlock: makeBlockRefSchema(valueLabel),
     endBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotCompletedBlocks);
-var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => z2.strictObject({
-  chainStatus: z2.literal(ChainIndexingStatusIds.Following),
-  config: z2.strictObject({
-    configType: z2.literal(ChainIndexingConfigTypeIds.Indefinite),
+var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => z4.strictObject({
+  chainStatus: z4.literal(ChainIndexingStatusIds.Following),
+  config: z4.strictObject({
+    configType: z4.literal(ChainIndexingConfigTypeIds.Indefinite),
     startBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
   latestKnownBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotFollowingBlocks);
-var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => z2.discriminatedUnion("chainStatus", [
+var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => z4.discriminatedUnion("chainStatus", [
   makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
   makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
   makeChainIndexingStatusSnapshotFollowingSchema(valueLabel)
 ]);
-var makeChainIndexingStatusesSchema = (valueLabel = "Value") => z2.record(makeChainIdStringSchema(), makeChainIndexingStatusSnapshotSchema(valueLabel), {
+var makeChainIndexingStatusesSchema = (valueLabel = "Value") => z4.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();
@@ -1227,29 +1657,29 @@ var makeChainIndexingStatusesSchema = (valueLabel = "Value") => z2.record(makeCh
   }
   return chainsIndexingStatus;
 });
-var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => z2.strictObject({
-  omnichainStatus: z2.literal(OmnichainIndexingStatusIds.Unstarted),
+var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => z4.strictObject({
+  omnichainStatus: z4.literal(OmnichainIndexingStatusIds.Unstarted),
   chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainSnapshotUnstartedHasValidChains).transform((chains) => chains),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => z2.strictObject({
-  omnichainStatus: z2.literal(OmnichainIndexingStatusIds.Backfill),
+var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => z4.strictObject({
+  omnichainStatus: z4.literal(OmnichainIndexingStatusIds.Backfill),
   chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotBackfillHasValidChains).transform(
     (chains) => chains
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => z2.strictObject({
-  omnichainStatus: z2.literal(OmnichainIndexingStatusIds.Completed),
+var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => z4.strictObject({
+  omnichainStatus: z4.literal(OmnichainIndexingStatusIds.Completed),
   chains: makeChainIndexingStatusesSchema(valueLabel).check(invariant_omnichainStatusSnapshotCompletedHasValidChains).transform((chains) => chains),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => z2.strictObject({
-  omnichainStatus: z2.literal(OmnichainIndexingStatusIds.Following),
+var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => z4.strictObject({
+  omnichainStatus: z4.literal(OmnichainIndexingStatusIds.Following),
   chains: makeChainIndexingStatusesSchema(valueLabel),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => z2.discriminatedUnion("omnichainStatus", [
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => z4.discriminatedUnion("omnichainStatus", [
   makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1257,236 +1687,237 @@ var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexin
 ]).check(invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot).check(invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains).check(
   invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains
 ).check(invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain);
-var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => z2.strictObject({
-  strategy: z2.literal(CrossChainIndexingStrategyIds.Omnichain),
+var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => z4.strictObject({
+  strategy: z4.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") => z2.discriminatedUnion("strategy", [
+var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => z4.discriminatedUnion("strategy", [
   makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
 ]);
-var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => z2.strictObject({
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => z4.strictObject({
   projectedAt: makeUnixTimestampSchema(valueLabel),
   worstCaseDistance: makeDurationSchema(valueLabel),
   snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
 }).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
 
-// src/ensindexer/config/zod-schemas.ts
-import z3 from "zod/v4";
-
-// src/ensindexer/config/is-subgraph-compatible.ts
-import { ENSNamespaceIds as ENSNamespaceIds2 } from "@ensnode/datasources";
-
-// src/ensindexer/config/types.ts
-var PluginName = /* @__PURE__ */ ((PluginName2) => {
-  PluginName2["Subgraph"] = "subgraph";
-  PluginName2["Basenames"] = "basenames";
-  PluginName2["Lineanames"] = "lineanames";
-  PluginName2["ThreeDNS"] = "threedns";
-  PluginName2["ProtocolAcceleration"] = "protocol-acceleration";
-  PluginName2["Registrars"] = "registrars";
-  PluginName2["TokenScope"] = "tokenscope";
-  return PluginName2;
-})(PluginName || {});
-
-// src/ensindexer/config/is-subgraph-compatible.ts
-function isSubgraphCompatible(config) {
-  const onlySubgraphPluginActivated = config.plugins.length === 1 && config.plugins[0] === "subgraph" /* Subgraph */;
-  const isSubgraphLabelSet = config.labelSet.labelSetId === "subgraph" && config.labelSet.labelSetVersion === 0;
-  const isEnsTestEnvLabelSet = config.labelSet.labelSetId === "ens-test-env" && config.labelSet.labelSetVersion === 0;
-  const labelSetIsSubgraphCompatible = isSubgraphLabelSet || config.namespace === ENSNamespaceIds2.EnsTestEnv && isEnsTestEnvLabelSet;
-  return onlySubgraphPluginActivated && labelSetIsSubgraphCompatible;
+// src/ensindexer/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:
+${prettifyError4(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
 }
-
-// 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"
-    });
+function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeOmnichainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(maybeSnapshot);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into OmnichainIndexingStatusSnapshot:
+${prettifyError4(parsed.error)}
+`
+    );
   }
+  return parsed.data;
 }
-
-// src/ensindexer/config/zod-schemas.ts
-var makeIndexedChainIdsSchema = (valueLabel = "Indexed Chain IDs") => z3.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") => z3.array(z3.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") => z3.string({ error: `${valueLabel} must be a string` }).trim().nonempty({
-  error: `${valueLabel} is required and must be a non-empty string.`
-});
-var makeLabelSetIdSchema = (valueLabel) => {
-  return z3.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 z3.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 deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
+  const schema = makeCrossChainIndexingStatusSnapshotSchema(valueLabel);
+  const parsed = schema.safeParse(maybeSnapshot);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into CrossChainIndexingStatusSnapshot:
+${prettifyError4(parsed.error)}
+`
+    );
   }
-  return z3.object({
-    labelSetId: makeLabelSetIdSchema(valueLabelLabelSetId),
-    labelSetVersion: makeLabelSetVersionSchema(valueLabelLabelSetVersion)
-  });
-};
-var makeNonEmptyStringSchema = (valueLabel = "Value") => z3.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
-var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => z3.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 deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel) {
+  const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
+  const parsed = schema.safeParse(maybeProjection);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize into RealtimeIndexingStatusProjection:
+${prettifyError4(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;
+}
+
+// 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 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 serializedSnapshots;
+}
+function serializeOmnichainIndexingStatusSnapshot(indexingStatus) {
+  switch (indexingStatus.omnichainStatus) {
+    case OmnichainIndexingStatusIds.Unstarted:
+      return {
+        omnichainStatus: OmnichainIndexingStatusIds.Unstarted,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
+      };
+    case OmnichainIndexingStatusIds.Backfill:
+      return {
+        omnichainStatus: OmnichainIndexingStatusIds.Backfill,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
+      };
+    case OmnichainIndexingStatusIds.Completed: {
+      return {
+        omnichainStatus: OmnichainIndexingStatusIds.Completed,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
+      };
+    }
+    case OmnichainIndexingStatusIds.Following:
+      return {
+        omnichainStatus: OmnichainIndexingStatusIds.Following,
+        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
+        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
+      };
   }
 }
-var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => z3.object({
-  labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
-  indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
-  isSubgraphCompatible: z3.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/build-rpc-urls.ts
-import {
-  arbitrum,
-  arbitrumSepolia,
-  base,
-  baseSepolia,
-  holesky,
-  linea,
-  lineaSepolia,
-  mainnet,
-  optimism,
-  optimismSepolia,
-  scroll,
-  scrollSepolia,
-  sepolia
-} from "viem/chains";
+// src/ensapi/config/serialize.ts
+function serializeENSApiPublicConfig(config) {
+  const { version, theGraphFallback, ensIndexerPublicConfig } = config;
+  return {
+    version,
+    theGraphFallback,
+    ensIndexerPublicConfig: serializeENSIndexerPublicConfig(ensIndexerPublicConfig)
+  };
+}
 
-// src/shared/config/rpc-configs-from-env.ts
-import { getENSNamespace } from "@ensnode/datasources";
+// src/api/config/deserialize.ts
+function deserializeConfigResponse(serializedResponse) {
+  return deserializeENSApiPublicConfig(serializedResponse);
+}
 
-// src/shared/config/validatons.ts
-import { getENSRootChainId as getENSRootChainId2 } from "@ensnode/datasources";
-function invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL(ctx) {
-  const endpoints = ctx.value;
-  const httpEndpoints = endpoints.filter(isHttpProtocol);
-  if (httpEndpoints.length < 1) {
-    ctx.issues.push({
-      code: "custom",
-      input: endpoints,
-      message: `RPC endpoint configuration for a chain must include at least one http/https protocol URL.`
-    });
-  }
+// src/api/config/serialize.ts
+function serializeConfigResponse(response) {
+  return serializeENSApiPublicConfig(response);
 }
-function invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL(ctx) {
-  const endpoints = ctx.value;
-  const wsEndpoints = endpoints.filter(isWebSocketProtocol);
-  if (wsEndpoints.length > 1) {
+
+// src/api/indexing-status/deserialize.ts
+import { prettifyError as prettifyError5 } from "zod/v4";
+
+// src/api/indexing-status/zod-schemas.ts
+import z11 from "zod/v4";
+
+// src/api/registrar-actions/zod-schemas.ts
+import { namehash as namehash2 } from "viem/ens";
+import z6 from "zod/v4";
+
+// src/api/shared/errors/zod-schemas.ts
+import z5 from "zod/v4";
+var ErrorResponseSchema = z5.object({
+  message: z5.string(),
+  details: z5.optional(z5.unknown())
+});
+
+// src/api/registrar-actions/response.ts
+var RegistrarActionsResponseCodes = {
+  /**
+   * Represents that Registrar Actions are available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that Registrar Actions are unavailable.
+   */
+  Error: "error"
+};
+
+// src/api/registrar-actions/zod-schemas.ts
+function invariant_registrationLifecycleNodeMatchesName(ctx) {
+  const { name, action } = ctx.value;
+  const expectedNode = action.registrationLifecycle.node;
+  const actualNode = namehash2(name);
+  if (actualNode !== expectedNode) {
     ctx.issues.push({
       code: "custom",
-      input: endpoints,
-      message: `RPC endpoint configuration for a chain must include at most one websocket (ws/wss) protocol URL.`
+      input: ctx.value,
+      message: `The 'action.registrationLifecycle.node' must match namehash of 'name'`
     });
   }
 }
-
-// src/shared/config/zod-schemas.ts
-import { z as z4 } from "zod/v4";
-import { ENSNamespaceIds as ENSNamespaceIds3 } from "@ensnode/datasources";
-var DatabaseSchemaNameSchema = z4.string({
-  error: "DATABASE_SCHEMA is required."
-}).trim().min(1, {
-  error: "DATABASE_SCHEMA is required and cannot be an empty string."
-});
-var RpcConfigSchema = z4.string().transform((val) => val.split(",")).pipe(z4.array(makeUrlSchema("RPC URL"))).check(invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL).check(invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL);
-var RpcConfigsSchema = z4.record(makeChainIdStringSchema("RPC URL"), RpcConfigSchema, {
-  error: "Chains configuration must be an object mapping valid chain IDs to their configs."
-}).transform((records) => {
-  const rpcConfigs = /* @__PURE__ */ new Map();
-  for (const [chainIdString, rpcConfig] of Object.entries(records)) {
-    const httpRPCs = rpcConfig.filter(isHttpProtocol);
-    const websocketRPC = rpcConfig.find(isWebSocketProtocol);
-    rpcConfigs.set(deserializeChainId(chainIdString), {
-      httpRPCs,
-      websocketRPC
-    });
-  }
-  return rpcConfigs;
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => z6.object({
+  action: makeRegistrarActionSchema(valueLabel),
+  name: makeReinterpretedNameSchema(valueLabel)
+}).check(invariant_registrationLifecycleNodeMatchesName);
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => z6.strictObject({
+  responseCode: z6.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: z6.array(makeNamedRegistrarActionSchema(valueLabel))
 });
-var EnsIndexerUrlSchema = makeUrlSchema("ENSINDEXER_URL");
-var ENSNamespaceSchema = z4.enum(ENSNamespaceIds3, {
-  error: ({ input }) => `Invalid NAMESPACE. Got '${input}', but supported ENS namespaces are: ${Object.keys(ENSNamespaceIds3).join(", ")}`
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => z6.strictObject({
+  responseCode: z6.literal(RegistrarActionsResponseCodes.Error),
+  error: ErrorResponseSchema
 });
-var PortSchema = z4.coerce.number({ error: "PORT must be a number." }).min(1, { error: "PORT must be greater than 1." }).max(65535, { error: "PORT must be less than 65535" }).optional();
-var TheGraphApiKeySchema = z4.string().optional();
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => z6.discriminatedUnion("responseCode", [
+  makeRegistrarActionsResponseOkSchema(valueLabel),
+  makeRegistrarActionsResponseErrorSchema(valueLabel)
+]);
 
-// src/shared/datasources-with-resolvers.ts
-import {
-  DatasourceNames,
-  maybeGetDatasource
-} from "@ensnode/datasources";
-var DATASOURCE_NAMES_WITH_RESOLVERS = [
-  DatasourceNames.ENSRoot,
-  DatasourceNames.Basenames,
-  DatasourceNames.Lineanames,
-  DatasourceNames.ThreeDNSOptimism,
-  DatasourceNames.ThreeDNSBase
-];
+// src/api/shared/pagination/zod-schemas.ts
+import z7 from "zod/v4";
 
-// src/shared/log-level.ts
-import { z as z5 } from "zod/v4";
-var LogLevelSchema = z5.enum(["fatal", "error", "warn", "info", "debug", "trace", "silent"]);
+// src/api/shared/pagination/request.ts
+var RECORDS_PER_PAGE_DEFAULT = 10;
+var RECORDS_PER_PAGE_MAX = 100;
 
-// src/shared/protocol-acceleration/interpret-record-values.ts
-import { isAddress as isAddress3, isAddressEqual as isAddressEqual2, zeroAddress } from "viem";
+// ../ens-referrals/src/address.ts
+import { isAddress as isAddress3 } from "viem";
 
-// ../ens-referrals/src/referrer.ts
-import { getAddress, pad, size as size2, slice, zeroAddress as zeroAddress2 } from "viem";
+// ../ens-referrals/src/encoding.ts
+import { getAddress, pad, size as size2, slice, zeroAddress } from "viem";
 var ENCODED_REFERRER_BYTE_OFFSET = 12;
 var ENCODED_REFERRER_BYTE_LENGTH = 32;
-var encodedReferrerPadding = pad("0x", {
+var EXPECTED_ENCODED_REFERRER_PADDING = pad("0x", {
   size: ENCODED_REFERRER_BYTE_OFFSET,
   dir: "left"
 });
-var zeroEncodedReferrer = pad("0x", {
+var ZERO_ENCODED_REFERRER = pad("0x", {
   size: ENCODED_REFERRER_BYTE_LENGTH,
   dir: "left"
 });
@@ -1497,8 +1928,8 @@ function decodeEncodedReferrer(encodedReferrer) {
     );
   }
   const padding = slice(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
-  if (padding !== encodedReferrerPadding) {
-    return zeroAddress2;
+  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
+    return zeroAddress;
   }
   const decodedReferrer = slice(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
   try {
@@ -1508,8 +1939,26 @@ function decodeEncodedReferrer(encodedReferrer) {
   }
 }
 
+// ../ens-referrals/src/leaderboard-page.ts
+var REFERRERS_PER_LEADERBOARD_PAGE_MAX = 100;
+
+// ../ens-referrals/src/link.ts
+import { getAddress as getAddress2 } from "viem";
+
+// ../ens-referrals/src/referrer-detail.ts
+var ReferrerDetailTypeIds = {
+  /**
+   * Represents a referrer who is ranked on the leaderboard.
+   */
+  Ranked: "ranked",
+  /**
+   * Represents a referrer who is not ranked on the leaderboard.
+   */
+  Unranked: "unranked"
+};
+
 // src/registrars/zod-schemas.ts
-import z6 from "zod/v4";
+import z8 from "zod/v4";
 
 // src/registrars/subregistry.ts
 function serializeSubregistry(subregistry) {
@@ -1567,11 +2016,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => z6.object({
+var makeSubregistrySchema = (valueLabel = "Subregistry") => z8.object({
   subregistryId: makeSerializedAccountIdSchema(`${valueLabel} Subregistry ID`),
   node: makeNodeSchema(`${valueLabel} Node`)
 });
-var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => z6.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => z8.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -1587,18 +2036,18 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => z6.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => z8.union([
   // pricing available
-  z6.object({
+  z8.object({
     baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
     premium: makePriceEthSchema(`${valueLabel} Premium`),
     total: makePriceEthSchema(`${valueLabel} Total`)
   }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
   // pricing unknown
-  z6.object({
-    baseCost: z6.null(),
-    premium: z6.null(),
-    total: z6.null()
+  z8.object({
+    baseCost: z8.null(),
+    premium: z8.null(),
+    total: z8.null()
   }).transform((v) => v)
 ]);
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
@@ -1621,9 +2070,9 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
     });
   }
 }
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => z6.union([
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => z8.union([
   // referral available
-  z6.object({
+  z8.object({
     encodedReferrer: makeHexStringSchema(
       { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
       `${valueLabel} Encoded Referrer`
@@ -1631,9 +2080,9 @@ var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral
     decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
   }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
   // referral not applicable
-  z6.object({
-    encodedReferrer: z6.null(),
-    decodedReferrer: z6.null()
+  z8.object({
+    encodedReferrer: z8.null(),
+    decodedReferrer: z8.null()
   })
 ]);
 function invariant_eventIdsInitialElementIsTheActionId(ctx) {
@@ -1646,9 +2095,9 @@ function invariant_eventIdsInitialElementIsTheActionId(ctx) {
     });
   }
 }
-var EventIdSchema = z6.string().nonempty();
-var EventIdsSchema = z6.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => z6.object({
+var EventIdSchema = z8.string().nonempty();
+var EventIdsSchema = z8.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => z8.object({
   id: EventIdSchema,
   incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
   registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`),
@@ -1662,380 +2111,205 @@ var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => z6
   eventIds: EventIdsSchema
 }).check(invariant_eventIdsInitialElementIsTheActionId);
 var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: z6.literal(RegistrarActionTypes.Registration)
+  type: z8.literal(RegistrarActionTypes.Registration)
 });
 var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: z6.literal(RegistrarActionTypes.Renewal)
+  type: z8.literal(RegistrarActionTypes.Renewal)
 });
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => z6.discriminatedUnion("type", [
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => z8.discriminatedUnion("type", [
   makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
   makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
 ]);
 
-// src/api/types.ts
-var IndexingStatusResponseCodes = {
-  /**
-   * Represents that the indexing status is available.
-   */
-  Ok: "ok",
-  /**
-   * Represents that the indexing status is unavailable.
-   */
-  Error: "error"
-};
-var RegistrarActionsFilterTypes = {
-  BySubregistryNode: "bySubregistryNode",
-  WithEncodedReferral: "withEncodedReferral"
-};
-var RegistrarActionsOrders = {
-  LatestRegistrarActions: "orderBy[timestamp]=desc"
-};
-var RegistrarActionsResponseCodes = {
-  /**
-   * Represents that Registrar Actions are available.
-   */
-  Ok: "ok",
-  /**
-   * Represents that Registrar Actions are unavailable.
-   */
-  Error: "error"
-};
-
-// src/api/zod-schemas.ts
-var ErrorResponseSchema = z7.object({
-  message: z7.string(),
-  details: z7.optional(z7.unknown())
-});
-var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z7.strictObject({
-  responseCode: z7.literal(IndexingStatusResponseCodes.Ok),
-  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
-});
-var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => z7.strictObject({
-  responseCode: z7.literal(IndexingStatusResponseCodes.Error)
-});
-var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z7.discriminatedUnion("responseCode", [
-  makeIndexingStatusResponseOkSchema(valueLabel),
-  makeIndexingStatusResponseErrorSchema(valueLabel)
-]);
-function invariant_registrationLifecycleNodeMatchesName(ctx) {
-  const { name, action } = ctx.value;
-  const expectedNode = action.registrationLifecycle.node;
-  const actualNode = namehash2(name);
-  if (actualNode !== expectedNode) {
-    ctx.issues.push({
-      code: "custom",
-      input: ctx.value,
-      message: `The 'action.registrationLifecycle.node' must match namehash of 'name'`
-    });
-  }
-}
-var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => z7.object({
-  action: makeRegistrarActionSchema(valueLabel),
-  name: makeReinterpretedNameSchema(valueLabel)
-}).check(invariant_registrationLifecycleNodeMatchesName);
-var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => z7.strictObject({
-  responseCode: z7.literal(RegistrarActionsResponseCodes.Ok),
-  registrarActions: z7.array(makeNamedRegistrarActionSchema(valueLabel))
-});
-var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => z7.strictObject({
-  responseCode: z7.literal(RegistrarActionsResponseCodes.Error),
-  error: ErrorResponseSchema
-});
-var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => z7.discriminatedUnion("responseCode", [
-  makeRegistrarActionsResponseOkSchema(valueLabel),
-  makeRegistrarActionsResponseErrorSchema(valueLabel)
-]);
-
-// src/api/deserialize.ts
-function deserializeErrorResponse(maybeErrorResponse) {
-  const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize ErrorResponse:
-${prettifyError2(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
-function deserializeIndexingStatusResponse(maybeResponse) {
-  const parsed = makeIndexingStatusResponseSchema().safeParse(maybeResponse);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize IndexingStatusResponse:
-${prettifyError2(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
-function deserializeRegistrarActionsResponse(maybeResponse) {
-  const parsed = makeRegistrarActionsResponseSchema().safeParse(maybeResponse);
-  if (parsed.error) {
-    throw new Error(
-      `Cannot deserialize RegistrarActionsResponse:
-${prettifyError2(parsed.error)}
-`
-    );
-  }
-  return parsed.data;
-}
-
-// src/api/registrar-actions/filters.ts
-function byParentNode(parentNode) {
-  if (typeof parentNode === "undefined") {
-    return void 0;
-  }
-  return {
-    filterType: RegistrarActionsFilterTypes.BySubregistryNode,
-    value: parentNode
-  };
-}
-function withReferral(withReferral2) {
-  if (!withReferral2) {
-    return void 0;
-  }
-  return {
-    filterType: RegistrarActionsFilterTypes.WithEncodedReferral
-  };
-}
-var registrarActionsFilter = {
-  byParentNode,
-  withReferral
-};
-
-// src/ensindexer/config/deserialize.ts
-import { prettifyError as prettifyError3 } from "zod/v4";
-function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
-  const schema = makeENSIndexerPublicConfigSchema(valueLabel);
-  const parsed = schema.safeParse(maybeConfig);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize ENSIndexerPublicConfig:
-${prettifyError3(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
-
-// src/ensindexer/config/label-utils.ts
-import { hexToBytes as hexToBytes2 } from "viem";
-function labelHashToBytes(labelHash) {
-  try {
-    if (labelHash.length !== 66) {
-      throw new Error(`Invalid labelHash length ${labelHash.length} characters (expected 66)`);
-    }
-    if (labelHash !== labelHash.toLowerCase()) {
-      throw new Error("Labelhash must be in lowercase");
-    }
-    if (!labelHash.startsWith("0x")) {
-      throw new Error("Labelhash must be 0x-prefixed");
-    }
-    const bytes = hexToBytes2(labelHash);
-    if (bytes.length !== 32) {
-      throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
-    }
-    return bytes;
-  } catch (e) {
-    if (e instanceof Error) {
-      throw e;
-    }
-    throw new Error("Invalid hex format");
-  }
-}
+// src/shared/config/build-rpc-urls.ts
+import {
+  arbitrum,
+  arbitrumSepolia,
+  base,
+  baseSepolia,
+  holesky,
+  linea,
+  lineaSepolia,
+  mainnet,
+  optimism,
+  optimismSepolia,
+  scroll,
+  scrollSepolia,
+  sepolia
+} from "viem/chains";
 
-// 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.");
+// src/shared/config/rpc-configs-from-env.ts
+import { getENSNamespace } from "@ensnode/datasources";
+
+// src/shared/config/validatons.ts
+import { getENSRootChainId as getENSRootChainId2 } from "@ensnode/datasources";
+function invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL(ctx) {
+  const endpoints = ctx.value;
+  const httpEndpoints = endpoints.filter(isHttpProtocol);
+  if (httpEndpoints.length < 1) {
+    ctx.issues.push({
+      code: "custom",
+      input: endpoints,
+      message: `RPC endpoint configuration for a chain must include at least one http/https protocol URL.`
+    });
   }
-  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}".`
-    );
+function invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL(ctx) {
+  const endpoints = ctx.value;
+  const wsEndpoints = endpoints.filter(isWebSocketProtocol);
+  if (wsEndpoints.length > 1) {
+    ctx.issues.push({
+      code: "custom",
+      input: endpoints,
+      message: `RPC endpoint configuration for a chain must include at most one websocket (ws/wss) protocol URL.`
+    });
   }
 }
 
-// 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`);
+// src/shared/config/zod-schemas.ts
+import { z as z9 } from "zod/v4";
+import { ENSNamespaceIds as ENSNamespaceIds3 } from "@ensnode/datasources";
+var DatabaseSchemaNameSchema = z9.string({
+  error: "DATABASE_SCHEMA is required."
+}).trim().min(1, {
+  error: "DATABASE_SCHEMA is required and cannot be an empty string."
+});
+var RpcConfigSchema = z9.string().transform((val) => val.split(",")).pipe(z9.array(makeUrlSchema("RPC URL"))).check(invariant_rpcEndpointConfigIncludesAtLeastOneHTTPProtocolURL).check(invariant_rpcEndpointConfigIncludesAtMostOneWebSocketsProtocolURL);
+var RpcConfigsSchema = z9.record(makeChainIdStringSchema("RPC URL"), RpcConfigSchema, {
+  error: "Chains configuration must be an object mapping valid chain IDs to their configs."
+}).transform((records) => {
+  const rpcConfigs = /* @__PURE__ */ new Map();
+  for (const [chainIdString, rpcConfig] of Object.entries(records)) {
+    const httpRPCs = rpcConfig.filter(isHttpProtocol);
+    const websocketRPC = rpcConfig.find(isWebSocketProtocol);
+    rpcConfigs.set(deserializeChainId(chainIdString), {
+      httpRPCs,
+      websocketRPC
+    });
   }
-  return num;
-}
+  return rpcConfigs;
+});
+var EnsIndexerUrlSchema = makeUrlSchema("ENSINDEXER_URL");
+var ENSNamespaceSchema = z9.enum(ENSNamespaceIds3, {
+  error: ({ input }) => `Invalid NAMESPACE. Got '${input}', but supported ENS namespaces are: ${Object.keys(ENSNamespaceIds3).join(", ")}`
+});
+var PortSchema = z9.coerce.number({ error: "PORT must be a number." }).min(1, { error: "PORT must be greater than 1." }).max(65535, { error: "PORT must be less than 65535" }).optional();
+var TheGraphApiKeySchema = z9.string().optional();
 
-// 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/shared/datasources-with-resolvers.ts
+import {
+  DatasourceNames,
+  maybeGetDatasource
+} from "@ensnode/datasources";
+var DATASOURCE_NAMES_WITH_RESOLVERS = [
+  DatasourceNames.ENSRoot,
+  DatasourceNames.Basenames,
+  DatasourceNames.Lineanames,
+  DatasourceNames.ThreeDNSOptimism,
+  DatasourceNames.ThreeDNSBase
+];
 
-// src/ensindexer/indexing-status/deserialize.ts
-import { prettifyError as prettifyError4 } from "zod/v4";
-function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
-  const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
-  const parsed = schema.safeParse(maybeSnapshot);
-  if (parsed.error) {
-    throw new Error(
-      `Cannot deserialize into ChainIndexingStatusSnapshot:
-${prettifyError4(parsed.error)}
-`
-    );
-  }
-  return parsed.data;
-}
-function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
-  const schema = makeOmnichainIndexingStatusSnapshotSchema(valueLabel);
-  const parsed = schema.safeParse(maybeSnapshot);
+// src/shared/log-level.ts
+import { z as z10 } from "zod/v4";
+var LogLevelSchema = z10.enum(["fatal", "error", "warn", "info", "debug", "trace", "silent"]);
+
+// src/shared/protocol-acceleration/interpret-record-values.ts
+import { isAddress as isAddress4, isAddressEqual as isAddressEqual2, zeroAddress as zeroAddress2 } from "viem";
+
+// src/api/indexing-status/response.ts
+var IndexingStatusResponseCodes = {
+  /**
+   * Represents that the indexing status is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that the indexing status is unavailable.
+   */
+  Error: "error"
+};
+
+// src/api/indexing-status/zod-schemas.ts
+var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => z11.strictObject({
+  responseCode: z11.literal(IndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
+});
+var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => z11.strictObject({
+  responseCode: z11.literal(IndexingStatusResponseCodes.Error)
+});
+var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => z11.discriminatedUnion("responseCode", [
+  makeIndexingStatusResponseOkSchema(valueLabel),
+  makeIndexingStatusResponseErrorSchema(valueLabel)
+]);
+
+// src/api/indexing-status/deserialize.ts
+function deserializeIndexingStatusResponse(maybeResponse) {
+  const parsed = makeIndexingStatusResponseSchema().safeParse(maybeResponse);
   if (parsed.error) {
-    throw new Error(
-      `Cannot deserialize into OmnichainIndexingStatusSnapshot:
-${prettifyError4(parsed.error)}
-`
-    );
+    throw new Error(`Cannot deserialize IndexingStatusResponse:
+${prettifyError5(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:
-${prettifyError4(parsed.error)}
-`
-    );
+
+// src/api/indexing-status/serialize.ts
+function serializeIndexingStatusResponse(response) {
+  switch (response.responseCode) {
+    case IndexingStatusResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection)
+      };
+    case IndexingStatusResponseCodes.Error:
+      return response;
   }
-  return parsed.data;
 }
-function deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel) {
-  const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
-  const parsed = schema.safeParse(maybeProjection);
+
+// src/api/registrar-actions/deserialize.ts
+import { prettifyError as prettifyError6 } from "zod/v4";
+function deserializeRegistrarActionsResponse(maybeResponse) {
+  const parsed = makeRegistrarActionsResponseSchema().safeParse(maybeResponse);
   if (parsed.error) {
     throw new Error(
-      `Cannot deserialize into RealtimeIndexingStatusProjection:
-${prettifyError4(parsed.error)}
+      `Cannot deserialize RegistrarActionsResponse:
+${prettifyError6(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/api/registrar-actions/request.ts
+var RegistrarActionsFilterTypes = {
+  BySubregistryNode: "bySubregistryNode",
+  WithEncodedReferral: "withEncodedReferral"
+};
+var RegistrarActionsOrders = {
+  LatestRegistrarActions: "orderBy[timestamp]=desc"
+};
 
-// src/ensindexer/indexing-status/serialize.ts
-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;
+// src/api/registrar-actions/filters.ts
+function byParentNode(parentNode) {
+  if (typeof parentNode === "undefined") {
+    return void 0;
   }
-  return serializedSnapshots;
+  return {
+    filterType: RegistrarActionsFilterTypes.BySubregistryNode,
+    value: parentNode
+  };
 }
-function serializeOmnichainIndexingStatusSnapshot(indexingStatus) {
-  switch (indexingStatus.omnichainStatus) {
-    case OmnichainIndexingStatusIds.Unstarted:
-      return {
-        omnichainStatus: OmnichainIndexingStatusIds.Unstarted,
-        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
-        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
-      };
-    case OmnichainIndexingStatusIds.Backfill:
-      return {
-        omnichainStatus: OmnichainIndexingStatusIds.Backfill,
-        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
-        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
-      };
-    case OmnichainIndexingStatusIds.Completed: {
-      return {
-        omnichainStatus: OmnichainIndexingStatusIds.Completed,
-        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
-        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
-      };
-    }
-    case OmnichainIndexingStatusIds.Following:
-      return {
-        omnichainStatus: OmnichainIndexingStatusIds.Following,
-        chains: serializeChainIndexingSnapshots(indexingStatus.chains),
-        omnichainIndexingCursor: indexingStatus.omnichainIndexingCursor
-      };
+function withReferral(withReferral2) {
+  if (!withReferral2) {
+    return void 0;
   }
+  return {
+    filterType: RegistrarActionsFilterTypes.WithEncodedReferral
+  };
 }
+var registrarActionsFilter = {
+  byParentNode,
+  withReferral
+};
 
 // src/api/registrar-actions/prerequisites.ts
 var registrarActionsPrerequisites = Object.freeze({
@@ -2104,18 +2378,7 @@ function getEthnamesSubregistryId(namespace) {
   };
 }
 
-// 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/api/registrar-actions/serialize.ts
 function serializeNamedRegistrarAction({
   action,
   name
@@ -2137,6 +2400,18 @@ function serializeRegistrarActionsResponse(response) {
   }
 }
 
+// src/api/shared/errors/deserialize.ts
+import { prettifyError as prettifyError7 } from "zod/v4";
+function deserializeErrorResponse(maybeErrorResponse) {
+  const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ErrorResponse:
+${prettifyError7(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
 // src/client-error.ts
 var ClientError = class _ClientError extends Error {
   details;
@@ -2151,160 +2426,195 @@ var ClientError = class _ClientError extends Error {
 };
 
 // src/ensanalytics/deserialize.ts
-import { prettifyError as prettifyError5 } from "zod/v4";
+import { prettifyError as prettifyError8 } from "zod/v4";
 
 // src/ensanalytics/zod-schemas.ts
-import z8 from "zod/v4";
+import z12 from "zod/v4";
 
 // src/ensanalytics/types.ts
-var ITEMS_PER_PAGE_DEFAULT = 25;
-var ITEMS_PER_PAGE_MAX = 100;
-var PaginatedAggregatedReferrersResponseCodes = {
+var ReferrerLeaderboardPageResponseCodes = {
+  /**
+   * Represents that the requested referrer leaderboard page is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that the referrer leaderboard data is not available.
+   */
+  Error: "error"
+};
+var ReferrerDetailResponseCodes = {
   /**
-   * Represents that the aggregated referrers data is available.
-   * @note The response may contain an empty array for the first page if there are no qualified referrers.
-   * When the array is empty, total will be 0, page will be 1, and both hasNext and hasPrev will be false.
+   * Represents that the referrer detail data is available.
    */
   Ok: "ok",
   /**
-   * Represents that the aggregated referrers data is not available.
+   * Represents that an error occurred while fetching the data.
    */
   Error: "error"
 };
 
 // src/ensanalytics/zod-schemas.ts
-var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetrics") => z8.object({
+var makeReferralProgramRulesSchema = (valueLabel = "ReferralProgramRules") => z12.object({
+  totalAwardPoolValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.totalAwardPoolValue`),
+  maxQualifiedReferrers: makeNonNegativeIntegerSchema(`${valueLabel}.maxQualifiedReferrers`),
+  startTime: makeUnixTimestampSchema(`${valueLabel}.startTime`),
+  endTime: makeUnixTimestampSchema(`${valueLabel}.endTime`),
+  subregistryId: makeAccountIdSchema(`${valueLabel}.subregistryId`)
+});
+var makeAwardedReferrerMetricsSchema = (valueLabel = "AwardedReferrerMetrics") => z12.object({
   referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
-  totalReferrals: makePositiveIntegerSchema(`${valueLabel}.totalReferrals`),
-  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`)
+  totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
+  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
+  rank: makePositiveIntegerSchema(`${valueLabel}.rank`),
+  isQualified: z12.boolean(),
+  finalScoreBoost: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScoreBoost`).max(
+    1,
+    `${valueLabel}.finalScoreBoost must be <= 1`
+  ),
+  finalScore: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScore`),
+  awardPoolShare: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolShare`).max(
+    1,
+    `${valueLabel}.awardPoolShare must be <= 1`
+  ),
+  awardPoolApproxValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolApproxValue`)
 });
-var makeAggregatedReferrerMetricsContributionSchema = (valueLabel = "AggregatedReferrerMetricsContribution") => makeAggregatedReferrerMetricsSchema(valueLabel).extend({
-  totalReferralsContribution: z8.number({
-    error: `${valueLabel}.totalReferralsContribution must be a number`
-  }).min(0, `${valueLabel}.totalReferralsContribution must be >= 0`).max(1, `${valueLabel}.totalReferralsContribution must be <= 1`),
-  totalIncrementalDurationContribution: z8.number({
-    error: `${valueLabel}.totalIncrementalDurationContribution must be a number`
-  }).min(0, `${valueLabel}.totalIncrementalDurationContribution must be >= 0`).max(1, `${valueLabel}.totalIncrementalDurationContribution must be <= 1`)
+var makeUnrankedReferrerMetricsSchema = (valueLabel = "UnrankedReferrerMetrics") => z12.object({
+  referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
+  totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
+  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
+  rank: z12.null(),
+  isQualified: z12.literal(false),
+  finalScoreBoost: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScoreBoost`).max(
+    1,
+    `${valueLabel}.finalScoreBoost must be <= 1`
+  ),
+  finalScore: makeFiniteNonNegativeNumberSchema(`${valueLabel}.finalScore`),
+  awardPoolShare: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolShare`).max(
+    1,
+    `${valueLabel}.awardPoolShare must be <= 1`
+  ),
+  awardPoolApproxValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.awardPoolApproxValue`)
 });
-var makePaginationParamsSchema = (valueLabel = "PaginationParams") => z8.object({
-  page: makePositiveIntegerSchema(`${valueLabel}.page`).default(1),
-  itemsPerPage: makePositiveIntegerSchema(`${valueLabel}.itemsPerPage`).max(ITEMS_PER_PAGE_MAX, `${valueLabel}.itemsPerPage must not exceed ${ITEMS_PER_PAGE_MAX}`).default(ITEMS_PER_PAGE_DEFAULT)
+var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetrics") => z12.object({
+  grandTotalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.grandTotalReferrals`),
+  grandTotalIncrementalDuration: makeDurationSchema(
+    `${valueLabel}.grandTotalIncrementalDuration`
+  ),
+  grandTotalQualifiedReferrersFinalScore: makeFiniteNonNegativeNumberSchema(
+    `${valueLabel}.grandTotalQualifiedReferrersFinalScore`
+  ),
+  minFinalScoreToQualify: makeFiniteNonNegativeNumberSchema(
+    `${valueLabel}.minFinalScoreToQualify`
+  )
 });
-var makePaginatedAggregatedReferrersSchema = (valueLabel = "PaginatedAggregatedReferrers") => z8.object({
-  referrers: z8.array(
-    makeAggregatedReferrerMetricsContributionSchema(`${valueLabel}.referrers[item]`)
+var makeReferrerLeaderboardPageContextSchema = (valueLabel = "ReferrerLeaderboardPageContext") => z12.object({
+  page: makePositiveIntegerSchema(`${valueLabel}.page`),
+  itemsPerPage: makePositiveIntegerSchema(`${valueLabel}.itemsPerPage`).max(
+    REFERRERS_PER_LEADERBOARD_PAGE_MAX,
+    `${valueLabel}.itemsPerPage must not exceed ${REFERRERS_PER_LEADERBOARD_PAGE_MAX}`
   ),
-  total: makeNonNegativeIntegerSchema(`${valueLabel}.total`),
-  paginationParams: makePaginationParamsSchema(`${valueLabel}.paginationParams`),
-  hasNext: z8.boolean(),
-  hasPrev: z8.boolean(),
-  updatedAt: makeUnixTimestampSchema(`${valueLabel}.updatedAt`)
-}).check((ctx) => {
-  const { paginationParams, hasNext, hasPrev, total } = ctx.value;
-  const expectedHasPrev = paginationParams.page > 1;
-  if (hasPrev !== expectedHasPrev) {
-    ctx.issues.push({
-      code: "custom",
-      message: `${valueLabel}.hasPrev must be ${expectedHasPrev} when page is ${paginationParams.page}`,
-      input: ctx.value
-    });
-  }
-  const endIndex = paginationParams.page * paginationParams.itemsPerPage;
-  const expectedHasNext = endIndex < total;
-  if (hasNext !== expectedHasNext) {
-    ctx.issues.push({
-      code: "custom",
-      message: `${valueLabel}.hasNext must be ${expectedHasNext} when page=${paginationParams.page}, itemsPerPage=${paginationParams.itemsPerPage}, total=${total}`,
-      input: ctx.value
-    });
-  }
+  totalRecords: makeNonNegativeIntegerSchema(`${valueLabel}.totalRecords`),
+  totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
+  hasNext: z12.boolean(),
+  hasPrev: z12.boolean(),
+  startIndex: z12.optional(makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`)),
+  endIndex: z12.optional(makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`))
+});
+var makeReferrerLeaderboardPageSchema = (valueLabel = "ReferrerLeaderboardPage") => z12.object({
+  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
+  referrers: z12.array(makeAwardedReferrerMetricsSchema(`${valueLabel}.referrers[item]`)),
+  aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
+  paginationContext: makeReferrerLeaderboardPageContextSchema(`${valueLabel}.paginationContext`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+});
+var makeReferrerLeaderboardPageResponseOkSchema = (valueLabel = "ReferrerLeaderboardPageResponseOk") => z12.object({
+  responseCode: z12.literal(ReferrerLeaderboardPageResponseCodes.Ok),
+  data: makeReferrerLeaderboardPageSchema(`${valueLabel}.data`)
+});
+var makeReferrerLeaderboardPageResponseErrorSchema = (_valueLabel = "ReferrerLeaderboardPageResponseError") => z12.object({
+  responseCode: z12.literal(ReferrerLeaderboardPageResponseCodes.Error),
+  error: z12.string(),
+  errorMessage: z12.string()
+});
+var makeReferrerLeaderboardPageResponseSchema = (valueLabel = "ReferrerLeaderboardPageResponse") => z12.union([
+  makeReferrerLeaderboardPageResponseOkSchema(valueLabel),
+  makeReferrerLeaderboardPageResponseErrorSchema(valueLabel)
+]);
+var makeReferrerDetailRankedSchema = (valueLabel = "ReferrerDetailRanked") => z12.object({
+  type: z12.literal(ReferrerDetailTypeIds.Ranked),
+  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
+  referrer: makeAwardedReferrerMetricsSchema(`${valueLabel}.referrer`),
+  aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+});
+var makeReferrerDetailUnrankedSchema = (valueLabel = "ReferrerDetailUnranked") => z12.object({
+  type: z12.literal(ReferrerDetailTypeIds.Unranked),
+  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
+  referrer: makeUnrankedReferrerMetricsSchema(`${valueLabel}.referrer`),
+  aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
-var makePaginatedAggregatedReferrersResponseOkSchema = (valueLabel = "PaginatedAggregatedReferrersResponse") => z8.object({
-  responseCode: z8.literal(PaginatedAggregatedReferrersResponseCodes.Ok),
-  data: makePaginatedAggregatedReferrersSchema(`${valueLabel}.data`)
+var makeReferrerDetailResponseOkSchema = (valueLabel = "ReferrerDetailResponse") => z12.object({
+  responseCode: z12.literal(ReferrerDetailResponseCodes.Ok),
+  data: z12.union([
+    makeReferrerDetailRankedSchema(`${valueLabel}.data`),
+    makeReferrerDetailUnrankedSchema(`${valueLabel}.data`)
+  ])
 });
-var makePaginatedAggregatedReferrersResponseErrorSchema = (_valueLabel = "PaginatedAggregatedReferrersResponse") => z8.object({
-  responseCode: z8.literal(PaginatedAggregatedReferrersResponseCodes.Error),
-  error: z8.string(),
-  errorMessage: z8.string()
+var makeReferrerDetailResponseErrorSchema = (_valueLabel = "ReferrerDetailResponse") => z12.object({
+  responseCode: z12.literal(ReferrerDetailResponseCodes.Error),
+  error: z12.string(),
+  errorMessage: z12.string()
 });
-var makePaginatedAggregatedReferrersResponseSchema = (valueLabel = "PaginatedAggregatedReferrersResponse") => z8.union([
-  makePaginatedAggregatedReferrersResponseOkSchema(valueLabel),
-  makePaginatedAggregatedReferrersResponseErrorSchema(valueLabel)
+var makeReferrerDetailResponseSchema = (valueLabel = "ReferrerDetailResponse") => z12.union([
+  makeReferrerDetailResponseOkSchema(valueLabel),
+  makeReferrerDetailResponseErrorSchema(valueLabel)
 ]);
 
 // src/ensanalytics/deserialize.ts
-function deserializePaginatedAggregatedReferrersResponse(maybeResponse, valueLabel) {
-  const schema = makePaginatedAggregatedReferrersResponseSchema(valueLabel);
+function deserializeReferrerLeaderboardPageResponse(maybeResponse, valueLabel) {
+  const schema = makeReferrerLeaderboardPageResponseSchema(valueLabel);
   const parsed = schema.safeParse(maybeResponse);
   if (parsed.error) {
     throw new Error(
-      `Cannot deserialize PaginatedAggregatedReferrersResponse:
-${prettifyError5(parsed.error)}
+      `Cannot deserialize SerializedReferrerLeaderboardPageResponse:
+${prettifyError8(parsed.error)}
 `
     );
   }
   return parsed.data;
 }
+function deserializeReferrerDetailResponse(maybeResponse, valueLabel) {
+  const schema = makeReferrerDetailResponseSchema(valueLabel);
+  const parsed = schema.safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ReferrerDetailResponse:
+${prettifyError8(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
 
 // src/ensanalytics/serialize.ts
-function serializePaginatedAggregatedReferrersResponse(response) {
+function serializeReferrerLeaderboardPageResponse(response) {
   switch (response.responseCode) {
-    case PaginatedAggregatedReferrersResponseCodes.Ok:
+    case ReferrerLeaderboardPageResponseCodes.Ok:
       return response;
-    case PaginatedAggregatedReferrersResponseCodes.Error:
+    case ReferrerLeaderboardPageResponseCodes.Error:
       return response;
   }
 }
-
-// src/ensapi/config/deserialize.ts
-import { prettifyError as prettifyError6, ZodError } from "zod/v4";
-
-// src/ensapi/config/zod-schemas.ts
-import { z as z9 } from "zod/v4";
-var TheGraphCannotFallbackReasonSchema = z9.enum({
-  NotSubgraphCompatible: "not-subgraph-compatible",
-  NoApiKey: "no-api-key",
-  NoSubgraphUrl: "no-subgraph-url"
-});
-var TheGraphFallbackSchema = z9.strictObject({
-  canFallback: z9.boolean(),
-  reason: TheGraphCannotFallbackReasonSchema.nullable()
-});
-function makeENSApiPublicConfigSchema(valueLabel) {
-  const label = valueLabel ?? "ENSApiPublicConfig";
-  return z9.strictObject({
-    version: z9.string().min(1, `${label}.version must be a non-empty string`),
-    theGraphFallback: TheGraphFallbackSchema,
-    ensIndexerPublicConfig: makeENSIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
-  });
-}
-
-// src/ensapi/config/deserialize.ts
-function deserializeENSApiPublicConfig(maybeConfig, valueLabel) {
-  const schema = makeENSApiPublicConfigSchema(valueLabel);
-  try {
-    return schema.parse(maybeConfig);
-  } catch (error) {
-    if (error instanceof ZodError) {
-      throw new Error(`Cannot deserialize ENSApiPublicConfig:
-${prettifyError6(error)}
-`);
-    }
-    throw error;
+function serializeReferrerDetailResponse(response) {
+  switch (response.responseCode) {
+    case ReferrerDetailResponseCodes.Ok:
+      return response;
+    case ReferrerDetailResponseCodes.Error:
+      return response;
   }
 }
 
-// src/ensapi/config/serialize.ts
-function serializeENSApiPublicConfig(config) {
-  const { version, theGraphFallback, ensIndexerPublicConfig } = config;
-  return {
-    version,
-    theGraphFallback,
-    ensIndexerPublicConfig: serializeENSIndexerPublicConfig(ensIndexerPublicConfig)
-  };
-}
-
 // src/client.ts
 var DEFAULT_ENSNODE_API_URL = "https://api.alpha.ensnode.io";
 var ENSNodeClient = class _ENSNodeClient {
@@ -2508,7 +2818,7 @@ var ENSNodeClient = class _ENSNodeClient {
       const errorResponse = deserializeErrorResponse(responseData);
       throw new Error(`Fetching ENSNode Config Failed: ${errorResponse.message}`);
     }
-    return deserializeENSApiPublicConfig(responseData);
+    return deserializeConfigResponse(responseData);
   }
   /**
    * Fetch ENSNode Indexing Status
@@ -2542,15 +2852,15 @@ var ENSNodeClient = class _ENSNodeClient {
     return deserializeIndexingStatusResponse(responseData);
   }
   /**
-   * Fetch Paginated Aggregated Referrers
+   * Fetch Referrer Leaderboard Page
    *
-   * Retrieves a paginated list of aggregated referrer metrics with contribution percentages.
+   * Retrieves a paginated list of referrer leaderboard metrics with contribution percentages.
    * Each referrer's contribution is calculated as a percentage of the grand totals across all referrers.
    *
    * @param request - Pagination parameters
    * @param request.page - The page number to retrieve (1-indexed, default: 1)
    * @param request.itemsPerPage - Number of items per page (default: 25, max: 100)
-   * @returns {PaginatedAggregatedReferrersResponse}
+   * @returns {ReferrerLeaderboardPageResponse}
    *
    * @throws if the ENSNode request fails
    * @throws if the ENSNode API returns an error response
@@ -2559,21 +2869,42 @@ var ENSNodeClient = class _ENSNodeClient {
    * @example
    * ```typescript
    * // Get first page with default page size (25 items)
-   * const response = await client.getAggregatedReferrers();
-   * if (response.responseCode === 'ok') {
-   *   console.log(response.data.referrers);
-   *   console.log(`Page ${response.data.paginationParams.page} of ${Math.ceil(response.data.total / response.data.paginationParams.itemsPerPage)}`);
+   * const response = await client.getReferrerLeaderboardPage();
+   * if (response.responseCode === ReferrerLeaderboardPageResponseCodes.Ok) {
+   *   const {
+   *     aggregatedMetrics,
+   *     referrers,
+   *     rules,
+   *     paginationContext,
+   *     updatedAt
+   *   } = response.data;
+   *   console.log(aggregatedMetrics);
+   *   console.log(referrers);
+   *   console.log(rules);
+   *   console.log(updatedAt);
+   *   console.log(`Page ${paginationContext.page} of ${paginationContext.totalPages}`);
    * }
    * ```
    *
    * @example
    * ```typescript
    * // Get second page with 50 items per page
-   * const response = await client.getAggregatedReferrers({ page: 2, itemsPerPage: 50 });
+   * const response = await client.getReferrerLeaderboardPage({ page: 2, itemsPerPage: 50 });
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Handle error response, ie. when Referrer Leaderboard is not currently available.
+   * const response = await client.getReferrerLeaderboardPage();
+   *
+   * if (response.responseCode === ReferrerLeaderboardPageResponseCodes.Error) {
+   *   console.error(response.error);
+   *   console.error(response.errorMessage);
+   * }
    * ```
    */
-  async getAggregatedReferrers(request) {
-    const url = new URL(`/ensanalytics/aggregated-referrers`, this.options.url);
+  async getReferrerLeaderboardPage(request) {
+    const url = new URL(`/ensanalytics/referrers`, this.options.url);
     if (request?.page) url.searchParams.set("page", request.page.toString());
     if (request?.itemsPerPage)
       url.searchParams.set("itemsPerPage", request.itemsPerPage.toString());
@@ -2584,10 +2915,100 @@ var ENSNodeClient = class _ENSNodeClient {
     } catch {
       throw new Error("Malformed response data: invalid JSON");
     }
-    return deserializePaginatedAggregatedReferrersResponse(
+    return deserializeReferrerLeaderboardPageResponse(
       responseData
     );
   }
+  /**
+   * Fetch Referrer Detail
+   *
+   * Retrieves detailed information about a specific referrer, whether they are on the
+   * leaderboard or not.
+   *
+   * The response data is a discriminated union type with a `type` field:
+   *
+   * **For referrers on the leaderboard** (`ReferrerDetailRanked`):
+   * - `type`: {@link ReferrerDetailTypeIds.Ranked}
+   * - `referrer`: The `AwardedReferrerMetrics` from @namehash/ens-referrals
+   * - `rules`: The referral program rules
+   * - `aggregatedMetrics`: Aggregated metrics for all referrers on the leaderboard
+   * - `accurateAsOf`: Unix timestamp indicating when the data was last updated
+   *
+   * **For referrers NOT on the leaderboard** (`ReferrerDetailUnranked`):
+   * - `type`: {@link ReferrerDetailTypeIds.Unranked}
+   * - `referrer`: The `UnrankedReferrerMetrics` from @namehash/ens-referrals
+   * - `rules`: The referral program rules
+   * - `aggregatedMetrics`: Aggregated metrics for all referrers on the leaderboard
+   * - `accurateAsOf`: Unix timestamp indicating when the data was last updated
+   *
+   * @see {@link https://www.npmjs.com/package/@namehash/ens-referrals|@namehash/ens-referrals} for calculation details
+   *
+   * @param request The referrer address to query
+   * @returns {ReferrerDetailResponse} Returns the referrer detail response
+   *
+   * @throws if the ENSNode request fails
+   * @throws if the response data is malformed
+   *
+   * @example
+   * ```typescript
+   * // Get referrer detail for a specific address
+   * const response = await client.getReferrerDetail({
+   *   referrer: "0x1234567890123456789012345678901234567890"
+   * });
+   * if (response.responseCode === ReferrerDetailResponseCodes.Ok) {
+   *   const { type, referrer, rules, aggregatedMetrics, accurateAsOf } = response.data;
+   *   console.log(type); // ReferrerDetailTypeIds.Ranked or ReferrerDetailTypeIds.Unranked
+   *   console.log(referrer);
+   *   console.log(accurateAsOf);
+   * }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Use discriminated union to check if referrer is ranked
+   * const response = await client.getReferrerDetail({
+   *   referrer: "0x1234567890123456789012345678901234567890"
+   * });
+   * if (response.responseCode === ReferrerDetailResponseCodes.Ok) {
+   *   if (response.data.type === ReferrerDetailTypeIds.Ranked) {
+   *     // TypeScript knows this is ReferrerDetailRanked
+   *     console.log(`Rank: ${response.data.referrer.rank}`);
+   *     console.log(`Qualified: ${response.data.referrer.isQualified}`);
+   *     console.log(`Award Pool Share: ${response.data.referrer.awardPoolShare * 100}%`);
+   *   } else {
+   *     // TypeScript knows this is ReferrerDetailUnranked
+   *     console.log("Referrer is not on the leaderboard (no referrals yet)");
+   *   }
+   * }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Handle error response, ie. when Referrer Detail is not currently available.
+   * const response = await client.getReferrerDetail({
+   *   referrer: "0x1234567890123456789012345678901234567890"
+   * });
+   *
+   * if (response.responseCode === ReferrerDetailResponseCodes.Error) {
+   *   console.error(response.error);
+   *   console.error(response.errorMessage);
+   * }
+   * ```
+   */
+  async getReferrerDetail(request) {
+    const url = new URL(
+      `/api/ensanalytics/referrers/${encodeURIComponent(request.referrer)}`,
+      this.options.url
+    );
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    return deserializeReferrerDetailResponse(responseData);
+  }
   /**
    * Fetch ENSNode Registrar Actions
    *
@@ -2751,6 +3172,231 @@ var translateDefaultableChainIdToChainId = (chainId, namespaceId) => {
 // src/resolution/resolver-records-selection.ts
 var isSelectionEmpty = (selection) => !selection.name && !selection.addresses?.length && !selection.texts?.length;
 
+// src/tokenscope/assets.ts
+import { AssetId as CaipAssetId } from "caip";
+import { isAddressEqual as isAddressEqual3, zeroAddress as zeroAddress3 } from "viem";
+var AssetNamespaces = {
+  ERC721: "erc721",
+  ERC1155: "erc1155"
+};
+function serializeAssetId(assetId) {
+  const { assetNamespace, contract, tokenId } = assetId;
+  return CaipAssetId.format({
+    chainId: { namespace: "eip155", reference: contract.chainId.toString() },
+    assetName: { namespace: assetNamespace, reference: contract.address },
+    tokenId: uint256ToHex32(tokenId)
+  }).toLowerCase();
+}
+var buildAssetId = (contract, tokenId, assetNamespace) => {
+  return {
+    assetNamespace,
+    contract,
+    tokenId
+  };
+};
+var NFTMintStatuses = {
+  Minted: "minted",
+  Burned: "burned"
+};
+var formatNFTTransferEventMetadata = (metadata) => {
+  const serializedAssetId = serializeAssetId(metadata.nft);
+  return [
+    `Event: ${metadata.eventHandlerName}`,
+    `Chain ID: ${metadata.chainId}`,
+    `Block Number: ${metadata.blockNumber}`,
+    `Transaction Hash: ${metadata.transactionHash}`,
+    `NFT: ${serializedAssetId}`
+  ].map((line) => ` - ${line}`).join("\n");
+};
+var NFTTransferTypes = {
+  /**
+   * Initial transfer from zeroAddress to a non-zeroAddress
+   * Can happen at most once to a NFT AssetId
+   *
+   * Invariants:
+   * - NFT is not indexed and therefore has no previous mint status or owner
+   * - new NFT mint status is `minted`
+   * - new NFT owner is a non-zeroAddress
+   */
+  Mint: "mint",
+  /**
+   * Subsequent transfer from zeroAddress to a non-zeroAddress
+   * Can happen any number of times to a NFT AssetId as it passes in a cycle from
+   * mint -> burn -> remint -> burn -> remint -> ...
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `burned`
+   * - previous NFT owner is the zeroAddress
+   * - new NFT mint status is `minted`
+   * - new NFT owner is a non-zeroAddress
+   */
+  Remint: "remint",
+  /**
+   * Special transfer type for improperly implemented NFT contracts that allow a NFT
+   * that is currently minted to be reminted before an intermediate burn.
+   *
+   * Transfer from zeroAddress to non-zeroAddress for an indexed NFT where the
+   * previously indexed nft had status `minted` with a non-zeroAddress owner.
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `minted`
+   * - previous NFT owner was a non-zeroAddress
+   * - new NFT mint status is `minted`
+   * - new NFT owner is a non-zeroAddress
+   */
+  MintedRemint: "minted-remint",
+  /**
+   * Transfer from a non-zeroAddress to zeroAddress
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `minted`
+   * - previous NFT owner is a non-zeroAddress
+   * - new NFT mint status is `burned`
+   * - new NFT owner is the zeroAddress
+   */
+  Burn: "burn",
+  /**
+   * Transfer from a non-zeroAddress to a distinct non-zeroAddress
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous and new NFT mint status is `minted`
+   * - previous and new NFT owner are distinct non-zeroAddress
+   */
+  Transfer: "transfer",
+  /**
+   * Transfer from a non-zeroAddress to the same non-zeroAddress
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous and new NFT mint status is `minted`
+   * - previous and new NFT owner are equivalent non-zeroAddress
+   */
+  SelfTransfer: "self-transfer",
+  /**
+   * Transfer from zeroAddress to zeroAddress for an indexed NFT
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous and new NFT mint status is `burned`
+   * - previous and new NFT owner are zeroAddress
+   */
+  RemintBurn: "remint-burn",
+  /**
+   * Special transfer type for improperly implemented NFT contracts that allow a NFT
+   * that is currently minted to be reminted again before an intermediate burn.
+   *
+   * Transfer from zeroAddress to zeroAddress for an indexed NFT where the
+   * previously indexed nft had status `minted` with a non-zeroAddress owner.
+   *
+   * Invariants:
+   * - NFT is indexed
+   * - previous NFT mint status was `minted`
+   * - previous NFT owner was a non-zeroAddress
+   * - new NFT mint status is `burned`
+   * - new NFT owner is the zeroAddress
+   */
+  MintedRemintBurn: "minted-remint-burn",
+  /**
+   * Transfer from zeroAddress to zeroAddress for an unindexed NFT
+   *
+   * Invariants:
+   * - NFT is not indexed and therefore has no previous mint status or owner
+   * - NFT should remain unindexed and without any mint status or owner
+   */
+  MintBurn: "mint-burn"
+};
+var getNFTTransferType = (from, to, allowMintedRemint, metadata, currentlyIndexedOwner) => {
+  const isIndexed = currentlyIndexedOwner !== void 0;
+  const isIndexedAsMinted = isIndexed && !isAddressEqual3(currentlyIndexedOwner, zeroAddress3);
+  const isMint = isAddressEqual3(from, zeroAddress3);
+  const isBurn = isAddressEqual3(to, zeroAddress3);
+  const isSelfTransfer = isAddressEqual3(from, to);
+  if (isIndexed && !isAddressEqual3(currentlyIndexedOwner, from)) {
+    if (isMint && allowMintedRemint) {
+    } else {
+      throw new Error(
+        `Error: Sending from ${from} conflicts with currently indexed owner ${currentlyIndexedOwner}.
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    }
+  }
+  if (isSelfTransfer) {
+    if (isMint) {
+      if (!isIndexed) {
+        return NFTTransferTypes.MintBurn;
+      } else if (!isIndexedAsMinted) {
+        return NFTTransferTypes.RemintBurn;
+      } else if (allowMintedRemint) {
+        return NFTTransferTypes.MintedRemintBurn;
+      } else {
+        throw new Error(
+          `Error: Invalid state transition from minted -> remint-burn
+${formatNFTTransferEventMetadata(metadata)}`
+        );
+      }
+    } else {
+      if (!isIndexed) {
+        throw new Error(
+          `Error: Invalid state transition from unindexed -> self-transfer
+${formatNFTTransferEventMetadata(metadata)}`
+        );
+      } else if (!isIndexedAsMinted) {
+        throw new Error(
+          `Error: invalid state transition from burned -> self-transfer
+${formatNFTTransferEventMetadata(metadata)}`
+        );
+      } else {
+        return NFTTransferTypes.SelfTransfer;
+      }
+    }
+  } else if (isMint) {
+    if (!isIndexed) {
+      return NFTTransferTypes.Mint;
+    } else if (!isIndexedAsMinted) {
+      return NFTTransferTypes.Remint;
+    } else if (allowMintedRemint) {
+      return NFTTransferTypes.MintedRemint;
+    } else {
+      throw new Error(
+        `Error: Invalid state transition from minted -> mint
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    }
+  } else if (isBurn) {
+    if (!isIndexed) {
+      throw new Error(
+        `Error: Invalid state transition from unindexed -> burn
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else if (!isIndexedAsMinted) {
+      throw new Error(
+        `Error: Invalid state transition from burned -> burn
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else {
+      return NFTTransferTypes.Burn;
+    }
+  } else {
+    if (!isIndexed) {
+      throw new Error(
+        `Error: Invalid state transition from unindexed -> transfer
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else if (!isIndexedAsMinted) {
+      throw new Error(
+        `Error: Invalid state transition from burned -> transfer
+${formatNFTTransferEventMetadata(metadata)}`
+      );
+    } else {
+      return NFTTransferTypes.Transfer;
+    }
+  }
+};
+
 // src/tracing/index.ts
 var TraceableENSProtocol = /* @__PURE__ */ ((TraceableENSProtocol2) => {
   TraceableENSProtocol2["ForwardResolution"] = "forward-resolution";
@@ -2785,6 +3431,7 @@ export {
   ATTR_PROTOCOL_NAME,
   ATTR_PROTOCOL_STEP,
   ATTR_PROTOCOL_STEP_RESULT,
+  AssetNamespaces,
   BASENAMES_NODE,
   ChainIndexingConfigTypeIds,
   ChainIndexingStatusIds,
@@ -2798,26 +3445,31 @@ export {
   ETH_COIN_TYPE,
   ETH_NODE,
   ForwardResolutionProtocolStep,
-  ITEMS_PER_PAGE_DEFAULT,
-  ITEMS_PER_PAGE_MAX,
   IndexingStatusResponseCodes,
   LINEANAMES_NODE,
   LruCache,
+  NFTMintStatuses,
+  NFTTransferTypes,
   OmnichainIndexingStatusIds,
   PROTOCOL_ATTRIBUTE_PREFIX,
-  PaginatedAggregatedReferrersResponseCodes,
   PluginName,
+  RECORDS_PER_PAGE_DEFAULT,
+  RECORDS_PER_PAGE_MAX,
   ROOT_NODE,
+  ReferrerDetailResponseCodes,
+  ReferrerLeaderboardPageResponseCodes,
   RegistrarActionTypes,
   RegistrarActionsFilterTypes,
   RegistrarActionsOrders,
   RegistrarActionsResponseCodes,
   ResolutionStatusIds,
   ReverseResolutionProtocolStep,
+  SWRCache,
   TheGraphCannotFallbackReasonSchema,
   TheGraphFallbackSchema,
   TraceableENSProtocol,
   TtlCache,
+  ZERO_ENCODED_REFERRER,
   accountIdEqual,
   addDuration,
   addPrices,
@@ -2826,6 +3478,7 @@ export {
   beautifyName,
   bigIntToNumber,
   bigintToCoinType,
+  buildAssetId,
   buildEnsRainbowClientLabelSet,
   buildLabelSetId,
   buildLabelSetVersion,
@@ -2847,6 +3500,7 @@ export {
   deserializeBlockrange,
   deserializeChainId,
   deserializeChainIndexingStatusSnapshot,
+  deserializeConfigResponse,
   deserializeCrossChainIndexingStatusSnapshot,
   deserializeDatetime,
   deserializeDuration,
@@ -2855,17 +3509,21 @@ export {
   deserializeErrorResponse,
   deserializeIndexingStatusResponse,
   deserializeOmnichainIndexingStatusSnapshot,
-  deserializePaginatedAggregatedReferrersResponse,
   deserializeRealtimeIndexingStatusProjection,
+  deserializeReferrerDetailResponse,
+  deserializeReferrerLeaderboardPageResponse,
   deserializeRegistrarActionsResponse,
   deserializeUnixTimestamp,
   deserializeUrl,
   durationBetween,
   encodeLabelHash,
   evmChainIdToCoinType,
+  formatNFTTransferEventMetadata,
   getCurrencyInfo,
   getENSRootChainId,
   getEthnamesSubregistryId,
+  getLatestIndexedBlockRef,
+  getNFTTransferType,
   getNameHierarchy,
   getOmnichainIndexingCursor,
   getOmnichainIndexingStatus,
@@ -2903,8 +3561,10 @@ export {
   registrarActionsPrerequisites,
   reverseName,
   serializeAccountId,
+  serializeAssetId,
   serializeChainId,
   serializeChainIndexingSnapshots,
+  serializeConfigResponse,
   serializeCrossChainIndexingStatusSnapshotOmnichain,
   serializeDatetime,
   serializeENSApiPublicConfig,
@@ -2913,10 +3573,11 @@ export {
   serializeIndexingStatusResponse,
   serializeNamedRegistrarAction,
   serializeOmnichainIndexingStatusSnapshot,
-  serializePaginatedAggregatedReferrersResponse,
   serializePrice,
   serializePriceEth,
   serializeRealtimeIndexingStatusProjection,
+  serializeReferrerDetailResponse,
+  serializeReferrerLeaderboardPageResponse,
   serializeRegistrarAction,
   serializeRegistrarActionPricing,
   serializeRegistrarActionsResponse,
@@ -2924,12 +3585,10 @@ export {
   serializeSubregistry,
   serializeUrl,
   sortChainStatusesByStartBlockAsc,
-  staleWhileRevalidate,
   stripNullBytes,
   translateDefaultableChainIdToChainId,
   uint256ToHex32,
   uniq,
-  validateSupportedLabelSetAndVersion,
-  zeroEncodedReferrer
+  validateSupportedLabelSetAndVersion
 };
 //# sourceMappingURL=index.js.map