@drift-labs/sdk 2.54.0-beta.3 → 2.54.0-beta.5

package/VERSION

@@ -1 +1 @@
-2.54.0-beta.3
+2.54.0-beta.5

package/lib/accounts/pollingInsuranceFundStakeAccountSubscriber.js

@@ -22,7 +22,6 @@ class PollingInsuranceFundStakeAccountSubscriber {
             };
         }
         await this.addToAccountLoader();
-        await this.fetchIfUnloaded();
         if (this.doesAccountExist()) {
             this.eventEmitter.emit('update');
         }

package/lib/driftClient.d.ts

@@ -310,7 +310,7 @@ export declare class DriftClient {
         direction?: PositionDirection;
     }, placeOrderParams: OrderParams[], txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     placeOrders(params: OrderParams[], txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
-    getPlaceOrdersIx(params: OrderParams[], subAccountId?: number): Promise<TransactionInstruction>;
+    getPlaceOrdersIx(params: OptionalOrderParams[], subAccountId?: number): Promise<TransactionInstruction>;
     fillPerpOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams, fillerPublicKey?: number): Promise<TransactionSignature>;
     getFillPerpOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, fillerSubAccountId?: number): Promise<TransactionInstruction>;
     getRevertFillIx(fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
@@ -427,6 +427,10 @@ export declare class DriftClient {
     updateUserOpenOrdersCount(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams, fillerPublicKey?: PublicKey): Promise<TransactionSignature>;
     getUpdateUserOpenOrdersCountIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
     placeAndTakePerpOrder(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    placeAndTakePerpWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean): Promise<{
+        txSig: TransactionSignature;
+        signedCancelExistingOrdersTx?: Transaction;
+    }>;
     getPlaceAndTakePerpOrderIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, subAccountId?: number): Promise<TransactionInstruction>;
     placeAndMakePerpOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     getPlaceAndMakePerpOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, subAccountId?: number): Promise<TransactionInstruction>;

package/lib/driftClient.js

@@ -1422,12 +1422,7 @@ class DriftClient {
     async sendMarketOrderAndGetSignedFillTx(orderParams, userAccountPublicKey, userAccount, makerInfo, txParams, bracketOrdersParams = new Array(), referrerInfo, cancelExistingOrders) {
         const marketIndex = orderParams.marketIndex;
         const orderId = userAccount.nextOrderId;
-        const bracketOrderIxs = [];
-        const placePerpOrderIx = await this.getPlacePerpOrderIx(orderParams, userAccount.subAccountId);
-        for (const bracketOrderParams of bracketOrdersParams) {
-            const placeBracketOrderIx = await this.getPlacePerpOrderIx(bracketOrderParams, userAccount.subAccountId);
-            bracketOrderIxs.push(placeBracketOrderIx);
-        }
+        const ordersIx = await this.getPlaceOrdersIx([orderParams, ...bracketOrdersParams], userAccount.subAccountId);
         let cancelOrdersIx;
         let cancelExistingOrdersTx;
         if (cancelExistingOrders && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
@@ -1437,7 +1432,7 @@ class DriftClient {
         }
         // use versioned transactions if there is a lookup table account and wallet is compatible
         if (this.txVersion === 0) {
-            const versionedMarketOrderTx = await this.buildTransaction([placePerpOrderIx].concat(bracketOrderIxs), txParams, 0);
+            const versionedMarketOrderTx = await this.buildTransaction(ordersIx, txParams, 0);
             const fillPerpOrderIx = await this.getFillPerpOrderIx(userAccountPublicKey, userAccount, {
                 orderId,
                 marketIndex,
@@ -1459,10 +1454,7 @@ class DriftClient {
             };
         }
         else {
-            const marketOrderTx = (0, utils_1.wrapInTx)(placePerpOrderIx, txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits, txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice);
-            if (bracketOrderIxs.length > 0) {
-                marketOrderTx.add(...bracketOrderIxs);
-            }
+            const marketOrderTx = (0, utils_1.wrapInTx)(ordersIx, txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits, txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice);
             // Apply the latest blockhash to the txs so that we can sign before sending them
             const currentBlockHash = (await this.connection.getLatestBlockhash('finalized')).blockhash;
             marketOrderTx.recentBlockhash = currentBlockHash;
@@ -1708,7 +1700,8 @@ class DriftClient {
             readableSpotMarketIndexes,
             useMarketLastSlotCache: true,
         });
-        return await this.program.instruction.placeOrders(params, {
+        const formattedParams = params.map((item) => (0, orderParams_1.getOrderParams)(item));
+        return await this.program.instruction.placeOrders(formattedParams, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 user,
@@ -2168,7 +2161,6 @@ class DriftClient {
                 slippageBps,
                 swapMode,
                 onlyDirectRoutes,
-                excludeDexes: ['Raydium CLMM'], // temp exclude to workaround bug with raydium clmm
             });
             quote = fetchedQuote;
         }
@@ -2412,6 +2404,25 @@ class DriftClient {
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
+    async placeAndTakePerpWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders) {
+        let signedCancelExistingOrdersTx;
+        if (cancelExistingOrders && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
+            const cancelOrdersIx = await this.getCancelOrdersIx(orderParams.marketType, orderParams.marketIndex, null, subAccountId);
+            const cancelExistingOrdersTx = await this.buildTransaction([cancelOrdersIx], txParams, this.txVersion);
+            // @ts-ignore
+            signedCancelExistingOrdersTx = await this.provider.wallet.signTransaction(cancelExistingOrdersTx);
+        }
+        const ixs = [];
+        const placeAndTakeIx = await this.getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo, subAccountId);
+        ixs.push(placeAndTakeIx);
+        if (bracketOrdersParams.length > 0) {
+            const bracketOrdersIx = await this.getPlaceOrdersIx(bracketOrdersParams, subAccountId);
+            ixs.push(bracketOrdersIx);
+        }
+        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(ixs, txParams), [], this.opts);
+        this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
+        return { txSig, signedCancelExistingOrdersTx };
+    }
     async getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo, subAccountId) {
         orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });
         const userStatsPublicKey = await this.getUserStatsAccountPublicKey();

package/lib/jupiter/jupiterClient.d.ts

@@ -195,6 +195,12 @@ export interface QuoteResponse {
      * @memberof QuoteResponse
      */
     timeTaken?: number;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    error?: string;
 }
 export declare class JupiterClient {
     url: string;

package/lib/jupiter/jupiterClient.js

@@ -44,7 +44,7 @@ class JupiterClient {
      * @param onlyDirectRoutes whether to only return direct routes
      */
     async getQuote({ inputMint, outputMint, amount, maxAccounts = 50, // 50 is an estimated amount with buffer
-    slippageBps = 50, swapMode = 'ExactIn', onlyDirectRoutes = false, excludeDexes = [], }) {
+    slippageBps = 50, swapMode = 'ExactIn', onlyDirectRoutes = false, excludeDexes, }) {
         const params = new URLSearchParams({
             inputMint: inputMint.toString(),
             outputMint: outputMint.toString(),
@@ -53,7 +53,7 @@ class JupiterClient {
             swapMode,
             onlyDirectRoutes: onlyDirectRoutes.toString(),
             maxAccounts: maxAccounts.toString(),
-            excludeDexes: excludeDexes.join(','),
+            ...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
         }).toString();
         const quote = await (await (0, node_fetch_1.default)(`${this.url}/v6/quote?${params}`)).json();
         return quote;

package/lib/math/funding.js

@@ -6,6 +6,7 @@ const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
 const oracles_1 = require("./oracles");
+const utils_1 = require("./utils");
 function calculateLiveMarkTwap(market, oraclePriceData, markPrice, now, period = new anchor_1.BN(3600)) {
     now = now || new anchor_1.BN((Date.now() / 1000).toFixed(0));
     const lastMarkTwapWithMantissa = market.amm.lastMarkPriceTwap;
@@ -73,7 +74,9 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, markPri
     // }
     const twapSpread = markTwap.sub(oracleTwap);
     const twapSpreadWithOffset = twapSpread.add(oracleTwap.abs().div(numericConstants_1.FUNDING_RATE_OFFSET_DENOMINATOR));
-    const twapSpreadPct = twapSpreadWithOffset
+    const maxSpread = getMaxPriceDivergenceForFundingRate(market, oracleTwap);
+    const clampedSpreadWithOffset = (0, utils_1.clampBN)(twapSpreadWithOffset, maxSpread.mul(new anchor_1.BN(-1)), maxSpread);
+    const twapSpreadPct = clampedSpreadWithOffset
         .mul(numericConstants_1.PRICE_PRECISION)
         .mul(new anchor_1.BN(100))
         .div(oracleTwap);
@@ -135,6 +138,26 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, markPri
     return [markTwap, oracleTwap, lowerboundEst, cappedAltEst, interpEst];
 }
 exports.calculateAllEstimatedFundingRate = calculateAllEstimatedFundingRate;
+function getMaxPriceDivergenceForFundingRate(market, oracleTwap) {
+    if ((0, types_1.isVariant)(market.contractTier, 'a')) {
+        return oracleTwap.divn(33);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'b')) {
+        return oracleTwap.divn(33);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'c')) {
+        return oracleTwap.divn(20);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'speculative')) {
+        return oracleTwap.divn(10);
+    }
+    else if ((0, types_1.isVariant)(market.contractTier, 'isolated')) {
+        return oracleTwap.divn(10);
+    }
+    else {
+        return oracleTwap.divn(10);
+    }
+}
 /**
  *
  * @param market

package/lib/math/oracles.js

@@ -25,8 +25,8 @@ function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
         .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
         .div(oraclePriceData.price)
         .gt(oracleGuardRails.validity.confidenceIntervalMaxSize);
-    const oracleIsStale = oraclePriceData.slot
-        .sub(new index_1.BN(slot))
+    const oracleIsStale = new index_1.BN(slot)
+        .sub(oraclePriceData.slot)
         .gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
     return !(!oraclePriceData.hasSufficientNumberOfDataPoints ||
         oracleIsStale ||

package/lib/math/superStake.js

@@ -233,7 +233,9 @@ async function calculateSolEarned({ marketIndex, user, depositRecords, }) {
     const now = Date.now() / 1000;
     const timestamps = [
         now,
-        ...depositRecords.map((r) => r.ts.toNumber()),
+        ...depositRecords
+            .filter((r) => r.marketIndex === marketIndex)
+            .map((r) => r.ts.toNumber()),
     ];
     let lstRatios = new Map();
     const getMsolPrice = async (timestamp) => {

package/lib/priorityFee/averageOverSlotsStrategy.d.ts

@@ -1,10 +1,5 @@
 import { PriorityFeeStrategy } from './types';
 export declare class AverageOverSlotsStrategy implements PriorityFeeStrategy {
-    private lookbackSlots;
-    /**
-     * @param lookbackSlots The number of slots to look back from the max slot in the sample
-     */
-    constructor(lookbackSlots?: number);
     calculate(samples: {
         slot: number;
         prioritizationFee: number;

package/lib/priorityFee/averageOverSlotsStrategy.js

@@ -2,27 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AverageOverSlotsStrategy = void 0;
 class AverageOverSlotsStrategy {
-    /**
-     * @param lookbackSlots The number of slots to look back from the max slot in the sample
-     */
-    constructor(lookbackSlots = 10) {
-        this.lookbackSlots = lookbackSlots;
-    }
     calculate(samples) {
         if (samples.length === 0) {
             return 0;
         }
-        const stopSlot = samples[0].slot - this.lookbackSlots;
         let runningSumFees = 0;
-        let countFees = 0;
         for (let i = 0; i < samples.length; i++) {
-            if (samples[i].slot <= stopSlot) {
-                return runningSumFees / countFees;
-            }
             runningSumFees += samples[i].prioritizationFee;
-            countFees++;
         }
-        return runningSumFees / countFees;
+        return runningSumFees / samples.length;
     }
 }
 exports.AverageOverSlotsStrategy = AverageOverSlotsStrategy;

package/lib/priorityFee/maxOverSlotsStrategy.d.ts

@@ -1,10 +1,5 @@
 import { PriorityFeeStrategy } from './types';
 export declare class MaxOverSlotsStrategy implements PriorityFeeStrategy {
-    private lookbackSlots;
-    /**
-     * @param lookbackSlots The number of slots to look back from the max slot in the sample
-     */
-    constructor(lookbackSlots?: number);
     calculate(samples: {
         slot: number;
         prioritizationFee: number;

package/lib/priorityFee/maxOverSlotsStrategy.js

@@ -2,26 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxOverSlotsStrategy = void 0;
 class MaxOverSlotsStrategy {
-    /**
-     * @param lookbackSlots The number of slots to look back from the max slot in the sample
-     */
-    constructor(lookbackSlots = 10) {
-        this.lookbackSlots = lookbackSlots;
-    }
     calculate(samples) {
         if (samples.length === 0) {
             return 0;
         }
         // Assuming samples are sorted in descending order of slot.
-        const stopSlot = samples[0].slot - this.lookbackSlots;
         let currMaxFee = samples[0].prioritizationFee;
         for (let i = 0; i < samples.length; i++) {
-            if (samples[i].slot <= stopSlot) {
-                return currMaxFee;
-            }
-            if (samples[i].prioritizationFee > currMaxFee) {
-                currMaxFee = samples[i].prioritizationFee;
-            }
+            currMaxFee = Math.max(samples[i].prioritizationFee, currMaxFee);
         }
         return currMaxFee;
     }

package/lib/priorityFee/priorityFeeSubscriber.d.ts

@@ -9,13 +9,17 @@ export declare class PriorityFeeSubscriber {
     customStrategy?: PriorityFeeStrategy;
     averageStrategy: AverageOverSlotsStrategy;
     maxStrategy: MaxOverSlotsStrategy;
+    lookbackDistance: number;
     intervalId?: ReturnType<typeof setTimeout>;
     latestPriorityFee: number;
-    lastStrategyResult: number;
     lastCustomStrategyResult: number;
     lastAvgStrategyResult: number;
     lastMaxStrategyResult: number;
     lastSlotSeen: number;
+    /**
+     * @param props
+     * customStrategy : strategy to return the priority fee to use based on recent samples. defaults to AVERAGE.
+     */
     constructor({ connection, frequencyMs, addresses, customStrategy, slotsToCheck, }: {
         connection: Connection;
         frequencyMs: number;
@@ -23,9 +27,6 @@ export declare class PriorityFeeSubscriber {
         customStrategy?: PriorityFeeStrategy;
         slotsToCheck?: number;
     });
-    get avgPriorityFee(): number;
-    get maxPriorityFee(): number;
-    get customPriorityFee(): number;
     subscribe(): Promise<void>;
     load(): Promise<void>;
     unsubscribe(): Promise<void>;

package/lib/priorityFee/priorityFeeSubscriber.js

@@ -4,11 +4,14 @@ exports.PriorityFeeSubscriber = void 0;
 const averageOverSlotsStrategy_1 = require("./averageOverSlotsStrategy");
 const maxOverSlotsStrategy_1 = require("./maxOverSlotsStrategy");
 class PriorityFeeSubscriber {
+    /**
+     * @param props
+     * customStrategy : strategy to return the priority fee to use based on recent samples. defaults to AVERAGE.
+     */
     constructor({ connection, frequencyMs, addresses, customStrategy, slotsToCheck = 10, }) {
         this.averageStrategy = new averageOverSlotsStrategy_1.AverageOverSlotsStrategy();
         this.maxStrategy = new maxOverSlotsStrategy_1.MaxOverSlotsStrategy();
         this.latestPriorityFee = 0;
-        this.lastStrategyResult = 0;
         this.lastCustomStrategyResult = 0;
         this.lastAvgStrategyResult = 0;
         this.lastMaxStrategyResult = 0;
@@ -16,25 +19,13 @@ class PriorityFeeSubscriber {
         this.connection = connection;
         this.frequencyMs = frequencyMs;
         this.addresses = addresses;
-        if (slotsToCheck) {
-            this.averageStrategy = new averageOverSlotsStrategy_1.AverageOverSlotsStrategy(slotsToCheck);
-            this.maxStrategy = new maxOverSlotsStrategy_1.MaxOverSlotsStrategy(slotsToCheck);
+        if (!customStrategy) {
+            this.customStrategy = new averageOverSlotsStrategy_1.AverageOverSlotsStrategy();
         }
-        if (customStrategy) {
+        else {
             this.customStrategy = customStrategy;
         }
-    }
-    get avgPriorityFee() {
-        return Math.floor(this.lastAvgStrategyResult);
-    }
-    get maxPriorityFee() {
-        return Math.floor(this.lastMaxStrategyResult);
-    }
-    get customPriorityFee() {
-        if (!this.customStrategy) {
-            console.error('Custom strategy not set');
-        }
-        return Math.floor(this.lastCustomStrategyResult);
+        this.lookbackDistance = slotsToCheck;
     }
     async subscribe() {
         if (this.intervalId) {
@@ -45,19 +36,22 @@ class PriorityFeeSubscriber {
     async load() {
         // @ts-ignore
         const rpcJSONResponse = await this.connection._rpcRequest('getRecentPrioritizationFees', [this.addresses]);
-        // getRecentPrioritizationFees returns results unsorted
         const results = rpcJSONResponse === null || rpcJSONResponse === void 0 ? void 0 : rpcJSONResponse.result;
         if (!results.length)
             return;
+        // # Sort and filter results based on the slot lookback setting
         const descResults = results.sort((a, b) => b.slot - a.slot);
         const mostRecentResult = descResults[0];
+        const cutoffSlot = mostRecentResult.slot - this.lookbackDistance;
+        const resultsToUse = descResults.filter((result) => result.slot >= cutoffSlot);
+        // # Handle results
         this.latestPriorityFee = mostRecentResult.prioritizationFee;
         this.lastSlotSeen = mostRecentResult.slot;
-        this.lastAvgStrategyResult = this.averageStrategy.calculate(descResults);
-        this.lastMaxStrategyResult = this.maxStrategy.calculate(descResults);
+        this.lastAvgStrategyResult = this.averageStrategy.calculate(resultsToUse);
+        this.lastMaxStrategyResult = this.maxStrategy.calculate(resultsToUse);
         if (this.customStrategy) {
             this.lastCustomStrategyResult =
-                this.customStrategy.calculate(descResults);
+                this.customStrategy.calculate(resultsToUse);
         }
     }
     async unsubscribe() {

package/lib/userMap/userMap.js

@@ -236,6 +236,10 @@ class UserMap {
                     await this.addPubkey(new web3_js_1.PublicKey(key), userAccount);
                     this.userMap.get(key).accountSubscriber.updateData(userAccount, slot);
                 }
+                else {
+                    const userAccount = this.decode('User', buffer);
+                    this.userMap.get(key).accountSubscriber.updateData(userAccount, slot);
+                }
                 // give event loop a chance to breathe
                 await new Promise((resolve) => setTimeout(resolve, 0));
             }

package/package.json

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

package/src/accounts/pollingInsuranceFundStakeAccountSubscriber.ts

@@ -54,7 +54,6 @@ export class PollingInsuranceFundStakeAccountSubscriber
 
 		await this.addToAccountLoader();
 
-		await this.fetchIfUnloaded();
 		if (this.doesAccountExist()) {
 			this.eventEmitter.emit('update');
 		}

package/src/driftClient.ts

@@ -2573,21 +2573,12 @@ export class DriftClient {
 	}> {
 		const marketIndex = orderParams.marketIndex;
 		const orderId = userAccount.nextOrderId;
-		const bracketOrderIxs = [];
 
-		const placePerpOrderIx = await this.getPlacePerpOrderIx(
-			orderParams,
+		const ordersIx = await this.getPlaceOrdersIx(
+			[orderParams, ...bracketOrdersParams],
 			userAccount.subAccountId
 		);
 
-		for (const bracketOrderParams of bracketOrdersParams) {
-			const placeBracketOrderIx = await this.getPlacePerpOrderIx(
-				bracketOrderParams,
-				userAccount.subAccountId
-			);
-			bracketOrderIxs.push(placeBracketOrderIx);
-		}
-
 		let cancelOrdersIx: TransactionInstruction;
 		let cancelExistingOrdersTx: Transaction;
 		if (cancelExistingOrders && isVariant(orderParams.marketType, 'perp')) {
@@ -2609,7 +2600,7 @@ export class DriftClient {
 		// use versioned transactions if there is a lookup table account and wallet is compatible
 		if (this.txVersion === 0) {
 			const versionedMarketOrderTx = await this.buildTransaction(
-				[placePerpOrderIx].concat(bracketOrderIxs),
+				ordersIx,
 				txParams,
 				0
 			);
@@ -2658,15 +2649,11 @@ export class DriftClient {
 			};
 		} else {
 			const marketOrderTx = wrapInTx(
-				placePerpOrderIx,
+				ordersIx,
 				txParams?.computeUnits,
 				txParams?.computeUnitsPrice
 			);
 
-			if (bracketOrderIxs.length > 0) {
-				marketOrderTx.add(...bracketOrderIxs);
-			}
-
 			// Apply the latest blockhash to the txs so that we can sign before sending them
 			const currentBlockHash = (
 				await this.connection.getLatestBlockhash('finalized')
@@ -3093,7 +3080,7 @@ export class DriftClient {
 	}
 
 	public async getPlaceOrdersIx(
-		params: OrderParams[],
+		params: OptionalOrderParams[],
 		subAccountId?: number
 	): Promise<TransactionInstruction> {
 		const user = await this.getUserAccountPublicKey(subAccountId);
@@ -3118,7 +3105,9 @@ export class DriftClient {
 			useMarketLastSlotCache: true,
 		});
 
-		return await this.program.instruction.placeOrders(params, {
+		const formattedParams = params.map((item) => getOrderParams(item));
+
+		return await this.program.instruction.placeOrders(formattedParams, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user,
@@ -3868,7 +3857,6 @@ export class DriftClient {
 				slippageBps,
 				swapMode,
 				onlyDirectRoutes,
-				excludeDexes: ['Raydium CLMM'], // temp exclude to workaround bug with raydium clmm
 			});
 
 			quote = fetchedQuote;
@@ -4335,6 +4323,69 @@ export class DriftClient {
 		return txSig;
 	}
 
+	public async placeAndTakePerpWithAdditionalOrders(
+		orderParams: OptionalOrderParams,
+		makerInfo?: MakerInfo | MakerInfo[],
+		referrerInfo?: ReferrerInfo,
+		bracketOrdersParams = new Array<OptionalOrderParams>(),
+		txParams?: TxParams,
+		subAccountId?: number,
+		cancelExistingOrders?: boolean
+	): Promise<{
+		txSig: TransactionSignature;
+		signedCancelExistingOrdersTx?: Transaction;
+	}> {
+		let signedCancelExistingOrdersTx: Transaction;
+
+		if (cancelExistingOrders && isVariant(orderParams.marketType, 'perp')) {
+			const cancelOrdersIx = await this.getCancelOrdersIx(
+				orderParams.marketType,
+				orderParams.marketIndex,
+				null,
+				subAccountId
+			);
+
+			const cancelExistingOrdersTx = await this.buildTransaction(
+				[cancelOrdersIx],
+				txParams,
+				this.txVersion
+			);
+
+			// @ts-ignore
+			signedCancelExistingOrdersTx = await this.provider.wallet.signTransaction(
+				cancelExistingOrdersTx
+			);
+		}
+
+		const ixs = [];
+
+		const placeAndTakeIx = await this.getPlaceAndTakePerpOrderIx(
+			orderParams,
+			makerInfo,
+			referrerInfo,
+			subAccountId
+		);
+
+		ixs.push(placeAndTakeIx);
+
+		if (bracketOrdersParams.length > 0) {
+			const bracketOrdersIx = await this.getPlaceOrdersIx(
+				bracketOrdersParams,
+				subAccountId
+			);
+			ixs.push(bracketOrdersIx);
+		}
+
+		const { txSig, slot } = await this.sendTransaction(
+			await this.buildTransaction(ixs, txParams),
+			[],
+			this.opts
+		);
+		this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
+
+		return { txSig, signedCancelExistingOrdersTx };
+	}
+
 	public async getPlaceAndTakePerpOrderIx(
 		orderParams: OptionalOrderParams,
 		makerInfo?: MakerInfo | MakerInfo[],

package/src/jupiter/jupiterClient.ts

@@ -210,6 +210,12 @@ export interface QuoteResponse {
 	 * @memberof QuoteResponse
 	 */
 	timeTaken?: number;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof QuoteResponse
+	 */
+	error?: string;
 }
 
 export class JupiterClient {
@@ -279,7 +285,7 @@ export class JupiterClient {
 		slippageBps = 50,
 		swapMode = 'ExactIn',
 		onlyDirectRoutes = false,
-		excludeDexes = [],
+		excludeDexes,
 	}: {
 		inputMint: PublicKey;
 		outputMint: PublicKey;
@@ -298,7 +304,7 @@ export class JupiterClient {
 			swapMode,
 			onlyDirectRoutes: onlyDirectRoutes.toString(),
 			maxAccounts: maxAccounts.toString(),
-			excludeDexes: excludeDexes.join(','),
+			...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
 		}).toString();
 		const quote = await (await fetch(`${this.url}/v6/quote?${params}`)).json();
 		return quote;

package/src/math/funding.ts

@@ -11,6 +11,7 @@ import { PerpMarketAccount, isVariant } from '../types';
 import { OraclePriceData } from '../oracles/types';
 import { calculateBidAskPrice } from './amm';
 import { calculateLiveOracleTwap } from './oracles';
+import { clampBN } from './utils';
 
 function calculateLiveMarkTwap(
 	market: PerpMarketAccount,
@@ -160,8 +161,15 @@ export async function calculateAllEstimatedFundingRate(
 	const twapSpreadWithOffset = twapSpread.add(
 		oracleTwap.abs().div(FUNDING_RATE_OFFSET_DENOMINATOR)
 	);
+	const maxSpread = getMaxPriceDivergenceForFundingRate(market, oracleTwap);
 
-	const twapSpreadPct = twapSpreadWithOffset
+	const clampedSpreadWithOffset = clampBN(
+		twapSpreadWithOffset,
+		maxSpread.mul(new BN(-1)),
+		maxSpread
+	);
+
+	const twapSpreadPct = clampedSpreadWithOffset
 		.mul(PRICE_PRECISION)
 		.mul(new BN(100))
 		.div(oracleTwap);
@@ -234,6 +242,25 @@ export async function calculateAllEstimatedFundingRate(
 	return [markTwap, oracleTwap, lowerboundEst, cappedAltEst, interpEst];
 }
 
+function getMaxPriceDivergenceForFundingRate(
+	market: PerpMarketAccount,
+	oracleTwap: BN
+) {
+	if (isVariant(market.contractTier, 'a')) {
+		return oracleTwap.divn(33);
+	} else if (isVariant(market.contractTier, 'b')) {
+		return oracleTwap.divn(33);
+	} else if (isVariant(market.contractTier, 'c')) {
+		return oracleTwap.divn(20);
+	} else if (isVariant(market.contractTier, 'speculative')) {
+		return oracleTwap.divn(10);
+	} else if (isVariant(market.contractTier, 'isolated')) {
+		return oracleTwap.divn(10);
+	} else {
+		return oracleTwap.divn(10);
+	}
+}
+
 /**
  *
  * @param market

package/src/math/oracles.ts

@@ -47,8 +47,8 @@ export function isOracleValid(
 		.div(oraclePriceData.price)
 		.gt(oracleGuardRails.validity.confidenceIntervalMaxSize);
 
-	const oracleIsStale = oraclePriceData.slot
-		.sub(new BN(slot))
+	const oracleIsStale = new BN(slot)
+		.sub(oraclePriceData.slot)
 		.gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
 
 	return !(

package/src/math/superStake.ts

@@ -439,7 +439,9 @@ export async function calculateSolEarned({
 	const now = Date.now() / 1000;
 	const timestamps: number[] = [
 		now,
-		...depositRecords.map((r) => r.ts.toNumber()),
+		...depositRecords
+			.filter((r) => r.marketIndex === marketIndex)
+			.map((r) => r.ts.toNumber()),
 	];
 
 	let lstRatios = new Map<number, number>();

package/src/priorityFee/averageOverSlotsStrategy.ts

@@ -1,30 +1,15 @@
 import { PriorityFeeStrategy } from './types';
 
 export class AverageOverSlotsStrategy implements PriorityFeeStrategy {
-	private lookbackSlots: number;
-
-	/**
-	 * @param lookbackSlots The number of slots to look back from the max slot in the sample
-	 */
-	constructor(lookbackSlots = 10) {
-		this.lookbackSlots = lookbackSlots;
-	}
-
 	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
 		if (samples.length === 0) {
 			return 0;
 		}
-		const stopSlot = samples[0].slot - this.lookbackSlots;
 		let runningSumFees = 0;
-		let countFees = 0;
 
 		for (let i = 0; i < samples.length; i++) {
-			if (samples[i].slot <= stopSlot) {
-				return runningSumFees / countFees;
-			}
 			runningSumFees += samples[i].prioritizationFee;
-			countFees++;
 		}
-		return runningSumFees / countFees;
+		return runningSumFees / samples.length;
 	}
 }

package/src/priorityFee/maxOverSlotsStrategy.ts

@@ -1,30 +1,15 @@
 import { PriorityFeeStrategy } from './types';
 
 export class MaxOverSlotsStrategy implements PriorityFeeStrategy {
-	private lookbackSlots: number;
-
-	/**
-	 * @param lookbackSlots The number of slots to look back from the max slot in the sample
-	 */
-	constructor(lookbackSlots = 10) {
-		this.lookbackSlots = lookbackSlots;
-	}
-
 	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
 		if (samples.length === 0) {
 			return 0;
 		}
 		// Assuming samples are sorted in descending order of slot.
-		const stopSlot = samples[0].slot - this.lookbackSlots;
 		let currMaxFee = samples[0].prioritizationFee;
 
 		for (let i = 0; i < samples.length; i++) {
-			if (samples[i].slot <= stopSlot) {
-				return currMaxFee;
-			}
-			if (samples[i].prioritizationFee > currMaxFee) {
-				currMaxFee = samples[i].prioritizationFee;
-			}
+			currMaxFee = Math.max(samples[i].prioritizationFee, currMaxFee);
 		}
 		return currMaxFee;
 	}

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -10,16 +10,20 @@ export class PriorityFeeSubscriber {
 	customStrategy?: PriorityFeeStrategy;
 	averageStrategy = new AverageOverSlotsStrategy();
 	maxStrategy = new MaxOverSlotsStrategy();
+	lookbackDistance: number;
 
 	intervalId?: ReturnType<typeof setTimeout>;
 
 	latestPriorityFee = 0;
-	lastStrategyResult = 0;
 	lastCustomStrategyResult = 0;
 	lastAvgStrategyResult = 0;
 	lastMaxStrategyResult = 0;
 	lastSlotSeen = 0;
 
+	/**
+	 * @param props
+	 * customStrategy : strategy to return the priority fee to use based on recent samples. defaults to AVERAGE.
+	 */
 	public constructor({
 		connection,
 		frequencyMs,
@@ -36,28 +40,12 @@ export class PriorityFeeSubscriber {
 		this.connection = connection;
 		this.frequencyMs = frequencyMs;
 		this.addresses = addresses;
-		if (slotsToCheck) {
-			this.averageStrategy = new AverageOverSlotsStrategy(slotsToCheck);
-			this.maxStrategy = new MaxOverSlotsStrategy(slotsToCheck);
-		}
-		if (customStrategy) {
+		if (!customStrategy) {
+			this.customStrategy = new AverageOverSlotsStrategy();
+		} else {
 			this.customStrategy = customStrategy;
 		}
-	}
-
-	public get avgPriorityFee(): number {
-		return Math.floor(this.lastAvgStrategyResult);
-	}
-
-	public get maxPriorityFee(): number {
-		return Math.floor(this.lastMaxStrategyResult);
-	}
-
-	public get customPriorityFee(): number {
-		if (!this.customStrategy) {
-			console.error('Custom strategy not set');
-		}
-		return Math.floor(this.lastCustomStrategyResult);
+		this.lookbackDistance = slotsToCheck;
 	}
 
 	public async subscribe(): Promise<void> {
@@ -75,21 +63,29 @@ export class PriorityFeeSubscriber {
 			[this.addresses]
 		);
 
-		// getRecentPrioritizationFees returns results unsorted
 		const results: { slot: number; prioritizationFee: number }[] =
 			rpcJSONResponse?.result;
+
 		if (!results.length) return;
-		const descResults = results.sort((a, b) => b.slot - a.slot);
 
+		// # Sort and filter results based on the slot lookback setting
+		const descResults = results.sort((a, b) => b.slot - a.slot);
 		const mostRecentResult = descResults[0];
+		const cutoffSlot = mostRecentResult.slot - this.lookbackDistance;
+
+		const resultsToUse = descResults.filter(
+			(result) => result.slot >= cutoffSlot
+		);
+
+		// # Handle results
 		this.latestPriorityFee = mostRecentResult.prioritizationFee;
 		this.lastSlotSeen = mostRecentResult.slot;
 
-		this.lastAvgStrategyResult = this.averageStrategy.calculate(descResults);
-		this.lastMaxStrategyResult = this.maxStrategy.calculate(descResults);
+		this.lastAvgStrategyResult = this.averageStrategy.calculate(resultsToUse);
+		this.lastMaxStrategyResult = this.maxStrategy.calculate(resultsToUse);
 		if (this.customStrategy) {
 			this.lastCustomStrategyResult =
-				this.customStrategy.calculate(descResults);
+				this.customStrategy.calculate(resultsToUse);
 		}
 	}
 

package/src/userMap/userMap.ts

@@ -337,6 +337,9 @@ export class UserMap implements UserMapInterface {
 					const userAccount = this.decode('User', buffer);
 					await this.addPubkey(new PublicKey(key), userAccount);
 					this.userMap.get(key).accountSubscriber.updateData(userAccount, slot);
+				} else {
+					const userAccount = this.decode('User', buffer);
+					this.userMap.get(key).accountSubscriber.updateData(userAccount, slot);
 				}
 				// give event loop a chance to breathe
 				await new Promise((resolve) => setTimeout(resolve, 0));

package/tests/amm/test.ts

@@ -28,6 +28,9 @@ import {
 	squareRootBN,
 	calculateReferencePriceOffset,
 	calculateInventoryLiquidityRatio,
+	ContractTier,
+	isOracleValid,
+	OracleGuardRails,
 } from '../../src';
 import { mockPerpMarkets } from '../dlob/helpers';
 
@@ -875,11 +878,12 @@ describe('AMM Tests', () => {
 		const mockMarket1 = myMockPerpMarkets[0];
 		const mockAmm = mockMarket1.amm;
 		const now = new BN(new Date().getTime() / 1000); //todo
+		const slot = 999999999;
 
 		const oraclePriceData = {
 			price: new BN(13.553 * PRICE_PRECISION.toNumber()),
-			slot: new BN(68 + 1),
-			confidence: new BN(1),
+			slot: new BN(slot),
+			confidence: new BN(1000),
 			hasSufficientNumberOfDataPoints: true,
 		};
 		mockAmm.oracleStd = new BN(0.18 * PRICE_PRECISION.toNumber());
@@ -901,6 +905,127 @@ describe('AMM Tests', () => {
 		const liveOracleStd = calculateLiveOracleStd(mockAmm, oraclePriceData, now);
 		console.log('liveOracleStd:', liveOracleStd.toNumber());
 		assert(liveOracleStd.eq(new BN(192962)));
+
+		const oracleGuardRails: OracleGuardRails = {
+			priceDivergence: {
+				markOraclePercentDivergence: PERCENTAGE_PRECISION.divn(10),
+				oracleTwap5MinPercentDivergence: PERCENTAGE_PRECISION.divn(10),
+			},
+			validity: {
+				slotsBeforeStaleForAmm: new BN(10),
+				slotsBeforeStaleForMargin: new BN(60),
+				confidenceIntervalMaxSize: new BN(20000),
+				tooVolatileRatio: new BN(5),
+			},
+		};
+
+		// good oracle
+		assert(isOracleValid(mockAmm, oraclePriceData, oracleGuardRails, slot + 5));
+
+		// conf too high
+		assert(
+			!isOracleValid(
+				mockAmm,
+				{
+					price: new BN(13.553 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot),
+					confidence: new BN(13.553 * PRICE_PRECISION.toNumber() * 0.021),
+					hasSufficientNumberOfDataPoints: true,
+				},
+				oracleGuardRails,
+				slot
+			)
+		);
+
+		// not hasSufficientNumberOfDataPoints
+		assert(
+			!isOracleValid(
+				mockAmm,
+				{
+					price: new BN(13.553 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot),
+					confidence: new BN(1),
+					hasSufficientNumberOfDataPoints: false,
+				},
+				oracleGuardRails,
+				slot
+			)
+		);
+
+		// negative oracle price
+		assert(
+			!isOracleValid(
+				mockAmm,
+				{
+					price: new BN(-1 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot),
+					confidence: new BN(1),
+					hasSufficientNumberOfDataPoints: true,
+				},
+				oracleGuardRails,
+				slot
+			)
+		);
+
+		// too delayed for amm
+		assert(
+			!isOracleValid(
+				mockAmm,
+				{
+					price: new BN(13.553 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot),
+					confidence: new BN(1),
+					hasSufficientNumberOfDataPoints: true,
+				},
+				oracleGuardRails,
+				slot + 100
+			)
+		);
+
+		// im passing stale slot (should not call oracle invalid)
+		assert(
+			isOracleValid(
+				mockAmm,
+				{
+					price: new BN(13.553 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot + 100),
+					confidence: new BN(1),
+					hasSufficientNumberOfDataPoints: true,
+				},
+				oracleGuardRails,
+				slot
+			)
+		);
+
+		// too volatile (more than 5x higher)
+		assert(
+			!isOracleValid(
+				mockAmm,
+				{
+					price: new BN(113.553 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot + 5),
+					confidence: new BN(1),
+					hasSufficientNumberOfDataPoints: true,
+				},
+				oracleGuardRails,
+				slot
+			)
+		);
+
+		// too volatile (more than 1/5 lower)
+		assert(
+			!isOracleValid(
+				mockAmm,
+				{
+					price: new BN(0.553 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot + 5),
+					confidence: new BN(1),
+					hasSufficientNumberOfDataPoints: true,
+				},
+				oracleGuardRails,
+				slot
+			)
+		);
 	});
 
 	it('predicted funding rate mock1', async () => {
@@ -1065,6 +1190,154 @@ describe('AMM Tests', () => {
 		assert(est2.eq(new BN('-719')));
 	});
 
+	it('predicted funding rate mock clamp', async () => {
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+		const mockMarket1 = myMockPerpMarkets[0];
+
+		// make it like OP
+		const now = new BN(1688881915);
+
+		mockMarket1.amm.fundingPeriod = new BN(3600);
+		mockMarket1.amm.lastFundingRateTs = new BN(1688864415);
+
+		const currentMarkPrice = new BN(1.2242 * PRICE_PRECISION.toNumber()); // trading at a premium
+		const oraclePriceData: OraclePriceData = {
+			price: new BN(1.924 * PRICE_PRECISION.toNumber()),
+			slot: new BN(0),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+		mockMarket1.amm.historicalOracleData.lastOraclePrice = new BN(
+			1.9535 * PRICE_PRECISION.toNumber()
+		);
+
+		// mockMarket1.amm.pegMultiplier = new BN(1.897573 * 1e3);
+
+		mockMarket1.amm.lastMarkPriceTwap = new BN(
+			1.218363 * PRICE_PRECISION.toNumber()
+		);
+		mockMarket1.amm.lastBidPriceTwap = new BN(
+			1.218363 * PRICE_PRECISION.toNumber()
+		);
+		mockMarket1.amm.lastAskPriceTwap = new BN(
+			1.218364 * PRICE_PRECISION.toNumber()
+		);
+		mockMarket1.amm.lastMarkPriceTwapTs = new BN(1688878815);
+
+		mockMarket1.amm.historicalOracleData.lastOraclePriceTwap = new BN(
+			1.820964 * PRICE_PRECISION.toNumber()
+		);
+		mockMarket1.amm.historicalOracleData.lastOraclePriceTwapTs = new BN(
+			1688879991
+		);
+		mockMarket1.contractTier = ContractTier.A;
+
+		const [
+			_markTwapLive,
+			_oracleTwapLive,
+			_lowerboundEst,
+			_cappedAltEst,
+			_interpEst,
+		] = await calculateAllEstimatedFundingRate(
+			mockMarket1,
+			oraclePriceData,
+			currentMarkPrice,
+			now
+		);
+
+		// console.log(_markTwapLive.toString());
+		// console.log(_oracleTwapLive.toString());
+		// console.log(_lowerboundEst.toString());
+		// console.log(_cappedAltEst.toString());
+		// console.log(_interpEst.toString());
+		// console.log('-----');
+
+		let [markTwapLive, oracleTwapLive, est1, est2] =
+			await calculateLongShortFundingRateAndLiveTwaps(
+				mockMarket1,
+				oraclePriceData,
+				currentMarkPrice,
+				now
+			);
+
+		console.log(
+			'markTwapLive:',
+			mockMarket1.amm.lastMarkPriceTwap.toString(),
+			'->',
+			markTwapLive.toString()
+		);
+		console.log(
+			'oracTwapLive:',
+			mockMarket1.amm.historicalOracleData.lastOraclePriceTwap.toString(),
+			'->',
+			oracleTwapLive.toString()
+		);
+		console.log('pred funding:', est1.toString(), est2.toString());
+
+		assert(markTwapLive.eq(new BN('1680634')));
+		assert(oracleTwapLive.eq(new BN('1876031')));
+		assert(est1.eq(est2));
+		assert(est2.eq(new BN('-126261')));
+
+		mockMarket1.contractTier = ContractTier.C;
+
+		[markTwapLive, oracleTwapLive, est1, est2] =
+			await calculateLongShortFundingRateAndLiveTwaps(
+				mockMarket1,
+				oraclePriceData,
+				currentMarkPrice,
+				now
+			);
+
+		console.log(
+			'markTwapLive:',
+			mockMarket1.amm.lastMarkPriceTwap.toString(),
+			'->',
+			markTwapLive.toString()
+		);
+		console.log(
+			'oracTwapLive:',
+			mockMarket1.amm.historicalOracleData.lastOraclePriceTwap.toString(),
+			'->',
+			oracleTwapLive.toString()
+		);
+		console.log('pred funding:', est1.toString(), est2.toString());
+
+		assert(markTwapLive.eq(new BN('1680634')));
+		assert(oracleTwapLive.eq(new BN('1876031')));
+		assert(est1.eq(est2));
+		assert(est2.eq(new BN('-208332')));
+
+		mockMarket1.contractTier = ContractTier.SPECULATIVE;
+
+		[markTwapLive, oracleTwapLive, est1, est2] =
+			await calculateLongShortFundingRateAndLiveTwaps(
+				mockMarket1,
+				oraclePriceData,
+				currentMarkPrice,
+				now
+			);
+
+		console.log(
+			'markTwapLive:',
+			mockMarket1.amm.lastMarkPriceTwap.toString(),
+			'->',
+			markTwapLive.toString()
+		);
+		console.log(
+			'oracTwapLive:',
+			mockMarket1.amm.historicalOracleData.lastOraclePriceTwap.toString(),
+			'->',
+			oracleTwapLive.toString()
+		);
+		console.log('pred funding:', est1.toString(), est2.toString());
+
+		assert(markTwapLive.eq(new BN('1680634')));
+		assert(oracleTwapLive.eq(new BN('1876031')));
+		assert(est1.eq(est2));
+		assert(est2.eq(new BN('-416666')));
+	});
+
 	it('orderbook L2 gen (no topOfBookQuoteAmounts, 10 numOrders, low liquidity)', async () => {
 		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
 

package/tests/dlob/test.ts

@@ -76,7 +76,7 @@ function insertOrderToDLOB(
 			auctionEndPrice,
 			maxTs,
 		},
-		userAccount,
+		userAccount.toString(),
 		slot.toNumber()
 	);
 }
@@ -127,7 +127,7 @@ function insertTriggerOrderToDLOB(
 			auctionEndPrice,
 			maxTs,
 		},
-		userAccount,
+		userAccount.toString(),
 		slot.toNumber()
 	);
 }

package/tests/tx/priorityFeeStrategy.ts

@@ -66,7 +66,7 @@ describe('PriorityFeeStrategy', () => {
 	});
 
 	it('MaxOverSlotsStrategy should calculate the max prioritization fee over slots', () => {
-		const maxOverSlotsStrategy = new MaxOverSlotsStrategy(5);
+		const maxOverSlotsStrategy = new MaxOverSlotsStrategy();
 		const samples = [
 			{ slot: 6, prioritizationFee: 432 },
 			{ slot: 3, prioritizationFee: 543 },
@@ -80,7 +80,7 @@ describe('PriorityFeeStrategy', () => {
 	});
 
 	it('AverageOverSlotsStrategy should calculate the average prioritization fee over slots', () => {
-		const averageOverSlotsStrategy = new AverageOverSlotsStrategy(5);
+		const averageOverSlotsStrategy = new AverageOverSlotsStrategy();
 		const samples = [
 			{ slot: 6, prioritizationFee: 432 },
 			{ slot: 3, prioritizationFee: 543 },