@drift-labs/sdk 2.16.0-beta.0 → 2.16.0-beta.3

package/lib/dlob/DLOB.js

@@ -289,6 +289,14 @@ class DLOB {
         const nodesToFill = new Array();
         let marketOrderGenerator = this.getMarketAsks(marketIndex, marketType);
         const marketAsksCrossingBids = this.findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, marketOrderGenerator, this.getMakerLimitBids.bind(this), (takerPrice, makerPrice) => {
+            if (__1.isVariant(marketType, 'spot')) {
+                if (takerPrice === undefined) {
+                    return false;
+                }
+                if (fallbackBid && makerPrice.lt(fallbackBid)) {
+                    return false;
+                }
+            }
             return takerPrice === undefined || takerPrice.lte(makerPrice);
         }, fallbackAsk);
         for (const marketAskCrossingBid of marketAsksCrossingBids) {
@@ -304,8 +312,16 @@ class DLOB {
             }
         }
         marketOrderGenerator = this.getMarketBids(marketIndex, marketType);
-        const marketBidsToFill = this.findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, marketOrderGenerator, this.getMakerLimitAsks.bind(this), (takerPrice, fallbackPrice) => {
-            return takerPrice === undefined || takerPrice.gte(fallbackPrice);
+        const marketBidsToFill = this.findMarketNodesCrossingLimitNodes(marketIndex, slot, marketType, oraclePriceData, marketOrderGenerator, this.getMakerLimitAsks.bind(this), (takerPrice, makerPrice) => {
+            if (__1.isVariant(marketType, 'spot')) {
+                if (takerPrice === undefined) {
+                    return false;
+                }
+                if (fallbackAsk && makerPrice.gt(fallbackAsk)) {
+                    return false;
+                }
+            }
+            return takerPrice === undefined || takerPrice.gte(makerPrice);
         }, fallbackBid);
         for (const marketBidToFill of marketBidsToFill) {
             nodesToFill.push(marketBidToFill);

package/lib/driftClient.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="bn.js" />
 import { AnchorProvider, BN, Program } from '@project-serum/anchor';
-import { StateAccount, IWallet, PositionDirection, UserAccount, PerpMarketAccount, OrderParams, Order, SpotMarketAccount, SpotPosition, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo, MarketType, TxParams, SerumV3FulfillmentConfigAccount } from './types';
+import { StateAccount, IWallet, PositionDirection, UserAccount, PerpMarketAccount, OrderParams, Order, SpotMarketAccount, SpotPosition, MakerInfo, TakerInfo, OptionalOrderParams, OrderType, ReferrerInfo, MarketType, TxParams, SerumV3FulfillmentConfigAccount } from './types';
 import * as anchor from '@project-serum/anchor';
 import { Connection, PublicKey, TransactionSignature, ConfirmOptions, Transaction, TransactionInstruction, AccountMeta, Signer } from '@solana/web3.js';
 import { TokenFaucet } from './tokenFaucet';
@@ -212,6 +212,7 @@ export declare class DriftClient {
     closePosition(marketIndex: number, limitPrice?: BN): Promise<TransactionSignature>;
     /**
      * Modifies an open order by closing it and replacing it with a new order.
+     * @deprecated use modifyOrder instead
      * @param orderId: The open order to modify
      * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
      * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
@@ -219,8 +220,29 @@ export declare class DriftClient {
      * @returns
      */
     modifyPerpOrder(orderId: number, newBaseAmount?: BN, newLimitPrice?: BN, newOraclePriceOffset?: number): Promise<TransactionSignature>;
+    /**
+     * Modifies an open order (spot or perp) by closing it and replacing it with a new order.
+     * @param orderId: The open order to modify
+     * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newOraclePriceOffset: The new oracle price offset for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newOrderType: Optional - New order type for the order.
+     * @param newTriggerPrice: Optional - Thew new trigger price for the order.
+     * @param isSpot: Optional - Set to true if the order is a spot order
+     * @returns
+     */
+    modifyOrder({ orderId, newBaseAmount, newLimitPrice, newOraclePriceOffset, newOrderType, newTriggerPrice, isSpot, }: {
+        orderId: number;
+        newBaseAmount?: BN;
+        newLimitPrice?: BN;
+        newOraclePriceOffset?: number;
+        newOrderType?: OrderType;
+        newTriggerPrice?: BN;
+        isSpot?: boolean;
+    }): Promise<TransactionSignature>;
     /**
      * Modifies an open order by closing it and replacing it with a new order.
+     * @deprecated use modifyOrderByUserOrderId instead
      * @param userOrderId: The open order to modify
      * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
      * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
@@ -228,6 +250,26 @@ export declare class DriftClient {
      * @returns
      */
     modifyPerpOrderByUserOrderId(userOrderId: number, newBaseAmount?: BN, newLimitPrice?: BN, newOraclePriceOffset?: number): Promise<TransactionSignature>;
+    /**
+     * Modifies an open order by closing it and replacing it with a new order.
+     * @param userOrderId: The open order to modify
+     * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newOraclePriceOffset: The new oracle price offset for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newOrderType: Optional - New order type for the order.
+     * @param newTriggerPrice: Optional - Thew new trigger price for the order.
+     * @param isSpot: Set to true if the order is a spot order
+     * @returns
+     */
+    modifyOrderByUserOrderId({ userOrderId, newBaseAmount, newLimitPrice, newOraclePriceOffset, newOrderType, newTriggerPrice, isSpot, }: {
+        userOrderId: number;
+        newBaseAmount?: BN;
+        newLimitPrice?: BN;
+        newOraclePriceOffset?: number;
+        newOrderType?: OrderType;
+        newTriggerPrice?: BN;
+        isSpot?: boolean;
+    }): Promise<TransactionSignature>;
     settlePNLs(users: {
         settleeUserAccountPublicKey: PublicKey;
         settleeUserAccount: UserAccount;

package/lib/driftClient.js

@@ -366,11 +366,16 @@ class DriftClient {
     }
     async updateUserMarginTradingEnabled(marginTradingEnabled, subAccountId = 0) {
         const userAccountPublicKey = pda_1.getUserAccountPublicKeySync(this.program.programId, this.wallet.publicKey, subAccountId);
+        await this.addUser(subAccountId);
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [this.getUserAccount(subAccountId)],
+        });
         const tx = await this.program.transaction.updateUserMarginTradingEnabled(subAccountId, marginTradingEnabled, {
             accounts: {
                 user: userAccountPublicKey,
                 authority: this.wallet.publicKey,
             },
+            remainingAccounts,
         });
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
@@ -1745,6 +1750,7 @@ class DriftClient {
     }
     /**
      * Modifies an open order by closing it and replacing it with a new order.
+     * @deprecated use modifyOrder instead
      * @param orderId: The open order to modify
      * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
      * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
@@ -1791,8 +1797,68 @@ class DriftClient {
         this.perpMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
         return txSig;
     }
+    /**
+     * Modifies an open order (spot or perp) by closing it and replacing it with a new order.
+     * @param orderId: The open order to modify
+     * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newOraclePriceOffset: The new oracle price offset for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newOrderType: Optional - New order type for the order.
+     * @param newTriggerPrice: Optional - Thew new trigger price for the order.
+     * @param isSpot: Optional - Set to true if the order is a spot order
+     * @returns
+     */
+    async modifyOrder({ orderId, newBaseAmount, newLimitPrice, newOraclePriceOffset, newOrderType, newTriggerPrice, isSpot, }) {
+        if (!newBaseAmount && !newLimitPrice && !newOraclePriceOffset) {
+            throw new Error(`Must provide newBaseAmount or newLimitPrice or newOraclePriceOffset to modify order`);
+        }
+        const openOrder = this.getUser().getOrder(orderId);
+        if (!openOrder) {
+            throw new Error(`No open order with id ${orderId.toString()}`);
+        }
+        const cancelOrderIx = await this.getCancelOrderIx(orderId);
+        const newOrderParams = {
+            orderType: newOrderType || openOrder.orderType,
+            marketType: openOrder.marketType,
+            direction: openOrder.direction,
+            baseAssetAmount: newBaseAmount || openOrder.baseAssetAmount,
+            price: newLimitPrice || openOrder.price,
+            marketIndex: openOrder.marketIndex,
+            reduceOnly: openOrder.reduceOnly,
+            postOnly: openOrder.postOnly,
+            immediateOrCancel: openOrder.immediateOrCancel,
+            triggerPrice: newTriggerPrice || openOrder.triggerPrice,
+            triggerCondition: openOrder.triggerCondition,
+            oraclePriceOffset: newOraclePriceOffset || openOrder.oraclePriceOffset,
+            auctionDuration: openOrder.auctionDuration,
+            maxTs: openOrder.maxTs,
+            auctionStartPrice: openOrder.auctionStartPrice,
+            auctionEndPrice: openOrder.auctionEndPrice,
+            userOrderId: openOrder.userOrderId,
+        };
+        const placeOrderIx = isSpot
+            ? await this.getPlaceSpotOrderIx(newOrderParams)
+            : await this.getPlacePerpOrderIx(newOrderParams);
+        const tx = new web3_js_1.Transaction();
+        tx.add(web3_js_1.ComputeBudgetProgram.requestUnits({
+            units: 1000000,
+            additionalFee: 0,
+        }));
+        tx.add(cancelOrderIx);
+        tx.add(placeOrderIx);
+        const { txSig, slot } = await this.sendTransaction(tx, [], this.opts);
+        if (isSpot) {
+            this.spotMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
+            this.spotMarketLastSlotCache.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, slot);
+        }
+        else {
+            this.perpMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
+        }
+        return txSig;
+    }
     /**
      * Modifies an open order by closing it and replacing it with a new order.
+     * @deprecated use modifyOrderByUserOrderId instead
      * @param userOrderId: The open order to modify
      * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
      * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
@@ -1839,6 +1905,65 @@ class DriftClient {
         this.perpMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
         return txSig;
     }
+    /**
+     * Modifies an open order by closing it and replacing it with a new order.
+     * @param userOrderId: The open order to modify
+     * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newOraclePriceOffset: The new oracle price offset for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+     * @param newOrderType: Optional - New order type for the order.
+     * @param newTriggerPrice: Optional - Thew new trigger price for the order.
+     * @param isSpot: Set to true if the order is a spot order
+     * @returns
+     */
+    async modifyOrderByUserOrderId({ userOrderId, newBaseAmount, newLimitPrice, newOraclePriceOffset, newOrderType, newTriggerPrice, isSpot, }) {
+        if (!newBaseAmount && !newLimitPrice && !newOraclePriceOffset) {
+            throw new Error(`Must provide newBaseAmount or newLimitPrice or newOraclePriceOffset to modify order`);
+        }
+        const openOrder = this.getUser().getOrderByUserOrderId(userOrderId);
+        if (!openOrder) {
+            throw new Error(`No open order with user order id ${userOrderId.toString()}`);
+        }
+        const cancelOrderIx = await this.getCancelOrderByUserIdIx(userOrderId);
+        const newOrderParams = {
+            orderType: newOrderType || openOrder.orderType,
+            marketType: openOrder.marketType,
+            direction: openOrder.direction,
+            baseAssetAmount: newBaseAmount || openOrder.baseAssetAmount,
+            price: newLimitPrice || openOrder.price,
+            marketIndex: openOrder.marketIndex,
+            reduceOnly: openOrder.reduceOnly,
+            postOnly: openOrder.postOnly,
+            immediateOrCancel: openOrder.immediateOrCancel,
+            triggerPrice: newTriggerPrice || openOrder.triggerPrice,
+            triggerCondition: openOrder.triggerCondition,
+            oraclePriceOffset: newOraclePriceOffset || openOrder.oraclePriceOffset,
+            auctionDuration: openOrder.auctionDuration,
+            maxTs: openOrder.maxTs,
+            auctionStartPrice: openOrder.auctionStartPrice,
+            auctionEndPrice: openOrder.auctionEndPrice,
+            userOrderId: openOrder.userOrderId,
+        };
+        const placeOrderIx = isSpot
+            ? await this.getPlaceSpotOrderIx(newOrderParams)
+            : await this.getPlacePerpOrderIx(newOrderParams);
+        const tx = new web3_js_1.Transaction();
+        tx.add(web3_js_1.ComputeBudgetProgram.requestUnits({
+            units: 1000000,
+            additionalFee: 0,
+        }));
+        tx.add(cancelOrderIx);
+        tx.add(placeOrderIx);
+        const { txSig, slot } = await this.sendTransaction(tx, [], this.opts);
+        if (isSpot) {
+            this.spotMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
+            this.spotMarketLastSlotCache.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, slot);
+        }
+        else {
+            this.perpMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
+        }
+        return txSig;
+    }
     async settlePNLs(users, marketIndex) {
         const ixs = [];
         for (const { settleeUserAccountPublicKey, settleeUserAccount } of users) {

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.16.0-beta.0",
+    "version": "2.16.0-beta.3",
     "name": "drift",
     "instructions": [
         {
@@ -8569,6 +8569,11 @@
             "code": 6225,
             "name": "InvalidOracleForSettlePnl",
             "msg": "InvalidOracleForSettlePnl"
+        },
+        {
+            "code": 6226,
+            "name": "MarginOrdersOpen",
+            "msg": "MarginOrdersOpen"
         }
     ]
 }

package/lib/math/margin.js

@@ -12,9 +12,7 @@ imfFactor, liabilityWeight, precision) {
         return liabilityWeight;
     }
     const sizeSqrt = utils_1.squareRootBN(size.abs().mul(new anchor_1.BN(10)).add(new anchor_1.BN(1))); //1e9 -> 1e10 -> 1e5
-    const denom0 = anchor_1.BN.max(new anchor_1.BN(1), numericConstants_1.SPOT_MARKET_IMF_PRECISION.div(imfFactor));
-    assert_1.assert(denom0.gt(numericConstants_1.ZERO));
-    const liabilityWeightNumerator = liabilityWeight.sub(liabilityWeight.div(anchor_1.BN.max(new anchor_1.BN(1), numericConstants_1.SPOT_MARKET_IMF_PRECISION.div(imfFactor))));
+    const liabilityWeightNumerator = liabilityWeight.sub(liabilityWeight.div(new anchor_1.BN(5)));
     const denom = new anchor_1.BN(100000).mul(numericConstants_1.SPOT_MARKET_IMF_PRECISION).div(precision);
     assert_1.assert(denom.gt(numericConstants_1.ZERO));
     const sizePremiumLiabilityWeight = liabilityWeightNumerator.add(sizeSqrt // 1e5

package/lib/math/spotBalance.js

@@ -201,9 +201,11 @@ function calculateWithdrawLimit(spotMarket, now) {
         .add(marketDepositTokenAmount.mul(sinceLast))
         .div(sinceLast.add(sinceStart));
     const maxBorrowTokens = anchor_1.BN.max(spotMarket.withdrawGuardThreshold, anchor_1.BN.min(anchor_1.BN.max(marketDepositTokenAmount.div(new anchor_1.BN(6)), borrowTokenTwapLive.add(borrowTokenTwapLive.div(new anchor_1.BN(5)))), marketDepositTokenAmount.sub(marketDepositTokenAmount.div(new anchor_1.BN(5))))); // between ~15-80% utilization with friction on twap
-    const minDepositTokens = depositTokenTwapLive.sub(anchor_1.BN.min(anchor_1.BN.max(depositTokenTwapLive.div(new anchor_1.BN(5)), spotMarket.withdrawGuardThreshold), depositTokenTwapLive));
+    const minDepositTokens = depositTokenTwapLive.sub(anchor_1.BN.max(depositTokenTwapLive.div(new anchor_1.BN(5)), anchor_1.BN.min(spotMarket.withdrawGuardThreshold, depositTokenTwapLive)));
     let withdrawLimit = anchor_1.BN.max(marketDepositTokenAmount.sub(minDepositTokens), numericConstants_1.ZERO);
-    let borrowLimit = anchor_1.BN.max(maxBorrowTokens.sub(marketBorrowTokenAmount), numericConstants_1.ZERO);
+    let borrowLimit = maxBorrowTokens.sub(marketBorrowTokenAmount);
+    borrowLimit = anchor_1.BN.min(borrowLimit, marketDepositTokenAmount.sub(minDepositTokens));
+    borrowLimit = anchor_1.BN.min(borrowLimit, marketDepositTokenAmount.sub(marketBorrowTokenAmount));
     if (borrowLimit.eq(numericConstants_1.ZERO)) {
         withdrawLimit = numericConstants_1.ZERO;
     }

package/lib/math/utils.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="bn.js" />
 import { BN } from '../';
 export declare function clampBN(x: BN, min: BN, max: BN): BN;
-export declare const squareRootBN: (n: any, closeness?: BN) => BN;
+export declare const squareRootBN: (n: BN) => BN;

package/lib/math/utils.js

@@ -6,28 +6,20 @@ function clampBN(x, min, max) {
     return __1.BN.max(min, __1.BN.min(x, max));
 }
 exports.clampBN = clampBN;
-const squareRootBN = (n, closeness = new __1.BN(1)) => {
-    if (n.lt(__1.ZERO)) {
-        throw new Error('square root of negative number');
+const squareRootBN = (n) => {
+    if (n.lt(new __1.BN(0))) {
+        throw new Error('Sqrt only works on non-negtiave inputs');
     }
-    // Assuming the sqrt of n as n only
-    let x = n;
-    // The closed guess will be stored in the root
-    let root;
-    // To count the number of iterations
-    let count = 0;
-    const TWO = new __1.BN(2);
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    while (count < Number.MAX_SAFE_INTEGER) {
-        count++;
-        // Calculate more closed x
-        root = x.add(n.div(x)).div(TWO);
-        // Check for closeness
-        if (x.sub(root).abs().lte(closeness))
-            break;
-        // Update root
-        x = root;
+    if (n.lt(new __1.BN(2))) {
+        return n;
+    }
+    const smallCand = exports.squareRootBN(n.shrn(2)).shln(1);
+    const largeCand = smallCand.add(new __1.BN(1));
+    if (largeCand.mul(largeCand).gt(n)) {
+        return smallCand;
+    }
+    else {
+        return largeCand;
     }
-    return root;
 };
 exports.squareRootBN = squareRootBN;

package/package.json

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

package/src/dlob/DLOB.ts

@@ -521,6 +521,15 @@ export class DLOB {
 			marketOrderGenerator,
 			this.getMakerLimitBids.bind(this),
 			(takerPrice, makerPrice) => {
+				if (isVariant(marketType, 'spot')) {
+					if (takerPrice === undefined) {
+						return false;
+					}
+
+					if (fallbackBid && makerPrice.lt(fallbackBid)) {
+						return false;
+					}
+				}
 				return takerPrice === undefined || takerPrice.lte(makerPrice);
 			},
 			fallbackAsk
@@ -557,8 +566,18 @@ export class DLOB {
 			oraclePriceData,
 			marketOrderGenerator,
 			this.getMakerLimitAsks.bind(this),
-			(takerPrice, fallbackPrice) => {
-				return takerPrice === undefined || takerPrice.gte(fallbackPrice);
+			(takerPrice, makerPrice) => {
+				if (isVariant(marketType, 'spot')) {
+					if (takerPrice === undefined) {
+						return false;
+					}
+
+					if (fallbackAsk && makerPrice.gt(fallbackAsk)) {
+						return false;
+					}
+				}
+
+				return takerPrice === undefined || takerPrice.gte(makerPrice);
 			},
 			fallbackBid
 		);

package/src/driftClient.ts

@@ -612,6 +612,12 @@ export class DriftClient {
 			this.wallet.publicKey,
 			subAccountId
 		);
+
+		await this.addUser(subAccountId);
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount(subAccountId)],
+		});
+
 		const tx = await this.program.transaction.updateUserMarginTradingEnabled(
 			subAccountId,
 			marginTradingEnabled,
@@ -620,6 +626,7 @@ export class DriftClient {
 					user: userAccountPublicKey,
 					authority: this.wallet.publicKey,
 				},
+				remainingAccounts,
 			}
 		);
 
@@ -3011,6 +3018,7 @@ export class DriftClient {
 
 	/**
 	 * Modifies an open order by closing it and replacing it with a new order.
+	 * @deprecated use modifyOrder instead
 	 * @param orderId: The open order to modify
 	 * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
 	 * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
@@ -3070,8 +3078,93 @@ export class DriftClient {
 		return txSig;
 	}
 
+	/**
+	 * Modifies an open order (spot or perp) by closing it and replacing it with a new order.
+	 * @param orderId: The open order to modify
+	 * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+	 * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+	 * @param newOraclePriceOffset: The new oracle price offset for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+	 * @param newOrderType: Optional - New order type for the order.
+	 * @param newTriggerPrice: Optional - Thew new trigger price for the order.
+	 * @param isSpot: Optional - Set to true if the order is a spot order
+	 * @returns
+	 */
+	public async modifyOrder({
+		orderId,
+		newBaseAmount,
+		newLimitPrice,
+		newOraclePriceOffset,
+		newOrderType,
+		newTriggerPrice,
+		isSpot,
+	}: {
+		orderId: number;
+		newBaseAmount?: BN;
+		newLimitPrice?: BN;
+		newOraclePriceOffset?: number;
+		newOrderType?: OrderType;
+		newTriggerPrice?: BN;
+		isSpot?: boolean;
+	}): Promise<TransactionSignature> {
+		if (!newBaseAmount && !newLimitPrice && !newOraclePriceOffset) {
+			throw new Error(
+				`Must provide newBaseAmount or newLimitPrice or newOraclePriceOffset to modify order`
+			);
+		}
+
+		const openOrder = this.getUser().getOrder(orderId);
+		if (!openOrder) {
+			throw new Error(`No open order with id ${orderId.toString()}`);
+		}
+		const cancelOrderIx = await this.getCancelOrderIx(orderId);
+
+		const newOrderParams: OptionalOrderParams = {
+			orderType: newOrderType || openOrder.orderType,
+			marketType: openOrder.marketType,
+			direction: openOrder.direction,
+			baseAssetAmount: newBaseAmount || openOrder.baseAssetAmount,
+			price: newLimitPrice || openOrder.price,
+			marketIndex: openOrder.marketIndex,
+			reduceOnly: openOrder.reduceOnly,
+			postOnly: openOrder.postOnly,
+			immediateOrCancel: openOrder.immediateOrCancel,
+			triggerPrice: newTriggerPrice || openOrder.triggerPrice,
+			triggerCondition: openOrder.triggerCondition,
+			oraclePriceOffset: newOraclePriceOffset || openOrder.oraclePriceOffset,
+			auctionDuration: openOrder.auctionDuration,
+			maxTs: openOrder.maxTs,
+			auctionStartPrice: openOrder.auctionStartPrice,
+			auctionEndPrice: openOrder.auctionEndPrice,
+			userOrderId: openOrder.userOrderId,
+		};
+		const placeOrderIx = isSpot
+			? await this.getPlaceSpotOrderIx(newOrderParams)
+			: await this.getPlacePerpOrderIx(newOrderParams);
+
+		const tx = new Transaction();
+		tx.add(
+			ComputeBudgetProgram.requestUnits({
+				units: 1_000_000,
+				additionalFee: 0,
+			})
+		);
+		tx.add(cancelOrderIx);
+		tx.add(placeOrderIx);
+		const { txSig, slot } = await this.sendTransaction(tx, [], this.opts);
+
+		if (isSpot) {
+			this.spotMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
+			this.spotMarketLastSlotCache.set(QUOTE_SPOT_MARKET_INDEX, slot);
+		} else {
+			this.perpMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
+		}
+
+		return txSig;
+	}
+
 	/**
 	 * Modifies an open order by closing it and replacing it with a new order.
+	 * @deprecated use modifyOrderByUserOrderId instead
 	 * @param userOrderId: The open order to modify
 	 * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
 	 * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
@@ -3133,6 +3226,92 @@ export class DriftClient {
 		return txSig;
 	}
 
+	/**
+	 * Modifies an open order by closing it and replacing it with a new order.
+	 * @param userOrderId: The open order to modify
+	 * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+	 * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+	 * @param newOraclePriceOffset: The new oracle price offset for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
+	 * @param newOrderType: Optional - New order type for the order.
+	 * @param newTriggerPrice: Optional - Thew new trigger price for the order.
+	 * @param isSpot: Set to true if the order is a spot order
+	 * @returns
+	 */
+	public async modifyOrderByUserOrderId({
+		userOrderId,
+		newBaseAmount,
+		newLimitPrice,
+		newOraclePriceOffset,
+		newOrderType,
+		newTriggerPrice,
+		isSpot,
+	}: {
+		userOrderId: number;
+		newBaseAmount?: BN;
+		newLimitPrice?: BN;
+		newOraclePriceOffset?: number;
+		newOrderType?: OrderType;
+		newTriggerPrice?: BN;
+		isSpot?: boolean;
+	}): Promise<TransactionSignature> {
+		if (!newBaseAmount && !newLimitPrice && !newOraclePriceOffset) {
+			throw new Error(
+				`Must provide newBaseAmount or newLimitPrice or newOraclePriceOffset to modify order`
+			);
+		}
+
+		const openOrder = this.getUser().getOrderByUserOrderId(userOrderId);
+		if (!openOrder) {
+			throw new Error(
+				`No open order with user order id ${userOrderId.toString()}`
+			);
+		}
+		const cancelOrderIx = await this.getCancelOrderByUserIdIx(userOrderId);
+
+		const newOrderParams: OptionalOrderParams = {
+			orderType: newOrderType || openOrder.orderType,
+			marketType: openOrder.marketType,
+			direction: openOrder.direction,
+			baseAssetAmount: newBaseAmount || openOrder.baseAssetAmount,
+			price: newLimitPrice || openOrder.price,
+			marketIndex: openOrder.marketIndex,
+			reduceOnly: openOrder.reduceOnly,
+			postOnly: openOrder.postOnly,
+			immediateOrCancel: openOrder.immediateOrCancel,
+			triggerPrice: newTriggerPrice || openOrder.triggerPrice,
+			triggerCondition: openOrder.triggerCondition,
+			oraclePriceOffset: newOraclePriceOffset || openOrder.oraclePriceOffset,
+			auctionDuration: openOrder.auctionDuration,
+			maxTs: openOrder.maxTs,
+			auctionStartPrice: openOrder.auctionStartPrice,
+			auctionEndPrice: openOrder.auctionEndPrice,
+			userOrderId: openOrder.userOrderId,
+		};
+		const placeOrderIx = isSpot
+			? await this.getPlaceSpotOrderIx(newOrderParams)
+			: await this.getPlacePerpOrderIx(newOrderParams);
+
+		const tx = new Transaction();
+		tx.add(
+			ComputeBudgetProgram.requestUnits({
+				units: 1_000_000,
+				additionalFee: 0,
+			})
+		);
+		tx.add(cancelOrderIx);
+		tx.add(placeOrderIx);
+		const { txSig, slot } = await this.sendTransaction(tx, [], this.opts);
+
+		if (isSpot) {
+			this.spotMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
+			this.spotMarketLastSlotCache.set(QUOTE_SPOT_MARKET_INDEX, slot);
+		} else {
+			this.perpMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
+		}
+
+		return txSig;
+	}
+
 	public async settlePNLs(
 		users: {
 			settleeUserAccountPublicKey: PublicKey;

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.16.0-beta.0",
+  "version": "2.16.0-beta.3",
   "name": "drift",
   "instructions": [
     {
@@ -8569,6 +8569,11 @@
       "code": 6225,
       "name": "InvalidOracleForSettlePnl",
       "msg": "InvalidOracleForSettlePnl"
+    },
+    {
+      "code": 6226,
+      "name": "MarginOrdersOpen",
+      "msg": "MarginOrdersOpen"
     }
   ]
 }

package/src/math/margin.ts

@@ -24,12 +24,8 @@ export function calculateSizePremiumLiabilityWeight(
 
 	const sizeSqrt = squareRootBN(size.abs().mul(new BN(10)).add(new BN(1))); //1e9 -> 1e10 -> 1e5
 
-	const denom0 = BN.max(new BN(1), SPOT_MARKET_IMF_PRECISION.div(imfFactor));
-	assert(denom0.gt(ZERO));
 	const liabilityWeightNumerator = liabilityWeight.sub(
-		liabilityWeight.div(
-			BN.max(new BN(1), SPOT_MARKET_IMF_PRECISION.div(imfFactor))
-		)
+		liabilityWeight.div(new BN(5))
 	);
 
 	const denom = new BN(100_000).mul(SPOT_MARKET_IMF_PRECISION).div(precision);

package/src/math/spotBalance.ts

@@ -338,12 +338,9 @@ export function calculateWithdrawLimit(
 	); // between ~15-80% utilization with friction on twap
 
 	const minDepositTokens = depositTokenTwapLive.sub(
-		BN.min(
-			BN.max(
-				depositTokenTwapLive.div(new BN(5)),
-				spotMarket.withdrawGuardThreshold
-			),
-			depositTokenTwapLive
+		BN.max(
+			depositTokenTwapLive.div(new BN(5)),
+			BN.min(spotMarket.withdrawGuardThreshold, depositTokenTwapLive)
 		)
 	);
 
@@ -352,7 +349,15 @@ export function calculateWithdrawLimit(
 		ZERO
 	);
 
-	let borrowLimit = BN.max(maxBorrowTokens.sub(marketBorrowTokenAmount), ZERO);
+	let borrowLimit = maxBorrowTokens.sub(marketBorrowTokenAmount);
+	borrowLimit = BN.min(
+		borrowLimit,
+		marketDepositTokenAmount.sub(minDepositTokens)
+	);
+	borrowLimit = BN.min(
+		borrowLimit,
+		marketDepositTokenAmount.sub(marketBorrowTokenAmount)
+	);
 
 	if (borrowLimit.eq(ZERO)) {
 		withdrawLimit = ZERO;

package/src/math/utils.ts

@@ -1,37 +1,23 @@
-import { BN, ZERO } from '../';
+import { BN } from '../';
 
 export function clampBN(x: BN, min: BN, max: BN): BN {
 	return BN.max(min, BN.min(x, max));
 }
 
-export const squareRootBN = (n, closeness = new BN(1)): BN => {
-	if (n.lt(ZERO)) {
-		throw new Error('square root of negative number');
+export const squareRootBN = (n: BN): BN => {
+	if (n.lt(new BN(0))) {
+		throw new Error('Sqrt only works on non-negtiave inputs');
+	}
+	if (n.lt(new BN(2))) {
+		return n;
 	}
 
-	// Assuming the sqrt of n as n only
-	let x = n;
-
-	// The closed guess will be stored in the root
-	let root;
-
-	// To count the number of iterations
-	let count = 0;
-	const TWO = new BN(2);
-
-	// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-	while (count < Number.MAX_SAFE_INTEGER) {
-		count++;
-
-		// Calculate more closed x
-		root = x.add(n.div(x)).div(TWO);
-
-		// Check for closeness
-		if (x.sub(root).abs().lte(closeness)) break;
+	const smallCand = squareRootBN(n.shrn(2)).shln(1);
+	const largeCand = smallCand.add(new BN(1));
 
-		// Update root
-		x = root;
+	if (largeCand.mul(largeCand).gt(n)) {
+		return smallCand;
+	} else {
+		return largeCand;
 	}
-
-	return root;
 };

package/tests/dlob/test.ts

@@ -4266,8 +4266,8 @@ describe('DLOB Spot Tests', () => {
 	});
 
 	it('Test two market orders to fill one limit order', () => {
-		const vAsk = new BN(15);
-		const vBid = new BN(8);
+		const fallbackAsk = new BN(15);
+		const fallbackBid = new BN(8);
 
 		const user0 = Keypair.generate();
 		const user1 = Keypair.generate();
@@ -4280,7 +4280,7 @@ describe('DLOB Spot Tests', () => {
 
 		const slot = 12;
 		const oracle = {
-			price: vBid.add(vAsk).div(new BN(2)),
+			price: fallbackBid.add(fallbackAsk).div(new BN(2)),
 			slot: new BN(slot),
 			confidence: new BN(1),
 			hasSufficientNumberOfDataPoints: true,
@@ -4297,8 +4297,8 @@ describe('DLOB Spot Tests', () => {
 			new BN(14), // price
 			BASE_PRECISION, // quantity
 			PositionDirection.SHORT,
-			vBid,
-			vAsk,
+			fallbackBid,
+			fallbackAsk,
 			undefined,
 			undefined,
 			undefined,
@@ -4314,8 +4314,8 @@ describe('DLOB Spot Tests', () => {
 			new BN(13), // price
 			BASE_PRECISION, // quantity
 			PositionDirection.SHORT,
-			vBid,
-			vAsk,
+			fallbackBid,
+			fallbackAsk,
 			undefined,
 			undefined,
 			undefined,
@@ -4331,8 +4331,8 @@ describe('DLOB Spot Tests', () => {
 			new BN(8), // price <-- best price
 			new BN(3).mul(BASE_PRECISION), // quantity
 			PositionDirection.SHORT,
-			vBid,
-			vAsk,
+			fallbackBid,
+			fallbackAsk,
 			undefined,
 			undefined,
 			undefined,
@@ -4361,11 +4361,11 @@ describe('DLOB Spot Tests', () => {
 			MarketType.SPOT,
 			4, // orderId
 			marketIndex,
-			new BN(0), // price
+			fallbackAsk, // price
 			new BN(1).mul(BASE_PRECISION), // quantity
 			PositionDirection.LONG,
-			vBid,
-			vAsk
+			fallbackBid,
+			fallbackAsk
 		);
 		insertOrderToDLOB(
 			dlob,
@@ -4374,11 +4374,11 @@ describe('DLOB Spot Tests', () => {
 			MarketType.SPOT,
 			5, // orderId
 			marketIndex,
-			new BN(0), // price
+			fallbackAsk, // price
 			new BN(2).mul(BASE_PRECISION), // quantity
 			PositionDirection.LONG,
-			vBid,
-			vAsk
+			fallbackBid,
+			fallbackAsk
 		);
 
 		const nodesToFillAfter = dlob.findNodesToFill(
@@ -4399,7 +4399,7 @@ describe('DLOB Spot Tests', () => {
 		);
 		console.log(`market nodes: ${mktNodes.length}`);
 
-		printBookState(dlob, marketIndex, vBid, vAsk, slot, oracle);
+		printBookState(dlob, marketIndex, fallbackBid, fallbackAsk, slot, oracle);
 
 		for (const n of nodesToFillAfter) {
 			console.log(