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

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

@@ -1122,6 +1122,22 @@ export class DriftClient {
 			subAccountId
 		);
 
+		const ix = await this.getUserDeletionIx(userAccountPublicKey);
+
+		const { txSig } = await this.sendTransaction(
+			await this.buildTransaction(ix, txParams),
+			[],
+			this.opts
+		);
+
+		const userMapKey = this.getUserMapKey(subAccountId, this.wallet.publicKey);
+		await this.users.get(userMapKey)?.unsubscribe();
+		this.users.delete(userMapKey);
+
+		return txSig;
+	}
+
+	public async getUserDeletionIx(userAccountPublicKey: PublicKey) {
 		const ix = await this.program.instruction.deleteUser({
 			accounts: {
 				user: userAccountPublicKey,
@@ -1131,19 +1147,42 @@ export class DriftClient {
 			},
 		});
 
+		return ix;
+	}
+
+	public async reclaimRent(
+		subAccountId = 0,
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const userAccountPublicKey = getUserAccountPublicKeySync(
+			this.program.programId,
+			this.wallet.publicKey,
+			subAccountId
+		);
+
+		const ix = await this.getReclaimRentIx(userAccountPublicKey);
+
 		const { txSig } = await this.sendTransaction(
 			await this.buildTransaction(ix, txParams),
 			[],
 			this.opts
 		);
 
-		const userMapKey = this.getUserMapKey(subAccountId, this.wallet.publicKey);
-		await this.users.get(userMapKey)?.unsubscribe();
-		this.users.delete(userMapKey);
-
 		return txSig;
 	}
 
+	public async getReclaimRentIx(userAccountPublicKey: PublicKey) {
+		return await this.program.instruction.reclaimRent({
+			accounts: {
+				user: userAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
+				authority: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+			},
+		});
+	}
+
 	public getUser(subAccountId?: number, authority?: PublicKey): User {
 		subAccountId = subAccountId ?? this.activeSubAccountId;
 		authority = authority ?? this.authority;
@@ -3953,9 +3992,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

@@ -1173,6 +1173,37 @@
       ],
       "args": []
     },
+    {
+      "name": "reclaimRent",
+      "accounts": [
+        {
+          "name": "user",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "userStats",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "rent",
+          "isMut": false,
+          "isSigner": false
+        }
+      ],
+      "args": []
+    },
     {
       "name": "fillPerpOrder",
       "accounts": [
@@ -7343,12 +7374,24 @@
             "name": "totalFeeEarnedPerLp",
             "type": "u64"
           },
+          {
+            "name": "netUnsettledFundingPnl",
+            "type": "i64"
+          },
+          {
+            "name": "quoteAssetAmountWithUnsettledLp",
+            "type": "i64"
+          },
+          {
+            "name": "referencePriceOffset",
+            "type": "i32"
+          },
           {
             "name": "padding",
             "type": {
               "array": [
                 "u8",
-                32
+                12
               ]
             }
           }
@@ -8232,6 +8275,9 @@
           },
           {
             "name": "Transfer"
+          },
+          {
+            "name": "Borrow"
           }
         ]
       }
@@ -11124,6 +11170,11 @@
       "code": 6256,
       "name": "CantPayUserInitFee",
       "msg": "CantPayUserInitFee"
+    },
+    {
+      "code": 6257,
+      "name": "CantReclaimRent",
+      "msg": "CantReclaimRent"
     }
   ]
 }

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';
@@ -68,7 +69,7 @@ export * from './constants/numericConstants';
 export * from './serum/serumSubscriber';
 export * from './serum/serumFulfillmentConfigMap';
 export * from './phoenix/phoenixSubscriber';
-export * from './priorityFee/priorityFeeSubscriber';
+export * from './priorityFee';
 export * from './phoenix/phoenixFulfillmentConfigMap';
 export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';

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) {