jupiter_api 0.1.9

jupiter api client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

/*
inputMint, outputMint, amount, slippageBps, swapMode, dexes, excludeDexes, onlyDirectRoutes, asLegacyTransaction, platformFeeBps, maxAccounts
*/

use anyhow::{anyhow, Context, Result};
use serde::{Deserialize, Serialize};

const QUOTE_BASE: &str = "https://quote-api.jup.ag/v6/quote";

/// defines options that can be used to tune the swap request
pub enum RequestOption<'a> {
    SwapMode(SwapMode),
    Dexes(&'a [&'a str]),
    ExcludeDexes(&'a [&'a str]),
    OnlyDirectRoutes,
    AsLegacyTransaction,
    PlatformFeeBps(u64),
    MaxAccounts(usize),
    SlippageBps(i64), // 50 = 0.5%, 100 = 1%, 200 = 2%
}

pub enum SwapMode {
    ExactIn,
    ExactOut,
}

impl ToString for SwapMode {
    fn to_string(&self) -> String {
        if let Self::ExactIn = self {
            "ExactIn".to_string()
        } else {
            "ExactOut".to_string()
        }
    }
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct QuoteResponse {
    pub input_mint: String,
    pub in_amount: String,
    pub output_mint: String,
    pub out_amount: String,
    pub other_amount_threshold: String,
    pub swap_mode: String,
    pub slippage_bps: i64,
    pub platform_fee: Option<PlatformFee>,
    pub price_impact_pct: String,
    pub route_plan: Vec<RoutePlan>,
    pub context_slot: i64,
    pub time_taken: f64,
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RoutePlan {
    pub swap_info: SwapInfo,
    pub percent: i64,
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SwapInfo {
    pub amm_key: String,
    pub label: String,
    pub input_mint: String,
    pub output_mint: String,
    pub in_amount: String,
    pub out_amount: String,
    pub fee_amount: String,
    pub fee_mint: String,
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PlatformFee {
    pub amount: String,
    pub fee_bps: i64,
}

/// formats the quote url with the required request options
pub fn format_quote_url(
    input_mint: &str,
    output_mint: &str,
    amount: u64,
    request_options: &[RequestOption<'_>],
) -> String {
    let mut quote_url =
        format!("{QUOTE_BASE}?inputMint={input_mint}&outputMint={output_mint}&amount={amount}");
    for request_option in request_options {
        match request_option {
            RequestOption::SwapMode(swap_mode) => {
                quote_url = format!("{quote_url}&swapMode={}", swap_mode.to_string());
            }
            RequestOption::Dexes(dexes) => {
                // skip
            }
            RequestOption::ExcludeDexes(dexes) => {
                // skip
            }
            RequestOption::OnlyDirectRoutes => {
                quote_url = format!("{quote_url}&onlyDirectRoutes=true");
            }
            RequestOption::AsLegacyTransaction => {
                quote_url = format!("{quote_url}&asLegacyTransaction=true");
            }
            RequestOption::PlatformFeeBps(fee_bps) => {
                quote_url = format!("{quote_url}&platformFeeBps={fee_bps}");
            }
            RequestOption::MaxAccounts(max_accounts) => {
                quote_url = format!("{quote_url}&maxAccounts={max_accounts}");
            }
            RequestOption::SlippageBps(slip) => {
                quote_url = format!("{quote_url}&slippageBps={slip}");
            }
        }
    }
    quote_url
}