@provable-games/metagame-sdk 0.1.0 → 0.1.2

package/dist/react.js

@@ -0,0 +1,906 @@
+import { useState, useEffect, useMemo, useCallback, useRef } from 'react';
+import { CallData } from 'starknet';
+
+// src/react/useDebounce.ts
+function useDebounce(value, delay) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+function usePagination({
+  totalItems,
+  pageSize = 10
+}) {
+  const [currentPage, setCurrentPage] = useState(0);
+  const totalPages = useMemo(
+    () => Math.max(1, Math.ceil(totalItems / pageSize)),
+    [totalItems, pageSize]
+  );
+  const hasNext = currentPage < totalPages - 1;
+  const hasPrev = currentPage > 0;
+  const next = useCallback(() => {
+    setCurrentPage((p) => Math.min(p + 1, totalPages - 1));
+  }, [totalPages]);
+  const prev = useCallback(() => {
+    setCurrentPage((p) => Math.max(p - 1, 0));
+  }, []);
+  const reset = useCallback(() => {
+    setCurrentPage(0);
+  }, []);
+  const startIndex = currentPage * pageSize;
+  const endIndex = Math.min(startIndex + pageSize, totalItems);
+  return {
+    currentPage,
+    totalPages,
+    hasNext,
+    hasPrev,
+    next,
+    prev,
+    reset,
+    startIndex,
+    endIndex
+  };
+}
+function useSearchFilter({
+  items,
+  searchFields,
+  debounceMs = 300
+}) {
+  const [search, setSearch] = useState("");
+  const debouncedSearch = useDebounce(search, debounceMs);
+  const filteredItems = useMemo(() => {
+    if (!debouncedSearch) return items;
+    const lower = debouncedSearch.toLowerCase();
+    return items.filter(
+      (item) => searchFields.some((field) => {
+        const value = item[field];
+        if (typeof value === "string") {
+          return value.toLowerCase().includes(lower);
+        }
+        if (typeof value === "number") {
+          return String(value).includes(lower);
+        }
+        return false;
+      })
+    );
+  }, [items, debouncedSearch, searchFields]);
+  return {
+    search,
+    setSearch,
+    filteredItems,
+    resultCount: filteredItems.length
+  };
+}
+function useTokenSelector({
+  tokens,
+  tokenType,
+  pageSize = 10,
+  debounceMs = 300
+}) {
+  const [search, setSearchRaw] = useState("");
+  const [selectedToken, setSelectedToken] = useState(null);
+  const debouncedSearch = useDebounce(search, debounceMs);
+  const allFiltered = useMemo(() => {
+    let result = tokens;
+    if (tokenType) {
+      result = result.filter((t) => t.tokenType === tokenType);
+    }
+    if (debouncedSearch) {
+      const lower = debouncedSearch.toLowerCase();
+      result = result.filter(
+        (t) => t.name.toLowerCase().includes(lower) || t.symbol.toLowerCase().includes(lower) || t.address.toLowerCase().includes(lower)
+      );
+    }
+    return result;
+  }, [tokens, tokenType, debouncedSearch]);
+  const pagination = usePagination({
+    totalItems: allFiltered.length,
+    pageSize
+  });
+  const filteredTokens = useMemo(
+    () => allFiltered.slice(pagination.startIndex, pagination.endIndex),
+    [allFiltered, pagination.startIndex, pagination.endIndex]
+  );
+  const setSearch = useCallback(
+    (q) => {
+      setSearchRaw(q);
+      pagination.reset();
+    },
+    [pagination]
+  );
+  const select = useCallback((token) => {
+    setSelectedToken(token);
+  }, []);
+  const clear = useCallback(() => {
+    setSelectedToken(null);
+  }, []);
+  const isSelected = useCallback(
+    (token) => selectedToken?.address === token.address,
+    [selectedToken]
+  );
+  const getTokenProps = useCallback(
+    (token) => ({
+      onClick: () => select(token),
+      "data-selected": isSelected(token),
+      role: "option",
+      "aria-selected": isSelected(token)
+    }),
+    [select, isSelected]
+  );
+  return {
+    search,
+    setSearch,
+    filteredTokens,
+    selectedToken,
+    select,
+    clear,
+    isSelected,
+    pagination,
+    getTokenProps
+  };
+}
+
+// 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/react/useStatusIndicator.ts
+function useStatusIndicator(timestamps, refreshMs = 1e3) {
+  const [now, setNow] = useState(() => Math.floor(Date.now() / 1e3));
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setNow(Math.floor(Date.now() / 1e3));
+    }, refreshMs);
+    return () => clearInterval(interval);
+  }, [refreshMs]);
+  return computeStatus(timestamps, now);
+}
+function useScoreTable({
+  participants,
+  pageSize = 10,
+  sortField = "rank",
+  sortDirection = "asc"
+}) {
+  const [sort, setSortState] = useState({ field: sortField, direction: sortDirection });
+  const [search, setSearchRaw] = useState("");
+  const debouncedSearch = useDebounce(search, 300);
+  const filtered = useMemo(() => {
+    if (!debouncedSearch) return participants;
+    const lower = debouncedSearch.toLowerCase();
+    return participants.filter(
+      (p) => p.address.toLowerCase().includes(lower) || p.name && p.name.toLowerCase().includes(lower)
+    );
+  }, [participants, debouncedSearch]);
+  const sorted = useMemo(() => {
+    const arr = [...filtered];
+    const dir = sort.direction === "asc" ? 1 : -1;
+    arr.sort((a, b) => {
+      const aVal = a[sort.field] ?? 0;
+      const bVal = b[sort.field] ?? 0;
+      if (typeof aVal === "string" && typeof bVal === "string") {
+        return dir * aVal.localeCompare(bVal);
+      }
+      return dir * (Number(aVal) - Number(bVal));
+    });
+    return arr;
+  }, [filtered, sort]);
+  const pagination = usePagination({
+    totalItems: sorted.length,
+    pageSize
+  });
+  const rows = useMemo(
+    () => sorted.slice(pagination.startIndex, pagination.endIndex),
+    [sorted, pagination.startIndex, pagination.endIndex]
+  );
+  const setSort = useCallback(
+    (field) => {
+      const validField = field;
+      setSortState((prev) => {
+        if (prev.field === validField) {
+          return {
+            field: validField,
+            direction: prev.direction === "asc" ? "desc" : "asc"
+          };
+        }
+        return { field: validField, direction: "asc" };
+      });
+    },
+    []
+  );
+  const setSearch = useCallback(
+    (q) => {
+      setSearchRaw(q);
+      pagination.reset();
+    },
+    [pagination]
+  );
+  return {
+    rows,
+    pagination,
+    sort,
+    setSort,
+    search,
+    setSearch
+  };
+}
+
+// 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
+    }))
+  }));
+}
+
+// src/react/usePrizeTable.ts
+function usePrizeTable({
+  prizes,
+  positionsPerPage = 5
+}) {
+  const grouped = useMemo(() => aggregatePrizesByPosition(prizes), [prizes]);
+  const pagination = usePagination({
+    totalItems: grouped.length,
+    pageSize: positionsPerPage
+  });
+  const rows = useMemo(
+    () => grouped.slice(pagination.startIndex, pagination.endIndex),
+    [grouped, pagination.startIndex, pagination.endIndex]
+  );
+  return {
+    rows,
+    totalPositions: grouped.length,
+    pagination
+  };
+}
+
+// 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/formatting.ts
+function calculateDistribution(positions, weight, creatorFee, gameFee, refundShare, distributionType = "exponential") {
+  if (positions <= 0) {
+    return [];
+  }
+  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/react/useEntryFeePreview.ts
+function useEntryFeePreview({
+  feePerEntry,
+  entryCount,
+  shares,
+  distributionPositions,
+  distributionType,
+  distributionWeight
+}) {
+  const breakdown = useMemo(
+    () => calculateEntryFeeBreakdown(feePerEntry, entryCount, shares),
+    [feePerEntry, entryCount, shares.creatorShare, shares.gameCreatorShare, shares.refundShare]
+  );
+  const percentages = useMemo(
+    () => distributionPositions > 0 ? calculateDistribution(
+      distributionPositions,
+      distributionWeight,
+      0,
+      0,
+      0,
+      distributionType
+    ) : [],
+    [distributionPositions, distributionWeight, distributionType]
+  );
+  const positionPrizes = useMemo(
+    () => distributePool(breakdown.prizePoolAmount, percentages),
+    [breakdown.prizePoolAmount, percentages]
+  );
+  return { breakdown, positionPrizes, percentages };
+}
+
+// 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
+  };
+}
+
+// src/react/useEntryQualification.ts
+function useEntryQualification(options) {
+  const {
+    variant,
+    ownedTokenIds = [],
+    tokenEntryCounts = {},
+    playerAddress,
+    extensionQualifications = [],
+    tournamentValidatorConfig,
+    extensionValidEntry = false,
+    extensionEntriesLeft = null,
+    entryLimit = 0
+  } = options;
+  return useMemo(() => {
+    if (variant === "none") {
+      return {
+        meetsRequirements: true,
+        bestProof: null,
+        qualifications: [],
+        totalEntriesLeft: Infinity,
+        entriesLeftBySource: [{ entriesLeft: Infinity }]
+      };
+    }
+    if (variant === "token") {
+      const result = evaluateTokenQualification({
+        ownedTokenIds,
+        usedEntryCounts: tokenEntryCounts,
+        entryLimit
+      });
+      return {
+        meetsRequirements: result.meetsRequirements,
+        bestProof: result.bestProof,
+        qualifications: result.qualifications,
+        totalEntriesLeft: result.totalEntriesLeft,
+        entriesLeftBySource: result.meetsRequirements ? [{ sourceType: "token", entriesLeft: result.totalEntriesLeft }] : []
+      };
+    }
+    if (variant === "extension") {
+      if (!playerAddress) {
+        return empty();
+      }
+      if (tournamentValidatorConfig && extensionQualifications.length > 0) {
+        const result = evaluateExtensionQualification({
+          checkedQualifications: extensionQualifications
+        });
+        const entriesBySource = /* @__PURE__ */ new Map();
+        for (const qual of extensionQualifications) {
+          if (qual.entriesLeft <= 0) continue;
+          const sourceId = qual.metadata?.tournamentId ?? qual.id;
+          const current = entriesBySource.get(sourceId) ?? 0;
+          entriesBySource.set(sourceId, current + qual.entriesLeft);
+        }
+        const qualifyingMode = tournamentValidatorConfig.qualifyingMode;
+        let meetsRequirements;
+        if (qualifyingMode === 0 || qualifyingMode === 1 || qualifyingMode === 3) {
+          meetsRequirements = result.meetsRequirements;
+        } else {
+          meetsRequirements = entriesBySource.size >= tournamentValidatorConfig.tournamentIds.length;
+        }
+        return {
+          meetsRequirements,
+          bestProof: result.bestProof,
+          qualifications: result.qualifications,
+          totalEntriesLeft: result.totalEntriesLeft,
+          entriesLeftBySource: Array.from(entriesBySource.entries()).map(
+            ([sourceId, entriesLeft]) => ({
+              sourceId,
+              sourceType: "tournament",
+              entriesLeft
+            })
+          )
+        };
+      }
+      const remaining = extensionEntriesLeft !== null ? extensionEntriesLeft : Infinity;
+      if (extensionValidEntry && remaining > 0) {
+        return {
+          meetsRequirements: true,
+          bestProof: { type: "extension", extensionProof: [] },
+          qualifications: [],
+          totalEntriesLeft: remaining,
+          entriesLeftBySource: [
+            { sourceType: "extension", entriesLeft: remaining }
+          ]
+        };
+      }
+      return empty();
+    }
+    return empty();
+  }, [
+    variant,
+    ownedTokenIds,
+    tokenEntryCounts,
+    playerAddress,
+    extensionQualifications,
+    tournamentValidatorConfig,
+    extensionValidEntry,
+    extensionEntriesLeft,
+    entryLimit
+  ]);
+}
+function empty() {
+  return {
+    meetsRequirements: false,
+    bestProof: null,
+    qualifications: [],
+    totalEntriesLeft: 0,
+    entriesLeftBySource: []
+  };
+}
+async function getExtensionEntriesLeft(provider, extensionAddress, contextId, playerAddress, qualification) {
+  try {
+    const result = await provider.callContract({
+      contractAddress: extensionAddress,
+      entrypoint: "entries_left",
+      calldata: CallData.compile([contextId, playerAddress, qualification])
+    });
+    if (result[0] === "0x1" || BigInt(result[0]) === 1n) {
+      return null;
+    }
+    return Number(result[1]);
+  } catch (error) {
+    console.error("Error checking extension entries_left:", error);
+    return null;
+  }
+}
+var OPUS_ABBOT_ADDRESS = "0x04d0bb0a4c40012384e7c419e6eb3c637b28e8363fb66958b60d90505b9c072f";
+var OPUS_SHRINE_ADDRESS = "0x0498edfaf50ca5855666a700c25dd629d577eb9afccdf3b5977aec79aee55ada";
+async function getUserTroveIds(provider, userAddress, abbotAddress = OPUS_ABBOT_ADDRESS) {
+  try {
+    const result = await provider.callContract({
+      contractAddress: abbotAddress,
+      entrypoint: "get_user_trove_ids",
+      calldata: CallData.compile([userAddress])
+    });
+    const arrayLength = Number(result[0] || 0);
+    const troveIds = [];
+    for (let i = 1; i <= arrayLength; i++) {
+      troveIds.push(BigInt(result[i] || 0));
+    }
+    return troveIds;
+  } catch (error) {
+    console.error("Error getting user trove IDs:", error);
+    return [];
+  }
+}
+async function getTroveDebt(provider, troveId, shrineAddress = OPUS_SHRINE_ADDRESS) {
+  try {
+    const result = await provider.callContract({
+      contractAddress: shrineAddress,
+      entrypoint: "get_trove_health",
+      calldata: CallData.compile([troveId])
+    });
+    return BigInt(result[3] || 0);
+  } catch (error) {
+    console.error("Error getting trove health:", error);
+    return null;
+  }
+}
+async function getUserTotalTroveDebt(provider, userAddress, abbotAddress, shrineAddress) {
+  const troveIds = await getUserTroveIds(provider, userAddress, abbotAddress);
+  if (troveIds.length === 0) return 0n;
+  let totalDebt = 0n;
+  for (const troveId of troveIds) {
+    const debt = await getTroveDebt(provider, troveId, shrineAddress);
+    if (debt !== null) totalDebt += debt;
+  }
+  return totalDebt;
+}
+
+// src/react/useExtensionQualification.ts
+var useExtensionQualification = (provider, extensionAddress, contextId, playerAddress, qualificationInputs, enabled = true) => {
+  const [qualifications, setQualifications] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const inputsKey = useMemo(() => {
+    if (!enabled || !provider || !extensionAddress || !contextId || !playerAddress) {
+      return "";
+    }
+    return JSON.stringify({
+      extensionAddress,
+      contextId,
+      playerAddress,
+      inputs: qualificationInputs.map((i) => ({
+        tid: i.tournamentId,
+        token: i.tokenId,
+        pos: i.position
+      }))
+    });
+  }, [enabled, provider, extensionAddress, contextId, playerAddress, qualificationInputs]);
+  const lastFetchedKey = useRef("");
+  useEffect(() => {
+    if (!enabled) {
+      lastFetchedKey.current = "";
+      setQualifications([]);
+      setLoading(false);
+      setError(null);
+    }
+  }, [enabled]);
+  useEffect(() => {
+    if (!inputsKey) return;
+    if (inputsKey === lastFetchedKey.current) return;
+    const checkQualifications = async () => {
+      lastFetchedKey.current = inputsKey;
+      setLoading(true);
+      setError(null);
+      try {
+        const results = await Promise.all(
+          qualificationInputs.map(async (input) => {
+            try {
+              const proof = [
+                input.tournamentId,
+                input.tokenId,
+                input.position.toString()
+              ];
+              const entriesLeft = await getExtensionEntriesLeft(
+                provider,
+                extensionAddress,
+                contextId,
+                playerAddress,
+                proof
+              );
+              if (entriesLeft !== null && entriesLeft > 0) {
+                return {
+                  id: `${input.tournamentId}-${input.tokenId}-${input.position}`,
+                  proof,
+                  entriesLeft,
+                  label: input.tournamentName,
+                  metadata: {
+                    tournamentId: input.tournamentId,
+                    tournamentName: input.tournamentName,
+                    tokenId: input.tokenId,
+                    position: input.position
+                  }
+                };
+              }
+              return null;
+            } catch (err) {
+              console.error(
+                `Error checking qualification for ${input.tournamentId}:`,
+                err
+              );
+              return null;
+            }
+          })
+        );
+        const validQualifications = results.filter(
+          (q) => q !== null
+        );
+        setQualifications(validQualifications);
+      } catch (err) {
+        console.error("Error checking extension qualifications:", err);
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setQualifications([]);
+      } finally {
+        setLoading(false);
+      }
+    };
+    checkQualifications();
+  }, [inputsKey, provider, extensionAddress, contextId, playerAddress, qualificationInputs]);
+  const totalEntriesLeft = qualifications.reduce(
+    (sum, q) => sum + q.entriesLeft,
+    0
+  );
+  const bestQualification = qualifications.length > 0 ? qualifications.reduce(
+    (best, current) => current.entriesLeft > best.entriesLeft ? current : best
+  ) : null;
+  return {
+    qualifications,
+    totalEntriesLeft,
+    bestQualification,
+    loading,
+    error
+  };
+};
+
+// 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/react/useOpusTrovesBannableEntries.ts
+var useOpusTrovesBannableEntries = (provider, games, config, enabled) => {
+  const [troveDebts, setTroveDebts] = useState(/* @__PURE__ */ new Map());
+  const [isLoading, setIsLoading] = useState(false);
+  const playerGroups = useMemo(() => {
+    const groups = /* @__PURE__ */ new Map();
+    games.forEach((game) => {
+      const owner = game?.owner;
+      if (!owner) return;
+      if (!groups.has(owner)) groups.set(owner, []);
+      groups.get(owner).push(game);
+    });
+    return groups;
+  }, [games]);
+  const playerAddresses = useMemo(
+    () => Array.from(playerGroups.keys()),
+    [playerGroups]
+  );
+  useEffect(() => {
+    if (!enabled || !provider || !config || playerAddresses.length === 0) {
+      setTroveDebts(/* @__PURE__ */ new Map());
+      return;
+    }
+    let cancelled = false;
+    setIsLoading(true);
+    const fetchDebts = async () => {
+      const debts = /* @__PURE__ */ new Map();
+      await Promise.all(
+        playerAddresses.map(async (addr) => {
+          try {
+            const debt = await getUserTotalTroveDebt(provider, addr);
+            debts.set(addr, debt);
+          } catch {
+            debts.set(addr, 0n);
+          }
+        })
+      );
+      if (!cancelled) {
+        setTroveDebts(debts);
+        setIsLoading(false);
+      }
+    };
+    fetchDebts();
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, provider, config, playerAddresses]);
+  const bannableEntries = useMemo(() => {
+    if (!enabled || isLoading || !config) return /* @__PURE__ */ new Set();
+    const players = /* @__PURE__ */ new Map();
+    for (const [owner, ownerGames] of playerGroups.entries()) {
+      players.set(owner, {
+        debt: troveDebts.get(owner) ?? 0n,
+        registeredTokenIds: ownerGames.map((g) => g.tokenId.toString())
+      });
+    }
+    return findAllBannableEntries(players, config);
+  }, [enabled, isLoading, playerGroups, troveDebts, config]);
+  return {
+    bannableEntries,
+    troveDebts,
+    isLoading,
+    playerGroups
+  };
+};
+
+export { useDebounce, useEntryFeePreview, useEntryQualification, useExtensionQualification, useOpusTrovesBannableEntries, usePagination, usePrizeTable, useScoreTable, useSearchFilter, useStatusIndicator, useTokenSelector };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map