@drift-labs/sdk 0.2.0-master.11 → 0.2.0-master.14

package/src/index.ts

@@ -35,6 +35,7 @@ export * from './math/amm';
 export * from './math/trade';
 export * from './math/orders';
 export * from './math/repeg';
+export * from './math/margin';
 export * from './orders';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';

package/src/math/amm.ts

@@ -33,11 +33,14 @@ export function calculatePegFromTargetPrice(
 	baseAssetReserve: BN,
 	quoteAssetReserve: BN
 ): BN {
-	return targetPrice
-		.mul(baseAssetReserve)
-		.div(quoteAssetReserve)
-		.add(PRICE_DIV_PEG.div(new BN(2)))
-		.div(PRICE_DIV_PEG);
+	return BN.max(
+		targetPrice
+			.mul(baseAssetReserve)
+			.div(quoteAssetReserve)
+			.add(PRICE_DIV_PEG.div(new BN(2)))
+			.div(PRICE_DIV_PEG),
+		ONE
+	);
 }
 
 export function calculateOptimalPegAndBudget(

package/src/math/bankBalance.ts

@@ -1,4 +1,9 @@
-import { BankAccount, BankBalanceType, isVariant } from '../types';
+import {
+	BankAccount,
+	BankBalanceType,
+	isVariant,
+	MarginCategory,
+} from '../types';
 import { BN } from '@project-serum/anchor';
 import {
 	BANK_UTILIZATION_PRECISION,
@@ -6,8 +11,14 @@ import {
 	TEN,
 	ZERO,
 	BANK_INTEREST_PRECISION,
+	BANK_WEIGHT_PRECISION,
 	ONE_YEAR,
+	AMM_RESERVE_PRECISION,
 } from '../constants/numericConstants';
+import {
+	calculateSizeDiscountAssetWeight,
+	calculateSizePremiumLiabilityWeight,
+} from './margin';
 
 export function getBalance(
 	tokenAmount: BN,
@@ -43,6 +54,92 @@ export function getTokenAmount(
 	return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
 }
 
+export function calculateAssetWeight(
+	balanceAmount: BN,
+	bank: BankAccount,
+	marginCategory: MarginCategory
+): BN {
+	const sizePrecision = TEN.pow(new BN(bank.decimals));
+	let sizeInAmmReservePrecision;
+	if (sizePrecision.gt(AMM_RESERVE_PRECISION)) {
+		sizeInAmmReservePrecision = balanceAmount.div(
+			sizePrecision.div(AMM_RESERVE_PRECISION)
+		);
+	} else {
+		sizeInAmmReservePrecision = balanceAmount
+			.mul(AMM_RESERVE_PRECISION)
+			.div(sizePrecision);
+	}
+
+	let assetWeight;
+
+	switch (marginCategory) {
+		case 'Initial':
+			assetWeight = calculateSizeDiscountAssetWeight(
+				sizeInAmmReservePrecision,
+				bank.imfFactor,
+				bank.initialAssetWeight
+			);
+			break;
+		case 'Maintenance':
+			assetWeight = calculateSizeDiscountAssetWeight(
+				sizeInAmmReservePrecision,
+				bank.imfFactor,
+				bank.maintenanceAssetWeight
+			);
+			break;
+		default:
+			assetWeight = bank.initialAssetWeight;
+			break;
+	}
+
+	return assetWeight;
+}
+
+export function calculateLiabilityWeight(
+	balanceAmount: BN,
+	bank: BankAccount,
+	marginCategory: MarginCategory
+): BN {
+	const sizePrecision = TEN.pow(new BN(bank.decimals));
+	let sizeInAmmReservePrecision;
+	if (sizePrecision.gt(AMM_RESERVE_PRECISION)) {
+		sizeInAmmReservePrecision = balanceAmount.div(
+			sizePrecision.div(AMM_RESERVE_PRECISION)
+		);
+	} else {
+		sizeInAmmReservePrecision = balanceAmount
+			.mul(AMM_RESERVE_PRECISION)
+			.div(sizePrecision);
+	}
+
+	let assetWeight;
+
+	switch (marginCategory) {
+		case 'Initial':
+			assetWeight = calculateSizePremiumLiabilityWeight(
+				sizeInAmmReservePrecision,
+				bank.imfFactor,
+				bank.initialLiabilityWeight,
+				BANK_WEIGHT_PRECISION
+			);
+			break;
+		case 'Maintenance':
+			assetWeight = calculateSizePremiumLiabilityWeight(
+				sizeInAmmReservePrecision,
+				bank.imfFactor,
+				bank.maintenanceLiabilityWeight,
+				BANK_WEIGHT_PRECISION
+			);
+			break;
+		default:
+			assetWeight = bank.initialLiabilityWeight;
+			break;
+	}
+
+	return assetWeight;
+}
+
 export function calculateInterestAccumulated(
 	bank: BankAccount,
 	now: BN
@@ -110,3 +207,52 @@ export function calculateInterestAccumulated(
 
 	return { borrowInterest, depositInterest };
 }
+
+export function calculateWithdrawLimit(
+	bank: BankAccount,
+	now: BN
+): { borrowLimit: BN; withdrawLimit: BN } {
+	const bankDepositTokenAmount = getTokenAmount(
+		bank.depositBalance,
+		bank,
+		BankBalanceType.DEPOSIT
+	);
+	const bankBorrowTokenAmount = getTokenAmount(
+		bank.borrowBalance,
+		bank,
+		BankBalanceType.BORROW
+	);
+
+	const twentyFourHours = new BN(60 * 60 * 24);
+	const sinceLast = now.sub(bank.lastUpdated);
+	const sinceStart = BN.max(ZERO, twentyFourHours.sub(sinceLast));
+	const borrowTokenTwapLive = bank.borrowTokenTwap
+		.mul(sinceStart)
+		.add(bankBorrowTokenAmount.mul(sinceLast))
+		.div(sinceLast.add(sinceLast));
+
+	const depositTokenTwapLive = bank.depositTokenTwap
+		.mul(sinceStart)
+		.add(bankDepositTokenAmount.mul(sinceLast))
+		.div(sinceLast.add(sinceLast));
+
+	const maxBorrowTokens = BN.min(
+		BN.max(
+			bankDepositTokenAmount.div(new BN(6)),
+			borrowTokenTwapLive.add(borrowTokenTwapLive.div(new BN(5)))
+		),
+		bankDepositTokenAmount.sub(bankDepositTokenAmount.div(new BN(10)))
+	); // between ~15-90% utilization with friction on twap
+
+	const minDepositTokens = depositTokenTwapLive.sub(
+		BN.min(
+			BN.max(depositTokenTwapLive.div(new BN(5)), bank.withdrawGuardThreshold),
+			depositTokenTwapLive
+		)
+	);
+
+	return {
+		borrowLimit: maxBorrowTokens.sub(bankBorrowTokenAmount),
+		withdrawLimit: bankDepositTokenAmount.sub(minDepositTokens),
+	};
+}

package/src/math/margin.ts

@@ -0,0 +1,124 @@
+import { squareRootBN } from './utils';
+import {
+	BANK_WEIGHT_PRECISION,
+	BANK_IMF_PRECISION,
+	ZERO,
+	BID_ASK_SPREAD_PRECISION,
+	AMM_TO_QUOTE_PRECISION_RATIO,
+	MARK_PRICE_PRECISION,
+} from '../constants/numericConstants';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+import { MarketAccount, UserPosition } from '..';
+
+export function calculateSizePremiumLiabilityWeight(
+	size: BN, // AMM_RESERVE_PRECISION
+	imfFactor: BN,
+	liabilityWeight: BN,
+	precision: BN
+): BN {
+	if (imfFactor.eq(ZERO)) {
+		return liabilityWeight;
+	}
+
+	const sizeSqrt = squareRootBN(size.div(new BN(1000)).add(new BN(1))); //1e13 -> 1e10 -> 1e5
+	const liabilityWeightNumerator = liabilityWeight.sub(
+		liabilityWeight.div(BN.max(new BN(1), BANK_IMF_PRECISION.div(imfFactor)))
+	);
+
+	const sizePremiumLiabilityWeight = liabilityWeightNumerator.add(
+		sizeSqrt // 1e5
+			.mul(imfFactor)
+			.div(new BN(100_000).mul(BANK_IMF_PRECISION).div(precision)) // 1e5
+	);
+
+	const maxLiabilityWeight = BN.max(
+		liabilityWeight,
+		sizePremiumLiabilityWeight
+	);
+	return maxLiabilityWeight;
+}
+
+export function calculateSizeDiscountAssetWeight(
+	size: BN, // AMM_RESERVE_PRECISION
+	imfFactor: BN,
+	assetWeight: BN
+): BN {
+	if (imfFactor.eq(ZERO)) {
+		return assetWeight;
+	}
+
+	const sizeSqrt = squareRootBN(size.div(new BN(1000)).add(new BN(1))); //1e13 -> 1e10 -> 1e5
+	const imfNumerator = BANK_IMF_PRECISION.add(
+		BANK_IMF_PRECISION.div(new BN(10))
+	);
+
+	const sizeDiscountAssetWeight = imfNumerator.mul(BANK_WEIGHT_PRECISION).div(
+		BANK_IMF_PRECISION.add(
+			sizeSqrt // 1e5
+				.mul(imfFactor)
+				.div(new BN(100_000)) // 1e5
+		)
+	);
+
+	const minAssetWeight = BN.min(assetWeight, sizeDiscountAssetWeight);
+
+	return minAssetWeight;
+}
+
+export function calculateOraclePriceForPerpMargin(
+	marketPosition: UserPosition,
+	market: MarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const oraclePriceOffset = BN.min(
+		new BN(market.amm.maxSpread)
+			.mul(oraclePriceData.price)
+			.div(BID_ASK_SPREAD_PRECISION),
+		oraclePriceData.confidence.add(
+			new BN(market.amm.baseSpread)
+				.mul(oraclePriceData.price)
+				.div(BID_ASK_SPREAD_PRECISION)
+		)
+	);
+
+	let marginPrice: BN;
+	if (marketPosition.baseAssetAmount.gt(ZERO)) {
+		marginPrice = oraclePriceData.price.sub(oraclePriceOffset);
+	} else {
+		marginPrice = oraclePriceData.price.add(oraclePriceOffset);
+	}
+
+	return marginPrice;
+}
+
+export function calculateMarginBaseAssetValue(
+	market: MarketAccount,
+	marketPosition: UserPosition,
+	oraclePriceData: OraclePriceData
+): BN {
+	const marginPrice = calculateOraclePriceForPerpMargin(
+		marketPosition,
+		market,
+		oraclePriceData
+	);
+	const baseAssetValue = marketPosition.baseAssetAmount
+		.abs()
+		.mul(marginPrice)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+
+	return baseAssetValue;
+}
+
+export function calculateWorstCaseBaseAssetAmount(
+	marketPosition: UserPosition
+): BN {
+	const allBids = marketPosition.baseAssetAmount.add(marketPosition.openBids);
+	const allAsks = marketPosition.baseAssetAmount.add(marketPosition.openAsks);
+
+	if (allBids.abs().gt(allAsks.abs())) {
+		return allBids;
+	} else {
+		return allAsks;
+	}
+}

package/src/math/market.ts

@@ -1,5 +1,11 @@
 import { BN } from '@project-serum/anchor';
-import { MarketAccount, PositionDirection } from '../types';
+import {
+	MarketAccount,
+	PositionDirection,
+	MarginCategory,
+	BankAccount,
+	BankBalanceType,
+} from '../types';
 import {
 	calculateAmmReservesAfterSwap,
 	calculatePrice,
@@ -7,7 +13,13 @@ import {
 	getSwapDirection,
 	calculateUpdatedAMM,
 } from './amm';
+import {
+	calculateSizeDiscountAssetWeight,
+	calculateSizePremiumLiabilityWeight,
+} from './margin';
 import { OraclePriceData } from '../oracles/types';
+import { MARGIN_PRECISION } from '../constants/numericConstants';
+import { getTokenAmount } from './bankBalance';
 
 /**
  * Calculates market mark price
@@ -103,3 +115,56 @@ export function calculateOracleSpread(
 ): BN {
 	return price.sub(oraclePriceData.price);
 }
+
+export function calculateMarketMarginRatio(
+	market: MarketAccount,
+	size: BN,
+	marginCategory: MarginCategory
+): number {
+	let marginRatio;
+	switch (marginCategory) {
+		case 'Initial':
+			marginRatio = calculateSizePremiumLiabilityWeight(
+				size,
+				market.imfFactor,
+				new BN(market.marginRatioInitial),
+				MARGIN_PRECISION
+			).toNumber();
+			break;
+		case 'Maintenance':
+			marginRatio = market.marginRatioMaintenance;
+			break;
+	}
+
+	return marginRatio;
+}
+
+export function calculateUnsettledAssetWeight(
+	market: MarketAccount,
+	unsettledPnl: BN,
+	marginCategory: MarginCategory
+): BN {
+	let assetWeight: BN;
+
+	switch (marginCategory) {
+		case 'Initial':
+			assetWeight = calculateSizeDiscountAssetWeight(
+				unsettledPnl,
+				market.unsettledImfFactor,
+				new BN(market.unsettledInitialAssetWeight)
+			);
+			break;
+		case 'Maintenance':
+			assetWeight = new BN(market.unsettledMaintenanceAssetWeight);
+			break;
+	}
+
+	return assetWeight;
+}
+
+export function calculateMarketAvailablePNL(
+	market: MarketAccount,
+	bank: BankAccount
+): BN {
+	return getTokenAmount(market.pnlPool.balance, bank, BankBalanceType.DEPOSIT);
+}

package/src/math/oracles.ts

@@ -1,6 +1,11 @@
 import { AMM, OracleGuardRails } from '../types';
 import { OraclePriceData } from '../oracles/types';
-import { ONE, ZERO } from '../constants/numericConstants';
+import {
+	BID_ASK_SPREAD_PRECISION,
+	MARK_PRICE_PRECISION,
+	ONE,
+	ZERO,
+} from '../constants/numericConstants';
 import { BN } from '../index';
 
 export function isOracleValid(
@@ -9,7 +14,7 @@ export function isOracleValid(
 	oracleGuardRails: OracleGuardRails,
 	slot: number
 ): boolean {
-	const isOraclePriceNonPositive = oraclePriceData.price.lt(ZERO);
+	const isOraclePriceNonPositive = oraclePriceData.price.lte(ZERO);
 	const isOraclePriceTooVolatile =
 		oraclePriceData.price
 			.div(BN.max(ONE, amm.lastOraclePriceTwap))
@@ -18,9 +23,11 @@ export function isOracleValid(
 			.div(BN.max(ONE, oraclePriceData.price))
 			.gt(oracleGuardRails.validity.tooVolatileRatio);
 
-	const isConfidenceTooLarge = oraclePriceData.price
-		.div(BN.max(ONE, oraclePriceData.confidence))
-		.lt(oracleGuardRails.validity.confidenceIntervalMaxSize);
+	const isConfidenceTooLarge = new BN(amm.baseSpread)
+		.add(BN.max(ONE, oraclePriceData.confidence))
+		.mul(BID_ASK_SPREAD_PRECISION)
+		.div(oraclePriceData.price)
+		.gt(new BN(amm.maxSpread));
 
 	const oracleIsStale = oraclePriceData.slot
 		.sub(new BN(slot))
@@ -34,3 +41,33 @@ export function isOracleValid(
 		isConfidenceTooLarge
 	);
 }
+
+export function isOracleTooDivergent(
+	amm: AMM,
+	oraclePriceData: OraclePriceData,
+	oracleGuardRails: OracleGuardRails,
+	now: BN
+): boolean {
+	const sinceLastUpdate = now.sub(amm.lastOraclePriceTwapTs);
+	const sinceStart = BN.max(ZERO, new BN(60 * 5).sub(sinceLastUpdate));
+	const oracleTwap5min = amm.lastOraclePriceTwap5min
+		.mul(sinceStart)
+		.add(oraclePriceData.price)
+		.mul(sinceLastUpdate)
+		.div(sinceStart.add(sinceLastUpdate));
+
+	const oracleSpread = oracleTwap5min.sub(oraclePriceData.price);
+	const oracleSpreadPct = oracleSpread
+		.mul(MARK_PRICE_PRECISION)
+		.div(oracleTwap5min);
+
+	const tooDivergent = oracleSpreadPct
+		.abs()
+		.gte(
+			BID_ASK_SPREAD_PRECISION.mul(
+				oracleGuardRails.priceDivergence.markOracleDivergenceNumerator
+			).div(oracleGuardRails.priceDivergence.markOracleDivergenceDenominator)
+		);
+
+	return tooDivergent;
+}

package/src/math/position.ts

@@ -18,6 +18,8 @@ import {
 	getSwapDirection,
 } from './amm';
 
+import { calculateMarginBaseAssetValue } from './margin';
+
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -84,6 +86,7 @@ export function calculateBaseAssetValue(
  * @param market
  * @param marketPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 export function calculatePositionPNL(
@@ -93,21 +96,21 @@ export function calculatePositionPNL(
 	oraclePriceData: OraclePriceData
 ): BN {
 	if (marketPosition.baseAssetAmount.eq(ZERO)) {
-		return ZERO;
+		return marketPosition.quoteAssetAmount;
 	}
 
-	const baseAssetValue = calculateBaseAssetValue(
+	const baseAssetValue = calculateMarginBaseAssetValue(
 		market,
 		marketPosition,
 		oraclePriceData
 	);
 
-	let pnl;
-	if (marketPosition.baseAssetAmount.gt(ZERO)) {
-		pnl = baseAssetValue.sub(marketPosition.quoteAssetAmount);
-	} else {
-		pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue);
-	}
+	const baseAssetValueSign = marketPosition.baseAssetAmount.isNeg()
+		? new BN(-1)
+		: new BN(1);
+	let pnl = baseAssetValue
+		.mul(baseAssetValueSign)
+		.add(marketPosition.quoteAssetAmount);
 
 	if (withFunding) {
 		const fundingRatePnL = calculatePositionFundingPNL(
@@ -121,6 +124,36 @@ export function calculatePositionPNL(
 	return pnl;
 }
 
+export function calculateUnsettledPnl(
+	market: MarketAccount,
+	marketPosition: UserPosition,
+	oraclePriceData: OraclePriceData
+): BN {
+	const unrealizedPnl = calculatePositionPNL(
+		market,
+		marketPosition,
+		true,
+		oraclePriceData
+	);
+
+	let unsettledPnl = unrealizedPnl;
+	if (unrealizedPnl.gt(ZERO)) {
+		const fundingPnL = calculatePositionFundingPNL(market, marketPosition).div(
+			PRICE_TO_QUOTE_PRECISION
+		);
+
+		const maxPositivePnl = BN.max(
+			marketPosition.quoteAssetAmount
+				.add(marketPosition.quoteEntryAmount)
+				.add(fundingPnL),
+			ZERO
+		);
+
+		unsettledPnl = BN.min(maxPositivePnl, unrealizedPnl);
+	}
+	return unsettledPnl;
+}
+
 /**
  *
  * @param market
@@ -156,7 +189,8 @@ export function positionIsAvailable(position: UserPosition): boolean {
 	return (
 		position.baseAssetAmount.eq(ZERO) &&
 		position.openOrders.eq(ZERO) &&
-		position.unsettledPnl.eq(ZERO)
+		position.quoteAssetAmount.eq(ZERO) &&
+		position.lpShares.eq(ZERO)
 	);
 }
 
@@ -170,6 +204,23 @@ export function calculateEntryPrice(userPosition: UserPosition): BN {
 		return ZERO;
 	}
 
+	return userPosition.quoteEntryAmount
+		.mul(MARK_PRICE_PRECISION)
+		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(userPosition.baseAssetAmount)
+		.abs();
+}
+
+/**
+ *
+ * @param userPosition
+ * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ */
+export function calculateCostBasis(userPosition: UserPosition): BN {
+	if (userPosition.baseAssetAmount.eq(ZERO)) {
+		return ZERO;
+	}
+
 	return userPosition.quoteAssetAmount
 		.mul(MARK_PRICE_PRECISION)
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)

package/src/math/trade.ts

@@ -177,13 +177,13 @@ export function calculateTradeAcquiredAmounts(
 
 	const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
 	const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-	const acquiredQuoteAssetamount = calculateQuoteAssetAmountSwapped(
+	const acquiredQuoteAssetAmount = calculateQuoteAssetAmountSwapped(
 		acquiredQuote.abs(),
 		amm.pegMultiplier,
 		swapDirection
 	);
 
-	return [acquiredBase, acquiredQuote, acquiredQuoteAssetamount];
+	return [acquiredBase, acquiredQuote, acquiredQuoteAssetAmount];
 }
 
 /**