@solworks/poll-mcp 0.1.20 → 0.1.26

package/dist/index.js

@@ -3,9 +3,12 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 import { PollClient } from '@solworks/poll-api-client';
+import { createRequire } from 'node:module';
 import { TOOL_DEFINITIONS } from './tools/index.js';
 import { RESOURCE_DEFINITIONS } from './resources/index.js';
 import { PROMPT_DEFINITIONS } from './prompts/index.js';
+const require = createRequire(import.meta.url);
+const { version: PKG_VERSION } = require('../package.json');
 /**
  * Convert a JSON Schema property type to a Zod schema.
  */
@@ -23,7 +26,7 @@ function jsonPropToZod(prop) {
     }
 }
 export function createServer(config, clientOverride) {
-    const server = new McpServer({ name: 'poll-fun', version: '0.1.18' }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
+    const server = new McpServer({ name: 'poll-fun', version: PKG_VERSION }, { capabilities: { tools: {}, resources: { listChanged: true }, prompts: {} } });
     const client = clientOverride ??
         new PollClient({
             apiUrl: config?.apiUrl ?? 'https://api.poll.fun',

package/dist/tools/index.js

@@ -437,6 +437,10 @@ export const TOOL_DEFINITIONS = {
             if (!betAddress)
                 return errorResult('Missing required parameter: betAddress');
             try {
+                const bet = await client.getBet(betAddress);
+                if (!bet.isPublic) {
+                    return errorResult('This is a private bet. You can only join private bets via the share link in the app.');
+                }
                 await client.joinBet(betAddress);
                 return textResult(`Successfully joined bet: ${betAddress}`);
             }
@@ -486,19 +490,23 @@ export const TOOL_DEFINITIONS = {
             type: 'object',
             properties: {
                 betAddress: { type: 'string', description: 'Address of the bet' },
-                wagerAddress: { type: 'string', description: 'Address of the wager to cancel' },
             },
-            required: ['betAddress', 'wagerAddress'],
+            required: ['betAddress'],
         },
         requiredScope: 'bet:write',
         async handler(args, client) {
             const betAddress = args.betAddress;
-            const wagerAddress = args.wagerAddress;
             if (!betAddress)
                 return errorResult('Missing required parameter: betAddress');
-            if (!wagerAddress)
-                return errorResult('Missing required parameter: wagerAddress');
             try {
+                const wagers = await client.getMyWagers();
+                const activeWager = wagers.find((w) => {
+                    const addr = w.betAddress ?? w.programBetBetAddress;
+                    return addr === betAddress && w.amount > 0;
+                });
+                if (!activeWager) {
+                    return errorResult(`You don't have an active wager on bet: ${betAddress}`);
+                }
                 await client.cancelWager({ marketPubkey: betAddress });
                 return textResult(`Wager cancelled successfully for bet: ${betAddress}`);
             }
@@ -523,6 +531,11 @@ export const TOOL_DEFINITIONS = {
             if (!betAddress)
                 return errorResult('Missing required parameter: betAddress');
             try {
+                const bet = await client.getBet(betAddress);
+                const status = (bet.status ?? '').toLowerCase();
+                if (status === 'resolving' || status === 'resolved' || status === 'distributed') {
+                    return errorResult(`Vote has already been initiated for this bet (status: ${bet.status})`);
+                }
                 await client.initiateVote(betAddress);
                 return textResult(`Vote initiated for bet: ${betAddress}`);
             }
@@ -551,6 +564,18 @@ export const TOOL_DEFINITIONS = {
             if (optionIndex === undefined || optionIndex === null)
                 return errorResult('Missing required parameter: optionIndex');
             try {
+                const [bet, account] = await Promise.all([
+                    client.getBet(betAddress),
+                    client.getAccount(),
+                ]);
+                const status = (bet.status ?? '').toLowerCase();
+                if (status !== 'resolving') {
+                    return errorResult(`Cannot vote: voting has not been initiated for this bet (status: ${bet.status}). Use initiate_vote first.`);
+                }
+                const alreadyVoted = Array.isArray(bet.votes) && bet.votes.some((v) => v.user === account.uuid || v.userUuid === account.uuid);
+                if (alreadyVoted) {
+                    return errorResult('You have already voted on this bet');
+                }
                 const outcome = optionIndex === 0 ? 'for' : 'against';
                 await client.vote({ marketPubkey: betAddress, outcome: outcome });
                 return textResult(`Vote cast successfully on bet ${betAddress} for option ${optionIndex} (${outcome})`);
@@ -576,6 +601,24 @@ export const TOOL_DEFINITIONS = {
             if (!betAddress)
                 return errorResult('Missing required parameter: betAddress');
             try {
+                const bet = await client.getBet(betAddress);
+                const status = (bet.status ?? '').toLowerCase();
+                if (status === 'distributed') {
+                    return errorResult('This bet has already been settled and distributed');
+                }
+                if (status !== 'resolving' && status !== 'resolved') {
+                    return errorResult(`Bet cannot be settled in its current status: ${bet.status}. Vote must be initiated first.`);
+                }
+                const wagerUsers = new Set((bet.wagers ?? []).filter((w) => w.amount > 0).map((w) => w.user));
+                const votedUsers = new Set((bet.votes ?? []).map((v) => v.user));
+                const notVoted = [...wagerUsers].filter((u) => !votedUsers.has(u));
+                if (notVoted.length > 0) {
+                    const names = notVoted.map((u) => {
+                        const wager = bet.wagers.find((w) => w.user === u);
+                        return wager?.userDisplayName ?? u;
+                    });
+                    return errorResult(`Cannot settle: ${notVoted.length} participant(s) have not voted yet: ${names.join(', ')}`);
+                }
                 await client.settleBet(betAddress);
                 return textResult(`Bet settled successfully: ${betAddress}`);
             }
@@ -610,6 +653,36 @@ export const TOOL_DEFINITIONS = {
         },
     },
     // ── Social write tools (scope: social:write) ──────────────────────
+    get_friend_requests: {
+        name: 'get_friend_requests',
+        description: 'Get your pending friend requests (received and sent)',
+        inputSchema: { type: 'object', properties: {} },
+        requiredScope: 'read',
+        async handler(_args, client) {
+            try {
+                const [received, sent] = await Promise.all([
+                    client.getReceivedFriendRequests(),
+                    client.getSentFriendRequests(),
+                ]);
+                const receivedLines = received.length > 0
+                    ? received.map((r, i) => `  ${i + 1}. From: ${r.sender?.displayName ?? 'Unknown'} (${r.sender?.uuid ?? '?'}) — Request ID: ${r.id} — ${r.createdAt}`)
+                    : ['  None'];
+                const sentLines = sent.length > 0
+                    ? sent.map((r, i) => `  ${i + 1}. To: ${r.receiver?.displayName ?? 'Unknown'} (${r.receiver?.uuid ?? '?'}) — Request ID: ${r.id} — ${r.createdAt}`)
+                    : ['  None'];
+                return textResult([
+                    `Received Friend Requests (${received.length}):`,
+                    ...receivedLines,
+                    '',
+                    `Sent Friend Requests (${sent.length}):`,
+                    ...sentLines,
+                ].join('\n'));
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
     send_friend_request: {
         name: 'send_friend_request',
         description: 'Send a friend request to another user',
@@ -678,6 +751,10 @@ export const TOOL_DEFINITIONS = {
             if (!betAddress)
                 return errorResult('Missing required parameter: betAddress');
             try {
+                const alreadyFavourited = await client.isBetFavourited(betAddress);
+                if (alreadyFavourited) {
+                    return textResult(`Bet is already in your favourites: ${betAddress}`);
+                }
                 await client.favouriteBet(betAddress);
                 return textResult(`Bet added to favourites: ${betAddress}`);
             }
@@ -702,6 +779,10 @@ export const TOOL_DEFINITIONS = {
             if (!betAddress)
                 return errorResult('Missing required parameter: betAddress');
             try {
+                const isFavourited = await client.isBetFavourited(betAddress);
+                if (!isFavourited) {
+                    return textResult(`Bet is not in your favourites: ${betAddress}`);
+                }
                 await client.unfavouriteBet(betAddress);
                 return textResult(`Bet removed from favourites: ${betAddress}`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solworks/poll-mcp",
-  "version": "0.1.20",
+  "version": "0.1.26",
   "description": "MCP server for Poll.fun. See documentation at https://dev.poll.fun",
   "type": "module",
   "main": "dist/index.js",
@@ -18,7 +18,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "@solworks/poll-api-client": "latest",
+    "@solworks/poll-api-client": "^0.1.17",
     "zod": "^3.24.0"
   },
   "devDependencies": {

package/tests/integration/server.test.ts

@@ -19,13 +19,14 @@ function mockClient(overrides: Partial<PollClient> = {}): PollClient {
     getXpBalance: vi.fn().mockResolvedValue({ xp: 1000, error: null }),
     getUsdcBalance: vi.fn().mockResolvedValue({ usdc: 50, error: null }),
     getTrendingBets: vi.fn().mockResolvedValue([
-      { question: 'Trending bet 1', totalVolume: 100 },
+      { question: 'Trending bet 1', totalOiFor: 50, totalOiAgainst: 50, betAddress: 'addr1' },
     ]),
     getLeaderboard: vi.fn().mockResolvedValue([
       { userId: 1, uuid: 'u1', displayName: 'Top', rank: 1, points: 999 },
     ]),
     getMyBets: vi.fn().mockResolvedValue([]),
     getMyWagers: vi.fn().mockResolvedValue([]),
+    trackEvent: vi.fn().mockResolvedValue(undefined),
     ...overrides,
   } as unknown as PollClient;
 }
@@ -81,6 +82,7 @@ describe('MCP Server integration', () => {
       'update_display_name',
       'send_friend_request',
       'respond_friend_request',
+      'get_friend_requests',
       'favourite_bet',
       'unfavourite_bet',
     ];
@@ -88,7 +90,7 @@ describe('MCP Server integration', () => {
     for (const name of expectedTools) {
       expect(toolNames).toContain(name);
     }
-    expect(tools.length).toBe(27);
+    expect(tools.length).toBe(28);
   });
 
   it('does NOT expose excluded tools', async () => {
@@ -138,6 +140,17 @@ describe('MCP Server integration', () => {
     expect(prompts.length).toBe(3);
   });
 
+  it('can read a resource and re-read returns fresh data', async () => {
+    const result1 = await mcpClient.readResource({ uri: 'poll://user/balances' });
+    expect(result1.contents[0].text).toContain('XP');
+
+    const result2 = await mcpClient.readResource({ uri: 'poll://user/balances' });
+    expect(result2.contents[0].text).toContain('XP');
+
+    // Verify handler was called twice (no server-side caching)
+    expect(client.getXpBalance).toHaveBeenCalledTimes(2);
+  });
+
   it('handles API errors gracefully', async () => {
     const errorClient = mockClient({
       getAccount: vi.fn().mockRejectedValue(new Error('API Error 401: Unauthorized')),

package/tests/unit/tools/bets.test.ts

@@ -10,8 +10,8 @@ describe('Bet tool handlers', () => {
   it('get_trending_bets returns formatted list', async () => {
     const client = mockClient({
       getTrendingBets: vi.fn().mockResolvedValue([
-        { question: 'Will BTC hit 100k?', totalVolume: 5000 },
-        { question: 'ETH above 5k?', totalVolume: 3000 },
+        { question: 'Will BTC hit 100k?', totalOiFor: 3000, totalOiAgainst: 2000, betAddress: 'addr1' },
+        { question: 'ETH above 5k?', totalOiFor: 2000, totalOiAgainst: 1000, betAddress: 'addr2' },
       ]),
     });
     const result = await TOOL_DEFINITIONS.get_trending_bets.handler({}, client);
@@ -28,7 +28,8 @@ describe('Bet tool handlers', () => {
         question: 'Will it rain tomorrow?',
         status: 'OPEN',
         options: ['Yes', 'No'],
-        totalVolume: 1000,
+        totalOiFor: 600,
+        totalOiAgainst: 400,
         createdAt: '2026-01-01T00:00:00Z',
         betAddress: 'addr123',
       }),
@@ -80,7 +81,8 @@ describe('Bet tool handlers', () => {
 
   it('place_wager with valid params', async () => {
     const placeWagerFn = vi.fn().mockResolvedValue({});
-    const client = mockClient({ placeWager: placeWagerFn });
+    const validateWagerSideFn = vi.fn().mockResolvedValue(undefined);
+    const client = mockClient({ placeWager: placeWagerFn, validateWagerSide: validateWagerSideFn });
     const result = await TOOL_DEFINITIONS.place_wager.handler(
       { betAddress: 'addr1', optionIndex: 0, amount: 50 },
       client
@@ -88,9 +90,9 @@ describe('Bet tool handlers', () => {
     expect(result.isError).toBeUndefined();
     expect(result.content[0].text).toContain('Wager placed successfully');
     expect(placeWagerFn).toHaveBeenCalledWith({
-      betAddress: 'addr1',
-      optionIndex: 0,
+      marketPubkey: 'addr1',
       amount: 50,
+      side: 'for',
     });
   });
 
@@ -104,6 +106,41 @@ describe('Bet tool handlers', () => {
     expect(result.content[0].text).toContain('Missing required parameter: betAddress');
   });
 
+  it('vote returns error when voting not initiated', async () => {
+    const client = mockClient({
+      getBet: vi.fn().mockResolvedValue({
+        status: 'Pending',
+        votes: [],
+      }),
+      getAccount: vi.fn().mockResolvedValue({ uuid: 'user-1' }),
+    });
+    const result = await TOOL_DEFINITIONS.vote.handler(
+      { betAddress: 'addr1', optionIndex: 0 },
+      client
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('voting has not been initiated');
+  });
+
+  it('vote succeeds when bet is in Resolving status', async () => {
+    const voteFn = vi.fn().mockResolvedValue({});
+    const client = mockClient({
+      getBet: vi.fn().mockResolvedValue({
+        status: 'Resolving',
+        votes: [],
+      }),
+      getAccount: vi.fn().mockResolvedValue({ uuid: 'user-1' }),
+      vote: voteFn,
+    });
+    const result = await TOOL_DEFINITIONS.vote.handler(
+      { betAddress: 'addr1', optionIndex: 0 },
+      client
+    );
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Vote cast successfully');
+    expect(voteFn).toHaveBeenCalledWith({ marketPubkey: 'addr1', outcome: 'for' });
+  });
+
   it('create_bet handles API error', async () => {
     const client = mockClient({
       createBet: vi.fn().mockRejectedValue(new Error('API Error 400: Invalid question')),

package/tests/unit/tools/social.test.ts

@@ -23,7 +23,10 @@ describe('Social tool handlers', () => {
 
   it('favourite_bet calls client', async () => {
     const favouriteFn = vi.fn().mockResolvedValue({});
-    const client = mockClient({ favouriteBet: favouriteFn });
+    const client = mockClient({
+      isBetFavourited: vi.fn().mockResolvedValue(false),
+      favouriteBet: favouriteFn,
+    });
     const result = await TOOL_DEFINITIONS.favourite_bet.handler(
       { betAddress: 'addr-fav' },
       client
@@ -33,6 +36,51 @@ describe('Social tool handlers', () => {
     expect(favouriteFn).toHaveBeenCalledWith('addr-fav');
   });
 
+  it('favourite_bet returns already-favourited message', async () => {
+    const favouriteFn = vi.fn();
+    const client = mockClient({
+      isBetFavourited: vi.fn().mockResolvedValue(true),
+      favouriteBet: favouriteFn,
+    });
+    const result = await TOOL_DEFINITIONS.favourite_bet.handler(
+      { betAddress: 'addr-fav' },
+      client
+    );
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Bet is already in your favourites: addr-fav');
+    expect(favouriteFn).not.toHaveBeenCalled();
+  });
+
+  it('unfavourite_bet removes favourite', async () => {
+    const unfavouriteFn = vi.fn().mockResolvedValue({});
+    const client = mockClient({
+      isBetFavourited: vi.fn().mockResolvedValue(true),
+      unfavouriteBet: unfavouriteFn,
+    });
+    const result = await TOOL_DEFINITIONS.unfavourite_bet.handler(
+      { betAddress: 'addr-fav' },
+      client
+    );
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Bet removed from favourites: addr-fav');
+    expect(unfavouriteFn).toHaveBeenCalledWith('addr-fav');
+  });
+
+  it('unfavourite_bet returns not-favourited message', async () => {
+    const unfavouriteFn = vi.fn();
+    const client = mockClient({
+      isBetFavourited: vi.fn().mockResolvedValue(false),
+      unfavouriteBet: unfavouriteFn,
+    });
+    const result = await TOOL_DEFINITIONS.unfavourite_bet.handler(
+      { betAddress: 'addr-fav' },
+      client
+    );
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain('Bet is not in your favourites: addr-fav');
+    expect(unfavouriteFn).not.toHaveBeenCalled();
+  });
+
   it('send_friend_request calls client', async () => {
     const sendFn = vi.fn().mockResolvedValue({});
     const client = mockClient({ sendFriendRequest: sendFn });