feat(solana-solvers): buy orders via v1 ExactOut, gated by enable_buy_orders

Author: squadgazzz

crates/solana-solvers/config/example.jupiter.toml

@@ -9,3 +9,5 @@ endpoint = "https://api.jup.ag"
 api-key = "your-jupiter-api-key"
 # Slippage tolerance in basis points, sent to Jupiter as slippageBps. 50 = 0.5%.
 slippage-bps = 50
+# Whether to serve buy orders. Off by default.
+enable-buy-orders = false

crates/solana-solvers/src/config.rs

@@ -25,6 +25,10 @@ pub struct JupiterConfig {
     /// Slippage tolerance in basis points, sent to Jupiter as `slippageBps`.
     /// 50 = 0.5%.
     pub slippage_bps: u16,
+
+    /// Whether to serve buy orders. Off by default.
+    #[serde(default)]
+    pub enable_buy_orders: bool,
 }
 
 /// Load and parse the TOML config file.
@@ -50,6 +54,7 @@ mod tests {
         assert_eq!(config.dex.endpoint.as_str(), "https://api.jup.ag/");
         assert_eq!(config.dex.slippage_bps, 50);
         assert!(config.dex.api_key.is_some());
+        assert!(!config.dex.enable_buy_orders);
     }
 
     #[test]

crates/solana-solvers/src/dex/jupiter/mod.rs

@@ -1,7 +1,7 @@
 //! Jupiter swap-API adapter.
 //!
-//! v1 `/quote` + `/swap-instructions` (ExactIn). Triton is a base-URL and key
-//! swap behind the same adapter.
+//! v1 `/quote` + `/swap-instructions` (ExactIn for sells, ExactOut for buys).
+//! Triton is a base-URL and key swap behind the same adapter.
 
 mod dto;
 
@@ -20,6 +20,7 @@ pub struct Jupiter {
     endpoint: reqwest::Url,
     api_key: Option<String>,
     slippage_bps: u16,
+    enable_buy_orders: bool,
 }
 
 impl Jupiter {
@@ -29,17 +30,19 @@ impl Jupiter {
             endpoint: config.endpoint.clone(),
             api_key: config.api_key.clone(),
             slippage_bps: config.slippage_bps,
+            enable_buy_orders: config.enable_buy_orders,
         })
     }
 
     /// Quote `order` for the settlement signer `taker` and return the swap to
     /// run inside the settlement transaction.
     pub async fn swap(&self, order: &Order, taker: &Pubkey) -> Result<Swap, Error> {
-        // Buy orders (ExactOut) aren't served here.
-        if order.side == Side::Buy {
-            return Err(Error::OrderNotSupported);
-        }
-        let quote = self.quote(order, "ExactIn").await?;
+        let swap_mode = match order.side {
+            Side::Sell => "ExactIn",
+            Side::Buy if self.enable_buy_orders => "ExactOut",
+            Side::Buy => return Err(Error::OrderNotSupported),
+        };
+        let quote = self.quote(order, swap_mode).await?;
         let in_amount = amount_field(&quote, "inAmount")?;
         let out_amount = amount_field(&quote, "outAmount")?;
         self.swap_instructions(&quote, taker, &order.buy_destination)
@@ -151,32 +154,29 @@ mod tests {
     const USDC: &str = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
     const WSOL: &str = "So11111111111111111111111111111111111111112";
 
-    fn config() -> JupiterConfig {
+    fn config(enable_buy_orders: bool) -> JupiterConfig {
         JupiterConfig {
             endpoint: "https://api.jup.ag".parse().unwrap(),
             api_key: std::env::var("JUPITER_API_KEY").ok(),
             slippage_bps: 50,
+            enable_buy_orders,
         }
     }
 
-    fn sell_order() -> Order {
+    fn order(side: Side) -> Order {
         Order {
             sell_mint: Pubkey::from_str(USDC).unwrap(),
             buy_mint: Pubkey::from_str(WSOL).unwrap(),
             buy_destination: Pubkey::from_str(WSOL).unwrap(),
             amount: 1_000_000,
-            side: Side::Sell,
+            side,
         }
     }
 
     #[tokio::test]
-    async fn buy_unsupported() {
-        let jupiter = Jupiter::new(&config()).unwrap();
-        let order = Order {
-            side: Side::Buy,
-            ..sell_order()
-        };
-        let result = jupiter.swap(&order, &Pubkey::new_unique()).await;
+    async fn buy_disabled() {
+        let jupiter = Jupiter::new(&config(false)).unwrap();
+        let result = jupiter.swap(&order(Side::Buy), &Pubkey::new_unique()).await;
         assert!(matches!(result, Err(Error::OrderNotSupported)));
     }
 
@@ -205,15 +205,31 @@ mod tests {
     #[tokio::test]
     #[ignore]
     async fn jupiter_live_sell() {
-        let jupiter = Jupiter::new(&config()).unwrap();
+        let jupiter = Jupiter::new(&config(false)).unwrap();
         // Any valid pubkey works for building instructions, the swap only runs
         // for real once the driver supplies its settlement signer.
         let swap = jupiter
-            .swap(&sell_order(), &Pubkey::from_str(WSOL).unwrap())
+            .swap(&order(Side::Sell), &Pubkey::from_str(WSOL).unwrap())
             .await
             .unwrap();
         assert_eq!(swap.in_amount, 1_000_000);
         assert!(swap.out_amount > 0);
         assert!(!swap.instructions.is_empty());
     }
+
+    /// Live Jupiter API. Needs network. Keyless works, set `JUPITER_API_KEY`
+    /// for headroom.
+    #[tokio::test]
+    #[ignore]
+    async fn jupiter_live_buy() {
+        let jupiter = Jupiter::new(&config(true)).unwrap();
+        // ExactOut: the swap delivers exactly the order's `amount` of buy mint.
+        let swap = jupiter
+            .swap(&order(Side::Buy), &Pubkey::from_str(WSOL).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(swap.out_amount, 1_000_000);
+        assert!(swap.in_amount > 0);
+        assert!(!swap.instructions.is_empty());
+    }
 }