@drift-labs/sdk 0.2.0-master.32 → 0.2.0-master.34

package/src/clearingHouseConfig.ts

@@ -11,8 +11,8 @@ export type ClearingHouseConfig = {
 	accountSubscription?: ClearingHouseSubscriptionConfig;
 	opts?: ConfirmOptions;
 	txSenderConfig?: TxSenderConfig;
-	userIds?: number[];
-	activeUserId?: number;
+	subAccountIds?: number[];
+	activeSubAccountId?: number;
 	perpMarketIndexes?: number[];
 	spotMarketIndexes?: number[];
 	oracleInfos?: OracleInfo[];

package/src/clearingHouseUser.ts

@@ -22,6 +22,7 @@ import {
 	MARGIN_PRECISION,
 	SPOT_MARKET_WEIGHT_PRECISION,
 	QUOTE_SPOT_MARKET_INDEX,
+	TEN,
 } from './constants/numericConstants';
 import {
 	UserAccountSubscriber,
@@ -40,12 +41,15 @@ import {
 	BN,
 	SpotMarketAccount,
 	getTokenValue,
+	SpotBalanceType,
 } from '.';
 import {
 	getTokenAmount,
 	calculateAssetWeight,
 	calculateLiabilityWeight,
+	calculateWithdrawLimit,
 } from './math/spotBalance';
+import { calculateMarketOpenBidAsk } from './math/amm';
 import {
 	calculateBaseAssetValueWithOracle,
 	calculateWorstCaseBaseAssetAmount,
@@ -186,6 +190,50 @@ export class ClearingHouseUser {
 		return userAccountRPCResponse.value !== null;
 	}
 
+	/**
+	 * calculates the total open bids/asks in a perp market (including lps)
+	 * @returns : open bids
+	 * @returns : open asks
+	 */
+	public getPerpBidAsks(marketIndex: number): [BN, BN] {
+		const position = this.getUserPosition(marketIndex);
+
+		const [lpOpenBids, lpOpenAsks] = this.getLPBidAsks(marketIndex);
+
+		const totalOpenBids = lpOpenBids.add(position.openBids);
+		const totalOpenAsks = lpOpenAsks.sub(position.openAsks);
+
+		return [totalOpenBids, totalOpenAsks];
+	}
+
+	/**
+	 * calculates the open bids and asks for an lp
+	 * @returns : lp open bids
+	 * @returns : lp open asks
+	 */
+	public getLPBidAsks(marketIndex: number): [BN, BN] {
+		const position = this.getUserPosition(marketIndex);
+		if (position.lpShares.eq(ZERO)) {
+			return [ZERO, ZERO];
+		}
+
+		const market = this.clearingHouse.getPerpMarketAccount(marketIndex);
+		const [marketOpenBids, marketOpenAsks] = calculateMarketOpenBidAsk(
+			market.amm.baseAssetReserve,
+			market.amm.minBaseAssetReserve,
+			market.amm.maxBaseAssetReserve
+		);
+
+		const lpOpenBids = marketOpenBids
+			.mul(position.lpShares)
+			.div(market.amm.sqrtK);
+		const lpOpenAsks = marketOpenAsks
+			.mul(position.lpShares)
+			.div(market.amm.sqrtK);
+
+		return [lpOpenBids, lpOpenAsks];
+	}
+
 	/**
 	 * calculates the market position if the lp position was settled
 	 * @returns : the settled userPosition
@@ -196,16 +244,20 @@ export class ClearingHouseUser {
 		const _position = this.getUserPosition(marketIndex);
 		const position = this.getClonedPosition(_position);
 
+		if (position.lpShares.eq(ZERO)) {
+			return [position, ZERO, ZERO];
+		}
+
 		const market = this.clearingHouse.getPerpMarketAccount(
 			position.marketIndex
 		);
 		const nShares = position.lpShares;
 
-		const deltaBaa = market.amm.marketPositionPerLp.baseAssetAmount
+		const deltaBaa = market.amm.baseAssetAmountPerLp
 			.sub(position.lastNetBaseAssetAmountPerLp)
 			.mul(nShares)
 			.div(AMM_RESERVE_PRECISION);
-		const deltaQaa = market.amm.marketPositionPerLp.quoteAssetAmount
+		const deltaQaa = market.amm.quoteAssetAmountPerLp
 			.sub(position.lastNetQuoteAssetAmountPerLp)
 			.mul(nShares)
 			.div(AMM_RESERVE_PRECISION);
@@ -217,7 +269,7 @@ export class ClearingHouseUser {
 			return sign;
 		}
 
-		function standardize(amount, stepsize) {
+		function standardize(amount: BN, stepsize: BN) {
 			const remainder = amount.abs().mod(stepsize).mul(sign(amount));
 			const standardizedAmount = amount.sub(remainder);
 			return [standardizedAmount, remainder];
@@ -225,18 +277,18 @@ export class ClearingHouseUser {
 
 		const [standardizedBaa, remainderBaa] = standardize(
 			deltaBaa,
-			market.amm.baseAssetAmountStepSize
+			market.amm.orderStepSize
 		);
 
 		position.remainderBaseAssetAmount += remainderBaa.toNumber();
 
 		if (
 			Math.abs(position.remainderBaseAssetAmount) >
-			market.amm.baseAssetAmountStepSize.toNumber()
+			market.amm.orderStepSize.toNumber()
 		) {
 			const [newStandardizedBaa, newRemainderBaa] = standardize(
-				position.remainderBaseAssetAmount,
-				market.amm.baseAssetAmountStepSize
+				new BN(position.remainderBaseAssetAmount),
+				market.amm.orderStepSize
 			);
 			position.baseAssetAmount =
 				position.baseAssetAmount.add(newStandardizedBaa);
@@ -364,7 +416,9 @@ export class ClearingHouseUser {
 				const market = this.clearingHouse.getPerpMarketAccount(
 					perpPosition.marketIndex
 				);
-				const oraclePriceData = this.getOracleDataForMarket(market.marketIndex);
+				const oraclePriceData = this.getOracleDataForPerpMarket(
+					market.marketIndex
+				);
 
 				let positionUnrealizedPnl = calculatePositionPNL(
 					market,
@@ -432,7 +486,7 @@ export class ClearingHouseUser {
 				if (spotPosition.marketIndex === QUOTE_SPOT_MARKET_INDEX) {
 					if (isVariant(spotPosition.balanceType, 'borrow')) {
 						const tokenAmount = getTokenAmount(
-							spotPosition.balance,
+							spotPosition.scaledBalance,
 							spotMarketAccount,
 							spotPosition.balanceType
 						);
@@ -441,7 +495,7 @@ export class ClearingHouseUser {
 						if (marginCategory === 'Initial') {
 							weight = BN.max(
 								weight,
-								new BN(this.getUserAccount().customMarginRatio)
+								new BN(this.getUserAccount().maxMarginRatio)
 							);
 						}
 
@@ -462,7 +516,7 @@ export class ClearingHouseUser {
 				if (!includeOpenOrders) {
 					if (isVariant(spotPosition.balanceType, 'borrow')) {
 						const tokenAmount = getTokenAmount(
-							spotPosition.balance,
+							spotPosition.scaledBalance,
 							spotMarketAccount,
 							spotPosition.balanceType
 						);
@@ -505,7 +559,7 @@ export class ClearingHouseUser {
 					if (marginCategory === 'Initial') {
 						weight = BN.max(
 							weight,
-							new BN(this.getUserAccount().customMarginRatio)
+							new BN(this.getUserAccount().maxMarginRatio)
 						);
 					}
 
@@ -545,10 +599,7 @@ export class ClearingHouseUser {
 			);
 
 			if (marginCategory === 'Initial') {
-				weight = BN.max(
-					weight,
-					new BN(this.getUserAccount().customMarginRatio)
-				);
+				weight = BN.max(weight, new BN(this.getUserAccount().maxMarginRatio));
 			}
 
 			if (liquidationBuffer !== undefined) {
@@ -585,7 +636,7 @@ export class ClearingHouseUser {
 				if (spotPosition.marketIndex === QUOTE_SPOT_MARKET_INDEX) {
 					if (isVariant(spotPosition.balanceType, 'deposit')) {
 						const tokenAmount = getTokenAmount(
-							spotPosition.balance,
+							spotPosition.scaledBalance,
 							spotMarketAccount,
 							spotPosition.balanceType
 						);
@@ -603,7 +654,7 @@ export class ClearingHouseUser {
 				if (!includeOpenOrders) {
 					if (isVariant(spotPosition.balanceType, 'deposit')) {
 						const tokenAmount = getTokenAmount(
-							spotPosition.balance,
+							spotPosition.scaledBalance,
 							spotMarketAccount,
 							spotPosition.balanceType
 						);
@@ -748,12 +799,12 @@ export class ClearingHouseUser {
 					perpPosition.openBids = perpPosition.openBids.add(openBids);
 				}
 
-				let valuationPrice = this.getOracleDataForMarket(
+				let valuationPrice = this.getOracleDataForPerpMarket(
 					market.marketIndex
 				).price;
 
 				if (isVariant(market.status, 'settlement')) {
-					valuationPrice = market.settlementPrice;
+					valuationPrice = market.expiryPrice;
 				}
 
 				const baseAssetAmount = includeOpenOrders
@@ -777,7 +828,7 @@ export class ClearingHouseUser {
 					if (marginCategory === 'Initial') {
 						marginRatio = BN.max(
 							marginRatio,
-							new BN(this.getUserAccount().customMarginRatio)
+							new BN(this.getUserAccount().maxMarginRatio)
 						);
 					}
 
@@ -785,6 +836,10 @@ export class ClearingHouseUser {
 						marginRatio = marginRatio.add(liquidationBuffer);
 					}
 
+					if (isVariant(market.status, 'settlement')) {
+						marginRatio = ZERO;
+					}
+
 					baseAssetValue = baseAssetValue
 						.mul(marginRatio)
 						.div(MARGIN_PRECISION);
@@ -843,7 +898,9 @@ export class ClearingHouseUser {
 
 		const entryPrice = calculateEntryPrice(position);
 
-		const oraclePriceData = this.getOracleDataForMarket(position.marketIndex);
+		const oraclePriceData = this.getOracleDataForPerpMarket(
+			position.marketIndex
+		);
 
 		if (amountToClose) {
 			if (amountToClose.eq(ZERO)) {
@@ -894,25 +951,10 @@ export class ClearingHouseUser {
 	 * calculates current user leverage across all positions
 	 * @returns : Precision TEN_THOUSAND
 	 */
-	public getLeverage(marginCategory?: MarginCategory): BN {
-		const totalLiabilityValue = this.getTotalPerpPositionValue(
-			marginCategory,
-			undefined,
-			true
-		).add(
-			this.getSpotMarketLiabilityValue(
-				undefined,
-				marginCategory,
-				undefined,
-				true
-			)
-		);
+	public getLeverage(): BN {
+		const totalLiabilityValue = this.getTotalLiabilityValue();
 
-		const totalAssetValue = this.getSpotMarketAssetValue(
-			undefined,
-			marginCategory,
-			true
-		).add(this.getUnrealizedPNL(true, undefined, marginCategory));
+		const totalAssetValue = this.getTotalAssetValue();
 
 		if (totalAssetValue.eq(ZERO) && totalLiabilityValue.eq(ZERO)) {
 			return ZERO;
@@ -921,9 +963,21 @@ export class ClearingHouseUser {
 		return totalLiabilityValue.mul(TEN_THOUSAND).div(totalAssetValue);
 	}
 
+	getTotalLiabilityValue(): BN {
+		return this.getTotalPerpPositionValue(undefined, undefined, true).add(
+			this.getSpotMarketLiabilityValue(undefined, undefined, undefined, true)
+		);
+	}
+
+	getTotalAssetValue(): BN {
+		return this.getSpotMarketAssetValue(undefined, undefined, true).add(
+			this.getUnrealizedPNL(true, undefined, undefined)
+		);
+	}
+
 	/**
 	 * calculates max allowable leverage exceeding hitting requirement category
-	 * @params category {Initial, Partial, Maintenance}
+	 * @params category {Initial, Maintenance}
 	 * @returns : Precision TEN_THOUSAND
 	 */
 	public getMaxLeverage(
@@ -932,45 +986,44 @@ export class ClearingHouseUser {
 	): BN {
 		const market = this.clearingHouse.getPerpMarketAccount(marketIndex);
 
-		const marginRatioCategory = calculateMarketMarginRatio(
+		const totalAssetValue = this.getTotalAssetValue();
+		if (totalAssetValue.eq(ZERO)) {
+			return ZERO;
+		}
+
+		const totalLiabilityValue = this.getTotalLiabilityValue();
+
+		const marginRatio = calculateMarketMarginRatio(
 			market,
 			// worstCaseBaseAssetAmount.abs(),
 			ZERO, // todo
 			category
 		);
-		const maxLeverage = TEN_THOUSAND.mul(TEN_THOUSAND).div(
-			new BN(marginRatioCategory)
-		);
-		return maxLeverage;
+		const freeCollateral = this.getFreeCollateral();
+
+		// how much more liabilities can be opened w remaining free collateral
+		const additionalLiabilities = freeCollateral
+			.mul(MARGIN_PRECISION)
+			.div(new BN(marginRatio));
+
+		return totalLiabilityValue
+			.add(additionalLiabilities)
+			.mul(TEN_THOUSAND)
+			.div(totalAssetValue);
 	}
 
 	/**
 	 * calculates margin ratio: total collateral / |total position value|
 	 * @returns : Precision TEN_THOUSAND
 	 */
-	public getMarginRatio(marginCategory?: MarginCategory): BN {
-		const totalLiabilityValue = this.getTotalPerpPositionValue(
-			marginCategory,
-			undefined,
-			true
-		).add(
-			this.getSpotMarketLiabilityValue(
-				undefined,
-				marginCategory,
-				undefined,
-				true
-			)
-		);
+	public getMarginRatio(): BN {
+		const totalLiabilityValue = this.getTotalLiabilityValue();
 
 		if (totalLiabilityValue.eq(ZERO)) {
 			return BN_MAX;
 		}
 
-		const totalAssetValue = this.getSpotMarketAssetValue(
-			undefined,
-			marginCategory,
-			true
-		).add(this.getUnrealizedPNL(true, undefined, marginCategory));
+		const totalAssetValue = this.getTotalAssetValue();
 
 		return totalAssetValue.mul(TEN_THOUSAND).div(totalLiabilityValue);
 	}
@@ -980,7 +1033,7 @@ export class ClearingHouseUser {
 
 		// if user being liq'd, can continue to be liq'd until total collateral above the margin requirement plus buffer
 		let liquidationBuffer = undefined;
-		if (this.getUserAccount().beingLiquidated) {
+		if (this.getUserAccount().isBeingLiquidated) {
 			liquidationBuffer = new BN(
 				this.clearingHouse.getStateAccount().liquidationMarginBufferRatio
 			);
@@ -1084,7 +1137,7 @@ export class ClearingHouseUser {
 		const proposedPerpPositionValue = calculateBaseAssetValueWithOracle(
 			market,
 			proposedPerpPosition,
-			this.getOracleDataForMarket(market.marketIndex)
+			this.getOracleDataForPerpMarket(market.marketIndex)
 		);
 
 		// total position value after trade
@@ -1101,7 +1154,7 @@ export class ClearingHouseUser {
 						const positionValue = calculateBaseAssetValueWithOracle(
 							market,
 							position,
-							this.getOracleDataForMarket(market.marketIndex)
+							this.getOracleDataForPerpMarket(market.marketIndex)
 						);
 						const marketMarginRequirement = positionValue
 							.mul(
@@ -1179,7 +1232,7 @@ export class ClearingHouseUser {
 		if (positionBaseSizeChange.eq(ZERO)) {
 			markPriceAfterTrade = calculateReservePrice(
 				this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex),
-				this.getOracleDataForMarket(perpPosition.marketIndex)
+				this.getOracleDataForPerpMarket(perpPosition.marketIndex)
 			);
 		} else {
 			const direction = positionBaseSizeChange.gt(ZERO)
@@ -1190,7 +1243,7 @@ export class ClearingHouseUser {
 				positionBaseSizeChange.abs(),
 				this.clearingHouse.getPerpMarketAccount(perpPosition.marketIndex),
 				'base',
-				this.getOracleDataForMarket(perpPosition.marketIndex)
+				this.getOracleDataForPerpMarket(perpPosition.marketIndex)
 			)[3]; // newPrice after swap
 		}
 
@@ -1272,7 +1325,7 @@ export class ClearingHouseUser {
 			? true
 			: targetSide === currentPositionSide;
 
-		const oracleData = this.getOracleDataForMarket(targetMarketIndex);
+		const oracleData = this.getOracleDataForPerpMarket(targetMarketIndex);
 
 		// add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
 		const oppositeSizeValueUSDC = targetingSameSide
@@ -1342,13 +1395,14 @@ export class ClearingHouseUser {
 	public accountLeverageRatioAfterTrade(
 		targetMarketIndex: number,
 		tradeQuoteAmount: BN,
-		tradeSide: PositionDirection
+		tradeSide: PositionDirection,
+		includeOpenOrders = true
 	): BN {
 		const currentPosition =
 			this.getUserPosition(targetMarketIndex) ||
 			this.getEmptyPosition(targetMarketIndex);
 
-		const oracleData = this.getOracleDataForMarket(targetMarketIndex);
+		const oracleData = this.getOracleDataForPerpMarket(targetMarketIndex);
 
 		let currentPositionQuoteAmount = this.getPerpPositionValue(
 			targetMarketIndex,
@@ -1371,19 +1425,32 @@ export class ClearingHouseUser {
 			.abs();
 
 		const totalPositionAfterTradeExcludingTargetMarket =
-			this.getTotalPerpPositionValueExcludingMarket(targetMarketIndex);
+			this.getTotalPerpPositionValueExcludingMarket(
+				targetMarketIndex,
+				undefined,
+				undefined,
+				includeOpenOrders
+			);
 
-		const totalCollateral = this.getTotalCollateral();
-		if (totalCollateral.gt(ZERO)) {
-			const newLeverage = currentPerpPositionAfterTrade
-				.add(totalPositionAfterTradeExcludingTargetMarket)
-				.abs()
-				.mul(TEN_THOUSAND)
-				.div(totalCollateral);
-			return newLeverage;
-		} else {
-			return new BN(0);
+		const totalAssetValue = this.getTotalAssetValue();
+
+		const totalPerpPositionValue = currentPerpPositionAfterTrade
+			.add(totalPositionAfterTradeExcludingTargetMarket)
+			.abs();
+
+		const totalLiabilitiesAfterTrade = totalPerpPositionValue.add(
+			this.getSpotMarketLiabilityValue(undefined, undefined, undefined, false)
+		);
+
+		if (totalAssetValue.eq(ZERO) && totalLiabilitiesAfterTrade.eq(ZERO)) {
+			return ZERO;
 		}
+
+		const newLeverage = totalLiabilitiesAfterTrade
+			.mul(TEN_THOUSAND)
+			.div(totalAssetValue);
+
+		return newLeverage;
 	}
 
 	/**
@@ -1399,17 +1466,96 @@ export class ClearingHouseUser {
 			.div(new BN(feeTier.feeDenominator));
 	}
 
+	/**
+	 * Calculates a user's max withdrawal amounts for a spot market. If reduceOnly is true,
+	 * it will return the max withdrawal amount without opening a liability for the user
+	 * @param marketIndex
+	 * @returns withdrawalLimit : Precision is the token precision for the chosen SpotMarket
+	 */
+	public getWithdrawalLimit(marketIndex: number, reduceOnly?: boolean): BN {
+		const nowTs = new BN(Math.floor(Date.now() / 1000));
+		const spotMarket = this.clearingHouse.getSpotMarketAccount(marketIndex);
+
+		const { borrowLimit, withdrawLimit } = calculateWithdrawLimit(
+			spotMarket,
+			nowTs
+		);
+
+		const freeCollateral = this.getFreeCollateral();
+		const oracleData = this.getOracleDataForSpotMarket(marketIndex);
+		const precisionIncrease = TEN.pow(new BN(spotMarket.decimals - 6));
+
+		const amountWithdrawable = freeCollateral
+			.mul(MARGIN_PRECISION)
+			.div(spotMarket.initialAssetWeight)
+			.mul(PRICE_PRECISION)
+			.div(oracleData.price)
+			.mul(precisionIncrease);
+
+		const userSpotPosition = this.getUserAccount().spotPositions.find(
+			(spotPosition) =>
+				isVariant(spotPosition.balanceType, 'deposit') &&
+				spotPosition.marketIndex == marketIndex
+		);
+
+		const userSpotBalance = userSpotPosition
+			? getTokenAmount(
+					userSpotPosition.scaledBalance,
+					this.clearingHouse.getSpotMarketAccount(marketIndex),
+					SpotBalanceType.DEPOSIT
+			  )
+			: ZERO;
+
+		const maxWithdrawValue = BN.min(
+			BN.min(amountWithdrawable, userSpotBalance),
+			withdrawLimit.abs()
+		);
+
+		if (reduceOnly) {
+			return BN.max(maxWithdrawValue, ZERO);
+		} else {
+			const weightedAssetValue = this.getSpotMarketAssetValue(
+				marketIndex,
+				'Initial',
+				false
+			);
+
+			const freeCollatAfterWithdraw = userSpotBalance.gt(ZERO)
+				? freeCollateral.sub(weightedAssetValue)
+				: freeCollateral;
+
+			const maxLiabilityAllowed = freeCollatAfterWithdraw
+				.mul(MARGIN_PRECISION)
+				.div(spotMarket.initialLiabilityWeight)
+				.mul(PRICE_PRECISION)
+				.div(oracleData.price)
+				.mul(precisionIncrease);
+
+			const maxBorrowValue = BN.min(
+				maxWithdrawValue.add(maxLiabilityAllowed),
+				borrowLimit.abs()
+			);
+
+			return BN.max(maxBorrowValue, ZERO);
+		}
+	}
+
 	/**
 	 * Get the total position value, excluding any position coming from the given target market
 	 * @param marketToIgnore
 	 * @returns positionValue : Precision QUOTE_PRECISION
 	 */
-	private getTotalPerpPositionValueExcludingMarket(marketToIgnore: number): BN {
+	private getTotalPerpPositionValueExcludingMarket(
+		marketToIgnore: number,
+		marginCategory?: MarginCategory,
+		liquidationBuffer?: BN,
+		includeOpenOrders?: boolean
+	): BN {
 		const currentPerpPosition =
 			this.getUserPosition(marketToIgnore) ||
 			this.getEmptyPosition(marketToIgnore);
 
-		const oracleData = this.getOracleDataForMarket(marketToIgnore);
+		const oracleData = this.getOracleDataForPerpMarket(marketToIgnore);
 
 		let currentPerpPositionValueUSDC = ZERO;
 		if (currentPerpPosition) {
@@ -1419,10 +1565,14 @@ export class ClearingHouseUser {
 			);
 		}
 
-		return this.getTotalPerpPositionValue().sub(currentPerpPositionValueUSDC);
+		return this.getTotalPerpPositionValue(
+			marginCategory,
+			liquidationBuffer,
+			includeOpenOrders
+		).sub(currentPerpPositionValueUSDC);
 	}
 
-	private getOracleDataForMarket(marketIndex: number): OraclePriceData {
+	private getOracleDataForPerpMarket(marketIndex: number): OraclePriceData {
 		const oracleKey =
 			this.clearingHouse.getPerpMarketAccount(marketIndex).amm.oracle;
 		const oracleData =

package/src/config.ts

@@ -17,6 +17,8 @@ type DriftConfig = {
 	PYTH_ORACLE_MAPPING_ADDRESS: string;
 	CLEARING_HOUSE_PROGRAM_ID: string;
 	USDC_MINT_ADDRESS: string;
+	SERUM_V3: string;
+	V2_ALPHA_TICKET_MINT_ADDRESS: string;
 	PERP_MARKETS: PerpMarketConfig[];
 	SPOT_MARKETS: SpotMarketConfig[];
 };
@@ -27,8 +29,11 @@ export const configs: { [key in DriftEnv]: DriftConfig } = {
 	devnet: {
 		ENV: 'devnet',
 		PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-		CLEARING_HOUSE_PROGRAM_ID: 'DUZwKJKAk2C9S88BYvQzck1M1i5hySQjxB4zW6tJ29Nw',
+		CLEARING_HOUSE_PROGRAM_ID: 'FPVkWvcQgc4aCS8TrKo5c8GqTbKMauvzpADdqzRT2WbT',
 		USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
+		SERUM_V3: 'DESVgJVGajEgKGXhb6XmqDHGz3VjdgP7rEVESBgxmroY',
+		V2_ALPHA_TICKET_MINT_ADDRESS:
+			'DeEiGWfCMP9psnLGkxGrBBMEAW5Jv8bBGMN8DCtFRCyB',
 		PERP_MARKETS: DevnetPerpMarkets,
 		SPOT_MARKETS: DevnetSpotMarkets,
 	},
@@ -37,6 +42,8 @@ export const configs: { [key in DriftEnv]: DriftConfig } = {
 		PYTH_ORACLE_MAPPING_ADDRESS: 'AHtgzX45WTKfkPG53L6WYhGEXwQkN1BVknET3sVsLL8J',
 		CLEARING_HOUSE_PROGRAM_ID: 'dammHkt7jmytvbS3nHTxQNEcP59aE57nxwV21YdqEDN',
 		USDC_MINT_ADDRESS: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+		SERUM_V3: '9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin',
+		V2_ALPHA_TICKET_MINT_ADDRESS: '',
 		PERP_MARKETS: MainnetMarkets,
 		SPOT_MARKETS: MainnetSpotMarkets,
 	},

package/src/constants/numericConstants.ts

@@ -37,7 +37,11 @@ export const SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION = new BN(10).pow(
 	SPOT_MARKET_CUMULATIVE_INTEREST_PRECISION_EXP
 );
 
-export const SPOT_MARKET_UTILIZATION_PRECISION = new BN(1000000);
+export const SPOT_MARKET_UTILIZATION_PRECISION_EXP = new BN(6);
+export const SPOT_MARKET_UTILIZATION_PRECISION = new BN(10).pow(
+	SPOT_MARKET_UTILIZATION_PRECISION_EXP
+);
+
 export const SPOT_MARKET_WEIGHT_PRECISION = new BN(10000);
 export const SPOT_MARKET_BALANCE_PRECISION_EXP = new BN(9);
 export const SPOT_MARKET_BALANCE_PRECISION = new BN(10).pow(