@gala-chain/launchpad-mcp-server/dist/prompts/pools.js

MCP server for Gala Launchpad - 102 tools (pool management, event watchers, GSwap DEX trading, price history, token creation, wallet management, DEX pool discovery, liquidity positions, token locks, locked token queries, composite pool data, cross-chain b

"use strict";
/**
 * Pool Management Prompts
 *
 * Slash commands for pool management, pricing, and token data operations
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.poolPrompts = exports.resolveTokenClassKeyPrompt = exports.resolveVaultAddressPrompt = exports.checkTokenSymbolPrompt = exports.checkTokenNamePrompt = exports.fetchAllPriceHistoryPrompt = exports.fetchPriceHistoryPrompt = exports.fetchTokenSpotPricePrompt = exports.fetchGalaSpotPricePrompt = exports.fetchVolumeDataPrompt = exports.fetchTokenBadgesPrompt = exports.fetchTokenDistributionPrompt = exports.fetchTokenDetailsPrompt = exports.fetchPoolDetailsForCalculationPrompt = exports.fetchPoolsPrompt = void 0;
const mcpToolNames_js_1 = require("../constants/mcpToolNames.js");
const validation_js_1 = require("../utils/validation.js");
const handlerHelpers_js_1 = require("./utils/handlerHelpers.js");
const textTemplates_js_1 = require("./utils/textTemplates.js");
/**
 * Fetch Pools - Paginated pool fetching with filters
 */
exports.fetchPoolsPrompt = {
    name: 'galachain-launchpad:fetch-pools',
    description: 'Fetch token pools with pagination and optional filters',
    arguments: [
        {
            name: 'type',
            description: 'Pool type: recent, popular (default: recent)',
            required: false,
        },
        {
            name: 'page',
            description: 'Page number (default: 1)',
            required: false,
        },
        {
            name: 'limit',
            description: 'Results per page (default: 20, max: 100)',
            required: false,
        },
    ],
    handler: (args) => {
        (0, validation_js_1.validateOptionalLimit)(args.limit, 100);
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Fetch token pools from Gala Launchpad.',
            parameters: {
                type: `Type: ${args.type || 'recent'}`,
                page: `Page: ${args.page || 1}`,
                limit: `Limit: ${args.limit || 20}`,
            },
            toolName: mcpToolNames_js_1.MCP_TOOLS.FETCH_POOLS,
            actionDescription: 'retrieve pools with pagination',
            displayFormat: 'Display results showing token names, symbols, and key metrics.',
        }));
    },
};
/**
 * Fetch Pool Details for Calculation - Optimized pool details
 */
exports.fetchPoolDetailsForCalculationPrompt = {
    name: 'galachain-launchpad:fetch-pool-details-for-calculation',
    description: 'Get optimized pool details for local bonding curve calculations',
    arguments: [
        {
            name: 'tokenName',
            description: 'Token name (e.g., anime, test216253)',
            required: true,
        },
    ],
    handler: (args) => {
        (0, validation_js_1.validateTokenName)(args.tokenName);
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Fetch optimized pool details for bonding curve calculations.',
            parameters: {
                token_name: `Token: ${args.tokenName}`,
            },
            toolName: mcpToolNames_js_1.MCP_TOOLS.FETCH_POOL_DETAILS_FOR_CALCULATION,
            actionDescription: 'get currentSupply (computed with full precision), remainingTokens, maxSupply, reverseBondingCurveMaxFeeFactor, and reverseBondingCurveMinFeeFactor',
            displayFormat: 'This data is optimized for use with local calculation tools.',
        }));
    },
};
/**
 * Fetch Token Details - Complete token metadata
 */
exports.fetchTokenDetailsPrompt = {
    name: 'galachain-launchpad:fetch-token-details',
    description: 'Fetch comprehensive token metadata from DEX API',
    arguments: [
        {
            name: 'tokenId',
            description: 'Token ID (e.g., GUSDC|Unit|none|eth:0x...)',
            required: true,
        },
    ],
    handler: (args) => {
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Fetch complete token metadata from the DEX API.',
            parameters: {
                token_id: `Token ID: ${args.tokenId}`,
            },
            toolName: mcpToolNames_js_1.MCP_TOOLS.FETCH_TOKEN_DETAILS,
            actionDescription: 'retrieve symbol, decimals, name, image, description, verification status, network information (chainId, contractAddress), and trading enabled status',
            displayFormat: 'Display the complete token information.',
        }));
    },
};
/**
 * Fetch Token Distribution - Holder analysis
 */
exports.fetchTokenDistributionPrompt = {
    name: 'galachain-launchpad:fetch-token-distribution',
    description: 'Get token holder distribution and supply metrics',
    arguments: [
        {
            name: 'tokenName',
            description: 'Token name (e.g., anime, test216253)',
            required: true,
        },
    ],
    handler: (args) => {
        (0, validation_js_1.validateTokenName)(args.tokenName);
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Analyze token holder distribution.',
            parameters: {
                token_name: `Token: ${args.tokenName}`,
            },
            toolName: mcpToolNames_js_1.MCP_TOOLS.FETCH_TOKEN_DISTRIBUTION,
            actionDescription: 'get complete holder list with addresses, balances, ownership percentages, total supply, total holder count, and last updated timestamp',
            displayFormat: 'Identify top holders and concentration risk.',
        }));
    },
};
/**
 * Fetch Token Badges - Achievement badges
 */
exports.fetchTokenBadgesPrompt = {
    name: 'galachain-launchpad:fetch-token-badges',
    description: 'Get achievement badges for volume and engagement',
    arguments: [
        {
            name: 'tokenName',
            description: 'Token name (e.g., anime, test216253)',
            required: true,
        },
    ],
    handler: (args) => {
        (0, validation_js_1.validateTokenName)(args.tokenName);
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Fetch achievement badges for token.',
            parameters: {
                token_name: `Token: ${args.tokenName}`,
            },
            toolName: mcpToolNames_js_1.MCP_TOOLS.FETCH_TOKEN_BADGES,
            actionDescription: 'retrieve badges for trading volume milestones, community engagement, and other achievements',
            displayFormat: 'Display all earned badges.',
        }));
    },
};
/**
 * Fetch Volume Data - OHLCV candlestick data
 */
exports.fetchVolumeDataPrompt = {
    name: 'galachain-launchpad:fetch-volume-data',
    description: 'Get OHLCV (candlestick) data for charting',
    arguments: [
        {
            name: 'tokenName',
            description: 'Token name (e.g., anime, test216253)',
            required: true,
        },
        {
            name: 'from',
            description: 'Start date (ISO 8601 format)',
            required: false,
        },
        {
            name: 'to',
            description: 'End date (ISO 8601 format)',
            required: false,
        },
        {
            name: 'resolution',
            description: 'Time resolution: 1m, 5m, 15m, 1h, 4h, 1d (default: 1h)',
            required: false,
        },
    ],
    handler: (args) => {
        (0, validation_js_1.validateTokenName)(args.tokenName);
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Fetch OHLCV candlestick data for charting.',
            parameters: {
                token_name: `Token: ${args.tokenName}`,
                ...(args.from && { from: `From: ${args.from}` }),
                ...(args.to && { to: `To: ${args.to}` }),
                resolution: `Resolution: ${args.resolution || '1h'}`,
            },
            toolName: mcpToolNames_js_1.MCP_TOOLS.FETCH_VOLUME_DATA,
            actionDescription: 'retrieve candlestick data',
            displayFormat: 'Display data suitable for price charts.',
        }));
    },
};
/**
 * Fetch GALA Spot Price - Current GALA USD price
 */
exports.fetchGalaSpotPricePrompt = {
    name: 'galachain-launchpad:fetch-gala-spot-price',
    description: 'Fetch current GALA USD spot price',
    handler: () => {
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Fetch the current GALA USD spot price.',
            toolName: mcpToolNames_js_1.MCP_TOOLS.FETCH_GALA_SPOT_PRICE,
            actionDescription: 'get the latest GALA price in USD',
            displayFormat: 'Display the price in a clear format.',
        }));
    },
};
/**
 * Fetch Token Spot Price - Current USD price for any token
 */
exports.fetchTokenSpotPricePrompt = {
    name: 'galachain-launchpad:fetch-token-spot-price',
    description: 'Fetch USD spot price for any token (launchpad or DEX)',
    arguments: [
        {
            name: 'tokenName',
            description: 'Token name (e.g., anime, gala, demonkpop)',
            required: true,
        },
    ],
    handler: (args) => {
        (0, validation_js_1.validateTokenName)(args.tokenName);
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Fetch current USD spot price for token.',
            parameters: {
                token_name: `Token: ${args.tokenName}`,
            },
            toolName: mcpToolNames_js_1.MCP_TOOLS.FETCH_TOKEN_SPOT_PRICE,
            actionDescription: 'get current USD price with smart routing (launchpad or DEX), real-time pricing data, and unified interface for all token types',
            displayFormat: 'Display the current price clearly.',
        }));
    },
};
/**
 * Fetch Price History - Paginated historical prices
 */
exports.fetchPriceHistoryPrompt = {
    name: 'galachain-launchpad:fetch-price-history',
    description: 'Fetch historical token prices with pagination',
    arguments: [
        {
            name: 'tokenId',
            description: 'Token ID (e.g., GUSDC|Unit|none|eth:0x...) OR tokenName (e.g., demonkpop)',
            required: true,
        },
        {
            name: 'from',
            description: 'Start date (ISO 8601 format)',
            required: false,
        },
        {
            name: 'to',
            description: 'End date (ISO 8601 format)',
            required: false,
        },
        {
            name: 'page',
            description: 'Page number (default: 1)',
            required: false,
        },
        {
            name: 'limit',
            description: 'Results per page (default: 10, max: 50)',
            required: false,
        },
    ],
    handler: (args) => {
        (0, validation_js_1.validateOptionalLimit)(args.limit, 50);
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Fetch historical price snapshots for token.',
            parameters: {
                token_id: `Token: ${args.tokenId}`,
                ...(args.from && { from: `From: ${args.from}` }),
                ...(args.to && { to: `To: ${args.to}` }),
                page: `Page: ${args.page || 1}`,
                limit: `Limit: ${args.limit || 10}`,
            },
            toolName: mcpToolNames_js_1.MCP_TOOLS.FETCH_PRICE_HISTORY,
            actionDescription: 'retrieve historical price data from DEX Backend API',
            displayFormat: 'Display price snapshots with timestamps.',
        }));
    },
};
/**
 * Fetch All Price History - Auto-paginated complete history
 */
exports.fetchAllPriceHistoryPrompt = {
    name: 'galachain-launchpad:fetch-all-price-history',
    description: 'Fetch complete historical token prices (auto-paginated)',
    arguments: [
        {
            name: 'tokenId',
            description: 'Token ID (e.g., GUSDC|Unit|none|eth:0x...) OR tokenName (e.g., demonkpop)',
            required: true,
        },
        {
            name: 'from',
            description: 'Start date (ISO 8601 format)',
            required: false,
        },
        {
            name: 'to',
            description: 'End date (ISO 8601 format)',
            required: false,
        },
    ],
    handler: (args) => {
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Fetch ALL historical price snapshots for token (automatic pagination).',
            parameters: {
                token_id: `Token: ${args.tokenId}`,
                from: args.from ? `From: ${args.from}` : undefined,
                to: args.to ? `To: ${args.to}` : undefined,
            },
            toolName: mcpToolNames_js_1.MCP_TOOLS.FETCH_ALL_PRICE_HISTORY,
            actionDescription: 'retrieve complete historical data',
            displayFormat: 'This automatically handles pagination and returns all available snapshots.',
        }));
    },
};
/**
 * Check Token Name - Name availability check
 */
exports.checkTokenNamePrompt = {
    name: 'galachain-launchpad:check-token-name',
    description: 'Check if a token name is available',
    arguments: [
        {
            name: 'tokenName',
            description: 'Token name to check (3-20 alphanumeric characters)',
            required: true,
        },
    ],
    handler: (args) => {
        (0, validation_js_1.validateTokenName)(args.tokenName);
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Check if token name is available.',
            parameters: {
                token_name: `Token Name: ${args.tokenName}`,
            },
            toolName: mcpToolNames_js_1.MCP_TOOLS.CHECK_TOKEN_NAME,
            actionDescription: 'verify availability',
            displayFormat: 'Display whether the name is available or already taken.',
        }));
    },
};
/**
 * Check Token Symbol - Symbol availability check
 */
exports.checkTokenSymbolPrompt = {
    name: 'galachain-launchpad:check-token-symbol',
    description: 'Check if a token symbol is available',
    arguments: [
        {
            name: 'symbol',
            description: 'Token symbol to check (1-8 uppercase characters)',
            required: true,
        },
    ],
    handler: (args) => {
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Check if token symbol is available.',
            parameters: {
                token_symbol: `Token Symbol: ${args.symbol}`,
            },
            toolName: mcpToolNames_js_1.MCP_TOOLS.CHECK_TOKEN_SYMBOL,
            actionDescription: 'verify availability',
            displayFormat: 'Display whether the symbol is available or already taken.',
        }));
    },
};
/**
 * Resolve Vault Address - GalaChain vault lookup
 */
exports.resolveVaultAddressPrompt = {
    name: 'galachain-launchpad:resolve-vault-address',
    description: 'Get GalaChain vault address for a token',
    arguments: [
        {
            name: 'tokenName',
            description: 'Token name (e.g., anime, test216253)',
            required: true,
        },
    ],
    handler: (args) => {
        (0, validation_js_1.validateTokenName)(args.tokenName);
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Resolve GalaChain vault address for token.',
            parameters: {
                token_name: `Token: ${args.tokenName}`,
            },
            toolName: mcpToolNames_js_1.MCP_TOOLS.RESOLVE_VAULT_ADDRESS,
            actionDescription: 'get the vault address',
            displayFormat: 'This is useful for debugging and direct GalaChain operations.',
        }));
    },
};
/**
 * Resolve Token Class Key - TokenClassKey resolution
 */
exports.resolveTokenClassKeyPrompt = {
    name: 'galachain-launchpad:resolve-token-class-key',
    description: 'Get GalaChain TokenClassKey for a launchpad token',
    arguments: [
        {
            name: 'tokenName',
            description: 'Token name (e.g., anime, test216253)',
            required: true,
        },
    ],
    handler: (args) => {
        (0, validation_js_1.validateTokenName)(args.tokenName);
        return (0, handlerHelpers_js_1.createPromptResponse)((0, textTemplates_js_1.createSimpleOperationText)({
            operation: 'Resolve GalaChain TokenClassKey for launchpad token.',
            parameters: {
                token_name: `Token: ${args.tokenName}`,
            },
            toolName: mcpToolNames_js_1.MCP_TOOLS.RESOLVE_TOKEN_CLASS_KEY,
            actionDescription: 'get the TokenClassKey',
            displayFormat: 'This is useful for direct GalaChain operations.',
        }));
    },
};
exports.poolPrompts = [
    exports.fetchPoolsPrompt,
    exports.fetchPoolDetailsForCalculationPrompt,
    exports.fetchTokenDetailsPrompt,
    exports.fetchTokenDistributionPrompt,
    exports.fetchTokenBadgesPrompt,
    exports.fetchVolumeDataPrompt,
    exports.fetchGalaSpotPricePrompt,
    exports.fetchTokenSpotPricePrompt,
    exports.fetchPriceHistoryPrompt,
    exports.fetchAllPriceHistoryPrompt,
    exports.checkTokenNamePrompt,
    exports.checkTokenSymbolPrompt,
    exports.resolveVaultAddressPrompt,
    exports.resolveTokenClassKeyPrompt,
];
//# sourceMappingURL=pools.js.map