@ensnode/ensnode-sdk 1.0.2 → 1.1.0

package/dist/index.js

@@ -38,8 +38,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 +341,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 +422,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 +566,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 +757,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 +766,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 +775,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 +797,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 +807,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)];
@@ -927,6 +1082,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) {
@@ -1478,15 +1643,18 @@ var LogLevelSchema = z5.enum(["fatal", "error", "warn", "info", "debug", "trace"
 // src/shared/protocol-acceleration/interpret-record-values.ts
 import { isAddress as isAddress3, isAddressEqual as isAddressEqual2, zeroAddress } from "viem";
 
-// ../ens-referrals/src/referrer.ts
+// ../ens-referrals/src/address.ts
+import { isAddress as isAddress4 } from "viem";
+
+// ../ens-referrals/src/encoding.ts
 import { getAddress, pad, size as size2, slice, zeroAddress as zeroAddress2 } 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,7 +1665,7 @@ function decodeEncodedReferrer(encodedReferrer) {
     );
   }
   const padding = slice(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
-  if (padding !== encodedReferrerPadding) {
+  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
     return zeroAddress2;
   }
   const decodedReferrer = slice(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
@@ -1508,6 +1676,12 @@ 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";
+
 // src/registrars/zod-schemas.ts
 import z6 from "zod/v4";
 
@@ -2157,89 +2331,98 @@ import { prettifyError as prettifyError5 } from "zod/v4";
 import z8 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 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 requested referrer leaderboard page is available.
    */
   Ok: "ok",
   /**
-   * Represents that the aggregated referrers data is not available.
+   * Represents that the referrer leaderboard data is not available.
    */
   Error: "error"
 };
 
 // src/ensanalytics/zod-schemas.ts
-var makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetrics") => z8.object({
-  referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
-  totalReferrals: makePositiveIntegerSchema(`${valueLabel}.totalReferrals`),
-  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`)
+var makeReferralProgramRulesSchema = (valueLabel = "ReferralProgramRules") => z8.object({
+  totalAwardPoolValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.totalAwardPoolValue`),
+  maxQualifiedReferrers: makeNonNegativeIntegerSchema(`${valueLabel}.maxQualifiedReferrers`),
+  startTime: makeUnixTimestampSchema(`${valueLabel}.startTime`),
+  endTime: makeUnixTimestampSchema(`${valueLabel}.endTime`),
+  subregistryId: makeAccountIdSchema(`${valueLabel}.subregistryId`)
 });
-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 makeAwardedReferrerMetricsSchema = (valueLabel = "AwardedReferrerMetrics") => z8.object({
+  referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
+  totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
+  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
+  rank: makePositiveIntegerSchema(`${valueLabel}.rank`),
+  isQualified: z8.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 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") => z8.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 makeReferrerLeaderboardPaginationContextSchema = (valueLabel = "ReferrerLeaderboardPaginationContext") => z8.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`),
+  totalRecords: makeNonNegativeIntegerSchema(`${valueLabel}.totalRecords`),
+  totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
   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
-    });
-  }
+  startIndex: z8.optional(makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`)),
+  endIndex: z8.optional(makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`))
 });
-var makePaginatedAggregatedReferrersResponseOkSchema = (valueLabel = "PaginatedAggregatedReferrersResponse") => z8.object({
-  responseCode: z8.literal(PaginatedAggregatedReferrersResponseCodes.Ok),
-  data: makePaginatedAggregatedReferrersSchema(`${valueLabel}.data`)
+var makeReferrerLeaderboardPageSchema = (valueLabel = "ReferrerLeaderboardPage") => z8.object({
+  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
+  referrers: z8.array(makeAwardedReferrerMetricsSchema(`${valueLabel}.referrers[item]`)),
+  aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
+  paginationContext: makeReferrerLeaderboardPaginationContextSchema(
+    `${valueLabel}.paginationContext`
+  ),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 });
-var makePaginatedAggregatedReferrersResponseErrorSchema = (_valueLabel = "PaginatedAggregatedReferrersResponse") => z8.object({
-  responseCode: z8.literal(PaginatedAggregatedReferrersResponseCodes.Error),
+var makeReferrerLeaderboardPageResponseOkSchema = (valueLabel = "ReferrerLeaderboardPageResponseOk") => z8.object({
+  responseCode: z8.literal(ReferrerLeaderboardPageResponseCodes.Ok),
+  data: makeReferrerLeaderboardPageSchema(`${valueLabel}.data`)
+});
+var makeReferrerLeaderboardPageResponseErrorSchema = (_valueLabel = "ReferrerLeaderboardPageResponseError") => z8.object({
+  responseCode: z8.literal(ReferrerLeaderboardPageResponseCodes.Error),
   error: z8.string(),
   errorMessage: z8.string()
 });
-var makePaginatedAggregatedReferrersResponseSchema = (valueLabel = "PaginatedAggregatedReferrersResponse") => z8.union([
-  makePaginatedAggregatedReferrersResponseOkSchema(valueLabel),
-  makePaginatedAggregatedReferrersResponseErrorSchema(valueLabel)
+var makeReferrerLeaderboardPageResponseSchema = (valueLabel = "ReferrerLeaderboardPageResponse") => z8.union([
+  makeReferrerLeaderboardPageResponseOkSchema(valueLabel),
+  makeReferrerLeaderboardPageResponseErrorSchema(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:
+      `Cannot deserialize SerializedReferrerLeaderboardPageResponse:
 ${prettifyError5(parsed.error)}
 `
     );
@@ -2248,11 +2431,11 @@ ${prettifyError5(parsed.error)}
 }
 
 // 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;
   }
 }
@@ -2542,15 +2725,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 +2742,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.getReferrerLeaderboard();
+   * 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.getReferrerLeaderboard({ page: 2, itemsPerPage: 50 });
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Handle error response, ie. when Referrer Leaderboard is not currently available.
+   * const response = await client.getReferrerLeaderboard();
+   *
+   * 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 getReferrerLeaderboard(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,7 +2788,7 @@ var ENSNodeClient = class _ENSNodeClient {
     } catch {
       throw new Error("Malformed response data: invalid JSON");
     }
-    return deserializePaginatedAggregatedReferrersResponse(
+    return deserializeReferrerLeaderboardPageResponse(
       responseData
     );
   }
@@ -2798,26 +3002,26 @@ export {
   ETH_COIN_TYPE,
   ETH_NODE,
   ForwardResolutionProtocolStep,
-  ITEMS_PER_PAGE_DEFAULT,
-  ITEMS_PER_PAGE_MAX,
   IndexingStatusResponseCodes,
   LINEANAMES_NODE,
   LruCache,
   OmnichainIndexingStatusIds,
   PROTOCOL_ATTRIBUTE_PREFIX,
-  PaginatedAggregatedReferrersResponseCodes,
   PluginName,
   ROOT_NODE,
+  ReferrerLeaderboardPageResponseCodes,
   RegistrarActionTypes,
   RegistrarActionsFilterTypes,
   RegistrarActionsOrders,
   RegistrarActionsResponseCodes,
   ResolutionStatusIds,
   ReverseResolutionProtocolStep,
+  SWRCache,
   TheGraphCannotFallbackReasonSchema,
   TheGraphFallbackSchema,
   TraceableENSProtocol,
   TtlCache,
+  ZERO_ENCODED_REFERRER,
   accountIdEqual,
   addDuration,
   addPrices,
@@ -2855,8 +3059,8 @@ export {
   deserializeErrorResponse,
   deserializeIndexingStatusResponse,
   deserializeOmnichainIndexingStatusSnapshot,
-  deserializePaginatedAggregatedReferrersResponse,
   deserializeRealtimeIndexingStatusProjection,
+  deserializeReferrerLeaderboardPageResponse,
   deserializeRegistrarActionsResponse,
   deserializeUnixTimestamp,
   deserializeUrl,
@@ -2866,6 +3070,7 @@ export {
   getCurrencyInfo,
   getENSRootChainId,
   getEthnamesSubregistryId,
+  getLatestIndexedBlockRef,
   getNameHierarchy,
   getOmnichainIndexingCursor,
   getOmnichainIndexingStatus,
@@ -2913,10 +3118,10 @@ export {
   serializeIndexingStatusResponse,
   serializeNamedRegistrarAction,
   serializeOmnichainIndexingStatusSnapshot,
-  serializePaginatedAggregatedReferrersResponse,
   serializePrice,
   serializePriceEth,
   serializeRealtimeIndexingStatusProjection,
+  serializeReferrerLeaderboardPageResponse,
   serializeRegistrarAction,
   serializeRegistrarActionPricing,
   serializeRegistrarActionsResponse,
@@ -2924,12 +3129,10 @@ export {
   serializeSubregistry,
   serializeUrl,
   sortChainStatusesByStartBlockAsc,
-  staleWhileRevalidate,
   stripNullBytes,
   translateDefaultableChainIdToChainId,
   uint256ToHex32,
   uniq,
-  validateSupportedLabelSetAndVersion,
-  zeroEncodedReferrer
+  validateSupportedLabelSetAndVersion
 };
 //# sourceMappingURL=index.js.map