@dimcool/sdk 0.1.29 → 0.1.31

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import { Transaction } from '@solana/web3.js';
-import { RpsGameAction, RpsGameState, RpsAction } from '@dimcool/rps';
-import { ChessGameAction, ChessGameState, ChessMovePayload } from '@dimcool/chess';
-import { NimGameAction, NimGameState } from '@dimcool/nim';
-import { DotsAndBoxesGameAction, DotsAndBoxesGameState } from '@dimcool/dots-and-boxes';
-import { TicTacToeGameAction, TicTacToeGameState } from '@dimcool/tic-tac-toe';
-import { Connect4GameAction, Connect4GameState } from '@dimcool/connect-four';
+import { RpsGameState, RpsGameAction, RpsAction } from '@dimcool/rps';
+import { ChessGameState, ChessGameAction, ChessMovePayload } from '@dimcool/chess';
+import { NimGameState, NimGameAction } from '@dimcool/nim';
+import { DotsAndBoxesGameState, DotsAndBoxesGameAction } from '@dimcool/dots-and-boxes';
+import { TicTacToeGameState, TicTacToeGameAction } from '@dimcool/tic-tac-toe';
+import { Connect4GameState, Connect4GameAction } from '@dimcool/connect-four';
 export { MICRO_UNITS, formatMoneyMinor, toMajor } from '@dimcool/utils';
 
 /**
@@ -108,6 +108,62 @@ interface ConnectionState {
     error: string | null;
 }
 
+interface AnalyticsUserData {
+    userId: string;
+    username?: string | null;
+    email?: string | null;
+    walletAddress?: string | null;
+    authProvider?: 'google' | 'apple' | 'injected' | 'keypair';
+    isBot?: boolean;
+    createdAt?: string;
+}
+interface IAnalyticsClient {
+    /**
+     * Called after a successful login. Implementations should identify the user
+     * and link any pre-login anonymous events to their profile.
+     */
+    userLoggedIn(user: AnalyticsUserData, meta: {
+        isNewUser: boolean;
+        authMethod: string;
+        referralCode?: string;
+    }): void;
+    /**
+     * Called on logout. Implementations should reset the current identity so
+     * subsequent events are associated with a new anonymous session.
+     */
+    userLoggedOut(): void;
+    /**
+     * Called on app boot when auth is restored from storage (returning user).
+     * Should re-attach the user identity without creating a new alias link.
+     */
+    sessionRestored(user: AnalyticsUserData): void;
+    /**
+     * Track a discrete event. Fire-and-forget — must never throw or block.
+     */
+    track(event: string, properties?: Record<string, unknown>): void;
+    /**
+     * Set persistent user properties that will be attached to the user's profile.
+     */
+    setUserProperties(properties: Record<string, unknown>): void;
+    /**
+     * Associate the current user with a group (e.g. game_type).
+     */
+    group(groupType: string, groupKey: string, properties?: Record<string, unknown>): void;
+}
+/** Default noop implementation — used when no analytics client is configured. */
+declare class NoopAnalyticsClient implements IAnalyticsClient {
+    userLoggedIn(_user: AnalyticsUserData, _meta: {
+        isNewUser: boolean;
+        authMethod: string;
+        referralCode?: string;
+    }): void;
+    userLoggedOut(): void;
+    sessionRestored(_user: AnalyticsUserData): void;
+    track(_event: string, _properties?: Record<string, unknown>): void;
+    setUserProperties(_properties: Record<string, unknown>): void;
+    group(_groupType: string, _groupKey: string, _properties?: Record<string, unknown>): void;
+}
+
 interface SDKConfig {
     appId: string;
     baseUrl?: string;
@@ -115,6 +171,7 @@ interface SDKConfig {
     httpClient?: IHttpClient;
     wsTransport?: WsTransport;
     logger?: ILogger;
+    analytics?: IAnalyticsClient;
     autoPay?: {
         enabled?: boolean;
         maxAmountMinor?: number;
@@ -207,6 +264,9 @@ interface FeatureFlag {
     createdAt: string;
     updatedAt: string;
 }
+interface AdminFeatureFlag extends FeatureFlag {
+    description: string | null;
+}
 interface ApiError {
     error?: string;
     message?: string | string[];
@@ -216,6 +276,7 @@ interface ApiError {
 interface UsernameAvailabilityResponse {
     valid: boolean;
     available: boolean;
+    reason?: 'reserved' | 'taken' | 'invalid_format' | 'blocked_domain';
 }
 interface PublicUser {
     id: string;
@@ -259,6 +320,10 @@ interface FriendRequestItem {
     mutualFriendsCount: number;
     createdAt: string;
 }
+interface PaginatedFriendRequests {
+    items: FriendRequestItem[];
+    nextCursor?: string;
+}
 interface PaginatedSearchUsers {
     users: SearchUser[];
     total: number;
@@ -284,6 +349,22 @@ interface PaginatedSessions {
     sessions: Session[];
     total: number;
 }
+interface SessionStats {
+    total: number;
+    email: number;
+    wallet: number;
+    walletBreakdown: {
+        phantomEmbedded: number;
+        keypair: number;
+        byProvider: {
+            google: number;
+            apple: number;
+            injected: number;
+            unknown: number;
+        };
+        byWalletName: Record<string, number>;
+    };
+}
 type ActivityFeedItemType = 'new_user' | 'win' | 'lobby_created' | 'game_started';
 interface ActivityFeedUser {
     id: string;
@@ -996,6 +1077,16 @@ declare class Wallet {
      * Confirm a transfer that was already sent by the client (signAndSendTransaction path).
      */
     confirmTransferSignature(signature: string, senderAddress: string, recipientAddress: string, amount: number, token?: TransferToken, ataCreated?: boolean, recipientInput?: string): Promise<SubmitTransferResponse>;
+    /**
+     * Sign a prepared transaction and invoke the appropriate backend callback
+     * based on the configured signer — without exposing the mode decision to callers.
+     *   - Embedded wallet (signAndSend): signs+sends, calls onSignedAndSent(signature)
+     *   - Injected wallet (signTransaction): signs locally, calls onSigned(signedTxBase64)
+     */
+    signAndDispatch<T>(unsignedTxBase64: string, handlers: {
+        onSigned: (signedTxBase64: string) => Promise<T>;
+        onSignedAndSent: (signature: string) => Promise<T>;
+    }): Promise<T>;
     /**
      * Full transfer flow in one call: prepare -> sign -> submit
      * Recipient can be username, .sol domain, or Solana address (resolved by backend).
@@ -1011,13 +1102,18 @@ declare class Auth {
     private logger;
     constructor(http: IHttpClient, storage: IStorage, wallet: Wallet, logger?: ILogger);
     login(email: string, password: string): Promise<LoginResponse>;
-    private generateHandshake;
+    generateHandshake(walletAddress: string): Promise<GenerateHandshakeResponse>;
     loginWithWallet(options?: {
         referralCode?: string;
         walletMeta?: WalletMeta;
     }): Promise<LoginResponse>;
+    loginWithExternalSignature(address: string, signedMessage: string, options?: {
+        referralCode?: string;
+        walletMeta?: WalletMeta;
+    }): Promise<LoginResponse>;
     logout(): void;
     isAuthenticated(): boolean;
+    getSessionStats(): Promise<SessionStats>;
     getLatestSessions(limit?: number): Promise<PaginatedSessions>;
 }
 
@@ -1025,6 +1121,11 @@ declare class Admin {
     private http;
     private logger?;
     constructor(http: IHttpClient, logger?: ILogger | undefined);
+    getInternalBots(): Promise<(User & {
+        sol: number;
+        usdc: number;
+        publicKey: string;
+    })[]>;
     getUserById(id: string): Promise<User>;
     getUserBalance(userId: string): Promise<{
         sol: number;
@@ -1108,8 +1209,14 @@ declare class Users {
     removeFriend(userId: string): Promise<{
         message: string;
     }>;
-    getIncomingFriendRequests(): Promise<FriendRequestItem[]>;
-    getOutgoingFriendRequests(): Promise<FriendRequestItem[]>;
+    getIncomingFriendRequests(opts?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<PaginatedFriendRequests>;
+    getOutgoingFriendRequests(opts?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<PaginatedFriendRequests>;
     acceptFriendRequest(userId: string): Promise<{
         message: string;
     }>;
@@ -1159,141 +1266,238 @@ declare class FeatureFlags {
     private loaded;
     constructor(http: IHttpClient, logger?: ILogger | undefined);
     getFeatureFlags(): Promise<FeatureFlag[]>;
+    getAdminFeatureFlags(): Promise<AdminFeatureFlag[]>;
     isEnabledFlag(name: string): boolean;
     isLoaded(): boolean;
     updateFeatureFlag(name: string, enabled: boolean): Promise<FeatureFlag>;
-    createFeatureFlag(name: string, enabled: boolean): Promise<FeatureFlag>;
+    createFeatureFlag(name: string, enabled: boolean, description?: string): Promise<AdminFeatureFlag>;
 }
 
-interface BetOption {
-    amount: MoneyMinor;
-    playersOnline: number;
-    estimatedTime: string;
-}
-interface LobbyPlayer {
-    userId: string;
-    username?: string;
-    avatar?: string;
-    joinedAt: string;
-    connected?: boolean;
-    /** USDC balance in minor units (cached, short TTL). Shown in lobby and used to gate Start Game. */
-    usdcBalance?: number;
-}
-interface Lobby {
-    id: string;
-    gameType: string;
-    gameName: string;
-    status: 'waiting' | 'preparing' | 'queued' | 'active';
-    creatorId: string;
-    maxPlayers: number;
-    betAmount?: MoneyMinor;
-    betOptions?: BetOption[];
-    gameId?: string;
-    createdAt: string;
-    updatedAt: string;
-    players: LobbyPlayer[];
-}
-interface CreateLobbyRequest {
-    gameType: string;
-}
-interface InviteFriendRequest {
-    friendId: string;
+/**
+ * Retry configuration options
+ */
+interface RetryOptions {
+    /** Maximum number of retry attempts (default: 3) */
+    maxAttempts?: number;
+    /** Base delay in milliseconds (default: 1000) */
+    baseDelayMs?: number;
+    /** Maximum delay in milliseconds (default: 10000) */
+    maxDelayMs?: number;
+    /** Multiplier for exponential backoff (default: 2) */
+    backoffMultiplier?: number;
+    /** Function to determine if error is retryable (default: network/5xx errors) */
+    isRetryable?: (error: unknown) => boolean;
+    /** Callback for each retry attempt */
+    onRetry?: (attempt: number, error: unknown, delayMs: number) => void;
 }
-interface QueueStats {
-    totalPlayersInQueue: number;
-    queueSizes: Record<string, number>;
-    totalQueuedLobbies: number;
+/**
+ * Default function to determine if an error is retryable.
+ * Retries on network errors and 5xx server errors.
+ */
+declare function isRetryableError(error: unknown): boolean;
+/**
+ * Execute an async function with exponential backoff retry.
+ *
+ * @param fn - Async function to execute
+ * @param options - Retry configuration
+ * @returns Promise resolving to the function result
+ * @throws Last error if all retries exhausted
+ *
+ * @example
+ * ```typescript
+ * const result = await withRetry(
+ *   () => fetch('/api/data'),
+ *   { maxAttempts: 3, baseDelayMs: 500 }
+ * );
+ * ```
+ */
+declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+
+type EqualityFn<T> = (a: T, b: T) => boolean;
+interface SdkStore<S> {
+    getSnapshot(): S;
+    getState(): S;
+    setState(next: S): void;
+    updateState(updater: (prev: S) => S): void;
+    subscribe(listener: () => void): () => void;
+    subscribeSelector<T>(selector: (state: S) => T, listener: () => void, isEqual?: EqualityFn<T>): () => void;
 }
-type ChatMessageType = 'user' | 'system';
-type SystemMessageType = 'player_joined' | 'player_left' | 'bet_changed' | 'call_joined' | 'call_left' | 'global_help' | 'global_challenge' | 'global_tip' | 'spectator_donation' | 'challenge_accepted' | 'challenge_declined';
-interface ChatMessageReply {
+declare function createSdkStore<S>(initial: S): SdkStore<S>;
+
+type DmThreadsStoreState = {
+    threads: DmThread[];
+    loading: boolean;
+    error: string | null;
+    needsRefresh: boolean;
+};
+type DmThreadsStore = {
+    store: SdkStore<DmThreadsStoreState>;
+    setBaseState: (threads: DmThread[]) => void;
+    setLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    setCurrentUserId: (userId: string | null) => void;
+    applyWsEvent: (event: WsEvent) => void;
+};
+declare function createDmThreadsStore(): DmThreadsStore;
+
+type ChatContextType = 'lobby' | 'game' | 'dm' | 'global';
+interface ChatContext {
+    type: ChatContextType;
     id: string;
-    userId?: string;
-    username?: string;
-    message: string;
-}
-interface ChatReaction {
-    emoji: string;
-    userId: string;
-    username?: string;
-    createdAt: string;
-}
-interface ChatReadBy {
-    userId: string;
-    readAt: string;
 }
-interface ChatMessage {
-    id: string;
-    lobbyId: string;
-    userId?: string;
-    username?: string;
-    avatarUrl?: string;
+interface SendMessageRequest {
     message: string;
-    type: ChatMessageType;
-    systemType?: SystemMessageType;
-    metadata?: Record<string, any>;
     replyTo?: ChatMessageReply;
-    reactions?: ChatReaction[];
-    readBy?: ChatReadBy[];
-    createdAt: string;
+    gifUrl?: string;
 }
-
-declare class Lobbies {
+interface DmThread {
+    dmKey: string;
+    otherUser: PublicUser;
+    lastMessage: string | null;
+    lastMessageAt: string | null;
+    lastMessageSenderId: string | null;
+    lastMessageSenderUsername: string | null;
+    unreadCount: number;
+}
+declare class Chat {
     private http;
     private logger?;
-    constructor(http: IHttpClient, logger?: ILogger | undefined);
-    createLobby(gameType: string, betAmount?: MoneyMinor): Promise<Lobby>;
-    getLobby(lobbyId: string): Promise<Lobby>;
-    inviteFriend(lobbyId: string, friendId: string): Promise<{
-        message: string;
-    }>;
-    acceptInvite(lobbyId: string): Promise<Lobby>;
-    joinLobby(lobbyId: string): Promise<Lobby>;
-    removePlayer(lobbyId: string, userId: string): Promise<{
-        message: string;
-    }>;
-    kickPlayer(lobbyId: string, userId: string): Promise<{
-        message: string;
-    }>;
-    leaveLobby(lobbyId: string): Promise<{
-        message: string;
-    }>;
-    joinQueue(lobbyId: string): Promise<Lobby>;
-    cancelQueue(lobbyId: string): Promise<Lobby>;
-    updateBetAmount(lobbyId: string, betAmount: MoneyMinor): Promise<Lobby>;
-    playSound(lobbyId: string, sound: string): Promise<{
-        success: boolean;
-    }>;
-    getActiveLobbies(): Promise<Lobby[]>;
-    getQueueStats(): Promise<QueueStats>;
-    deleteLobby(lobbyId: string): Promise<{
-        message: string;
-    }>;
+    private retryOptions;
+    private dmThreadsStore?;
+    constructor(http: IHttpClient, logger?: any | undefined, retryOptions?: RetryOptions);
+    setDmThreadsStore(store: DmThreadsStore): void;
+    private encodeContextId;
     /**
-     * Play again: Create a new lobby and prepare deposit in one flow.
-     * Returns the lobby and unsigned transaction that needs to be signed.
-     * @param gameType - The game type to play again
-     * @param betAmount - The bet amount (same as previous game)
-     * @param escrow - The escrow service instance (from sdk.escrow)
+     * Send a chat message with automatic retry on transient failures
+     *
+     * @param clientMessageId - Optional client-generated ID for optimistic UI.
+     *                          Echoed back in response metadata for deduplication.
      */
-    playAgain(gameType: string, betAmount: MoneyMinor, escrow: {
-        prepareAndStartDeposit: (id: string) => Promise<{
-            transaction: string;
-            message: string;
-        }>;
-    }): Promise<{
-        lobby: Lobby;
-        unsignedTransaction: string;
+    sendMessage(context: ChatContext, message: string, replyTo?: ChatMessageReply, gifUrl?: string, clientMessageId?: string): Promise<ChatMessage>;
+    /** Response from paginated chat history */
+    getChatHistory(context: ChatContext, limit?: number, cursor?: string): Promise<ChatMessage[]>;
+    /**
+     * Get chat history with pagination support.
+     * Returns messages and a cursor for loading older messages.
+     * For global context, uses the public endpoint so it works without auth.
+     */
+    getChatHistoryPaginated(context: ChatContext, limit?: number, cursor?: string): Promise<{
+        messages: ChatMessage[];
+        nextCursor: string | null;
     }>;
-}
-
-interface GameType {
-    id: string;
-    name: string;
-    maxPlayers: number;
-    minPlayers: number;
-    description?: string;
-    /** Agent-facing instructions including game pace (how fast the game is). */
+    /**
+     * Add a reaction to a message
+     */
+    addReaction(context: ChatContext, messageId: string, emoji: string): Promise<ChatMessage>;
+    /**
+     * Remove a reaction from a message
+     */
+    removeReaction(context: ChatContext, messageId: string, emoji: string): Promise<ChatMessage>;
+    /**
+     * Mark a message as read
+     */
+    markAsRead(context: ChatContext, messageId: string): Promise<ChatMessage>;
+    listDmThreads(): Promise<DmThread[]>;
+    getDmThread(dmKey: string): Promise<DmThread>;
+    /**
+     * Mark all messages in a DM thread as read
+     */
+    markDmThreadAsRead(dmKey: string): Promise<{
+        markedCount: number;
+    }>;
+    /**
+     * Accept a global chat challenge. Returns the lobby (and gameId if started).
+     */
+    acceptGlobalChallenge(challengeId: string): Promise<{
+        lobbyId: string;
+        gameId?: string;
+        status: string;
+    }>;
+    /**
+     * Broadcast a tip message to global chat (call after the user has signed and submitted the transfer).
+     */
+    broadcastGlobalTip(recipientUserId: string, amount: number): Promise<ChatMessage>;
+}
+
+type GameStoreState = {
+    gamesById: Record<string, Game>;
+    /** Real-time spectator counts by userId, updated via spectator:count:updated WS events. */
+    spectatorCounts: Record<string, number>;
+};
+type GameStore = {
+    store: SdkStore<GameStoreState>;
+    setBaseState: (games: Game[]) => void;
+    applyWsEvent: (event: WsEvent) => void;
+    joinGame: (gameId: string) => () => void;
+    /** Join the spectate channel for a user. Returns a leave function. */
+    joinSpectateChannel: (spectatedUserId: string) => () => void;
+    /** Get a snapshot of the spectator count for a user (from the store). */
+    getSpectatorCount: (userId: string) => number;
+};
+declare function createGameStore(transport: WsTransport): GameStore;
+
+type GameActionsStoreState = {
+    statesByGameId: Record<string, GameStateResponse>;
+};
+interface ChessClockTimes {
+    whiteTimeMs: number;
+    blackTimeMs: number;
+}
+interface ChessCapturedPieces {
+    capturedByWhite: string[];
+    capturedByBlack: string[];
+}
+interface TicTacToeClockTimes {
+    xTimeMs: number;
+    oTimeMs: number;
+}
+interface Connect4ClockTimes {
+    redTimeMs: number;
+    yellowTimeMs: number;
+}
+/**
+ * Common lifecycle fields extracted from any game state.
+ * Used by useGameLifecycle to avoid casting the raw union type.
+ */
+interface GameLifecycleState {
+    status: string;
+    winnerId: string | null;
+    betAmount: number;
+    wonAmount: number | null;
+    totalPotMinor: number | undefined;
+    currentPlayerId: string | null;
+}
+/**
+ * Pure selector — extracts lifecycle fields from any game state variant.
+ * Accepts a single GameStateResponse so callers can use it after selecting
+ * the stable store entry via useSdkSelector, avoiding new-object-per-call issues.
+ */
+declare function selectGameLifecycleState(gameState: GameStateResponse | null | undefined): GameLifecycleState | null;
+type GameActionsStore = {
+    store: SdkStore<GameActionsStoreState>;
+    setBaseState: (gameId: string, state: GameStateResponse) => void;
+    clearState: (gameId: string) => void;
+    applyWsEvent: (event: WsEvent) => void;
+    joinGame: (gameId: string) => () => void;
+    getCountdownDigit: (gameId: string, nowMs: number) => number | null;
+    /** Live chess clock — deducts elapsed time since turnStartedAt. */
+    getChessClockTimes: (gameId: string, nowMs: number) => ChessClockTimes | null;
+    /** Captured pieces derived from the current FEN position. */
+    getChessCapturedPieces: (gameId: string) => ChessCapturedPieces | null;
+    /** Live TTT clock — deducts elapsed from the current player's mark (X or O). */
+    getTicTacToeClockTimes: (gameId: string, nowMs: number) => TicTacToeClockTimes | null;
+    /** Live Connect Four clock — deducts elapsed from the current player's color. */
+    getConnect4ClockTimes: (gameId: string, nowMs: number) => Connect4ClockTimes | null;
+};
+declare function createGameActionsStore(transport: WsTransport): GameActionsStore;
+
+interface GameType {
+    id: string;
+    name: string;
+    maxPlayers: number;
+    minPlayers: number;
+    description?: string;
+    /** Agent-facing instructions including game pace (how fast the game is). */
     detailedInstructions?: string;
     available: boolean;
     betOptions?: BetOption[];
@@ -1392,7 +1596,11 @@ declare class Games {
     private http;
     private wallet;
     private logger?;
+    private gameStore?;
+    private gameActionsStore?;
     constructor(http: IHttpClient, wallet: Wallet, logger?: ILogger | undefined);
+    setGameStore(store: GameStore): void;
+    setGameActionsStore(store: GameActionsStore): void;
     getAvailableGames(): Promise<GameType[]>;
     /**
      * Get real-time metrics for all games.
@@ -1455,8 +1663,16 @@ declare class Games {
         signature: string;
         status: string;
     }>;
+    /**
+     * Confirm a donation that was already sent by the client (signAndSendTransaction path).
+     */
+    confirmGameDonationSignature(gameId: string, amountMinor: number, signature: string): Promise<{
+        signature: string;
+        status: string;
+    }>;
     /**
      * One-call donation flow: prepare -> sign -> submit.
+     * Automatically uses the right signing path (embedded vs injected wallet).
      */
     sendDonation(gameId: string, amountMinor: number): Promise<DonateToGameResponse>;
     /**
@@ -1466,249 +1682,6 @@ declare class Games {
     notifyRematchLobbyCreated(gameId: string, lobbyId: string): Promise<void>;
 }
 
-/** A player currently in an active game; used for "Live now" and "Who to watch" UI. */
-interface LivePlayer {
-    userId: string;
-    username: string;
-    avatar?: string;
-    gameId: string;
-    gameType: string;
-    spectatorCount: number;
-}
-/** Paginated response for live players (newest first, sample of games per page). */
-interface LivePlayersPage {
-    items: LivePlayer[];
-    nextCursor: string | null;
-}
-/**
- * SDK class for spectate discovery — finding who to watch.
- *
- * @example
- * ```ts
- * const page = await sdk.spectate.getLivePlayers({ limit: 10 });
- * console.log(page.items); // LivePlayer[]
- * ```
- */
-declare class Spectate {
-    private http;
-    private logger?;
-    constructor(http: IHttpClient, logger?: ILogger | undefined);
-    /**
-     * Get list of live players (one per unique player), sampled from newest games, paginated.
-     * Use for "Live now" and "Who to watch" UI; link to /spectate/:username.
-     * @param options.limit - Number of games to consider per page (1–20, default 10).
-     * @param options.cursor - Opaque cursor from previous page for next page.
-     */
-    getLivePlayers(options?: {
-        limit?: number;
-        cursor?: string;
-    }): Promise<LivePlayersPage>;
-}
-
-/**
- * Retry configuration options
- */
-interface RetryOptions {
-    /** Maximum number of retry attempts (default: 3) */
-    maxAttempts?: number;
-    /** Base delay in milliseconds (default: 1000) */
-    baseDelayMs?: number;
-    /** Maximum delay in milliseconds (default: 10000) */
-    maxDelayMs?: number;
-    /** Multiplier for exponential backoff (default: 2) */
-    backoffMultiplier?: number;
-    /** Function to determine if error is retryable (default: network/5xx errors) */
-    isRetryable?: (error: unknown) => boolean;
-    /** Callback for each retry attempt */
-    onRetry?: (attempt: number, error: unknown, delayMs: number) => void;
-}
-/**
- * Default function to determine if an error is retryable.
- * Retries on network errors and 5xx server errors.
- */
-declare function isRetryableError(error: unknown): boolean;
-/**
- * Execute an async function with exponential backoff retry.
- *
- * @param fn - Async function to execute
- * @param options - Retry configuration
- * @returns Promise resolving to the function result
- * @throws Last error if all retries exhausted
- *
- * @example
- * ```typescript
- * const result = await withRetry(
- *   () => fetch('/api/data'),
- *   { maxAttempts: 3, baseDelayMs: 500 }
- * );
- * ```
- */
-declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
-
-type ChatContextType = 'lobby' | 'game' | 'dm' | 'global';
-interface ChatContext {
-    type: ChatContextType;
-    id: string;
-}
-interface SendMessageRequest {
-    message: string;
-    replyTo?: ChatMessageReply;
-    gifUrl?: string;
-}
-interface DmThread {
-    dmKey: string;
-    otherUser: PublicUser;
-    lastMessage: string | null;
-    lastMessageAt: string | null;
-    lastMessageSenderId: string | null;
-    lastMessageSenderUsername: string | null;
-    unreadCount: number;
-}
-declare class Chat {
-    private http;
-    private logger?;
-    private retryOptions;
-    constructor(http: IHttpClient, logger?: any | undefined, retryOptions?: RetryOptions);
-    private encodeContextId;
-    /**
-     * Send a chat message with automatic retry on transient failures
-     *
-     * @param clientMessageId - Optional client-generated ID for optimistic UI.
-     *                          Echoed back in response metadata for deduplication.
-     */
-    sendMessage(context: ChatContext, message: string, replyTo?: ChatMessageReply, gifUrl?: string, clientMessageId?: string): Promise<ChatMessage>;
-    /** Response from paginated chat history */
-    getChatHistory(context: ChatContext, limit?: number, cursor?: string): Promise<ChatMessage[]>;
-    /**
-     * Get chat history with pagination support.
-     * Returns messages and a cursor for loading older messages.
-     * For global context, uses the public endpoint so it works without auth.
-     */
-    getChatHistoryPaginated(context: ChatContext, limit?: number, cursor?: string): Promise<{
-        messages: ChatMessage[];
-        nextCursor: string | null;
-    }>;
-    /**
-     * Add a reaction to a message
-     */
-    addReaction(context: ChatContext, messageId: string, emoji: string): Promise<ChatMessage>;
-    /**
-     * Remove a reaction from a message
-     */
-    removeReaction(context: ChatContext, messageId: string, emoji: string): Promise<ChatMessage>;
-    /**
-     * Mark a message as read
-     */
-    markAsRead(context: ChatContext, messageId: string): Promise<ChatMessage>;
-    listDmThreads(): Promise<DmThread[]>;
-    getDmThread(dmKey: string): Promise<DmThread>;
-    /**
-     * Mark all messages in a DM thread as read
-     */
-    markDmThreadAsRead(dmKey: string): Promise<{
-        markedCount: number;
-    }>;
-    /**
-     * Accept a global chat challenge. Returns the lobby (and gameId if started).
-     */
-    acceptGlobalChallenge(challengeId: string): Promise<{
-        lobbyId: string;
-        gameId?: string;
-        status: string;
-    }>;
-    /**
-     * Broadcast a tip message to global chat (call after the user has signed and submitted the transfer).
-     */
-    broadcastGlobalTip(recipientUserId: string, amount: number): Promise<ChatMessage>;
-}
-
-interface CreateChallengeRequest {
-    gameType: string;
-    amount: number;
-    targetUserId?: string;
-    targetUsername?: string;
-    /** When set, post challenge system message to this DM thread (format: "userId1:userId2" sorted). */
-    dmKey?: string;
-}
-interface CreateChallengeResponse {
-    challengeId: string;
-    challengerId: string;
-    targetUserId: string;
-    gameType: string;
-    amountMinor: number;
-    challengerUsername?: string;
-}
-interface AcceptChallengeResponse {
-    lobbyId: string;
-    gameId?: string;
-    status: string;
-}
-declare class Challenges {
-    private http;
-    private logger?;
-    constructor(http: IHttpClient, logger?: any | undefined);
-    /**
-     * Create a challenge (any user can challenge any other user by id or username).
-     */
-    create(dto: CreateChallengeRequest): Promise<CreateChallengeResponse>;
-    /**
-     * Accept a challenge. Only the challenged user can accept. Creates a lobby with the challenge amount and adds both users.
-     */
-    accept(challengeId: string): Promise<AcceptChallengeResponse>;
-    /**
-     * Decline a challenge. Only the challenged user can decline. Optionally post a "declined" message to the DM thread.
-     */
-    decline(challengeId: string, dmKey?: string): Promise<{
-        message?: string;
-    }>;
-}
-
-interface PrepareTipRequest {
-    recipientUsername: string;
-    amount: number;
-}
-interface PrepareTipResponse {
-    transaction: string;
-    fee: number;
-    totalAmount: number;
-    recipientAddress: string;
-    recipientUserId: string;
-    recipientUsername: string;
-    amount: number;
-}
-interface BroadcastTipRequest {
-    recipientUserId: string;
-    amount: number;
-}
-interface SendTipResponse extends SubmitTransferResponse {
-    recipientAddress: string;
-    recipientUserId: string;
-    recipientUsername: string;
-    amount: number;
-    fee: number;
-    totalAmount: number;
-    message: ChatMessage;
-}
-/**
- * Tips are a shorthand for wallet send + global tip broadcast.
- */
-declare class Tips {
-    private http;
-    private wallet;
-    private chat;
-    private logger?;
-    constructor(http: IHttpClient, wallet: Wallet, chat: Chat, logger?: any | undefined);
-    prepare(dto: PrepareTipRequest): Promise<PrepareTipResponse>;
-    /**
-     * Broadcast a tip message to global chat (call after the transfer has been submitted).
-     */
-    broadcast(dto: BroadcastTipRequest): Promise<ChatMessage>;
-    /**
-     * One-call tip flow: prepare -> sign -> submit transfer -> broadcast tip message.
-     */
-    send(recipientUsername: string, amount: number): Promise<SendTipResponse>;
-}
-
 type WsEventName = 'lobby:created' | 'lobby:updated' | 'lobby:player:joined' | 'lobby:player:left' | 'lobby:player:connected' | 'lobby:player:disconnected' | 'lobby:bet:updated' | 'lobby:invitation' | 'lobby:deleted' | 'lobby:queue:joined' | 'lobby:queue:cancelled' | 'lobby:matched' | 'lobby:deposit:updated' | 'lobby:typing:start' | 'lobby:typing:stop' | 'game:updated' | 'game:completed' | 'game:paid' | 'game:abandoned' | 'game:turn' | 'game:move' | 'game:state' | 'game:player:connected' | 'game:player:disconnected' | 'game:rps:starting' | 'game:rps:round:started' | 'game:rps:action:received' | 'game:rps:timer:cutoff' | 'game:rps:round:reveal' | 'game:rps:round:completed' | 'game:rps:timeout' | 'game:rematch:requested' | 'game:rematch:cancelled' | 'game:rematch:started' | 'game:rematch:lobby:created' | 'game:pot:updated' | 'game:market:price:updated' | 'game:market:order:filled' | 'game:market:resolved' | 'spectator:count:updated' | 'chat:message' | 'chat:reaction' | 'chat:read' | 'chat:typing' | 'notification';
 type GameTurnPayload = {
     turn: number;
@@ -1815,10 +1788,10 @@ type MarketResolvedPayload = {
 type LobbyDepositUpdatedPayload = {
     lobbyId: string;
     userId: string;
-    status: string;
+    status: 'confirmed' | 'failed' | 'refunded' | 'refund_failed';
     allConfirmed: boolean;
 };
-type WsEvent = {
+type WsEventBase = {
     event: 'lobby:created';
     payload: Lobby;
 } | {
@@ -2016,17 +1989,282 @@ type WsEvent = {
     event: 'notification';
     payload: unknown;
 };
+type WsEvent = WsEventBase & {
+    _serverTs?: number;
+};
+
+type LobbyMatchedEvent = {
+    gameId: string;
+    gameType: string;
+    matchedLobbies: Lobby[];
+};
+type LobbyStoreState = {
+    lobbiesById: Record<string, Lobby>;
+    matchedEvent: LobbyMatchedEvent | null;
+    typingByLobbyId: Record<string, string[]>;
+    depositStatusByLobbyId: Record<string, LobbyDepositUpdatedPayload>;
+};
+type LobbyStore = {
+    store: SdkStore<LobbyStoreState>;
+    setBaseState: (lobbies: Lobby[]) => void;
+    applyWsEvent: (event: WsEvent) => void;
+    joinLobby: (lobbyId: string) => () => void;
+    subscribeMatched: (callback: (event: LobbyMatchedEvent) => void) => () => void;
+    subscribeDepositUpdate: (lobbyId: string, callback: (data: LobbyDepositUpdatedPayload) => void) => () => void;
+};
+declare function createLobbyStore(transport: WsTransport): LobbyStore;
+
+interface BetOption {
+    amount: MoneyMinor;
+    playersOnline: number;
+    estimatedTime: string;
+}
+interface LobbyPlayer {
+    userId: string;
+    username?: string;
+    avatar?: string;
+    joinedAt: string;
+    connected?: boolean;
+    /** USDC balance in minor units (cached, short TTL). Shown in lobby and used to gate Start Game. */
+    usdcBalance?: number;
+}
+interface Lobby {
+    id: string;
+    gameType: string;
+    gameName: string;
+    status: 'waiting' | 'preparing' | 'queued' | 'active';
+    creatorId: string;
+    maxPlayers: number;
+    betAmount?: MoneyMinor;
+    betOptions?: BetOption[];
+    gameId?: string;
+    createdAt: string;
+    updatedAt: string;
+    players: LobbyPlayer[];
+}
+interface CreateLobbyRequest {
+    gameType: string;
+}
+interface InviteFriendRequest {
+    friendId: string;
+}
+interface QueueStats {
+    totalPlayersInQueue: number;
+    queueSizes: Record<string, number>;
+    totalQueuedLobbies: number;
+}
+type ChatMessageType = 'user' | 'system';
+type SystemMessageType = 'player_joined' | 'player_left' | 'bet_changed' | 'call_joined' | 'call_left' | 'global_help' | 'global_challenge' | 'global_tip' | 'spectator_donation' | 'challenge_accepted' | 'challenge_declined';
+interface ChatMessageReply {
+    id: string;
+    userId?: string;
+    username?: string;
+    message: string;
+}
+interface ChatReaction {
+    emoji: string;
+    userId: string;
+    username?: string;
+    createdAt: string;
+}
+interface ChatReadBy {
+    userId: string;
+    readAt: string;
+}
+interface ChatMessage {
+    id: string;
+    lobbyId: string;
+    userId?: string;
+    username?: string;
+    avatarUrl?: string;
+    message: string;
+    type: ChatMessageType;
+    systemType?: SystemMessageType;
+    metadata?: Record<string, any>;
+    replyTo?: ChatMessageReply;
+    reactions?: ChatReaction[];
+    readBy?: ChatReadBy[];
+    createdAt: string;
+}
+
+declare class Lobbies {
+    private http;
+    private logger?;
+    private lobbyStore?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    /** Called by SDK after the store is created so mutations can update state directly. */
+    setLobbyStore(store: LobbyStore): void;
+    createLobby(gameType: string, betAmount?: MoneyMinor): Promise<Lobby>;
+    getLobby(lobbyId: string): Promise<Lobby>;
+    inviteFriend(lobbyId: string, friendId: string): Promise<{
+        message: string;
+    }>;
+    acceptInvite(lobbyId: string): Promise<Lobby>;
+    joinLobby(lobbyId: string): Promise<Lobby>;
+    removePlayer(lobbyId: string, userId: string): Promise<{
+        message: string;
+    }>;
+    kickPlayer(lobbyId: string, userId: string): Promise<{
+        message: string;
+    }>;
+    leaveLobby(lobbyId: string): Promise<{
+        message: string;
+    }>;
+    joinQueue(lobbyId: string): Promise<Lobby>;
+    cancelQueue(lobbyId: string): Promise<Lobby>;
+    updateBetAmount(lobbyId: string, betAmount: MoneyMinor): Promise<Lobby>;
+    playSound(lobbyId: string, sound: string): Promise<{
+        success: boolean;
+    }>;
+    getActiveLobbies(): Promise<Lobby[]>;
+    getQueueStats(): Promise<QueueStats>;
+    deleteLobby(lobbyId: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * Play again: Create a new lobby and prepare deposit in one flow.
+     * Returns the lobby and unsigned transaction that needs to be signed.
+     * @param gameType - The game type to play again
+     * @param betAmount - The bet amount (same as previous game)
+     * @param escrow - The escrow service instance (from sdk.escrow)
+     */
+    playAgain(gameType: string, betAmount: MoneyMinor, escrow: {
+        prepareAndStartDeposit: (id: string) => Promise<{
+            transaction: string;
+            message: string;
+        }>;
+    }): Promise<{
+        lobby: Lobby;
+        unsignedTransaction: string;
+    }>;
+}
 
-type EqualityFn<T> = (a: T, b: T) => boolean;
-interface SdkStore<S> {
-    getSnapshot(): S;
-    getState(): S;
-    setState(next: S): void;
-    updateState(updater: (prev: S) => S): void;
-    subscribe(listener: () => void): () => void;
-    subscribeSelector<T>(selector: (state: S) => T, listener: () => void, isEqual?: EqualityFn<T>): () => void;
+/** A player currently in an active game; used for "Live now" and "Who to watch" UI. */
+interface LivePlayer {
+    userId: string;
+    username: string;
+    avatar?: string;
+    gameId: string;
+    gameType: string;
+    spectatorCount: number;
+}
+/** Paginated response for live players (newest first, sample of games per page). */
+interface LivePlayersPage {
+    items: LivePlayer[];
+    nextCursor: string | null;
+}
+/**
+ * SDK class for spectate discovery — finding who to watch.
+ *
+ * @example
+ * ```ts
+ * const page = await sdk.spectate.getLivePlayers({ limit: 10 });
+ * console.log(page.items); // LivePlayer[]
+ * ```
+ */
+declare class Spectate {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    /**
+     * Get list of live players (one per unique player), sampled from newest games, paginated.
+     * Use for "Live now" and "Who to watch" UI; link to /spectate/:username.
+     * @param options.limit - Number of games to consider per page (1–20, default 10).
+     * @param options.cursor - Opaque cursor from previous page for next page.
+     */
+    getLivePlayers(options?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<LivePlayersPage>;
+}
+
+interface CreateChallengeRequest {
+    gameType: string;
+    amount: number;
+    targetUserId?: string;
+    targetUsername?: string;
+    /** When set, post challenge system message to this DM thread (format: "userId1:userId2" sorted). */
+    dmKey?: string;
+}
+interface CreateChallengeResponse {
+    challengeId: string;
+    challengerId: string;
+    targetUserId: string;
+    gameType: string;
+    amountMinor: number;
+    challengerUsername?: string;
+}
+interface AcceptChallengeResponse {
+    lobbyId: string;
+    gameId?: string;
+    status: string;
+}
+declare class Challenges {
+    private http;
+    private logger?;
+    constructor(http: IHttpClient, logger?: any | undefined);
+    /**
+     * Create a challenge (any user can challenge any other user by id or username).
+     */
+    create(dto: CreateChallengeRequest): Promise<CreateChallengeResponse>;
+    /**
+     * Accept a challenge. Only the challenged user can accept. Creates a lobby with the challenge amount and adds both users.
+     */
+    accept(challengeId: string): Promise<AcceptChallengeResponse>;
+    /**
+     * Decline a challenge. Only the challenged user can decline. Optionally post a "declined" message to the DM thread.
+     */
+    decline(challengeId: string, dmKey?: string): Promise<{
+        message?: string;
+    }>;
+}
+
+interface PrepareTipRequest {
+    recipientUsername: string;
+    amount: number;
+    supportsPresign?: boolean;
+}
+interface PrepareTipResponse {
+    transaction: string;
+    fee: number;
+    totalAmount: number;
+    recipientAddress: string;
+    recipientUserId: string;
+    recipientUsername: string;
+    amount: number;
+}
+interface BroadcastTipRequest {
+    recipientUserId: string;
+    amount: number;
+}
+interface SendTipResponse extends SubmitTransferResponse {
+    recipientAddress: string;
+    recipientUserId: string;
+    recipientUsername: string;
+    amount: number;
+    fee: number;
+    totalAmount: number;
+    message: ChatMessage;
+}
+/**
+ * Tips are a shorthand for wallet send + global tip broadcast.
+ */
+declare class Tips {
+    private http;
+    private wallet;
+    private chat;
+    private logger?;
+    constructor(http: IHttpClient, wallet: Wallet, chat: Chat, logger?: any | undefined);
+    prepare(dto: PrepareTipRequest): Promise<PrepareTipResponse>;
+    /**
+     * Broadcast a tip message to global chat (call after the transfer has been submitted).
+     */
+    broadcast(dto: BroadcastTipRequest): Promise<ChatMessage>;
+    /**
+     * One-call tip flow: prepare -> sign -> submit transfer -> broadcast tip message.
+     */
+    send(recipientUsername: string, amount: number): Promise<SendTipResponse>;
 }
-declare function createSdkStore<S>(initial: S): SdkStore<S>;
 
 type NotificationEvent = {
     title: string;
@@ -2050,6 +2288,9 @@ type NotificationsStore = {
     applyWsEvent: (event: WsEvent) => void;
     setListFromApi: (res: PaginatedNotificationsResponse) => void;
     clear: () => void;
+    markAsRead: (id: string) => void;
+    markAllAsRead: () => void;
+    dismiss: (id: string) => void;
 };
 declare function createNotificationsStore(): NotificationsStore;
 
@@ -2159,7 +2400,15 @@ declare class Escrow {
      * initializes depositStatus, and prepares the unsigned transaction in one call.
      * Eliminates one HTTP round-trip vs startDeposits() + prepareDepositTransaction().
      */
-    prepareAndStartDeposit(lobbyId: string): Promise<PrepareDepositResponse>;
+    prepareAndStartDeposit(lobbyId: string, supportsPresign?: boolean): Promise<PrepareDepositResponse>;
+    /**
+     * Sign and submit a prepared (unsigned) deposit transaction using the
+     * configured signer. Automatically picks the right path:
+     *   - Embedded wallet: signAndSendTransaction → confirmDepositSignature
+     *   - Injected wallet: signTransaction → submitDeposit
+     * Returns the on-chain signature.
+     */
+    signAndSubmitPreparedDeposit(lobbyId: string, unsignedTxBase64: string): Promise<string>;
     /**
      * Submit a signed deposit transaction
      * The transaction will be submitted to the Solana network and confirmed
@@ -2184,8 +2433,13 @@ declare class Escrow {
      */
     depositForLobby(lobbyId: string): Promise<DepositForLobbyResponse>;
     /**
-     * Zero-polling deposit variant using server-side awaitConfirmation.
-     * 2 HTTP calls total, 0 client-side polling. Ideal for agents.
+     * Deposit for a lobby and wait until the calling user's own deposit is confirmed.
+     * Ideal for agents: returns as soon as your deposit is on-chain without waiting
+     * for the other player. The server auto-joins the queue when all players deposit.
+     *
+     * Confirmation is handled asynchronously by the transaction queue processor.
+     * This method polls the deposit status endpoint until the signature appears as
+     * confirmed (up to 60 seconds).
      *
      * Automatically uses signAndSendTransaction or signTransaction based on signer capability.
      */
@@ -2500,7 +2754,8 @@ interface AdminMarketDetail {
 declare class Markets {
     private http;
     private logger?;
-    constructor(http: IHttpClient, logger?: ILogger | undefined);
+    private wallet?;
+    constructor(http: IHttpClient, logger?: ILogger | undefined, wallet?: Wallet | undefined);
     /**
      * Get the prediction market state for a game.
      * Returns prices, volume, collateral, and resolution status.
@@ -2529,6 +2784,15 @@ declare class Markets {
      * @param amountMinor - Amount to spend in USDC minor units
      */
     submitBuyOrder(gameId: string, signedTransaction: string, outcomeId: string, amountMinor: number): Promise<MarketBuyResult>;
+    /**
+     * Confirm a buy order that was already broadcast by the client (signAndSendTransaction path).
+     */
+    confirmBuyOrderSignature(gameId: string, depositSignature: string, outcomeId: string, amountMinor: number): Promise<MarketBuyResult>;
+    /**
+     * One-call buy order: prepare → sign → submit, automatically choosing
+     * the right signing path (embedded vs injected wallet).
+     */
+    buy(gameId: string, outcomeId: string, amountMinor: number): Promise<MarketBuyResult>;
     /**
      * Sell shares back to the AMM pool.
      * @param gameId - The game ID
@@ -2562,56 +2826,6 @@ declare class Markets {
     }>;
 }
 
-type LobbyMatchedEvent = {
-    gameId: string;
-    gameType: string;
-    matchedLobbies: Lobby[];
-};
-type LobbyStoreState = {
-    lobbiesById: Record<string, Lobby>;
-    matchedEvent: LobbyMatchedEvent | null;
-    typingByLobbyId: Record<string, string[]>;
-    depositStatusByLobbyId: Record<string, LobbyDepositUpdatedPayload>;
-};
-type LobbyStore = {
-    store: SdkStore<LobbyStoreState>;
-    setBaseState: (lobbies: Lobby[]) => void;
-    applyWsEvent: (event: WsEvent) => void;
-    joinLobby: (lobbyId: string) => () => void;
-    subscribeMatched: (callback: (event: LobbyMatchedEvent) => void) => () => void;
-    subscribeDepositUpdate: (lobbyId: string, callback: (data: LobbyDepositUpdatedPayload) => void) => () => void;
-};
-declare function createLobbyStore(transport: WsTransport): LobbyStore;
-
-type GameStoreState = {
-    gamesById: Record<string, Game>;
-    /** Real-time spectator counts by userId, updated via spectator:count:updated WS events. */
-    spectatorCounts: Record<string, number>;
-};
-type GameStore = {
-    store: SdkStore<GameStoreState>;
-    setBaseState: (games: Game[]) => void;
-    applyWsEvent: (event: WsEvent) => void;
-    joinGame: (gameId: string) => () => void;
-    /** Join the spectate channel for a user. Returns a leave function. */
-    joinSpectateChannel: (spectatedUserId: string) => () => void;
-    /** Get a snapshot of the spectator count for a user (from the store). */
-    getSpectatorCount: (userId: string) => number;
-};
-declare function createGameStore(transport: WsTransport): GameStore;
-
-type GameActionsStoreState = {
-    statesByGameId: Record<string, GameStateResponse>;
-};
-type GameActionsStore = {
-    store: SdkStore<GameActionsStoreState>;
-    setBaseState: (gameId: string, state: GameStateResponse) => void;
-    clearState: (gameId: string) => void;
-    applyWsEvent: (event: WsEvent) => void;
-    joinGame: (gameId: string) => () => void;
-};
-declare function createGameActionsStore(transport: WsTransport): GameActionsStore;
-
 interface TypingUser {
     userId: string;
     username?: string;
@@ -2633,22 +2847,6 @@ type ChatStore = {
 };
 declare function createChatStore(transport: WsTransport): ChatStore;
 
-type DmThreadsStoreState = {
-    threads: DmThread[];
-    loading: boolean;
-    error: string | null;
-    needsRefresh: boolean;
-};
-type DmThreadsStore = {
-    store: SdkStore<DmThreadsStoreState>;
-    setBaseState: (threads: DmThread[]) => void;
-    setLoading: (loading: boolean) => void;
-    setError: (error: string | null) => void;
-    setCurrentUserId: (userId: string | null) => void;
-    applyWsEvent: (event: WsEvent) => void;
-};
-declare function createDmThreadsStore(): DmThreadsStore;
-
 type FriendshipStatus = 'none' | 'incoming' | 'outgoing' | 'friends';
 type FriendsStoreState = {
     /** Optimistic overrides keyed by userId. Only set when status differs from API (e.g. 'outgoing' after send, cleared when API data arrives). */
@@ -2711,6 +2909,7 @@ declare class SDK {
     notificationsStore: NotificationsStore;
     friendsStore: FriendsStore;
     events: WsEventBus;
+    analytics: IAnalyticsClient;
     private wsRouter;
     constructor(config: SDKConfig);
     /**
@@ -2720,6 +2919,18 @@ declare class SDK {
      * to be connected to the app via WebSocket.
      */
     ensureWebSocketConnected(timeoutMs?: number): Promise<void>;
+    /**
+     * Handle the full deposit-to-queue lifecycle for a lobby.
+     *
+     * After the deposit is confirmed, the backend may not have processed the
+     * `lobby.deposit.allConfirmed` event yet, so the lobby can still be in
+     * 'preparing' status. This method re-fetches the lobby and explicitly
+     * joins the queue if needed, then pushes the latest state to the store
+     * so the UI transitions immediately.
+     */
+    depositAndJoinQueue(lobbyId: string): Promise<DepositForLobbyResponse & {
+        lobby: Lobby;
+    }>;
 }
 
 /**
@@ -2757,16 +2968,16 @@ declare abstract class BaseWsTransport implements WsTransport {
 }
 
 declare class StandaloneWsTransport extends BaseWsTransport {
+    private static readonly FAST_RETRY_LIMIT;
+    private static readonly FAST_RETRY_DELAY_MS;
+    private static readonly MAX_BACKOFF_MS;
     private socket;
     private url;
     private accessToken;
     private reconnectAttempts;
     private reconnectTimer;
-    private periodicReconnectInterval;
-    private maxReconnectAttempts;
-    private reconnectDelay;
-    private reconnectDelayMax;
-    private static readonly PERIODIC_RECONNECT_MS;
+    private needsReconnect;
+    private visibilityHandler;
     private wildcardHandlers;
     private eventHandlers;
     private registeredEvents;
@@ -2785,8 +2996,7 @@ declare class StandaloneWsTransport extends BaseWsTransport {
     private reconnectWithAuth;
     /** Clear socket reference so ensureSocket() can create a new connection. */
     private clearSocketForReconnect;
-    private clearPeriodicReconnect;
-    private startPeriodicReconnect;
+    private reconnectImmediately;
     private scheduleReconnect;
     private getEventHandlers;
     private unsubscribeEvent;
@@ -2800,6 +3010,10 @@ declare class StandaloneWsTransport extends BaseWsTransport {
 declare class SharedWorkerTransport extends BaseWsTransport {
     private client;
     private url;
+    /** Tracks whether a successful connection has been established at least once,
+     *  so that subsequent ws_open events are treated as reconnects and the
+     *  `connection:reconnected` event is dispatched to subscribers. */
+    private hasConnectedBefore;
     constructor(workerUrl: string, socketUrl: string);
     connect(): void;
     disconnect(): void;
@@ -2843,4 +3057,4 @@ declare class HttpClient implements IHttpClient {
     private payChallenge;
 }
 
-export { type AcceptChallengeResponse, type Achievement, Activity, type ActivityFeedItem, type ActivityFeedItemType, type ActivityFeedResponse, type ActivityFeedUser, Admin, type AdminDailyStats, type AdminDailyStatsItem, type AdminGameHistory, type AdminGameHistoryFeeBreakdown, type AdminGameHistoryFeePlayer, type AdminGameHistoryPlayer, type AdminMarketDailyStats, type AdminMarketDailyStatsItem, type AdminMarketDetail, type AdminMarketStats, type AdminStats, type AdminWalletActivityItem, type AdminWalletActivityResponse, type ApiError, type AppNotification, type AppNotificationType, type ApplyReferralCodeResponse, type BalanceResponse, type BetOption, type BroadcastTipRequest, BrowserLocalStorage, Challenges, Chat, type ChatContext, type ChatContextType, type ChatMessage, type ChatMessageReply, type ChatMessageType, type ChatReaction, type ChatReadBy, type ChatState, type ChatStore, type ChatStoreState, type ClaimReferralRewardsResponse, type CreateChallengeRequest, type CreateChallengeResponse, type CreateLobbyRequest, type CreateTicketData, type CriticalIncident, type CriticalIncidentCategory, type CriticalIncidentImpactType, type CriticalIncidentSeverity, type CriticalIncidentStatus, type CriticalIncidentSummary, type CurrentGame, Daily, type DailyParticipant, type DailyRoom, type DailyToken, type DepositForLobbyResponse, type DepositStatus, type DepositStatusResponse, type DmThread, type DmThreadsStore, type DmThreadsStoreState, type DonateToGameResponse, ESTIMATED_SOL_FEE_LAMPORTS, Escrow, type EscrowSweepPreview, type EscrowSweepRecord, type FaucetResponse, type FeatureFlag, type FriendRequestItem, type FriendsStore, type FriendsStoreState, type FriendshipStatus, type Game, type GameActionsStore, type GameActionsStoreState, type GameHistoryItem, type GameMetrics, type GamePlayer, type GameStateResponse, type GameStore, type GameStoreState, type GameType, Games, type GenerateHandshakeResponse, type GetTicketsOptions, HttpClient, type IHttpClient, type ILogger, type IStorage, type ImageUploadPayload, type InviteFriendRequest, type LeaderboardEntry, type LeaderboardQuery, type LeaderboardRange, type LeaderboardResponse, Leaderboards, type LivePlayer, type LivePlayersPage, Lobbies, type Lobby, type LobbyDepositUpdatedPayload, type LobbyMatchedEvent, type LobbyPlayer, type LobbyStore, type LobbyStoreState, type LogLevel, type LoginResponse, MIN_SOL_TRANSFER_AMOUNT, MIN_TRANSFER_AMOUNT, type MarketBuyResult, type MarketPosition, type MarketSellResult, type MarketState, Markets, type MoneyMinor, NodeStorage, type NotificationEvent, type NotificationsStore, type NotificationsStoreState, type PaginatedCriticalIncidents, type PaginatedFriends, type PaginatedNotificationsResponse, type PaginatedPlatformFees, type PaginatedReports, type PaginatedSearchUsers, type PaginatedSessions, type PaginatedSupportTickets, type PaginatedTransactionJobs, type PaginatedUsers, type PaymentRequiredChallenge, type PlatformFeeItem, type PrepareDepositResponse, type PrepareTipRequest, type PrepareTipResponse, type PrepareTransferRequest, type PrepareTransferResponse, type PublicUser, type QueueStats, type RedeemResult, type ReferralRewardItem, type ReferralRewardStatus, type ReferralRewardsResponse, type ReferralSummary, type ReferralTreeItem, type ReferralTreeResponse, Referrals, type Report, type ReportCount, type ReportStatus, type ReportUser, Reports, type RetryOptions, SDK, type SDKConfig, SDK_VERSION, SOL_DECIMALS, SOL_MINT, type SdkStore, type SdkUpgradeInfo, type SearchUser, type SendMessageRequest, type SendTipResponse, type SendTransferResponse, type Session, SharedWorkerTransport, Spectate, type SpectatorMetrics, type SpectatorMetricsByUser, StandaloneWsTransport, type SubmitDepositResponse, type SubmitTransferRequest, type SubmitTransferResponse, Support, type SupportMessage, type SupportMessageSenderRole, type SupportTicket, type SupportTicketCategory, type SupportTicketPriority, type SupportTicketStatus, type SupportTicketUser, type SystemMessageType, TOKEN_KEY, TRANSFER_FEE_MINOR, Tips, type TransactionJob, type TransactionJobStatus, type TransactionJobType, type TransactionQueueStats, type TransferToken, type TypingUser, type UpdateTicketData, type User, type UserAchievement, type UserActivity, type UserActivityStatus, type UserStats, type UsernameAvailabilityResponse, Users, type ValidAction, Wallet, type WalletActivityCounterpartyType, type WalletActivityDirection, type WalletActivityItem, type WalletActivityKind, type WalletActivityResponse, type WalletActivityStatus, type WalletClaimAction, type WalletMeta, type WalletResponse, type WalletSigner, type WsEvent, WsEventBus, type WsEventName, type WsTransport, type ConnectionState as WsTransportState, createChatStore, createDmThreadsStore, createFriendsStore, createGameActionsStore, createGameStore, createLobbyStore, createLogger, createNotificationsStore, createSdkStore, isRetryableError, logger, withRetry };
+export { type AcceptChallengeResponse, type Achievement, Activity, type ActivityFeedItem, type ActivityFeedItemType, type ActivityFeedResponse, type ActivityFeedUser, Admin, type AdminDailyStats, type AdminDailyStatsItem, type AdminFeatureFlag, type AdminGameHistory, type AdminGameHistoryFeeBreakdown, type AdminGameHistoryFeePlayer, type AdminGameHistoryPlayer, type AdminMarketDailyStats, type AdminMarketDailyStatsItem, type AdminMarketDetail, type AdminMarketStats, type AdminStats, type AdminWalletActivityItem, type AdminWalletActivityResponse, type AnalyticsUserData, type ApiError, type AppNotification, type AppNotificationType, type ApplyReferralCodeResponse, type BalanceResponse, type BetOption, type BroadcastTipRequest, BrowserLocalStorage, Challenges, Chat, type ChatContext, type ChatContextType, type ChatMessage, type ChatMessageReply, type ChatMessageType, type ChatReaction, type ChatReadBy, type ChatState, type ChatStore, type ChatStoreState, type ChessCapturedPieces, type ChessClockTimes, type ClaimReferralRewardsResponse, type Connect4ClockTimes, type CreateChallengeRequest, type CreateChallengeResponse, type CreateLobbyRequest, type CreateTicketData, type CriticalIncident, type CriticalIncidentCategory, type CriticalIncidentImpactType, type CriticalIncidentSeverity, type CriticalIncidentStatus, type CriticalIncidentSummary, type CurrentGame, Daily, type DailyParticipant, type DailyRoom, type DailyToken, type DepositForLobbyResponse, type DepositStatus, type DepositStatusResponse, type DmThread, type DmThreadsStore, type DmThreadsStoreState, type DonateToGameResponse, ESTIMATED_SOL_FEE_LAMPORTS, Escrow, type EscrowSweepPreview, type EscrowSweepRecord, type FaucetResponse, type FeatureFlag, type FriendRequestItem, type FriendsStore, type FriendsStoreState, type FriendshipStatus, type Game, type GameActionsStore, type GameActionsStoreState, type GameHistoryItem, type GameLifecycleState, type GameMetrics, type GamePlayer, type GameStateResponse, type GameStore, type GameStoreState, type GameType, Games, type GenerateHandshakeResponse, type GetTicketsOptions, HttpClient, type IAnalyticsClient, type IHttpClient, type ILogger, type IStorage, type ImageUploadPayload, type InviteFriendRequest, type LeaderboardEntry, type LeaderboardQuery, type LeaderboardRange, type LeaderboardResponse, Leaderboards, type LivePlayer, type LivePlayersPage, Lobbies, type Lobby, type LobbyDepositUpdatedPayload, type LobbyMatchedEvent, type LobbyPlayer, type LobbyStore, type LobbyStoreState, type LogLevel, type LoginResponse, MIN_SOL_TRANSFER_AMOUNT, MIN_TRANSFER_AMOUNT, type MarketBuyResult, type MarketPosition, type MarketSellResult, type MarketState, Markets, type MoneyMinor, NodeStorage, NoopAnalyticsClient, type NotificationEvent, type NotificationsStore, type NotificationsStoreState, type PaginatedCriticalIncidents, type PaginatedFriendRequests, type PaginatedFriends, type PaginatedNotificationsResponse, type PaginatedPlatformFees, type PaginatedReports, type PaginatedSearchUsers, type PaginatedSessions, type PaginatedSupportTickets, type PaginatedTransactionJobs, type PaginatedUsers, type PaymentRequiredChallenge, type PlatformFeeItem, type PrepareDepositResponse, type PrepareTipRequest, type PrepareTipResponse, type PrepareTransferRequest, type PrepareTransferResponse, type PublicUser, type QueueStats, type RedeemResult, type ReferralRewardItem, type ReferralRewardStatus, type ReferralRewardsResponse, type ReferralSummary, type ReferralTreeItem, type ReferralTreeResponse, Referrals, type Report, type ReportCount, type ReportStatus, type ReportUser, Reports, type RetryOptions, SDK, type SDKConfig, SDK_VERSION, SOL_DECIMALS, SOL_MINT, type SdkStore, type SdkUpgradeInfo, type SearchUser, type SendMessageRequest, type SendTipResponse, type SendTransferResponse, type Session, type SessionStats, SharedWorkerTransport, Spectate, type SpectatorMetrics, type SpectatorMetricsByUser, StandaloneWsTransport, type SubmitDepositResponse, type SubmitTransferRequest, type SubmitTransferResponse, Support, type SupportMessage, type SupportMessageSenderRole, type SupportTicket, type SupportTicketCategory, type SupportTicketPriority, type SupportTicketStatus, type SupportTicketUser, type SystemMessageType, TOKEN_KEY, TRANSFER_FEE_MINOR, type TicTacToeClockTimes, Tips, type TransactionJob, type TransactionJobStatus, type TransactionJobType, type TransactionQueueStats, type TransferToken, type TypingUser, type UpdateTicketData, type User, type UserAchievement, type UserActivity, type UserActivityStatus, type UserStats, type UsernameAvailabilityResponse, Users, type ValidAction, Wallet, type WalletActivityCounterpartyType, type WalletActivityDirection, type WalletActivityItem, type WalletActivityKind, type WalletActivityResponse, type WalletActivityStatus, type WalletClaimAction, type WalletMeta, type WalletResponse, type WalletSigner, type WsEvent, WsEventBus, type WsEventName, type WsTransport, type ConnectionState as WsTransportState, createChatStore, createDmThreadsStore, createFriendsStore, createGameActionsStore, createGameStore, createLobbyStore, createLogger, createNotificationsStore, createSdkStore, isRetryableError, logger, selectGameLifecycleState, withRetry };