@velocity-exchange/sdk 0.0.5 → 0.2.0

package/src/index.ts

@@ -26,10 +26,7 @@ export { WebSocketAccountSubscriberV2 } from './accounts/webSocketAccountSubscri
 export { WebSocketProgramAccountSubscriber } from './accounts/webSocketProgramAccountSubscriber';
 export { WebSocketProgramUserAccountSubscriber } from './accounts/websocketProgramUserAccountSubscriber';
 export { WebSocketProgramAccountsSubscriberV2 } from './accounts/webSocketProgramAccountsSubscriberV2';
-export {
-	WebSocketVelocityClientAccountSubscriberV2,
-	WebSocketDriftClientAccountSubscriberV2,
-} from './accounts/webSocketVelocityClientAccountSubscriberV2';
+export { WebSocketVelocityClientAccountSubscriberV2 } from './accounts/webSocketVelocityClientAccountSubscriberV2';
 export * from './accounts/bulkAccountLoader';
 export * from './accounts/bulkUserSubscription';
 export * from './accounts/bulkUserStatsSubscription';
@@ -110,13 +107,11 @@ export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';
 export * from './tx/whileValidTxSender';
 export * from './tx/priorityFeeCalculator';
-export * from './tx/forwardOnlyTxSender';
 export * from './tx/types';
 export * from './tx/txHandler';
 export * from './tx/txParamProcessor';
 export * from './util/computeUnits';
 export * from './util/digest';
-export * from './util/tps';
 export * from './util/promiseTimeout';
 export * from './math/spotBalance';
 export * from './velocityClientConfig';

package/src/jupiter/jupiterClient.ts

@@ -6,7 +6,7 @@ import {
 	TransactionMessage,
 	VersionedTransaction,
 } from '@solana/web3.js';
-import fetch from 'node-fetch';
+import fetch, { RequestInit } from 'node-fetch';
 import { BN } from '../isomorphic/anchor';
 import { SwapMode } from '../swap/UnifiedSwapClient';
 
@@ -302,6 +302,22 @@ export class JupiterClient {
 		maxAutoSlippageBps?: number;
 		usdEstimate?: number;
 	}): Promise<QuoteResponse> {
+		if (autoSlippage && maxAutoSlippageBps === undefined) {
+			throw new Error(
+				'JupiterClient.getQuote: maxAutoSlippageBps is required when autoSlippage is enabled'
+			);
+		}
+		if (autoSlippage && usdEstimate === undefined) {
+			throw new Error(
+				'JupiterClient.getQuote: usdEstimate is required when autoSlippage is enabled'
+			);
+		}
+		const maxAutoSlippageBpsParam =
+			autoSlippage && maxAutoSlippageBps !== undefined
+				? maxAutoSlippageBps.toString()
+				: '0';
+		const autoSlippageCollisionUsdValueParam =
+			autoSlippage && usdEstimate !== undefined ? usdEstimate.toString() : '0';
 		const params = new URLSearchParams({
 			inputMint: inputMint.toString(),
 			outputMint: outputMint.toString(),
@@ -311,10 +327,8 @@ export class JupiterClient {
 			onlyDirectRoutes: onlyDirectRoutes.toString(),
 			maxAccounts: maxAccounts.toString(),
 			autoSlippage: autoSlippage.toString(),
-			maxAutoSlippageBps: autoSlippage ? maxAutoSlippageBps.toString() : '0',
-			autoSlippageCollisionUsdValue: autoSlippage
-				? usdEstimate.toString()
-				: '0',
+			maxAutoSlippageBps: maxAutoSlippageBpsParam,
+			autoSlippageCollisionUsdValue: autoSlippageCollisionUsdValueParam,
 			...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
 		});
 		if (swapMode === 'ExactOut') {
@@ -409,7 +423,9 @@ export class JupiterClient {
 					return await this.getLookupTable(lookup.accountKey);
 				})
 			)
-		).filter((lookup) => lookup);
+		).filter(
+			(lookup): lookup is AddressLookupTableAccount => lookup !== undefined
+		);
 
 		const transactionMessage = TransactionMessage.decompile(message, {
 			addressLookupTableAccounts: lookupTables,
@@ -422,12 +438,16 @@ export class JupiterClient {
 
 	async getLookupTable(
 		accountKey: PublicKey
-	): Promise<AddressLookupTableAccount> {
-		if (this.lookupTableCahce.has(accountKey.toString())) {
-			return this.lookupTableCahce.get(accountKey.toString());
+	): Promise<AddressLookupTableAccount | undefined> {
+		const cached = this.lookupTableCahce.get(accountKey.toString());
+		if (cached !== undefined) {
+			return cached;
 		}
 
-		return (await this.connection.getAddressLookupTable(accountKey)).value;
+		return (
+			(await this.connection.getAddressLookupTable(accountKey)).value ??
+			undefined
+		);
 	}
 
 	/**

package/src/margin/README.md

@@ -4,8 +4,8 @@ This document describes the single-source-of-truth margin engine in the SDK that
 
 ### Alignment with on-chain
 
-- The SDK snapshot shape mirrors `programs/drift/src/state/margin_calculation.rs` field-for-field.
-- The inputs and ordering mirror `calculate_margin_requirement_and_total_collateral_and_liability_info` in `programs/drift/src/math/margin.rs`.
+- The SDK snapshot shape mirrors `programs/velocity/src/state/margin_calculation.rs` field-for-field.
+- The inputs and ordering mirror `calculate_margin_requirement_and_total_collateral_and_liability_info` in `programs/velocity/src/math/margin.rs`.
 - Isolated positions are represented as `isolatedMarginCalculations` keyed by perp `marketIndex`, matching program logic.
 
 ### Core SDK types (shape parity)

package/src/marginCalculation.ts

@@ -48,6 +48,7 @@ export class MarginContext {
 		this.strict = false;
 		this.ignoreInvalidDepositOracles = false;
 		this.isolatedMarginBuffers = new Map();
+		this.crossMarginBuffer = ZERO;
 	}
 
 	static standard(marginType: MarginCategory): MarginContext {

package/src/math/amm.ts

@@ -8,15 +8,16 @@ import {
 	ONE,
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	QUOTE_PRECISION,
-	MARGIN_PRECISION,
 	PRICE_DIV_PEG,
 	PERCENTAGE_PRECISION,
 	DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT,
 	FUNDING_RATE_BUFFER_PRECISION,
+	FUNDING_RATE_OFFSET_PERCENTAGE,
 	TWO,
 } from '../constants/numericConstants';
 import {
 	AMM,
+	MarketStats,
 	PositionDirection,
 	SwapDirection,
 	PerpMarketAccount,
@@ -67,8 +68,9 @@ export function calculateOptimalPegAndBudget(
 	);
 	const prePegCost = calculateRepegCost(amm, newPeg);
 
-	const totalFeeLB = amm.totalExchangeFee.div(new BN(2));
-	const budget = BN.max(ZERO, amm.totalFeeMinusDistributions.sub(totalFeeLB));
+	// no protocol floor post-isolation: tfmd contains only the AMM's own
+	// equity and is fully spendable on the repeg
+	const budget = BN.max(ZERO, amm.totalFeeMinusDistributions);
 
 	let checkLowerBound = true;
 	if (budget.lt(prePegCost)) {
@@ -101,9 +103,9 @@ export function calculateOptimalPegAndBudget(
 			checkLowerBound = false;
 
 			return [newTargetPrice, newOptimalPeg, newBudget, false];
-		} else if (
-			amm.totalFeeMinusDistributions.lt(amm.totalExchangeFee.div(new BN(2)))
-		) {
+		} else if (budget.eq(ZERO)) {
+			// mirrors the program: budget = max(0, tfmd), so a zero budget
+			// means the AMM has no equity to spend (no floor post-isolation)
 			checkLowerBound = false;
 		}
 	}
@@ -155,7 +157,7 @@ export function calculateNewAmm(
 
 export function calculateUpdatedAMM(
 	amm: AMM,
-	mmOraclePriceData: MMOraclePriceData
+	mmOraclePriceData?: MMOraclePriceData
 ): AMM {
 	if (amm.curveUpdateIntensity == 0 || mmOraclePriceData === undefined) {
 		return amm;
@@ -195,13 +197,15 @@ export function calculateUpdatedAMM(
 
 export function calculateUpdatedAMMSpreadReserves(
 	amm: AMM,
+	marketStats: MarketStats,
 	direction: PositionDirection,
-	mmOraclePriceData: MMOraclePriceData,
+	mmOraclePriceData?: MMOraclePriceData,
 	latestSlot?: BN
 ): { baseAssetReserve: BN; quoteAssetReserve: BN; sqrtK: BN; newPeg: BN } {
 	const newAmm = calculateUpdatedAMM(amm, mmOraclePriceData);
 	const [shortReserves, longReserves] = calculateSpreadReserves(
 		newAmm,
+		marketStats,
 		mmOraclePriceData,
 		undefined,
 		latestSlot
@@ -223,7 +227,8 @@ export function calculateUpdatedAMMSpreadReserves(
 
 export function calculateBidAskPrice(
 	amm: AMM,
-	mmOraclePriceData: MMOraclePriceData,
+	marketStats: MarketStats,
+	mmOraclePriceData?: MMOraclePriceData,
 	withUpdate = true,
 	latestSlot?: BN
 ): [BN, BN] {
@@ -236,6 +241,7 @@ export function calculateBidAskPrice(
 
 	const [bidReserves, askReserves] = calculateSpreadReserves(
 		newAmm,
+		marketStats,
 		mmOraclePriceData,
 		undefined,
 		latestSlot
@@ -546,14 +552,6 @@ export function calculateEffectiveLeverage(
 	return effectiveLeverage;
 }
 
-export function calculateMaxSpread(marginRatioInitial: number): number {
-	const maxTargetSpread: number = new BN(marginRatioInitial)
-		.mul(BID_ASK_SPREAD_PRECISION.div(MARGIN_PRECISION))
-		.toNumber();
-
-	return maxTargetSpread;
-}
-
 export function calculateVolSpreadBN(
 	lastOracleConfPct: BN,
 	reservePrice: BN,
@@ -603,6 +601,81 @@ export function calculateVolSpreadBN(
 	return [longVolSpread, shortVolSpread];
 }
 
+/**
+ * Funding bias β(f) (BID_ASK_SPREAD_PRECISION): bounded multiplier for the
+ * paying-side spread while the vAMM is paying funding. Mirrors the program's
+ * `calculate_spread_funding_bias_scale`.
+ *
+ *   ρ(f) = clamp(|f| / f_ref, 0, 1),  f_ref = FUNDING_RATE_OFFSET_PERCENTAGE
+ *   β(f) = 1 + s * ρ(f),              s = fundingBiasSensitivity / 100
+ *
+ * f = 24h avg funding rate normalized to a daily fraction of the oracle twap
+ * captured at the last funding update. The vAMM pays when f * q < 0
+ * (q = baseAssetAmountWithAmm). Returns 1x when the vAMM receives funding or
+ * s = 0.
+ */
+export function calculateSpreadFundingBiasScale(
+	baseAssetAmountWithAmm: BN,
+	last24HAvgFundingRate: BN,
+	lastFundingOracleTwap: BN,
+	fundingBiasSensitivity: number
+): number {
+	const one = BID_ASK_SPREAD_PRECISION.toNumber();
+	if (fundingBiasSensitivity === 0 || lastFundingOracleTwap.lte(ZERO)) {
+		return one;
+	}
+
+	// f: daily funding rate as a fraction of price, FUNDING_RATE_PRECISION
+	const fNorm = last24HAvgFundingRate
+		.mul(PRICE_PRECISION)
+		.div(lastFundingOracleTwap)
+		.muln(24);
+
+	// f * q >= 0: vAMM receives (or rate/inventory is zero), β = 1
+	if (fNorm.isZero() || baseAssetAmountWithAmm.isZero()) {
+		return one;
+	}
+	if (fNorm.isNeg() === baseAssetAmountWithAmm.isNeg()) {
+		return one;
+	}
+
+	// ρ = clamp(|f| / f_ref, 0, 1), PERCENTAGE_PRECISION
+	const ramp = BN.min(
+		fNorm.abs().mul(PERCENTAGE_PRECISION).div(FUNDING_RATE_OFFSET_PERCENTAGE),
+		PERCENTAGE_PRECISION
+	).toNumber();
+
+	// β = 1 + s * ρ
+	return one + Math.floor((fundingBiasSensitivity * ramp) / 100);
+}
+
+export interface SpreadTerms {
+	longVolSpread: number;
+	shortVolSpread: number;
+	longSpreadwPS: number;
+	shortSpreadwPS: number;
+	maxTargetSpread: number;
+	inventorySpreadScale: number;
+	longSpreadwInvScale: number;
+	shortSpreadwInvScale: number;
+	effectiveLeverage: number;
+	effectiveLeverageCapped: number;
+	longSpreadwEL: number;
+	shortSpreadwEL: number;
+	revenueRetreatAmount: number;
+	halfRevenueRetreatAmount: number;
+	longSpreadwRevRetreat: number;
+	shortSpreadwRevRetreat: number;
+	fundingBiasScale: number;
+	longSpreadwFundingBias: number;
+	shortSpreadwFundingBias: number;
+	longSpreadwOffsetShrink: number;
+	shortSpreadwOffsetShrink: number;
+	totalSpread: number;
+	longSpread: number;
+	shortSpread: number;
+}
+
 export function calculateSpreadBN(
 	baseSpread: number,
 	lastOracleReservePriceSpreadPct: BN,
@@ -624,8 +697,63 @@ export function calculateSpreadBN(
 	shortIntensity: BN,
 	volume24H: BN,
 	ammInventorySpreadAdjustment: number,
+	last24HAvgFundingRate?: BN,
+	lastFundingOracleTwap?: BN,
+	fundingBiasSensitivity?: number,
+	returnTerms?: false
+): [number, number];
+export function calculateSpreadBN(
+	baseSpread: number,
+	lastOracleReservePriceSpreadPct: BN,
+	lastOracleConfPct: BN,
+	maxSpread: number,
+	quoteAssetReserve: BN,
+	terminalQuoteAssetReserve: BN,
+	pegMultiplier: BN,
+	baseAssetAmountWithAmm: BN,
+	reservePrice: BN,
+	totalFeeMinusDistributions: BN,
+	netRevenueSinceLastFunding: BN,
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN,
+	markStd: BN,
+	oracleStd: BN,
+	longIntensity: BN,
+	shortIntensity: BN,
+	volume24H: BN,
+	ammInventorySpreadAdjustment: number,
+	last24HAvgFundingRate: BN,
+	lastFundingOracleTwap: BN,
+	fundingBiasSensitivity: number,
+	returnTerms: true
+): SpreadTerms;
+export function calculateSpreadBN(
+	baseSpread: number,
+	lastOracleReservePriceSpreadPct: BN,
+	lastOracleConfPct: BN,
+	maxSpread: number,
+	quoteAssetReserve: BN,
+	terminalQuoteAssetReserve: BN,
+	pegMultiplier: BN,
+	baseAssetAmountWithAmm: BN,
+	reservePrice: BN,
+	totalFeeMinusDistributions: BN,
+	netRevenueSinceLastFunding: BN,
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN,
+	markStd: BN,
+	oracleStd: BN,
+	longIntensity: BN,
+	shortIntensity: BN,
+	volume24H: BN,
+	ammInventorySpreadAdjustment: number,
+	last24HAvgFundingRate: BN = ZERO,
+	lastFundingOracleTwap: BN = ZERO,
+	fundingBiasSensitivity = 0,
 	returnTerms = false
-) {
+): [number, number] | SpreadTerms {
 	assert(Number.isInteger(baseSpread));
 	assert(Number.isInteger(maxSpread));
 
@@ -646,6 +774,9 @@ export function calculateSpreadBN(
 		halfRevenueRetreatAmount: 0,
 		longSpreadwRevRetreat: 0,
 		shortSpreadwRevRetreat: 0,
+		fundingBiasScale: 0,
+		longSpreadwFundingBias: 0,
+		shortSpreadwFundingBias: 0,
 		longSpreadwOffsetShrink: 0,
 		shortSpreadwOffsetShrink: 0,
 		totalSpread: 0,
@@ -792,6 +923,32 @@ export function calculateSpreadBN(
 	spreadTerms.longSpreadwRevRetreat = longSpread;
 	spreadTerms.shortSpreadwRevRetreat = shortSpread;
 
+	// funding bias: w_pay = min(w_max, (w_0 * σ(q) * λ(q) + r(q)) * β(f)).
+	// β multiplies the fully built paying side only, selected by sign(q)
+	// (the same side σ widens); the max-spread cap below still bounds it.
+	// β = 1 when the vAMM receives.
+	const fundingBiasScale = calculateSpreadFundingBiasScale(
+		baseAssetAmountWithAmm,
+		last24HAvgFundingRate,
+		lastFundingOracleTwap,
+		fundingBiasSensitivity
+	);
+	const spreadPrecision = BID_ASK_SPREAD_PRECISION.toNumber();
+	if (fundingBiasScale > spreadPrecision) {
+		if (baseAssetAmountWithAmm.gt(ZERO)) {
+			longSpread = Math.floor(
+				(longSpread * fundingBiasScale) / spreadPrecision
+			);
+		} else if (baseAssetAmountWithAmm.lt(ZERO)) {
+			shortSpread = Math.floor(
+				(shortSpread * fundingBiasScale) / spreadPrecision
+			);
+		}
+	}
+	spreadTerms.fundingBiasScale = fundingBiasScale;
+	spreadTerms.longSpreadwFundingBias = longSpread;
+	spreadTerms.shortSpreadwFundingBias = shortSpread;
+
 	if (ammInventorySpreadAdjustment < 0) {
 		const adjustment = Math.abs(ammInventorySpreadAdjustment);
 
@@ -844,7 +1001,8 @@ export function calculateSpreadBN(
 
 export function calculateSpread(
 	amm: AMM,
-	oraclePriceData: OraclePriceData,
+	marketStats: MarketStats,
+	oraclePriceData?: OraclePriceData,
 	now?: BN,
 	reservePrice?: BN
 ): [number, number] {
@@ -852,6 +1010,12 @@ export function calculateSpread(
 		return [amm.baseSpread / 2, amm.baseSpread / 2];
 	}
 
+	if (!oraclePriceData) {
+		throw new Error(
+			'calculateSpread: oraclePriceData is required when baseSpread and curveUpdateIntensity are nonzero'
+		);
+	}
+
 	if (!reservePrice) {
 		reservePrice = calculatePrice(
 			amm.baseAssetReserve,
@@ -867,9 +1031,13 @@ export function calculateSpread(
 		.div(reservePrice);
 
 	now = now || new BN(new Date().getTime() / 1000); //todo
-	const liveOracleStd = calculateLiveOracleStd(amm, oraclePriceData, now);
+	const liveOracleStd = calculateLiveOracleStd(
+		marketStats,
+		oraclePriceData,
+		now
+	);
 	const confIntervalPct = getNewOracleConfPct(
-		amm,
+		marketStats,
 		oraclePriceData,
 		reservePrice,
 		now
@@ -890,12 +1058,15 @@ export function calculateSpread(
 		amm.baseAssetReserve,
 		amm.minBaseAssetReserve,
 		amm.maxBaseAssetReserve,
-		amm.markStd,
+		marketStats.markStd,
 		liveOracleStd,
-		amm.longIntensityVolume,
-		amm.shortIntensityVolume,
-		amm.volume24H,
-		amm.ammInventorySpreadAdjustment
+		marketStats.longIntensityVolume,
+		marketStats.shortIntensityVolume,
+		marketStats.volume24H,
+		amm.ammInventorySpreadAdjustment,
+		marketStats.last24HAvgFundingRate,
+		marketStats.lastFundingOracleTwap,
+		amm.fundingBiasSensitivity
 	);
 	let longSpread = spreads[0];
 	let shortSpread = spreads[1];
@@ -925,7 +1096,8 @@ export function calculateSpread(
 
 export function calculateSpreadReserves(
 	amm: AMM,
-	mmOraclePriceData: MMOraclePriceData,
+	marketStats: MarketStats,
+	mmOraclePriceData?: MMOraclePriceData,
 	now?: BN,
 	latestSlot?: BN
 ) {
@@ -934,8 +1106,8 @@ export function calculateSpreadReserves(
 		direction: PositionDirection,
 		amm: AMM
 	): {
-		baseAssetReserve;
-		quoteAssetReserve;
+		baseAssetReserve: BN;
+		quoteAssetReserve: BN;
 	} {
 		if (spread === 0) {
 			return {
@@ -1022,25 +1194,27 @@ export function calculateSpreadReserves(
 
 		referencePriceOffset = calculateReferencePriceOffset(
 			reservePrice,
-			amm.last24HAvgFundingRate,
+			marketStats.last24HAvgFundingRate,
 			liquidityFractionAfterDeadband,
-			amm.historicalOracleData.lastOraclePriceTwap5Min,
-			amm.lastMarkPriceTwap5Min,
-			amm.historicalOracleData.lastOraclePriceTwap,
-			amm.lastMarkPriceTwap,
+			marketStats.historicalOracleData.lastOraclePriceTwap5Min,
+			marketStats.lastMarkPriceTwap5Min,
+			marketStats.historicalOracleData.lastOraclePriceTwap,
+			marketStats.lastMarkPriceTwap,
 			maxOffset
 		).toNumber();
 	}
 
 	let [longSpread, shortSpread] = calculateSpread(
 		amm,
+		marketStats,
 		mmOraclePriceData,
 		now,
 		reservePrice
 	);
 
+	const lastReferencePriceOffset = marketStats.lastReferencePriceOffset;
 	const doReferencePricOffsetSmooth =
-		Math.sign(referencePriceOffset) !== Math.sign(amm.referencePriceOffset) &&
+		Math.sign(referencePriceOffset) !== Math.sign(lastReferencePriceOffset) &&
 		amm.curveUpdateIntensity > 100;
 
 	if (doReferencePricOffsetSmooth) {
@@ -1048,17 +1222,17 @@ export function calculateSpreadReserves(
 			latestSlot != null
 				? BN.max(latestSlot.sub(amm.lastUpdateSlot), ZERO).toNumber()
 				: 0;
-		const fullOffsetDelta = referencePriceOffset - amm.referencePriceOffset;
+		const fullOffsetDelta = referencePriceOffset - lastReferencePriceOffset;
 		const raw = Math.trunc(
 			Math.min(Math.abs(fullOffsetDelta), slotsPassed * 1000) / 10
 		);
 		const maxAllowed =
-			Math.abs(amm.referencePriceOffset) || Math.abs(referencePriceOffset);
+			Math.abs(lastReferencePriceOffset) || Math.abs(referencePriceOffset);
 
 		const magnitude = Math.min(Math.max(raw, 10), maxAllowed);
 		const referencePriceDelta = Math.sign(fullOffsetDelta) * magnitude;
 
-		referencePriceOffset = amm.referencePriceOffset + referencePriceDelta;
+		referencePriceOffset = lastReferencePriceOffset + referencePriceDelta;
 
 		if (referencePriceDelta < 0) {
 			longSpread += Math.abs(referencePriceDelta);
@@ -1159,9 +1333,10 @@ export function calculateTerminalPrice(market: PerpMarketAccount) {
 
 export function calculateMaxBaseAssetAmountToTrade(
 	amm: AMM,
+	marketStats: MarketStats,
 	limit_price: BN,
 	direction: PositionDirection,
-	mmOraclePriceData?: MMOraclePriceData,
+	mmOraclePriceData: MMOraclePriceData,
 	now?: BN
 ): [BN, PositionDirection] {
 	const invariant = amm.sqrtK.mul(amm.sqrtK);
@@ -1175,6 +1350,7 @@ export function calculateMaxBaseAssetAmountToTrade(
 	const newBaseAssetReserve = squareRootBN(newBaseAssetReserveSquared);
 	const [shortSpreadReserves, longSpreadReserves] = calculateSpreadReserves(
 		amm,
+		marketStats,
 		mmOraclePriceData,
 		now
 	);
@@ -1221,6 +1397,7 @@ export function calculateQuoteAssetAmountSwapped(
 
 export function calculateMaxBaseAssetAmountFillable(
 	amm: AMM,
+	orderStepSize: BN,
 	orderDirection: PositionDirection
 ): BN {
 	const maxFillSize = amm.baseAssetReserve.div(
@@ -1241,6 +1418,6 @@ export function calculateMaxBaseAssetAmountFillable(
 
 	return standardizeBaseAssetAmount(
 		BN.min(maxFillSize, maxBaseAssetAmountOnSide),
-		amm.orderStepSize
+		orderStepSize
 	);
 }

package/src/math/auction.ts

@@ -254,11 +254,11 @@ export function getTriggerAuctionStartPrice(params: {
 	const { perpMarket, direction, oraclePrice, limitPrice } = params;
 
 	const twapMismatch =
-		perpMarket.amm.historicalOracleData.lastOraclePriceTwapTs
-			.sub(perpMarket.amm.lastMarkPriceTwapTs)
+		perpMarket.marketStats.historicalOracleData.lastOraclePriceTwapTs
+			.sub(perpMarket.marketStats.lastMarkPriceTwapTs)
 			.abs()
 			.gte(new BN(60)) ||
-		perpMarket.amm.volume24H.lte(new BN(100_000).mul(QUOTE_PRECISION));
+		perpMarket.marketStats.volume24H.lte(new BN(100_000).mul(QUOTE_PRECISION));
 
 	let baselineStartOffset: BN;
 
@@ -266,27 +266,31 @@ export function getTriggerAuctionStartPrice(params: {
 		const contractTierNumber = getPerpMarketTierNumber(perpMarket);
 		const priceDivisor = contractTierNumber <= 1 ? 500 : 100;
 		baselineStartOffset = isVariant(direction, 'long')
-			? perpMarket.amm.lastBidPriceTwap.divn(priceDivisor)
-			: perpMarket.amm.lastAskPriceTwap.divn(priceDivisor).neg();
+			? perpMarket.marketStats.lastBidPriceTwap.divn(priceDivisor)
+			: perpMarket.marketStats.lastAskPriceTwap.divn(priceDivisor).neg();
 	} else {
 		const markTwapSlow = isVariant(direction, 'long')
-			? perpMarket.amm.lastBidPriceTwap
-			: perpMarket.amm.lastAskPriceTwap;
+			? perpMarket.marketStats.lastBidPriceTwap
+			: perpMarket.marketStats.lastAskPriceTwap;
 
-		const markTwapFast = perpMarket.amm.lastMarkPriceTwap5Min;
+		const markTwapFast = perpMarket.marketStats.lastMarkPriceTwap5Min;
 		const oracleTwapSlow =
-			perpMarket.amm.historicalOracleData.lastOraclePriceTwap;
+			perpMarket.marketStats.historicalOracleData.lastOraclePriceTwap;
 		const oracleTwapFast =
-			perpMarket.amm.historicalOracleData.lastOraclePriceTwap5Min;
+			perpMarket.marketStats.historicalOracleData.lastOraclePriceTwap5Min;
 
 		const offsetSlow = markTwapSlow.sub(oracleTwapSlow);
 		const offsetFast = markTwapFast.sub(oracleTwapFast);
 
-		const fracOfLongSpreadInPrice = new BN(perpMarket.amm.longSpread)
+		// long_spread/short_spread were removed from AMM in the decoupling refactor.
+		// Fall back to half base_spread as the per-side spread approximation; the
+		// AMM no longer caches an exact per-side spread without oracle context.
+		const halfBaseSpread = new BN(Math.floor(perpMarket.amm.baseSpread / 2));
+		const fracOfLongSpreadInPrice = halfBaseSpread
 			.mul(markTwapSlow)
 			.div(PRICE_PRECISION.muln(10)); // divide by 10x for safety
 
-		const fracOfShortSpreadInPrice = new BN(perpMarket.amm.shortSpread)
+		const fracOfShortSpreadInPrice = halfBaseSpread
 			.mul(markTwapSlow)
 			.div(PRICE_PRECISION.muln(10)); // divide by 10x for safety
 

package/src/math/bankruptcy.ts

@@ -4,7 +4,7 @@ import { isVariant } from '../types';
 import { User } from '../user';
 
 export function isUserBankrupt(user: User): boolean {
-	const userAccount = user.getUserAccount();
+	const userAccount = user.getUserAccountOrThrow();
 	let hasLiability = false;
 	for (const position of userAccount.spotPositions) {
 		if (position.scaledBalance.gt(ZERO)) {