@dimcool/sdk 0.1.28 → 0.1.30

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,
@@ -748,6 +749,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 +772,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();
@@ -988,11 +1003,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 +1110,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 +1132,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 +1149,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 +1170,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 +1189,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 +1234,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 +1258,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 +1289,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 +1331,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 +1351,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 +1453,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 +1537,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 +1605,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 +1631,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 +1768,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 +1985,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 +2077,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 +2116,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 +2156,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 +2184,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 +2252,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 +2291,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 +2307,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;
+    }
+    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: "confirmed", canProceedToQueue: true };
+    return { signature, status: "pending", canProceedToQueue: false };
   }
   async claimLobbyDepositRefund(lobbyId, depositSignature) {
     return this.http.post(
@@ -2548,9 +2701,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 +2746,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 +2824,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 +2933,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 +3060,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 +3077,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 +3087,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 +3115,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 +3200,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 +3229,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 +3370,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) {
@@ -3903,7 +4132,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
@@ -4260,6 +4520,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 +4553,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 +4594,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 +4724,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 +4753,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 +4797,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 +4849,7 @@ var import_utils = __toESM(require_dist(), 1);
   MIN_TRANSFER_AMOUNT,
   Markets,
   NodeStorage,
+  NoopAnalyticsClient,
   Referrals,
   Reports,
   SDK,