@gala-chain/launchpad-mcp-server 1.14.0 → 1.14.2

package/src/utils/validation.ts

@@ -0,0 +1,336 @@
+/**
+ * Validation Utilities for MCP Prompts
+ *
+ * Input validation functions for slash command arguments.
+ * Prevents malformed inputs and provides clear error messages.
+ */
+
+/**
+ * Validation error class for better error handling
+ */
+export class ValidationError extends Error {
+  constructor(
+    public field: string,
+    message: string
+  ) {
+    super(`Validation error for '${field}': ${message}`);
+    this.name = 'ValidationError';
+  }
+}
+
+/**
+ * Validate token name format
+ *
+ * Token names must be 2-20 characters, alphanumeric with hyphens and underscores.
+ *
+ * @param name - Token name to validate
+ * @param fieldName - Field name for error messages (default: 'tokenName')
+ * @throws {ValidationError} If token name is invalid
+ *
+ * @example
+ * ```typescript
+ * validateTokenName('anime'); // ✅ Valid
+ * validateTokenName('test-123'); // ✅ Valid
+ * validateTokenName('my_token'); // ✅ Valid
+ * validateTokenName('a'); // ❌ Throws: too short
+ * validateTokenName('token@#$'); // ❌ Throws: invalid characters
+ * ```
+ */
+export function validateTokenName(name: string, fieldName = 'tokenName'): void {
+  if (!name || typeof name !== 'string') {
+    throw new ValidationError(fieldName, 'Token name is required');
+  }
+
+  if (name.length < 2 || name.length > 20) {
+    throw new ValidationError(
+      fieldName,
+      `Token name must be 2-20 characters (got ${name.length})`
+    );
+  }
+
+  const tokenNameRegex = /^[a-zA-Z0-9-_]+$/;
+  if (!tokenNameRegex.test(name)) {
+    throw new ValidationError(
+      fieldName,
+      'Token name can only contain letters, numbers, hyphens, and underscores'
+    );
+  }
+}
+
+/**
+ * Validate numeric amount
+ *
+ * Amounts must be positive numbers (integers or decimals).
+ *
+ * @param amount - Amount to validate (string or number)
+ * @param fieldName - Field name for error messages
+ * @throws {ValidationError} If amount is invalid
+ *
+ * @example
+ * ```typescript
+ * validateNumericAmount('100', 'galaAmount'); // ✅ Valid
+ * validateNumericAmount('99.5', 'tokenAmount'); // ✅ Valid
+ * validateNumericAmount('-5', 'amount'); // ❌ Throws: negative
+ * validateNumericAmount('abc', 'amount'); // ❌ Throws: not a number
+ * ```
+ */
+export function validateNumericAmount(
+  amount: string | number,
+  fieldName: string
+): void {
+  if (amount === null || amount === undefined || amount === '') {
+    throw new ValidationError(fieldName, 'Amount is required');
+  }
+
+  const numAmount = typeof amount === 'string' ? parseFloat(amount) : amount;
+
+  if (isNaN(numAmount)) {
+    throw new ValidationError(fieldName, `Amount must be a valid number (got: ${amount})`);
+  }
+
+  if (numAmount <= 0) {
+    throw new ValidationError(
+      fieldName,
+      `Amount must be positive (got: ${numAmount})`
+    );
+  }
+
+  if (!isFinite(numAmount)) {
+    throw new ValidationError(fieldName, 'Amount must be a finite number');
+  }
+}
+
+/**
+ * Validate slippage tolerance percentage
+ *
+ * Slippage must be between 0.01% and 100%.
+ *
+ * @param slippage - Slippage percentage to validate
+ * @param fieldName - Field name for error messages (default: 'slippage')
+ * @throws {ValidationError} If slippage is invalid
+ *
+ * @example
+ * ```typescript
+ * validateSlippage('1'); // ✅ Valid (1%)
+ * validateSlippage('0.5'); // ✅ Valid (0.5%)
+ * validateSlippage('50'); // ✅ Valid (50%)
+ * validateSlippage('0'); // ❌ Throws: too low
+ * validateSlippage('150'); // ❌ Throws: too high
+ * ```
+ */
+export function validateSlippage(
+  slippage: string | number,
+  fieldName = 'slippage'
+): void {
+  if (slippage === null || slippage === undefined || slippage === '') {
+    throw new ValidationError(fieldName, 'Slippage is required');
+  }
+
+  const numSlippage = typeof slippage === 'string' ? parseFloat(slippage) : slippage;
+
+  if (isNaN(numSlippage)) {
+    throw new ValidationError(
+      fieldName,
+      `Slippage must be a valid number (got: ${slippage})`
+    );
+  }
+
+  if (numSlippage < 0.01 || numSlippage > 100) {
+    throw new ValidationError(
+      fieldName,
+      `Slippage must be between 0.01% and 100% (got: ${numSlippage}%)`
+    );
+  }
+}
+
+/**
+ * Validate wallet address format
+ *
+ * Supports both GalaChain format (eth|0x...) and standard Ethereum format (0x...).
+ *
+ * @param address - Wallet address to validate
+ * @param fieldName - Field name for error messages (default: 'address')
+ * @throws {ValidationError} If address is invalid
+ *
+ * @example
+ * ```typescript
+ * validateAddress('eth|0x1234567890abcdef1234567890abcdef12345678'); // ✅ Valid
+ * validateAddress('0x1234567890abcdef1234567890abcdef12345678'); // ✅ Valid
+ * validateAddress('invalid'); // ❌ Throws: invalid format
+ * ```
+ */
+export function validateAddress(address: string, fieldName = 'address'): void {
+  if (!address || typeof address !== 'string') {
+    throw new ValidationError(fieldName, 'Address is required');
+  }
+
+  // GalaChain format: eth|0x{40 hex chars}
+  const galachainRegex = /^eth\|0x[a-fA-F0-9]{40}$/;
+  // Standard Ethereum format: 0x{40 hex chars}
+  const ethereumRegex = /^0x[a-fA-F0-9]{40}$/;
+
+  if (!galachainRegex.test(address) && !ethereumRegex.test(address)) {
+    throw new ValidationError(
+      fieldName,
+      'Address must be in GalaChain format (eth|0x...) or Ethereum format (0x...)'
+    );
+  }
+}
+
+/**
+ * Validate token symbol format
+ *
+ * Symbols must be 1-8 uppercase letters.
+ *
+ * @param symbol - Token symbol to validate
+ * @param fieldName - Field name for error messages (default: 'symbol')
+ * @throws {ValidationError} If symbol is invalid
+ *
+ * @example
+ * ```typescript
+ * validateTokenSymbol('GALA'); // ✅ Valid
+ * validateTokenSymbol('TEST'); // ✅ Valid
+ * validateTokenSymbol('test'); // ❌ Throws: must be uppercase
+ * validateTokenSymbol('TOOLONG123'); // ❌ Throws: too long
+ * ```
+ */
+export function validateTokenSymbol(symbol: string, fieldName = 'symbol'): void {
+  if (!symbol || typeof symbol !== 'string') {
+    throw new ValidationError(fieldName, 'Symbol is required');
+  }
+
+  if (symbol.length < 1 || symbol.length > 8) {
+    throw new ValidationError(
+      fieldName,
+      `Symbol must be 1-8 characters (got ${symbol.length})`
+    );
+  }
+
+  const symbolRegex = /^[A-Z]+$/;
+  if (!symbolRegex.test(symbol)) {
+    throw new ValidationError(
+      fieldName,
+      'Symbol must be uppercase letters only (A-Z)'
+    );
+  }
+}
+
+/**
+ * Validate pagination limit
+ *
+ * Limits must be positive integers within reasonable range (1-100).
+ *
+ * @param limit - Pagination limit to validate
+ * @param max - Maximum allowed limit (default: 100)
+ * @param fieldName - Field name for error messages (default: 'limit')
+ * @throws {ValidationError} If limit is invalid
+ *
+ * @example
+ * ```typescript
+ * validatePaginationLimit('20'); // ✅ Valid
+ * validatePaginationLimit('1'); // ✅ Valid
+ * validatePaginationLimit('0'); // ❌ Throws: too low
+ * validatePaginationLimit('150'); // ❌ Throws: too high
+ * ```
+ */
+export function validatePaginationLimit(
+  limit: string | number,
+  max = 100,
+  fieldName = 'limit'
+): void {
+  if (limit === null || limit === undefined || limit === '') {
+    throw new ValidationError(fieldName, 'Limit is required');
+  }
+
+  const numLimit = typeof limit === 'string' ? parseInt(limit, 10) : limit;
+
+  if (isNaN(numLimit) || !Number.isInteger(numLimit)) {
+    throw new ValidationError(
+      fieldName,
+      `Limit must be a valid integer (got: ${limit})`
+    );
+  }
+
+  if (numLimit < 1 || numLimit > max) {
+    throw new ValidationError(
+      fieldName,
+      `Limit must be between 1 and ${max} (got: ${numLimit})`
+    );
+  }
+}
+
+/**
+ * Validate comma-separated token list
+ *
+ * For batch operations that accept multiple token names.
+ *
+ * @param tokens - Comma-separated token names
+ * @param fieldName - Field name for error messages (default: 'tokens')
+ * @throws {ValidationError} If token list is invalid
+ *
+ * @example
+ * ```typescript
+ * validateTokenList('anime,test,dragon'); // ✅ Valid
+ * validateTokenList('token1'); // ✅ Valid (single token)
+ * validateTokenList(''); // ❌ Throws: empty list
+ * validateTokenList('token1,invalid@#$'); // ❌ Throws: invalid token name
+ * ```
+ */
+export function validateTokenList(tokens: string, fieldName = 'tokens'): string[] {
+  if (!tokens || typeof tokens !== 'string') {
+    throw new ValidationError(fieldName, 'Token list is required');
+  }
+
+  const tokenArray = tokens.split(',').map((t) => t.trim());
+
+  if (tokenArray.length === 0 || tokenArray.some((t) => !t)) {
+    throw new ValidationError(fieldName, 'Token list cannot be empty');
+  }
+
+  // Validate each token name
+  tokenArray.forEach((token, index) => {
+    try {
+      validateTokenName(token, `${fieldName}[${index}]`);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        throw new ValidationError(
+          fieldName,
+          `Invalid token at position ${index + 1}: ${token}`
+        );
+      }
+      throw error;
+    }
+  });
+
+  return tokenArray;
+}
+
+/**
+ * Safe validation wrapper that doesn't throw
+ *
+ * Useful for non-critical validation where you want to continue with a warning.
+ *
+ * @param validationFn - Validation function to execute
+ * @returns Object with success flag and optional error
+ *
+ * @example
+ * ```typescript
+ * const result = safeValidate(() => validateTokenName('anime'));
+ * if (!result.success) {
+ *   console.warn('Validation warning:', result.error);
+ * }
+ * ```
+ */
+export function safeValidate(
+  validationFn: () => void
+): { success: boolean; error?: string } {
+  try {
+    validationFn();
+    return { success: true };
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      return { success: false, error: error.message };
+    }
+    return { success: false, error: String(error) };
+  }
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": false,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "types": ["node", "jest"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests", "src/scripts", "src/**/__tests__"]
+}