@drift-labs/sdk 2.52.0-beta.0 → 2.52.0-beta.10

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 this.lastAvgStrategyResult;
+	}
+
+	public get maxPriorityFee(): number {
+		return this.lastMaxStrategyResult;
+	}
+
+	public get customPriorityFee(): number {
+		if (!this.customStrategy) {
+			console.error('Custom strategy not set');
+		}
+		return 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;
+}

package/src/slot/SlotSubscriber.ts

@@ -3,7 +3,9 @@ import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types/types/src';
 
 // eslint-disable-next-line @typescript-eslint/ban-types
-type SlotSubscriberConfig = {}; // for future customization
+type SlotSubscriberConfig = {
+	resubTimeoutMs?: number;
+}; // for future customization
 
 export interface SlotSubscriberEvents {
 	newSlot: (newSlot: number) => void;
@@ -14,15 +16,22 @@ export class SlotSubscriber {
 	subscriptionId: number;
 	eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
 
+	// Reconnection
+	timeoutId?: NodeJS.Timeout;
+	resubTimeoutMs?: number;
+	isUnsubscribing = false;
+	receivingData = false;
+
 	public constructor(
 		private connection: Connection,
-		_config?: SlotSubscriberConfig
+		config?: SlotSubscriberConfig
 	) {
 		this.eventEmitter = new EventEmitter();
+		this.resubTimeoutMs = config?.resubTimeoutMs;
 	}
 
 	public async subscribe(): Promise<void> {
-		if (this.subscriptionId) {
+		if (this.subscriptionId != null) {
 			return;
 		}
 
@@ -30,19 +39,57 @@ export class SlotSubscriber {
 
 		this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
 			if (!this.currentSlot || this.currentSlot < slotInfo.slot) {
+				if (this.resubTimeoutMs && !this.isUnsubscribing) {
+					this.receivingData = true;
+					clearTimeout(this.timeoutId);
+					this.setTimeout();
+				}
 				this.currentSlot = slotInfo.slot;
 				this.eventEmitter.emit('newSlot', slotInfo.slot);
 			}
 		});
+
+		if (this.resubTimeoutMs) {
+			this.setTimeout();
+		}
+	}
+
+	private setTimeout(): void {
+		this.timeoutId = setTimeout(async () => {
+			if (this.isUnsubscribing) {
+				// If we are in the process of unsubscribing, do not attempt to resubscribe
+				return;
+			}
+
+			if (this.receivingData) {
+				console.log(
+					`No new slot in ${this.resubTimeoutMs}ms, slot subscriber resubscribing`
+				);
+				await this.unsubscribe(true);
+				this.receivingData = false;
+				await this.subscribe();
+			}
+		}, this.resubTimeoutMs);
 	}
 
 	public getSlot(): number {
 		return this.currentSlot;
 	}
 
-	public async unsubscribe(): Promise<void> {
-		if (this.subscriptionId) {
+	public async unsubscribe(onResub = false): Promise<void> {
+		if (!onResub) {
+			this.resubTimeoutMs = undefined;
+		}
+		this.isUnsubscribing = true;
+		clearTimeout(this.timeoutId);
+		this.timeoutId = undefined;
+
+		if (this.subscriptionId != null) {
 			await this.connection.removeSlotChangeListener(this.subscriptionId);
+			this.subscriptionId = undefined;
+			this.isUnsubscribing = false;
+		} else {
+			this.isUnsubscribing = false;
 		}
 	}
 }

package/src/types.ts

@@ -182,6 +182,7 @@ export class SpotFulfillmentStatus {
 export class DepositExplanation {
 	static readonly NONE = { none: {} };
 	static readonly TRANSFER = { transfer: {} };
+	static readonly BORROW = { borrow: {} };
 }
 
 export class SettlePnlExplanation {
@@ -710,7 +711,7 @@ export type AMM = {
 	pegMultiplier: BN;
 	cumulativeFundingRateLong: BN;
 	cumulativeFundingRateShort: BN;
-	last24hAvgFundingRate: BN;
+	last24HAvgFundingRate: BN;
 	lastFundingRateShort: BN;
 	lastFundingRateLong: BN;
 

package/src/user.ts

@@ -27,6 +27,7 @@ import {
 	OPEN_ORDER_MARGIN_REQUIREMENT,
 	PRICE_PRECISION,
 	QUOTE_PRECISION,
+	QUOTE_PRECISION_EXP,
 	QUOTE_SPOT_MARKET_INDEX,
 	SPOT_MARKET_WEIGHT_PRECISION,
 	TEN,
@@ -40,6 +41,7 @@ import {
 	UserAccountSubscriber,
 } from './accounts/types';
 import {
+	BigNum,
 	BN,
 	calculateBaseAssetValue,
 	calculateMarketMarginRatio,
@@ -1399,8 +1401,12 @@ export class User {
 		includeOpenOrders = false
 	): BN {
 		const userPosition =
-			this.getPerpPositionWithLPSettle(marketIndex)[0] ||
-			this.getEmptyPosition(marketIndex);
+			this.getPerpPositionWithLPSettle(
+				marketIndex,
+				undefined,
+				false,
+				true
+			)[0] || this.getEmptyPosition(marketIndex);
 		const market = this.driftClient.getPerpMarketAccount(
 			userPosition.marketIndex
 		);
@@ -3013,7 +3019,7 @@ export class User {
 		let makerFee =
 			feeTier.makerRebateNumerator / feeTier.makerRebateDenominator;
 
-		if (marketIndex && isVariant(marketType, 'perp')) {
+		if (marketIndex !== undefined && isVariant(marketType, 'perp')) {
 			const marketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
 			takerFee += (takerFee * marketAccount.feeAdjustment) / 100;
 			makerFee += (makerFee * marketAccount.feeAdjustment) / 100;
@@ -3030,11 +3036,22 @@ export class User {
 	 * @param quoteAmount
 	 * @returns feeForQuote : Precision QUOTE_PRECISION
 	 */
-	public calculateFeeForQuoteAmount(quoteAmount: BN): BN {
-		const feeTier = this.getUserFeeTier(MarketType.PERP);
-		return quoteAmount
-			.mul(new BN(feeTier.feeNumerator))
-			.div(new BN(feeTier.feeDenominator));
+	public calculateFeeForQuoteAmount(quoteAmount: BN, marketIndex?: number): BN {
+		if (marketIndex !== undefined) {
+			const takerFeeMultiplier = this.getMarketFees(
+				MarketType.PERP,
+				marketIndex
+			).takerFee;
+			const feeAmountNum =
+				BigNum.from(quoteAmount, QUOTE_PRECISION_EXP).toNum() *
+				takerFeeMultiplier;
+			return BigNum.fromPrint(feeAmountNum.toString(), QUOTE_PRECISION_EXP).val;
+		} else {
+			const feeTier = this.getUserFeeTier(MarketType.PERP);
+			return quoteAmount
+				.mul(new BN(feeTier.feeNumerator))
+				.div(new BN(feeTier.feeDenominator));
+		}
 	}
 
 	/**

package/src/userMap/userMap.ts

@@ -13,7 +13,7 @@ import {
 	LPRecord,
 	StateAccount,
 	DLOB,
-	BasicUserAccountSubscriber,
+	OneShotUserAccountSubscriber,
 	BN,
 } from '..';
 
@@ -60,6 +60,7 @@ export class UserMap implements UserMapInterface {
 		}
 	};
 	private decode;
+	private mostRecentSlot = 0;
 
 	private syncPromise?: Promise<void>;
 	private syncPromiseResolver: () => void;
@@ -132,10 +133,12 @@ export class UserMap implements UserMapInterface {
 			userAccountPublicKey,
 			accountSubscription: {
 				type: 'custom',
-				userAccountSubscriber: new BasicUserAccountSubscriber(
+				userAccountSubscriber: new OneShotUserAccountSubscriber(
+					this.driftClient.program,
 					userAccountPublicKey,
 					userAccount,
-					slot
+					slot,
+					this.commitment
 				),
 			},
 		});
@@ -310,6 +313,8 @@ export class UserMap implements UserMapInterface {
 
 			const slot = rpcResponseAndContext.context.slot;
 
+			this.updateLatestSlot(slot);
+
 			const programAccountBufferMap = new Map<string, Buffer>();
 			for (const programAccount of rpcResponseAndContext.value) {
 				programAccountBufferMap.set(
@@ -371,6 +376,7 @@ export class UserMap implements UserMapInterface {
 		userAccount: UserAccount,
 		slot: number
 	) {
+		this.updateLatestSlot(slot);
 		if (!this.userMap.has(key)) {
 			this.addPubkey(new PublicKey(key), userAccount, slot);
 		} else {
@@ -378,4 +384,12 @@ export class UserMap implements UserMapInterface {
 			user.accountSubscriber.updateData(userAccount, slot);
 		}
 	}
+
+	updateLatestSlot(slot: number): void {
+		this.mostRecentSlot = Math.max(slot, this.mostRecentSlot);
+	}
+
+	public getSlot(): number {
+		return this.mostRecentSlot;
+	}
 }

package/src/userStats.ts

@@ -82,4 +82,12 @@ export class UserStats {
 			};
 		}
 	}
+
+	public static getOldestActionTs(account: UserStatsAccount): number {
+		return Math.min(
+			account.lastFillerVolume30DTs.toNumber(),
+			account.lastMakerVolume30DTs.toNumber(),
+			account.lastTakerVolume30DTs.toNumber()
+		);
+	}
 }