@velocity-exchange/sdk 0.0.5 → 0.2.0

package/src/math/builder.ts

@@ -1,4 +1,48 @@
-import { RevenueShareOrder } from '../types';
+import { PublicKey } from '@solana/web3.js';
+import {
+	OrderParams,
+	ReferrerStatus,
+	RevenueShareEscrowAccount,
+	RevenueShareOrder,
+	UserStatsAccount,
+} from '../types';
+
+/**
+ * True when the user's RevenueShareEscrow was initialized with a referrer.
+ * Fills for such users must include the escrow account or the program rejects
+ * them with UnableToLoadRevenueShareAccount.
+ */
+export function isBuilderReferral(
+	userStats: Pick<UserStatsAccount, 'referrerStatus'>
+): boolean {
+	return (userStats.referrerStatus & ReferrerStatus.BuilderReferral) !== 0;
+}
+
+/**
+ * True when the escrow was initialized with a referrer. Referral rewards
+ * accrue into such escrows on fills, so fills of the escrow owner's orders
+ * must include the escrow account (see `isBuilderReferral`).
+ */
+export function escrowHasReferrer(
+	escrow: Pick<RevenueShareEscrowAccount, 'referrer'>
+): boolean {
+	return !escrow.referrer.equals(PublicKey.default);
+}
+
+/**
+ * True when the order params carry a builder code (`builderIdx` +
+ * `builderFeeTenthBps`).
+ */
+export function hasBuilderParams(
+	orderParams: Pick<OrderParams, 'builderIdx' | 'builderFeeTenthBps'>
+): boolean {
+	return (
+		orderParams.builderIdx !== null &&
+		orderParams.builderIdx !== undefined &&
+		orderParams.builderFeeTenthBps !== null &&
+		orderParams.builderFeeTenthBps !== undefined
+	);
+}
 
 const FLAG_IS_OPEN = 0x01;
 export function isBuilderOrderOpen(order: RevenueShareOrder): boolean {

package/src/math/funding.ts

@@ -28,8 +28,8 @@ function calculateLiveMarkTwap(
 ): BN {
 	now = now || new BN((Date.now() / 1000).toFixed(0));
 
-	const lastMarkTwapWithMantissa = market.amm.lastMarkPriceTwap;
-	const lastMarkPriceTwapTs = market.amm.lastMarkPriceTwapTs;
+	const lastMarkTwapWithMantissa = market.marketStats.lastMarkPriceTwap;
+	const lastMarkPriceTwapTs = market.marketStats.lastMarkPriceTwapTs;
 
 	const timeSinceLastMarkChange = now.sub(lastMarkPriceTwapTs);
 	const markTwapTimeSinceLastUpdate = BN.max(
@@ -38,7 +38,11 @@ function calculateLiveMarkTwap(
 	);
 
 	if (!markPrice) {
-		const [bid, ask] = calculateBidAskPrice(market.amm, mmOraclePriceData);
+		const [bid, ask] = calculateBidAskPrice(
+			market.amm,
+			market.marketStats,
+			mmOraclePriceData
+		);
 		markPrice = bid.add(ask).div(new BN(2));
 	}
 
@@ -60,25 +64,28 @@ function shrinkStaleTwaps(
 	let newMarkTwap = markTwapWithMantissa;
 	let newOracleTwap = oracleTwapWithMantissa;
 	if (
-		market.amm.lastMarkPriceTwapTs.gt(
-			market.amm.historicalOracleData.lastOraclePriceTwapTs
+		market.marketStats.lastMarkPriceTwapTs.gt(
+			market.marketStats.historicalOracleData.lastOraclePriceTwapTs
 		)
 	) {
 		// shrink oracle based on invalid intervals
 		const oracleInvalidDuration = BN.max(
 			ZERO,
-			market.amm.lastMarkPriceTwapTs.sub(
-				market.amm.historicalOracleData.lastOraclePriceTwapTs
+			market.marketStats.lastMarkPriceTwapTs.sub(
+				market.marketStats.historicalOracleData.lastOraclePriceTwapTs
 			)
 		);
 		const timeSinceLastOracleTwapUpdate = now.sub(
-			market.amm.historicalOracleData.lastOraclePriceTwapTs
+			market.marketStats.historicalOracleData.lastOraclePriceTwapTs
 		);
 		const oracleTwapTimeSinceLastUpdate = BN.max(
 			ONE,
 			BN.min(
-				market.amm.fundingPeriod,
-				BN.max(ONE, market.amm.fundingPeriod.sub(timeSinceLastOracleTwapUpdate))
+				market.marketStats.fundingPeriod,
+				BN.max(
+					ONE,
+					market.marketStats.fundingPeriod.sub(timeSinceLastOracleTwapUpdate)
+				)
 			)
 		);
 		newOracleTwap = oracleTwapTimeSinceLastUpdate
@@ -86,23 +93,28 @@ function shrinkStaleTwaps(
 			.add(oracleInvalidDuration.mul(markTwapWithMantissa))
 			.div(oracleTwapTimeSinceLastUpdate.add(oracleInvalidDuration));
 	} else if (
-		market.amm.lastMarkPriceTwapTs.lt(
-			market.amm.historicalOracleData.lastOraclePriceTwapTs
+		market.marketStats.lastMarkPriceTwapTs.lt(
+			market.marketStats.historicalOracleData.lastOraclePriceTwapTs
 		)
 	) {
 		// shrink mark to oracle twap over tradless intervals
 		const tradelessDuration = BN.max(
 			ZERO,
-			market.amm.historicalOracleData.lastOraclePriceTwapTs.sub(
-				market.amm.lastMarkPriceTwapTs
+			market.marketStats.historicalOracleData.lastOraclePriceTwapTs.sub(
+				market.marketStats.lastMarkPriceTwapTs
 			)
 		);
-		const timeSinceLastMarkTwapUpdate = now.sub(market.amm.lastMarkPriceTwapTs);
+		const timeSinceLastMarkTwapUpdate = now.sub(
+			market.marketStats.lastMarkPriceTwapTs
+		);
 		const markTwapTimeSinceLastUpdate = BN.max(
 			ONE,
 			BN.min(
-				market.amm.fundingPeriod,
-				BN.max(ONE, market.amm.fundingPeriod.sub(timeSinceLastMarkTwapUpdate))
+				market.marketStats.fundingPeriod,
+				BN.max(
+					ONE,
+					market.marketStats.fundingPeriod.sub(timeSinceLastMarkTwapUpdate)
+				)
 			)
 		);
 		newMarkTwap = markTwapTimeSinceLastUpdate
@@ -141,13 +153,18 @@ export function calculateAllEstimatedFundingRate(
 		mmOraclePriceData,
 		markPrice,
 		now,
-		market.amm.fundingPeriod
+		market.marketStats.fundingPeriod
 	);
+	if (!oraclePriceData) {
+		throw new Error(
+			'calculateAllEstimatedFundingRate: oraclePriceData is required for an initialized market'
+		);
+	}
 	const liveOracleTwap = calculateLiveOracleTwap(
-		market.amm.historicalOracleData,
+		market.marketStats.historicalOracleData,
 		oraclePriceData,
 		now,
-		market.amm.fundingPeriod
+		market.marketStats.fundingPeriod
 	);
 	const [markTwap, oracleTwap] = shrinkStaleTwaps(
 		market,
@@ -187,10 +204,10 @@ export function calculateAllEstimatedFundingRate(
 
 	const secondsInHour = new BN(3600);
 	const hoursInDay = new BN(24);
-	const timeSinceLastUpdate = now.sub(market.amm.lastFundingRateTs);
+	const timeSinceLastUpdate = now.sub(market.lastFundingRateTs);
 
 	const lowerboundEst = twapSpreadPct
-		.mul(market.amm.fundingPeriod)
+		.mul(market.marketStats.fundingPeriod)
 		.mul(BN.min(secondsInHour, timeSinceLastUpdate))
 		.div(secondsInHour)
 		.div(secondsInHour)
@@ -210,19 +227,15 @@ export function calculateAllEstimatedFundingRate(
 	let cappedAltEst: BN;
 	let largerSide: BN;
 	let smallerSide: BN;
-	if (
-		market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())
-	) {
-		largerSide = market.amm.baseAssetAmountLong.abs();
-		smallerSide = market.amm.baseAssetAmountShort.abs();
+	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+		largerSide = market.baseAssetAmountLong.abs();
+		smallerSide = market.baseAssetAmountShort.abs();
 		if (twapSpread.gt(new BN(0))) {
 			return [markTwap, oracleTwap, lowerboundEst, interpEst, interpEst];
 		}
-	} else if (
-		market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())
-	) {
-		largerSide = market.amm.baseAssetAmountShort.abs();
-		smallerSide = market.amm.baseAssetAmountLong.abs();
+	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+		largerSide = market.baseAssetAmountShort.abs();
+		smallerSide = market.baseAssetAmountLong.abs();
 		if (twapSpread.lt(new BN(0))) {
 			return [markTwap, oracleTwap, lowerboundEst, interpEst, interpEst];
 		}
@@ -370,11 +383,9 @@ export function calculateLongShortFundingRate(
 		now
 	);
 
-	if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort)) {
+	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
 		return [cappedAltEst, interpEst];
-	} else if (
-		market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort)
-	) {
+	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
 		return [interpEst, cappedAltEst];
 	} else {
 		return [interpEst, interpEst];
@@ -404,13 +415,9 @@ export function calculateLongShortFundingRateAndLiveTwaps(
 			now
 		);
 
-	if (
-		market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())
-	) {
+	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
 		return [markTwapLive, oracleTwapLive, cappedAltEst, interpEst];
-	} else if (
-		market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())
-	) {
+	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
 		return [markTwapLive, oracleTwapLive, interpEst, cappedAltEst];
 	} else {
 		return [markTwapLive, oracleTwapLive, interpEst, interpEst];
@@ -424,13 +431,10 @@ export function calculateLongShortFundingRateAndLiveTwaps(
  */
 export function calculateFundingPool(market: PerpMarketAccount): BN {
 	// todo
-	const totalFeeLB = market.amm.totalExchangeFee.div(new BN(2));
+	// no protocol floor post-isolation: 1/3 of the AMM's own equity
 	const feePool = BN.max(
 		ZERO,
-		market.amm.totalFeeMinusDistributions
-			.sub(totalFeeLB)
-			.mul(new BN(1))
-			.div(new BN(3))
+		market.amm.totalFeeMinusDistributions.mul(new BN(1)).div(new BN(3))
 	);
 	return feePool;
 }

package/src/math/insurance.ts

@@ -6,7 +6,7 @@ import { SpotBalanceType, SpotMarketAccount } from '../types';
 export function nextRevenuePoolSettleApr(
 	spotMarket: SpotMarketAccount,
 	vaultBalance: BN, // vault token amount
-	amount?: BN // delta token amount
+	amount: BN // delta token amount
 ): number {
 	const MAX_APR = new BN(10).mul(PERCENTAGE_PRECISION); // 1000% APR
 
@@ -18,13 +18,11 @@ export function nextRevenuePoolSettleApr(
 	);
 
 	const payoutRatio = 0.1;
-	const ratioForStakers =
-		spotMarket.insuranceFund.totalFactor > 0 &&
-		spotMarket.insuranceFund.userFactor > 0 &&
-		spotMarket.insuranceFund.revenueSettlePeriod.gt(ZERO)
-			? spotMarket.insuranceFund.userFactor /
-			  spotMarket.insuranceFund.totalFactor
-			: 0;
+	// the insurance fund is 100% staker-owned: every settled token accrues to
+	// stakers as share-price appreciation (no protocol split)
+	const ratioForStakers = spotMarket.insuranceFund.revenueSettlePeriod.gt(ZERO)
+		? 1
+		: 0;
 
 	// Settle periods from on-chain data:
 	const revSettlePeriod =

package/src/math/margin.ts

@@ -1,5 +1,5 @@
 /**
- * Margin calculation helpers — TypeScript mirror of `programs/drift/src/math/margin.rs`.
+ * Margin calculation helpers — TypeScript mirror of `programs/velocity/src/math/margin.rs`.
  * Computes initial/maintenance margin requirements, free collateral, and account health.
  * Used by {@link User} for leverage queries and by keeper bots for liquidation eligibility checks.
  */
@@ -8,7 +8,6 @@ import {
 	SPOT_MARKET_WEIGHT_PRECISION,
 	SPOT_MARKET_IMF_PRECISION,
 	ZERO,
-	BID_ASK_SPREAD_PRECISION,
 	AMM_RESERVE_PRECISION,
 	BASE_PRECISION,
 	MARGIN_PRECISION,
@@ -20,15 +19,7 @@ import { OraclePriceData } from '../oracles/types';
 import { calculateMarketMarginRatio } from './market';
 import { calculateScaledInitialAssetWeight } from './spotBalance';
 import { VelocityClient } from '../velocityClient';
-import { OneShotUserAccountSubscriber } from '../accounts/oneShotUserAccountSubscriber';
-import {
-	PerpMarketAccount,
-	PerpPosition,
-	PositionDirection,
-	UserAccount,
-} from '../types';
-import { PublicKey } from '@solana/web3.js';
-import { User } from '../user';
+import { PerpMarketAccount, PerpPosition } from '../types';
 import { isVariant } from '../types';
 import { assert } from '../assert/assert';
 
@@ -97,32 +88,6 @@ export function calculateSizeDiscountAssetWeight(
 	return minAssetWeight;
 }
 
-export function calculateOraclePriceForPerpMargin(
-	perpPosition: PerpPosition,
-	market: PerpMarketAccount,
-	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 (perpPosition.baseAssetAmount.gt(ZERO)) {
-		marginPrice = oraclePriceData.price.sub(oraclePriceOffset);
-	} else {
-		marginPrice = oraclePriceData.price.add(oraclePriceOffset);
-	}
-
-	return marginPrice;
-}
-
 /**
  * This is _not_ the same as liability value as for prediction markets, the liability for the short in prediction market is (1 - oracle price) * base
  * See {@link calculatePerpLiabilityValue} to get the liabiltiy value
@@ -220,17 +185,18 @@ export function calculatePerpLiabilityValue(
  * @returns
  */
 export function calculateMarginUSDCRequiredForTrade(
-	driftClient: VelocityClient,
+	velocityClient: VelocityClient,
 	targetMarketIndex: number,
 	baseSize: BN,
 	userMaxMarginRatio?: number,
 	entryPrice?: BN
 ): BN {
-	const targetMarket = driftClient.getPerpMarketAccount(targetMarketIndex);
+	const targetMarket =
+		velocityClient.getPerpMarketAccountOrThrow(targetMarketIndex);
 
 	const price =
 		entryPrice ??
-		driftClient.getOracleDataForPerpMarket(targetMarket.marketIndex).price;
+		velocityClient.getOracleDataForPerpMarket(targetMarket.marketIndex).price;
 
 	const perpLiabilityValue = calculatePerpLiabilityValue(baseSize, price);
 
@@ -254,7 +220,7 @@ export function calculateMarginUSDCRequiredForTrade(
  * Returns collateral required in the precision of the target collateral market.
  */
 export function calculateCollateralDepositRequiredForTrade(
-	driftClient: VelocityClient,
+	velocityClient: VelocityClient,
 	targetMarketIndex: number,
 	baseSize: BN,
 	collateralIndex: number,
@@ -262,17 +228,18 @@ export function calculateCollateralDepositRequiredForTrade(
 	estEntryPrice?: BN
 ): BN {
 	const marginRequiredUsdc = calculateMarginUSDCRequiredForTrade(
-		driftClient,
+		velocityClient,
 		targetMarketIndex,
 		baseSize,
 		userMaxMarginRatio,
 		estEntryPrice
 	);
 
-	const collateralMarket = driftClient.getSpotMarketAccount(collateralIndex);
+	const collateralMarket =
+		velocityClient.getSpotMarketAccountOrThrow(collateralIndex);
 
 	const collateralOracleData =
-		driftClient.getOracleDataForSpotMarket(collateralIndex);
+		velocityClient.getOracleDataForSpotMarket(collateralIndex);
 
 	const scaledAssetWeight = calculateScaledInitialAssetWeight(
 		collateralMarket,
@@ -280,7 +247,7 @@ export function calculateCollateralDepositRequiredForTrade(
 	);
 
 	// Base amount required to deposit = (marginRequiredUsdc / priceOfAsset) / assetWeight .. (E.g. $100 required / $10000 price / 0.5 weight)
-	const baseAmountRequired = driftClient
+	const baseAmountRequired = velocityClient
 		.convertToSpotPrecision(collateralIndex, marginRequiredUsdc)
 		.mul(PRICE_PRECISION) // adjust for division by oracle price
 		.mul(SPOT_MARKET_WEIGHT_PRECISION) // adjust for division by scaled asset weight
@@ -292,77 +259,3 @@ export function calculateCollateralDepositRequiredForTrade(
 
 	return baseAmountRequired;
 }
-
-export function calculateCollateralValueOfDeposit(
-	driftClient: VelocityClient,
-	collateralIndex: number,
-	baseSize: BN
-): BN {
-	const collateralMarket = driftClient.getSpotMarketAccount(collateralIndex);
-
-	const collateralOracleData =
-		driftClient.getOracleDataForSpotMarket(collateralIndex);
-
-	const scaledAssetWeight = calculateScaledInitialAssetWeight(
-		collateralMarket,
-		collateralOracleData.price
-	);
-
-	// CollateralBaseValue = oracle price * collateral base amount (and shift to QUOTE_PRECISION)
-	const collateralBaseValue = collateralOracleData.price
-		.mul(baseSize)
-		.mul(QUOTE_PRECISION)
-		.div(PRICE_PRECISION)
-		.div(new BN(10).pow(new BN(collateralMarket.decimals)));
-
-	const depositCollateralValue = collateralBaseValue
-		.mul(scaledAssetWeight)
-		.div(SPOT_MARKET_WEIGHT_PRECISION);
-
-	return depositCollateralValue;
-}
-
-export function calculateLiquidationPrice(
-	freeCollateral: BN,
-	freeCollateralDelta: BN,
-	oraclePrice: BN
-): BN {
-	const liqPriceDelta = freeCollateral
-		.mul(QUOTE_PRECISION)
-		.div(freeCollateralDelta);
-
-	const liqPrice = oraclePrice.sub(liqPriceDelta);
-
-	if (liqPrice.lt(ZERO)) {
-		return new BN(-1);
-	}
-
-	return liqPrice;
-}
-
-export function calculateUserMaxPerpOrderSize(
-	driftClient: VelocityClient,
-	userAccountKey: PublicKey,
-	userAccount: UserAccount,
-	targetMarketIndex: number,
-	tradeSide: PositionDirection
-): { tradeSize: BN; oppositeSideTradeSize: BN } {
-	const userAccountSubscriber = new OneShotUserAccountSubscriber(
-		driftClient.program,
-		userAccountKey,
-		userAccount
-	);
-
-	const user = new User({
-		driftClient,
-		userAccountPublicKey: userAccountKey,
-		accountSubscription: {
-			type: 'custom',
-			userAccountSubscriber: userAccountSubscriber,
-		},
-	});
-
-	user.isSubscribed = true;
-
-	return user.getMaxTradeSizeUSDCForPerp(targetMarketIndex, tradeSide);
-}

package/src/math/market.ts

@@ -5,16 +5,12 @@ import {
 	MarginCategory,
 	SpotMarketAccount,
 	SpotBalanceType,
-	MarketType,
 	isVariant,
 } from '../types';
 import {
-	calculateAmmReservesAfterSwap,
 	calculatePrice,
 	calculateUpdatedAMMSpreadReserves,
-	getSwapDirection,
 	calculateUpdatedAMM,
-	calculateMarketOpenBidAsk,
 } from './amm';
 import {
 	calculateSizeDiscountAssetWeight,
@@ -32,7 +28,6 @@ import {
 	FUNDING_RATE_PRECISION,
 } from '../constants/numericConstants';
 import { getTokenAmount } from './spotBalance';
-import { DLOB } from '../dlob/DLOB';
 import { assert } from '../assert/assert';
 
 /**
@@ -43,7 +38,7 @@ import { assert } from '../assert/assert';
  */
 export function calculateReservePrice(
 	market: PerpMarketAccount,
-	mmOraclePriceData: MMOraclePriceData
+	mmOraclePriceData?: MMOraclePriceData
 ): BN {
 	const newAmm = calculateUpdatedAMM(market.amm, mmOraclePriceData);
 	return calculatePrice(
@@ -61,12 +56,13 @@ export function calculateReservePrice(
  */
 export function calculateBidPrice(
 	market: PerpMarketAccount,
-	mmOraclePriceData: MMOraclePriceData,
+	mmOraclePriceData?: MMOraclePriceData,
 	latestSlot?: BN
 ): BN {
 	const { baseAssetReserve, quoteAssetReserve, newPeg } =
 		calculateUpdatedAMMSpreadReserves(
 			market.amm,
+			market.marketStats,
 			PositionDirection.SHORT,
 			mmOraclePriceData,
 			latestSlot
@@ -83,12 +79,13 @@ export function calculateBidPrice(
  */
 export function calculateAskPrice(
 	market: PerpMarketAccount,
-	mmOraclePriceData: MMOraclePriceData,
+	mmOraclePriceData?: MMOraclePriceData,
 	latestSlot?: BN
 ): BN {
 	const { baseAssetReserve, quoteAssetReserve, newPeg } =
 		calculateUpdatedAMMSpreadReserves(
 			market.amm,
+			market.marketStats,
 			PositionDirection.LONG,
 			mmOraclePriceData,
 			latestSlot
@@ -97,36 +94,6 @@ export function calculateAskPrice(
 	return calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
 }
 
-export function calculateNewMarketAfterTrade(
-	baseAssetAmount: BN,
-	direction: PositionDirection,
-	market: PerpMarketAccount
-): PerpMarketAccount {
-	const [newQuoteAssetReserve, newBaseAssetReserve] =
-		calculateAmmReservesAfterSwap(
-			market.amm,
-			'base',
-			baseAssetAmount.abs(),
-			getSwapDirection('base', direction)
-		);
-
-	const newAmm = Object.assign({}, market.amm);
-	const newMarket = Object.assign({}, market);
-	newMarket.amm = newAmm;
-	newMarket.amm.quoteAssetReserve = newQuoteAssetReserve;
-	newMarket.amm.baseAssetReserve = newBaseAssetReserve;
-
-	return newMarket;
-}
-
-export function calculateOracleReserveSpread(
-	market: PerpMarketAccount,
-	mmOraclePriceData: MMOraclePriceData
-): BN {
-	const reservePrice = calculateReservePrice(market, mmOraclePriceData);
-	return calculateOracleSpread(reservePrice, mmOraclePriceData);
-}
-
 export function calculateOracleSpread(
 	price: BN,
 	oraclePriceData: OraclePriceData
@@ -251,8 +218,8 @@ export function calculateNetUserPnl(
 		.div(BASE_PRECISION)
 		.div(PRICE_TO_QUOTE_PRECISION);
 
-	const netUserCostBasis = perpMarket.amm.quoteAssetAmount.add(
-		perpMarket.amm.netUnsettledFundingPnl
+	const netUserCostBasis = perpMarket.quoteAssetAmount.add(
+		perpMarket.netUnsettledFundingPnl
 	);
 
 	const netUserPnl = netUserPositionValue.add(netUserCostBasis);
@@ -287,55 +254,6 @@ export function calculateNetUserPnlImbalance(
 	return imbalance;
 }
 
-export function calculateAvailablePerpLiquidity(
-	market: PerpMarketAccount,
-	mmOraclePriceData: MMOraclePriceData,
-	dlob: DLOB,
-	slot: number
-): { bids: BN; asks: BN } {
-	let [bids, asks] = calculateMarketOpenBidAsk(
-		market.amm.baseAssetReserve,
-		market.amm.minBaseAssetReserve,
-		market.amm.maxBaseAssetReserve,
-		market.amm.orderStepSize
-	);
-
-	asks = asks.abs();
-
-	for (const bid of dlob.getRestingLimitBids(
-		market.marketIndex,
-		slot,
-		MarketType.PERP,
-		mmOraclePriceData
-	)) {
-		bids = bids.add(
-			bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled)
-		);
-	}
-
-	for (const ask of dlob.getRestingLimitAsks(
-		market.marketIndex,
-		slot,
-		MarketType.PERP,
-		mmOraclePriceData
-	)) {
-		asks = asks.add(
-			ask.order.baseAssetAmount.sub(ask.order.baseAssetAmountFilled)
-		);
-	}
-
-	return {
-		bids: bids,
-		asks: asks,
-	};
-}
-
-export function calculatePerpMarketBaseLiquidatorFee(
-	market: PerpMarketAccount
-): number {
-	return market.liquidatorFee;
-}
-
 /**
  * Calculates trigger price for a perp market based on oracle price and current time
  * Implements the same logic as the Rust get_trigger_price function
@@ -358,9 +276,9 @@ export function getTriggerPrice(
 	const lastFillPrice = market.lastFillPrice;
 
 	// Calculate 5-minute basis
-	const markPrice5minTwap = market.amm.lastMarkPriceTwap5Min;
+	const markPrice5minTwap = market.marketStats.lastMarkPriceTwap5Min;
 	const lastOraclePriceTwap5min =
-		market.amm.historicalOracleData.lastOraclePriceTwap5Min;
+		market.marketStats.historicalOracleData.lastOraclePriceTwap5Min;
 	const basis5min = markPrice5minTwap.sub(lastOraclePriceTwap5min);
 
 	const oraclePlusBasis5min = oraclePrice.add(basis5min);
@@ -388,23 +306,23 @@ function getLastFundingBasis(
 	oraclePrice: BN,
 	now: BN
 ): BN {
-	if (market.amm.lastFundingOracleTwap.gt(ZERO)) {
-		const lastFundingRate = market.amm.lastFundingRate
+	if (market.marketStats.lastFundingOracleTwap.gt(ZERO)) {
+		const lastFundingRate = market.lastFundingRate
 			.mul(PRICE_PRECISION)
-			.div(market.amm.lastFundingOracleTwap)
+			.div(market.marketStats.lastFundingOracleTwap)
 			.muln(24);
 		const lastFundingRatePreAdj = lastFundingRate.sub(
 			FUNDING_RATE_PRECISION.div(new BN(3333)) // FUNDING_RATE_OFFSET_PERCENTAGE
 		);
 		const timeLeftUntilFundingUpdate = BN.min(
-			BN.max(now.sub(market.amm.lastFundingRateTs), ZERO),
-			market.amm.fundingPeriod
+			BN.max(now.sub(market.lastFundingRateTs), ZERO),
+			market.marketStats.fundingPeriod
 		);
 		const lastFundingBasis = oraclePrice
 			.mul(lastFundingRatePreAdj)
 			.div(PERCENTAGE_PRECISION)
-			.mul(market.amm.fundingPeriod.sub(timeLeftUntilFundingUpdate))
-			.div(market.amm.fundingPeriod)
+			.mul(market.marketStats.fundingPeriod.sub(timeLeftUntilFundingUpdate))
+			.div(market.marketStats.fundingPeriod)
 			.div(new BN(1000)); // FUNDING_RATE_BUFFER
 		return lastFundingBasis;
 	} else {