@drift-labs/sdk 0.2.0-master.4 → 0.2.0-master.41

package/src/math/amm.ts

@@ -1,7 +1,7 @@
 import { BN } from '@project-serum/anchor';
 import {
 	AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO,
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	PEG_PRECISION,
 	ZERO,
 	BID_ASK_SPREAD_PRECISION,
@@ -15,11 +15,11 @@ import {
 	AMM,
 	PositionDirection,
 	SwapDirection,
-	MarketAccount,
+	PerpMarketAccount,
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
-import { squareRootBN } from '..';
+import { squareRootBN, standardizeBaseAssetAmount } from '..';
 
 import { OraclePriceData } from '../oracles/types';
 import {
@@ -33,18 +33,21 @@ 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(
 	amm: AMM,
 	oraclePriceData: OraclePriceData
 ): [BN, BN, BN, boolean] {
-	const markPriceBefore = calculatePrice(
+	const reservePriceBefore = calculatePrice(
 		amm.baseAssetReserve,
 		amm.quoteAssetReserve,
 		amm.pegMultiplier
@@ -67,15 +70,15 @@ export function calculateOptimalPegAndBudget(
 		let newTargetPrice: BN;
 		let newOptimalPeg: BN;
 		let newBudget: BN;
-		const targetPriceGap = markPriceBefore.sub(targetPrice);
+		const targetPriceGap = reservePriceBefore.sub(targetPrice);
 
 		if (targetPriceGap.abs().gt(maxPriceSpread)) {
 			const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
 
 			if (targetPriceGap.lt(new BN(0))) {
-				newTargetPrice = markPriceBefore.add(markAdj);
+				newTargetPrice = reservePriceBefore.add(markAdj);
 			} else {
-				newTargetPrice = markPriceBefore.sub(markAdj);
+				newTargetPrice = reservePriceBefore.sub(markAdj);
 			}
 
 			newOptimalPeg = calculatePegFromTargetPrice(
@@ -114,7 +117,7 @@ export function calculateNewAmm(
 		newAmm.sqrtK = newAmm.sqrtK.mul(pKNumer).div(pKDenom);
 		const invariant = newAmm.sqrtK.mul(newAmm.sqrtK);
 		newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
-		const directionToClose = amm.netBaseAssetAmount.gt(ZERO)
+		const directionToClose = amm.baseAssetAmountWithAmm.gt(ZERO)
 			? PositionDirection.SHORT
 			: PositionDirection.LONG;
 
@@ -122,7 +125,7 @@ export function calculateNewAmm(
 			calculateAmmReservesAfterSwap(
 				newAmm,
 				'base',
-				amm.netBaseAssetAmount.abs(),
+				amm.baseAssetAmountWithAmm.abs(),
 				getSwapDirection('base', directionToClose)
 			);
 
@@ -154,7 +157,7 @@ export function calculateUpdatedAMM(
 	newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
 	newAmm.pegMultiplier = newPeg;
 
-	const directionToClose = amm.netBaseAssetAmount.gt(ZERO)
+	const directionToClose = amm.baseAssetAmountWithAmm.gt(ZERO)
 		? PositionDirection.SHORT
 		: PositionDirection.LONG;
 
@@ -162,7 +165,7 @@ export function calculateUpdatedAMM(
 		calculateAmmReservesAfterSwap(
 			newAmm,
 			'base',
-			amm.netBaseAssetAmount.abs(),
+			amm.baseAssetAmountWithAmm.abs(),
 			getSwapDirection('base', directionToClose)
 		);
 
@@ -239,7 +242,7 @@ export function calculateBidAskPrice(
  * @param baseAssetReserves
  * @param quoteAssetReserves
  * @param pegMultiplier
- * @returns price : Precision MARK_PRICE_PRECISION
+ * @returns price : Precision PRICE_PRECISION
  */
 export function calculatePrice(
 	baseAssetReserves: BN,
@@ -251,7 +254,7 @@ export function calculatePrice(
 	}
 
 	return quoteAssetReserves
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(pegMultiplier)
 		.div(PEG_PRECISION)
 		.div(baseAssetReserves);
@@ -305,13 +308,62 @@ export function calculateAmmReservesAfterSwap(
 	return [newQuoteAssetReserve, newBaseAssetReserve];
 }
 
+export function calculateMarketOpenBidAsk(
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN
+): [BN, BN] {
+	// open orders
+	let openAsks;
+	if (maxBaseAssetReserve > baseAssetReserve) {
+		openAsks = maxBaseAssetReserve.sub(baseAssetReserve).mul(new BN(-1));
+	} else {
+		openAsks = ZERO;
+	}
+
+	let openBids;
+	if (minBaseAssetReserve < baseAssetReserve) {
+		openBids = baseAssetReserve.sub(minBaseAssetReserve);
+	} else {
+		openBids = ZERO;
+	}
+	return [openBids, openAsks];
+}
+
+export function calculateInventoryScale(
+	netBaseAssetAmount: BN,
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN
+): number {
+	const maxScale = BID_ASK_SPREAD_PRECISION.mul(new BN(10));
+	// inventory skew
+	const [openBids, openAsks] = calculateMarketOpenBidAsk(
+		baseAssetReserve,
+		minBaseAssetReserve,
+		maxBaseAssetReserve
+	);
+
+	const minSideLiquidity = BN.max(
+		new BN(1),
+		BN.min(openBids.abs(), openAsks.abs())
+	);
+	const inventoryScale =
+		BN.min(
+			maxScale,
+			netBaseAssetAmount.mul(maxScale).div(minSideLiquidity).abs()
+		).toNumber() / BID_ASK_SPREAD_PRECISION.toNumber();
+
+	return inventoryScale;
+}
+
 export function calculateEffectiveLeverage(
 	baseSpread: number,
 	quoteAssetReserve: BN,
 	terminalQuoteAssetReserve: BN,
 	pegMultiplier: BN,
 	netBaseAssetAmount: BN,
-	markPrice: BN,
+	reservePrice: BN,
 	totalFeeMinusDistributions: BN
 ): number {
 	// inventory skew
@@ -321,8 +373,8 @@ export function calculateEffectiveLeverage(
 		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
 
 	const localBaseAssetValue = netBaseAssetAmount
-		.mul(markPrice)
-		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+		.mul(reservePrice)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(PRICE_PRECISION));
 
 	const effectiveLeverage =
 		localBaseAssetValue.sub(netBaseAssetValue).toNumber() /
@@ -342,34 +394,59 @@ export function calculateMaxSpread(marginRatioInitial: number): number {
 
 export function calculateSpreadBN(
 	baseSpread: number,
-	lastOracleMarkSpreadPct: BN,
+	lastOracleReservePriceSpreadPct: BN,
 	lastOracleConfPct: BN,
 	maxSpread: number,
 	quoteAssetReserve: BN,
 	terminalQuoteAssetReserve: BN,
 	pegMultiplier: BN,
 	netBaseAssetAmount: BN,
-	markPrice: BN,
-	totalFeeMinusDistributions: BN
+	reservePrice: BN,
+	totalFeeMinusDistributions: BN,
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN
 ): [number, number] {
 	let longSpread = baseSpread / 2;
 	let shortSpread = baseSpread / 2;
 
-	if (lastOracleMarkSpreadPct.gt(ZERO)) {
+	if (lastOracleReservePriceSpreadPct.gt(ZERO)) {
 		shortSpread = Math.max(
 			shortSpread,
-			lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber()
+			lastOracleReservePriceSpreadPct.abs().toNumber() +
+				lastOracleConfPct.toNumber()
 		);
-	} else if (lastOracleMarkSpreadPct.lt(ZERO)) {
+	} else if (lastOracleReservePriceSpreadPct.lt(ZERO)) {
 		longSpread = Math.max(
 			longSpread,
-			lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber()
+			lastOracleReservePriceSpreadPct.abs().toNumber() +
+				lastOracleConfPct.toNumber()
 		);
 	}
 
-	const maxTargetSpread: number = maxSpread;
+	const maxTargetSpread: number = Math.max(
+		maxSpread,
+		lastOracleReservePriceSpreadPct.abs().toNumber()
+	);
 
-	const MAX_INVENTORY_SKEW = 5;
+	const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = 10;
+
+	const inventoryScale = calculateInventoryScale(
+		netBaseAssetAmount,
+		baseAssetReserve,
+		minBaseAssetReserve,
+		maxBaseAssetReserve
+	);
+	const inventorySpreadScale = Math.min(
+		MAX_BID_ASK_INVENTORY_SKEW_FACTOR,
+		1 + inventoryScale
+	);
+
+	if (netBaseAssetAmount.gt(ZERO)) {
+		longSpread *= inventorySpreadScale;
+	} else if (netBaseAssetAmount.lt(ZERO)) {
+		shortSpread *= inventorySpreadScale;
+	}
 
 	const effectiveLeverage = calculateEffectiveLeverage(
 		baseSpread,
@@ -377,20 +454,23 @@ export function calculateSpreadBN(
 		terminalQuoteAssetReserve,
 		pegMultiplier,
 		netBaseAssetAmount,
-		markPrice,
+		reservePrice,
 		totalFeeMinusDistributions
 	);
 
 	if (totalFeeMinusDistributions.gt(ZERO)) {
-		const spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+		const spreadScale = Math.min(
+			MAX_BID_ASK_INVENTORY_SKEW_FACTOR,
+			1 + effectiveLeverage
+		);
 		if (netBaseAssetAmount.gt(ZERO)) {
 			longSpread *= spreadScale;
 		} else {
 			shortSpread *= spreadScale;
 		}
 	} else {
-		longSpread *= MAX_INVENTORY_SKEW;
-		shortSpread *= MAX_INVENTORY_SKEW;
+		longSpread *= MAX_BID_ASK_INVENTORY_SKEW_FACTOR;
+		shortSpread *= MAX_BID_ASK_INVENTORY_SKEW_FACTOR;
 	}
 
 	const totalSpread = longSpread + shortSpread;
@@ -416,23 +496,23 @@ export function calculateSpread(
 		return amm.baseSpread / 2;
 	}
 
-	const markPrice = calculatePrice(
+	const reservePrice = calculatePrice(
 		amm.baseAssetReserve,
 		amm.quoteAssetReserve,
 		amm.pegMultiplier
 	);
 
-	const targetPrice = oraclePriceData?.price || markPrice;
+	const targetPrice = oraclePriceData?.price || reservePrice;
 	const confInterval = oraclePriceData.confidence || ZERO;
 
-	const targetMarkSpreadPct = markPrice
+	const targetMarkSpreadPct = reservePrice
 		.sub(targetPrice)
 		.mul(BID_ASK_SPREAD_PRECISION)
-		.div(markPrice);
+		.div(reservePrice);
 
 	const confIntervalPct = confInterval
 		.mul(BID_ASK_SPREAD_PRECISION)
-		.div(markPrice);
+		.div(reservePrice);
 
 	const [longSpread, shortSpread] = calculateSpreadBN(
 		amm.baseSpread,
@@ -442,9 +522,12 @@ export function calculateSpread(
 		amm.quoteAssetReserve,
 		amm.terminalQuoteAssetReserve,
 		amm.pegMultiplier,
-		amm.netBaseAssetAmount,
-		markPrice,
-		amm.totalFeeMinusDistributions
+		amm.baseAssetAmountWithAmm,
+		reservePrice,
+		amm.totalFeeMinusDistributions,
+		amm.baseAssetReserve,
+		amm.minBaseAssetReserve,
+		amm.maxBaseAssetReserve
 	);
 
 	let spread: number;
@@ -543,10 +626,10 @@ export function getSwapDirection(
  * Helper function calculating terminal price of amm
  *
  * @param market
- * @returns cost : Precision MARK_PRICE_PRECISION
+ * @returns cost : Precision PRICE_PRECISION
  */
-export function calculateTerminalPrice(market: MarketAccount) {
-	const directionToClose = market.amm.netBaseAssetAmount.gt(ZERO)
+export function calculateTerminalPrice(market: PerpMarketAccount) {
+	const directionToClose = market.amm.baseAssetAmountWithAmm.gt(ZERO)
 		? PositionDirection.SHORT
 		: PositionDirection.LONG;
 
@@ -554,12 +637,12 @@ export function calculateTerminalPrice(market: MarketAccount) {
 		calculateAmmReservesAfterSwap(
 			market.amm,
 			'base',
-			market.amm.netBaseAssetAmount.abs(),
+			market.amm.baseAssetAmountWithAmm.abs(),
 			getSwapDirection('base', directionToClose)
 		);
 
 	const terminalPrice = newQuoteAssetReserve
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(market.amm.pegMultiplier)
 		.div(PEG_PRECISION)
 		.div(newBaseAssetReserve);
@@ -576,7 +659,7 @@ export function calculateMaxBaseAssetAmountToTrade(
 	const invariant = amm.sqrtK.mul(amm.sqrtK);
 
 	const newBaseAssetReserveSquared = invariant
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(amm.pegMultiplier)
 		.div(limit_price)
 		.div(PEG_PRECISION);
@@ -610,6 +693,10 @@ export function calculateQuoteAssetAmountSwapped(
 	pegMultiplier: BN,
 	swapDirection: SwapDirection
 ): BN {
+	if (isVariant(swapDirection, 'remove')) {
+		quoteAssetReserves = quoteAssetReserves.add(ONE);
+	}
+
 	let quoteAssetAmount = quoteAssetReserves
 		.mul(pegMultiplier)
 		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
@@ -620,3 +707,29 @@ export function calculateQuoteAssetAmountSwapped(
 
 	return quoteAssetAmount;
 }
+
+export function calculateMaxBaseAssetAmountFillable(
+	amm: AMM,
+	orderDirection: PositionDirection
+): BN {
+	const maxFillSize = amm.baseAssetReserve.div(
+		new BN(amm.maxFillReserveFraction)
+	);
+	let maxBaseAssetAmountOnSide: BN;
+	if (isVariant(orderDirection, 'long')) {
+		maxBaseAssetAmountOnSide = BN.max(
+			ZERO,
+			amm.baseAssetReserve.sub(amm.minBaseAssetReserve)
+		);
+	} else {
+		maxBaseAssetAmountOnSide = BN.max(
+			ZERO,
+			amm.maxBaseAssetReserve.sub(amm.baseAssetReserve)
+		);
+	}
+
+	return standardizeBaseAssetAmount(
+		BN.min(maxFillSize, maxBaseAssetAmountOnSide),
+		amm.orderStepSize
+	);
+}

package/src/math/conversion.ts

@@ -1,9 +1,9 @@
 import { BN } from '../';
-import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
+import { PRICE_PRECISION } from '../constants/numericConstants';
 
 export const convertToNumber = (
 	bigNumber: BN,
-	precision: BN = MARK_PRICE_PRECISION
+	precision: BN = PRICE_PRECISION
 ) => {
 	if (!bigNumber) return 0;
 	return (

package/src/math/exchangeStatus.ts

@@ -0,0 +1,31 @@
+import {
+	isOneOfVariant,
+	isVariant,
+	PerpMarketAccount,
+	SpotMarketAccount,
+	StateAccount,
+} from '../types';
+
+export function exchangePaused(state: StateAccount): boolean {
+	return isVariant(state.exchangeStatus, 'paused');
+}
+
+export function fillPaused(
+	state: StateAccount,
+	market: PerpMarketAccount | SpotMarketAccount
+): boolean {
+	return (
+		isOneOfVariant(state.exchangeStatus, ['paused', 'fillPaused']) ||
+		isOneOfVariant(market.status, ['paused', 'fillPaused'])
+	);
+}
+
+export function ammPaused(
+	state: StateAccount,
+	market: PerpMarketAccount | SpotMarketAccount
+): boolean {
+	return (
+		isOneOfVariant(state.exchangeStatus, ['paused', 'ammPaused']) ||
+		isOneOfVariant(market.status, ['paused', 'ammPaused'])
+	);
+}

package/src/math/funding.ts

@@ -1,13 +1,13 @@
 import { BN } from '@project-serum/anchor';
 import {
 	AMM_RESERVE_PRECISION,
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
-import { MarketAccount } from '../types';
-import { calculateMarkPrice } from './market';
+import { PerpMarketAccount, isVariant } from '../types';
 import { OraclePriceData } from '../oracles/types';
+import { calculateBidAskPrice } from './amm';
 
 /**
  *
@@ -17,7 +17,7 @@ import { OraclePriceData } from '../oracles/types';
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateAllEstimatedFundingRate(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN, BN]> {
@@ -29,7 +29,7 @@ export async function calculateAllEstimatedFundingRate(
 	const hoursInDay = new BN(24);
 	const ONE = new BN(1);
 
-	if (!market.initialized) {
+	if (isVariant(market.status, 'uninitialized')) {
 		return [ZERO, ZERO, ZERO, ZERO, ZERO];
 	}
 
@@ -48,10 +48,8 @@ export async function calculateAllEstimatedFundingRate(
 		secondsInHour,
 		BN.max(ZERO, secondsInHour.sub(timeSinceLastMarkChange))
 	);
-	const baseAssetPriceWithMantissa = calculateMarkPrice(
-		market,
-		oraclePriceData
-	);
+	const [bid, ask] = calculateBidAskPrice(market.amm, oraclePriceData);
+	const baseAssetPriceWithMantissa = bid.add(ask).div(new BN(2));
 
 	const markTwapWithMantissa = markTwapTimeSinceLastUpdate
 		.mul(lastMarkTwapWithMantissa)
@@ -60,8 +58,10 @@ export async function calculateAllEstimatedFundingRate(
 
 	// calculate real-time (predicted) oracle twap
 	// note: oracle twap depends on `when the chord is struck` (market is trade)
-	const lastOracleTwapWithMantissa = market.amm.lastOraclePriceTwap;
-	const lastOraclePriceTwapTs = market.amm.lastOraclePriceTwapTs;
+	const lastOracleTwapWithMantissa =
+		market.amm.historicalOracleData.lastOraclePriceTwap;
+	const lastOraclePriceTwapTs =
+		market.amm.historicalOracleData.lastOraclePriceTwapTs;
 
 	const oracleInvalidDuration = BN.max(
 		ZERO,
@@ -85,12 +85,12 @@ export async function calculateAllEstimatedFundingRate(
 		const oracleLiveVsTwap = oraclePrice
 			.sub(lastOracleTwapWithMantissa)
 			.abs()
-			.mul(MARK_PRICE_PRECISION)
+			.mul(PRICE_PRECISION)
 			.mul(new BN(100))
 			.div(lastOracleTwapWithMantissa);
 
 		// verify pyth live input is within 10% of last twap for live update
-		if (oracleLiveVsTwap.lte(MARK_PRICE_PRECISION.mul(new BN(10)))) {
+		if (oracleLiveVsTwap.lte(PRICE_PRECISION.mul(new BN(10)))) {
 			oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
 				.mul(lastOracleTwapWithMantissa)
 				.add(timeSinceLastMarkChange.mul(oraclePrice))
@@ -108,7 +108,7 @@ export async function calculateAllEstimatedFundingRate(
 	);
 
 	const twapSpreadPct = twapSpread
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(new BN(100))
 		.div(shrunkLastOracleTwapwithMantissa);
 
@@ -125,7 +125,7 @@ export async function calculateAllEstimatedFundingRate(
 	const interpRateQuote = twapSpreadPct
 		.mul(periodAdjustment)
 		.div(hoursInDay)
-		.div(MARK_PRICE_PRECISION.div(QUOTE_PRECISION));
+		.div(PRICE_PRECISION.div(QUOTE_PRECISION));
 
 	let feePoolSize = calculateFundingPool(market);
 	if (interpRateQuote.lt(new BN(0))) {
@@ -135,9 +135,11 @@ export async function calculateAllEstimatedFundingRate(
 	let cappedAltEst: BN;
 	let largerSide: BN;
 	let smallerSide: BN;
-	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
-		largerSide = market.baseAssetAmountLong.abs();
-		smallerSide = market.baseAssetAmountShort.abs();
+	if (
+		market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())
+	) {
+		largerSide = market.amm.baseAssetAmountLong.abs();
+		smallerSide = market.amm.baseAssetAmountShort.abs();
 		if (twapSpread.gt(new BN(0))) {
 			return [
 				markTwapWithMantissa,
@@ -147,9 +149,11 @@ export async function calculateAllEstimatedFundingRate(
 				interpEst,
 			];
 		}
-	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
-		largerSide = market.baseAssetAmountShort.abs();
-		smallerSide = market.baseAssetAmountLong.abs();
+	} else if (
+		market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())
+	) {
+		largerSide = market.amm.baseAssetAmountShort.abs();
+		smallerSide = market.amm.baseAssetAmountLong.abs();
 		if (twapSpread.lt(new BN(0))) {
 			return [
 				markTwapWithMantissa,
@@ -173,12 +177,12 @@ export async function calculateAllEstimatedFundingRate(
 		// funding smaller flow
 		cappedAltEst = smallerSide.mul(twapSpread).div(hoursInDay);
 		const feePoolTopOff = feePoolSize
-			.mul(MARK_PRICE_PRECISION.div(QUOTE_PRECISION))
+			.mul(PRICE_PRECISION.div(QUOTE_PRECISION))
 			.mul(AMM_RESERVE_PRECISION);
 		cappedAltEst = cappedAltEst.add(feePoolTopOff).div(largerSide);
 
 		cappedAltEst = cappedAltEst
-			.mul(MARK_PRICE_PRECISION)
+			.mul(PRICE_PRECISION)
 			.mul(new BN(100))
 			.div(oracleTwapWithMantissa)
 			.mul(periodAdjustment);
@@ -208,7 +212,7 @@ export async function calculateAllEstimatedFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateEstimatedFundingRate(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1),
 	estimationMethod?: 'interpolated' | 'lowerbound' | 'capped'
@@ -238,7 +242,7 @@ export async function calculateEstimatedFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateLongShortFundingRate(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN]> {
@@ -249,9 +253,11 @@ export async function calculateLongShortFundingRate(
 			periodAdjustment
 		);
 
-	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
+	if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort)) {
 		return [cappedAltEst, interpEst];
-	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
+	} else if (
+		market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort)
+	) {
 		return [interpEst, cappedAltEst];
 	} else {
 		return [interpEst, interpEst];
@@ -266,7 +272,7 @@ export async function calculateLongShortFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateLongShortFundingRateAndLiveTwaps(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN]> {
@@ -277,9 +283,13 @@ export async function calculateLongShortFundingRateAndLiveTwaps(
 			periodAdjustment
 		);
 
-	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+	if (
+		market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())
+	) {
 		return [markTwapLive, oracleTwapLive, cappedAltEst, interpEst];
-	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+	} else if (
+		market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())
+	) {
 		return [markTwapLive, oracleTwapLive, interpEst, cappedAltEst];
 	} else {
 		return [markTwapLive, oracleTwapLive, interpEst, interpEst];
@@ -291,7 +301,7 @@ export async function calculateLongShortFundingRateAndLiveTwaps(
  * @param market
  * @returns Estimated fee pool size
  */
-export function calculateFundingPool(market: MarketAccount): BN {
+export function calculateFundingPool(market: PerpMarketAccount): BN {
 	// todo
 	const totalFeeLB = market.amm.totalExchangeFee.div(new BN(2));
 	const feePool = BN.max(

package/src/math/insurance.ts

@@ -0,0 +1,35 @@
+import { ZERO } from '../constants/numericConstants';
+import { BN } from '../index';
+
+export function stakeAmountToShares(
+	amount: BN,
+	totalIfShares: BN,
+	insuranceFundVaultBalance: BN
+): BN {
+	let nShares: BN;
+	if (insuranceFundVaultBalance.gt(ZERO)) {
+		nShares = amount.mul(totalIfShares).div(insuranceFundVaultBalance);
+	} else {
+		nShares = amount;
+	}
+
+	return nShares;
+}
+
+export function unstakeSharesToAmount(
+	nShares: BN,
+	totalIfShares: BN,
+	insuranceFundVaultBalance: BN
+): BN {
+	let amount: BN;
+	if (totalIfShares.gt(ZERO)) {
+		amount = BN.max(
+			ZERO,
+			nShares.mul(insuranceFundVaultBalance).div(totalIfShares)
+		);
+	} else {
+		amount = ZERO;
+	}
+
+	return amount;
+}