sol-trade-sdk 10.0.0

A high-performance Rust SDK for Solana DEX trading.
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! SOL / WSOL / USDC ↔ stock-quote ↔ meme trading for StonkFun.
//!
//! Most StonkFun pools are priced in a non-SOL quote (xStocks, PreStocks, STONK,
//! etc.). Wallets that only hold SOL need an atomic two-hop:
//!
//! - buy:  `SOL/WSOL/USDC → quote → meme`
//! - sell: `meme → quote → SOL/WSOL/USDC`
//! Each buy or sell is a separate transaction. Already-held quote tokens trade
//! directly with `curve_direct` / `graduated_direct`, without conversion hops.
//!
//! [`StonkFunViaSolParams`] covers both the LaunchLab curve (inner) and graduated
//! CPMM (outer) meme legs. Legacy single hops support CPMM and AMM v4;
//! [`StonkFunSolHop::Route`] also accepts externally quoted CLMM, Whirlpool,
//! DLMM and split/multi-hop conversion paths.
//!
//! # Quick start
//!
//! ```ignore
//! use sol_trade_sdk::{
//!     BuyAmount, SimpleBuyParams, StonkFunViaSolParams,
//! };
//!
//! let via = StonkFunViaSolParams::curve_with_cpmm(curve_params, wsol_stock_pool);
//! let buy = SimpleBuyParams::stonkfun_with_sol(
//!     meme_mint,
//!     BuyAmount::ExactInput(100_000_000), // 0.1 SOL
//!     via,
//!     recent_blockhash,
//!     gas_fee_strategy,
//! );
//! ```

use super::{BonkParams, RaydiumAmmV4Params, RaydiumCpmmParams};

/// SOL, WSOL or USDC ↔ quote ↔ meme routing. The legacy name remains compatible.
pub type StonkFunViaQuoteParams = StonkFunViaSolParams;

/// Meme ↔ StonkFun-quote leg: either the LaunchLab curve or a graduated CPMM pool.
#[derive(Clone)]
pub enum StonkFunMemeLeg {
    /// Inner-curve / bonding-curve pool (`DexParamEnum::StonkFun`).
    Curve(BonkParams),
    /// Graduated external CPMM pool (`DexParamEnum::StonkFunSwap`).
    Graduated(RaydiumCpmmParams),
}

/// Funding asset ↔ StonkFun-quote conversion. Legacy name retained for compatibility.
#[derive(Clone)]
pub enum StonkFunSolHop {
    RaydiumCpmm(RaydiumCpmmParams),
    RaydiumAmmV4(RaydiumAmmV4Params),
    /// Explicit externally quoted paths, including concentrated venues and splits.
    Route(super::StonkFunQuoteRoute),
}

impl From<super::StonkFunQuoteRoute> for StonkFunSolHop {
    fn from(route: super::StonkFunQuoteRoute) -> Self {
        Self::Route(route)
    }
}

impl From<RaydiumCpmmParams> for StonkFunSolHop {
    fn from(params: RaydiumCpmmParams) -> Self {
        Self::RaydiumCpmm(params)
    }
}

impl From<RaydiumAmmV4Params> for StonkFunSolHop {
    fn from(params: RaydiumAmmV4Params) -> Self {
        Self::RaydiumAmmV4(params)
    }
}

/// Funding/receipt wrapper around an inner or graduated StonkFun leg.
///
/// Prefer the `curve_with_*` / `graduated_with_*` constructors, then pass the
/// result to [`crate::client::SimpleBuyParams::stonkfun_with_sol`] or
/// [`crate::client::SimpleSellParams::stonkfun_to_sol`].
///
/// ATA lifecycle follows the caller's account policy:
/// - `Auto` (default on the Simple helpers): create WSOL / stock-quote / meme
///   ATAs when missing; keep stock-quote across trades; unwrap WSOL back to
///   native SOL on sells so the wallet balance looks normal.
/// - `HotPathMinimal` / `AssumePrepared`: never create or close — prebuild ATAs
///   offline for lowest latency.
#[derive(Clone)]
pub struct StonkFunViaSolParams {
    pub meme_leg: StonkFunMemeLeg,
    pub sol_hop: StonkFunSolHop,
}

impl StonkFunViaSolParams {
    /// Use an already-held pool quote directly, without conversion hops.
    pub fn curve_direct(meme_leg: BonkParams) -> Self {
        Self::curve(meme_leg, super::StonkFunQuoteRoute::default())
    }

    /// Direct quote↔meme trading on a graduated pool.
    pub fn graduated_direct(meme_leg: RaydiumCpmmParams) -> Self {
        Self::graduated(meme_leg, super::StonkFunQuoteRoute::default())
    }
    /// Inner-curve meme leg + arbitrary SOL hop.
    pub fn curve(meme_leg: BonkParams, sol_hop: impl Into<StonkFunSolHop>) -> Self {
        Self { meme_leg: StonkFunMemeLeg::Curve(meme_leg), sol_hop: sol_hop.into() }
    }

    /// Graduated CPMM meme leg + arbitrary SOL hop.
    pub fn graduated(meme_leg: RaydiumCpmmParams, sol_hop: impl Into<StonkFunSolHop>) -> Self {
        Self { meme_leg: StonkFunMemeLeg::Graduated(meme_leg), sol_hop: sol_hop.into() }
    }

    /// Inner curve priced in a stock quote, with a Raydium CPMM `WSOL/quote` hop.
    pub fn curve_with_cpmm(meme_leg: BonkParams, sol_quote_pool: RaydiumCpmmParams) -> Self {
        Self::curve(meme_leg, sol_quote_pool)
    }

    /// Inner curve priced in a stock quote, with a Raydium AMM v4 `WSOL/quote` hop.
    pub fn curve_with_amm_v4(meme_leg: BonkParams, sol_quote_pool: RaydiumAmmV4Params) -> Self {
        Self::curve(meme_leg, sol_quote_pool)
    }

    /// Graduated StonkFun CPMM pool, with a Raydium CPMM `WSOL/quote` hop.
    pub fn graduated_with_cpmm(
        meme_leg: RaydiumCpmmParams,
        sol_quote_pool: RaydiumCpmmParams,
    ) -> Self {
        Self::graduated(meme_leg, sol_quote_pool)
    }

    /// Graduated StonkFun CPMM pool, with a Raydium AMM v4 `WSOL/quote` hop.
    pub fn graduated_with_amm_v4(
        meme_leg: RaydiumCpmmParams,
        sol_quote_pool: RaydiumAmmV4Params,
    ) -> Self {
        Self::graduated(meme_leg, sol_quote_pool)
    }

    /// Wrap as the protocol extension enum used by buy/sell APIs.
    #[inline]
    pub fn into_extension(self) -> super::DexParamEnum {
        super::DexParamEnum::StonkFunViaSol(self)
    }
}

impl From<StonkFunViaSolParams> for super::DexParamEnum {
    fn from(params: StonkFunViaSolParams) -> Self {
        Self::StonkFunViaSol(params)
    }
}