@drift-labs/sdk 2.38.1-beta.9 → 2.39.1-beta.1

package/VERSION

@@ -1 +1 @@
-2.38.1-beta.9
+2.39.1-beta.1

package/lib/driftClient.d.ts

@@ -13,7 +13,7 @@ import { DriftClientConfig } from './driftClientConfig';
 import { User } from './user';
 import { UserSubscriptionConfig } from './userConfig';
 import { UserStats } from './userStats';
-import { JupiterClient, Route, SwapMode } from './jupiter/jupiterClient';
+import { JupiterClient, QuoteResponse, Route, SwapMode } from './jupiter/jupiterClient';
 import { UserStatsSubscriptionConfig } from './userStatsConfig';
 type RemainingAccountParams = {
     userAccounts: UserAccount[];
@@ -319,7 +319,7 @@ export declare class DriftClient {
      * @param reduceOnly specify if In or Out token on the drift account must reduceOnly, checked at end of swap
      * @param txParams
      */
-    swap({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, txParams, }: {
+    swap({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, txParams, v6, }: {
         jupiterClient: JupiterClient;
         outMarketIndex: number;
         inMarketIndex: number;
@@ -331,6 +331,9 @@ export declare class DriftClient {
         route?: Route;
         reduceOnly?: SwapReduceOnly;
         txParams?: TxParams;
+        v6?: {
+            quote?: QuoteResponse;
+        };
     }): Promise<TransactionSignature>;
     getJupiterSwapIx({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, route, reduceOnly, userAccountPublicKey, }: {
         jupiterClient: JupiterClient;
@@ -349,6 +352,23 @@ export declare class DriftClient {
         ixs: TransactionInstruction[];
         lookupTables: AddressLookupTableAccount[];
     }>;
+    getJupiterSwapIxV6({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, quote, reduceOnly, userAccountPublicKey, }: {
+        jupiterClient: JupiterClient;
+        outMarketIndex: number;
+        inMarketIndex: number;
+        outAssociatedTokenAccount?: PublicKey;
+        inAssociatedTokenAccount?: PublicKey;
+        amount: BN;
+        slippageBps?: number;
+        swapMode?: SwapMode;
+        onlyDirectRoutes?: boolean;
+        quote?: QuoteResponse;
+        reduceOnly?: SwapReduceOnly;
+        userAccountPublicKey?: PublicKey;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        lookupTables: AddressLookupTableAccount[];
+    }>;
     /**
      * Get the drift begin_swap and end_swap instructions
      *

package/lib/driftClient.js

@@ -1975,19 +1975,41 @@ class DriftClient {
      * @param reduceOnly specify if In or Out token on the drift account must reduceOnly, checked at end of swap
      * @param txParams
      */
-    async swap({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, txParams, }) {
-        const { ixs, lookupTables } = await this.getJupiterSwapIx({
-            jupiterClient,
-            outMarketIndex,
-            inMarketIndex,
-            outAssociatedTokenAccount,
-            inAssociatedTokenAccount,
-            amount,
-            slippageBps,
-            swapMode,
-            route,
-            reduceOnly,
-        });
+    async swap({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, txParams, v6, }) {
+        let ixs;
+        let lookupTables;
+        if (v6) {
+            const res = await this.getJupiterSwapIxV6({
+                jupiterClient,
+                outMarketIndex,
+                inMarketIndex,
+                outAssociatedTokenAccount,
+                inAssociatedTokenAccount,
+                amount,
+                slippageBps,
+                swapMode,
+                quote: v6.quote,
+                reduceOnly,
+            });
+            ixs = res.ixs;
+            lookupTables = res.lookupTables;
+        }
+        else {
+            const res = await this.getJupiterSwapIx({
+                jupiterClient,
+                outMarketIndex,
+                inMarketIndex,
+                outAssociatedTokenAccount,
+                inAssociatedTokenAccount,
+                amount,
+                slippageBps,
+                swapMode,
+                route,
+                reduceOnly,
+            });
+            ixs = res.ixs;
+            lookupTables = res.lookupTables;
+        }
         const tx = (await this.buildTransaction(ixs, txParams, 0, lookupTables));
         const { txSig, slot } = await this.sendTransaction(tx);
         this.spotMarketLastSlotCache.set(outMarketIndex, slot);
@@ -2056,6 +2078,65 @@ class DriftClient {
         ];
         return { ixs, lookupTables };
     }
+    async getJupiterSwapIxV6({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, quote, reduceOnly, userAccountPublicKey, }) {
+        const outMarket = this.getSpotMarketAccount(outMarketIndex);
+        const inMarket = this.getSpotMarketAccount(inMarketIndex);
+        if (!quote) {
+            const fetchedQuote = await jupiterClient.getQuote({
+                inputMint: inMarket.mint,
+                outputMint: outMarket.mint,
+                amount,
+                slippageBps,
+                swapMode,
+                onlyDirectRoutes,
+            });
+            quote = fetchedQuote;
+        }
+        const transaction = await jupiterClient.getSwap({
+            quote,
+            userPublicKey: this.provider.wallet.publicKey,
+            slippageBps,
+        });
+        const { transactionMessage, lookupTables } = await jupiterClient.getTransactionMessageAndLookupTables({
+            transaction,
+        });
+        const jupiterInstructions = jupiterClient.getJupiterInstructions({
+            transactionMessage,
+            inputMint: inMarket.mint,
+            outputMint: outMarket.mint,
+        });
+        const preInstructions = [];
+        if (!outAssociatedTokenAccount) {
+            outAssociatedTokenAccount = await this.getAssociatedTokenAccount(outMarket.marketIndex, false);
+            const accountInfo = await this.connection.getAccountInfo(outAssociatedTokenAccount);
+            if (!accountInfo) {
+                preInstructions.push(this.createAssociatedTokenAccountIdempotentInstruction(outAssociatedTokenAccount, this.provider.wallet.publicKey, this.provider.wallet.publicKey, outMarket.mint));
+            }
+        }
+        if (!inAssociatedTokenAccount) {
+            inAssociatedTokenAccount = await this.getAssociatedTokenAccount(inMarket.marketIndex, false);
+            const accountInfo = await this.connection.getAccountInfo(inAssociatedTokenAccount);
+            if (!accountInfo) {
+                preInstructions.push(this.createAssociatedTokenAccountIdempotentInstruction(inAssociatedTokenAccount, this.provider.wallet.publicKey, this.provider.wallet.publicKey, inMarket.mint));
+            }
+        }
+        const { beginSwapIx, endSwapIx } = await this.getSwapIx({
+            outMarketIndex,
+            inMarketIndex,
+            amountIn: amount,
+            inTokenAccount: inAssociatedTokenAccount,
+            outTokenAccount: outAssociatedTokenAccount,
+            reduceOnly,
+            userAccountPublicKey,
+        });
+        const ixs = [
+            ...preInstructions,
+            beginSwapIx,
+            ...jupiterInstructions,
+            endSwapIx,
+        ];
+        return { ixs, lookupTables };
+    }
     /**
      * Get the drift begin_swap and end_swap instructions
      *
@@ -2077,6 +2158,7 @@ class DriftClient {
         const remainingAccounts = this.getRemainingAccounts({
             userAccounts,
             writableSpotMarketIndexes: [outMarketIndex, inMarketIndex],
+            readableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
         });
         const outSpotMarket = this.getSpotMarketAccount(outMarketIndex);
         const inSpotMarket = this.getSpotMarketAccount(inMarketIndex);

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.38.0",
+    "version": "2.39.0",
     "name": "drift",
     "instructions": [
         {

package/lib/index.d.ts

@@ -65,6 +65,7 @@ export * from './priorityFee/priorityFeeSubscriber';
 export * from './phoenix/phoenixFulfillmentConfigMap';
 export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';
+export * from './tx/priorityFeeCalculator';
 export * from './tx/types';
 export * from './util/computeUnits';
 export * from './util/tps';

package/lib/index.js

@@ -88,6 +88,7 @@ __exportStar(require("./priorityFee/priorityFeeSubscriber"), exports);
 __exportStar(require("./phoenix/phoenixFulfillmentConfigMap"), exports);
 __exportStar(require("./tx/fastSingleTxSender"), exports);
 __exportStar(require("./tx/retryTxSender"), exports);
+__exportStar(require("./tx/priorityFeeCalculator"), exports);
 __exportStar(require("./tx/types"), exports);
 __exportStar(require("./util/computeUnits"), exports);
 __exportStar(require("./util/tps"), exports);

package/lib/math/spotBalance.js

@@ -167,7 +167,7 @@ function calculateLiabilityWeight(size, spotMarket, marginCategory) {
             liabilityWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
             break;
         default:
-            liabilityWeight = spotMarket.initialLiabilityWeight;
+            liabilityWeight = new anchor_1.BN(spotMarket.initialLiabilityWeight);
             break;
     }
     return liabilityWeight;

package/lib/tx/priorityFeeCalculator.d.ts

@@ -0,0 +1,44 @@
+import { TransactionInstruction } from '@solana/web3.js';
+/**
+ * This class determines whether a priority fee needs to be included in a transaction based on
+ * a recent history of timed out transactions.
+ */
+export declare class PriorityFeeCalculator {
+    lastTxTimeoutCount: number;
+    priorityFeeTriggered: boolean;
+    lastTxTimeoutCountTriggered: number;
+    priorityFeeLatchDurationMs: number;
+    /**
+     * Constructor for the PriorityFeeCalculator class.
+     * @param currentTimeMs - The current time in milliseconds.
+     * @param priorityFeeLatchDurationMs - The duration for how long to stay in triggered state before resetting. Default value is 10 seconds.
+     */
+    constructor(currentTimeMs: number, priorityFeeLatchDurationMs?: number);
+    /**
+     * Update the priority fee state based on the current time and the current timeout count.
+     * @param currentTimeMs current time in milliseconds
+     * @returns true if priority fee should be included in the next transaction
+     */
+    updatePriorityFee(currentTimeMs: number, txTimeoutCount: number): boolean;
+    /**
+     * This method returns a transaction instruction list that sets the compute limit on the ComputeBudget program.
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetIxs(computeUnitLimit: number): Array<TransactionInstruction>;
+    /**
+     * Calculates the compute unit price to use based on the desired additional fee to pay and the compute unit limit.
+     * @param computeUnitLimit desired CU to use
+     * @param additionalFeeMicroLamports desired additional fee to pay, in micro lamports
+     * @returns the compute unit price to use, in micro lamports
+     */
+    calculateComputeUnitPrice(computeUnitLimit: number, additionalFeeMicroLamports: number): number;
+    /**
+     * This method generates a list of transaction instructions for the ComputeBudget program, and includes a priority fee if it's required
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @param usePriorityFee - A boolean indicating whether to include a priority fee in the transaction, this should be from `this.updatePriorityFee()` or `this.priorityFeeTriggered()`.
+     * @param additionalFeeMicroLamports - The additional fee to be paid, in micro lamports, the actual price will be calculated.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetWithPriorityFeeIx(computeUnitLimit: number, usePriorityFee: boolean, additionalFeeMicroLamports: number): Array<TransactionInstruction>;
+}

package/lib/tx/priorityFeeCalculator.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriorityFeeCalculator = void 0;
+const web3_js_1 = require("@solana/web3.js");
+/**
+ * This class determines whether a priority fee needs to be included in a transaction based on
+ * a recent history of timed out transactions.
+ */
+class PriorityFeeCalculator {
+    /**
+     * Constructor for the PriorityFeeCalculator class.
+     * @param currentTimeMs - The current time in milliseconds.
+     * @param priorityFeeLatchDurationMs - The duration for how long to stay in triggered state before resetting. Default value is 10 seconds.
+     */
+    constructor(currentTimeMs, priorityFeeLatchDurationMs = 10 * 1000) {
+        this.lastTxTimeoutCount = 0;
+        this.priorityFeeTriggered = false;
+        this.lastTxTimeoutCountTriggered = currentTimeMs;
+        this.priorityFeeLatchDurationMs = priorityFeeLatchDurationMs;
+    }
+    /**
+     * Update the priority fee state based on the current time and the current timeout count.
+     * @param currentTimeMs current time in milliseconds
+     * @returns true if priority fee should be included in the next transaction
+     */
+    updatePriorityFee(currentTimeMs, txTimeoutCount) {
+        let triggerPriorityFee = false;
+        if (txTimeoutCount > this.lastTxTimeoutCount) {
+            this.lastTxTimeoutCount = txTimeoutCount;
+            this.lastTxTimeoutCountTriggered = currentTimeMs;
+            triggerPriorityFee = true;
+        }
+        else {
+            if (!this.priorityFeeTriggered) {
+                triggerPriorityFee = false;
+            }
+            else if (currentTimeMs - this.lastTxTimeoutCountTriggered <
+                this.priorityFeeLatchDurationMs) {
+                triggerPriorityFee = true;
+            }
+        }
+        this.priorityFeeTriggered = triggerPriorityFee;
+        return triggerPriorityFee;
+    }
+    /**
+     * This method returns a transaction instruction list that sets the compute limit on the ComputeBudget program.
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetIxs(computeUnitLimit) {
+        const ixs = [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+                units: computeUnitLimit,
+            }),
+        ];
+        return ixs;
+    }
+    /**
+     * Calculates the compute unit price to use based on the desired additional fee to pay and the compute unit limit.
+     * @param computeUnitLimit desired CU to use
+     * @param additionalFeeMicroLamports desired additional fee to pay, in micro lamports
+     * @returns the compute unit price to use, in micro lamports
+     */
+    calculateComputeUnitPrice(computeUnitLimit, additionalFeeMicroLamports) {
+        return additionalFeeMicroLamports / computeUnitLimit;
+    }
+    /**
+     * This method generates a list of transaction instructions for the ComputeBudget program, and includes a priority fee if it's required
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @param usePriorityFee - A boolean indicating whether to include a priority fee in the transaction, this should be from `this.updatePriorityFee()` or `this.priorityFeeTriggered()`.
+     * @param additionalFeeMicroLamports - The additional fee to be paid, in micro lamports, the actual price will be calculated.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetWithPriorityFeeIx(computeUnitLimit, usePriorityFee, additionalFeeMicroLamports) {
+        const ixs = this.generateComputeBudgetIxs(computeUnitLimit);
+        if (usePriorityFee) {
+            const computeUnitPrice = this.calculateComputeUnitPrice(computeUnitLimit, additionalFeeMicroLamports);
+            ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: computeUnitPrice,
+            }));
+        }
+        return ixs;
+    }
+}
+exports.PriorityFeeCalculator = PriorityFeeCalculator;

package/lib/user.js

@@ -577,7 +577,7 @@ class User {
                     continue;
                 }
             }
-            const { tokenAmount: worstCaseTokenAmount, ordersValue: worstCaseQuoteTokenAmount, } = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory);
+            const { tokenAmount: worstCaseTokenAmount, ordersValue: worstCaseQuoteTokenAmount, } = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory !== null && marginCategory !== void 0 ? marginCategory : 'Initial');
             if (worstCaseTokenAmount.gt(numericConstants_1.ZERO) && countForBase) {
                 const baseAssetValue = this.getSpotAssetValue(worstCaseTokenAmount, strictOraclePrice, spotMarketAccount, marginCategory);
                 totalAssetValue = totalAssetValue.add(baseAssetValue);
@@ -1834,7 +1834,7 @@ class User {
             const spotMarketAccount = this.driftClient.getQuoteSpotMarketAccount();
             const oraclePriceData = this.getOracleDataForSpotMarket(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
             const baseAssetValue = (0, _1.getTokenValue)(netQuoteValue, spotMarketAccount.decimals, oraclePriceData);
-            const { weight, weightedTokenValue } = (0, spotPosition_1.calculateWeightedTokenValue)(netQuoteValue, baseAssetValue, oraclePriceData, spotMarketAccount, marginCategory);
+            const { weight, weightedTokenValue } = (0, spotPosition_1.calculateWeightedTokenValue)(netQuoteValue, baseAssetValue, oraclePriceData.price, spotMarketAccount, marginCategory);
             if (netQuoteValue.lt(numericConstants_1.ZERO)) {
                 healthComponents.borrows.push({
                     marketIndex: spotMarketAccount.marketIndex,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.38.1-beta.9",
+	"version": "2.39.1-beta.1",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/driftClient.ts

@@ -113,7 +113,12 @@ import { isSpotPositionAvailable } from './math/spotPosition';
 import { calculateMarketMaxAvailableInsurance } from './math/market';
 import { fetchUserStatsAccount } from './accounts/fetch';
 import { castNumberToSpotPrecision } from './math/spotMarket';
-import { JupiterClient, Route, SwapMode } from './jupiter/jupiterClient';
+import {
+	JupiterClient,
+	QuoteResponse,
+	Route,
+	SwapMode,
+} from './jupiter/jupiterClient';
 import { getNonIdleUserFilter } from './memcmp';
 import { UserStatsSubscriptionConfig } from './userStatsConfig';
 import { getMarinadeDepositIx, getMarinadeFinanceProgram } from './marinade';
@@ -3418,6 +3423,7 @@ export class DriftClient {
 		route,
 		reduceOnly,
 		txParams,
+		v6,
 	}: {
 		jupiterClient: JupiterClient;
 		outMarketIndex: number;
@@ -3430,19 +3436,44 @@ export class DriftClient {
 		route?: Route;
 		reduceOnly?: SwapReduceOnly;
 		txParams?: TxParams;
+		v6?: {
+			quote?: QuoteResponse;
+		};
 	}): Promise<TransactionSignature> {
-		const { ixs, lookupTables } = await this.getJupiterSwapIx({
-			jupiterClient,
-			outMarketIndex,
-			inMarketIndex,
-			outAssociatedTokenAccount,
-			inAssociatedTokenAccount,
-			amount,
-			slippageBps,
-			swapMode,
-			route,
-			reduceOnly,
-		});
+		let ixs: anchor.web3.TransactionInstruction[];
+		let lookupTables: anchor.web3.AddressLookupTableAccount[];
+
+		if (v6) {
+			const res = await this.getJupiterSwapIxV6({
+				jupiterClient,
+				outMarketIndex,
+				inMarketIndex,
+				outAssociatedTokenAccount,
+				inAssociatedTokenAccount,
+				amount,
+				slippageBps,
+				swapMode,
+				quote: v6.quote,
+				reduceOnly,
+			});
+			ixs = res.ixs;
+			lookupTables = res.lookupTables;
+		} else {
+			const res = await this.getJupiterSwapIx({
+				jupiterClient,
+				outMarketIndex,
+				inMarketIndex,
+				outAssociatedTokenAccount,
+				inAssociatedTokenAccount,
+				amount,
+				slippageBps,
+				swapMode,
+				route,
+				reduceOnly,
+			});
+			ixs = res.ixs;
+			lookupTables = res.lookupTables;
+		}
 
 		const tx = (await this.buildTransaction(
 			ixs,
@@ -3588,6 +3619,132 @@ export class DriftClient {
 		return { ixs, lookupTables };
 	}
 
+	public async getJupiterSwapIxV6({
+		jupiterClient,
+		outMarketIndex,
+		inMarketIndex,
+		outAssociatedTokenAccount,
+		inAssociatedTokenAccount,
+		amount,
+		slippageBps,
+		swapMode,
+		onlyDirectRoutes,
+		quote,
+		reduceOnly,
+		userAccountPublicKey,
+	}: {
+		jupiterClient: JupiterClient;
+		outMarketIndex: number;
+		inMarketIndex: number;
+		outAssociatedTokenAccount?: PublicKey;
+		inAssociatedTokenAccount?: PublicKey;
+		amount: BN;
+		slippageBps?: number;
+		swapMode?: SwapMode;
+		onlyDirectRoutes?: boolean;
+		quote?: QuoteResponse;
+		reduceOnly?: SwapReduceOnly;
+		userAccountPublicKey?: PublicKey;
+	}): Promise<{
+		ixs: TransactionInstruction[];
+		lookupTables: AddressLookupTableAccount[];
+	}> {
+		const outMarket = this.getSpotMarketAccount(outMarketIndex);
+		const inMarket = this.getSpotMarketAccount(inMarketIndex);
+
+		if (!quote) {
+			const fetchedQuote = await jupiterClient.getQuote({
+				inputMint: inMarket.mint,
+				outputMint: outMarket.mint,
+				amount,
+				slippageBps,
+				swapMode,
+				onlyDirectRoutes,
+			});
+
+			quote = fetchedQuote;
+		}
+
+		const transaction = await jupiterClient.getSwap({
+			quote,
+			userPublicKey: this.provider.wallet.publicKey,
+			slippageBps,
+		});
+
+		const { transactionMessage, lookupTables } =
+			await jupiterClient.getTransactionMessageAndLookupTables({
+				transaction,
+			});
+
+		const jupiterInstructions = jupiterClient.getJupiterInstructions({
+			transactionMessage,
+			inputMint: inMarket.mint,
+			outputMint: outMarket.mint,
+		});
+
+		const preInstructions = [];
+		if (!outAssociatedTokenAccount) {
+			outAssociatedTokenAccount = await this.getAssociatedTokenAccount(
+				outMarket.marketIndex,
+				false
+			);
+
+			const accountInfo = await this.connection.getAccountInfo(
+				outAssociatedTokenAccount
+			);
+			if (!accountInfo) {
+				preInstructions.push(
+					this.createAssociatedTokenAccountIdempotentInstruction(
+						outAssociatedTokenAccount,
+						this.provider.wallet.publicKey,
+						this.provider.wallet.publicKey,
+						outMarket.mint
+					)
+				);
+			}
+		}
+
+		if (!inAssociatedTokenAccount) {
+			inAssociatedTokenAccount = await this.getAssociatedTokenAccount(
+				inMarket.marketIndex,
+				false
+			);
+
+			const accountInfo = await this.connection.getAccountInfo(
+				inAssociatedTokenAccount
+			);
+			if (!accountInfo) {
+				preInstructions.push(
+					this.createAssociatedTokenAccountIdempotentInstruction(
+						inAssociatedTokenAccount,
+						this.provider.wallet.publicKey,
+						this.provider.wallet.publicKey,
+						inMarket.mint
+					)
+				);
+			}
+		}
+
+		const { beginSwapIx, endSwapIx } = await this.getSwapIx({
+			outMarketIndex,
+			inMarketIndex,
+			amountIn: amount,
+			inTokenAccount: inAssociatedTokenAccount,
+			outTokenAccount: outAssociatedTokenAccount,
+			reduceOnly,
+			userAccountPublicKey,
+		});
+
+		const ixs = [
+			...preInstructions,
+			beginSwapIx,
+			...jupiterInstructions,
+			endSwapIx,
+		];
+
+		return { ixs, lookupTables };
+	}
+
 	/**
 	 * Get the drift begin_swap and end_swap instructions
 	 *
@@ -3632,6 +3789,7 @@ export class DriftClient {
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts,
 			writableSpotMarketIndexes: [outMarketIndex, inMarketIndex],
+			readableSpotMarketIndexes: [QUOTE_SPOT_MARKET_INDEX],
 		});
 
 		const outSpotMarket = this.getSpotMarketAccount(outMarketIndex);

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.38.0",
+  "version": "2.39.0",
   "name": "drift",
   "instructions": [
     {

package/src/index.ts

@@ -66,6 +66,7 @@ export * from './priorityFee/priorityFeeSubscriber';
 export * from './phoenix/phoenixFulfillmentConfigMap';
 export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';
+export * from './tx/priorityFeeCalculator';
 export * from './tx/types';
 export * from './util/computeUnits';
 export * from './util/tps';

package/src/math/spotBalance.ts

@@ -255,7 +255,7 @@ export function calculateLiabilityWeight(
 			);
 			break;
 		default:
-			liabilityWeight = spotMarket.initialLiabilityWeight;
+			liabilityWeight = new BN(spotMarket.initialLiabilityWeight);
 			break;
 	}
 

package/src/tx/priorityFeeCalculator.ts

@@ -0,0 +1,117 @@
+import { ComputeBudgetProgram, TransactionInstruction } from '@solana/web3.js';
+
+/**
+ * This class determines whether a priority fee needs to be included in a transaction based on
+ * a recent history of timed out transactions.
+ */
+export class PriorityFeeCalculator {
+	lastTxTimeoutCount: number;
+	priorityFeeTriggered: boolean;
+	lastTxTimeoutCountTriggered: number;
+	priorityFeeLatchDurationMs: number; // how long to stay in triggered state before resetting
+
+	/**
+	 * Constructor for the PriorityFeeCalculator class.
+	 * @param currentTimeMs - The current time in milliseconds.
+	 * @param priorityFeeLatchDurationMs - The duration for how long to stay in triggered state before resetting. Default value is 10 seconds.
+	 */
+	constructor(
+		currentTimeMs: number,
+		priorityFeeLatchDurationMs: number = 10 * 1000
+	) {
+		this.lastTxTimeoutCount = 0;
+		this.priorityFeeTriggered = false;
+		this.lastTxTimeoutCountTriggered = currentTimeMs;
+		this.priorityFeeLatchDurationMs = priorityFeeLatchDurationMs;
+	}
+
+	/**
+	 * Update the priority fee state based on the current time and the current timeout count.
+	 * @param currentTimeMs current time in milliseconds
+	 * @returns true if priority fee should be included in the next transaction
+	 */
+	public updatePriorityFee(
+		currentTimeMs: number,
+		txTimeoutCount: number
+	): boolean {
+		let triggerPriorityFee = false;
+
+		if (txTimeoutCount > this.lastTxTimeoutCount) {
+			this.lastTxTimeoutCount = txTimeoutCount;
+			this.lastTxTimeoutCountTriggered = currentTimeMs;
+			triggerPriorityFee = true;
+		} else {
+			if (!this.priorityFeeTriggered) {
+				triggerPriorityFee = false;
+			} else if (
+				currentTimeMs - this.lastTxTimeoutCountTriggered <
+				this.priorityFeeLatchDurationMs
+			) {
+				triggerPriorityFee = true;
+			}
+		}
+
+		this.priorityFeeTriggered = triggerPriorityFee;
+
+		return triggerPriorityFee;
+	}
+
+	/**
+	 * This method returns a transaction instruction list that sets the compute limit on the ComputeBudget program.
+	 * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+	 * @returns An array of transaction instructions.
+	 */
+	public generateComputeBudgetIxs(
+		computeUnitLimit: number
+	): Array<TransactionInstruction> {
+		const ixs = [
+			ComputeBudgetProgram.setComputeUnitLimit({
+				units: computeUnitLimit,
+			}),
+		];
+
+		return ixs;
+	}
+
+	/**
+	 * Calculates the compute unit price to use based on the desired additional fee to pay and the compute unit limit.
+	 * @param computeUnitLimit desired CU to use
+	 * @param additionalFeeMicroLamports desired additional fee to pay, in micro lamports
+	 * @returns the compute unit price to use, in micro lamports
+	 */
+	public calculateComputeUnitPrice(
+		computeUnitLimit: number,
+		additionalFeeMicroLamports: number
+	): number {
+		return additionalFeeMicroLamports / computeUnitLimit;
+	}
+
+	/**
+	 * This method generates a list of transaction instructions for the ComputeBudget program, and includes a priority fee if it's required
+	 * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+	 * @param usePriorityFee - A boolean indicating whether to include a priority fee in the transaction, this should be from `this.updatePriorityFee()` or `this.priorityFeeTriggered()`.
+	 * @param additionalFeeMicroLamports - The additional fee to be paid, in micro lamports, the actual price will be calculated.
+	 * @returns An array of transaction instructions.
+	 */
+	public generateComputeBudgetWithPriorityFeeIx(
+		computeUnitLimit: number,
+		usePriorityFee: boolean,
+		additionalFeeMicroLamports: number
+	): Array<TransactionInstruction> {
+		const ixs = this.generateComputeBudgetIxs(computeUnitLimit);
+
+		if (usePriorityFee) {
+			const computeUnitPrice = this.calculateComputeUnitPrice(
+				computeUnitLimit,
+				additionalFeeMicroLamports
+			);
+			ixs.push(
+				ComputeBudgetProgram.setComputeUnitPrice({
+					microLamports: computeUnitPrice,
+				})
+			);
+		}
+
+		return ixs;
+	}
+}

package/src/user.ts

@@ -967,7 +967,7 @@ export class User {
 				spotPosition,
 				spotMarketAccount,
 				strictOraclePrice,
-				marginCategory
+				marginCategory ?? 'Initial'
 			);
 
 			if (worstCaseTokenAmount.gt(ZERO) && countForBase) {
@@ -3320,7 +3320,7 @@ export class User {
 			const { weight, weightedTokenValue } = calculateWeightedTokenValue(
 				netQuoteValue,
 				baseAssetValue,
-				oraclePriceData,
+				oraclePriceData.price,
 				spotMarketAccount,
 				marginCategory
 			);

package/tests/tx/priorityFeeCalculator.ts

@@ -0,0 +1,77 @@
+import { expect } from 'chai';
+import { PriorityFeeCalculator } from '../../src/tx/priorityFeeCalculator';
+
+describe('PriorityFeeCalculator', () => {
+	let priorityFeeCalculator: PriorityFeeCalculator;
+
+	const startTime = 1000000;
+	const latch_duration = 10_000;
+
+	beforeEach(() => {
+		priorityFeeCalculator = new PriorityFeeCalculator(
+			startTime,
+			latch_duration
+		);
+	});
+
+	it('should trigger priority fee when timeout count increases', () => {
+		const timeoutCount = 1;
+		expect(priorityFeeCalculator.updatePriorityFee(startTime, timeoutCount)).to
+			.be.true;
+		expect(
+			priorityFeeCalculator.updatePriorityFee(
+				startTime + latch_duration,
+				timeoutCount + 1
+			)
+		).to.be.true;
+		expect(
+			priorityFeeCalculator.updatePriorityFee(
+				startTime + latch_duration,
+				timeoutCount + 2
+			)
+		).to.be.true;
+	});
+
+	it('should trigger priority fee when timeout count increases, and stay latched until latch duration', () => {
+		const timeoutCount = 1;
+		expect(priorityFeeCalculator.updatePriorityFee(startTime, timeoutCount)).to
+			.be.true;
+		expect(
+			priorityFeeCalculator.updatePriorityFee(
+				startTime + latch_duration / 2,
+				timeoutCount
+			)
+		).to.be.true;
+		expect(
+			priorityFeeCalculator.updatePriorityFee(
+				startTime + latch_duration - 1,
+				timeoutCount
+			)
+		).to.be.true;
+		expect(
+			priorityFeeCalculator.updatePriorityFee(
+				startTime + latch_duration * 2,
+				timeoutCount
+			)
+		).to.be.false;
+	});
+
+	it('should not trigger priority fee when timeout count does not increase', () => {
+		const timeoutCount = 0;
+		expect(priorityFeeCalculator.updatePriorityFee(startTime, timeoutCount)).to
+			.be.false;
+	});
+
+	it('should correctly calculate compute unit price', () => {
+		const computeUnitLimit = 1_000_000;
+		const additionalFeeMicroLamports = 1_000_000_000; // 1000 lamports
+		const actualComputeUnitPrice =
+			priorityFeeCalculator.calculateComputeUnitPrice(
+				computeUnitLimit,
+				additionalFeeMicroLamports
+			);
+		expect(actualComputeUnitPrice * computeUnitLimit).to.equal(
+			additionalFeeMicroLamports
+		);
+	});
+});