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

package/lib/tx/fastSingleTxSender.d.ts

@@ -27,6 +27,6 @@ export declare class FastSingleTxSender extends BaseTxSender {
     });
     startBlockhashRefreshLoop(): void;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, _opts: ConfirmOptions): Promise<Transaction>;
-    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<VersionedTransaction>;
+    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions, blockhash?: string): Promise<VersionedTransaction>;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
 }

package/lib/tx/fastSingleTxSender.js

@@ -52,7 +52,7 @@ class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
         const signedTx = await this.wallet.signTransaction(tx);
         return signedTx;
     }
-    async getVersionedTransaction(ixs, lookupTableAccounts, additionalSigners, opts) {
+    async getVersionedTransaction(ixs, lookupTableAccounts, additionalSigners, opts, blockhash) {
         var _a;
         if (additionalSigners === undefined) {
             additionalSigners = [];
@@ -60,10 +60,18 @@ class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
         if (opts === undefined) {
             opts = this.opts;
         }
+        let recentBlockhash = '';
+        if (blockhash) {
+            recentBlockhash = blockhash;
+        }
+        else {
+            recentBlockhash =
+                (_a = this.recentBlockhash) !== null && _a !== void 0 ? _a : (await this.connection.getLatestBlockhash(opts.preflightCommitment))
+                    .blockhash;
+        }
         const message = new web3_js_1.TransactionMessage({
             payerKey: this.wallet.publicKey,
-            recentBlockhash: (_a = this.recentBlockhash) !== null && _a !== void 0 ? _a : (await this.connection.getLatestBlockhash(opts.preflightCommitment))
-                .blockhash,
+            recentBlockhash,
             instructions: ixs,
         }).compileToV0Message(lookupTableAccounts);
         const tx = new web3_js_1.VersionedTransaction(message);

package/lib/tx/types.d.ts

@@ -17,7 +17,7 @@ export interface TxSender {
     wallet: IWallet;
     send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean, extraConfirmationOptions?: ExtraConfirmationOptions): Promise<TxSigAndSlot>;
     sendVersionedTransaction(tx: VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean, extraConfirmationOptions?: ExtraConfirmationOptions): Promise<TxSigAndSlot>;
-    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<VersionedTransaction>;
+    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions, blockhash?: string): Promise<VersionedTransaction>;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
     simulateTransaction(tx: VersionedTransaction): Promise<boolean>;
     getTimeoutCount(): number;

package/lib/types.d.ts

@@ -80,6 +80,9 @@ export declare class ContractTier {
     static readonly SPECULATIVE: {
         speculative: {};
     };
+    static readonly HIGHLY_SPECULATIVE: {
+        highlySpeculative: {};
+    };
     static readonly ISOLATED: {
         isolated: {};
     };

package/lib/types.js

@@ -60,6 +60,7 @@ ContractTier.A = { a: {} };
 ContractTier.B = { b: {} };
 ContractTier.C = { c: {} };
 ContractTier.SPECULATIVE = { speculative: {} };
+ContractTier.HIGHLY_SPECULATIVE = { highlySpeculative: {} };
 ContractTier.ISOLATED = { isolated: {} };
 class AssetTier {
 }

package/lib/user.d.ts

@@ -246,13 +246,15 @@ export declare class User {
     /**
      * Calculate the liquidation price of a perp position, with optional parameter to calculate the liquidation price after a trade
      * @param marketIndex
-     * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
+     * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^9
+     * @param estimatedEntryPrice
      * @param marginCategory // allow Initial to be passed in if we are trying to calculate price for DLP de-risking
+     * @param includeOpenOrders
      * @returns Precision : PRICE_PRECISION
      */
-    liquidationPrice(marketIndex: number, positionBaseSizeChange?: BN, estimatedEntryPrice?: BN, marginCategory?: MarginCategory): BN;
-    calculateEntriesEffectOnFreeCollateral(market: PerpMarketAccount, oraclePrice: BN, perpPosition: PerpPosition, positionBaseSizeChange: BN, estimatedEntryPrice: BN): BN;
-    calculateFreeCollateralDeltaForPerp(market: PerpMarketAccount, perpPosition: PerpPosition, positionBaseSizeChange: BN, marginCategory?: MarginCategory): BN | undefined;
+    liquidationPrice(marketIndex: number, positionBaseSizeChange?: BN, estimatedEntryPrice?: BN, marginCategory?: MarginCategory, includeOpenOrders?: boolean): BN;
+    calculateEntriesEffectOnFreeCollateral(market: PerpMarketAccount, oraclePrice: BN, perpPosition: PerpPosition, positionBaseSizeChange: BN, estimatedEntryPrice: BN, includeOpenOrders: boolean): BN;
+    calculateFreeCollateralDeltaForPerp(market: PerpMarketAccount, perpPosition: PerpPosition, positionBaseSizeChange: BN, marginCategory?: MarginCategory, includeOpenOrders?: boolean): BN | undefined;
     calculateFreeCollateralDeltaForSpot(market: SpotMarketAccount, signedTokenAmount: BN, marginCategory?: MarginCategory): BN;
     /**
      * Calculates the estimated liquidation price for a position after closing a quote amount of the position.

package/lib/user.js

@@ -1082,13 +1082,15 @@ class User {
     /**
      * Calculate the liquidation price of a perp position, with optional parameter to calculate the liquidation price after a trade
      * @param marketIndex
-     * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
+     * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^9
+     * @param estimatedEntryPrice
      * @param marginCategory // allow Initial to be passed in if we are trying to calculate price for DLP de-risking
+     * @param includeOpenOrders
      * @returns Precision : PRICE_PRECISION
      */
-    liquidationPrice(marketIndex, positionBaseSizeChange = numericConstants_1.ZERO, estimatedEntryPrice = numericConstants_1.ZERO, marginCategory = 'Maintenance') {
+    liquidationPrice(marketIndex, positionBaseSizeChange = numericConstants_1.ZERO, estimatedEntryPrice = numericConstants_1.ZERO, marginCategory = 'Maintenance', includeOpenOrders = false) {
         const totalCollateral = this.getTotalCollateral(marginCategory);
-        const marginRequirement = this.getMarginRequirement(marginCategory, undefined, false);
+        const marginRequirement = this.getMarginRequirement(marginCategory, undefined, false, includeOpenOrders);
         let freeCollateral = _1.BN.max(numericConstants_1.ZERO, totalCollateral.sub(marginRequirement));
         const oracle = this.driftClient.getPerpMarketAccount(marketIndex).amm.oracle;
         const oraclePrice = this.driftClient.getOracleDataForPerpMarket(marketIndex).price;
@@ -1096,9 +1098,9 @@ class User {
         const currentPerpPosition = this.getPerpPositionWithLPSettle(marketIndex, undefined, true)[0] ||
             this.getEmptyPosition(marketIndex);
         positionBaseSizeChange = (0, _1.standardizeBaseAssetAmount)(positionBaseSizeChange, market.amm.orderStepSize);
-        const freeCollateralChangeFromNewPosition = this.calculateEntriesEffectOnFreeCollateral(market, oraclePrice, currentPerpPosition, positionBaseSizeChange, estimatedEntryPrice);
+        const freeCollateralChangeFromNewPosition = this.calculateEntriesEffectOnFreeCollateral(market, oraclePrice, currentPerpPosition, positionBaseSizeChange, estimatedEntryPrice, includeOpenOrders);
         freeCollateral = freeCollateral.add(freeCollateralChangeFromNewPosition);
-        let freeCollateralDelta = this.calculateFreeCollateralDeltaForPerp(market, currentPerpPosition, positionBaseSizeChange, marginCategory);
+        let freeCollateralDelta = this.calculateFreeCollateralDeltaForPerp(market, currentPerpPosition, positionBaseSizeChange, marginCategory, includeOpenOrders);
         if (!freeCollateralDelta) {
             return new _1.BN(-1);
         }
@@ -1125,7 +1127,7 @@ class User {
         }
         return liqPrice;
     }
-    calculateEntriesEffectOnFreeCollateral(market, oraclePrice, perpPosition, positionBaseSizeChange, estimatedEntryPrice) {
+    calculateEntriesEffectOnFreeCollateral(market, oraclePrice, perpPosition, positionBaseSizeChange, estimatedEntryPrice, includeOpenOrders) {
         let freeCollateralChange = numericConstants_1.ZERO;
         // update free collateral to account for change in pnl from new position
         if (!estimatedEntryPrice.eq(numericConstants_1.ZERO) && !positionBaseSizeChange.eq(numericConstants_1.ZERO)) {
@@ -1139,8 +1141,6 @@ class User {
                 freeCollateralChange = costBasis.sub(newPositionValue);
             }
             else {
-                console.log('newPositionValue', newPositionValue.toString());
-                console.log('costBasis', costBasis.toString());
                 freeCollateralChange = newPositionValue.sub(costBasis);
             }
             // assume worst fee tier
@@ -1150,30 +1150,33 @@ class User {
                 .divn(takerFeeTier.feeDenominator);
             freeCollateralChange = freeCollateralChange.sub(takerFee);
         }
-        const worstCaseBaseAssetAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition);
-        const newWorstCaseBaseAssetAmount = worstCaseBaseAssetAmount.add(positionBaseSizeChange);
-        const newMarginRatio = (0, _1.calculateMarketMarginRatio)(market, newWorstCaseBaseAssetAmount.abs(), 'Maintenance');
+        const baseAssetAmount = includeOpenOrders
+            ? (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition)
+            : perpPosition.baseAssetAmount;
+        const newBaseAssetAmount = baseAssetAmount.add(positionBaseSizeChange);
+        const newMarginRatio = (0, _1.calculateMarketMarginRatio)(market, newBaseAssetAmount.abs(), 'Maintenance');
         // update free collateral to account for new margin requirement from position change
-        freeCollateralChange = freeCollateralChange.sub(newWorstCaseBaseAssetAmount
+        freeCollateralChange = freeCollateralChange.sub(newBaseAssetAmount
             .abs()
-            .sub(worstCaseBaseAssetAmount.abs())
+            .sub(baseAssetAmount.abs())
             .mul(oraclePrice)
             .div(numericConstants_1.BASE_PRECISION)
             .mul(new _1.BN(newMarginRatio))
             .div(numericConstants_1.MARGIN_PRECISION));
         return freeCollateralChange;
     }
-    calculateFreeCollateralDeltaForPerp(market, perpPosition, positionBaseSizeChange, marginCategory = 'Maintenance') {
-        const currentBaseAssetAmount = perpPosition.baseAssetAmount;
-        const worstCaseBaseAssetAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition);
-        const orderBaseAssetAmount = worstCaseBaseAssetAmount.sub(currentBaseAssetAmount);
-        const proposedBaseAssetAmount = currentBaseAssetAmount.add(positionBaseSizeChange);
-        const proposedWorstCaseBaseAssetAmount = worstCaseBaseAssetAmount.add(positionBaseSizeChange);
-        const marginRatio = (0, _1.calculateMarketMarginRatio)(market, proposedWorstCaseBaseAssetAmount.abs(), marginCategory, this.getUserAccount().maxMarginRatio);
+    calculateFreeCollateralDeltaForPerp(market, perpPosition, positionBaseSizeChange, marginCategory = 'Maintenance', includeOpenOrders = false) {
+        const baseAssetAmount = includeOpenOrders
+            ? (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition)
+            : perpPosition.baseAssetAmount;
+        // zero if include orders == false
+        const orderBaseAssetAmount = baseAssetAmount.sub(perpPosition.baseAssetAmount);
+        const proposedBaseAssetAmount = baseAssetAmount.add(positionBaseSizeChange);
+        const marginRatio = (0, _1.calculateMarketMarginRatio)(market, proposedBaseAssetAmount.abs(), marginCategory, this.getUserAccount().maxMarginRatio);
         const marginRatioQuotePrecision = new _1.BN(marginRatio)
             .mul(numericConstants_1.QUOTE_PRECISION)
             .div(numericConstants_1.MARGIN_PRECISION);
-        if (proposedWorstCaseBaseAssetAmount.eq(numericConstants_1.ZERO)) {
+        if (proposedBaseAssetAmount.eq(numericConstants_1.ZERO)) {
             return undefined;
         }
         let freeCollateralDelta = numericConstants_1.ZERO;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.74.0-beta.1",
+	"version": "2.74.0-beta.10",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/adminClient.ts

@@ -31,7 +31,13 @@ import {
 import { squareRootBN } from './math/utils';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { DriftClient } from './driftClient';
-import { PEG_PRECISION } from './constants/numericConstants';
+import {
+	PEG_PRECISION,
+	ZERO,
+	ONE,
+	BASE_PRECISION,
+	PRICE_PRECISION,
+} from './constants/numericConstants';
 import { calculateTargetPriceTrade } from './math/trade';
 import { calculateAmmReservesAfterSwap, getSwapDirection } from './math/amm';
 import { PROGRAM_ID as PHOENIX_PROGRAM_ID } from '@ellipsis-labs/phoenix-sdk';
@@ -84,7 +90,14 @@ export class AdminClient extends DriftClient {
 		maintenanceLiabilityWeight: number,
 		imfFactor = 0,
 		liquidatorFee = 0,
+		ifLiquidationFee = 0,
 		activeStatus = true,
+		assetTier = AssetTier.COLLATERAL,
+		scaleInitialAssetWeightStart = ZERO,
+		withdrawGuardThreshold = ZERO,
+		orderTickSize = ONE,
+		orderStepSize = ONE,
+		ifTotalFactor = 0,
 		name = DEFAULT_MARKET_NAME
 	): Promise<TransactionSignature> {
 		const spotMarketIndex = this.getStateAccount().numberOfSpotMarkets;
@@ -115,7 +128,14 @@ export class AdminClient extends DriftClient {
 			maintenanceLiabilityWeight,
 			imfFactor,
 			liquidatorFee,
+			ifLiquidationFee,
 			activeStatus,
+			assetTier,
+			scaleInitialAssetWeightStart,
+			withdrawGuardThreshold,
+			orderTickSize,
+			orderStepSize,
+			ifTotalFactor,
 			nameBuffer,
 			{
 				accounts: {
@@ -238,7 +258,20 @@ export class AdminClient extends DriftClient {
 		marginRatioInitial = 2000,
 		marginRatioMaintenance = 500,
 		liquidatorFee = 0,
+		ifLiquidatorFee = 10000,
+		imfFactor = 0,
 		activeStatus = true,
+		baseSpread = 0,
+		maxSpread = 142500,
+		maxOpenInterest = ZERO,
+		maxRevenueWithdrawPerPeriod = ZERO,
+		quoteMaxInsurance = ZERO,
+		orderStepSize = BASE_PRECISION.divn(10000),
+		orderTickSize = PRICE_PRECISION.divn(100000),
+		minOrderSize = BASE_PRECISION.divn(10000),
+		concentrationCoefScale = ONE,
+		curveUpdateIntensity = 0,
+		ammJitIntensity = 0,
 		name = DEFAULT_MARKET_NAME
 	): Promise<TransactionSignature> {
 		const currentPerpMarketIndex = this.getStateAccount().numberOfMarkets;
@@ -259,7 +292,20 @@ export class AdminClient extends DriftClient {
 				marginRatioInitial,
 				marginRatioMaintenance,
 				liquidatorFee,
+				ifLiquidatorFee,
+				imfFactor,
 				activeStatus,
+				baseSpread,
+				maxSpread,
+				maxOpenInterest,
+				maxRevenueWithdrawPerPeriod,
+				quoteMaxInsurance,
+				orderStepSize,
+				orderTickSize,
+				minOrderSize,
+				concentrationCoefScale,
+				curveUpdateIntensity,
+				ammJitIntensity,
 				nameBuffer,
 				{
 					accounts: {
@@ -2172,4 +2218,30 @@ export class AdminClient extends DriftClient {
 
 		return txSig;
 	}
+
+	public async deletePrelaunchOracle(
+		perpMarketIndex: number
+	): Promise<TransactionSignature> {
+		const deletePrelaunchOracleIx =
+			await this.program.instruction.deletePrelaunchOracle(perpMarketIndex, {
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					prelaunchOracle: await getPrelaunchOraclePublicKey(
+						this.program.programId,
+						perpMarketIndex
+					),
+					perpMarket: await getPerpMarketPublicKey(
+						this.program.programId,
+						perpMarketIndex
+					),
+				},
+			});
+
+		const tx = await this.buildTransaction(deletePrelaunchOracleIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
 }

package/src/blockhashSubscriber/BlockhashSubscriber.ts

@@ -0,0 +1,108 @@
+import {
+	BlockhashWithExpiryBlockHeight,
+	Commitment,
+	Connection,
+	Context,
+} from '@solana/web3.js';
+import { BlockhashSubscriberConfig } from './types';
+
+export class BlockhashSubscriber {
+	private connection: Connection;
+	private isSubscribed = false;
+	private latestBlockHeight: number;
+	private latestBlockHeightContext: Context | undefined;
+	private blockhashes: Array<BlockhashWithExpiryBlockHeight> = [];
+	private updateBlockhashIntervalId: NodeJS.Timeout | undefined;
+	private commitment: Commitment;
+	private updateIntervalMs: number;
+
+	constructor(config: BlockhashSubscriberConfig) {
+		if (!config.connection && !config.rpcUrl) {
+			throw new Error(
+				'BlockhashSubscriber requires one of connection or rpcUrl must be provided'
+			);
+		}
+		this.connection = config.connection || new Connection(config.rpcUrl!);
+		this.commitment = config.commitment ?? 'confirmed';
+		this.updateIntervalMs = config.updateIntervalMs ?? 1000;
+	}
+
+	getBlockhashCacheSize(): number {
+		return this.blockhashes.length;
+	}
+
+	getLatestBlockHeight(): number {
+		return this.latestBlockHeight;
+	}
+
+	getLatestBlockHeightContext(): Context | undefined {
+		return this.latestBlockHeightContext;
+	}
+
+	getLatestBlockhash(
+		offset?: number
+	): BlockhashWithExpiryBlockHeight | undefined {
+		if (this.blockhashes.length === 0) {
+			return undefined;
+		}
+		const clampedOffset = Math.max(
+			0,
+			Math.min(this.blockhashes.length - 1, offset ?? 0)
+		);
+
+		return this.blockhashes[this.blockhashes.length - 1 - clampedOffset];
+	}
+
+	pruneBlockhashes() {
+		if (this.latestBlockHeight) {
+			this.blockhashes = this.blockhashes.filter(
+				(blockhash) => blockhash.lastValidBlockHeight > this.latestBlockHeight!
+			);
+		}
+	}
+
+	async updateBlockhash() {
+		const [resp, lastConfirmedBlockHeight] = await Promise.all([
+			this.connection.getLatestBlockhashAndContext({
+				commitment: this.commitment,
+			}),
+			this.connection.getBlockHeight({ commitment: this.commitment }),
+		]);
+		this.latestBlockHeight = lastConfirmedBlockHeight;
+		this.latestBlockHeightContext = resp.context;
+
+		// avoid caching duplicate blockhashes
+		if (this.blockhashes.length > 0) {
+			if (
+				resp.value.blockhash ===
+				this.blockhashes[this.blockhashes.length - 1].blockhash
+			) {
+				return;
+			}
+		}
+
+		this.blockhashes.push(resp.value);
+		this.pruneBlockhashes();
+	}
+
+	async subscribe() {
+		if (this.isSubscribed) {
+			return;
+		}
+		this.isSubscribed = true;
+
+		await this.updateBlockhash();
+		this.updateBlockhashIntervalId = setInterval(
+			this.updateBlockhash.bind(this),
+			this.updateIntervalMs
+		);
+	}
+
+	unsubscribe() {
+		if (this.updateBlockhashIntervalId) {
+			clearInterval(this.updateBlockhashIntervalId);
+			this.updateBlockhashIntervalId = undefined;
+		}
+		this.isSubscribed = false;
+	}
+}

package/src/blockhashSubscriber/index.ts

@@ -0,0 +1 @@
+export * from './BlockhashSubscriber';

package/src/blockhashSubscriber/types.ts

@@ -0,0 +1,8 @@
+import { Commitment, Connection } from '@solana/web3.js';
+
+export type BlockhashSubscriberConfig = {
+	rpcUrl?: string;
+	connection?: Connection;
+	commitment?: Commitment;
+	updateIntervalMs?: number;
+};

package/src/dlob/orderBookLevels.ts

@@ -219,6 +219,9 @@ export function getVammL2Generator({
 					);
 
 				baseSwapped = bidAmm.baseAssetReserve.sub(afterSwapBaseReserves).abs();
+				if (baseSwapped.eq(ZERO)) {
+					return;
+				}
 				if (remainingBaseLiquidity.lt(baseSwapped)) {
 					baseSwapped = remainingBaseLiquidity;
 					[afterSwapQuoteReserves, afterSwapBaseReserves] =
@@ -299,6 +302,9 @@ export function getVammL2Generator({
 					);
 
 				baseSwapped = askAmm.baseAssetReserve.sub(afterSwapBaseReserves).abs();
+				if (baseSwapped.eq(ZERO)) {
+					return;
+				}
 				if (remainingBaseLiquidity.lt(baseSwapped)) {
 					baseSwapped = remainingBaseLiquidity;
 					[afterSwapQuoteReserves, afterSwapBaseReserves] =
@@ -423,6 +429,30 @@ function groupL2Levels(
 	return groupedLevels;
 }
 
+/**
+ * Method to merge bids or asks by price
+ */
+const mergeByPrice = (bidsOrAsks: L2Level[]) => {
+	const merged = new Map<string, L2Level>();
+	for (const level of bidsOrAsks) {
+		const key = level.price.toString();
+		if (merged.has(key)) {
+			const existing = merged.get(key);
+			existing.size = existing.size.add(level.size);
+			for (const [source, size] of Object.entries(level.sources)) {
+				if (existing.sources[source]) {
+					existing.sources[source] = existing.sources[source].add(size);
+				} else {
+					existing.sources[source] = size;
+				}
+			}
+		} else {
+			merged.set(key, cloneL2Level(level));
+		}
+	}
+	return Array.from(merged.values());
+};
+
 /**
  * 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
@@ -461,8 +491,8 @@ export function uncrossL2(
 		return { bids, asks };
 	}
 
-	const newBids = [];
-	const newAsks = [];
+	const newBids: L2Level[] = [];
+	const newAsks: L2Level[] = [];
 
 	const updateLevels = (newPrice: BN, oldLevel: L2Level, levels: L2Level[]) => {
 		if (levels.length > 0 && levels[levels.length - 1].price.eq(newPrice)) {
@@ -522,19 +552,19 @@ export function uncrossL2(
 			continue;
 		}
 
-		if (nextBid.price.gte(nextAsk.price)) {
-			if (userBids.has(nextBid.price.toString())) {
-				newBids.push(nextBid);
-				bidIndex++;
-				continue;
-			}
+		if (userBids.has(nextBid.price.toString())) {
+			newBids.push(nextBid);
+			bidIndex++;
+			continue;
+		}
 
-			if (userAsks.has(nextAsk.price.toString())) {
-				newAsks.push(nextAsk);
-				askIndex++;
-				continue;
-			}
+		if (userAsks.has(nextAsk.price.toString())) {
+			newAsks.push(nextAsk);
+			askIndex++;
+			continue;
+		}
 
+		if (nextBid.price.gte(nextAsk.price)) {
 			if (
 				nextBid.price.gt(referencePrice) &&
 				nextAsk.price.gt(referencePrice)
@@ -588,8 +618,14 @@ export function uncrossL2(
 		}
 	}
 
+	newBids.sort((a, b) => b.price.cmp(a.price));
+	newAsks.sort((a, b) => a.price.cmp(b.price));
+
+	const finalNewBids = mergeByPrice(newBids);
+	const finalNewAsks = mergeByPrice(newAsks);
+
 	return {
-		bids: newBids,
-		asks: newAsks,
+		bids: finalNewBids,
+		asks: finalNewAsks,
 	};
 }

package/src/driftClient.ts

@@ -1074,6 +1074,43 @@ export class DriftClient {
 		return ix;
 	}
 
+	public async updateUserReduceOnly(
+		updates: { reduceOnly: boolean; subAccountId: number }[]
+	): Promise<TransactionSignature> {
+		const ixs = await Promise.all(
+			updates.map(async ({ reduceOnly, subAccountId }) => {
+				return await this.getUpdateUserReduceOnlyIx(reduceOnly, subAccountId);
+			})
+		);
+
+		const tx = await this.buildTransaction(ixs, this.txParams);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+		return txSig;
+	}
+
+	public async getUpdateUserReduceOnlyIx(
+		reduceOnly: boolean,
+		subAccountId: number
+	) {
+		const ix = await this.program.instruction.updateUserReduceOnly(
+			subAccountId,
+			reduceOnly,
+			{
+				accounts: {
+					user: getUserAccountPublicKeySync(
+						this.program.programId,
+						this.wallet.publicKey,
+						subAccountId
+					),
+					authority: this.wallet.publicKey,
+				},
+			}
+		);
+
+		return ix;
+	}
+
 	public async fetchAllUserAccounts(
 		includeIdle = true
 	): Promise<ProgramAccount<UserAccount>[]> {