@drift-labs/sdk 2.152.0-beta.2 → 2.153.0-beta.1

package/src/titan/titanClient.ts

@@ -94,6 +94,8 @@ export class TitanClient {
 	url: string;
 	connection: Connection;
 	proxyUrl?: string;
+	private lastQuoteData?: SwapQuotes;
+	private lastQuoteParams?: string;
 
 	constructor({
 		connection,
@@ -112,15 +114,12 @@ export class TitanClient {
 		this.proxyUrl = proxyUrl;
 	}
 
-	/**
-	 * Get routes for a swap
-	 */
-	public async getQuote({
+	private buildParams({
 		inputMint,
 		outputMint,
 		amount,
 		userPublicKey,
-		maxAccounts = 50, // 50 is an estimated amount with buffer
+		maxAccounts,
 		slippageBps,
 		swapMode,
 		onlyDirectRoutes,
@@ -134,32 +133,78 @@ export class TitanClient {
 		userPublicKey: PublicKey;
 		maxAccounts?: number;
 		slippageBps?: number;
-		swapMode?: string;
+		swapMode?: string | SwapMode;
 		onlyDirectRoutes?: boolean;
 		excludeDexes?: string[];
 		sizeConstraint?: number;
 		accountsLimitWritable?: number;
-	}): Promise<QuoteResponse> {
-		const params = new URLSearchParams({
+	}): URLSearchParams {
+		// Normalize swapMode to enum value
+		const normalizedSwapMode =
+			swapMode === 'ExactOut' || swapMode === SwapMode.ExactOut
+				? SwapMode.ExactOut
+				: SwapMode.ExactIn;
+
+		return new URLSearchParams({
 			inputMint: inputMint.toString(),
 			outputMint: outputMint.toString(),
 			amount: amount.toString(),
 			userPublicKey: userPublicKey.toString(),
 			...(slippageBps && { slippageBps: slippageBps.toString() }),
-			...(swapMode && {
-				swapMode:
-					swapMode === 'ExactOut' ? SwapMode.ExactOut : SwapMode.ExactIn,
-			}),
+			...(swapMode && { swapMode: normalizedSwapMode.toString() }),
+			...(maxAccounts && { accountsLimitTotal: maxAccounts.toString() }),
+			...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
 			...(onlyDirectRoutes && {
 				onlyDirectRoutes: onlyDirectRoutes.toString(),
 			}),
-			...(maxAccounts && { accountsLimitTotal: maxAccounts.toString() }),
-			...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
 			...(sizeConstraint && { sizeConstraint: sizeConstraint.toString() }),
 			...(accountsLimitWritable && {
 				accountsLimitWritable: accountsLimitWritable.toString(),
 			}),
 		});
+	}
+
+	/**
+	 * Get routes for a swap
+	 */
+	public async getQuote({
+		inputMint,
+		outputMint,
+		amount,
+		userPublicKey,
+		maxAccounts = 50, // 50 is an estimated amount with buffer
+		slippageBps,
+		swapMode,
+		onlyDirectRoutes,
+		excludeDexes,
+		sizeConstraint,
+		accountsLimitWritable,
+	}: {
+		inputMint: PublicKey;
+		outputMint: PublicKey;
+		amount: BN;
+		userPublicKey: PublicKey;
+		maxAccounts?: number;
+		slippageBps?: number;
+		swapMode?: string;
+		onlyDirectRoutes?: boolean;
+		excludeDexes?: string[];
+		sizeConstraint?: number;
+		accountsLimitWritable?: number;
+	}): Promise<QuoteResponse> {
+		const params = this.buildParams({
+			inputMint,
+			outputMint,
+			amount,
+			userPublicKey,
+			maxAccounts,
+			slippageBps,
+			swapMode,
+			onlyDirectRoutes,
+			excludeDexes,
+			sizeConstraint,
+			accountsLimitWritable,
+		});
 
 		let response: Response;
 
@@ -195,11 +240,12 @@ export class TitanClient {
 		const buffer = await response.arrayBuffer();
 		const data = decode(buffer) as SwapQuotes;
 
-		const route =
-			data.quotes[
-				Object.keys(data.quotes).find((key) => key.toLowerCase() === 'titan') ||
-					''
-			];
+		// Cache the quote data and parameters for later use in getSwap
+		this.lastQuoteData = data;
+		this.lastQuoteParams = params.toString();
+
+		// We are only querying for the best avaiable route so use that
+		const route = data.quotes[Object.keys(data.quotes)[0]];
 
 		if (!route) {
 			throw new Error('No routes available');
@@ -268,66 +314,32 @@ export class TitanClient {
 		transactionMessage: TransactionMessage;
 		lookupTables: AddressLookupTableAccount[];
 	}> {
-		const params = new URLSearchParams({
-			inputMint: inputMint.toString(),
-			outputMint: outputMint.toString(),
-			amount: amount.toString(),
-			userPublicKey: userPublicKey.toString(),
-			...(slippageBps && { slippageBps: slippageBps.toString() }),
-			...(swapMode && { swapMode: swapMode }),
-			...(maxAccounts && { accountsLimitTotal: maxAccounts.toString() }),
-			...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
-			...(onlyDirectRoutes && {
-				onlyDirectRoutes: onlyDirectRoutes.toString(),
-			}),
-			...(sizeConstraint && { sizeConstraint: sizeConstraint.toString() }),
-			...(accountsLimitWritable && {
-				accountsLimitWritable: accountsLimitWritable.toString(),
-			}),
+		const params = this.buildParams({
+			inputMint,
+			outputMint,
+			amount,
+			userPublicKey,
+			maxAccounts,
+			slippageBps,
+			swapMode,
+			onlyDirectRoutes,
+			excludeDexes,
+			sizeConstraint,
+			accountsLimitWritable,
 		});
 
-		let response: Response;
-
-		if (this.proxyUrl) {
-			// Use proxy route - send parameters in request body
-			response = await fetch(this.proxyUrl, {
-				method: 'POST',
-				headers: {
-					'Content-Type': 'application/json',
-				},
-				body: JSON.stringify(Object.fromEntries(params.entries())),
-			});
-		} else {
-			// Direct request to Titan API
-			response = await fetch(
-				`${this.url}/api/v1/quote/swap?${params.toString()}`,
-				{
-					headers: {
-						Accept: 'application/vnd.msgpack',
-						'Accept-Encoding': 'gzip, deflate, br',
-						Authorization: `Bearer ${this.authToken}`,
-					},
-				}
-			);
-		}
-
-		if (!response.ok) {
-			if (response.status === 404) {
-				throw new Error('No routes available');
-			}
+		// Check if we have cached quote data that matches the current parameters
+		if (!this.lastQuoteData || this.lastQuoteParams !== params.toString()) {
 			throw new Error(
-				`Titan API error: ${response.status} ${response.statusText}`
+				'No matching quote data found. Please get a fresh quote before attempting to swap.'
 			);
 		}
 
-		const buffer = await response.arrayBuffer();
-		const data = decode(buffer) as SwapQuotes;
+		// Reuse the cached quote data
+		const data = this.lastQuoteData;
 
-		const route =
-			data.quotes[
-				Object.keys(data.quotes).find((key) => key.toLowerCase() === 'titan') ||
-					''
-			];
+		// We are only querying for the best avaiable route so use that
+		const route = data.quotes[Object.keys(data.quotes)[0]];
 
 		if (!route) {
 			throw new Error('No routes available');
@@ -342,6 +354,10 @@ export class TitanClient {
 				throw new Error(
 					'Something went wrong with creating the Titan swap transaction. Please try again.'
 				);
+			} finally {
+				// Clear cached quote data after use
+				this.lastQuoteData = undefined;
+				this.lastQuoteParams = undefined;
 			}
 		}
 		throw new Error('No instructions provided in the route');

package/src/user.ts

@@ -4587,7 +4587,7 @@ export class User {
 		return calc;
 	}
 
-	private isPerpPositionIsolated(perpPosition: PerpPosition): boolean {
+	public isPerpPositionIsolated(perpPosition: PerpPosition): boolean {
 		return (perpPosition.positionFlag & PositionFlag.IsolatedPosition) !== 0;
 	}
 }