@drift-labs/sdk 2.143.0-beta.7 → 2.143.0-beta.9

package/src/dlob/DLOB.ts

@@ -467,10 +467,6 @@ export class DLOB {
 
 		const isAmmPaused = ammPaused(stateAccount, marketAccount);
 
-		const minAuctionDuration = isVariant(marketType, 'perp')
-			? stateAccount.minPerpAuctionDuration
-			: 0;
-
 		const { makerRebateNumerator, makerRebateDenominator } =
 			this.getMakerRebate(marketType, stateAccount, marketAccount);
 
@@ -481,7 +477,8 @@ export class DLOB {
 				marketType,
 				oraclePriceData,
 				isAmmPaused,
-				minAuctionDuration,
+				stateAccount,
+				marketAccount,
 				fallbackAsk,
 				fallbackBid
 			);
@@ -493,7 +490,8 @@ export class DLOB {
 				marketType,
 				oraclePriceData,
 				isAmmPaused,
-				minAuctionDuration,
+				stateAccount,
+				marketAccount,
 				makerRebateNumerator,
 				makerRebateDenominator,
 				fallbackAsk,
@@ -597,7 +595,10 @@ export class DLOB {
 			? OraclePriceData
 			: MMOraclePriceData,
 		isAmmPaused: boolean,
-		minAuctionDuration: number,
+		stateAccount: StateAccount,
+		marketAccount: T extends { spot: unknown }
+			? SpotMarketAccount
+			: PerpMarketAccount,
 		makerRebateNumerator: number,
 		makerRebateDenominator: number,
 		fallbackAsk: BN | undefined,
@@ -636,7 +637,8 @@ export class DLOB {
 				(askPrice) => {
 					return askPrice.lte(fallbackBidWithBuffer);
 				},
-				minAuctionDuration
+				stateAccount,
+				marketAccount
 			);
 
 			for (const askCrossingFallback of asksCrossingFallback) {
@@ -664,7 +666,8 @@ export class DLOB {
 				(bidPrice) => {
 					return bidPrice.gte(fallbackAskWithBuffer);
 				},
-				minAuctionDuration
+				stateAccount,
+				marketAccount
 			);
 
 			for (const bidCrossingFallback of bidsCrossingFallback) {
@@ -683,7 +686,10 @@ export class DLOB {
 			? OraclePriceData
 			: MMOraclePriceData,
 		isAmmPaused: boolean,
-		minAuctionDuration: number,
+		state: StateAccount,
+		marketAccount: T extends { spot: unknown }
+			? SpotMarketAccount
+			: PerpMarketAccount,
 		fallbackAsk: BN | undefined,
 		fallbackBid?: BN | undefined
 	): NodeToFill[] {
@@ -736,7 +742,8 @@ export class DLOB {
 					(takerPrice) => {
 						return takerPrice === undefined || takerPrice.lte(fallbackBid);
 					},
-					minAuctionDuration
+					state,
+					marketAccount
 				);
 
 			for (const takingAskCrossingFallback of takingAsksCrossingFallback) {
@@ -793,7 +800,8 @@ export class DLOB {
 					(takerPrice) => {
 						return takerPrice === undefined || takerPrice.gte(fallbackAsk);
 					},
-					minAuctionDuration
+					state,
+					marketAccount
 				);
 			for (const marketBidCrossingFallback of takingBidsCrossingFallback) {
 				nodesToFill.push(marketBidCrossingFallback);
@@ -911,7 +919,10 @@ export class DLOB {
 			: MMOraclePriceData,
 		nodeGenerator: Generator<DLOBNode>,
 		doesCross: (nodePrice: BN | undefined) => boolean,
-		minAuctionDuration: number
+		state: StateAccount,
+		marketAccount: T extends { spot: unknown }
+			? SpotMarketAccount
+			: PerpMarketAccount
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
@@ -934,8 +945,10 @@ export class DLOB {
 				isVariant(marketType, 'spot') ||
 				isFallbackAvailableLiquiditySource(
 					node.order,
-					minAuctionDuration,
-					slot
+					oraclePriceData as MMOraclePriceData,
+					slot,
+					state,
+					marketAccount as PerpMarketAccount
 				);
 
 			if (crosses && fallbackAvailable) {

package/src/idl/drift.json

@@ -6566,7 +6566,7 @@
       ]
     },
     {
-      "name": "updatePerpMarketTakerSpeedBumpOverride",
+      "name": "updatePerpMarketOracleLowRiskSlotDelayOverride",
       "accounts": [
         {
           "name": "admin",
@@ -6586,7 +6586,7 @@
       ],
       "args": [
         {
-          "name": "takerSpeedBumpOverride",
+          "name": "oracleLowRiskSlotDelayOverride",
           "type": "i8"
         }
       ]
@@ -11194,7 +11194,7 @@
             "type": "i8"
           },
           {
-            "name": "takerSpeedBumpOverride",
+            "name": "oracleLowRiskSlotDelayOverride",
             "docs": [
               "the override for the state.min_perp_auction_duration",
               "0 is no override, -1 is disable speed bump, 1-100 is literal speed bump"
@@ -12278,7 +12278,17 @@
             "name": "InsufficientDataPoints"
           },
           {
-            "name": "StaleForAMM"
+            "name": "StaleForAMM",
+            "fields": [
+              {
+                "name": "immediate",
+                "type": "bool"
+              },
+              {
+                "name": "lowRisk",
+                "type": "bool"
+              }
+            ]
           },
           {
             "name": "Valid"
@@ -12304,7 +12314,10 @@
             "name": "FillOrderMatch"
           },
           {
-            "name": "FillOrderAmm"
+            "name": "FillOrderAmmLowRisk"
+          },
+          {
+            "name": "FillOrderAmmImmediate"
           },
           {
             "name": "Liquidate"
@@ -12954,23 +12967,6 @@
         ]
       }
     },
-    {
-      "name": "AMMAvailability",
-      "type": {
-        "kind": "enum",
-        "variants": [
-          {
-            "name": "Immediate"
-          },
-          {
-            "name": "AfterMinDuration"
-          },
-          {
-            "name": "Unavailable"
-          }
-        ]
-      }
-    },
     {
       "name": "RevenueShareOrderBitFlag",
       "type": {

package/src/math/auction.ts

@@ -1,4 +1,12 @@
-import { isOneOfVariant, isVariant, Order, PositionDirection } from '../types';
+import {
+	isOneOfVariant,
+	isVariant,
+	OracleValidity,
+	Order,
+	PerpOperation,
+	PositionDirection,
+	StateAccount,
+} from '../types';
 import { BN } from '@coral-xyz/anchor';
 import {
 	ONE,
@@ -8,6 +16,10 @@ import {
 } from '../constants/numericConstants';
 import { getVariant, OrderBitFlag, PerpMarketAccount } from '../types';
 import { getPerpMarketTierNumber } from './tiers';
+import { MMOraclePriceData } from '../oracles/types';
+import { isLowRiskForAmm } from './orders';
+import { getOracleValidity } from './oracles';
+import { isOperationPaused } from './exchangeStatus';
 
 export function isAuctionComplete(order: Order, slot: number): boolean {
 	if (order.auctionDuration === 0) {
@@ -19,18 +31,49 @@ export function isAuctionComplete(order: Order, slot: number): boolean {
 
 export function isFallbackAvailableLiquiditySource(
 	order: Order,
-	minAuctionDuration: number,
-	slot: number
+	mmOraclePriceData: MMOraclePriceData,
+	slot: number,
+	state: StateAccount,
+	market: PerpMarketAccount,
+	isLiquidation?: boolean
 ): boolean {
-	if (minAuctionDuration === 0) {
-		return true;
+	if (isOperationPaused(market.pausedOperations, PerpOperation.AMM_FILL)) {
+		return false;
+	}
+
+	// TODO: include too much drawdown check & mm oracle volatility
+
+	const oracleValidity = getOracleValidity(
+		market!,
+		{
+			price: mmOraclePriceData.price,
+			slot: mmOraclePriceData.slot,
+			confidence: mmOraclePriceData.confidence,
+			hasSufficientNumberOfDataPoints:
+				mmOraclePriceData.hasSufficientNumberOfDataPoints,
+		},
+		state.oracleGuardRails,
+		new BN(slot)
+	);
+	if (oracleValidity <= OracleValidity.StaleForAMMLowRisk) {
+		return false;
 	}
 
-	if ((order.bitFlags & OrderBitFlag.SafeTriggerOrder) !== 0) {
+	if (oracleValidity == OracleValidity.Valid) {
 		return true;
 	}
 
-	return new BN(slot).sub(order.slot).gt(new BN(minAuctionDuration));
+	const isOrderLowRiskForAmm = isLowRiskForAmm(
+		order,
+		mmOraclePriceData,
+		isLiquidation
+	);
+
+	if (!isOrderLowRiskForAmm) {
+		return false;
+	} else {
+		return true;
+	}
 }
 
 /**

package/src/math/margin.ts

@@ -10,6 +10,7 @@ import {
 	MARGIN_PRECISION,
 	PRICE_PRECISION,
 	QUOTE_PRECISION,
+	PERCENTAGE_PRECISION,
 } from '../constants/numericConstants';
 import { BN } from '@coral-xyz/anchor';
 import { OraclePriceData } from '../oracles/types';
@@ -32,7 +33,8 @@ export function calculateSizePremiumLiabilityWeight(
 	size: BN, // AMM_RESERVE_PRECISION
 	imfFactor: BN,
 	liabilityWeight: BN,
-	precision: BN
+	precision: BN,
+	isBounded = true
 ): BN {
 	if (imfFactor.eq(ZERO)) {
 		return liabilityWeight;
@@ -53,10 +55,13 @@ export function calculateSizePremiumLiabilityWeight(
 			.div(denom) // 1e5
 	);
 
-	const maxLiabilityWeight = BN.max(
-		liabilityWeight,
-		sizePremiumLiabilityWeight
-	);
+	let maxLiabilityWeight;
+	if (isBounded) {
+		maxLiabilityWeight = BN.max(liabilityWeight, sizePremiumLiabilityWeight);
+	} else {
+		maxLiabilityWeight = sizePremiumLiabilityWeight;
+	}
+
 	return maxLiabilityWeight;
 }
 
@@ -370,3 +375,37 @@ export function calculateUserMaxPerpOrderSize(
 
 	return user.getMaxTradeSizeUSDCForPerp(targetMarketIndex, tradeSide);
 }
+
+export function calcHighLeverageModeInitialMarginRatioFromSize(
+	preSizeAdjMarginRatio: BN,
+	sizeAdjMarginRatio: BN,
+	defaultMarginRatio: BN
+): BN {
+	let result: BN;
+
+	if (sizeAdjMarginRatio.lt(preSizeAdjMarginRatio)) {
+		const sizePctDiscountFactor = PERCENTAGE_PRECISION.sub(
+			preSizeAdjMarginRatio
+				.sub(sizeAdjMarginRatio)
+				.mul(PERCENTAGE_PRECISION)
+				.div(preSizeAdjMarginRatio.div(new BN(5)))
+		);
+
+		const hlmMarginDelta = BN.max(
+			preSizeAdjMarginRatio.sub(defaultMarginRatio),
+			new BN(1)
+		);
+
+		const hlmMarginDeltaProportion = hlmMarginDelta
+			.mul(sizePctDiscountFactor)
+			.div(PERCENTAGE_PRECISION);
+
+		result = hlmMarginDeltaProportion.add(defaultMarginRatio);
+	} else if (sizeAdjMarginRatio.eq(preSizeAdjMarginRatio)) {
+		result = defaultMarginRatio;
+	} else {
+		result = sizeAdjMarginRatio;
+	}
+
+	return result;
+}

package/src/math/market.ts

@@ -19,6 +19,7 @@ import {
 import {
 	calculateSizeDiscountAssetWeight,
 	calculateSizePremiumLiabilityWeight,
+	calcHighLeverageModeInitialMarginRatioFromSize,
 } from './margin';
 import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
 import {
@@ -143,45 +144,74 @@ export function calculateMarketMarginRatio(
 	customMarginRatio = 0,
 	userHighLeverageMode = false
 ): number {
-	let marginRationInitial;
-	let marginRatioMaintenance;
+	if (market.status === 'Settlement') return 0;
 
-	if (
+	const isHighLeverageUser =
 		userHighLeverageMode &&
 		market.highLeverageMarginRatioInitial > 0 &&
-		market.highLeverageMarginRatioMaintenance
-	) {
-		marginRationInitial = market.highLeverageMarginRatioInitial;
-		marginRatioMaintenance = market.highLeverageMarginRatioMaintenance;
-	} else {
-		marginRationInitial = market.marginRatioInitial;
-		marginRatioMaintenance = market.marginRatioMaintenance;
-	}
+		market.highLeverageMarginRatioMaintenance > 0;
+
+	const marginRatioInitial = isHighLeverageUser
+		? market.highLeverageMarginRatioInitial
+		: market.marginRatioInitial;
+
+	const marginRatioMaintenance = isHighLeverageUser
+		? market.highLeverageMarginRatioMaintenance
+		: market.marginRatioMaintenance;
 
-	let marginRatio;
+	let defaultMarginRatio: number;
 	switch (marginCategory) {
-		case 'Initial': {
-			// use lowest leverage between max allowed and optional user custom max
-			marginRatio = Math.max(
-				calculateSizePremiumLiabilityWeight(
-					size,
-					new BN(market.imfFactor),
-					new BN(marginRationInitial),
-					MARGIN_PRECISION
-				).toNumber(),
-				customMarginRatio
-			);
+		case 'Initial':
+			defaultMarginRatio = marginRatioInitial;
 			break;
-		}
-		case 'Maintenance': {
-			marginRatio = calculateSizePremiumLiabilityWeight(
-				size,
-				new BN(market.imfFactor),
-				new BN(marginRatioMaintenance),
-				MARGIN_PRECISION
-			).toNumber();
+		case 'Maintenance':
+			defaultMarginRatio = marginRatioMaintenance;
 			break;
+		default:
+			throw new Error('Invalid margin category');
+	}
+
+	let marginRatio: number;
+
+	if (isHighLeverageUser && marginCategory !== 'Maintenance') {
+		// Use ordinary-mode initial/fill ratios for size-adjusted calc
+		let preSizeAdjMarginRatio: number;
+		switch (marginCategory) {
+			case 'Initial':
+				preSizeAdjMarginRatio = market.marginRatioInitial;
+				break;
+			default:
+				preSizeAdjMarginRatio = marginRatioMaintenance;
+				break;
 		}
+
+		const sizeAdjMarginRatio = calculateSizePremiumLiabilityWeight(
+			size,
+			new BN(market.imfFactor),
+			new BN(preSizeAdjMarginRatio),
+			MARGIN_PRECISION,
+			false
+		).toNumber();
+
+		marginRatio = calcHighLeverageModeInitialMarginRatioFromSize(
+			new BN(preSizeAdjMarginRatio),
+			new BN(sizeAdjMarginRatio),
+			new BN(defaultMarginRatio)
+		).toNumber();
+	} else {
+		const sizeAdjMarginRatio = calculateSizePremiumLiabilityWeight(
+			size,
+			new BN(market.imfFactor),
+			new BN(defaultMarginRatio),
+			MARGIN_PRECISION,
+			true
+		).toNumber();
+
+		marginRatio = Math.max(defaultMarginRatio, sizeAdjMarginRatio);
+	}
+
+	if (marginCategory === 'Initial') {
+		marginRatio = Math.max(marginRatio, customMarginRatio);
 	}
 
 	return marginRatio;

package/src/math/oracles.ts

@@ -3,7 +3,9 @@ import {
 	HistoricalOracleData,
 	OracleGuardRails,
 	OracleSource,
+	OracleValidity,
 	PerpMarketAccount,
+	isOneOfVariant,
 	isVariant,
 } from '../types';
 import { OraclePriceData } from '../oracles/types';
@@ -14,6 +16,7 @@ import {
 	ZERO,
 	FIVE_MINUTE,
 	PERCENTAGE_PRECISION,
+	FIVE,
 } from '../constants/numericConstants';
 import { assert } from '../assert/assert';
 import { BN } from '@coral-xyz/anchor';
@@ -51,6 +54,91 @@ export function getMaxConfidenceIntervalMultiplier(
 	return maxConfidenceIntervalMultiplier;
 }
 
+export function getOracleValidity(
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData,
+	oracleGuardRails: OracleGuardRails,
+	slot: BN,
+	oracleStalenessBuffer = FIVE
+): OracleValidity {
+	const isNonPositive = oraclePriceData.price.lte(ZERO);
+	const isTooVolatile = BN.max(
+		oraclePriceData.price,
+		market.amm.historicalOracleData.lastOraclePriceTwap
+	)
+		.div(
+			BN.max(
+				ONE,
+				BN.min(
+					oraclePriceData.price,
+					market.amm.historicalOracleData.lastOraclePriceTwap
+				)
+			)
+		)
+		.gt(oracleGuardRails.validity.tooVolatileRatio);
+
+	const confPctOfPrice = oraclePriceData.confidence
+		.mul(BID_ASK_SPREAD_PRECISION)
+		.div(oraclePriceData.price);
+	const isConfTooLarge = confPctOfPrice.gt(
+		oracleGuardRails.validity.confidenceIntervalMaxSize.mul(
+			getMaxConfidenceIntervalMultiplier(market)
+		)
+	);
+
+	const oracleDelay = slot.sub(oraclePriceData.slot).sub(oracleStalenessBuffer);
+
+	let isStaleForAmmImmediate = true;
+	if (market.amm.oracleSlotDelayOverride != 0) {
+		isStaleForAmmImmediate = oracleDelay.gt(
+			BN.max(new BN(market.amm.oracleSlotDelayOverride), ZERO)
+		);
+	}
+
+	let isStaleForAmmLowRisk = false;
+	if (market.amm.oracleLowRiskSlotDelayOverride != 0) {
+		isStaleForAmmLowRisk = oracleDelay.gt(
+			BN.max(new BN(market.amm.oracleLowRiskSlotDelayOverride), ZERO)
+		);
+	} else {
+		isStaleForAmmLowRisk = oracleDelay.gt(
+			oracleGuardRails.validity.slotsBeforeStaleForAmm
+		);
+	}
+
+	let isStaleForMargin = oracleDelay.gt(
+		new BN(oracleGuardRails.validity.slotsBeforeStaleForMargin)
+	);
+	if (
+		isOneOfVariant(market.amm.oracleSource, [
+			'pythStableCoinPull',
+			'pythLazerStableCoin',
+		])
+	) {
+		isStaleForMargin = oracleDelay.gt(
+			new BN(oracleGuardRails.validity.slotsBeforeStaleForMargin).muln(3)
+		);
+	}
+
+	if (isNonPositive) {
+		return OracleValidity.NonPositive;
+	} else if (isTooVolatile) {
+		return OracleValidity.TooVolatile;
+	} else if (isConfTooLarge) {
+		return OracleValidity.TooUncertain;
+	} else if (isStaleForMargin) {
+		return OracleValidity.StaleForMargin;
+	} else if (!oraclePriceData.hasSufficientNumberOfDataPoints) {
+		return OracleValidity.InsufficientDataPoints;
+	} else if (isStaleForAmmLowRisk) {
+		return OracleValidity.StaleForAMMLowRisk;
+	} else if (isStaleForAmmImmediate) {
+		return OracleValidity.isStaleForAmmImmediate;
+	} else {
+		return OracleValidity.Valid;
+	}
+}
+
 export function isOracleValid(
 	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,

package/src/math/orders.ts

@@ -8,6 +8,8 @@ import {
 	PositionDirection,
 	ProtectedMakerParams,
 	MarketTypeStr,
+	OrderBitFlag,
+	StateAccount,
 } from '../types';
 import {
 	ZERO,
@@ -243,10 +245,16 @@ export function isFillableByVAMM(
 	mmOraclePriceData: MMOraclePriceData,
 	slot: number,
 	ts: number,
-	minAuctionDuration: number
+	state: StateAccount
 ): boolean {
 	return (
-		(isFallbackAvailableLiquiditySource(order, minAuctionDuration, slot) &&
+		(isFallbackAvailableLiquiditySource(
+			order,
+			mmOraclePriceData,
+			slot,
+			state,
+			market
+		) &&
 			calculateBaseAssetAmountForAmmToFulfill(
 				order,
 				market,
@@ -257,6 +265,26 @@ export function isFillableByVAMM(
 	);
 }
 
+export function isLowRiskForAmm(
+	order: Order,
+	mmOraclePriceData: MMOraclePriceData,
+	isLiquidation?: boolean
+): boolean {
+	if (isVariant(order.marketType, 'spot')) {
+		return false;
+	}
+
+	const orderOlderThanOracleDelay = new BN(order.slot).lte(
+		mmOraclePriceData.slot
+	);
+
+	return (
+		orderOlderThanOracleDelay ||
+		isLiquidation ||
+		(order.bitFlags & OrderBitFlag.SafeTriggerOrder) !== 0
+	);
+}
+
 export function calculateBaseAssetAmountForAmmToFulfill(
 	order: Order,
 	market: PerpMarketAccount,

package/src/types.ts

@@ -1107,7 +1107,8 @@ export type AMM = {
 	quoteAssetAmountWithUnsettledLp: BN;
 	referencePriceOffset: number;
 
-	takerSpeedBumpOverride: number;
+	oracleLowRiskSlotDelayOverride: number;
+	oracleSlotDelayOverride: number;
 	ammSpreadAdjustment: number;
 	ammInventorySpreadAdjustment: number;
 
@@ -1473,6 +1474,17 @@ export type OracleGuardRails = {
 	};
 };
 
+export enum OracleValidity {
+	NonPositive = 0,
+	TooVolatile = 1,
+	TooUncertain = 2,
+	StaleForMargin = 3,
+	InsufficientDataPoints = 4,
+	StaleForAMMLowRisk = 5,
+	isStaleForAmmImmediate = 6,
+	Valid = 7,
+}
+
 export type PrelaunchOracle = {
 	price: BN;
 	maxPrice: BN;

package/tests/dlob/helpers.ts

@@ -145,7 +145,7 @@ export const mockAMM: AMM = {
 	quoteAssetAmountWithUnsettledLp: new BN(0),
 	referencePriceOffset: 0,
 
-	takerSpeedBumpOverride: 0,
+	oracleLowRiskSlotDelayOverride: 0,
 	ammSpreadAdjustment: 0,
 	ammInventorySpreadAdjustment: 0,
 	mmOracleSequenceId: new BN(0),
@@ -672,9 +672,9 @@ export class MockUserMap implements UserMapInterface {
 		});
 	}
 
-	public async subscribe(): Promise<void> {}
+	public async subscribe(): Promise<void> { }
 
-	public async unsubscribe(): Promise<void> {}
+	public async unsubscribe(): Promise<void> { }
 
 	public async addPubkey(userAccountPublicKey: PublicKey): Promise<void> {
 		const user = new User({
@@ -733,7 +733,7 @@ export class MockUserMap implements UserMapInterface {
 		);
 	}
 
-	public async updateWithOrderRecord(_record: OrderRecord): Promise<void> {}
+	public async updateWithOrderRecord(_record: OrderRecord): Promise<void> { }
 
 	public values(): IterableIterator<User> {
 		return this.userMap.values();