@provable-games/metagame-sdk 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,1071 @@
+'use strict';
+
+var starknet = require('starknet');
+
+// src/types/extensions.ts
+var QualifyingMode = /* @__PURE__ */ ((QualifyingMode2) => {
+  QualifyingMode2[QualifyingMode2["AtLeastOne"] = 0] = "AtLeastOne";
+  QualifyingMode2[QualifyingMode2["CumulativePerTournament"] = 1] = "CumulativePerTournament";
+  QualifyingMode2[QualifyingMode2["All"] = 2] = "All";
+  QualifyingMode2[QualifyingMode2["CumulativePerEntry"] = 3] = "CumulativePerEntry";
+  QualifyingMode2[QualifyingMode2["AllParticipateAnyWin"] = 4] = "AllParticipateAnyWin";
+  QualifyingMode2[QualifyingMode2["AllWithCumulative"] = 5] = "AllWithCumulative";
+  return QualifyingMode2;
+})(QualifyingMode || {});
+
+// src/utils/address.ts
+function indexAddress(address) {
+  return address.replace(/^0x0+/, "0x");
+}
+function padAddress(address) {
+  if (address && address !== "") {
+    const length = address.length;
+    const neededLength = 66 - length;
+    let zeros = "";
+    for (let i = 0; i < neededLength; i++) {
+      zeros += "0";
+    }
+    return address.substring(0, 2) + zeros + address.substring(2);
+  }
+  return "";
+}
+function displayAddress(address) {
+  if (address === void 0) return "unknown";
+  return address.substring(0, 6) + "..." + address.substring(address.length - 4);
+}
+function bigintToHex(v) {
+  if (!v) return "0x0";
+  return `0x${BigInt(v).toString(16)}`;
+}
+
+// src/utils/formatting.ts
+function formatNumber(num) {
+  if (Math.abs(num) >= 1e6) {
+    return parseFloat((num / 1e6).toFixed(2)) + "m";
+  } else if (Math.abs(num) >= 1e3) {
+    return parseFloat((num / 1e3).toFixed(2)) + "k";
+  } else if (Math.abs(num) >= 1) {
+    return num.toFixed(0);
+  } else if (Math.abs(num) >= 0.1) {
+    return num.toFixed(1);
+  } else if (Math.abs(num) >= 0.01) {
+    return num.toFixed(2);
+  } else if (Math.abs(num) >= 1e-3) {
+    return num.toFixed(3);
+  } else if (num === 0) {
+    return "0";
+  } else {
+    return num.toFixed(4);
+  }
+}
+function formatPrizeAmount(num) {
+  if (Math.abs(num) >= 1e6) {
+    return parseFloat((num / 1e6).toFixed(2)) + "m";
+  } else if (Math.abs(num) >= 1e3) {
+    return parseFloat((num / 1e3).toFixed(2)) + "k";
+  } else if (Math.abs(num) >= 100) {
+    return num.toFixed(1);
+  } else if (Math.abs(num) >= 10) {
+    return num.toFixed(2);
+  } else if (Math.abs(num) >= 1) {
+    return num.toFixed(2);
+  } else if (Math.abs(num) >= 0.1) {
+    return num.toFixed(2);
+  } else if (Math.abs(num) >= 0.01) {
+    return num.toFixed(3);
+  } else if (Math.abs(num) >= 1e-3) {
+    return num.toFixed(4);
+  } else if (num === 0) {
+    return "0";
+  } else {
+    return num.toFixed(5);
+  }
+}
+function formatUsdValue(value) {
+  if (value === 0) return "0.00";
+  if (value < 0.01 && value > 0) return "<0.01";
+  return value.toFixed(2);
+}
+function formatScore(num) {
+  if (Math.abs(num) >= 1e6) {
+    return parseFloat((num / 1e6).toFixed(2)) + "m";
+  } else if (Math.abs(num) >= 1e3) {
+    return parseFloat((num / 1e3).toFixed(2)) + "k";
+  } else if (Math.abs(num) >= 10) {
+    return num.toFixed(0);
+  } else if (Math.abs(num) > 0) {
+    return num.toFixed(0);
+  } else {
+    return "0";
+  }
+}
+function formatTime(seconds) {
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) {
+    return `${days} Day${days > 1 ? "s" : ""}`;
+  } else if (hours > 0) {
+    return `${hours} Hour${hours > 1 ? "s" : ""}`;
+  } else if (minutes > 0) {
+    return `${minutes} Min${minutes > 1 ? "s" : ""}`;
+  } else {
+    return `${seconds.toFixed(0)} Sec${seconds > 1 ? "s" : ""}`;
+  }
+}
+function getOrdinalSuffix(position) {
+  const formatPosition = isNaN(position) ? 0 : position;
+  if (formatPosition % 10 === 1 && formatPosition !== 11) return "st";
+  if (formatPosition % 10 === 2 && formatPosition !== 12) return "nd";
+  if (position % 10 === 3 && position !== 13) return "rd";
+  return "th";
+}
+function calculatePayouts(totalPlaces, weightingFactor) {
+  const weights = [];
+  for (let i = 1; i <= totalPlaces; i++) {
+    weights.push(1 / Math.pow(i, weightingFactor));
+  }
+  const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+  const payouts = weights.map(
+    (weight) => Math.floor(weight / totalWeight * 100)
+  );
+  const totalPayout = payouts.reduce((sum, payout) => sum + payout, 0);
+  let remaining = 100 - totalPayout;
+  let index = 0;
+  while (remaining > 0) {
+    payouts[index] += 1;
+    remaining -= 1;
+    index = (index + 1) % totalPlaces;
+  }
+  return payouts;
+}
+function calculateDistribution(positions, weight, creatorFee, gameFee, refundShare, distributionType = "exponential") {
+  if (positions <= 0) {
+    return [];
+  }
+  const safeCreatorFee = creatorFee ?? 0;
+  const safeGameFee = gameFee ?? 0;
+  const safeRefundShare = refundShare ?? 0;
+  const prizePoolPercentage = 100 - safeCreatorFee - safeGameFee - safeRefundShare;
+  if (prizePoolPercentage <= 0) {
+    return Array(positions).fill(0);
+  }
+  let rawDistributions = [];
+  if (distributionType === "uniform") {
+    rawDistributions = Array(positions).fill(1);
+  } else if (distributionType === "linear") {
+    for (let i = 0; i < positions; i++) {
+      const positionValue = positions - i;
+      const share = 1 + (positionValue - 1) * (weight / 10);
+      rawDistributions.push(share);
+    }
+  } else {
+    for (let i = 0; i < positions; i++) {
+      const share = Math.pow(1 - i / positions, weight);
+      rawDistributions.push(share);
+    }
+  }
+  const total = rawDistributions.reduce((a, b) => a + b, 0);
+  if (total === 0) {
+    return Array(positions).fill(0);
+  }
+  const basisPointShares = rawDistributions.map((d) => {
+    const ratio = d / total;
+    const basisPoints = ratio * 1e4;
+    return Math.floor(basisPoints);
+  });
+  const totalBasisPoints = basisPointShares.reduce((a, b) => a + b, 0);
+  const remainingBasisPoints = 1e4 - totalBasisPoints;
+  if (remainingBasisPoints !== 0 && positions > 0) {
+    basisPointShares[0] = basisPointShares[0] + remainingBasisPoints;
+  }
+  return basisPointShares.map((bp) => bp / 100);
+}
+
+// src/utils/prizes.ts
+function groupPrizesByToken(prizes) {
+  return prizes.reduce(
+    (acc, prize) => {
+      const key = prize.tokenAddress;
+      if (!acc[key]) {
+        acc[key] = {
+          type: prize.tokenType,
+          address: prize.tokenAddress,
+          totalAmount: "0"
+        };
+      }
+      acc[key].totalAmount = String(
+        BigInt(acc[key].totalAmount) + BigInt(prize.amount)
+      );
+      return acc;
+    },
+    {}
+  );
+}
+function calculatePrizeValue(amount, decimals, price) {
+  return Number(amount) / 10 ** decimals * price;
+}
+
+// src/utils/status.ts
+function computeStatus(timestamps, now) {
+  const currentTimestamp = now ?? Math.floor(Date.now() / 1e3);
+  if (timestamps.unlocked === false) {
+    return {
+      label: "Locked",
+      variant: "locked",
+      isActive: false,
+      countdown: null
+    };
+  }
+  if (timestamps.completed) {
+    return {
+      label: "Completed",
+      variant: "completed",
+      isActive: false,
+      countdown: null
+    };
+  }
+  const { registrationStart, registrationEnd, start, end, submissionEnd } = timestamps;
+  if (registrationStart && registrationEnd) {
+    if (currentTimestamp < registrationStart) {
+      return {
+        label: "Upcoming",
+        variant: "upcoming",
+        isActive: false,
+        countdown: {
+          targetTimestamp: registrationStart,
+          label: "Registration"
+        }
+      };
+    }
+    if (currentTimestamp >= registrationStart && currentTimestamp < registrationEnd) {
+      return {
+        label: "Registration",
+        variant: "registration",
+        isActive: true,
+        countdown: { targetTimestamp: registrationEnd, label: "Closes" }
+      };
+    }
+  }
+  if (currentTimestamp < start) {
+    return {
+      label: "Upcoming",
+      variant: "upcoming",
+      isActive: false,
+      countdown: { targetTimestamp: start, label: "Starts" }
+    };
+  }
+  if (currentTimestamp >= start && currentTimestamp < end) {
+    return {
+      label: "Live",
+      variant: "active",
+      isActive: true,
+      countdown: { targetTimestamp: end, label: "Ends" }
+    };
+  }
+  if (submissionEnd && currentTimestamp >= end && currentTimestamp < submissionEnd) {
+    return {
+      label: "Submission",
+      variant: "submission",
+      isActive: true,
+      countdown: { targetTimestamp: submissionEnd, label: "Submit" }
+    };
+  }
+  return {
+    label: "Ended",
+    variant: "ended",
+    isActive: false,
+    countdown: null
+  };
+}
+
+// src/utils/time.ts
+function isBefore(date1, date2) {
+  return date1.getTime() < date2.getTime();
+}
+
+// src/utils/entryFee.ts
+function calculateEntryFeeBreakdown(feePerEntry, entryCount, shares) {
+  const totalCollected = feePerEntry * BigInt(entryCount);
+  if (totalCollected === 0n) {
+    return {
+      totalCollected: 0n,
+      creatorAmount: 0n,
+      gameCreatorAmount: 0n,
+      refundAmount: 0n,
+      prizePoolAmount: 0n
+    };
+  }
+  const creatorAmount = shares.creatorShare > 0 ? totalCollected * BigInt(shares.creatorShare) / 10000n : 0n;
+  const gameCreatorAmount = shares.gameCreatorShare > 0 ? totalCollected * BigInt(shares.gameCreatorShare) / 10000n : 0n;
+  const refundAmount = shares.refundShare > 0 ? totalCollected * BigInt(shares.refundShare) / 10000n : 0n;
+  const prizePoolBps = 1e4 - shares.creatorShare - shares.gameCreatorShare - shares.refundShare;
+  const prizePoolAmount = prizePoolBps > 0 ? totalCollected * BigInt(prizePoolBps) / 10000n : 0n;
+  return {
+    totalCollected,
+    creatorAmount,
+    gameCreatorAmount,
+    refundAmount,
+    prizePoolAmount
+  };
+}
+function distributePool(prizePoolAmount, percentages) {
+  return percentages.map((pct, index) => ({
+    position: index + 1,
+    amount: prizePoolAmount * BigInt(Math.floor(pct * 100)) / 10000n
+  })).filter((entry) => entry.amount > 0n);
+}
+
+// src/utils/prizeAggregation.ts
+function aggregatePrizesByPosition(prizes) {
+  const positionMap = /* @__PURE__ */ new Map();
+  for (const prize of prizes) {
+    if (!positionMap.has(prize.position)) {
+      positionMap.set(prize.position, {
+        erc20Map: /* @__PURE__ */ new Map(),
+        erc721Map: /* @__PURE__ */ new Map()
+      });
+    }
+    const group = positionMap.get(prize.position);
+    if (prize.tokenType === "erc20") {
+      const current = group.erc20Map.get(prize.tokenAddress) ?? 0n;
+      group.erc20Map.set(prize.tokenAddress, current + BigInt(prize.amount));
+    } else {
+      const ids = group.erc721Map.get(prize.tokenAddress) ?? [];
+      ids.push(prize.id);
+      group.erc721Map.set(prize.tokenAddress, ids);
+    }
+  }
+  return Array.from(positionMap.entries()).sort(([a], [b]) => a - b).map(([position, { erc20Map, erc721Map }]) => ({
+    position,
+    erc20: Array.from(erc20Map.entries()).map(([tokenAddress, totalAmount]) => ({
+      tokenAddress,
+      totalAmount
+    })),
+    erc721: Array.from(erc721Map.entries()).map(([tokenAddress, tokenIds]) => ({
+      tokenAddress,
+      tokenIds
+    }))
+  }));
+}
+function aggregatePrizesBySponsor(prizes) {
+  const sponsorMap = /* @__PURE__ */ new Map();
+  for (const prize of prizes) {
+    if (!prize.sponsorAddress || prize.sponsorAddress === "0x0") continue;
+    if (!sponsorMap.has(prize.sponsorAddress)) {
+      sponsorMap.set(prize.sponsorAddress, {
+        erc20Map: /* @__PURE__ */ new Map(),
+        nftMap: /* @__PURE__ */ new Map(),
+        nftCount: 0,
+        totalCount: 0
+      });
+    }
+    const sponsor = sponsorMap.get(prize.sponsorAddress);
+    sponsor.totalCount++;
+    if (prize.tokenType === "erc20") {
+      const current = sponsor.erc20Map.get(prize.tokenAddress) ?? {
+        amount: 0n,
+        count: 0
+      };
+      sponsor.erc20Map.set(prize.tokenAddress, {
+        amount: current.amount + BigInt(prize.amount),
+        count: current.count + 1
+      });
+    } else {
+      sponsor.nftCount++;
+      const ids = sponsor.nftMap.get(prize.tokenAddress) ?? [];
+      ids.push(prize.amount);
+      sponsor.nftMap.set(prize.tokenAddress, ids);
+    }
+  }
+  return Array.from(sponsorMap.entries()).map(([sponsorAddress, { erc20Map, nftMap, nftCount, totalCount }]) => ({
+    sponsorAddress,
+    tokens: Array.from(erc20Map.entries()).map(
+      ([tokenAddress, { amount, count }]) => ({
+        tokenAddress,
+        totalAmount: amount,
+        prizeCount: count
+      })
+    ),
+    nftCollections: Array.from(nftMap.entries()).map(
+      ([tokenAddress, tokenIds]) => ({
+        tokenAddress,
+        tokenIds
+      })
+    ),
+    nftCount,
+    totalPrizeCount: totalCount
+  })).sort((a, b) => b.totalPrizeCount - a.totalPrizeCount);
+}
+function filterClaimablePrizes(prizes, claimedIds) {
+  return prizes.filter((prize) => !claimedIds.has(prize.id));
+}
+function filterZeroPrizes(prizes) {
+  return prizes.filter((prize) => {
+    if (prize.tokenType === "erc20") {
+      return BigInt(prize.amount) > 0n;
+    }
+    return true;
+  });
+}
+
+// src/utils/nftInput.ts
+function parseNFTBulkInput(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return { entries: [], errors: [] };
+  if (trimmed.startsWith("[")) {
+    return parseJsonFormat(trimmed);
+  }
+  return parseKeyValueFormat(trimmed);
+}
+function parseJsonFormat(input) {
+  const errors = [];
+  try {
+    const parsed = JSON.parse(input);
+    if (!Array.isArray(parsed)) {
+      return { entries: [], errors: ["Expected a JSON array"] };
+    }
+    const entries = [];
+    for (let i = 0; i < parsed.length; i++) {
+      const item = parsed[i];
+      const tokenId = item.tokenId ?? item.token_id ?? item.id;
+      const position = item.position ?? item.pos;
+      if (tokenId == null || position == null) {
+        errors.push(
+          `Item ${i + 1}: missing tokenId or position`
+        );
+        continue;
+      }
+      const posNum = Number(position);
+      if (!Number.isFinite(posNum) || posNum < 1) {
+        errors.push(`Item ${i + 1}: position must be >= 1`);
+        continue;
+      }
+      entries.push({ tokenId: String(tokenId), position: posNum });
+    }
+    return { entries, errors };
+  } catch {
+    return { entries: [], errors: ["Invalid JSON format"] };
+  }
+}
+function parseKeyValueFormat(input) {
+  const errors = [];
+  const entries = [];
+  const lines = input.split(/[\n,]/).map((s) => s.trim()).filter((s) => s.length > 0);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const parts = line.split(":").map((s) => s.trim());
+    if (parts.length !== 2) {
+      errors.push(`Line ${i + 1}: expected "tokenId:position" format`);
+      continue;
+    }
+    const [tokenIdStr, posStr] = parts;
+    const position = Number(posStr);
+    if (!tokenIdStr) {
+      errors.push(`Line ${i + 1}: missing tokenId`);
+      continue;
+    }
+    if (!Number.isFinite(position) || position < 1) {
+      errors.push(`Line ${i + 1}: position must be >= 1`);
+      continue;
+    }
+    entries.push({ tokenId: tokenIdStr, position });
+  }
+  return { entries, errors };
+}
+
+// src/utils/extensions.ts
+var EXTENSION_ADDRESSES = {
+  SN_SEPOLIA: {
+    tournamentValidator: "0x04c9ba290bbebd47f87141801623748884af610230cdaf69232007b4135be3f1",
+    erc20BalanceValidator: "0x05437210fd8231893da2317971983ae1f810d8d500344ad09e5b258b5820a908",
+    opusTrovesValidator: "0x0317f96eeff41d1badffd9bda126d36c1806523d8c91a5b440f9bdf2aa2b9fe7",
+    snapshotValidator: "0x02628045f0688663ecacbaefdbbc46c2e315b2da39271419e8a3443fe4120f61",
+    zkPassportValidator: "0x025b65137c5297e03491830635f4c5d76eb17e5b2db3bf49dbee34bba94ad3e6",
+    governanceValidator: "0x0585e6b1aa8daac7711004a92a8d0d3b5a81eaac8c9a07db24fc34b1a4f2322c"
+  },
+  SN_MAIN: {
+    tournamentValidator: "0x0771b57c0709fc4407ff8b63d573f302b96fb03638364032fad734e3c310b9e0",
+    erc20BalanceValidator: "0x051fc2681f65ee18e99dab3cc2ca2eca1b4532c735e752f575ace91ed30f17b7",
+    opusTrovesValidator: "0x0604bc0d54727f439786c65d7dc6f7d46de1aba7e129ef9caf65fef111a1644e",
+    snapshotValidator: "0x03e6820e9e1cfb5c22465a86f469c651355f05397e29fc94de8e832d5f3d8ede",
+    zkPassportValidator: "0x01a25f04c8a39da7bb37adcc53d595fde9e60702611d15b1c498df0657001479",
+    governanceValidator: ""
+    // placeholder until deployed
+  }
+};
+var OPUS_SUPPORTED_ASSETS = {
+  SN_SEPOLIA: [],
+  SN_MAIN: [
+    "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
+    // ETH
+    "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
+    // STRK
+    "0x0124aeb495b947201f5fac96fd1138e326ad86195b98df6dec9009158a533b49",
+    // LORDS
+    "0x075afe6402ad5a5c20dd25e10ec3b3986acaa647b77e4ae24b0cbc9a54a27a87",
+    // EKUBO
+    "0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac"
+    // WBTC
+  ]
+};
+function getExtensionAddresses(chainId) {
+  return EXTENSION_ADDRESSES[chainId] ?? {};
+}
+function getOpusSupportedAssets(chainId) {
+  return OPUS_SUPPORTED_ASSETS[chainId] ?? [];
+}
+function getWhitelistedExtensionAddresses(chainId) {
+  const addresses = EXTENSION_ADDRESSES[chainId] ?? {};
+  const set = /* @__PURE__ */ new Set();
+  for (const addr of Object.values(addresses)) {
+    if (addr) {
+      set.add(normalizeAddr(addr));
+    }
+  }
+  return set;
+}
+function isWhitelistedExtension(extensionAddress, chainId) {
+  const whitelist = getWhitelistedExtensionAddresses(chainId);
+  return whitelist.has(normalizeAddr(extensionAddress));
+}
+function normalizeAddr(address) {
+  if (!address) return "";
+  const hex = address.toLowerCase().replace(/^0x0*/, "");
+  return hex;
+}
+function identifyExtensionType(extensionAddress, chainId) {
+  const addresses = getExtensionAddresses(chainId);
+  const normalized = normalizeAddr(extensionAddress);
+  if (addresses.tournamentValidator && normalizeAddr(addresses.tournamentValidator) === normalized) {
+    return "tournament";
+  }
+  if (addresses.erc20BalanceValidator && normalizeAddr(addresses.erc20BalanceValidator) === normalized) {
+    return "erc20Balance";
+  }
+  if (addresses.opusTrovesValidator && normalizeAddr(addresses.opusTrovesValidator) === normalized) {
+    return "opusTroves";
+  }
+  if (addresses.snapshotValidator && normalizeAddr(addresses.snapshotValidator) === normalized) {
+    return "snapshot";
+  }
+  if (addresses.zkPassportValidator && normalizeAddr(addresses.zkPassportValidator) === normalized) {
+    return "zkPassport";
+  }
+  if (addresses.governanceValidator && normalizeAddr(addresses.governanceValidator) === normalized) {
+    return "governance";
+  }
+  return "unknown";
+}
+function parseTournamentValidatorConfig(config) {
+  if (!config || config.length < 3) return null;
+  return {
+    requirementType: String(config[0]) === "1" ? "won" : "participated",
+    qualifyingMode: Number(config[1]),
+    topPositions: Number(config[2]),
+    tournamentIds: config.slice(3).map((id) => String(BigInt(id)))
+  };
+}
+function parseERC20BalanceValidatorConfig(config) {
+  if (!config || config.length < 8) return null;
+  const tokenAddress = String(config[0]);
+  const minThreshold = BigInt(config[2]) << 128n | BigInt(config[1]);
+  const maxThreshold = BigInt(config[4]) << 128n | BigInt(config[3]);
+  const valuePerEntry = BigInt(config[6]) << 128n | BigInt(config[5]);
+  const maxEntries = Number(config[7]);
+  return {
+    tokenAddress,
+    minThreshold,
+    maxThreshold,
+    valuePerEntry,
+    maxEntries
+  };
+}
+function parseOpusTrovesValidatorConfig(config) {
+  if (!config || config.length < 4) return null;
+  const assetCount = Number(config[0]);
+  const assetAddresses = config.slice(1, assetCount + 1).map(String);
+  const threshold = BigInt(config[assetCount + 1] ?? "0");
+  const valuePerEntry = BigInt(config[assetCount + 2] ?? "0");
+  const maxEntries = Number(config[assetCount + 3] ?? "0");
+  return {
+    assetCount,
+    assetAddresses,
+    threshold,
+    valuePerEntry,
+    maxEntries
+  };
+}
+function parseSnapshotValidatorConfig(config) {
+  if (!config || config.length === 0) return null;
+  return {
+    snapshotId: String(Number(BigInt(config[0] ?? "0")))
+  };
+}
+function parseZkPassportValidatorConfig(config) {
+  if (!config || config.length < 6) return null;
+  return {
+    verifierAddress: String(config[0]),
+    serviceScope: BigInt(config[1]),
+    subscope: BigInt(config[2]),
+    paramCommitment: BigInt(config[3]),
+    maxProofAge: Number(config[4]),
+    nullifierType: Number(config[5])
+  };
+}
+function parseGovernanceValidatorConfig(config) {
+  if (!config || config.length < 11) return null;
+  return {
+    governorAddress: String(config[0]),
+    governanceTokenAddress: String(config[1]),
+    balanceThreshold: BigInt(config[3]) << 128n | BigInt(config[2]),
+    proposalId: BigInt(config[5]) << 128n | BigInt(config[4]),
+    checkVoted: String(config[6]) === "1" || BigInt(config[6]) === 1n,
+    votesThreshold: BigInt(config[8]) << 128n | BigInt(config[7]),
+    votesPerEntry: BigInt(config[10]) << 128n | BigInt(config[9])
+  };
+}
+function parseExtensionConfig(extensionAddress, config, chainId) {
+  const extensionType = identifyExtensionType(extensionAddress, chainId);
+  switch (extensionType) {
+    case "tournament": {
+      const parsed = parseTournamentValidatorConfig(config);
+      return parsed ? { type: "tournament", config: parsed } : null;
+    }
+    case "erc20Balance": {
+      const parsed = parseERC20BalanceValidatorConfig(config);
+      return parsed ? { type: "erc20Balance", config: parsed } : null;
+    }
+    case "opusTroves": {
+      const parsed = parseOpusTrovesValidatorConfig(config);
+      return parsed ? { type: "opusTroves", config: parsed } : null;
+    }
+    case "snapshot": {
+      const parsed = parseSnapshotValidatorConfig(config);
+      return parsed ? { type: "snapshot", config: parsed } : null;
+    }
+    case "zkPassport": {
+      const parsed = parseZkPassportValidatorConfig(config);
+      return parsed ? { type: "zkPassport", config: parsed } : null;
+    }
+    case "governance": {
+      const parsed = parseGovernanceValidatorConfig(config);
+      return parsed ? { type: "governance", config: parsed } : null;
+    }
+    default:
+      return { type: "unknown", config: null };
+  }
+}
+function getQualifyingModeInfo(mode) {
+  switch (mode) {
+    case 0:
+      return {
+        label: "At Least One",
+        description: "Qualify in at least one tournament"
+      };
+    case 1:
+      return {
+        label: "Cumulative per Tournament",
+        description: "Track entry limits separately for each tournament"
+      };
+    case 2:
+      return {
+        label: "All",
+        description: "Must qualify in all tournaments"
+      };
+    case 3:
+      return {
+        label: "Cumulative per Entry",
+        description: "Track entries per qualifying token ID"
+      };
+    case 4:
+      return {
+        label: "All Participate, Any Win",
+        description: "Must participate in all tournaments, but only need to win in any one"
+      };
+    case 5:
+      return {
+        label: "All With Cumulative",
+        description: "Must participate in all tournaments, entries multiply by tournament count"
+      };
+    default:
+      return { label: "Unknown", description: "" };
+  }
+}
+function formatTokenAmount(value, decimals) {
+  if (value === 0n) return "0";
+  const divisor = 10n ** BigInt(decimals);
+  const integerPart = value / divisor;
+  const remainder = value % divisor;
+  if (remainder === 0n) return integerPart.toString();
+  const decimalStr = remainder.toString().padStart(decimals, "0");
+  const trimmed = decimalStr.replace(/0+$/, "");
+  return trimmed ? `${integerPart}.${trimmed}` : integerPart.toString();
+}
+function formatCashToUSD(value) {
+  return formatTokenAmount(value, 18);
+}
+
+// src/utils/qualification.ts
+function evaluateTokenQualification(input) {
+  if (input.ownedTokenIds.length === 0) {
+    return {
+      meetsRequirements: false,
+      bestProof: null,
+      qualifications: [],
+      totalEntriesLeft: 0
+    };
+  }
+  const qualifications = [];
+  for (const tokenId of input.ownedTokenIds) {
+    const usedCount = input.usedEntryCounts[tokenId] ?? 0;
+    const remaining = input.entryLimit > 0 ? input.entryLimit - usedCount : Infinity;
+    if (remaining > 0) {
+      qualifications.push({
+        id: `token-${tokenId}`,
+        entriesLeft: remaining,
+        proof: { type: "token", tokenId },
+        label: `Token #${tokenId}`,
+        metadata: { tokenId }
+      });
+    }
+  }
+  const totalEntriesLeft = qualifications.reduce(
+    (sum, q) => sum + (q.entriesLeft === Infinity ? 1 : q.entriesLeft),
+    0
+  );
+  const best = qualifications.length > 0 ? qualifications.reduce(
+    (a, b) => b.entriesLeft > a.entriesLeft ? b : a
+  ) : null;
+  return {
+    meetsRequirements: qualifications.length > 0,
+    bestProof: best?.proof ?? null,
+    qualifications,
+    totalEntriesLeft
+  };
+}
+function evaluateExtensionQualification(input) {
+  const qualifications = input.checkedQualifications.filter((q) => q.entriesLeft > 0).map((q) => ({
+    id: q.id,
+    entriesLeft: q.entriesLeft,
+    proof: {
+      type: "extension",
+      extensionProof: q.proof
+    },
+    label: q.label,
+    metadata: q.metadata
+  }));
+  const totalEntriesLeft = qualifications.reduce(
+    (sum, q) => sum + q.entriesLeft,
+    0
+  );
+  const best = qualifications.length > 0 ? qualifications.reduce(
+    (a, b) => b.entriesLeft > a.entriesLeft ? b : a
+  ) : null;
+  return {
+    meetsRequirements: qualifications.length > 0,
+    bestProof: best?.proof ?? null,
+    qualifications,
+    totalEntriesLeft
+  };
+}
+function evaluateQualification(variant, input) {
+  if (variant === "none" || input.type === "none") {
+    return {
+      meetsRequirements: true,
+      bestProof: null,
+      qualifications: [
+        {
+          id: "no-requirement",
+          entriesLeft: Infinity,
+          proof: { type: "none" }
+        }
+      ],
+      totalEntriesLeft: Infinity
+    };
+  }
+  switch (input.type) {
+    case "token":
+      return evaluateTokenQualification(input.data);
+    case "extension":
+      return evaluateExtensionQualification(input.data);
+    default:
+      return {
+        meetsRequirements: false,
+        bestProof: null,
+        qualifications: [],
+        totalEntriesLeft: 0
+      };
+  }
+}
+function buildQualificationProof(proof) {
+  if (!proof) {
+    return new starknet.CairoOption(starknet.CairoOptionVariant.None);
+  }
+  switch (proof.type) {
+    case "token":
+      return buildNFTProof(proof.tokenId ?? "0");
+    case "extension":
+      return buildExtensionProof(proof.extensionProof ?? []);
+    case "none":
+      return new starknet.CairoOption(starknet.CairoOptionVariant.None);
+    default:
+      return new starknet.CairoOption(starknet.CairoOptionVariant.None);
+  }
+}
+function buildNFTProof(tokenId) {
+  return new starknet.CairoOption(
+    starknet.CairoOptionVariant.Some,
+    new starknet.CairoCustomEnum({
+      NFT: {
+        token_id: {
+          low: tokenId,
+          high: "0"
+        }
+      },
+      Extension: void 0
+    })
+  );
+}
+function buildTournamentExtensionProof(tournamentId, tokenId, position) {
+  return buildExtensionProof([
+    tournamentId.toString(),
+    tokenId.toString(),
+    position.toString()
+  ]);
+}
+function buildExtensionProof(proofData) {
+  return new starknet.CairoOption(
+    starknet.CairoOptionVariant.Some,
+    new starknet.CairoCustomEnum({
+      NFT: void 0,
+      Extension: proofData
+    })
+  );
+}
+
+// src/utils/tournamentValidator.ts
+function buildParticipationMap(registrations, requiredTournamentIds) {
+  const requiredSet = new Set(requiredTournamentIds);
+  const map = {};
+  for (const reg of registrations) {
+    if (!requiredSet.has(reg.tournamentId)) continue;
+    if (!map[reg.tournamentId]) map[reg.tournamentId] = [];
+    map[reg.tournamentId].push(reg.gameTokenId);
+  }
+  return map;
+}
+function buildWinMap(leaderboards, ownedGameTokenIds, topPositions = 0) {
+  const ownedSet = new Set(ownedGameTokenIds);
+  const map = {};
+  for (const lb of leaderboards) {
+    if (!lb.isFinalized) continue;
+    const limit = topPositions > 0 ? topPositions : lb.tokenIds.length;
+    for (let i = 0; i < Math.min(limit, lb.tokenIds.length); i++) {
+      if (ownedSet.has(lb.tokenIds[i])) {
+        if (!map[lb.tournamentId]) map[lb.tournamentId] = [];
+        map[lb.tournamentId].push({
+          tokenId: lb.tokenIds[i],
+          position: i + 1
+        });
+      }
+    }
+  }
+  return map;
+}
+function resolveTournamentQualifications(config, participationMap, winMap, tournamentNames) {
+  const inputs = [];
+  if (config.requirementType === "won") {
+    for (const tournamentId of config.tournamentIds) {
+      const wonEntries = winMap[tournamentId];
+      if (!wonEntries) continue;
+      for (const entry of wonEntries) {
+        inputs.push({
+          tournamentId,
+          tokenId: entry.tokenId,
+          position: entry.position,
+          tournamentName: tournamentNames?.[tournamentId]
+        });
+      }
+    }
+  } else {
+    for (const tournamentId of config.tournamentIds) {
+      const tokenIds = participationMap[tournamentId];
+      if (!tokenIds) continue;
+      for (const tokenId of tokenIds) {
+        inputs.push({
+          tournamentId,
+          tokenId,
+          position: 1,
+          // Participation = position 1
+          tournamentName: tournamentNames?.[tournamentId]
+        });
+      }
+    }
+  }
+  return inputs;
+}
+
+// src/utils/opusTroves.ts
+function calculateOpusTrovesEntries(debt, config) {
+  let allowed = 0;
+  if (config.valuePerEntry > 0n) {
+    if (debt > config.threshold) {
+      allowed = Number((debt - config.threshold) / config.valuePerEntry);
+    }
+  } else {
+    if (debt >= config.threshold && config.maxEntries > 0) {
+      allowed = config.maxEntries;
+    }
+  }
+  if (config.maxEntries > 0) {
+    allowed = Math.min(allowed, config.maxEntries);
+  }
+  return allowed;
+}
+function findBannableEntries(registeredTokenIds, entriesAllowed) {
+  const bannable = /* @__PURE__ */ new Set();
+  const bannableCount = Math.max(0, registeredTokenIds.length - entriesAllowed);
+  if (bannableCount > 0) {
+    const sorted = [...registeredTokenIds].sort((a, b) => {
+      return Number(BigInt(a)) - Number(BigInt(b));
+    });
+    for (let i = 0; i < bannableCount; i++) {
+      bannable.add(sorted[i]);
+    }
+  }
+  return bannable;
+}
+function findAllBannableEntries(players, config) {
+  const allBannable = /* @__PURE__ */ new Set();
+  for (const [, { debt, registeredTokenIds }] of players) {
+    const allowed = calculateOpusTrovesEntries(debt, config);
+    const bannable = findBannableEntries(registeredTokenIds, allowed);
+    for (const id of bannable) {
+      allBannable.add(id);
+    }
+  }
+  return allBannable;
+}
+
+// src/utils/prizePool.ts
+function buildEntryFeePrizes(entryFee, entryCount) {
+  if (!entryFee.amount || entryCount === 0 || entryFee.distributionCount <= 0) {
+    return [];
+  }
+  const shares = {
+    creatorShare: entryFee.tournamentCreatorShare,
+    gameCreatorShare: entryFee.gameCreatorShare,
+    refundShare: entryFee.refundShare
+  };
+  const breakdown = calculateEntryFeeBreakdown(
+    BigInt(entryFee.amount),
+    entryCount,
+    shares
+  );
+  if (breakdown.prizePoolAmount <= 0n) return [];
+  const dist = entryFee.distribution;
+  let distributionType = "uniform";
+  let weight = 10;
+  if (dist?.type === "linear" || dist?.Linear !== void 0) {
+    distributionType = "linear";
+    weight = Number(dist.weight ?? dist.Linear ?? 100) / 10;
+  } else if (dist?.type === "exponential" || dist?.Exponential !== void 0) {
+    distributionType = "exponential";
+    weight = Number(dist.weight ?? dist.Exponential ?? 100) / 10;
+  }
+  const percentages = calculateDistribution(
+    entryFee.distributionCount,
+    weight,
+    0,
+    0,
+    0,
+    distributionType
+  );
+  const positions = distributePool(breakdown.prizePoolAmount, percentages);
+  return positions.map((pos) => ({
+    id: `entry_fee_${pos.position}`,
+    position: pos.position,
+    tokenAddress: entryFee.tokenAddress,
+    tokenType: "erc20",
+    amount: pos.amount.toString(),
+    sponsorAddress: ""
+  }));
+}
+function calculateTotalPrizeValueUSD(prizes, prices, decimals, normalizeAddress = (addr) => addr) {
+  let total = 0;
+  for (const prize of prizes) {
+    if (prize.tokenType !== "erc20") continue;
+    const addr = normalizeAddress(prize.tokenAddress);
+    const price = prices[addr];
+    if (price === void 0) continue;
+    const dec = decimals[addr] ?? 18;
+    total += calculatePrizeValue(prize.amount, dec, price);
+  }
+  return total;
+}
+function calculatePaidPlaces(sponsoredPrizes, entryFeeDistributionCount) {
+  const maxSponsoredPosition = sponsoredPrizes.reduce(
+    (max, p) => Math.max(max, p.position),
+    0
+  );
+  return Math.max(maxSponsoredPosition, entryFeeDistributionCount);
+}
+
+exports.QualifyingMode = QualifyingMode;
+exports.aggregatePrizesByPosition = aggregatePrizesByPosition;
+exports.aggregatePrizesBySponsor = aggregatePrizesBySponsor;
+exports.bigintToHex = bigintToHex;
+exports.buildEntryFeePrizes = buildEntryFeePrizes;
+exports.buildExtensionProof = buildExtensionProof;
+exports.buildNFTProof = buildNFTProof;
+exports.buildParticipationMap = buildParticipationMap;
+exports.buildQualificationProof = buildQualificationProof;
+exports.buildTournamentExtensionProof = buildTournamentExtensionProof;
+exports.buildWinMap = buildWinMap;
+exports.calculateDistribution = calculateDistribution;
+exports.calculateEntryFeeBreakdown = calculateEntryFeeBreakdown;
+exports.calculateOpusTrovesEntries = calculateOpusTrovesEntries;
+exports.calculatePaidPlaces = calculatePaidPlaces;
+exports.calculatePayouts = calculatePayouts;
+exports.calculatePrizeValue = calculatePrizeValue;
+exports.calculateTotalPrizeValueUSD = calculateTotalPrizeValueUSD;
+exports.computeStatus = computeStatus;
+exports.displayAddress = displayAddress;
+exports.distributePool = distributePool;
+exports.evaluateExtensionQualification = evaluateExtensionQualification;
+exports.evaluateQualification = evaluateQualification;
+exports.evaluateTokenQualification = evaluateTokenQualification;
+exports.filterClaimablePrizes = filterClaimablePrizes;
+exports.filterZeroPrizes = filterZeroPrizes;
+exports.findAllBannableEntries = findAllBannableEntries;
+exports.findBannableEntries = findBannableEntries;
+exports.formatCashToUSD = formatCashToUSD;
+exports.formatNumber = formatNumber;
+exports.formatPrizeAmount = formatPrizeAmount;
+exports.formatScore = formatScore;
+exports.formatTime = formatTime;
+exports.formatTokenAmount = formatTokenAmount;
+exports.formatUsdValue = formatUsdValue;
+exports.getExtensionAddresses = getExtensionAddresses;
+exports.getOpusSupportedAssets = getOpusSupportedAssets;
+exports.getOrdinalSuffix = getOrdinalSuffix;
+exports.getQualifyingModeInfo = getQualifyingModeInfo;
+exports.getWhitelistedExtensionAddresses = getWhitelistedExtensionAddresses;
+exports.groupPrizesByToken = groupPrizesByToken;
+exports.identifyExtensionType = identifyExtensionType;
+exports.indexAddress = indexAddress;
+exports.isBefore = isBefore;
+exports.isWhitelistedExtension = isWhitelistedExtension;
+exports.padAddress = padAddress;
+exports.parseERC20BalanceValidatorConfig = parseERC20BalanceValidatorConfig;
+exports.parseExtensionConfig = parseExtensionConfig;
+exports.parseGovernanceValidatorConfig = parseGovernanceValidatorConfig;
+exports.parseNFTBulkInput = parseNFTBulkInput;
+exports.parseOpusTrovesValidatorConfig = parseOpusTrovesValidatorConfig;
+exports.parseSnapshotValidatorConfig = parseSnapshotValidatorConfig;
+exports.parseTournamentValidatorConfig = parseTournamentValidatorConfig;
+exports.parseZkPassportValidatorConfig = parseZkPassportValidatorConfig;
+exports.resolveTournamentQualifications = resolveTournamentQualifications;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map