@drift-labs/sdk 0.2.0-master.29 → 0.2.0-master.30

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,
@@ -242,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,
@@ -254,7 +254,7 @@ export function calculatePrice(
 	}
 
 	return quoteAssetReserves
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(pegMultiplier)
 		.div(PEG_PRECISION)
 		.div(baseAssetReserves);
@@ -343,11 +343,14 @@ export function calculateInventoryScale(
 		maxBaseAssetReserve
 	);
 
-	const totalLiquidity = BN.max(openBids.abs().add(openAsks.abs()), new BN(1));
+	const minSideLiquidity = BN.max(
+		new BN(1),
+		BN.min(openBids.abs(), openAsks.abs())
+	);
 	const inventoryScale =
-		BN.min(netBaseAssetAmount.abs(), totalLiquidity)
-			.mul(BID_ASK_SPREAD_PRECISION.mul(new BN(5)))
-			.div(totalLiquidity)
+		BN.min(netBaseAssetAmount.abs(), minSideLiquidity)
+			.mul(BID_ASK_SPREAD_PRECISION.mul(new BN(10)))
+			.div(minSideLiquidity)
 			.toNumber() / BID_ASK_SPREAD_PRECISION.toNumber();
 
 	return inventoryScale;
@@ -370,7 +373,7 @@ export function calculateEffectiveLeverage(
 
 	const localBaseAssetValue = netBaseAssetAmount
 		.mul(markPrice)
-		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(PRICE_PRECISION));
 
 	const effectiveLeverage =
 		localBaseAssetValue.sub(netBaseAssetValue).toNumber() /
@@ -614,7 +617,7 @@ 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: PerpMarketAccount) {
 	const directionToClose = market.amm.netBaseAssetAmount.gt(ZERO)
@@ -630,7 +633,7 @@ export function calculateTerminalPrice(market: PerpMarketAccount) {
 		);
 
 	const terminalPrice = newQuoteAssetReserve
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(market.amm.pegMultiplier)
 		.div(PEG_PRECISION)
 		.div(newBaseAssetReserve);
@@ -647,7 +650,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);

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/funding.ts

@@ -1,12 +1,12 @@
 import { BN } from '@project-serum/anchor';
 import {
 	AMM_RESERVE_PRECISION,
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
 import { PerpMarketAccount, isVariant } from '../types';
-import { calculateMarkPrice } from './market';
+import { calculateReservePrice } from './market';
 import { OraclePriceData } from '../oracles/types';
 
 /**
@@ -48,7 +48,7 @@ export async function calculateAllEstimatedFundingRate(
 		secondsInHour,
 		BN.max(ZERO, secondsInHour.sub(timeSinceLastMarkChange))
 	);
-	const baseAssetPriceWithMantissa = calculateMarkPrice(
+	const baseAssetPriceWithMantissa = calculateReservePrice(
 		market,
 		oraclePriceData
 	);
@@ -60,8 +60,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 +87,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 +110,7 @@ export async function calculateAllEstimatedFundingRate(
 	);
 
 	const twapSpreadPct = twapSpread
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(new BN(100))
 		.div(shrunkLastOracleTwapwithMantissa);
 
@@ -125,7 +127,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))) {
@@ -173,12 +175,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);

package/src/math/margin.ts

@@ -4,8 +4,7 @@ import {
 	SPOT_MARKET_IMF_PRECISION,
 	ZERO,
 	BID_ASK_SPREAD_PRECISION,
-	AMM_TO_QUOTE_PRECISION_RATIO,
-	MARK_PRICE_PRECISION,
+	AMM_RESERVE_PRECISION,
 } from '../constants/numericConstants';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
@@ -22,7 +21,7 @@ export function calculateSizePremiumLiabilityWeight(
 		return liabilityWeight;
 	}
 
-	const sizeSqrt = squareRootBN(size.div(new BN(1000)).add(new BN(1))); //1e13 -> 1e10 -> 1e5
+	const sizeSqrt = squareRootBN(size.mul(new BN(10)).add(new BN(1))); //1e9 -> 1e10 -> 1e5
 
 	const denom0 = BN.max(new BN(1), SPOT_MARKET_IMF_PRECISION.div(imfFactor));
 	assert(denom0.gt(ZERO));
@@ -57,7 +56,7 @@ export function calculateSizeDiscountAssetWeight(
 		return assetWeight;
 	}
 
-	const sizeSqrt = squareRootBN(size.div(new BN(1000)).add(new BN(1))); //1e13 -> 1e10 -> 1e5
+	const sizeSqrt = squareRootBN(size.mul(new BN(10)).add(new BN(1))); //1e9 -> 1e10 -> 1e5
 	const imfNumerator = SPOT_MARKET_IMF_PRECISION.add(
 		SPOT_MARKET_IMF_PRECISION.div(new BN(10))
 	);
@@ -111,7 +110,7 @@ export function calculateBaseAssetValueWithOracle(
 	return perpPosition.baseAssetAmount
 		.abs()
 		.mul(oraclePriceData.price)
-		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+		.div(AMM_RESERVE_PRECISION);
 }
 
 export function calculateWorstCaseBaseAssetAmount(

package/src/math/market.ts

@@ -30,9 +30,9 @@ import { getTokenAmount } from './spotBalance';
  * Calculates market mark price
  *
  * @param market
- * @return markPrice : Precision MARK_PRICE_PRECISION
+ * @return markPrice : Precision PRICE_PRECISION
  */
-export function calculateMarkPrice(
+export function calculateReservePrice(
 	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
@@ -48,7 +48,7 @@ export function calculateMarkPrice(
  * Calculates market bid price
  *
  * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
+ * @return bidPrice : Precision PRICE_PRECISION
  */
 export function calculateBidPrice(
 	market: PerpMarketAccount,
@@ -68,7 +68,7 @@ export function calculateBidPrice(
  * Calculates market ask price
  *
  * @param market
- * @return askPrice : Precision MARK_PRICE_PRECISION
+ * @return askPrice : Precision PRICE_PRECISION
  */
 export function calculateAskPrice(
 	market: PerpMarketAccount,
@@ -110,7 +110,7 @@ export function calculateMarkOracleSpread(
 	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
-	const markPrice = calculateMarkPrice(market, oraclePriceData);
+	const markPrice = calculateReservePrice(market, oraclePriceData);
 	return calculateOracleSpread(markPrice, oraclePriceData);
 }
 

package/src/math/oracles.ts

@@ -3,7 +3,7 @@ import { OraclePriceData } from '../oracles/types';
 import {
 	BID_ASK_SPREAD_PRECISION,
 	MARGIN_PRECISION,
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	ONE,
 	ZERO,
 } from '../constants/numericConstants';
@@ -34,9 +34,9 @@ export function isOracleValid(
 	const isOraclePriceNonPositive = oraclePriceData.price.lte(ZERO);
 	const isOraclePriceTooVolatile =
 		oraclePriceData.price
-			.div(BN.max(ONE, amm.lastOraclePriceTwap))
+			.div(BN.max(ONE, amm.historicalOracleData.lastOraclePriceTwap))
 			.gt(oracleGuardRails.validity.tooVolatileRatio) ||
-		amm.lastOraclePriceTwap
+		amm.historicalOracleData.lastOraclePriceTwap
 			.div(BN.max(ONE, oraclePriceData.price))
 			.gt(oracleGuardRails.validity.tooVolatileRatio);
 
@@ -48,7 +48,7 @@ export function isOracleValid(
 
 	const oracleIsStale = oraclePriceData.slot
 		.sub(new BN(slot))
-		.gt(oracleGuardRails.validity.slotsBeforeStale);
+		.gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
 
 	return !(
 		!oraclePriceData.hasSufficientNumberOfDataPoints ||
@@ -65,18 +65,18 @@ export function isOracleTooDivergent(
 	oracleGuardRails: OracleGuardRails,
 	now: BN
 ): boolean {
-	const sinceLastUpdate = now.sub(amm.lastOraclePriceTwapTs);
+	const sinceLastUpdate = now.sub(
+		amm.historicalOracleData.lastOraclePriceTwapTs
+	);
 	const sinceStart = BN.max(ZERO, new BN(60 * 5).sub(sinceLastUpdate));
-	const oracleTwap5min = amm.lastOraclePriceTwap5min
+	const oracleTwap5min = amm.historicalOracleData.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 oracleSpreadPct = oracleSpread.mul(PRICE_PRECISION).div(oracleTwap5min);
 
 	const tooDivergent = oracleSpreadPct
 		.abs()

package/src/math/position.ts

@@ -3,10 +3,9 @@ import {
 	AMM_RESERVE_PRECISION,
 	AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO,
 	AMM_TO_QUOTE_PRECISION_RATIO,
-	FUNDING_PAYMENT_PRECISION,
-	MARK_PRICE_PRECISION,
+	FUNDING_RATE_BUFFER_PRECISION,
+	PRICE_PRECISION,
 	ONE,
-	PRICE_TO_QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
 import { OraclePriceData } from '../oracles/types';
@@ -119,10 +118,7 @@ export function calculatePositionPNL(
 		.add(perpPosition.quoteAssetAmount);
 
 	if (withFunding) {
-		const fundingRatePnL = calculatePositionFundingPNL(
-			market,
-			perpPosition
-		).div(PRICE_TO_QUOTE_PRECISION);
+		const fundingRatePnL = calculatePositionFundingPNL(market, perpPosition);
 
 		pnl = pnl.add(fundingRatePnL);
 	}
@@ -143,9 +139,7 @@ export function calculateClaimablePnl(
 		oraclePriceData
 	);
 
-	const fundingPnL = calculatePositionFundingPNL(market, perpPosition).div(
-		PRICE_TO_QUOTE_PRECISION
-	);
+	const fundingPnL = calculatePositionFundingPNL(market, perpPosition);
 
 	let unsettledPnl = unrealizedPnl.add(fundingPnL);
 	if (unrealizedPnl.gt(ZERO)) {
@@ -193,7 +187,7 @@ export function calculatePositionFundingPNL(
 		.sub(perpPosition.lastCumulativeFundingRate)
 		.mul(perpPosition.baseAssetAmount)
 		.div(AMM_RESERVE_PRECISION)
-		.div(FUNDING_PAYMENT_PRECISION)
+		.div(FUNDING_RATE_BUFFER_PRECISION)
 		.mul(new BN(-1));
 
 	return perPositionFundingRate;
@@ -202,7 +196,7 @@ export function calculatePositionFundingPNL(
 export function positionIsAvailable(position: PerpPosition): boolean {
 	return (
 		position.baseAssetAmount.eq(ZERO) &&
-		position.openOrders.eq(ZERO) &&
+		position.openOrders === 0 &&
 		position.quoteAssetAmount.eq(ZERO) &&
 		position.lpShares.eq(ZERO)
 	);
@@ -211,7 +205,7 @@ export function positionIsAvailable(position: PerpPosition): boolean {
 /**
  *
  * @param userPosition
- * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ * @returns Precision: PRICE_PRECISION (10^10)
  */
 export function calculateEntryPrice(userPosition: PerpPosition): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
@@ -219,7 +213,7 @@ export function calculateEntryPrice(userPosition: PerpPosition): BN {
 	}
 
 	return userPosition.quoteEntryAmount
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
 		.div(userPosition.baseAssetAmount)
 		.abs();
@@ -228,7 +222,7 @@ export function calculateEntryPrice(userPosition: PerpPosition): BN {
 /**
  *
  * @param userPosition
- * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ * @returns Precision: PRICE_PRECISION (10^10)
  */
 export function calculateCostBasis(userPosition: PerpPosition): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
@@ -236,7 +230,7 @@ export function calculateCostBasis(userPosition: PerpPosition): BN {
 	}
 
 	return userPosition.quoteAssetAmount
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
 		.div(userPosition.baseAssetAmount)
 		.abs();
@@ -259,7 +253,5 @@ export function positionCurrentDirection(
 }
 
 export function isEmptyPosition(userPosition: PerpPosition): boolean {
-	return (
-		userPosition.baseAssetAmount.eq(ZERO) && userPosition.openOrders.eq(ZERO)
-	);
+	return userPosition.baseAssetAmount.eq(ZERO) && userPosition.openOrders === 0;
 }

package/src/math/repeg.ts

@@ -1,7 +1,7 @@
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	AMM_RESERVE_PRECISION,
 	PEG_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
@@ -31,15 +31,15 @@ export function calculateAdjustKCost(
 
 	const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
 
-	const p = numerator.mul(MARK_PRICE_PRECISION).div(denomenator);
+	const p = numerator.mul(PRICE_PRECISION).div(denomenator);
 
 	const cost = quoteScale
 		.div(x.add(d))
 		.sub(
 			quoteScale
 				.mul(p)
-				.div(MARK_PRICE_PRECISION)
-				.div(x.mul(p).div(MARK_PRICE_PRECISION).add(d))
+				.div(PRICE_PRECISION)
+				.div(x.mul(p).div(PRICE_PRECISION).add(d))
 		)
 		.div(AMM_TO_QUOTE_PRECISION_RATIO)
 		.div(PEG_PRECISION);
@@ -101,7 +101,8 @@ export function calculateBudgetedKBN(
 	// protocol is spending to increase k
 	if (C.lt(ZERO)) {
 		// thus denom1 is negative and solution is unstable
-		if (denom1.lt(pegged_y_d_d.abs())) {
+		if (denom1.abs().gt(denom2.abs())) {
+			console.log('denom1 > denom2', denom1.toString(), denom2.toString());
 			console.log('budget cost exceeds stable K solution');
 			return [new BN(10000), new BN(1)];
 		}
@@ -174,11 +175,11 @@ export function calculateBudgetedPeg(amm: AMM, cost: BN, targetPrice: BN): BN {
 		return targetPeg;
 	}
 
-	const deltaPegMultiplier = C.mul(MARK_PRICE_PRECISION).div(
+	const deltaPegMultiplier = C.mul(PRICE_PRECISION).div(
 		deltaQuoteAssetReserves.div(AMM_TO_QUOTE_PRECISION_RATIO)
 	);
 	const newPeg = Q.sub(
-		deltaPegMultiplier.mul(PEG_PRECISION).div(MARK_PRICE_PRECISION)
+		deltaPegMultiplier.mul(PEG_PRECISION).div(PRICE_PRECISION)
 	);
 
 	return newPeg;

package/src/math/spotBalance.ts

@@ -10,7 +10,7 @@ import {
 	ONE,
 	TEN,
 	ZERO,
-	SPOT_MARKET_INTEREST_PRECISION,
+	SPOT_MARKET_RATE_PRECISION,
 	SPOT_MARKET_WEIGHT_PRECISION,
 	ONE_YEAR,
 	AMM_RESERVE_PRECISION,
@@ -26,7 +26,7 @@ export function getBalance(
 	spotMarket: SpotMarketAccount,
 	balanceType: SpotBalanceType
 ): BN {
-	const precisionIncrease = TEN.pow(new BN(16 - spotMarket.decimals));
+	const precisionIncrease = TEN.pow(new BN(19 - spotMarket.decimals));
 
 	const cumulativeInterest = isVariant(balanceType, 'deposit')
 		? spotMarket.cumulativeDepositInterest
@@ -46,7 +46,7 @@ export function getTokenAmount(
 	spotMarket: SpotMarketAccount,
 	balanceType: SpotBalanceType
 ): BN {
-	const precisionDecrease = TEN.pow(new BN(16 - spotMarket.decimals));
+	const precisionDecrease = TEN.pow(new BN(19 - spotMarket.decimals));
 
 	const cumulativeInterest = isVariant(balanceType, 'deposit')
 		? spotMarket.cumulativeDepositInterest
@@ -75,7 +75,7 @@ export function getTokenValue(
 		return ZERO;
 	}
 
-	const precisionDecrease = TEN.pow(new BN(10 + spotDecimals - 6));
+	const precisionDecrease = TEN.pow(new BN(spotDecimals));
 
 	return tokenAmount.mul(oraclePriceData.price).div(precisionDecrease);
 }
@@ -253,12 +253,12 @@ export function calculateInterestAccumulated(
 	const borrowInterest = bank.cumulativeBorrowInterest
 		.mul(modifiedBorrowRate)
 		.div(ONE_YEAR)
-		.div(SPOT_MARKET_INTEREST_PRECISION)
+		.div(SPOT_MARKET_RATE_PRECISION)
 		.add(ONE);
 	const depositInterest = bank.cumulativeDepositInterest
 		.mul(modifiedDepositRate)
 		.div(ONE_YEAR)
-		.div(SPOT_MARKET_INTEREST_PRECISION);
+		.div(SPOT_MARKET_RATE_PRECISION);
 
 	return { borrowInterest, depositInterest };
 }

package/src/math/spotPosition.ts

@@ -31,14 +31,14 @@ export function getWorstCaseTokenAmounts(
 
 	if (tokenAmountAllAsksFill.abs().gt(tokenAmountAllBidsFill.abs())) {
 		const worstCaseQuoteTokenAmount = getTokenValue(
-			spotPosition.openBids.neg(),
+			spotPosition.openAsks.neg(),
 			spotMarketAccount.decimals,
 			oraclePriceData
 		);
 		return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
 	} else {
 		const worstCaseQuoteTokenAmount = getTokenValue(
-			spotPosition.openAsks.neg(),
+			spotPosition.openBids.neg(),
 			spotMarketAccount.decimals,
 			oraclePriceData
 		);

package/src/math/trade.ts

@@ -2,7 +2,7 @@ import { PerpMarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	PEG_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	ZERO,
@@ -10,7 +10,7 @@ import {
 import {
 	calculateBidPrice,
 	calculateAskPrice,
-	calculateMarkPrice,
+	calculateReservePrice,
 } from './market';
 import {
 	calculateAmmReservesAfterSwap,
@@ -48,13 +48,13 @@ export type PriceImpactUnit =
  * @param useSpread whether to consider spread with calculating slippage
  * @return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice]
  *
- * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'entryPrice' => the average price of the trade : Precision MARK_PRICE_PRECISION
+ * 'entryPrice' => the average price of the trade : Precision PRICE_PRECISION
  *
- * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
+ * 'newPrice' => the price of the asset after the trade : Precision PRICE_PRECISION
  */
 export function calculateTradeSlippage(
 	direction: PositionDirection,
@@ -73,7 +73,7 @@ export function calculateTradeSlippage(
 			oldPrice = calculateBidPrice(market, oraclePriceData);
 		}
 	} else {
-		oldPrice = calculateMarkPrice(market, oraclePriceData);
+		oldPrice = calculateReservePrice(market, oraclePriceData);
 	}
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO, oldPrice, oldPrice];
@@ -90,7 +90,7 @@ export function calculateTradeSlippage(
 
 	const entryPrice = acquiredQuoteAssetAmount
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(acquiredBaseReserve.abs());
 
 	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
@@ -121,12 +121,12 @@ export function calculateTradeSlippage(
 
 	const pctMaxSlippage = newPrice
 		.sub(oldPrice)
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(oldPrice)
 		.abs();
 	const pctAvgSlippage = entryPrice
 		.sub(oldPrice)
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(oldPrice)
 		.abs();
 
@@ -199,8 +199,8 @@ export function calculateTradeAcquiredAmounts(
  * [
  *   direction => direction of trade required, PositionDirection
  *   tradeSize => size of trade required, TODO-PRECISION
- *   entryPrice => the entry price for the trade, MARK_PRICE_PRECISION
- *   targetPrice => the target price MARK_PRICE_PRECISION
+ *   entryPrice => the entry price for the trade, PRICE_PRECISION
+ *   targetPrice => the target price PRICE_PRECISION
  * ]
  */
 export function calculateTargetPriceTrade(
@@ -215,7 +215,7 @@ export function calculateTargetPriceTrade(
 	assert(targetPrice.gt(ZERO));
 	assert(pct.lte(MAXPCT) && pct.gt(ZERO));
 
-	const markPriceBefore = calculateMarkPrice(market, oraclePriceData);
+	const markPriceBefore = calculateReservePrice(market, oraclePriceData);
 	const bidPriceBefore = calculateBidPrice(market, oraclePriceData);
 	const askPriceBefore = calculateAskPrice(market, oraclePriceData);
 
@@ -252,7 +252,7 @@ export function calculateTargetPriceTrade(
 	}
 
 	const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
-	const k = invariant.mul(MARK_PRICE_PRECISION);
+	const k = invariant.mul(PRICE_PRECISION);
 
 	let baseAssetReserveAfter;
 	let quoteAssetReserveAfter;
@@ -277,9 +277,7 @@ export function calculateTargetPriceTrade(
 		baseAssetReserveAfter = squareRootBN(
 			k.div(targetPrice).mul(peg).div(PEG_PRECISION).sub(biasModifier)
 		).sub(new BN(1));
-		quoteAssetReserveAfter = k
-			.div(MARK_PRICE_PRECISION)
-			.div(baseAssetReserveAfter);
+		quoteAssetReserveAfter = k.div(PRICE_PRECISION).div(baseAssetReserveAfter);
 
 		markPriceAfter = calculatePrice(
 			baseAssetReserveAfter,
@@ -298,9 +296,7 @@ export function calculateTargetPriceTrade(
 		baseAssetReserveAfter = squareRootBN(
 			k.div(targetPrice).mul(peg).div(PEG_PRECISION).add(biasModifier)
 		).add(new BN(1));
-		quoteAssetReserveAfter = k
-			.div(MARK_PRICE_PRECISION)
-			.div(baseAssetReserveAfter);
+		quoteAssetReserveAfter = k.div(PRICE_PRECISION).div(baseAssetReserveAfter);
 
 		markPriceAfter = calculatePrice(
 			baseAssetReserveAfter,
@@ -334,7 +330,7 @@ export function calculateTargetPriceTrade(
 
 	const entryPrice = tradeSize
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(baseSize.abs());
 
 	assert(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');

package/src/oracles/pythClient.ts

@@ -2,7 +2,7 @@ import { parsePriceData } from '@pythnetwork/client';
 import { Connection, PublicKey } from '@solana/web3.js';
 import { OracleClient, OraclePriceData } from './types';
 import { BN } from '@project-serum/anchor';
-import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
+import { PRICE_PRECISION, TEN } from '../constants/numericConstants';
 
 export class PythClient implements OracleClient {
 	private connection: Connection;
@@ -38,6 +38,6 @@ export function convertPythPrice(price: number, exponent: number): BN {
 	exponent = Math.abs(exponent);
 	const pythPrecision = TEN.pow(new BN(exponent).abs());
 	return new BN(price * Math.pow(10, exponent))
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(pythPrecision);
 }

package/src/oracles/quoteAssetOracleClient.ts

@@ -1,10 +1,10 @@
 import { PublicKey } from '@solana/web3.js';
 import { OracleClient, OraclePriceData } from './types';
 import { BN } from '@project-serum/anchor';
-import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
+import { PRICE_PRECISION } from '../constants/numericConstants';
 
 export const QUOTE_ORACLE_PRICE_DATA: OraclePriceData = {
-	price: MARK_PRICE_PRECISION,
+	price: PRICE_PRECISION,
 	slot: new BN(0),
 	confidence: new BN(1),
 	hasSufficientNumberOfDataPoints: true,