Grove's MCP Server for Pocket Network

Instructions

Implementation Reference

• src/handlers/sui-handlers.ts:472-490 (handler)

  Handler logic for the 'query_sui_events' tool. Extracts parameters from args and calls SuiService.queryEvents, then formats the response.

  case 'query_sui_events': {
    const query = args?.query as any;
    const cursor = args?.cursor as string | undefined;
    const limit = args?.limit as number | undefined;
    const descendingOrder = args?.descendingOrder as boolean | undefined;
    const network = (args?.network as 'mainnet' | 'testnet') || 'mainnet';
  
    const result = await suiService.queryEvents(query, cursor, limit, descendingOrder, network);
  
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(result, null, 2),
        },
      ],
      isError: !result.success,
    };
  }

• src/handlers/sui-handlers.ts:241-271 (schema)

  Tool definition including name, description, and input schema for 'query_sui_events'.

  {
    name: 'query_sui_events',
    description: 'Query Sui events',
    inputSchema: {
      type: 'object',
      properties: {
        query: {
          type: 'object',
          description: 'Event query filter',
        },
        cursor: {
          type: 'string',
          description: 'Optional: Pagination cursor',
        },
        limit: {
          type: 'number',
          description: 'Optional: Number of results to return',
        },
        descendingOrder: {
          type: 'boolean',
          description: 'Optional: Sort order (default: false)',
        },
        network: {
          type: 'string',
          enum: ['mainnet', 'testnet'],
          description: 'Network type (defaults to mainnet)',
        },
      },
      required: ['query'],
    },
  },

• src/services/sui-service.ts:296-318 (helper)

  Core implementation of event querying via RPC call to 'suix_queryEvents' on the Sui blockchain service.

  async queryEvents(
    query: any,
    cursor?: string,
    limit?: number,
    descendingOrder?: boolean,
    network: 'mainnet' | 'testnet' = 'mainnet'
  ): Promise<EndpointResponse> {
    const service = this.blockchainService.getServiceByBlockchain('sui', network);
  
    if (!service) {
      return {
        success: false,
        error: `Sui service not found for ${network}`,
      };
    }
  
    const params: any[] = [query];
    if (cursor !== undefined) params.push(cursor);
    if (limit !== undefined) params.push(limit);
    if (descendingOrder !== undefined) params.push(descendingOrder);
  
    return this.blockchainService.callRPCMethod(service.id, 'suix_queryEvents', params);
  }

• src/index.ts:87-101 (registration)

  Registration of all tools, including Sui handlers which define 'query_sui_events', into the server's tool list.

  // Register all tools from handlers
  const tools: Tool[] = [
    ...registerBlockchainHandlers(server, blockchainService),
    ...registerDomainHandlers(server, domainResolver),
    ...registerTransactionHandlers(server, advancedBlockchain),
    ...registerTokenHandlers(server, advancedBlockchain),
    ...registerMultichainHandlers(server, advancedBlockchain),
    ...registerContractHandlers(server, advancedBlockchain),
    ...registerUtilityHandlers(server, advancedBlockchain),
    ...registerEndpointHandlers(server, endpointManager),
    ...registerSolanaHandlers(server, solanaService),
    ...registerCosmosHandlers(server, cosmosService),
    ...registerSuiHandlers(server, suiService),
    ...registerDocsHandlers(server, docsManager),
  ];

• src/index.ts:114-126 (registration)

  Dispatch chain in tool execution handler that routes 'query_sui_events' to handleSuiTool.

  let result =
    (await handleBlockchainTool(name, args, blockchainService)) ||
    (await handleDomainTool(name, args, domainResolver)) ||
    (await handleTransactionTool(name, args, advancedBlockchain)) ||
    (await handleTokenTool(name, args, advancedBlockchain)) ||
    (await handleMultichainTool(name, args, advancedBlockchain)) ||
    (await handleContractTool(name, args, advancedBlockchain)) ||
    (await handleUtilityTool(name, args, advancedBlockchain)) ||
    (await handleEndpointTool(name, args, endpointManager)) ||
    (await handleSolanaTool(name, args, solanaService)) ||
    (await handleCosmosTool(name, args, cosmosService)) ||
    (await handleSuiTool(name, args, suiService)) ||
    (await handleDocsTool(name, args, docsManager));