@namehash/ens-referrals 1.9.0 → 1.10.1

package/dist/index.js

@@ -1,132 +1,16 @@
 // 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.`);
+import { isNormalizedAddress } from "enssdk";
+var validateNormalizedAddress = (address) => {
+  if (!isNormalizedAddress(address)) {
+    throw new Error(`Invalid address: '${address}'. Address must be a lowercase 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/api/deserialize.ts
 import { prettifyError } from "zod/v4";
 
 // src/api/zod-schemas.ts
-import { z as z2 } from "zod/v4";
+import z5 from "zod/v4";
 
 // ../../node_modules/.pnpm/caip@1.1.1/node_modules/caip/dist/index.mjs
 function _extends() {
@@ -428,12 +312,123 @@ var AssetId = /* @__PURE__ */ (function() {
 AssetId.spec = CAIP["19"].assetId;
 
 // ../ensnode-sdk/src/shared/zod-schemas.ts
-import { isAddress as isAddress2, isHex, size } from "viem";
+import { reinterpretName, toNormalizedAddress } from "enssdk";
+import { isAddress, isHex, size } from "viem";
 import { z } from "zod/v4";
 
-// ../ensnode-sdk/src/shared/address.ts
-function asLowerCaseAddress(address) {
-  return address.toLowerCase();
+// ../ensnode-sdk/src/shared/currencies.ts
+import { parseUnits } from "viem";
+
+// ../ensnode-sdk/src/shared/numbers.ts
+function scaleBigintByNumber(value, scaleFactor) {
+  if (value < 0n) {
+    throw new Error(`scaleBigintByNumber: value must be non-negative, got: ${value.toString()}`);
+  }
+  if (!Number.isFinite(scaleFactor)) {
+    throw new Error(
+      `scaleBigintByNumber: scaleFactor must be a finite number, got: ${scaleFactor}`
+    );
+  }
+  if (scaleFactor < 0) {
+    throw new Error(`scaleBigintByNumber: scaleFactor must be non-negative, got: ${scaleFactor}`);
+  }
+  if (scaleFactor >= 1e21) {
+    throw new Error(`scaleBigintByNumber: scaleFactor must be less than 1e21, got: ${scaleFactor}`);
+  }
+  if (value === 0n || scaleFactor === 0) {
+    return 0n;
+  }
+  if (scaleFactor === 1) {
+    return value;
+  }
+  const fixedStr = scaleFactor.toFixed(20);
+  const [integerPart, decimalPart = ""] = fixedStr.split(".");
+  const trimmedDecimal = decimalPart.replace(/0+$/, "") || "0";
+  const numerator = BigInt(integerPart + trimmedDecimal);
+  const denominator = 10n ** BigInt(trimmedDecimal.length);
+  return value * numerator / denominator;
+}
+
+// ../ensnode-sdk/src/shared/currencies.ts
+var CurrencyIds = {
+  ETH: "ETH",
+  USDC: "USDC",
+  DAI: "DAI"
+};
+var currencyInfo = {
+  [CurrencyIds.ETH]: {
+    id: CurrencyIds.ETH,
+    name: "ETH",
+    decimals: 18
+  },
+  [CurrencyIds.USDC]: {
+    id: CurrencyIds.USDC,
+    name: "USDC",
+    decimals: 6
+  },
+  [CurrencyIds.DAI]: {
+    id: CurrencyIds.DAI,
+    name: "Dai Stablecoin",
+    decimals: 18
+  }
+};
+function priceEth(amount) {
+  return {
+    amount,
+    currency: CurrencyIds.ETH
+  };
+}
+function priceUsdc(amount) {
+  return {
+    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 {
+    ...price,
+    amount: scaledAmount
+  };
 }
 
 // ../ensnode-sdk/src/shared/zod-schemas.ts
@@ -457,22 +452,78 @@ var makeDurationSchema = (valueLabel = "Value") => z.number({
   error: `${valueLabel} must be a number.`
 }).pipe(makeNonNegativeIntegerSchema(valueLabel));
 var makeChainIdSchema = (valueLabel = "Chain ID") => makePositiveIntegerSchema(valueLabel).transform((val) => val);
-var makeLowercaseAddressSchema = (valueLabel = "EVM address") => z.string().check((ctx) => {
-  if (!isAddress2(ctx.value)) {
+var makeNormalizedAddressSchema = (valueLabel = "EVM address") => z.string().check((ctx) => {
+  if (!isAddress(ctx.value, { strict: false })) {
     ctx.issues.push({
       code: "custom",
       message: `${valueLabel} must be a valid EVM address`,
       input: ctx.value
     });
   }
-}).transform((val) => asLowerCaseAddress(val));
+}).transform((val) => toNormalizedAddress(val));
 var makeUnixTimestampSchema = (valueLabel = "Timestamp") => makeIntegerSchema(valueLabel);
+var makeUrlSchema = (valueLabel = "Value") => z.url({
+  error: `${valueLabel} must be a valid URL string (e.g., http://localhost:8080 or https://example.com).`,
+  abort: true
+}).transform((v) => new URL(v));
+var makePriceAmountSchema = (valueLabel = "Amount") => z.coerce.bigint({
+  error: `${valueLabel} must represent a bigint.`
+}).nonnegative({
+  error: `${valueLabel} must not be negative.`
+});
+var makePriceCurrencySchema = (currency, valueLabel = "Price Currency") => z.strictObject({
+  amount: makePriceAmountSchema(`${valueLabel} amount`),
+  currency: z.literal(currency, {
+    error: `${valueLabel} currency must be set to '${currency}'.`
+  })
+});
+var makePriceEthSchema = (valueLabel = "Price ETH") => makePriceCurrencySchema(CurrencyIds.ETH, valueLabel).transform((v) => v);
+var makePriceUsdcSchema = (valueLabel = "Price USDC") => makePriceCurrencySchema(CurrencyIds.USDC, valueLabel).transform((v) => v);
 var makeAccountIdSchema = (valueLabel = "AccountId") => z.strictObject({
   chainId: makeChainIdSchema(`${valueLabel} chain ID`),
-  address: makeLowercaseAddressSchema(`${valueLabel} address`)
+  address: makeNormalizedAddressSchema(`${valueLabel} address`)
 });
 
-// src/leaderboard-page.ts
+// ../ensnode-sdk/src/shared/serialize.ts
+function serializePrice(price) {
+  return {
+    currency: price.currency,
+    amount: price.amount.toString()
+  };
+}
+function serializePriceEth(price) {
+  return serializePrice(price);
+}
+function serializePriceUsdc(price) {
+  return serializePrice(price);
+}
+
+// src/award-models/pie-split/api/zod-schemas.ts
+import z3 from "zod/v4";
+
+// src/award-models/shared/api/zod-schemas.ts
+import z2 from "zod/v4";
+
+// 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/award-models/shared/leaderboard-page.ts
 var REFERRERS_PER_LEADERBOARD_PAGE_DEFAULT = 25;
 var REFERRERS_PER_LEADERBOARD_PAGE_MAX = 100;
 var validateReferrerLeaderboardPageParams = (params) => {
@@ -504,18 +555,67 @@ 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}.`
+      `Invalid ReferrerLeaderboardPageContext: totalRecords must be a non-negative integer but is ${context.totalRecords}.`
+    );
+  }
+  if (!isPositiveInteger(context.totalPages)) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPageContext: totalPages must be a positive integer (>= 1) but is ${context.totalPages}.`
+    );
+  }
+  const expectedTotalPages = context.totalRecords === 0 ? 1 : Math.ceil(context.totalRecords / context.recordsPerPage);
+  if (context.totalPages !== expectedTotalPages) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPageContext: totalPages is ${context.totalPages} but expected ${expectedTotalPages} based on totalRecords (${context.totalRecords}) and recordsPerPage (${context.recordsPerPage}).`
+    );
+  }
+  if (context.page > context.totalPages) {
+    throw new Error(
+      `Invalid ReferrerLeaderboardPageContext: page ${context.page} exceeds totalPages ${context.totalPages}.`
     );
   }
+  const expectedStartIndex = (context.page - 1) * context.recordsPerPage;
+  const expectedEndIndex = Math.min(
+    expectedStartIndex + context.recordsPerPage - 1,
+    context.totalRecords - 1
+  );
+  if (context.totalRecords === 0) {
+    if (context.startIndex !== void 0) {
+      throw new Error(
+        `Invalid ReferrerLeaderboardPageContext: startIndex must be undefined when totalRecords is 0 but is ${context.startIndex}.`
+      );
+    }
+    if (context.endIndex !== void 0) {
+      throw new Error(
+        `Invalid ReferrerLeaderboardPageContext: endIndex must be undefined when totalRecords is 0 but is ${context.endIndex}.`
+      );
+    }
+  } else {
+    if (context.startIndex !== expectedStartIndex) {
+      throw new Error(
+        `Invalid ReferrerLeaderboardPageContext: startIndex is ${context.startIndex} but expected ${expectedStartIndex} based on page (${context.page}) and recordsPerPage (${context.recordsPerPage}).`
+      );
+    }
+    if (context.endIndex !== expectedEndIndex) {
+      throw new Error(
+        `Invalid ReferrerLeaderboardPageContext: endIndex is ${context.endIndex} but expected ${expectedEndIndex} based on startIndex (${expectedStartIndex}), recordsPerPage (${context.recordsPerPage}), and totalRecords (${context.totalRecords}).`
+      );
+    }
+    if (typeof context.endIndex !== "undefined" && typeof context.startIndex !== "undefined" && context.endIndex < context.startIndex) {
+      throw new Error(
+        `Invalid ReferrerLeaderboardPageContext: endIndex (${context.endIndex}) must be greater than or equal to startIndex (${context.startIndex}).`
+      );
+    }
+  }
   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}).`
+      `Invalid ReferrerLeaderboardPageContext: if hasNext is false, endIndex (${endIndex}) must be greater than or equal to totalRecords (${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}).`
+      `Invalid ReferrerLeaderboardPageContext: if hasNext is true, endIndex (${endIndex}) must be less than totalRecords (${context.totalRecords}).`
     );
   }
   if (!context.hasPrev && context.page !== 1) {
@@ -565,59 +665,1373 @@ var buildReferrerLeaderboardPageContext = (optionalParams, leaderboard) => {
   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 = [];
+function sliceReferrers(referrers, pageContext) {
+  if (pageContext.totalRecords === 0 || pageContext.startIndex === void 0 || pageContext.endIndex === void 0) {
+    return [];
   }
-  return {
-    rules: leaderboard.rules,
-    referrers,
-    aggregatedMetrics: leaderboard.aggregatedMetrics,
-    pageContext,
-    accurateAsOf: leaderboard.accurateAsOf
-  };
+  const all = [...referrers.values()];
+  return all.slice(pageContext.startIndex, pageContext.endIndex + 1);
+}
+
+// src/award-models/shared/status.ts
+var ReferralProgramEditionStatuses = {
+  /**
+   * Represents a referral program edition that has been announced, but hasn't started yet.
+   */
+  Scheduled: "Scheduled",
+  /**
+   * Represents a currently ongoing referral program edition.
+   */
+  Active: "Active",
+  /**
+   * Represents a referral program edition that is still within its active window
+   * but whose award pool has been fully consumed.
+   *
+   * @note Not all award models may support this status.
+   */
+  Exhausted: "Exhausted",
+  /**
+   * Represents a referral program edition that has passed its end time but whose awards have not yet
+   * been distributed. The edition is in a review window before full closure.
+   *
+   * Transitions to {@link ReferralProgramEditionStatuses.Closed} once `areAwardsDistributed` is set to `true`.
+   */
+  AwardsReview: "AwardsReview",
+  /**
+   * Represents a referral program edition that has already ended and whose awards have been distributed.
+   */
+  Closed: "Closed"
+};
+var calcBaseReferralProgramEditionStatus = (rules, now) => {
+  if (now < rules.startTime) return ReferralProgramEditionStatuses.Scheduled;
+  if (now > rules.endTime)
+    return rules.areAwardsDistributed ? ReferralProgramEditionStatuses.Closed : ReferralProgramEditionStatuses.AwardsReview;
+  return ReferralProgramEditionStatuses.Active;
 };
 
-// src/rank.ts
-var validateReferrerRank = (rank) => {
-  if (!isPositiveInteger(rank)) {
-    throw new Error(`Invalid ReferrerRank: ${rank}. ReferrerRank must be a positive integer.`);
+// src/award-models/shared/api/zod-schemas.ts
+var makeBaseReferralProgramRulesSchema = (valueLabel) => z2.object({
+  awardModel: z2.string(),
+  startTime: makeUnixTimestampSchema(`${valueLabel}.startTime`),
+  endTime: makeUnixTimestampSchema(`${valueLabel}.endTime`),
+  subregistryId: makeAccountIdSchema(`${valueLabel}.subregistryId`),
+  rulesUrl: makeUrlSchema(`${valueLabel}.rulesUrl`),
+  areAwardsDistributed: z2.boolean()
+}).refine((data) => data.endTime >= data.startTime, {
+  message: `${valueLabel}.endTime must be >= ${valueLabel}.startTime`,
+  path: ["endTime"]
+});
+var makeReferrerLeaderboardPageContextSchema = (valueLabel = "ReferrerLeaderboardPageContext") => z2.object({
+  page: makePositiveIntegerSchema(`${valueLabel}.page`),
+  recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
+    REFERRERS_PER_LEADERBOARD_PAGE_MAX,
+    `${valueLabel}.recordsPerPage must not exceed ${REFERRERS_PER_LEADERBOARD_PAGE_MAX}`
+  ),
+  totalRecords: makeNonNegativeIntegerSchema(`${valueLabel}.totalRecords`),
+  totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
+  hasNext: z2.boolean(),
+  hasPrev: z2.boolean(),
+  startIndex: z2.optional(makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`)),
+  endIndex: z2.optional(makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`))
+});
+var makeReferralProgramStatusSchema = (_valueLabel = "status") => z2.enum(ReferralProgramEditionStatuses);
+var makeBaseReferralProgramEditionSummarySchema = (valueLabel) => z2.object({
+  awardModel: z2.string(),
+  slug: z2.string().min(1, `${valueLabel}.slug must not be empty`),
+  displayName: z2.string().min(1, `${valueLabel}.displayName must not be empty`),
+  status: makeReferralProgramStatusSchema(`${valueLabel}.status`),
+  rules: makeBaseReferralProgramRulesSchema(`${valueLabel}.rules`)
+});
+var makeBaseReferrerLeaderboardPageSchema = (valueLabel) => z2.object({
+  awardModel: z2.string(),
+  pageContext: makeReferrerLeaderboardPageContextSchema(`${valueLabel}.pageContext`),
+  status: makeReferralProgramStatusSchema(`${valueLabel}.status`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+});
+
+// src/award-models/shared/edition-metrics.ts
+var ReferrerEditionMetricsTypeIds = {
+  /**
+   * Represents a referrer who is ranked on the leaderboard.
+   */
+  Ranked: "ranked",
+  /**
+   * Represents a referrer who is not ranked on the leaderboard.
+   */
+  Unranked: "unranked"
+};
+
+// src/time.ts
+var validateUnixTimestamp = (timestamp) => {
+  if (!isInteger(timestamp)) {
+    throw new Error(`Invalid Unix timestamp: ${timestamp}. Unix timestamp must be an 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 SECONDS_PER_YEAR = 31556952;
+function isValidDuration(duration) {
+  return isNonNegativeInteger(duration);
 }
-var compareReferrerMetrics = (a, b) => {
-  if (a.totalIncrementalDuration !== b.totalIncrementalDuration) {
-    return b.totalIncrementalDuration - a.totalIncrementalDuration;
+function validateDuration(duration) {
+  if (!isValidDuration(duration)) {
+    throw new Error(`Invalid duration: ${duration}. Duration must be a non-negative integer.`);
+  }
+}
+
+// src/award-models/shared/rules.ts
+var ReferralProgramAwardModels = {
+  PieSplit: "pie-split",
+  RevShareCap: "rev-share-cap",
+  Unrecognized: "unrecognized"
+};
+var validateBaseReferralProgramRules = (rules) => {
+  makeAccountIdSchema("BaseReferralProgramRules.subregistryId").parse(rules.subregistryId);
+  validateUnixTimestamp(rules.startTime);
+  validateUnixTimestamp(rules.endTime);
+  if (!(rules.rulesUrl instanceof URL)) {
+    throw new Error(
+      `BaseReferralProgramRules: rulesUrl must be a URL instance, got ${typeof rules.rulesUrl}.`
+    );
+  }
+  if (rules.endTime < rules.startTime) {
+    throw new Error(
+      `BaseReferralProgramRules: startTime: ${rules.startTime} is after endTime: ${rules.endTime}.`
+    );
+  }
+};
+
+// src/award-models/pie-split/api/zod-schemas.ts
+var makeReferralProgramRulesPieSplitSchema = (valueLabel = "ReferralProgramRulesPieSplit") => makeBaseReferralProgramRulesSchema(valueLabel).safeExtend({
+  awardModel: z3.literal(ReferralProgramAwardModels.PieSplit),
+  awardPool: makePriceUsdcSchema(`${valueLabel}.awardPool`),
+  maxQualifiedReferrers: makeNonNegativeIntegerSchema(`${valueLabel}.maxQualifiedReferrers`)
+});
+var makeAwardedReferrerMetricsPieSplitSchema = (valueLabel = "AwardedReferrerMetricsPieSplit") => z3.object({
+  referrer: makeNormalizedAddressSchema(`${valueLabel}.referrer`),
+  totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
+  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  totalRevenueContribution: makePriceEthSchema(`${valueLabel}.totalRevenueContribution`),
+  score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
+  rank: makePositiveIntegerSchema(`${valueLabel}.rank`),
+  isQualified: z3.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: makePriceUsdcSchema(`${valueLabel}.awardPoolApproxValue`)
+});
+var makeUnrankedReferrerMetricsPieSplitSchema = (valueLabel = "UnrankedReferrerMetricsPieSplit") => z3.object({
+  referrer: makeNormalizedAddressSchema(`${valueLabel}.referrer`),
+  totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
+  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  totalRevenueContribution: makePriceEthSchema(`${valueLabel}.totalRevenueContribution`),
+  score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
+  rank: z3.null(),
+  isQualified: z3.literal(false),
+  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: makePriceUsdcSchema(`${valueLabel}.awardPoolApproxValue`)
+});
+var makeAggregatedReferrerMetricsPieSplitSchema = (valueLabel = "AggregatedReferrerMetricsPieSplit") => z3.object({
+  grandTotalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.grandTotalReferrals`),
+  grandTotalIncrementalDuration: makeDurationSchema(
+    `${valueLabel}.grandTotalIncrementalDuration`
+  ),
+  grandTotalRevenueContribution: makePriceEthSchema(
+    `${valueLabel}.grandTotalRevenueContribution`
+  ),
+  grandTotalQualifiedReferrersFinalScore: makeFiniteNonNegativeNumberSchema(
+    `${valueLabel}.grandTotalQualifiedReferrersFinalScore`
+  ),
+  minFinalScoreToQualify: makeFiniteNonNegativeNumberSchema(
+    `${valueLabel}.minFinalScoreToQualify`
+  )
+});
+var makeReferrerEditionMetricsRankedPieSplitSchema = (valueLabel = "ReferrerEditionMetricsRankedPieSplit") => z3.object({
+  awardModel: z3.literal(ReferralProgramAwardModels.PieSplit),
+  type: z3.literal(ReferrerEditionMetricsTypeIds.Ranked),
+  rules: makeReferralProgramRulesPieSplitSchema(`${valueLabel}.rules`),
+  referrer: makeAwardedReferrerMetricsPieSplitSchema(`${valueLabel}.referrer`),
+  aggregatedMetrics: makeAggregatedReferrerMetricsPieSplitSchema(
+    `${valueLabel}.aggregatedMetrics`
+  ),
+  status: makeReferralProgramStatusSchema(`${valueLabel}.status`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+}).refine((data) => data.awardModel === data.rules.awardModel, {
+  message: `${valueLabel}.awardModel must equal ${valueLabel}.rules.awardModel`,
+  path: ["awardModel"]
+});
+var makeReferrerEditionMetricsUnrankedPieSplitSchema = (valueLabel = "ReferrerEditionMetricsUnrankedPieSplit") => z3.object({
+  awardModel: z3.literal(ReferralProgramAwardModels.PieSplit),
+  type: z3.literal(ReferrerEditionMetricsTypeIds.Unranked),
+  rules: makeReferralProgramRulesPieSplitSchema(`${valueLabel}.rules`),
+  referrer: makeUnrankedReferrerMetricsPieSplitSchema(`${valueLabel}.referrer`),
+  aggregatedMetrics: makeAggregatedReferrerMetricsPieSplitSchema(
+    `${valueLabel}.aggregatedMetrics`
+  ),
+  status: makeReferralProgramStatusSchema(`${valueLabel}.status`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+}).refine((data) => data.awardModel === data.rules.awardModel, {
+  message: `${valueLabel}.awardModel must equal ${valueLabel}.rules.awardModel`,
+  path: ["awardModel"]
+});
+var makeReferrerEditionMetricsPieSplitSchema = (valueLabel = "ReferrerEditionMetricsPieSplit") => z3.discriminatedUnion("type", [
+  makeReferrerEditionMetricsRankedPieSplitSchema(valueLabel),
+  makeReferrerEditionMetricsUnrankedPieSplitSchema(valueLabel)
+]);
+var makeReferralProgramEditionSummaryPieSplitSchema = (valueLabel = "ReferralProgramEditionSummaryPieSplit") => makeBaseReferralProgramEditionSummarySchema(valueLabel).safeExtend({
+  awardModel: z3.literal(ReferralProgramAwardModels.PieSplit),
+  rules: makeReferralProgramRulesPieSplitSchema(`${valueLabel}.rules`)
+}).refine((data) => data.awardModel === data.rules.awardModel, {
+  message: `${valueLabel}.awardModel must equal ${valueLabel}.rules.awardModel`,
+  path: ["awardModel"]
+});
+var makeReferrerLeaderboardPagePieSplitSchema = (valueLabel = "ReferrerLeaderboardPagePieSplit") => makeBaseReferrerLeaderboardPageSchema(valueLabel).safeExtend({
+  awardModel: z3.literal(ReferralProgramAwardModels.PieSplit),
+  rules: makeReferralProgramRulesPieSplitSchema(`${valueLabel}.rules`),
+  referrers: z3.array(
+    makeAwardedReferrerMetricsPieSplitSchema(`${valueLabel}.referrers[record]`)
+  ),
+  aggregatedMetrics: makeAggregatedReferrerMetricsPieSplitSchema(
+    `${valueLabel}.aggregatedMetrics`
+  )
+}).refine((data) => data.awardModel === data.rules.awardModel, {
+  message: `${valueLabel}.awardModel must equal ${valueLabel}.rules.awardModel`,
+  path: ["awardModel"]
+});
+
+// src/award-models/rev-share-cap/api/zod-schemas.ts
+import z4 from "zod/v4";
+
+// src/award-models/rev-share-cap/rules.ts
+var AdminActionTypes = {
+  /**
+   * The referrer is disqualified for awards.
+   */
+  Disqualification: "Disqualification",
+  /**
+   * The referrer is warned about a potential disqualification but may still be qualified for awards.
+   */
+  Warning: "Warning"
+};
+var validateReferralProgramRulesRevShareCap = (rules) => {
+  if (rules.awardModel !== ReferralProgramAwardModels.RevShareCap) {
+    throw new Error(
+      `ReferralProgramRulesRevShareCap: awardModel must be "${ReferralProgramAwardModels.RevShareCap}", got "${rules.awardModel}".`
+    );
+  }
+  makePriceUsdcSchema("ReferralProgramRulesRevShareCap.awardPool").parse(rules.awardPool);
+  makePriceUsdcSchema("ReferralProgramRulesRevShareCap.minBaseRevenueContribution").parse(
+    rules.minBaseRevenueContribution
+  );
+  makePriceUsdcSchema("ReferralProgramRulesRevShareCap.baseAnnualRevenueContribution").parse(
+    rules.baseAnnualRevenueContribution
+  );
+  if (!Number.isFinite(rules.maxBaseRevenueShare) || rules.maxBaseRevenueShare < 0 || rules.maxBaseRevenueShare > 1) {
+    throw new Error(
+      `ReferralProgramRulesRevShareCap: maxBaseRevenueShare must be between 0 and 1 (inclusive), got ${rules.maxBaseRevenueShare}.`
+    );
+  }
+  for (const action of rules.adminActions) {
+    validateNormalizedAddress(action.referrer);
+    if (action.reason.trim().length === 0 || action.reason !== action.reason.trim()) {
+      throw new Error(
+        "ReferralProgramRulesRevShareCap: admin action reason must be a trimmed, non-empty string."
+      );
+    }
+  }
+  const adminActionAddresses = rules.adminActions.map((a) => a.referrer);
+  const uniqueAdminActionAddresses = new Set(adminActionAddresses);
+  if (uniqueAdminActionAddresses.size !== adminActionAddresses.length) {
+    throw new Error(
+      "ReferralProgramRulesRevShareCap: adminActions must not contain duplicate referrer addresses."
+    );
+  }
+  validateBaseReferralProgramRules(rules);
+};
+var buildReferralProgramRulesRevShareCap = (awardPool, minBaseRevenueContribution, baseAnnualRevenueContribution, maxBaseRevenueShare, startTime, endTime, subregistryId, rulesUrl, areAwardsDistributed, adminActions = []) => {
+  const result = {
+    awardModel: ReferralProgramAwardModels.RevShareCap,
+    awardPool,
+    minBaseRevenueContribution,
+    baseAnnualRevenueContribution,
+    maxBaseRevenueShare,
+    startTime,
+    endTime,
+    subregistryId,
+    rulesUrl,
+    areAwardsDistributed,
+    adminActions
+  };
+  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
+  );
+  return totalBaseRevenueContribution.amount >= rules.minBaseRevenueContribution.amount && !isAdminDisqualified;
+}
+
+// src/award-models/rev-share-cap/api/zod-schemas.ts
+var makeAdminActionDisqualificationSchema = (valueLabel = "AdminActionDisqualification") => z4.object({
+  actionType: z4.literal(AdminActionTypes.Disqualification),
+  referrer: makeNormalizedAddressSchema(`${valueLabel}.referrer`),
+  reason: z4.string().trim().min(1, `${valueLabel}.reason must not be empty`)
+});
+var makeAdminActionWarningSchema = (valueLabel = "AdminActionWarning") => z4.object({
+  actionType: z4.literal(AdminActionTypes.Warning),
+  referrer: makeNormalizedAddressSchema(`${valueLabel}.referrer`),
+  reason: z4.string().trim().min(1, `${valueLabel}.reason must not be empty`)
+});
+var makeAdminActionSchema = (valueLabel = "AdminAction") => z4.discriminatedUnion("actionType", [
+  makeAdminActionDisqualificationSchema(valueLabel),
+  makeAdminActionWarningSchema(valueLabel)
+]);
+var makeReferralProgramRulesRevShareCapSchema = (valueLabel = "ReferralProgramRulesRevShareCap") => makeBaseReferralProgramRulesSchema(valueLabel).safeExtend({
+  awardModel: z4.literal(ReferralProgramAwardModels.RevShareCap),
+  awardPool: makePriceUsdcSchema(`${valueLabel}.awardPool`),
+  minBaseRevenueContribution: makePriceUsdcSchema(`${valueLabel}.minBaseRevenueContribution`),
+  baseAnnualRevenueContribution: makePriceUsdcSchema(
+    `${valueLabel}.baseAnnualRevenueContribution`
+  ),
+  maxBaseRevenueShare: makeFiniteNonNegativeNumberSchema(`${valueLabel}.maxBaseRevenueShare`).max(
+    1,
+    `${valueLabel}.maxBaseRevenueShare must be <= 1`
+  ),
+  adminActions: z4.array(makeAdminActionSchema(`${valueLabel}.adminActions[item]`)).refine(
+    (items) => {
+      const referrers = items.map((a) => a.referrer);
+      return new Set(referrers).size === referrers.length;
+    },
+    {
+      message: `${valueLabel}.adminActions must not contain duplicate referrer addresses`
+    }
+  ).default([])
+});
+var makeAwardedReferrerMetricsRevShareCapSchema = (valueLabel = "AwardedReferrerMetricsRevShareCap") => z4.object({
+  referrer: makeNormalizedAddressSchema(`${valueLabel}.referrer`),
+  totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
+  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  totalRevenueContribution: makePriceEthSchema(`${valueLabel}.totalRevenueContribution`),
+  totalBaseRevenueContribution: makePriceUsdcSchema(
+    `${valueLabel}.totalBaseRevenueContribution`
+  ),
+  rank: makePositiveIntegerSchema(`${valueLabel}.rank`),
+  isQualified: z4.boolean(),
+  uncappedAward: makePriceUsdcSchema(`${valueLabel}.uncappedAward`),
+  cappedAward: makePriceUsdcSchema(`${valueLabel}.cappedAward`),
+  adminAction: makeAdminActionSchema(`${valueLabel}.adminAction`).nullable()
+}).refine((data) => data.cappedAward.amount <= data.uncappedAward.amount, {
+  message: `${valueLabel}.cappedAward must be <= ${valueLabel}.uncappedAward`,
+  path: ["cappedAward"]
+}).refine(
+  (data) => data.adminAction?.actionType !== AdminActionTypes.Disqualification || data.isQualified === false && data.cappedAward.amount === 0n,
+  {
+    message: `When ${valueLabel}.adminAction.actionType is Disqualification, isQualified must be false and cappedAward.amount must be 0`,
+    path: ["adminAction"]
+  }
+).refine((data) => data.isQualified || data.cappedAward.amount === 0n, {
+  message: `${valueLabel}.cappedAward must be 0 when isQualified is false`,
+  path: ["cappedAward"]
+}).refine((data) => data.adminAction === null || data.adminAction.referrer === data.referrer, {
+  message: `${valueLabel}.adminAction.referrer must match ${valueLabel}.referrer`,
+  path: ["adminAction", "referrer"]
+});
+var makeUnrankedReferrerMetricsRevShareCapSchema = (valueLabel = "UnrankedReferrerMetricsRevShareCap") => z4.object({
+  referrer: makeNormalizedAddressSchema(`${valueLabel}.referrer`),
+  totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
+  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
+  totalRevenueContribution: makePriceEthSchema(`${valueLabel}.totalRevenueContribution`),
+  totalBaseRevenueContribution: makePriceUsdcSchema(
+    `${valueLabel}.totalBaseRevenueContribution`
+  ),
+  rank: z4.null(),
+  isQualified: z4.literal(false),
+  uncappedAward: makePriceUsdcSchema(`${valueLabel}.uncappedAward`),
+  cappedAward: makePriceUsdcSchema(`${valueLabel}.cappedAward`),
+  adminAction: makeAdminActionSchema(`${valueLabel}.adminAction`).nullable()
+}).refine((data) => data.totalReferrals === 0, {
+  message: `${valueLabel}.totalReferrals must be 0 for unranked referrers`,
+  path: ["totalReferrals"]
+}).refine((data) => data.totalIncrementalDuration === 0, {
+  message: `${valueLabel}.totalIncrementalDuration must be 0 for unranked referrers`,
+  path: ["totalIncrementalDuration"]
+}).refine((data) => data.totalRevenueContribution.amount === 0n, {
+  message: `${valueLabel}.totalRevenueContribution must be 0 for unranked referrers`,
+  path: ["totalRevenueContribution"]
+}).refine((data) => data.totalBaseRevenueContribution.amount === 0n, {
+  message: `${valueLabel}.totalBaseRevenueContribution must be 0 for unranked referrers`,
+  path: ["totalBaseRevenueContribution"]
+}).refine((data) => data.uncappedAward.amount === 0n, {
+  message: `${valueLabel}.uncappedAward must be 0 for unranked referrers`,
+  path: ["uncappedAward"]
+}).refine((data) => data.cappedAward.amount === 0n, {
+  message: `${valueLabel}.cappedAward must be 0 for unranked referrers`,
+  path: ["cappedAward"]
+}).refine((data) => data.adminAction === null || data.adminAction.referrer === data.referrer, {
+  message: `${valueLabel}.adminAction.referrer must match ${valueLabel}.referrer`,
+  path: ["adminAction", "referrer"]
+});
+var makeAggregatedReferrerMetricsRevShareCapSchema = (valueLabel = "AggregatedReferrerMetricsRevShareCap") => z4.object({
+  grandTotalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.grandTotalReferrals`),
+  grandTotalIncrementalDuration: makeDurationSchema(
+    `${valueLabel}.grandTotalIncrementalDuration`
+  ),
+  grandTotalRevenueContribution: makePriceEthSchema(
+    `${valueLabel}.grandTotalRevenueContribution`
+  ),
+  awardPoolRemaining: makePriceUsdcSchema(`${valueLabel}.awardPoolRemaining`)
+});
+var addAdminActionConsistencyIssues = (ctx, metricsAdminAction, referrer, rulesAdminActions, path) => {
+  const expected = rulesAdminActions.find((a) => a.referrer === referrer) ?? null;
+  if (expected === null && metricsAdminAction !== null) {
+    ctx.addIssue({
+      code: z4.ZodIssueCode.custom,
+      message: `adminAction expected null, got actionType="${metricsAdminAction.actionType}"`,
+      path
+    });
+    return;
+  }
+  if (expected !== null && (metricsAdminAction === null || metricsAdminAction.actionType !== expected.actionType || metricsAdminAction.referrer !== expected.referrer || metricsAdminAction.reason !== expected.reason)) {
+    ctx.addIssue({
+      code: z4.ZodIssueCode.custom,
+      message: `adminAction does not match the corresponding entry in rules.adminActions`,
+      path
+    });
+  }
+};
+var makeReferrerEditionMetricsRankedRevShareCapSchema = (valueLabel = "ReferrerEditionMetricsRankedRevShareCap") => z4.object({
+  awardModel: z4.literal(ReferralProgramAwardModels.RevShareCap),
+  type: z4.literal(ReferrerEditionMetricsTypeIds.Ranked),
+  rules: makeReferralProgramRulesRevShareCapSchema(`${valueLabel}.rules`),
+  referrer: makeAwardedReferrerMetricsRevShareCapSchema(`${valueLabel}.referrer`),
+  aggregatedMetrics: makeAggregatedReferrerMetricsRevShareCapSchema(
+    `${valueLabel}.aggregatedMetrics`
+  ),
+  status: makeReferralProgramStatusSchema(`${valueLabel}.status`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+}).refine((data) => data.awardModel === data.rules.awardModel, {
+  message: `${valueLabel}.awardModel must equal ${valueLabel}.rules.awardModel`,
+  path: ["awardModel"]
+}).refine((data) => data.referrer.cappedAward.amount <= data.rules.awardPool.amount, {
+  message: `${valueLabel}.referrer.cappedAward must be <= ${valueLabel}.rules.awardPool`,
+  path: ["referrer", "cappedAward", "amount"]
+}).superRefine((data, ctx) => {
+  addAdminActionConsistencyIssues(
+    ctx,
+    data.referrer.adminAction,
+    data.referrer.referrer,
+    data.rules.adminActions,
+    ["referrer", "adminAction"]
+  );
+});
+var makeReferrerEditionMetricsUnrankedRevShareCapSchema = (valueLabel = "ReferrerEditionMetricsUnrankedRevShareCap") => z4.object({
+  awardModel: z4.literal(ReferralProgramAwardModels.RevShareCap),
+  type: z4.literal(ReferrerEditionMetricsTypeIds.Unranked),
+  rules: makeReferralProgramRulesRevShareCapSchema(`${valueLabel}.rules`),
+  referrer: makeUnrankedReferrerMetricsRevShareCapSchema(`${valueLabel}.referrer`),
+  aggregatedMetrics: makeAggregatedReferrerMetricsRevShareCapSchema(
+    `${valueLabel}.aggregatedMetrics`
+  ),
+  status: makeReferralProgramStatusSchema(`${valueLabel}.status`),
+  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
+}).refine((data) => data.awardModel === data.rules.awardModel, {
+  message: `${valueLabel}.awardModel must equal ${valueLabel}.rules.awardModel`,
+  path: ["awardModel"]
+}).superRefine((data, ctx) => {
+  addAdminActionConsistencyIssues(
+    ctx,
+    data.referrer.adminAction,
+    data.referrer.referrer,
+    data.rules.adminActions,
+    ["referrer", "adminAction"]
+  );
+});
+var makeReferrerEditionMetricsRevShareCapSchema = (valueLabel = "ReferrerEditionMetricsRevShareCap") => z4.discriminatedUnion("type", [
+  makeReferrerEditionMetricsRankedRevShareCapSchema(valueLabel),
+  makeReferrerEditionMetricsUnrankedRevShareCapSchema(valueLabel)
+]);
+var makeReferralProgramEditionSummaryRevShareCapSchema = (valueLabel = "ReferralProgramEditionSummaryRevShareCap") => makeBaseReferralProgramEditionSummarySchema(valueLabel).safeExtend({
+  awardModel: z4.literal(ReferralProgramAwardModels.RevShareCap),
+  rules: makeReferralProgramRulesRevShareCapSchema(`${valueLabel}.rules`),
+  awardPoolRemaining: makePriceUsdcSchema(`${valueLabel}.awardPoolRemaining`)
+}).refine((data) => data.awardModel === data.rules.awardModel, {
+  message: `${valueLabel}.awardModel must equal ${valueLabel}.rules.awardModel`,
+  path: ["awardModel"]
+});
+var makeReferrerLeaderboardPageRevShareCapSchema = (valueLabel = "ReferrerLeaderboardPageRevShareCap") => makeBaseReferrerLeaderboardPageSchema(valueLabel).safeExtend({
+  awardModel: z4.literal(ReferralProgramAwardModels.RevShareCap),
+  rules: makeReferralProgramRulesRevShareCapSchema(`${valueLabel}.rules`),
+  referrers: z4.array(
+    makeAwardedReferrerMetricsRevShareCapSchema(`${valueLabel}.referrers[record]`)
+  ),
+  aggregatedMetrics: makeAggregatedReferrerMetricsRevShareCapSchema(
+    `${valueLabel}.aggregatedMetrics`
+  )
+}).refine((data) => data.awardModel === data.rules.awardModel, {
+  message: `${valueLabel}.awardModel must equal ${valueLabel}.rules.awardModel`,
+  path: ["awardModel"]
+}).superRefine((data, ctx) => {
+  data.referrers.forEach((referrer, index) => {
+    if (referrer.cappedAward.amount > data.rules.awardPool.amount) {
+      ctx.addIssue({
+        code: z4.ZodIssueCode.custom,
+        message: `${valueLabel}.referrers[${index}].cappedAward must be <= ${valueLabel}.rules.awardPool`,
+        path: ["referrers", index, "cappedAward", "amount"]
+      });
+    }
+    addAdminActionConsistencyIssues(
+      ctx,
+      referrer.adminAction,
+      referrer.referrer,
+      data.rules.adminActions,
+      ["referrers", index, "adminAction"]
+    );
+  });
+});
+
+// src/api/types.ts
+var ReferrerLeaderboardPageResponseCodes = {
+  /**
+   * Represents that the requested referrer leaderboard page is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that the referrer leaderboard data is not available.
+   */
+  Error: "error"
+};
+var MAX_EDITIONS_PER_REQUEST = 20;
+var ReferrerMetricsEditionsResponseCodes = {
+  /**
+   * Represents that the referrer metrics data for the requested editions is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that an error occurred while fetching the data.
+   */
+  Error: "error"
+};
+var ReferralProgramEditionSummariesResponseCodes = {
+  /**
+   * Represents that the edition summaries are available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that the edition summaries are not available.
+   */
+  Error: "error"
+};
+
+// src/api/zod-schemas.ts
+var reemitIssues = (ctx, issues, pathPrefix = []) => {
+  for (const issue of issues) {
+    ctx.addIssue({
+      ...issue,
+      path: [...pathPrefix, ...issue.path]
+    });
+  }
+};
+var makeReferralProgramRulesSchema = (valueLabel = "ReferralProgramRules") => z5.discriminatedUnion("awardModel", [
+  makeReferralProgramRulesPieSplitSchema(valueLabel),
+  makeReferralProgramRulesRevShareCapSchema(valueLabel)
+]);
+var makeReferrerLeaderboardPageSchema = (valueLabel = "ReferrerLeaderboardPage") => {
+  const knownAwardModels = Object.values(ReferralProgramAwardModels).filter(
+    (m) => m !== ReferralProgramAwardModels.Unrecognized
+  );
+  const looseSchema = z5.looseObject({ awardModel: z5.string() });
+  const knownSchema = z5.discriminatedUnion("awardModel", [
+    makeReferrerLeaderboardPagePieSplitSchema(valueLabel),
+    makeReferrerLeaderboardPageRevShareCapSchema(valueLabel)
+  ]);
+  const baseSchema = makeBaseReferrerLeaderboardPageSchema(valueLabel);
+  return looseSchema.transform((data, ctx) => {
+    if (knownAwardModels.includes(data.awardModel)) {
+      const parsed2 = knownSchema.safeParse(data);
+      if (!parsed2.success) {
+        reemitIssues(ctx, parsed2.error.issues);
+        return z5.NEVER;
+      }
+      return parsed2.data;
+    }
+    const parsed = baseSchema.safeParse(data);
+    if (!parsed.success) {
+      reemitIssues(ctx, parsed.error.issues);
+      return z5.NEVER;
+    }
+    return {
+      ...parsed.data,
+      awardModel: ReferralProgramAwardModels.Unrecognized,
+      originalAwardModel: data.awardModel
+    };
+  });
+};
+var makeReferrerLeaderboardPageResponseOkSchema = (valueLabel = "ReferrerLeaderboardPageResponseOk") => z5.object({
+  responseCode: z5.literal(ReferrerLeaderboardPageResponseCodes.Ok),
+  data: makeReferrerLeaderboardPageSchema(`${valueLabel}.data`)
+});
+var makeReferrerLeaderboardPageResponseErrorSchema = (_valueLabel = "ReferrerLeaderboardPageResponseError") => z5.object({
+  responseCode: z5.literal(ReferrerLeaderboardPageResponseCodes.Error),
+  error: z5.string(),
+  errorMessage: z5.string()
+});
+var makeReferrerLeaderboardPageResponseSchema = (valueLabel = "ReferrerLeaderboardPageResponse") => z5.discriminatedUnion("responseCode", [
+  makeReferrerLeaderboardPageResponseOkSchema(valueLabel),
+  makeReferrerLeaderboardPageResponseErrorSchema(valueLabel)
+]);
+var makeReferrerEditionMetricsSchema = (valueLabel = "ReferrerEditionMetrics") => {
+  const knownAwardModels = Object.values(ReferralProgramAwardModels).filter(
+    (m) => m !== ReferralProgramAwardModels.Unrecognized
+  );
+  const looseSchema = z5.looseObject({ awardModel: z5.string() });
+  const knownSchema = z5.discriminatedUnion("awardModel", [
+    makeReferrerEditionMetricsPieSplitSchema(valueLabel),
+    makeReferrerEditionMetricsRevShareCapSchema(valueLabel)
+  ]);
+  return looseSchema.transform((data, ctx) => {
+    if (knownAwardModels.includes(data.awardModel)) {
+      const parsed = knownSchema.safeParse(data);
+      if (!parsed.success) {
+        reemitIssues(ctx, parsed.error.issues);
+        return z5.NEVER;
+      }
+      return parsed.data;
+    }
+    return {
+      awardModel: ReferralProgramAwardModels.Unrecognized,
+      originalAwardModel: data.awardModel
+    };
+  });
+};
+var makeReferralProgramEditionSlugSchema = (valueLabel = "ReferralProgramEditionSlug") => z5.string().min(1, `${valueLabel} must not be empty`).regex(
+  /^[a-z0-9]+(-[a-z0-9]+)*$/,
+  `${valueLabel} must contain only lowercase letters, digits, and hyphens. Must not start or end with a hyphen.`
+);
+var makeReferrerMetricsEditionsResponseOkSchema = (valueLabel = "ReferrerMetricsEditionsResponseOk") => z5.object({
+  responseCode: z5.literal(ReferrerMetricsEditionsResponseCodes.Ok),
+  data: z5.record(
+    makeReferralProgramEditionSlugSchema(`${valueLabel}.data[edition]`),
+    makeReferrerEditionMetricsSchema(`${valueLabel}.data[edition]`)
+  )
+});
+var makeReferrerMetricsEditionsResponseErrorSchema = (_valueLabel = "ReferrerMetricsEditionsResponseError") => z5.object({
+  responseCode: z5.literal(ReferrerMetricsEditionsResponseCodes.Error),
+  error: z5.string(),
+  errorMessage: z5.string()
+});
+var makeReferrerMetricsEditionsResponseSchema = (valueLabel = "ReferrerMetricsEditionsResponse") => z5.discriminatedUnion("responseCode", [
+  makeReferrerMetricsEditionsResponseOkSchema(valueLabel),
+  makeReferrerMetricsEditionsResponseErrorSchema(valueLabel)
+]);
+var makeReferralProgramEditionConfigBaseSchema = (valueLabel) => z5.object({
+  slug: makeReferralProgramEditionSlugSchema(`${valueLabel}.slug`),
+  displayName: z5.string().min(1, `${valueLabel}.displayName must not be empty`),
+  rules: makeBaseReferralProgramRulesSchema(`${valueLabel}.rules`)
+});
+var makeReferralProgramEditionConfigSchema = (valueLabel = "ReferralProgramEditionConfig") => makeReferralProgramEditionConfigBaseSchema(valueLabel).safeExtend({
+  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`)
+});
+var makeReferralProgramEditionConfigSetArraySchema = (valueLabel = "ReferralProgramEditionConfigSetArray") => {
+  const knownAwardModels = Object.values(ReferralProgramAwardModels).filter(
+    (m) => m !== ReferralProgramAwardModels.Unrecognized
+  );
+  const configSchema = makeReferralProgramEditionConfigSchema(`${valueLabel}[edition]`);
+  const looseItemSchema = z5.looseObject({
+    rules: z5.looseObject({ awardModel: z5.string() })
+  });
+  const unrecognizedBaseSchema = makeReferralProgramEditionConfigBaseSchema(
+    `${valueLabel}[edition]`
+  );
+  return z5.array(looseItemSchema).transform((items, ctx) => {
+    const result = [];
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      if (knownAwardModels.includes(item.rules.awardModel)) {
+        const parsed = configSchema.safeParse(item);
+        if (!parsed.success) {
+          reemitIssues(ctx, parsed.error.issues, [i]);
+        } else {
+          result.push(parsed.data);
+        }
+      } else {
+        const parsed = unrecognizedBaseSchema.safeParse(item);
+        if (!parsed.success) {
+          reemitIssues(ctx, parsed.error.issues, [i]);
+          continue;
+        }
+        result.push({
+          ...parsed.data,
+          rules: {
+            ...parsed.data.rules,
+            awardModel: ReferralProgramAwardModels.Unrecognized,
+            originalAwardModel: item.rules.awardModel
+          }
+        });
+      }
+    }
+    const slugs = /* @__PURE__ */ new Set();
+    for (const edition of result) {
+      if (slugs.has(edition.slug)) {
+        ctx.addIssue({
+          code: "custom",
+          message: `${valueLabel} must not contain duplicate edition slugs`
+        });
+        return [];
+      }
+      slugs.add(edition.slug);
+    }
+    return result;
+  });
+};
+var makeReferralProgramEditionSummarySchema = (valueLabel = "ReferralProgramEditionSummary") => {
+  const knownAwardModels = Object.values(ReferralProgramAwardModels).filter(
+    (m) => m !== ReferralProgramAwardModels.Unrecognized
+  );
+  const looseSchema = z5.looseObject({ awardModel: z5.string() });
+  const knownSchema = z5.discriminatedUnion("awardModel", [
+    makeReferralProgramEditionSummaryPieSplitSchema(valueLabel),
+    makeReferralProgramEditionSummaryRevShareCapSchema(valueLabel)
+  ]);
+  const baseSchema = makeBaseReferralProgramEditionSummarySchema(valueLabel);
+  return looseSchema.transform((data, ctx) => {
+    if (knownAwardModels.includes(data.awardModel)) {
+      const parsed2 = knownSchema.safeParse(data);
+      if (!parsed2.success) {
+        reemitIssues(ctx, parsed2.error.issues);
+        return z5.NEVER;
+      }
+      return parsed2.data;
+    }
+    const parsed = baseSchema.safeParse(data);
+    if (!parsed.success) {
+      reemitIssues(ctx, parsed.error.issues);
+      return z5.NEVER;
+    }
+    return {
+      ...parsed.data,
+      awardModel: ReferralProgramAwardModels.Unrecognized,
+      rules: {
+        ...parsed.data.rules,
+        awardModel: ReferralProgramAwardModels.Unrecognized,
+        originalAwardModel: data.awardModel
+      }
+    };
+  });
+};
+var makeReferralProgramEditionSummariesDataSchema = (valueLabel = "ReferralProgramEditionSummariesData") => z5.object({
+  editions: z5.array(makeReferralProgramEditionSummarySchema(`${valueLabel}.editions[edition]`))
+});
+var makeReferralProgramEditionSummariesResponseOkSchema = (valueLabel = "ReferralProgramEditionSummariesResponseOk") => z5.object({
+  responseCode: z5.literal(ReferralProgramEditionSummariesResponseCodes.Ok),
+  data: makeReferralProgramEditionSummariesDataSchema(`${valueLabel}.data`)
+});
+var makeReferralProgramEditionSummariesResponseErrorSchema = (_valueLabel = "ReferralProgramEditionSummariesResponseError") => z5.object({
+  responseCode: z5.literal(ReferralProgramEditionSummariesResponseCodes.Error),
+  error: z5.string(),
+  errorMessage: z5.string()
+});
+var makeReferralProgramEditionSummariesResponseSchema = (valueLabel = "ReferralProgramEditionSummariesResponse") => z5.discriminatedUnion("responseCode", [
+  makeReferralProgramEditionSummariesResponseOkSchema(valueLabel),
+  makeReferralProgramEditionSummariesResponseErrorSchema(valueLabel)
+]);
+
+// src/api/deserialize.ts
+function deserializeReferrerLeaderboardPageResponse(maybeResponse, valueLabel) {
+  const schema = makeReferrerLeaderboardPageResponseSchema(valueLabel);
+  const parsed = schema.safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize SerializedReferrerLeaderboardPageResponse:
+${prettifyError(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+function deserializeReferrerMetricsEditionsResponse(maybeResponse, valueLabel) {
+  const schema = makeReferrerMetricsEditionsResponseSchema(valueLabel);
+  const parsed = schema.safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize ReferrerMetricsEditionsResponse:
+${prettifyError(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+function deserializeReferralProgramEditionConfigSetArray(maybeArray, valueLabel) {
+  const schema = makeReferralProgramEditionConfigSetArraySchema(valueLabel);
+  const parsed = schema.safeParse(maybeArray);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize ReferralProgramEditionConfigSetArray:
+${prettifyError(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+function deserializeReferralProgramEditionSummariesResponse(maybeResponse, valueLabel) {
+  const schema = makeReferralProgramEditionSummariesResponseSchema(valueLabel);
+  const parsed = schema.safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize ReferralProgramEditionSummariesResponse:
+${prettifyError(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+
+// src/award-models/pie-split/api/serialize.ts
+function serializeReferralProgramRulesPieSplit(rules) {
+  return {
+    awardModel: rules.awardModel,
+    awardPool: serializePriceUsdc(rules.awardPool),
+    maxQualifiedReferrers: rules.maxQualifiedReferrers,
+    startTime: rules.startTime,
+    endTime: rules.endTime,
+    subregistryId: rules.subregistryId,
+    rulesUrl: rules.rulesUrl.toString(),
+    areAwardsDistributed: rules.areAwardsDistributed
+  };
+}
+function serializeAggregatedReferrerMetricsPieSplit(metrics) {
+  return {
+    grandTotalReferrals: metrics.grandTotalReferrals,
+    grandTotalIncrementalDuration: metrics.grandTotalIncrementalDuration,
+    grandTotalRevenueContribution: serializePriceEth(metrics.grandTotalRevenueContribution),
+    grandTotalQualifiedReferrersFinalScore: metrics.grandTotalQualifiedReferrersFinalScore,
+    minFinalScoreToQualify: metrics.minFinalScoreToQualify
+  };
+}
+function serializeAwardedReferrerMetricsPieSplit(metrics) {
+  return {
+    referrer: metrics.referrer,
+    totalReferrals: metrics.totalReferrals,
+    totalIncrementalDuration: metrics.totalIncrementalDuration,
+    totalRevenueContribution: serializePriceEth(metrics.totalRevenueContribution),
+    score: metrics.score,
+    rank: metrics.rank,
+    isQualified: metrics.isQualified,
+    finalScoreBoost: metrics.finalScoreBoost,
+    finalScore: metrics.finalScore,
+    awardPoolShare: metrics.awardPoolShare,
+    awardPoolApproxValue: serializePriceUsdc(metrics.awardPoolApproxValue)
+  };
+}
+function serializeUnrankedReferrerMetricsPieSplit(metrics) {
+  return {
+    referrer: metrics.referrer,
+    totalReferrals: metrics.totalReferrals,
+    totalIncrementalDuration: metrics.totalIncrementalDuration,
+    totalRevenueContribution: serializePriceEth(metrics.totalRevenueContribution),
+    score: metrics.score,
+    rank: metrics.rank,
+    isQualified: metrics.isQualified,
+    finalScoreBoost: metrics.finalScoreBoost,
+    finalScore: metrics.finalScore,
+    awardPoolShare: metrics.awardPoolShare,
+    awardPoolApproxValue: serializePriceUsdc(metrics.awardPoolApproxValue)
+  };
+}
+function serializeReferrerEditionMetricsRankedPieSplit(detail) {
+  return {
+    awardModel: detail.awardModel,
+    type: detail.type,
+    rules: serializeReferralProgramRulesPieSplit(detail.rules),
+    referrer: serializeAwardedReferrerMetricsPieSplit(detail.referrer),
+    aggregatedMetrics: serializeAggregatedReferrerMetricsPieSplit(detail.aggregatedMetrics),
+    status: detail.status,
+    accurateAsOf: detail.accurateAsOf
+  };
+}
+function serializeReferrerEditionMetricsUnrankedPieSplit(detail) {
+  return {
+    awardModel: detail.awardModel,
+    type: detail.type,
+    rules: serializeReferralProgramRulesPieSplit(detail.rules),
+    referrer: serializeUnrankedReferrerMetricsPieSplit(detail.referrer),
+    aggregatedMetrics: serializeAggregatedReferrerMetricsPieSplit(detail.aggregatedMetrics),
+    status: detail.status,
+    accurateAsOf: detail.accurateAsOf
+  };
+}
+function serializeReferrerEditionMetricsPieSplit(detail) {
+  switch (detail.type) {
+    case ReferrerEditionMetricsTypeIds.Ranked:
+      return serializeReferrerEditionMetricsRankedPieSplit(detail);
+    case ReferrerEditionMetricsTypeIds.Unranked:
+      return serializeReferrerEditionMetricsUnrankedPieSplit(detail);
+    default: {
+      const _exhaustiveCheck = detail;
+      throw new Error(`Unknown type: ${_exhaustiveCheck.type}`);
+    }
+  }
+}
+function serializeReferrerLeaderboardPagePieSplit(page) {
+  return {
+    awardModel: page.awardModel,
+    rules: serializeReferralProgramRulesPieSplit(page.rules),
+    referrers: page.referrers.map(serializeAwardedReferrerMetricsPieSplit),
+    aggregatedMetrics: serializeAggregatedReferrerMetricsPieSplit(page.aggregatedMetrics),
+    pageContext: page.pageContext,
+    status: page.status,
+    accurateAsOf: page.accurateAsOf
+  };
+}
+function serializeReferralProgramEditionSummaryPieSplit(summary) {
+  return {
+    awardModel: summary.awardModel,
+    slug: summary.slug,
+    displayName: summary.displayName,
+    status: summary.status,
+    rules: serializeReferralProgramRulesPieSplit(summary.rules)
+  };
+}
+
+// src/award-models/rev-share-cap/api/serialize.ts
+function serializeReferralProgramRulesRevShareCap(rules) {
+  return {
+    awardModel: rules.awardModel,
+    awardPool: serializePriceUsdc(rules.awardPool),
+    minBaseRevenueContribution: serializePriceUsdc(rules.minBaseRevenueContribution),
+    baseAnnualRevenueContribution: serializePriceUsdc(rules.baseAnnualRevenueContribution),
+    maxBaseRevenueShare: rules.maxBaseRevenueShare,
+    startTime: rules.startTime,
+    endTime: rules.endTime,
+    subregistryId: rules.subregistryId,
+    rulesUrl: rules.rulesUrl.toString(),
+    areAwardsDistributed: rules.areAwardsDistributed,
+    adminActions: rules.adminActions
+  };
+}
+function serializeAggregatedReferrerMetricsRevShareCap(metrics) {
+  return {
+    grandTotalReferrals: metrics.grandTotalReferrals,
+    grandTotalIncrementalDuration: metrics.grandTotalIncrementalDuration,
+    grandTotalRevenueContribution: serializePriceEth(metrics.grandTotalRevenueContribution),
+    awardPoolRemaining: serializePriceUsdc(metrics.awardPoolRemaining)
+  };
+}
+function serializeAwardedReferrerMetricsRevShareCap(metrics) {
+  return {
+    referrer: metrics.referrer,
+    totalReferrals: metrics.totalReferrals,
+    totalIncrementalDuration: metrics.totalIncrementalDuration,
+    totalRevenueContribution: serializePriceEth(metrics.totalRevenueContribution),
+    totalBaseRevenueContribution: serializePriceUsdc(metrics.totalBaseRevenueContribution),
+    rank: metrics.rank,
+    isQualified: metrics.isQualified,
+    uncappedAward: serializePriceUsdc(metrics.uncappedAward),
+    cappedAward: serializePriceUsdc(metrics.cappedAward),
+    adminAction: metrics.adminAction
+  };
+}
+function serializeUnrankedReferrerMetricsRevShareCap(metrics) {
+  return {
+    referrer: metrics.referrer,
+    totalReferrals: metrics.totalReferrals,
+    totalIncrementalDuration: metrics.totalIncrementalDuration,
+    totalRevenueContribution: serializePriceEth(metrics.totalRevenueContribution),
+    totalBaseRevenueContribution: serializePriceUsdc(metrics.totalBaseRevenueContribution),
+    rank: metrics.rank,
+    isQualified: metrics.isQualified,
+    uncappedAward: serializePriceUsdc(metrics.uncappedAward),
+    cappedAward: serializePriceUsdc(metrics.cappedAward),
+    adminAction: metrics.adminAction
+  };
+}
+function serializeReferrerEditionMetricsRankedRevShareCap(detail) {
+  return {
+    awardModel: detail.awardModel,
+    type: detail.type,
+    rules: serializeReferralProgramRulesRevShareCap(detail.rules),
+    referrer: serializeAwardedReferrerMetricsRevShareCap(detail.referrer),
+    aggregatedMetrics: serializeAggregatedReferrerMetricsRevShareCap(detail.aggregatedMetrics),
+    status: detail.status,
+    accurateAsOf: detail.accurateAsOf
+  };
+}
+function serializeReferrerEditionMetricsUnrankedRevShareCap(detail) {
+  return {
+    awardModel: detail.awardModel,
+    type: detail.type,
+    rules: serializeReferralProgramRulesRevShareCap(detail.rules),
+    referrer: serializeUnrankedReferrerMetricsRevShareCap(detail.referrer),
+    aggregatedMetrics: serializeAggregatedReferrerMetricsRevShareCap(detail.aggregatedMetrics),
+    status: detail.status,
+    accurateAsOf: detail.accurateAsOf
+  };
+}
+function serializeReferrerEditionMetricsRevShareCap(detail) {
+  switch (detail.type) {
+    case ReferrerEditionMetricsTypeIds.Ranked:
+      return serializeReferrerEditionMetricsRankedRevShareCap(detail);
+    case ReferrerEditionMetricsTypeIds.Unranked:
+      return serializeReferrerEditionMetricsUnrankedRevShareCap(detail);
+    default: {
+      const _exhaustiveCheck = detail;
+      throw new Error(
+        `Unknown type: ${_exhaustiveCheck.type}`
+      );
+    }
+  }
+}
+function serializeReferrerLeaderboardPageRevShareCap(page) {
+  return {
+    awardModel: page.awardModel,
+    rules: serializeReferralProgramRulesRevShareCap(page.rules),
+    referrers: page.referrers.map(serializeAwardedReferrerMetricsRevShareCap),
+    aggregatedMetrics: serializeAggregatedReferrerMetricsRevShareCap(page.aggregatedMetrics),
+    pageContext: page.pageContext,
+    status: page.status,
+    accurateAsOf: page.accurateAsOf
+  };
+}
+function serializeReferralProgramEditionSummaryRevShareCap(summary) {
+  return {
+    awardModel: summary.awardModel,
+    slug: summary.slug,
+    displayName: summary.displayName,
+    status: summary.status,
+    rules: serializeReferralProgramRulesRevShareCap(summary.rules),
+    awardPoolRemaining: serializePriceUsdc(summary.awardPoolRemaining)
+  };
+}
+
+// src/api/serialize.ts
+function serializeReferralProgramRules(rules) {
+  switch (rules.awardModel) {
+    case ReferralProgramAwardModels.PieSplit:
+      return serializeReferralProgramRulesPieSplit(rules);
+    case ReferralProgramAwardModels.RevShareCap:
+      return serializeReferralProgramRulesRevShareCap(rules);
+    case ReferralProgramAwardModels.Unrecognized: {
+      const unrecognized = rules;
+      throw new Error(
+        `ReferralProgramRulesUnrecognized (originalAwardModel: '${unrecognized.originalAwardModel}') must not be serialized \u2014 it is a client-side forward-compatibility placeholder only.`
+      );
+    }
+    default: {
+      const _exhaustiveCheck = rules;
+      throw new Error(
+        `Unknown award model: ${_exhaustiveCheck.awardModel}`
+      );
+    }
+  }
+}
+function serializeReferrerLeaderboardPage(page) {
+  switch (page.awardModel) {
+    case ReferralProgramAwardModels.PieSplit:
+      return serializeReferrerLeaderboardPagePieSplit(page);
+    case ReferralProgramAwardModels.RevShareCap:
+      return serializeReferrerLeaderboardPageRevShareCap(page);
+    case ReferralProgramAwardModels.Unrecognized: {
+      const unrecognized = page;
+      throw new Error(
+        `ReferrerLeaderboardPageUnrecognized (originalAwardModel: '${unrecognized.originalAwardModel}') must not be serialized \u2014 it is a client-side forward-compatibility placeholder only.`
+      );
+    }
+    default: {
+      const _exhaustiveCheck = page;
+      throw new Error(
+        `Unknown award model: ${_exhaustiveCheck.awardModel}`
+      );
+    }
+  }
+}
+function serializeReferrerEditionMetrics(detail) {
+  switch (detail.awardModel) {
+    case ReferralProgramAwardModels.PieSplit:
+      return serializeReferrerEditionMetricsPieSplit(detail);
+    case ReferralProgramAwardModels.RevShareCap:
+      return serializeReferrerEditionMetricsRevShareCap(detail);
+    case ReferralProgramAwardModels.Unrecognized: {
+      const unrecognized = detail;
+      throw new Error(
+        `ReferrerEditionMetricsUnrecognized (originalAwardModel: '${unrecognized.originalAwardModel}') must not be serialized \u2014 it is a client-side forward-compatibility placeholder only.`
+      );
+    }
+    default: {
+      const _exhaustiveCheck = detail;
+      throw new Error(
+        `Unknown award model: ${_exhaustiveCheck.awardModel}`
+      );
+    }
+  }
+}
+function serializeReferralProgramEditionSummary(summary) {
+  switch (summary.awardModel) {
+    case ReferralProgramAwardModels.PieSplit:
+      return serializeReferralProgramEditionSummaryPieSplit(summary);
+    case ReferralProgramAwardModels.RevShareCap:
+      return serializeReferralProgramEditionSummaryRevShareCap(summary);
+    case ReferralProgramAwardModels.Unrecognized: {
+      const unrecognized = summary;
+      throw new Error(
+        `ReferralProgramEditionSummaryUnrecognized (originalAwardModel: '${unrecognized.rules.originalAwardModel}') must not be serialized \u2014 it is a client-side forward-compatibility placeholder only.`
+      );
+    }
+    default: {
+      const _exhaustiveCheck = summary;
+      throw new Error(
+        `Unknown award model: ${_exhaustiveCheck.awardModel}`
+      );
+    }
+  }
+}
+function serializeReferrerLeaderboardPageResponse(response) {
+  switch (response.responseCode) {
+    case ReferrerLeaderboardPageResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        data: serializeReferrerLeaderboardPage(response.data)
+      };
+    case ReferrerLeaderboardPageResponseCodes.Error:
+      return response;
+  }
+}
+function serializeReferrerMetricsEditionsResponse(response) {
+  switch (response.responseCode) {
+    case ReferrerMetricsEditionsResponseCodes.Ok: {
+      const serializedData = Object.fromEntries(
+        Object.entries(response.data).map(([editionSlug, detail]) => [
+          editionSlug,
+          serializeReferrerEditionMetrics(detail)
+        ])
+      );
+      return {
+        responseCode: response.responseCode,
+        data: serializedData
+      };
+    }
+    case ReferrerMetricsEditionsResponseCodes.Error:
+      return response;
+    default: {
+      const _exhaustiveCheck = response;
+      throw new Error(
+        `Unknown response code: ${_exhaustiveCheck.responseCode}`
+      );
+    }
+  }
+}
+function serializeReferralProgramEditionSummariesResponse(response) {
+  switch (response.responseCode) {
+    case ReferralProgramEditionSummariesResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        data: {
+          editions: response.data.editions.map(serializeReferralProgramEditionSummary)
+        }
+      };
+    case ReferralProgramEditionSummariesResponseCodes.Error:
+      return response;
+    default: {
+      const _exhaustiveCheck = response;
+      throw new Error(
+        `Unknown response code: ${_exhaustiveCheck.responseCode}`
+      );
+    }
+  }
+}
+
+// src/award-models/shared/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.`
+    );
+  }
+};
+
+// src/award-models/pie-split/aggregations.ts
+var validateAggregatedReferrerMetricsPieSplit = (metrics) => {
+  validateNonNegativeInteger(metrics.grandTotalReferrals);
+  validateDuration(metrics.grandTotalIncrementalDuration);
+  makePriceEthSchema("AggregatedReferrerMetricsPieSplit.grandTotalRevenueContribution").parse(
+    metrics.grandTotalRevenueContribution
+  );
+  validateReferrerScore(metrics.grandTotalQualifiedReferrersFinalScore);
+  validateReferrerScore(metrics.minFinalScoreToQualify);
+};
+var buildAggregatedReferrerMetricsPieSplit = (referrers, rules) => {
+  let grandTotalReferrals = 0;
+  let grandTotalIncrementalDuration = 0;
+  let grandTotalRevenueContributionAmount = 0n;
+  let grandTotalQualifiedReferrersFinalScore = 0;
+  let minFinalScoreToQualify = Number.MAX_SAFE_INTEGER;
+  for (const referrer of referrers) {
+    grandTotalReferrals += referrer.totalReferrals;
+    grandTotalIncrementalDuration += referrer.totalIncrementalDuration;
+    grandTotalRevenueContributionAmount += referrer.totalRevenueContribution.amount;
+    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(
+          "AggregatedReferrerMetricsPieSplit: There are referrers on the leaderboard, and the rules allow for qualified referrers, but no qualified referrers."
+        );
+      }
+      minFinalScoreToQualify = 0;
+    }
+  }
+  const result = {
+    grandTotalReferrals,
+    grandTotalIncrementalDuration,
+    grandTotalRevenueContribution: priceEth(grandTotalRevenueContributionAmount),
+    grandTotalQualifiedReferrersFinalScore,
+    minFinalScoreToQualify
+  };
+  validateAggregatedReferrerMetricsPieSplit(result);
+  return result;
+};
+
+// src/edition.ts
+var REFERRAL_PROGRAM_EDITION_SLUG_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+function validateReferralProgramEditionConfigSet(configSet) {
+  const violation = Array.from(configSet.entries()).find(([key, config]) => key !== config.slug);
+  if (violation) {
+    const [key, config] = violation;
+    throw new Error(
+      `Edition config set invariant violation: map key "${key}" does not match config.slug "${config.slug}"`
+    );
+  }
+}
+function buildReferralProgramEditionConfigSet(configs) {
+  const slugCounts = configs.reduce((counts, config) => {
+    counts.set(config.slug, (counts.get(config.slug) || 0) + 1);
+    return counts;
+  }, /* @__PURE__ */ new Map());
+  const duplicates = Array.from(slugCounts.entries()).filter(([_, count]) => count > 1).map(([slug, count]) => `"${slug}" (${count} occurrences)`);
+  if (duplicates.length > 0) {
+    throw new Error(`Duplicate edition config slugs detected: ${duplicates.join(", ")}`);
+  }
+  const configSet = new Map(configs.map((config) => [config.slug, config]));
+  validateReferralProgramEditionConfigSet(configSet);
+  return configSet;
+}
+
+// src/award-models/shared/edition-summary.ts
+var validateBaseReferralProgramEditionSummary = (summary) => {
+  if (!REFERRAL_PROGRAM_EDITION_SLUG_PATTERN.test(summary.slug)) {
+    throw new Error(
+      `BaseReferralProgramEditionSummary: slug "${summary.slug}" does not match required pattern ${REFERRAL_PROGRAM_EDITION_SLUG_PATTERN}.`
+    );
+  }
+  if (summary.displayName.length === 0) {
+    throw new Error("BaseReferralProgramEditionSummary: displayName must not be empty.");
+  }
+  if (summary.awardModel !== summary.rules.awardModel) {
+    throw new Error(
+      `BaseReferralProgramEditionSummary: awardModel (${summary.awardModel}) must equal rules.awardModel (${summary.rules.awardModel}).`
+    );
+  }
+};
+
+// src/award-models/pie-split/rules.ts
+var validateReferralProgramRulesPieSplit = (rules) => {
+  makePriceUsdcSchema("ReferralProgramRulesPieSplit.awardPool").parse(rules.awardPool);
+  validateNonNegativeInteger(rules.maxQualifiedReferrers);
+  validateBaseReferralProgramRules(rules);
+};
+var buildReferralProgramRulesPieSplit = (awardPool, maxQualifiedReferrers, startTime, endTime, subregistryId, rulesUrl, areAwardsDistributed) => {
+  const result = {
+    awardModel: ReferralProgramAwardModels.PieSplit,
+    awardPool,
+    maxQualifiedReferrers,
+    startTime,
+    endTime,
+    subregistryId,
+    rulesUrl,
+    areAwardsDistributed
+  };
+  validateReferralProgramRulesPieSplit(result);
+  return result;
+};
+
+// src/award-models/pie-split/status.ts
+var calcReferralProgramEditionStatusPieSplit = (rules, now) => calcBaseReferralProgramEditionStatus(rules, now);
+
+// src/award-models/pie-split/edition-summary.ts
+var validateEditionSummaryPieSplit = (summary) => {
+  validateReferralProgramRulesPieSplit(summary.rules);
+  validateBaseReferralProgramEditionSummary(summary);
+};
+function buildEditionSummaryPieSplit(slug, displayName, rules, leaderboard) {
+  const status = calcReferralProgramEditionStatusPieSplit(rules, leaderboard.accurateAsOf);
+  const result = { awardModel: rules.awardModel, slug, displayName, status, rules };
+  validateEditionSummaryPieSplit(result);
+  return result;
+}
+
+// src/award-models/shared/leaderboard-guards.ts
+var assertLeaderboardInputs = (allReferrers, rules, accurateAsOf) => {
+  const uniqueReferrers = new Set(allReferrers.map((r) => r.referrer));
+  if (uniqueReferrers.size !== allReferrers.length) {
+    throw new Error(
+      "ReferrerLeaderboard: Cannot build a leaderboard 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.`
+    );
+  }
+};
+
+// src/award-models/shared/rank.ts
+var validateReferrerRank = (rank) => {
+  if (!isPositiveInteger(rank)) {
+    throw new Error(`Invalid ReferrerRank: ${rank}. ReferrerRank must be a positive integer.`);
+  }
+};
+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;
 };
+var sortReferrerMetrics = (referrers) => {
+  return [...referrers].sort(compareReferrerMetrics);
+};
 
 // src/referrer-metrics.ts
 var buildReferrerMetrics = (referrer, totalReferrals, totalIncrementalDuration, totalRevenueContribution) => {
   const result = {
-    referrer: normalizeAddress(referrer),
+    referrer,
     totalReferrals,
     totalIncrementalDuration,
     totalRevenueContribution
@@ -626,153 +2040,189 @@ var buildReferrerMetrics = (referrer, totalReferrals, totalIncrementalDuration,
   return result;
 };
 var validateReferrerMetrics = (metrics) => {
-  validateLowercaseAddress(metrics.referrer);
+  validateNormalizedAddress(metrics.referrer);
   validateNonNegativeInteger(metrics.totalReferrals);
   validateDuration(metrics.totalIncrementalDuration);
-  validateRevenueContribution(metrics.totalRevenueContribution);
+  makePriceEthSchema("ReferrerMetrics.totalRevenueContribution").parse(
+    metrics.totalRevenueContribution
+  );
 };
-var sortReferrerMetrics = (referrers) => {
-  return [...referrers].sort(compareReferrerMetrics);
+
+// src/award-models/pie-split/score.ts
+var calcReferrerScorePieSplit = (totalIncrementalDuration) => {
+  return totalIncrementalDuration / SECONDS_PER_YEAR;
 };
-var buildScoredReferrerMetrics = (referrer) => {
+
+// src/award-models/pie-split/rank.ts
+function isReferrerQualifiedPieSplit(rank, rules) {
+  return rank <= rules.maxQualifiedReferrers;
+}
+function calcReferrerFinalScoreBoostPieSplit(rank, rules) {
+  if (!isReferrerQualifiedPieSplit(rank, rules)) return 0;
+  if (rules.maxQualifiedReferrers === 1) return 1;
+  return 1 - (rank - 1) / (rules.maxQualifiedReferrers - 1);
+}
+function calcReferrerFinalScoreMultiplierPieSplit(rank, rules) {
+  return 1 + calcReferrerFinalScoreBoostPieSplit(rank, rules);
+}
+function calcReferrerFinalScorePieSplit(rank, totalIncrementalDuration, rules) {
+  return calcReferrerScorePieSplit(totalIncrementalDuration) * calcReferrerFinalScoreMultiplierPieSplit(rank, rules);
+}
+
+// src/award-models/pie-split/metrics.ts
+var buildScoredReferrerMetricsPieSplit = (referrer) => {
   const result = {
     ...referrer,
-    score: calcReferrerScore(referrer.totalIncrementalDuration)
+    score: calcReferrerScorePieSplit(referrer.totalIncrementalDuration)
   };
-  validateScoredReferrerMetrics(result);
+  validateScoredReferrerMetricsPieSplit(result);
   return result;
 };
-var validateScoredReferrerMetrics = (metrics) => {
+var validateScoredReferrerMetricsPieSplit = (metrics) => {
   validateReferrerMetrics(metrics);
   validateReferrerScore(metrics.score);
-  const expectedScore = calcReferrerScore(metrics.totalIncrementalDuration);
+  const expectedScore = calcReferrerScorePieSplit(metrics.totalIncrementalDuration);
   if (metrics.score !== expectedScore) {
     throw new Error(`Referrer: Invalid score: ${metrics.score}, expected: ${expectedScore}.`);
   }
 };
-var validateRankedReferrerMetrics = (metrics, rules) => {
-  validateScoredReferrerMetrics(metrics);
+var validateRankedReferrerMetricsPieSplit = (metrics, rules) => {
+  validateScoredReferrerMetricsPieSplit(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).`
+      `Invalid RankedReferrerMetricsPieSplit: Invalid finalScoreBoost: ${metrics.finalScoreBoost}. finalScoreBoost must be between 0 and 1 (inclusive).`
     );
   }
   validateReferrerScore(metrics.finalScore);
-  const expectedIsQualified = isReferrerQualified(metrics.rank, rules);
+  const expectedIsQualified = isReferrerQualifiedPieSplit(metrics.rank, rules);
   if (metrics.isQualified !== expectedIsQualified) {
     throw new Error(
-      `RankedReferrerMetrics: Invalid isQualified: ${metrics.isQualified}, expected: ${expectedIsQualified}.`
+      `RankedReferrerMetricsPieSplit: Invalid isQualified: ${metrics.isQualified}, expected: ${expectedIsQualified}.`
     );
   }
-  const expectedFinalScoreBoost = calcReferrerFinalScoreBoost(metrics.rank, rules);
+  const expectedFinalScoreBoost = calcReferrerFinalScoreBoostPieSplit(metrics.rank, rules);
   if (metrics.finalScoreBoost !== expectedFinalScoreBoost) {
     throw new Error(
-      `RankedReferrerMetrics: Invalid finalScoreBoost: ${metrics.finalScoreBoost}, expected: ${expectedFinalScoreBoost}.`
+      `RankedReferrerMetricsPieSplit: Invalid finalScoreBoost: ${metrics.finalScoreBoost}, expected: ${expectedFinalScoreBoost}.`
     );
   }
-  const expectedFinalScore = calcReferrerFinalScore(
+  const expectedFinalScore = calcReferrerFinalScorePieSplit(
     metrics.rank,
     metrics.totalIncrementalDuration,
     rules
   );
   if (metrics.finalScore !== expectedFinalScore) {
     throw new Error(
-      `RankedReferrerMetrics: Invalid finalScore: ${metrics.finalScore}, expected: ${expectedFinalScore}.`
+      `RankedReferrerMetricsPieSplit: Invalid finalScore: ${metrics.finalScore}, expected: ${expectedFinalScore}.`
     );
   }
 };
-var buildRankedReferrerMetrics = (referrer, rank, rules) => {
+var buildRankedReferrerMetricsPieSplit = (referrer, rank, rules) => {
   const result = {
     ...referrer,
     rank,
-    isQualified: isReferrerQualified(rank, rules),
-    finalScoreBoost: calcReferrerFinalScoreBoost(rank, rules),
-    finalScore: calcReferrerFinalScore(rank, referrer.totalIncrementalDuration, rules)
+    isQualified: isReferrerQualifiedPieSplit(rank, rules),
+    finalScoreBoost: calcReferrerFinalScoreBoostPieSplit(rank, rules),
+    finalScore: calcReferrerFinalScorePieSplit(rank, referrer.totalIncrementalDuration, rules)
   };
-  validateRankedReferrerMetrics(result, rules);
+  validateRankedReferrerMetricsPieSplit(result, rules);
   return result;
 };
-var calcReferrerAwardPoolShare = (referrer, aggregatedMetrics, rules) => {
-  if (!isReferrerQualified(referrer.rank, rules)) return 0;
+var calcReferrerAwardPoolSharePieSplit = (referrer, aggregatedMetrics) => {
+  if (!referrer.isQualified) return 0;
   if (aggregatedMetrics.grandTotalQualifiedReferrersFinalScore === 0) return 0;
-  return calcReferrerFinalScore(referrer.rank, referrer.totalIncrementalDuration, rules) / aggregatedMetrics.grandTotalQualifiedReferrersFinalScore;
+  return referrer.finalScore / aggregatedMetrics.grandTotalQualifiedReferrersFinalScore;
 };
-var validateAwardedReferrerMetrics = (referrer, rules) => {
-  validateRankedReferrerMetrics(referrer, rules);
+var validateAwardedReferrerMetricsPieSplit = (referrer, rules) => {
+  validateRankedReferrerMetricsPieSplit(referrer, rules);
   if (referrer.awardPoolShare < 0 || referrer.awardPoolShare > 1) {
     throw new Error(
-      `Invalid AwardedReferrerMetrics: ${referrer.awardPoolShare}. awardPoolShare must be between 0 and 1 (inclusive).`
+      `Invalid AwardedReferrerMetricsPieSplit: ${referrer.awardPoolShare}. awardPoolShare must be between 0 and 1 (inclusive).`
     );
   }
-  if (referrer.awardPoolApproxValue < 0 || referrer.awardPoolApproxValue > rules.totalAwardPoolValue) {
+  makePriceUsdcSchema("AwardedReferrerMetricsPieSplit.awardPoolApproxValue").parse(
+    referrer.awardPoolApproxValue
+  );
+  if (referrer.awardPoolApproxValue.amount > rules.awardPool.amount) {
     throw new Error(
-      `Invalid AwardedReferrerMetrics: ${referrer.awardPoolApproxValue}. awardPoolApproxValue must be between 0 and ${rules.totalAwardPoolValue} (inclusive).`
+      `AwardedReferrerMetricsPieSplit: awardPoolApproxValue.amount ${referrer.awardPoolApproxValue.amount.toString()} exceeds awardPool.amount ${rules.awardPool.amount.toString()}.`
     );
   }
 };
-var buildAwardedReferrerMetrics = (referrer, aggregatedMetrics, rules) => {
-  const awardPoolShare = calcReferrerAwardPoolShare(referrer, aggregatedMetrics, rules);
+var buildAwardedReferrerMetricsPieSplit = (referrer, aggregatedMetrics, rules) => {
+  const awardPoolShare = calcReferrerAwardPoolSharePieSplit(referrer, aggregatedMetrics);
+  const awardPoolApproxValue = scalePrice(rules.awardPool, awardPoolShare);
   const result = {
     ...referrer,
     awardPoolShare,
-    awardPoolApproxValue: awardPoolShare * rules.totalAwardPoolValue
+    awardPoolApproxValue
   };
-  validateAwardedReferrerMetrics(result, rules);
+  validateAwardedReferrerMetricsPieSplit(result, rules);
   return result;
 };
-var validateUnrankedReferrerMetrics = (metrics) => {
-  validateScoredReferrerMetrics(metrics);
+var validateUnrankedReferrerMetricsPieSplit = (metrics) => {
+  validateScoredReferrerMetricsPieSplit(metrics);
   if (metrics.rank !== null) {
-    throw new Error(`Invalid UnrankedReferrerMetrics: rank must be null, got: ${metrics.rank}.`);
+    throw new Error(
+      `Invalid UnrankedReferrerMetricsPieSplit: rank must be null, got: ${metrics.rank}.`
+    );
   }
   if (metrics.isQualified !== false) {
     throw new Error(
-      `Invalid UnrankedReferrerMetrics: isQualified must be false, got: ${metrics.isQualified}.`
+      `Invalid UnrankedReferrerMetricsPieSplit: isQualified must be false, got: ${metrics.isQualified}.`
     );
   }
   if (metrics.totalReferrals !== 0) {
     throw new Error(
-      `Invalid UnrankedReferrerMetrics: totalReferrals must be 0, got: ${metrics.totalReferrals}.`
+      `Invalid UnrankedReferrerMetricsPieSplit: totalReferrals must be 0, got: ${metrics.totalReferrals}.`
     );
   }
   if (metrics.totalIncrementalDuration !== 0) {
     throw new Error(
-      `Invalid UnrankedReferrerMetrics: totalIncrementalDuration must be 0, got: ${metrics.totalIncrementalDuration}.`
+      `Invalid UnrankedReferrerMetricsPieSplit: totalIncrementalDuration must be 0, got: ${metrics.totalIncrementalDuration}.`
     );
   }
-  if (metrics.totalRevenueContribution !== 0n) {
+  makePriceEthSchema("UnrankedReferrerMetricsPieSplit.totalRevenueContribution").parse(
+    metrics.totalRevenueContribution
+  );
+  if (metrics.totalRevenueContribution.amount !== 0n) {
     throw new Error(
-      `Invalid UnrankedReferrerMetrics: totalRevenueContribution must be 0n, got: ${metrics.totalRevenueContribution.toString()}.`
+      `Invalid UnrankedReferrerMetricsPieSplit: totalRevenueContribution.amount must be 0n, got: ${metrics.totalRevenueContribution.amount.toString()}.`
     );
   }
   if (metrics.score !== 0) {
-    throw new Error(`Invalid UnrankedReferrerMetrics: score must be 0, got: ${metrics.score}.`);
+    throw new Error(
+      `Invalid UnrankedReferrerMetricsPieSplit: score must be 0, got: ${metrics.score}.`
+    );
   }
   if (metrics.finalScoreBoost !== 0) {
     throw new Error(
-      `Invalid UnrankedReferrerMetrics: finalScoreBoost must be 0, got: ${metrics.finalScoreBoost}.`
+      `Invalid UnrankedReferrerMetricsPieSplit: finalScoreBoost must be 0, got: ${metrics.finalScoreBoost}.`
     );
   }
   if (metrics.finalScore !== 0) {
     throw new Error(
-      `Invalid UnrankedReferrerMetrics: finalScore must be 0, got: ${metrics.finalScore}.`
+      `Invalid UnrankedReferrerMetricsPieSplit: finalScore must be 0, got: ${metrics.finalScore}.`
     );
   }
   if (metrics.awardPoolShare !== 0) {
     throw new Error(
-      `Invalid UnrankedReferrerMetrics: awardPoolShare must be 0, got: ${metrics.awardPoolShare}.`
+      `Invalid UnrankedReferrerMetricsPieSplit: awardPoolShare must be 0, got: ${metrics.awardPoolShare}.`
     );
   }
-  if (metrics.awardPoolApproxValue !== 0) {
+  makePriceUsdcSchema("UnrankedReferrerMetricsPieSplit.awardPoolApproxValue").parse(
+    metrics.awardPoolApproxValue
+  );
+  if (metrics.awardPoolApproxValue.amount !== 0n) {
     throw new Error(
-      `Invalid UnrankedReferrerMetrics: awardPoolApproxValue must be 0, got: ${metrics.awardPoolApproxValue}.`
+      `Invalid UnrankedReferrerMetricsPieSplit: awardPoolApproxValue must be 0n, got: ${metrics.awardPoolApproxValue.amount.toString()}.`
     );
   }
 };
-var buildUnrankedReferrerMetrics = (referrer) => {
-  const baseMetrics = buildReferrerMetrics(referrer, 0, 0, 0n);
-  const scoredMetrics = buildScoredReferrerMetrics(baseMetrics);
+var buildUnrankedReferrerMetricsPieSplit = (referrer) => {
+  const metrics = buildReferrerMetrics(referrer, 0, 0, priceEth(0n));
+  const scoredMetrics = buildScoredReferrerMetricsPieSplit(metrics);
   const result = {
     ...scoredMetrics,
     rank: null,
@@ -780,438 +2230,411 @@ var buildUnrankedReferrerMetrics = (referrer) => {
     finalScoreBoost: 0,
     finalScore: 0,
     awardPoolShare: 0,
-    awardPoolApproxValue: 0
+    awardPoolApproxValue: priceUsdc(0n)
   };
-  validateUnrankedReferrerMetrics(result);
+  validateUnrankedReferrerMetricsPieSplit(result);
   return result;
 };
 
-// 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"
+// src/award-models/pie-split/leaderboard.ts
+var buildReferrerLeaderboardPieSplit = (allReferrers, rules, accurateAsOf) => {
+  assertLeaderboardInputs(allReferrers, rules, accurateAsOf);
+  const sortedReferrers = sortReferrerMetrics(allReferrers);
+  const scoredReferrers = sortedReferrers.map((r) => buildScoredReferrerMetricsPieSplit(r));
+  const rankedReferrers = scoredReferrers.map(
+    (r, index) => buildRankedReferrerMetricsPieSplit(r, index + 1, rules)
+  );
+  const aggregatedMetrics = buildAggregatedReferrerMetricsPieSplit(rankedReferrers, rules);
+  const awardedReferrers = rankedReferrers.map(
+    (r) => buildAwardedReferrerMetricsPieSplit(r, aggregatedMetrics, rules)
+  );
+  const referrers = new Map(awardedReferrers.map((r) => [r.referrer, r]));
+  return { awardModel: rules.awardModel, rules, aggregatedMetrics, referrers, accurateAsOf };
 };
-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
-    };
-  }
+
+// src/award-models/pie-split/leaderboard-page.ts
+function buildLeaderboardPagePieSplit(pageContext, leaderboard) {
+  const status = calcReferralProgramEditionStatusPieSplit(
+    leaderboard.rules,
+    leaderboard.accurateAsOf
+  );
   return {
-    type: ReferrerDetailTypeIds.Unranked,
+    awardModel: leaderboard.awardModel,
     rules: leaderboard.rules,
-    referrer: buildUnrankedReferrerMetrics(referrer),
+    referrers: sliceReferrers(leaderboard.referrers, pageContext),
     aggregatedMetrics: leaderboard.aggregatedMetrics,
+    pageContext,
+    status,
     accurateAsOf: leaderboard.accurateAsOf
   };
-};
+}
 
-// src/api/types.ts
-var ReferrerLeaderboardPageResponseCodes = {
-  /**
-   * Represents that the requested referrer leaderboard page is available.
-   */
-  Ok: "ok",
-  /**
-   * Represents that the referrer leaderboard data is not available.
-   */
-  Error: "error"
+// src/award-models/rev-share-cap/aggregations.ts
+var validateAggregatedReferrerMetricsRevShareCap = (metrics) => {
+  validateNonNegativeInteger(metrics.grandTotalReferrals);
+  validateDuration(metrics.grandTotalIncrementalDuration);
+  makePriceEthSchema("AggregatedReferrerMetricsRevShareCap.grandTotalRevenueContribution").parse(
+    metrics.grandTotalRevenueContribution
+  );
+  makePriceUsdcSchema("AggregatedReferrerMetricsRevShareCap.awardPoolRemaining").parse(
+    metrics.awardPoolRemaining
+  );
 };
-var ReferrerDetailResponseCodes = {
-  /**
-   * Represents that the referrer detail data is available.
-   */
-  Ok: "ok",
-  /**
-   * Represents that an error occurred while fetching the data.
-   */
-  Error: "error"
+var buildAggregatedReferrerMetricsRevShareCap = (referrers, awardPoolRemaining) => {
+  let grandTotalReferrals = 0;
+  let grandTotalIncrementalDuration = 0;
+  let grandTotalRevenueContributionAmount = 0n;
+  for (const referrer of referrers) {
+    grandTotalReferrals += referrer.totalReferrals;
+    grandTotalIncrementalDuration += referrer.totalIncrementalDuration;
+    grandTotalRevenueContributionAmount += referrer.totalRevenueContribution.amount;
+  }
+  const aggregatedMetrics = {
+    grandTotalReferrals,
+    grandTotalIncrementalDuration,
+    grandTotalRevenueContribution: priceEth(grandTotalRevenueContributionAmount),
+    awardPoolRemaining
+  };
+  validateAggregatedReferrerMetricsRevShareCap(aggregatedMetrics);
+  return aggregatedMetrics;
 };
 
-// src/api/zod-schemas.ts
-var makeRevenueContributionSchema = (valueLabel = "RevenueContribution") => z2.coerce.bigint({
-  error: `${valueLabel} must represent a bigint.`
-}).nonnegative({
-  error: `${valueLabel} must not be negative.`
-});
-var makeReferralProgramRulesSchema = (valueLabel = "ReferralProgramRules") => z2.object({
-  totalAwardPoolValue: makeFiniteNonNegativeNumberSchema(`${valueLabel}.totalAwardPoolValue`),
-  maxQualifiedReferrers: makeNonNegativeIntegerSchema(`${valueLabel}.maxQualifiedReferrers`),
-  startTime: makeUnixTimestampSchema(`${valueLabel}.startTime`),
-  endTime: makeUnixTimestampSchema(`${valueLabel}.endTime`),
-  subregistryId: makeAccountIdSchema(`${valueLabel}.subregistryId`)
-});
-var makeAwardedReferrerMetricsSchema = (valueLabel = "AwardedReferrerMetrics") => z2.object({
-  referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
-  totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
-  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
-  totalRevenueContribution: makeRevenueContributionSchema(
-    `${valueLabel}.totalRevenueContribution`
-  ),
-  score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
-  rank: makePositiveIntegerSchema(`${valueLabel}.rank`),
-  isQualified: z2.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 makeUnrankedReferrerMetricsSchema = (valueLabel = "UnrankedReferrerMetrics") => z2.object({
-  referrer: makeLowercaseAddressSchema(`${valueLabel}.referrer`),
-  totalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.totalReferrals`),
-  totalIncrementalDuration: makeDurationSchema(`${valueLabel}.totalIncrementalDuration`),
-  totalRevenueContribution: makeRevenueContributionSchema(
-    `${valueLabel}.totalRevenueContribution`
-  ),
-  score: makeFiniteNonNegativeNumberSchema(`${valueLabel}.score`),
-  rank: z2.null(),
-  isQualified: z2.literal(false),
-  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 makeAggregatedReferrerMetricsSchema = (valueLabel = "AggregatedReferrerMetrics") => z2.object({
-  grandTotalReferrals: makeNonNegativeIntegerSchema(`${valueLabel}.grandTotalReferrals`),
-  grandTotalIncrementalDuration: makeDurationSchema(
-    `${valueLabel}.grandTotalIncrementalDuration`
-  ),
-  grandTotalRevenueContribution: makeRevenueContributionSchema(
-    `${valueLabel}.grandTotalRevenueContribution`
-  ),
-  grandTotalQualifiedReferrersFinalScore: makeFiniteNonNegativeNumberSchema(
-    `${valueLabel}.grandTotalQualifiedReferrersFinalScore`
-  ),
-  minFinalScoreToQualify: makeFiniteNonNegativeNumberSchema(
-    `${valueLabel}.minFinalScoreToQualify`
-  )
-});
-var makeReferrerLeaderboardPageContextSchema = (valueLabel = "ReferrerLeaderboardPageContext") => z2.object({
-  page: makePositiveIntegerSchema(`${valueLabel}.page`),
-  recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
-    REFERRERS_PER_LEADERBOARD_PAGE_MAX,
-    `${valueLabel}.recordsPerPage must not exceed ${REFERRERS_PER_LEADERBOARD_PAGE_MAX}`
-  ),
-  totalRecords: makeNonNegativeIntegerSchema(`${valueLabel}.totalRecords`),
-  totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: z2.boolean(),
-  hasPrev: z2.boolean(),
-  startIndex: z2.optional(makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`)),
-  endIndex: z2.optional(makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`))
-});
-var makeReferrerLeaderboardPageSchema = (valueLabel = "ReferrerLeaderboardPage") => z2.object({
-  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
-  referrers: z2.array(makeAwardedReferrerMetricsSchema(`${valueLabel}.referrers[record]`)),
-  aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
-  pageContext: makeReferrerLeaderboardPageContextSchema(`${valueLabel}.pageContext`),
-  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
-});
-var makeReferrerLeaderboardPageResponseOkSchema = (valueLabel = "ReferrerLeaderboardPageResponseOk") => z2.object({
-  responseCode: z2.literal(ReferrerLeaderboardPageResponseCodes.Ok),
-  data: makeReferrerLeaderboardPageSchema(`${valueLabel}.data`)
-});
-var makeReferrerLeaderboardPageResponseErrorSchema = (_valueLabel = "ReferrerLeaderboardPageResponseError") => z2.object({
-  responseCode: z2.literal(ReferrerLeaderboardPageResponseCodes.Error),
-  error: z2.string(),
-  errorMessage: z2.string()
-});
-var makeReferrerLeaderboardPageResponseSchema = (valueLabel = "ReferrerLeaderboardPageResponse") => z2.union([
-  makeReferrerLeaderboardPageResponseOkSchema(valueLabel),
-  makeReferrerLeaderboardPageResponseErrorSchema(valueLabel)
-]);
-var makeReferrerDetailRankedSchema = (valueLabel = "ReferrerDetailRanked") => z2.object({
-  type: z2.literal(ReferrerDetailTypeIds.Ranked),
-  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
-  referrer: makeAwardedReferrerMetricsSchema(`${valueLabel}.referrer`),
-  aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
-  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
-});
-var makeReferrerDetailUnrankedSchema = (valueLabel = "ReferrerDetailUnranked") => z2.object({
-  type: z2.literal(ReferrerDetailTypeIds.Unranked),
-  rules: makeReferralProgramRulesSchema(`${valueLabel}.rules`),
-  referrer: makeUnrankedReferrerMetricsSchema(`${valueLabel}.referrer`),
-  aggregatedMetrics: makeAggregatedReferrerMetricsSchema(`${valueLabel}.aggregatedMetrics`),
-  accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
-});
-var makeReferrerDetailResponseOkSchema = (valueLabel = "ReferrerDetailResponse") => z2.object({
-  responseCode: z2.literal(ReferrerDetailResponseCodes.Ok),
-  data: z2.union([
-    makeReferrerDetailRankedSchema(`${valueLabel}.data`),
-    makeReferrerDetailUnrankedSchema(`${valueLabel}.data`)
-  ])
-});
-var makeReferrerDetailResponseErrorSchema = (_valueLabel = "ReferrerDetailResponse") => z2.object({
-  responseCode: z2.literal(ReferrerDetailResponseCodes.Error),
-  error: z2.string(),
-  errorMessage: z2.string()
-});
-var makeReferrerDetailResponseSchema = (valueLabel = "ReferrerDetailResponse") => z2.union([
-  makeReferrerDetailResponseOkSchema(valueLabel),
-  makeReferrerDetailResponseErrorSchema(valueLabel)
-]);
+// src/award-models/rev-share-cap/status.ts
+var calcReferralProgramEditionStatusRevShareCap = (rules, now, aggregatedMetrics) => {
+  const base = calcBaseReferralProgramEditionStatus(rules, now);
+  if (base === ReferralProgramEditionStatuses.Active && aggregatedMetrics.awardPoolRemaining.amount === 0n) {
+    return ReferralProgramEditionStatuses.Exhausted;
+  }
+  return base;
+};
 
-// src/api/deserialize.ts
-function deserializeRevenueContribution(value) {
-  return BigInt(value);
-}
-function deserializeReferralProgramRules(rules) {
-  return rules;
-}
-function deserializeAwardedReferrerMetrics(metrics) {
-  return {
-    referrer: metrics.referrer,
-    totalReferrals: metrics.totalReferrals,
-    totalIncrementalDuration: metrics.totalIncrementalDuration,
-    totalRevenueContribution: deserializeRevenueContribution(metrics.totalRevenueContribution),
-    score: metrics.score,
-    rank: metrics.rank,
-    isQualified: metrics.isQualified,
-    finalScoreBoost: metrics.finalScoreBoost,
-    finalScore: metrics.finalScore,
-    awardPoolShare: metrics.awardPoolShare,
-    awardPoolApproxValue: metrics.awardPoolApproxValue
+// src/award-models/rev-share-cap/edition-summary.ts
+var validateEditionSummaryRevShareCap = (summary) => {
+  validateReferralProgramRulesRevShareCap(summary.rules);
+  makePriceUsdcSchema("ReferralProgramEditionSummaryRevShareCap.awardPoolRemaining").parse(
+    summary.awardPoolRemaining
+  );
+  validateBaseReferralProgramEditionSummary(summary);
+};
+function buildEditionSummaryRevShareCap(slug, displayName, rules, leaderboard) {
+  const status = calcReferralProgramEditionStatusRevShareCap(
+    rules,
+    leaderboard.accurateAsOf,
+    leaderboard.aggregatedMetrics
+  );
+  const result = {
+    awardModel: rules.awardModel,
+    slug,
+    displayName,
+    status,
+    rules,
+    awardPoolRemaining: leaderboard.aggregatedMetrics.awardPoolRemaining
   };
+  validateEditionSummaryRevShareCap(result);
+  return result;
 }
-function deserializeUnrankedReferrerMetrics(metrics) {
-  return {
-    referrer: metrics.referrer,
-    totalReferrals: metrics.totalReferrals,
-    totalIncrementalDuration: metrics.totalIncrementalDuration,
-    totalRevenueContribution: deserializeRevenueContribution(metrics.totalRevenueContribution),
-    score: metrics.score,
-    rank: metrics.rank,
-    isQualified: metrics.isQualified,
-    finalScoreBoost: metrics.finalScoreBoost,
-    finalScore: metrics.finalScore,
-    awardPoolShare: metrics.awardPoolShare,
-    awardPoolApproxValue: metrics.awardPoolApproxValue
+
+// src/award-models/rev-share-cap/metrics.ts
+var validateReferrerMetricsRevShareCap = (metrics, rules) => {
+  validateReferrerMetrics(metrics);
+  makePriceUsdcSchema("ReferrerMetricsRevShareCap.totalBaseRevenueContribution").parse(
+    metrics.totalBaseRevenueContribution
+  );
+  const expectedTotalBaseRevenueContribution = calcBaseRevenueContribution(
+    rules,
+    metrics.totalIncrementalDuration
+  );
+  if (metrics.totalBaseRevenueContribution.amount !== expectedTotalBaseRevenueContribution.amount) {
+    throw new Error(
+      `ReferrerMetricsRevShareCap: Invalid totalBaseRevenueContribution: ${metrics.totalBaseRevenueContribution.amount.toString()}, expected: ${expectedTotalBaseRevenueContribution.amount.toString()}.`
+    );
+  }
+};
+var buildReferrerMetricsRevShareCap = (metrics, rules) => {
+  const totalBaseRevenueContribution = calcBaseRevenueContribution(
+    rules,
+    metrics.totalIncrementalDuration
+  );
+  const result = {
+    ...metrics,
+    totalBaseRevenueContribution
   };
-}
-function deserializeAggregatedReferrerMetrics(metrics) {
-  return {
-    grandTotalReferrals: metrics.grandTotalReferrals,
-    grandTotalIncrementalDuration: metrics.grandTotalIncrementalDuration,
-    grandTotalRevenueContribution: deserializeRevenueContribution(
-      metrics.grandTotalRevenueContribution
+  validateReferrerMetricsRevShareCap(result, rules);
+  return result;
+};
+var validateAdminActionConsistency = (metricsAdminAction, referrer, rules, context) => {
+  const expected = rules.adminActions.find((a) => a.referrer === referrer) ?? null;
+  if (expected === null && metricsAdminAction !== null) {
+    throw new Error(
+      `${context}: expected null, got actionType="${metricsAdminAction.actionType}".`
+    );
+  }
+  if (expected !== null) {
+    if (metricsAdminAction === null || metricsAdminAction.actionType !== expected.actionType || metricsAdminAction.referrer !== expected.referrer || metricsAdminAction.reason !== expected.reason) {
+      throw new Error(`${context}: does not match expected action from rules.`);
+    }
+  }
+};
+var validateRankedReferrerMetricsRevShareCap = (metrics, rules) => {
+  validateReferrerMetricsRevShareCap(metrics, rules);
+  validateReferrerRank(metrics.rank);
+  const expectedIsQualified = isReferrerQualifiedRevShareCap(
+    metrics.referrer,
+    metrics.totalBaseRevenueContribution,
+    rules
+  );
+  if (metrics.isQualified !== expectedIsQualified) {
+    throw new Error(
+      `RankedReferrerMetricsRevShareCap: Invalid isQualified: ${metrics.isQualified}, expected: ${expectedIsQualified}.`
+    );
+  }
+  validateAdminActionConsistency(
+    metrics.adminAction,
+    metrics.referrer,
+    rules,
+    "RankedReferrerMetricsRevShareCap: Invalid adminAction"
+  );
+};
+var buildRankedReferrerMetricsRevShareCap = (referrer, rank, rules) => {
+  const adminAction = rules.adminActions.find((a) => a.referrer === referrer.referrer) ?? null;
+  const result = {
+    ...referrer,
+    rank,
+    isQualified: isReferrerQualifiedRevShareCap(
+      referrer.referrer,
+      referrer.totalBaseRevenueContribution,
+      rules
     ),
-    grandTotalQualifiedReferrersFinalScore: metrics.grandTotalQualifiedReferrersFinalScore,
-    minFinalScoreToQualify: metrics.minFinalScoreToQualify
-  };
-}
-function deserializeReferrerLeaderboardPage(page) {
-  return {
-    rules: deserializeReferralProgramRules(page.rules),
-    referrers: page.referrers.map(deserializeAwardedReferrerMetrics),
-    aggregatedMetrics: deserializeAggregatedReferrerMetrics(page.aggregatedMetrics),
-    pageContext: page.pageContext,
-    accurateAsOf: page.accurateAsOf
-  };
-}
-function deserializeReferrerDetailRanked(detail) {
-  return {
-    type: detail.type,
-    rules: deserializeReferralProgramRules(detail.rules),
-    referrer: deserializeAwardedReferrerMetrics(detail.referrer),
-    aggregatedMetrics: deserializeAggregatedReferrerMetrics(detail.aggregatedMetrics),
-    accurateAsOf: detail.accurateAsOf
+    adminAction
   };
-}
-function deserializeReferrerDetailUnranked(detail) {
-  return {
-    type: detail.type,
-    rules: deserializeReferralProgramRules(detail.rules),
-    referrer: deserializeUnrankedReferrerMetrics(detail.referrer),
-    aggregatedMetrics: deserializeAggregatedReferrerMetrics(detail.aggregatedMetrics),
-    accurateAsOf: detail.accurateAsOf
+  validateRankedReferrerMetricsRevShareCap(result, rules);
+  return result;
+};
+var validateAwardedReferrerMetricsRevShareCap = (metrics, rules) => {
+  validateRankedReferrerMetricsRevShareCap(metrics, rules);
+  makePriceUsdcSchema("AwardedReferrerMetricsRevShareCap.uncappedAward").parse(
+    metrics.uncappedAward
+  );
+  makePriceUsdcSchema("AwardedReferrerMetricsRevShareCap.cappedAward").parse(metrics.cappedAward);
+  if (metrics.adminAction?.actionType === AdminActionTypes.Disqualification && metrics.cappedAward.amount !== 0n) {
+    throw new Error(
+      `AwardedReferrerMetricsRevShareCap: cappedAward.amount must be 0n for admin-disqualified referrers, got ${metrics.cappedAward.amount.toString()}.`
+    );
+  }
+  if (!metrics.isQualified && metrics.cappedAward.amount !== 0n) {
+    throw new Error(
+      `AwardedReferrerMetricsRevShareCap: cappedAward.amount must be 0n for unqualified referrers, got ${metrics.cappedAward.amount.toString()}.`
+    );
+  }
+  if (metrics.cappedAward.amount > rules.awardPool.amount) {
+    throw new Error(
+      `AwardedReferrerMetricsRevShareCap: cappedAward.amount ${metrics.cappedAward.amount.toString()} exceeds awardPool.amount ${rules.awardPool.amount.toString()}.`
+    );
+  }
+  if (metrics.cappedAward.amount > metrics.uncappedAward.amount) {
+    throw new Error(
+      `AwardedReferrerMetricsRevShareCap: cappedAward.amount ${metrics.cappedAward.amount.toString()} exceeds uncappedAward.amount ${metrics.uncappedAward.amount.toString()}.`
+    );
+  }
+};
+var buildAwardedReferrerMetricsRevShareCap = (referrer, uncappedAward, cappedAward, rules) => {
+  const result = {
+    ...referrer,
+    uncappedAward,
+    cappedAward
   };
-}
-function deserializeReferrerLeaderboardPageResponse(maybeResponse, valueLabel) {
-  let deserialized;
-  switch (maybeResponse.responseCode) {
-    case "ok": {
-      deserialized = {
-        responseCode: maybeResponse.responseCode,
-        data: deserializeReferrerLeaderboardPage(maybeResponse.data)
-      };
-      break;
-    }
-    case "error":
-      deserialized = maybeResponse;
-      break;
+  validateAwardedReferrerMetricsRevShareCap(result, rules);
+  return result;
+};
+var validateUnrankedReferrerMetricsRevShareCap = (metrics, rules) => {
+  validateReferrerMetrics(metrics);
+  if (metrics.rank !== null) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetricsRevShareCap: rank must be null, got: ${metrics.rank}.`
+    );
   }
-  const schema = makeReferrerLeaderboardPageResponseSchema(valueLabel);
-  const parsed = schema.safeParse(deserialized);
-  if (parsed.error) {
+  if (metrics.isQualified !== false) {
     throw new Error(
-      `Cannot deserialize SerializedReferrerLeaderboardPageResponse:
-${prettifyError(parsed.error)}
-`
+      `Invalid UnrankedReferrerMetricsRevShareCap: isQualified must be false, got: ${metrics.isQualified}.`
     );
   }
-  return parsed.data;
-}
-function deserializeReferrerDetailResponse(maybeResponse, valueLabel) {
-  let deserialized;
-  switch (maybeResponse.responseCode) {
-    case "ok": {
-      switch (maybeResponse.data.type) {
-        case "ranked":
-          deserialized = {
-            responseCode: maybeResponse.responseCode,
-            data: deserializeReferrerDetailRanked(maybeResponse.data)
-          };
-          break;
-        case "unranked":
-          deserialized = {
-            responseCode: maybeResponse.responseCode,
-            data: deserializeReferrerDetailUnranked(maybeResponse.data)
-          };
-          break;
-      }
-      break;
-    }
-    case "error":
-      deserialized = maybeResponse;
-      break;
+  validateAdminActionConsistency(
+    metrics.adminAction,
+    metrics.referrer,
+    rules,
+    "Invalid UnrankedReferrerMetricsRevShareCap: adminAction"
+  );
+  if (metrics.totalReferrals !== 0) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetricsRevShareCap: totalReferrals must be 0, got: ${metrics.totalReferrals}.`
+    );
   }
-  const schema = makeReferrerDetailResponseSchema(valueLabel);
-  const parsed = schema.safeParse(deserialized);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize ReferrerDetailResponse:
-${prettifyError(parsed.error)}
-`);
+  if (metrics.totalIncrementalDuration !== 0) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetricsRevShareCap: totalIncrementalDuration must be 0, got: ${metrics.totalIncrementalDuration}.`
+    );
   }
-  return parsed.data;
-}
-
-// src/api/serialize.ts
-function serializeRevenueContribution(revenueContribution) {
-  return revenueContribution.toString();
-}
-function serializeReferralProgramRules(rules) {
-  return rules;
-}
-function serializeAwardedReferrerMetrics(metrics) {
-  return {
-    referrer: metrics.referrer,
-    totalReferrals: metrics.totalReferrals,
-    totalIncrementalDuration: metrics.totalIncrementalDuration,
-    totalRevenueContribution: serializeRevenueContribution(metrics.totalRevenueContribution),
-    score: metrics.score,
-    rank: metrics.rank,
-    isQualified: metrics.isQualified,
-    finalScoreBoost: metrics.finalScoreBoost,
-    finalScore: metrics.finalScore,
-    awardPoolShare: metrics.awardPoolShare,
-    awardPoolApproxValue: metrics.awardPoolApproxValue
-  };
-}
-function serializeUnrankedReferrerMetrics(metrics) {
-  return {
-    referrer: metrics.referrer,
-    totalReferrals: metrics.totalReferrals,
-    totalIncrementalDuration: metrics.totalIncrementalDuration,
-    totalRevenueContribution: serializeRevenueContribution(metrics.totalRevenueContribution),
-    score: metrics.score,
-    rank: metrics.rank,
-    isQualified: metrics.isQualified,
-    finalScoreBoost: metrics.finalScoreBoost,
-    finalScore: metrics.finalScore,
-    awardPoolShare: metrics.awardPoolShare,
-    awardPoolApproxValue: metrics.awardPoolApproxValue
-  };
-}
-function serializeAggregatedReferrerMetrics(metrics) {
-  return {
-    grandTotalReferrals: metrics.grandTotalReferrals,
-    grandTotalIncrementalDuration: metrics.grandTotalIncrementalDuration,
-    grandTotalRevenueContribution: serializeRevenueContribution(
-      metrics.grandTotalRevenueContribution
-    ),
-    grandTotalQualifiedReferrersFinalScore: metrics.grandTotalQualifiedReferrersFinalScore,
-    minFinalScoreToQualify: metrics.minFinalScoreToQualify
-  };
-}
-function serializeReferrerLeaderboardPage(page) {
-  return {
-    rules: serializeReferralProgramRules(page.rules),
-    referrers: page.referrers.map(serializeAwardedReferrerMetrics),
-    aggregatedMetrics: serializeAggregatedReferrerMetrics(page.aggregatedMetrics),
-    pageContext: page.pageContext,
-    accurateAsOf: page.accurateAsOf
-  };
-}
-function serializeReferrerDetailRanked(detail) {
-  return {
-    type: detail.type,
-    rules: serializeReferralProgramRules(detail.rules),
-    referrer: serializeAwardedReferrerMetrics(detail.referrer),
-    aggregatedMetrics: serializeAggregatedReferrerMetrics(detail.aggregatedMetrics),
-    accurateAsOf: detail.accurateAsOf
-  };
-}
-function serializeReferrerDetailUnranked(detail) {
-  return {
-    type: detail.type,
-    rules: serializeReferralProgramRules(detail.rules),
-    referrer: serializeUnrankedReferrerMetrics(detail.referrer),
-    aggregatedMetrics: serializeAggregatedReferrerMetrics(detail.aggregatedMetrics),
-    accurateAsOf: detail.accurateAsOf
+  makePriceEthSchema("UnrankedReferrerMetricsRevShareCap.totalRevenueContribution").parse(
+    metrics.totalRevenueContribution
+  );
+  if (metrics.totalRevenueContribution.amount !== 0n) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetricsRevShareCap: totalRevenueContribution.amount must be 0n, got: ${metrics.totalRevenueContribution.amount.toString()}.`
+    );
+  }
+  makePriceUsdcSchema("UnrankedReferrerMetricsRevShareCap.totalBaseRevenueContribution").parse(
+    metrics.totalBaseRevenueContribution
+  );
+  if (metrics.totalBaseRevenueContribution.amount !== 0n) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetricsRevShareCap: totalBaseRevenueContribution.amount must be 0n, got: ${metrics.totalBaseRevenueContribution.amount.toString()}.`
+    );
+  }
+  makePriceUsdcSchema("UnrankedReferrerMetricsRevShareCap.uncappedAward").parse(
+    metrics.uncappedAward
+  );
+  if (metrics.uncappedAward.amount !== 0n) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetricsRevShareCap: uncappedAward.amount must be 0n, got: ${metrics.uncappedAward.amount.toString()}.`
+    );
+  }
+  makePriceUsdcSchema("UnrankedReferrerMetricsRevShareCap.cappedAward").parse(metrics.cappedAward);
+  if (metrics.cappedAward.amount !== 0n) {
+    throw new Error(
+      `Invalid UnrankedReferrerMetricsRevShareCap: cappedAward.amount must be 0n, got: ${metrics.cappedAward.amount.toString()}.`
+    );
+  }
+};
+var buildUnrankedReferrerMetricsRevShareCap = (referrer, rules) => {
+  const metrics = buildReferrerMetrics(referrer, 0, 0, priceEth(0n));
+  const adminAction = rules.adminActions.find((a) => a.referrer === metrics.referrer) ?? null;
+  const result = {
+    ...metrics,
+    totalBaseRevenueContribution: priceUsdc(0n),
+    rank: null,
+    isQualified: false,
+    uncappedAward: priceUsdc(0n),
+    cappedAward: priceUsdc(0n),
+    adminAction
   };
+  validateUnrankedReferrerMetricsRevShareCap(result, rules);
+  return result;
+};
+
+// src/award-models/rev-share-cap/sort-referral-events.ts
+function sortReferralEvents(events) {
+  return [...events].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
 }
-function serializeReferrerLeaderboardPageResponse(response) {
-  switch (response.responseCode) {
-    case ReferrerLeaderboardPageResponseCodes.Ok:
-      return {
-        responseCode: response.responseCode,
-        data: serializeReferrerLeaderboardPage(response.data)
+
+// src/award-models/rev-share-cap/leaderboard.ts
+var buildReferrerLeaderboardRevShareCap = (events, rules, accurateAsOf) => {
+  const sortedEvents = sortReferralEvents(events);
+  const referrerStates = /* @__PURE__ */ new Map();
+  let awardPoolRemaining = rules.awardPool;
+  for (const event of sortedEvents) {
+    const referrerId = event.referrer;
+    let referrerState = referrerStates.get(referrerId);
+    if (!referrerState) {
+      referrerState = {
+        totalReferrals: 0,
+        totalIncrementalDuration: 0,
+        totalRevenueContribution: priceEth(0n),
+        hasQualified: false,
+        cappedAward: priceUsdc(0n)
       };
-    case ReferrerLeaderboardPageResponseCodes.Error:
-      return response;
+      referrerStates.set(referrerId, referrerState);
+    }
+    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(
+        incrementalBaseRevenue,
+        rules.maxBaseRevenueShare
+      );
+      const incrementalCappedAward = minPrice(incrementalUncappedAward, awardPoolRemaining);
+      referrerState.cappedAward = addPrices(referrerState.cappedAward, incrementalCappedAward);
+      awardPoolRemaining = subtractPrice(awardPoolRemaining, incrementalCappedAward);
+    }
   }
-}
-function serializeReferrerDetailResponse(response) {
-  switch (response.responseCode) {
-    case ReferrerDetailResponseCodes.Ok:
-      switch (response.data.type) {
-        case "ranked":
-          return {
-            responseCode: response.responseCode,
-            data: serializeReferrerDetailRanked(response.data)
-          };
-        case "unranked":
-          return {
-            responseCode: response.responseCode,
-            data: serializeReferrerDetailUnranked(response.data)
-          };
+  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;
       }
-      break;
-    case ReferrerDetailResponseCodes.Error:
-      return response;
-  }
+      if (referrerStateB.totalIncrementalDuration !== referrerStateA.totalIncrementalDuration) {
+        return referrerStateB.totalIncrementalDuration - referrerStateA.totalIncrementalDuration;
+      }
+      if (referrerIdB > referrerIdA) return 1;
+      if (referrerIdB < referrerIdA) return -1;
+      return 0;
+    }
+  );
+  const awardedReferrers = sortedEntries.map(
+    ([referrerId, referrerState], index) => {
+      const baseMetrics = buildReferrerMetrics(
+        referrerId,
+        referrerState.totalReferrals,
+        referrerState.totalIncrementalDuration,
+        referrerState.totalRevenueContribution
+      );
+      const revShareMetrics = buildReferrerMetricsRevShareCap(baseMetrics, rules);
+      const rankedMetrics = buildRankedReferrerMetricsRevShareCap(
+        revShareMetrics,
+        index + 1,
+        rules
+      );
+      const uncappedAward = scalePrice(
+        revShareMetrics.totalBaseRevenueContribution,
+        rules.maxBaseRevenueShare
+      );
+      return buildAwardedReferrerMetricsRevShareCap(
+        rankedMetrics,
+        uncappedAward,
+        referrerState.cappedAward,
+        rules
+      );
+    }
+  );
+  const aggregatedMetrics = buildAggregatedReferrerMetricsRevShareCap(
+    awardedReferrers,
+    awardPoolRemaining
+  );
+  const referrers = new Map(awardedReferrers.map((r) => [r.referrer, r]));
+  return { awardModel: rules.awardModel, rules, aggregatedMetrics, referrers, accurateAsOf };
+};
+
+// src/award-models/rev-share-cap/leaderboard-page.ts
+function buildLeaderboardPageRevShareCap(pageContext, leaderboard) {
+  const status = calcReferralProgramEditionStatusRevShareCap(
+    leaderboard.rules,
+    leaderboard.accurateAsOf,
+    leaderboard.aggregatedMetrics
+  );
+  return {
+    awardModel: leaderboard.awardModel,
+    rules: leaderboard.rules,
+    referrers: sliceReferrers(leaderboard.referrers, pageContext),
+    aggregatedMetrics: leaderboard.aggregatedMetrics,
+    pageContext,
+    status,
+    accurateAsOf: leaderboard.accurateAsOf
+  };
 }
 
 // src/client.ts
@@ -1234,51 +2657,96 @@ var ENSReferralsClient = class _ENSReferralsClient {
       url: new URL(this.options.url.href)
     });
   }
+  /**
+   * Get Referral Program Edition Config Set
+   *
+   * Fetches and deserializes a referral program edition config set from a remote URL.
+   *
+   * @param url - The URL to fetch the edition config set from
+   * @returns A ReferralProgramEditionConfigSet (Map of edition slugs to edition configurations)
+   *
+   * @remarks Editions whose `rules.awardModel` is not recognized by this client version are
+   * preserved as {@link ReferralProgramRulesUnrecognized}. The returned map includes all
+   * editions — recognized and unrecognized alike. Callers should check `editionConfig.rules.awardModel`
+   * and skip editions with `"unrecognized"` as appropriate. The returned map may be empty.
+   *
+   * @throws if the fetch fails
+   * @throws if the response is not valid JSON
+   * @throws if the data doesn't match the expected schema
+   *
+   * @example
+   * ```typescript
+   * const url = new URL("https://example.com/editions.json");
+   * const editionConfigSet = await ENSReferralsClient.getReferralProgramEditionConfigSet(url);
+   * console.log(`Loaded ${editionConfigSet.size} editions`);
+   * ```
+   */
+  static async getReferralProgramEditionConfigSet(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    let json;
+    try {
+      json = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    const editionConfigs = deserializeReferralProgramEditionConfigSetArray(json);
+    return buildReferralProgramEditionConfigSet(editionConfigs);
+  }
   /**
    * Fetch Referrer Leaderboard Page
    *
-   * 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.
+   * Retrieves a paginated list of referrer leaderboard metrics for a specific referral program edition.
    *
-   * @param request - Pagination parameters
+   * @param request - Request parameters including edition and pagination
+   * @param request.edition - The referral program edition slug (e.g., "2025-12", "2026-03", or any other configured edition slug)
    * @param request.page - The page number to retrieve (1-indexed, default: 1)
    * @param request.recordsPerPage - Number of records per page (default: 25, max: 100)
    * @returns {ReferrerLeaderboardPageResponse}
    *
+   * @remarks If the server returns a leaderboard page whose `awardModel` is not recognized by
+   * this client version, it is preserved as {@link ReferrerLeaderboardPageUnrecognized}. Callers
+   * should check `response.data.awardModel` and handle the `"unrecognized"` case accordingly.
+   *
    * @throws if the ENSNode request fails
    * @throws if the ENSNode API returns an error response
    * @throws if the ENSNode response breaks required invariants
    *
    * @example
    * ```typescript
-   * // Get first page with default page size (25 records)
-   * const response = await client.getReferrerLeaderboardPage();
+   * // Get first page of 2025-12 leaderboard with default page size (25 records)
+   * const editionSlug = "2025-12";
+   * const response = await client.getReferrerLeaderboardPage({ edition: editionSlug });
    * if (response.responseCode === ReferrerLeaderboardPageResponseCodes.Ok) {
-   *   const {
-   *     aggregatedMetrics,
-   *     referrers,
-   *     rules,
-   *     pageContext,
-   *     updatedAt
-   *   } = response.data;
-   *   console.log(aggregatedMetrics);
-   *   console.log(referrers);
-   *   console.log(rules);
-   *   console.log(updatedAt);
-   *   console.log(`Page ${pageContext.page} of ${pageContext.totalPages}`);
+   *   const { awardModel, pageContext, accurateAsOf } = response.data;
+   *   if (awardModel === ReferralProgramAwardModels.Unrecognized) {
+   *     console.log(`Unrecognized award model: ${response.data.originalAwardModel} — skipping`);
+   *   } else {
+   *     const { aggregatedMetrics, referrers, rules } = response.data;
+   *     console.log(`Edition: ${editionSlug}`);
+   *     console.log(`Subregistry: ${rules.subregistryId}`);
+   *     console.log(`Total Referrers: ${pageContext.totalRecords}`);
+   *     console.log(`Page ${pageContext.page} of ${pageContext.totalPages}`);
+   *   }
    * }
    * ```
    *
    * @example
    * ```typescript
-   * // Get second page with 50 records per page
-   * const response = await client.getReferrerLeaderboardPage({ page: 2, recordsPerPage: 50 });
+   * // Get second page of 2026-03 with 50 records per page
+   * const response = await client.getReferrerLeaderboardPage({
+   *   edition: "2026-03",
+   *   page: 2,
+   *   recordsPerPage: 50
+   * });
    * ```
    *
    * @example
    * ```typescript
-   * // Handle error response, ie. when Referrer Leaderboard is not currently available.
-   * const response = await client.getReferrerLeaderboardPage();
+   * // Handle error response (e.g., unknown edition or data not available)
+   * const response = await client.getReferrerLeaderboardPage({ edition: "2025-12" });
    *
    * if (response.responseCode === ReferrerLeaderboardPageResponseCodes.Error) {
    *   console.error(response.error);
@@ -1287,9 +2755,10 @@ var ENSReferralsClient = class _ENSReferralsClient {
    * ```
    */
   async getReferrerLeaderboardPage(request) {
-    const url = new URL(`/ensanalytics/referrers`, this.options.url);
-    if (request?.page) url.searchParams.set("page", request.page.toString());
-    if (request?.recordsPerPage)
+    const url = new URL(`/v1/ensanalytics/referral-leaderboard`, this.options.url);
+    url.searchParams.set("edition", request.edition);
+    if (request.page !== void 0) url.searchParams.set("page", request.page.toString());
+    if (request.recordsPerPage !== void 0)
       url.searchParams.set("recordsPerPage", request.recordsPerPage.toString());
     const response = await fetch(url);
     let responseData;
@@ -1303,86 +2772,151 @@ var ENSReferralsClient = class _ENSReferralsClient {
     );
   }
   /**
-   * Fetch Referrer Detail
+   * Fetch Referrer Metrics for Specific Editions
    *
-   * Retrieves detailed information about a specific referrer, whether they are on the
-   * leaderboard or not.
+   * Retrieves detailed information about a specific referrer for the requested
+   * referral program editions. Returns a record mapping each requested edition slug
+   * to the referrer's metrics for that edition.
    *
-   * The response data is a discriminated union type with a `type` field:
+   * The response data maps edition slugs to referrer metrics. Each edition's entry is a
+   * {@link ReferrerEditionMetrics} discriminated union. Narrow on `awardModel` first to
+   * exclude unrecognized models, then on `type` to distinguish ranked from unranked:
    *
-   * **For referrers on the leaderboard** (`ReferrerDetailRanked`):
-   * - `type`: {@link ReferrerDetailTypeIds.Ranked}
-   * - `referrer`: The `AwardedReferrerMetrics` from @namehash/ens-referrals
-   * - `rules`: The referral program rules
-   * - `aggregatedMetrics`: Aggregated metrics for all referrers on the leaderboard
-   * - `accurateAsOf`: Unix timestamp indicating when the data was last updated
+   * - `awardModel: "unrecognized"` ({@link ReferrerEditionMetricsUnrecognized}): the server
+   *   returned an award model this client does not recognize. Only `originalAwardModel` is
+   *   available; no model-specific fields are present.
+   * - `type: "ranked"` ({@link ReferrerEditionMetricsTypeIds.Ranked}): the referrer appears on
+   *   the leaderboard. `referrer` contains rank, qualification status, and award share.
+   * - `type: "unranked"` ({@link ReferrerEditionMetricsTypeIds.Unranked}): the referrer has no
+   *   activity in this edition. `referrer` contains zero-value placeholders.
    *
-   * **For referrers NOT on the leaderboard** (`ReferrerDetailUnranked`):
-   * - `type`: {@link ReferrerDetailTypeIds.Unranked}
-   * - `referrer`: The `UnrankedReferrerMetrics` from @namehash/ens-referrals
-   * - `rules`: The referral program rules
-   * - `aggregatedMetrics`: Aggregated metrics for all referrers on the leaderboard
-   * - `accurateAsOf`: Unix timestamp indicating when the data was last updated
+   * **Note:** This endpoint does not allow partial success. When `responseCode === Ok`,
+   * all requested editions are guaranteed to be present in the response data. If any
+   * requested edition cannot be returned, the entire request fails with an error.
    *
    * @see {@link https://www.npmjs.com/package/@namehash/ens-referrals|@namehash/ens-referrals} for calculation details
    *
-   * @param request The referrer address to query
-   * @returns {ReferrerDetailResponse} Returns the referrer detail response
+   * @param request The referrer address and edition slugs to query
+   * @returns {ReferrerMetricsEditionsResponse} Returns the referrer metrics for requested editions
+   *
+   * @remarks If the server returns metrics for an edition whose `awardModel` is not recognized by
+   * this client version, that edition's entry in `response.data` is preserved as
+   * {@link ReferrerEditionMetricsUnrecognized}. Callers should check each edition's `awardModel`
+   * and handle the `"unrecognized"` case accordingly.
    *
    * @throws if the ENSNode request fails
    * @throws if the response data is malformed
    *
    * @example
    * ```typescript
-   * // Get referrer detail for a specific address
-   * const response = await client.getReferrerDetail({
-   *   referrer: "0x1234567890123456789012345678901234567890"
+   * // Get referrer metrics for specific editions
+   * const response = await client.getReferrerMetricsEditions({
+   *   referrer: "0x1234567890123456789012345678901234567890",
+   *   editions: ["2025-12", "2026-01"]
    * });
-   * if (response.responseCode === ReferrerDetailResponseCodes.Ok) {
-   *   const { type, referrer, rules, aggregatedMetrics, accurateAsOf } = response.data;
-   *   console.log(type); // ReferrerDetailTypeIds.Ranked or ReferrerDetailTypeIds.Unranked
-   *   console.log(referrer);
-   *   console.log(accurateAsOf);
+   * if (response.responseCode === ReferrerMetricsEditionsResponseCodes.Ok) {
+   *   // All requested editions are present in response.data
+   *   for (const [editionSlug, detail] of Object.entries(response.data)) {
+   *     console.log(`Edition: ${editionSlug}`);
+   *     if (detail.awardModel === ReferralProgramAwardModels.Unrecognized) {
+   *       console.log(`Unrecognized award model: ${detail.originalAwardModel} — skipping`);
+   *       continue;
+   *     }
+   *     console.log(`Type: ${detail.type}`);
+   *     if (detail.type === ReferrerEditionMetricsTypeIds.Ranked) {
+   *       console.log(`Rank: ${detail.referrer.rank}`);
+   *       console.log(`Award Share: ${detail.referrer.awardPoolShare * 100}%`);
+   *     }
+   *   }
    * }
    * ```
    *
    * @example
    * ```typescript
-   * // Use discriminated union to check if referrer is ranked
-   * const response = await client.getReferrerDetail({
-   *   referrer: "0x1234567890123456789012345678901234567890"
+   * // Access specific edition data directly (edition is guaranteed to exist when OK)
+   * const response = await client.getReferrerMetricsEditions({
+   *   referrer: "0x1234567890123456789012345678901234567890",
+   *   editions: ["2025-12"]
    * });
-   * if (response.responseCode === ReferrerDetailResponseCodes.Ok) {
-   *   if (response.data.type === ReferrerDetailTypeIds.Ranked) {
-   *     // TypeScript knows this is ReferrerDetailRanked
-   *     console.log(`Rank: ${response.data.referrer.rank}`);
-   *     console.log(`Qualified: ${response.data.referrer.isQualified}`);
-   *     console.log(`Award Pool Share: ${response.data.referrer.awardPoolShare * 100}%`);
-   *   } else {
-   *     // TypeScript knows this is ReferrerDetailUnranked
-   *     console.log("Referrer is not on the leaderboard (no referrals yet)");
+   * if (response.responseCode === ReferrerMetricsEditionsResponseCodes.Ok) {
+   *   const detail = response.data["2025-12"];
+   *   if (detail && detail.awardModel === ReferralProgramAwardModels.Unrecognized) {
+   *     console.log(`Unrecognized award model: ${detail.originalAwardModel} — skipping`);
+   *   } else if (detail && detail.type === ReferrerEditionMetricsTypeIds.Ranked) {
+   *     console.log(`Edition 2025-12 Rank: ${detail.referrer.rank}`);
+   *   } else if (detail) {
+   *     console.log("Referrer is not on the leaderboard for 2025-12");
    *   }
    * }
    * ```
    *
    * @example
    * ```typescript
-   * // Handle error response, ie. when Referrer Detail is not currently available.
-   * const response = await client.getReferrerDetail({
-   *   referrer: "0x1234567890123456789012345678901234567890"
+   * // Handle error response (e.g., unknown edition or data not available)
+   * const response = await client.getReferrerMetricsEditions({
+   *   referrer: "0x1234567890123456789012345678901234567890",
+   *   editions: ["2025-12", "invalid-edition"]
    * });
    *
-   * if (response.responseCode === ReferrerDetailResponseCodes.Error) {
+   * if (response.responseCode === ReferrerMetricsEditionsResponseCodes.Error) {
    *   console.error(response.error);
    *   console.error(response.errorMessage);
    * }
    * ```
    */
-  async getReferrerDetail(request) {
+  async getReferrerMetricsEditions(request) {
     const url = new URL(
-      `/ensanalytics/referrers/${encodeURIComponent(request.referrer)}`,
+      `/v1/ensanalytics/referrer/${encodeURIComponent(request.referrer)}`,
       this.options.url
     );
+    url.searchParams.set("editions", request.editions.join(","));
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    return deserializeReferrerMetricsEditionsResponse(
+      responseData
+    );
+  }
+  /**
+   * Get the currently configured referral program edition summaries.
+   * Editions are sorted in descending order by start timestamp (most recent first).
+   *
+   * @returns A response containing edition summaries, or an error response if unavailable.
+   *
+   * @remarks Editions whose `rules.awardModel` is not recognized by this client version are
+   * preserved as {@link ReferralProgramEditionSummaryUnrecognized}. The returned response includes all
+   * editions — recognized and unrecognized alike. Callers should check `edition.awardModel`
+   * and skip editions with `"unrecognized"` as appropriate. The returned editions list may be empty.
+   *
+   * @example
+   * ```typescript
+   * const response = await client.getEditionSummaries();
+   *
+   * if (response.responseCode === ReferralProgramEditionSummariesResponseCodes.Ok) {
+   *   console.log(`Found ${response.data.editions.length} editions`);
+   *   for (const edition of response.data.editions) {
+   *     console.log(`${edition.slug}: ${edition.displayName}`);
+   *   }
+   * }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Handle error response
+   * const response = await client.getEditionSummaries();
+   *
+   * if (response.responseCode === ReferralProgramEditionSummariesResponseCodes.Error) {
+   *   console.error(response.error);
+   *   console.error(response.errorMessage);
+   * }
+   * ```
+   */
+  async getEditionSummaries() {
+    const url = new URL(`/v1/ensanalytics/editions`, this.options.url);
     const response = await fetch(url);
     let responseData;
     try {
@@ -1390,53 +2924,111 @@ var ENSReferralsClient = class _ENSReferralsClient {
     } catch {
       throw new Error("Malformed response data: invalid JSON");
     }
-    return deserializeReferrerDetailResponse(responseData);
+    return deserializeReferralProgramEditionSummariesResponse(
+      responseData
+    );
   }
 };
 
-// src/currency.ts
-function isValidUSDQuantity(value) {
-  return isFiniteNonNegativeNumber(value);
-}
-function validateUSDQuantity(value) {
-  if (!isValidUSDQuantity(value)) {
-    throw new Error(`Invalid USD quantity: ${value}.`);
+// src/edition-metrics.ts
+var getReferrerEditionMetrics = (referrer, leaderboard) => {
+  switch (leaderboard.awardModel) {
+    case ReferralProgramAwardModels.PieSplit: {
+      const status = calcReferralProgramEditionStatusPieSplit(
+        leaderboard.rules,
+        leaderboard.accurateAsOf
+      );
+      const awardedReferrerMetrics = leaderboard.referrers.get(referrer);
+      if (awardedReferrerMetrics) {
+        return {
+          awardModel: leaderboard.awardModel,
+          type: ReferrerEditionMetricsTypeIds.Ranked,
+          rules: leaderboard.rules,
+          referrer: awardedReferrerMetrics,
+          aggregatedMetrics: leaderboard.aggregatedMetrics,
+          status,
+          accurateAsOf: leaderboard.accurateAsOf
+        };
+      }
+      return {
+        awardModel: leaderboard.awardModel,
+        type: ReferrerEditionMetricsTypeIds.Unranked,
+        rules: leaderboard.rules,
+        referrer: buildUnrankedReferrerMetricsPieSplit(referrer),
+        aggregatedMetrics: leaderboard.aggregatedMetrics,
+        status,
+        accurateAsOf: leaderboard.accurateAsOf
+      };
+    }
+    case ReferralProgramAwardModels.RevShareCap: {
+      const status = calcReferralProgramEditionStatusRevShareCap(
+        leaderboard.rules,
+        leaderboard.accurateAsOf,
+        leaderboard.aggregatedMetrics
+      );
+      const awardedReferrerMetrics = leaderboard.referrers.get(referrer);
+      if (awardedReferrerMetrics) {
+        return {
+          awardModel: leaderboard.awardModel,
+          type: ReferrerEditionMetricsTypeIds.Ranked,
+          rules: leaderboard.rules,
+          referrer: awardedReferrerMetrics,
+          aggregatedMetrics: leaderboard.aggregatedMetrics,
+          status,
+          accurateAsOf: leaderboard.accurateAsOf
+        };
+      }
+      return {
+        awardModel: leaderboard.awardModel,
+        type: ReferrerEditionMetricsTypeIds.Unranked,
+        rules: leaderboard.rules,
+        referrer: buildUnrankedReferrerMetricsRevShareCap(referrer, leaderboard.rules),
+        aggregatedMetrics: leaderboard.aggregatedMetrics,
+        status,
+        accurateAsOf: leaderboard.accurateAsOf
+      };
+    }
+    default: {
+      const _exhaustiveCheck = leaderboard;
+      throw new Error(
+        `Unknown award model: ${_exhaustiveCheck.awardModel}`
+      );
+    }
   }
-}
+};
 
-// 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"
-    );
+// src/edition-summary.ts
+function buildEditionSummary(config, leaderboard) {
+  const { slug, displayName } = config;
+  switch (leaderboard.awardModel) {
+    case ReferralProgramAwardModels.PieSplit:
+      return buildEditionSummaryPieSplit(slug, displayName, leaderboard.rules, leaderboard);
+    case ReferralProgramAwardModels.RevShareCap:
+      return buildEditionSummaryRevShareCap(slug, displayName, leaderboard.rules, leaderboard);
+    default: {
+      const _exhaustiveCheck = leaderboard;
+      throw new Error(
+        `Unknown award model: ${_exhaustiveCheck.awardModel}`
+      );
+    }
   }
-  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.`
-    );
+}
+
+// src/leaderboard-page.ts
+var getReferrerLeaderboardPage = (pageParams, leaderboard) => {
+  const pageContext = buildReferrerLeaderboardPageContext(pageParams, leaderboard);
+  switch (leaderboard.awardModel) {
+    case ReferralProgramAwardModels.PieSplit:
+      return buildLeaderboardPagePieSplit(pageContext, leaderboard);
+    case ReferralProgramAwardModels.RevShareCap:
+      return buildLeaderboardPageRevShareCap(pageContext, leaderboard);
+    default: {
+      const _exhaustiveCheck = leaderboard;
+      throw new Error(
+        `Unknown award model: ${_exhaustiveCheck.awardModel}`
+      );
+    }
   }
-  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/link.ts
@@ -1446,119 +3038,96 @@ function buildEnsReferralUrl(address) {
   ensAppUrl.searchParams.set("referrer", 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;
-};
-
-// src/status.ts
-var ReferralProgramStatuses = {
-  /**
-   * Represents a referral program that has been announced, but hasn't started yet.
-   */
-  Scheduled: "Scheduled",
-  /**
-   * Represents a currently ongoing referral program.
-   */
-  Active: "Active",
-  /**
-   * Represents a referral program that has already ended.
-   */
-  Closed: "Closed"
-};
-var calcReferralProgramStatus = (referralProgramRules, now) => {
-  if (now < referralProgramRules.startTime) return ReferralProgramStatuses.Scheduled;
-  if (now > referralProgramRules.endTime) return ReferralProgramStatuses.Closed;
-  return ReferralProgramStatuses.Active;
-};
 export {
+  AdminActionTypes,
   DEFAULT_ENSNODE_API_URL,
   ENSReferralsClient,
-  ENS_HOLIDAY_AWARDS_END_DATE,
-  ENS_HOLIDAY_AWARDS_MAX_QUALIFIED_REFERRERS,
-  ENS_HOLIDAY_AWARDS_START_DATE,
-  ENS_HOLIDAY_AWARDS_TOTAL_AWARD_POOL_VALUE,
+  MAX_EDITIONS_PER_REQUEST,
+  REFERRAL_PROGRAM_EDITION_SLUG_PATTERN,
   REFERRERS_PER_LEADERBOARD_PAGE_DEFAULT,
   REFERRERS_PER_LEADERBOARD_PAGE_MAX,
-  ReferralProgramStatuses,
-  ReferrerDetailResponseCodes,
-  ReferrerDetailTypeIds,
+  ReferralProgramAwardModels,
+  ReferralProgramEditionStatuses,
+  ReferralProgramEditionSummariesResponseCodes,
+  ReferrerEditionMetricsTypeIds,
   ReferrerLeaderboardPageResponseCodes,
+  ReferrerMetricsEditionsResponseCodes,
   SECONDS_PER_YEAR,
-  buildAggregatedReferrerMetrics,
-  buildAwardedReferrerMetrics,
+  buildAggregatedReferrerMetricsPieSplit,
+  buildAggregatedReferrerMetricsRevShareCap,
+  buildAwardedReferrerMetricsPieSplit,
+  buildAwardedReferrerMetricsRevShareCap,
+  buildEditionSummary,
+  buildEditionSummaryPieSplit,
+  buildEditionSummaryRevShareCap,
   buildEnsReferralUrl,
-  buildRankedReferrerMetrics,
-  buildReferralProgramRules,
-  buildReferrerLeaderboard,
+  buildLeaderboardPagePieSplit,
+  buildLeaderboardPageRevShareCap,
+  buildRankedReferrerMetricsPieSplit,
+  buildRankedReferrerMetricsRevShareCap,
+  buildReferralProgramEditionConfigSet,
+  buildReferralProgramRulesPieSplit,
+  buildReferralProgramRulesRevShareCap,
   buildReferrerLeaderboardPageContext,
   buildReferrerLeaderboardPageParams,
+  buildReferrerLeaderboardPieSplit,
+  buildReferrerLeaderboardRevShareCap,
   buildReferrerMetrics,
-  buildScoredReferrerMetrics,
-  buildUnrankedReferrerMetrics,
-  calcReferralProgramStatus,
-  calcReferrerAwardPoolShare,
-  calcReferrerFinalScore,
-  calcReferrerFinalScoreBoost,
-  calcReferrerFinalScoreMultiplier,
-  calcReferrerScore,
+  buildReferrerMetricsRevShareCap,
+  buildScoredReferrerMetricsPieSplit,
+  buildUnrankedReferrerMetricsPieSplit,
+  buildUnrankedReferrerMetricsRevShareCap,
+  calcBaseReferralProgramEditionStatus,
+  calcBaseRevenueContribution,
+  calcReferralProgramEditionStatusPieSplit,
+  calcReferralProgramEditionStatusRevShareCap,
+  calcReferrerAwardPoolSharePieSplit,
+  calcReferrerScorePieSplit,
   compareReferrerMetrics,
-  deserializeReferrerDetailResponse,
+  deserializeReferralProgramEditionConfigSetArray,
+  deserializeReferralProgramEditionSummariesResponse,
   deserializeReferrerLeaderboardPageResponse,
-  getReferrerDetail,
+  deserializeReferrerMetricsEditionsResponse,
+  getReferrerEditionMetrics,
   getReferrerLeaderboardPage,
   isFiniteNonNegativeNumber,
   isInteger,
   isNonNegativeInteger,
   isPositiveInteger,
-  isReferrerQualified,
+  isReferrerQualifiedRevShareCap,
   isValidDuration,
   isValidReferrerScore,
-  isValidRevenueContribution,
-  isValidUSDQuantity,
-  normalizeAddress,
-  serializeReferrerDetailResponse,
+  serializeReferralProgramEditionSummariesResponse,
+  serializeReferralProgramEditionSummary,
+  serializeReferralProgramRules,
   serializeReferrerLeaderboardPageResponse,
+  serializeReferrerMetricsEditionsResponse,
+  sliceReferrers,
   sortReferrerMetrics,
-  validateAggregatedReferrerMetrics,
-  validateAwardedReferrerMetrics,
+  validateAggregatedReferrerMetricsPieSplit,
+  validateAggregatedReferrerMetricsRevShareCap,
+  validateAwardedReferrerMetricsPieSplit,
+  validateAwardedReferrerMetricsRevShareCap,
+  validateBaseReferralProgramEditionSummary,
+  validateBaseReferralProgramRules,
   validateDuration,
-  validateLowercaseAddress,
+  validateEditionSummaryPieSplit,
+  validateEditionSummaryRevShareCap,
   validateNonNegativeInteger,
-  validateRankedReferrerMetrics,
-  validateReferralProgramRules,
+  validateNormalizedAddress,
+  validateRankedReferrerMetricsPieSplit,
+  validateRankedReferrerMetricsRevShareCap,
+  validateReferralProgramEditionConfigSet,
+  validateReferralProgramRulesPieSplit,
+  validateReferralProgramRulesRevShareCap,
   validateReferrerLeaderboardPageContext,
   validateReferrerMetrics,
+  validateReferrerMetricsRevShareCap,
   validateReferrerRank,
   validateReferrerScore,
-  validateRevenueContribution,
-  validateScoredReferrerMetrics,
-  validateUSDQuantity,
+  validateScoredReferrerMetricsPieSplit,
   validateUnixTimestamp,
-  validateUnrankedReferrerMetrics
+  validateUnrankedReferrerMetricsPieSplit,
+  validateUnrankedReferrerMetricsRevShareCap
 };
 //# sourceMappingURL=index.js.map