MCP Jupiter

Instructions

Implementation Reference

• src/handlers/jupiter.ts:8-68 (handler)

  Main handler function for jupiter_get_quote tool. Validates input mints, builds URLSearchParams for Jupiter quote API, fetches the quote, and returns formatted success or error response.

  export const getQuoteHandler = async (input: GetQuoteInput): Promise<ToolResultSchema> => {
    try {
      // Validate input and output mints
      const inputMintResult = validatePublicKey(input.inputMint);
      if (!(inputMintResult instanceof PublicKey)) {
        return inputMintResult;
      }
      
      const outputMintResult = validatePublicKey(input.outputMint);
      if (!(outputMintResult instanceof PublicKey)) {
        return outputMintResult;
      }
      
      // Build query parameters
      const params = new URLSearchParams();
      params.append("inputMint", input.inputMint);
      params.append("outputMint", input.outputMint);
      params.append("amount", input.amount);
      
      if (input.slippageBps !== undefined) {
        params.append("slippageBps", input.slippageBps.toString());
      }
      
      if (input.onlyDirectRoutes !== undefined) {
        params.append("onlyDirectRoutes", input.onlyDirectRoutes.toString());
      }
      
      if (input.asLegacyTransaction !== undefined) {
        params.append("asLegacyTransaction", input.asLegacyTransaction.toString());
      }
      
      if (input.maxAccounts !== undefined) {
        params.append("maxAccounts", input.maxAccounts.toString());
      }
      
      if (input.swapMode !== undefined) {
        params.append("swapMode", input.swapMode);
      }
      
      if (input.excludeDexes !== undefined && input.excludeDexes.length > 0) {
        params.append("excludeDexes", input.excludeDexes.join(","));
      }
      
      if (input.platformFeeBps !== undefined) {
        params.append("platformFeeBps", input.platformFeeBps.toString());
      }
      
      // Make the API request
      const response = await fetch(`${JUPITER_API_BASE_URL}/quote?${params.toString()}`);
      
      if (!response.ok) {
        const errorText = await response.text();
        return createErrorResponse(`Error getting quote: ${response.status} ${response.statusText} - ${errorText}`);
      }
      
      const quoteData = await response.json();
      return createSuccessResponse(`Quote: ${JSON.stringify(quoteData, null, 2)}`);
    } catch (error) {
      return createErrorResponse(`Error getting quote: ${error instanceof Error ? error.message : String(error)}`);
    }
  };

• src/tools.ts:4-26 (schema)

  JSON input schema definition for the jupiter_get_quote tool, including properties and required fields.

  {
    name: "jupiter_get_quote",
    description: "Get a quote for swapping tokens on Jupiter",
    inputSchema: {
      type: "object",
      properties: {
        inputMint: { type: "string" },
        outputMint: { type: "string" },
        amount: { type: "string" },
        slippageBps: { type: "number" },
        onlyDirectRoutes: { type: "boolean" },
        asLegacyTransaction: { type: "boolean" },
        maxAccounts: { type: "number" },
        swapMode: { type: "string" },
        excludeDexes: { 
          type: "array",
          items: { type: "string" }
        },
        platformFeeBps: { type: "number" }
      },
      required: ["inputMint", "outputMint", "amount"]
    }
  },

• src/tools.ts:57-63 (registration)

  Registration of the getQuoteHandler function under the key 'jupiter_get_quote' in the handlers dictionary.

  type handlerDictionary = Record<typeof tools[number]["name"], (input: any) => any>;
  
  export const handlers: handlerDictionary = {
    "jupiter_get_quote": getQuoteHandler,
    "jupiter_build_swap_transaction": buildSwapTransactionHandler,
    "jupiter_send_swap_transaction": sendSwapTransactionHandler
  };

• src/handlers/jupiter.types.ts:1-12 (schema)

  TypeScript interface defining the input type GetQuoteInput for the handler, matching the JSON schema.

  export interface GetQuoteInput {
    inputMint: string;
    outputMint: string;
    amount: string;
    slippageBps?: number;
    onlyDirectRoutes?: boolean;
    asLegacyTransaction?: boolean;
    maxAccounts?: number;
    swapMode?: string;
    excludeDexes?: string[];
    platformFeeBps?: number;
  }

• src/handlers/utils.ts:53-59 (helper)

  Helper function validatePublicKey used in the handler to validate input and output mint public keys, returning error response if invalid.

  export const validatePublicKey = (publicKeyString: string): PublicKey | ToolResultSchema => {
    const { publicKey, error } = createPublicKey(publicKeyString);
    if (error) {
      return createErrorResponse(error);
    }
    return publicKey!;
  };