MCP Jupiter

Instructions

Implementation Reference

• src/handlers/jupiter.ts:70-123 (handler)

  The main handler function that executes the tool: validates user public key, parses quote response, builds request to Jupiter /swap-instructions API, and returns the serialized swap transaction.

  export const buildSwapTransactionHandler = async (input: BuildSwapTransactionInput): Promise<ToolResultSchema> => {
    try {
      // Validate user public key
      const userPublicKeyResult = validatePublicKey(input.userPublicKey);
      if (!(userPublicKeyResult instanceof PublicKey)) {
        return userPublicKeyResult;
      }
      
      // Parse the quote response
      let quoteResponse;
      try {
        quoteResponse = JSON.parse(input.quoteResponse);
      } catch (error) {
        return createErrorResponse(`Invalid quote response: ${error instanceof Error ? error.message : String(error)}`);
      }
      
      // Build the request body
      const requestBody: any = {
        quoteResponse,
        userPublicKey: input.userPublicKey
      };
      
      if (input.prioritizationFeeLamports !== undefined) {
        requestBody.prioritizationFeeLamports = input.prioritizationFeeLamports;
      }
      
      if (input.computeUnitPriceMicroLamports !== undefined) {
        requestBody.computeUnitPriceMicroLamports = input.computeUnitPriceMicroLamports;
      }
      
      if (input.asLegacyTransaction !== undefined) {
        requestBody.asLegacyTransaction = input.asLegacyTransaction;
      }
      
      // Make the API request
      const response = await fetch(`${JUPITER_API_BASE_URL}/swap-instructions`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json"
        },
        body: JSON.stringify(requestBody)
      });
      
      if (!response.ok) {
        const errorText = await response.text();
        return createErrorResponse(`Error building swap transaction: ${response.status} ${response.statusText} - ${errorText}`);
      }
      
      const swapData = await response.json();
      return createSuccessResponse(`Swap transaction: ${JSON.stringify(swapData, null, 2)}`);
    } catch (error) {
      return createErrorResponse(`Error building swap transaction: ${error instanceof Error ? error.message : String(error)}`);
    }
  };

• src/tools.ts:27-41 (schema)

  Input schema and metadata definition for the tool used in MCP tool list.

  {
    name: "jupiter_build_swap_transaction",
    description: "Build a swap transaction on Jupiter",
    inputSchema: {
      type: "object",
      properties: {
        quoteResponse: { type: "string" },
        userPublicKey: { type: "string" },
        prioritizationFeeLamports: { type: "number" },
        computeUnitPriceMicroLamports: { type: "number" },
        asLegacyTransaction: { type: "boolean" }
      },
      required: ["quoteResponse", "userPublicKey"]
    }
  },

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

  Maps the tool name to its handler function for dynamic dispatch.

  export const handlers: handlerDictionary = {
    "jupiter_get_quote": getQuoteHandler,
    "jupiter_build_swap_transaction": buildSwapTransactionHandler,
    "jupiter_send_swap_transaction": sendSwapTransactionHandler
  };

• src/handlers/jupiter.types.ts:14-20 (schema)

  TypeScript type definition for the tool's input parameters, matching the inputSchema.

  export interface BuildSwapTransactionInput {
    quoteResponse: string;
    userPublicKey: string;
    prioritizationFeeLamports?: number;
    computeUnitPriceMicroLamports?: number;
    asLegacyTransaction?: boolean;
  }

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

  Helper function used in the handler to validate the userPublicKey.

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