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

package/VERSION

@@ -1 +1 @@
-2.144.0-beta.6
+2.145.0-beta.1

package/lib/browser/driftClient.d.ts

@@ -18,7 +18,8 @@ import { User } from './user';
 import { UserSubscriptionConfig } from './userConfig';
 import { DriftEnv } from './config';
 import { UserStats } from './userStats';
-import { JupiterClient, QuoteResponse, SwapMode } from './jupiter/jupiterClient';
+import { JupiterClient, QuoteResponse } from './jupiter/jupiterClient';
+import { SwapMode } from './swap/UnifiedSwapClient';
 import { UserStatsSubscriptionConfig } from './userStatsConfig';
 import { TxHandler } from './tx/txHandler';
 import { WormholeCoreBridgeSolana } from '@pythnetwork/pyth-solana-receiver/lib/idl/wormhole_core_bridge_solana';
@@ -27,8 +28,10 @@ import { Slothash } from './slot/SlothashSubscriber';
 import { SignedMsgOrderParams } from './types';
 import { RevenueShareEscrowMap } from './userMap/revenueShareEscrowMap';
 import { TitanClient } 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;
 type RemainingAccountParams = {
@@ -552,7 +555,7 @@ export declare class DriftClient {
      * @param txParams
      */
     swap({ swapClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, reduceOnly, txParams, v6, quote, onlyDirectRoutes, }: {
-        swapClient: SwapClient;
+        swapClient: UnifiedSwapClient | SwapClient;
         outMarketIndex: number;
         inMarketIndex: number;
         outAssociatedTokenAccount?: PublicKey;
@@ -626,6 +629,25 @@ export declare class DriftClient {
         beginSwapIx: TransactionInstruction;
         endSwapIx: TransactionInstruction;
     }>;
+    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[];
+    }>;
     stakeForMSOL({ amount }: {
         amount: BN;
     }): Promise<TxSigAndSlot>;

package/lib/browser/driftClient.js

@@ -76,6 +76,7 @@ const webSocketDriftClientAccountSubscriber_1 = require("./accounts/webSocketDri
 const orders_1 = require("./math/orders");
 const builder_1 = require("./math/builder");
 const titanClient_1 = require("./titan/titanClient");
+const UnifiedSwapClient_1 = require("./swap/UnifiedSwapClient");
 /**
  * # DriftClient
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -3120,7 +3121,24 @@ class DriftClient {
      */
     async swap({ swapClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, reduceOnly, txParams, v6, quote, onlyDirectRoutes = false, }) {
         let res;
-        if (swapClient instanceof titanClient_1.TitanClient) {
+        // Use unified SwapClient if available
+        if (swapClient instanceof UnifiedSwapClient_1.UnifiedSwapClient) {
+            res = await this.getSwapIxV2({
+                swapClient,
+                outMarketIndex,
+                inMarketIndex,
+                outAssociatedTokenAccount,
+                inAssociatedTokenAccount,
+                amount,
+                slippageBps,
+                swapMode,
+                onlyDirectRoutes,
+                reduceOnly,
+                quote,
+                v6,
+            });
+        }
+        else if (swapClient instanceof titanClient_1.TitanClient) {
             res = await this.getTitanSwapIx({
                 titanClient: swapClient,
                 outMarketIndex,
@@ -3151,7 +3169,7 @@ class DriftClient {
             });
         }
         else {
-            throw new Error('Invalid swap client type. Must be TitanClient or JupiterClient.');
+            throw new Error('Invalid swap client type. Must be SwapClient, TitanClient, or JupiterClient.');
         }
         const ixs = res.ixs;
         const lookupTables = res.lookupTables;
@@ -3373,6 +3391,63 @@ class DriftClient {
         });
         return { beginSwapIx, endSwapIx };
     }
+    async getSwapIxV2({ swapClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, reduceOnly, quote, v6, }) {
+        // 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 = [];
+        // 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 !== null && quote !== void 0 ? quote : v6 === null || v6 === void 0 ? void 0 : v6.quote,
+        });
+        const allInstructions = [
+            ...preInstructions,
+            beginSwapIx,
+            ...swapResult.instructions,
+            endSwapIx,
+        ];
+        return {
+            ixs: allInstructions,
+            lookupTables: swapResult.lookupTables,
+        };
+    }
     async stakeForMSOL({ amount }) {
         const ixs = await this.getStakeForMSOLIx({ amount });
         const tx = await this.buildTransaction(ixs);

package/lib/browser/idl/drift.json

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

package/lib/browser/index.d.ts

@@ -52,7 +52,7 @@ export * from './events/webSocketLogProvider';
 export * from './events/parse';
 export * from './events/pollingLogProvider';
 export * from './jupiter/jupiterClient';
-export { TitanClient } from './titan/titanClient';
+export * from './swap/UnifiedSwapClient';
 export * from './math/auction';
 export * from './math/builder';
 export * from './math/spotMarket';

package/lib/browser/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pyth = exports.PublicKey = exports.BN = exports.TitanClient = exports.CustomizedCadenceBulkAccountLoader = exports.WebSocketDriftClientAccountSubscriberV2 = exports.WebSocketProgramAccountsSubscriberV2 = exports.WebSocketProgramUserAccountSubscriber = exports.WebSocketProgramAccountSubscriber = exports.WebSocketAccountSubscriberV2 = void 0;
+exports.pyth = exports.PublicKey = exports.BN = exports.CustomizedCadenceBulkAccountLoader = exports.WebSocketDriftClientAccountSubscriberV2 = exports.WebSocketProgramAccountsSubscriberV2 = exports.WebSocketProgramUserAccountSubscriber = exports.WebSocketProgramAccountSubscriber = exports.WebSocketAccountSubscriberV2 = void 0;
 const anchor_1 = require("@coral-xyz/anchor");
 Object.defineProperty(exports, "BN", { enumerable: true, get: function () { return anchor_1.BN; } });
 const web3_js_1 = require("@solana/web3.js");
@@ -81,8 +81,8 @@ __exportStar(require("./events/webSocketLogProvider"), exports);
 __exportStar(require("./events/parse"), exports);
 __exportStar(require("./events/pollingLogProvider"), exports);
 __exportStar(require("./jupiter/jupiterClient"), exports);
-var titanClient_1 = require("./titan/titanClient");
-Object.defineProperty(exports, "TitanClient", { enumerable: true, get: function () { return titanClient_1.TitanClient; } });
+// Primary swap client interface - use this for all swap operations
+__exportStar(require("./swap/UnifiedSwapClient"), exports);
 __exportStar(require("./math/auction"), exports);
 __exportStar(require("./math/builder"), exports);
 __exportStar(require("./math/spotMarket"), exports);

package/lib/browser/jupiter/jupiterClient.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import { AddressLookupTableAccount, Connection, PublicKey, TransactionInstruction, TransactionMessage, VersionedTransaction } from '@solana/web3.js';
 import { BN } from '@coral-xyz/anchor';
-export type SwapMode = 'ExactIn' | 'ExactOut';
+import { SwapMode } from '../swap/UnifiedSwapClient';
 export interface MarketInfo {
     id: string;
     inAmount: number;

package/lib/browser/swap/UnifiedSwapClient.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="bn.js" />
+import { Connection, PublicKey, TransactionMessage, AddressLookupTableAccount, VersionedTransaction, TransactionInstruction } from '@solana/web3.js';
+import { BN } from '@coral-xyz/anchor';
+import { JupiterClient, QuoteResponse as JupiterQuoteResponse } from '../jupiter/jupiterClient';
+import { TitanClient, QuoteResponse as TitanQuoteResponse } from '../titan/titanClient';
+export type SwapMode = 'ExactIn' | 'ExactOut';
+export type SwapClientType = 'jupiter' | 'titan';
+export type UnifiedQuoteResponse = JupiterQuoteResponse | TitanQuoteResponse;
+export interface SwapQuoteParams {
+    inputMint: PublicKey;
+    outputMint: PublicKey;
+    amount: BN;
+    userPublicKey?: PublicKey;
+    maxAccounts?: number;
+    slippageBps?: number;
+    swapMode?: SwapMode;
+    onlyDirectRoutes?: boolean;
+    excludeDexes?: string[];
+    sizeConstraint?: number;
+    accountsLimitWritable?: number;
+    autoSlippage?: boolean;
+    maxAutoSlippageBps?: number;
+    usdEstimate?: number;
+}
+export interface SwapTransactionParams {
+    quote: UnifiedQuoteResponse;
+    userPublicKey: PublicKey;
+    slippageBps?: number;
+}
+export interface SwapTransactionResult {
+    transaction?: VersionedTransaction;
+    transactionMessage?: TransactionMessage;
+    lookupTables?: AddressLookupTableAccount[];
+}
+export declare class UnifiedSwapClient {
+    private client;
+    private clientType;
+    constructor({ clientType, connection, authToken, url, }: {
+        clientType: SwapClientType;
+        connection: Connection;
+        authToken?: string;
+        url?: string;
+    });
+    /**
+     * Get a swap quote from the underlying client
+     */
+    getQuote(params: SwapQuoteParams): Promise<UnifiedQuoteResponse>;
+    /**
+     * Get a swap transaction from the underlying client
+     */
+    getSwap(params: SwapTransactionParams): Promise<SwapTransactionResult>;
+    /**
+     * Get swap instructions from the underlying client (Jupiter or Titan)
+     * This is the core swap logic without any context preparation
+     */
+    getSwapInstructions({ inputMint, outputMint, amount, userPublicKey, slippageBps, swapMode, onlyDirectRoutes, quote, sizeConstraint, }: {
+        inputMint: PublicKey;
+        outputMint: PublicKey;
+        amount: BN;
+        userPublicKey: PublicKey;
+        slippageBps?: number;
+        swapMode?: SwapMode;
+        onlyDirectRoutes?: boolean;
+        quote?: UnifiedQuoteResponse;
+        sizeConstraint?: number;
+    }): Promise<{
+        instructions: TransactionInstruction[];
+        lookupTables: AddressLookupTableAccount[];
+    }>;
+    /**
+     * Get the underlying client instance
+     */
+    getClient(): JupiterClient | TitanClient;
+    /**
+     * Get the client type
+     */
+    getClientType(): SwapClientType;
+    /**
+     * Check if this is a Jupiter client
+     */
+    isJupiter(): boolean;
+    /**
+     * Check if this is a Titan client
+     */
+    isTitan(): boolean;
+}

package/lib/browser/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/lib/node/driftClient.d.ts

@@ -18,7 +18,8 @@ import { User } from './user';
 import { UserSubscriptionConfig } from './userConfig';
 import { DriftEnv } from './config';
 import { UserStats } from './userStats';
-import { JupiterClient, QuoteResponse, SwapMode } from './jupiter/jupiterClient';
+import { JupiterClient, QuoteResponse } from './jupiter/jupiterClient';
+import { SwapMode } from './swap/UnifiedSwapClient';
 import { UserStatsSubscriptionConfig } from './userStatsConfig';
 import { TxHandler } from './tx/txHandler';
 import { WormholeCoreBridgeSolana } from '@pythnetwork/pyth-solana-receiver/lib/idl/wormhole_core_bridge_solana';
@@ -27,8 +28,10 @@ import { Slothash } from './slot/SlothashSubscriber';
 import { SignedMsgOrderParams } from './types';
 import { RevenueShareEscrowMap } from './userMap/revenueShareEscrowMap';
 import { TitanClient } 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;
 type RemainingAccountParams = {
@@ -552,7 +555,7 @@ export declare class DriftClient {
      * @param txParams
      */
     swap({ swapClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, reduceOnly, txParams, v6, quote, onlyDirectRoutes, }: {
-        swapClient: SwapClient;
+        swapClient: UnifiedSwapClient | SwapClient;
         outMarketIndex: number;
         inMarketIndex: number;
         outAssociatedTokenAccount?: PublicKey;
@@ -626,6 +629,25 @@ export declare class DriftClient {
         beginSwapIx: TransactionInstruction;
         endSwapIx: TransactionInstruction;
     }>;
+    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[];
+    }>;
     stakeForMSOL({ amount }: {
         amount: BN;
     }): Promise<TxSigAndSlot>;