@drift-labs/sdk 2.54.0-beta.1 → 2.54.0-beta.10

package/src/math/superStake.ts

@@ -333,6 +333,63 @@ export async function fetchJitoSolMetrics() {
 	return data;
 }
 
+export type MSOL_METRICS_ENDPOINT_RESPONSE = {
+	total_active_balance: number;
+	available_reserve_balance: number;
+	emergency_cooling_down: number;
+	tvl_sol: number;
+	msol_directed_stake_sol: number;
+	msol_directed_stake_msol: number;
+	mnde_total_supply: number;
+	mnde_circulating_supply: number;
+	validators_count: number;
+	stake_accounts: number;
+	staking_sol_cap: number;
+	m_sol_price: number;
+	avg_staking_apy: number;
+	msol_price_apy_14d: number;
+	msol_price_apy_30d: number;
+	msol_price_apy_90d: number;
+	msol_price_apy_365d: number;
+	reserve_pda: number;
+	treasury_m_sol_amount: number;
+	m_sol_mint_supply: number;
+	m_sol_supply_state: number;
+	liq_pool_sol: number;
+	liq_pool_m_sol: number;
+	liq_pool_value: number;
+	liq_pool_token_supply: number;
+	liq_pool_token_price: number;
+	liq_pool_target: number;
+	liq_pool_min_fee: number;
+	liq_pool_max_fee: number;
+	liq_pool_current_fee: number;
+	liq_pool_treasury_cut: number;
+	liq_pool_cap: number;
+	total_cooling_down: number;
+	last_stake_delta_epoch: number;
+	circulating_ticket_count: number;
+	circulating_ticket_balance: number;
+	reward_fee_bp: number;
+	lido_staking: number;
+	lido_st_sol_price: number;
+	lido_stsol_price_apy_14d: number;
+	lido_stsol_price_apy_30d: number;
+	lido_stsol_price_apy_90d: number;
+	lido_stsol_price_apy_365d: number;
+	stake_delta: number;
+	bot_balance: number;
+	treasury_farm_claim_mnde_balance: number;
+	last_3_epochs_avg_duration_hs: number;
+	mnde_votes_validators: number;
+};
+
+export const fetchMSolMetrics = async () => {
+	const res = await fetch('https://api2.marinade.finance/metrics_json');
+	const data: MSOL_METRICS_ENDPOINT_RESPONSE = await res.json();
+	return data;
+};
+
 const getJitoSolHistoricalPriceMap = async (timestamps: number[]) => {
 	try {
 		const data = await fetchJitoSolMetrics();
@@ -382,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/tx/baseTxSender.ts

@@ -247,9 +247,11 @@ export abstract class BaseTxSender implements TxSender {
 		commitment: Commitment = 'finalized'
 	): Promise<RpcResponseAndContext<SignatureResult> | undefined> {
 		let totalTime = 0;
-		let backoffTime = 250;
+		let backoffTime = 400; // approx block time
 
 		while (totalTime < this.timeout) {
+			await new Promise((resolve) => setTimeout(resolve, backoffTime));
+
 			const response = await this.connection.getSignatureStatus(signature);
 			const result = response && response.value?.[0];
 
@@ -257,7 +259,6 @@ export abstract class BaseTxSender implements TxSender {
 				return { context: result.context, value: { err: null } };
 			}
 
-			await new Promise((resolve) => setTimeout(resolve, backoffTime));
 			totalTime += backoffTime;
 			backoffTime = Math.min(backoffTime * 2, 5000);
 		}

package/src/tx/retryTxSender.ts

@@ -1,9 +1,5 @@
 import { ConfirmationStrategy, TxSigAndSlot } from './types';
-import {
-	ConfirmOptions,
-	TransactionSignature,
-	Connection,
-} from '@solana/web3.js';
+import { ConfirmOptions, Connection } from '@solana/web3.js';
 import { AnchorProvider } from '@coral-xyz/anchor';
 import { IWallet } from '../types';
 import { BaseTxSender } from './baseTxSender';
@@ -70,14 +66,8 @@ export class RetryTxSender extends BaseTxSender {
 	): Promise<TxSigAndSlot> {
 		const startTime = this.getTimestamp();
 
-		let txid: TransactionSignature;
-		try {
-			txid = await this.connection.sendRawTransaction(rawTransaction, opts);
-			this.sendToAdditionalConnections(rawTransaction, opts);
-		} catch (e) {
-			console.error(e);
-			throw e;
-		}
+		const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+		this.sendToAdditionalConnections(rawTransaction, opts);
 
 		let done = false;
 		const resolveReference: ResolveReference = {
@@ -105,16 +95,8 @@ export class RetryTxSender extends BaseTxSender {
 			}
 		})();
 
-		let slot: number;
-		try {
-			const result = await this.confirmTransaction(txid, opts.commitment);
-			slot = result.context.slot;
-		} catch (e) {
-			console.error(e);
-			throw e;
-		} finally {
-			stopWaiting();
-		}
+		const result = await this.confirmTransaction(txid, opts.commitment);
+		const slot = result.context.slot;
 
 		return { txSig: txid, slot };
 	}

package/src/tx/utils.ts

@@ -1,7 +1,9 @@
+import { Wallet } from '@coral-xyz/anchor';
 import {
 	Transaction,
 	TransactionInstruction,
 	ComputeBudgetProgram,
+	VersionedTransaction,
 } from '@solana/web3.js';
 
 const COMPUTE_UNITS_DEFAULT = 200_000;
@@ -30,3 +32,33 @@ export function wrapInTx(
 
 	return tx.add(instruction);
 }
+
+/* Helper function for signing multiple transactions where some may be undefined and mapping the output */
+export async function getSignedTransactionMap(
+	wallet: Wallet,
+	txsToSign: (Transaction | VersionedTransaction | undefined)[],
+	keys: string[]
+): Promise<{ [key: string]: Transaction | VersionedTransaction | undefined }> {
+	const signedTxMap: {
+		[key: string]: Transaction | VersionedTransaction | undefined;
+	} = {};
+
+	const keysWithTx = [];
+	txsToSign.forEach((tx, index) => {
+		if (tx == undefined) {
+			signedTxMap[keys[index]] = undefined;
+		} else {
+			keysWithTx.push(keys[index]);
+		}
+	});
+
+	const signedTxs = await wallet.signAllTransactions(
+		txsToSign.filter((tx) => tx !== undefined)
+	);
+
+	signedTxs.forEach((signedTx, index) => {
+		signedTxMap[keysWithTx[index]] = signedTx;
+	});
+
+	return signedTxMap;
+}

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 },