@drift-labs/sdk 2.145.0 → 2.146.0-alpha.13

package/src/marginCalculation.ts

@@ -0,0 +1,306 @@
+import { BN } from '@coral-xyz/anchor';
+import { MARGIN_PRECISION } from './constants/numericConstants';
+import { MarketType } from './types';
+
+export type MarginCategory = 'Initial' | 'Maintenance' | 'Fill';
+
+export type MarginCalculationMode =
+	| { type: 'Standard' }
+	| { type: 'Liquidation' };
+
+export class MarketIdentifier {
+	marketType: MarketType;
+	marketIndex: number;
+
+	private constructor(marketType: MarketType, marketIndex: number) {
+		this.marketType = marketType;
+		this.marketIndex = marketIndex;
+	}
+
+	static spot(marketIndex: number): MarketIdentifier {
+		return new MarketIdentifier(MarketType.SPOT, marketIndex);
+	}
+
+	static perp(marketIndex: number): MarketIdentifier {
+		return new MarketIdentifier(MarketType.PERP, marketIndex);
+	}
+
+	equals(other: MarketIdentifier | undefined): boolean {
+		return (
+			!!other &&
+			this.marketType === other.marketType &&
+			this.marketIndex === other.marketIndex
+		);
+	}
+}
+
+export class MarginContext {
+	marginType: MarginCategory;
+	mode: MarginCalculationMode;
+	strict: boolean;
+	ignoreInvalidDepositOracles: boolean;
+	marginBuffer: BN; // scaled by MARGIN_PRECISION
+	marginRatioOverride?: number;
+
+	private constructor(marginType: MarginCategory) {
+		this.marginType = marginType;
+		this.mode = { type: 'Standard' };
+		this.strict = false;
+		this.ignoreInvalidDepositOracles = false;
+		this.marginBuffer = new BN(0);
+	}
+
+	static standard(marginType: MarginCategory): MarginContext {
+		return new MarginContext(marginType);
+	}
+
+	static liquidation(marginBuffer: BN): MarginContext {
+		const ctx = new MarginContext('Maintenance');
+		ctx.mode = { type: 'Liquidation' };
+		ctx.marginBuffer = marginBuffer ?? new BN(0);
+		return ctx;
+	}
+
+	strictMode(strict: boolean): this {
+		this.strict = strict;
+		return this;
+	}
+
+	ignoreInvalidDeposits(ignore: boolean): this {
+		this.ignoreInvalidDepositOracles = ignore;
+		return this;
+	}
+
+	setMarginBuffer(buffer?: BN): this {
+		this.marginBuffer = buffer ?? new BN(0);
+		return this;
+	}
+
+	setMarginRatioOverride(ratio: number): this {
+		this.marginRatioOverride = ratio;
+		return this;
+	}
+}
+
+export class IsolatedMarginCalculation {
+	marginRequirement: BN;
+	totalCollateral: BN; // deposit + pnl
+	totalCollateralBuffer: BN;
+	marginRequirementPlusBuffer: BN;
+
+	constructor() {
+		this.marginRequirement = new BN(0);
+		this.totalCollateral = new BN(0);
+		this.totalCollateralBuffer = new BN(0);
+		this.marginRequirementPlusBuffer = new BN(0);
+	}
+
+	getTotalCollateralPlusBuffer(): BN {
+		return this.totalCollateral.add(this.totalCollateralBuffer);
+	}
+
+	meetsMarginRequirement(): boolean {
+		return this.totalCollateral.gte(this.marginRequirement);
+	}
+
+	meetsMarginRequirementWithBuffer(): boolean {
+		return this.getTotalCollateralPlusBuffer().gte(
+			this.marginRequirementPlusBuffer
+		);
+	}
+
+	marginShortage(): BN {
+		const shortage = this.marginRequirementPlusBuffer.sub(
+			this.getTotalCollateralPlusBuffer()
+		);
+		return shortage.isNeg() ? new BN(0) : shortage;
+	}
+}
+
+export class MarginCalculation {
+	context: MarginContext;
+	totalCollateral: BN;
+	totalCollateralBuffer: BN;
+	marginRequirement: BN;
+	marginRequirementPlusBuffer: BN;
+	isolatedMarginCalculations: Map<number, IsolatedMarginCalculation>;
+	numSpotLiabilities: number;
+	numPerpLiabilities: number;
+	allDepositOraclesValid: boolean;
+	allLiabilityOraclesValid: boolean;
+	withPerpIsolatedLiability: boolean;
+	withSpotIsolatedLiability: boolean;
+	totalSpotLiabilityValue: BN;
+	totalPerpLiabilityValue: BN;
+	trackedMarketMarginRequirement: BN;
+	fuelDeposits: number;
+	fuelBorrows: number;
+	fuelPositions: number;
+
+	constructor(context: MarginContext) {
+		this.context = context;
+		this.totalCollateral = new BN(0);
+		this.totalCollateralBuffer = new BN(0);
+		this.marginRequirement = new BN(0);
+		this.marginRequirementPlusBuffer = new BN(0);
+		this.isolatedMarginCalculations = new Map();
+		this.numSpotLiabilities = 0;
+		this.numPerpLiabilities = 0;
+		this.allDepositOraclesValid = true;
+		this.allLiabilityOraclesValid = true;
+		this.withPerpIsolatedLiability = false;
+		this.withSpotIsolatedLiability = false;
+		this.totalSpotLiabilityValue = new BN(0);
+		this.totalPerpLiabilityValue = new BN(0);
+		this.trackedMarketMarginRequirement = new BN(0);
+		this.fuelDeposits = 0;
+		this.fuelBorrows = 0;
+		this.fuelPositions = 0;
+	}
+
+	addCrossMarginTotalCollateral(delta: BN): void {
+		this.totalCollateral = this.totalCollateral.add(delta);
+		if (this.context.marginBuffer.gt(new BN(0)) && delta.isNeg()) {
+			this.totalCollateralBuffer = this.totalCollateralBuffer.add(
+				delta.mul(this.context.marginBuffer).div(MARGIN_PRECISION)
+			);
+		}
+	}
+
+	addCrossMarginRequirement(marginRequirement: BN, liabilityValue: BN): void {
+		this.marginRequirement = this.marginRequirement.add(marginRequirement);
+		if (this.context.marginBuffer.gt(new BN(0))) {
+			this.marginRequirementPlusBuffer = this.marginRequirementPlusBuffer.add(
+				marginRequirement.add(
+					liabilityValue.mul(this.context.marginBuffer).div(MARGIN_PRECISION)
+				)
+			);
+		}
+	}
+
+	addIsolatedMarginCalculation(
+		marketIndex: number,
+		depositValue: BN,
+		pnl: BN,
+		liabilityValue: BN,
+		marginRequirement: BN
+	): void {
+		const totalCollateral = depositValue.add(pnl);
+		const totalCollateralBuffer =
+			this.context.marginBuffer.gt(new BN(0)) && pnl.isNeg()
+				? pnl.mul(this.context.marginBuffer).div(MARGIN_PRECISION)
+				: new BN(0);
+
+		const marginRequirementPlusBuffer = this.context.marginBuffer.gt(new BN(0))
+			? marginRequirement.add(
+					liabilityValue.mul(this.context.marginBuffer).div(MARGIN_PRECISION)
+			  )
+			: new BN(0);
+
+		const iso = new IsolatedMarginCalculation();
+		iso.marginRequirement = marginRequirement;
+		iso.totalCollateral = totalCollateral;
+		iso.totalCollateralBuffer = totalCollateralBuffer;
+		iso.marginRequirementPlusBuffer = marginRequirementPlusBuffer;
+		this.isolatedMarginCalculations.set(marketIndex, iso);
+	}
+
+	addSpotLiability(): void {
+		this.numSpotLiabilities += 1;
+	}
+
+	addPerpLiability(): void {
+		this.numPerpLiabilities += 1;
+	}
+
+	addSpotLiabilityValue(spotLiabilityValue: BN): void {
+		this.totalSpotLiabilityValue =
+			this.totalSpotLiabilityValue.add(spotLiabilityValue);
+	}
+
+	addPerpLiabilityValue(perpLiabilityValue: BN): void {
+		this.totalPerpLiabilityValue =
+			this.totalPerpLiabilityValue.add(perpLiabilityValue);
+	}
+
+	updateAllDepositOraclesValid(valid: boolean): void {
+		this.allDepositOraclesValid = this.allDepositOraclesValid && valid;
+	}
+
+	updateAllLiabilityOraclesValid(valid: boolean): void {
+		this.allLiabilityOraclesValid = this.allLiabilityOraclesValid && valid;
+	}
+
+	updateWithSpotIsolatedLiability(isolated: boolean): void {
+		this.withSpotIsolatedLiability = this.withSpotIsolatedLiability || isolated;
+	}
+
+	updateWithPerpIsolatedLiability(isolated: boolean): void {
+		this.withPerpIsolatedLiability = this.withPerpIsolatedLiability || isolated;
+	}
+
+	validateNumSpotLiabilities(): void {
+		if (this.numSpotLiabilities > 0 && this.marginRequirement.eq(new BN(0))) {
+			throw new Error(
+				'InvalidMarginRatio: num_spot_liabilities>0 but margin_requirement=0'
+			);
+		}
+	}
+
+	getNumOfLiabilities(): number {
+		return this.numSpotLiabilities + this.numPerpLiabilities;
+	}
+
+	getCrossTotalCollateralPlusBuffer(): BN {
+		return this.totalCollateral.add(this.totalCollateralBuffer);
+	}
+
+	meetsCrossMarginRequirement(): boolean {
+		return this.totalCollateral.gte(this.marginRequirement);
+	}
+
+	meetsCrossMarginRequirementWithBuffer(): boolean {
+		return this.getCrossTotalCollateralPlusBuffer().gte(
+			this.marginRequirementPlusBuffer
+		);
+	}
+
+	meetsMarginRequirement(): boolean {
+		if (!this.meetsCrossMarginRequirement()) return false;
+		for (const [, iso] of this.isolatedMarginCalculations) {
+			if (!iso.meetsMarginRequirement()) return false;
+		}
+		return true;
+	}
+
+	meetsMarginRequirementWithBuffer(): boolean {
+		if (!this.meetsCrossMarginRequirementWithBuffer()) return false;
+		for (const [, iso] of this.isolatedMarginCalculations) {
+			if (!iso.meetsMarginRequirementWithBuffer()) return false;
+		}
+		return true;
+	}
+
+	getCrossFreeCollateral(): BN {
+		const free = this.totalCollateral.sub(this.marginRequirement);
+		return free.isNeg() ? new BN(0) : free;
+	}
+
+	getIsolatedFreeCollateral(marketIndex: number): BN {
+		const iso = this.isolatedMarginCalculations.get(marketIndex);
+		if (!iso)
+			throw new Error('InvalidMarginCalculation: missing isolated calc');
+		const free = iso.totalCollateral.sub(iso.marginRequirement);
+		return free.isNeg() ? new BN(0) : free;
+	}
+
+	getIsolatedMarginCalculation(
+		marketIndex: number
+	): IsolatedMarginCalculation | undefined {
+		return this.isolatedMarginCalculations.get(marketIndex);
+	}
+
+	hasIsolatedMarginCalculation(marketIndex: number): boolean {
+		return this.isolatedMarginCalculations.has(marketIndex);
+	}
+}

package/src/math/margin.ts

@@ -165,8 +165,20 @@ export function calculateWorstCaseBaseAssetAmount(
 export function calculateWorstCasePerpLiabilityValue(
 	perpPosition: PerpPosition,
 	perpMarket: PerpMarketAccount,
-	oraclePrice: BN
+	oraclePrice: BN,
+	includeOpenOrders: boolean = true
 ): { worstCaseBaseAssetAmount: BN; worstCaseLiabilityValue: BN } {
+	// return early if no open orders required
+	if (!includeOpenOrders) {
+		return {
+			worstCaseBaseAssetAmount: perpPosition.baseAssetAmount,
+			worstCaseLiabilityValue: calculatePerpLiabilityValue(
+				perpPosition.baseAssetAmount,
+				oraclePrice,
+				isVariant(perpMarket.contractType, 'prediction')
+			),
+		};
+	}
 	const allBids = perpPosition.baseAssetAmount.add(perpPosition.openBids);
 	const allAsks = perpPosition.baseAssetAmount.add(perpPosition.openAsks);
 

package/src/math/position.ts

@@ -14,6 +14,7 @@ import {
 	PositionDirection,
 	PerpPosition,
 	SpotMarketAccount,
+	PositionFlag,
 } from '../types';
 import {
 	calculateUpdatedAMM,
@@ -127,7 +128,6 @@ export function calculatePositionPNL(
 
 	if (withFunding) {
 		const fundingRatePnL = calculateUnsettledFundingPnl(market, perpPosition);
-
 		pnl = pnl.add(fundingRatePnL);
 	}
 
@@ -244,7 +244,17 @@ export function positionIsAvailable(position: PerpPosition): boolean {
 		position.baseAssetAmount.eq(ZERO) &&
 		position.openOrders === 0 &&
 		position.quoteAssetAmount.eq(ZERO) &&
-		position.lpShares.eq(ZERO)
+		position.lpShares.eq(ZERO) &&
+		position.isolatedPositionScaledBalance.eq(ZERO) &&
+		!positionIsBeingLiquidated(position)
+	);
+}
+
+export function positionIsBeingLiquidated(position: PerpPosition): boolean {
+	return (
+		(position.positionFlag &
+			(PositionFlag.BeingLiquidated | PositionFlag.Bankruptcy)) >
+		0
 	);
 }
 

package/src/math/spotPosition.ts

@@ -33,7 +33,8 @@ export function getWorstCaseTokenAmounts(
 	spotMarketAccount: SpotMarketAccount,
 	strictOraclePrice: StrictOraclePrice,
 	marginCategory: MarginCategory,
-	customMarginRatio?: number
+	customMarginRatio?: number,
+	includeOpenOrders: boolean = true
 ): OrderFillSimulation {
 	const tokenAmount = getSignedTokenAmount(
 		getTokenAmount(
@@ -50,7 +51,10 @@ export function getWorstCaseTokenAmounts(
 		strictOraclePrice
 	);
 
-	if (spotPosition.openBids.eq(ZERO) && spotPosition.openAsks.eq(ZERO)) {
+	if (
+		(spotPosition.openBids.eq(ZERO) && spotPosition.openAsks.eq(ZERO)) ||
+		!includeOpenOrders
+	) {
 		const { weight, weightedTokenValue } = calculateWeightedTokenValue(
 			tokenAmount,
 			tokenValue,

package/src/types.ts

@@ -584,6 +584,10 @@ export type SpotBankruptcyRecord = {
 	ifPayment: BN;
 };
 
+export class LiquidationBitFlag {
+	static readonly IsolatedPosition = 1;
+}
+
 export type SettlePnlRecord = {
 	ts: BN;
 	user: PublicKey;
@@ -1136,6 +1140,8 @@ export type PerpPosition = {
 	lastBaseAssetAmountPerLp: BN;
 	lastQuoteAssetAmountPerLp: BN;
 	perLpBase: number;
+	positionFlag: number;
+	isolatedPositionScaledBalance: BN;
 };
 
 export type UserStatsAccount = {
@@ -1288,6 +1294,12 @@ export class OrderParamsBitFlag {
 	static readonly UpdateHighLeverageMode = 2;
 }
 
+export class PositionFlag {
+	static readonly IsolatedPosition = 1;
+	static readonly BeingLiquidated = 2;
+	static readonly Bankruptcy = 3;
+}
+
 export type NecessaryOrderParams = {
 	orderType: OrderType;
 	marketIndex: number;
@@ -1299,6 +1311,10 @@ export type OptionalOrderParams = {
 	[Property in keyof OrderParams]?: OrderParams[Property];
 } & NecessaryOrderParams;
 
+export type PerpOrderIsolatedExtras = {
+	isolatedPositionDepositAmount?: BN;
+};
+
 export type ModifyOrderParams = {
 	[Property in keyof OrderParams]?: OrderParams[Property] | null;
 } & { policy?: ModifyOrderPolicy };