@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/math/position.ts

@@ -1,381 +0,0 @@
-import { BN } from '../isomorphic/anchor';
-import {
-	AMM_RESERVE_PRECISION,
-	AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO,
-	AMM_TO_QUOTE_PRECISION_RATIO,
-	FUNDING_RATE_BUFFER_PRECISION,
-	PRICE_PRECISION,
-	ONE,
-	ZERO,
-} from '../constants/numericConstants';
-import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
-import {
-	PerpMarketAccount,
-	PositionDirection,
-	PerpPosition,
-	SpotMarketAccount,
-	PositionFlag,
-} from '../types';
-import {
-	calculateUpdatedAMM,
-	calculateUpdatedAMMSpreadReserves,
-	calculateAmmReservesAfterSwap,
-	getSwapDirection,
-} from './amm';
-import { calculateBaseAssetValueWithOracle } from './margin';
-import { calculateNetUserPnlImbalance } from './market';
-
-/**
- * Simulates fully closing `userPosition` against the AMM (optionally through its bid/ask
- * spread reserves) and returns the resulting quote value — i.e. the market value of closing
- * the entire position right now, distinct from `calculateBaseAssetValueWithOracle`'s
- * mark-to-oracle valuation used for margin.
- * @param market Perp market whose AMM is used to price the close.
- * @param userPosition Position to value; returns zero if flat (`baseAssetAmount == 0`).
- * @param mmOraclePriceData MM oracle price data used to re-peg/update the AMM before pricing (unless `skipUpdate`).
- * @param useSpread If true (default) and the market has a nonzero base spread, price through the bid/ask spread reserves on the closing side rather than the raw AMM reserves.
- * @param skipUpdate If true, price against `market.amm` as-is without applying `calculateUpdatedAMM`/spread-reserve updates first (default false).
- * @param latestSlot Current slot, forwarded to the spread-reserve update for reference-price-offset smoothing.
- * @returns Value of fully closing the position, QUOTE_PRECISION (1e6).
- */
-export function calculateBaseAssetValue(
-	market: PerpMarketAccount,
-	userPosition: PerpPosition,
-	mmOraclePriceData: MMOraclePriceData,
-	useSpread = true,
-	skipUpdate = false,
-	latestSlot?: BN
-): BN {
-	if (userPosition.baseAssetAmount.eq(ZERO)) {
-		return ZERO;
-	}
-
-	const directionToClose = findDirectionToClose(userPosition);
-	let prepegAmm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
-
-	if (!skipUpdate) {
-		if (market.amm.baseSpread > 0 && useSpread) {
-			const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
-				calculateUpdatedAMMSpreadReserves(
-					market.amm,
-					market.marketStats,
-					directionToClose,
-					mmOraclePriceData,
-					latestSlot
-				);
-			prepegAmm = {
-				baseAssetReserve,
-				quoteAssetReserve,
-				sqrtK: sqrtK,
-				pegMultiplier: newPeg,
-			};
-		} else {
-			prepegAmm = calculateUpdatedAMM(market.amm, mmOraclePriceData);
-		}
-	} else {
-		prepegAmm = market.amm;
-	}
-
-	const [newQuoteAssetReserve, _] = calculateAmmReservesAfterSwap(
-		prepegAmm,
-		'base',
-		userPosition.baseAssetAmount.abs(),
-		getSwapDirection('base', directionToClose)
-	);
-
-	switch (directionToClose) {
-		case PositionDirection.SHORT:
-			return prepegAmm.quoteAssetReserve
-				.sub(newQuoteAssetReserve)
-				.mul(prepegAmm.pegMultiplier)
-				.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-
-		case PositionDirection.LONG:
-			return newQuoteAssetReserve
-				.sub(prepegAmm.quoteAssetReserve)
-				.mul(prepegAmm.pegMultiplier)
-				.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
-				.add(ONE);
-
-		default:
-			throw new Error('Invalid position direction to close');
-	}
-}
-
-/**
- * Calculates a position's unrealized pnl, marked to the oracle price (via
- * `calculateBaseAssetValueWithOracle`) rather than the AMM close price. For a flat position
- * this is simply `quoteAssetAmount` (any residual realized/settled pnl still on the position).
- * @param market Perp market the position belongs to.
- * @param perpPosition Position to value.
- * @param withFunding If true, adds unsettled funding pnl (`calculateUnsettledFundingPnl`) to the result (default false).
- * @param oraclePriceData Must provide `price`, PRICE_PRECISION (1e6); used unless the market is in `settlement` status (which uses `market.expiryPrice` internally).
- * @returns Unrealized pnl, QUOTE_PRECISION (1e6, signed).
- */
-export function calculatePositionPNL(
-	market: PerpMarketAccount,
-	perpPosition: PerpPosition,
-	withFunding = false,
-	oraclePriceData: Pick<OraclePriceData, 'price'>
-): BN {
-	if (perpPosition.baseAssetAmount.eq(ZERO)) {
-		return perpPosition.quoteAssetAmount;
-	}
-
-	const baseAssetValue = calculateBaseAssetValueWithOracle(
-		market,
-		perpPosition,
-		oraclePriceData
-	);
-
-	const baseAssetValueSign = perpPosition.baseAssetAmount.isNeg()
-		? new BN(-1)
-		: new BN(1);
-	let pnl = baseAssetValue
-		.mul(baseAssetValueSign)
-		.add(perpPosition.quoteAssetAmount);
-
-	if (withFunding) {
-		const fundingRatePnL = calculateUnsettledFundingPnl(market, perpPosition);
-		pnl = pnl.add(fundingRatePnL);
-	}
-
-	return pnl;
-}
-
-/**
- * Caps a position's unrealized pnl (incl. funding) to the amount actually settleable via
- * `settle_pnl`, mirroring `PerpPosition::get_claimable_pnl` in
- * `programs/velocity/src/state/user.rs`. Positive pnl can only be settled up to whichever is
- * larger: pnl already realized by reducing the position (`quoteAssetAmount -
- * quoteEntryAmount`, floored at zero) plus any pnl-pool surplus over the market's net user
- * pnl (`calculateNetUserPnlImbalance`, negated and floored at zero). Negative pnl passes
- * through uncapped — this function does not itself gate on margin requirements (the program
- * separately blocks settling negative pnl for a user who wouldn't meet maintenance margin
- * afterward).
- * @param market Perp market the position belongs to.
- * @param spotMarket Quote spot market, used to size the pnl pool via `calculateNetUserPnlImbalance`.
- * @param perpPosition Position to evaluate.
- * @param oraclePriceData Must provide `price`, PRICE_PRECISION (1e6).
- * @returns Settleable pnl, QUOTE_PRECISION (1e6, signed) — equal to unrealized pnl if negative or uncapped, otherwise capped.
- */
-export function calculateClaimablePnl(
-	market: PerpMarketAccount,
-	spotMarket: SpotMarketAccount,
-	perpPosition: PerpPosition,
-	oraclePriceData: Pick<OraclePriceData, 'price'>
-): BN {
-	const unrealizedPnl = calculatePositionPNL(
-		market,
-		perpPosition,
-		true,
-		oraclePriceData
-	);
-
-	let unsettledPnl = unrealizedPnl;
-	if (unrealizedPnl.gt(ZERO)) {
-		const excessPnlPool = BN.max(
-			ZERO,
-			calculateNetUserPnlImbalance(market, spotMarket, oraclePriceData).mul(
-				new BN(-1)
-			)
-		);
-
-		const maxPositivePnl = BN.max(
-			perpPosition.quoteAssetAmount.sub(perpPosition.quoteEntryAmount),
-			ZERO
-		).add(excessPnlPool);
-
-		unsettledPnl = BN.min(maxPositivePnl, unrealizedPnl);
-	}
-	return unsettledPnl;
-}
-
-/**
- * Returns the cumulative fees-plus-funding component of a position's pnl (i.e. the part of
- * pnl not explained by price movement): settled funding/fees so far
- * (`quoteBreakEvenAmount - quoteEntryAmount`) plus, optionally, unsettled funding accrued
- * since the last funding settlement.
- * @param market Perp market the position belongs to.
- * @param perpPosition Position to evaluate.
- * @param includeUnsettled If true (default), adds `calculateUnsettledFundingPnl` to the result.
- * @returns Fees + funding pnl, QUOTE_PRECISION (1e6, signed).
- */
-export function calculateFeesAndFundingPnl(
-	market: PerpMarketAccount,
-	perpPosition: PerpPosition,
-	includeUnsettled = true
-): BN {
-	const settledFundingAndFeesPnl = perpPosition.quoteBreakEvenAmount.sub(
-		perpPosition.quoteEntryAmount
-	);
-
-	if (!includeUnsettled) {
-		return settledFundingAndFeesPnl;
-	}
-
-	const unsettledFundingPnl = calculateUnsettledFundingPnl(
-		market,
-		perpPosition
-	);
-
-	return settledFundingAndFeesPnl.add(unsettledFundingPnl);
-}
-
-/**
- * Returns unsettled funding pnl accrued on the position since its last funding settlement:
- * the delta between the market's current cumulative funding rate (long or short side,
- * selected by position direction) and the position's `lastCumulativeFundingRate`, applied to
- * `baseAssetAmount`. Zero for a flat position.
- *
- * To calculate all fees and funding pnl including settled, use `calculateFeesAndFundingPnl`.
- *
- * @param market Perp market the position belongs to; uses `cumulativeFundingRateLong`/`cumulativeFundingRateShort`.
- * @param perpPosition Position to evaluate.
- * @returns Unsettled funding pnl, QUOTE_PRECISION (1e6, signed).
- */
-export function calculateUnsettledFundingPnl(
-	market: PerpMarketAccount,
-	perpPosition: PerpPosition
-): BN {
-	if (perpPosition.baseAssetAmount.eq(ZERO)) {
-		return ZERO;
-	}
-
-	let ammCumulativeFundingRate: BN;
-	if (perpPosition.baseAssetAmount.gt(ZERO)) {
-		ammCumulativeFundingRate = market.cumulativeFundingRateLong;
-	} else {
-		ammCumulativeFundingRate = market.cumulativeFundingRateShort;
-	}
-
-	const perPositionFundingRate = ammCumulativeFundingRate
-		.sub(perpPosition.lastCumulativeFundingRate)
-		.mul(perpPosition.baseAssetAmount)
-		.div(AMM_RESERVE_PRECISION)
-		.div(FUNDING_RATE_BUFFER_PRECISION)
-		.mul(new BN(-1));
-
-	return perPositionFundingRate;
-}
-
-/**
- * True if a `PerpPosition` slot is free to be reused for a different market, mirroring
- * `PerpPosition::is_available` in `programs/velocity/src/state/user.rs`: no open base
- * position, no open orders, no unsettled quote pnl, no isolated-margin collateral parked in
- * it (`isolatedPositionScaledBalance == 0`), and not currently mid-liquidation/bankruptcy.
- * An isolated position with collateral still deposited is never "available" even if flat,
- * since that collateral must be withdrawn first.
- * @param position Position slot to check.
- * @returns `true` if the slot can be assigned to a new market.
- */
-export function positionIsAvailable(position: PerpPosition): boolean {
-	return (
-		position.baseAssetAmount.eq(ZERO) &&
-		position.openOrders === 0 &&
-		position.quoteAssetAmount.eq(ZERO) &&
-		position.isolatedPositionScaledBalance.eq(ZERO) &&
-		!positionIsBeingLiquidated(position)
-	);
-}
-
-/** True if `position.positionFlag` has the `BeingLiquidated` or `Bankruptcy` bit set. */
-export function positionIsBeingLiquidated(position: PerpPosition): boolean {
-	return (
-		(position.positionFlag &
-			(PositionFlag.BeingLiquidated | PositionFlag.Bankruptcy)) >
-		0
-	);
-}
-
-/**
- * Price at which closing the position realizes zero further pnl, i.e. entry price adjusted
- * for fees and funding paid/received so far (`quoteBreakEvenAmount / baseAssetAmount`).
- * @param userPosition Position to evaluate.
- * @returns Break-even price (always non-negative), PRICE_PRECISION (1e6). Zero if flat.
- */
-export function calculateBreakEvenPrice(userPosition: PerpPosition): BN {
-	if (userPosition.baseAssetAmount.eq(ZERO)) {
-		return ZERO;
-	}
-
-	return userPosition.quoteBreakEvenAmount
-		.mul(PRICE_PRECISION)
-		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
-		.div(userPosition.baseAssetAmount)
-		.abs();
-}
-
-/**
- * Average entry price of the position, before fees/funding (`quoteEntryAmount / baseAssetAmount`).
- * @param userPosition Position to evaluate.
- * @returns Average entry price (always non-negative), PRICE_PRECISION (1e6). Zero if flat.
- */
-export function calculateEntryPrice(userPosition: PerpPosition): BN {
-	if (userPosition.baseAssetAmount.eq(ZERO)) {
-		return ZERO;
-	}
-
-	return userPosition.quoteEntryAmount
-		.mul(PRICE_PRECISION)
-		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
-		.div(userPosition.baseAssetAmount)
-		.abs();
-}
-
-/**
- * Cost basis of the position (`quoteAssetAmount / baseAssetAmount`, optionally including
- * realized settled pnl), i.e. the current quote value backing the position expressed per
- * unit of base — this differs from `calculateEntryPrice` whenever the position has
- * accumulated settled pnl or fees since it was opened.
- * @param userPosition Position to evaluate.
- * @param includeSettledPnl If true, folds `userPosition.settledPnl` into the quote amount before dividing (default false).
- * @returns Cost basis (always non-negative), PRICE_PRECISION (1e6). Zero if flat.
- */
-export function calculateCostBasis(
-	userPosition: PerpPosition,
-	includeSettledPnl = false
-): BN {
-	if (userPosition.baseAssetAmount.eq(ZERO)) {
-		return ZERO;
-	}
-
-	return userPosition.quoteAssetAmount
-		.add(includeSettledPnl ? userPosition.settledPnl : ZERO)
-		.mul(PRICE_PRECISION)
-		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
-		.div(userPosition.baseAssetAmount)
-		.abs();
-}
-
-/** Direction of the trade that would fully close `userPosition`: `SHORT` for a long position (base > 0), `LONG` otherwise (including flat). */
-export function findDirectionToClose(
-	userPosition: PerpPosition
-): PositionDirection {
-	return userPosition.baseAssetAmount.gt(ZERO)
-		? PositionDirection.SHORT
-		: PositionDirection.LONG;
-}
-
-/** The position's own directional exposure: `LONG` if `baseAssetAmount >= 0` (including flat), `SHORT` if negative. */
-export function positionCurrentDirection(
-	userPosition: PerpPosition
-): PositionDirection {
-	return userPosition.baseAssetAmount.gte(ZERO)
-		? PositionDirection.LONG
-		: PositionDirection.SHORT;
-}
-
-/** True if the position has no open base exposure and no open orders (a coarser check than `positionIsAvailable` — does not check quote pnl, isolated collateral, or liquidation flags). */
-export function isEmptyPosition(userPosition: PerpPosition): boolean {
-	return userPosition.baseAssetAmount.eq(ZERO) && userPosition.openOrders === 0;
-}
-
-/** True if the position has any open orders, resting bids, or resting asks, mirroring `PerpPosition::has_open_order` in `programs/velocity/src/state/user.rs`. */
-export function hasOpenOrders(position: PerpPosition): boolean {
-	return (
-		position.openOrders != 0 ||
-		!position.openBids.eq(ZERO) ||
-		!position.openAsks.eq(ZERO)
-	);
-}

package/src/math/repeg.ts

@@ -1,223 +0,0 @@
-import { BN } from '../isomorphic/anchor';
-import { assert } from '../assert/assert';
-import {
-	PRICE_PRECISION,
-	AMM_RESERVE_PRECISION,
-	PEG_PRECISION,
-	AMM_TO_QUOTE_PRECISION_RATIO,
-	PRICE_DIV_PEG,
-	QUOTE_PRECISION,
-	ZERO,
-	ONE,
-	PERCENTAGE_PRECISION,
-} from '../constants/numericConstants';
-import { AMM } from '../types';
-/**
- * Closed-form estimate of the quote-denominated cost of scaling the AMM's `sqrtK`
- * (liquidity depth) by `numerator / denomenator` while holding `pegMultiplier` fixed.
- * Used by `calculateNewAmm` as the cheap-to-compute stand-in for the program's K-shrink
- * step (`adjust_k_cost_and_update` in `vlp/amm/quoter.rs`, which shrinks `sqrtK` by 0.1%
- * — i.e. `numerator`/`denomenator` = 999/1000 — when a straight repeg to the oracle price
- * would exceed the AMM's affordability budget). A positive result is a cost the AMM must
- * fund from `totalFeeMinusDistributions`; shrinking K (denomenator > numerator) typically
- * yields a negative cost (a rebate) since it reduces the AMM's net unrealized exposure.
- * @param amm AMM state (uses `baseAssetReserve`, `quoteAssetReserve`, `baseAssetAmountWithAmm`, `pegMultiplier`).
- * @param numerator Numerator of the K scale factor (e.g. 999).
- * @param denomenator Denominator of the K scale factor (e.g. 1000).
- * @returns Cost of the K adjustment, QUOTE_PRECISION (1e6).
- */
-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.baseAssetAmountWithAmm;
-	const Q = amm.pegMultiplier;
-
-	const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
-
-	const p = numerator.mul(PRICE_PRECISION).div(denomenator);
-
-	const cost = quoteScale
-		.mul(PERCENTAGE_PRECISION)
-		.mul(PERCENTAGE_PRECISION)
-		.div(x.add(d))
-		.sub(
-			quoteScale
-				.mul(p)
-				.mul(PERCENTAGE_PRECISION)
-				.mul(PERCENTAGE_PRECISION)
-				.div(PRICE_PRECISION)
-				.div(x.mul(p).div(PRICE_PRECISION).add(d))
-		)
-		.div(PERCENTAGE_PRECISION)
-		.div(PERCENTAGE_PRECISION)
-		.div(AMM_TO_QUOTE_PRECISION_RATIO)
-		.div(PEG_PRECISION);
-
-	return cost.mul(new BN(-1));
-}
-
-// /**
-//  * Helper function calculating adjust k cost
-//  * @param amm
-//  * @param numerator
-//  * @param denomenator
-//  * @returns cost : Precision QUOTE_ASSET_PRECISION
-//  */
-// export function calculateAdjustKCost2(
-// 	amm: AMM,
-// 	numerator: BN,
-// 	denomenator: BN
-// ): BN {
-// 	// const k = market.amm.sqrtK.mul(market.amm.sqrtK);
-// 	const directionToClose = amm.baseAssetAmountWithAmm.gt(ZERO)
-// 		? PositionDirection.SHORT
-// 		: PositionDirection.LONG;
-
-// 	const [newQuoteAssetReserve, _newBaseAssetReserve] =
-// 		calculateAmmReservesAfterSwap(
-// 			amm,
-// 			'base',
-// 			amm.baseAssetAmountWithAmm.abs(),
-// 			getSwapDirection('base', directionToClose)
-// 		);
-// }
-
-/**
- * Calculates the quote-denominated cost of moving the AMM's `pegMultiplier` to `newPeg`,
- * mirroring `calculate_repeg_cost` in `vlp/amm/math/repeg.rs`: `(quoteAssetReserve -
- * terminalQuoteAssetReserve) * (newPeg - pegMultiplier) / AMM_TO_QUOTE_PRECISION_RATIO`.
- * The sign follows the AMM's inventory skew (`quoteAssetReserve - terminalQuoteAssetReserve`)
- * — repegging in the direction that favors the AMM's current net position is free or a
- * rebate; repegging against it costs `totalFeeMinusDistributions`. Zero when the AMM carries
- * no net inventory (`quoteAssetReserve == terminalQuoteAssetReserve`).
- * @param amm AMM state (uses `quoteAssetReserve`, `terminalQuoteAssetReserve`, `pegMultiplier`).
- * @param newPeg Candidate peg multiplier, PEG_PRECISION (1e6).
- * @returns Signed cost of the repeg, QUOTE_PRECISION (1e6).
- */
-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;
-}
-
-/**
- * Solves for a `sqrtK` scale factor `numerator / denominator` such that repegging the AMM
- * to price-neutral (holding the terminal/reserve price relationship implied by the current
- * inventory) costs exactly `budget`. Used as the closed-form companion to
- * `calculateAdjustKCost` (same K-shrink mechanism as the program's `adjust_k_cost_and_update`)
- * when solving for "how much must K move to spend exactly this much." Falls back to a fixed
- * `[10000, 1]` (10000x factor) if the budget is negative (protocol spending to increase K) and the
- * solution would be numerically unstable.
- * @param x AMM `baseAssetReserve`, AMM_RESERVE_PRECISION (1e9).
- * @param y AMM `quoteAssetReserve`, AMM_RESERVE_PRECISION (1e9).
- * @param budget Quote budget available to spend on the K adjustment, QUOTE_PRECISION (1e6).
- * @param Q AMM `pegMultiplier`, PEG_PRECISION (1e6).
- * @param d AMM `baseAssetAmountWithAmm` (net AMM inventory), AMM_RESERVE_PRECISION (1e9).
- * @returns `[numerator, denominator]` scale factor to apply to `sqrtK`/`baseAssetReserve`.
- */
-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;
-
-	// protocol is spending to increase k
-	if (C.lt(ZERO)) {
-		// thus denom1 is negative and solution is unstable
-		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)];
-		}
-	}
-
-	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];
-}
-
-/**
- * Calculates the largest peg move affordable within `budget`, capped so it never overshoots
- * `targetPrice`'s implied peg. Mirrors the "use full budget peg" branch of `adjust_amm` in
- * `vlp/amm/math/repeg.rs`: computes a per-peg-unit cost from the AMM's inventory skew, then
- * returns `targetPeg` directly whenever moving toward it is free or revenue-generating
- * (`useTargetPeg`), otherwise walks the peg by `budget / perPegCost` and floors it at 1.
- * @param amm AMM state (uses `quoteAssetReserve`, `terminalQuoteAssetReserve`, `baseAssetReserve`, `pegMultiplier`).
- * @param budget Quote budget available to spend on the repeg, QUOTE_PRECISION (1e6).
- * @param targetPrice Oracle-implied target price driving the optimal peg, PRICE_PRECISION (1e6).
- * @returns New peg multiplier, PEG_PRECISION (1e6), never below 1.
- */
-export function calculateBudgetedPeg(
-	amm: AMM,
-	budget: BN,
-	targetPrice: BN
-): BN {
-	let perPegCost = amm.quoteAssetReserve
-		.sub(amm.terminalQuoteAssetReserve)
-		.div(AMM_RESERVE_PRECISION.div(PRICE_PRECISION));
-
-	if (perPegCost.gt(ZERO)) {
-		perPegCost = perPegCost.add(ONE);
-	} else if (perPegCost.lt(ZERO)) {
-		perPegCost = perPegCost.sub(ONE);
-	}
-
-	const targetPeg = targetPrice
-		.mul(amm.baseAssetReserve)
-		.div(amm.quoteAssetReserve)
-		.div(PRICE_DIV_PEG);
-
-	const pegChangeDirection = targetPeg.sub(amm.pegMultiplier);
-
-	const useTargetPeg =
-		(perPegCost.lt(ZERO) && pegChangeDirection.gt(ZERO)) ||
-		(perPegCost.gt(ZERO) && pegChangeDirection.lt(ZERO));
-
-	if (perPegCost.eq(ZERO) || useTargetPeg) {
-		return targetPeg;
-	}
-
-	const budgetDeltaPeg = budget.mul(PEG_PRECISION).div(perPegCost);
-	const newPeg = BN.max(ONE, amm.pegMultiplier.add(budgetDeltaPeg));
-
-	return newPeg;
-}