@dimcool/dimclaw 0.1.29 → 0.1.30

package/dist/index.js

@@ -32839,6 +32839,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;
@@ -32852,6 +32862,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();
@@ -33075,11 +33089,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(
@@ -33166,6 +33194,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;
@@ -33185,10 +33216,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;
@@ -33199,11 +33231,17 @@ var Lobbies = class {
     this.http = http2;
     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`, {
@@ -33214,7 +33252,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(
@@ -33231,12 +33271,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`, {
@@ -33275,6 +33320,12 @@ var Games = class {
     this.wallet = wallet;
     this.logger = logger2;
   }
+  setGameStore(store) {
+    this.gameStore = store;
+  }
+  setGameActionsStore(store) {
+    this.gameActionsStore = store;
+  }
   async getAvailableGames() {
     return this.http.get("/games/available");
   }
@@ -33287,7 +33338,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.
@@ -33314,7 +33369,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
@@ -33350,8 +33411,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()) {
@@ -33360,16 +33431,10 @@ var Games = class {
       );
     }
     const prepared = await this.prepareGameDonation(gameId, amountMinor);
-    const unsignedTx = 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,
@@ -33462,6 +33527,9 @@ var Chat = class {
     this.logger = logger2;
     this.retryOptions = { ...DEFAULT_RETRY_OPTIONS, ...retryOptions };
   }
+  setDmThreadsStore(store) {
+    this.dmThreadsStore = store;
+  }
   encodeContextId(id) {
     return encodeURIComponent(id);
   }
@@ -33543,7 +33611,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(
@@ -33631,21 +33701,32 @@ var Tips = class {
       );
     }
     const { publicKey: senderAddress } = await this.wallet.loadWallet();
-    const prepared = await this.prepare({ recipientUsername, amount });
-    const unsignedTx = 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
@@ -33963,13 +34044,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", {
@@ -34053,6 +34136,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 = 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).
@@ -34134,12 +34240,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
@@ -34182,7 +34308,11 @@ var Escrow = class {
         "No signer configured. Use sdk.wallet.setSigner(...) first."
       );
     }
-    const { transaction } = await this.prepareAndStartDeposit(lobbyId);
+    const supportsPresign = !this.wallet.isSignAndSendMode();
+    const { transaction } = await this.prepareAndStartDeposit(
+      lobbyId,
+      supportsPresign
+    );
     const unsignedTx = Transaction.from(base64ToBytes(transaction));
     let signature;
     if (this.wallet.isSignAndSendMode()) {
@@ -34217,8 +34347,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.
    */
@@ -34228,26 +34363,45 @@ var Escrow = class {
         "No signer configured. Use sdk.wallet.setSigner(...) first."
       );
     }
-    const { transaction } = await this.prepareAndStartDeposit(lobbyId);
+    const supportsPresign2 = !this.wallet.isSignAndSendMode();
+    const { transaction } = await this.prepareAndStartDeposit(
+      lobbyId,
+      supportsPresign2
+    );
     const unsignedTx = 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(
@@ -34589,9 +34743,10 @@ var Support = class {
   }
 };
 var Markets = class {
-  constructor(http2, logger2) {
+  constructor(http2, logger2, wallet) {
     this.http = http2;
     this.logger = logger2;
+    this.wallet = wallet;
   }
   /**
    * Get the prediction market state for a game.
@@ -34633,6 +34788,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
@@ -34681,6 +34865,20 @@ var Markets = class {
     return this.http.get(`/games/admin/markets${qs ? `?${qs}` : ""}`);
   }
 };
+var NoopAnalyticsClient = class {
+  userLoggedIn(_user, _meta) {
+  }
+  userLoggedOut() {
+  }
+  sessionRestored(_user) {
+  }
+  track(_event, _properties) {
+  }
+  setUserProperties(_properties) {
+  }
+  group(_groupType, _groupKey, _properties) {
+  }
+};
 var BaseWsTransport = class {
   constructor() {
     this.roomRefs = /* @__PURE__ */ new Map();
@@ -34768,21 +34966,35 @@ var _StandaloneWsTransport = class _StandaloneWsTransport2 extends BaseWsTranspo
     this.accessToken = null;
     this.reconnectAttempts = 0;
     this.reconnectTimer = null;
-    this.periodicReconnectInterval = null;
-    this.maxReconnectAttempts = 5;
-    this.reconnectDelay = 1e3;
-    this.reconnectDelayMax = 3e4;
+    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 = url3;
+    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;
@@ -34881,13 +35093,13 @@ var _StandaloneWsTransport = class _StandaloneWsTransport2 extends BaseWsTranspo
       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) {
@@ -34898,6 +35110,7 @@ var _StandaloneWsTransport = class _StandaloneWsTransport2 extends BaseWsTranspo
     });
     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");
@@ -34907,6 +35120,7 @@ var _StandaloneWsTransport = class _StandaloneWsTransport2 extends BaseWsTranspo
     });
     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);
@@ -34934,31 +35148,31 @@ var _StandaloneWsTransport = class _StandaloneWsTransport2 extends BaseWsTranspo
     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();
-    }, _StandaloneWsTransport2.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 < _StandaloneWsTransport2.FAST_RETRY_LIMIT) {
+      delay = _StandaloneWsTransport2.FAST_RETRY_DELAY_MS;
+    } else {
+      const backoffAttempt = attempt - _StandaloneWsTransport2.FAST_RETRY_LIMIT;
+      delay = Math.min(
+        _StandaloneWsTransport2.FAST_RETRY_DELAY_MS * Math.pow(2, backoffAttempt),
+        _StandaloneWsTransport2.MAX_BACKOFF_MS
+      );
+      if (attempt === _StandaloneWsTransport2.FAST_RETRY_LIMIT) {
+        this.dispatchEvent("connection:slow-retry", { timestamp: Date.now() });
+      }
+    }
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.ensureSocket();
@@ -35019,7 +35233,9 @@ var _StandaloneWsTransport = class _StandaloneWsTransport2 extends BaseWsTranspo
     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;
 function createSdkStore(initial) {
   const store = createStore()(subscribeWithSelector(() => initial));
@@ -35040,14 +35256,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) {
@@ -35177,12 +35395,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) {
@@ -35920,7 +36149,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
+  };
 }
 function createFriendsStore() {
   const store = createSdkStore({
@@ -36267,6 +36527,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,
@@ -36299,14 +36560,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(
@@ -36336,6 +36601,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 };
+  }
 };
 var import_utils14 = __toESM2(require_dist(), 1);
 var export_MICRO_UNITS = import_utils14.MICRO_UNITS;
@@ -36482,7 +36770,9 @@ var import_tweetnacl = __toESM(require_nacl_fast(), 1);
 var DimAgentClient = class {
   sdk;
   agentConfig;
+  externalSignerMode;
   keypair;
+  _externalAddress = null;
   config;
   authenticated = false;
   userId = null;
@@ -36496,21 +36786,26 @@ var DimAgentClient = class {
   constructor(config) {
     this.config = config;
     this.agentConfig = config.agentConfig;
-    const secretKeyBytes = esm_default4.decode(config.walletPrivateKey);
-    this.keypair = Keypair.fromSecretKey(secretKeyBytes);
+    this.externalSignerMode = !config.walletPrivateKey;
+    if (config.walletPrivateKey) {
+      const secretKeyBytes = esm_default4.decode(config.walletPrivateKey);
+      this.keypair = Keypair.fromSecretKey(secretKeyBytes);
+    } else {
+      this.keypair = null;
+    }
     this.sdk = new SDK({
       appId: "dim-agents",
       baseUrl: config.apiUrl || "https://api.dim.cool",
       storage: new NodeStorage(),
       autoPay: {
-        enabled: true,
+        enabled: !this.externalSignerMode,
         maxAmountMinor: 25e3,
         maxRetries: 1
       }
     });
   }
   get walletAddress() {
-    return this.keypair.publicKey.toBase58();
+    return this.keypair?.publicKey.toBase58() ?? this._externalAddress ?? "";
   }
   get isAuthenticated() {
     return this.authenticated;
@@ -36519,17 +36814,23 @@ var DimAgentClient = class {
     return this.userId;
   }
   async authenticate() {
+    if (!this.keypair) {
+      throw new Error(
+        "No keypair configured. Use dim_request_auth_message + dim_complete_login for external signer mode."
+      );
+    }
+    const keypair = this.keypair;
     this.sdk.wallet.setSigner({
       address: this.walletAddress,
       signMessage: async (message) => {
         const signature = import_tweetnacl.default.sign.detached(
           new TextEncoder().encode(message),
-          this.keypair.secretKey
+          keypair.secretKey
         );
         return Buffer.from(signature).toString("base64");
       },
       signTransaction: async (transaction) => {
-        transaction.partialSign(this.keypair);
+        transaction.partialSign(keypair);
         return transaction;
       }
     });
@@ -36583,10 +36884,45 @@ var DimAgentClient = class {
   get pendingEventCount() {
     return this.eventQueue.length;
   }
-  /** Get the Keypair for transaction signing. */
+  /** Get the Keypair for transaction signing (keypair mode only). */
   getKeypair() {
+    if (!this.keypair) {
+      throw new Error(
+        "No keypair configured \u2014 running in external signer mode."
+      );
+    }
     return this.keypair;
   }
+  /** Request the auth handshake message for a given address (external signer mode). */
+  async requestAuthMessage(address) {
+    return this.sdk.auth.generateHandshake(address);
+  }
+  /**
+   * Complete authentication using an externally provided signature (external signer mode).
+   * @param address - Solana wallet address (base58)
+   * @param signatureBase58 - Detached ed25519 signature in base58 (from sign_solana_message)
+   */
+  async completeAuth(address, signatureBase58) {
+    const signatureBytes = esm_default4.decode(signatureBase58);
+    const signedMessage = Buffer.from(signatureBytes).toString("base64");
+    const response = await this.sdk.auth.loginWithExternalSignature(
+      address,
+      signedMessage,
+      {
+        referralCode: this.config.referralCode,
+        walletMeta: { type: "phantom-embedded", provider: "injected" }
+      }
+    );
+    this.sdk.wsTransport.setAccessToken(response.access_token);
+    this._externalAddress = address;
+    this.authenticated = true;
+    this.userId = response.user.id;
+    return {
+      userId: response.user.id,
+      username: response.user.username,
+      accessToken: response.access_token
+    };
+  }
   // ── Game chat cursors ────────────────────────────────────────────────
   /** Get the last-seen chat timestamp for a game. */
   getGameChatCursor(gameId) {
@@ -36714,6 +37050,77 @@ async function login(client) {
     };
   }
 }
+async function requestAuthMessage(client, args) {
+  try {
+    const { message } = await client.requestAuthMessage(args.address);
+    return {
+      data: {
+        message,
+        address: args.address,
+        nextStep: 'Sign this message with sign_solana_message (networkId: "solana:mainnet"), then call dim_complete_login with the address and the base58 signature.'
+      }
+    };
+  } catch (error) {
+    return {
+      error: `Failed to get auth message: ${error instanceof Error ? error.message : String(error)}`,
+      isError: true
+    };
+  }
+}
+async function completeLogin(client, args) {
+  try {
+    const result = await client.completeAuth(args.address, args.signature);
+    client.startEventListeners();
+    const nextSteps = [];
+    if (result.username == null || result.username === "") {
+      nextSteps.push("No username set \u2014 call dim_set_username to claim one");
+    }
+    nextSteps.push("Check your balance with dim_get_balance");
+    nextSteps.push("Explore available games with dim_list_games");
+    try {
+      const summary = await client.sdk.referrals.getSummary();
+      if (!summary.hasReferrer) {
+        nextSteps.push(
+          "No referrer yet \u2014 call dim_apply_referral_code for 10% fee discount"
+        );
+      }
+      if (result.username) {
+        nextSteps.push(
+          `Share your referral code "${result.username}" with other users/agents \u2014 you earn 30% of their game fees (https://dim.cool/?ref=${result.username})`
+        );
+      }
+    } catch {
+    }
+    const response = {
+      success: true,
+      userId: result.userId,
+      username: result.username ?? null,
+      walletAddress: client.walletAddress,
+      walletNote: "DIM is noncustodial. Signing is handled by your external wallet for this session.",
+      safetyRules: SAFETY_RULES,
+      nextSteps
+    };
+    const ac = client.agentConfig;
+    const dailyLimit = ac?.dailySpendLimit ?? 20;
+    response.agentConfig = {
+      autoAcceptFriendRequests: ac?.autoAcceptFriendRequests ?? false,
+      autoReplyDms: ac?.autoReplyDms ?? false,
+      autoPlayGames: ac?.autoPlayGames ?? false,
+      maxBetPerGame: ac?.maxBetPerGame ?? 1,
+      dailySpendLimit: dailyLimit,
+      autoJoinGlobalChat: ac?.autoJoinGlobalChat ?? false,
+      autoPromoteReferrals: ac?.autoPromoteReferrals ?? false,
+      dailySpentSoFar: client.dailySpentDollars,
+      dailyRemaining: dailyLimit - client.dailySpentDollars
+    };
+    return { data: response };
+  } catch (error) {
+    return {
+      error: `Login failed: ${error instanceof Error ? error.message : String(error)}`,
+      isError: true
+    };
+  }
+}
 async function getProfile(client) {
   try {
     if (!client.currentUserId) {
@@ -36842,10 +37249,19 @@ async function listFriends(client, args) {
     };
   }
 }
-async function getIncomingFriendRequests(client) {
+async function getIncomingFriendRequests(client, args) {
   try {
-    const result = await client.sdk.users.getIncomingFriendRequests();
-    return { data: result };
+    const result = await client.sdk.users.getIncomingFriendRequests({
+      limit: args?.limit,
+      cursor: args?.cursor
+    });
+    return {
+      data: {
+        items: result.items,
+        nextCursor: result.nextCursor,
+        hasMore: !!result.nextCursor
+      }
+    };
   } catch (error) {
     return {
       error: `Failed to get requests: ${error instanceof Error ? error.message : String(error)}`,
@@ -36966,6 +37382,42 @@ async function sendUsdc(client, args) {
     const spendErr = client.checkSpendLimit(args.amount);
     if (spendErr) return { error: spendErr, isError: true };
     const amountMinor = Math.round(args.amount * 1e6);
+    if (client.externalSignerMode) {
+      const senderAddress = client.walletAddress;
+      if (!senderAddress) {
+        return {
+          error: "Wallet address not set. Call dim_complete_login first.",
+          isError: true
+        };
+      }
+      const prepared = await client.sdk.wallet.prepareTransfer(
+        senderAddress,
+        args.recipient,
+        amountMinor
+      );
+      return {
+        data: {
+          needsSigning: true,
+          unsignedTx: prepared.transaction,
+          fee: prepared.fee,
+          totalAmount: prepared.totalAmount,
+          recipientAddress: prepared.recipientAddress,
+          ataCreated: prepared.ataCreated ?? false,
+          confirmWith: {
+            tool: "dim_confirm_send_usdc",
+            params: {
+              recipientAddress: prepared.recipientAddress,
+              amount: amountMinor,
+              fee: prepared.fee,
+              token: "USDC",
+              ataCreated: prepared.ataCreated ?? false,
+              recipientInput: args.recipient
+            }
+          },
+          hint: "Sign and broadcast unsignedTx with send_solana_transaction, then call dim_confirm_send_usdc with the signature and the confirmWith.params."
+        }
+      };
+    }
     const result = await client.sdk.wallet.send(args.recipient, amountMinor);
     client.recordSpend(amountMinor);
     return {
@@ -36986,11 +37438,74 @@ async function sendUsdc(client, args) {
     };
   }
 }
+async function confirmSendUsdc(client, args) {
+  try {
+    const senderAddress = client.walletAddress;
+    const result = await client.sdk.wallet.confirmTransferSignature(
+      args.signature,
+      senderAddress,
+      args.recipientAddress,
+      args.amount,
+      args.token || "USDC",
+      args.ataCreated,
+      args.recipientInput
+    );
+    client.recordSpend(args.amount);
+    return {
+      data: {
+        success: true,
+        signature: result.signature,
+        status: result.status,
+        recipientAddress: args.recipientAddress
+      }
+    };
+  } catch (error) {
+    return {
+      error: `Failed to confirm USDC transfer: ${error instanceof Error ? error.message : String(error)}`,
+      isError: true
+    };
+  }
+}
 async function tipUser(client, args) {
   try {
     const spendErr = client.checkSpendLimit(args.amount);
     if (spendErr) return { error: spendErr, isError: true };
     const amountMinor = Math.round(args.amount * 1e6);
+    if (client.externalSignerMode) {
+      const senderAddress = client.walletAddress;
+      if (!senderAddress) {
+        return {
+          error: "Wallet address not set. Call dim_complete_login first.",
+          isError: true
+        };
+      }
+      const prepared = await client.sdk.tips.prepare({
+        recipientUsername: args.recipientUsername,
+        amount: amountMinor,
+        supportsPresign: false
+      });
+      return {
+        data: {
+          needsSigning: true,
+          unsignedTx: prepared.transaction,
+          fee: prepared.fee,
+          totalAmount: prepared.totalAmount,
+          recipientAddress: prepared.recipientAddress,
+          confirmWith: {
+            tool: "dim_confirm_tip_user",
+            params: {
+              recipientAddress: prepared.recipientAddress,
+              recipientUserId: prepared.recipientUserId,
+              recipientUsername: prepared.recipientUsername,
+              amount: prepared.amount,
+              fee: prepared.fee,
+              ataCreated: false
+            }
+          },
+          hint: "Sign and broadcast unsignedTx with send_solana_transaction, then call dim_confirm_tip_user with the signature and the confirmWith.params."
+        }
+      };
+    }
     const result = await client.sdk.tips.send(
       args.recipientUsername,
       amountMinor
@@ -37013,6 +37528,38 @@ async function tipUser(client, args) {
     };
   }
 }
+async function confirmTipUser(client, args) {
+  try {
+    const senderAddress = client.walletAddress;
+    await client.sdk.wallet.confirmTransferSignature(
+      args.signature,
+      senderAddress,
+      args.recipientAddress,
+      args.amount,
+      "USDC",
+      args.ataCreated ?? false,
+      args.recipientUsername
+    );
+    await client.sdk.tips.broadcast({
+      recipientUserId: args.recipientUserId,
+      amount: args.amount
+    });
+    client.recordSpend(args.amount);
+    return {
+      data: {
+        success: true,
+        signature: args.signature,
+        recipient: args.recipientUsername,
+        broadcastedToGlobalChat: true
+      }
+    };
+  } catch (error) {
+    return {
+      error: `Failed to confirm tip: ${error instanceof Error ? error.message : String(error)}`,
+      isError: true
+    };
+  }
+}
 async function getWalletActivity(client, args) {
   try {
     const activity = await client.sdk.wallet.getActivity({
@@ -37119,6 +37666,7 @@ function buildRpsContext(state, agentUserId) {
     roundHistory: state.roundHistory,
     phase: roundState?.phase,
     timeRemaining: roundState?.timeRemaining,
+    ...state.bufferEndsAt != null && { bufferEndsAt: state.bufferEndsAt },
     moveFormat: 'dim_submit_action: gameType="rock-paper-scissors", action="play", payload={ action: "rock"|"paper"|"scissors" }'
   };
 }
@@ -37131,6 +37679,7 @@ function buildChessContext(state, agentUserId) {
     yourColor,
     whiteTimeMs: state.whiteTimeMs,
     blackTimeMs: state.blackTimeMs,
+    ...state.bufferEndsAt != null && { bufferEndsAt: state.bufferEndsAt },
     moveFormat: 'dim_submit_action: gameType="chess", action="move", payload={ from: "e2", to: "e4" }'
   };
 }
@@ -37340,6 +37889,23 @@ async function createLobby(client, args) {
 }
 async function depositForLobby(client, args) {
   try {
+    if (client.externalSignerMode) {
+      const { transaction } = await client.sdk.escrow.prepareAndStartDeposit(
+        args.lobbyId,
+        false
+      );
+      return {
+        data: {
+          needsSigning: true,
+          unsignedTx: transaction,
+          confirmWith: {
+            tool: "dim_confirm_lobby_deposit",
+            params: { lobbyId: args.lobbyId }
+          },
+          hint: "Sign and broadcast unsignedTx with send_solana_transaction, then call dim_confirm_lobby_deposit with the lobbyId and signature."
+        }
+      };
+    }
     const result = await client.sdk.escrow.depositForLobbySync(args.lobbyId);
     return {
       data: {
@@ -37356,6 +37922,44 @@ async function depositForLobby(client, args) {
     };
   }
 }
+async function confirmLobbyDeposit(client, args) {
+  try {
+    await client.sdk.escrow.confirmDepositSignature(
+      args.lobbyId,
+      args.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 client.sdk.escrow.getDepositStatus(args.lobbyId);
+      if (status.canProceedToQueue) {
+        return {
+          data: {
+            signature: args.signature,
+            status: "confirmed",
+            canProceedToQueue: true,
+            hint: "Deposit confirmed. Call dim_join_queue to enter matchmaking."
+          }
+        };
+      }
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+    }
+    return {
+      data: {
+        signature: args.signature,
+        status: "pending",
+        canProceedToQueue: false,
+        hint: "Deposit submitted but not yet confirmed on-chain. Try dim_confirm_lobby_deposit again in a few seconds."
+      }
+    };
+  } catch (error) {
+    return {
+      error: `Failed to confirm deposit: ${error instanceof Error ? error.message : String(error)}`,
+      isError: true
+    };
+  }
+}
 async function leaveLobby(client, args) {
   try {
     const result = await client.sdk.lobbies.leaveLobby(args.lobbyId);
@@ -37425,7 +38029,7 @@ async function joinQueue(client, args) {
         gameId,
         matched: !!matched,
         ...spectateUrl && { spectateUrl },
-        hint: matched ? `Game started! Call dim_game_loop with gameId "${gameId}" to play.${spectateUrl ? ` Tell the user they can spectate at ${spectateUrl}` : ""}` : "No match found within timeout. Call dim_join_queue again to resume waiting."
+        hint: matched ? `Game matched! Call dim_game_loop with gameId "${gameId}" IMMEDIATELY \u2014 do NOT wait for user input. The game has a start buffer; dim_game_loop will block until your first turn begins.${spectateUrl ? ` Tell the user they can spectate at ${spectateUrl}` : ""}` : "No match found within timeout. Call dim_join_queue again to resume waiting."
       }
     };
   } catch (error) {
@@ -37500,6 +38104,23 @@ async function donateToPot(client, args) {
     const spendErr = client.checkSpendLimit(args.amount);
     if (spendErr) return { error: spendErr, isError: true };
     const amountMinor = Math.round(args.amount * 1e6);
+    if (client.externalSignerMode) {
+      const prepared = await client.sdk.games.prepareGameDonation(
+        args.gameId,
+        amountMinor
+      );
+      return {
+        data: {
+          needsSigning: true,
+          unsignedTx: prepared.transaction,
+          confirmWith: {
+            tool: "dim_confirm_donate_to_pot",
+            params: { gameId: args.gameId, amount: amountMinor }
+          },
+          hint: "Sign and broadcast unsignedTx with send_solana_transaction, then call dim_confirm_donate_to_pot with the signature."
+        }
+      };
+    }
     const result = await client.sdk.games.sendDonation(
       args.gameId,
       amountMinor
@@ -37523,6 +38144,29 @@ async function donateToPot(client, args) {
     };
   }
 }
+async function confirmDonateToPot(client, args) {
+  try {
+    const result = await client.sdk.games.confirmGameDonationSignature(
+      args.gameId,
+      args.amount,
+      args.signature
+    );
+    client.recordSpend(args.amount);
+    return {
+      data: {
+        success: true,
+        gameId: args.gameId,
+        signature: result.signature,
+        status: result.status
+      }
+    };
+  } catch (error) {
+    return {
+      error: `Failed to confirm donation: ${error instanceof Error ? error.message : String(error)}`,
+      isError: true
+    };
+  }
+}
 async function getGame(client, args) {
   try {
     const game = await client.sdk.games.getGame(args.gameId);
@@ -37534,6 +38178,12 @@ async function getGame(client, args) {
     };
   }
 }
+function isInStartingPhase(state) {
+  const roundState = state.roundState;
+  if (roundState?.phase === "starting") return true;
+  if (state.status === "active" && state.currentPlayerId == null) return true;
+  return false;
+}
 async function gameLoop(client, args) {
   try {
     const { gameId } = args;
@@ -37551,7 +38201,7 @@ async function gameLoop(client, args) {
       if (state?.status === "completed") {
         return buildGameLoopReturn(client, gameId, state, "completed");
       }
-      if (state?.currentPlayerId === client.currentUserId) {
+      if (state?.currentPlayerId === client.currentUserId && !isInStartingPhase(state)) {
         return buildGameLoopReturn(client, gameId, state, "your-turn");
       }
       await raceTimeout(
@@ -38177,10 +38827,10 @@ async function checkNotifications(client) {
         isError: true
       };
     }
-    const [notifications, dmThreads, friendRequests] = await Promise.all([
+    const [notifications, dmThreads, friendRequestsPage] = await Promise.all([
       client.sdk.notifications.list({ page: 1, limit: 20 }),
       client.sdk.chat.listDmThreads(),
-      client.sdk.users.getIncomingFriendRequests()
+      client.sdk.users.getIncomingFriendRequests({ limit: 20 })
     ]);
     const unreadDms = dmThreads.filter(
       (t) => (t.unreadCount ?? 0) > 0
@@ -38192,9 +38842,10 @@ async function checkNotifications(client) {
         unreadNotificationCount: notifications.unreadCount,
         notifications: notifications.notifications.filter((n) => !n.read),
         unreadDmThreads: unreadDms,
-        incomingFriendRequests: friendRequests,
+        incomingFriendRequests: friendRequestsPage.items,
+        hasMoreIncomingFriendRequests: !!friendRequestsPage.nextCursor,
         pendingWsEvents: client.pendingEventCount,
-        hint: "Use dim_get_pending_events to drain buffered real-time events."
+        hint: "Use dim_get_pending_events to drain buffered real-time events. Use dim_get_incoming_friend_requests with cursor for more friend requests if hasMoreIncomingFriendRequests is true."
       }
     };
   } catch (error) {
@@ -38610,6 +39261,36 @@ async function getMyStats(client) {
 
 // ../dim-agent-core/src/tools/index.ts
 var TOOL_DEFINITIONS = [
+  // ── External signer mode (auth) ──────────────────────────────────────
+  {
+    name: "dim_request_auth_message",
+    description: "External wallet login step 1: given a Solana wallet address, returns the message to sign. Sign it with sign_solana_message on your wallet MCP (e.g. Phantom), then call dim_complete_login.",
+    params: {
+      address: {
+        type: "string",
+        description: "Your Solana wallet address (base58)",
+        required: true
+      }
+    },
+    execute: (c, a) => requestAuthMessage(c, a)
+  },
+  {
+    name: "dim_complete_login",
+    description: "External wallet login step 2: provide the wallet address and base58 signature from sign_solana_message to complete authentication with DIM.",
+    params: {
+      address: {
+        type: "string",
+        description: "Your Solana wallet address (base58)",
+        required: true
+      },
+      signature: {
+        type: "string",
+        description: "Base58-encoded signature returned by sign_solana_message",
+        required: true
+      }
+    },
+    execute: (c, a) => completeLogin(c, a)
+  },
   // ── Auth ─────────────────────────────────────────────────────────────
   {
     name: "dim_login",
@@ -38763,9 +39444,23 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: "dim_get_incoming_friend_requests",
-    description: "List pending incoming friend requests.",
-    params: {},
-    execute: (c) => getIncomingFriendRequests(c)
+    description: "List pending incoming friend requests. Returns { items, nextCursor, hasMore }. Pass cursor from a previous response to page through results.",
+    params: {
+      limit: {
+        type: "number",
+        description: "Maximum number of requests to return (1\u2013100, default 50).",
+        required: false
+      },
+      cursor: {
+        type: "string",
+        description: "Pagination cursor from a previous response nextCursor field. Omit for the first page.",
+        required: false
+      }
+    },
+    execute: (c, a) => getIncomingFriendRequests(
+      c,
+      a
+    )
   },
   // ── Chat ─────────────────────────────────────────────────────────────
   {
@@ -38891,6 +39586,90 @@ var TOOL_DEFINITIONS = [
     },
     execute: (c, a) => tipUser(c, a)
   },
+  {
+    name: "dim_confirm_send_usdc",
+    description: "External wallet: confirm a USDC transfer after signing and broadcasting the transaction. Provide the on-chain signature and the params from the confirmWith object returned by dim_send_usdc.",
+    params: {
+      signature: {
+        type: "string",
+        description: "On-chain transaction signature returned by send_solana_transaction",
+        required: true
+      },
+      recipientAddress: {
+        type: "string",
+        description: "Recipient Solana address (from confirmWith.params)",
+        required: true
+      },
+      amount: {
+        type: "number",
+        description: "Amount in USDC minor units (from confirmWith.params)",
+        required: true
+      },
+      fee: {
+        type: "number",
+        description: "Fee in minor units (from confirmWith.params)"
+      },
+      token: {
+        type: "string",
+        description: "Token type: USDC or SOL (default: USDC)"
+      },
+      ataCreated: {
+        type: "string",
+        description: "Whether a new ATA was created (from confirmWith.params)"
+      },
+      recipientInput: {
+        type: "string",
+        description: "Original recipient input (from confirmWith.params)"
+      }
+    },
+    execute: (c, a) => confirmSendUsdc(
+      c,
+      a
+    )
+  },
+  {
+    name: "dim_confirm_tip_user",
+    description: "External wallet: confirm a tip after signing and broadcasting the transaction. Provide the on-chain signature and the params from the confirmWith object returned by dim_tip_user.",
+    params: {
+      signature: {
+        type: "string",
+        description: "On-chain transaction signature returned by send_solana_transaction",
+        required: true
+      },
+      recipientAddress: {
+        type: "string",
+        description: "Recipient Solana address (from confirmWith.params)",
+        required: true
+      },
+      recipientUserId: {
+        type: "string",
+        description: "Recipient user ID (from confirmWith.params)",
+        required: true
+      },
+      recipientUsername: {
+        type: "string",
+        description: "Recipient username (from confirmWith.params)",
+        required: true
+      },
+      amount: {
+        type: "number",
+        description: "Amount in USDC minor units (from confirmWith.params)",
+        required: true
+      },
+      fee: {
+        type: "number",
+        description: "Fee in minor units (from confirmWith.params)"
+      },
+      ataCreated: {
+        type: "string",
+        description: "Whether a new ATA was created (from confirmWith.params)"
+      }
+    },
+    execute: (c, a) => confirmTipUser(
+      c,
+      a
+    )
+  },
   {
     name: "dim_get_wallet_activity",
     description: "Get recent wallet transaction activity (deposits, payouts, transfers, refunds) and your DIM wallet address. Highlights any claimable items.",
@@ -38987,6 +39766,23 @@ var TOOL_DEFINITIONS = [
     },
     execute: (c, a) => depositForLobby(c, a)
   },
+  {
+    name: "dim_confirm_lobby_deposit",
+    description: "External wallet: confirm a lobby deposit after signing and broadcasting the transaction. Polls until the deposit is confirmed on-chain, then returns canProceedToQueue.",
+    params: {
+      lobbyId: {
+        type: "string",
+        description: "The lobby ID (from confirmWith.params)",
+        required: true
+      },
+      signature: {
+        type: "string",
+        description: "On-chain transaction signature returned by send_solana_transaction",
+        required: true
+      }
+    },
+    execute: (c, a) => confirmLobbyDeposit(c, a)
+  },
   {
     name: "dim_leave_lobby",
     description: "Leave a lobby. Use this to exit a lobby you created or joined. Returns when you have left.",
@@ -39079,6 +39875,31 @@ var TOOL_DEFINITIONS = [
     },
     execute: (c, a) => gameLoop(c, a)
   },
+  {
+    name: "dim_confirm_donate_to_pot",
+    description: "External wallet: confirm a game pot donation after signing and broadcasting the transaction.",
+    params: {
+      signature: {
+        type: "string",
+        description: "On-chain transaction signature returned by send_solana_transaction",
+        required: true
+      },
+      gameId: {
+        type: "string",
+        description: "The game ID (from confirmWith.params)",
+        required: true
+      },
+      amount: {
+        type: "number",
+        description: "Amount in USDC minor units (from confirmWith.params)",
+        required: true
+      }
+    },
+    execute: (c, a) => confirmDonateToPot(
+      c,
+      a
+    )
+  },
   {
     name: "dim_request_rematch",
     description: "Request a rematch after a completed game. If both players request, a lobby is created automatically server-side.",