@dimcool/sdk 0.1.29 → 0.1.31

package/dist/index.cjs

@@ -214,6 +214,7 @@ __export(index_exports, {
   MIN_TRANSFER_AMOUNT: () => MIN_TRANSFER_AMOUNT,
   Markets: () => Markets,
   NodeStorage: () => NodeStorage,
+  NoopAnalyticsClient: () => NoopAnalyticsClient,
   Referrals: () => Referrals,
   Reports: () => Reports,
   SDK: () => SDK,
@@ -241,6 +242,7 @@ __export(index_exports, {
   formatMoneyMinor: () => import_utils.formatMoneyMinor,
   isRetryableError: () => isRetryableError,
   logger: () => logger,
+  selectGameLifecycleState: () => selectGameLifecycleState,
   toMajor: () => import_utils.toMajor,
   withRetry: () => withRetry
 });
@@ -748,6 +750,16 @@ var Auth = class {
     this.logger.debug("Token stored in storage", { tokenKey: TOKEN_KEY });
     return response;
   }
+  async loginWithExternalSignature(address, signedMessage, options) {
+    const response = await this.http.post("/auth/login-wallet", {
+      signedMessage,
+      address,
+      referralCode: options?.referralCode,
+      walletMeta: options?.walletMeta
+    });
+    this.storage.set(TOKEN_KEY, response.access_token);
+    return response;
+  }
   logout() {
     this.logger.debug("Auth.logout called");
     const hadToken = this.storage.get(TOKEN_KEY) !== null;
@@ -761,6 +773,10 @@ var Auth = class {
     });
     return isAuth;
   }
+  async getSessionStats() {
+    this.logger.debug("Auth.getSessionStats called");
+    return this.http.get("/auth/sessions/stats");
+  }
   async getLatestSessions(limit) {
     this.logger.debug("Auth.getLatestSessions called", { limit });
     const params = new URLSearchParams();
@@ -781,6 +797,9 @@ var Admin = class {
     this.http = http;
     this.logger = logger2;
   }
+  async getInternalBots() {
+    return this.http.get("/admin/internal-bots");
+  }
   async getUserById(id) {
     return this.http.get(`/admin/users/${id}`);
   }
@@ -988,11 +1007,25 @@ var Users = class {
   async removeFriend(userId) {
     return this.http.delete(`/friends/${userId}`);
   }
-  async getIncomingFriendRequests() {
-    return this.http.get("/friends/requests/incoming");
+  async getIncomingFriendRequests(opts) {
+    const params = new URLSearchParams();
+    if (opts?.limit !== void 0)
+      params.append("limit", opts.limit.toString());
+    if (opts?.cursor !== void 0) params.append("cursor", opts.cursor);
+    const qs = params.toString();
+    return this.http.get(
+      qs ? `/friends/requests/incoming?${qs}` : "/friends/requests/incoming"
+    );
   }
-  async getOutgoingFriendRequests() {
-    return this.http.get("/friends/requests/outgoing");
+  async getOutgoingFriendRequests(opts) {
+    const params = new URLSearchParams();
+    if (opts?.limit !== void 0)
+      params.append("limit", opts.limit.toString());
+    if (opts?.cursor !== void 0) params.append("cursor", opts.cursor);
+    const qs = params.toString();
+    return this.http.get(
+      qs ? `/friends/requests/outgoing?${qs}` : "/friends/requests/outgoing"
+    );
   }
   async acceptFriendRequest(userId) {
     return this.http.post(
@@ -1081,6 +1114,9 @@ var FeatureFlags = class {
     this.loaded = true;
     return this.flags;
   }
+  async getAdminFeatureFlags() {
+    return this.http.get("/feature-flags/admin");
+  }
   isEnabledFlag(name) {
     const flag = this.flags.find((f) => f.name === name);
     return flag?.enabled ?? false;
@@ -1100,10 +1136,11 @@ var FeatureFlags = class {
     }
     return flag;
   }
-  async createFeatureFlag(name, enabled) {
+  async createFeatureFlag(name, enabled, description) {
     const flag = await this.http.post("/feature-flags", {
       name,
-      enabled
+      enabled,
+      ...description !== void 0 && { description }
     });
     this.flags.push(flag);
     return flag;
@@ -1116,11 +1153,17 @@ var Lobbies = class {
     this.http = http;
     this.logger = logger2;
   }
+  /** Called by SDK after the store is created so mutations can update state directly. */
+  setLobbyStore(store) {
+    this.lobbyStore = store;
+  }
   async createLobby(gameType, betAmount) {
     return this.http.post("/lobbies", { gameType, betAmount });
   }
   async getLobby(lobbyId) {
-    return this.http.get(`/lobbies/${lobbyId}`);
+    const lobby = await this.http.get(`/lobbies/${lobbyId}`);
+    this.lobbyStore?.setBaseState([lobby]);
+    return lobby;
   }
   async inviteFriend(lobbyId, friendId) {
     return this.http.post(`/lobbies/${lobbyId}/invite`, {
@@ -1131,7 +1174,9 @@ var Lobbies = class {
     return this.http.post(`/lobbies/${lobbyId}/accept-invite`, {});
   }
   async joinLobby(lobbyId) {
-    return this.http.post(`/lobbies/${lobbyId}/join`, {});
+    const lobby = await this.http.post(`/lobbies/${lobbyId}/join`, {});
+    this.lobbyStore?.setBaseState([lobby]);
+    return lobby;
   }
   async removePlayer(lobbyId, userId) {
     return this.http.delete(
@@ -1148,12 +1193,17 @@ var Lobbies = class {
     return this.http.post(`/lobbies/${lobbyId}/join-queue`, {});
   }
   async cancelQueue(lobbyId) {
-    return this.http.delete(`/lobbies/${lobbyId}/queue`);
+    const lobby = await this.http.delete(`/lobbies/${lobbyId}/queue`);
+    this.lobbyStore?.setBaseState([lobby]);
+    return lobby;
   }
   async updateBetAmount(lobbyId, betAmount) {
-    return this.http.patch(`/lobbies/${lobbyId}/bet-amount`, {
-      betAmount
-    });
+    const lobby = await this.http.patch(
+      `/lobbies/${lobbyId}/bet-amount`,
+      { betAmount }
+    );
+    this.lobbyStore?.setBaseState([lobby]);
+    return lobby;
   }
   async playSound(lobbyId, sound) {
     return this.http.post(`/lobbies/${lobbyId}/sound`, {
@@ -1188,13 +1238,18 @@ var Lobbies = class {
 };
 
 // src/games.ts
-var import_web32 = require("@solana/web3.js");
 var Games = class {
   constructor(http, wallet, logger2) {
     this.http = http;
     this.wallet = wallet;
     this.logger = logger2;
   }
+  setGameStore(store) {
+    this.gameStore = store;
+  }
+  setGameActionsStore(store) {
+    this.gameActionsStore = store;
+  }
   async getAvailableGames() {
     return this.http.get("/games/available");
   }
@@ -1207,7 +1262,11 @@ var Games = class {
     return this.http.get("/games/metrics");
   }
   async getGame(gameId) {
-    return this.http.get(`/games/${gameId}`);
+    const existing = this.gameStore?.store.getState().gamesById[gameId];
+    if (existing?.status === "completed") return existing;
+    const game = await this.http.get(`/games/${gameId}`);
+    this.gameStore?.setBaseState([game]);
+    return game;
   }
   /**
    * Get list of currently active (live) games. Public endpoint for spectating.
@@ -1234,7 +1293,13 @@ var Games = class {
    * Get current game state with timer information
    */
   async getGameState(gameId) {
-    return this.http.get(`/games/${gameId}/state`);
+    const existing = this.gameActionsStore?.store.getState().statesByGameId[gameId];
+    if (existing?.status === "completed") return existing;
+    const state = await this.http.get(
+      `/games/${gameId}/state`
+    );
+    this.gameActionsStore?.setBaseState(gameId, state);
+    return state;
   }
   /**
    * Request a rematch for a completed game
@@ -1270,8 +1335,18 @@ var Games = class {
       { amountMinor, signedTransaction }
     );
   }
+  /**
+   * Confirm a donation that was already sent by the client (signAndSendTransaction path).
+   */
+  async confirmGameDonationSignature(gameId, amountMinor, signature) {
+    return this.http.post(
+      `/games/${gameId}/donate/confirm-signature`,
+      { amountMinor, signature }
+    );
+  }
   /**
    * One-call donation flow: prepare -> sign -> submit.
+   * Automatically uses the right signing path (embedded vs injected wallet).
    */
   async sendDonation(gameId, amountMinor) {
     if (!this.wallet.hasSigner()) {
@@ -1280,16 +1355,10 @@ var Games = class {
       );
     }
     const prepared = await this.prepareGameDonation(gameId, amountMinor);
-    const unsignedTx = import_web32.Transaction.from(base64ToBytes(prepared.transaction));
-    const signedTx = await this.wallet.signTransaction(unsignedTx);
-    const signedTransaction = bytesToBase64(
-      signedTx.serialize({ requireAllSignatures: false })
-    );
-    const result = await this.donateToGame(
-      gameId,
-      amountMinor,
-      signedTransaction
-    );
+    const result = await this.wallet.signAndDispatch(prepared.transaction, {
+      onSigned: (signedTxBase64) => this.donateToGame(gameId, amountMinor, signedTxBase64),
+      onSignedAndSent: (sig) => this.confirmGameDonationSignature(gameId, amountMinor, sig)
+    });
     return {
       ...result,
       escrowAddress: prepared.escrowAddress,
@@ -1388,6 +1457,9 @@ var Chat = class {
     this.logger = logger2;
     this.retryOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };
   }
+  setDmThreadsStore(store) {
+    this.dmThreadsStore = store;
+  }
   encodeContextId(id) {
     return encodeURIComponent(id);
   }
@@ -1469,7 +1541,9 @@ var Chat = class {
     return response;
   }
   async listDmThreads() {
-    return this.http.get("/chat/dm/threads");
+    const threads = await this.http.get("/chat/dm/threads");
+    this.dmThreadsStore?.setBaseState(threads);
+    return threads;
   }
   async getDmThread(dmKey) {
     return this.http.get(
@@ -1535,7 +1609,6 @@ var Challenges = class {
 };
 
 // src/tips.ts
-var import_web33 = require("@solana/web3.js");
 var Tips = class {
   constructor(http, wallet, chat, logger2) {
     this.http = http;
@@ -1562,21 +1635,32 @@ var Tips = class {
       );
     }
     const { publicKey: senderAddress } = await this.wallet.loadWallet();
-    const prepared = await this.prepare({ recipientUsername, amount });
-    const unsignedTx = import_web33.Transaction.from(base64ToBytes(prepared.transaction));
-    const signedTx = await this.wallet.signTransaction(unsignedTx);
-    const signedTxBase64 = bytesToBase64(
-      signedTx.serialize({ requireAllSignatures: false })
-    );
-    const transfer = await this.wallet.submitTransfer(
-      signedTxBase64,
-      senderAddress,
-      prepared.recipientAddress,
-      prepared.amount,
-      "USDC",
-      false,
-      prepared.recipientUsername
-    );
+    const supportsPresign = !this.wallet.isSignAndSendMode();
+    const prepared = await this.prepare({
+      recipientUsername,
+      amount,
+      supportsPresign
+    });
+    const transfer = await this.wallet.signAndDispatch(prepared.transaction, {
+      onSigned: (signedTxBase64) => this.wallet.submitTransfer(
+        signedTxBase64,
+        senderAddress,
+        prepared.recipientAddress,
+        prepared.amount,
+        "USDC",
+        false,
+        prepared.recipientUsername
+      ),
+      onSignedAndSent: (sig) => this.wallet.confirmTransferSignature(
+        sig,
+        senderAddress,
+        prepared.recipientAddress,
+        prepared.amount,
+        "USDC",
+        false,
+        prepared.recipientUsername
+      )
+    });
     const message = await this.chat.broadcastGlobalTip(
       prepared.recipientUserId,
       prepared.amount
@@ -1688,7 +1772,7 @@ var Achievements = class {
 };
 
 // src/wallet.ts
-var import_web34 = require("@solana/web3.js");
+var import_web32 = require("@solana/web3.js");
 var TRANSFER_FEE_MINOR = 1e4;
 var MIN_TRANSFER_AMOUNT = 5e4;
 var MIN_SOL_TRANSFER_AMOUNT = 1e6;
@@ -1905,13 +1989,15 @@ var Wallet = class {
       );
     }
     try {
+      const supportsPresign = !this.isSignAndSendMode();
       const response = await this.http.post(
         "/wallets/transfer/prepare",
         {
           senderAddress,
           recipient,
           amount: amountMinor,
-          token
+          token,
+          supportsPresign
         }
       );
       this.logger.debug("Transfer prepared", {
@@ -1995,6 +2081,29 @@ var Wallet = class {
       throw error;
     }
   }
+  /**
+   * 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)
+   */
+  async signAndDispatch(unsignedTxBase64, handlers) {
+    if (!this.signer) {
+      throw new Error(
+        "No signer configured. Call setSigner() with a WalletSigner implementation first."
+      );
+    }
+    const unsignedTx = import_web32.Transaction.from(base64ToBytes(unsignedTxBase64));
+    if (this.isSignAndSendMode()) {
+      const sig = await this.signAndSendTransaction(unsignedTx);
+      return handlers.onSignedAndSent(sig);
+    }
+    const signedTx = await this.signTransaction(unsignedTx);
+    const signedBase64 = bytesToBase64(
+      signedTx.serialize({ requireAllSignatures: false })
+    );
+    return handlers.onSigned(signedBase64);
+  }
   /**
    * Full transfer flow in one call: prepare -> sign -> submit
    * Recipient can be username, .sol domain, or Solana address (resolved by backend).
@@ -2011,7 +2120,7 @@ var Wallet = class {
       amount,
       token
     );
-    const unsignedTx = import_web34.Transaction.from(base64ToBytes(prepared.transaction));
+    const unsignedTx = import_web32.Transaction.from(base64ToBytes(prepared.transaction));
     let submitted;
     if (this.isSignAndSendMode()) {
       const signature = await this.signAndSendTransaction(unsignedTx);
@@ -2051,7 +2160,7 @@ var Wallet = class {
 };
 
 // src/escrow.ts
-var import_web35 = require("@solana/web3.js");
+var import_web33 = require("@solana/web3.js");
 var Escrow = class {
   constructor(http, wallet, logger2) {
     this.http = http;
@@ -2079,12 +2188,32 @@ var Escrow = class {
    * initializes depositStatus, and prepares the unsigned transaction in one call.
    * Eliminates one HTTP round-trip vs startDeposits() + prepareDepositTransaction().
    */
-  async prepareAndStartDeposit(lobbyId) {
+  async prepareAndStartDeposit(lobbyId, supportsPresign) {
+    const presign = supportsPresign ?? !this.wallet.isSignAndSendMode();
     return this.http.post(
       `/escrow/lobby/${lobbyId}/deposit/prepare-and-start`,
-      {}
+      { supportsPresign: presign }
     );
   }
+  /**
+   * 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.
+   */
+  async signAndSubmitPreparedDeposit(lobbyId, unsignedTxBase64) {
+    return this.wallet.signAndDispatch(unsignedTxBase64, {
+      onSigned: async (signedTxBase64) => {
+        const result = await this.submitDeposit(lobbyId, signedTxBase64);
+        return result.signature;
+      },
+      onSignedAndSent: async (signature) => {
+        await this.confirmDepositSignature(lobbyId, signature);
+        return signature;
+      }
+    });
+  }
   /**
    * Submit a signed deposit transaction
    * The transaction will be submitted to the Solana network and confirmed
@@ -2127,8 +2256,12 @@ var Escrow = class {
         "No signer configured. Use sdk.wallet.setSigner(...) first."
       );
     }
-    const { transaction } = await this.prepareAndStartDeposit(lobbyId);
-    const unsignedTx = import_web35.Transaction.from(base64ToBytes(transaction));
+    const supportsPresign = !this.wallet.isSignAndSendMode();
+    const { transaction } = await this.prepareAndStartDeposit(
+      lobbyId,
+      supportsPresign
+    );
+    const unsignedTx = import_web33.Transaction.from(base64ToBytes(transaction));
     let signature;
     if (this.wallet.isSignAndSendMode()) {
       signature = await this.wallet.signAndSendTransaction(unsignedTx);
@@ -2162,8 +2295,13 @@ var Escrow = class {
     };
   }
   /**
-   * 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.
    */
@@ -2173,26 +2311,45 @@ var Escrow = class {
         "No signer configured. Use sdk.wallet.setSigner(...) first."
       );
     }
-    const { transaction } = await this.prepareAndStartDeposit(lobbyId);
-    const unsignedTx = import_web35.Transaction.from(base64ToBytes(transaction));
+    const supportsPresign2 = !this.wallet.isSignAndSendMode();
+    const { transaction } = await this.prepareAndStartDeposit(
+      lobbyId,
+      supportsPresign2
+    );
+    const unsignedTx = import_web33.Transaction.from(base64ToBytes(transaction));
     let signature;
     if (this.wallet.isSignAndSendMode()) {
       signature = await this.wallet.signAndSendTransaction(unsignedTx);
-      await this.http.post(
-        `/escrow/lobby/${lobbyId}/deposit/confirm-signature?awaitConfirmation=true`,
-        { signature }
-      );
+      await this.confirmDepositSignature(lobbyId, signature);
     } else {
       const signedTx = await this.wallet.signTransaction(unsignedTx);
       const signedBase64 = bytesToBase64(
         signedTx.serialize({ requireAllSignatures: false })
       );
-      const result = await this.http.post(`/escrow/lobby/${lobbyId}/deposit/submit?awaitConfirmation=true`, {
-        signedTransaction: signedBase64
-      });
-      signature = result.signature;
+      const submitResult = await this.submitDeposit(lobbyId, signedBase64);
+      signature = submitResult.signature;
     }
-    return { signature, status: "confirmed", canProceedToQueue: true };
+    const MAX_WAIT_MS = 6e4;
+    const POLL_INTERVAL_MS = 1e3;
+    const startTime = Date.now();
+    while (Date.now() - startTime < MAX_WAIT_MS) {
+      const status = await this.getDepositStatus(lobbyId);
+      const myDeposit = status.deposits.find(
+        (d) => d.transactionHash === signature
+      );
+      if (myDeposit?.status === "confirmed") {
+        return {
+          signature,
+          status: "confirmed",
+          canProceedToQueue: status.canProceedToQueue
+        };
+      }
+      if (status.allConfirmed && status.canProceedToQueue) {
+        return { signature, status: "confirmed", canProceedToQueue: true };
+      }
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+    }
+    return { signature, status: "pending", canProceedToQueue: false };
   }
   async claimLobbyDepositRefund(lobbyId, depositSignature) {
     return this.http.post(
@@ -2548,9 +2705,10 @@ var Support = class {
 
 // src/markets.ts
 var Markets = class {
-  constructor(http, logger2) {
+  constructor(http, logger2, wallet) {
     this.http = http;
     this.logger = logger2;
+    this.wallet = wallet;
   }
   /**
    * Get the prediction market state for a game.
@@ -2592,6 +2750,35 @@ var Markets = class {
       { signedTransaction, outcomeId, amountMinor }
     );
   }
+  /**
+   * Confirm a buy order that was already broadcast by the client (signAndSendTransaction path).
+   */
+  async confirmBuyOrderSignature(gameId, depositSignature, outcomeId, amountMinor) {
+    return this.http.post(
+      `/games/${gameId}/market/orders/buy/confirm-signature`,
+      { depositSignature, outcomeId, amountMinor }
+    );
+  }
+  /**
+   * One-call buy order: prepare → sign → submit, automatically choosing
+   * the right signing path (embedded vs injected wallet).
+   */
+  async buy(gameId, outcomeId, amountMinor) {
+    if (!this.wallet?.hasSigner()) {
+      throw new Error(
+        "No signer configured. Use sdk.wallet.setSigner(...) first."
+      );
+    }
+    const { transaction } = await this.prepareBuyOrder(
+      gameId,
+      outcomeId,
+      amountMinor
+    );
+    return this.wallet.signAndDispatch(transaction, {
+      onSigned: (signedTxBase64) => this.submitBuyOrder(gameId, signedTxBase64, outcomeId, amountMinor),
+      onSignedAndSent: (sig) => this.confirmBuyOrderSignature(gameId, sig, outcomeId, amountMinor)
+    });
+  }
   /**
    * Sell shares back to the AMM pool.
    * @param gameId - The game ID
@@ -2641,6 +2828,22 @@ var Markets = class {
   }
 };
 
+// src/analytics.ts
+var NoopAnalyticsClient = class {
+  userLoggedIn(_user, _meta) {
+  }
+  userLoggedOut() {
+  }
+  sessionRestored(_user) {
+  }
+  track(_event, _properties) {
+  }
+  setUserProperties(_properties) {
+  }
+  group(_groupType, _groupKey, _properties) {
+  }
+};
+
 // src/ws/standalone-transport.ts
 var import_socket = require("socket.io-client");
 
@@ -2734,22 +2937,35 @@ var _StandaloneWsTransport = class _StandaloneWsTransport extends BaseWsTranspor
     this.accessToken = null;
     this.reconnectAttempts = 0;
     this.reconnectTimer = null;
-    this.periodicReconnectInterval = null;
-    this.maxReconnectAttempts = 5;
-    this.reconnectDelay = 1e3;
-    this.reconnectDelayMax = 3e4;
-    // 5 minutes
+    this.needsReconnect = false;
+    this.visibilityHandler = null;
     this.wildcardHandlers = /* @__PURE__ */ new Set();
     this.eventHandlers = /* @__PURE__ */ new Map();
     this.registeredEvents = /* @__PURE__ */ new Set();
     this.wildcardRegistered = false;
     this.url = url;
+    if (typeof document !== "undefined") {
+      this.visibilityHandler = () => {
+        if (document.visibilityState === "visible" && !this.connectionState.connected) {
+          this.reconnectImmediately();
+        }
+      };
+      document.addEventListener("visibilitychange", this.visibilityHandler);
+    }
   }
   connect() {
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.reconnectAttempts = 0;
     this.ensureSocket();
   }
   disconnect() {
-    this.clearPeriodicReconnect();
+    if (this.visibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+      this.visibilityHandler = null;
+    }
     if (!this.socket) return;
     this.socket.disconnect();
     this.socket = null;
@@ -2848,13 +3064,13 @@ var _StandaloneWsTransport = class _StandaloneWsTransport extends BaseWsTranspor
       reconnection: false
     });
     socket.on("connect", () => {
-      this.clearPeriodicReconnect();
       this.updateConnectionState({
         connected: true,
         connecting: false,
         error: null
       });
-      const wasReconnect = this.reconnectAttempts > 0;
+      const wasReconnect = this.needsReconnect;
+      this.needsReconnect = false;
       this.reconnectAttempts = 0;
       this.onReconnect();
       if (wasReconnect) {
@@ -2865,6 +3081,7 @@ var _StandaloneWsTransport = class _StandaloneWsTransport extends BaseWsTranspor
     });
     socket.on("disconnect", (reason) => {
       this.updateConnectionState({ connected: false, connecting: false });
+      this.needsReconnect = true;
       this.clearSocketForReconnect();
       if (reason === "io server disconnect") {
         this.handleAuthFailure("io server disconnect");
@@ -2874,6 +3091,7 @@ var _StandaloneWsTransport = class _StandaloneWsTransport extends BaseWsTranspor
     });
     socket.on("connect_error", (error) => {
       const message = error?.message || "connect_error";
+      this.needsReconnect = true;
       this.clearSocketForReconnect();
       if (message.includes("unauthorized") || message.includes("401")) {
         this.handleAuthFailure(message);
@@ -2901,31 +3119,31 @@ var _StandaloneWsTransport = class _StandaloneWsTransport extends BaseWsTranspor
     this.socket.removeAllListeners();
     this.socket = null;
   }
-  clearPeriodicReconnect() {
-    if (this.periodicReconnectInterval !== null) {
-      clearInterval(this.periodicReconnectInterval);
-      this.periodicReconnectInterval = null;
+  reconnectImmediately() {
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
     }
-  }
-  startPeriodicReconnect() {
-    if (this.periodicReconnectInterval !== null) return;
-    this.periodicReconnectInterval = setInterval(() => {
-      if (this.connectionState.connected) return;
-      this.reconnectAttempts = 0;
-      this.ensureSocket();
-    }, _StandaloneWsTransport.PERIODIC_RECONNECT_MS);
+    this.reconnectAttempts = 0;
+    this.ensureSocket();
   }
   scheduleReconnect() {
     if (this.reconnectTimer !== null) return;
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      this.startPeriodicReconnect();
-      return;
-    }
-    const delay = Math.min(
-      this.reconnectDelay * Math.pow(2, this.reconnectAttempts),
-      this.reconnectDelayMax
-    );
+    const attempt = this.reconnectAttempts;
     this.reconnectAttempts += 1;
+    let delay;
+    if (attempt < _StandaloneWsTransport.FAST_RETRY_LIMIT) {
+      delay = _StandaloneWsTransport.FAST_RETRY_DELAY_MS;
+    } else {
+      const backoffAttempt = attempt - _StandaloneWsTransport.FAST_RETRY_LIMIT;
+      delay = Math.min(
+        _StandaloneWsTransport.FAST_RETRY_DELAY_MS * Math.pow(2, backoffAttempt),
+        _StandaloneWsTransport.MAX_BACKOFF_MS
+      );
+      if (attempt === _StandaloneWsTransport.FAST_RETRY_LIMIT) {
+        this.dispatchEvent("connection:slow-retry", { timestamp: Date.now() });
+      }
+    }
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.ensureSocket();
@@ -2986,7 +3204,9 @@ var _StandaloneWsTransport = class _StandaloneWsTransport extends BaseWsTranspor
     this.wildcardRegistered = true;
   }
 };
-_StandaloneWsTransport.PERIODIC_RECONNECT_MS = 5 * 60 * 1e3;
+_StandaloneWsTransport.FAST_RETRY_LIMIT = 60;
+_StandaloneWsTransport.FAST_RETRY_DELAY_MS = 1e3;
+_StandaloneWsTransport.MAX_BACKOFF_MS = 3e4;
 var StandaloneWsTransport = _StandaloneWsTransport;
 
 // src/stores/store-utils.ts
@@ -3013,14 +3233,16 @@ function createLobbyStore(transport) {
     depositStatusByLobbyId: {}
   });
   const setBaseState = (lobbies) => {
-    const lobbiesById = {};
-    for (const lobby of lobbies) {
-      lobbiesById[lobby.id] = lobby;
-    }
-    store.updateState((state) => ({
-      ...state,
-      lobbiesById
-    }));
+    store.updateState((state) => {
+      const lobbiesById = { ...state.lobbiesById };
+      for (const lobby of lobbies) {
+        const existing = lobbiesById[lobby.id];
+        if (!existing || lobby.updatedAt >= existing.updatedAt) {
+          lobbiesById[lobby.id] = lobby;
+        }
+      }
+      return { ...state, lobbiesById };
+    });
   };
   const applyWsEvent = (event) => {
     switch (event.event) {
@@ -3152,12 +3374,23 @@ function createGameStore(transport) {
     gamesById: {},
     spectatorCounts: {}
   });
+  const STATUS_RANK = {
+    active: 0,
+    completed: 1,
+    abandoned: 1
+  };
   const setBaseState = (games) => {
-    const gamesById = {};
-    for (const game of games) {
-      gamesById[game.gameId] = game;
-    }
-    store.updateState((state) => ({ ...state, gamesById }));
+    store.updateState((state) => {
+      const gamesById = { ...state.gamesById };
+      for (const game of games) {
+        const existing = gamesById[game.gameId];
+        if (existing && STATUS_RANK[existing.status] > STATUS_RANK[game.status]) {
+          continue;
+        }
+        gamesById[game.gameId] = game;
+      }
+      return { ...state, gamesById };
+    });
   };
   const applyWsEvent = (event) => {
     switch (event.event) {
@@ -3234,6 +3467,19 @@ function createGameStore(transport) {
 }
 
 // src/stores/game-actions-store.ts
+function selectGameLifecycleState(gameState) {
+  const s = gameState;
+  if (!s) return null;
+  const raw = s;
+  return {
+    status: raw.status,
+    winnerId: raw.winnerId ?? null,
+    betAmount: raw.betAmount ?? 0,
+    wonAmount: raw.wonAmount ?? null,
+    totalPotMinor: raw.totalPotMinor,
+    currentPlayerId: raw.currentPlayerId ?? null
+  };
+}
 var isRpsCompletionPayload = (payload) => payload.gameType === "rock-paper-scissors";
 function createGameActionsStore(transport) {
   const store = createSdkStore({
@@ -3255,8 +3501,21 @@ function createGameActionsStore(transport) {
     });
   };
   const isNonRpsState = (state) => Boolean(state && !isRpsState(state));
+  const pendingEvents = /* @__PURE__ */ new Map();
+  function enqueue(gameId, event) {
+    const q = pendingEvents.get(gameId) ?? [];
+    q.push(event);
+    pendingEvents.set(gameId, q);
+  }
+  function drainQueue(gameId) {
+    const q = pendingEvents.get(gameId);
+    if (!q?.length) return;
+    pendingEvents.delete(gameId);
+    for (const ev of q) applyWsEvent(ev);
+  }
   const setBaseState = (gameId, state) => {
     updateState(gameId, state);
+    drainQueue(gameId);
   };
   const clearState = (gameId) => {
     store.updateState((state) => {
@@ -3266,6 +3525,7 @@ function createGameActionsStore(transport) {
       const { [gameId]: _, ...rest } = state.statesByGameId;
       return { ...state, statesByGameId: rest };
     });
+    pendingEvents.delete(gameId);
   };
   const applyWsEvent = (event) => {
     switch (event.event) {
@@ -3284,7 +3544,10 @@ function createGameActionsStore(transport) {
       }
       case "game:rps:starting": {
         const current = store.getState().statesByGameId[event.payload.gameId];
-        if (!current || !isRpsState(current)) return;
+        if (!current || !isRpsState(current)) {
+          enqueue(event.payload.gameId, event);
+          return;
+        }
         const betAmount = typeof event.payload.betAmount === "number" ? event.payload.betAmount : void 0;
         const startedAt = typeof event.payload.startedAt === "string" ? event.payload.startedAt : current.roundState.startedAt;
         const bufferEndsAt = typeof event.payload.bufferEndsAt === "string" ? event.payload.bufferEndsAt : current.roundState.selectionEndsAt;
@@ -3305,7 +3568,10 @@ function createGameActionsStore(transport) {
       }
       case "game:rps:round:started": {
         const current = store.getState().statesByGameId[event.payload.gameId];
-        if (!current || !isRpsState(current)) return;
+        if (!current || !isRpsState(current)) {
+          enqueue(event.payload.gameId, event);
+          return;
+        }
         const actions = {};
         const baseUsers = /* @__PURE__ */ new Set();
         Object.keys(current.roundState.actions).forEach(
@@ -3339,7 +3605,10 @@ function createGameActionsStore(transport) {
       }
       case "game:rps:action:received": {
         const current = store.getState().statesByGameId[event.payload.gameId];
-        if (!current || !isRpsState(current)) return;
+        if (!current || !isRpsState(current)) {
+          enqueue(event.payload.gameId, event);
+          return;
+        }
         const updated = {
           ...current,
           roundState: {
@@ -3358,7 +3627,10 @@ function createGameActionsStore(transport) {
       }
       case "game:rps:timer:cutoff": {
         const current = store.getState().statesByGameId[event.payload.gameId];
-        if (!current || !isRpsState(current)) return;
+        if (!current || !isRpsState(current)) {
+          enqueue(event.payload.gameId, event);
+          return;
+        }
         const updated = {
           ...current,
           roundState: {
@@ -3372,7 +3644,10 @@ function createGameActionsStore(transport) {
       }
       case "game:rps:round:reveal": {
         const current = store.getState().statesByGameId[event.payload.gameId];
-        if (!current || !isRpsState(current)) return;
+        if (!current || !isRpsState(current)) {
+          enqueue(event.payload.gameId, event);
+          return;
+        }
         const actions = {};
         const payloadActions = event.payload.actions;
         Object.keys(payloadActions || {}).forEach((userId) => {
@@ -3396,7 +3671,10 @@ function createGameActionsStore(transport) {
       }
       case "game:rps:round:completed": {
         const current = store.getState().statesByGameId[event.payload.gameId];
-        if (!current || !isRpsState(current)) return;
+        if (!current || !isRpsState(current)) {
+          enqueue(event.payload.gameId, event);
+          return;
+        }
         const roundHistory = [
           ...current.roundHistory || [],
           {
@@ -3421,7 +3699,10 @@ function createGameActionsStore(transport) {
       }
       case "game:rps:timeout": {
         const current = store.getState().statesByGameId[event.payload.gameId];
-        if (!current || !isRpsState(current)) return;
+        if (!current || !isRpsState(current)) {
+          enqueue(event.payload.gameId, event);
+          return;
+        }
         const timedOutUser = event.payload.playerId;
         const action = event.payload.action;
         const updated = {
@@ -3446,7 +3727,10 @@ function createGameActionsStore(transport) {
         const payload = event.payload;
         const { gameId } = payload;
         const current = store.getState().statesByGameId[gameId];
-        if (!current) return;
+        if (!current) {
+          enqueue(gameId, event);
+          return;
+        }
         const updated = isRpsCompletionPayload(payload) && isRpsState(current) ? {
           ...current,
           status: "completed",
@@ -3495,11 +3779,15 @@ function createGameActionsStore(transport) {
         const current = store.getState().statesByGameId[gameId];
         const updated = current ? { ...current, ...incoming } : incoming;
         updateState(gameId, updated);
+        drainQueue(gameId);
         break;
       }
       case "game:rematch:requested": {
         const current = store.getState().statesByGameId[event.payload.gameId];
-        if (!current) return;
+        if (!current) {
+          enqueue(event.payload.gameId, event);
+          return;
+        }
         const requestedBy = event.payload.requestedBy;
         const userId = event.payload.userId;
         const requested = new Set(
@@ -3515,7 +3803,10 @@ function createGameActionsStore(transport) {
       }
       case "game:rematch:cancelled": {
         const current = store.getState().statesByGameId[event.payload.gameId];
-        if (!current) return;
+        if (!current) {
+          enqueue(event.payload.gameId, event);
+          return;
+        }
         const requestedBy = event.payload.requestedBy ?? [];
         const updated = {
           ...current,
@@ -3526,7 +3817,10 @@ function createGameActionsStore(transport) {
       }
       case "game:rematch:started": {
         const current = store.getState().statesByGameId[event.payload.gameId];
-        if (!current) return;
+        if (!current) {
+          enqueue(event.payload.gameId, event);
+          return;
+        }
         const updated = {
           ...current,
           rematchRequestedBy: event.payload.playerIds ?? []
@@ -3537,7 +3831,10 @@ function createGameActionsStore(transport) {
       case "game:pot:updated": {
         const { gameId, totalPotMinor } = event.payload;
         const current = store.getState().statesByGameId[gameId];
-        if (!current) return;
+        if (!current) {
+          enqueue(gameId, event);
+          return;
+        }
         const updated = {
           ...current,
           totalPotMinor
@@ -3550,12 +3847,123 @@ function createGameActionsStore(transport) {
     }
   };
   const joinGame = (gameId) => transport.joinRoom(`game:${gameId}`);
+  const getCountdownDigit = (gameId, nowMs) => {
+    const state = store.getState().statesByGameId[gameId];
+    if (!state) return null;
+    if (isRpsState(state)) {
+      if (state.roundState.phase !== "starting") return null;
+      const remaining = new Date(state.roundState.selectionEndsAt).getTime() - nowMs;
+      if (remaining <= 0) return null;
+      return Math.ceil(remaining / 1e3);
+    }
+    const bufferEndsAt = state.bufferEndsAt;
+    if (bufferEndsAt) {
+      const remaining = new Date(bufferEndsAt).getTime() - nowMs;
+      if (remaining <= 0) return null;
+      return Math.ceil(remaining / 1e3);
+    }
+    return null;
+  };
+  const getChessClockTimes = (gameId, nowMs) => {
+    const state = store.getState().statesByGameId[gameId];
+    if (!state || state.gameType !== "chess") return null;
+    const s = state;
+    let whiteMs = s.whiteTimeMs ?? 0;
+    let blackMs = s.blackTimeMs ?? 0;
+    if (s.status === "active" && s.currentPlayerId) {
+      const startedAt = Date.parse(s.turnStartedAt);
+      if (!Number.isNaN(startedAt)) {
+        const elapsed = Math.max(0, nowMs - startedAt);
+        if (s.currentPlayerId === s.whitePlayerId) {
+          whiteMs = Math.max(0, whiteMs - elapsed);
+        } else if (s.currentPlayerId === s.blackPlayerId) {
+          blackMs = Math.max(0, blackMs - elapsed);
+        }
+      }
+    }
+    return { whiteTimeMs: whiteMs, blackTimeMs: blackMs };
+  };
+  const getChessCapturedPieces = (gameId) => {
+    const state = store.getState().statesByGameId[gameId];
+    if (!state || state.gameType !== "chess") return null;
+    const fen = state.fen;
+    if (!fen) return { capturedByWhite: [], capturedByBlack: [] };
+    const placement = fen.split(" ")[0];
+    const white = {};
+    const black = {};
+    for (const char of placement) {
+      if (char === "/" || char >= "1" && char <= "8") continue;
+      const lower = char.toLowerCase();
+      if (char === lower) {
+        black[lower] = (black[lower] ?? 0) + 1;
+      } else {
+        white[lower] = (white[lower] ?? 0) + 1;
+      }
+    }
+    const INITIAL = {
+      p: 8,
+      r: 2,
+      n: 2,
+      b: 2,
+      q: 1,
+      k: 1
+    };
+    const capturedByWhite = [];
+    const capturedByBlack = [];
+    for (const [type, initial] of Object.entries(INITIAL)) {
+      const missingBlack = initial - (black[type] ?? 0);
+      for (let i = 0; i < missingBlack; i++) capturedByWhite.push(`b${type}`);
+      const missingWhite = initial - (white[type] ?? 0);
+      for (let i = 0; i < missingWhite; i++) capturedByBlack.push(`w${type}`);
+    }
+    return { capturedByWhite, capturedByBlack };
+  };
+  const getTicTacToeClockTimes = (gameId, nowMs) => {
+    const state = store.getState().statesByGameId[gameId];
+    if (!state || state.gameType !== "tic-tac-toe") return null;
+    const s = state;
+    let xMs = s.xTimeMs ?? 0;
+    let oMs = s.oTimeMs ?? 0;
+    if (s.status === "active" && s.currentPlayerId) {
+      const currentMark = s.playerMarks[s.currentPlayerId];
+      const startedAt = Date.parse(s.turnStartedAt);
+      if (!Number.isNaN(startedAt)) {
+        const elapsed = Math.max(0, nowMs - startedAt);
+        if (currentMark === "X") xMs = Math.max(0, xMs - elapsed);
+        else if (currentMark === "O") oMs = Math.max(0, oMs - elapsed);
+      }
+    }
+    return { xTimeMs: xMs, oTimeMs: oMs };
+  };
+  const getConnect4ClockTimes = (gameId, nowMs) => {
+    const state = store.getState().statesByGameId[gameId];
+    if (!state || state.gameType !== "connect-four") return null;
+    const s = state;
+    let redMs = s.redTimeMs ?? 0;
+    let yellowMs = s.yellowTimeMs ?? 0;
+    if (s.status === "active" && s.currentPlayerId) {
+      const currentColor = s.playerColors[s.currentPlayerId];
+      const startedAt = Date.parse(s.turnStartedAt);
+      if (!Number.isNaN(startedAt)) {
+        const elapsed = Math.max(0, nowMs - startedAt);
+        if (currentColor === "RED") redMs = Math.max(0, redMs - elapsed);
+        else if (currentColor === "YELLOW")
+          yellowMs = Math.max(0, yellowMs - elapsed);
+      }
+    }
+    return { redTimeMs: redMs, yellowTimeMs: yellowMs };
+  };
   return {
     store,
     setBaseState,
     clearState,
     applyWsEvent,
-    joinGame
+    joinGame,
+    getCountdownDigit,
+    getChessClockTimes,
+    getChessCapturedPieces,
+    getTicTacToeClockTimes,
+    getConnect4ClockTimes
   };
 }
 function isRpsState(state) {
@@ -3903,7 +4311,38 @@ function createNotificationsStore() {
       appNotifications: []
     }));
   };
-  return { store, applyWsEvent, setListFromApi, clear };
+  const markAsRead = (id) => {
+    store.updateState((state) => ({
+      ...state,
+      appNotifications: state.appNotifications.map(
+        (n) => n.id === id ? { ...n, read: true } : n
+      )
+    }));
+  };
+  const markAllAsRead = () => {
+    store.updateState((state) => ({
+      ...state,
+      appNotifications: state.appNotifications.map((n) => ({
+        ...n,
+        read: true
+      }))
+    }));
+  };
+  const dismiss = (id) => {
+    store.updateState((state) => ({
+      ...state,
+      appNotifications: state.appNotifications.filter((n) => n.id !== id)
+    }));
+  };
+  return {
+    store,
+    applyWsEvent,
+    setListFromApi,
+    clear,
+    markAsRead,
+    markAllAsRead,
+    dismiss
+  };
 }
 
 // src/stores/friends-store.ts
@@ -4194,12 +4633,14 @@ var WsRouter = class {
       }
       const decoded = decodeWsEvent(eventName, payload);
       if (!decoded) return;
-      this.deps.lobbyStore.applyWsEvent(decoded);
-      this.deps.gameStore.applyWsEvent(decoded);
-      this.deps.gameActionsStore.applyWsEvent(decoded);
-      this.deps.chatStore.applyWsEvent(decoded);
-      this.deps.dmThreadsStore.applyWsEvent(decoded);
-      this.deps.notificationsStore.applyWsEvent(decoded);
+      const serverTs = payload !== null && typeof payload === "object" ? payload._serverTs : void 0;
+      const event = serverTs !== void 0 ? { ...decoded, _serverTs: serverTs } : decoded;
+      this.deps.lobbyStore.applyWsEvent(event);
+      this.deps.gameStore.applyWsEvent(event);
+      this.deps.gameActionsStore.applyWsEvent(event);
+      this.deps.chatStore.applyWsEvent(event);
+      this.deps.dmThreadsStore.applyWsEvent(event);
+      this.deps.notificationsStore.applyWsEvent(event);
     });
   }
   stop() {
@@ -4211,12 +4652,14 @@ var WsRouter = class {
       this.transport.subscribeEvent(eventName, (payload) => {
         const decoded = decodeWsEvent(eventName, payload);
         if (!decoded) return;
-        this.deps.lobbyStore.applyWsEvent(decoded);
-        this.deps.gameStore.applyWsEvent(decoded);
-        this.deps.gameActionsStore.applyWsEvent(decoded);
-        this.deps.chatStore.applyWsEvent(decoded);
-        this.deps.dmThreadsStore.applyWsEvent(decoded);
-        this.deps.notificationsStore.applyWsEvent(decoded);
+        const serverTs = payload !== null && typeof payload === "object" ? payload._serverTs : void 0;
+        const event = serverTs !== void 0 ? { ...decoded, _serverTs: serverTs } : decoded;
+        this.deps.lobbyStore.applyWsEvent(event);
+        this.deps.gameStore.applyWsEvent(event);
+        this.deps.gameActionsStore.applyWsEvent(event);
+        this.deps.chatStore.applyWsEvent(event);
+        this.deps.dmThreadsStore.applyWsEvent(event);
+        this.deps.notificationsStore.applyWsEvent(event);
       });
     }
   }
@@ -4260,6 +4703,7 @@ var SDK = class {
   constructor(config) {
     const baseUrl = config.baseUrl || "http://localhost:3000";
     const logger2 = config.logger || logger;
+    this.analytics = config.analytics ?? new NoopAnalyticsClient();
     this.http = config.httpClient || new HttpClient(
       baseUrl,
       config.storage,
@@ -4292,14 +4736,18 @@ var SDK = class {
     this.referrals = new Referrals(this.http, logger2);
     this.reports = new Reports(this.http, logger2);
     this.support = new Support(this.http, logger2);
-    this.markets = new Markets(this.http, logger2);
+    this.markets = new Markets(this.http, logger2, this.wallet);
     this.wsTransport = config.wsTransport || new StandaloneWsTransport(baseUrl);
     this.wsTransport.setAppId(config.appId);
     this.lobbyStore = createLobbyStore(this.wsTransport);
+    this.lobbies.setLobbyStore(this.lobbyStore);
     this.gameStore = createGameStore(this.wsTransport);
+    this.games.setGameStore(this.gameStore);
     this.gameActionsStore = createGameActionsStore(this.wsTransport);
+    this.games.setGameActionsStore(this.gameActionsStore);
     this.chatStore = createChatStore(this.wsTransport);
     this.dmThreadsStore = createDmThreadsStore();
+    this.chat.setDmThreadsStore(this.dmThreadsStore);
     this.notificationsStore = createNotificationsStore();
     this.friendsStore = createFriendsStore();
     this.notifications = new Notifications(
@@ -4329,6 +4777,29 @@ var SDK = class {
     this.wsTransport.connect();
     await this.wsTransport.waitUntilConnected(timeoutMs);
   }
+  /**
+   * 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.
+   */
+  async depositAndJoinQueue(lobbyId) {
+    const result = await this.escrow.depositForLobby(lobbyId);
+    if (!result.canProceedToQueue) {
+      const lobby2 = await this.lobbies.getLobby(lobbyId);
+      this.lobbyStore.setBaseState([lobby2]);
+      return { ...result, lobby: lobby2 };
+    }
+    let lobby = await this.lobbies.getLobby(lobbyId);
+    if (lobby.status === "preparing") {
+      lobby = await this.lobbies.joinQueue(lobbyId);
+    }
+    this.lobbyStore.setBaseState([lobby]);
+    return { ...result, lobby };
+  }
 };
 
 // ../ws-shared-worker/dist/protocol.js
@@ -4436,6 +4907,26 @@ var SharedWorkerClient = class {
       }
     }
   }
+  /**
+   * Dispatch a synthetic local event directly to all registered handlers for
+   * that event name (and wildcard handlers), without sending anything over the
+   * wire.  Used by SharedWorkerTransport to fire synthetic events like
+   * `connection:reconnected` that originate from transport-layer logic rather
+   * than from the server.
+   */
+  dispatchLocalEvent(eventName, payload) {
+    const handlers = this.eventHandlers.get(eventName);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(payload);
+      }
+    }
+    if (this.wildcardHandlers.size > 0) {
+      for (const handler of this.wildcardHandlers) {
+        handler(eventName, payload);
+      }
+    }
+  }
   postMessage(command) {
     this.port.postMessage(command);
   }
@@ -4445,6 +4936,10 @@ var SharedWorkerClient = class {
 var SharedWorkerTransport = class extends BaseWsTransport {
   constructor(workerUrl, socketUrl) {
     super();
+    /** 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. */
+    this.hasConnectedBefore = false;
     this.client = new SharedWorkerClient(workerUrl);
     this.url = socketUrl;
     this.client.onMessage((event) => this.handleWorkerMessage(event));
@@ -4485,14 +4980,22 @@ var SharedWorkerTransport = class extends BaseWsTransport {
   }
   handleWorkerMessage(event) {
     switch (event.type) {
-      case "ws_open":
+      case "ws_open": {
+        const wasReconnect = this.hasConnectedBefore;
+        this.hasConnectedBefore = true;
         this.updateConnectionState({
           connected: true,
           connecting: false,
           error: null
         });
         this.onReconnect();
+        if (wasReconnect) {
+          this.client.dispatchLocalEvent("connection:reconnected", {
+            timestamp: Date.now()
+          });
+        }
         break;
+      }
       case "ws_close":
         this.updateConnectionState({
           connected: false,
@@ -4529,6 +5032,7 @@ var import_utils = __toESM(require_dist(), 1);
   MIN_TRANSFER_AMOUNT,
   Markets,
   NodeStorage,
+  NoopAnalyticsClient,
   Referrals,
   Reports,
   SDK,
@@ -4556,6 +5060,7 @@ var import_utils = __toESM(require_dist(), 1);
   formatMoneyMinor,
   isRetryableError,
   logger,
+  selectGameLifecycleState,
   toMajor,
   withRetry
 });