@drift-labs/sdk 2.35.1-beta.6 → 2.35.1-beta.8

package/VERSION

@@ -1 +1 @@
-2.35.1-beta.6
+2.35.1-beta.8

package/lib/dlob/DLOB.js

@@ -491,11 +491,21 @@ class DLOB {
         }
         // All bids/asks that can expire
         // dont try to expire limit orders with tif as its inefficient use of blockspace
-        const bidGenerators = [nodeLists.market.bid.getGenerator()];
-        const askGenerators = [nodeLists.market.ask.getGenerator()];
+        const bidGenerators = [
+            nodeLists.takingLimit.bid.getGenerator(),
+            nodeLists.restingLimit.bid.getGenerator(),
+            nodeLists.floatingLimit.bid.getGenerator(),
+            nodeLists.market.bid.getGenerator(),
+        ];
+        const askGenerators = [
+            nodeLists.takingLimit.ask.getGenerator(),
+            nodeLists.restingLimit.ask.getGenerator(),
+            nodeLists.floatingLimit.ask.getGenerator(),
+            nodeLists.market.ask.getGenerator(),
+        ];
         for (const bidGenerator of bidGenerators) {
             for (const bid of bidGenerator) {
-                if ((0, __1.isOrderExpired)(bid.order, ts)) {
+                if ((0, __1.isOrderExpired)(bid.order, ts, true)) {
                     nodesToFill.push({
                         node: bid,
                         makerNodes: [],
@@ -505,7 +515,7 @@ class DLOB {
         }
         for (const askGenerator of askGenerators) {
             for (const ask of askGenerator) {
-                if ((0, __1.isOrderExpired)(ask.order, ts)) {
+                if ((0, __1.isOrderExpired)(ask.order, ts, true)) {
                     nodesToFill.push({
                         node: ask,
                         makerNodes: [],

package/lib/math/orders.d.ts

@@ -13,7 +13,7 @@ export declare function hasAuctionPrice(order: Order, slot: number): boolean;
 export declare function isFillableByVAMM(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number, ts: number): boolean;
 export declare function calculateBaseAssetAmountForAmmToFulfill(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;
 export declare function calculateBaseAssetAmountToFillUpToLimitPrice(order: Order, amm: AMM, limitPrice: BN, oraclePriceData: OraclePriceData): BN;
-export declare function isOrderExpired(order: Order, ts: number): boolean;
+export declare function isOrderExpired(order: Order, ts: number, enforceBuffer?: boolean): boolean;
 export declare function isMarketOrder(order: Order): boolean;
 export declare function isLimitOrder(order: Order): boolean;
 export declare function mustBeTriggered(order: Order): boolean;

package/lib/math/orders.js

@@ -168,13 +168,20 @@ function isSameDirection(firstDirection, secondDirection) {
     return (((0, types_1.isVariant)(firstDirection, 'long') && (0, types_1.isVariant)(secondDirection, 'long')) ||
         ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
 }
-function isOrderExpired(order, ts) {
+function isOrderExpired(order, ts, enforceBuffer = false) {
     if (mustBeTriggered(order) ||
         !(0, types_1.isVariant)(order.status, 'open') ||
         order.maxTs.eq(numericConstants_1.ZERO)) {
         return false;
     }
-    return new anchor_1.BN(ts).gt(order.maxTs);
+    let maxTs;
+    if (enforceBuffer && isLimitOrder(order)) {
+        maxTs = order.maxTs.addn(15);
+    }
+    else {
+        maxTs = order.maxTs;
+    }
+    return new anchor_1.BN(ts).gt(maxTs);
 }
 exports.isOrderExpired = isOrderExpired;
 function isMarketOrder(order) {

package/lib/user.d.ts

@@ -98,7 +98,7 @@ export declare class User {
      * calculates Buying Power = free collateral / initial margin ratio
      * @returns : Precision QUOTE_PRECISION
      */
-    getPerpBuyingPower(marketIndex: number): BN;
+    getPerpBuyingPower(marketIndex: number, collateralBuffer?: any): BN;
     getPerpBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex: number, freeCollateral: BN, baseAssetAmount: BN): BN;
     /**
      * calculates Free Collateral = Total collateral - initial margin requirement
@@ -191,10 +191,11 @@ export declare class User {
     /**
      * calculates max allowable leverage exceeding hitting requirement category
      * for large sizes where imf factor activates, result is a lower bound
-     * @params category {Initial, Maintenance}
+     * @param marginCategory {Initial, Maintenance}
+     * @param isLp if calculating max leveraging for adding lp, need to add buffer
      * @returns : Precision TEN_THOUSAND
      */
-    getMaxLeverageForPerp(perpMarketIndex: number, marginCategory?: MarginCategory): BN;
+    getMaxLeverageForPerp(perpMarketIndex: number, marginCategory?: MarginCategory, isLp?: boolean): BN;
     /**
      * calculates max allowable leverage exceeding hitting requirement category
      * @param spotMarketIndex
@@ -262,7 +263,7 @@ export declare class User {
      * @param tradeSide
      * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
      */
-    getMaxTradeSizeUSDCForPerp(targetMarketIndex: number, tradeSide: PositionDirection): BN;
+    getMaxTradeSizeUSDCForPerp(targetMarketIndex: number, tradeSide: PositionDirection, isLp?: boolean): BN;
     /**
      * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
      *

package/lib/user.js

@@ -363,12 +363,12 @@ class User {
      * calculates Buying Power = free collateral / initial margin ratio
      * @returns : Precision QUOTE_PRECISION
      */
-    getPerpBuyingPower(marketIndex) {
+    getPerpBuyingPower(marketIndex, collateralBuffer = numericConstants_1.ZERO) {
         const perpPosition = this.getPerpPositionWithLPSettle(marketIndex, undefined, true)[0];
         const worstCaseBaseAssetAmount = perpPosition
             ? (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition)
             : numericConstants_1.ZERO;
-        const freeCollateral = this.getFreeCollateral();
+        const freeCollateral = this.getFreeCollateral().sub(collateralBuffer);
         return this.getPerpBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex, freeCollateral, worstCaseBaseAssetAmount);
     }
     getPerpBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex, freeCollateral, baseAssetAmount) {
@@ -818,10 +818,11 @@ class User {
     /**
      * calculates max allowable leverage exceeding hitting requirement category
      * for large sizes where imf factor activates, result is a lower bound
-     * @params category {Initial, Maintenance}
+     * @param marginCategory {Initial, Maintenance}
+     * @param isLp if calculating max leveraging for adding lp, need to add buffer
      * @returns : Precision TEN_THOUSAND
      */
-    getMaxLeverageForPerp(perpMarketIndex, marginCategory = 'Initial') {
+    getMaxLeverageForPerp(perpMarketIndex, marginCategory = 'Initial', isLp = false) {
         const market = this.driftClient.getPerpMarketAccount(perpMarketIndex);
         const marketPrice = this.driftClient.getOracleDataForPerpMarket(perpMarketIndex).price;
         const { perpLiabilityValue, perpPnl, spotAssetValue, spotLiabilityValue } = this.getLeverageComponents();
@@ -831,7 +832,10 @@ class User {
             return numericConstants_1.ZERO;
         }
         const totalLiabilityValue = perpLiabilityValue.add(spotLiabilityValue);
-        const freeCollateral = this.getFreeCollateral();
+        const lpBuffer = isLp
+            ? marketPrice.mul(market.amm.orderStepSize).div(numericConstants_1.AMM_RESERVE_PRECISION)
+            : numericConstants_1.ZERO;
+        const freeCollateral = this.getFreeCollateral().sub(lpBuffer);
         let rawMarginRatio;
         switch (marginCategory) {
             case 'Initial':
@@ -1145,7 +1149,7 @@ class User {
      * @param tradeSide
      * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
      */
-    getMaxTradeSizeUSDCForPerp(targetMarketIndex, tradeSide) {
+    getMaxTradeSizeUSDCForPerp(targetMarketIndex, tradeSide, isLp = false) {
         const currentPosition = this.getPerpPositionWithLPSettle(targetMarketIndex, undefined, true)[0] ||
             this.getEmptyPosition(targetMarketIndex);
         const targetSide = (0, types_1.isVariant)(tradeSide, 'short') ? 'short' : 'long';
@@ -1156,11 +1160,17 @@ class User {
             ? true
             : targetSide === currentPositionSide;
         const oracleData = this.getOracleDataForPerpMarket(targetMarketIndex);
+        const marketAccount = this.driftClient.getPerpMarketAccount(targetMarketIndex);
+        const lpBuffer = isLp
+            ? oracleData.price
+                .mul(marketAccount.amm.orderStepSize)
+                .div(numericConstants_1.AMM_RESERVE_PRECISION)
+            : numericConstants_1.ZERO;
         // add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
         const oppositeSizeValueUSDC = targetingSameSide
             ? numericConstants_1.ZERO
             : this.getPerpPositionValue(targetMarketIndex, oracleData);
-        let maxPositionSize = this.getPerpBuyingPower(targetMarketIndex);
+        let maxPositionSize = this.getPerpBuyingPower(targetMarketIndex, lpBuffer);
         if (maxPositionSize.gte(numericConstants_1.ZERO)) {
             if (oppositeSizeValueUSDC.eq(numericConstants_1.ZERO)) {
                 // case 1 : Regular trade where current total position less than max, and no opposite position to account for

package/package.json

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

package/src/dlob/DLOB.ts

@@ -931,12 +931,22 @@ export class DLOB {
 
 		// All bids/asks that can expire
 		// dont try to expire limit orders with tif as its inefficient use of blockspace
-		const bidGenerators = [nodeLists.market.bid.getGenerator()];
-		const askGenerators = [nodeLists.market.ask.getGenerator()];
+		const bidGenerators = [
+			nodeLists.takingLimit.bid.getGenerator(),
+			nodeLists.restingLimit.bid.getGenerator(),
+			nodeLists.floatingLimit.bid.getGenerator(),
+			nodeLists.market.bid.getGenerator(),
+		];
+		const askGenerators = [
+			nodeLists.takingLimit.ask.getGenerator(),
+			nodeLists.restingLimit.ask.getGenerator(),
+			nodeLists.floatingLimit.ask.getGenerator(),
+			nodeLists.market.ask.getGenerator(),
+		];
 
 		for (const bidGenerator of bidGenerators) {
 			for (const bid of bidGenerator) {
-				if (isOrderExpired(bid.order, ts)) {
+				if (isOrderExpired(bid.order, ts, true)) {
 					nodesToFill.push({
 						node: bid,
 						makerNodes: [],
@@ -947,7 +957,7 @@ export class DLOB {
 
 		for (const askGenerator of askGenerators) {
 			for (const ask of askGenerator) {
-				if (isOrderExpired(ask.order, ts)) {
+				if (isOrderExpired(ask.order, ts, true)) {
 					nodesToFill.push({
 						node: ask,
 						makerNodes: [],

package/src/math/orders.ts

@@ -279,7 +279,11 @@ function isSameDirection(
 	);
 }
 
-export function isOrderExpired(order: Order, ts: number): boolean {
+export function isOrderExpired(
+	order: Order,
+	ts: number,
+	enforceBuffer = false
+): boolean {
 	if (
 		mustBeTriggered(order) ||
 		!isVariant(order.status, 'open') ||
@@ -288,7 +292,14 @@ export function isOrderExpired(order: Order, ts: number): boolean {
 		return false;
 	}
 
-	return new BN(ts).gt(order.maxTs);
+	let maxTs;
+	if (enforceBuffer && isLimitOrder(order)) {
+		maxTs = order.maxTs.addn(15);
+	} else {
+		maxTs = order.maxTs;
+	}
+
+	return new BN(ts).gt(maxTs);
 }
 
 export function isMarketOrder(order: Order): boolean {

package/src/user.ts

@@ -558,7 +558,7 @@ export class User {
 	 * calculates Buying Power = free collateral / initial margin ratio
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getPerpBuyingPower(marketIndex: number): BN {
+	public getPerpBuyingPower(marketIndex: number, collateralBuffer = ZERO): BN {
 		const perpPosition = this.getPerpPositionWithLPSettle(
 			marketIndex,
 			undefined,
@@ -568,7 +568,7 @@ export class User {
 			? calculateWorstCaseBaseAssetAmount(perpPosition)
 			: ZERO;
 
-		const freeCollateral = this.getFreeCollateral();
+		const freeCollateral = this.getFreeCollateral().sub(collateralBuffer);
 
 		return this.getPerpBuyingPowerFromFreeCollateralAndBaseAssetAmount(
 			marketIndex,
@@ -1490,12 +1490,14 @@ export class User {
 	/**
 	 * calculates max allowable leverage exceeding hitting requirement category
 	 * for large sizes where imf factor activates, result is a lower bound
-	 * @params category {Initial, Maintenance}
+	 * @param marginCategory {Initial, Maintenance}
+	 * @param isLp if calculating max leveraging for adding lp, need to add buffer
 	 * @returns : Precision TEN_THOUSAND
 	 */
 	public getMaxLeverageForPerp(
 		perpMarketIndex: number,
-		marginCategory: MarginCategory = 'Initial'
+		marginCategory: MarginCategory = 'Initial',
+		isLp = false
 	): BN {
 		const market = this.driftClient.getPerpMarketAccount(perpMarketIndex);
 		const marketPrice =
@@ -1514,7 +1516,11 @@ export class User {
 
 		const totalLiabilityValue = perpLiabilityValue.add(spotLiabilityValue);
 
-		const freeCollateral = this.getFreeCollateral();
+		const lpBuffer = isLp
+			? marketPrice.mul(market.amm.orderStepSize).div(AMM_RESERVE_PRECISION)
+			: ZERO;
+
+		const freeCollateral = this.getFreeCollateral().sub(lpBuffer);
 
 		let rawMarginRatio;
 
@@ -2059,7 +2065,8 @@ export class User {
 	 */
 	public getMaxTradeSizeUSDCForPerp(
 		targetMarketIndex: number,
-		tradeSide: PositionDirection
+		tradeSide: PositionDirection,
+		isLp = false
 	): BN {
 		const currentPosition =
 			this.getPerpPositionWithLPSettle(targetMarketIndex, undefined, true)[0] ||
@@ -2077,12 +2084,21 @@ export class User {
 
 		const oracleData = this.getOracleDataForPerpMarket(targetMarketIndex);
 
+		const marketAccount =
+			this.driftClient.getPerpMarketAccount(targetMarketIndex);
+
+		const lpBuffer = isLp
+			? oracleData.price
+					.mul(marketAccount.amm.orderStepSize)
+					.div(AMM_RESERVE_PRECISION)
+			: ZERO;
+
 		// add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
 		const oppositeSizeValueUSDC = targetingSameSide
 			? ZERO
 			: this.getPerpPositionValue(targetMarketIndex, oracleData);
 
-		let maxPositionSize = this.getPerpBuyingPower(targetMarketIndex);
+		let maxPositionSize = this.getPerpBuyingPower(targetMarketIndex, lpBuffer);
 		if (maxPositionSize.gte(ZERO)) {
 			if (oppositeSizeValueUSDC.eq(ZERO)) {
 				// case 1 : Regular trade where current total position less than max, and no opposite position to account for