@drift-labs/sdk 2.43.0-beta.16 → 2.43.0-beta.18

package/VERSION

@@ -1 +1 @@
-2.43.0-beta.16
+2.43.0-beta.18

package/lib/adminClient.d.ts

@@ -33,6 +33,7 @@ export declare class AdminClient extends DriftClient {
     updateSpotFeeStructure(feeStructure: FeeStructure): Promise<TransactionSignature>;
     updateInitialPctToLiquidate(initialPctToLiquidate: number): Promise<TransactionSignature>;
     updateLiquidationDuration(liquidationDuration: number): Promise<TransactionSignature>;
+    updateLiquidationMarginBufferRatio(updateLiquidationMarginBufferRatio: number): Promise<TransactionSignature>;
     updateOracleGuardRails(oracleGuardRails: OracleGuardRails): Promise<TransactionSignature>;
     updateStateSettlementDuration(settlementDuration: number): Promise<TransactionSignature>;
     updateWithdrawGuardThreshold(spotMarketIndex: number, withdrawGuardThreshold: BN): Promise<TransactionSignature>;

package/lib/adminClient.js

@@ -421,6 +421,14 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
+    async updateLiquidationMarginBufferRatio(updateLiquidationMarginBufferRatio) {
+        return await this.program.rpc.updateLiquidationMarginBufferRatio(updateLiquidationMarginBufferRatio, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+            },
+        });
+    }
     async updateOracleGuardRails(oracleGuardRails) {
         const tx = await this.program.transaction.updateOracleGuardRails(oracleGuardRails, {
             accounts: {

package/lib/dlob/DLOB.d.ts

@@ -87,10 +87,16 @@ export declare class DLOB {
         takerNode: DLOBNode;
         makerNode: DLOBNode;
     } | undefined;
-    getBestAsk(marketIndex: number, fallbackAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
-    getBestBid(marketIndex: number, fallbackBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
+    getBestAsk(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
+    getBestBid(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): BN;
+    getStopLosses(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
+    getStopLossMarkets(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
+    getStopLossLimits(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
+    getTakeProfits(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
+    getTakeProfitMarkets(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
+    getTakeProfitLimits(marketIndex: number, marketType: MarketType, direction: PositionDirection): Generator<DLOBNode>;
     findNodesToTrigger(marketIndex: number, slot: number, oraclePrice: BN, marketType: MarketType, stateAccount: StateAccount): NodeToTrigger[];
-    printTopOfOrderLists(sdkConfig: any, driftClient: DriftClient, slotSubscriber: SlotSubscriber, marketIndex: number, marketType: MarketType): void;
+    printTop(driftClient: DriftClient, slotSubscriber: SlotSubscriber, marketIndex: number, marketType: MarketType): void;
     getDLOBOrders(): DLOBOrders;
     getNodeLists(): Generator<NodeList<DLOBNodeType>>;
     /**

package/lib/dlob/DLOB.js

@@ -796,16 +796,80 @@ class DLOB {
             };
         }
     }
-    getBestAsk(marketIndex, fallbackAsk, slot, marketType, oraclePriceData) {
-        return this.getAsks(marketIndex, fallbackAsk, slot, marketType, oraclePriceData)
+    getBestAsk(marketIndex, slot, marketType, oraclePriceData) {
+        return this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData)
             .next()
             .value.getPrice(oraclePriceData, slot);
     }
-    getBestBid(marketIndex, fallbackBid, slot, marketType, oraclePriceData) {
-        return this.getBids(marketIndex, fallbackBid, slot, marketType, oraclePriceData)
+    getBestBid(marketIndex, slot, marketType, oraclePriceData) {
+        return this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData)
             .next()
             .value.getPrice(oraclePriceData, slot);
     }
+    *getStopLosses(marketIndex, marketType, direction) {
+        const marketTypeStr = (0, __1.getVariant)(marketType);
+        const marketNodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        if ((0, __1.isVariant)(direction, 'long') && marketNodeLists.trigger.below) {
+            for (const node of marketNodeLists.trigger.below.getGenerator()) {
+                if ((0, __1.isVariant)(node.order.direction, 'short')) {
+                    yield node;
+                }
+            }
+        }
+        else if ((0, __1.isVariant)(direction, 'short') && marketNodeLists.trigger.above) {
+            for (const node of marketNodeLists.trigger.above.getGenerator()) {
+                if ((0, __1.isVariant)(node.order.direction, 'long')) {
+                    yield node;
+                }
+            }
+        }
+    }
+    *getStopLossMarkets(marketIndex, marketType, direction) {
+        for (const node of this.getStopLosses(marketIndex, marketType, direction)) {
+            if ((0, __1.isVariant)(node.order.orderType, 'triggerMarket')) {
+                yield node;
+            }
+        }
+    }
+    *getStopLossLimits(marketIndex, marketType, direction) {
+        for (const node of this.getStopLosses(marketIndex, marketType, direction)) {
+            if ((0, __1.isVariant)(node.order.orderType, 'triggerLimit')) {
+                yield node;
+            }
+        }
+    }
+    *getTakeProfits(marketIndex, marketType, direction) {
+        const marketTypeStr = (0, __1.getVariant)(marketType);
+        const marketNodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+        if ((0, __1.isVariant)(direction, 'long') && marketNodeLists.trigger.above) {
+            for (const node of marketNodeLists.trigger.above.getGenerator()) {
+                if ((0, __1.isVariant)(node.order.direction, 'short')) {
+                    yield node;
+                }
+            }
+        }
+        else if ((0, __1.isVariant)(direction, 'short') && marketNodeLists.trigger.below) {
+            for (const node of marketNodeLists.trigger.below.getGenerator()) {
+                if ((0, __1.isVariant)(node.order.direction, 'long')) {
+                    yield node;
+                }
+            }
+        }
+    }
+    *getTakeProfitMarkets(marketIndex, marketType, direction) {
+        for (const node of this.getTakeProfits(marketIndex, marketType, direction)) {
+            if ((0, __1.isVariant)(node.order.orderType, 'triggerMarket')) {
+                yield node;
+            }
+        }
+    }
+    *getTakeProfitLimits(marketIndex, marketType, direction) {
+        for (const node of this.getTakeProfits(marketIndex, marketType, direction)) {
+            if ((0, __1.isVariant)(node.order.orderType, 'triggerLimit')) {
+                yield node;
+            }
+        }
+    }
     findNodesToTrigger(marketIndex, slot, oraclePrice, marketType, stateAccount) {
         if ((0, exchangeStatus_1.exchangePaused)(stateAccount)) {
             return [];
@@ -845,15 +909,12 @@ class DLOB {
         }
         return nodesToTrigger;
     }
-    printTopOfOrderLists(sdkConfig, driftClient, slotSubscriber, marketIndex, marketType) {
+    printTop(driftClient, slotSubscriber, marketIndex, marketType) {
         if ((0, __1.isVariant)(marketType, 'perp')) {
-            const market = driftClient.getPerpMarketAccount(marketIndex);
             const slot = slotSubscriber.getSlot();
             const oraclePriceData = driftClient.getOracleDataForPerpMarket(marketIndex);
-            const fallbackAsk = (0, __1.calculateAskPrice)(market, oraclePriceData);
-            const fallbackBid = (0, __1.calculateBidPrice)(market, oraclePriceData);
-            const bestAsk = this.getBestAsk(marketIndex, fallbackAsk, slot, marketType, oraclePriceData);
-            const bestBid = this.getBestBid(marketIndex, fallbackBid, slot, marketType, oraclePriceData);
+            const bestAsk = this.getBestAsk(marketIndex, slot, marketType, oraclePriceData);
+            const bestBid = this.getBestBid(marketIndex, slot, marketType, oraclePriceData);
             const mid = bestAsk.add(bestBid).div(new __1.BN(2));
             const bidSpread = ((0, __1.convertToNumber)(bestBid, __1.PRICE_PRECISION) /
                 (0, __1.convertToNumber)(oraclePriceData.price, __1.PRICE_PRECISION) -
@@ -863,7 +924,8 @@ class DLOB {
                 (0, __1.convertToNumber)(oraclePriceData.price, __1.PRICE_PRECISION) -
                 1) *
                 100.0;
-            console.log(`Market ${sdkConfig.MARKETS[marketIndex].symbol} Orders`);
+            const name = (0, __1.decodeName)(driftClient.getPerpMarketAccount(marketIndex).name);
+            console.log(`Market ${name} Orders`);
             console.log(`  Ask`, (0, __1.convertToNumber)(bestAsk, __1.PRICE_PRECISION).toFixed(3), `(${askSpread.toFixed(4)}%)`);
             console.log(`  Mid`, (0, __1.convertToNumber)(mid, __1.PRICE_PRECISION).toFixed(3));
             console.log(`  Bid`, (0, __1.convertToNumber)(bestBid, __1.PRICE_PRECISION).toFixed(3), `(${bidSpread.toFixed(4)}%)`);
@@ -871,8 +933,8 @@ class DLOB {
         else if ((0, __1.isVariant)(marketType, 'spot')) {
             const slot = slotSubscriber.getSlot();
             const oraclePriceData = driftClient.getOracleDataForPerpMarket(marketIndex);
-            const bestAsk = this.getBestAsk(marketIndex, undefined, slot, marketType, oraclePriceData);
-            const bestBid = this.getBestBid(marketIndex, undefined, slot, marketType, oraclePriceData);
+            const bestAsk = this.getBestAsk(marketIndex, slot, marketType, oraclePriceData);
+            const bestBid = this.getBestBid(marketIndex, slot, marketType, oraclePriceData);
             const mid = bestAsk.add(bestBid).div(new __1.BN(2));
             const bidSpread = ((0, __1.convertToNumber)(bestBid, __1.PRICE_PRECISION) /
                 (0, __1.convertToNumber)(oraclePriceData.price, __1.PRICE_PRECISION) -
@@ -882,7 +944,8 @@ class DLOB {
                 (0, __1.convertToNumber)(oraclePriceData.price, __1.PRICE_PRECISION) -
                 1) *
                 100.0;
-            console.log(`Market ${sdkConfig.MARKETS[marketIndex].symbol} Orders`);
+            const name = (0, __1.decodeName)(driftClient.getSpotMarketAccount(marketIndex).name);
+            console.log(`Market ${name} Orders`);
             console.log(`  Ask`, (0, __1.convertToNumber)(bestAsk, __1.PRICE_PRECISION).toFixed(3), `(${askSpread.toFixed(4)}%)`);
             console.log(`  Mid`, (0, __1.convertToNumber)(mid, __1.PRICE_PRECISION).toFixed(3));
             console.log(`  Bid`, (0, __1.convertToNumber)(bestBid, __1.PRICE_PRECISION).toFixed(3), `(${bidSpread.toFixed(4)}%)`);

package/lib/idl/drift.json

@@ -4098,6 +4098,27 @@
                 }
             ]
         },
+        {
+            "name": "updateLiquidationMarginBufferRatio",
+            "accounts": [
+                {
+                    "name": "admin",
+                    "isMut": false,
+                    "isSigner": true
+                },
+                {
+                    "name": "state",
+                    "isMut": true,
+                    "isSigner": false
+                }
+            ],
+            "args": [
+                {
+                    "name": "liquidationMarginBufferRatio",
+                    "type": "u32"
+                }
+            ]
+        },
         {
             "name": "updateOracleGuardRails",
             "accounts": [

package/lib/math/amm.js

@@ -410,7 +410,8 @@ function calculateSpreadReserves(amm, oraclePriceData, now) {
                 quoteAssetReserve: amm.quoteAssetReserve,
             };
         }
-        const quoteAssetReserveDelta = amm.quoteAssetReserve.div(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(new anchor_1.BN(spread / 2)));
+        const spreadFraction = anchor_1.BN.max(new anchor_1.BN(spread / 2), numericConstants_1.ONE);
+        const quoteAssetReserveDelta = amm.quoteAssetReserve.div(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(spreadFraction));
         let quoteAssetReserve;
         if ((0, types_1.isVariant)(direction, 'long')) {
             quoteAssetReserve = amm.quoteAssetReserve.add(quoteAssetReserveDelta);

package/package.json

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

package/src/adminClient.ts

@@ -787,6 +787,20 @@ export class AdminClient extends DriftClient {
 		);
 	}
 
+	public async updateLiquidationMarginBufferRatio(
+		updateLiquidationMarginBufferRatio: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateLiquidationMarginBufferRatio(
+			updateLiquidationMarginBufferRatio,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+				},
+			}
+		);
+	}
+
 	public async updateOracleGuardRails(
 		oracleGuardRails: OracleGuardRails
 	): Promise<TransactionSignature> {

package/src/dlob/DLOB.ts

@@ -2,9 +2,8 @@ import { getOrderSignature, getVammNodeGenerator, NodeList } from './NodeList';
 import {
 	BASE_PRECISION,
 	BN,
-	calculateAskPrice,
-	calculateBidPrice,
 	convertToNumber,
+	decodeName,
 	DLOBNode,
 	DLOBNodeType,
 	DriftClient,
@@ -1430,14 +1429,12 @@ export class DLOB {
 
 	public getBestAsk(
 		marketIndex: number,
-		fallbackAsk: BN | undefined,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData
 	): BN {
-		return this.getAsks(
+		return this.getRestingLimitAsks(
 			marketIndex,
-			fallbackAsk,
 			slot,
 			marketType,
 			oraclePriceData
@@ -1448,14 +1445,12 @@ export class DLOB {
 
 	public getBestBid(
 		marketIndex: number,
-		fallbackBid: BN | undefined,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData
 	): BN {
-		return this.getBids(
+		return this.getRestingLimitBids(
 			marketIndex,
-			fallbackBid,
 			slot,
 			marketType,
 			oraclePriceData
@@ -1464,6 +1459,108 @@ export class DLOB {
 			.value.getPrice(oraclePriceData, slot);
 	}
 
+	public *getStopLosses(
+		marketIndex: number,
+		marketType: MarketType,
+		direction: PositionDirection
+	): Generator<DLOBNode> {
+		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
+		const marketNodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+
+		if (isVariant(direction, 'long') && marketNodeLists.trigger.below) {
+			for (const node of marketNodeLists.trigger.below.getGenerator()) {
+				if (isVariant(node.order.direction, 'short')) {
+					yield node;
+				}
+			}
+		} else if (isVariant(direction, 'short') && marketNodeLists.trigger.above) {
+			for (const node of marketNodeLists.trigger.above.getGenerator()) {
+				if (isVariant(node.order.direction, 'long')) {
+					yield node;
+				}
+			}
+		}
+	}
+
+	public *getStopLossMarkets(
+		marketIndex: number,
+		marketType: MarketType,
+		direction: PositionDirection
+	): Generator<DLOBNode> {
+		for (const node of this.getStopLosses(marketIndex, marketType, direction)) {
+			if (isVariant(node.order.orderType, 'triggerMarket')) {
+				yield node;
+			}
+		}
+	}
+
+	public *getStopLossLimits(
+		marketIndex: number,
+		marketType: MarketType,
+		direction: PositionDirection
+	): Generator<DLOBNode> {
+		for (const node of this.getStopLosses(marketIndex, marketType, direction)) {
+			if (isVariant(node.order.orderType, 'triggerLimit')) {
+				yield node;
+			}
+		}
+	}
+
+	public *getTakeProfits(
+		marketIndex: number,
+		marketType: MarketType,
+		direction: PositionDirection
+	): Generator<DLOBNode> {
+		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
+		const marketNodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+
+		if (isVariant(direction, 'long') && marketNodeLists.trigger.above) {
+			for (const node of marketNodeLists.trigger.above.getGenerator()) {
+				if (isVariant(node.order.direction, 'short')) {
+					yield node;
+				}
+			}
+		} else if (isVariant(direction, 'short') && marketNodeLists.trigger.below) {
+			for (const node of marketNodeLists.trigger.below.getGenerator()) {
+				if (isVariant(node.order.direction, 'long')) {
+					yield node;
+				}
+			}
+		}
+	}
+
+	public *getTakeProfitMarkets(
+		marketIndex: number,
+		marketType: MarketType,
+		direction: PositionDirection
+	): Generator<DLOBNode> {
+		for (const node of this.getTakeProfits(
+			marketIndex,
+			marketType,
+			direction
+		)) {
+			if (isVariant(node.order.orderType, 'triggerMarket')) {
+				yield node;
+			}
+		}
+	}
+
+	public *getTakeProfitLimits(
+		marketIndex: number,
+		marketType: MarketType,
+		direction: PositionDirection
+	): Generator<DLOBNode> {
+		for (const node of this.getTakeProfits(
+			marketIndex,
+			marketType,
+			direction
+		)) {
+			if (isVariant(node.order.orderType, 'triggerLimit')) {
+				yield node;
+			}
+		}
+	}
+
 	public findNodesToTrigger(
 		marketIndex: number,
 		slot: number,
@@ -1512,32 +1609,25 @@ export class DLOB {
 		return nodesToTrigger;
 	}
 
-	public printTopOfOrderLists(
-		sdkConfig: any,
+	public printTop(
 		driftClient: DriftClient,
 		slotSubscriber: SlotSubscriber,
 		marketIndex: number,
 		marketType: MarketType
 	) {
 		if (isVariant(marketType, 'perp')) {
-			const market = driftClient.getPerpMarketAccount(marketIndex);
-
 			const slot = slotSubscriber.getSlot();
 			const oraclePriceData =
 				driftClient.getOracleDataForPerpMarket(marketIndex);
-			const fallbackAsk = calculateAskPrice(market, oraclePriceData);
-			const fallbackBid = calculateBidPrice(market, oraclePriceData);
 
 			const bestAsk = this.getBestAsk(
 				marketIndex,
-				fallbackAsk,
 				slot,
 				marketType,
 				oraclePriceData
 			);
 			const bestBid = this.getBestBid(
 				marketIndex,
-				fallbackBid,
 				slot,
 				marketType,
 				oraclePriceData
@@ -1555,7 +1645,10 @@ export class DLOB {
 					1) *
 				100.0;
 
-			console.log(`Market ${sdkConfig.MARKETS[marketIndex].symbol} Orders`);
+			const name = decodeName(
+				driftClient.getPerpMarketAccount(marketIndex).name
+			);
+			console.log(`Market ${name} Orders`);
 			console.log(
 				`  Ask`,
 				convertToNumber(bestAsk, PRICE_PRECISION).toFixed(3),
@@ -1574,14 +1667,12 @@ export class DLOB {
 
 			const bestAsk = this.getBestAsk(
 				marketIndex,
-				undefined,
 				slot,
 				marketType,
 				oraclePriceData
 			);
 			const bestBid = this.getBestBid(
 				marketIndex,
-				undefined,
 				slot,
 				marketType,
 				oraclePriceData
@@ -1599,7 +1690,10 @@ export class DLOB {
 					1) *
 				100.0;
 
-			console.log(`Market ${sdkConfig.MARKETS[marketIndex].symbol} Orders`);
+			const name = decodeName(
+				driftClient.getSpotMarketAccount(marketIndex).name
+			);
+			console.log(`Market ${name} Orders`);
 			console.log(
 				`  Ask`,
 				convertToNumber(bestAsk, PRICE_PRECISION).toFixed(3),

package/src/idl/drift.json

@@ -4098,6 +4098,27 @@
         }
       ]
     },
+    {
+      "name": "updateLiquidationMarginBufferRatio",
+      "accounts": [
+        {
+          "name": "admin",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "state",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "liquidationMarginBufferRatio",
+          "type": "u32"
+        }
+      ]
+    },
     {
       "name": "updateOracleGuardRails",
       "accounts": [

package/src/math/amm.ts

@@ -760,9 +760,9 @@ export function calculateSpreadReserves(
 				quoteAssetReserve: amm.quoteAssetReserve,
 			};
 		}
-
+		const spreadFraction = BN.max(new BN(spread / 2), ONE);
 		const quoteAssetReserveDelta = amm.quoteAssetReserve.div(
-			BID_ASK_SPREAD_PRECISION.div(new BN(spread / 2))
+			BID_ASK_SPREAD_PRECISION.div(spreadFraction)
 		);
 
 		let quoteAssetReserve;