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

package/src/dlob/orderBookLevels.ts

@@ -407,3 +407,139 @@ function groupL2Levels(
 	}
 	return groupedLevels;
 }
+
+/**
+ * The purpose of this function is uncross the L2 orderbook by modifying the bid/ask price at the top of the book
+ * This will make the liquidity look worse but more intuitive (users familiar with clob get confused w temporarily
+ * crossing book)
+ *
+ * Things to note about how it works:
+ * - it will not uncross the user's liquidity
+ * - it does the uncrossing by "shifting" the crossing liquidity to the nearest uncrossed levels. Thus the output liquidity maintains the same total size.
+ *
+ * @param bids
+ * @param asks
+ * @param oraclePrice
+ * @param oracleTwap5Min
+ * @param markTwap5Min
+ * @param grouping
+ * @param userBids
+ * @param userAsks
+ */
+export function uncrossL2(
+	bids: L2Level[],
+	asks: L2Level[],
+	oraclePrice: BN,
+	oracleTwap5Min: BN,
+	markTwap5Min: BN,
+	grouping: BN,
+	userBids: Set<string>,
+	userAsks: Set<string>
+): { bids: L2Level[]; asks: L2Level[] } {
+	// If there are no bids or asks, there is nothing to center
+	if (bids.length === 0 || asks.length === 0) {
+		return { bids, asks };
+	}
+
+	// If the top of the book is already centered, there is nothing to do
+	if (bids[0].price.lt(asks[0].price)) {
+		return { bids, asks };
+	}
+
+	const newBids = [];
+	const newAsks = [];
+
+	const updateLevels = (newPrice: BN, oldLevel: L2Level, levels: L2Level[]) => {
+		if (levels.length > 0 && levels[levels.length - 1].price.eq(newPrice)) {
+			levels[levels.length - 1].size = levels[levels.length - 1].size.add(
+				oldLevel.size
+			);
+			for (const [source, size] of Object.entries(oldLevel.sources)) {
+				if (levels[levels.length - 1].sources[source]) {
+					levels[levels.length - 1].sources = {
+						...levels[levels.length - 1].sources,
+						[source]: levels[levels.length - 1].sources[source].add(size),
+					};
+				} else {
+					levels[levels.length - 1].sources[source] = size;
+				}
+			}
+		} else {
+			levels.push({
+				price: newPrice,
+				size: oldLevel.size,
+				sources: oldLevel.sources,
+			});
+		}
+	};
+
+	// This is the best estimate of the premium in the market vs oracle to filter crossing around
+	const referencePrice = oraclePrice.add(markTwap5Min.sub(oracleTwap5Min));
+
+	let bidIndex = 0;
+	let askIndex = 0;
+	while (bidIndex < bids.length || askIndex < asks.length) {
+		const nextBid = bids[bidIndex];
+		const nextAsk = asks[askIndex];
+
+		if (!nextBid) {
+			newAsks.push(nextAsk);
+			askIndex++;
+			continue;
+		}
+
+		if (!nextAsk) {
+			newBids.push(nextBid);
+			bidIndex++;
+			continue;
+		}
+
+		if (nextBid.price.gt(nextAsk.price)) {
+			if (userBids.has(nextBid.price.toString())) {
+				newBids.push(nextBid);
+				bidIndex++;
+				continue;
+			}
+
+			if (userAsks.has(nextAsk.price.toString())) {
+				newAsks.push(nextAsk);
+				askIndex++;
+				continue;
+			}
+
+			if (
+				nextBid.price.gt(referencePrice) &&
+				nextAsk.price.gt(referencePrice)
+			) {
+				const newBidPrice = nextAsk.price.sub(grouping);
+				updateLevels(newBidPrice, nextBid, newBids);
+				bidIndex++;
+			} else if (
+				nextAsk.price.lt(referencePrice) &&
+				nextBid.price.lt(referencePrice)
+			) {
+				const newAskPrice = nextBid.price.add(grouping);
+				updateLevels(newAskPrice, nextAsk, newAsks);
+				askIndex++;
+			} else {
+				const newBidPrice = referencePrice.sub(grouping);
+				const newAskPrice = referencePrice.add(grouping);
+				updateLevels(newBidPrice, nextBid, newBids);
+				updateLevels(newAskPrice, nextAsk, newAsks);
+				bidIndex++;
+				askIndex++;
+			}
+		} else {
+			newAsks.push(nextAsk);
+			askIndex++;
+
+			newBids.push(nextBid);
+			bidIndex++;
+		}
+	}
+
+	return {
+		bids: newBids,
+		asks: newAsks,
+	};
+}

package/src/driftClient.ts

@@ -1112,6 +1112,19 @@ export class DriftClient {
 		);
 	}
 
+	public async getUserDeletionIx(userAccountPublicKey: PublicKey) {
+		const ix = await this.program.instruction.deleteUser({
+			accounts: {
+				user: userAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
+				authority: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+			},
+		});
+
+		return ix;
+	}
+
 	public async deleteUser(
 		subAccountId = 0,
 		txParams?: TxParams
@@ -1122,14 +1135,7 @@ export class DriftClient {
 			subAccountId
 		);
 
-		const ix = await this.program.instruction.deleteUser({
-			accounts: {
-				user: userAccountPublicKey,
-				userStats: this.getUserStatsAccountPublicKey(),
-				authority: this.wallet.publicKey,
-				state: await this.getStatePublicKey(),
-			},
-		});
+		const ix = await this.getUserDeletionIx(userAccountPublicKey);
 
 		const { txSig } = await this.sendTransaction(
 			await this.buildTransaction(ix, txParams),
@@ -3953,9 +3959,14 @@ export class DriftClient {
 			userAccountPublicKey || (await this.getUserAccountPublicKey());
 
 		const userAccounts = [];
-		if (this.hasUser() && this.getUser().getUserAccountAndSlot()) {
-			userAccounts.push(this.getUser().getUserAccountAndSlot()!.data);
+		try {
+			if (this.hasUser() && this.getUser().getUserAccountAndSlot()) {
+				userAccounts.push(this.getUser().getUserAccountAndSlot()!.data);
+			}
+		} catch (err) {
+			// ignore
 		}
+
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts,
 			writableSpotMarketIndexes: [outMarketIndex, inMarketIndex],

package/src/events/webSocketLogProvider.ts

@@ -23,7 +23,7 @@ export class WebSocketLogProvider implements LogProvider {
 	}
 
 	public async subscribe(callback: logProviderCallback): Promise<boolean> {
-		if (this.subscriptionId) {
+		if (this.subscriptionId != null) {
 			return true;
 		}
 
@@ -62,7 +62,7 @@ export class WebSocketLogProvider implements LogProvider {
 	}
 
 	public isSubscribed(): boolean {
-		return this.subscriptionId !== undefined;
+		return this.subscriptionId != null;
 	}
 
 	public async unsubscribe(external = false): Promise<boolean> {
@@ -71,7 +71,7 @@ export class WebSocketLogProvider implements LogProvider {
 		clearTimeout(this.timeoutId);
 		this.timeoutId = undefined;
 
-		if (this.subscriptionId !== undefined) {
+		if (this.subscriptionId != null) {
 			try {
 				await this.connection.removeOnLogsListener(this.subscriptionId);
 				this.subscriptionId = undefined;

package/src/factory/bigNum.ts

@@ -497,7 +497,11 @@ export class BigNum {
 		return `${prefix}${val.replace('-', '')}`;
 	}
 
-	public toMillified(precision = 3, rounded = false): string {
+	public toMillified(
+		precision = 3,
+		rounded = false,
+		type: 'financial' | 'scientific' = 'financial'
+	): string {
 		if (rounded) {
 			return this.toRounded(precision).toMillified(precision);
 		}
@@ -520,7 +524,12 @@ export class BigNum {
 			return this.shift(new BN(precision)).toPrecision(precision, true);
 		}
 
-		const unitTicks = ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+		const unitTicks =
+			type === 'financial'
+				? ['', 'K', 'M', 'B', 'T', 'Q']
+				: ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+		// TODO -- handle nubers which are larger than the max unit tick
+
 		const unitNumber = Math.floor((leftSide.length - 1) / 3);
 		const unit = unitTicks[unitNumber];
 

package/src/idl/drift.json

@@ -7343,12 +7343,24 @@
             "name": "totalFeeEarnedPerLp",
             "type": "u64"
           },
+          {
+            "name": "netUnsettledFundingPnl",
+            "type": "i64"
+          },
+          {
+            "name": "quoteAssetAmountWithUnsettledLp",
+            "type": "i64"
+          },
+          {
+            "name": "referencePriceOffset",
+            "type": "i32"
+          },
           {
             "name": "padding",
             "type": {
               "array": [
                 "u8",
-                32
+                12
               ]
             }
           }

package/src/index.ts

@@ -21,6 +21,7 @@ export * from './accounts/pollingUserAccountSubscriber';
 export * from './accounts/pollingUserStatsAccountSubscriber';
 export * from './accounts/pollingInsuranceFundStakeAccountSubscriber';
 export * from './accounts/basicUserAccountSubscriber';
+export * from './accounts/oneShotUserAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses/pda';
 export * from './adminClient';

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/phoenix/phoenixSubscriber.ts

@@ -178,9 +178,9 @@ 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 size = new BN(quantity).mul(new BN(basePrecision));
 			yield {
-				price: new BN(Math.floor(price * pricePrecision)),
+				price: new BN(price).mul(new BN(pricePrecision)),
 				size,
 				sources: {
 					phoenix: size,

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

@@ -710,7 +710,7 @@ export type AMM = {
 	pegMultiplier: BN;
 	cumulativeFundingRateLong: BN;
 	cumulativeFundingRateShort: BN;
-	last24hAvgFundingRate: BN;
+	last24HAvgFundingRate: BN;
 	lastFundingRateShort: BN;
 	lastFundingRateLong: BN;