Jupiter Swap API Client

When building a TransactionConfig, you can prioritize your transaction using either compute_unit_price_micro_lamports or prioritization_fee_lamports. These two fields are mutually exclusive.

Compute Unit Price

Use compute_unit_price_micro_lamports to set a specific price per compute unit.

• MicroLamports(u64): A specific value in micro-lamports.
• Auto: Automatically determines the price.

Prioritization Fee

Use prioritization_fee_lamports to pay an additional fee for the transaction. Options include:

• AutoMultiplier(u32): Uses a multiplier for automatic fee calculation.
• JitoTipLamports(u64): A specific tip amount for Jito.
• PriorityLevelWithMaxLamports: Uses a predefined PriorityLevel (Medium, High, or VeryHigh) with a max_lamports cap. Setting global: true applies the fee globally.
• Lamports(u64): A fixed amount of lamports.
• Auto: Automatic fee calculation.
• Disabled: No prioritization fee.

// Example: Setting a high priority via Jito tip
let config = TransactionConfig {
    prioritization_fee_lamports: Some(PrioritizationFeeLamports::JitoTipLamports(100000)),
    ..Default::default()
};

// Example: Setting a specific compute unit price
let config = TransactionConfig {
    compute_unit_price_micro_lamports: Some(ComputeUnitPriceMicroLamports::MicroLamports(500)),
    ..Default::default()
};

The JupiterSwapApiClient provides high-level methods to interact with the Jupiter Swap API. You initialize it with a base URL (e.g., https://quote-api.jup.ag/v6).

Key methods:

• quote(&QuoteRequest): Fetches a quote for a potential swap. Requires an amount, input_mint, output_mint, and slippage_bps.
• swap(&SwapRequest): Executes a swap request, returning a transaction. Requires user_public_key, the quote_response, and a TransactionConfig.
• swap_instructions(&SwapRequest): Retrieves swap instructions instead of a full transaction.

use jupiter_swap_api_client::{
    quote::QuoteRequest, swap::SwapRequest, transaction_config::TransactionConfig,
    JupiterSwapApiClient,
};
use solana_sdk::pubkey::Pubkey;

const USDC_MINT: Pubkey = pubkey!("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
const NATIVE_MINT: Pubkey = pubkey!("So11111111111111111111111111111111111111112");
const TEST_WALLET: Pubkey = pubkey!("2AQdpHJ2JpcEgPiATUXjQxA8QmafFegfQwSLWSprPicm");

#[tokio::main]
async fn main() {
    let jupiter_swap_api_client = JupiterSwapApiClient::new("https://quote-api.jup.ag/v6");

    let quote_request = QuoteRequest {
        amount: 1_000_000,
        input_mint: USDC_MINT,
        output_mint: NATIVE_MINT,
        slippage_bps: 50,
        ..QuoteRequest::default()
    };

    // GET /quote
    let quote_response = jupiter_swap_api_client.quote(&quote_request).await.unwrap();
    println!("{quote_response:#?}");

    // POST /swap
    let swap_response = jupiter_swap_api_client
        .swap(&SwapRequest {
            user_public_key: TEST_WALLET,
            quote_response: quote_response.clone(),
            config: TransactionConfig::default(),
        })
        .await
        .unwrap();

    println!("Raw tx len: {}", swap_response.swap_transaction.len());

    // POST /swap-instructions
    let swap_instructions = jupiter_swap_api_client
        .swap_instructions(&SwapRequest {
            user_public_key: TEST_WALLET,
            quote_response,
            config: TransactionConfig::default(),
        })
        .await
        .unwrap();
    println!("{swap_instructions:#?}");
}

To obtain a swap quote and route plan, construct a QuoteRequest. This structure defines the parameters for the routing engine, including token mints, amounts, slippage, and routing constraints.

Key configuration options include:

• input_mint / output_mint: The Pubkey of the tokens being swapped.
• amount: The quantity of the input or output token (depending on swap_mode).
• swap_mode: Determines if the input or output amount is fixed (ExactIn or ExactOut).
• slippage_bps: Maximum allowed slippage in basis points (e.g., 50 for 0.5%).
• dexes / excluded_dexes: Comma-separated strings of DEX labels to include or exclude.
• only_direct_routes: If true, restricts routing to single-hop swaps.
• platform_fee_bps: Optional fee to collect in basis points.
• compute_auto_slippage: Enables dynamic slippage calculation.

Note: QuoteRequest::default() provides a safe default slippage of 50 BPS.

let request = QuoteRequest {
    input_mint: input_pubkey,
    output_mint: output_pubkey,
    amount: 1000000, // amount in atoms
    swap_mode: Some(SwapMode::ExactIn),
    slippage_bps: 50,
    ..Default::default()
};