get_solana_balance

Instructions

Implementation Reference

• src/handlers/solana-handlers.ts:57-75 (schema)

  Defines the input schema, description, and registration of the get_solana_balance tool in the tools array returned by registerSolanaHandlers

  {
    name: 'get_solana_balance',
    description: 'Get SOL balance for a Solana address',
    inputSchema: {
      type: 'object',
      properties: {
        address: {
          type: 'string',
          description: 'Solana address',
        },
        network: {
          type: 'string',
          enum: ['mainnet', 'testnet'],
          description: 'Network type (defaults to mainnet)',
        },
      },
      required: ['address'],
    },
  },

• src/handlers/solana-handlers.ts:288-303 (handler)

  Executes the get_solana_balance tool by parsing arguments, calling SolanaService.getBalance, and returning formatted JSON response

  case 'get_solana_balance': {
    const address = args?.address as string;
    const network = (args?.network as 'mainnet' | 'testnet') || 'mainnet';
  
    const result = await solanaService.getBalance(address, network);
  
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(result, null, 2),
        },
      ],
      isError: !result.success,
    };
  }

• src/services/solana-service.ts:197-232 (helper)

  Implements the getBalance logic: retrieves Solana RPC service, calls 'getBalance' RPC method, converts lamports to SOL, and returns structured response

  async getBalance(
    address: string,
    network: 'mainnet' | 'testnet' = 'mainnet'
  ): Promise<EndpointResponse> {
    const service = this.blockchainService.getServiceByBlockchain('solana', network);
  
    if (!service) {
      return {
        success: false,
        error: `Solana service not found for ${network}`,
      };
    }
  
    const result = await this.blockchainService.callRPCMethod(
      service.id,
      'getBalance',
      [address]
    );
  
    if (result.success && result.data?.value !== undefined) {
      const lamports = result.data.value;
      const sol = lamports / 1e9; // 1 SOL = 1 billion lamports
  
      return {
        success: true,
        data: {
          address,
          lamports,
          sol,
        },
        metadata: result.metadata,
      };
    }
  
    return result;
  }

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

  Registers the Solana tools (including get_solana_balance schema) by including registerSolanaHandlers in the tools array provided to listTools handler

  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 (handler)

  Routes tool execution to the appropriate handler, including handleSolanaTool for get_solana_balance

  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));