@namehash/ens-referrals 0.0.0-next-20260102143513

package/dist/index.js

@@ -0,0 +1,646 @@
+// src/address.ts
+import { isAddress } from "viem";
+var validateLowercaseAddress = (address) => {
+  if (!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/revenue-contribution.ts
+function isValidRevenueContribution(value) {
+  return typeof value === "bigint" && value >= 0n;
+}
+function validateRevenueContribution(value) {
+  if (typeof value !== "bigint") {
+    throw new Error(`Invalid revenue contribution: must be a bigint, got: ${typeof value}`);
+  }
+  if (value < 0n) {
+    throw new Error(`Invalid revenue contribution: must be non-negative, got: ${value.toString()}`);
+  }
+}
+
+// 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);
+  validateRevenueContribution(metrics.grandTotalRevenueContribution);
+  validateReferrerScore(metrics.grandTotalQualifiedReferrersFinalScore);
+  validateReferrerScore(metrics.minFinalScoreToQualify);
+};
+var buildAggregatedReferrerMetrics = (referrers, rules) => {
+  let grandTotalReferrals = 0;
+  let grandTotalIncrementalDuration = 0;
+  let grandTotalRevenueContribution = 0n;
+  let grandTotalQualifiedReferrersFinalScore = 0;
+  let minFinalScoreToQualify = Number.MAX_SAFE_INTEGER;
+  for (const referrer of referrers) {
+    grandTotalReferrals += referrer.totalReferrals;
+    grandTotalIncrementalDuration += referrer.totalIncrementalDuration;
+    grandTotalRevenueContribution += referrer.totalRevenueContribution;
+    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,
+    grandTotalRevenueContribution,
+    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
+import { getAddress, pad, size, slice, zeroAddress } from "viem";
+var ENCODED_REFERRER_BYTE_OFFSET = 12;
+var ENCODED_REFERRER_BYTE_LENGTH = 32;
+var EXPECTED_ENCODED_REFERRER_PADDING = pad("0x", {
+  size: ENCODED_REFERRER_BYTE_OFFSET,
+  dir: "left"
+});
+var ZERO_ENCODED_REFERRER = pad("0x", {
+  size: ENCODED_REFERRER_BYTE_LENGTH,
+  dir: "left"
+});
+function buildEncodedReferrer(address) {
+  const lowercaseAddress = address.toLowerCase();
+  return pad(lowercaseAddress, { size: ENCODED_REFERRER_BYTE_LENGTH, dir: "left" });
+}
+function decodeEncodedReferrer(encodedReferrer) {
+  if (size(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
+    throw new Error(
+      `Encoded referrer value must be represented by ${ENCODED_REFERRER_BYTE_LENGTH} bytes.`
+    );
+  }
+  const padding = slice(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
+  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
+    return zeroAddress;
+  }
+  const decodedReferrer = slice(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
+  try {
+    return 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, totalRevenueContribution) => {
+  const result = {
+    referrer: normalizeAddress(referrer),
+    totalReferrals,
+    totalIncrementalDuration,
+    totalRevenueContribution
+  };
+  validateReferrerMetrics(result);
+  return result;
+};
+var validateReferrerMetrics = (metrics) => {
+  validateLowercaseAddress(metrics.referrer);
+  validateNonNegativeInteger(metrics.totalReferrals);
+  validateDuration(metrics.totalIncrementalDuration);
+  validateRevenueContribution(metrics.totalRevenueContribution);
+};
+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;
+};
+var validateUnrankedReferrerMetrics = (metrics) => {
+  validateScoredReferrerMetrics(metrics);
+  if (metrics.rank !== null) {
+    throw new Error(`Invalid UnrankedReferrerMetrics: rank must be null, got: ${metrics.rank}.`);
+  }
+  if (metrics.isQualified !== false) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetrics: isQualified must be false, got: ${metrics.isQualified}.`
+    );
+  }
+  if (metrics.totalReferrals !== 0) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetrics: totalReferrals must be 0, got: ${metrics.totalReferrals}.`
+    );
+  }
+  if (metrics.totalIncrementalDuration !== 0) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetrics: totalIncrementalDuration must be 0, got: ${metrics.totalIncrementalDuration}.`
+    );
+  }
+  if (metrics.totalRevenueContribution !== 0n) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetrics: totalRevenueContribution must be 0n, got: ${metrics.totalRevenueContribution.toString()}.`
+    );
+  }
+  if (metrics.score !== 0) {
+    throw new Error(`Invalid UnrankedReferrerMetrics: score must be 0, got: ${metrics.score}.`);
+  }
+  if (metrics.finalScoreBoost !== 0) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetrics: finalScoreBoost must be 0, got: ${metrics.finalScoreBoost}.`
+    );
+  }
+  if (metrics.finalScore !== 0) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetrics: finalScore must be 0, got: ${metrics.finalScore}.`
+    );
+  }
+  if (metrics.awardPoolShare !== 0) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetrics: awardPoolShare must be 0, got: ${metrics.awardPoolShare}.`
+    );
+  }
+  if (metrics.awardPoolApproxValue !== 0) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetrics: awardPoolApproxValue must be 0, got: ${metrics.awardPoolApproxValue}.`
+    );
+  }
+};
+var buildUnrankedReferrerMetrics = (referrer) => {
+  const baseMetrics = buildReferrerMetrics(referrer, 0, 0, 0n);
+  const scoredMetrics = buildScoredReferrerMetrics(baseMetrics);
+  const result = {
+    ...scoredMetrics,
+    rank: null,
+    isQualified: false,
+    finalScoreBoost: 0,
+    finalScore: 0,
+    awardPoolShare: 0,
+    awardPoolApproxValue: 0
+  };
+  validateUnrankedReferrerMetrics(result);
+  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 validateReferrerLeaderboardPageParams = (params) => {
+  if (params.page !== void 0 && !isPositiveInteger(params.page)) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPageParams: ${params.page}. page must be a positive integer.`
+    );
+  }
+  if (params.recordsPerPage !== void 0 && !isPositiveInteger(params.recordsPerPage)) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPageParams: ${params.recordsPerPage}. recordsPerPage must be a positive integer.`
+    );
+  }
+  if (params.recordsPerPage !== void 0 && params.recordsPerPage > REFERRERS_PER_LEADERBOARD_PAGE_MAX) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPageParams: ${params.recordsPerPage}. recordsPerPage must be less than or equal to ${REFERRERS_PER_LEADERBOARD_PAGE_MAX}.`
+    );
+  }
+};
+var buildReferrerLeaderboardPageParams = (params) => {
+  const result = {
+    page: params.page ?? 1,
+    recordsPerPage: params.recordsPerPage ?? REFERRERS_PER_LEADERBOARD_PAGE_DEFAULT
+  };
+  validateReferrerLeaderboardPageParams(result);
+  return result;
+};
+var validateReferrerLeaderboardPageContext = (context) => {
+  validateReferrerLeaderboardPageParams(context);
+  if (!isNonNegativeInteger(context.totalRecords)) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPageContext: total must be a non-negative integer but is ${context.totalRecords}.`
+    );
+  }
+  const startIndex = (context.page - 1) * context.recordsPerPage;
+  const endIndex = startIndex + context.recordsPerPage;
+  if (!context.hasNext && endIndex < context.totalRecords) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPageContext: if hasNext is false, endIndex (${endIndex}) must be greater than or equal to total (${context.totalRecords}).`
+    );
+  } else if (context.hasNext && context.page * context.recordsPerPage >= context.totalRecords) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPageContext: if hasNext is true, endIndex (${endIndex}) must be less than total (${context.totalRecords}).`
+    );
+  }
+  if (!context.hasPrev && context.page !== 1) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPageContext: 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 ReferrerLeaderboardPageContext: if hasPrev is true, page must not be the first page (1) but is ${context.page}.`
+    );
+  }
+};
+var buildReferrerLeaderboardPageContext = (optionalParams, leaderboard) => {
+  const materializedParams = buildReferrerLeaderboardPageParams(optionalParams);
+  const totalRecords = leaderboard.referrers.size;
+  const totalPages = Math.max(1, Math.ceil(totalRecords / materializedParams.recordsPerPage));
+  if (materializedParams.page > totalPages) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPageContext: 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.recordsPerPage;
+  const maxTheoreticalIndexOnPage = startIndex + (materializedParams.recordsPerPage - 1);
+  const endIndex = Math.min(maxTheoreticalIndexOnPage, totalRecords - 1);
+  const hasNext = maxTheoreticalIndexOnPage < totalRecords - 1;
+  const hasPrev = materializedParams.page > 1;
+  const result = {
+    ...materializedParams,
+    totalRecords,
+    totalPages,
+    hasNext,
+    hasPrev,
+    startIndex,
+    endIndex
+  };
+  validateReferrerLeaderboardPageContext(result);
+  return result;
+};
+var getReferrerLeaderboardPage = (pageParams, leaderboard) => {
+  const pageContext = buildReferrerLeaderboardPageContext(pageParams, leaderboard);
+  let referrers;
+  if (pageContext.totalRecords > 0 && typeof pageContext.startIndex !== "undefined" && typeof pageContext.endIndex !== "undefined") {
+    referrers = Array.from(leaderboard.referrers.values()).slice(
+      pageContext.startIndex,
+      pageContext.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,
+    pageContext,
+    accurateAsOf: leaderboard.accurateAsOf
+  };
+};
+
+// src/link.ts
+import { getAddress as getAddress2 } from "viem";
+function buildEnsReferralUrl(address) {
+  const ensAppUrl = new URL("https://app.ens.domains");
+  ensAppUrl.searchParams.set("referrer", getAddress2(address));
+  return ensAppUrl;
+}
+
+// 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"
+};
+var getReferrerDetail = (referrer, leaderboard) => {
+  const awardedReferrerMetrics = leaderboard.referrers.get(referrer);
+  if (awardedReferrerMetrics) {
+    return {
+      type: ReferrerDetailTypeIds.Ranked,
+      rules: leaderboard.rules,
+      referrer: awardedReferrerMetrics,
+      aggregatedMetrics: leaderboard.aggregatedMetrics,
+      accurateAsOf: leaderboard.accurateAsOf
+    };
+  }
+  return {
+    type: ReferrerDetailTypeIds.Unranked,
+    rules: leaderboard.rules,
+    referrer: buildUnrankedReferrerMetrics(referrer),
+    aggregatedMetrics: leaderboard.aggregatedMetrics,
+    accurateAsOf: leaderboard.accurateAsOf
+  };
+};
+
+// 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;
+};
+export {
+  ENCODED_REFERRER_BYTE_LENGTH,
+  ENCODED_REFERRER_BYTE_OFFSET,
+  ENS_HOLIDAY_AWARDS_END_DATE,
+  ENS_HOLIDAY_AWARDS_MAX_QUALIFIED_REFERRERS,
+  ENS_HOLIDAY_AWARDS_START_DATE,
+  ENS_HOLIDAY_AWARDS_TOTAL_AWARD_POOL_VALUE,
+  EXPECTED_ENCODED_REFERRER_PADDING,
+  REFERRERS_PER_LEADERBOARD_PAGE_DEFAULT,
+  REFERRERS_PER_LEADERBOARD_PAGE_MAX,
+  ReferrerDetailTypeIds,
+  SECONDS_PER_YEAR,
+  ZERO_ENCODED_REFERRER,
+  buildAggregatedReferrerMetrics,
+  buildAwardedReferrerMetrics,
+  buildEncodedReferrer,
+  buildEnsReferralUrl,
+  buildRankedReferrerMetrics,
+  buildReferralProgramRules,
+  buildReferrerLeaderboard,
+  buildReferrerLeaderboardPageContext,
+  buildReferrerLeaderboardPageParams,
+  buildReferrerMetrics,
+  buildScoredReferrerMetrics,
+  buildUnrankedReferrerMetrics,
+  calcReferrerAwardPoolShare,
+  calcReferrerFinalScore,
+  calcReferrerFinalScoreBoost,
+  calcReferrerFinalScoreMultiplier,
+  calcReferrerScore,
+  compareReferrerMetrics,
+  decodeEncodedReferrer,
+  getReferrerDetail,
+  getReferrerLeaderboardPage,
+  isFiniteNonNegativeNumber,
+  isInteger,
+  isNonNegativeInteger,
+  isPositiveInteger,
+  isReferrerQualified,
+  isValidDuration,
+  isValidReferrerScore,
+  isValidRevenueContribution,
+  isValidUSDQuantity,
+  normalizeAddress,
+  sortReferrerMetrics,
+  validateAggregatedReferrerMetrics,
+  validateAwardedReferrerMetrics,
+  validateDuration,
+  validateLowercaseAddress,
+  validateNonNegativeInteger,
+  validateRankedReferrerMetrics,
+  validateReferralProgramRules,
+  validateReferrerLeaderboardPageContext,
+  validateReferrerMetrics,
+  validateReferrerRank,
+  validateReferrerScore,
+  validateRevenueContribution,
+  validateScoredReferrerMetrics,
+  validateUSDQuantity,
+  validateUnixTimestamp,
+  validateUnrankedReferrerMetrics
+};
+//# sourceMappingURL=index.js.map