@namehash/ens-referrals 1.10.0 → 1.10.1

package/dist/index.cjs

@@ -69,6 +69,7 @@ __export(index_exports, {
   buildUnrankedReferrerMetricsPieSplit: () => buildUnrankedReferrerMetricsPieSplit,
   buildUnrankedReferrerMetricsRevShareCap: () => buildUnrankedReferrerMetricsRevShareCap,
   calcBaseReferralProgramEditionStatus: () => calcBaseReferralProgramEditionStatus,
+  calcBaseRevenueContribution: () => calcBaseRevenueContribution,
   calcReferralProgramEditionStatusPieSplit: () => calcReferralProgramEditionStatusPieSplit,
   calcReferralProgramEditionStatusRevShareCap: () => calcReferralProgramEditionStatusRevShareCap,
   calcReferrerAwardPoolSharePieSplit: () => calcReferrerAwardPoolSharePieSplit,
@@ -508,6 +509,45 @@ function priceUsdc(amount) {
     currency: CurrencyIds.USDC
   };
 }
+function isPriceCurrencyEqual(priceA, priceB) {
+  return priceA.currency === priceB.currency;
+}
+function addPrices(...prices) {
+  const firstPrice = prices[0];
+  const allPricesInSameCurrency = prices.every((price) => isPriceCurrencyEqual(firstPrice, price));
+  if (allPricesInSameCurrency === false) {
+    throw new Error("All prices must have the same currency to be added together.");
+  }
+  const { currency } = firstPrice;
+  return prices.reduce(
+    (acc, price) => ({
+      amount: acc.amount + price.amount,
+      currency
+    }),
+    {
+      amount: 0n,
+      currency: firstPrice.currency
+    }
+  );
+}
+function subtractPrice(a, b) {
+  if (!isPriceCurrencyEqual(a, b)) {
+    throw new Error("All prices must have the same currency to be subtracted.");
+  }
+  const resultAmount = a.amount - b.amount;
+  if (resultAmount < 0n) {
+    throw new Error("subtractPrice result must be non-negative.");
+  }
+  return { amount: resultAmount, currency: a.currency };
+}
+function minPrice(...prices) {
+  const firstPrice = prices[0];
+  const allPricesInSameCurrency = prices.every((price) => isPriceCurrencyEqual(firstPrice, price));
+  if (allPricesInSameCurrency === false) {
+    throw new Error("All prices must have the same currency to be compared.");
+  }
+  return prices.reduce((acc, price) => price.amount < acc.amount ? price : acc);
+}
 function scalePrice(price, scaleFactor) {
   const scaledAmount = scaleBigintByNumber(price.amount, scaleFactor);
   return {
@@ -1062,6 +1102,11 @@ var buildReferralProgramRulesRevShareCap = (awardPool, minBaseRevenueContributio
   validateReferralProgramRulesRevShareCap(result);
   return result;
 };
+function calcBaseRevenueContribution(rules, duration) {
+  return priceUsdc(
+    rules.baseAnnualRevenueContribution.amount * BigInt(duration) / BigInt(SECONDS_PER_YEAR)
+  );
+}
 function isReferrerQualifiedRevShareCap(referrer, totalBaseRevenueContribution, rules) {
   const isAdminDisqualified = rules.adminActions.some(
     (a) => a.referrer === referrer && a.actionType === AdminActionTypes.Disqualification
@@ -2420,8 +2465,9 @@ var validateReferrerMetricsRevShareCap = (metrics, rules) => {
   makePriceUsdcSchema("ReferrerMetricsRevShareCap.totalBaseRevenueContribution").parse(
     metrics.totalBaseRevenueContribution
   );
-  const expectedTotalBaseRevenueContribution = priceUsdc(
-    rules.baseAnnualRevenueContribution.amount * BigInt(metrics.totalIncrementalDuration) / BigInt(SECONDS_PER_YEAR)
+  const expectedTotalBaseRevenueContribution = calcBaseRevenueContribution(
+    rules,
+    metrics.totalIncrementalDuration
   );
   if (metrics.totalBaseRevenueContribution.amount !== expectedTotalBaseRevenueContribution.amount) {
     throw new Error(
@@ -2430,8 +2476,9 @@ var validateReferrerMetricsRevShareCap = (metrics, rules) => {
   }
 };
 var buildReferrerMetricsRevShareCap = (metrics, rules) => {
-  const totalBaseRevenueContribution = priceUsdc(
-    rules.baseAnnualRevenueContribution.amount * BigInt(metrics.totalIncrementalDuration) / BigInt(SECONDS_PER_YEAR)
+  const totalBaseRevenueContribution = calcBaseRevenueContribution(
+    rules,
+    metrics.totalIncrementalDuration
   );
   const result = {
     ...metrics,
@@ -2605,71 +2652,71 @@ function sortReferralEvents(events) {
 }
 
 // src/award-models/rev-share-cap/leaderboard.ts
-var bigintMin = (a, b) => a < b ? a : b;
 var buildReferrerLeaderboardRevShareCap = (events, rules, accurateAsOf) => {
   const sortedEvents = sortReferralEvents(events);
   const referrerStates = /* @__PURE__ */ new Map();
-  let awardPoolRemaining = rules.awardPool.amount;
+  let awardPoolRemaining = rules.awardPool;
   for (const event of sortedEvents) {
-    const referrer = event.referrer;
-    let state = referrerStates.get(referrer);
-    if (!state) {
-      state = {
+    const referrerId = event.referrer;
+    let referrerState = referrerStates.get(referrerId);
+    if (!referrerState) {
+      referrerState = {
         totalReferrals: 0,
         totalIncrementalDuration: 0,
-        totalRevenueContributionAmount: 0n,
-        wasQualified: false,
-        cappedAwardAmount: 0n
+        totalRevenueContribution: priceEth(0n),
+        hasQualified: false,
+        cappedAward: priceUsdc(0n)
       };
-      referrerStates.set(referrer, state);
+      referrerStates.set(referrerId, referrerState);
     }
-    state.totalReferrals += 1;
-    state.totalIncrementalDuration += event.incrementalDuration;
-    state.totalRevenueContributionAmount += event.incrementalRevenueContribution.amount;
-    const totalBaseRevenueAmount = rules.baseAnnualRevenueContribution.amount * BigInt(state.totalIncrementalDuration) / BigInt(SECONDS_PER_YEAR);
-    const isNowQualified = isReferrerQualifiedRevShareCap(
-      referrer,
-      priceUsdc(totalBaseRevenueAmount),
-      rules
-    );
-    if (isNowQualified && !state.wasQualified) {
-      const accumulatedUncappedAward = scalePrice(
-        priceUsdc(totalBaseRevenueAmount),
-        rules.maxBaseRevenueShare
-      ).amount;
-      const incrementalCappedAward = bigintMin(accumulatedUncappedAward, awardPoolRemaining);
-      state.cappedAwardAmount += incrementalCappedAward;
-      awardPoolRemaining -= incrementalCappedAward;
-      state.wasQualified = true;
-    } else if (state.wasQualified) {
-      const incrementalBaseRevenueAmount = rules.baseAnnualRevenueContribution.amount * BigInt(event.incrementalDuration) / BigInt(SECONDS_PER_YEAR);
+    referrerState.totalReferrals += 1;
+    referrerState.totalIncrementalDuration += event.incrementalDuration;
+    referrerState.totalRevenueContribution = addPrices(
+      referrerState.totalRevenueContribution,
+      event.incrementalRevenueContribution
+    );
+    const totalBaseRevenue = calcBaseRevenueContribution(
+      rules,
+      referrerState.totalIncrementalDuration
+    );
+    const isNowQualified = isReferrerQualifiedRevShareCap(referrerId, totalBaseRevenue, rules);
+    if (isNowQualified && !referrerState.hasQualified) {
+      const accumulatedUncappedAward = scalePrice(totalBaseRevenue, rules.maxBaseRevenueShare);
+      const incrementalCappedAward = minPrice(accumulatedUncappedAward, awardPoolRemaining);
+      referrerState.cappedAward = addPrices(referrerState.cappedAward, incrementalCappedAward);
+      awardPoolRemaining = subtractPrice(awardPoolRemaining, incrementalCappedAward);
+      referrerState.hasQualified = true;
+    } else if (referrerState.hasQualified) {
+      const incrementalBaseRevenue = calcBaseRevenueContribution(rules, event.incrementalDuration);
       const incrementalUncappedAward = scalePrice(
-        priceUsdc(incrementalBaseRevenueAmount),
+        incrementalBaseRevenue,
         rules.maxBaseRevenueShare
-      ).amount;
-      const incrementalCappedAward = bigintMin(incrementalUncappedAward, awardPoolRemaining);
-      state.cappedAwardAmount += incrementalCappedAward;
-      awardPoolRemaining -= incrementalCappedAward;
+      );
+      const incrementalCappedAward = minPrice(incrementalUncappedAward, awardPoolRemaining);
+      referrerState.cappedAward = addPrices(referrerState.cappedAward, incrementalCappedAward);
+      awardPoolRemaining = subtractPrice(awardPoolRemaining, incrementalCappedAward);
     }
   }
-  const sortedEntries = [...referrerStates.entries()].sort(([a, stateA], [b, stateB]) => {
-    if (stateB.cappedAwardAmount !== stateA.cappedAwardAmount) {
-      return stateB.cappedAwardAmount > stateA.cappedAwardAmount ? 1 : -1;
-    }
-    if (stateB.totalIncrementalDuration !== stateA.totalIncrementalDuration) {
-      return stateB.totalIncrementalDuration - stateA.totalIncrementalDuration;
+  const sortedEntries = [...referrerStates.entries()].sort(
+    ([referrerIdA, referrerStateA], [referrerIdB, referrerStateB]) => {
+      if (referrerStateB.cappedAward.amount !== referrerStateA.cappedAward.amount) {
+        return referrerStateB.cappedAward.amount > referrerStateA.cappedAward.amount ? 1 : -1;
+      }
+      if (referrerStateB.totalIncrementalDuration !== referrerStateA.totalIncrementalDuration) {
+        return referrerStateB.totalIncrementalDuration - referrerStateA.totalIncrementalDuration;
+      }
+      if (referrerIdB > referrerIdA) return 1;
+      if (referrerIdB < referrerIdA) return -1;
+      return 0;
     }
-    if (b > a) return 1;
-    if (b < a) return -1;
-    return 0;
-  });
+  );
   const awardedReferrers = sortedEntries.map(
-    ([referrerAddr, state], index) => {
+    ([referrerId, referrerState], index) => {
       const baseMetrics = buildReferrerMetrics(
-        referrerAddr,
-        state.totalReferrals,
-        state.totalIncrementalDuration,
-        priceEth(state.totalRevenueContributionAmount)
+        referrerId,
+        referrerState.totalReferrals,
+        referrerState.totalIncrementalDuration,
+        referrerState.totalRevenueContribution
       );
       const revShareMetrics = buildReferrerMetricsRevShareCap(baseMetrics, rules);
       const rankedMetrics = buildRankedReferrerMetricsRevShareCap(
@@ -2684,14 +2731,14 @@ var buildReferrerLeaderboardRevShareCap = (events, rules, accurateAsOf) => {
       return buildAwardedReferrerMetricsRevShareCap(
         rankedMetrics,
         uncappedAward,
-        priceUsdc(state.cappedAwardAmount),
+        referrerState.cappedAward,
         rules
       );
     }
   );
   const aggregatedMetrics = buildAggregatedReferrerMetricsRevShareCap(
     awardedReferrers,
-    priceUsdc(awardPoolRemaining)
+    awardPoolRemaining
   );
   const referrers = new Map(awardedReferrers.map((r) => [r.referrer, r]));
   return { awardModel: rules.awardModel, rules, aggregatedMetrics, referrers, accurateAsOf };