@provable-games/budokan-sdk 0.1.19 → 0.1.21

package/dist/react.cjs

@@ -3,6 +3,7 @@
 var react = require('react');
 var starknet = require('starknet');
 var jsxRuntime = require('react/jsx-runtime');
+var react$1 = require('@provable-games/denshokan-sdk/react');
 
 // src/react/context.tsx
 
@@ -243,7 +244,6 @@ async function getTournament(baseUrl, tournamentId, ctx) {
 }
 async function getTournamentRegistrations(baseUrl, tournamentId, params, ctx) {
   const qs = buildQueryString({
-    player_address: params?.playerAddress,
     game_token_ids: params?.gameTokenIds?.length ? params.gameTokenIds.join(",") : void 0,
     has_submitted: params?.hasSubmitted,
     is_banned: params?.isBanned,
@@ -316,42 +316,8 @@ function normalizeAddress(address) {
   return ("0x" + stripped.padStart(64, "0")).toLowerCase();
 }
 
-// src/api/players.ts
-function fetchOpts2(ctx) {
-  return {
-    retryAttempts: ctx?.retryAttempts,
-    retryDelay: ctx?.retryDelay,
-    timeout: ctx?.timeout
-  };
-}
-async function getPlayerTournaments(baseUrl, address, params, ctx) {
-  const normalized = normalizeAddress(address);
-  const qs = buildQueryString({
-    limit: params?.limit,
-    offset: params?.offset,
-    phase: params?.phase,
-    game_token_ids: params?.gameTokenIds?.join(",")
-  });
-  const result = await apiFetch(`${baseUrl}/players/${normalized}/tournaments${qs}`, fetchOpts2(ctx));
-  const { total, limit: resLimit, offset: resOffset } = extractPagination(result, { limit: params?.limit, offset: params?.offset });
-  return {
-    data: result.data.map((item) => snakeToCamel(item)),
-    total,
-    limit: resLimit,
-    offset: resOffset
-  };
-}
-async function getPlayerStats(baseUrl, address, ctx) {
-  const normalized = normalizeAddress(address);
-  const result = await apiFetch(
-    `${baseUrl}/players/${normalized}/stats`,
-    fetchOpts2(ctx)
-  );
-  return snakeToCamel(result.data);
-}
-
 // src/api/games.ts
-function fetchOpts3(ctx) {
+function fetchOpts2(ctx) {
   return {
     retryAttempts: ctx?.retryAttempts,
     retryDelay: ctx?.retryDelay,
@@ -366,7 +332,7 @@ async function getGameTournaments(baseUrl, gameAddress, params, ctx) {
     limit: params?.limit,
     offset: params?.offset
   });
-  const result = await apiFetch(`${baseUrl}/games/${normalized}/tournaments${qs}`, fetchOpts3(ctx));
+  const result = await apiFetch(`${baseUrl}/games/${normalized}/tournaments${qs}`, fetchOpts2(ctx));
   const { total, limit: resLimit, offset: resOffset } = extractPagination(result, { limit: params?.limit, offset: params?.offset });
   return {
     data: result.data.map((item) => snakeToCamel(item)),
@@ -379,47 +345,30 @@ async function getGameStats(baseUrl, gameAddress, ctx) {
   const normalized = normalizeAddress(gameAddress);
   const result = await apiFetch(
     `${baseUrl}/games/${normalized}/stats`,
-    fetchOpts3(ctx)
+    fetchOpts2(ctx)
   );
   return snakeToCamel(result.data);
 }
 
 // src/api/activity.ts
-function fetchOpts4(ctx) {
+function fetchOpts3(ctx) {
   return {
     retryAttempts: ctx?.retryAttempts,
     retryDelay: ctx?.retryDelay,
     timeout: ctx?.timeout
   };
 }
-async function getActivity(baseUrl, params, ctx) {
-  const qs = buildQueryString({
-    event_type: params?.eventType,
-    tournament_id: params?.tournamentId,
-    player_address: params?.playerAddress,
-    limit: params?.limit,
-    offset: params?.offset
-  });
-  const result = await apiFetch(`${baseUrl}/activity${qs}`, fetchOpts4(ctx));
-  const { total, limit: resLimit, offset: resOffset } = extractPagination(result, { limit: params?.limit, offset: params?.offset });
-  return {
-    data: result.data.map((item) => snakeToCamel(item)),
-    total,
-    limit: resLimit,
-    offset: resOffset
-  };
-}
 async function getActivityStats(baseUrl, ctx) {
   const result = await apiFetch(
     `${baseUrl}/activity/stats`,
-    fetchOpts4(ctx)
+    fetchOpts3(ctx)
   );
   return snakeToCamel(result.data);
 }
 async function getPrizeStats(baseUrl, ctx) {
   const result = await apiFetch(
     `${baseUrl}/activity/prize-stats`,
-    fetchOpts4(ctx)
+    fetchOpts3(ctx)
   );
   return snakeToCamel(result.data);
 }
@@ -981,8 +930,6 @@ function parseRegistration(raw, tournamentId) {
     gameTokenId: starknet.num.toHex(obj.game_token_id),
     gameAddress: "",
     // Not in on-chain struct
-    playerAddress: "",
-    // Not in on-chain struct
     entryNumber: Number(obj.entry_id ?? 0),
     hasSubmitted: Boolean(obj.has_submitted),
     isBanned: Boolean(obj.is_banned)
@@ -1141,20 +1088,6 @@ async function viewerRegistrations(contract, tournamentId, offset, limit) {
     };
   }, contract.address);
 }
-async function viewerRegistrationsByOwner(contract, tournamentId, owner, offset, limit) {
-  return wrapRpcCall(async () => {
-    const result = await contract.call("tournament_registrations_by_owner", [tournamentId, owner, offset, limit]);
-    const obj = result;
-    const entries = obj.entries ?? [];
-    const total = Number(obj.total ?? 0);
-    return {
-      data: entries.map((e) => parseRegistration(e, tournamentId)),
-      total,
-      limit,
-      offset
-    };
-  }, contract.address);
-}
 async function viewerRegistrationsByTokenIds(contract, tournamentId, tokenIds, offset, limit) {
   return wrapRpcCall(async () => {
     const result = await contract.call("tournament_registrations_by_token_ids", [tournamentId, tokenIds, offset, limit]);
@@ -1200,12 +1133,6 @@ async function viewerRewardClaims(contract, tournamentId, offset, limit) {
     };
   }, contract.address);
 }
-async function viewerPlayerTournaments(contract, playerAddress, offset, limit) {
-  return wrapRpcCall(async () => {
-    const result = await contract.call("player_tournaments", [playerAddress, offset, limit]);
-    return parseFilterResult(result);
-  }, contract.address);
-}
 
 // src/rpc/abis/budokanViewer.json
 var budokanViewer_default = [
@@ -4513,9 +4440,6 @@ var BudokanClient = class {
       const contract = await this.getViewerContract();
       const offset = params?.offset ?? 0;
       const limit = params?.limit ?? 20;
-      if (params?.playerAddress) {
-        return viewerRegistrationsByOwner(contract, tournamentId, params.playerAddress, offset, limit);
-      }
       if (params?.gameTokenIds?.length) {
         return viewerRegistrationsByTokenIds(contract, tournamentId, params.gameTokenIds, offset, limit);
       }
@@ -4548,43 +4472,6 @@ var BudokanClient = class {
       this.connectionStatus
     );
   }
-  // ---- Player Queries (API-only, no on-chain equivalent) ----
-  /**
-   * Fetch tournaments that a player has registered for.
-   * Supports RPC fallback via viewer contract.
-   */
-  async getPlayerTournaments(address, params) {
-    const rpcFallback = async () => {
-      const contract = await this.getViewerContract();
-      const offset = params?.offset ?? 0;
-      const limit = params?.limit ?? 20;
-      const filterResult = await viewerPlayerTournaments(contract, address, offset, limit);
-      let data = [];
-      if (filterResult.tournamentIds.length > 0) {
-        const tournaments = await viewerTournamentsBatch(contract, filterResult.tournamentIds);
-        data = tournaments.map((t) => ({
-          ...t,
-          tournamentId: t.id
-        }));
-      }
-      return { data, total: filterResult.total, limit, offset };
-    };
-    if (this.resolvedConfig.primarySource === "rpc") {
-      return rpcFallback();
-    }
-    return withFallback(
-      () => getPlayerTournaments(this.resolvedConfig.apiBaseUrl, address, params, this.apiCtx),
-      rpcFallback,
-      this.connectionStatus
-    );
-  }
-  /**
-   * Fetch stats for a player.
-   * API-only — no RPC fallback available.
-   */
-  async getPlayerStats(address) {
-    return getPlayerStats(this.resolvedConfig.apiBaseUrl, address, this.apiCtx);
-  }
   // ---- Game Queries ----
   /**
    * Fetch tournaments for a specific game.
@@ -4683,13 +4570,6 @@ var BudokanClient = class {
     return getTournamentPrizeAggregation(this.resolvedConfig.apiBaseUrl, tournamentId, this.apiCtx);
   }
   // ---- Activity Queries (API-only, activity is indexed) ----
-  /**
-   * Fetch activity events with optional filtering.
-   * API-only — no RPC fallback available.
-   */
-  async getActivity(params) {
-    return getActivity(this.resolvedConfig.apiBaseUrl, params, this.apiCtx);
-  }
   /**
    * Fetch platform-wide activity stats.
    * API-only — no RPC fallback available.
@@ -4850,30 +4730,6 @@ function useTournamentCount(phase) {
   }, [fetch2]);
   return { count, loading, error, refetch: fetch2 };
 }
-function usePlayerTournamentCount(address, phase) {
-  const client = useBudokanClient();
-  const [count, setCount] = react.useState(null);
-  const [loading, setLoading] = react.useState(!!address);
-  const [error, setError] = react.useState(null);
-  useResetOnClient(client, setCount, setError);
-  const fetch2 = react.useCallback(async () => {
-    if (!address) return;
-    setLoading(true);
-    setError(null);
-    try {
-      const result = await client.getPlayerTournaments(address, { phase, limit: 1 });
-      setCount(result.total ?? 0);
-    } catch (e) {
-      setError(e);
-    } finally {
-      setLoading(false);
-    }
-  }, [client, address, phase]);
-  react.useEffect(() => {
-    fetch2();
-  }, [fetch2]);
-  return { count, loading, error, refetch: fetch2 };
-}
 function useLeaderboard(tournamentId) {
   const client = useBudokanClient();
   const [leaderboard, setLeaderboard] = react.useState(null);
@@ -4923,84 +4779,157 @@ function useRegistrations(tournamentId, params) {
   }, [fetch2]);
   return { registrations, loading, error, refetch: fetch2 };
 }
-function usePlayer(address, params) {
+var MAX_OWNED_TOKENS = 1e3;
+var emptyPage = (limit, offset) => ({
+  data: [],
+  total: 0,
+  limit,
+  offset
+});
+function useOwnedTournamentIds(owner, contextId) {
   const client = useBudokanClient();
-  const [tournaments, setTournaments] = react.useState(null);
-  const [stats, setStats] = react.useState(null);
-  const [loading, setLoading] = react.useState(!!address);
-  const [error, setError] = react.useState(null);
-  useResetOnClient(client, setTournaments, setStats, setError);
-  const paramsKey = JSON.stringify(params);
-  const fetch2 = react.useCallback(async () => {
-    if (!address) return;
-    setLoading(true);
-    setError(null);
-    try {
-      const [tournamentsResult, statsResult] = await Promise.all([
-        client.getPlayerTournaments(address, params),
-        client.getPlayerStats(address)
-      ]);
-      setTournaments(tournamentsResult);
-      setStats(statsResult);
-    } catch (e) {
-      setError(e);
-    } finally {
-      setLoading(false);
+  const budokanAddress = client.clientConfig.budokanAddress;
+  const enabled = !!owner && !!budokanAddress;
+  const { data, isLoading } = react$1.useTokens(
+    enabled ? {
+      owner,
+      minterAddress: budokanAddress,
+      hasContext: true,
+      ...{},
+      limit: MAX_OWNED_TOKENS
+    } : void 0
+  );
+  const tournamentIds = react.useMemo(() => {
+    if (!enabled) return null;
+    if (!data?.data) return null;
+    const ids = /* @__PURE__ */ new Set();
+    for (const t of data.data) {
+      if (t.contextId) ids.add(String(t.contextId));
     }
-  }, [client, address, paramsKey]);
-  react.useEffect(() => {
-    fetch2();
-  }, [fetch2]);
-  return { tournaments, stats, loading, error };
+    return [...ids];
+  }, [enabled, data]);
+  return { tournamentIds, loading: isLoading };
 }
-function usePlayerStats(address) {
-  const client = useBudokanClient();
-  const [stats, setStats] = react.useState(null);
-  const [loading, setLoading] = react.useState(!!address);
-  const [error, setError] = react.useState(null);
-  useResetOnClient(client, setStats, setError);
-  const fetch2 = react.useCallback(async () => {
-    if (!address) return;
-    setLoading(true);
-    setError(null);
-    try {
-      const result = await client.getPlayerStats(address);
-      setStats(result);
-    } catch (e) {
-      setError(e);
-    } finally {
-      setLoading(false);
+function useTournamentsByOwner(owner, params) {
+  const { tournamentIds, loading: tokensLoading } = useOwnedTournamentIds(owner);
+  const inner = useTournaments(
+    tournamentIds && tournamentIds.length > 0 ? {
+      tournamentIds,
+      phase: params?.phase,
+      limit: params?.limit,
+      offset: params?.offset,
+      sort: params?.sort,
+      includePrizeSummary: params?.includePrizeSummary
+    } : void 0
+  );
+  if (tournamentIds !== null && tournamentIds.length === 0) {
+    return {
+      tournaments: emptyPage(
+        params?.limit ?? 50,
+        params?.offset ?? 0
+      ),
+      loading: false,
+      error: null,
+      refetch: async () => {
+      }
+    };
+  }
+  return {
+    tournaments: inner.tournaments,
+    loading: tokensLoading || inner.loading,
+    error: inner.error,
+    refetch: inner.refetch
+  };
+}
+function useTournamentsByOwnerCount(owner, params) {
+  const { tournamentIds, loading: tokensLoading } = useOwnedTournamentIds(owner);
+  const phaseFilter = params?.phase;
+  const filtered = useTournaments(
+    phaseFilter && tournamentIds && tournamentIds.length > 0 ? { tournamentIds, phase: phaseFilter, limit: 1 } : void 0
+  );
+  if (tournamentIds === null) {
+    return {
+      count: null,
+      loading: tokensLoading,
+      error: null,
+      refetch: async () => {
+      }
+    };
+  }
+  if (tournamentIds.length === 0) {
+    return {
+      count: 0,
+      loading: false,
+      error: null,
+      refetch: async () => {
+      }
+    };
+  }
+  if (!phaseFilter) {
+    return {
+      count: tournamentIds.length,
+      loading: false,
+      error: null,
+      refetch: async () => {
+      }
+    };
+  }
+  return {
+    count: filtered.tournaments?.total ?? null,
+    loading: filtered.loading,
+    error: filtered.error,
+    refetch: async () => {
     }
-  }, [client, address]);
-  react.useEffect(() => {
-    fetch2();
-  }, [fetch2]);
-  return { stats, loading, error, refetch: fetch2 };
+  };
 }
-function usePlayerTournaments(address, params) {
+function useRegistrationsByOwner(tournamentId, owner, params) {
   const client = useBudokanClient();
-  const [tournaments, setTournaments] = react.useState(null);
-  const [loading, setLoading] = react.useState(!!address);
-  const [error, setError] = react.useState(null);
-  useResetOnClient(client, setTournaments, setError);
-  const paramsKey = JSON.stringify(params);
-  const fetch2 = react.useCallback(async () => {
-    if (!address) return;
-    setLoading(true);
-    setError(null);
-    try {
-      const result = await client.getPlayerTournaments(address, params);
-      setTournaments(result);
-    } catch (e) {
-      setError(e);
-    } finally {
-      setLoading(false);
+  const budokanAddress = client.clientConfig.budokanAddress;
+  const contextId = tournamentId ? Number(tournamentId) : void 0;
+  const enabled = !!owner && !!budokanAddress && tournamentId != null && contextId !== void 0;
+  const { data: tokensResult, isLoading: tokensLoading } = react$1.useTokens(
+    enabled ? {
+      owner,
+      minterAddress: budokanAddress,
+      contextId,
+      limit: MAX_OWNED_TOKENS
+    } : void 0
+  );
+  const ownedGameTokenIds = react.useMemo(() => {
+    if (!enabled) return null;
+    if (!tokensResult?.data) return null;
+    const ids = [];
+    for (const t of tokensResult.data) {
+      if (t.tokenId == null) continue;
+      try {
+        ids.push(BigInt(String(t.tokenId)).toString());
+      } catch {
+      }
     }
-  }, [client, address, paramsKey]);
-  react.useEffect(() => {
-    fetch2();
-  }, [fetch2]);
-  return { tournaments, loading, error, refetch: fetch2 };
+    return ids;
+  }, [enabled, tokensResult]);
+  const inner = useRegistrations(
+    ownedGameTokenIds && ownedGameTokenIds.length > 0 ? tournamentId : void 0,
+    ownedGameTokenIds && ownedGameTokenIds.length > 0 ? { ...params, gameTokenIds: ownedGameTokenIds } : void 0
+  );
+  if (ownedGameTokenIds !== null && ownedGameTokenIds.length === 0) {
+    return {
+      registrations: emptyPage(
+        params?.limit ?? 50,
+        params?.offset ?? 0
+      ),
+      loading: false,
+      error: null,
+      refetch: async () => {
+      }
+    };
+  }
+  return {
+    registrations: inner.registrations,
+    loading: tokensLoading || inner.loading,
+    error: inner.error,
+    refetch: inner.refetch
+  };
 }
 function useRewardClaims(tournamentId, params) {
   const client = useBudokanClient();
@@ -5220,20 +5149,19 @@ exports.useActivityStats = useActivityStats;
 exports.useBudokanClient = useBudokanClient;
 exports.useConnectionStatus = useConnectionStatus;
 exports.useLeaderboard = useLeaderboard;
-exports.usePlayer = usePlayer;
-exports.usePlayerStats = usePlayerStats;
-exports.usePlayerTournamentCount = usePlayerTournamentCount;
-exports.usePlayerTournaments = usePlayerTournaments;
 exports.usePrizeAggregation = usePrizeAggregation;
 exports.usePrizeStats = usePrizeStats;
 exports.usePrizes = usePrizes;
 exports.useQualifications = useQualifications;
 exports.useRegistrations = useRegistrations;
+exports.useRegistrationsByOwner = useRegistrationsByOwner;
 exports.useRewardClaims = useRewardClaims;
 exports.useRewardClaimsSummary = useRewardClaimsSummary;
 exports.useSubscription = useSubscription;
 exports.useTournament = useTournament;
 exports.useTournamentCount = useTournamentCount;
 exports.useTournaments = useTournaments;
+exports.useTournamentsByOwner = useTournamentsByOwner;
+exports.useTournamentsByOwnerCount = useTournamentsByOwnerCount;
 //# sourceMappingURL=react.cjs.map
 //# sourceMappingURL=react.cjs.map