@gala-chain/launchpad-mcp-server 1.21.6 → 1.22.0

package/src/prompts/utils/workflowTemplates.ts

@@ -0,0 +1,511 @@
+/**
+ * Workflow Template Utilities
+ *
+ * Reusable templates for common workflow patterns in prompts.
+ * Reduces duplication and ensures consistency across slash commands.
+ */
+
+import { MCP_TOOLS } from '../../constants/mcpToolNames.js';
+
+/**
+ * Configuration for trading workflow generation
+ */
+export interface TradingWorkflowConfig {
+  operation: 'buy' | 'sell' | 'graduate';
+  tokenName: string;
+  amount?: string;
+  amountType?: 'gala' | 'tokens';
+  slippage?: string;
+}
+
+/**
+ * Create a complete trading workflow with all standard steps
+ *
+ * @param config - Trading workflow configuration
+ * @returns Formatted workflow text with numbered steps
+ *
+ * @example
+ * ```typescript
+ * const workflow = createTradingWorkflow({
+ *   operation: 'buy',
+ *   tokenName: 'anime',
+ *   amount: '100',
+ *   amountType: 'gala',
+ *   slippage: '1'
+ * });
+ * ```
+ */
+export function createTradingWorkflow(config: TradingWorkflowConfig): string {
+  const { operation, tokenName, amount, amountType, slippage = '1' } = config;
+
+  switch (operation) {
+    case 'buy':
+      return createBuyWorkflow(tokenName, amount!, amountType!, slippage);
+    case 'sell':
+      return createSellWorkflow(tokenName, amount!, slippage);
+    case 'graduate':
+      return createGraduationWorkflow(tokenName, slippage);
+    default:
+      throw new Error(`Unknown operation: ${operation}`);
+  }
+}
+
+/**
+ * Create buy tokens workflow
+ */
+function createBuyWorkflow(
+  tokenName: string,
+  amount: string,
+  amountType: 'gala' | 'tokens',
+  slippage: string
+): string {
+  const slippageFactor = parseFloat(slippage) / 100;
+  const typeParam = amountType === 'gala' ? 'native' : 'exact';
+  const amountLabel = amountType === 'gala' ? 'GALA to spend' : 'Tokens to buy';
+
+  return `Help me buy tokens on Gala Launchpad:
+
+Token: ${tokenName}
+${amountLabel}: ${amount}
+Slippage tolerance: ${slippage}%
+
+Please follow this workflow:
+
+1. Calculate buy amount using ${MCP_TOOLS.CALCULATE_BUY_AMOUNT}:
+   - tokenName: "${tokenName}"
+   - amount: "${amount}"
+   - type: "${typeParam}" (${amountType === 'gala' ? 'spending GALA' : 'buying exact tokens'})
+
+2. Show me the breakdown:
+   - Tokens I'll receive
+   - Transaction fee
+   - Gas fee
+   - Reverse bonding curve fee
+   - Total cost
+
+3. Ask for confirmation before executing
+
+4. If I confirm, execute the buy using ${MCP_TOOLS.BUY_TOKENS} with:
+   - expectedAmount from calculation
+   - maxAcceptableReverseBondingCurveFee from calculation
+   - slippageToleranceFactor: ${slippageFactor}
+
+5. After purchase, show transaction ID and verify balance`;
+}
+
+/**
+ * Create sell tokens workflow
+ */
+function createSellWorkflow(
+  tokenName: string,
+  amount: string,
+  slippage: string
+): string {
+  const slippageFactor = parseFloat(slippage) / 100;
+
+  return `Help me sell tokens on Gala Launchpad:
+
+Token: ${tokenName}
+Tokens to sell: ${amount}
+Slippage tolerance: ${slippage}%
+
+Please follow this workflow:
+
+1. Check my token balance using ${MCP_TOOLS.FETCH_TOKEN_BALANCE}
+
+2. Calculate sell amount using ${MCP_TOOLS.CALCULATE_SELL_AMOUNT}:
+   - tokenName: "${tokenName}"
+   - amount: "${amount}"
+   - type: "exact" (selling exact token amount)
+
+3. Show me the breakdown:
+   - GALA I'll receive
+   - Transaction fee
+   - Gas fee
+   - Reverse bonding curve fee
+   - Net proceeds
+
+4. Ask for confirmation before executing
+
+5. If I confirm, execute the sell using ${MCP_TOOLS.SELL_TOKENS} with:
+   - expectedAmount from calculation
+   - maxAcceptableReverseBondingCurveFee from calculation
+   - slippageToleranceFactor: ${slippageFactor}
+
+6. After sale, show transaction ID and verify updated balance`;
+}
+
+/**
+ * Create token graduation workflow
+ */
+function createGraduationWorkflow(tokenName: string, slippage: string): string {
+  const slippageFactor = parseFloat(slippage) / 100;
+
+  return `Help me graduate the token "${tokenName}" on Gala Launchpad:
+
+Slippage tolerance: ${slippage}%
+
+Please follow this workflow:
+
+1. Check if token is already graduated using ${MCP_TOOLS.FETCH_POOL_DETAILS}
+   - If saleStatus is "Completed", inform me it's already graduated
+
+2. Fetch optimized pool details using ${MCP_TOOLS.FETCH_POOL_DETAILS_FOR_CALCULATION}
+
+3. Calculate graduation cost using ${MCP_TOOLS.CALCULATE_BUY_AMOUNT_FOR_GRADUATION} with:
+   - calculateAmountMode: "local"
+   - currentSupply from pool details
+
+4. Show me the breakdown:
+   - GALA required to graduate: [amount field - this is GALA cost, NOT token quantity!]
+   - Transaction fee
+   - Gas fee
+   - Total cost
+
+5. Check my GALA balance using ${MCP_TOOLS.FETCH_GALA_BALANCE}
+   - Verify I have enough GALA for graduation
+
+6. Ask for confirmation before executing
+
+7. If I confirm, execute graduation using ${MCP_TOOLS.GRADUATE_TOKEN} with:
+   - tokenName: "${tokenName}"
+   - slippageToleranceFactor: ${slippageFactor}
+   - calculateAmountMode: "local"
+   - currentSupply from pool details (optimization!)
+
+8. After graduation:
+   - Show transaction ID
+   - Verify pool status changed to "Completed"
+   - Get frontend URL using ${MCP_TOOLS.GET_URL_BY_TOKEN_NAME}
+
+IMPORTANT: The "amount" field in graduation calculations is GALA cost, not token quantity!`;
+}
+
+/**
+ * Format a list of steps with numbers
+ *
+ * @param steps - Array of step descriptions
+ * @returns Formatted steps with numbering
+ *
+ * @example
+ * ```typescript
+ * formatWorkflowSteps([
+ *   'Fetch pool details',
+ *   'Calculate price',
+ *   'Show results'
+ * ]);
+ * // Returns:
+ * // "1. Fetch pool details
+ * // 2. Calculate price
+ * // 3. Show results"
+ * ```
+ */
+export function formatWorkflowSteps(steps: string[]): string {
+  return steps.map((step, index) => `${index + 1}. ${step}`).join('\n\n');
+}
+
+/**
+ * Create a standard confirmation step for destructive operations
+ *
+ * @param operation - Operation name (e.g., 'buy', 'sell', 'graduate')
+ * @returns Confirmation step text
+ */
+export function createConfirmationStep(operation: string): string {
+  return `Ask for confirmation before executing the ${operation} operation`;
+}
+
+/**
+ * Create a standard verification step after transaction
+ *
+ * @param operation - Operation name
+ * @param verifications - Array of verification checks to perform
+ * @returns Verification step text
+ */
+export function createVerificationStep(
+  operation: string,
+  verifications: string[]
+): string {
+  const checks = verifications
+    .map((check, index) => `   ${String.fromCharCode(97 + index)}. ${check}`)
+    .join('\n');
+
+  return `After ${operation} completes:\n${checks}`;
+}
+
+/**
+ * Create an optimized performance note for LOCAL calculations
+ *
+ * @returns Performance optimization guidance text
+ */
+export function createPerformanceNote(): string {
+  return `Use the performance optimization pattern from SDK v3.9.0 to minimize network calls.`;
+}
+
+/**
+ * Create a cost breakdown display template
+ *
+ * @param operation - Operation type for context
+ * @returns Cost breakdown template text
+ */
+export function createCostBreakdown(operation: 'buy' | 'sell' | 'graduate'): string {
+  switch (operation) {
+    case 'buy':
+      return `Show me the breakdown:
+   - Tokens I'll receive
+   - Transaction fee
+   - Gas fee
+   - Reverse bonding curve fee
+   - Total cost`;
+    case 'sell':
+      return `Show me the breakdown:
+   - GALA I'll receive
+   - Transaction fee
+   - Gas fee
+   - Reverse bonding curve fee
+   - Net proceeds`;
+    case 'graduate':
+      return `Show me the breakdown:
+   - GALA required to graduate
+   - Transaction fee
+   - Gas fee
+   - Total cost`;
+  }
+}
+
+/**
+ * Create a balance check step
+ *
+ * @param assetType - Type of asset to check ('GALA' or token name)
+ * @returns Balance check step text
+ */
+export function createBalanceCheckStep(assetType: 'GALA' | string): string {
+  if (assetType === 'GALA') {
+    return `Check my GALA balance using ${MCP_TOOLS.FETCH_GALA_BALANCE}`;
+  }
+  return `Check my ${assetType} token balance using ${MCP_TOOLS.FETCH_TOKEN_BALANCE}`;
+}
+
+/**
+ * Create analysis workflow for token evaluation
+ *
+ * @param tokenName - Token to analyze
+ * @returns Complete analysis workflow
+ */
+export function createAnalysisWorkflow(tokenName: string): string {
+  return `Analyze the token "${tokenName}" using the Gala Launchpad MCP server:
+
+1. Fetch optimized pool details using ${MCP_TOOLS.FETCH_POOL_DETAILS_FOR_CALCULATION}
+2. Calculate current USD spot price using LOCAL mode with the currentSupply
+3. Calculate graduation cost using LOCAL mode with the currentSupply
+4. Show remaining tokens and pool status (saleStatus)
+5. Calculate pool progress percentage: (currentSupply / maxSupply * 100)
+
+${createPerformanceNote()}
+
+Provide a brief analysis including:
+- Current token price in USD
+- Total GALA required to graduate the pool
+- How close the token is to graduation (percentage)
+- Whether this would be a good time to buy or wait`;
+}
+
+/**
+ * Create portfolio analysis workflow
+ *
+ * @returns Complete portfolio analysis workflow
+ */
+export function createPortfolioWorkflow(): string {
+  return `Analyze my complete Gala Launchpad portfolio:
+
+1. Get GALA balance using ${MCP_TOOLS.FETCH_GALA_BALANCE}
+
+2. Get all tokens I'm holding using ${MCP_TOOLS.FETCH_TOKENS_HELD}
+   - Use pagination if needed to get all tokens
+
+3. For each token, calculate USD value using optimized pattern:
+   a. Fetch pool details once: ${MCP_TOOLS.FETCH_POOL_DETAILS_FOR_CALCULATION}
+   b. Calculate spot price: ${MCP_TOOLS.FETCH_LAUNCHPAD_TOKEN_SPOT_PRICE} with LOCAL mode
+   c. Multiply token balance by spot price for USD value
+
+4. Calculate GALA USD value using ${MCP_TOOLS.FETCH_GALA_SPOT_PRICE}
+
+5. Present a comprehensive portfolio summary:
+   - GALA balance and USD value
+   - Each token holding with:
+     * Token name
+     * Balance
+     * USD spot price
+     * Total USD value
+   - Total portfolio value in USD
+   - Top 3 holdings by value
+   - Number of different tokens held
+
+${createPerformanceNote()}`;
+}
+
+/**
+ * Create token creation workflow
+ *
+ * @param args - Token creation arguments (name, symbol, description, etc.)
+ * @returns Complete token creation workflow
+ */
+export function createCreateTokenWorkflow(args: {
+  tokenName: string;
+  tokenSymbol: string;
+  description: string;
+  imagePath?: string;
+  websiteUrl?: string;
+  twitterUrl?: string;
+  telegramUrl?: string;
+  preBuyGala?: string;
+}): string {
+  const steps: string[] = [];
+
+  steps.push(`Validate token name "${args.tokenName}" is available using ${MCP_TOOLS.CHECK_TOKEN_NAME}`);
+  steps.push(`Validate token symbol "${args.tokenSymbol}" is available using ${MCP_TOOLS.CHECK_TOKEN_SYMBOL}`);
+  steps.push(`Check launch fee using ${MCP_TOOLS.FETCH_LAUNCH_TOKEN_FEE}`);
+  steps.push(`Check my GALA balance using ${MCP_TOOLS.FETCH_GALA_BALANCE}`);
+
+  if (args.imagePath) {
+    steps.push(
+      `Upload token image from path "${args.imagePath}" using ${MCP_TOOLS.UPLOAD_TOKEN_IMAGE}`
+    );
+  }
+
+  if (args.preBuyGala) {
+    steps.push(
+      `Calculate initial buy for ${args.preBuyGala} GALA using ${MCP_TOOLS.CALCULATE_INITIAL_BUY}`
+    );
+  }
+
+  steps.push(`Show complete cost breakdown:`);
+  steps.push(`   - Launch fee`);
+  if (args.preBuyGala) {
+    steps.push(`   - Pre-buy GALA amount`);
+  }
+  steps.push(`   - Estimated total cost`);
+  steps.push(`Ask for confirmation before proceeding`);
+
+  steps.push(`If confirmed, launch token using ${MCP_TOOLS.LAUNCH_TOKEN} with:`);
+  steps.push(`   - tokenName: "${args.tokenName}"`);
+  steps.push(`   - tokenSymbol: "${args.tokenSymbol}"`);
+  steps.push(`   - tokenDescription: "${args.description}"`);
+  if (args.imagePath) {
+    steps.push(`   - tokenImage: [from uploaded image]`);
+  }
+  if (args.websiteUrl) {
+    steps.push(`   - websiteUrl: "${args.websiteUrl}"`);
+  }
+  if (args.twitterUrl) {
+    steps.push(`   - twitterUrl: "${args.twitterUrl}"`);
+  }
+  if (args.telegramUrl) {
+    steps.push(`   - telegramUrl: "${args.telegramUrl}"`);
+  }
+  if (args.preBuyGala) {
+    steps.push(`   - preBuyQuantity: [from calculation]`);
+  }
+
+  steps.push(`After launch:`);
+  steps.push(`   a. Get frontend URL using ${MCP_TOOLS.GET_URL_BY_TOKEN_NAME}`);
+  steps.push(`   b. Verify token was created successfully`);
+  steps.push(`   c. Provide token details and launch link`);
+
+  return `Help me create a new token on Gala Launchpad:
+
+Token Name: ${args.tokenName}
+Token Symbol: ${args.tokenSymbol}
+Description: ${args.description}
+${args.websiteUrl ? `Website: ${args.websiteUrl}` : ''}
+${args.twitterUrl ? `Twitter: ${args.twitterUrl}` : ''}
+${args.telegramUrl ? `Telegram: ${args.telegramUrl}` : ''}
+${args.preBuyGala ? `Pre-buy GALA: ${args.preBuyGala}` : 'No pre-buy'}
+
+Please follow this workflow:
+
+${formatWorkflowSteps(steps)}
+
+IMPORTANT: At least one social URL (website, Twitter, or Telegram) should be provided for token creation.`;
+}
+
+/**
+ * Create token discovery workflow
+ *
+ * @param args - Discovery arguments (type, filters)
+ * @returns Complete discovery workflow
+ */
+export function createDiscoverTokensWorkflow(args: {
+  type: 'recent' | 'popular' | 'near-graduation';
+  minProgress?: string;
+  maxPrice?: string;
+  limit: number;
+}): string {
+  const steps: string[] = [];
+
+  // Fetch pools
+  if (args.type === 'near-graduation') {
+    steps.push(`Fetch all pools using ${MCP_TOOLS.FETCH_ALL_POOLS} with type: 'recent'`);
+  } else {
+    steps.push(`Fetch ${args.type} pools using ${MCP_TOOLS.FETCH_ALL_POOLS} with type: '${args.type}'`);
+  }
+
+  // Calculate prices
+  steps.push(
+    `For each pool, calculate USD spot price using ${MCP_TOOLS.FETCH_LAUNCHPAD_TOKEN_SPOT_PRICE} with LOCAL mode for speed`
+  );
+
+  // Filter by progress if requested
+  if (args.type === 'near-graduation' || args.minProgress) {
+    steps.push(`Filter tokens by graduation progress (min: ${args.minProgress || '90'}%)`);
+  }
+
+  // Filter by price if requested
+  if (args.maxPrice) {
+    steps.push(`Filter tokens by maximum USD price: $${args.maxPrice}`);
+  }
+
+  // Sort and present
+  if (args.type === 'near-graduation') {
+    steps.push(`Sort by graduation progress (highest first)`);
+  } else if (args.type === 'popular') {
+    steps.push(`Sort by trading volume (highest first)`);
+  } else {
+    steps.push(`Sort by creation date (newest first)`);
+  }
+
+  steps.push(`Present top ${args.limit} results with:`);
+  steps.push(`   - Token name and symbol`);
+  steps.push(`   - Current USD price`);
+  steps.push(`   - 24h volume (if available)`);
+  steps.push(`   - Graduation progress percentage`);
+  steps.push(`   - Quick investment analysis`);
+
+  steps.push(`Suggest 2-3 most interesting opportunities based on filters`);
+
+  let typeDescription = '';
+  if (args.type === 'recent') {
+    typeDescription = 'Recently launched tokens';
+  } else if (args.type === 'popular') {
+    typeDescription = 'Most popular tokens by volume';
+  } else {
+    typeDescription = 'Tokens close to graduating the bonding curve';
+  }
+
+  return `Help me discover tokens on Gala Launchpad:
+
+Discovery Type: ${typeDescription}
+${args.minProgress ? `Min Graduation Progress: ${args.minProgress}%` : ''}
+${args.maxPrice ? `Max Price: $${args.maxPrice}` : ''}
+Limit: ${args.limit} tokens
+
+Please follow this workflow:
+
+${formatWorkflowSteps(steps)}
+
+${createPerformanceNote()}
+
+After presenting the results, ask if I'd like to:
+- Analyze any specific token further (use /analyze-token)
+- Buy tokens from the discovery list
+- Set alerts for tokens near graduation`;
+}