@drift-labs/sdk 2.37.1-beta.2 → 2.37.1-beta.4

package/VERSION

@@ -1 +1 @@
-2.37.1-beta.2
+2.37.1-beta.4

package/lib/events/eventSubscriber.js

@@ -101,7 +101,7 @@ class EventSubscriber {
         const records = [];
         // @ts-ignore
         const events = (0, parse_1.parseLogs)(this.program, slot, logs);
-        let runningEventIndex = 0;
+        let _runningEventIndex = 0;
         for (const event of events) {
             // @ts-ignore
             const expectRecordType = this.eventListMap.has(event.name);
@@ -109,10 +109,10 @@ class EventSubscriber {
                 event.data.txSig = txSig;
                 event.data.slot = slot;
                 event.data.eventType = event.name;
-                event.data.txSigIndex = runningEventIndex;
+                //event.data.txSigIndex = _runningEventIndex;
                 records.push(event.data);
             }
-            runningEventIndex++;
+            _runningEventIndex++;
         }
         return records;
     }

package/lib/events/fetchLogs.js

@@ -83,14 +83,14 @@ class LogParser {
         const records = [];
         // @ts-ignore
         const eventGenerator = this.program._events._eventParser.parseLogs(event.logs, false);
-        let runningEventIndex = 0;
+        let _runningEventIndex = 0;
         for (const eventLog of eventGenerator) {
             eventLog.data.txSig = event.txSig;
             eventLog.data.slot = event.slot;
             eventLog.data.eventType = eventLog.name;
-            eventLog.data.txSigIndex = runningEventIndex;
+            //eventLog.data.txSigIndex = _runningEventIndex;
             records.push(eventLog.data);
-            runningEventIndex++;
+            _runningEventIndex++;
         }
         return records;
     }

package/lib/events/types.d.ts

@@ -17,7 +17,6 @@ export type EventSubscriptionOrderDirection = 'asc' | 'desc';
 export type Event<T> = T & {
     txSig: TransactionSignature;
     slot: number;
-    txSigIndex: number;
 };
 export type WrappedEvent<Type extends EventType> = EventMap[Type] & {
     eventType: Type;

package/lib/math/auction.js

@@ -64,7 +64,7 @@ function getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice) {
     const deltaDenominator = new _1.BN(order.auctionDuration);
     const deltaNumerator = _1.BN.min(slotsElapsed, deltaDenominator);
     if (deltaDenominator.eq(_1.ZERO)) {
-        return order.auctionEndPrice.add(order.auctionEndPrice);
+        return oraclePrice.add(order.auctionEndPrice);
     }
     let priceOffsetDelta;
     if ((0, types_1.isVariant)(order.direction, 'long')) {

package/lib/types.d.ts

@@ -50,6 +50,9 @@ export declare class UserStatus {
     static readonly BANKRUPT: {
         bankrupt: {};
     };
+    static readonly REDUCE_ONLY: {
+        reduceOnly: {};
+    };
 }
 export declare class ContractType {
     static readonly PERPETUAL: {

package/lib/types.js

@@ -33,6 +33,7 @@ exports.UserStatus = UserStatus;
 UserStatus.ACTIVE = { active: {} };
 UserStatus.BEING_LIQUIDATED = { beingLiquidated: {} };
 UserStatus.BANKRUPT = { bankrupt: {} };
+UserStatus.REDUCE_ONLY = { reduceOnly: {} };
 class ContractType {
 }
 exports.ContractType = ContractType;

package/lib/user.d.ts

@@ -153,6 +153,12 @@ export declare class User {
      * @returns : number (value from [0, 100])
      */
     getHealth(): number;
+    calculateWeightedPerpPositionValue(perpPosition: PerpPosition, marginCategory?: MarginCategory, liquidationBuffer?: BN, includeOpenOrders?: boolean, strict?: boolean): BN;
+    /**
+     * calculates position value of a single perp market in margin system
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getPerpMarketLiabilityValue(marketIndex: number, marginCategory?: MarginCategory, liquidationBuffer?: BN, includeOpenOrders?: boolean, strict?: boolean): BN;
     /**
      * calculates sum of position value across all positions in margin system
      * @returns : Precision QUOTE_PRECISION

package/lib/user.js

@@ -660,64 +660,81 @@ class User {
         }
         return health;
     }
+    calculateWeightedPerpPositionValue(perpPosition, marginCategory, liquidationBuffer, includeOpenOrders, strict = false) {
+        const market = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
+        if (perpPosition.lpShares.gt(numericConstants_1.ZERO)) {
+            // is an lp, clone so we dont mutate the position
+            perpPosition = this.getPerpPositionWithLPSettle(market.marketIndex, this.getClonedPosition(perpPosition), !!marginCategory)[0];
+        }
+        let valuationPrice = this.getOracleDataForPerpMarket(market.marketIndex).price;
+        if ((0, types_1.isVariant)(market.status, 'settlement')) {
+            valuationPrice = market.expiryPrice;
+        }
+        const baseAssetAmount = includeOpenOrders
+            ? (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition)
+            : perpPosition.baseAssetAmount;
+        let baseAssetValue = baseAssetAmount
+            .abs()
+            .mul(valuationPrice)
+            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.PRICE_PRECISION));
+        if (marginCategory) {
+            let marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, baseAssetAmount.abs(), marginCategory));
+            if (marginCategory === 'Initial') {
+                marginRatio = _1.BN.max(marginRatio, new _1.BN(this.getUserAccount().maxMarginRatio));
+            }
+            if (liquidationBuffer !== undefined) {
+                marginRatio = marginRatio.add(liquidationBuffer);
+            }
+            if ((0, types_1.isVariant)(market.status, 'settlement')) {
+                marginRatio = numericConstants_1.ZERO;
+            }
+            const quoteSpotMarket = this.driftClient.getSpotMarketAccount(market.quoteSpotMarketIndex);
+            const quoteOraclePriceData = this.driftClient.getOraclePriceDataAndSlot(quoteSpotMarket.oracle).data;
+            let quotePrice;
+            if (strict) {
+                quotePrice = _1.BN.max(quoteOraclePriceData.price, quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min);
+            }
+            else {
+                quotePrice = quoteOraclePriceData.price;
+            }
+            baseAssetValue = baseAssetValue
+                .mul(quotePrice)
+                .div(numericConstants_1.PRICE_PRECISION)
+                .mul(marginRatio)
+                .div(numericConstants_1.MARGIN_PRECISION);
+            if (includeOpenOrders) {
+                baseAssetValue = baseAssetValue.add(new _1.BN(perpPosition.openOrders).mul(numericConstants_1.OPEN_ORDER_MARGIN_REQUIREMENT));
+                if (perpPosition.lpShares.gt(numericConstants_1.ZERO)) {
+                    baseAssetValue = baseAssetValue.add(_1.BN.max(numericConstants_1.QUOTE_PRECISION, valuationPrice
+                        .mul(market.amm.orderStepSize)
+                        .mul(numericConstants_1.QUOTE_PRECISION)
+                        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+                        .div(numericConstants_1.PRICE_PRECISION)));
+                }
+            }
+        }
+        return baseAssetValue;
+    }
+    /**
+     * calculates position value of a single perp market in margin system
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getPerpMarketLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders, strict = false) {
+        const perpPosition = this.getPerpPosition(marketIndex);
+        if (!perpPosition) {
+            return numericConstants_1.ZERO;
+        }
+        else {
+            return this.calculateWeightedPerpPositionValue(perpPosition, marginCategory, liquidationBuffer, includeOpenOrders, strict);
+        }
+    }
     /**
      * calculates sum of position value across all positions in margin system
      * @returns : Precision QUOTE_PRECISION
      */
     getTotalPerpPositionValue(marginCategory, liquidationBuffer, includeOpenOrders, strict = false) {
         return this.getActivePerpPositions().reduce((totalPerpValue, perpPosition) => {
-            const market = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
-            if (perpPosition.lpShares.gt(numericConstants_1.ZERO)) {
-                // is an lp, clone so we dont mutate the position
-                perpPosition = this.getPerpPositionWithLPSettle(market.marketIndex, this.getClonedPosition(perpPosition), !!marginCategory)[0];
-            }
-            let valuationPrice = this.getOracleDataForPerpMarket(market.marketIndex).price;
-            if ((0, types_1.isVariant)(market.status, 'settlement')) {
-                valuationPrice = market.expiryPrice;
-            }
-            const baseAssetAmount = includeOpenOrders
-                ? (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition)
-                : perpPosition.baseAssetAmount;
-            let baseAssetValue = baseAssetAmount
-                .abs()
-                .mul(valuationPrice)
-                .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.PRICE_PRECISION));
-            if (marginCategory) {
-                let marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, baseAssetAmount.abs(), marginCategory));
-                if (marginCategory === 'Initial') {
-                    marginRatio = _1.BN.max(marginRatio, new _1.BN(this.getUserAccount().maxMarginRatio));
-                }
-                if (liquidationBuffer !== undefined) {
-                    marginRatio = marginRatio.add(liquidationBuffer);
-                }
-                if ((0, types_1.isVariant)(market.status, 'settlement')) {
-                    marginRatio = numericConstants_1.ZERO;
-                }
-                const quoteSpotMarket = this.driftClient.getSpotMarketAccount(market.quoteSpotMarketIndex);
-                const quoteOraclePriceData = this.driftClient.getOraclePriceDataAndSlot(quoteSpotMarket.oracle).data;
-                let quotePrice;
-                if (strict) {
-                    quotePrice = _1.BN.max(quoteOraclePriceData.price, quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min);
-                }
-                else {
-                    quotePrice = quoteOraclePriceData.price;
-                }
-                baseAssetValue = baseAssetValue
-                    .mul(quotePrice)
-                    .div(numericConstants_1.PRICE_PRECISION)
-                    .mul(marginRatio)
-                    .div(numericConstants_1.MARGIN_PRECISION);
-                if (includeOpenOrders) {
-                    baseAssetValue = baseAssetValue.add(new _1.BN(perpPosition.openOrders).mul(numericConstants_1.OPEN_ORDER_MARGIN_REQUIREMENT));
-                    if (perpPosition.lpShares.gt(numericConstants_1.ZERO)) {
-                        baseAssetValue = baseAssetValue.add(_1.BN.max(numericConstants_1.QUOTE_PRECISION, valuationPrice
-                            .mul(market.amm.orderStepSize)
-                            .mul(numericConstants_1.QUOTE_PRECISION)
-                            .div(numericConstants_1.AMM_RESERVE_PRECISION)
-                            .div(numericConstants_1.PRICE_PRECISION)));
-                    }
-                }
-            }
+            const baseAssetValue = this.calculateWeightedPerpPositionValue(perpPosition, marginCategory, liquidationBuffer, includeOpenOrders, strict);
             return totalPerpValue.add(baseAssetValue);
         }, numericConstants_1.ZERO);
     }

package/package.json

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

package/src/events/eventSubscriber.ts

@@ -168,7 +168,7 @@ export class EventSubscriber {
 		const records = [];
 		// @ts-ignore
 		const events = parseLogs(this.program, slot, logs);
-		let runningEventIndex = 0;
+		let _runningEventIndex = 0;
 		for (const event of events) {
 			// @ts-ignore
 			const expectRecordType = this.eventListMap.has(event.name);
@@ -176,10 +176,10 @@ export class EventSubscriber {
 				event.data.txSig = txSig;
 				event.data.slot = slot;
 				event.data.eventType = event.name;
-				event.data.txSigIndex = runningEventIndex;
+				//event.data.txSigIndex = _runningEventIndex;
 				records.push(event.data);
 			}
-			runningEventIndex++;
+			_runningEventIndex++;
 		}
 		return records;
 	}

package/src/events/fetchLogs.ts

@@ -155,14 +155,14 @@ export class LogParser {
 			event.logs,
 			false
 		);
-		let runningEventIndex = 0;
+		let _runningEventIndex = 0;
 		for (const eventLog of eventGenerator) {
 			eventLog.data.txSig = event.txSig;
 			eventLog.data.slot = event.slot;
 			eventLog.data.eventType = eventLog.name;
-			eventLog.data.txSigIndex = runningEventIndex;
+			//eventLog.data.txSigIndex = _runningEventIndex;
 			records.push(eventLog.data);
-			runningEventIndex++;
+			_runningEventIndex++;
 		}
 		return records;
 	}

package/src/events/types.ts

@@ -64,7 +64,7 @@ export type EventSubscriptionOrderDirection = 'asc' | 'desc';
 export type Event<T> = T & {
 	txSig: TransactionSignature;
 	slot: number;
-	txSigIndex: number; // Unique index for each event inside a tx
+	//txSigIndex: number; // Unique index for each event inside a tx
 };
 
 export type WrappedEvent<Type extends EventType> = EventMap[Type] & {

package/src/math/auction.ts

@@ -79,7 +79,7 @@ export function getAuctionPriceForOracleOffsetAuction(
 	const deltaNumerator = BN.min(slotsElapsed, deltaDenominator);
 
 	if (deltaDenominator.eq(ZERO)) {
-		return order.auctionEndPrice.add(order.auctionEndPrice);
+		return oraclePrice.add(order.auctionEndPrice);
 	}
 
 	let priceOffsetDelta;

package/src/types.ts

@@ -31,6 +31,7 @@ export class UserStatus {
 	static readonly ACTIVE = { active: {} };
 	static readonly BEING_LIQUIDATED = { beingLiquidated: {} };
 	static readonly BANKRUPT = { bankrupt: {} };
+	static readonly REDUCE_ONLY = { reduceOnly: {} };
 }
 
 export class ContractType {

package/src/user.ts

@@ -1196,116 +1196,157 @@ export class User {
 		return health;
 	}
 
-	/**
-	 * calculates sum of position value across all positions in margin system
-	 * @returns : Precision QUOTE_PRECISION
-	 */
-	getTotalPerpPositionValue(
+	calculateWeightedPerpPositionValue(
+		perpPosition: PerpPosition,
 		marginCategory?: MarginCategory,
 		liquidationBuffer?: BN,
 		includeOpenOrders?: boolean,
 		strict = false
 	): BN {
-		return this.getActivePerpPositions().reduce(
-			(totalPerpValue, perpPosition) => {
-				const market = this.driftClient.getPerpMarketAccount(
-					perpPosition.marketIndex
-				);
+		const market = this.driftClient.getPerpMarketAccount(
+			perpPosition.marketIndex
+		);
 
-				if (perpPosition.lpShares.gt(ZERO)) {
-					// is an lp, clone so we dont mutate the position
-					perpPosition = this.getPerpPositionWithLPSettle(
-						market.marketIndex,
-						this.getClonedPosition(perpPosition),
-						!!marginCategory
-					)[0];
-				}
+		if (perpPosition.lpShares.gt(ZERO)) {
+			// is an lp, clone so we dont mutate the position
+			perpPosition = this.getPerpPositionWithLPSettle(
+				market.marketIndex,
+				this.getClonedPosition(perpPosition),
+				!!marginCategory
+			)[0];
+		}
 
-				let valuationPrice = this.getOracleDataForPerpMarket(
-					market.marketIndex
-				).price;
+		let valuationPrice = this.getOracleDataForPerpMarket(
+			market.marketIndex
+		).price;
 
-				if (isVariant(market.status, 'settlement')) {
-					valuationPrice = market.expiryPrice;
-				}
+		if (isVariant(market.status, 'settlement')) {
+			valuationPrice = market.expiryPrice;
+		}
 
-				const baseAssetAmount = includeOpenOrders
-					? calculateWorstCaseBaseAssetAmount(perpPosition)
-					: perpPosition.baseAssetAmount;
+		const baseAssetAmount = includeOpenOrders
+			? calculateWorstCaseBaseAssetAmount(perpPosition)
+			: perpPosition.baseAssetAmount;
 
-				let baseAssetValue = baseAssetAmount
-					.abs()
-					.mul(valuationPrice)
-					.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(PRICE_PRECISION));
-
-				if (marginCategory) {
-					let marginRatio = new BN(
-						calculateMarketMarginRatio(
-							market,
-							baseAssetAmount.abs(),
-							marginCategory
-						)
-					);
+		let baseAssetValue = baseAssetAmount
+			.abs()
+			.mul(valuationPrice)
+			.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(PRICE_PRECISION));
 
-					if (marginCategory === 'Initial') {
-						marginRatio = BN.max(
-							marginRatio,
-							new BN(this.getUserAccount().maxMarginRatio)
-						);
-					}
+		if (marginCategory) {
+			let marginRatio = new BN(
+				calculateMarketMarginRatio(
+					market,
+					baseAssetAmount.abs(),
+					marginCategory
+				)
+			);
 
-					if (liquidationBuffer !== undefined) {
-						marginRatio = marginRatio.add(liquidationBuffer);
-					}
+			if (marginCategory === 'Initial') {
+				marginRatio = BN.max(
+					marginRatio,
+					new BN(this.getUserAccount().maxMarginRatio)
+				);
+			}
 
-					if (isVariant(market.status, 'settlement')) {
-						marginRatio = ZERO;
-					}
+			if (liquidationBuffer !== undefined) {
+				marginRatio = marginRatio.add(liquidationBuffer);
+			}
 
-					const quoteSpotMarket = this.driftClient.getSpotMarketAccount(
-						market.quoteSpotMarketIndex
-					);
-					const quoteOraclePriceData =
-						this.driftClient.getOraclePriceDataAndSlot(
-							quoteSpotMarket.oracle
-						).data;
-
-					let quotePrice;
-					if (strict) {
-						quotePrice = BN.max(
-							quoteOraclePriceData.price,
-							quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min
-						);
-					} else {
-						quotePrice = quoteOraclePriceData.price;
-					}
+			if (isVariant(market.status, 'settlement')) {
+				marginRatio = ZERO;
+			}
+
+			const quoteSpotMarket = this.driftClient.getSpotMarketAccount(
+				market.quoteSpotMarketIndex
+			);
+			const quoteOraclePriceData = this.driftClient.getOraclePriceDataAndSlot(
+				quoteSpotMarket.oracle
+			).data;
+
+			let quotePrice;
+			if (strict) {
+				quotePrice = BN.max(
+					quoteOraclePriceData.price,
+					quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min
+				);
+			} else {
+				quotePrice = quoteOraclePriceData.price;
+			}
 
-					baseAssetValue = baseAssetValue
-						.mul(quotePrice)
-						.div(PRICE_PRECISION)
-						.mul(marginRatio)
-						.div(MARGIN_PRECISION);
+			baseAssetValue = baseAssetValue
+				.mul(quotePrice)
+				.div(PRICE_PRECISION)
+				.mul(marginRatio)
+				.div(MARGIN_PRECISION);
 
-					if (includeOpenOrders) {
-						baseAssetValue = baseAssetValue.add(
-							new BN(perpPosition.openOrders).mul(OPEN_ORDER_MARGIN_REQUIREMENT)
-						);
+			if (includeOpenOrders) {
+				baseAssetValue = baseAssetValue.add(
+					new BN(perpPosition.openOrders).mul(OPEN_ORDER_MARGIN_REQUIREMENT)
+				);
 
-						if (perpPosition.lpShares.gt(ZERO)) {
-							baseAssetValue = baseAssetValue.add(
-								BN.max(
-									QUOTE_PRECISION,
-									valuationPrice
-										.mul(market.amm.orderStepSize)
-										.mul(QUOTE_PRECISION)
-										.div(AMM_RESERVE_PRECISION)
-										.div(PRICE_PRECISION)
-								)
-							);
-						}
-					}
+				if (perpPosition.lpShares.gt(ZERO)) {
+					baseAssetValue = baseAssetValue.add(
+						BN.max(
+							QUOTE_PRECISION,
+							valuationPrice
+								.mul(market.amm.orderStepSize)
+								.mul(QUOTE_PRECISION)
+								.div(AMM_RESERVE_PRECISION)
+								.div(PRICE_PRECISION)
+						)
+					);
 				}
+			}
+		}
+
+		return baseAssetValue;
+	}
 
+	/**
+	 * calculates position value of a single perp market in margin system
+	 * @returns : Precision QUOTE_PRECISION
+	 */
+	public getPerpMarketLiabilityValue(
+		marketIndex: number,
+		marginCategory?: MarginCategory,
+		liquidationBuffer?: BN,
+		includeOpenOrders?: boolean,
+		strict = false
+	): BN {
+		const perpPosition = this.getPerpPosition(marketIndex);
+		if (!perpPosition) {
+			return ZERO;
+		} else {
+			return this.calculateWeightedPerpPositionValue(
+				perpPosition,
+				marginCategory,
+				liquidationBuffer,
+				includeOpenOrders,
+				strict
+			);
+		}
+	}
+
+	/**
+	 * calculates sum of position value across all positions in margin system
+	 * @returns : Precision QUOTE_PRECISION
+	 */
+	getTotalPerpPositionValue(
+		marginCategory?: MarginCategory,
+		liquidationBuffer?: BN,
+		includeOpenOrders?: boolean,
+		strict = false
+	): BN {
+		return this.getActivePerpPositions().reduce(
+			(totalPerpValue, perpPosition) => {
+				const baseAssetValue = this.calculateWeightedPerpPositionValue(
+					perpPosition,
+					marginCategory,
+					liquidationBuffer,
+					includeOpenOrders,
+					strict
+				);
 				return totalPerpValue.add(baseAssetValue);
 			},
 			ZERO