sodax_get_swap_tokens

Instructions

Implementation Reference

• src/tools/sodaxApi.ts:135-165 (handler)

  The MCP tool registration for 'sodax_get_swap_tokens'. Defines the Zod schema (chainId optional string, format optional enum), uses READ_ONLY annotations, and the handler calls getSwapTokens(chainId) from the service layer, formats a summary prefix, and returns the result.

  // Tool 2: Get Swap Tokens
  server.tool(
    "sodax_get_swap_tokens",
    "Get available tokens for swapping on SODAX, optionally filtered by chain",
    {
      chainId: z.string().optional()
        .describe("Filter tokens by chain ID (e.g., 'base', 'ethereum', 'icon')"),
      format: z.nativeEnum(ResponseFormat).optional().default(ResponseFormat.MARKDOWN)
        .describe("Response format: 'json' for raw data or 'markdown' for formatted text")
    },
    READ_ONLY,
    async ({ chainId, format }) => {
      try {
        const tokens = await getSwapTokens(chainId);
        const summary = chainId 
          ? `## Swap Tokens on ${chainId}\n\n${tokens.length} tokens available\n\n`
          : `## All Swap Tokens\n\n${tokens.length} tokens available across all chains\n\n`;
        return {
          content: [{
            type: "text",
            text: summary + formatResponse(tokens, format)
          }]
        };
      } catch (error) {
        return {
          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
          isError: true
        };
      }
    }
  );

• src/services/sodaxApi.ts:77-107 (helper)

  The service function getSwapTokens() that performs the actual API call. Optionally accepts a chainId, builds the endpoint (/config/swap/{chainId}/tokens or /config/swap/tokens), fetches from the SODAX API, flattens the response (handles both array and object-keyed formats), caches results, and returns SwapToken[].

  export async function getSwapTokens(chainId?: string): Promise<SwapToken[]> {
    const cacheKey = `tokens-${chainId || "all"}`;
    const cached = getCached<SwapToken[]>(cacheKey);
    if (cached) return cached;
  
    try {
      const endpoint = chainId ? `/config/swap/${chainId}/tokens` : "/config/swap/tokens";
      const response = await apiClient.get(endpoint);
      // API returns object keyed by chain ID, flatten if getting all
      const data = response.data;
      let tokens: SwapToken[] = [];
      if (chainId && Array.isArray(data)) {
        tokens = data;
      } else if (typeof data === "object" && !Array.isArray(data)) {
        // Flatten all chain tokens into single array
        for (const chain of Object.keys(data)) {
          const chainTokens = data[chain];
          if (Array.isArray(chainTokens)) {
            tokens.push(...chainTokens.map(t => ({ ...t, chainId: chain })));
          }
        }
      } else {
        tokens = data?.data || [];
      }
      setCache(cacheKey, tokens);
      return tokens;
    } catch (error) {
      console.error("Error fetching swap tokens:", error);
      throw new Error("Failed to fetch swap tokens from SODAX API");
    }
  }

• src/types.ts:31-39 (schema)

  The SwapToken interface defining the shape of each token returned: address, chainId, symbol, name, decimals, logoUrl (optional), and priceUsd (optional).

  export interface SwapToken {
    address: string;
    chainId: string;
    symbol: string;
    name: string;
    decimals: number;
    logoUrl?: string;
    priceUsd?: number;
  }

• src/tools/sodaxApi.ts:106-165 (registration)

  The registerSodaxApiTools(server) function is called from src/index.ts line 44 to register all SODAX tools, including sodax_get_swap_tokens via server.tool().

  export function registerSodaxApiTools(server: McpServer): void {
    
    // Tool 1: Get Supported Chains
    server.tool(
      "sodax_get_supported_chains",
      "List all blockchain networks supported by SODAX for cross-chain swaps and DeFi operations",
      {
        format: z.nativeEnum(ResponseFormat).optional().default(ResponseFormat.MARKDOWN)
          .describe("Response format: 'json' for raw data or 'markdown' for formatted text")
      },
      READ_ONLY,
      async ({ format }) => {
        try {
          const chains = await getSupportedChains();
          return {
            content: [{
              type: "text",
              text: formatResponse(chains, format)
            }]
          };
        } catch (error) {
          return {
            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
            isError: true
          };
        }
      }
    );
  
    // Tool 2: Get Swap Tokens
    server.tool(
      "sodax_get_swap_tokens",
      "Get available tokens for swapping on SODAX, optionally filtered by chain",
      {
        chainId: z.string().optional()
          .describe("Filter tokens by chain ID (e.g., 'base', 'ethereum', 'icon')"),
        format: z.nativeEnum(ResponseFormat).optional().default(ResponseFormat.MARKDOWN)
          .describe("Response format: 'json' for raw data or 'markdown' for formatted text")
      },
      READ_ONLY,
      async ({ chainId, format }) => {
        try {
          const tokens = await getSwapTokens(chainId);
          const summary = chainId 
            ? `## Swap Tokens on ${chainId}\n\n${tokens.length} tokens available\n\n`
            : `## All Swap Tokens\n\n${tokens.length} tokens available across all chains\n\n`;
          return {
            content: [{
              type: "text",
              text: summary + formatResponse(tokens, format)
            }]
          };
        } catch (error) {
          return {
            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
            isError: true
          };
        }
      }
    );

• src/index.ts:44-48 (registration)

  Registration call: registerSodaxApiTools(server) is invoked on line 44 to register all SODAX tools into the MCP server instance.

    registerSodaxApiTools(server);
    await registerGitBookProxyTools(server);
  
    return server;
  }