@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.0

package/src/math/bankBalance.ts

@@ -0,0 +1,112 @@
+import { BankAccount, BankBalanceType, isVariant } from '../types';
+import { BN } from '@project-serum/anchor';
+import {
+	BANK_UTILIZATION_PRECISION,
+	ONE,
+	TEN,
+	ZERO,
+	BANK_INTEREST_PRECISION,
+	ONE_YEAR,
+} from '../constants/numericConstants';
+
+export function getBalance(
+	tokenAmount: BN,
+	bank: BankAccount,
+	balanceType: BankBalanceType
+): BN {
+	const precisionIncrease = TEN.pow(new BN(16 - bank.decimals));
+
+	const cumulativeInterest = isVariant(balanceType, 'deposit')
+		? bank.cumulativeDepositInterest
+		: bank.cumulativeBorrowInterest;
+
+	let balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
+
+	if (!balance.eq(ZERO) && isVariant(balanceType, 'borrow')) {
+		balance = balance.add(ONE);
+	}
+
+	return balance;
+}
+
+export function getTokenAmount(
+	balanceAmount: BN,
+	bank: BankAccount,
+	balanceType: BankBalanceType
+): BN {
+	const precisionDecrease = TEN.pow(new BN(16 - bank.decimals));
+
+	const cumulativeInterest = isVariant(balanceType, 'deposit')
+		? bank.cumulativeDepositInterest
+		: bank.cumulativeBorrowInterest;
+
+	return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
+}
+
+export function calculateInterestAccumulated(
+	bank: BankAccount,
+	now: BN
+): { borrowInterest: BN; depositInterest: BN } {
+	const token_deposit_amount = getTokenAmount(
+		bank.depositBalance,
+		bank,
+		BankBalanceType.DEPOSIT
+	);
+	const token_borrow_amount = getTokenAmount(
+		bank.borrowBalance,
+		bank,
+		BankBalanceType.BORROW
+	);
+
+	let utilization: BN;
+	if (token_borrow_amount.eq(ZERO) && token_deposit_amount.eq(ZERO)) {
+		utilization = ZERO;
+	} else if (token_deposit_amount.eq(ZERO)) {
+		utilization = BANK_UTILIZATION_PRECISION;
+	} else {
+		utilization = token_borrow_amount
+			.mul(BANK_UTILIZATION_PRECISION)
+			.div(token_deposit_amount);
+	}
+
+	let interest_rate: BN;
+	if (utilization.gt(bank.optimalUtilization)) {
+		const surplusUtilization = utilization.sub(bank.optimalUtilization);
+		const borrowRateSlope = bank.maxBorrowRate
+			.sub(bank.optimalBorrowRate)
+			.mul(BANK_UTILIZATION_PRECISION)
+			.div(BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+
+		interest_rate = bank.optimalBorrowRate.add(
+			surplusUtilization.mul(borrowRateSlope).div(BANK_UTILIZATION_PRECISION)
+		);
+	} else {
+		const borrowRateSlope = bank.optimalBorrowRate
+			.mul(BANK_UTILIZATION_PRECISION)
+			.div(BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+
+		interest_rate = utilization
+			.mul(borrowRateSlope)
+			.div(BANK_UTILIZATION_PRECISION);
+	}
+
+	const timeSinceLastUpdate = now.sub(bank.lastUpdated);
+
+	const modifiedBorrowRate = interest_rate.mul(timeSinceLastUpdate);
+
+	const modifiedDepositRate = modifiedBorrowRate
+		.mul(utilization)
+		.div(BANK_UTILIZATION_PRECISION);
+
+	const borrowInterest = bank.cumulativeBorrowInterest
+		.mul(modifiedBorrowRate)
+		.div(ONE_YEAR)
+		.div(BANK_INTEREST_PRECISION)
+		.add(ONE);
+	const depositInterest = bank.cumulativeDepositInterest
+		.mul(modifiedDepositRate)
+		.div(ONE_YEAR)
+		.div(BANK_INTEREST_PRECISION);
+
+	return { borrowInterest, depositInterest };
+}

package/src/math/conversion.ts

@@ -1,8 +1,5 @@
 import { BN } from '../';
-import {
-	MARK_PRICE_PRECISION,
-	PEG_PRECISION,
-} from '../constants/numericConstants';
+import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
 
 export const convertToNumber = (
 	bigNumber: BN,
@@ -14,10 +11,3 @@ export const convertToNumber = (
 		bigNumber.mod(precision).toNumber() / precision.toNumber()
 	);
 };
-
-export const convertBaseAssetAmountToNumber = (baseAssetAmount: BN) => {
-	return convertToNumber(
-		baseAssetAmount,
-		MARK_PRICE_PRECISION.mul(PEG_PRECISION)
-	);
-};

package/src/math/funding.ts

@@ -5,7 +5,7 @@ import {
 	QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
-import { Market } from '../types';
+import { MarketAccount } from '../types';
 import { calculateMarkPrice } from './market';
 import { OraclePriceData } from '../oracles/types';
 
@@ -17,7 +17,7 @@ import { OraclePriceData } from '../oracles/types';
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateAllEstimatedFundingRate(
-	market: Market,
+	market: MarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN, BN]> {
@@ -48,7 +48,10 @@ export async function calculateAllEstimatedFundingRate(
 		secondsInHour,
 		BN.max(ZERO, secondsInHour.sub(timeSinceLastMarkChange))
 	);
-	const baseAssetPriceWithMantissa = calculateMarkPrice(market);
+	const baseAssetPriceWithMantissa = calculateMarkPrice(
+		market,
+		oraclePriceData
+	);
 
 	const markTwapWithMantissa = markTwapTimeSinceLastUpdate
 		.mul(lastMarkTwapWithMantissa)
@@ -205,7 +208,7 @@ export async function calculateAllEstimatedFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateEstimatedFundingRate(
-	market: Market,
+	market: MarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1),
 	estimationMethod?: 'interpolated' | 'lowerbound' | 'capped'
@@ -235,7 +238,7 @@ export async function calculateEstimatedFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateLongShortFundingRate(
-	market: Market,
+	market: MarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN]> {
@@ -263,7 +266,7 @@ export async function calculateLongShortFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateLongShortFundingRateAndLiveTwaps(
-	market: Market,
+	market: MarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN]> {
@@ -288,14 +291,14 @@ export async function calculateLongShortFundingRateAndLiveTwaps(
  * @param market
  * @returns Estimated fee pool size
  */
-export function calculateFundingPool(market: Market): BN {
+export function calculateFundingPool(market: MarketAccount): BN {
 	// todo
-	const totalFeeLB = market.amm.totalFee.div(new BN(2));
+	const totalFeeLB = market.amm.totalExchangeFee.div(new BN(2));
 	const feePool = BN.max(
 		ZERO,
 		market.amm.totalFeeMinusDistributions
 			.sub(totalFeeLB)
-			.mul(new BN(2))
+			.mul(new BN(1))
 			.div(new BN(3))
 	);
 	return feePool;

package/src/math/market.ts

@@ -1,10 +1,11 @@
 import { BN } from '@project-serum/anchor';
-import { Market, PositionDirection } from '../types';
+import { MarketAccount, PositionDirection } from '../types';
 import {
 	calculateAmmReservesAfterSwap,
 	calculatePrice,
-	calculateSpreadReserves,
+	calculateUpdatedAMMSpreadReserves,
 	getSwapDirection,
+	calculateUpdatedAMM,
 } from './amm';
 import { OraclePriceData } from '../oracles/types';
 
@@ -14,11 +15,15 @@ import { OraclePriceData } from '../oracles/types';
  * @param market
  * @return markPrice : Precision MARK_PRICE_PRECISION
  */
-export function calculateMarkPrice(market: Market): BN {
+export function calculateMarkPrice(
+	market: MarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const newAmm = calculateUpdatedAMM(market.amm, oraclePriceData);
 	return calculatePrice(
-		market.amm.baseAssetReserve,
-		market.amm.quoteAssetReserve,
-		market.amm.pegMultiplier
+		newAmm.baseAssetReserve,
+		newAmm.quoteAssetReserve,
+		newAmm.pegMultiplier
 	);
 }
 
@@ -28,17 +33,18 @@ export function calculateMarkPrice(market: Market): BN {
  * @param market
  * @return bidPrice : Precision MARK_PRICE_PRECISION
  */
-export function calculateBidPrice(market: Market): BN {
-	const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-		market.amm,
-		PositionDirection.SHORT
-	);
+export function calculateBidPrice(
+	market: MarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const { baseAssetReserve, quoteAssetReserve, newPeg } =
+		calculateUpdatedAMMSpreadReserves(
+			market.amm,
+			PositionDirection.SHORT,
+			oraclePriceData
+		);
 
-	return calculatePrice(
-		baseAssetReserve,
-		quoteAssetReserve,
-		market.amm.pegMultiplier
-	);
+	return calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
 }
 
 /**
@@ -47,24 +53,25 @@ export function calculateBidPrice(market: Market): BN {
  * @param market
  * @return bidPrice : Precision MARK_PRICE_PRECISION
  */
-export function calculateAskPrice(market: Market): BN {
-	const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-		market.amm,
-		PositionDirection.LONG
-	);
+export function calculateAskPrice(
+	market: MarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const { baseAssetReserve, quoteAssetReserve, newPeg } =
+		calculateUpdatedAMMSpreadReserves(
+			market.amm,
+			PositionDirection.LONG,
+			oraclePriceData
+		);
 
-	return calculatePrice(
-		baseAssetReserve,
-		quoteAssetReserve,
-		market.amm.pegMultiplier
-	);
+	return calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
 }
 
 export function calculateNewMarketAfterTrade(
 	baseAssetAmount: BN,
 	direction: PositionDirection,
-	market: Market
-): Market {
+	market: MarketAccount
+): MarketAccount {
 	const [newQuoteAssetReserve, newBaseAssetReserve] =
 		calculateAmmReservesAfterSwap(
 			market.amm,
@@ -83,10 +90,10 @@ export function calculateNewMarketAfterTrade(
 }
 
 export function calculateMarkOracleSpread(
-	market: Market,
+	market: MarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
-	const markPrice = calculateMarkPrice(market);
+	const markPrice = calculateMarkPrice(market, oraclePriceData);
 	return calculateOracleSpread(markPrice, oraclePriceData);
 }
 

package/src/math/orders.ts

@@ -1,6 +1,9 @@
 import { ClearingHouseUser } from '../clearingHouseUser';
 import { isVariant, Order } from '../types';
 import { ZERO, TWO } from '../constants/numericConstants';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+import { getAuctionPrice } from './auction';
 
 export function isOrderRiskIncreasing(
 	user: ClearingHouseUser,
@@ -106,3 +109,38 @@ export function isOrderReduceOnly(
 
 	return true;
 }
+
+export function standardizeBaseAssetAmount(
+	baseAssetAmount: BN,
+	stepSize: BN
+): BN {
+	const remainder = baseAssetAmount.mod(stepSize);
+	return baseAssetAmount.sub(remainder);
+}
+
+export function getLimitPrice(
+	order: Order,
+	oraclePriceData: OraclePriceData,
+	slot: number
+): BN {
+	let limitPrice;
+	if (!order.oraclePriceOffset.eq(ZERO)) {
+		const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+		if (order.postOnly) {
+			limitPrice = isVariant(order.direction, 'long')
+				? BN.min(order.price, floatingPrice)
+				: BN.max(order.price, floatingPrice);
+		} else {
+			limitPrice = floatingPrice;
+		}
+	} else if (
+		isVariant(order.orderType, 'market') ||
+		isVariant(order.orderType, 'triggerMarket')
+	) {
+		limitPrice = getAuctionPrice(order, slot);
+	} else {
+		limitPrice = order.price;
+	}
+
+	return limitPrice;
+}

package/src/math/position.ts

@@ -9,29 +9,54 @@ import {
 	PRICE_TO_QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
-import { Market, PositionDirection, UserPosition } from '../types';
-import { calculateAmmReservesAfterSwap, getSwapDirection } from './amm';
-import { SETTLEMENT_RATIO_PRECISION, SETTLEMENT_RATIOS } from '../settlement';
+import { OraclePriceData } from '../oracles/types';
+import { MarketAccount, PositionDirection, UserPosition } from '../types';
+import {
+	calculateUpdatedAMM,
+	calculateUpdatedAMMSpreadReserves,
+	calculateAmmReservesAfterSwap,
+	getSwapDirection,
+} from './amm';
 
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
  * @param market
  * @param userPosition
+ * @param oraclePriceData
  * @returns Base Asset Value. : Precision QUOTE_PRECISION
  */
 export function calculateBaseAssetValue(
-	market: Market,
-	userPosition: UserPosition
+	market: MarketAccount,
+	userPosition: UserPosition,
+	oraclePriceData: OraclePriceData
 ): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
 	}
 
 	const directionToClose = findDirectionToClose(userPosition);
+	let prepegAmm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
+
+	if (market.amm.baseSpread > 0) {
+		const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+			calculateUpdatedAMMSpreadReserves(
+				market.amm,
+				directionToClose,
+				oraclePriceData
+			);
+		prepegAmm = {
+			baseAssetReserve,
+			quoteAssetReserve,
+			sqrtK: sqrtK,
+			pegMultiplier: newPeg,
+		};
+	} else {
+		prepegAmm = calculateUpdatedAMM(market.amm, oraclePriceData);
+	}
 
 	const [newQuoteAssetReserve, _] = calculateAmmReservesAfterSwap(
-		market.amm,
+		prepegAmm,
 		'base',
 		userPosition.baseAssetAmount.abs(),
 		getSwapDirection('base', directionToClose)
@@ -39,15 +64,15 @@ export function calculateBaseAssetValue(
 
 	switch (directionToClose) {
 		case PositionDirection.SHORT:
-			return market.amm.quoteAssetReserve
+			return prepegAmm.quoteAssetReserve
 				.sub(newQuoteAssetReserve)
-				.mul(market.amm.pegMultiplier)
+				.mul(prepegAmm.pegMultiplier)
 				.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
 
 		case PositionDirection.LONG:
 			return newQuoteAssetReserve
-				.sub(market.amm.quoteAssetReserve)
-				.mul(market.amm.pegMultiplier)
+				.sub(prepegAmm.quoteAssetReserve)
+				.mul(prepegAmm.pegMultiplier)
 				.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
 				.add(ONE);
 	}
@@ -62,15 +87,20 @@ export function calculateBaseAssetValue(
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 export function calculatePositionPNL(
-	market: Market,
+	market: MarketAccount,
 	marketPosition: UserPosition,
-	withFunding = false
+	withFunding = false,
+	oraclePriceData: OraclePriceData
 ): BN {
 	if (marketPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
 	}
 
-	const baseAssetValue = calculateBaseAssetValue(market, marketPosition);
+	const baseAssetValue = calculateBaseAssetValue(
+		market,
+		marketPosition,
+		oraclePriceData
+	);
 
 	let pnl;
 	if (marketPosition.baseAssetAmount.gt(ZERO)) {
@@ -91,27 +121,6 @@ export function calculatePositionPNL(
 	return pnl;
 }
 
-export function calculateSettledPositionPNL(
-	market: Market,
-	marketPosition: UserPosition
-): BN {
-	let pnl = calculatePositionPNL(market, marketPosition);
-
-	if (pnl.gt(ZERO)) {
-		try {
-			pnl = pnl
-				.mul(new BN(SETTLEMENT_RATIOS[marketPosition.marketIndex.toNumber()]))
-				.div(SETTLEMENT_RATIO_PRECISION);
-		} catch (e) {
-			console.log(pnl.toString());
-			console.log(marketPosition.marketIndex.toNumber());
-			throw e;
-		}
-	}
-
-	return pnl;
-}
-
 /**
  *
  * @param market
@@ -119,7 +128,7 @@ export function calculateSettledPositionPNL(
  * @returns // TODO-PRECISION
  */
 export function calculatePositionFundingPNL(
-	market: Market,
+	market: MarketAccount,
 	marketPosition: UserPosition
 ): BN {
 	if (marketPosition.baseAssetAmount.eq(ZERO)) {
@@ -143,6 +152,10 @@ export function calculatePositionFundingPNL(
 	return perPositionFundingRate;
 }
 
+export function positionIsAvailable(position: UserPosition): boolean {
+	return position.baseAssetAmount.eq(ZERO) && position.openOrders.eq(ZERO);
+}
+
 /**
  *
  * @param userPosition

package/src/math/repeg.ts

@@ -0,0 +1,175 @@
+import { BN } from '@project-serum/anchor';
+import { assert } from '../assert/assert';
+import {
+	MARK_PRICE_PRECISION,
+	AMM_RESERVE_PRECISION,
+	PEG_PRECISION,
+	AMM_TO_QUOTE_PRECISION_RATIO,
+	QUOTE_PRECISION,
+	ZERO,
+} from '../constants/numericConstants';
+import { AMM } from '../types';
+/**
+ * Helper function calculating adjust k cost
+ * @param amm
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateAdjustKCost(
+	amm: AMM,
+	numerator: BN,
+	denomenator: BN
+): BN {
+	// const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+	const x = amm.baseAssetReserve;
+	const y = amm.quoteAssetReserve;
+
+	const d = amm.netBaseAssetAmount;
+	const Q = amm.pegMultiplier;
+
+	const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
+
+	const p = numerator.mul(MARK_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(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(PEG_PRECISION);
+
+	return cost.mul(new BN(-1));
+}
+
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param amm
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateRepegCost(amm: AMM, newPeg: BN): BN {
+	const dqar = amm.quoteAssetReserve.sub(amm.terminalQuoteAssetReserve);
+	const cost = dqar
+		.mul(newPeg.sub(amm.pegMultiplier))
+		.div(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(PEG_PRECISION);
+	return cost;
+}
+
+export function calculateBudgetedKBN(
+	x: BN,
+	y: BN,
+	budget: BN,
+	Q: BN,
+	d: BN
+): [BN, BN] {
+	assert(Q.gt(new BN(0)));
+	const C = budget.mul(new BN(-1));
+
+	let dSign = new BN(1);
+	if (d.lt(new BN(0))) {
+		dSign = new BN(-1);
+	}
+	const pegged_y_d_d = y
+		.mul(d)
+		.mul(d)
+		.mul(Q)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_RESERVE_PRECISION)
+		.div(PEG_PRECISION);
+
+	const numer1 = pegged_y_d_d;
+	const numer2 = C.mul(d)
+		.div(QUOTE_PRECISION)
+		.mul(x.add(d))
+		.div(AMM_RESERVE_PRECISION)
+		.mul(dSign);
+
+	const denom1 = C.mul(x)
+		.mul(x.add(d))
+		.div(AMM_RESERVE_PRECISION)
+		.div(QUOTE_PRECISION);
+	const denom2 = pegged_y_d_d;
+
+	const numerator = numer1.sub(numer2).div(AMM_TO_QUOTE_PRECISION_RATIO);
+	const denominator = denom1.add(denom2).div(AMM_TO_QUOTE_PRECISION_RATIO);
+
+	return [numerator, denominator];
+}
+
+export function calculateBudgetedK(amm: AMM, cost: BN): [BN, BN] {
+	// wolframalpha.com
+	// (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+	// p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*d*d*Q)
+
+	// numer
+	//   =  y*d*d*Q - Cxd - Cdd
+	//   =  y/x*Q*d*d - Cd - Cd/x
+	//   = mark      - C/d - C/(x)
+	//   =  mark/C    - 1/d - 1/x
+
+	// denom
+	// = C*x*x + C*x*d + y*d*d*Q
+	// = x/d**2 + 1 / d + mark/C
+
+	// todo: assumes k = x * y
+	// otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+
+	const x = amm.baseAssetReserve;
+	const y = amm.quoteAssetReserve;
+
+	const d = amm.netBaseAssetAmount;
+	const Q = amm.pegMultiplier;
+
+	const [numerator, denominator] = calculateBudgetedKBN(x, y, cost, Q, d);
+
+	return [numerator, denominator];
+}
+
+export function calculateBudgetedPeg(amm: AMM, cost: BN, targetPrice: BN): BN {
+	// wolframalpha.com
+	// (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+	// p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+
+	// todo: assumes k = x * y
+	// otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+	const targetPeg = targetPrice
+		.mul(amm.baseAssetReserve)
+		.div(amm.quoteAssetReserve)
+		.div(MARK_PRICE_PRECISION.div(PEG_PRECISION));
+
+	const k = amm.sqrtK.mul(amm.sqrtK);
+	const x = amm.baseAssetReserve;
+	const y = amm.quoteAssetReserve;
+
+	const d = amm.netBaseAssetAmount;
+	const Q = amm.pegMultiplier;
+
+	const C = cost.mul(new BN(-1));
+
+	const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
+	const pegChangeDirection = targetPeg.sub(Q);
+
+	const useTargetPeg =
+		(deltaQuoteAssetReserves.lt(ZERO) && pegChangeDirection.gt(ZERO)) ||
+		(deltaQuoteAssetReserves.gt(ZERO) && pegChangeDirection.lt(ZERO));
+
+	if (deltaQuoteAssetReserves.eq(ZERO) || useTargetPeg) {
+		return targetPeg;
+	}
+
+	const deltaPegMultiplier = C.mul(MARK_PRICE_PRECISION).div(
+		deltaQuoteAssetReserves.div(AMM_TO_QUOTE_PRECISION_RATIO)
+	);
+	const newPeg = Q.sub(
+		deltaPegMultiplier.mul(PEG_PRECISION).div(MARK_PRICE_PRECISION)
+	);
+
+	return newPeg;
+}