@gala-chain/launchpad-mcp-server 1.7.2 → 1.7.4

package/src/tools/utils/getAddress.ts

@@ -0,0 +1,12 @@
+/**
+ * Get Address Tool (45% code reduction via factory pattern)
+ */
+
+import { createNoParamTool } from '../../utils/tool-factory.js';
+
+export const getAddressTool = createNoParamTool({
+  name: 'gala_launchpad_get_address',
+  description: 'Get the GalaChain address format (eth|0x...) for the authenticated wallet.',
+  handler: (sdk) => sdk.getAddress(),
+  resultKey: 'address',
+});

package/src/tools/utils/getCacheInfo.ts

@@ -0,0 +1,14 @@
+/**
+ * Get Cache Info Tool
+ *
+ * Returns statistics about the token metadata cache for monitoring and debugging.
+ * The cache persists entire MCP server lifetime and accumulates metadata across conversations.
+ */
+
+import { createNoParamTool } from '../../utils/tool-factory.js';
+
+export const getCacheInfoTool = createNoParamTool({
+  name: 'gala_launchpad_get_cache_info',
+  description: 'Get token metadata cache statistics including total tokens cached, cache size in bytes, and timestamp of oldest entry. The cache persists for the entire MCP server lifetime.',
+  handler: (sdk) => sdk.getCacheInfo(),
+});

package/src/tools/utils/getConfig.ts

@@ -0,0 +1,11 @@
+/**
+ * Get Config Tool (45% code reduction via factory pattern)
+ */
+
+import { createNoParamTool } from '../../utils/tool-factory.js';
+
+export const getConfigTool = createNoParamTool({
+  name: 'gala_launchpad_get_config',
+  description: 'Get the current SDK configuration including environment, base URLs, timeouts, feature flags, and effective slippage tolerance factors.',
+  handler: (sdk) => sdk.getConfig(),
+});

package/src/tools/utils/getEthereumAddress.ts

@@ -0,0 +1,12 @@
+/**
+ * Get Ethereum Address Tool (45% code reduction via factory pattern)
+ */
+
+import { createNoParamTool } from '../../utils/tool-factory.js';
+
+export const getEthereumAddressTool = createNoParamTool({
+  name: 'gala_launchpad_get_ethereum_address',
+  description: 'Get the standard Ethereum address format (0x...) for the authenticated wallet.',
+  handler: (sdk) => sdk.getEthereumAddress(),
+  resultKey: 'address',
+});

package/src/tools/utils/getUrlByTokenName.ts

@@ -0,0 +1,12 @@
+/**
+ * Get URL by Token Name Tool (73% code reduction via factory pattern)
+ */
+
+import { createResolutionTool } from '../../utils/tool-factory.js';
+
+export const getUrlByTokenNameTool = createResolutionTool({
+  name: 'gala_launchpad_get_url_by_token_name',
+  description: 'Get the launchpad frontend URL for a specific token. Returns the complete URL for viewing/trading the token in the web interface.',
+  resolver: async (sdk, tokenName) => sdk.getUrlByTokenName(tokenName),
+  resultKey: 'url',
+});

package/src/tools/utils/index.ts

@@ -0,0 +1,25 @@
+/**
+ * Utility Tools
+ */
+
+import { createWalletTool } from './createWallet.js';
+import { getAddressTool } from './getAddress.js';
+import { getEthereumAddressTool } from './getEthereumAddress.js';
+import { getConfigTool } from './getConfig.js';
+import { getUrlByTokenNameTool } from './getUrlByTokenName.js';
+import { explainSdkUsageTool } from './explainSdkUsage.js';
+import { isTokenGraduatedTool } from './isTokenGraduated.js';
+import { getCacheInfoTool } from './getCacheInfo.js';
+import { clearCacheTool } from './clearCache.js';
+
+export const utilityTools = [
+  createWalletTool,
+  getAddressTool,
+  getEthereumAddressTool,
+  getConfigTool,
+  getUrlByTokenNameTool,
+  explainSdkUsageTool,
+  isTokenGraduatedTool,
+  getCacheInfoTool,
+  clearCacheTool,
+];

package/src/tools/utils/isTokenGraduated.ts

@@ -0,0 +1,16 @@
+/**
+ * Check if token has graduated from bonding curve (73% code reduction via factory pattern)
+ */
+
+import { createResolutionTool } from '../../utils/tool-factory.js';
+
+export const isTokenGraduatedTool = createResolutionTool({
+  name: 'gala_launchpad_is_token_graduated',
+  description: `Check if a token has completed the bonding curve phase and graduated to full DEX trading.
+
+RETURNS: Boolean indicating if pool saleStatus is "Completed"
+
+USAGE: Useful for conditional logic before attempting graduation or checking pool state.`,
+  resolver: (sdk, tokenName) => sdk.isTokenGraduated(tokenName),
+  resultKey: 'graduated',
+});

package/src/types/mcp.ts

@@ -0,0 +1,72 @@
+/**
+ * MCP Protocol Types
+ */
+
+import type { LaunchpadSDK } from '@gala-chain/launchpad-sdk';
+
+/**
+ * MCP Tool Definition
+ */
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: 'object';
+    properties: Record<string, any>;
+    required?: string[];
+  };
+  handler: (sdk: LaunchpadSDK, args: any) => Promise<MCPToolResponse>;
+}
+
+/**
+ * MCP Tool Response
+ */
+export interface MCPToolResponse {
+  content: Array<{
+    type: 'text' | 'image' | 'resource';
+    text?: string;
+    data?: string;
+    mimeType?: string;
+  }>;
+  isError?: boolean;
+}
+
+/**
+ * Tool execution context
+ */
+export interface ToolContext {
+  sdk: LaunchpadSDK;
+  debug: boolean;
+}
+
+/**
+ * MCP Prompt Argument Definition
+ */
+export interface MCPPromptArgument {
+  name: string;
+  description: string;
+  required: boolean;
+}
+
+/**
+ * MCP Prompt Definition
+ */
+export interface MCPPrompt {
+  name: string;
+  description: string;
+  arguments?: MCPPromptArgument[];
+  handler: (args: Record<string, string>) => PromptMessage[];
+}
+
+/**
+ * Prompt Message (from MCP spec)
+ */
+export interface PromptMessage {
+  role: 'user' | 'assistant';
+  content: {
+    type: 'text' | 'image' | 'resource';
+    text?: string;
+    data?: string;
+    mimeType?: string;
+  };
+}

package/src/utils/__tests__/validation.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Validation Utilities Tests
+ *
+ * Tests for input validation functions
+ */
+
+import {
+  validateTokenName,
+  validateNumericAmount,
+  validateSlippage,
+  validateAddress,
+  validateTokenSymbol,
+  validatePaginationLimit,
+  validateTokenList,
+  safeValidate,
+  ValidationError,
+} from '../validation';
+
+describe('Validation Utilities', () => {
+  describe('validateTokenName()', () => {
+    it('should accept valid token names', () => {
+      expect(() => validateTokenName('anime')).not.toThrow();
+      expect(() => validateTokenName('test123')).not.toThrow();
+      expect(() => validateTokenName('my-token')).not.toThrow();
+      expect(() => validateTokenName('my_token')).not.toThrow();
+      expect(() => validateTokenName('TEST-123')).not.toThrow();
+    });
+
+    it('should reject invalid token names', () => {
+      expect(() => validateTokenName('')).toThrow(ValidationError);
+      expect(() => validateTokenName('a')).toThrow(ValidationError);
+      expect(() => validateTokenName('verylongtokennamethatexceedstwentycharacters')).toThrow(ValidationError);
+      expect(() => validateTokenName('token@#$')).toThrow(ValidationError);
+      expect(() => validateTokenName('token with spaces')).toThrow(ValidationError);
+    });
+  });
+
+  describe('validateNumericAmount()', () => {
+    it('should accept valid numeric amounts', () => {
+      expect(() => validateNumericAmount('100', 'amount')).not.toThrow();
+      expect(() => validateNumericAmount('0.5', 'amount')).not.toThrow();
+      expect(() => validateNumericAmount('99999.99', 'amount')).not.toThrow();
+      expect(() => validateNumericAmount(100, 'amount')).not.toThrow();
+    });
+
+    it('should reject invalid numeric amounts', () => {
+      expect(() => validateNumericAmount('', 'amount')).toThrow(ValidationError);
+      expect(() => validateNumericAmount('abc', 'amount')).toThrow(ValidationError);
+      expect(() => validateNumericAmount('-5', 'amount')).toThrow(ValidationError);
+      expect(() => validateNumericAmount('0', 'amount')).toThrow(ValidationError);
+      expect(() => validateNumericAmount(Infinity, 'amount')).toThrow(ValidationError);
+    });
+  });
+
+  describe('validateSlippage()', () => {
+    it('should accept valid slippage values', () => {
+      expect(() => validateSlippage('1')).not.toThrow();
+      expect(() => validateSlippage('0.5')).not.toThrow();
+      expect(() => validateSlippage('50')).not.toThrow();
+      expect(() => validateSlippage('0.01')).not.toThrow();
+      expect(() => validateSlippage('100')).not.toThrow();
+    });
+
+    it('should reject invalid slippage values', () => {
+      expect(() => validateSlippage('0')).toThrow(ValidationError);
+      expect(() => validateSlippage('0.005')).toThrow(ValidationError);
+      expect(() => validateSlippage('101')).toThrow(ValidationError);
+      expect(() => validateSlippage('-1')).toThrow(ValidationError);
+    });
+  });
+
+  describe('validateAddress()', () => {
+    it('should accept valid addresses', () => {
+      expect(() => validateAddress('eth|0x1234567890abcdef1234567890abcdef12345678')).not.toThrow();
+      expect(() => validateAddress('0x1234567890abcdef1234567890abcdef12345678')).not.toThrow();
+      expect(() => validateAddress('0xABCDEF1234567890abcdef1234567890ABCDEF12')).not.toThrow();
+    });
+
+    it('should reject invalid addresses', () => {
+      expect(() => validateAddress('')).toThrow(ValidationError);
+      expect(() => validateAddress('invalid')).toThrow(ValidationError);
+      expect(() => validateAddress('0x123')).toThrow(ValidationError);
+      expect(() => validateAddress('eth|123')).toThrow(ValidationError);
+    });
+  });
+
+  describe('validateTokenSymbol()', () => {
+    it('should accept valid symbols', () => {
+      expect(() => validateTokenSymbol('GALA')).not.toThrow();
+      expect(() => validateTokenSymbol('TEST')).not.toThrow();
+      expect(() => validateTokenSymbol('A')).not.toThrow();
+      expect(() => validateTokenSymbol('ABCDEFGH')).not.toThrow();
+    });
+
+    it('should reject invalid symbols', () => {
+      expect(() => validateTokenSymbol('')).toThrow(ValidationError);
+      expect(() => validateTokenSymbol('test')).toThrow(ValidationError);
+      expect(() => validateTokenSymbol('TOOLONG123')).toThrow(ValidationError);
+      expect(() => validateTokenSymbol('TEST123')).toThrow(ValidationError);
+    });
+  });
+
+  describe('validatePaginationLimit()', () => {
+    it('should accept valid limits', () => {
+      expect(() => validatePaginationLimit('1')).not.toThrow();
+      expect(() => validatePaginationLimit('20')).not.toThrow();
+      expect(() => validatePaginationLimit('100')).not.toThrow();
+      expect(() => validatePaginationLimit(50)).not.toThrow();
+    });
+
+    it('should reject invalid limits', () => {
+      expect(() => validatePaginationLimit('0')).toThrow(ValidationError);
+      expect(() => validatePaginationLimit('101')).toThrow(ValidationError);
+      expect(() => validatePaginationLimit('-1')).toThrow(ValidationError);
+      expect(() => validatePaginationLimit('abc')).toThrow(ValidationError);
+    });
+  });
+
+  describe('validateTokenList()', () => {
+    it('should accept valid token lists', () => {
+      const result1 = validateTokenList('anime,test,dragon');
+      expect(result1).toEqual(['anime', 'test', 'dragon']);
+
+      const result2 = validateTokenList('token1');
+      expect(result2).toEqual(['token1']);
+    });
+
+    it('should reject invalid token lists', () => {
+      expect(() => validateTokenList('')).toThrow(ValidationError);
+      expect(() => validateTokenList('token1,invalid@#$')).toThrow(ValidationError);
+    });
+  });
+
+  describe('safeValidate()', () => {
+    it('should return success for valid input', () => {
+      const result = safeValidate(() => validateTokenName('anime'));
+      expect(result.success).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should return error for invalid input', () => {
+      const result = safeValidate(() => validateTokenName('invalid@#$'));
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+});

package/src/utils/constraints.ts

@@ -0,0 +1,146 @@
+/**
+ * Central Constraints Reference
+ *
+ * This file documents the pagination limits enforced by the SDK for different operations.
+ * These constants are imported from the SDK's internal constraint definitions and serve
+ * as the single source of truth for MCP tool schema validation.
+ *
+ * IMPORTANT: Always keep these in sync with the SDK's actual constraints:
+ * - TRADE_CONSTRAINTS.PAGINATION.MAX_LIMIT (trade.dto.ts)
+ * - USER_CONSTRAINTS.PAGINATION.MAX_LIMIT (user.dto.ts)
+ * - PAGINATION_CONSTRAINTS.MAX_LIMIT (launchpad.dto.ts)
+ * - COMMENT_CONSTRAINTS.PAGINATION.MAX_LIMIT (comment.dto.ts)
+ */
+
+/**
+ * MCP Tool Constraint Constants
+ *
+ * These values MUST match the SDK's internal constraint definitions to prevent
+ * validation errors when AI agents use the MCP tools.
+ */
+export const MCP_CONSTRAINTS = {
+  /**
+   * Trade operations limit (fetchTrades)
+   * Source: TRADE_CONSTRAINTS.PAGINATION.MAX_LIMIT
+   * SDK File: packages/sdk/src/types/trade.dto.ts:331
+   */
+  TRADE_LIMIT: 20,
+
+  /**
+   * User operations limit (fetchTokensHeld, fetchTokensCreated)
+   * Source: USER_CONSTRAINTS.PAGINATION.MAX_LIMIT
+   * SDK File: packages/sdk/src/types/user.dto.ts:297
+   */
+  USER_LIMIT: 20,
+
+  /**
+   * General pool operations limit (fetchPools)
+   * Source: PAGINATION_CONSTRAINTS.MAX_LIMIT
+   * SDK File: packages/sdk/src/types/launchpad.dto.ts:587
+   */
+  POOL_LIMIT: 100,
+
+  /**
+   * Comment operations limit (fetchComments)
+   * Source: COMMENT_CONSTRAINTS.PAGINATION.MAX_LIMIT
+   * SDK File: packages/sdk/src/types/comment.dto.ts:149
+   */
+  COMMENT_LIMIT: 50,
+
+  /**
+   * Minimum limit for all pagination operations
+   */
+  MIN_LIMIT: 1,
+
+  /**
+   * Minimum page number for all pagination operations
+   */
+  MIN_PAGE: 1,
+
+  /**
+   * Maximum page number for all pagination operations
+   */
+  MAX_PAGE: 1000,
+} as const;
+
+/**
+ * Constraint usage reference for MCP tool developers
+ *
+ * @example
+ * // Trading tools (fetchTrades)
+ * limit: {
+ *   type: 'number',
+ *   minimum: MCP_CONSTRAINTS.MIN_LIMIT,
+ *   maximum: MCP_CONSTRAINTS.TRADE_LIMIT, // 20
+ *   description: `Results per page (default: 20, maximum: ${MCP_CONSTRAINTS.TRADE_LIMIT})`
+ * }
+ *
+ * @example
+ * // Balance/User tools (fetchTokensHeld, fetchTokensCreated)
+ * limit: {
+ *   type: 'number',
+ *   minimum: MCP_CONSTRAINTS.MIN_LIMIT,
+ *   maximum: MCP_CONSTRAINTS.USER_LIMIT, // 20
+ *   description: `Results per page (default: 20, maximum: ${MCP_CONSTRAINTS.USER_LIMIT})`
+ * }
+ *
+ * @example
+ * // Pool tools (fetchPools)
+ * limit: {
+ *   type: 'number',
+ *   minimum: MCP_CONSTRAINTS.MIN_LIMIT,
+ *   maximum: MCP_CONSTRAINTS.POOL_LIMIT, // 100
+ *   description: `Results per page (default: 20, maximum: ${MCP_CONSTRAINTS.POOL_LIMIT})`
+ * }
+ *
+ * @example
+ * // Social tools (fetchComments)
+ * limit: {
+ *   type: 'number',
+ *   minimum: MCP_CONSTRAINTS.MIN_LIMIT,
+ *   maximum: MCP_CONSTRAINTS.COMMENT_LIMIT, // 50
+ *   description: `Results per page (default: 20, maximum: ${MCP_CONSTRAINTS.COMMENT_LIMIT})`
+ * }
+ */
+
+/**
+ * Validation helper to check if a limit value is valid for a specific operation type
+ *
+ * @param limit The limit value to validate
+ * @param operationType The type of operation ('trade' | 'user' | 'pool' | 'comment')
+ * @returns true if valid, false otherwise
+ */
+export function isValidLimit(
+  limit: number,
+  operationType: 'trade' | 'user' | 'pool' | 'comment'
+): boolean {
+  if (!Number.isInteger(limit) || limit < MCP_CONSTRAINTS.MIN_LIMIT) {
+    return false;
+  }
+
+  const maxLimits = {
+    trade: MCP_CONSTRAINTS.TRADE_LIMIT,
+    user: MCP_CONSTRAINTS.USER_LIMIT,
+    pool: MCP_CONSTRAINTS.POOL_LIMIT,
+    comment: MCP_CONSTRAINTS.COMMENT_LIMIT,
+  };
+
+  return limit <= maxLimits[operationType];
+}
+
+/**
+ * Get the maximum limit for a specific operation type
+ *
+ * @param operationType The type of operation
+ * @returns The maximum limit value
+ */
+export function getMaxLimit(operationType: 'trade' | 'user' | 'pool' | 'comment'): number {
+  const maxLimits = {
+    trade: MCP_CONSTRAINTS.TRADE_LIMIT,
+    user: MCP_CONSTRAINTS.USER_LIMIT,
+    pool: MCP_CONSTRAINTS.POOL_LIMIT,
+    comment: MCP_CONSTRAINTS.COMMENT_LIMIT,
+  };
+
+  return maxLimits[operationType];
+}

package/src/utils/default-values.ts

@@ -0,0 +1,208 @@
+/**
+ * Default Value Utilities
+ *
+ * Centralized default values for tool parameters to eliminate magic numbers
+ * and ensure consistency across 47 MCP tools.
+ *
+ * @see Phase 2.2 of refactoring plan
+ */
+
+import { MCP_CONSTRAINTS } from './constraints.js';
+
+// =============================================================================
+// Pagination Defaults
+// =============================================================================
+
+/**
+ * Default pagination configuration
+ */
+export const DEFAULT_PAGINATION = {
+  page: 1,
+  limit: 20,
+} as const;
+
+/**
+ * Operation-specific default limits
+ */
+export const DEFAULT_LIMITS = {
+  trade: 20,
+  user: 20,
+  pool: 20,
+  comment: 20,
+} as const;
+
+/**
+ * Maximum limits per operation type (from MCP_CONSTRAINTS)
+ */
+export const MAX_LIMITS = {
+  trade: MCP_CONSTRAINTS.TRADE_LIMIT, // 20
+  user: MCP_CONSTRAINTS.USER_LIMIT, // 20
+  pool: MCP_CONSTRAINTS.POOL_LIMIT, // 100
+  comment: MCP_CONSTRAINTS.COMMENT_LIMIT, // 50
+} as const;
+
+// =============================================================================
+// Trading Defaults
+// =============================================================================
+
+/**
+ * Default slippage tolerance (1%)
+ */
+export const DEFAULT_SLIPPAGE_TOLERANCE = 0.01;
+
+/**
+ * Default reverse bonding curve fee slippage tolerance (1%)
+ */
+export const DEFAULT_RBC_FEE_SLIPPAGE = 0.01;
+
+/**
+ * Default pool type for fetchPools
+ */
+export const DEFAULT_POOL_TYPE = 'recent';
+
+/**
+ * Default sort order
+ */
+export const DEFAULT_SORT_ORDER = 'DESC';
+
+// =============================================================================
+// Volume Data Defaults
+// =============================================================================
+
+/**
+ * Default resolution for volume data (1 hour)
+ */
+export const DEFAULT_VOLUME_RESOLUTION = '1h';
+
+/**
+ * Resolution mapping (string to seconds)
+ */
+export const RESOLUTION_MAP: Record<string, number> = {
+  '1m': 60,
+  '5m': 300,
+  '15m': 900,
+  '1h': 3600,
+  '4h': 14400,
+  '1d': 86400,
+} as const;
+
+// =============================================================================
+// Utility Functions
+// =============================================================================
+
+/**
+ * Applies default pagination values to args object
+ *
+ * @example
+ * ```typescript
+ * const params = applyPaginationDefaults(args);
+ * // { page: 1, limit: 20, ...otherArgs }
+ * ```
+ */
+export function applyPaginationDefaults<T extends Record<string, any>>(
+  args: T,
+  defaults: { page?: number; limit?: number } = DEFAULT_PAGINATION
+): T & { page: number; limit: number } {
+  return {
+    ...args,
+    page: args.page ?? defaults.page ?? DEFAULT_PAGINATION.page,
+    limit: args.limit ?? defaults.limit ?? DEFAULT_PAGINATION.limit,
+  };
+}
+
+/**
+ * Applies operation-specific pagination defaults
+ *
+ * @example
+ * ```typescript
+ * const params = applyOperationPaginationDefaults(args, 'pool');
+ * // Uses default limit of 20 for pool operations
+ * ```
+ */
+export function applyOperationPaginationDefaults<T extends Record<string, any>>(
+  args: T,
+  operationType: keyof typeof DEFAULT_LIMITS
+): T & { page: number; limit: number } {
+  return applyPaginationDefaults(args, {
+    page: DEFAULT_PAGINATION.page,
+    limit: DEFAULT_LIMITS[operationType],
+  });
+}
+
+/**
+ * Applies default slippage values to trading args
+ *
+ * @example
+ * ```typescript
+ * const params = applySlippageDefaults(args);
+ * // { slippageToleranceFactor: 0.01, maxAcceptableReverseBondingCurveFeeSlippageFactor: 0.01, ...args }
+ * ```
+ */
+export function applySlippageDefaults<T extends Record<string, any>>(
+  args: T,
+  defaults: {
+    slippageToleranceFactor?: number;
+    maxAcceptableReverseBondingCurveFeeSlippageFactor?: number;
+  } = {}
+): T & {
+  slippageToleranceFactor: number;
+  maxAcceptableReverseBondingCurveFeeSlippageFactor: number;
+} {
+  return {
+    ...args,
+    slippageToleranceFactor:
+      args.slippageToleranceFactor ??
+      defaults.slippageToleranceFactor ??
+      DEFAULT_SLIPPAGE_TOLERANCE,
+    maxAcceptableReverseBondingCurveFeeSlippageFactor:
+      args.maxAcceptableReverseBondingCurveFeeSlippageFactor ??
+      defaults.maxAcceptableReverseBondingCurveFeeSlippageFactor ??
+      DEFAULT_RBC_FEE_SLIPPAGE,
+  };
+}
+
+/**
+ * Converts volume resolution string to seconds
+ *
+ * @example
+ * ```typescript
+ * const seconds = resolutionToSeconds('1h', '1h');
+ * // 3600
+ * ```
+ */
+export function resolutionToSeconds(
+  resolution: string | undefined,
+  defaultResolution: string = DEFAULT_VOLUME_RESOLUTION
+): number {
+  return RESOLUTION_MAP[resolution ?? defaultResolution] ?? RESOLUTION_MAP[defaultResolution];
+}
+
+/**
+ * Converts ISO 8601 date string to Unix timestamp (seconds)
+ *
+ * @example
+ * ```typescript
+ * const timestamp = dateToUnixTimestamp('2024-01-15T14:30:25Z');
+ * // 1705329025
+ * ```
+ */
+export function dateToUnixTimestamp(isoDate: string | undefined): number | undefined {
+  if (!isoDate) return undefined;
+  return Math.floor(new Date(isoDate).getTime() / 1000);
+}
+
+// =============================================================================
+// Export All
+// =============================================================================
+
+export const defaultValues = {
+  pagination: DEFAULT_PAGINATION,
+  limits: DEFAULT_LIMITS,
+  maxLimits: MAX_LIMITS,
+  slippageTolerance: DEFAULT_SLIPPAGE_TOLERANCE,
+  rbcFeeSlippage: DEFAULT_RBC_FEE_SLIPPAGE,
+  poolType: DEFAULT_POOL_TYPE,
+  sortOrder: DEFAULT_SORT_ORDER,
+  volumeResolution: DEFAULT_VOLUME_RESOLUTION,
+  resolutionMap: RESOLUTION_MAP,
+};