@pokertools/sdk 1.0.11 → 1.0.16

package/dist/react/index.d.ts

@@ -1,7 +1,7 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
 import * as _pokertools_types from '@pokertools/types';
-import { LoginRequest, LoginResponse, TableListItem, CreateTableRequest, PublicState, BuyInRequest, GameActionRequest, AddChipsRequest } from '@pokertools/types';
+import { LoginRequest, LoginResponse, TableListItem, CreateTableRequest, PublicState, BuyInRequest, GameActionRequest, AddChipsRequest, TournamentListItem, CreateTournamentRequest, TournamentDetails, RegisterTournamentRequest, StartTournamentResponse, ReconcileTournamentResponse, SettleTournamentResponse } from '@pokertools/types';
 
 /**
  * SDK-specific types and configuration
@@ -40,6 +40,7 @@ interface PokerSDKConfig {
 interface UserBalances {
     main: number;
     inPlay: number;
+    pendingWithdrawal: number;
 }
 /**
  * User profile with balances
@@ -104,6 +105,7 @@ interface WithdrawalRequest {
     address: string;
     message: string;
     signature: `0x${string}`;
+    idempotencyKey?: string;
 }
 /**
  * Withdrawal record
@@ -262,6 +264,48 @@ declare class PokerClient {
      * Stand from table (leave and cash out)
      */
     stand(tableId: string): Promise<void>;
+    /**
+     * Get active and registering tournaments.
+     */
+    getTournaments(): Promise<TournamentListItem[]>;
+    /**
+     * Create a tournament lobby and backing tournament table.
+     */
+    createTournament(request: CreateTournamentRequest): Promise<{
+        tournamentId: string;
+        tableId: string;
+    }>;
+    /**
+     * Get tournament lobby details, entries, prize pool, and table reference.
+     */
+    getTournament(tournamentId: string): Promise<TournamentDetails>;
+    /**
+     * Register for a tournament. Debits buy-in and fee from MAIN balance.
+     */
+    registerTournament(tournamentId: string, request: RegisterTournamentRequest): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Start a tournament once at least two players are registered.
+     */
+    startTournament(tournamentId: string): Promise<StartTournamentResponse>;
+    /**
+     * Reconcile a running multi-table tournament after completed hands.
+     */
+    reconcileTournament(tournamentId: string): Promise<ReconcileTournamentResponse>;
+    /**
+     * Manually advance tournament blind level.
+     */
+    advanceTournamentBlinds(tournamentId: string): Promise<{
+        results: Record<string, {
+            blindLevel?: number;
+            error?: string;
+        }>;
+    }>;
+    /**
+     * Settle a completed tournament and pay the configured prize distribution.
+     */
+    settleTournament(tournamentId: string): Promise<SettleTournamentResponse>;
     /**
      * Fold hand
      */
@@ -673,6 +717,34 @@ interface UseTablesResult {
  * Hook to get list of active tables
  */
 declare function useTables(): UseTablesResult;
+interface UseTournamentsResult {
+    /** Active and registering tournament lobbies */
+    tournaments: TournamentListItem[];
+    /** Loading state */
+    isLoading: boolean;
+    /** Error if any */
+    error: Error | null;
+    /** Refresh tournament list */
+    refresh: () => Promise<void>;
+}
+/**
+ * Hook to get active and registering tournaments.
+ */
+declare function useTournaments(): UseTournamentsResult;
+interface UseTournamentResult {
+    /** Tournament lobby details */
+    tournament: TournamentDetails | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error if any */
+    error: Error | null;
+    /** Refresh tournament details */
+    refresh: () => Promise<void>;
+}
+/**
+ * Hook to get a tournament lobby and its entries/tables.
+ */
+declare function useTournament(tournamentId: string | null): UseTournamentResult;
 /**
  * Hook to manage WebSocket connection
  */
@@ -687,4 +759,4 @@ declare function useConnection(): {
     ping: () => Promise<number | null>;
 };
 
-export { type PokerContextValue, PokerProvider, type PokerProviderProps, type UseTableOptions, type UseTableResult, type UseTablesResult, type UseUserResult, useConnection, usePoker, usePokerClient, usePokerSocket, useTable, useTables, useUser };
+export { type PokerContextValue, PokerProvider, type PokerProviderProps, type UseTableOptions, type UseTableResult, type UseTablesResult, type UseTournamentResult, type UseTournamentsResult, type UseUserResult, useConnection, usePoker, usePokerClient, usePokerSocket, useTable, useTables, useTournament, useTournaments, useUser };

package/dist/react/index.js

@@ -158,6 +158,62 @@ var PokerClient = class {
   async stand(tableId) {
     await this.request("POST", `/tables/${tableId}/stand`);
   }
+  /**
+   * Get active and registering tournaments.
+   */
+  async getTournaments() {
+    const response = await this.request(
+      "GET",
+      "/tournaments"
+    );
+    return response.tournaments;
+  }
+  /**
+   * Create a tournament lobby and backing tournament table.
+   */
+  async createTournament(request) {
+    return this.request("POST", "/tournaments", request);
+  }
+  /**
+   * Get tournament lobby details, entries, prize pool, and table reference.
+   */
+  async getTournament(tournamentId) {
+    const response = await this.request(
+      "GET",
+      `/tournaments/${tournamentId}`
+    );
+    return response.tournament;
+  }
+  /**
+   * Register for a tournament. Debits buy-in and fee from MAIN balance.
+   */
+  async registerTournament(tournamentId, request) {
+    return this.request("POST", `/tournaments/${tournamentId}/register`, request);
+  }
+  /**
+   * Start a tournament once at least two players are registered.
+   */
+  async startTournament(tournamentId) {
+    return this.request("POST", `/tournaments/${tournamentId}/start`);
+  }
+  /**
+   * Reconcile a running multi-table tournament after completed hands.
+   */
+  async reconcileTournament(tournamentId) {
+    return this.request("POST", `/tournaments/${tournamentId}/reconcile`);
+  }
+  /**
+   * Manually advance tournament blind level.
+   */
+  async advanceTournamentBlinds(tournamentId) {
+    return this.request("POST", `/tournaments/${tournamentId}/advance-blinds`);
+  }
+  /**
+   * Settle a completed tournament and pay the configured prize distribution.
+   */
+  async settleTournament(tournamentId) {
+    return this.request("POST", `/tournaments/${tournamentId}/settle`);
+  }
   // ============================================================================
   // Convenience Action Methods
   // ============================================================================
@@ -1100,6 +1156,55 @@ function useTables() {
   }, [refresh]);
   return { tables, isLoading, error, refresh };
 }
+function useTournaments() {
+  const { client } = usePoker();
+  const [tournaments, setTournaments] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const refresh = useCallback(async () => {
+    try {
+      setIsLoading(true);
+      const data = await client.getTournaments();
+      setTournaments(data);
+      setError(null);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  return { tournaments, isLoading, error, refresh };
+}
+function useTournament(tournamentId) {
+  const { client } = usePoker();
+  const [tournament, setTournament] = useState(null);
+  const [isLoading, setIsLoading] = useState(Boolean(tournamentId));
+  const [error, setError] = useState(null);
+  const refresh = useCallback(async () => {
+    if (!tournamentId) {
+      setTournament(null);
+      setIsLoading(false);
+      return;
+    }
+    try {
+      setIsLoading(true);
+      const data = await client.getTournament(tournamentId);
+      setTournament(data);
+      setError(null);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, tournamentId]);
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  return { tournament, isLoading, error, refresh };
+}
 function useConnection() {
   const { socket, connectionState, connect, disconnect } = usePoker();
   const [latency, setLatency] = useState(null);
@@ -1125,6 +1230,6 @@ function useConnection() {
   };
 }
 
-export { PokerProvider, useConnection, usePoker, usePokerClient, usePokerSocket, useTable, useTables, useUser };
+export { PokerProvider, useConnection, usePoker, usePokerClient, usePokerSocket, useTable, useTables, useTournament, useTournaments, useUser };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map