@namehash/ens-referrals 1.0.1 → 1.1.0

package/dist/index.cjs

@@ -23,55 +23,530 @@ __export(index_exports, {
   ENCODED_REFERRER_BYTE_LENGTH: () => ENCODED_REFERRER_BYTE_LENGTH,
   ENCODED_REFERRER_BYTE_OFFSET: () => ENCODED_REFERRER_BYTE_OFFSET,
   ENS_HOLIDAY_AWARDS_END_DATE: () => ENS_HOLIDAY_AWARDS_END_DATE,
+  ENS_HOLIDAY_AWARDS_MAX_QUALIFIED_REFERRERS: () => ENS_HOLIDAY_AWARDS_MAX_QUALIFIED_REFERRERS,
   ENS_HOLIDAY_AWARDS_START_DATE: () => ENS_HOLIDAY_AWARDS_START_DATE,
+  ENS_HOLIDAY_AWARDS_TOTAL_AWARD_POOL_VALUE: () => ENS_HOLIDAY_AWARDS_TOTAL_AWARD_POOL_VALUE,
+  EXPECTED_ENCODED_REFERRER_PADDING: () => EXPECTED_ENCODED_REFERRER_PADDING,
+  REFERRERS_PER_LEADERBOARD_PAGE_DEFAULT: () => REFERRERS_PER_LEADERBOARD_PAGE_DEFAULT,
+  REFERRERS_PER_LEADERBOARD_PAGE_MAX: () => REFERRERS_PER_LEADERBOARD_PAGE_MAX,
+  SECONDS_PER_YEAR: () => SECONDS_PER_YEAR,
+  ZERO_ENCODED_REFERRER: () => ZERO_ENCODED_REFERRER,
+  buildAggregatedReferrerMetrics: () => buildAggregatedReferrerMetrics,
+  buildAwardedReferrerMetrics: () => buildAwardedReferrerMetrics,
   buildEncodedReferrer: () => buildEncodedReferrer,
   buildEnsReferralUrl: () => buildEnsReferralUrl,
+  buildRankedReferrerMetrics: () => buildRankedReferrerMetrics,
+  buildReferralProgramRules: () => buildReferralProgramRules,
+  buildReferrerLeaderboard: () => buildReferrerLeaderboard,
+  buildReferrerLeaderboardPaginationContext: () => buildReferrerLeaderboardPaginationContext,
+  buildReferrerLeaderboardPaginationParams: () => buildReferrerLeaderboardPaginationParams,
+  buildReferrerMetrics: () => buildReferrerMetrics,
+  buildScoredReferrerMetrics: () => buildScoredReferrerMetrics,
+  calcReferrerAwardPoolShare: () => calcReferrerAwardPoolShare,
+  calcReferrerFinalScore: () => calcReferrerFinalScore,
+  calcReferrerFinalScoreBoost: () => calcReferrerFinalScoreBoost,
+  calcReferrerFinalScoreMultiplier: () => calcReferrerFinalScoreMultiplier,
+  calcReferrerScore: () => calcReferrerScore,
+  compareReferrerMetrics: () => compareReferrerMetrics,
   decodeEncodedReferrer: () => decodeEncodedReferrer,
-  encodedReferrerPadding: () => encodedReferrerPadding,
-  zeroEncodedReferrer: () => zeroEncodedReferrer
+  getReferrerLeaderboardPage: () => getReferrerLeaderboardPage,
+  isFiniteNonNegativeNumber: () => isFiniteNonNegativeNumber,
+  isInteger: () => isInteger,
+  isNonNegativeInteger: () => isNonNegativeInteger,
+  isPositiveInteger: () => isPositiveInteger,
+  isReferrerQualified: () => isReferrerQualified,
+  isValidDuration: () => isValidDuration,
+  isValidReferrerScore: () => isValidReferrerScore,
+  isValidUSDQuantity: () => isValidUSDQuantity,
+  normalizeAddress: () => normalizeAddress,
+  sortReferrerMetrics: () => sortReferrerMetrics,
+  validateAggregatedReferrerMetrics: () => validateAggregatedReferrerMetrics,
+  validateAwardedReferrerMetrics: () => validateAwardedReferrerMetrics,
+  validateDuration: () => validateDuration,
+  validateLowercaseAddress: () => validateLowercaseAddress,
+  validateNonNegativeInteger: () => validateNonNegativeInteger,
+  validateRankedReferrerMetrics: () => validateRankedReferrerMetrics,
+  validateReferralProgramRules: () => validateReferralProgramRules,
+  validateReferrerLeaderboardPaginationContext: () => validateReferrerLeaderboardPaginationContext,
+  validateReferrerMetrics: () => validateReferrerMetrics,
+  validateReferrerRank: () => validateReferrerRank,
+  validateReferrerScore: () => validateReferrerScore,
+  validateScoredReferrerMetrics: () => validateScoredReferrerMetrics,
+  validateUSDQuantity: () => validateUSDQuantity,
+  validateUnixTimestamp: () => validateUnixTimestamp
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/constants.ts
-var ENS_HOLIDAY_AWARDS_START_DATE = 1764547200;
-var ENS_HOLIDAY_AWARDS_END_DATE = 1767225599;
-
-// src/referrer.ts
+// src/address.ts
 var import_viem = require("viem");
+var validateLowercaseAddress = (address) => {
+  if (!(0, import_viem.isAddress)(address, { strict: false })) {
+    throw new Error(`Invalid address: ${address}. Address must be a valid EVM address.`);
+  }
+  if (address !== address.toLowerCase()) {
+    throw new Error(`Invalid address: ${address}. Address must be in lowercase format.`);
+  }
+};
+var normalizeAddress = (address) => {
+  return address.toLowerCase();
+};
+
+// src/number.ts
+var isInteger = (value) => {
+  return Number.isInteger(value);
+};
+var isNonNegativeInteger = (value) => {
+  return value >= 0 && Number.isInteger(value);
+};
+var isPositiveInteger = (value) => {
+  return value >= 1 && Number.isInteger(value);
+};
+var validateNonNegativeInteger = (value) => {
+  if (!isNonNegativeInteger(value)) {
+    throw new Error(`Invalid non-negative integer: ${value}.`);
+  }
+};
+var isFiniteNonNegativeNumber = (value) => {
+  return value >= 0 && Number.isFinite(value);
+};
+
+// src/time.ts
+var validateUnixTimestamp = (timestamp) => {
+  if (!isInteger(timestamp)) {
+    throw new Error(`Invalid Unix timestamp: ${timestamp}. Unix timestamp must be an integer.`);
+  }
+};
+var SECONDS_PER_YEAR = 31556952;
+function isValidDuration(duration) {
+  return isNonNegativeInteger(duration);
+}
+function validateDuration(duration) {
+  if (!isValidDuration(duration)) {
+    throw new Error(`Invalid duration: ${duration}. Duration must be a non-negative integer.`);
+  }
+}
+
+// src/score.ts
+var isValidReferrerScore = (score) => {
+  return score >= 0 && Number.isFinite(score);
+};
+var validateReferrerScore = (score) => {
+  if (!isValidReferrerScore(score)) {
+    throw new Error(
+      `Invalid referrer score: ${score}. Referrer score must be a finite non-negative number.`
+    );
+  }
+};
+var calcReferrerScore = (totalIncrementalDuration) => {
+  return totalIncrementalDuration / SECONDS_PER_YEAR;
+};
+
+// src/aggregations.ts
+var validateAggregatedReferrerMetrics = (metrics) => {
+  validateNonNegativeInteger(metrics.grandTotalReferrals);
+  validateDuration(metrics.grandTotalIncrementalDuration);
+  validateReferrerScore(metrics.grandTotalQualifiedReferrersFinalScore);
+  validateReferrerScore(metrics.minFinalScoreToQualify);
+};
+var buildAggregatedReferrerMetrics = (referrers, rules) => {
+  let grandTotalReferrals = 0;
+  let grandTotalIncrementalDuration = 0;
+  let grandTotalQualifiedReferrersFinalScore = 0;
+  let minFinalScoreToQualify = Number.MAX_SAFE_INTEGER;
+  for (const referrer of referrers) {
+    grandTotalReferrals += referrer.totalReferrals;
+    grandTotalIncrementalDuration += referrer.totalIncrementalDuration;
+    if (referrer.isQualified) {
+      grandTotalQualifiedReferrersFinalScore += referrer.finalScore;
+      if (referrer.finalScore < minFinalScoreToQualify) {
+        minFinalScoreToQualify = referrer.finalScore;
+      }
+    }
+  }
+  if (minFinalScoreToQualify === Number.MAX_SAFE_INTEGER) {
+    if (rules.maxQualifiedReferrers === 0) {
+    } else {
+      if (referrers.length !== 0) {
+        throw new Error(
+          "AggregatedReferrerMetrics: There are referrers on the leaderboard, and the rules allow for qualified referrers, but no qualified referrers."
+        );
+      }
+      minFinalScoreToQualify = 0;
+    }
+  }
+  const result = {
+    grandTotalReferrals,
+    grandTotalIncrementalDuration,
+    grandTotalQualifiedReferrersFinalScore,
+    minFinalScoreToQualify
+  };
+  validateAggregatedReferrerMetrics(result);
+  return result;
+};
+
+// src/currency.ts
+function isValidUSDQuantity(value) {
+  return isFiniteNonNegativeNumber(value);
+}
+function validateUSDQuantity(value) {
+  if (!isValidUSDQuantity(value)) {
+    throw new Error(`Invalid USD quantity: ${value}.`);
+  }
+}
+
+// src/encoding.ts
+var import_viem2 = require("viem");
 var ENCODED_REFERRER_BYTE_OFFSET = 12;
 var ENCODED_REFERRER_BYTE_LENGTH = 32;
-var encodedReferrerPadding = (0, import_viem.pad)("0x", {
+var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem2.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_OFFSET,
   dir: "left"
 });
-var zeroEncodedReferrer = (0, import_viem.pad)("0x", {
+var ZERO_ENCODED_REFERRER = (0, import_viem2.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_LENGTH,
   dir: "left"
 });
 function buildEncodedReferrer(address) {
   const lowercaseAddress = address.toLowerCase();
-  return (0, import_viem.pad)(lowercaseAddress, { size: ENCODED_REFERRER_BYTE_LENGTH, dir: "left" });
+  return (0, import_viem2.pad)(lowercaseAddress, { size: ENCODED_REFERRER_BYTE_LENGTH, dir: "left" });
 }
 function decodeEncodedReferrer(encodedReferrer) {
-  if ((0, import_viem.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
+  if ((0, import_viem2.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_viem.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
-  if (padding !== encodedReferrerPadding) {
-    return import_viem.zeroAddress;
+  const padding = (0, import_viem2.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
+  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
+    return import_viem2.zeroAddress;
   }
-  const decodedReferrer = (0, import_viem.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
+  const decodedReferrer = (0, import_viem2.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
   try {
-    return (0, import_viem.getAddress)(decodedReferrer);
+    return (0, import_viem2.getAddress)(decodedReferrer);
   } catch {
     throw new Error(`Decoded referrer value must be a valid EVM address.`);
   }
 }
+
+// src/rank.ts
+var validateReferrerRank = (rank) => {
+  if (!isPositiveInteger(rank)) {
+    throw new Error(`Invalid ReferrerRank: ${rank}. ReferrerRank must be a positive integer.`);
+  }
+};
+function isReferrerQualified(rank, rules) {
+  return rank <= rules.maxQualifiedReferrers;
+}
+function calcReferrerFinalScoreBoost(rank, rules) {
+  if (!isReferrerQualified(rank, rules)) return 0;
+  return 1 - (rank - 1) / (rules.maxQualifiedReferrers - 1);
+}
+function calcReferrerFinalScoreMultiplier(rank, rules) {
+  return 1 + calcReferrerFinalScoreBoost(rank, rules);
+}
+function calcReferrerFinalScore(rank, totalIncrementalDuration, rules) {
+  return calcReferrerScore(totalIncrementalDuration) * calcReferrerFinalScoreMultiplier(rank, rules);
+}
+var compareReferrerMetrics = (a, b) => {
+  if (a.totalIncrementalDuration !== b.totalIncrementalDuration) {
+    return b.totalIncrementalDuration - a.totalIncrementalDuration;
+  }
+  if (b.referrer > a.referrer) return 1;
+  if (b.referrer < a.referrer) return -1;
+  return 0;
+};
+
+// src/referrer-metrics.ts
+var buildReferrerMetrics = (referrer, totalReferrals, totalIncrementalDuration) => {
+  const result = {
+    referrer: normalizeAddress(referrer),
+    totalReferrals,
+    totalIncrementalDuration
+  };
+  validateReferrerMetrics(result);
+  return result;
+};
+var validateReferrerMetrics = (metrics) => {
+  validateLowercaseAddress(metrics.referrer);
+  validateNonNegativeInteger(metrics.totalReferrals);
+  validateDuration(metrics.totalIncrementalDuration);
+};
+var sortReferrerMetrics = (referrers) => {
+  return [...referrers].sort(compareReferrerMetrics);
+};
+var buildScoredReferrerMetrics = (referrer) => {
+  const result = {
+    ...referrer,
+    score: calcReferrerScore(referrer.totalIncrementalDuration)
+  };
+  validateScoredReferrerMetrics(result);
+  return result;
+};
+var validateScoredReferrerMetrics = (metrics) => {
+  validateReferrerMetrics(metrics);
+  validateReferrerScore(metrics.score);
+  const expectedScore = calcReferrerScore(metrics.totalIncrementalDuration);
+  if (metrics.score !== expectedScore) {
+    throw new Error(`Referrer: Invalid score: ${metrics.score}, expected: ${expectedScore}.`);
+  }
+};
+var validateRankedReferrerMetrics = (metrics, rules) => {
+  validateScoredReferrerMetrics(metrics);
+  validateReferrerRank(metrics.rank);
+  if (metrics.finalScoreBoost < 0 || metrics.finalScoreBoost > 1) {
+    throw new Error(
+      `Invalid RankedReferrerMetrics: Invalid finalScoreBoost: ${metrics.finalScoreBoost}. finalScoreBoost must be between 0 and 1 (inclusive).`
+    );
+  }
+  validateReferrerScore(metrics.finalScore);
+  const expectedIsQualified = isReferrerQualified(metrics.rank, rules);
+  if (metrics.isQualified !== expectedIsQualified) {
+    throw new Error(
+      `RankedReferrerMetrics: Invalid isQualified: ${metrics.isQualified}, expected: ${expectedIsQualified}.`
+    );
+  }
+  const expectedFinalScoreBoost = calcReferrerFinalScoreBoost(metrics.rank, rules);
+  if (metrics.finalScoreBoost !== expectedFinalScoreBoost) {
+    throw new Error(
+      `RankedReferrerMetrics: Invalid finalScoreBoost: ${metrics.finalScoreBoost}, expected: ${expectedFinalScoreBoost}.`
+    );
+  }
+  const expectedFinalScore = calcReferrerFinalScore(
+    metrics.rank,
+    metrics.totalIncrementalDuration,
+    rules
+  );
+  if (metrics.finalScore !== expectedFinalScore) {
+    throw new Error(
+      `RankedReferrerMetrics: Invalid finalScore: ${metrics.finalScore}, expected: ${expectedFinalScore}.`
+    );
+  }
+};
+var buildRankedReferrerMetrics = (referrer, rank, rules) => {
+  const result = {
+    ...referrer,
+    rank,
+    isQualified: isReferrerQualified(rank, rules),
+    finalScoreBoost: calcReferrerFinalScoreBoost(rank, rules),
+    finalScore: calcReferrerFinalScore(rank, referrer.totalIncrementalDuration, rules)
+  };
+  validateRankedReferrerMetrics(result, rules);
+  return result;
+};
+var calcReferrerAwardPoolShare = (referrer, aggregatedMetrics, rules) => {
+  if (!isReferrerQualified(referrer.rank, rules)) return 0;
+  if (aggregatedMetrics.grandTotalQualifiedReferrersFinalScore === 0) return 0;
+  return calcReferrerFinalScore(referrer.rank, referrer.totalIncrementalDuration, rules) / aggregatedMetrics.grandTotalQualifiedReferrersFinalScore;
+};
+var validateAwardedReferrerMetrics = (referrer, rules) => {
+  validateRankedReferrerMetrics(referrer, rules);
+  if (referrer.awardPoolShare < 0 || referrer.awardPoolShare > 1) {
+    throw new Error(
+      `Invalid AwardedReferrerMetrics: ${referrer.awardPoolShare}. awardPoolShare must be between 0 and 1 (inclusive).`
+    );
+  }
+  if (referrer.awardPoolApproxValue < 0 || referrer.awardPoolApproxValue > rules.totalAwardPoolValue) {
+    throw new Error(
+      `Invalid AwardedReferrerMetrics: ${referrer.awardPoolApproxValue}. awardPoolApproxValue must be between 0 and ${rules.totalAwardPoolValue} (inclusive).`
+    );
+  }
+};
+var buildAwardedReferrerMetrics = (referrer, aggregatedMetrics, rules) => {
+  const awardPoolShare = calcReferrerAwardPoolShare(referrer, aggregatedMetrics, rules);
+  const result = {
+    ...referrer,
+    awardPoolShare,
+    awardPoolApproxValue: awardPoolShare * rules.totalAwardPoolValue
+  };
+  validateAwardedReferrerMetrics(result, rules);
+  return result;
+};
+
+// src/leaderboard.ts
+var buildReferrerLeaderboard = (allReferrers, rules, accurateAsOf) => {
+  const uniqueReferrers = allReferrers.map((referrer) => referrer.referrer);
+  if (uniqueReferrers.length !== allReferrers.length) {
+    throw new Error(
+      "ReferrerLeaderboard: Cannot buildReferrerLeaderboard containing duplicate referrers"
+    );
+  }
+  if (accurateAsOf < rules.startTime && allReferrers.length > 0) {
+    throw new Error(
+      `ReferrerLeaderboard: accurateAsOf (${accurateAsOf}) is before startTime (${rules.startTime}) which indicates allReferrers should be empty, but allReferrers is not empty.`
+    );
+  }
+  const sortedReferrers = sortReferrerMetrics(allReferrers);
+  const scoredReferrers = sortedReferrers.map((referrer) => buildScoredReferrerMetrics(referrer));
+  const rankedReferrers = scoredReferrers.map((referrer, index) => {
+    return buildRankedReferrerMetrics(referrer, index + 1, rules);
+  });
+  const aggregatedMetrics = buildAggregatedReferrerMetrics(rankedReferrers, rules);
+  const awardedReferrers = rankedReferrers.map((referrer) => {
+    return buildAwardedReferrerMetrics(referrer, aggregatedMetrics, rules);
+  });
+  const referrers = new Map(
+    awardedReferrers.map((referrer) => {
+      return [referrer.referrer, referrer];
+    })
+  );
+  return {
+    rules,
+    aggregatedMetrics,
+    referrers,
+    accurateAsOf
+  };
+};
+
+// src/leaderboard-page.ts
+var REFERRERS_PER_LEADERBOARD_PAGE_DEFAULT = 25;
+var REFERRERS_PER_LEADERBOARD_PAGE_MAX = 100;
+var validateReferrerLeaderboardPaginationParams = (params) => {
+  if (params.page !== void 0 && !isPositiveInteger(params.page)) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPaginationParams: ${params.page}. page must be a positive integer.`
+    );
+  }
+  if (params.itemsPerPage !== void 0 && !isPositiveInteger(params.itemsPerPage)) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPaginationParams: ${params.itemsPerPage}. itemsPerPage must be a positive integer.`
+    );
+  }
+  if (params.itemsPerPage !== void 0 && params.itemsPerPage > REFERRERS_PER_LEADERBOARD_PAGE_MAX) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPaginationParams: ${params.itemsPerPage}. itemsPerPage must be less than or equal to ${REFERRERS_PER_LEADERBOARD_PAGE_MAX}.`
+    );
+  }
+};
+var buildReferrerLeaderboardPaginationParams = (params) => {
+  const result = {
+    page: params.page ?? 1,
+    itemsPerPage: params.itemsPerPage ?? REFERRERS_PER_LEADERBOARD_PAGE_DEFAULT
+  };
+  validateReferrerLeaderboardPaginationParams(result);
+  return result;
+};
+var validateReferrerLeaderboardPaginationContext = (context) => {
+  validateReferrerLeaderboardPaginationParams(context);
+  if (!isNonNegativeInteger(context.totalRecords)) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPaginationContext: total must be a non-negative integer but is ${context.totalRecords}.`
+    );
+  }
+  const startIndex = (context.page - 1) * context.itemsPerPage;
+  const endIndex = startIndex + context.itemsPerPage;
+  if (!context.hasNext && endIndex < context.totalRecords) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPaginationContext: if hasNext is false, endIndex (${endIndex}) must be greater than or equal to total (${context.totalRecords}).`
+    );
+  } else if (context.hasNext && context.page * context.itemsPerPage >= context.totalRecords) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPaginationContext: if hasNext is true, endIndex (${endIndex}) must be less than total (${context.totalRecords}).`
+    );
+  }
+  if (!context.hasPrev && context.page !== 1) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPaginationContext: if hasPrev is false, page must be the first page (1) but is ${context.page}.`
+    );
+  } else if (context.hasPrev && context.page === 1) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPaginationContext: if hasPrev is true, page must not be the first page (1) but is ${context.page}.`
+    );
+  }
+};
+var buildReferrerLeaderboardPaginationContext = (optionalParams, leaderboard) => {
+  const materializedParams = buildReferrerLeaderboardPaginationParams(optionalParams);
+  const totalRecords = leaderboard.referrers.size;
+  const totalPages = Math.max(1, Math.ceil(totalRecords / materializedParams.itemsPerPage));
+  if (materializedParams.page > totalPages) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPaginationContext: page ${materializedParams.page} exceeds total pages ${totalPages}.`
+    );
+  }
+  if (totalRecords === 0) {
+    return {
+      ...materializedParams,
+      totalRecords: 0,
+      totalPages: 1,
+      hasNext: false,
+      hasPrev: false,
+      startIndex: void 0,
+      endIndex: void 0
+    };
+  }
+  const startIndex = (materializedParams.page - 1) * materializedParams.itemsPerPage;
+  const maxTheoreticalIndexOnPage = startIndex + (materializedParams.itemsPerPage - 1);
+  const endIndex = Math.min(maxTheoreticalIndexOnPage, totalRecords - 1);
+  const hasNext = maxTheoreticalIndexOnPage < totalRecords;
+  const hasPrev = materializedParams.page > 1;
+  const result = {
+    ...materializedParams,
+    totalRecords,
+    totalPages,
+    hasNext,
+    hasPrev,
+    startIndex,
+    endIndex
+  };
+  validateReferrerLeaderboardPaginationContext(result);
+  return result;
+};
+var getReferrerLeaderboardPage = (paginationParams, leaderboard) => {
+  const paginationContext = buildReferrerLeaderboardPaginationContext(
+    paginationParams,
+    leaderboard
+  );
+  let referrers;
+  if (paginationContext.totalRecords > 0 && typeof paginationContext.startIndex !== "undefined" && typeof paginationContext.endIndex !== "undefined") {
+    referrers = Array.from(leaderboard.referrers.values()).slice(
+      paginationContext.startIndex,
+      paginationContext.endIndex + 1
+      // For `slice`, this is exclusive of the element at the index 'end'. We need it to be inclusive, hence plus one.
+    );
+  } else {
+    referrers = [];
+  }
+  return {
+    rules: leaderboard.rules,
+    referrers,
+    aggregatedMetrics: leaderboard.aggregatedMetrics,
+    paginationContext,
+    accurateAsOf: leaderboard.accurateAsOf
+  };
+};
+
+// src/link.ts
+var import_viem3 = require("viem");
 function buildEnsReferralUrl(address) {
   const ensAppUrl = new URL("https://app.ens.domains");
-  ensAppUrl.searchParams.set("referrer", (0, import_viem.getAddress)(address));
+  ensAppUrl.searchParams.set("referrer", (0, import_viem3.getAddress)(address));
   return ensAppUrl;
 }
+
+// src/rules.ts
+var ENS_HOLIDAY_AWARDS_START_DATE = 1764547200;
+var ENS_HOLIDAY_AWARDS_END_DATE = 1767225599;
+var ENS_HOLIDAY_AWARDS_MAX_QUALIFIED_REFERRERS = 10;
+var ENS_HOLIDAY_AWARDS_TOTAL_AWARD_POOL_VALUE = 1e4;
+var validateReferralProgramRules = (rules) => {
+  validateUSDQuantity(rules.totalAwardPoolValue);
+  validateNonNegativeInteger(rules.maxQualifiedReferrers);
+  validateUnixTimestamp(rules.startTime);
+  validateUnixTimestamp(rules.endTime);
+  if (rules.endTime < rules.startTime) {
+    throw new Error(
+      `ReferralProgramRules: startTime: ${rules.startTime} is after endTime: ${rules.endTime}.`
+    );
+  }
+};
+var buildReferralProgramRules = (totalAwardPoolValue, maxQualifiedReferrers, startTime, endTime, subregistryId) => {
+  const result = {
+    totalAwardPoolValue,
+    maxQualifiedReferrers,
+    startTime,
+    endTime,
+    subregistryId
+  };
+  validateReferralProgramRules(result);
+  return result;
+};
 //# sourceMappingURL=index.cjs.map