@drift-labs/sdk 2.144.0-beta.6 → 2.145.0-beta.1

package/lib/node/swap/UnifiedSwapClient.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnifiedSwapClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const jupiterClient_1 = require("../jupiter/jupiterClient");
+const titanClient_1 = require("../titan/titanClient");
+class UnifiedSwapClient {
+    constructor({ clientType, connection, authToken, url, }) {
+        this.clientType = clientType;
+        if (clientType === 'jupiter') {
+            this.client = new jupiterClient_1.JupiterClient({
+                connection,
+                url,
+            });
+        }
+        else if (clientType === 'titan') {
+            if (!authToken) {
+                throw new Error('authToken is required for Titan client');
+            }
+            this.client = new titanClient_1.TitanClient({
+                connection,
+                authToken,
+                url,
+            });
+        }
+        else {
+            throw new Error(`Unsupported client type: ${clientType}`);
+        }
+    }
+    /**
+     * Get a swap quote from the underlying client
+     */
+    async getQuote(params) {
+        if (this.clientType === 'jupiter') {
+            const jupiterClient = this.client;
+            const { userPublicKey: _userPublicKey, // Not needed for Jupiter
+            sizeConstraint: _sizeConstraint, // Jupiter-specific params to exclude
+            accountsLimitWritable: _accountsLimitWritable, ...jupiterParams } = params;
+            return await jupiterClient.getQuote(jupiterParams);
+        }
+        else {
+            const titanClient = this.client;
+            const { autoSlippage: _autoSlippage, // Titan-specific params to exclude
+            maxAutoSlippageBps: _maxAutoSlippageBps, usdEstimate: _usdEstimate, ...titanParams } = params;
+            if (!titanParams.userPublicKey) {
+                throw new Error('userPublicKey is required for Titan quotes');
+            }
+            // Cast to ensure TypeScript knows userPublicKey is defined
+            const titanParamsWithUser = {
+                ...titanParams,
+                userPublicKey: titanParams.userPublicKey,
+                swapMode: titanParams.swapMode, // Titan expects string
+            };
+            return await titanClient.getQuote(titanParamsWithUser);
+        }
+    }
+    /**
+     * Get a swap transaction from the underlying client
+     */
+    async getSwap(params) {
+        if (this.clientType === 'jupiter') {
+            const jupiterClient = this.client;
+            // Cast the quote to Jupiter's QuoteResponse type
+            const jupiterParams = {
+                ...params,
+                quote: params.quote,
+            };
+            const transaction = await jupiterClient.getSwap(jupiterParams);
+            return { transaction };
+        }
+        else {
+            const titanClient = this.client;
+            const { quote, userPublicKey, slippageBps } = params;
+            // For Titan, we need to reconstruct the parameters from the quote
+            const titanQuote = quote;
+            const result = await titanClient.getSwap({
+                inputMint: new web3_js_1.PublicKey(titanQuote.inputMint),
+                outputMint: new web3_js_1.PublicKey(titanQuote.outputMint),
+                amount: new anchor_1.BN(titanQuote.inAmount),
+                userPublicKey,
+                slippageBps: slippageBps || titanQuote.slippageBps,
+                swapMode: titanQuote.swapMode,
+            });
+            return {
+                transactionMessage: result.transactionMessage,
+                lookupTables: result.lookupTables,
+            };
+        }
+    }
+    /**
+     * Get swap instructions from the underlying client (Jupiter or Titan)
+     * This is the core swap logic without any context preparation
+     */
+    async getSwapInstructions({ inputMint, outputMint, amount, userPublicKey, slippageBps, swapMode = 'ExactIn', onlyDirectRoutes = false, quote, sizeConstraint, }) {
+        const isExactOut = swapMode === 'ExactOut';
+        let swapInstructions;
+        let lookupTables;
+        if (this.clientType === 'jupiter') {
+            const jupiterClient = this.client;
+            // Get quote if not provided
+            let finalQuote = quote;
+            if (!finalQuote) {
+                finalQuote = await jupiterClient.getQuote({
+                    inputMint,
+                    outputMint,
+                    amount,
+                    slippageBps,
+                    swapMode,
+                    onlyDirectRoutes,
+                });
+            }
+            if (!finalQuote) {
+                throw new Error("Could not fetch Jupiter's quote. Please try again.");
+            }
+            // Get swap transaction and extract instructions
+            const transaction = await jupiterClient.getSwap({
+                quote: finalQuote,
+                userPublicKey,
+                slippageBps,
+            });
+            const { transactionMessage, lookupTables: jupiterLookupTables } = await jupiterClient.getTransactionMessageAndLookupTables({
+                transaction,
+            });
+            swapInstructions = jupiterClient.getJupiterInstructions({
+                transactionMessage,
+                inputMint,
+                outputMint,
+            });
+            lookupTables = jupiterLookupTables;
+        }
+        else {
+            const titanClient = this.client;
+            // For Titan, get swap directly (it handles quote internally)
+            const { transactionMessage, lookupTables: titanLookupTables } = await titanClient.getSwap({
+                inputMint,
+                outputMint,
+                amount,
+                userPublicKey,
+                slippageBps,
+                swapMode: isExactOut ? titanClient_1.SwapMode.ExactOut : titanClient_1.SwapMode.ExactIn,
+                onlyDirectRoutes,
+                sizeConstraint: sizeConstraint || 1280 - 375, // MAX_TX_BYTE_SIZE - buffer for drift instructions
+            });
+            swapInstructions = titanClient.getTitanInstructions({
+                transactionMessage,
+                inputMint,
+                outputMint,
+            });
+            lookupTables = titanLookupTables;
+        }
+        return { instructions: swapInstructions, lookupTables };
+    }
+    /**
+     * Get the underlying client instance
+     */
+    getClient() {
+        return this.client;
+    }
+    /**
+     * Get the client type
+     */
+    getClientType() {
+        return this.clientType;
+    }
+    /**
+     * Check if this is a Jupiter client
+     */
+    isJupiter() {
+        return this.clientType === 'jupiter';
+    }
+    /**
+     * Check if this is a Titan client
+     */
+    isTitan() {
+        return this.clientType === 'titan';
+    }
+}
+exports.UnifiedSwapClient = UnifiedSwapClient;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.144.0-beta.6",
+	"version": "2.145.0-beta.1",
 	"main": "lib/node/index.js",
 	"types": "lib/node/index.d.ts",
 	"module": "./lib/browser/index.js",

package/src/driftClient.ts

@@ -157,11 +157,8 @@ import { isSpotPositionAvailable } from './math/spotPosition';
 import { calculateMarketMaxAvailableInsurance } from './math/market';
 import { fetchUserStatsAccount } from './accounts/fetch';
 import { castNumberToSpotPrecision } from './math/spotMarket';
-import {
-	JupiterClient,
-	QuoteResponse,
-	SwapMode,
-} from './jupiter/jupiterClient';
+import { JupiterClient, QuoteResponse } from './jupiter/jupiterClient';
+import { SwapMode } from './swap/UnifiedSwapClient';
 import { getNonIdleUserFilter } from './memcmp';
 import { UserStatsSubscriptionConfig } from './userStatsConfig';
 import { getMarinadeDepositIx, getMarinadeFinanceProgram } from './marinade';
@@ -210,9 +207,11 @@ import {
 	isBuilderOrderCompleted,
 } from './math/builder';
 import { TitanClient, SwapMode as TitanSwapMode } from './titan/titanClient';
+import { UnifiedSwapClient } from './swap/UnifiedSwapClient';
 
 /**
- * Union type for swap clients (Titan and Jupiter)
+ * Union type for swap clients (Titan and Jupiter) - Legacy type
+ * @deprecated Use UnifiedSwapClient class instead
  */
 export type SwapClient = TitanClient | JupiterClient;
 
@@ -5772,7 +5771,7 @@ export class DriftClient {
 		quote,
 		onlyDirectRoutes = false,
 	}: {
-		swapClient: SwapClient;
+		swapClient: UnifiedSwapClient | SwapClient;
 		outMarketIndex: number;
 		inMarketIndex: number;
 		outAssociatedTokenAccount?: PublicKey;
@@ -5793,7 +5792,23 @@ export class DriftClient {
 			lookupTables: AddressLookupTableAccount[];
 		};
 
-		if (swapClient instanceof TitanClient) {
+		// Use unified SwapClient if available
+		if (swapClient instanceof UnifiedSwapClient) {
+			res = await this.getSwapIxV2({
+				swapClient,
+				outMarketIndex,
+				inMarketIndex,
+				outAssociatedTokenAccount,
+				inAssociatedTokenAccount,
+				amount,
+				slippageBps,
+				swapMode,
+				onlyDirectRoutes,
+				reduceOnly,
+				quote,
+				v6,
+			});
+		} else if (swapClient instanceof TitanClient) {
 			res = await this.getTitanSwapIx({
 				titanClient: swapClient,
 				outMarketIndex,
@@ -5823,7 +5838,7 @@ export class DriftClient {
 			});
 		} else {
 			throw new Error(
-				'Invalid swap client type. Must be TitanClient or JupiterClient.'
+				'Invalid swap client type. Must be SwapClient, TitanClient, or JupiterClient.'
 			);
 		}
 
@@ -6243,6 +6258,134 @@ export class DriftClient {
 		return { beginSwapIx, endSwapIx };
 	}
 
+	public async getSwapIxV2({
+		swapClient,
+		outMarketIndex,
+		inMarketIndex,
+		outAssociatedTokenAccount,
+		inAssociatedTokenAccount,
+		amount,
+		slippageBps,
+		swapMode,
+		onlyDirectRoutes,
+		reduceOnly,
+		quote,
+		v6,
+	}: {
+		swapClient: UnifiedSwapClient;
+		outMarketIndex: number;
+		inMarketIndex: number;
+		outAssociatedTokenAccount?: PublicKey;
+		inAssociatedTokenAccount?: PublicKey;
+		amount: BN;
+		slippageBps?: number;
+		swapMode?: SwapMode;
+		onlyDirectRoutes?: boolean;
+		reduceOnly?: SwapReduceOnly;
+		quote?: QuoteResponse;
+		v6?: {
+			quote?: QuoteResponse;
+		};
+	}): Promise<{
+		ixs: TransactionInstruction[];
+		lookupTables: AddressLookupTableAccount[];
+	}> {
+		// Get market accounts to determine mints
+		const outMarket = this.getSpotMarketAccount(outMarketIndex);
+		const inMarket = this.getSpotMarketAccount(inMarketIndex);
+
+		const isExactOut = swapMode === 'ExactOut';
+		const exactOutBufferedAmountIn = amount.muln(1001).divn(1000); // Add 10bp buffer
+
+		const preInstructions: TransactionInstruction[] = [];
+
+		// Handle token accounts if not provided
+		let finalOutAssociatedTokenAccount = outAssociatedTokenAccount;
+		let finalInAssociatedTokenAccount = inAssociatedTokenAccount;
+
+		if (!finalOutAssociatedTokenAccount) {
+			const tokenProgram = this.getTokenProgramForSpotMarket(outMarket);
+			finalOutAssociatedTokenAccount = await this.getAssociatedTokenAccount(
+				outMarket.marketIndex,
+				false,
+				tokenProgram
+			);
+
+			const accountInfo = await this.connection.getAccountInfo(
+				finalOutAssociatedTokenAccount
+			);
+			if (!accountInfo) {
+				preInstructions.push(
+					this.createAssociatedTokenAccountIdempotentInstruction(
+						finalOutAssociatedTokenAccount,
+						this.provider.wallet.publicKey,
+						this.provider.wallet.publicKey,
+						outMarket.mint,
+						tokenProgram
+					)
+				);
+			}
+		}
+
+		if (!finalInAssociatedTokenAccount) {
+			const tokenProgram = this.getTokenProgramForSpotMarket(inMarket);
+			finalInAssociatedTokenAccount = await this.getAssociatedTokenAccount(
+				inMarket.marketIndex,
+				false,
+				tokenProgram
+			);
+
+			const accountInfo = await this.connection.getAccountInfo(
+				finalInAssociatedTokenAccount
+			);
+			if (!accountInfo) {
+				preInstructions.push(
+					this.createAssociatedTokenAccountIdempotentInstruction(
+						finalInAssociatedTokenAccount,
+						this.provider.wallet.publicKey,
+						this.provider.wallet.publicKey,
+						inMarket.mint,
+						tokenProgram
+					)
+				);
+			}
+		}
+
+		// Get drift swap instructions for begin and end
+		const { beginSwapIx, endSwapIx } = await this.getSwapIx({
+			outMarketIndex,
+			inMarketIndex,
+			amountIn: isExactOut ? exactOutBufferedAmountIn : amount,
+			inTokenAccount: finalInAssociatedTokenAccount,
+			outTokenAccount: finalOutAssociatedTokenAccount,
+			reduceOnly,
+		});
+
+		// Get core swap instructions from SwapClient
+		const swapResult = await swapClient.getSwapInstructions({
+			inputMint: inMarket.mint,
+			outputMint: outMarket.mint,
+			amount,
+			userPublicKey: this.provider.wallet.publicKey,
+			slippageBps,
+			swapMode,
+			onlyDirectRoutes,
+			quote: quote ?? v6?.quote,
+		});
+
+		const allInstructions = [
+			...preInstructions,
+			beginSwapIx,
+			...swapResult.instructions,
+			endSwapIx,
+		];
+
+		return {
+			ixs: allInstructions,
+			lookupTables: swapResult.lookupTables,
+		};
+	}
+
 	public async stakeForMSOL({ amount }: { amount: BN }): Promise<TxSigAndSlot> {
 		const ixs = await this.getStakeForMSOLIx({ amount });
 		const tx = await this.buildTransaction(ixs);

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.143.0",
+  "version": "2.144.0",
   "name": "drift",
   "instructions": [
     {

package/src/index.ts

@@ -53,7 +53,8 @@ export * from './events/webSocketLogProvider';
 export * from './events/parse';
 export * from './events/pollingLogProvider';
 export * from './jupiter/jupiterClient';
-export { TitanClient } from './titan/titanClient';
+// Primary swap client interface - use this for all swap operations
+export * from './swap/UnifiedSwapClient';
 export * from './math/auction';
 export * from './math/builder';
 export * from './math/spotMarket';

package/src/jupiter/jupiterClient.ts

@@ -8,8 +8,7 @@ import {
 } from '@solana/web3.js';
 import fetch from 'node-fetch';
 import { BN } from '@coral-xyz/anchor';
-
-export type SwapMode = 'ExactIn' | 'ExactOut';
+import { SwapMode } from '../swap/UnifiedSwapClient';
 
 export interface MarketInfo {
 	id: string;