@dimcool/dimclaw 0.1.10

package/index.ts

@@ -0,0 +1,1848 @@
+/**
+ * @dimcool/dimclaw — OpenClaw plugin for DIM.
+ * Uses the SDK directly (no MCP subprocess). Register all DIM tools for OpenClaw agents.
+ */
+
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { Keypair, Transaction } from '@solana/web3.js';
+import bs58 from 'bs58';
+import { DimClient } from './dim-client';
+
+type PluginConfig = {
+  walletPrivateKey?: string;
+  walletStorePath?: string;
+  apiUrl?: string;
+};
+
+function getPluginConfig(api: { config?: unknown }): PluginConfig | null {
+  const config = api.config as Record<string, unknown> | undefined;
+  const plugins = config?.plugins as
+    | { entries?: Record<string, { config?: PluginConfig }> }
+    | undefined;
+  const dimclawEntry = plugins?.entries?.dimclaw;
+  return dimclawEntry?.config ?? null;
+}
+
+function resolveStorePath(storePath: string): string {
+  const expanded =
+    storePath.startsWith('~/') && process.env.HOME
+      ? path.join(process.env.HOME, storePath.slice(2))
+      : storePath;
+  return path.resolve(expanded);
+}
+
+interface WalletRecord {
+  version: 1;
+  walletAddress: string;
+  walletPrivateKey: string;
+  createdAt: string;
+}
+
+async function readWalletFile(storePath: string): Promise<WalletRecord | null> {
+  try {
+    const raw = await readFile(storePath, 'utf8');
+    const parsed = JSON.parse(raw) as Partial<WalletRecord>;
+    if (parsed.walletPrivateKey && parsed.walletAddress) {
+      return {
+        version: 1,
+        walletAddress: parsed.walletAddress,
+        walletPrivateKey: parsed.walletPrivateKey,
+        createdAt: parsed.createdAt ?? new Date().toISOString(),
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function writeWalletFile(
+  storePath: string,
+  record: WalletRecord,
+): Promise<void> {
+  await mkdir(path.dirname(storePath), { recursive: true });
+  const tmp = `${storePath}.tmp`;
+  await writeFile(tmp, `${JSON.stringify(record, null, 2)}\n`, {
+    encoding: 'utf8',
+    mode: 0o600,
+  });
+  await rename(tmp, storePath);
+}
+
+function createWalletRecord(): WalletRecord {
+  const keypair = Keypair.generate();
+  return {
+    version: 1,
+    walletAddress: keypair.publicKey.toBase58(),
+    walletPrivateKey: bs58.encode(keypair.secretKey),
+    createdAt: new Date().toISOString(),
+  };
+}
+
+/** Resolve wallet private key from config: direct key, or read/create at store path. */
+async function resolveWalletKey(config: PluginConfig): Promise<string | null> {
+  if (config.walletPrivateKey?.trim()) return config.walletPrivateKey.trim();
+  if (!config.walletStorePath?.trim()) return null;
+  const storePath = resolveStorePath(config.walletStorePath.trim());
+  const existing = await readWalletFile(storePath);
+  if (existing) return existing.walletPrivateKey;
+  const record = createWalletRecord();
+  await writeWalletFile(storePath, record);
+  return record.walletPrivateKey;
+}
+
+function textResult(
+  text: string,
+  isError = false,
+): { content: Array<{ type: 'text'; text: string }>; isError?: boolean } {
+  return {
+    content: [{ type: 'text', text }],
+    ...(isError ? { isError: true } : {}),
+  };
+}
+
+export default function register(api: {
+  config?: unknown;
+  registerTool: (tool: {
+    name: string;
+    description: string;
+    parameters?: Record<string, unknown>;
+    execute: (
+      id: unknown,
+      params: Record<string, unknown>,
+    ) => Promise<{
+      content: Array<{ type: 'text'; text: string }>;
+      isError?: boolean;
+    }>;
+  }) => void;
+}) {
+  let client: DimClient | null = null;
+
+  async function getClient(): Promise<DimClient | null> {
+    if (client) return client;
+    const config = getPluginConfig(api);
+    if (!config) return null;
+    const walletPrivateKey = await resolveWalletKey(config);
+    if (!walletPrivateKey) return null;
+    client = new DimClient({
+      walletPrivateKey,
+      apiUrl: config.apiUrl,
+    });
+    return client;
+  }
+
+  async function requireClient(): Promise<
+    DimClient | { error: ReturnType<typeof textResult> }
+  > {
+    const c = await getClient();
+    if (c) return c;
+    return {
+      error: textResult(
+        'DIM plugin is not configured. Set walletPrivateKey, or walletStorePath (we will create a wallet there if missing), under plugins.entries.dimclaw.config, then restart the gateway.',
+        true,
+      ),
+    };
+  }
+
+  // --- Auth ---
+  api.registerTool({
+    name: 'dim_login',
+    description:
+      'Authenticate with DIM using the configured wallet. Must be called before using any other tools. Returns user profile info.',
+    parameters: { type: 'object', properties: {}, additionalProperties: false },
+    async execute() {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const result = await c.authenticate();
+        const response: Record<string, unknown> = {
+          success: true,
+          userId: result.userId,
+          username: result.username,
+          walletAddress: c.walletAddress,
+        };
+        try {
+          const summary = await c.sdk.referrals.getSummary();
+          if (!summary.hasReferrer) {
+            response.referralHint =
+              'You have no referrer yet. Use dim_apply_referral_code to apply one and get a 10% fee discount.';
+          }
+        } catch {
+          /* non-critical */
+        }
+        return textResult(JSON.stringify(response, null, 2));
+      } catch (err) {
+        return textResult(
+          `Authentication failed: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_profile',
+    description:
+      'Get the current authenticated user profile including username, avatar, bio, and chess ELO rating.',
+    parameters: { type: 'object', properties: {}, additionalProperties: false },
+    async execute() {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        if (!c.currentUserId)
+          return textResult('Not authenticated. Call dim_login first.', true);
+        const user = await c.sdk.users.getUserById(c.currentUserId);
+        return textResult(JSON.stringify(user, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get profile: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_set_username',
+    description:
+      'Set or update the username for the authenticated user. Username must be alphanumeric, 3-20 characters.',
+    parameters: {
+      type: 'object',
+      properties: {
+        username: { type: 'string', description: 'The desired username' },
+      },
+      required: ['username'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      const username = String(params.username ?? '');
+      try {
+        const { available, valid } =
+          await c.sdk.users.isUsernameAvailable(username);
+        if (!valid)
+          return textResult(
+            'Invalid username. Must be alphanumeric, 3-20 characters.',
+            true,
+          );
+        if (!available)
+          return textResult(`Username "${username}" is already taken.`, true);
+        const user = await c.sdk.users.updateUsername(username);
+        return textResult(
+          JSON.stringify({ success: true, username: user.username }, null, 2),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to set username: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  // --- Wallet ---
+  api.registerTool({
+    name: 'dim_get_balance',
+    description:
+      'Get the wallet balance for the authenticated user. Returns SOL and USDC amounts. USDC amounts are in minor units (1 USDC = 1,000,000 minor units).',
+    parameters: { type: 'object', properties: {}, additionalProperties: false },
+    async execute() {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const balance = await c.sdk.wallet.getBalances();
+        const usdcDollars = balance.usdc / 1_000_000;
+        return textResult(
+          JSON.stringify(
+            { ...balance, usdcFormatted: `$${usdcDollars.toFixed(2)}` },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to get balance: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_send_usdc',
+    description:
+      'Send USDC to another user by username or Solana address. A 1 cent ($0.01) fee applies per transfer. Minimum transfer is 5 cents ($0.05). Amount is in USDC dollars (e.g., 1.50 for $1.50).',
+    parameters: {
+      type: 'object',
+      properties: {
+        recipient: {
+          type: 'string',
+          description: 'Recipient username or Solana wallet address',
+        },
+        amount: {
+          type: 'number',
+          description: 'Amount in USDC dollars (e.g., 1.50 for $1.50)',
+        },
+      },
+      required: ['recipient', 'amount'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      const recipient = String(params.recipient ?? '');
+      const amount = Number(params.amount ?? 0);
+      try {
+        const amountMinor = Math.round(amount * 1_000_000);
+        const result = await c.sdk.wallet.send(recipient, amountMinor);
+        return textResult(
+          JSON.stringify(
+            {
+              success: true,
+              signature: result.signature,
+              status: result.status,
+              amountSent: `$${amount.toFixed(2)}`,
+              fee: '$0.01',
+              recipient,
+              recipientAddress: result.recipientAddress,
+            },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to send USDC: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_tip_user',
+    description:
+      'Tip a user with USDC and broadcast the tip to global chat. A 1 cent fee applies. Amount is in USDC dollars.',
+    parameters: {
+      type: 'object',
+      properties: {
+        recipientUsername: {
+          type: 'string',
+          description: 'Username of the user to tip',
+        },
+        amount: {
+          type: 'number',
+          description: 'Tip amount in USDC dollars (e.g., 1.00 for $1.00)',
+        },
+      },
+      required: ['recipientUsername', 'amount'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      const recipientUsername = String(params.recipientUsername ?? '');
+      const amount = Number(params.amount ?? 0);
+      try {
+        const amountMinor = Math.round(amount * 1_000_000);
+        const result = await c.sdk.tips.send(recipientUsername, amountMinor);
+        return textResult(
+          JSON.stringify(
+            {
+              success: true,
+              signature: result.signature,
+              tipAmount: `$${amount.toFixed(2)}`,
+              fee: '$0.01',
+              recipient: recipientUsername,
+              broadcastedToGlobalChat: true,
+            },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to tip user: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_wallet_activity',
+    description:
+      'Get recent wallet transaction activity (deposits, payouts, transfers, refunds).',
+    parameters: {
+      type: 'object',
+      properties: {
+        limit: {
+          type: 'number',
+          description: 'Max items to return (default: 20)',
+        },
+      },
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      const limit = typeof params.limit === 'number' ? params.limit : 20;
+      try {
+        const activity = await c.sdk.wallet.getActivity({ limit });
+        return textResult(JSON.stringify(activity, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get wallet activity: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  // --- Friends ---
+  api.registerTool({
+    name: 'dim_search_users',
+    description:
+      'Search for DIM users by username. Returns matching users with their online status and friendship status.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Username to search for' },
+        limit: {
+          type: 'number',
+          description: 'Max results to return (default: 10)',
+        },
+      },
+      required: ['query'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      const query = String(params.query ?? '');
+      const limit = typeof params.limit === 'number' ? params.limit : 10;
+      try {
+        const result = await c.sdk.users.searchUsers(query, 1, limit);
+        return textResult(JSON.stringify(result, null, 2));
+      } catch (err) {
+        return textResult(
+          `Search failed: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_send_friend_request',
+    description:
+      'Send a friend request to a user by their user ID. If they already sent you a request, this auto-accepts.',
+    parameters: {
+      type: 'object',
+      properties: {
+        userId: {
+          type: 'string',
+          description: 'The user ID to send a friend request to',
+        },
+      },
+      required: ['userId'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const result = await c.sdk.users.addFriend(String(params.userId ?? ''));
+        return textResult(JSON.stringify(result, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to send friend request: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_accept_friend_request',
+    description: 'Accept an incoming friend request from a user.',
+    parameters: {
+      type: 'object',
+      properties: {
+        userId: {
+          type: 'string',
+          description: 'The user ID whose friend request to accept',
+        },
+      },
+      required: ['userId'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const result = await c.sdk.users.acceptFriendRequest(
+          String(params.userId ?? ''),
+        );
+        return textResult(JSON.stringify(result, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to accept friend request: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_list_friends',
+    description: "List the authenticated user's friends with pagination.",
+    parameters: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        limit: {
+          type: 'number',
+          description: 'Friends per page (default: 20)',
+        },
+        search: { type: 'string', description: 'Filter friends by username' },
+      },
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      if (!c.currentUserId)
+        return textResult('Not authenticated. Call dim_login first.', true);
+      try {
+        const result = await c.sdk.users.getFriends(
+          c.currentUserId,
+          typeof params.page === 'number' ? params.page : 1,
+          typeof params.limit === 'number' ? params.limit : 20,
+          typeof params.search === 'string' ? params.search : undefined,
+        );
+        return textResult(JSON.stringify(result, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to list friends: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_incoming_friend_requests',
+    description: 'List pending incoming friend requests.',
+    parameters: { type: 'object', properties: {}, additionalProperties: false },
+    async execute() {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const result = await c.sdk.users.getIncomingFriendRequests();
+        return textResult(JSON.stringify(result, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get requests: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  // --- Chat ---
+  api.registerTool({
+    name: 'dim_send_message',
+    description:
+      "Send a chat message in a specific context (lobby, game, DM, or global chat). For DMs, the contextId is the other user's ID.",
+    parameters: {
+      type: 'object',
+      properties: {
+        contextType: {
+          type: 'string',
+          enum: ['lobby', 'game', 'dm', 'global'],
+          description: 'Chat context type',
+        },
+        contextId: {
+          type: 'string',
+          description:
+            'Context ID: lobby ID, game ID, user ID (for DM), or "global"',
+        },
+        message: {
+          type: 'string',
+          description: 'Message text (1-500 characters)',
+        },
+      },
+      required: ['contextType', 'contextId', 'message'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const result = await c.sdk.chat.sendMessage(
+          {
+            type: params.contextType as 'lobby' | 'game' | 'dm' | 'global',
+            id: String(params.contextId ?? ''),
+          },
+          String(params.message ?? ''),
+        );
+        return textResult(JSON.stringify(result, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to send message: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_chat_history',
+    description:
+      'Get chat history for a context (lobby, game, DM, or global). Returns messages in chronological order.',
+    parameters: {
+      type: 'object',
+      properties: {
+        contextType: {
+          type: 'string',
+          enum: ['lobby', 'game', 'dm', 'global'],
+          description: 'Chat context type',
+        },
+        contextId: {
+          type: 'string',
+          description:
+            'Context ID: lobby ID, game ID, user ID (for DM), or "global"',
+        },
+        limit: {
+          type: 'number',
+          description: 'Max messages to return (default: 50)',
+        },
+      },
+      required: ['contextType', 'contextId'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      const limit = typeof params.limit === 'number' ? params.limit : 50;
+      try {
+        const messages = await c.sdk.chat.getChatHistory(
+          {
+            type: params.contextType as 'lobby' | 'game' | 'dm' | 'global',
+            id: String(params.contextId ?? ''),
+          },
+          limit,
+        );
+        return textResult(JSON.stringify(messages, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get chat history: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_send_dm',
+    description: 'Send a direct message to another user by their user ID.',
+    parameters: {
+      type: 'object',
+      properties: {
+        userId: { type: 'string', description: 'The user ID to send a DM to' },
+        message: {
+          type: 'string',
+          description: 'Message text (1-500 characters)',
+        },
+      },
+      required: ['userId', 'message'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const result = await c.sdk.chat.sendMessage(
+          { type: 'dm', id: String(params.userId ?? '') },
+          String(params.message ?? ''),
+        );
+        return textResult(JSON.stringify(result, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to send DM: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_list_dm_threads',
+    description:
+      'List all DM conversation threads with last message info and unread counts.',
+    parameters: { type: 'object', properties: {}, additionalProperties: false },
+    async execute() {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const threads = await c.sdk.chat.listDmThreads();
+        return textResult(JSON.stringify(threads, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to list DM threads: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  // --- Games ---
+  api.registerTool({
+    name: 'dim_list_games',
+    description:
+      'List all available game types on DIM with player counts and descriptions. Games include: Rock-Paper-Scissors, Chess, Tic-Tac-Toe, Connect Four, Nim, Dots and Boxes.',
+    parameters: { type: 'object', properties: {}, additionalProperties: false },
+    async execute() {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const games = await c.sdk.games.getAvailableGames();
+        return textResult(JSON.stringify(games, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to list games: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_game_metrics',
+    description:
+      'Get real-time metrics for all games: active players, live games, and money in play per game type.',
+    parameters: { type: 'object', properties: {}, additionalProperties: false },
+    async execute() {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const metrics = await c.sdk.games.getMetrics();
+        return textResult(JSON.stringify(metrics, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get metrics: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_create_lobby',
+    description:
+      'Create a new game lobby. The agent becomes the lobby creator. Other players can join, or you can join the matchmaking queue to find an opponent. Bet amount is in USDC minor units (1 USDC = 1,000,000). A 1% fee (min 1 cent) is charged per player.',
+    parameters: {
+      type: 'object',
+      properties: {
+        gameType: {
+          type: 'string',
+          description:
+            'Game type ID (e.g., "rock-paper-scissors", "chess", "tic-tac-toe", "connect-four", "nim", "dots-and-boxes")',
+        },
+        betAmount: {
+          type: 'number',
+          description:
+            'Bet amount in USDC minor units (e.g., 1000000 = $1.00). Common amounts: 1000000 ($1), 5000000 ($5), 10000000 ($10)',
+        },
+      },
+      required: ['gameType'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      const gameType = String(params.gameType ?? '');
+      const betAmount =
+        typeof params.betAmount === 'number' ? params.betAmount : undefined;
+      try {
+        const lobby = await c.sdk.lobbies.createLobby(gameType, betAmount);
+        return textResult(
+          JSON.stringify(
+            {
+              lobbyId: lobby.id,
+              gameType: lobby.gameType,
+              status: lobby.status,
+              betAmount: lobby.betAmount,
+              betFormatted: lobby.betAmount
+                ? `$${(lobby.betAmount / 1_000_000).toFixed(2)}`
+                : 'Free',
+              maxPlayers: lobby.maxPlayers,
+              players: lobby.players.length,
+              hint: 'Use dim_join_queue to find an opponent, or share the lobbyId for someone to join directly.',
+            },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to create lobby: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_join_queue',
+    description:
+      'Join the matchmaking queue for a lobby. If the lobby is full, the game starts immediately. Otherwise, waits for an opponent. Returns the lobby (and gameId if matched).',
+    parameters: {
+      type: 'object',
+      properties: {
+        lobbyId: {
+          type: 'string',
+          description: 'The lobby ID to join the queue for',
+        },
+      },
+      required: ['lobbyId'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        await c.ensureConnected();
+        const lobby = await c.sdk.lobbies.joinQueue(
+          String(params.lobbyId ?? ''),
+        );
+        const matched = lobby.status === 'active' && lobby.gameId;
+        return textResult(
+          JSON.stringify(
+            {
+              lobbyId: lobby.id,
+              status: lobby.status,
+              gameId: lobby.gameId || null,
+              matched: !!matched,
+              hint: matched
+                ? `Game started! Use dim_get_game_state with gameId "${lobby.gameId}" to see the game state, then dim_submit_action to play.`
+                : 'Waiting for an opponent. Poll dim_get_lobby to check for a match.',
+            },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to join queue: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_lobby',
+    description:
+      'Get the current state of a lobby including players, status, and gameId (if matched).',
+    parameters: {
+      type: 'object',
+      properties: {
+        lobbyId: { type: 'string', description: 'The lobby ID to check' },
+      },
+      required: ['lobbyId'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const lobby = await c.sdk.lobbies.getLobby(
+          String(params.lobbyId ?? ''),
+        );
+        return textResult(JSON.stringify(lobby, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get lobby: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_game_state',
+    description:
+      'Get the current state of an active game including round info, scores, timer, and available actions. The response format depends on the game type.',
+    parameters: {
+      type: 'object',
+      properties: {
+        gameId: { type: 'string', description: 'The game ID to get state for' },
+      },
+      required: ['gameId'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const state = await c.sdk.games.getGameState(
+          String(params.gameId ?? ''),
+        );
+        return textResult(JSON.stringify(state, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get game state: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_submit_action',
+    description:
+      'Submit a game action. The action format depends on the game type.\n\n' +
+      'Rock-Paper-Scissors: gameType="rock-paper-scissors", action="play", payload={ action: "rock"|"paper"|"scissors" }\n' +
+      'Chess: gameType="chess", action="move", payload={ from: "e2", to: "e4" }\n' +
+      'Tic-Tac-Toe: gameType="tic-tac-toe", action="place", payload={ position: 0-8 }\n' +
+      'Connect Four: gameType="connect-four", action="drop", payload={ column: 0-6 }\n' +
+      'Nim: gameType="nim", action="take", payload={ heap: 0-2, count: 1-N }\n' +
+      'Dots and Boxes: gameType="dots-and-boxes", action="draw", payload={ row, col, direction: "h"|"v" }',
+    parameters: {
+      type: 'object',
+      properties: {
+        gameId: {
+          type: 'string',
+          description: 'The game ID to submit an action for',
+        },
+        gameType: {
+          type: 'string',
+          description:
+            'Game type (e.g., "rock-paper-scissors", "chess", "tic-tac-toe")',
+        },
+        action: {
+          type: 'string',
+          description: 'Action type (e.g., "play", "move", "place", "drop")',
+        },
+        payload: {
+          type: 'object',
+          description:
+            'Action payload (game-specific, see tool description for format)',
+        },
+      },
+      required: ['gameId', 'gameType', 'action', 'payload'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        await c.sdk.games.submitAction(String(params.gameId ?? ''), {
+          gameType: String(params.gameType ?? ''),
+          action: String(params.action ?? ''),
+          payload: (params.payload as Record<string, unknown>) ?? {},
+        } as never);
+        return textResult(
+          JSON.stringify(
+            {
+              success: true,
+              gameId: params.gameId,
+              action: params.action,
+              hint: 'Use dim_get_game_state to see the updated game state.',
+            },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to submit action: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_donate_to_pot',
+    description:
+      'Donate USDC to a game pot (spectator donation). One-call flow: prepare, sign, and submit internally.',
+    parameters: {
+      type: 'object',
+      properties: {
+        gameId: { type: 'string', description: 'The game ID to donate to' },
+        amount: {
+          type: 'number',
+          description: 'Amount in USDC dollars (minimum $0.10)',
+        },
+      },
+      required: ['gameId', 'amount'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      const amount = Number(params.amount ?? 0);
+      try {
+        const amountMinor = Math.round(amount * 1_000_000);
+        const result = await c.sdk.games.sendDonation(
+          String(params.gameId ?? ''),
+          amountMinor,
+        );
+        return textResult(
+          JSON.stringify(
+            {
+              success: true,
+              gameId: params.gameId,
+              signature: result.signature,
+              status: result.status,
+              amountDonated: `$${amount.toFixed(2)}`,
+              amountMinor: result.amountMinor,
+              escrowAddress: result.escrowAddress,
+            },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to donate to pot: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_game',
+    description:
+      'Get game info including status (active/completed/abandoned), players, and lobby IDs.',
+    parameters: {
+      type: 'object',
+      properties: { gameId: { type: 'string', description: 'The game ID' } },
+      required: ['gameId'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const game = await c.sdk.games.getGame(String(params.gameId ?? ''));
+        return textResult(JSON.stringify(game, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get game: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  // --- Challenges ---
+  api.registerTool({
+    name: 'dim_challenge_user',
+    description:
+      'Challenge another user to a game for USDC. The target user will receive a notification. Amount must be between $1 and $1000. You can specify the target by userId or username.',
+    parameters: {
+      type: 'object',
+      properties: {
+        gameType: {
+          type: 'string',
+          description:
+            'Game type (e.g., "rock-paper-scissors", "chess", "tic-tac-toe")',
+        },
+        amount: {
+          type: 'number',
+          description: 'Challenge amount in USDC dollars (e.g., 5.00 for $5)',
+        },
+        targetUsername: {
+          type: 'string',
+          description: 'Username of the user to challenge',
+        },
+        targetUserId: {
+          type: 'string',
+          description: 'User ID of the user to challenge',
+        },
+      },
+      required: ['gameType', 'amount'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      const targetUsername =
+        typeof params.targetUsername === 'string'
+          ? params.targetUsername
+          : undefined;
+      const targetUserId =
+        typeof params.targetUserId === 'string'
+          ? params.targetUserId
+          : undefined;
+      if (!targetUsername && !targetUserId) {
+        return textResult(
+          'Must provide either targetUsername or targetUserId.',
+          true,
+        );
+      }
+      try {
+        const amountMinor = Math.round(Number(params.amount ?? 0) * 1_000_000);
+        const result = await c.sdk.challenges.create({
+          gameType: String(params.gameType ?? ''),
+          amount: amountMinor,
+          targetUsername,
+          targetUserId,
+        });
+        return textResult(
+          JSON.stringify(
+            {
+              ...result,
+              amountFormatted: `$${Number(params.amount).toFixed(2)}`,
+              hint: 'The challenged user will receive a notification. When they accept, a lobby is created automatically.',
+            },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to create challenge: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_accept_challenge',
+    description:
+      'Accept a challenge that was sent to you. Creates a lobby with the challenge amount and returns the lobby/game info.',
+    parameters: {
+      type: 'object',
+      properties: {
+        challengeId: {
+          type: 'string',
+          description: 'The challenge ID to accept',
+        },
+      },
+      required: ['challengeId'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const result = await c.sdk.challenges.accept(
+          String(params.challengeId ?? ''),
+        );
+        return textResult(
+          JSON.stringify(
+            {
+              ...result,
+              hint: result.gameId
+                ? `Game started! Use dim_get_game_state with gameId "${result.gameId}".`
+                : `Lobby created: ${result.lobbyId}. Use dim_join_queue to start matchmaking.`,
+            },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to accept challenge: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  // --- Referrals ---
+  api.registerTool({
+    name: 'dim_get_referral_summary',
+    description:
+      'Get your referral summary including your referral code (your username), referral link, total referrals per level, and earnings (pending + claimed). DIM has a 3-level referral system: Level 1 = 30% of game fees, Level 2 = 3%, Level 3 = 2%.',
+    parameters: { type: 'object', properties: {}, additionalProperties: false },
+    async execute() {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const summary = await c.sdk.referrals.getSummary();
+        const pendingDollars = summary.earnings.pending / 1_000_000;
+        const claimedDollars = summary.earnings.claimed / 1_000_000;
+        const result: Record<string, unknown> = {
+          ...summary,
+          pendingFormatted: `$${pendingDollars.toFixed(2)}`,
+          claimedFormatted: `$${claimedDollars.toFixed(2)}`,
+          referralRates: {
+            level1: '30% of referred user game fees',
+            level2: '3% of level-2 referral game fees',
+            level3: '2% of level-3 referral game fees',
+          },
+          referredUserBenefit: '10% fee discount (0.9% instead of 1%)',
+        };
+        if (!summary.hasReferrer) {
+          result.applyReferralHint =
+            'You have no referrer yet. Use dim_apply_referral_code to apply one and get a 10% fee discount.';
+        }
+        return textResult(JSON.stringify(result, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get referral summary: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_referral_tree',
+    description:
+      'Get your referral tree at a specific level. Level 1 = direct referrals, Level 2 = referrals of your referrals, Level 3 = one more level deep.',
+    parameters: {
+      type: 'object',
+      properties: {
+        level: {
+          type: 'string',
+          enum: ['1', '2', '3'],
+          description: 'Referral level to view (1, 2, or 3)',
+        },
+        limit: {
+          type: 'number',
+          description: 'Max results (default: 50, max: 200)',
+        },
+        cursor: { type: 'string', description: 'Pagination cursor' },
+      },
+      required: ['level'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const tree = await c.sdk.referrals.getTree({
+          level: parseInt(String(params.level ?? '1'), 10) as 1 | 2 | 3,
+          limit: typeof params.limit === 'number' ? params.limit : 50,
+          cursor: typeof params.cursor === 'string' ? params.cursor : undefined,
+        });
+        return textResult(JSON.stringify(tree, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get referral tree: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_referral_rewards',
+    description:
+      'Get your referral reward history. Filter by status: PENDING (unclaimed), CLAIMED (already claimed), CANCELLED.',
+    parameters: {
+      type: 'object',
+      properties: {
+        status: {
+          type: 'string',
+          enum: ['PENDING', 'CLAIMED', 'CANCELLED'],
+          description: 'Filter by reward status',
+        },
+        limit: {
+          type: 'number',
+          description: 'Max results (default: 50, max: 200)',
+        },
+        cursor: { type: 'string', description: 'Pagination cursor' },
+      },
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const rewards = await c.sdk.referrals.getRewards({
+          status: params.status as
+            | 'PENDING'
+            | 'CLAIMED'
+            | 'CANCELLED'
+            | undefined,
+          limit: typeof params.limit === 'number' ? params.limit : 50,
+          cursor: typeof params.cursor === 'string' ? params.cursor : undefined,
+        });
+        return textResult(JSON.stringify(rewards, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get referral rewards: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_claim_referral_rewards',
+    description:
+      'Claim all pending referral rewards. USDC is transferred from escrow to your wallet. Returns the claimed amount and transaction signature.',
+    parameters: { type: 'object', properties: {}, additionalProperties: false },
+    async execute() {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const result = await c.sdk.referrals.claimRewards();
+        const claimedDollars = result.claimedAmount / 1_000_000;
+        return textResult(
+          JSON.stringify(
+            { ...result, claimedFormatted: `$${claimedDollars.toFixed(2)}` },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to claim rewards: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_apply_referral_code',
+    description:
+      "Apply a referral code to your account (another user's username). Can only be applied once — if you already have a referrer, this will fail. Gives you a 10% fee discount.",
+    parameters: {
+      type: 'object',
+      properties: {
+        referralCode: {
+          type: 'string',
+          description: "The referral code to apply (another user's username)",
+        },
+      },
+      required: ['referralCode'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const result = await c.sdk.referrals.applyCode(
+          String(params.referralCode ?? ''),
+        );
+        return textResult(
+          JSON.stringify(
+            {
+              ...result,
+              message: `Referral code applied! ${result.referrerUsername} is now your referrer. You get a 10% fee discount on all games.`,
+            },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to apply referral code: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  // --- Support ---
+  api.registerTool({
+    name: 'dim_create_support_ticket',
+    description:
+      'Create a support ticket to contact the DIM team. Use this when you need help with your account, payments, games, bugs, or any other issue. Categories: BUG, FEATURE_REQUEST, QUESTION, ACCOUNT, PAYMENT, GAME, TECHNICAL, OTHER.',
+    parameters: {
+      type: 'object',
+      properties: {
+        message: {
+          type: 'string',
+          description: 'Describe the issue or question (max 2000 chars)',
+        },
+        category: {
+          type: 'string',
+          enum: [
+            'BUG',
+            'FEATURE_REQUEST',
+            'QUESTION',
+            'ACCOUNT',
+            'PAYMENT',
+            'GAME',
+            'TECHNICAL',
+            'OTHER',
+          ],
+          description: 'Ticket category (default: OTHER)',
+        },
+        subject: {
+          type: 'string',
+          description:
+            'Short subject line (auto-generated from category if omitted)',
+        },
+      },
+      required: ['message'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const ticket = await c.sdk.support.create({
+          message: String(params.message ?? ''),
+          category: params.category as
+            | 'BUG'
+            | 'FEATURE_REQUEST'
+            | 'QUESTION'
+            | 'ACCOUNT'
+            | 'PAYMENT'
+            | 'GAME'
+            | 'TECHNICAL'
+            | 'OTHER'
+            | undefined,
+          subject:
+            typeof params.subject === 'string' ? params.subject : undefined,
+        });
+        return textResult(
+          JSON.stringify(
+            {
+              ...ticket,
+              hint: 'Ticket created successfully. You can check its status with dim_get_my_tickets or add follow-up messages with dim_add_ticket_message.',
+            },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to create support ticket: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_my_tickets',
+    description:
+      'Get your support tickets. Filter by status (OPEN, IN_PROGRESS, WAITING_REPLY, RESOLVED, CLOSED) or category.',
+    parameters: {
+      type: 'object',
+      properties: {
+        status: {
+          type: 'string',
+          enum: ['OPEN', 'IN_PROGRESS', 'WAITING_REPLY', 'RESOLVED', 'CLOSED'],
+          description: 'Filter by ticket status',
+        },
+        category: {
+          type: 'string',
+          enum: [
+            'BUG',
+            'FEATURE_REQUEST',
+            'QUESTION',
+            'ACCOUNT',
+            'PAYMENT',
+            'GAME',
+            'TECHNICAL',
+            'OTHER',
+          ],
+          description: 'Filter by category',
+        },
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        limit: {
+          type: 'number',
+          description: 'Results per page (default: 10)',
+        },
+      },
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const tickets = await c.sdk.support.getMyTickets({
+          status: params.status as any,
+          category: params.category as any,
+          page: typeof params.page === 'number' ? params.page : undefined,
+          limit: typeof params.limit === 'number' ? params.limit : undefined,
+        });
+        return textResult(JSON.stringify(tickets, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get tickets: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_ticket',
+    description:
+      'Get a specific support ticket with all messages. You can only view your own tickets.',
+    parameters: {
+      type: 'object',
+      properties: {
+        ticketId: { type: 'string', description: 'The ticket ID' },
+      },
+      required: ['ticketId'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const ticket = await c.sdk.support.getMyTicketById(
+          String(params.ticketId ?? ''),
+        );
+        return textResult(JSON.stringify(ticket, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get ticket: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_add_ticket_message',
+    description:
+      'Add a follow-up message to an existing support ticket. You can only message your own tickets.',
+    parameters: {
+      type: 'object',
+      properties: {
+        ticketId: { type: 'string', description: 'The ticket ID' },
+        message: {
+          type: 'string',
+          description: 'Your follow-up message (max 2000 chars)',
+        },
+      },
+      required: ['ticketId', 'message'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const msg = await c.sdk.support.addMessage(
+          String(params.ticketId ?? ''),
+          String(params.message ?? ''),
+        );
+        return textResult(
+          JSON.stringify(
+            { ...msg, hint: 'Message added. The DIM team will be notified.' },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to add message: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_close_ticket',
+    description:
+      'Close a support ticket. Only close if your issue has been resolved.',
+    parameters: {
+      type: 'object',
+      properties: {
+        ticketId: { type: 'string', description: 'The ticket ID to close' },
+      },
+      required: ['ticketId'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const ticket = await c.sdk.support.closeTicket(
+          String(params.ticketId ?? ''),
+        );
+        return textResult(JSON.stringify(ticket, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to close ticket: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  // --- Markets ---
+  api.registerTool({
+    name: 'dim_get_market',
+    description:
+      'Get the prediction market state for an active game. Returns share prices (implied probabilities), total collateral locked, total volume, and resolution status.',
+    parameters: {
+      type: 'object',
+      properties: {
+        gameId: {
+          type: 'string',
+          description: 'The game ID to get market state for',
+        },
+      },
+      required: ['gameId'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const market = await c.sdk.markets.getMarket(
+          String(params.gameId ?? ''),
+        );
+        return textResult(JSON.stringify(market, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get market: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_buy_shares',
+    description:
+      'Buy shares in a prediction market outcome. Pick which player you think will win and how much to bet. Amount is in USDC dollars (e.g., 1.00 for $1.00).',
+    parameters: {
+      type: 'object',
+      properties: {
+        gameId: { type: 'string', description: 'The game ID' },
+        outcomeId: {
+          type: 'string',
+          description: 'The outcome (player user ID) to buy shares of',
+        },
+        amount: {
+          type: 'number',
+          description: 'Amount in USDC dollars (e.g., 1.00 for $1.00)',
+        },
+      },
+      required: ['gameId', 'outcomeId', 'amount'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      const amount = Number(params.amount ?? 0);
+      const gameId = String(params.gameId ?? '');
+      const outcomeId = String(params.outcomeId ?? '');
+      try {
+        const amountMinor = Math.round(amount * 1_000_000);
+        const { transaction: txBase64 } = await c.sdk.markets.prepareBuyOrder(
+          gameId,
+          outcomeId,
+          amountMinor,
+        );
+        const tx = Transaction.from(Buffer.from(txBase64, 'base64'));
+        tx.partialSign(c.getKeypair());
+        const signedTxBase64 = Buffer.from(tx.serialize()).toString('base64');
+        const result = await c.sdk.markets.submitBuyOrder(
+          gameId,
+          signedTxBase64,
+          outcomeId,
+          amountMinor,
+        );
+        return textResult(
+          JSON.stringify(
+            {
+              success: true,
+              tradeId: result.tradeId,
+              sharesReceived: result.sharesReceived,
+              costPerShare: result.costPerShare,
+              amountSpent: `$${amount.toFixed(2)}`,
+            },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to buy shares: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_sell_shares',
+    description:
+      'Sell shares to exit a prediction market position. Shares are in minor units (1 share = 1,000,000 minor units).',
+    parameters: {
+      type: 'object',
+      properties: {
+        gameId: { type: 'string', description: 'The game ID' },
+        outcomeId: {
+          type: 'string',
+          description: 'The outcome to sell shares of',
+        },
+        shares: {
+          type: 'number',
+          description:
+            'Number of shares to sell in minor units (1 share = 1,000,000)',
+        },
+      },
+      required: ['gameId', 'outcomeId', 'shares'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const result = await c.sdk.markets.sellShares(
+          String(params.gameId ?? ''),
+          String(params.outcomeId ?? ''),
+          Number(params.shares ?? 0),
+        );
+        return textResult(
+          JSON.stringify(
+            {
+              success: true,
+              tradeId: result.tradeId,
+              amountReceived: result.amountReceived,
+              pricePerShare: result.pricePerShare,
+              newPrices: result.newPrices,
+            },
+            null,
+            2,
+          ),
+        );
+      } catch (err) {
+        return textResult(
+          `Failed to sell shares: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_positions',
+    description:
+      'Get your current prediction market positions for a game. Shows shares held, average cost, current value, and unrealized profit/loss.',
+    parameters: {
+      type: 'object',
+      properties: { gameId: { type: 'string', description: 'The game ID' } },
+      required: ['gameId'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const positions = await c.sdk.markets.getMyPositions(
+          String(params.gameId ?? ''),
+        );
+        return textResult(JSON.stringify(positions, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get positions: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_redeem_shares',
+    description:
+      'Redeem winning shares after a prediction market has been resolved. Winners split the pool pro-rata by shares held, minus a 3% fee.',
+    parameters: {
+      type: 'object',
+      properties: {
+        gameId: {
+          type: 'string',
+          description: 'The game ID to redeem shares for',
+        },
+      },
+      required: ['gameId'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        const result = await c.sdk.markets.redeemShares(
+          String(params.gameId ?? ''),
+        );
+        return textResult(JSON.stringify(result, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to redeem shares: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+
+  api.registerTool({
+    name: 'dim_get_market_analytics',
+    description:
+      'Get platform analytics for prediction markets. Shows total markets, orders, volume, fees, unique traders, and daily trends. Requires admin privileges.',
+    parameters: {
+      type: 'object',
+      properties: {
+        type: {
+          type: 'string',
+          enum: ['overview', 'daily', 'markets'],
+          description:
+            'overview = aggregate totals, daily = per-day breakdown, markets = paginated list of all markets',
+        },
+        days: {
+          type: 'number',
+          description: 'Number of days for daily stats (default 30)',
+        },
+        page: {
+          type: 'number',
+          description: 'Page number for markets list (default 1)',
+        },
+        limit: {
+          type: 'number',
+          description: 'Items per page for markets list (default 20)',
+        },
+      },
+      required: ['type'],
+      additionalProperties: false,
+    },
+    async execute(_, params) {
+      const c = await requireClient();
+      if ('error' in c) return c.error;
+      try {
+        let data: unknown;
+        switch (String(params.type)) {
+          case 'overview':
+            data = await c.sdk.markets.getAdminStats();
+            break;
+          case 'daily':
+            data = await c.sdk.markets.getAdminDailyStats(
+              typeof params.days === 'number' ? params.days : 30,
+            );
+            break;
+          case 'markets':
+            data = await c.sdk.markets.getAdminMarkets(
+              typeof params.page === 'number' ? params.page : undefined,
+              typeof params.limit === 'number' ? params.limit : undefined,
+            );
+            break;
+          default:
+            return textResult(
+              'Invalid type. Use overview, daily, or markets.',
+              true,
+            );
+        }
+        return textResult(JSON.stringify(data, null, 2));
+      } catch (err) {
+        return textResult(
+          `Failed to get market analytics: ${err instanceof Error ? err.message : String(err)}`,
+          true,
+        );
+      }
+    },
+  });
+}