@drift-labs/sdk 2.33.1-beta.6 → 2.33.1-beta.8

package/VERSION

@@ -1 +1 @@
-2.33.1-beta.6
+2.33.1-beta.8

package/lib/driftClient.d.ts

@@ -309,9 +309,11 @@ export declare class DriftClient {
      * @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 inAssociatedTokenAccount the token account to
-     * @param amount the amount of the token to sell
+     * @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 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, }: {

package/lib/driftClient.js

@@ -1940,9 +1940,11 @@ class DriftClient {
      * @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 inAssociatedTokenAccount the token account to
-     * @param amount the amount of the token to sell
+     * @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 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, }) {

package/lib/math/spotBalance.js

@@ -286,7 +286,7 @@ function calculateTokenUtilizationLimits(depositTokenAmount, borrowTokenAmount,
     // First, it determines a maximum withdrawal utilization from the market's target and historic utilization.
     // Then, it deduces corresponding deposit/borrow amounts.
     // Note: For deposit sizes below the guard threshold, withdrawals aren't blocked.
-    const maxWithdrawUtilization = anchor_1.BN.max(spotMarket.optimalUtilization, spotMarket.utilizationTwap.add(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(spotMarket.utilizationTwap).div(new anchor_1.BN(2))));
+    const maxWithdrawUtilization = anchor_1.BN.max(new anchor_1.BN(spotMarket.optimalUtilization), spotMarket.utilizationTwap.add(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(spotMarket.utilizationTwap).div(new anchor_1.BN(2))));
     let minDepositTokensForUtilization = borrowTokenAmount
         .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
         .div(maxWithdrawUtilization);

package/lib/user.d.ts

@@ -30,18 +30,22 @@ export declare class User {
     getUserAccount(): UserAccount;
     forceGetUserAccount(): Promise<UserAccount>;
     getUserAccountAndSlot(): DataAndSlot<UserAccount> | undefined;
+    getPerpPositionForUserAccount(userAccount: UserAccount, marketIndex: number): PerpPosition | undefined;
     /**
      * Gets the user's current position for a given perp market. If the user has no position returns undefined
      * @param marketIndex
      * @returns userPerpPosition
      */
     getPerpPosition(marketIndex: number): PerpPosition | undefined;
+    getPerpPositionAndSlot(marketIndex: number): DataAndSlot<PerpPosition | undefined>;
+    getSpotPositionForUserAccount(userAccount: UserAccount, marketIndex: number): SpotPosition | undefined;
     /**
      * Gets the user's current position for a given spot market. If the user has no position returns undefined
      * @param marketIndex
      * @returns userSpotPosition
      */
     getSpotPosition(marketIndex: number): SpotPosition | undefined;
+    getSpotPositionAndSlot(marketIndex: number): DataAndSlot<SpotPosition | undefined>;
     getEmptySpotPosition(marketIndex: number): SpotPosition;
     /**
      * Returns the token amount for a given market. The spot market precision is based on the token mint decimals.
@@ -52,17 +56,23 @@ export declare class User {
     getTokenAmount(marketIndex: number): BN;
     getEmptyPosition(marketIndex: number): PerpPosition;
     getClonedPosition(position: PerpPosition): PerpPosition;
+    getOrderForUserAccount(userAccount: UserAccount, orderId: number): Order | undefined;
     /**
      * @param orderId
      * @returns Order
      */
     getOrder(orderId: number): Order | undefined;
+    getOrderAndSlot(orderId: number): DataAndSlot<Order | undefined>;
+    getOrderByUserIdForUserAccount(userAccount: UserAccount, userOrderId: number): Order | undefined;
     /**
      * @param userOrderId
      * @returns Order
      */
     getOrderByUserOrderId(userOrderId: number): Order | undefined;
+    getOrderByUserOrderIdAndSlot(userOrderId: number): DataAndSlot<Order | undefined>;
+    getOpenOrdersForUserAccount(userAccount?: UserAccount): Order[];
     getOpenOrders(): Order[];
+    getOpenOrdersAndSlot(): DataAndSlot<Order[]>;
     getUserAccountPublicKey(): PublicKey;
     exists(): Promise<boolean>;
     /**
@@ -107,8 +117,12 @@ export declare class User {
      * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
      */
     getMaintenanceMarginRequirement(liquidationBuffer?: BN): BN;
+    getActivePerpPositionsForUserAccount(userAccount: UserAccount): PerpPosition[];
     getActivePerpPositions(): PerpPosition[];
+    getActivePerpPositionsAndSlot(): DataAndSlot<PerpPosition[]>;
+    getActiveSpotPositionsForUserAccount(userAccount: UserAccount): SpotPosition[];
     getActiveSpotPositions(): SpotPosition[];
+    getActiveSpotPositionsAndSlot(): DataAndSlot<SpotPosition[]>;
     /**
      * calculates unrealized position price pnl
      * @returns : Precision QUOTE_PRECISION

package/lib/user.js

@@ -64,13 +64,28 @@ class User {
     getUserAccountAndSlot() {
         return this.accountSubscriber.getUserAccountAndSlot();
     }
+    getPerpPositionForUserAccount(userAccount, marketIndex) {
+        return userAccount.perpPositions.find((position) => position.marketIndex === marketIndex);
+    }
     /**
      * Gets the user's current position for a given perp market. If the user has no position returns undefined
      * @param marketIndex
      * @returns userPerpPosition
      */
     getPerpPosition(marketIndex) {
-        return this.getUserAccount().perpPositions.find((position) => position.marketIndex === marketIndex);
+        const userAccount = this.getUserAccount();
+        return this.getPerpPositionForUserAccount(userAccount, marketIndex);
+    }
+    getPerpPositionAndSlot(marketIndex) {
+        const userAccount = this.getUserAccountAndSlot();
+        const perpPosition = this.getPerpPositionForUserAccount(userAccount.data, marketIndex);
+        return {
+            data: perpPosition,
+            slot: userAccount.slot,
+        };
+    }
+    getSpotPositionForUserAccount(userAccount, marketIndex) {
+        return userAccount.spotPositions.find((position) => position.marketIndex === marketIndex);
     }
     /**
      * Gets the user's current position for a given spot market. If the user has no position returns undefined
@@ -78,7 +93,16 @@ class User {
      * @returns userSpotPosition
      */
     getSpotPosition(marketIndex) {
-        return this.getUserAccount().spotPositions.find((position) => position.marketIndex === marketIndex);
+        const userAccount = this.getUserAccount();
+        return this.getSpotPositionForUserAccount(userAccount, marketIndex);
+    }
+    getSpotPositionAndSlot(marketIndex) {
+        const userAccount = this.getUserAccountAndSlot();
+        const spotPosition = this.getSpotPositionForUserAccount(userAccount.data, marketIndex);
+        return {
+            data: spotPosition,
+            slot: userAccount.slot,
+        };
     }
     getEmptySpotPosition(marketIndex) {
         return {
@@ -127,23 +151,58 @@ class User {
         const clonedPosition = Object.assign({}, position);
         return clonedPosition;
     }
+    getOrderForUserAccount(userAccount, orderId) {
+        return userAccount.orders.find((order) => order.orderId === orderId);
+    }
     /**
      * @param orderId
      * @returns Order
      */
     getOrder(orderId) {
-        return this.getUserAccount().orders.find((order) => order.orderId === orderId);
+        const userAccount = this.getUserAccount();
+        return this.getOrderForUserAccount(userAccount, orderId);
+    }
+    getOrderAndSlot(orderId) {
+        const userAccount = this.getUserAccountAndSlot();
+        const order = this.getOrderForUserAccount(userAccount.data, orderId);
+        return {
+            data: order,
+            slot: userAccount.slot,
+        };
+    }
+    getOrderByUserIdForUserAccount(userAccount, userOrderId) {
+        return userAccount.orders.find((order) => order.userOrderId === userOrderId);
     }
     /**
      * @param userOrderId
      * @returns Order
      */
     getOrderByUserOrderId(userOrderId) {
-        return this.getUserAccount().orders.find((order) => order.userOrderId === userOrderId);
+        const userAccount = this.getUserAccount();
+        return this.getOrderByUserIdForUserAccount(userAccount, userOrderId);
+    }
+    getOrderByUserOrderIdAndSlot(userOrderId) {
+        const userAccount = this.getUserAccountAndSlot();
+        const order = this.getOrderByUserIdForUserAccount(userAccount.data, userOrderId);
+        return {
+            data: order,
+            slot: userAccount.slot,
+        };
+    }
+    getOpenOrdersForUserAccount(userAccount) {
+        return userAccount === null || userAccount === void 0 ? void 0 : userAccount.orders.filter((order) => (0, types_1.isVariant)(order.status, 'open'));
     }
     getOpenOrders() {
-        var _a;
-        return (_a = this.getUserAccount()) === null || _a === void 0 ? void 0 : _a.orders.filter((order) => (0, types_1.isVariant)(order.status, 'open'));
+        const userAccount = this.getUserAccount();
+        return this.getOpenOrdersForUserAccount(userAccount);
+    }
+    getOpenOrdersAndSlot() {
+        const userAccount = this.getUserAccountAndSlot();
+        const openOrders = this.getOpenOrdersForUserAccount(userAccount.data);
+        return {
+            data: openOrders,
+            slot: userAccount.slot,
+        };
     }
     getUserAccountPublicKey() {
         return this.userAccountPublicKey;
@@ -316,14 +375,38 @@ class User {
     getMaintenanceMarginRequirement(liquidationBuffer) {
         return this.getMarginRequirement('Maintenance', liquidationBuffer);
     }
-    getActivePerpPositions() {
-        return this.getUserAccount().perpPositions.filter((pos) => !pos.baseAssetAmount.eq(numericConstants_1.ZERO) ||
+    getActivePerpPositionsForUserAccount(userAccount) {
+        return userAccount.perpPositions.filter((pos) => !pos.baseAssetAmount.eq(numericConstants_1.ZERO) ||
             !pos.quoteAssetAmount.eq(numericConstants_1.ZERO) ||
             !(pos.openOrders == 0) ||
             !pos.lpShares.eq(numericConstants_1.ZERO));
     }
+    getActivePerpPositions() {
+        const userAccount = this.getUserAccount();
+        return this.getActivePerpPositionsForUserAccount(userAccount);
+    }
+    getActivePerpPositionsAndSlot() {
+        const userAccount = this.getUserAccountAndSlot();
+        const positions = this.getActivePerpPositionsForUserAccount(userAccount.data);
+        return {
+            data: positions,
+            slot: userAccount.slot,
+        };
+    }
+    getActiveSpotPositionsForUserAccount(userAccount) {
+        return userAccount.spotPositions.filter((pos) => !(0, spotPosition_1.isSpotPositionAvailable)(pos));
+    }
     getActiveSpotPositions() {
-        return this.getUserAccount().spotPositions.filter((pos) => !(0, spotPosition_1.isSpotPositionAvailable)(pos));
+        const userAccount = this.getUserAccount();
+        return this.getActiveSpotPositionsForUserAccount(userAccount);
+    }
+    getActiveSpotPositionsAndSlot() {
+        const userAccount = this.getUserAccountAndSlot();
+        const positions = this.getActiveSpotPositionsForUserAccount(userAccount.data);
+        return {
+            data: positions,
+            slot: userAccount.slot,
+        };
     }
     /**
      * calculates unrealized position price pnl

package/package.json

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

package/src/driftClient.ts

@@ -3353,9 +3353,11 @@ export class DriftClient {
 	 * @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 inAssociatedTokenAccount the token account to
-	 * @param amount the amount of the token to sell
+	 * @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 reduceOnly specify if In or Out token on the drift account must reduceOnly, checked at end of swap
 	 * @param txParams
 	 */
 	public async swap({

package/src/math/spotBalance.ts

@@ -430,7 +430,7 @@ export function calculateTokenUtilizationLimits(
 	// Note: For deposit sizes below the guard threshold, withdrawals aren't blocked.
 
 	const maxWithdrawUtilization = BN.max(
-		spotMarket.optimalUtilization,
+		new BN(spotMarket.optimalUtilization),
 		spotMarket.utilizationTwap.add(
 			SPOT_MARKET_UTILIZATION_PRECISION.sub(spotMarket.utilizationTwap).div(
 				new BN(2)

package/src/user.ts

@@ -147,13 +147,44 @@ export class User {
 		return this.accountSubscriber.getUserAccountAndSlot();
 	}
 
+	public getPerpPositionForUserAccount(
+		userAccount: UserAccount,
+		marketIndex: number
+	): PerpPosition | undefined {
+		return userAccount.perpPositions.find(
+			(position) => position.marketIndex === marketIndex
+		);
+	}
+
 	/**
 	 * Gets the user's current position for a given perp market. If the user has no position returns undefined
 	 * @param marketIndex
 	 * @returns userPerpPosition
 	 */
 	public getPerpPosition(marketIndex: number): PerpPosition | undefined {
-		return this.getUserAccount().perpPositions.find(
+		const userAccount = this.getUserAccount();
+		return this.getPerpPositionForUserAccount(userAccount, marketIndex);
+	}
+
+	public getPerpPositionAndSlot(
+		marketIndex: number
+	): DataAndSlot<PerpPosition | undefined> {
+		const userAccount = this.getUserAccountAndSlot();
+		const perpPosition = this.getPerpPositionForUserAccount(
+			userAccount.data,
+			marketIndex
+		);
+		return {
+			data: perpPosition,
+			slot: userAccount.slot,
+		};
+	}
+
+	public getSpotPositionForUserAccount(
+		userAccount: UserAccount,
+		marketIndex: number
+	): SpotPosition | undefined {
+		return userAccount.spotPositions.find(
 			(position) => position.marketIndex === marketIndex
 		);
 	}
@@ -164,9 +195,22 @@ export class User {
 	 * @returns userSpotPosition
 	 */
 	public getSpotPosition(marketIndex: number): SpotPosition | undefined {
-		return this.getUserAccount().spotPositions.find(
-			(position) => position.marketIndex === marketIndex
+		const userAccount = this.getUserAccount();
+		return this.getSpotPositionForUserAccount(userAccount, marketIndex);
+	}
+
+	public getSpotPositionAndSlot(
+		marketIndex: number
+	): DataAndSlot<SpotPosition | undefined> {
+		const userAccount = this.getUserAccountAndSlot();
+		const spotPosition = this.getSpotPositionForUserAccount(
+			userAccount.data,
+			marketIndex
 		);
+		return {
+			data: spotPosition,
+			slot: userAccount.slot,
+		};
 	}
 
 	getEmptySpotPosition(marketIndex: number): SpotPosition {
@@ -227,13 +271,37 @@ export class User {
 		return clonedPosition;
 	}
 
+	public getOrderForUserAccount(
+		userAccount: UserAccount,
+		orderId: number
+	): Order | undefined {
+		return userAccount.orders.find((order) => order.orderId === orderId);
+	}
+
 	/**
 	 * @param orderId
 	 * @returns Order
 	 */
 	public getOrder(orderId: number): Order | undefined {
-		return this.getUserAccount().orders.find(
-			(order) => order.orderId === orderId
+		const userAccount = this.getUserAccount();
+		return this.getOrderForUserAccount(userAccount, orderId);
+	}
+
+	public getOrderAndSlot(orderId: number): DataAndSlot<Order | undefined> {
+		const userAccount = this.getUserAccountAndSlot();
+		const order = this.getOrderForUserAccount(userAccount.data, orderId);
+		return {
+			data: order,
+			slot: userAccount.slot,
+		};
+	}
+
+	public getOrderByUserIdForUserAccount(
+		userAccount: UserAccount,
+		userOrderId: number
+	): Order | undefined {
+		return userAccount.orders.find(
+			(order) => order.userOrderId === userOrderId
 		);
 	}
 
@@ -242,17 +310,44 @@ export class User {
 	 * @returns Order
 	 */
 	public getOrderByUserOrderId(userOrderId: number): Order | undefined {
-		return this.getUserAccount().orders.find(
-			(order) => order.userOrderId === userOrderId
+		const userAccount = this.getUserAccount();
+		return this.getOrderByUserIdForUserAccount(userAccount, userOrderId);
+	}
+
+	public getOrderByUserOrderIdAndSlot(
+		userOrderId: number
+	): DataAndSlot<Order | undefined> {
+		const userAccount = this.getUserAccountAndSlot();
+		const order = this.getOrderByUserIdForUserAccount(
+			userAccount.data,
+			userOrderId
 		);
+		return {
+			data: order,
+			slot: userAccount.slot,
+		};
 	}
 
-	public getOpenOrders(): Order[] {
-		return this.getUserAccount()?.orders.filter((order) =>
+	public getOpenOrdersForUserAccount(userAccount?: UserAccount): Order[] {
+		return userAccount?.orders.filter((order) =>
 			isVariant(order.status, 'open')
 		);
 	}
 
+	public getOpenOrders(): Order[] {
+		const userAccount = this.getUserAccount();
+		return this.getOpenOrdersForUserAccount(userAccount);
+	}
+
+	public getOpenOrdersAndSlot(): DataAndSlot<Order[]> {
+		const userAccount = this.getUserAccountAndSlot();
+		const openOrders = this.getOpenOrdersForUserAccount(userAccount.data);
+		return {
+			data: openOrders,
+			slot: userAccount.slot,
+		};
+	}
+
 	public getUserAccountPublicKey(): PublicKey {
 		return this.userAccountPublicKey;
 	}
@@ -502,8 +597,10 @@ export class User {
 		return this.getMarginRequirement('Maintenance', liquidationBuffer);
 	}
 
-	public getActivePerpPositions(): PerpPosition[] {
-		return this.getUserAccount().perpPositions.filter(
+	public getActivePerpPositionsForUserAccount(
+		userAccount: UserAccount
+	): PerpPosition[] {
+		return userAccount.perpPositions.filter(
 			(pos) =>
 				!pos.baseAssetAmount.eq(ZERO) ||
 				!pos.quoteAssetAmount.eq(ZERO) ||
@@ -512,12 +609,44 @@ export class User {
 		);
 	}
 
-	public getActiveSpotPositions(): SpotPosition[] {
-		return this.getUserAccount().spotPositions.filter(
+	public getActivePerpPositions(): PerpPosition[] {
+		const userAccount = this.getUserAccount();
+		return this.getActivePerpPositionsForUserAccount(userAccount);
+	}
+	public getActivePerpPositionsAndSlot(): DataAndSlot<PerpPosition[]> {
+		const userAccount = this.getUserAccountAndSlot();
+		const positions = this.getActivePerpPositionsForUserAccount(
+			userAccount.data
+		);
+		return {
+			data: positions,
+			slot: userAccount.slot,
+		};
+	}
+
+	public getActiveSpotPositionsForUserAccount(
+		userAccount: UserAccount
+	): SpotPosition[] {
+		return userAccount.spotPositions.filter(
 			(pos) => !isSpotPositionAvailable(pos)
 		);
 	}
 
+	public getActiveSpotPositions(): SpotPosition[] {
+		const userAccount = this.getUserAccount();
+		return this.getActiveSpotPositionsForUserAccount(userAccount);
+	}
+	public getActiveSpotPositionsAndSlot(): DataAndSlot<SpotPosition[]> {
+		const userAccount = this.getUserAccountAndSlot();
+		const positions = this.getActiveSpotPositionsForUserAccount(
+			userAccount.data
+		);
+		return {
+			data: positions,
+			slot: userAccount.slot,
+		};
+	}
+
 	/**
 	 * calculates unrealized position price pnl
 	 * @returns : Precision QUOTE_PRECISION