@drift-labs/sdk 2.42.0-beta.0 → 2.42.0-beta.2

package/VERSION

@@ -1 +1 @@
-2.42.0-beta.0
+2.42.0-beta.2

package/lib/driftClient.d.ts

@@ -103,7 +103,7 @@ export declare class DriftClient {
      * @param includeDelegates
      */
     updateWallet(newWallet: IWallet, subAccountIds?: number[], activeSubAccountId?: number, includeDelegates?: boolean, authoritySubaccountMap?: Map<string, number[]>): Promise<boolean>;
-    switchActiveUser(subAccountId: number, authority?: PublicKey): void;
+    switchActiveUser(subAccountId: number, authority?: PublicKey): Promise<void>;
     addUser(subAccountId: number, authority?: PublicKey, userAccount?: UserAccount): Promise<boolean>;
     /**
      * Adds and subscribes to users based on params set by the constructor or by updateWallet.

package/lib/driftClient.js

@@ -339,10 +339,24 @@ class DriftClient {
         }
         return success;
     }
-    switchActiveUser(subAccountId, authority) {
+    async switchActiveUser(subAccountId, authority) {
+        var _a;
+        const authorityChanged = !((_a = this.authority) === null || _a === void 0 ? void 0 : _a.equals(authority));
         this.activeSubAccountId = subAccountId;
         this.authority = authority !== null && authority !== void 0 ? authority : this.authority;
         this.userStatsAccountPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(this.program.programId, this.authority);
+        /* If changing the user authority ie switching from delegate to non-delegate account, need to re-subscribe to the user stats account */
+        if (authorityChanged) {
+            if (this.userStats && this.userStats.isSubscribed) {
+                await this.userStats.unsubscribe();
+            }
+            this.userStats = new userStats_1.UserStats({
+                driftClient: this,
+                userStatsAccountPublicKey: this.userStatsAccountPublicKey,
+                accountSubscription: this.userAccountSubscriptionConfig,
+            });
+            this.userStats.subscribe();
+        }
     }
     async addUser(subAccountId, authority, userAccount) {
         authority = authority !== null && authority !== void 0 ? authority : this.authority;

package/lib/user.d.ts

@@ -335,8 +335,19 @@ export declare class User {
      * @returns leverageRatio : Precision TEN_THOUSAND
      */
     accountLeverageRatioAfterTrade(targetMarketIndex: number, targetMarketType: MarketType, tradeQuoteAmount: BN, tradeSide: PositionDirection, includeOpenOrders?: boolean): BN;
+    getUserFeeTier(marketType: MarketType): import("./types").FeeTier;
     /**
-     * Calculates how much fee will be taken for a given sized trade
+     * Calculates taker / maker fee (as a percentage, e.g. .001 = 10 basis points) for particular marketType
+     * @param marketType
+     * @param positionMarketIndex
+     * @returns : {takerFee: number, makerFee: number} Precision None
+     */
+    getMarketFees(marketType: MarketType, marketIndex?: number): {
+        takerFee: number;
+        makerFee: number;
+    };
+    /**
+     * Calculates how much perp fee will be taken for a given sized trade
      * @param quoteAmount
      * @returns feeForQuote : Precision QUOTE_PRECISION
      */

package/lib/user.js

@@ -1590,13 +1590,67 @@ class User {
             .div(netAssetValue);
         return newLeverage;
     }
+    getUserFeeTier(marketType) {
+        const state = this.driftClient.getStateAccount();
+        let feeTierIndex = 0;
+        if ((0, types_1.isVariant)(marketType, 'perp')) {
+            const userStatsAccount = this.driftClient
+                .getUserStats()
+                .getAccount();
+            const total30dVolume = userStatsAccount.takerVolume30D.add(userStatsAccount.makerVolume30D); // todo: update using now and lastTs?
+            const stakedQuoteAssetAmount = userStatsAccount.ifStakedQuoteAssetAmount;
+            const volumeTiers = [
+                new _1.BN(100000000).mul(numericConstants_1.QUOTE_PRECISION),
+                new _1.BN(50000000).mul(numericConstants_1.QUOTE_PRECISION),
+                new _1.BN(10000000).mul(numericConstants_1.QUOTE_PRECISION),
+                new _1.BN(5000000).mul(numericConstants_1.QUOTE_PRECISION),
+                new _1.BN(1000000).mul(numericConstants_1.QUOTE_PRECISION),
+            ];
+            const stakedTiers = [
+                new _1.BN(10000).mul(numericConstants_1.QUOTE_PRECISION),
+                new _1.BN(5000).mul(numericConstants_1.QUOTE_PRECISION),
+                new _1.BN(2000).mul(numericConstants_1.QUOTE_PRECISION),
+                new _1.BN(1000).mul(numericConstants_1.QUOTE_PRECISION),
+                new _1.BN(500).mul(numericConstants_1.QUOTE_PRECISION),
+            ];
+            for (let i = 0; i < volumeTiers.length; i++) {
+                if (total30dVolume.gte(volumeTiers[i]) ||
+                    stakedQuoteAssetAmount.gte(stakedTiers[i])) {
+                    feeTierIndex = 5 - i;
+                    break;
+                }
+            }
+            return state.perpFeeStructure.feeTiers[feeTierIndex];
+        }
+        return state.spotFeeStructure.feeTiers[feeTierIndex];
+    }
+    /**
+     * Calculates taker / maker fee (as a percentage, e.g. .001 = 10 basis points) for particular marketType
+     * @param marketType
+     * @param positionMarketIndex
+     * @returns : {takerFee: number, makerFee: number} Precision None
+     */
+    getMarketFees(marketType, marketIndex) {
+        const feeTier = this.getUserFeeTier(marketType);
+        let takerFee = feeTier.feeNumerator / feeTier.feeDenominator;
+        let makerFee = feeTier.makerRebateNumerator / feeTier.makerRebateDenominator;
+        if (marketIndex && (0, types_1.isVariant)(marketType, 'perp')) {
+            const marketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
+            takerFee += (takerFee * marketAccount.feeAdjustment) / 100;
+            makerFee += (makerFee * marketAccount.feeAdjustment) / 100;
+        }
+        return {
+            takerFee,
+            makerFee,
+        };
+    }
     /**
-     * Calculates how much fee will be taken for a given sized trade
+     * Calculates how much perp fee will be taken for a given sized trade
      * @param quoteAmount
      * @returns feeForQuote : Precision QUOTE_PRECISION
      */
     calculateFeeForQuoteAmount(quoteAmount) {
-        const feeTier = this.driftClient.getStateAccount().perpFeeStructure.feeTiers[0];
+        const feeTier = this.getUserFeeTier(_1.MarketType.PERP);
         return quoteAmount
             .mul(new _1.BN(feeTier.feeNumerator))
             .div(new _1.BN(feeTier.feeDenominator));

package/package.json

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

package/src/driftClient.ts

@@ -588,13 +588,30 @@ export class DriftClient {
 		return success;
 	}
 
-	public switchActiveUser(subAccountId: number, authority?: PublicKey) {
+	public async switchActiveUser(subAccountId: number, authority?: PublicKey) {
+		const authorityChanged = !this.authority?.equals(authority);
+
 		this.activeSubAccountId = subAccountId;
 		this.authority = authority ?? this.authority;
 		this.userStatsAccountPublicKey = getUserStatsAccountPublicKey(
 			this.program.programId,
 			this.authority
 		);
+
+		/* If changing the user authority ie switching from delegate to non-delegate account, need to re-subscribe to the user stats account */
+		if (authorityChanged) {
+			if (this.userStats && this.userStats.isSubscribed) {
+				await this.userStats.unsubscribe();
+			}
+
+			this.userStats = new UserStats({
+				driftClient: this,
+				userStatsAccountPublicKey: this.userStatsAccountPublicKey,
+				accountSubscription: this.userAccountSubscriptionConfig,
+			});
+
+			this.userStats.subscribe();
+		}
 	}
 
 	public async addUser(

package/src/user.ts

@@ -12,6 +12,7 @@ import {
 	isOneOfVariant,
 	PerpMarketAccount,
 	HealthComponents,
+	UserStatsAccount,
 } from './types';
 import { calculateEntryPrice, positionIsAvailable } from './math/position';
 import {
@@ -2909,14 +2910,82 @@ export class User {
 		return newLeverage;
 	}
 
+	public getUserFeeTier(marketType: MarketType) {
+		const state = this.driftClient.getStateAccount();
+
+		let feeTierIndex = 0;
+		if (isVariant(marketType, 'perp')) {
+			const userStatsAccount: UserStatsAccount = this.driftClient
+				.getUserStats()
+				.getAccount();
+
+			const total30dVolume = userStatsAccount.takerVolume30D.add(
+				userStatsAccount.makerVolume30D
+			); // todo: update using now and lastTs?
+
+			const stakedQuoteAssetAmount = userStatsAccount.ifStakedQuoteAssetAmount;
+			const volumeTiers = [
+				new BN(100_000_000).mul(QUOTE_PRECISION),
+				new BN(50_000_000).mul(QUOTE_PRECISION),
+				new BN(10_000_000).mul(QUOTE_PRECISION),
+				new BN(5_000_000).mul(QUOTE_PRECISION),
+				new BN(1_000_000).mul(QUOTE_PRECISION),
+			];
+			const stakedTiers = [
+				new BN(10000).mul(QUOTE_PRECISION),
+				new BN(5000).mul(QUOTE_PRECISION),
+				new BN(2000).mul(QUOTE_PRECISION),
+				new BN(1000).mul(QUOTE_PRECISION),
+				new BN(500).mul(QUOTE_PRECISION),
+			];
+
+			for (let i = 0; i < volumeTiers.length; i++) {
+				if (
+					total30dVolume.gte(volumeTiers[i]) ||
+					stakedQuoteAssetAmount.gte(stakedTiers[i])
+				) {
+					feeTierIndex = 5 - i;
+					break;
+				}
+			}
+
+			return state.perpFeeStructure.feeTiers[feeTierIndex];
+		}
+
+		return state.spotFeeStructure.feeTiers[feeTierIndex];
+	}
+
+	/**
+	 * Calculates taker / maker fee (as a percentage, e.g. .001 = 10 basis points) for particular marketType
+	 * @param marketType
+	 * @param positionMarketIndex
+	 * @returns : {takerFee: number, makerFee: number} Precision None
+	 */
+	public getMarketFees(marketType: MarketType, marketIndex?: number) {
+		const feeTier = this.getUserFeeTier(marketType);
+		let takerFee = feeTier.feeNumerator / feeTier.feeDenominator;
+		let makerFee =
+			feeTier.makerRebateNumerator / feeTier.makerRebateDenominator;
+
+		if (marketIndex && isVariant(marketType, 'perp')) {
+			const marketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
+			takerFee += (takerFee * marketAccount.feeAdjustment) / 100;
+			makerFee += (makerFee * marketAccount.feeAdjustment) / 100;
+		}
+
+		return {
+			takerFee,
+			makerFee,
+		};
+	}
+
 	/**
-	 * Calculates how much fee will be taken for a given sized trade
+	 * Calculates how much perp fee will be taken for a given sized trade
 	 * @param quoteAmount
 	 * @returns feeForQuote : Precision QUOTE_PRECISION
 	 */
 	public calculateFeeForQuoteAmount(quoteAmount: BN): BN {
-		const feeTier =
-			this.driftClient.getStateAccount().perpFeeStructure.feeTiers[0];
+		const feeTier = this.getUserFeeTier(MarketType.PERP);
 		return quoteAmount
 			.mul(new BN(feeTier.feeNumerator))
 			.div(new BN(feeTier.feeDenominator));