HashPilot

Instructions

Implementation Reference

• src/tools/composite.ts:19-147 (handler)

  Main handler function for 'token_manage' tool. Dispatches to specific tokenTools functions based on the 'operation' parameter (e.g., create, associate, transfer).

  export async function tokenManage(args: {
    operation: 'create' | 'associate' | 'transfer' | 'mint' | 'burn' | 'freeze' | 'unfreeze' | 'kyc_grant' | 'kyc_revoke' | 'wipe' | 'pause' | 'unpause';
    // Common parameters
    tokenId?: string;
    accountId?: string;
    amount?: number;
    // Create-specific
    name?: string;
    symbol?: string;
    decimals?: number;
    initialSupply?: number;
    adminKey?: boolean;
    kycKey?: boolean;
    freezeKey?: boolean;
    wipeKey?: boolean;
    supplyKey?: boolean;
    pauseKey?: boolean;
    memo?: string;
    customFees?: any[];
    // Transfer-specific
    from?: string;
    to?: string;
    senderPrivateKey?: string;
    // Associate-specific
    privateKey?: string;
  }): Promise<ToolResult> {
    try {
      logger.info('Token management operation', { operation: args.operation });
  
      switch (args.operation) {
        case 'create':
          return await tokenTools.createToken({
            name: args.name!,
            symbol: args.symbol!,
            decimals: args.decimals,
            initialSupply: args.initialSupply,
            adminKey: args.adminKey,
            kycKey: args.kycKey,
            freezeKey: args.freezeKey,
            wipeKey: args.wipeKey,
            supplyKey: args.supplyKey,
            pauseKey: args.pauseKey,
            memo: args.memo,
            customFees: args.customFees,
          });
  
        case 'associate':
          return await tokenTools.associateToken({
            accountId: args.accountId!,
            tokenId: args.tokenId!,
            privateKey: args.privateKey,
          });
  
        case 'transfer':
          return await tokenTools.transferToken({
            tokenId: args.tokenId!,
            from: args.from!,
            to: args.to!,
            amount: args.amount!,
            senderPrivateKey: args.senderPrivateKey,
          });
  
        case 'mint':
          return await tokenTools.mintToken({
            tokenId: args.tokenId!,
            amount: args.amount!,
          });
  
        case 'burn':
          return await tokenTools.burnToken({
            tokenId: args.tokenId!,
            amount: args.amount!,
          });
  
        case 'freeze':
          return await tokenTools.freezeToken({
            tokenId: args.tokenId!,
            accountId: args.accountId!,
          });
  
        case 'unfreeze':
          return await tokenTools.unfreezeToken({
            tokenId: args.tokenId!,
            accountId: args.accountId!,
          });
  
        case 'kyc_grant':
          return await tokenTools.grantKyc({
            tokenId: args.tokenId!,
            accountId: args.accountId!,
          });
  
        case 'kyc_revoke':
          return await tokenTools.revokeKyc({
            tokenId: args.tokenId!,
            accountId: args.accountId!,
          });
  
        case 'wipe':
          return await tokenTools.wipeToken({
            tokenId: args.tokenId!,
            accountId: args.accountId!,
            amount: args.amount!,
          });
  
        case 'pause':
          return await tokenTools.pauseToken({
            tokenId: args.tokenId!,
          });
  
        case 'unpause':
          return await tokenTools.unpauseToken({
            tokenId: args.tokenId!,
          });
  
        default:
          return {
            success: false,
            error: `Unknown token operation: ${args.operation}`,
          };
      }
    } catch (error) {
      logger.error('Token management failed', { operation: args.operation, error });
      return {
        success: false,
        error: error instanceof Error ? error.message : 'Unknown error',
      };
    }
  }

• src/tools/composite.ts:372-465 (schema)

  Tool schema definition for 'token_manage', including detailed description, input schema with all parameters and enums for operations.

    {
      name: 'token_manage',
      description: `Comprehensive Hedera Token Service (HTS) management. Execute ANY token operation through a single unified interface.
  
  OPERATIONS:
  - create: Create new fungible token with custom fees, keys, and supply controls
  - associate: Associate token with account (required before receiving tokens)
  - transfer: Transfer tokens between accounts
  - mint: Mint additional tokens (requires supply key)
  - burn: Burn tokens from treasury
  - freeze/unfreeze: Control account's ability to transfer specific token
  - kyc_grant/kyc_revoke: Manage KYC status for regulated tokens
  - wipe: Remove tokens from account (requires wipe key)
  - pause/unpause: Halt/resume all token operations globally
  
  USE THIS FOR: All token lifecycle management, compliance operations, supply control, and transfer operations.
  
  REQUIRES: Operator account with appropriate keys (admin/supply/freeze/kyc/wipe/pause) based on operation.`,
      inputSchema: {
        type: 'object' as const,
        properties: {
          operation: {
            type: 'string',
            enum: ['create', 'associate', 'transfer', 'mint', 'burn', 'freeze', 'unfreeze', 'kyc_grant', 'kyc_revoke', 'wipe', 'pause', 'unpause'],
            description: 'Token operation to perform',
          },
          tokenId: {
            type: 'string',
            description: 'Token ID (format: 0.0.xxxxx) - required for all ops except create',
          },
          accountId: {
            type: 'string',
            description: 'Target account ID - for associate/freeze/unfreeze/kyc/wipe',
          },
          amount: {
            type: 'number',
            description: 'Amount for transfer/mint/burn/wipe operations',
          },
          name: {
            type: 'string',
            description: 'Token name (for create)',
          },
          symbol: {
            type: 'string',
            description: 'Token symbol (for create)',
          },
          decimals: {
            type: 'number',
            description: 'Decimal places (for create, default: 0)',
          },
          initialSupply: {
            type: 'number',
            description: 'Initial token supply (for create)',
          },
          adminKey: {
            type: 'boolean',
            description: 'Enable admin key (for create)',
          },
          supplyKey: {
            type: 'boolean',
            description: 'Enable supply key for mint/burn (for create)',
          },
          freezeKey: {
            type: 'boolean',
            description: 'Enable freeze key (for create)',
          },
          kycKey: {
            type: 'boolean',
            description: 'Enable KYC key (for create)',
          },
          wipeKey: {
            type: 'boolean',
            description: 'Enable wipe key (for create)',
          },
          pauseKey: {
            type: 'boolean',
            description: 'Enable pause key (for create)',
          },
          memo: {
            type: 'string',
            description: 'Token memo (for create)',
          },
          from: {
            type: 'string',
            description: 'Source account (for transfer)',
          },
          to: {
            type: 'string',
            description: 'Destination account (for transfer)',
          },
        },
        required: ['operation'],
      },
    },

• src/index.ts:588-589 (registration)

  Tool registration in the main MCP server request handler switch statement, mapping 'token_manage' calls to the tokenManage function.

  case 'token_manage':
    result = await tokenManage(args as any);

• src/index.ts:34-34 (registration)

  Import of the tokenManage handler function from composite.ts.

  tokenManage,