@provable-games/budokan-sdk 0.1.21 → 0.1.23

package/dist/react.d.cts

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
-import { i as BudokanClientConfig, B as BudokanClient, T as Tournament, b as PaginatedResult, e as TournamentListParams, m as Phase, l as LeaderboardEntry, R as Registration, c as RewardClaim, d as RewardClaimSummary, g as PrizeStats, a as Prize, P as PrizeAggregation, Q as QualificationEntry, f as PlatformStats, o as WSEventMessage, n as WSChannel, C as ConnectionMode } from './client-0HDPKrdw.cjs';
+import { i as BudokanClientConfig, B as BudokanClient, T as Tournament, b as PaginatedResult, e as TournamentListParams, m as Phase, l as LeaderboardEntry, R as Registration, c as RewardClaim, d as RewardClaimSummary, g as PrizeStats, a as Prize, P as PrizeAggregation, Q as QualificationEntry, f as PlatformStats, o as PlayerRewards, q as WSEventMessage, p as WSChannel, C as ConnectionMode } from './player-BUynfv7D.cjs';
 import 'starknet';
 import '@provable-games/metagame-sdk';
 
@@ -200,6 +200,49 @@ interface UseActivityStatsResult {
  */
 declare function useActivityStats(): UseActivityStatsResult;
 
+interface UsePlayerRewardsResult {
+    rewards: PlayerRewards | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Aggregate a player's placement/earnings data across finalized Budokan
+ * tournaments they currently hold tokens in.
+ *
+ * Composition:
+ *
+ *   denshokan useTokens (current ownership)
+ *     ↓ group by contextId (= tournament id)
+ *   budokan useTournaments({ tournamentIds })
+ *     ↓ filter to finalized
+ *   for each finalized tournament (parallel):
+ *     budokan getTournamentPrizes        — full prize records
+ *     budokan getTournamentRewardClaims  — paginated, all pages
+ *     denshokan getTokenRanks (bulk)     — final ranks for owned tokens
+ *     ↓ filter ranks to paid positions  (max position derived from prizes
+ *       + entry-fee distribution_count)
+ *
+ * Per-tournament failures are tolerated: a 5xx on one tournament's prize/
+ * claim/rank fetch skips that tournament and continues, rather than
+ * failing the whole hook. Failures are logged via `console.warn`.
+ *
+ * Why source ownership from denshokan: PR #243 dropped
+ * `registrations.player_address` because the indexed value goes stale on
+ * transfer. The contract keys registrations by token_id only, so the only
+ * trustworthy answer to "what tournaments has this wallet placed in" is
+ * to ask denshokan who currently holds Budokan-minted tokens.
+ *
+ * Staleness: the hook only re-fetches when the player's owned token set
+ * changes (transfers/new mints) or when the underlying tournament list
+ * changes. It does *not* observe time-based finalization transitions on
+ * its own — if a tournament's submission window closes while the
+ * consumer is mounted, call `refetch()` to pick up the new placement.
+ *
+ * Pass `undefined` to skip fetching.
+ */
+declare function usePlayerRewards(address: string | undefined): UsePlayerRewardsResult;
+
 interface UseSubscriptionResult {
     lastMessage: WSEventMessage | null;
     isConnected: boolean;
@@ -223,4 +266,4 @@ declare function useConnectionStatus(): {
     datasourceMode: ConnectionMode;
 };
 
-export { BudokanProvider, type BudokanProviderProps, type UseActivityStatsResult, type UseLeaderboardResult, type UsePrizeAggregationResult, type UsePrizeStatsResult, type UsePrizesResult, type UseQualificationsResult, type UseRegistrationsResult, type UseRewardClaimsResult, type UseRewardClaimsSummaryResult, type UseSubscriptionResult, type UseTournamentCountResult, type UseTournamentResult, type UseTournamentsResult, useActivityStats, useBudokanClient, useConnectionStatus, useLeaderboard, usePrizeAggregation, usePrizeStats, usePrizes, useQualifications, useRegistrations, useRegistrationsByOwner, useRewardClaims, useRewardClaimsSummary, useSubscription, useTournament, useTournamentCount, useTournaments, useTournamentsByOwner, useTournamentsByOwnerCount };
+export { BudokanProvider, type BudokanProviderProps, type UseActivityStatsResult, type UseLeaderboardResult, type UsePlayerRewardsResult, type UsePrizeAggregationResult, type UsePrizeStatsResult, type UsePrizesResult, type UseQualificationsResult, type UseRegistrationsResult, type UseRewardClaimsResult, type UseRewardClaimsSummaryResult, type UseSubscriptionResult, type UseTournamentCountResult, type UseTournamentResult, type UseTournamentsResult, useActivityStats, useBudokanClient, useConnectionStatus, useLeaderboard, usePlayerRewards, usePrizeAggregation, usePrizeStats, usePrizes, useQualifications, useRegistrations, useRegistrationsByOwner, useRewardClaims, useRewardClaimsSummary, useSubscription, useTournament, useTournamentCount, useTournaments, useTournamentsByOwner, useTournamentsByOwnerCount };

package/dist/react.d.ts

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
-import { i as BudokanClientConfig, B as BudokanClient, T as Tournament, b as PaginatedResult, e as TournamentListParams, m as Phase, l as LeaderboardEntry, R as Registration, c as RewardClaim, d as RewardClaimSummary, g as PrizeStats, a as Prize, P as PrizeAggregation, Q as QualificationEntry, f as PlatformStats, o as WSEventMessage, n as WSChannel, C as ConnectionMode } from './client-0HDPKrdw.js';
+import { i as BudokanClientConfig, B as BudokanClient, T as Tournament, b as PaginatedResult, e as TournamentListParams, m as Phase, l as LeaderboardEntry, R as Registration, c as RewardClaim, d as RewardClaimSummary, g as PrizeStats, a as Prize, P as PrizeAggregation, Q as QualificationEntry, f as PlatformStats, o as PlayerRewards, q as WSEventMessage, p as WSChannel, C as ConnectionMode } from './player-BUynfv7D.js';
 import 'starknet';
 import '@provable-games/metagame-sdk';
 
@@ -200,6 +200,49 @@ interface UseActivityStatsResult {
  */
 declare function useActivityStats(): UseActivityStatsResult;
 
+interface UsePlayerRewardsResult {
+    rewards: PlayerRewards | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Aggregate a player's placement/earnings data across finalized Budokan
+ * tournaments they currently hold tokens in.
+ *
+ * Composition:
+ *
+ *   denshokan useTokens (current ownership)
+ *     ↓ group by contextId (= tournament id)
+ *   budokan useTournaments({ tournamentIds })
+ *     ↓ filter to finalized
+ *   for each finalized tournament (parallel):
+ *     budokan getTournamentPrizes        — full prize records
+ *     budokan getTournamentRewardClaims  — paginated, all pages
+ *     denshokan getTokenRanks (bulk)     — final ranks for owned tokens
+ *     ↓ filter ranks to paid positions  (max position derived from prizes
+ *       + entry-fee distribution_count)
+ *
+ * Per-tournament failures are tolerated: a 5xx on one tournament's prize/
+ * claim/rank fetch skips that tournament and continues, rather than
+ * failing the whole hook. Failures are logged via `console.warn`.
+ *
+ * Why source ownership from denshokan: PR #243 dropped
+ * `registrations.player_address` because the indexed value goes stale on
+ * transfer. The contract keys registrations by token_id only, so the only
+ * trustworthy answer to "what tournaments has this wallet placed in" is
+ * to ask denshokan who currently holds Budokan-minted tokens.
+ *
+ * Staleness: the hook only re-fetches when the player's owned token set
+ * changes (transfers/new mints) or when the underlying tournament list
+ * changes. It does *not* observe time-based finalization transitions on
+ * its own — if a tournament's submission window closes while the
+ * consumer is mounted, call `refetch()` to pick up the new placement.
+ *
+ * Pass `undefined` to skip fetching.
+ */
+declare function usePlayerRewards(address: string | undefined): UsePlayerRewardsResult;
+
 interface UseSubscriptionResult {
     lastMessage: WSEventMessage | null;
     isConnected: boolean;
@@ -223,4 +266,4 @@ declare function useConnectionStatus(): {
     datasourceMode: ConnectionMode;
 };
 
-export { BudokanProvider, type BudokanProviderProps, type UseActivityStatsResult, type UseLeaderboardResult, type UsePrizeAggregationResult, type UsePrizeStatsResult, type UsePrizesResult, type UseQualificationsResult, type UseRegistrationsResult, type UseRewardClaimsResult, type UseRewardClaimsSummaryResult, type UseSubscriptionResult, type UseTournamentCountResult, type UseTournamentResult, type UseTournamentsResult, useActivityStats, useBudokanClient, useConnectionStatus, useLeaderboard, usePrizeAggregation, usePrizeStats, usePrizes, useQualifications, useRegistrations, useRegistrationsByOwner, useRewardClaims, useRewardClaimsSummary, useSubscription, useTournament, useTournamentCount, useTournaments, useTournamentsByOwner, useTournamentsByOwnerCount };
+export { BudokanProvider, type BudokanProviderProps, type UseActivityStatsResult, type UseLeaderboardResult, type UsePlayerRewardsResult, type UsePrizeAggregationResult, type UsePrizeStatsResult, type UsePrizesResult, type UseQualificationsResult, type UseRegistrationsResult, type UseRewardClaimsResult, type UseRewardClaimsSummaryResult, type UseSubscriptionResult, type UseTournamentCountResult, type UseTournamentResult, type UseTournamentsResult, useActivityStats, useBudokanClient, useConnectionStatus, useLeaderboard, usePlayerRewards, usePrizeAggregation, usePrizeStats, usePrizes, useQualifications, useRegistrations, useRegistrationsByOwner, useRewardClaims, useRewardClaimsSummary, useSubscription, useTournament, useTournamentCount, useTournaments, useTournamentsByOwner, useTournamentsByOwnerCount };

package/dist/react.js

@@ -1,7 +1,7 @@
 import { createContext, useMemo, useRef, useEffect, useContext, useState, useCallback } from 'react';
 import { num, CairoCustomEnum } from 'starknet';
 import { jsx } from 'react/jsx-runtime';
-import { useTokens } from '@provable-games/denshokan-sdk/react';
+import { useTokens, useDenshokanClient } from '@provable-games/denshokan-sdk/react';
 
 // src/react/context.tsx
 
@@ -1112,6 +1112,84 @@ async function viewerPrizes(contract, tournamentId) {
     return result.map(parsePrize);
   }, contract.address);
 }
+function translateCairoRewardType(rewardType) {
+  if (!rewardType || typeof rewardType !== "object") {
+    throw new Error(`Unexpected RewardType payload: ${JSON.stringify(rewardType)}`);
+  }
+  const rt = rewardType;
+  const outer = typeof rt.activeVariant === "function" ? rt.activeVariant() : null;
+  const innerBag = typeof rt.activeVariant === "function" ? rt.variant : rt;
+  if (outer === "Prize" || innerBag.Prize !== void 0) {
+    const prize = innerBag.Prize;
+    const subVariant = typeof prize?.activeVariant === "function" ? prize.activeVariant() : null;
+    const subBag = typeof prize?.activeVariant === "function" ? prize.variant : prize;
+    if (subVariant === "Single" || subBag?.Single !== void 0) {
+      return {
+        claimKind: "prize_single",
+        prizeId: BigInt(subBag.Single).toString(),
+        payoutIndex: null,
+        position: null,
+        refundTokenId: null
+      };
+    }
+    if (subVariant === "Distributed" || subBag?.Distributed !== void 0) {
+      const distributed = subBag.Distributed;
+      const prizeId = distributed?.["0"] ?? distributed?.[0];
+      const payoutIndex = distributed?.["1"] ?? distributed?.[1];
+      return {
+        claimKind: "prize_distributed",
+        prizeId: BigInt(prizeId).toString(),
+        payoutIndex: Number(payoutIndex),
+        position: null,
+        refundTokenId: null
+      };
+    }
+  }
+  if (outer === "EntryFee" || innerBag.EntryFee !== void 0) {
+    const entryFee = innerBag.EntryFee;
+    const subVariant = typeof entryFee?.activeVariant === "function" ? entryFee.activeVariant() : null;
+    const subBag = typeof entryFee?.activeVariant === "function" ? entryFee.variant : entryFee;
+    if (subVariant === "Position" || subBag?.Position !== void 0) {
+      return {
+        claimKind: "entry_fee_position",
+        prizeId: null,
+        payoutIndex: null,
+        position: Number(subBag.Position),
+        refundTokenId: null
+      };
+    }
+    if (subVariant === "TournamentCreator" || subBag?.TournamentCreator !== void 0) {
+      return {
+        claimKind: "entry_fee_tournament_creator",
+        prizeId: null,
+        payoutIndex: null,
+        position: null,
+        refundTokenId: null
+      };
+    }
+    if (subVariant === "GameCreator" || subBag?.GameCreator !== void 0) {
+      return {
+        claimKind: "entry_fee_game_creator",
+        prizeId: null,
+        payoutIndex: null,
+        position: null,
+        refundTokenId: null
+      };
+    }
+    if (subVariant === "Refund" || subBag?.Refund !== void 0) {
+      return {
+        claimKind: "entry_fee_refund",
+        prizeId: null,
+        payoutIndex: null,
+        position: null,
+        refundTokenId: `0x${BigInt(subBag.Refund).toString(16)}`
+      };
+    }
+  }
+  throw new Error(
+    `Unrecognised on-chain RewardType variant: ${JSON.stringify(rewardType)}`
+  );
+}
 async function viewerRewardClaims(contract, tournamentId, offset, limit) {
   return wrapRpcCall(async () => {
     const result = await contract.call("tournament_reward_claims", [tournamentId, offset, limit]);
@@ -1119,7 +1197,7 @@ async function viewerRewardClaims(contract, tournamentId, offset, limit) {
     const claims = obj.claims?.map((raw) => {
       const claim = raw;
       return {
-        rewardType: claim.reward_type,
+        ...translateCairoRewardType(claim.reward_type),
         claimed: Boolean(claim.claimed)
       };
     }) ?? [];
@@ -4516,8 +4594,7 @@ var BudokanClient = class {
       const result = await viewerRewardClaims(contract, tournamentId, offset, limit);
       const data = result.claims.map((c) => ({
         tournamentId,
-        rewardType: c.rewardType,
-        claimed: c.claimed
+        ...c
       }));
       return { data, total: result.total, limit, offset };
     };
@@ -4792,7 +4869,6 @@ function useOwnedTournamentIds(owner, contextId) {
     enabled ? {
       owner,
       minterAddress: budokanAddress,
-      hasContext: true,
       ...{},
       limit: MAX_OWNED_TOKENS
     } : void 0
@@ -4908,7 +4984,11 @@ function useRegistrationsByOwner(tournamentId, owner, params) {
   }, [enabled, tokensResult]);
   const inner = useRegistrations(
     ownedGameTokenIds && ownedGameTokenIds.length > 0 ? tournamentId : void 0,
-    ownedGameTokenIds && ownedGameTokenIds.length > 0 ? { ...params, gameTokenIds: ownedGameTokenIds } : void 0
+    ownedGameTokenIds && ownedGameTokenIds.length > 0 ? {
+      limit: Math.min(ownedGameTokenIds.length, MAX_OWNED_TOKENS),
+      ...params,
+      gameTokenIds: ownedGameTokenIds
+    } : void 0
   );
   if (ownedGameTokenIds !== null && ownedGameTokenIds.length === 0) {
     return {
@@ -5097,6 +5177,200 @@ function useActivityStats() {
   }, [fetch2]);
   return { stats, loading, error, refetch: fetch2 };
 }
+function usePlayerRewards(address) {
+  const budokan = useBudokanClient();
+  const denshokan = useDenshokanClient();
+  const budokanAddress = budokan.clientConfig.budokanAddress;
+  const [rewards, setRewards] = useState(null);
+  const [aggregating, setAggregating] = useState(false);
+  const [error, setError] = useState(null);
+  useResetOnClient(budokan, setRewards, setError);
+  const tokensEnabled = !!address && !!budokanAddress;
+  const { data: tokensResult, isLoading: tokensLoading } = useTokens(
+    tokensEnabled ? {
+      owner: address,
+      minterAddress: budokanAddress,
+      limit: 1e3
+    } : void 0
+  );
+  const tokensByTournament = useMemo(() => {
+    if (!tokensResult?.data) return null;
+    const map = /* @__PURE__ */ new Map();
+    for (const t of tokensResult.data) {
+      if (t.contextId == null || !t.tokenId) continue;
+      const tid = String(t.contextId);
+      let list = map.get(tid);
+      if (!list) {
+        list = [];
+        map.set(tid, list);
+      }
+      list.push(t.tokenId);
+    }
+    return map;
+  }, [tokensResult]);
+  const tournamentIds = useMemo(
+    () => tokensByTournament ? Array.from(tokensByTournament.keys()) : [],
+    [tokensByTournament]
+  );
+  const { tournaments: tournamentsPage, loading: tournamentsLoading } = useTournaments(
+    tournamentIds.length > 0 ? { tournamentIds, limit: 1e3 } : void 0
+  );
+  const tournamentIdsKey = tournamentIds.join(",");
+  const fetch2 = useCallback(async () => {
+    if (!tokensEnabled) {
+      setRewards(null);
+      return;
+    }
+    if (!tokensByTournament) return;
+    if (tokensByTournament.size === 0) {
+      setRewards(emptyRewards());
+      return;
+    }
+    if (!tournamentsPage?.data) return;
+    const now = Math.floor(Date.now() / 1e3);
+    const finalized = tournamentsPage.data.filter((t) => {
+      const sub = Number(t.submissionEndTime ?? 0);
+      return sub > 0 && sub <= now;
+    });
+    if (finalized.length === 0) {
+      setRewards(emptyRewards());
+      return;
+    }
+    setAggregating(true);
+    setError(null);
+    try {
+      const settled = await Promise.allSettled(
+        finalized.map(async (t) => {
+          const tid = t.id;
+          const tokenIds = tokensByTournament.get(tid) ?? [];
+          if (tokenIds.length === 0) return null;
+          const [prizes, allClaims, ranksResult] = await Promise.all([
+            budokan.getTournamentPrizes(tid),
+            fetchAllRewardClaims(budokan, tid),
+            denshokan.getTokenRanks(tokenIds, {
+              contextId: Number(tid),
+              minterAddress: budokanAddress
+            })
+          ]);
+          let maxPaid = 0;
+          for (const p of prizes) {
+            if ((p.payoutPosition ?? 0) > 0) {
+              maxPaid = Math.max(maxPaid, p.payoutPosition);
+            }
+            if ((p.distributionCount ?? 0) > 0) {
+              maxPaid = Math.max(maxPaid, p.distributionCount);
+            }
+          }
+          const efDistCount = Number(t.entryFee?.distributionCount ?? 0);
+          if (efDistCount > 0) maxPaid = Math.max(maxPaid, efDistCount);
+          if (maxPaid === 0) return null;
+          const placements = ranksResult.data.filter((r) => r.rank > 0 && r.rank <= maxPaid).map((r) => ({
+            tournamentId: tid,
+            tokenId: r.tokenId,
+            position: r.rank,
+            score: String(r.score ?? "0")
+          }));
+          if (placements.length === 0) return null;
+          return {
+            tournament: t,
+            prizes,
+            rewardClaims: allClaims,
+            placements
+          };
+        })
+      );
+      const valid = settled.map((s, i) => {
+        if (s.status === "fulfilled") return s.value;
+        console.warn(
+          `usePlayerRewards: tournament ${finalized[i].id} fetch failed; skipping`,
+          s.reason
+        );
+        return null;
+      }).filter((r) => r !== null);
+      const allPlacements = valid.flatMap(
+        (r) => r.placements
+      );
+      const wins = allPlacements.length;
+      const bestPlacement = wins > 0 ? Math.min(...allPlacements.map((p) => p.position)) : null;
+      const tournamentsList = valid.map((r) => r.tournament);
+      const prizesList = valid.flatMap((r) => r.prizes);
+      const rewardClaimsList = valid.flatMap(
+        (r) => r.rewardClaims
+      );
+      setRewards({
+        wins,
+        bestPlacement,
+        placements: allPlacements,
+        tournaments: tournamentsList,
+        prizes: prizesList,
+        rewardClaims: rewardClaimsList
+      });
+    } catch (e) {
+      setError(e);
+    } finally {
+      setAggregating(false);
+    }
+  }, [
+    tokensEnabled,
+    tokensByTournament,
+    tournamentsPage,
+    tournamentIdsKey,
+    budokan,
+    denshokan,
+    budokanAddress
+  ]);
+  const lastRunRef = useRef("");
+  useEffect(() => {
+    if (!tokensEnabled) {
+      setRewards(null);
+      return;
+    }
+    if (!tokensByTournament || !tournamentsPage?.data) return;
+    const fingerprint = `${address}|${tournamentIdsKey}|${tournamentsPage.data.length}`;
+    if (fingerprint === lastRunRef.current) return;
+    lastRunRef.current = fingerprint;
+    fetch2();
+  }, [
+    address,
+    tokensEnabled,
+    tokensByTournament,
+    tournamentsPage,
+    tournamentIdsKey,
+    fetch2
+  ]);
+  const loading = tokensEnabled && (tokensLoading || tournamentsLoading) || aggregating;
+  return { rewards, loading, error, refetch: fetch2 };
+}
+function emptyRewards() {
+  return {
+    wins: 0,
+    bestPlacement: null,
+    placements: [],
+    tournaments: [],
+    prizes: [],
+    rewardClaims: []
+  };
+}
+async function fetchAllRewardClaims(client, tournamentId) {
+  const first = await client.getTournamentRewardClaims(tournamentId, {
+    limit: 100
+  });
+  const accumulated = [...first.data];
+  const total = first.total ?? accumulated.length;
+  if (accumulated.length >= total) return accumulated;
+  const pageSize = Math.max(first.data.length, 1);
+  let offset = accumulated.length;
+  while (offset < total) {
+    const next = await client.getTournamentRewardClaims(tournamentId, {
+      limit: pageSize,
+      offset
+    });
+    if (next.data.length === 0) break;
+    accumulated.push(...next.data);
+    offset += next.data.length;
+  }
+  return accumulated;
+}
 function useSubscription(channels, tournamentIds) {
   const client = useBudokanClient();
   const [lastMessage, setLastMessage] = useState(null);
@@ -5142,6 +5416,6 @@ function useConnectionStatus() {
   return { isConnected, datasourceMode };
 }
 
-export { BudokanProvider, useActivityStats, useBudokanClient, useConnectionStatus, useLeaderboard, usePrizeAggregation, usePrizeStats, usePrizes, useQualifications, useRegistrations, useRegistrationsByOwner, useRewardClaims, useRewardClaimsSummary, useSubscription, useTournament, useTournamentCount, useTournaments, useTournamentsByOwner, useTournamentsByOwnerCount };
+export { BudokanProvider, useActivityStats, useBudokanClient, useConnectionStatus, useLeaderboard, usePlayerRewards, usePrizeAggregation, usePrizeStats, usePrizes, useQualifications, useRegistrations, useRegistrationsByOwner, useRewardClaims, useRewardClaimsSummary, useSubscription, useTournament, useTournamentCount, useTournaments, useTournamentsByOwner, useTournamentsByOwnerCount };
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map