@solworks/poll-mcp 0.1.0

package/dist/tools/index.js

@@ -0,0 +1,686 @@
+function errorResult(message) {
+    return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+}
+function textResult(text) {
+    return { content: [{ type: 'text', text }] };
+}
+export const TOOL_DEFINITIONS = {
+    // ── Read tools (scope: read) ───────────────────────────────────────
+    get_account: {
+        name: 'get_account',
+        description: 'Get the current user account information',
+        inputSchema: { type: 'object', properties: {} },
+        requiredScope: 'read',
+        async handler(_args, client) {
+            try {
+                const account = await client.getAccount();
+                const lines = [
+                    `Account Information:`,
+                    `  Display Name: ${account.displayName ?? 'Not set'}`,
+                    `  UUID: ${account.uuid}`,
+                    `  ID: ${account.id}`,
+                    `  Email: ${account.email ?? 'Not set'}`,
+                ];
+                return textResult(lines.join('\n'));
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    get_profile: {
+        name: 'get_profile',
+        description: 'Get a user profile by UUID, or your own profile if no UUID is provided',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'User UUID to look up (optional)' },
+            },
+        },
+        requiredScope: 'read',
+        async handler(args, client) {
+            try {
+                const uuid = args.uuid;
+                const profile = await client.getProfile(uuid);
+                const lines = [
+                    `User Profile:`,
+                    `  Display Name: ${profile.displayName ?? 'Not set'}`,
+                    `  UUID: ${profile.uuid}`,
+                ];
+                return textResult(lines.join('\n'));
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    get_balance: {
+        name: 'get_balance',
+        description: 'Get both XP and USDC balances for the current user',
+        inputSchema: { type: 'object', properties: {} },
+        requiredScope: 'read',
+        async handler(_args, client) {
+            try {
+                const [xp, usdc] = await Promise.all([
+                    client.getXpBalance(),
+                    client.getUsdcBalance(),
+                ]);
+                const lines = [
+                    `Balances:`,
+                    `  XP: ${xp.xp}`,
+                    `  USDC: ${usdc.usdc ?? 'N/A'}`,
+                ];
+                return textResult(lines.join('\n'));
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    list_public_bets: {
+        name: 'list_public_bets',
+        description: 'List public bets with optional pagination',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                page: { type: 'number', description: 'Page number (optional)' },
+            },
+        },
+        requiredScope: 'read',
+        async handler(args, client) {
+            try {
+                const page = args.page;
+                const bets = await client.listPublicBets({ page });
+                const display = bets.slice(0, 20);
+                const lines = display.map((b, i) => `${i + 1}. ${b.question} — Status: ${b.status}, Volume: ${b.totalVolume ?? 'N/A'}`);
+                let text = `Public Bets:\n${lines.join('\n')}`;
+                if (bets.length > 20)
+                    text += `\n\n(Showing 20 of ${bets.length})`;
+                if (bets.length === 0)
+                    text = 'No public bets found.';
+                return textResult(text);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    get_trending_bets: {
+        name: 'get_trending_bets',
+        description: 'Get currently trending bets on the platform',
+        inputSchema: { type: 'object', properties: {} },
+        requiredScope: 'read',
+        async handler(_args, client) {
+            try {
+                const bets = await client.getTrendingBets();
+                const display = bets.slice(0, 20);
+                const lines = display.map((b, i) => `${i + 1}. ${b.question} — Volume: ${b.totalVolume ?? 'N/A'}`);
+                let text = `Trending Bets:\n${lines.join('\n')}`;
+                if (bets.length > 20)
+                    text += `\n\n(Showing 20 of ${bets.length})`;
+                if (bets.length === 0)
+                    text = 'No trending bets found.';
+                return textResult(text);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    get_bet: {
+        name: 'get_bet',
+        description: 'Get details of a specific bet by its ID or address',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Bet ID or address' },
+            },
+            required: ['id'],
+        },
+        requiredScope: 'read',
+        async handler(args, client) {
+            const id = args.id;
+            if (!id)
+                return errorResult('Missing required parameter: id');
+            try {
+                const bet = await client.getBet(id);
+                const lines = [
+                    `Bet Details:`,
+                    `  Question: ${bet.question}`,
+                    `  Status: ${bet.status}`,
+                    `  Options: ${bet.options.join(', ')}`,
+                    `  Volume: ${bet.totalVolume ?? 'N/A'}`,
+                    `  Created: ${bet.createdAt}`,
+                ];
+                if (bet.betAddress)
+                    lines.push(`  Address: ${bet.betAddress}`);
+                return textResult(lines.join('\n'));
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    get_my_wagers: {
+        name: 'get_my_wagers',
+        description: 'Get your wagers, optionally filtered to only active ones',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                active: { type: 'boolean', description: 'Filter to active wagers only (optional)' },
+            },
+        },
+        requiredScope: 'read',
+        async handler(args, client) {
+            try {
+                const active = args.active;
+                const wagers = await client.getMyWagers({ active });
+                if (wagers.length === 0)
+                    return textResult('No wagers found.');
+                const lines = wagers.map((w, i) => `${i + 1}. Bet: ${w.betAddress} — Option: ${w.optionIndex}, Amount: ${w.amount}, Status: ${w.status}`);
+                return textResult(`Your Wagers:\n${lines.join('\n')}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    get_leaderboard: {
+        name: 'get_leaderboard',
+        description: 'Get the platform leaderboard rankings',
+        inputSchema: { type: 'object', properties: {} },
+        requiredScope: 'read',
+        async handler(_args, client) {
+            try {
+                const entries = await client.getLeaderboard();
+                const display = entries.slice(0, 25);
+                const lines = display.map((e) => `#${e.rank} ${e.displayName ?? 'Anonymous'} — ${e.points} pts`);
+                let text = `Leaderboard:\n${lines.join('\n')}`;
+                if (entries.length > 25)
+                    text += `\n\n(Showing 25 of ${entries.length})`;
+                return textResult(text);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    get_my_ranking: {
+        name: 'get_my_ranking',
+        description: 'Get your current leaderboard ranking',
+        inputSchema: { type: 'object', properties: {} },
+        requiredScope: 'read',
+        async handler(_args, client) {
+            try {
+                const ranking = await client.getMyRanking();
+                const lines = [
+                    `Your Ranking:`,
+                    `  Rank: #${ranking.rank}`,
+                    `  Points: ${ranking.points}`,
+                    `  Display Name: ${ranking.displayName ?? 'Not set'}`,
+                ];
+                return textResult(lines.join('\n'));
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    get_wallet_transactions: {
+        name: 'get_wallet_transactions',
+        description: 'Get your wallet transaction history',
+        inputSchema: { type: 'object', properties: {} },
+        requiredScope: 'read',
+        async handler(_args, client) {
+            try {
+                const txns = await client.getWalletTransactions();
+                if (txns.length === 0)
+                    return textResult('No transactions found.');
+                const lines = txns.map((t, i) => `${i + 1}. ${t.type} — Amount: ${t.amount}, Date: ${t.createdAt}`);
+                return textResult(`Wallet Transactions:\n${lines.join('\n')}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    get_friends: {
+        name: 'get_friends',
+        description: 'Get your friends list',
+        inputSchema: { type: 'object', properties: {} },
+        requiredScope: 'read',
+        async handler(_args, client) {
+            try {
+                const friends = await client.getFriends();
+                if (friends.length === 0)
+                    return textResult('No friends found.');
+                const lines = friends.map((f, i) => `${i + 1}. ${f.displayName ?? 'Anonymous'} (${f.uuid})`);
+                return textResult(`Friends:\n${lines.join('\n')}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    get_notifications: {
+        name: 'get_notifications',
+        description: 'Get your notifications with optional pagination',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                page: { type: 'number', description: 'Page number (optional)' },
+            },
+        },
+        requiredScope: 'read',
+        async handler(args, client) {
+            try {
+                const page = args.page;
+                const notifications = await client.getNotifications({ page });
+                const display = notifications.slice(0, 20);
+                if (display.length === 0)
+                    return textResult('No notifications found.');
+                const lines = display.map((n, i) => `${i + 1}. [${n.read ? 'Read' : 'Unread'}] ${n.title}${n.body ? ` — ${n.body}` : ''} (${n.createdAt})`);
+                let text = `Notifications:\n${lines.join('\n')}`;
+                if (notifications.length > 20)
+                    text += `\n\n(Showing 20 of ${notifications.length})`;
+                return textResult(text);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    get_streak: {
+        name: 'get_streak',
+        description: 'Get your current and longest betting streak',
+        inputSchema: { type: 'object', properties: {} },
+        requiredScope: 'read',
+        async handler(_args, client) {
+            try {
+                const streak = await client.getStreak();
+                const lines = [
+                    `Streak Info:`,
+                    `  Current Streak: ${streak.currentStreak}`,
+                    `  Longest Streak: ${streak.longestStreak}`,
+                ];
+                return textResult(lines.join('\n'));
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    get_favourite_bets: {
+        name: 'get_favourite_bets',
+        description: 'Get your list of favourite bets',
+        inputSchema: { type: 'object', properties: {} },
+        requiredScope: 'read',
+        async handler(_args, client) {
+            try {
+                const bets = await client.getFavouriteBets();
+                if (bets.length === 0)
+                    return textResult('No favourite bets found.');
+                const lines = bets.map((b, i) => `${i + 1}. ${b.question} — Status: ${b.status}, Volume: ${b.totalVolume ?? 'N/A'}`);
+                return textResult(`Favourite Bets:\n${lines.join('\n')}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    get_probability_history: {
+        name: 'get_probability_history',
+        description: 'Get the probability history for a specific bet',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                betAddress: { type: 'string', description: 'Bet address' },
+            },
+            required: ['betAddress'],
+        },
+        requiredScope: 'read',
+        async handler(args, client) {
+            const betAddress = args.betAddress;
+            if (!betAddress)
+                return errorResult('Missing required parameter: betAddress');
+            try {
+                const history = await client.getProbabilityHistory(betAddress);
+                if (history.length === 0)
+                    return textResult('No probability history available.');
+                const lines = history.map((p) => `  ${p.timestamp}: ${(p.probability * 100).toFixed(1)}%`);
+                return textResult(`Probability History for ${betAddress}:\n${lines.join('\n')}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    // ── Bet write tools (scope: bet:write) ─────────────────────────────
+    create_bet: {
+        name: 'create_bet',
+        description: 'Create a new bet with a question and options',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                question: { type: 'string', description: 'The bet question' },
+                options: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'List of answer options',
+                },
+                type: { type: 'string', description: 'Bet type (e.g. USDC, XP). Optional.' },
+                amount: { type: 'number', description: 'Initial wager amount (optional)' },
+                expiresAt: { type: 'string', description: 'Expiration date in ISO format (optional)' },
+            },
+            required: ['question', 'options'],
+        },
+        requiredScope: 'bet:write',
+        async handler(args, client) {
+            const question = args.question;
+            const options = args.options;
+            if (!question)
+                return errorResult('Missing required parameter: question');
+            if (!options || !Array.isArray(options) || options.length < 2)
+                return errorResult('Missing or invalid parameter: options (must be an array with at least 2 items)');
+            try {
+                const bet = await client.createBet({
+                    question,
+                    options,
+                    type: args.type ?? 'USDC',
+                    amount: args.amount,
+                    expiresAt: args.expiresAt,
+                });
+                return textResult(`Bet created successfully!\n  Question: ${bet.question}\n  Options: ${bet.options.join(', ')}\n  Status: ${bet.status}\n  ID: ${bet.id}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    join_bet: {
+        name: 'join_bet',
+        description: 'Join an existing bet',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                betAddress: { type: 'string', description: 'Address of the bet to join' },
+            },
+            required: ['betAddress'],
+        },
+        requiredScope: 'bet:write',
+        async handler(args, client) {
+            const betAddress = args.betAddress;
+            if (!betAddress)
+                return errorResult('Missing required parameter: betAddress');
+            try {
+                await client.joinBet(betAddress);
+                return textResult(`Successfully joined bet: ${betAddress}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    place_wager: {
+        name: 'place_wager',
+        description: 'Place a wager on a bet option',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                betAddress: { type: 'string', description: 'Address of the bet' },
+                optionIndex: { type: 'number', description: 'Index of the option to bet on (0-based)' },
+                amount: { type: 'number', description: 'Amount to wager' },
+            },
+            required: ['betAddress', 'optionIndex', 'amount'],
+        },
+        requiredScope: 'bet:write',
+        async handler(args, client) {
+            const betAddress = args.betAddress;
+            const optionIndex = args.optionIndex;
+            const amount = args.amount;
+            if (!betAddress)
+                return errorResult('Missing required parameter: betAddress');
+            if (optionIndex === undefined || optionIndex === null)
+                return errorResult('Missing required parameter: optionIndex');
+            if (amount === undefined || amount === null)
+                return errorResult('Missing required parameter: amount');
+            try {
+                await client.placeWager({ betAddress, optionIndex, amount });
+                return textResult(`Wager placed successfully!\n  Bet: ${betAddress}\n  Option: ${optionIndex}\n  Amount: ${amount}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    cancel_wager: {
+        name: 'cancel_wager',
+        description: 'Cancel a previously placed wager',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                betAddress: { type: 'string', description: 'Address of the bet' },
+                wagerAddress: { type: 'string', description: 'Address of the wager to cancel' },
+            },
+            required: ['betAddress', 'wagerAddress'],
+        },
+        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 {
+                await client.cancelWager({ betAddress, wagerAddress });
+                return textResult(`Wager cancelled successfully: ${wagerAddress}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    initiate_vote: {
+        name: 'initiate_vote',
+        description: 'Initiate the voting phase for a bet',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                betAddress: { type: 'string', description: 'Address of the bet' },
+            },
+            required: ['betAddress'],
+        },
+        requiredScope: 'bet:write',
+        async handler(args, client) {
+            const betAddress = args.betAddress;
+            if (!betAddress)
+                return errorResult('Missing required parameter: betAddress');
+            try {
+                await client.initiateVote(betAddress);
+                return textResult(`Vote initiated for bet: ${betAddress}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    vote: {
+        name: 'vote',
+        description: 'Cast a vote on a bet outcome',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                betAddress: { type: 'string', description: 'Address of the bet' },
+                optionIndex: { type: 'number', description: 'Index of the option to vote for (0-based)' },
+            },
+            required: ['betAddress', 'optionIndex'],
+        },
+        requiredScope: 'bet:write',
+        async handler(args, client) {
+            const betAddress = args.betAddress;
+            const optionIndex = args.optionIndex;
+            if (!betAddress)
+                return errorResult('Missing required parameter: betAddress');
+            if (optionIndex === undefined || optionIndex === null)
+                return errorResult('Missing required parameter: optionIndex');
+            try {
+                await client.vote({ betAddress, optionIndex });
+                return textResult(`Vote cast successfully on bet ${betAddress} for option ${optionIndex}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    settle_bet: {
+        name: 'settle_bet',
+        description: 'Settle a bet to distribute winnings',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                betAddress: { type: 'string', description: 'Address of the bet to settle' },
+            },
+            required: ['betAddress'],
+        },
+        requiredScope: 'bet:write',
+        async handler(args, client) {
+            const betAddress = args.betAddress;
+            if (!betAddress)
+                return errorResult('Missing required parameter: betAddress');
+            try {
+                await client.settleBet(betAddress);
+                return textResult(`Bet settled successfully: ${betAddress}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    // ── User write tools (scope: user:write) ───────────────────────────
+    update_display_name: {
+        name: 'update_display_name',
+        description: 'Update your display name',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'New display name' },
+            },
+            required: ['name'],
+        },
+        requiredScope: 'user:write',
+        async handler(args, client) {
+            const name = args.name;
+            if (!name)
+                return errorResult('Missing required parameter: name');
+            try {
+                await client.updateDisplayName(name);
+                return textResult(`Display name updated to: ${name}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    // ── Social write tools (scope: social:write) ──────────────────────
+    send_friend_request: {
+        name: 'send_friend_request',
+        description: 'Send a friend request to another user',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                uuid: { type: 'string', description: 'UUID of the user to send a request to' },
+            },
+            required: ['uuid'],
+        },
+        requiredScope: 'social:write',
+        async handler(args, client) {
+            const uuid = args.uuid;
+            if (!uuid)
+                return errorResult('Missing required parameter: uuid');
+            try {
+                await client.sendFriendRequest(uuid);
+                return textResult(`Friend request sent to: ${uuid}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    respond_friend_request: {
+        name: 'respond_friend_request',
+        description: 'Accept or decline a friend request',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                requestId: { type: 'string', description: 'ID of the friend request' },
+                accept: { type: 'boolean', description: 'True to accept, false to decline' },
+            },
+            required: ['requestId', 'accept'],
+        },
+        requiredScope: 'social:write',
+        async handler(args, client) {
+            const requestId = args.requestId;
+            const accept = args.accept;
+            if (!requestId)
+                return errorResult('Missing required parameter: requestId');
+            if (accept === undefined || accept === null)
+                return errorResult('Missing required parameter: accept');
+            try {
+                await client.respondFriendRequest(requestId, accept);
+                return textResult(`Friend request ${accept ? 'accepted' : 'declined'}: ${requestId}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    favourite_bet: {
+        name: 'favourite_bet',
+        description: 'Add a bet to your favourites',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                betAddress: { type: 'string', description: 'Address of the bet to favourite' },
+            },
+            required: ['betAddress'],
+        },
+        requiredScope: 'social:write',
+        async handler(args, client) {
+            const betAddress = args.betAddress;
+            if (!betAddress)
+                return errorResult('Missing required parameter: betAddress');
+            try {
+                await client.favouriteBet(betAddress);
+                return textResult(`Bet added to favourites: ${betAddress}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+    unfavourite_bet: {
+        name: 'unfavourite_bet',
+        description: 'Remove a bet from your favourites',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                betAddress: { type: 'string', description: 'Address of the bet to unfavourite' },
+            },
+            required: ['betAddress'],
+        },
+        requiredScope: 'social:write',
+        async handler(args, client) {
+            const betAddress = args.betAddress;
+            if (!betAddress)
+                return errorResult('Missing required parameter: betAddress');
+            try {
+                await client.unfavouriteBet(betAddress);
+                return textResult(`Bet removed from favourites: ${betAddress}`);
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+        },
+    },
+};