@drift-labs/sdk 2.82.0-beta.1 → 2.82.0-beta.11

package/src/auctionSubscriber/auctionSubscriber.ts

@@ -6,20 +6,26 @@ import { EventEmitter } from 'events';
 import { UserAccount } from '../types';
 import { ConfirmOptions, Context, PublicKey } from '@solana/web3.js';
 import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
+import { ResubOpts } from '../accounts/types';
 
 export class AuctionSubscriber {
 	private driftClient: DriftClient;
 	private opts: ConfirmOptions;
-	private resubTimeoutMs?: number;
+	private resubOpts?: ResubOpts;
 
 	eventEmitter: StrictEventEmitter<EventEmitter, AuctionSubscriberEvents>;
 	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
 
-	constructor({ driftClient, opts, resubTimeoutMs }: AuctionSubscriberConfig) {
+	constructor({
+		driftClient,
+		opts,
+		resubTimeoutMs,
+		logResubMessages,
+	}: AuctionSubscriberConfig) {
 		this.driftClient = driftClient;
 		this.opts = opts || this.driftClient.opts;
 		this.eventEmitter = new EventEmitter();
-		this.resubTimeoutMs = resubTimeoutMs;
+		this.resubOpts = { resubTimeoutMs, logResubMessages };
 	}
 
 	public async subscribe() {
@@ -35,7 +41,7 @@ export class AuctionSubscriber {
 					filters: [getUserFilter(), getUserWithAuctionFilter()],
 					commitment: this.opts.commitment,
 				},
-				this.resubTimeoutMs
+				this.resubOpts
 			);
 		}
 

package/src/auctionSubscriber/types.ts

@@ -6,6 +6,7 @@ export type AuctionSubscriberConfig = {
 	driftClient: DriftClient;
 	opts?: ConfirmOptions;
 	resubTimeoutMs?: number;
+	logResubMessages?: boolean;
 };
 
 export interface AuctionSubscriberEvents {

package/src/blockhashSubscriber/types.ts

@@ -1,8 +1,12 @@
 import { Commitment, Connection } from '@solana/web3.js';
 
 export type BlockhashSubscriberConfig = {
+	/// rpcUrl to poll block hashes from, one of rpcUrl or Connection must provided
 	rpcUrl?: string;
+	/// connection to poll block hashes from, one of rpcUrl or Connection must provided
 	connection?: Connection;
+	/// commitment to poll block hashes with, default is 'confirmed'
 	commitment?: Commitment;
+	/// interval to poll block hashes, default is 1000 ms
 	updateIntervalMs?: number;
 };

package/src/constants/perpMarkets.ts

@@ -553,9 +553,9 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 		symbol: 'KMNO-PERP',
 		baseAssetSymbol: 'KMNO',
 		marketIndex: 28,
-		oracle: new PublicKey('sDAQaZQJQ4RXAxH3x526mbEXyQZT15ktkL84d7hmk7M'),
+		oracle: new PublicKey('6ynsvjkE2UoiRScbDx7ZxbBsyn7wyvg5P1vENvhtkG1C'),
 		launchTs: 1712240681000,
-		oracleSource: OracleSource.Prelaunch,
+		oracleSource: OracleSource.SWITCHBOARD,
 	},
 	{
 		fullName: 'Tensor',

package/src/driftClient.ts

@@ -251,11 +251,13 @@ export class DriftClient {
 			this.userAccountSubscriptionConfig = {
 				type: 'websocket',
 				resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+				logResubMessages: config.accountSubscription?.logResubMessages,
 				commitment: config.accountSubscription?.commitment,
 			};
 			this.userStatsAccountSubscriptionConfig = {
 				type: 'websocket',
 				resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+				logResubMessages: config.accountSubscription?.logResubMessages,
 				commitment: config.accountSubscription?.commitment,
 			};
 		}
@@ -298,7 +300,10 @@ export class DriftClient {
 				config.spotMarketIndexes ?? [],
 				config.oracleInfos ?? [],
 				noMarketsAndOraclesSpecified,
-				config.accountSubscription?.resubTimeoutMs,
+				{
+					resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+					logResubMessages: config.accountSubscription?.logResubMessages,
+				},
 				config.accountSubscription?.commitment
 			);
 		}
@@ -6488,18 +6493,33 @@ export class DriftClient {
 	}
 
 	public async settleRevenueToInsuranceFund(
-		marketIndex: number
+		spotMarketIndex: number,
+		subAccountId?: number,
+		txParams?: TxParams
 	): Promise<TransactionSignature> {
-		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const tx = await this.buildTransaction(
+			await this.getSettleRevenueToInsuranceFundIx(
+				spotMarketIndex,
+				subAccountId
+			),
+			txParams
+		);
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+		return txSig;
+	}
 
+	public async getSettleRevenueToInsuranceFundIx(
+		spotMarketIndex: number,
+		subAccountId?: number
+	): Promise<TransactionInstruction> {
+		const spotMarketAccount = this.getSpotMarketAccount(spotMarketIndex);
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount()],
+			userAccounts: [this.getUserAccount(subAccountId)],
 			useMarketLastSlotCache: true,
-			writableSpotMarketIndexes: [marketIndex],
+			writableSpotMarketIndexes: [spotMarketIndex],
 		});
-
 		const ix = await this.program.instruction.settleRevenueToInsuranceFund(
-			marketIndex,
+			spotMarketIndex,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
@@ -6512,11 +6532,7 @@ export class DriftClient {
 				remainingAccounts,
 			}
 		);
-
-		const tx = await this.buildTransaction(ix);
-
-		const { txSig } = await this.sendTransaction(tx, [], this.opts);
-		return txSig;
+		return ix;
 	}
 
 	public async resolvePerpPnlDeficit(
@@ -6629,6 +6645,48 @@ export class DriftClient {
 		return extendedInfo;
 	}
 
+	/**
+	 * 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,
+		user?: User
+	) {
+		let feeTier;
+		if (user) {
+			feeTier = user.getUserFeeTier(marketType);
+		} else {
+			const state = this.getStateAccount();
+			feeTier = isVariant(marketType, 'perp')
+				? state.perpFeeStructure.feeTiers[0]
+				: state.spotFeeStructure.feeTiers[0];
+		}
+
+		let takerFee = feeTier.feeNumerator / feeTier.feeDenominator;
+		let makerFee =
+			feeTier.makerRebateNumerator / feeTier.makerRebateDenominator;
+
+		if (marketIndex !== undefined) {
+			let marketAccount = null;
+			if (isVariant(marketType, 'perp')) {
+				marketAccount = this.getPerpMarketAccount(marketIndex);
+			} else {
+				marketAccount = this.getSpotMarketAccount(marketIndex);
+			}
+			takerFee += (takerFee * marketAccount.feeAdjustment) / 100;
+			makerFee += (makerFee * marketAccount.feeAdjustment) / 100;
+		}
+
+		return {
+			takerFee,
+			makerFee,
+		};
+	}
+
 	/**
 	 * Returns the market index and type for a given market name
 	 * E.g. "SOL-PERP" -> { marketIndex: 0, marketType: MarketType.PERP }

package/src/driftClientConfig.ts

@@ -39,6 +39,7 @@ export type DriftClientSubscriptionConfig =
 	| {
 			type: 'websocket';
 			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
 			commitment?: Commitment;
 	  }
 	| {

package/src/orderSubscriber/OrderSubscriber.ts

@@ -39,7 +39,10 @@ export class OrderSubscriber {
 				orderSubscriber: this,
 				commitment: this.commitment,
 				skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
-				resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
+				resubOpts: {
+					resubTimeoutMs: config.subscriptionConfig?.resubTimeoutMs,
+					logResubMessages: config.subscriptionConfig?.logResubMessages,
+				},
 				resyncIntervalMs: config.subscriptionConfig.resyncIntervalMs,
 				decoded: config.decodeData,
 			});

package/src/orderSubscriber/WebsocketSubscription.ts

@@ -3,12 +3,13 @@ import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
 import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
 import { UserAccount } from '../types';
 import { Commitment, Context, PublicKey } from '@solana/web3.js';
+import { ResubOpts } from '../accounts/types';
 
 export class WebsocketSubscription {
 	private orderSubscriber: OrderSubscriber;
 	private commitment: Commitment;
 	private skipInitialLoad: boolean;
-	private resubTimeoutMs?: number;
+	private resubOpts?: ResubOpts;
 	private resyncIntervalMs?: number;
 
 	private subscriber?: WebSocketProgramAccountSubscriber<UserAccount>;
@@ -20,21 +21,21 @@ export class WebsocketSubscription {
 		orderSubscriber,
 		commitment,
 		skipInitialLoad = false,
-		resubTimeoutMs,
+		resubOpts,
 		resyncIntervalMs,
 		decoded = true,
 	}: {
 		orderSubscriber: OrderSubscriber;
 		commitment: Commitment;
 		skipInitialLoad?: boolean;
-		resubTimeoutMs?: number;
+		resubOpts?: ResubOpts;
 		resyncIntervalMs?: number;
 		decoded?: boolean;
 	}) {
 		this.orderSubscriber = orderSubscriber;
 		this.commitment = commitment;
 		this.skipInitialLoad = skipInitialLoad;
-		this.resubTimeoutMs = resubTimeoutMs;
+		this.resubOpts = resubOpts;
 		this.resyncIntervalMs = resyncIntervalMs;
 		this.decoded = decoded;
 	}
@@ -53,7 +54,7 @@ export class WebsocketSubscription {
 				filters: [getUserFilter(), getNonIdleUserFilter()],
 				commitment: this.commitment,
 			},
-			this.resubTimeoutMs
+			this.resubOpts
 		);
 
 		await this.subscriber.subscribe(

package/src/orderSubscriber/types.ts

@@ -14,6 +14,7 @@ export type OrderSubscriberConfig = {
 				type: 'websocket';
 				skipInitialLoad?: boolean;
 				resubTimeoutMs?: number;
+				logResubMessages?: boolean;
 				resyncIntervalMs?: number;
 				commitment?: Commitment;
 		  };

package/src/priorityFee/driftPriorityFeeMethod.ts

@@ -1,18 +1,30 @@
 import fetch from 'node-fetch';
-import { HeliusPriorityFeeLevels } from './heliusPriorityFeeMethod';
+import { HeliusPriorityLevel } from './heliusPriorityFeeMethod';
 
-export type DriftPriorityFeeResponse = HeliusPriorityFeeLevels[];
+export type DriftMarketInfo = {
+	marketType: string;
+	marketIndex: number;
+};
+
+export type DriftPriorityFeeLevels = {
+	[key in HeliusPriorityLevel]: number;
+} & {
+	marketType: 'perp' | 'spot';
+	marketIndex: number;
+};
+
+export type DriftPriorityFeeResponse = DriftPriorityFeeLevels[];
 
 export async function fetchDriftPriorityFee(
 	url: string,
 	marketTypes: string[],
-	marketIndexs: number[]
+	marketIndexes: number[]
 ): Promise<DriftPriorityFeeResponse> {
 	try {
 		const response = await fetch(
 			`${url}/batchPriorityFees?marketType=${marketTypes.join(
 				','
-			)}&marketIndex=${marketIndexs.join(',')}`
+			)}&marketIndex=${marketIndexes.join(',')}`
 		);
 		if (!response.ok) {
 			throw new Error(`HTTP error! status: ${response.status}`);

package/src/priorityFee/index.ts

@@ -4,6 +4,8 @@ export * from './ewmaStrategy';
 export * from './maxOverSlotsStrategy';
 export * from './maxStrategy';
 export * from './priorityFeeSubscriber';
+export * from './priorityFeeSubscriberMap';
 export * from './solanaPriorityFeeMethod';
 export * from './heliusPriorityFeeMethod';
+export * from './driftPriorityFeeMethod';
 export * from './types';

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -1,5 +1,6 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 import {
+	DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS,
 	PriorityFeeMethod,
 	PriorityFeeStrategy,
 	PriorityFeeSubscriberConfig,
@@ -12,12 +13,10 @@ import {
 	HeliusPriorityLevel,
 	fetchHeliusPriorityFee,
 } from './heliusPriorityFeeMethod';
-import { fetchDriftPriorityFee } from './driftPriorityFeeMethod';
-
-export type DriftMarketInfo = {
-	marketType: string;
-	marketIndex: number;
-};
+import {
+	fetchDriftPriorityFee,
+	DriftMarketInfo,
+} from './driftPriorityFeeMethod';
 
 export class PriorityFeeSubscriber {
 	connection: Connection;
@@ -46,7 +45,8 @@ export class PriorityFeeSubscriber {
 
 	public constructor(config: PriorityFeeSubscriberConfig) {
 		this.connection = config.connection;
-		this.frequencyMs = config.frequencyMs;
+		this.frequencyMs =
+			config.frequencyMs ?? DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS;
 		this.addresses = config.addresses
 			? config.addresses.map((address) => address.toBase58())
 			: [];

package/src/priorityFee/priorityFeeSubscriberMap.ts

@@ -0,0 +1,112 @@
+import {
+	DriftMarketInfo,
+	DriftPriorityFeeLevels,
+	DriftPriorityFeeResponse,
+	fetchDriftPriorityFee,
+} from './driftPriorityFeeMethod';
+import {
+	DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS,
+	PriorityFeeSubscriberMapConfig,
+} from './types';
+
+/**
+ * takes advantage of /batchPriorityFees endpoint from drift hosted priority fee service
+ */
+export class PriorityFeeSubscriberMap {
+	frequencyMs: number;
+	intervalId?: ReturnType<typeof setTimeout>;
+
+	driftMarkets?: DriftMarketInfo[];
+	driftPriorityFeeEndpoint?: string;
+	feesMap: Map<string, Map<number, DriftPriorityFeeLevels>>; // marketType -> marketIndex -> priority fee
+
+	public constructor(config: PriorityFeeSubscriberMapConfig) {
+		this.frequencyMs = config.frequencyMs;
+		this.frequencyMs =
+			config.frequencyMs ?? DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS;
+		this.driftPriorityFeeEndpoint = config.driftPriorityFeeEndpoint;
+		this.driftMarkets = config.driftMarkets;
+		this.feesMap = new Map<string, Map<number, DriftPriorityFeeLevels>>();
+		this.feesMap.set('perp', new Map<number, DriftPriorityFeeLevels>());
+		this.feesMap.set('spot', new Map<number, DriftPriorityFeeLevels>());
+	}
+
+	private updateFeesMap(driftPriorityFeeResponse: DriftPriorityFeeResponse) {
+		driftPriorityFeeResponse.forEach((fee: DriftPriorityFeeLevels) => {
+			this.feesMap.get(fee.marketType)!.set(fee.marketIndex, fee);
+		});
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.intervalId) {
+			return;
+		}
+
+		await this.load();
+		this.intervalId = setInterval(this.load.bind(this), this.frequencyMs);
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+	}
+
+	public async load(): Promise<void> {
+		try {
+			if (!this.driftMarkets) {
+				return;
+			}
+			const fees = await fetchDriftPriorityFee(
+				this.driftPriorityFeeEndpoint!,
+				this.driftMarkets.map((m) => m.marketType),
+				this.driftMarkets.map((m) => m.marketIndex)
+			);
+			this.updateFeesMap(fees);
+		} catch (e) {
+			console.error('Error fetching drift priority fees', e);
+		}
+	}
+
+	public updateMarketTypeAndIndex(driftMarkets: DriftMarketInfo[]) {
+		this.driftMarkets = driftMarkets;
+	}
+
+	public getPriorityFees(
+		marketType: string,
+		marketIndex: number
+	): DriftPriorityFeeLevels | undefined {
+		return this.feesMap.get(marketType)?.get(marketIndex);
+	}
+}
+
+/** Example usage:
+async function main() {
+    const driftMarkets: DriftMarketInfo[] = [
+        { marketType: 'perp', marketIndex: 0 },
+        { marketType: 'perp', marketIndex: 1 },
+        { marketType: 'spot', marketIndex: 2 }
+    ];
+
+    const subscriber = new PriorityFeeSubscriberMap({
+        driftPriorityFeeEndpoint: 'https://dlob.drift.trade',
+        frequencyMs: 5000,
+        driftMarkets
+    });
+    await subscriber.subscribe();
+
+    for (let i = 0; i < 20; i++) {
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        driftMarkets.forEach(market => {
+            const fees = subscriber.getPriorityFees(market.marketType, market.marketIndex);
+            console.log(`Priority fees for ${market.marketType} market ${market.marketIndex}:`, fees);
+        });
+    }
+
+
+    await subscriber.unsubscribe();
+}
+
+main().catch(console.error);
+*/

package/src/priorityFee/types.ts

@@ -1,8 +1,12 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { HeliusPriorityFeeResponse } from './heliusPriorityFeeMethod';
-import { DriftMarketInfo } from './priorityFeeSubscriber';
-import { DriftPriorityFeeResponse } from './driftPriorityFeeMethod';
+import {
+	DriftMarketInfo,
+	DriftPriorityFeeResponse,
+} from './driftPriorityFeeMethod';
+
+export const DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS = 10_000;
 
 export interface PriorityFeeStrategy {
 	// calculate the priority fee for a given set of samples.
@@ -25,7 +29,7 @@ export type PriorityFeeSubscriberConfig = {
 	/// rpc connection, optional if using priorityFeeMethod.HELIUS
 	connection?: Connection;
 	/// frequency to make RPC calls to update priority fee samples, in milliseconds
-	frequencyMs: number;
+	frequencyMs?: number;
 	/// addresses you plan to write lock, used to determine priority fees
 	addresses?: PublicKey[];
 	/// drift market type and index, optionally provide at initialization time if using priorityFeeMethod.DRIFT
@@ -45,3 +49,12 @@ export type PriorityFeeSubscriberConfig = {
 	/// multiplier applied to priority fee before maxFeeMicroLamports, defaults to 1.0
 	priorityFeeMultiplier?: number;
 };
+
+export type PriorityFeeSubscriberMapConfig = {
+	/// frequency to make RPC calls to update priority fee samples, in milliseconds
+	frequencyMs?: number;
+	/// drift market type and associated market index to query
+	driftMarkets?: DriftMarketInfo[];
+	/// url for drift cached priority fee endpoint
+	driftPriorityFeeEndpoint: string;
+};

package/src/tx/baseTxSender.ts

@@ -2,6 +2,7 @@ import {
 	ConfirmationStrategy,
 	ExtraConfirmationOptions,
 	TxSender,
+	TxSendError,
 	TxSigAndSlot,
 } from './types';
 import {
@@ -25,6 +26,7 @@ import bs58 from 'bs58';
 import { IWallet } from '../types';
 
 const DEFAULT_TIMEOUT = 35000;
+const NOT_CONFIRMED_ERROR_CODE = -1001;
 
 export abstract class BaseTxSender implements TxSender {
 	connection: Connection;
@@ -282,10 +284,11 @@ export abstract class BaseTxSender implements TxSender {
 			}
 			this.timeoutCount += 1;
 			const duration = (Date.now() - start) / 1000;
-			throw new Error(
+			throw new TxSendError(
 				`Transaction was not confirmed in ${duration.toFixed(
 					2
-				)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`
+				)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`,
+				NOT_CONFIRMED_ERROR_CODE
 			);
 		}
 
@@ -317,10 +320,11 @@ export abstract class BaseTxSender implements TxSender {
 		// Transaction not confirmed within 30 seconds
 		this.timeoutCount += 1;
 		const duration = (Date.now() - start) / 1000;
-		throw new Error(
+		throw new TxSendError(
 			`Transaction was not confirmed in ${duration.toFixed(
 				2
-			)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`
+			)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`,
+			NOT_CONFIRMED_ERROR_CODE
 		);
 	}
 

package/src/tx/types.ts

@@ -60,3 +60,15 @@ export interface TxSender {
 
 	getTimeoutCount(): number;
 }
+
+export class TxSendError extends Error {
+	constructor(
+		public message: string,
+		public code: number
+	) {
+		super(message);
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(this, TxSendError);
+		}
+	}
+}

package/src/tx/utils.ts

@@ -53,7 +53,11 @@ export async function getSignedTransactionMap(
 	});
 
 	const signedTxs = await wallet.signAllTransactions(
-		txsToSign.filter((tx) => tx !== undefined)
+		txsToSign
+			.map((tx) => {
+				return tx as Transaction;
+			})
+			.filter((tx) => tx !== undefined)
 	);
 
 	signedTxs.forEach((signedTx, index) => {

package/src/user.ts

@@ -118,7 +118,10 @@ export class User {
 			this.accountSubscriber = new WebSocketUserAccountSubscriber(
 				config.driftClient.program,
 				config.userAccountPublicKey,
-				config.accountSubscription?.resubTimeoutMs,
+				{
+					resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+					logResubMessages: config.accountSubscription?.logResubMessages,
+				},
 				config.accountSubscription?.commitment
 			);
 		}
@@ -3162,35 +3165,6 @@ export class User {
 		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 !== undefined) {
-			let marketAccount = null;
-			if (isVariant(marketType, 'perp')) {
-				marketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
-			} else {
-				marketAccount = this.driftClient.getSpotMarketAccount(marketIndex);
-			}
-			takerFee += (takerFee * marketAccount.feeAdjustment) / 100;
-			makerFee += (makerFee * marketAccount.feeAdjustment) / 100;
-		}
-
-		return {
-			takerFee,
-			makerFee,
-		};
-	}
-
 	/**
 	 * Calculates how much perp fee will be taken for a given sized trade
 	 * @param quoteAmount
@@ -3198,9 +3172,10 @@ export class User {
 	 */
 	public calculateFeeForQuoteAmount(quoteAmount: BN, marketIndex?: number): BN {
 		if (marketIndex !== undefined) {
-			const takerFeeMultiplier = this.getMarketFees(
+			const takerFeeMultiplier = this.driftClient.getMarketFees(
 				MarketType.PERP,
-				marketIndex
+				marketIndex,
+				this
 			).takerFee;
 			const feeAmountNum =
 				BigNum.from(quoteAmount, QUOTE_PRECISION_EXP).toNum() *

package/src/userConfig.ts

@@ -13,6 +13,7 @@ export type UserSubscriptionConfig =
 	| {
 			type: 'websocket';
 			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
 			commitment?: Commitment;
 	  }
 	| {