@ensnode/ensnode-sdk 1.0.2 → 1.1.0

package/dist/index.cjs

@@ -47,26 +47,26 @@ __export(index_exports, {
   ETH_COIN_TYPE: () => ETH_COIN_TYPE,
   ETH_NODE: () => ETH_NODE,
   ForwardResolutionProtocolStep: () => ForwardResolutionProtocolStep,
-  ITEMS_PER_PAGE_DEFAULT: () => ITEMS_PER_PAGE_DEFAULT,
-  ITEMS_PER_PAGE_MAX: () => ITEMS_PER_PAGE_MAX,
   IndexingStatusResponseCodes: () => IndexingStatusResponseCodes,
   LINEANAMES_NODE: () => LINEANAMES_NODE,
   LruCache: () => LruCache,
   OmnichainIndexingStatusIds: () => OmnichainIndexingStatusIds,
   PROTOCOL_ATTRIBUTE_PREFIX: () => PROTOCOL_ATTRIBUTE_PREFIX,
-  PaginatedAggregatedReferrersResponseCodes: () => PaginatedAggregatedReferrersResponseCodes,
   PluginName: () => PluginName,
   ROOT_NODE: () => ROOT_NODE,
+  ReferrerLeaderboardPageResponseCodes: () => ReferrerLeaderboardPageResponseCodes,
   RegistrarActionTypes: () => RegistrarActionTypes,
   RegistrarActionsFilterTypes: () => RegistrarActionsFilterTypes,
   RegistrarActionsOrders: () => RegistrarActionsOrders,
   RegistrarActionsResponseCodes: () => RegistrarActionsResponseCodes,
   ResolutionStatusIds: () => ResolutionStatusIds,
   ReverseResolutionProtocolStep: () => ReverseResolutionProtocolStep,
+  SWRCache: () => SWRCache,
   TheGraphCannotFallbackReasonSchema: () => TheGraphCannotFallbackReasonSchema,
   TheGraphFallbackSchema: () => TheGraphFallbackSchema,
   TraceableENSProtocol: () => TraceableENSProtocol,
   TtlCache: () => TtlCache,
+  ZERO_ENCODED_REFERRER: () => ZERO_ENCODED_REFERRER,
   accountIdEqual: () => accountIdEqual,
   addDuration: () => addDuration,
   addPrices: () => addPrices,
@@ -104,8 +104,8 @@ __export(index_exports, {
   deserializeErrorResponse: () => deserializeErrorResponse,
   deserializeIndexingStatusResponse: () => deserializeIndexingStatusResponse,
   deserializeOmnichainIndexingStatusSnapshot: () => deserializeOmnichainIndexingStatusSnapshot,
-  deserializePaginatedAggregatedReferrersResponse: () => deserializePaginatedAggregatedReferrersResponse,
   deserializeRealtimeIndexingStatusProjection: () => deserializeRealtimeIndexingStatusProjection,
+  deserializeReferrerLeaderboardPageResponse: () => deserializeReferrerLeaderboardPageResponse,
   deserializeRegistrarActionsResponse: () => deserializeRegistrarActionsResponse,
   deserializeUnixTimestamp: () => deserializeUnixTimestamp,
   deserializeUrl: () => deserializeUrl,
@@ -115,6 +115,7 @@ __export(index_exports, {
   getCurrencyInfo: () => getCurrencyInfo,
   getENSRootChainId: () => import_datasources2.getENSRootChainId,
   getEthnamesSubregistryId: () => getEthnamesSubregistryId,
+  getLatestIndexedBlockRef: () => getLatestIndexedBlockRef,
   getNameHierarchy: () => getNameHierarchy,
   getOmnichainIndexingCursor: () => getOmnichainIndexingCursor,
   getOmnichainIndexingStatus: () => getOmnichainIndexingStatus,
@@ -162,10 +163,10 @@ __export(index_exports, {
   serializeIndexingStatusResponse: () => serializeIndexingStatusResponse,
   serializeNamedRegistrarAction: () => serializeNamedRegistrarAction,
   serializeOmnichainIndexingStatusSnapshot: () => serializeOmnichainIndexingStatusSnapshot,
-  serializePaginatedAggregatedReferrersResponse: () => serializePaginatedAggregatedReferrersResponse,
   serializePrice: () => serializePrice,
   serializePriceEth: () => serializePriceEth,
   serializeRealtimeIndexingStatusProjection: () => serializeRealtimeIndexingStatusProjection,
+  serializeReferrerLeaderboardPageResponse: () => serializeReferrerLeaderboardPageResponse,
   serializeRegistrarAction: () => serializeRegistrarAction,
   serializeRegistrarActionPricing: () => serializeRegistrarActionPricing,
   serializeRegistrarActionsResponse: () => serializeRegistrarActionsResponse,
@@ -173,13 +174,11 @@ __export(index_exports, {
   serializeSubregistry: () => serializeSubregistry,
   serializeUrl: () => serializeUrl,
   sortChainStatusesByStartBlockAsc: () => sortChainStatusesByStartBlockAsc,
-  staleWhileRevalidate: () => staleWhileRevalidate,
   stripNullBytes: () => stripNullBytes,
   translateDefaultableChainIdToChainId: () => translateDefaultableChainIdToChainId,
   uint256ToHex32: () => uint256ToHex32,
   uniq: () => uniq,
-  validateSupportedLabelSetAndVersion: () => validateSupportedLabelSetAndVersion,
-  zeroEncodedReferrer: () => zeroEncodedReferrer
+  validateSupportedLabelSetAndVersion: () => validateSupportedLabelSetAndVersion
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -187,7 +186,7 @@ module.exports = __toCommonJS(index_exports);
 var import_v49 = require("zod/v4");
 
 // src/api/zod-schemas.ts
-var import_viem12 = require("viem");
+var import_viem14 = require("viem");
 var import_v48 = __toESM(require("zod/v4"), 1);
 
 // src/ensindexer/indexing-status/zod-schemas.ts
@@ -223,8 +222,58 @@ function asLowerCaseAddress(address) {
   return address.toLowerCase();
 }
 
-// src/shared/cache.ts
+// src/shared/cache/lru-cache.ts
+var LruCache = class {
+  _cache = /* @__PURE__ */ new Map();
+  _capacity;
+  /**
+   * Create a new LRU cache with the given capacity.
+   *
+   * @param capacity The maximum number of items in the cache. If set to 0, the cache is effectively disabled.
+   * @throws Error if capacity is not a non-negative integer.
+   */
+  constructor(capacity) {
+    if (!Number.isInteger(capacity)) {
+      throw new Error(
+        `LruCache requires capacity to be an integer but a capacity of ${capacity} was requested.`
+      );
+    }
+    if (capacity < 0) {
+      throw new Error(
+        `LruCache requires a non-negative capacity but a capacity of ${capacity} was requested.`
+      );
+    }
+    this._capacity = capacity;
+  }
+  set(key, value) {
+    this._cache.set(key, value);
+    if (this._cache.size > this._capacity) {
+      const oldestKey = this._cache.keys().next().value;
+      this._cache.delete(oldestKey);
+    }
+  }
+  get(key) {
+    const value = this._cache.get(key);
+    if (value) {
+      this._cache.delete(key);
+      this._cache.set(key, value);
+    }
+    return value;
+  }
+  clear() {
+    this._cache.clear();
+  }
+  get size() {
+    return this._cache.size;
+  }
+  get capacity() {
+    return this._capacity;
+  }
+};
+
+// src/shared/cache/swr-cache.ts
 var import_date_fns = require("date-fns");
+var import_getUnixTime = require("date-fns/getUnixTime");
 
 // src/shared/deserialize.ts
 var import_v42 = require("zod/v4");
@@ -473,6 +522,13 @@ function reinterpretName(name) {
 }
 
 // src/shared/zod-schemas.ts
+var makeFiniteNonNegativeNumberSchema = (valueLabel = "Value") => import_v4.default.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") => import_v4.default.int({
   error: `${valueLabel} must be an integer.`
 });
@@ -547,13 +603,13 @@ var makePriceCurrencySchema = (currency, valueLabel = "Price Currency") => impor
 });
 var makePriceEthSchema = (valueLabel = "Price ETH") => makePriceCurrencySchema(CurrencyIds.ETH, valueLabel).transform((v) => v);
 var makeAccountIdSchema = (valueLabel = "AccountId") => import_v4.default.strictObject({
-  chainId: makeChainIdStringSchema(`${valueLabel} chain ID`),
+  chainId: makeChainIdSchema(`${valueLabel} chain ID`),
   address: makeLowercaseAddressSchema(`${valueLabel} address`)
 });
 var makeSerializedAccountIdSchema = (valueLabel = "Account ID") => import_v4.default.coerce.string().transform((v) => {
   const result = new import_caip.AccountId(v);
   return {
-    chainId: result.chainId.reference,
+    chainId: Number(result.chainId.reference),
     address: result.address
   };
 }).pipe(makeAccountIdSchema(valueLabel));
@@ -691,54 +747,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: (0, import_getUnixTime.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: (0, import_date_fns.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, (0, import_getUnixTime.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
+var import_getUnixTime2 = require("date-fns/getUnixTime");
 var TtlCache = class {
   _cache = /* @__PURE__ */ new Map();
   _ttl;
@@ -751,7 +938,7 @@ var TtlCache = class {
     this._ttl = ttl;
   }
   _cleanup() {
-    const now = (0, import_date_fns.getUnixTime)(/* @__PURE__ */ new Date());
+    const now = (0, import_getUnixTime2.getUnixTime)(/* @__PURE__ */ new Date());
     for (const [key, entry] of this._cache.entries()) {
       if (entry.expiresAt <= now) {
         this._cache.delete(key);
@@ -760,7 +947,7 @@ var TtlCache = class {
   }
   set(key, value) {
     this._cleanup();
-    const expiresAt = addDuration((0, import_date_fns.getUnixTime)(/* @__PURE__ */ new Date()), this._ttl);
+    const expiresAt = addDuration((0, import_getUnixTime2.getUnixTime)(/* @__PURE__ */ new Date()), this._ttl);
     this._cache.set(key, { value, expiresAt });
   }
   get(key) {
@@ -769,7 +956,7 @@ var TtlCache = class {
     if (!entry) {
       return void 0;
     }
-    if (entry.expiresAt <= (0, import_date_fns.getUnixTime)(/* @__PURE__ */ new Date())) {
+    if (entry.expiresAt <= (0, import_getUnixTime2.getUnixTime)(/* @__PURE__ */ new Date())) {
       this._cache.delete(key);
       return void 0;
     }
@@ -791,7 +978,7 @@ var TtlCache = class {
     if (!entry) {
       return false;
     }
-    if (entry.expiresAt <= (0, import_date_fns.getUnixTime)(/* @__PURE__ */ new Date())) {
+    if (entry.expiresAt <= (0, import_getUnixTime2.getUnixTime)(/* @__PURE__ */ new Date())) {
       this._cache.delete(key);
       return false;
     }
@@ -801,39 +988,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: (0, import_date_fns.getUnixTime)(/* @__PURE__ */ new Date()) };
-        cacheInitializer = null;
-        return value;
-      }).catch(() => {
-        cacheInitializer = null;
-        return null;
-      });
-      return cacheInitializer;
-    }
-    const isStale = durationBetween(cache.updatedAt, (0, import_date_fns.getUnixTime)(/* @__PURE__ */ new Date())) > ttl;
-    if (!isStale) return cache.value;
-    if (cache.inProgressRevalidation) return cache.value;
-    const revalidationPromise = fn().then((value) => {
-      cache = { value, updatedAt: (0, import_date_fns.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)];
@@ -1109,6 +1263,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) {
@@ -1643,36 +1807,45 @@ var LogLevelSchema = import_v46.z.enum(["fatal", "error", "warn", "info", "debug
 // src/shared/protocol-acceleration/interpret-record-values.ts
 var import_viem10 = require("viem");
 
-// ../ens-referrals/src/referrer.ts
+// ../ens-referrals/src/address.ts
 var import_viem11 = require("viem");
+
+// ../ens-referrals/src/encoding.ts
+var import_viem12 = require("viem");
 var ENCODED_REFERRER_BYTE_OFFSET = 12;
 var ENCODED_REFERRER_BYTE_LENGTH = 32;
-var encodedReferrerPadding = (0, import_viem11.pad)("0x", {
+var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem12.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_OFFSET,
   dir: "left"
 });
-var zeroEncodedReferrer = (0, import_viem11.pad)("0x", {
+var ZERO_ENCODED_REFERRER = (0, import_viem12.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_LENGTH,
   dir: "left"
 });
 function decodeEncodedReferrer(encodedReferrer) {
-  if ((0, import_viem11.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
+  if ((0, import_viem12.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
     throw new Error(
       `Encoded referrer value must be represented by ${ENCODED_REFERRER_BYTE_LENGTH} bytes.`
     );
   }
-  const padding = (0, import_viem11.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
-  if (padding !== encodedReferrerPadding) {
-    return import_viem11.zeroAddress;
+  const padding = (0, import_viem12.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
+  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
+    return import_viem12.zeroAddress;
   }
-  const decodedReferrer = (0, import_viem11.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
+  const decodedReferrer = (0, import_viem12.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
   try {
-    return (0, import_viem11.getAddress)(decodedReferrer);
+    return (0, import_viem12.getAddress)(decodedReferrer);
   } catch {
     throw new Error(`Decoded referrer value must be a valid EVM address.`);
   }
 }
 
+// ../ens-referrals/src/leaderboard-page.ts
+var REFERRERS_PER_LEADERBOARD_PAGE_MAX = 100;
+
+// ../ens-referrals/src/link.ts
+var import_viem13 = require("viem");
+
 // src/registrars/zod-schemas.ts
 var import_v47 = __toESM(require("zod/v4"), 1);
 
@@ -1885,7 +2058,7 @@ var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response")
 function invariant_registrationLifecycleNodeMatchesName(ctx) {
   const { name, action } = ctx.value;
   const expectedNode = action.registrationLifecycle.node;
-  const actualNode = (0, import_viem12.namehash)(name);
+  const actualNode = (0, import_viem14.namehash)(name);
   if (actualNode !== expectedNode) {
     ctx.issues.push({
       code: "custom",
@@ -1979,7 +2152,7 @@ ${(0, import_v410.prettifyError)(parsed.error)}
 }
 
 // src/ensindexer/config/label-utils.ts
-var import_viem13 = require("viem");
+var import_viem15 = require("viem");
 function labelHashToBytes(labelHash) {
   try {
     if (labelHash.length !== 66) {
@@ -1991,7 +2164,7 @@ function labelHashToBytes(labelHash) {
     if (!labelHash.startsWith("0x")) {
       throw new Error("Labelhash must be 0x-prefixed");
     }
-    const bytes = (0, import_viem13.hexToBytes)(labelHash);
+    const bytes = (0, import_viem15.hexToBytes)(labelHash);
     if (bytes.length !== 32) {
       throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
     }
@@ -2322,89 +2495,98 @@ var import_v413 = require("zod/v4");
 var import_v412 = __toESM(require("zod/v4"), 1);
 
 // 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") => import_v412.default.object({
-  referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
-  totalReferrals: makePositiveIntegerSchema(`${valueLabel}.totalReferrals`),
-  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`)
+var makeReferralProgramRulesSchema = (valueLabel = "ReferralProgramRules") => import_v412.default.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: import_v412.default.number({
-    error: `${valueLabel}.totalReferralsContribution must be a number`
-  }).min(0, `${valueLabel}.totalReferralsContribution must be >= 0`).max(1, `${valueLabel}.totalReferralsContribution must be <= 1`),
-  totalIncrementalDurationContribution: import_v412.default.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") => import_v412.default.object({
+  referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
+  totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
+  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
+  rank: makePositiveIntegerSchema(`${valueLabel}.rank`),
+  isQualified: import_v412.default.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") => import_v412.default.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") => import_v412.default.object({
+  grandTotalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.grandTotalReferrals`),
+  grandTotalIncrementalDuration: makeDurationSchema(
+    `${valueLabel}.grandTotalIncrementalDuration`
+  ),
+  grandTotalQualifiedReferrersFinalScore: makeFiniteNonNegativeNumberSchema(
+    `${valueLabel}.grandTotalQualifiedReferrersFinalScore`
+  ),
+  minFinalScoreToQualify: makeFiniteNonNegativeNumberSchema(
+    `${valueLabel}.minFinalScoreToQualify`
+  )
 });
-var makePaginatedAggregatedReferrersSchema = (valueLabel = "PaginatedAggregatedReferrers") => import_v412.default.object({
-  referrers: import_v412.default.array(
-    makeAggregatedReferrerMetricsContributionSchema(`${valueLabel}.referrers[item]`)
+var makeReferrerLeaderboardPaginationContextSchema = (valueLabel = "ReferrerLeaderboardPaginationContext") => import_v412.default.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: import_v412.default.boolean(),
   hasPrev: import_v412.default.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: import_v412.default.optional(makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`)),
+  endIndex: import_v412.default.optional(makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`))
 });
-var makePaginatedAggregatedReferrersResponseOkSchema = (valueLabel = "PaginatedAggregatedReferrersResponse") => import_v412.default.object({
-  responseCode: import_v412.default.literal(PaginatedAggregatedReferrersResponseCodes.Ok),
-  data: makePaginatedAggregatedReferrersSchema(`${valueLabel}.data`)
+var makeReferrerLeaderboardPageSchema = (valueLabel = "ReferrerLeaderboardPage") => import_v412.default.object({
+  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
+  referrers: import_v412.default.array(makeAwardedReferrerMetricsSchema(`${valueLabel}.referrers[item]`)),
+  aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
+  paginationContext: makeReferrerLeaderboardPaginationContextSchema(
+    `${valueLabel}.paginationContext`
+  ),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+});
+var makeReferrerLeaderboardPageResponseOkSchema = (valueLabel = "ReferrerLeaderboardPageResponseOk") => import_v412.default.object({
+  responseCode: import_v412.default.literal(ReferrerLeaderboardPageResponseCodes.Ok),
+  data: makeReferrerLeaderboardPageSchema(`${valueLabel}.data`)
 });
-var makePaginatedAggregatedReferrersResponseErrorSchema = (_valueLabel = "PaginatedAggregatedReferrersResponse") => import_v412.default.object({
-  responseCode: import_v412.default.literal(PaginatedAggregatedReferrersResponseCodes.Error),
+var makeReferrerLeaderboardPageResponseErrorSchema = (_valueLabel = "ReferrerLeaderboardPageResponseError") => import_v412.default.object({
+  responseCode: import_v412.default.literal(ReferrerLeaderboardPageResponseCodes.Error),
   error: import_v412.default.string(),
   errorMessage: import_v412.default.string()
 });
-var makePaginatedAggregatedReferrersResponseSchema = (valueLabel = "PaginatedAggregatedReferrersResponse") => import_v412.default.union([
-  makePaginatedAggregatedReferrersResponseOkSchema(valueLabel),
-  makePaginatedAggregatedReferrersResponseErrorSchema(valueLabel)
+var makeReferrerLeaderboardPageResponseSchema = (valueLabel = "ReferrerLeaderboardPageResponse") => import_v412.default.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:
 ${(0, import_v413.prettifyError)(parsed.error)}
 `
     );
@@ -2413,11 +2595,11 @@ ${(0, import_v413.prettifyError)(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;
   }
 }
@@ -2707,15 +2889,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
@@ -2724,21 +2906,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());
@@ -2749,7 +2952,7 @@ var ENSNodeClient = class _ENSNodeClient {
     } catch {
       throw new Error("Malformed response data: invalid JSON");
     }
-    return deserializePaginatedAggregatedReferrersResponse(
+    return deserializeReferrerLeaderboardPageResponse(
       responseData
     );
   }