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

package/src/math/amm.ts

@@ -12,6 +12,7 @@ import {
 	PRICE_DIV_PEG,
 	PERCENTAGE_PRECISION,
 	DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT,
+	FUNDING_RATE_BUFFER_PRECISION,
 	TWO,
 } from '../constants/numericConstants';
 import {
@@ -22,7 +23,7 @@ import {
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
-import { squareRootBN, clampBN, standardizeBaseAssetAmount } from '..';
+import { squareRootBN, sigNum, clampBN, standardizeBaseAssetAmount } from '..';
 
 import { OraclePriceData } from '../oracles/types';
 import {
@@ -352,21 +353,12 @@ export function calculateMarketOpenBidAsk(
 	return [openBids, openAsks];
 }
 
-export function calculateInventoryScale(
+export function calculateInventoryLiquidityRatio(
 	baseAssetAmountWithAmm: BN,
 	baseAssetReserve: BN,
 	minBaseAssetReserve: BN,
-	maxBaseAssetReserve: BN,
-	directionalSpread: number,
-	maxSpread: number
-): number {
-	if (baseAssetAmountWithAmm.eq(ZERO)) {
-		return 1;
-	}
-
-	const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = BID_ASK_SPREAD_PRECISION.mul(
-		new BN(10)
-	);
+	maxBaseAssetReserve: BN
+): BN {
 	// inventory skew
 	const [openBids, openAsks] = calculateMarketOpenBidAsk(
 		baseAssetReserve,
@@ -383,6 +375,31 @@ export function calculateInventoryScale(
 			.abs(),
 		PERCENTAGE_PRECISION
 	);
+	return inventoryScaleBN;
+}
+
+export function calculateInventoryScale(
+	baseAssetAmountWithAmm: BN,
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN,
+	directionalSpread: number,
+	maxSpread: number
+): number {
+	if (baseAssetAmountWithAmm.eq(ZERO)) {
+		return 1;
+	}
+
+	const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = BID_ASK_SPREAD_PRECISION.mul(
+		new BN(10)
+	);
+
+	const inventoryScaleBN = calculateInventoryLiquidityRatio(
+		baseAssetAmountWithAmm,
+		baseAssetReserve,
+		minBaseAssetReserve,
+		maxBaseAssetReserve
+	);
 
 	const inventoryScaleMaxBN = BN.max(
 		MAX_BID_ASK_INVENTORY_SKEW_FACTOR,
@@ -402,6 +419,76 @@ export function calculateInventoryScale(
 	return inventoryScaleCapped;
 }
 
+export function calculateReferencePriceOffset(
+	reservePrice: BN,
+	last24hAvgFundingRate: BN,
+	liquidityFraction: BN,
+	oracleTwapFast: BN,
+	markTwapFast: BN,
+	oracleTwapSlow: BN,
+	markTwapSlow: BN,
+	maxOffsetPct: number
+): BN {
+	if (last24hAvgFundingRate.eq(ZERO)) {
+		return ZERO;
+	}
+
+	const maxOffsetInPrice = new BN(maxOffsetPct)
+		.mul(reservePrice)
+		.div(PERCENTAGE_PRECISION);
+
+	// Calculate quote denominated market premium
+	const markPremiumMinute = clampBN(
+		markTwapFast.sub(oracleTwapFast),
+		maxOffsetInPrice.mul(new BN(-1)),
+		maxOffsetInPrice
+	);
+
+	const markPremiumHour = clampBN(
+		markTwapSlow.sub(oracleTwapSlow),
+		maxOffsetInPrice.mul(new BN(-1)),
+		maxOffsetInPrice
+	);
+
+	// Convert last24hAvgFundingRate to quote denominated premium
+	const markPremiumDay = clampBN(
+		last24hAvgFundingRate.div(FUNDING_RATE_BUFFER_PRECISION).mul(new BN(24)),
+		maxOffsetInPrice.mul(new BN(-1)),
+		maxOffsetInPrice
+	);
+
+	// Take average clamped premium as the price-based offset
+	const markPremiumAvg = markPremiumMinute
+		.add(markPremiumHour)
+		.add(markPremiumDay)
+		.div(new BN(3));
+
+	const markPremiumAvgPct = markPremiumAvg
+		.mul(PRICE_PRECISION)
+		.div(reservePrice);
+
+	const inventoryPct = clampBN(
+		liquidityFraction.mul(new BN(maxOffsetPct)).div(PERCENTAGE_PRECISION),
+		maxOffsetInPrice.mul(new BN(-1)),
+		maxOffsetInPrice
+	);
+
+	// Only apply when inventory is consistent with recent and 24h market premium
+	let offsetPct = markPremiumAvgPct.add(inventoryPct);
+
+	if (!sigNum(inventoryPct).eq(sigNum(markPremiumAvgPct))) {
+		offsetPct = ZERO;
+	}
+
+	const clampedOffsetPct = clampBN(
+		offsetPct,
+		new BN(-maxOffsetPct),
+		new BN(maxOffsetPct)
+	);
+
+	return clampedOffsetPct;
+}
+
 export function calculateEffectiveLeverage(
 	baseSpread: number,
 	quoteAssetReserve: BN,
@@ -532,6 +619,8 @@ export function calculateSpreadBN(
 		halfRevenueRetreatAmount: 0,
 		longSpreadwRevRetreat: 0,
 		shortSpreadwRevRetreat: 0,
+		longSpreadwOffsetShrink: 0,
+		shortSpreadwOffsetShrink: 0,
 		totalSpread: 0,
 		longSpread: 0,
 		shortSpread: 0,
@@ -678,7 +767,6 @@ export function calculateSpreadBN(
 	spreadTerms.totalSpread = totalSpread;
 	spreadTerms.longSpread = longSpread;
 	spreadTerms.shortSpread = shortSpread;
-
 	if (returnTerms) {
 		return spreadTerms;
 	}
@@ -688,17 +776,20 @@ export function calculateSpreadBN(
 export function calculateSpread(
 	amm: AMM,
 	oraclePriceData: OraclePriceData,
-	now?: BN
+	now?: BN,
+	reservePrice?: BN
 ): [number, number] {
 	if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
 		return [amm.baseSpread / 2, amm.baseSpread / 2];
 	}
 
-	const reservePrice = calculatePrice(
-		amm.baseAssetReserve,
-		amm.quoteAssetReserve,
-		amm.pegMultiplier
-	);
+	if (!reservePrice) {
+		reservePrice = calculatePrice(
+			amm.baseAssetReserve,
+			amm.quoteAssetReserve,
+			amm.pegMultiplier
+		);
+	}
 
 	const targetPrice = oraclePriceData?.price || reservePrice;
 	const confInterval = oraclePriceData.confidence || ZERO;
@@ -760,13 +851,22 @@ export function calculateSpreadReserves(
 				quoteAssetReserve: amm.quoteAssetReserve,
 			};
 		}
-		const spreadFraction = BN.max(new BN(spread / 2), ONE);
+		let spreadFraction = new BN(spread / 2);
+
+		// make non-zero
+		if (spreadFraction.eq(ZERO)) {
+			spreadFraction = spread >= 0 ? new BN(1) : new BN(-1);
+		}
+
 		const quoteAssetReserveDelta = amm.quoteAssetReserve.div(
 			BID_ASK_SPREAD_PRECISION.div(spreadFraction)
 		);
 
 		let quoteAssetReserve;
-		if (isVariant(direction, 'long')) {
+		if (
+			(spread >= 0 && isVariant(direction, 'long')) ||
+			(spread <= 0 && isVariant(direction, 'short'))
+		) {
 			quoteAssetReserve = amm.quoteAssetReserve.add(quoteAssetReserveDelta);
 		} else {
 			quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAssetReserveDelta);
@@ -779,14 +879,48 @@ export function calculateSpreadReserves(
 		};
 	}
 
-	const [longSpread, shortSpread] = calculateSpread(amm, oraclePriceData, now);
+	const reservePrice = calculatePrice(
+		amm.baseAssetReserve,
+		amm.quoteAssetReserve,
+		amm.pegMultiplier
+	);
+
+	// always allow 10 bps of price offset, up to a fifth of the market's max_spread
+	const maxOffset = Math.max(
+		amm.maxSpread / 5,
+		PERCENTAGE_PRECISION.toNumber() / 1000
+	);
+	const liquidityFraction = calculateInventoryLiquidityRatio(
+		amm.baseAssetAmountWithAmm,
+		amm.baseAssetReserve,
+		amm.minBaseAssetReserve,
+		amm.maxBaseAssetReserve
+	);
+	const referencePriceOffset = calculateReferencePriceOffset(
+		reservePrice,
+		amm.last24HAvgFundingRate,
+		liquidityFraction,
+		amm.historicalOracleData.lastOraclePriceTwap5Min,
+		amm.lastMarkPriceTwap5Min,
+		amm.historicalOracleData.lastOraclePriceTwap,
+		amm.lastMarkPriceTwap,
+		maxOffset
+	);
+
+	const [longSpread, shortSpread] = calculateSpread(
+		amm,
+		oraclePriceData,
+		now,
+		reservePrice
+	);
+
 	const askReserves = calculateSpreadReserve(
-		longSpread,
+		longSpread + referencePriceOffset.toNumber(),
 		PositionDirection.LONG,
 		amm
 	);
 	const bidReserves = calculateSpreadReserve(
-		shortSpread,
+		shortSpread + referencePriceOffset.toNumber(),
 		PositionDirection.SHORT,
 		amm
 	);

package/src/math/state.ts

@@ -22,5 +22,8 @@ export function calculateInitUserFee(stateAccount: StateAccount): BN {
 }
 
 export function getMaxNumberOfSubAccounts(stateAccount: StateAccount): BN {
+	if (stateAccount.maxNumberOfSubAccounts <= 5) {
+		return new BN(stateAccount.maxNumberOfSubAccounts);
+	}
 	return new BN(stateAccount.maxNumberOfSubAccounts).muln(100);
 }

package/src/orderSubscriber/OrderSubscriber.ts

@@ -39,6 +39,7 @@ export class OrderSubscriber {
 				commitment: this.commitment,
 				skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
 				resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
+				resyncIntervalMs: config.subscriptionConfig.resyncIntervalMs,
 			});
 		}
 		if (config.fastDecode ?? true) {

package/src/orderSubscriber/WebsocketSubscription.ts

@@ -9,24 +9,29 @@ export class WebsocketSubscription {
 	private commitment: Commitment;
 	private skipInitialLoad: boolean;
 	private resubTimeoutMs?: number;
+	private resyncIntervalMs?: number;
 
 	private subscriber?: WebSocketProgramAccountSubscriber<UserAccount>;
+	private resyncTimeoutId?: NodeJS.Timeout;
 
 	constructor({
 		orderSubscriber,
 		commitment,
 		skipInitialLoad = false,
 		resubTimeoutMs,
+		resyncIntervalMs,
 	}: {
 		orderSubscriber: OrderSubscriber;
 		commitment: Commitment;
 		skipInitialLoad?: boolean;
 		resubTimeoutMs?: number;
+		resyncIntervalMs?: number;
 	}) {
 		this.orderSubscriber = orderSubscriber;
 		this.commitment = commitment;
 		this.skipInitialLoad = skipInitialLoad;
 		this.resubTimeoutMs = resubTimeoutMs;
+		this.resyncIntervalMs = resyncIntervalMs;
 	}
 
 	public async subscribe(): Promise<void> {
@@ -61,11 +66,34 @@ export class WebsocketSubscription {
 		if (!this.skipInitialLoad) {
 			await this.orderSubscriber.fetch();
 		}
+
+		if (this.resyncIntervalMs) {
+			const recursiveResync = () => {
+				this.resyncTimeoutId = setTimeout(() => {
+					this.orderSubscriber
+						.fetch()
+						.catch((e) => {
+							console.error('Failed to resync in OrderSubscriber');
+							console.log(e);
+						})
+						.finally(() => {
+							// eslint-disable-next-line @typescript-eslint/no-unused-vars
+							if (!this.resyncTimeoutId) return;
+							recursiveResync();
+						});
+				}, this.resyncIntervalMs);
+			};
+			recursiveResync();
+		}
 	}
 
 	public async unsubscribe(): Promise<void> {
 		if (!this.subscriber) return;
 		await this.subscriber.unsubscribe();
 		this.subscriber = undefined;
+		if (this.resyncTimeoutId !== undefined) {
+			clearTimeout(this.resyncTimeoutId);
+			this.resyncTimeoutId = undefined;
+		}
 	}
 }

package/src/orderSubscriber/types.ts

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

package/src/phoenix/phoenixSubscriber.ts

@@ -6,6 +6,7 @@ import {
 	toNum,
 	getMarketUiLadder,
 	Market,
+	getMarketLadder,
 } from '@ellipsis-labs/phoenix-sdk';
 import { PRICE_PRECISION } from '../constants/numericConstants';
 import { BN } from '@coral-xyz/anchor';
@@ -163,13 +164,18 @@ export class PhoenixSubscriber implements L2OrderBookGenerator {
 	}
 
 	*getL2Levels(side: 'bids' | 'asks'): Generator<L2Level> {
-		const basePrecision = Math.pow(
-			10,
-			this.market.data.header.baseParams.decimals
+		const tickSize = this.market.data.header
+			.tickSizeInQuoteAtomsPerBaseUnit as BN;
+		const baseLotsToRawBaseUnits = this.market.baseLotsToRawBaseUnits(1);
+
+		const basePrecision = new BN(
+			Math.pow(10, this.market.data.header.baseParams.decimals) *
+				baseLotsToRawBaseUnits
 		);
-		const pricePrecision = PRICE_PRECISION.toNumber();
 
-		const ladder = getMarketUiLadder(
+		const pricePrecision = PRICE_PRECISION.div(tickSize as BN);
+
+		const ladder = getMarketLadder(
 			this.market,
 			this.lastSlot,
 			this.lastUnixTimestamp,
@@ -177,10 +183,10 @@ export class PhoenixSubscriber implements L2OrderBookGenerator {
 		);
 
 		for (let i = 0; i < ladder[side].length; i++) {
-			const { price, quantity } = ladder[side][i];
-			const size = new BN(Math.floor(quantity * basePrecision));
+			const { priceInTicks, sizeInBaseLots } = ladder[side][i];
+			const size = sizeInBaseLots.mul(basePrecision);
 			yield {
-				price: new BN(Math.floor(price * pricePrecision)),
+				price: priceInTicks.mul(new BN(pricePrecision)),
 				size,
 				sources: {
 					phoenix: size,

package/src/priorityFee/averageOverSlotsStrategy.ts

@@ -0,0 +1,30 @@
+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;
+	}
+}

package/src/priorityFee/averageStrategy.ts

@@ -0,0 +1,11 @@
+import { PriorityFeeStrategy } from './types';
+
+export class AverageStrategy implements PriorityFeeStrategy {
+	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
+		return (
+			samples.reduce((a, b) => {
+				return a + b.prioritizationFee;
+			}, 0) / samples.length
+		);
+	}
+}

package/src/priorityFee/ewmaStrategy.ts

@@ -0,0 +1,40 @@
+import { PriorityFeeStrategy } from './types';
+
+class EwmaStrategy implements PriorityFeeStrategy {
+	private halfLife: number;
+
+	/**
+	 * @param halfLife The half life of the EWMA in slots. Default is 25 slots, approx 10 seconds.
+	 */
+	constructor(halfLife = 25) {
+		this.halfLife = halfLife;
+	}
+
+	// samples provided in desc slot order
+	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
+		if (samples.length === 0) {
+			return 0;
+		}
+		if (samples.length === 1) {
+			return samples[0].prioritizationFee;
+		}
+
+		let ewma = 0;
+
+		const samplesReversed = samples.slice().reverse();
+		for (let i = 0; i < samplesReversed.length; i++) {
+			if (i === 0) {
+				ewma = samplesReversed[i].prioritizationFee;
+				continue;
+			}
+			const gap = samplesReversed[i].slot - samplesReversed[i - 1].slot;
+			const alpha = 1 - Math.exp((Math.log(0.5) / this.halfLife) * gap);
+
+			ewma = alpha * samplesReversed[i].prioritizationFee + (1 - alpha) * ewma;
+		}
+
+		return ewma;
+	}
+}
+
+export { EwmaStrategy };

package/src/priorityFee/index.ts

@@ -0,0 +1,7 @@
+export * from './averageOverSlotsStrategy';
+export * from './averageStrategy';
+export * from './ewmaStrategy';
+export * from './maxOverSlotsStrategy';
+export * from './maxStrategy';
+export * from './priorityFeeSubscriber';
+export * from './types';

package/src/priorityFee/maxOverSlotsStrategy.ts

@@ -0,0 +1,31 @@
+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;
+			}
+		}
+		return currMaxFee;
+	}
+}

package/src/priorityFee/maxStrategy.ts

@@ -0,0 +1,7 @@
+import { PriorityFeeStrategy } from './types';
+
+export class MaxStrategy implements PriorityFeeStrategy {
+	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
+		return Math.max(...samples.map((result) => result.prioritizationFee));
+	}
+}

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -1,35 +1,63 @@
 import { Connection, PublicKey } from '@solana/web3.js';
+import { PriorityFeeStrategy } from './types';
+import { AverageOverSlotsStrategy } from './averageOverSlotsStrategy';
+import { MaxOverSlotsStrategy } from './maxOverSlotsStrategy';
 
 export class PriorityFeeSubscriber {
 	connection: Connection;
 	frequencyMs: number;
 	addresses: PublicKey[];
-	slotsToCheck: number;
+	customStrategy?: PriorityFeeStrategy;
+	averageStrategy = new AverageOverSlotsStrategy();
+	maxStrategy = new MaxOverSlotsStrategy();
 
 	intervalId?: ReturnType<typeof setTimeout>;
 
 	latestPriorityFee = 0;
-	// avg of last {slotsToCheck} slots
-	avgPriorityFee = 0;
-	// max of last {slotsToCheck} slots
-	maxPriorityFee = 0;
+	lastStrategyResult = 0;
+	lastCustomStrategyResult = 0;
+	lastAvgStrategyResult = 0;
+	lastMaxStrategyResult = 0;
 	lastSlotSeen = 0;
 
 	public constructor({
 		connection,
 		frequencyMs,
 		addresses,
+		customStrategy,
 		slotsToCheck = 10,
 	}: {
 		connection: Connection;
 		frequencyMs: number;
 		addresses: PublicKey[];
+		customStrategy?: PriorityFeeStrategy;
 		slotsToCheck?: number;
 	}) {
 		this.connection = connection;
 		this.frequencyMs = frequencyMs;
 		this.addresses = addresses;
-		this.slotsToCheck = slotsToCheck;
+		if (slotsToCheck) {
+			this.averageStrategy = new AverageOverSlotsStrategy(slotsToCheck);
+			this.maxStrategy = new MaxOverSlotsStrategy(slotsToCheck);
+		}
+		if (customStrategy) {
+			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);
 	}
 
 	public async subscribe(): Promise<void> {
@@ -47,23 +75,22 @@ export class PriorityFeeSubscriber {
 			[this.addresses]
 		);
 
-		const descResults: { slot: number; prioritizationFee: number }[] =
-			rpcJSONResponse?.result
-				?.sort((a, b) => b.slot - a.slot)
-				?.slice(0, this.slotsToCheck) ?? [];
-
-		if (!descResults?.length) return;
+		// 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);
 
 		const mostRecentResult = descResults[0];
 		this.latestPriorityFee = mostRecentResult.prioritizationFee;
 		this.lastSlotSeen = mostRecentResult.slot;
-		this.avgPriorityFee =
-			descResults.reduce((a, b) => {
-				return a + b.prioritizationFee;
-			}, 0) / descResults.length;
-		this.maxPriorityFee = Math.max(
-			...descResults.map((result) => result.prioritizationFee)
-		);
+
+		this.lastAvgStrategyResult = this.averageStrategy.calculate(descResults);
+		this.lastMaxStrategyResult = this.maxStrategy.calculate(descResults);
+		if (this.customStrategy) {
+			this.lastCustomStrategyResult =
+				this.customStrategy.calculate(descResults);
+		}
 	}
 
 	public async unsubscribe(): Promise<void> {

package/src/priorityFee/types.ts

@@ -0,0 +1,5 @@
+export interface PriorityFeeStrategy {
+	// calculate the priority fee for a given set of samples.
+	// expect samples to be sorted in descending order (by slot)
+	calculate(samples: { slot: number; prioritizationFee: number }[]): number;
+}