@dubsdotapp/expo 0.1.0

package/src/errors.ts

@@ -0,0 +1,127 @@
+import type { ParsedError, SolanaErrorCode } from './types';
+
+export class DubsApiError extends Error {
+  public readonly code: string;
+  public readonly httpStatus: number;
+
+  constructor(code: string, message: string, httpStatus: number) {
+    super(message);
+    this.name = 'DubsApiError';
+    this.code = code;
+    this.httpStatus = httpStatus;
+  }
+}
+
+/** Custom error codes from dubs_solana_program (6000-6049) */
+export const SOLANA_PROGRAM_ERRORS: Record<number, SolanaErrorCode> = {
+  6000: { code: 'invalid_amount', message: 'Amount must be greater than 0' },
+  6001: { code: 'invalid_max_players', message: 'Max players must be between 1 and 20' },
+  6002: { code: 'game_not_active', message: 'Game is not active' },
+  6003: { code: 'game_full', message: 'Game is full' },
+  6004: { code: 'player_already_joined', message: 'Player has already joined this game' },
+  6005: { code: 'insufficient_funds', message: 'Insufficient funds in pot' },
+  6006: { code: 'unauthorized', message: 'Only the game creator can perform this action' },
+  6007: { code: 'invalid_winner_index', message: 'Invalid winner index' },
+  6008: { code: 'game_still_active', message: 'Game is still active — must close before resetting' },
+  6009: { code: 'pot_not_empty', message: 'Pot must be empty before resetting — distribute winnings first' },
+  6010: { code: 'no_winners_specified', message: 'At least one winner must be specified' },
+  6011: { code: 'mismatched_winners_percentages', message: 'Number of winners must match number of percentages' },
+  6012: { code: 'percentages_invalid', message: 'Percentages must sum to exactly 100' },
+  6013: { code: 'winner_account_mismatch', message: 'Winner account does not match expected player' },
+  6014: { code: 'invalid_operator_fee', message: 'Operator fee must be between 0 and 100' },
+  6015: { code: 'operator_wallet_mismatch', message: 'Operator wallet does not match game settings' },
+  6016: { code: 'winner_not_in_game', message: 'Winner address is not a player in this game' },
+  6017: { code: 'voting_not_enabled', message: 'Voting is not enabled for this game' },
+  6018: { code: 'voter_not_in_game', message: 'Voter is not a player in this game' },
+  6019: { code: 'voted_for_not_in_game', message: 'Cannot vote for someone who is not in the game' },
+  6020: { code: 'voting_incomplete', message: 'Voting incomplete — need majority of players to vote' },
+  6021: { code: 'invalid_referee_commission', message: 'Referee commission must be between 0 and 100' },
+  6022: { code: 'total_fees_exceed_100', message: 'Total fees (operator + referee) cannot exceed 100%' },
+  6023: { code: 'referee_mode_requires_referee', message: 'Referee mode requires a referee address' },
+  6024: { code: 'referee_must_earn_commission', message: 'Referee must earn commission' },
+  6025: { code: 'referee_cannot_be_player', message: 'Referee cannot join as a player (conflict of interest)' },
+  6026: { code: 'only_referee_can_vote', message: 'Only the referee can vote in Referee mode' },
+  6027: { code: 'referee_account_mismatch', message: 'Referee account does not match game settings' },
+  6028: { code: 'invalid_lock_time', message: 'Lock time must be in the future' },
+  6029: { code: 'game_locked', message: 'Game is locked — no more players can join' },
+  6030: { code: 'lock_time_passed', message: 'Lock time has passed — game is now locked' },
+  6031: { code: 'unauthorized_oracle', message: 'Only authorized oracle can resolve this game' },
+  6032: { code: 'game_not_locked', message: 'Game must be locked before it can be resolved' },
+  6033: { code: 'already_resolved', message: 'Game has already been resolved' },
+  6034: { code: 'game_not_resolved', message: 'Game has not been resolved yet' },
+  6035: { code: 'player_not_in_game', message: 'Player is not in this game' },
+  6036: { code: 'not_a_winner', message: 'Player did not win this game' },
+  6037: { code: 'invalid_game_mode', message: 'Invalid game mode for this operation' },
+  6038: { code: 'already_claimed', message: 'Player has already claimed their winnings' },
+  6039: { code: 'lock_time_too_soon', message: 'Lock time must be at least 2 minutes in the future' },
+  6040: { code: 'operator_account_missing', message: 'Operator account must be provided' },
+  6041: { code: 'no_winners_to_distribute', message: 'No winners to distribute funds to' },
+  6042: { code: 'insufficient_funds_for_rent', message: 'Insufficient funds to maintain rent exemption' },
+  6043: { code: 'cannot_resolve_before_lock', message: 'Cannot resolve game before lock time has passed' },
+  6044: { code: 'emergency_refund_not_available', message: 'Emergency refund not available yet — must wait 7 days after lock time' },
+  6045: { code: 'sponsor_account_missing', message: 'Sponsor account must be provided for tie refund' },
+  6046: { code: 'sponsor_wallet_mismatch', message: 'Sponsor wallet does not match stored sponsor' },
+  6047: { code: 'invalid_bet_amount', message: 'Bet amount must be greater than zero' },
+  6048: { code: 'no_survivors_to_distribute', message: 'No survivors to distribute winnings to' },
+  6049: { code: 'too_many_survivors', message: 'Too many survivors (max 50 per batch)' },
+};
+
+/** Known Solana built-in instruction errors */
+const SOLANA_BUILTIN_ERRORS: Record<number, SolanaErrorCode> = {
+  0: { code: 'generic_error', message: 'Generic instruction error' },
+  1: { code: 'invalid_argument', message: 'Invalid argument passed to program' },
+  2: { code: 'invalid_instruction_data', message: 'Invalid instruction data' },
+  3: { code: 'invalid_account_data', message: 'Invalid account data' },
+  4: { code: 'account_data_too_small', message: 'Account data too small' },
+  5: { code: 'insufficient_funds', message: 'Insufficient funds for transaction' },
+  6: { code: 'incorrect_program_id', message: 'Incorrect program ID' },
+  7: { code: 'missing_required_signature', message: 'Missing required signature' },
+  8: { code: 'account_already_initialized', message: 'Account already initialized' },
+  9: { code: 'uninitialized_account', message: 'Attempt to operate on uninitialized account' },
+};
+
+/**
+ * Parse a raw Solana transaction error into a human-readable { code, message }.
+ * Handles: { InstructionError: [idx, { Custom: N }] }, string errors, etc.
+ */
+export function parseSolanaError(err: unknown): ParsedError {
+  if (!err) return { code: 'unknown_error', message: 'Unknown transaction error' };
+
+  let parsed = err;
+
+  if (typeof parsed === 'string') {
+    try {
+      const jsonMatch = parsed.match(/\{.*\}/s);
+      if (jsonMatch) parsed = JSON.parse(jsonMatch[0]);
+      else return { code: 'transaction_failed', message: parsed };
+    } catch {
+      return { code: 'transaction_failed', message: parsed as string };
+    }
+  }
+
+  if (typeof parsed === 'object' && parsed !== null && 'InstructionError' in parsed) {
+    const [ixIndex, details] = (parsed as { InstructionError: [number, unknown] }).InstructionError;
+
+    if (details && typeof details === 'object' && 'Custom' in details) {
+      const customCode = (details as { Custom: number }).Custom;
+      const known = SOLANA_PROGRAM_ERRORS[customCode];
+      if (known) return known;
+      return { code: `program_error_${customCode}`, message: `Program error code ${customCode} (instruction ${ixIndex})` };
+    }
+
+    if (typeof details === 'string') {
+      const snake = details.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+      return { code: snake, message: details.replace(/([a-z])([A-Z])/g, '$1 $2') };
+    }
+
+    if (typeof details === 'number') {
+      const known = SOLANA_BUILTIN_ERRORS[details];
+      if (known) return known;
+      return { code: `instruction_error_${details}`, message: `Instruction error ${details}` };
+    }
+
+    return { code: 'instruction_error', message: `Instruction ${ixIndex} failed: ${JSON.stringify(details)}` };
+  }
+
+  return { code: 'transaction_failed', message: typeof parsed === 'object' ? JSON.stringify(parsed) : String(parsed) };
+}

package/src/hooks/index.ts

@@ -0,0 +1,12 @@
+export { useEvents } from './useEvents';
+export { useGame } from './useGame';
+export { useGames } from './useGames';
+export { useNetworkGames } from './useNetworkGames';
+export { useCreateGame } from './useCreateGame';
+export type { CreateGameMutationResult } from './useCreateGame';
+export { useJoinGame } from './useJoinGame';
+export type { JoinGameMutationResult } from './useJoinGame';
+export { useClaim } from './useClaim';
+export type { ClaimMutationResult } from './useClaim';
+export { useAuth } from './useAuth';
+export type { UseAuthResult } from './useAuth';

package/src/hooks/useAuth.ts

@@ -0,0 +1,180 @@
+import { useState, useCallback, useRef } from 'react';
+import bs58 from 'bs58';
+import { useDubs } from '../provider';
+import type { AuthStatus, DubsUser } from '../types';
+
+export interface UseAuthResult {
+  /** Current auth status */
+  status: AuthStatus;
+  /** Authenticated user profile, or null */
+  user: DubsUser | null;
+  /** JWT token, or null */
+  token: string | null;
+  /** Convenience boolean */
+  isAuthenticated: boolean;
+  /** Error from the last operation, or null */
+  error: Error | null;
+
+  /**
+   * Full nonce → sign → verify flow.
+   * If the wallet is already registered, resolves to authenticated state.
+   * If new wallet, resolves to needsRegistration state — call register() next.
+   */
+  authenticate: () => Promise<void>;
+
+  /**
+   * Register a new user after authenticate() returned needsRegistration.
+   * Reuses the nonce+signature from authenticate() — no second signing prompt.
+   */
+  register: (username: string, referralCode?: string) => Promise<void>;
+
+  /** Log out and clear state */
+  logout: () => Promise<void>;
+
+  /**
+   * Restore a session from a saved token (e.g. AsyncStorage on app restart).
+   * Calls GET /auth/me to validate. Returns true if valid, false otherwise.
+   */
+  restoreSession: (token: string) => Promise<boolean>;
+
+  /** Reset to idle state, clearing errors and user */
+  reset: () => void;
+}
+
+export function useAuth(): UseAuthResult {
+  const { client, wallet } = useDubs();
+  const [status, setStatus] = useState<AuthStatus>('idle');
+  const [user, setUser] = useState<DubsUser | null>(null);
+  const [token, setToken] = useState<string | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+
+  // Stash nonce+signature between authenticate → register (single-sign flow)
+  const pendingAuth = useRef<{
+    walletAddress: string;
+    nonce: string;
+    signature: string;
+  } | null>(null);
+
+  const reset = useCallback(() => {
+    setStatus('idle');
+    setUser(null);
+    setToken(null);
+    setError(null);
+    pendingAuth.current = null;
+    client.setToken(null);
+  }, [client]);
+
+  const authenticate = useCallback(async () => {
+    try {
+      if (!wallet.publicKey) {
+        throw new Error('Wallet not connected');
+      }
+      if (!wallet.signMessage) {
+        throw new Error('Wallet does not support signMessage');
+      }
+
+      const walletAddress = wallet.publicKey.toBase58();
+      setStatus('authenticating');
+      setError(null);
+
+      // 1. Get nonce
+      const { nonce, message } = await client.getNonce(walletAddress);
+
+      // 2. Sign message
+      setStatus('signing');
+      const messageBytes = new TextEncoder().encode(message);
+      const signatureBytes = await wallet.signMessage(messageBytes);
+      const signature = bs58.encode(signatureBytes);
+
+      // 3. Verify with server
+      setStatus('verifying');
+      const result = await client.authenticate({ walletAddress, signature, nonce });
+
+      if (result.needsRegistration) {
+        // Stash credentials for register() — nonce is NOT consumed
+        pendingAuth.current = { walletAddress, nonce, signature };
+        setStatus('needsRegistration');
+        return;
+      }
+
+      // Existing user — fully authenticated
+      setUser(result.user!);
+      setToken(result.token!);
+      setStatus('authenticated');
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setStatus('error');
+    }
+  }, [client, wallet]);
+
+  const register = useCallback(async (username: string, referralCode?: string) => {
+    try {
+      const pending = pendingAuth.current;
+      if (!pending) {
+        throw new Error('No pending authentication — call authenticate() first');
+      }
+
+      setStatus('registering');
+      setError(null);
+
+      const result = await client.register({
+        walletAddress: pending.walletAddress,
+        signature: pending.signature,
+        nonce: pending.nonce,
+        username,
+        referralCode,
+      });
+
+      pendingAuth.current = null;
+      setUser(result.user);
+      setToken(result.token);
+      setStatus('authenticated');
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setStatus('error');
+    }
+  }, [client]);
+
+  const logout = useCallback(async () => {
+    try {
+      await client.logout();
+    } catch {
+      // Ignore logout errors — clear state regardless
+    }
+    setUser(null);
+    setToken(null);
+    setStatus('idle');
+    setError(null);
+    pendingAuth.current = null;
+  }, [client]);
+
+  const restoreSession = useCallback(async (savedToken: string): Promise<boolean> => {
+    try {
+      client.setToken(savedToken);
+      const me = await client.getMe();
+      setUser(me);
+      setToken(savedToken);
+      setStatus('authenticated');
+      return true;
+    } catch {
+      client.setToken(null);
+      setUser(null);
+      setToken(null);
+      setStatus('idle');
+      return false;
+    }
+  }, [client]);
+
+  return {
+    status,
+    user,
+    token,
+    isAuthenticated: status === 'authenticated',
+    error,
+    authenticate,
+    register,
+    logout,
+    restoreSession,
+    reset,
+  };
+}

package/src/hooks/useClaim.ts

@@ -0,0 +1,64 @@
+import { useState, useCallback } from 'react';
+import { useDubs } from '../provider';
+import { signAndSendBase64Transaction, pollTransactionConfirmation } from '../utils/transaction';
+import type { BuildClaimParams, MutationStatus } from '../types';
+
+export interface ClaimMutationResult {
+  gameId: string;
+  signature: string;
+  explorerUrl: string;
+}
+
+export function useClaim() {
+  const { client, wallet, connection } = useDubs();
+  const [status, setStatus] = useState<MutationStatus>('idle');
+  const [error, setError] = useState<Error | null>(null);
+  const [data, setData] = useState<ClaimMutationResult | null>(null);
+
+  const reset = useCallback(() => {
+    setStatus('idle');
+    setError(null);
+    setData(null);
+  }, []);
+
+  const execute = useCallback(async (params: BuildClaimParams): Promise<ClaimMutationResult> => {
+    setStatus('building');
+    setError(null);
+    setData(null);
+
+    try {
+      // 1. Build unsigned claim transaction
+      const claimResult = await client.buildClaimTransaction(params);
+
+      // 2. Sign transaction
+      setStatus('signing');
+      const signature = await signAndSendBase64Transaction(
+        claimResult.transaction,
+        wallet,
+        connection,
+      );
+
+      // 3. Poll for confirmation (no backend confirm step for claims)
+      setStatus('confirming');
+      await pollTransactionConfirmation(signature, connection);
+
+      const explorerUrl = `https://solscan.io/tx/${signature}`;
+      const result: ClaimMutationResult = {
+        gameId: params.gameId,
+        signature,
+        explorerUrl,
+      };
+
+      setData(result);
+      setStatus('success');
+      return result;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      setError(error);
+      setStatus('error');
+      throw error;
+    }
+  }, [client, wallet, connection]);
+
+  return { execute, status, error, data, reset };
+}

package/src/hooks/useCreateGame.ts

@@ -0,0 +1,78 @@
+import { useState, useCallback } from 'react';
+import { useDubs } from '../provider';
+import { signAndSendBase64Transaction, pollTransactionConfirmation } from '../utils/transaction';
+import type { CreateGameParams, ConfirmGameResult, MutationStatus } from '../types';
+
+export interface CreateGameMutationResult {
+  gameId: string;
+  gameAddress: string;
+  signature: string;
+  explorerUrl: string;
+}
+
+export function useCreateGame() {
+  const { client, wallet, connection } = useDubs();
+  const [status, setStatus] = useState<MutationStatus>('idle');
+  const [error, setError] = useState<Error | null>(null);
+  const [data, setData] = useState<CreateGameMutationResult | null>(null);
+
+  const reset = useCallback(() => {
+    setStatus('idle');
+    setError(null);
+    setData(null);
+  }, []);
+
+  const execute = useCallback(async (params: CreateGameParams): Promise<CreateGameMutationResult> => {
+    setStatus('building');
+    setError(null);
+    setData(null);
+
+    try {
+      // 1. Build unsigned transaction
+      const createResult = await client.createGame(params);
+
+      // 2. Sign transaction
+      setStatus('signing');
+      const signature = await signAndSendBase64Transaction(
+        createResult.transaction,
+        wallet,
+        connection,
+      );
+
+      // 3. Poll for confirmation
+      setStatus('confirming');
+      await pollTransactionConfirmation(signature, connection);
+
+      // 4. Confirm with backend
+      setStatus('saving');
+      const explorerUrl = `https://solscan.io/tx/${signature}`;
+      await client.confirmGame({
+        gameId: createResult.gameId,
+        playerWallet: params.playerWallet,
+        signature,
+        teamChoice: params.teamChoice,
+        wagerAmount: params.wagerAmount,
+        role: 'creator',
+        gameAddress: createResult.gameAddress,
+      });
+
+      const result: CreateGameMutationResult = {
+        gameId: createResult.gameId,
+        gameAddress: createResult.gameAddress,
+        signature,
+        explorerUrl,
+      };
+
+      setData(result);
+      setStatus('success');
+      return result;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      setError(error);
+      setStatus('error');
+      throw error;
+    }
+  }, [client, wallet, connection]);
+
+  return { execute, status, error, data, reset };
+}

package/src/hooks/useEvents.ts

@@ -0,0 +1,34 @@
+import { useState, useEffect, useCallback } from 'react';
+import { useDubs } from '../provider';
+import type { UnifiedEvent, Pagination, GetUpcomingEventsParams, QueryResult } from '../types';
+
+export function useEvents(
+  params?: GetUpcomingEventsParams,
+): QueryResult<{ events: UnifiedEvent[]; pagination: Pagination }> {
+  const { client } = useDubs();
+  const [data, setData] = useState<{ events: UnifiedEvent[]; pagination: Pagination } | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  // Serialize params for dependency comparison
+  const paramKey = JSON.stringify(params ?? {});
+
+  const fetchData = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.getUpcomingEvents(params);
+      setData(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, paramKey]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+
+  return { data, loading, error, refetch: fetchData };
+}

package/src/hooks/useGame.ts

@@ -0,0 +1,30 @@
+import { useState, useEffect, useCallback } from 'react';
+import { useDubs } from '../provider';
+import type { GameDetail, QueryResult } from '../types';
+
+export function useGame(gameId: string | null): QueryResult<GameDetail> {
+  const { client } = useDubs();
+  const [data, setData] = useState<GameDetail | null>(null);
+  const [loading, setLoading] = useState(!!gameId);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetchData = useCallback(async () => {
+    if (!gameId) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const game = await client.getGame(gameId);
+      setData(game);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, gameId]);
+
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+
+  return { data, loading, error, refetch: fetchData };
+}

package/src/hooks/useGames.ts

@@ -0,0 +1,31 @@
+import { useState, useEffect, useCallback } from 'react';
+import { useDubs } from '../provider';
+import type { GameListItem, GetGamesParams, QueryResult } from '../types';
+
+export function useGames(params?: GetGamesParams): QueryResult<GameListItem[]> {
+  const { client } = useDubs();
+  const [data, setData] = useState<GameListItem[] | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  const paramKey = JSON.stringify(params ?? {});
+
+  const fetchData = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const games = await client.getGames(params);
+      setData(games);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, paramKey]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+
+  return { data, loading, error, refetch: fetchData };
+}

package/src/hooks/useJoinGame.ts

@@ -0,0 +1,78 @@
+import { useState, useCallback } from 'react';
+import { useDubs } from '../provider';
+import { signAndSendBase64Transaction, pollTransactionConfirmation } from '../utils/transaction';
+import type { JoinGameParams, MutationStatus } from '../types';
+
+export interface JoinGameMutationResult {
+  gameId: string;
+  gameAddress: string;
+  signature: string;
+  explorerUrl: string;
+}
+
+export function useJoinGame() {
+  const { client, wallet, connection } = useDubs();
+  const [status, setStatus] = useState<MutationStatus>('idle');
+  const [error, setError] = useState<Error | null>(null);
+  const [data, setData] = useState<JoinGameMutationResult | null>(null);
+
+  const reset = useCallback(() => {
+    setStatus('idle');
+    setError(null);
+    setData(null);
+  }, []);
+
+  const execute = useCallback(async (params: JoinGameParams): Promise<JoinGameMutationResult> => {
+    setStatus('building');
+    setError(null);
+    setData(null);
+
+    try {
+      // 1. Build unsigned transaction
+      const joinResult = await client.joinGame(params);
+
+      // 2. Sign transaction
+      setStatus('signing');
+      const signature = await signAndSendBase64Transaction(
+        joinResult.transaction,
+        wallet,
+        connection,
+      );
+
+      // 3. Poll for confirmation
+      setStatus('confirming');
+      await pollTransactionConfirmation(signature, connection);
+
+      // 4. Confirm with backend
+      setStatus('saving');
+      const explorerUrl = `https://solscan.io/tx/${signature}`;
+      await client.confirmGame({
+        gameId: params.gameId,
+        playerWallet: params.playerWallet,
+        signature,
+        teamChoice: params.teamChoice,
+        wagerAmount: params.amount,
+        role: 'joiner',
+        gameAddress: joinResult.gameAddress,
+      });
+
+      const result: JoinGameMutationResult = {
+        gameId: params.gameId,
+        gameAddress: joinResult.gameAddress,
+        signature,
+        explorerUrl,
+      };
+
+      setData(result);
+      setStatus('success');
+      return result;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      setError(error);
+      setStatus('error');
+      throw error;
+    }
+  }, [client, wallet, connection]);
+
+  return { execute, status, error, data, reset };
+}

package/src/hooks/useNetworkGames.ts

@@ -0,0 +1,31 @@
+import { useState, useEffect, useCallback } from 'react';
+import { useDubs } from '../provider';
+import type { GameListItem, Pagination, GetNetworkGamesParams, QueryResult } from '../types';
+
+export function useNetworkGames(params?: GetNetworkGamesParams): QueryResult<{ games: GameListItem[]; pagination: Pagination }> {
+  const { client } = useDubs();
+  const [data, setData] = useState<{ games: GameListItem[]; pagination: Pagination } | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  const paramKey = JSON.stringify(params ?? {});
+
+  const fetchData = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.getNetworkGames(params);
+      setData(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [client, paramKey]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+
+  return { data, loading, error, refetch: fetchData };
+}