@drift-labs/sdk 2.144.0-beta.2 → 2.144.0-beta.3

package/lib/node/titan/titanClient.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TitanClient = exports.SwapMode = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const msgpack_1 = require("@msgpack/msgpack");
+var SwapMode;
+(function (SwapMode) {
+    SwapMode["ExactIn"] = "ExactIn";
+    SwapMode["ExactOut"] = "ExactOut";
+})(SwapMode || (exports.SwapMode = SwapMode = {}));
+const TITAN_API_URL = 'https://api.titan.exchange';
+class TitanClient {
+    constructor({ connection, authToken, url, }) {
+        this.connection = connection;
+        this.authToken = authToken;
+        this.url = url !== null && url !== void 0 ? url : TITAN_API_URL;
+    }
+    /**
+     * Get routes for a swap
+     */
+    async getQuote({ inputMint, outputMint, amount, userPublicKey, maxAccounts = 50, // 50 is an estimated amount with buffer
+    slippageBps, swapMode, onlyDirectRoutes, excludeDexes, sizeConstraint, accountsLimitWritable, }) {
+        var _a;
+        const params = 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,
+            }),
+            ...(onlyDirectRoutes && {
+                onlyDirectRoutes: onlyDirectRoutes.toString(),
+            }),
+            ...(maxAccounts && { accountsLimitTotal: maxAccounts.toString() }),
+            ...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
+            ...(sizeConstraint && { sizeConstraint: sizeConstraint.toString() }),
+            ...(accountsLimitWritable && {
+                accountsLimitWritable: accountsLimitWritable.toString(),
+            }),
+        });
+        const 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) {
+            throw new Error(`Titan API error: ${response.status} ${response.statusText}`);
+        }
+        const buffer = await response.arrayBuffer();
+        const data = (0, msgpack_1.decode)(buffer);
+        const route = data.quotes[Object.keys(data.quotes).find((key) => key.toLowerCase() === 'titan') ||
+            ''];
+        if (!route) {
+            throw new Error('No routes available');
+        }
+        return {
+            inputMint: inputMint.toString(),
+            inAmount: amount.toString(),
+            outputMint: outputMint.toString(),
+            outAmount: route.outAmount.toString(),
+            swapMode: data.swapMode,
+            slippageBps: route.slippageBps,
+            platformFee: route.platformFee
+                ? {
+                    amount: route.platformFee.amount.toString(),
+                    feeBps: route.platformFee.fee_bps,
+                }
+                : undefined,
+            routePlan: ((_a = route.steps) === null || _a === void 0 ? void 0 : _a.map((step) => {
+                var _a;
+                return ({
+                    swapInfo: {
+                        ammKey: new web3_js_1.PublicKey(step.ammKey).toString(),
+                        label: step.label,
+                        inputMint: new web3_js_1.PublicKey(step.inputMint).toString(),
+                        outputMint: new web3_js_1.PublicKey(step.outputMint).toString(),
+                        inAmount: step.inAmount.toString(),
+                        outAmount: step.outAmount.toString(),
+                        feeAmount: ((_a = step.feeAmount) === null || _a === void 0 ? void 0 : _a.toString()) || '0',
+                        feeMint: step.feeMint ? new web3_js_1.PublicKey(step.feeMint).toString() : '',
+                    },
+                    percent: 100,
+                });
+            })) || [],
+            contextSlot: route.contextSlot,
+            timeTaken: route.timeTaken,
+        };
+    }
+    /**
+     * Get a swap transaction for quote
+     */
+    async getSwap({ inputMint, outputMint, amount, userPublicKey, maxAccounts = 50, // 50 is an estimated amount with buffer
+    slippageBps, swapMode, onlyDirectRoutes, excludeDexes, sizeConstraint, accountsLimitWritable, }) {
+        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 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');
+            }
+            throw new Error(`Titan API error: ${response.status} ${response.statusText}`);
+        }
+        const buffer = await response.arrayBuffer();
+        const data = (0, msgpack_1.decode)(buffer);
+        const route = data.quotes[Object.keys(data.quotes).find((key) => key.toLowerCase() === 'titan') ||
+            ''];
+        if (!route) {
+            throw new Error('No routes available');
+        }
+        if (route.instructions && route.instructions.length > 0) {
+            try {
+                const { transactionMessage, lookupTables } = await this.getTransactionMessageAndLookupTables(route, userPublicKey);
+                return { transactionMessage, lookupTables };
+            }
+            catch (err) {
+                throw new Error('Something went wrong with creating the Titan swap transaction. Please try again.');
+            }
+        }
+        throw new Error('No instructions provided in the route');
+    }
+    /**
+     * Get the titan instructions from transaction by filtering out instructions to compute budget and associated token programs
+     * @param transactionMessage the transaction message
+     * @param inputMint the input mint
+     * @param outputMint the output mint
+     */
+    getTitanInstructions({ transactionMessage, inputMint, outputMint, }) {
+        // Filter out common system instructions that can be handled by DriftClient
+        const filteredInstructions = transactionMessage.instructions.filter((instruction) => {
+            const programId = instruction.programId.toString();
+            // Filter out system programs
+            if (programId === 'ComputeBudget111111111111111111111111111111') {
+                return false;
+            }
+            if (programId === 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA') {
+                return false;
+            }
+            if (programId === '11111111111111111111111111111111') {
+                return false;
+            }
+            // Filter out Associated Token Account creation for input/output mints
+            if (programId === 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL') {
+                if (instruction.keys.length > 3) {
+                    const mint = instruction.keys[3].pubkey;
+                    if (mint.equals(inputMint) || mint.equals(outputMint)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        });
+        return filteredInstructions;
+    }
+    async getTransactionMessageAndLookupTables(route, userPublicKey) {
+        const solanaInstructions = route.instructions.map((instruction) => ({
+            programId: new web3_js_1.PublicKey(instruction.p),
+            keys: instruction.a.map((meta) => ({
+                pubkey: new web3_js_1.PublicKey(meta.p),
+                isSigner: meta.s,
+                isWritable: meta.w,
+            })),
+            data: Buffer.from(instruction.d),
+        }));
+        // Get recent blockhash
+        const { blockhash } = await this.connection.getLatestBlockhash();
+        // Build address lookup tables if provided
+        const addressLookupTables = [];
+        if (route.addressLookupTables && route.addressLookupTables.length > 0) {
+            for (const altPubkey of route.addressLookupTables) {
+                try {
+                    const altAccount = await this.connection.getAddressLookupTable(new web3_js_1.PublicKey(altPubkey));
+                    if (altAccount.value) {
+                        addressLookupTables.push(altAccount.value);
+                    }
+                }
+                catch (err) {
+                    console.warn(`Failed to fetch address lookup table:`, err);
+                }
+            }
+        }
+        const transactionMessage = new web3_js_1.TransactionMessage({
+            payerKey: userPublicKey,
+            recentBlockhash: blockhash,
+            instructions: solanaInstructions,
+        });
+        return { transactionMessage, lookupTables: addressLookupTables };
+    }
+}
+exports.TitanClient = TitanClient;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.144.0-beta.2",
+	"version": "2.144.0-beta.3",
 	"main": "lib/node/index.js",
 	"types": "lib/node/index.d.ts",
 	"module": "./lib/browser/index.js",
@@ -44,6 +44,7 @@
 		"@coral-xyz/anchor-30": "npm:@coral-xyz/anchor@0.30.1",
 		"@ellipsis-labs/phoenix-sdk": "1.4.5",
 		"@grpc/grpc-js": "1.14.0",
+		"@msgpack/msgpack": "^3.1.2",
 		"@openbook-dex/openbook-v2": "0.2.10",
 		"@project-serum/serum": "0.13.65",
 		"@pythnetwork/client": "2.5.3",

package/src/accounts/grpcDriftClientAccountSubscriberV2.ts

@@ -709,21 +709,6 @@ export class grpcDriftClientAccountSubscriberV2
 			await this.perpMarketsSubscriber.removeAccounts(
 				perpMarketPubkeysToRemove
 			);
-			// Clean up the mapping for removed perp markets
-			for (const pubkey of perpMarketPubkeysToRemove) {
-				const pubkeyString = pubkey.toBase58();
-				for (const [
-					marketIndex,
-					accountPubkey,
-				] of this.perpMarketIndexToAccountPubkeyMap.entries()) {
-					if (accountPubkey === pubkeyString) {
-						this.perpMarketIndexToAccountPubkeyMap.delete(marketIndex);
-						this.perpOracleMap.delete(marketIndex);
-						this.perpOracleStringMap.delete(marketIndex);
-						break;
-					}
-				}
-			}
 		}
 
 		// Remove accounts in batches - oracles

package/src/driftClient.ts

@@ -190,6 +190,7 @@ import { createMinimalEd25519VerifyIx } from './util/ed25519Utils';
 import {
 	createNativeInstructionDiscriminatorBuffer,
 	isVersionedTransaction,
+	MAX_TX_BYTE_SIZE,
 } from './tx/utils';
 import pythSolanaReceiverIdl from './idl/pyth_solana_receiver.json';
 import { asV0Tx, PullFeed, AnchorUtils } from '@switchboard-xyz/on-demand';
@@ -208,6 +209,12 @@ import {
 	isBuilderOrderReferral,
 	isBuilderOrderCompleted,
 } from './math/builder';
+import { TitanClient, SwapMode as TitanSwapMode } from './titan/titanClient';
+
+/**
+ * Union type for swap clients (Titan and Jupiter)
+ */
+export type SwapClient = TitanClient | JupiterClient;
 
 type RemainingAccountParams = {
 	userAccounts: UserAccount[];
@@ -5733,23 +5740,23 @@ export class DriftClient {
 	}
 
 	/**
-	 * Swap tokens in drift account using jupiter
-	 * @param jupiterClient jupiter client to find routes and jupiter instructions
+	 * Swap tokens in drift account using titan or jupiter
+	 * @param swapClient swap client to find routes and instructions (Titan or Jupiter)
 	 * @param outMarketIndex the market index of the token you're buying
 	 * @param inMarketIndex the market index of the token you're selling
-	 * @param outAssociatedTokenAccount the token account to receive the token being sold on jupiter
+	 * @param outAssociatedTokenAccount the token account to receive the token being sold on titan or jupiter
 	 * @param inAssociatedTokenAccount the token account to
 	 * @param amount the amount of TokenIn, regardless of swapMode
-	 * @param slippageBps the max slippage passed to jupiter api
-	 * @param swapMode jupiter swapMode (ExactIn or ExactOut), default is ExactIn
-	 * @param route the jupiter route to use for the swap
+	 * @param slippageBps the max slippage passed to titan or jupiter api
+	 * @param swapMode titan or jupiter swapMode (ExactIn or ExactOut), default is ExactIn
+	 * @param route the titan or jupiter route to use for the swap
 	 * @param reduceOnly specify if In or Out token on the drift account must reduceOnly, checked at end of swap
 	 * @param v6 pass in the quote response from Jupiter quote's API (deprecated, use quote instead)
 	 * @param quote pass in the quote response from Jupiter quote's API
 	 * @param txParams
 	 */
 	public async swap({
-		jupiterClient,
+		swapClient,
 		outMarketIndex,
 		inMarketIndex,
 		outAssociatedTokenAccount,
@@ -5763,7 +5770,7 @@ export class DriftClient {
 		quote,
 		onlyDirectRoutes = false,
 	}: {
-		jupiterClient: JupiterClient;
+		swapClient: SwapClient;
 		outMarketIndex: number;
 		inMarketIndex: number;
 		outAssociatedTokenAccount?: PublicKey;
@@ -5779,21 +5786,45 @@ export class DriftClient {
 		};
 		quote?: QuoteResponse;
 	}): Promise<TransactionSignature> {
-		const quoteToUse = quote ?? v6?.quote;
+		let res: {
+			ixs: TransactionInstruction[];
+			lookupTables: AddressLookupTableAccount[];
+		};
+
+		if (swapClient instanceof TitanClient) {
+			res = await this.getTitanSwapIx({
+				titanClient: swapClient,
+				outMarketIndex,
+				inMarketIndex,
+				outAssociatedTokenAccount,
+				inAssociatedTokenAccount,
+				amount,
+				slippageBps,
+				swapMode,
+				onlyDirectRoutes,
+				reduceOnly,
+			});
+		} else if (swapClient instanceof JupiterClient) {
+			const quoteToUse = quote ?? v6?.quote;
+			res = await this.getJupiterSwapIxV6({
+				jupiterClient: swapClient,
+				outMarketIndex,
+				inMarketIndex,
+				outAssociatedTokenAccount,
+				inAssociatedTokenAccount,
+				amount,
+				slippageBps,
+				swapMode,
+				quote: quoteToUse,
+				reduceOnly,
+				onlyDirectRoutes,
+			});
+		} else {
+			throw new Error(
+				'Invalid swap client type. Must be TitanClient or JupiterClient.'
+			);
+		}
 
-		const res = await this.getJupiterSwapIxV6({
-			jupiterClient,
-			outMarketIndex,
-			inMarketIndex,
-			outAssociatedTokenAccount,
-			inAssociatedTokenAccount,
-			amount,
-			slippageBps,
-			swapMode,
-			quote: quoteToUse,
-			reduceOnly,
-			onlyDirectRoutes,
-		});
 		const ixs = res.ixs;
 		const lookupTables = res.lookupTables;
 
@@ -5811,6 +5842,126 @@ export class DriftClient {
 		return txSig;
 	}
 
+	public async getTitanSwapIx({
+		titanClient,
+		outMarketIndex,
+		inMarketIndex,
+		outAssociatedTokenAccount,
+		inAssociatedTokenAccount,
+		amount,
+		slippageBps,
+		swapMode,
+		onlyDirectRoutes,
+		reduceOnly,
+		userAccountPublicKey,
+	}: {
+		titanClient: TitanClient;
+		outMarketIndex: number;
+		inMarketIndex: number;
+		outAssociatedTokenAccount?: PublicKey;
+		inAssociatedTokenAccount?: PublicKey;
+		amount: BN;
+		slippageBps?: number;
+		swapMode?: string;
+		onlyDirectRoutes?: boolean;
+		reduceOnly?: SwapReduceOnly;
+		userAccountPublicKey?: PublicKey;
+	}): Promise<{
+		ixs: TransactionInstruction[];
+		lookupTables: AddressLookupTableAccount[];
+	}> {
+		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 = [];
+		if (!outAssociatedTokenAccount) {
+			const tokenProgram = this.getTokenProgramForSpotMarket(outMarket);
+			outAssociatedTokenAccount = await this.getAssociatedTokenAccount(
+				outMarket.marketIndex,
+				false,
+				tokenProgram
+			);
+
+			const accountInfo = await this.connection.getAccountInfo(
+				outAssociatedTokenAccount
+			);
+			if (!accountInfo) {
+				preInstructions.push(
+					this.createAssociatedTokenAccountIdempotentInstruction(
+						outAssociatedTokenAccount,
+						this.provider.wallet.publicKey,
+						this.provider.wallet.publicKey,
+						outMarket.mint,
+						tokenProgram
+					)
+				);
+			}
+		}
+
+		if (!inAssociatedTokenAccount) {
+			const tokenProgram = this.getTokenProgramForSpotMarket(inMarket);
+			inAssociatedTokenAccount = await this.getAssociatedTokenAccount(
+				inMarket.marketIndex,
+				false,
+				tokenProgram
+			);
+
+			const accountInfo = await this.connection.getAccountInfo(
+				inAssociatedTokenAccount
+			);
+			if (!accountInfo) {
+				preInstructions.push(
+					this.createAssociatedTokenAccountIdempotentInstruction(
+						inAssociatedTokenAccount,
+						this.provider.wallet.publicKey,
+						this.provider.wallet.publicKey,
+						inMarket.mint,
+						tokenProgram
+					)
+				);
+			}
+		}
+
+		const { beginSwapIx, endSwapIx } = await this.getSwapIx({
+			outMarketIndex,
+			inMarketIndex,
+			amountIn: isExactOut ? exactOutBufferedAmountIn : amount,
+			inTokenAccount: inAssociatedTokenAccount,
+			outTokenAccount: outAssociatedTokenAccount,
+			reduceOnly,
+			userAccountPublicKey,
+		});
+
+		const { transactionMessage, lookupTables } = await titanClient.getSwap({
+			inputMint: inMarket.mint,
+			outputMint: outMarket.mint,
+			amount,
+			userPublicKey: this.provider.wallet.publicKey,
+			slippageBps,
+			swapMode: isExactOut ? TitanSwapMode.ExactOut : TitanSwapMode.ExactIn,
+			onlyDirectRoutes,
+			sizeConstraint: MAX_TX_BYTE_SIZE - 375, // buffer for drift instructions
+		});
+
+		const titanInstructions = titanClient.getTitanInstructions({
+			transactionMessage,
+			inputMint: inMarket.mint,
+			outputMint: outMarket.mint,
+		});
+
+		const ixs = [
+			...preInstructions,
+			beginSwapIx,
+			...titanInstructions,
+			endSwapIx,
+		];
+
+		return { ixs, lookupTables };
+	}
+
 	public async getJupiterSwapIxV6({
 		jupiterClient,
 		outMarketIndex,