@gala-chain/launchpad-mcp-server 5.0.3 → 5.0.4-beta.1

package/dist/tools/handler-factories.d.ts

@@ -0,0 +1,1401 @@
+/**
+ * Handler Factory Utilities
+ *
+ * Provides reusable factory functions for creating MCP tool handlers with common patterns.
+ * Reduces boilerplate and ensures consistent error handling across all tools.
+ *
+ * @example
+ * // Simple single-arg handler
+ * const handler = createSimpleHandler('fetchGalaBalance', (args) => args.address);
+ *
+ * @example
+ * // Toggle enable/disable pattern
+ * const handler = createToggleHandler('enableChat', 'disableChat');
+ *
+ * @example
+ * // Transaction status handler
+ * const handler = createTransactionStatusHandler('getSolanaTransactionStatus', 'Solana');
+ *
+ * @example
+ * // No-arg convenience fetcher
+ * const handler = createConvenienceFetcher('getGlobalChatStatus');
+ */
+import type { MCPToolResponse } from '../types/mcp.js';
+import type { LaunchpadSDK } from '@gala-chain/launchpad-sdk';
+/**
+ * Core SDK invocation result
+ */
+interface SdkInvocationResult<T = unknown> {
+    result: T;
+}
+/**
+ * Options for invoking an SDK method
+ *
+ * @internal Used by handler factories to invoke SDK methods with consistent error handling.
+ */
+interface InvokeSdkMethodOptions {
+    /**
+     * The SDK instance to call the method on.
+     * Method will be looked up as sdk[methodName].
+     */
+    sdk: LaunchpadSDK;
+    /**
+     * Name of the SDK method to call.
+     * Must be a valid method name on LaunchpadSDK (validated at runtime).
+     */
+    methodName: string;
+    /**
+     * Extracted arguments to pass to the method.
+     * - `undefined`: Calls method with no arguments
+     * - Array: Spreads as positional arguments via apply()
+     * - Other: Passes as single argument via call()
+     */
+    extractedArgs?: unknown | unknown[];
+    /**
+     * Context for error messages.
+     * Defaults to methodName if not provided.
+     */
+    errorContext?: string;
+}
+/**
+ * Core helper: Looks up and invokes an SDK method with the given arguments.
+ *
+ * This is the core primitive that all handler factories use. It handles:
+ * - Method lookup on the SDK instance
+ * - Method existence validation
+ * - Argument handling (no args, single arg, spread array)
+ * - Proper `this` binding via call/apply
+ *
+ * @param options - Invocation configuration
+ * @returns Promise resolving to the SDK method result
+ * @throws Error if the SDK method doesn't exist
+ *
+ * @internal Exported for use by pagination-handler-factory; not part of public API.
+ */
+export declare function invokeSdkMethod<T = unknown>(options: InvokeSdkMethodOptions): Promise<SdkInvocationResult<T>>;
+/**
+ * Creates a simple handler that calls an SDK method with extracted arguments.
+ *
+ * Handles single or multi-argument SDK methods, with optional custom argument extraction.
+ *
+ * @param sdkMethodName - Name of the SDK method to call (must exist on LaunchpadSDK)
+ * @param argExtractor - Optional function to extract/transform args before calling SDK method
+ * @returns Handler that calls the SDK method and returns formatted success response
+ *
+ * @example
+ * // Simple single-arg extraction
+ * const handler = createSimpleHandler('fetchGalaBalance', (args) => args.address);
+ *
+ * @example
+ * // Multi-arg extraction
+ * const handler = createSimpleHandler('fetchTokenBalance', (args) => [
+ *   args.tokenName,
+ *   args.address
+ * ]);
+ *
+ * @example
+ * // No extraction (uses entire args object)
+ * const handler = createSimpleHandler('registerAccount');
+ */
+export declare function createSimpleHandler(sdkMethodName: string, argExtractor?: (args: Record<string, unknown>) => unknown | unknown[]): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a toggle handler for enable/disable patterns.
+ *
+ * Returns a handler that calls the appropriate enable or disable SDK method
+ * based on the `enabled` argument value.
+ *
+ * @param enableMethod - Name of the SDK method to enable (called when enabled=true)
+ * @param disableMethod - Name of the SDK method to disable (called when enabled=false)
+ * @param argExtractor - Optional function to extract arguments for the SDK methods
+ * @returns Handler that toggles between enable and disable methods
+ *
+ * @example
+ * const handler = createToggleHandler('enableChat', 'disableChat', (args) => args.tokenName);
+ *
+ * // When args = { enabled: true, tokenName: 'mytoken' }
+ * // Calls: sdk.enableChat('mytoken')
+ *
+ * // When args = { enabled: false, tokenName: 'mytoken' }
+ * // Calls: sdk.disableChat('mytoken')
+ */
+export declare function createToggleHandler(enableMethod: string, disableMethod: string, argExtractor?: (args: Record<string, unknown>) => unknown | unknown[]): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a transaction status handler for blockchain transaction queries.
+ *
+ * Handles transaction status patterns like getSolanaTransactionStatus and getEthereumTransactionStatus.
+ * These methods typically require a transaction hash and optional chain hint.
+ *
+ * @param sdkMethod - Name of the SDK method to call (e.g., 'getSolanaTransactionStatus')
+ * @param chainName - Name of the chain for context in error messages
+ * @returns Handler that queries transaction status
+ *
+ * @example
+ * const handler = createTransactionStatusHandler('getSolanaTransactionStatus', 'Solana');
+ *
+ * // Args expected: { transactionHash, chainHint? }
+ */
+export declare function createTransactionStatusHandler(sdkMethod: string, chainName: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a convenience fetcher handler for simple no-arg or single-arg SDK methods.
+ *
+ * Ideal for read-only queries that don't require complex argument extraction.
+ * Automatically formats the result as JSON.
+ *
+ * @param sdkMethod - Name of the SDK method to call
+ * @param argExtractor - Optional function to extract single argument
+ * @returns Handler that fetches data from SDK
+ *
+ * @example
+ * // No-arg fetcher
+ * const handler = createConvenienceFetcher('getGlobalChatStatus');
+ *
+ * // Single-arg fetcher
+ * const handler = createConvenienceFetcher('fetchProfile', (args) => args.address);
+ */
+export declare function createConvenienceFetcher(sdkMethod: string, argExtractor?: (args: Record<string, unknown>) => unknown): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a simple handler that returns a boolean success result.
+ *
+ * Use this for handlers that call SDK methods and just need to report success/failure,
+ * rather than returning the full SDK result.
+ *
+ * @param sdkMethodName - Name of the SDK method to call
+ * @param argExtractor - Optional function to extract/transform args before calling SDK method
+ * @param successMessage - Optional custom success message (defaults to "Operation completed successfully")
+ * @returns Handler that calls the SDK method and returns formatted boolean response
+ *
+ * @example
+ * const handler = createBooleanHandler('updateProfile', (args) => [
+ *   { fullName: args.fullName, profileImage: args.profileImage },
+ *   args.address,
+ *   args.privateKey
+ * ], 'Profile updated successfully');
+ */
+export declare function createBooleanHandler(sdkMethodName: string, argExtractor?: (args: Record<string, unknown>) => unknown | unknown[], successMessage?: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a handler with custom result transformation.
+ *
+ * Use this for handlers that need to post-process SDK results before formatting.
+ * The resultTransformer receives the raw SDK result and args, and returns the
+ * transformed data to be formatted.
+ *
+ * @param sdkMethodName - Name of the SDK method to call
+ * @param argExtractor - Optional function to extract/transform args before calling SDK method
+ * @param resultTransformer - Function to transform the SDK result before formatting
+ * @returns Handler that calls the SDK method and returns formatted transformed response
+ *
+ * @example
+ * const handler = createTransformingHandler(
+ *   'getSupportedBridgeTokens',
+ *   undefined,
+ *   (result, args) => {
+ *     if (args.chain) {
+ *       return result.tokens.filter(t => t.supportedChains.includes(args.chain));
+ *     }
+ *     return result;
+ *   }
+ * );
+ */
+export declare function createTransformingHandler<TResult, TTransformed>(sdkMethodName: string, argExtractor: ((args: Record<string, unknown>) => unknown | unknown[]) | undefined, resultTransformer: (result: TResult, args: Record<string, unknown>) => TTransformed): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a reaction handler for add/remove reaction operations.
+ *
+ * This factory handles the common pattern of reaction operations that take
+ * tokenName, messageId, and reactionType parameters. Consolidates add/remove
+ * into a single factory with operation type parameter.
+ *
+ * Note: The `operation` parameter is intentionally kept for API clarity and
+ * future extensibility (e.g., logging, metrics). The actual SDK method
+ * determines the operation semantics.
+ *
+ * @param _operation - Either 'add' or 'remove' (documents intent, used for API clarity)
+ * @param sdkMethodName - Name of the SDK method to call
+ * @returns Handler that calls the SDK method with reaction parameters
+ *
+ * @example
+ * // Create add reaction handler
+ * const handler = createReactionHandler('add', 'addContentReaction');
+ *
+ * // Create remove reaction handler
+ * const handler = createReactionHandler('remove', 'removeContentReaction');
+ *
+ * @since 5.13.0
+ */
+export declare function createReactionHandler(operation: 'add' | 'remove', sdkMethodName: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a WebSocket action handler with custom response formatting.
+ *
+ * This factory handles WebSocket operations that don't return meaningful
+ * SDK responses but need to return a custom success response.
+ *
+ * @param sdkMethodName - Name of the SDK method to call
+ * @param argExtractor - Function to extract arguments from input
+ * @param responseBuilder - Function to build the success response from args
+ * @returns Handler that calls SDK method and returns custom response
+ *
+ * @example
+ * const handler = createWebSocketActionHandler(
+ *   'sendStreamChatViaWebSocket',
+ *   (args) => [args.tokenName, args.content],
+ *   (args) => ({ sent: true, tokenName: args.tokenName, content: args.content })
+ * );
+ *
+ * @since 5.13.0
+ */
+export declare function createWebSocketActionHandler(sdkMethodName: string, argExtractor: (args: Record<string, unknown>) => unknown[], responseBuilder: (args: Record<string, unknown>) => Record<string, unknown>): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a typing indicator handler for start/stop typing operations.
+ *
+ * This factory handles the typing indicator pattern where a boolean
+ * determines which SDK method to call (sendTypingStart or sendTypingStop).
+ *
+ * Note: This handler uses synchronous SDK methods, which is why it doesn't
+ * use the shared invokeSdkMethod helper (designed for async methods).
+ *
+ * @param startMethod - SDK method name for start typing (sync method)
+ * @param stopMethod - SDK method name for stop typing (sync method)
+ * @returns Handler that calls appropriate method based on isTyping flag
+ *
+ * @example
+ * const handler = createTypingIndicatorHandler('sendTypingStart', 'sendTypingStop');
+ *
+ * @since 5.13.0
+ */
+export declare function createTypingIndicatorHandler(startMethod: string, stopMethod: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Configuration for content CRUD handler factories.
+ *
+ * These factories consolidate the common CRUD patterns found in comments,
+ * chat-messages, and similar streaming content tools.
+ */
+export interface ContentCrudConfig {
+    /**
+     * SDK method name for the list operation (e.g., 'getComments', 'getChatMessages')
+     */
+    listMethod: string;
+    /**
+     * SDK method name for the create operation (e.g., 'createComment', 'sendChatMessage')
+     */
+    createMethod: string;
+    /**
+     * SDK method name for the update operation (e.g., 'updateComment', 'updateChatMessage')
+     */
+    updateMethod: string;
+    /**
+     * SDK method name for the delete operation (e.g., 'deleteComment', 'deleteChatMessage')
+     */
+    deleteMethod: string;
+    /**
+     * Human-readable resource name for error messages (e.g., 'Comment', 'Chat message')
+     */
+    resourceName: string;
+}
+/**
+ * Creates a list handler for content with tokenName/userAddress filters and pagination.
+ *
+ * This factory handles the common pattern of listing content (comments, chat messages)
+ * with optional tokenName and/or userAddress filters plus pagination.
+ *
+ * @param sdkMethod - Name of the SDK method to call
+ * @param options - Configuration options
+ * @returns Handler that lists content with filters and pagination
+ *
+ * @example
+ * const handler = createContentListHandler('getComments', {
+ *   requireAtLeastOneFilter: true,
+ *   resourceName: 'comments'
+ * });
+ *
+ * @since 6.3.0
+ */
+export declare function createContentListHandler(sdkMethod: string, options?: {
+    /** Whether at least one of tokenName or userAddress is required */
+    requireAtLeastOneFilter?: boolean;
+    /** Resource name for error messages */
+    resourceName?: string;
+}): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a create handler for content with tokenName and content fields.
+ *
+ * This factory handles the common pattern of creating content (comments, chat messages)
+ * with tokenName and content as required fields.
+ *
+ * @param sdkMethod - Name of the SDK method to call
+ * @returns Handler that creates content
+ *
+ * @example
+ * const handler = createContentCreateHandler('createComment');
+ *
+ * @since 6.3.0
+ */
+export declare function createContentCreateHandler(sdkMethod: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates an update handler for content with id and content fields.
+ *
+ * This factory handles the common pattern of updating content (comments, chat messages)
+ * with id and content wrapped in an update object.
+ *
+ * @param sdkMethod - Name of the SDK method to call
+ * @returns Handler that updates content
+ *
+ * @example
+ * const handler = createContentUpdateHandler('updateComment');
+ *
+ * @since 6.3.0
+ */
+export declare function createContentUpdateHandler(sdkMethod: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a delete handler for content with just an id field.
+ *
+ * This factory handles the common pattern of deleting content (comments, chat messages)
+ * by id, returning a boolean success response.
+ *
+ * @param sdkMethod - Name of the SDK method to call
+ * @param successMessage - Optional custom success message
+ * @returns Handler that deletes content
+ *
+ * @example
+ * const handler = createContentDeleteHandler('deleteComment', 'Comment deleted');
+ *
+ * @since 6.3.0
+ */
+export declare function createContentDeleteHandler(sdkMethod: string, successMessage?: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates all four CRUD handlers for a content resource.
+ *
+ * Returns an object with list, create, update, and delete handlers configured
+ * for the specified SDK methods. This is a convenience factory for resources
+ * that implement the full CRUD pattern.
+ *
+ * @param config - Configuration specifying SDK methods and resource name
+ * @returns Object containing all four CRUD handlers
+ *
+ * @example
+ * const { list, create, update, delete: remove } = createContentCrudHandlers({
+ *   listMethod: 'getComments',
+ *   createMethod: 'createComment',
+ *   updateMethod: 'updateComment',
+ *   deleteMethod: 'deleteComment',
+ *   resourceName: 'Comment'
+ * });
+ *
+ * @since 6.3.0
+ */
+export declare function createContentCrudHandlers(config: ContentCrudConfig): {
+    list: (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+    create: (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+    update: (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+    delete: (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+};
+/**
+ * Configuration for streaming resource handlers.
+ *
+ * Streaming resources follow patterns like:
+ * - list: List resources for a token (paginated)
+ * - get: Get a single resource by tokenName + resourceId
+ * - delete: Delete a resource by tokenName + resourceId
+ */
+export interface StreamingResourceConfig {
+    /**
+     * SDK method name for the list operation
+     */
+    listMethod: string;
+    /**
+     * SDK method name for the get operation (optional)
+     */
+    getMethod?: string;
+    /**
+     * SDK method name for the delete operation (optional)
+     */
+    deleteMethod?: string;
+    /**
+     * Name of the resource ID field in args (e.g., 'assetId', 'targetId')
+     */
+    resourceIdField: string;
+    /**
+     * Human-readable resource name for success messages
+     */
+    resourceName: string;
+}
+/**
+ * Creates a list handler for streaming resources with tokenName and pagination.
+ *
+ * @param sdkMethod - Name of the SDK method to call
+ * @returns Handler that lists streaming resources
+ *
+ * @example
+ * const handler = createStreamingListHandler('getStreamRecordings');
+ *
+ * @since 6.3.0
+ */
+export declare function createStreamingListHandler(sdkMethod: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a get/fetch handler for streaming resources with tokenName and resourceId.
+ *
+ * @param sdkMethod - Name of the SDK method to call
+ * @param resourceIdField - Name of the resource ID field in args
+ * @returns Handler that fetches a single streaming resource
+ *
+ * @example
+ * const handler = createStreamingGetHandler('getRecordingDownload', 'assetId');
+ *
+ * @since 6.3.0
+ */
+export declare function createStreamingGetHandler(sdkMethod: string, resourceIdField: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a delete handler for streaming resources with tokenName and resourceId.
+ *
+ * @param sdkMethod - Name of the SDK method to call
+ * @param resourceIdField - Name of the resource ID field in args
+ * @param successMessage - Success message to return
+ * @returns Handler that deletes a streaming resource
+ *
+ * @example
+ * const handler = createStreamingDeleteHandler('deleteRecording', 'assetId', 'Recording deleted');
+ *
+ * @since 6.3.0
+ */
+export declare function createStreamingDeleteHandler(sdkMethod: string, resourceIdField: string, successMessage: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a handler for operations that take tokenName and userAddress.
+ *
+ * This is a common pattern for ban/moderation operations:
+ * - createBan
+ * - removeBan
+ * - getBanStatus
+ *
+ * Reduces boilerplate by providing consistent argument extraction.
+ *
+ * @param sdkMethodName - Name of the SDK method to call
+ * @param additionalExtractor - Optional function to extract additional arguments
+ * @returns Handler that calls SDK method with tokenName, userAddress, and optional extras
+ *
+ * @example
+ * // Simple case: tokenName + userAddress only
+ * const handler = createTokenUserHandler('removeBan');
+ *
+ * // With additional args
+ * const handler = createTokenUserHandler('createBan', (args) => ({
+ *   reason: args.reason as string | undefined,
+ *   durationSeconds: args.durationSeconds as number | undefined,
+ * }));
+ *
+ * @since 6.6.0
+ */
+export declare function createTokenUserHandler(sdkMethodName: string, additionalExtractor?: (args: Record<string, unknown>) => Record<string, unknown>): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a handler for no-argument async actions that return a custom response.
+ *
+ * Use this for SDK methods that take no arguments and need a custom success response.
+ * Ideal for WebSocket connection management, initialization operations, etc.
+ *
+ * @param sdkMethodName - Name of the SDK method to call (takes no arguments)
+ * @param successResponse - Static response to return on success
+ * @returns Handler that calls SDK method and returns the custom response
+ *
+ * @example
+ * const handler = createNoArgActionHandler(
+ *   'connectStreamWebSocket',
+ *   { connected: true, message: 'Connected to stream WebSocket' }
+ * );
+ *
+ * @since 6.6.0
+ */
+export declare function createNoArgActionHandler(sdkMethodName: string, successResponse: Record<string, unknown>): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Configuration for wrap/unwrap tool creation
+ */
+export interface WrapUnwrapToolConfig {
+    /** Tool name (e.g., 'gala_launchpad_wrap_token') */
+    name: string;
+    /** Tool description */
+    description: string;
+    /** SDK method to call ('wrapToken' or 'unwrapToken') */
+    sdkMethodName: 'wrapToken' | 'unwrapToken';
+}
+/**
+ * Creates a wrap or unwrap handler for cross-channel bridge operations.
+ *
+ * Both wrap and unwrap operations share identical structure:
+ * - tokenId (flexible format)
+ * - amount (decimal string)
+ * - recipient (optional)
+ * - memo (optional)
+ *
+ * The only difference is the SDK method called.
+ *
+ * @param sdkMethodName - Either 'wrapToken' or 'unwrapToken'
+ * @returns Handler for the wrap/unwrap operation
+ *
+ * @example
+ * const wrapHandler = createWrapUnwrapHandler('wrapToken');
+ * const unwrapHandler = createWrapUnwrapHandler('unwrapToken');
+ *
+ * @since 6.4.0
+ */
+export declare function createWrapUnwrapHandler(sdkMethodName: 'wrapToken' | 'unwrapToken'): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Supported external blockchain chains for balance operations.
+ */
+export type ExternalChain = 'Ethereum' | 'Solana';
+/**
+ * Configuration for external chain balance tool creation.
+ *
+ * These tools share identical patterns across Ethereum and Solana:
+ * - Token balance: symbol + optional address
+ * - Native balance: optional address only
+ * - All balances: optional address only
+ */
+export interface ExternalChainBalanceConfig {
+    /** Chain identifier */
+    chain: ExternalChain;
+    /** Chain-specific address format (for description) */
+    addressFormat: string;
+    /** Native token symbol (ETH for Ethereum, SOL for Solana) */
+    nativeSymbol: string;
+    /** Supported ERC-20/SPL token symbols */
+    tokenSymbols: string[];
+    /** Number of RPC calls for "all balances" operation */
+    allBalancesRpcCount: number;
+}
+/**
+ * Pre-configured chain settings for Ethereum and Solana.
+ * Single source of truth for chain-specific configuration.
+ */
+export declare const EXTERNAL_CHAIN_CONFIG: Record<ExternalChain, ExternalChainBalanceConfig>;
+/**
+ * Creates a token balance handler for external chains (Ethereum ERC-20, Solana SPL).
+ *
+ * Used for fetching single token balances on external chains.
+ * Takes symbol and optional address, returns token balance.
+ *
+ * @param chain - Target chain ('Ethereum' or 'Solana')
+ * @returns Handler that fetches single token balance
+ *
+ * @example
+ * const handler = createExternalTokenBalanceHandler('Ethereum');
+ * // SDK method: fetchEthereumWalletTokenBalance
+ *
+ * @since 6.5.0
+ */
+export declare function createExternalTokenBalanceHandler(chain: ExternalChain): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a native balance handler for external chains (ETH, SOL).
+ *
+ * Used for fetching native currency balance on external chains.
+ * Takes optional address, returns native balance.
+ *
+ * @param chain - Target chain ('Ethereum' or 'Solana')
+ * @returns Handler that fetches native currency balance
+ *
+ * @example
+ * const handler = createExternalNativeBalanceHandler('Solana');
+ * // SDK method: fetchSolanaWalletNativeBalance
+ *
+ * @since 6.5.0
+ */
+export declare function createExternalNativeBalanceHandler(chain: ExternalChain): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates an all-balances handler for external chains.
+ *
+ * Used for fetching all supported token balances on external chains.
+ * Takes optional address, returns native + all supported token balances.
+ *
+ * @param chain - Target chain ('Ethereum' or 'Solana')
+ * @returns Handler that fetches all balances
+ *
+ * @example
+ * const handler = createExternalAllBalancesHandler('Ethereum');
+ * // SDK method: fetchEthereumWalletAllBalances
+ *
+ * @since 6.5.0
+ */
+export declare function createExternalAllBalancesHandler(chain: ExternalChain): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Field definition for generic argument extraction.
+ *
+ * Specifies how to extract and type a single field from MCP args.
+ *
+ * @since 6.11.0
+ */
+export interface FieldDefinition {
+    /** The field name in MCP args */
+    name: string;
+    /** Whether the field is required (default: false, meaning undefined allowed) */
+    required?: boolean;
+}
+/**
+ * Creates a type-safe argument extractor function from field definitions.
+ *
+ * This factory eliminates repetitive argument extraction patterns like:
+ * ```typescript
+ * // Before (repeated many times)
+ * function extractFooArgs(args: Record<string, unknown>): FooArgs {
+ *   return {
+ *     page: args.page as number | undefined,
+ *     limit: args.limit as number | undefined,
+ *   };
+ * }
+ *
+ * // After
+ * const extractFooArgs = createArgumentExtractor<FooArgs>(['page', 'limit']);
+ * ```
+ *
+ * @param fields - Array of field names to extract (strings or FieldDefinition objects)
+ * @returns Function that extracts specified fields from MCP args with proper typing
+ *
+ * @example
+ * // Simple field names (all optional)
+ * const extractPaginationArgs = createArgumentExtractor<PaginationArgs>(['page', 'limit']);
+ *
+ * @example
+ * // Mixed required/optional
+ * const extractTransferArgs = createArgumentExtractor<TransferArgs>([
+ *   { name: 'recipientAddress', required: true },
+ *   { name: 'amount', required: true },
+ *   'uniqueKey',  // optional
+ *   'privateKey', // optional
+ * ]);
+ *
+ * @since 6.11.0
+ */
+export declare function createArgumentExtractor<T>(fields: (string | FieldDefinition)[]): (args: Record<string, unknown>) => T;
+/**
+ * Standard pagination parameters extracted from MCP tool args.
+ *
+ * Used by list/query operations that support page-based pagination.
+ *
+ * @since 6.7.0
+ */
+export interface PaginationArgs {
+    page: number | undefined;
+    limit: number | undefined;
+}
+/**
+ * Offset-based pagination parameters for bridgeable/wrappable token queries.
+ *
+ * @since 6.7.0
+ */
+export interface OffsetPaginationArgs {
+    offset: number | undefined;
+    limit: number | undefined;
+}
+/**
+ * Common filter parameters for list operations with search capabilities.
+ *
+ * @since 6.7.0
+ */
+export interface SearchFilterArgs {
+    search: string | undefined;
+    name: string | undefined;
+    userAddress: string | undefined;
+}
+/**
+ * Extracts standard page/limit pagination from MCP args.
+ *
+ * Use this helper to avoid repetitive casting in list handlers.
+ *
+ * @param args - MCP tool arguments
+ * @returns Typed pagination object with page and limit
+ *
+ * @example
+ * handler: createSimpleHandler('listItems', (args) => ({
+ *   tokenName: args.tokenName as string,
+ *   ...extractPaginationArgs(args),
+ * })),
+ *
+ * @since 6.7.0
+ */
+export declare const extractPaginationArgs: (args: Record<string, unknown>) => PaginationArgs;
+/**
+ * Creates a handler for SDK methods that take an optional wallet address.
+ *
+ * Consolidates the common pattern where an SDK method accepts an optional
+ * address parameter that defaults to the SDK's configured wallet.
+ *
+ * @param sdkMethodName - Name of the SDK method to call
+ * @returns Handler that fetches data with optional address
+ *
+ * @example
+ * // For fetchGalaBalance, fetchProfile
+ * const handler = createOptionalAddressFetcher('fetchGalaBalance');
+ *
+ * @since 6.8.0
+ */
+export declare function createOptionalAddressFetcher(sdkMethodName: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a handler for SDK methods that take tokenName and address parameters.
+ *
+ * Consolidates the common pattern for balance queries that need both
+ * a token identifier and a wallet address.
+ *
+ * @param sdkMethodName - Name of the SDK method to call
+ * @returns Handler that fetches token-specific data for an address
+ *
+ * @example
+ * // For fetchTokenBalance
+ * const handler = createTokenAddressHandler('fetchTokenBalance');
+ *
+ * @since 6.8.0
+ */
+export declare function createTokenAddressHandler(sdkMethodName: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Extracts offset/limit pagination from MCP args.
+ *
+ * Used for bridgeable token queries that use offset-based pagination.
+ *
+ * @param args - MCP tool arguments
+ * @returns Typed pagination object with offset and limit
+ *
+ * @example
+ * handler: createSimpleHandler('fetchTokens', (args) => ({
+ *   network: args.network as string,
+ *   ...extractOffsetPaginationArgs(args),
+ * })),
+ *
+ * @since 6.7.0
+ */
+export declare const extractOffsetPaginationArgs: (args: Record<string, unknown>) => OffsetPaginationArgs;
+/**
+ * Extracts common search/filter parameters from MCP args.
+ *
+ * Used for list operations that support search, name, and userAddress filters.
+ *
+ * @param args - MCP tool arguments
+ * @returns Typed filter object
+ *
+ * @example
+ * handler: createSimpleHandler('listBans', (args) => ({
+ *   tokenName: args.tokenName as string,
+ *   ...extractPaginationArgs(args),
+ *   ...extractSearchFilterArgs(args),
+ * })),
+ *
+ * @since 6.7.0
+ */
+export declare const extractSearchFilterArgs: (args: Record<string, unknown>) => SearchFilterArgs;
+/**
+ * Extracts status filter with typed union constraint.
+ *
+ * @param args - MCP tool arguments
+ * @returns Status string or undefined
+ *
+ * @example
+ * handler: createSimpleHandler('listInvites', (args) => ({
+ *   ...extractPaginationArgs(args),
+ *   status: extractStatusArg<'PENDING' | 'CLAIMED' | 'REVOKED' | 'EXPIRED'>(args),
+ * })),
+ *
+ * @since 6.7.0
+ */
+export declare function extractStatusArg<T extends string>(args: Record<string, unknown>): T | undefined;
+/**
+ * Creates a handler for paginated list operations with common patterns.
+ *
+ * This factory reduces boilerplate for handlers that:
+ * - Require tokenName (optional or required)
+ * - Use page/limit pagination
+ * - Optionally include status filter
+ *
+ * @param sdkMethodName - Name of the SDK method to call
+ * @param options - Configuration options
+ * @returns Handler that calls SDK method with extracted args
+ *
+ * @example
+ * const handler = createPaginatedListHandler('listModeratorInvites', {
+ *   tokenNameRequired: false,
+ *   includeStatus: true,
+ * });
+ *
+ * @since 6.7.0
+ */
+export declare function createPaginatedListHandler<TStatus extends string = string>(sdkMethodName: string, options?: {
+    /** Whether tokenName is required (true) or optional (false) */
+    tokenNameRequired?: boolean;
+    /** Whether to include status filter in args */
+    includeStatus?: boolean;
+}): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Common arguments for batch token operations (lock, unlock).
+ */
+interface BatchTokenOperationArgs {
+    tokens: Array<{
+        tokenName: string;
+        amount: string;
+    }>;
+    uniqueKey: string | undefined;
+    privateKey: string | undefined;
+}
+/**
+ * Extracts common batch token operation args from MCP tool args.
+ *
+ * Used by lockTokens and unlockTokens which share identical argument patterns.
+ *
+ * @param args - MCP tool arguments
+ * @returns Typed batch operation arguments
+ *
+ * @since 6.8.0
+ */
+export declare const extractBatchTokenOperationArgs: (args: Record<string, unknown>) => BatchTokenOperationArgs;
+/**
+ * Creates a handler for batch token operations (lock, unlock).
+ *
+ * Consolidates the common pattern for operations that batch multiple
+ * token amounts with optional uniqueKey and privateKey.
+ *
+ * @param sdkMethodName - Name of the SDK method to call ('lockTokens' or 'unlockTokens')
+ * @returns Handler that processes batch token operations
+ *
+ * @example
+ * const lockHandler = createBatchTokenOperationHandler('lockTokens');
+ * const unlockHandler = createBatchTokenOperationHandler('unlockTokens');
+ *
+ * @since 6.8.0
+ */
+export declare function createBatchTokenOperationHandler(sdkMethodName: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Common base arguments shared by all transfer operations.
+ *
+ * @since 6.11.0
+ */
+interface BaseTransferArgs {
+    amount: string;
+    uniqueKey: string | undefined;
+    privateKey: string | undefined;
+}
+/**
+ * Arguments for GALA transfer operations (uses recipientAddress).
+ */
+interface TransferArgs extends BaseTransferArgs {
+    recipientAddress: string;
+}
+/**
+ * Arguments for token transfer operations (uses 'to' and tokenName).
+ */
+interface TokenTransferArgs extends BaseTransferArgs {
+    to: string;
+    tokenName: string;
+}
+/**
+ * Extracts GALA transfer args from MCP tool args.
+ *
+ * Used by transferGala which uses recipientAddress.
+ *
+ * @param args - MCP tool arguments
+ * @returns Typed transfer arguments
+ *
+ * @since 6.8.0
+ */
+export declare function extractTransferArgs(args: Record<string, unknown>): TransferArgs;
+/**
+ * Extracts token transfer args from MCP tool args.
+ *
+ * Used by transferToken which uses 'to' and tokenName.
+ *
+ * @param args - MCP tool arguments
+ * @returns Typed token transfer arguments
+ *
+ * @since 6.8.0
+ */
+export declare function extractTokenTransferArgs(args: Record<string, unknown>): TokenTransferArgs;
+/**
+ * Creates a handler for GALA transfer operations.
+ *
+ * Consolidates the GALA transfer pattern which uses recipientAddress.
+ *
+ * @returns Handler that processes GALA transfers
+ *
+ * @example
+ * const handler = createGalaTransferHandler();
+ *
+ * @since 6.8.0
+ */
+export declare function createGalaTransferHandler(): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a handler for token transfer operations.
+ *
+ * Consolidates the token transfer pattern which uses 'to' and tokenName.
+ *
+ * @returns Handler that processes token transfers
+ *
+ * @example
+ * const handler = createTokenTransferHandler();
+ *
+ * @since 6.8.0
+ */
+export declare function createTokenTransferHandler(): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a fetcher handler for SDK methods that take tokenName as the sole argument.
+ *
+ * This is a specialized version of createConvenienceFetcher that eliminates the
+ * repetitive pattern: `(args) => args.tokenName as string`
+ *
+ * Common in streaming/chat status tools:
+ * - getChatStatus
+ * - getStreamInfo
+ * - getSimulcastTargets
+ * - resetStreamKey
+ *
+ * @param sdkMethod - Name of the SDK method that accepts tokenName
+ * @returns Handler that calls SDK method with tokenName extracted from args
+ *
+ * @example
+ * // Before (repetitive)
+ * handler: createConvenienceFetcher('getChatStatus', (args) => args.tokenName as string),
+ * handler: createConvenienceFetcher('getStreamInfo', (args) => args.tokenName as string),
+ *
+ * // After (DRY)
+ * handler: createTokenNameFetcher('getChatStatus'),
+ * handler: createTokenNameFetcher('getStreamInfo'),
+ *
+ * @since 6.8.0
+ */
+export declare function createTokenNameFetcher(sdkMethod: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a simple handler for SDK methods that take tokenName as the sole argument.
+ *
+ * Similar to createTokenNameFetcher but uses createSimpleHandler internally.
+ * Use this for write operations that take only tokenName.
+ *
+ * @param sdkMethod - Name of the SDK method that accepts tokenName
+ * @returns Handler that calls SDK method with tokenName extracted from args
+ *
+ * @example
+ * // Before (repetitive)
+ * handler: createSimpleHandler('startStream', (args) => args.tokenName as string),
+ *
+ * // After (DRY)
+ * handler: createTokenNameHandler('startStream'),
+ *
+ * @since 6.8.0
+ */
+export declare function createTokenNameHandler(sdkMethod: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a boolean handler for SDK methods that take tokenName and return success.
+ *
+ * Combines tokenName extraction with boolean success response.
+ * Use for operations like stopStream that return { success: true }.
+ *
+ * @param sdkMethod - Name of the SDK method that accepts tokenName
+ * @param successMessage - Success message to return
+ * @returns Handler that calls SDK method and returns boolean success
+ *
+ * @example
+ * // Before
+ * handler: createBooleanHandler('stopStream', (args) => args.tokenName as string, 'Stream stopped'),
+ *
+ * // After
+ * handler: createTokenNameBooleanHandler('stopStream', 'Stream stopped'),
+ *
+ * @since 6.8.0
+ */
+export declare function createTokenNameBooleanHandler(sdkMethod: string, successMessage: string): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a handler that calls an SDK method and builds a response with custom message.
+ *
+ * Use this for handlers that need to format a response with an interpolated message
+ * based on the SDK result. This is a common pattern in pool info, quote, and
+ * position query tools.
+ *
+ * @param sdkMethodName - Name of the SDK method to call
+ * @param argExtractor - Function to extract arguments from MCP args
+ * @param responseBuilder - Function to build the response object from SDK result
+ * @returns Handler that calls SDK method and returns custom formatted response
+ *
+ * @example
+ * const handler = createCustomMessageHandler(
+ *   'getSwapPoolInfo',
+ *   (args) => [args.tokenA as string, args.tokenB as string],
+ *   (result, args) => ({
+ *     ...result,
+ *     message: `Pool ${args.tokenA}/${args.tokenB} has ${result.liquidity} liquidity`,
+ *   })
+ * );
+ *
+ * @since 6.9.0
+ */
+export declare function createCustomMessageHandler<TResult, TResponse extends Record<string, unknown>>(sdkMethodName: string, argExtractor: (args: Record<string, unknown>) => unknown | unknown[], responseBuilder: (result: TResult, args: Record<string, unknown>) => TResponse): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a handler that validates wallet configuration before calling SDK method.
+ *
+ * Use this for write operations that require a configured wallet (swaps, liquidity
+ * add/remove, transfers, etc.). Fails fast with helpful error if wallet not configured.
+ *
+ * @param sdkMethodName - Name of the SDK method to call
+ * @param argExtractor - Function to extract arguments from MCP args
+ * @param responseBuilder - Optional function to build custom response (defaults to result)
+ * @param walletValidator - Optional custom wallet validation function
+ * @returns Handler that validates wallet then calls SDK method
+ *
+ * @example
+ * const handler = createWalletRequiredHandler(
+ *   'executeSwap',
+ *   (args) => [args.fromToken, args.toToken, args.amount, args.estimatedOutput, args.feeTier, args.slippageTolerance || 0.01],
+ *   (result) => ({ ...result, message: `Swap completed!` })
+ * );
+ *
+ * @since 6.9.0
+ */
+export declare function createWalletRequiredHandler<TResult, TResponse extends Record<string, unknown> = Record<string, unknown>>(sdkMethodName: string, argExtractor: (args: Record<string, unknown>) => unknown | unknown[], responseBuilder?: (result: TResult, args: Record<string, unknown>) => TResponse, walletValidator?: (sdk: LaunchpadSDK) => void): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a handler that returns found: false response if SDK result is null/undefined.
+ *
+ * Use this for position lookups and resource queries that may return null when
+ * the resource doesn't exist. Provides consistent not-found responses.
+ *
+ * @param sdkMethodName - Name of the SDK method to call
+ * @param argExtractor - Function to extract arguments from MCP args
+ * @param notFoundBuilder - Function to build not-found response (receives args)
+ * @param foundBuilder - Function to build found response (receives result and args)
+ * @returns Handler with conditional found/not-found response
+ *
+ * @example
+ * const handler = createNotFoundHandler(
+ *   'getSwapLiquidityPositionById',
+ *   (args) => [args.ownerAddress, args.positionId],
+ *   (args) => ({ found: false, message: `Position ${args.positionId} not found` }),
+ *   (result, args) => ({ found: true, ...result, message: `Found position ${args.positionId}` })
+ * );
+ *
+ * @since 6.9.0
+ */
+export declare function createNotFoundHandler<TResult, TNotFound extends Record<string, unknown>, TFound extends Record<string, unknown>>(sdkMethodName: string, argExtractor: (args: Record<string, unknown>) => unknown | unknown[], notFoundBuilder: (args: Record<string, unknown>) => TNotFound, foundBuilder: (result: TResult, args: Record<string, unknown>) => TFound): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a handler for no-argument SDK methods with custom response formatting.
+ *
+ * Unlike createNoArgActionHandler which returns a static response, this factory
+ * allows building the response from the SDK result. Useful for session info,
+ * status queries, and other async methods that return data.
+ *
+ * @param sdkMethodName - Name of the SDK method to call (takes no arguments)
+ * @param responseBuilder - Function to build response from SDK result
+ * @returns Handler that calls SDK method and formats response
+ *
+ * @example
+ * const handler = createNoArgResultHandler(
+ *   'getSession',
+ *   (session) => ({
+ *     address: session.address,
+ *     expiresAt: session.expiresAt,
+ *     message: `Session for ${session.address}, expires ${new Date(session.expiresAt).toISOString()}`,
+ *   })
+ * );
+ *
+ * @since 6.9.0
+ */
+export declare function createNoArgResultHandler<TResult, TResponse extends Record<string, unknown>>(sdkMethodName: string, responseBuilder: (result: TResult) => TResponse): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Creates a handler for synchronous SDK methods that return boolean with conditional messages.
+ *
+ * Use for sync methods like isAuthenticated(), shouldRefreshToken() that need
+ * different messages based on the boolean result.
+ *
+ * @param syncMethodName - Name of the sync SDK method to call
+ * @param argExtractor - Optional function to extract arguments from MCP args
+ * @param messages - Object with true and false message strings
+ * @returns Handler that calls sync method and returns formatted boolean response
+ *
+ * @example
+ * const handler = createSyncBooleanHandler(
+ *   'isAuthenticated',
+ *   undefined,
+ *   { true: 'Session is valid', false: 'Not authenticated or token expired' }
+ * );
+ *
+ * @since 6.9.0
+ */
+export declare function createSyncBooleanHandler(syncMethodName: string, argExtractor: ((args: Record<string, unknown>) => unknown) | undefined, messages: {
+    true: string;
+    false: string;
+}): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Flexible token identifier extracted from MCP args.
+ *
+ * Returns either tokenName OR tokenId based on which was provided.
+ * Mutual exclusivity validation happens in the SDK.
+ *
+ * @since 6.10.0
+ */
+export interface FlexibleTokenId {
+    tokenName?: string;
+    tokenId?: unknown;
+}
+/**
+ * Extracts flexible token identifier from MCP args.
+ *
+ * Handles the common pattern where tools accept either tokenName (convenience)
+ * or tokenId (full identifier), but not both. Returns an object with the
+ * appropriate property set based on which was provided.
+ *
+ * Pattern replaced:
+ * ```typescript
+ * // Before (repeated 6+ times)
+ * if (args.tokenName) {
+ *   options.tokenName = args.tokenName;
+ * } else {
+ *   options.tokenId = args.tokenId;
+ * }
+ *
+ * // After
+ * const tokenId = extractFlexibleTokenId(args);
+ * const options = { ...tokenId, ...otherOptions };
+ * ```
+ *
+ * @param args - MCP tool arguments containing tokenName and/or tokenId
+ * @returns Object with either tokenName or tokenId property set
+ *
+ * @example
+ * // In fetchPriceHistory handler:
+ * handler: createSimpleHandler('fetchPriceHistory', (args) => ({
+ *   ...extractFlexibleTokenId(args),
+ *   sortOrder: args.sortOrder,
+ *   page: args.page,
+ *   limit: args.limit,
+ * })),
+ *
+ * @since 6.10.0
+ */
+export declare function extractFlexibleTokenId(args: Record<string, unknown>): FlexibleTokenId;
+/**
+ * Creates a handler for SDK methods that may return null with different success responses.
+ *
+ * Use for methods like getAccessToken() that return null when not authenticated,
+ * requiring different response structures for null vs non-null results.
+ *
+ * @param sdkMethodName - Name of the SDK method to call (sync or async)
+ * @param nullResponse - Response to return when result is null/undefined
+ * @param valueBuilder - Function to build response when result has value
+ * @param isSync - Whether the SDK method is synchronous (default: false)
+ * @returns Handler with conditional null/value responses
+ *
+ * @example
+ * const handler = createConditionalResponseHandler(
+ *   'getAccessToken',
+ *   { accessToken: null, message: 'Not authenticated - no token available' },
+ *   (token) => ({ accessToken: token, message: 'Access token retrieved' }),
+ *   true // sync method
+ * );
+ *
+ * @since 6.9.0
+ */
+export declare function createConditionalResponseHandler<TResult, TNullResponse extends Record<string, unknown>, TValueResponse extends Record<string, unknown>>(sdkMethodName: string, nullResponse: TNullResponse, valueBuilder: (result: TResult) => TValueResponse, isSync?: boolean): (sdk: LaunchpadSDK, args: Record<string, unknown>) => Promise<MCPToolResponse>;
+/**
+ * Standard authentication requirement descriptions for MCP tool definitions.
+ *
+ * Provides consistent, reusable auth requirement strings to eliminate
+ * repetitive boilerplate in tool descriptions.
+ *
+ * @example
+ * description: `Get chat status for a stream.
+ *
+ * ${AUTH_DESCRIPTIONS.PUBLIC}`,
+ *
+ * @example
+ * description: `Start a stream.
+ *
+ * ${AUTH_DESCRIPTIONS.JWT_SESSION}`,
+ *
+ * @since 6.8.0
+ */
+export declare const AUTH_DESCRIPTIONS: {
+    /** No authentication required */
+    readonly PUBLIC: "Authentication: None required (public endpoint)";
+    /** Requires JWT session (login first) */
+    readonly JWT_SESSION: "Authentication: Requires JWT session (call gala_launchpad_login first)";
+    /** Requires wallet signature */
+    readonly WALLET_SIGNATURE: "Authentication: Requires wallet signature";
+    /** Requires stream admin API key */
+    readonly ADMIN_API_KEY: "Authentication: Requires streamAdminApiKey configuration";
+    /** Requires admin API key OR JWT as token owner */
+    readonly ADMIN_OR_OWNER: "Authentication: Requires streamAdminApiKey (admin) OR JWT auth (token owner)";
+    /** Requires admin API key OR JWT as moderator */
+    readonly ADMIN_OR_MODERATOR: "Authentication: Requires streamAdminApiKey (admin) OR JWT auth (token owner/moderator)";
+    /** Requires admin API key OR JWT as overseer */
+    readonly ADMIN_OR_OVERSEER: "Authentication: Requires streamAdminApiKey (admin) OR JWT auth as Overseer";
+    /** Requires admin API key OR JWT as existing overseer */
+    readonly ADMIN_OR_EXISTING_OVERSEER: "Authentication: Requires streamAdminApiKey (admin) OR JWT auth as existing Overseer";
+    /** Stream creator only (wallet signature) */
+    readonly STREAM_CREATOR: "Authentication: Requires wallet signature (stream creator only)";
+    /** Optional JWT - returns null/limited if not authenticated */
+    readonly OPTIONAL_JWT: "Authentication: Optional JWT - returns limited data if not authenticated";
+    /** Requires JWT or API key with specific permission */
+    readonly JWT_OR_API_KEY: (permission: string) => string;
+};
+/**
+ * Creates a handler for SDK methods that return optional results (null/undefined if not found).
+ *
+ * Use this for resource lookup operations where not finding the resource is a valid
+ * outcome (not an error). Returns a consistent { found: false } response when
+ * the resource doesn't exist, and { found: true, data: result } when it does.
+ *
+ * @param sdkMethod - Function that calls the SDK method with sdk and args
+ * @param notFoundMessage - Message to return when resource is not found (default: 'Resource not found')
+ * @returns Handler with consistent found/not-found response structure
+ *
+ * @example
+ * const handler = createOptionResultHandler(
+ *   (sdk, args) => sdk.getSwapLiquidityPositionById(args.ownerAddress, args.positionId),
+ *   'Position not found'
+ * );
+ *
+ * @since 6.12.0
+ */
+export declare function createOptionResultHandler<T extends Record<string, unknown>>(sdkMethod: (sdk: LaunchpadSDK, args: T) => Promise<unknown | null | undefined>, notFoundMessage?: string): (sdk: LaunchpadSDK, args: T) => Promise<MCPToolResponse>;
+/**
+ * Creates a handler for SDK methods requiring wallet validation with optional result transformation.
+ *
+ * This is a simplified version of createWalletRequiredHandler that takes the SDK method
+ * directly (as a function) rather than a method name string. Useful for cases where
+ * you need direct SDK method calls with type safety.
+ *
+ * @param sdkMethod - Function that calls the SDK method with sdk and args
+ * @param transformer - Optional function to transform the result before returning
+ * @returns Handler that validates wallet then calls SDK method
+ *
+ * @example
+ * const handler = createWalletRequiredMethodHandler(
+ *   (sdk, args) => sdk.addSwapLiquidityByPrice({
+ *     token0: args.token0, token1: args.token1, fee: args.fee,
+ *     minPrice: args.minPrice, maxPrice: args.maxPrice,
+ *     amount0Desired: args.amount0Desired, amount1Desired: args.amount1Desired,
+ *   }),
+ *   (result) => ({ ...result, message: 'Liquidity added!' })
+ * );
+ *
+ * @since 6.12.0
+ */
+export declare function createWalletRequiredMethodHandler<T extends Record<string, unknown>, R>(sdkMethod: (sdk: LaunchpadSDK, args: T) => Promise<R>, transformer?: (result: R) => unknown): (sdk: LaunchpadSDK, args: T) => Promise<MCPToolResponse>;
+/**
+ * Creates a handler for SDK methods that accept optional parameter objects.
+ *
+ * This factory handles the common pattern where an SDK method takes an optional
+ * params object, and you want to build those params from the MCP args.
+ *
+ * @param sdkMethod - Function that calls the SDK method with sdk and optional params
+ * @param paramBuilder - Optional function to build params from args (if omitted, passes args directly)
+ * @param resultTransformer - Optional function to transform the result before returning
+ * @returns Handler that builds params and calls SDK method
+ *
+ * @example
+ * const handler = createOptionalParamsHandler(
+ *   (sdk, params) => sdk.getAllSwapUserLiquidityPositions(params?.ownerAddress, params?.options),
+ *   (args) => ({
+ *     ownerAddress: args.ownerAddress,
+ *     options: args.withPrices ? { withPrices: true } : undefined,
+ *   }),
+ *   (result, args) => formatPositionListResponse(parsePositionListResult(result), { ownerAddress: args.ownerAddress })
+ * );
+ *
+ * @since 6.12.0
+ */
+export declare function createOptionalParamsHandler<T extends Record<string, unknown>, R>(sdkMethod: (sdk: LaunchpadSDK, params?: Partial<T>) => Promise<R>, paramBuilder?: (args: T) => Partial<T>, resultTransformer?: (result: R, args: T) => unknown): (sdk: LaunchpadSDK, args: T) => Promise<MCPToolResponse>;
+/**
+ * Liquidity position data fetched from SDK, used for enriching operation responses.
+ *
+ * @since 6.14.0
+ */
+export interface PositionData {
+    token0: string;
+    token1: string;
+    feeTier: number;
+    tickLower: number;
+    tickUpper: number;
+}
+/**
+ * Standard result from liquidity position operations (remove, collect fees).
+ *
+ * @since 6.14.0
+ */
+export interface PositionOperationResult {
+    transactionId: string;
+    status?: string;
+    amount0?: string;
+    amount1?: string;
+}
+/**
+ * Configuration for position enrichment handler factory.
+ *
+ * @since 6.14.0
+ */
+export interface PositionEnrichmentConfig<TArgs extends Record<string, unknown>, TResult extends PositionOperationResult> {
+    /**
+     * Function that calls the SDK operation method with position data and args.
+     * Receives the fetched position (with token pair info) and the original args.
+     */
+    operation: (sdk: LaunchpadSDK, position: PositionData, args: TArgs) => Promise<TResult>;
+    /**
+     * Function to build the enriched response from the operation result and position.
+     */
+    responseBuilder: (result: TResult, position: PositionData, args: TArgs) => Record<string, unknown>;
+}
+/**
+ * Creates a handler for liquidity position operations that require pre-fetching position details.
+ *
+ * This factory consolidates the common pattern found in removeLiquidity and collectPositionFees:
+ * 1. Validate wallet configured
+ * 2. Extract ownerAddress and positionId from args
+ * 3. Fetch position details via getSwapLiquidityPositionById
+ * 4. Validate position exists
+ * 5. Call the SDK operation with position data
+ * 6. Return enriched response with position token info
+ *
+ * Pattern replaced:
+ * ```typescript
+ * // Before (40+ lines duplicated in 2 handlers)
+ * handler: withErrorHandling(async (sdk, args) => {
+ *   validateWalletConfigured(sdk);
+ *   const ownerAddress = args.ownerAddress as string;
+ *   const positionId = args.positionId as string;
+ *   const position = await sdk.getSwapLiquidityPositionById(ownerAddress, positionId);
+ *   if (!position) throw new Error(`Position ${positionId} not found...`);
+ *   const result = await sdk.someOperation({...});
+ *   return formatSuccess({ transactionId: result.transactionId, token0: position.token0, ... });
+ * })
+ *
+ * // After
+ * handler: createPositionEnrichmentHandler({
+ *   operation: (sdk, position, args) => sdk.removeSwapLiquidity({
+ *     token0: position.token0, token1: position.token1, ...args,
+ *   }),
+ *   responseBuilder: (result, position, args) => ({
+ *     transactionId: result.transactionId,
+ *     token0: position.token0,
+ *     message: `Liquidity removed! Received ${result.amount0} ${position.token0}...`,
+ *   })
+ * })
+ * ```
+ *
+ * @param config - Configuration specifying the SDK operation and response builder
+ * @returns Handler that pre-fetches position, calls operation, and returns enriched response
+ *
+ * @example
+ * // Remove liquidity handler
+ * const handler = createPositionEnrichmentHandler({
+ *   operation: (sdk, position, args) => sdk.removeSwapLiquidity({
+ *     token0: position.token0,
+ *     token1: position.token1,
+ *     fee: position.feeTier,
+ *     tickLower: position.tickLower,
+ *     tickUpper: position.tickUpper,
+ *     liquidity: args.liquidity,
+ *     amount0Min: args.amount0Min,
+ *     amount1Min: args.amount1Min,
+ *     positionId: args.positionId,
+ *   }),
+ *   responseBuilder: (result, position, args) => ({
+ *     transactionId: result.transactionId,
+ *     status: result.status,
+ *     positionId: args.positionId,
+ *     token0: position.token0,
+ *     token1: position.token1,
+ *     amount0: result.amount0,
+ *     amount1: result.amount1,
+ *     message: `Liquidity removed! Received ${result.amount0} ${position.token0} and ${result.amount1} ${position.token1}`,
+ *   })
+ * });
+ *
+ * @since 6.14.0
+ */
+export declare function createPositionEnrichmentHandler<TArgs extends Record<string, unknown>, TResult extends PositionOperationResult>(config: PositionEnrichmentConfig<TArgs, TResult>): (sdk: LaunchpadSDK, args: TArgs) => Promise<MCPToolResponse>;
+export {};
+//# sourceMappingURL=handler-factories.d.ts.map