@drift-labs/sdk 2.1.2 → 2.2.0-beta.1

package/lib/dlob/DLOB.js

@@ -4,6 +4,13 @@ exports.DLOB = void 0;
 const NodeList_1 = require("./NodeList");
 const __1 = require("..");
 const exchangeStatus_1 = require("../math/exchangeStatus");
+const SUPPORTED_ORDER_TYPES = [
+    'market',
+    'limit',
+    'triggerMarket',
+    'triggerLimit',
+    'oracle',
+];
 class DLOB {
     constructor() {
         this.openOrders = new Map();
@@ -118,6 +125,9 @@ class DLOB {
         if ((0, __1.isVariant)(order.status, 'init')) {
             return;
         }
+        if (!(0, __1.isOneOfVariant)(order.orderType, SUPPORTED_ORDER_TYPES)) {
+            return;
+        }
         const marketType = (0, __1.getVariant)(order.marketType);
         if (!this.orderLists.get(marketType).has(order.marketIndex)) {
             this.addOrderList(marketType, order.marketIndex);
@@ -200,7 +210,7 @@ class DLOB {
         if (isInactiveTriggerOrder) {
             type = 'trigger';
         }
-        else if ((0, __1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
+        else if ((0, __1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket', 'oracle'])) {
             type = 'market';
         }
         else if (order.oraclePriceOffset !== 0) {

package/lib/math/auction.d.ts

@@ -2,4 +2,6 @@
 import { Order } from '../types';
 import { BN } from '../.';
 export declare function isAuctionComplete(order: Order, slot: number): boolean;
-export declare function getAuctionPrice(order: Order, slot: number): BN;
+export declare function getAuctionPrice(order: Order, slot: number, oraclePrice: BN): BN;
+export declare function getAuctionPriceForFixedAuction(order: Order, slot: number): BN;
+export declare function getAuctionPriceForOracleOffsetAuction(order: Order, slot: number, oraclePrice: BN): BN;

package/lib/math/auction.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAuctionPrice = exports.isAuctionComplete = void 0;
+exports.getAuctionPriceForOracleOffsetAuction = exports.getAuctionPriceForFixedAuction = exports.getAuctionPrice = exports.isAuctionComplete = void 0;
 const types_1 = require("../types");
 const _1 = require("../.");
 function isAuctionComplete(order, slot) {
@@ -10,7 +10,19 @@ function isAuctionComplete(order, slot) {
     return new _1.BN(slot).sub(order.slot).gt(new _1.BN(order.auctionDuration));
 }
 exports.isAuctionComplete = isAuctionComplete;
-function getAuctionPrice(order, slot) {
+function getAuctionPrice(order, slot, oraclePrice) {
+    if ((0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
+        return getAuctionPriceForFixedAuction(order, slot);
+    }
+    else if ((0, types_1.isVariant)(order.orderType, 'oracle')) {
+        return getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice);
+    }
+    else {
+        throw Error(`Cant get auction price for order type ${order.orderType}`);
+    }
+}
+exports.getAuctionPrice = getAuctionPrice;
+function getAuctionPriceForFixedAuction(order, slot) {
     const slotsElapsed = new _1.BN(slot).sub(order.slot);
     const deltaDenominator = new _1.BN(order.auctionDuration);
     const deltaNumerator = _1.BN.min(slotsElapsed, deltaDenominator);
@@ -39,4 +51,34 @@ function getAuctionPrice(order, slot) {
     }
     return price;
 }
-exports.getAuctionPrice = getAuctionPrice;
+exports.getAuctionPriceForFixedAuction = getAuctionPriceForFixedAuction;
+function getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice) {
+    const slotsElapsed = new _1.BN(slot).sub(order.slot);
+    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);
+    }
+    let priceOffsetDelta;
+    if ((0, types_1.isVariant)(order.direction, 'long')) {
+        priceOffsetDelta = order.auctionEndPrice
+            .sub(order.auctionStartPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    else {
+        priceOffsetDelta = order.auctionStartPrice
+            .sub(order.auctionEndPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    let priceOffset;
+    if ((0, types_1.isVariant)(order.direction, 'long')) {
+        priceOffset = order.auctionStartPrice.add(priceOffsetDelta);
+    }
+    else {
+        priceOffset = order.auctionStartPrice.sub(priceOffsetDelta);
+    }
+    return oraclePrice.add(priceOffset);
+}
+exports.getAuctionPriceForOracleOffsetAuction = getAuctionPriceForOracleOffsetAuction;

package/lib/math/orders.d.ts

@@ -9,6 +9,7 @@ export declare function isOrderReduceOnly(user: User, order: Order): boolean;
 export declare function standardizeBaseAssetAmount(baseAssetAmount: BN, stepSize: BN): BN;
 export declare function getLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number, fallbackPrice?: BN): BN | undefined;
 export declare function hasLimitPrice(order: Order, slot: number): boolean;
+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;

package/lib/math/orders.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTriggered = exports.mustBeTriggered = exports.isLimitOrder = exports.isMarketOrder = exports.isOrderExpired = exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = exports.hasLimitPrice = exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
+exports.isTriggered = exports.mustBeTriggered = exports.isLimitOrder = exports.isMarketOrder = exports.isOrderExpired = exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = exports.hasAuctionPrice = exports.hasLimitPrice = exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
 const types_1 = require("../types");
 const numericConstants_1 = require("../constants/numericConstants");
 const anchor_1 = require("@project-serum/anchor");
@@ -81,19 +81,14 @@ function standardizeBaseAssetAmount(baseAssetAmount, stepSize) {
 exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
 function getLimitPrice(order, oraclePriceData, slot, fallbackPrice) {
     let limitPrice;
-    if (order.oraclePriceOffset !== 0) {
+    if (hasAuctionPrice(order, slot)) {
+        limitPrice = (0, auction_1.getAuctionPrice)(order, slot, oraclePriceData.price);
+    }
+    else if (order.oraclePriceOffset !== 0) {
         limitPrice = oraclePriceData.price.add(new anchor_1.BN(order.oraclePriceOffset));
     }
-    else if ((0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
-        if (!(0, auction_1.isAuctionComplete)(order, slot)) {
-            limitPrice = (0, auction_1.getAuctionPrice)(order, slot);
-        }
-        else if (!order.price.eq(numericConstants_1.ZERO)) {
-            limitPrice = order.price;
-        }
-        else {
-            limitPrice = fallbackPrice;
-        }
+    else if (order.price.eq(numericConstants_1.ZERO)) {
+        limitPrice = fallbackPrice;
     }
     else {
         limitPrice = order.price;
@@ -107,6 +102,10 @@ function hasLimitPrice(order, slot) {
         !(0, auction_1.isAuctionComplete)(order, slot));
 }
 exports.hasLimitPrice = hasLimitPrice;
+function hasAuctionPrice(order, slot) {
+    return isMarketOrder(order) && !(0, auction_1.isAuctionComplete)(order, slot);
+}
+exports.hasAuctionPrice = hasAuctionPrice;
 function isFillableByVAMM(order, market, oraclePriceData, slot, ts) {
     return (((0, auction_1.isAuctionComplete)(order, slot) &&
         !calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).eq(numericConstants_1.ZERO)) ||
@@ -149,7 +148,7 @@ function isSameDirection(firstDirection, secondDirection) {
         ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
 }
 function isOrderExpired(order, ts) {
-    if ((0, types_1.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']) ||
+    if (mustBeTriggered(order) ||
         !(0, types_1.isVariant)(order.status, 'open') ||
         order.maxTs.eq(numericConstants_1.ZERO)) {
         return false;
@@ -158,7 +157,7 @@ function isOrderExpired(order, ts) {
 }
 exports.isOrderExpired = isOrderExpired;
 function isMarketOrder(order) {
-    return (0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket']);
+    return (0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket', 'oracle']);
 }
 exports.isMarketOrder = isMarketOrder;
 function isLimitOrder(order) {

package/package.json

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

package/src/dlob/DLOB.ts

@@ -62,6 +62,14 @@ export type NodeToTrigger = {
 	node: TriggerOrderNode;
 };
 
+const SUPPORTED_ORDER_TYPES = [
+	'market',
+	'limit',
+	'triggerMarket',
+	'triggerLimit',
+	'oracle',
+];
+
 export class DLOB {
 	openOrders = new Map<MarketTypeStr, Set<string>>();
 	orderLists = new Map<MarketTypeStr, Map<number, MarketNodeLists>>();
@@ -204,6 +212,10 @@ export class DLOB {
 			return;
 		}
 
+		if (!isOneOfVariant(order.orderType, SUPPORTED_ORDER_TYPES)) {
+			return;
+		}
+
 		const marketType = getVariant(order.marketType) as MarketTypeStr;
 
 		if (!this.orderLists.get(marketType).has(order.marketIndex)) {
@@ -313,7 +325,9 @@ export class DLOB {
 		let type: DLOBNodeType;
 		if (isInactiveTriggerOrder) {
 			type = 'trigger';
-		} else if (isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
+		} else if (
+			isOneOfVariant(order.orderType, ['market', 'triggerMarket', 'oracle'])
+		) {
 			type = 'market';
 		} else if (order.oraclePriceOffset !== 0) {
 			type = 'floatingLimit';

package/src/math/auction.ts

@@ -1,4 +1,4 @@
-import { isVariant, Order } from '../types';
+import { isOneOfVariant, isVariant, Order } from '../types';
 import { BN, ZERO } from '../.';
 
 export function isAuctionComplete(order: Order, slot: number): boolean {
@@ -9,7 +9,21 @@ export function isAuctionComplete(order: Order, slot: number): boolean {
 	return new BN(slot).sub(order.slot).gt(new BN(order.auctionDuration));
 }
 
-export function getAuctionPrice(order: Order, slot: number): BN {
+export function getAuctionPrice(
+	order: Order,
+	slot: number,
+	oraclePrice: BN
+): BN {
+	if (isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
+		return getAuctionPriceForFixedAuction(order, slot);
+	} else if (isVariant(order.orderType, 'oracle')) {
+		return getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice);
+	} else {
+		throw Error(`Cant get auction price for order type ${order.orderType}`);
+	}
+}
+
+export function getAuctionPriceForFixedAuction(order: Order, slot: number): BN {
 	const slotsElapsed = new BN(slot).sub(order.slot);
 
 	const deltaDenominator = new BN(order.auctionDuration);
@@ -41,3 +55,40 @@ export function getAuctionPrice(order: Order, slot: number): BN {
 
 	return price;
 }
+
+export function getAuctionPriceForOracleOffsetAuction(
+	order: Order,
+	slot: number,
+	oraclePrice: BN
+): BN {
+	const slotsElapsed = new BN(slot).sub(order.slot);
+
+	const deltaDenominator = new BN(order.auctionDuration);
+	const deltaNumerator = BN.min(slotsElapsed, deltaDenominator);
+
+	if (deltaDenominator.eq(ZERO)) {
+		return order.auctionEndPrice.add(order.auctionEndPrice);
+	}
+
+	let priceOffsetDelta;
+	if (isVariant(order.direction, 'long')) {
+		priceOffsetDelta = order.auctionEndPrice
+			.sub(order.auctionStartPrice)
+			.mul(deltaNumerator)
+			.div(deltaDenominator);
+	} else {
+		priceOffsetDelta = order.auctionStartPrice
+			.sub(order.auctionEndPrice)
+			.mul(deltaNumerator)
+			.div(deltaDenominator);
+	}
+
+	let priceOffset;
+	if (isVariant(order.direction, 'long')) {
+		priceOffset = order.auctionStartPrice.add(priceOffsetDelta);
+	} else {
+		priceOffset = order.auctionStartPrice.sub(priceOffsetDelta);
+	}
+
+	return oraclePrice.add(priceOffset);
+}

package/src/math/orders.ts

@@ -131,16 +131,12 @@ export function getLimitPrice(
 	fallbackPrice?: BN
 ): BN | undefined {
 	let limitPrice;
-	if (order.oraclePriceOffset !== 0) {
+	if (hasAuctionPrice(order, slot)) {
+		limitPrice = getAuctionPrice(order, slot, oraclePriceData.price);
+	} else if (order.oraclePriceOffset !== 0) {
 		limitPrice = oraclePriceData.price.add(new BN(order.oraclePriceOffset));
-	} else if (isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
-		if (!isAuctionComplete(order, slot)) {
-			limitPrice = getAuctionPrice(order, slot);
-		} else if (!order.price.eq(ZERO)) {
-			limitPrice = order.price;
-		} else {
-			limitPrice = fallbackPrice;
-		}
+	} else if (order.price.eq(ZERO)) {
+		limitPrice = fallbackPrice;
 	} else {
 		limitPrice = order.price;
 	}
@@ -156,6 +152,10 @@ export function hasLimitPrice(order: Order, slot: number): boolean {
 	);
 }
 
+export function hasAuctionPrice(order: Order, slot: number): boolean {
+	return isMarketOrder(order) && !isAuctionComplete(order, slot);
+}
+
 export function isFillableByVAMM(
 	order: Order,
 	market: PerpMarketAccount,
@@ -252,7 +252,7 @@ function isSameDirection(
 
 export function isOrderExpired(order: Order, ts: number): boolean {
 	if (
-		isOneOfVariant(order.orderType, ['triggerMarket', 'triggerLimit']) ||
+		mustBeTriggered(order) ||
 		!isVariant(order.status, 'open') ||
 		order.maxTs.eq(ZERO)
 	) {
@@ -263,7 +263,7 @@ export function isOrderExpired(order: Order, ts: number): boolean {
 }
 
 export function isMarketOrder(order: Order): boolean {
-	return isOneOfVariant(order.orderType, ['market', 'triggerMarket']);
+	return isOneOfVariant(order.orderType, ['market', 'triggerMarket', 'oracle']);
 }
 
 export function isLimitOrder(order: Order): boolean {