@drift-labs/sdk 2.52.0-beta.1 → 2.52.0-beta.3

package/lib/user.js

@@ -1645,7 +1645,7 @@ class User {
         const feeTier = this.getUserFeeTier(marketType);
         let takerFee = feeTier.feeNumerator / feeTier.feeDenominator;
         let makerFee = feeTier.makerRebateNumerator / feeTier.makerRebateDenominator;
-        if (marketIndex && (0, types_1.isVariant)(marketType, 'perp')) {
+        if (marketIndex !== undefined && (0, types_1.isVariant)(marketType, 'perp')) {
             const marketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
             takerFee += (takerFee * marketAccount.feeAdjustment) / 100;
             makerFee += (makerFee * marketAccount.feeAdjustment) / 100;
@@ -1660,11 +1660,19 @@ class User {
      * @param quoteAmount
      * @returns feeForQuote : Precision QUOTE_PRECISION
      */
-    calculateFeeForQuoteAmount(quoteAmount) {
-        const feeTier = this.getUserFeeTier(_1.MarketType.PERP);
-        return quoteAmount
-            .mul(new _1.BN(feeTier.feeNumerator))
-            .div(new _1.BN(feeTier.feeDenominator));
+    calculateFeeForQuoteAmount(quoteAmount, marketIndex) {
+        if (marketIndex !== undefined) {
+            const takerFeeMultiplier = this.getMarketFees(_1.MarketType.PERP, marketIndex).takerFee;
+            const feeAmountNum = _1.BigNum.from(quoteAmount, numericConstants_1.QUOTE_PRECISION_EXP).toNum() *
+                takerFeeMultiplier;
+            return _1.BigNum.fromPrint(feeAmountNum.toString(), numericConstants_1.QUOTE_PRECISION_EXP).val;
+        }
+        else {
+            const feeTier = this.getUserFeeTier(_1.MarketType.PERP);
+            return quoteAmount
+                .mul(new _1.BN(feeTier.feeNumerator))
+                .div(new _1.BN(feeTier.feeDenominator));
+        }
     }
     /**
      * Calculates a user's max withdrawal amounts for a spot market. If reduceOnly is true,

package/lib/userMap/userMap.d.ts

@@ -22,6 +22,7 @@ export declare class UserMap implements UserMapInterface {
     private subscription;
     private stateAccountUpdateCallback;
     private decode;
+    private mostRecentSlot;
     private syncPromise?;
     private syncPromiseResolver;
     /**
@@ -68,4 +69,6 @@ export declare class UserMap implements UserMapInterface {
     sync(): Promise<void>;
     unsubscribe(): Promise<void>;
     updateUserAccount(key: string, userAccount: UserAccount, slot: number): Promise<void>;
+    updateLatestSlot(slot: number): void;
+    getSlot(): number;
 }

package/lib/userMap/userMap.js

@@ -21,6 +21,7 @@ class UserMap {
                 this.lastNumberOfSubAccounts = state.numberOfSubAccounts;
             }
         };
+        this.mostRecentSlot = 0;
         this.driftClient = config.driftClient;
         if (config.connection) {
             this.connection = config.connection;
@@ -218,6 +219,7 @@ class UserMap {
             await this.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
             const rpcResponseAndContext = rpcJSONResponse.result;
             const slot = rpcResponseAndContext.context.slot;
+            this.updateLatestSlot(slot);
             const programAccountBufferMap = new Map();
             for (const programAccount of rpcResponseAndContext.value) {
                 programAccountBufferMap.set(programAccount.pubkey.toString(), 
@@ -263,6 +265,7 @@ class UserMap {
         }
     }
     async updateUserAccount(key, userAccount, slot) {
+        this.updateLatestSlot(slot);
         if (!this.userMap.has(key)) {
             this.addPubkey(new web3_js_1.PublicKey(key), userAccount, slot);
         }
@@ -271,5 +274,11 @@ class UserMap {
             user.accountSubscriber.updateData(userAccount, slot);
         }
     }
+    updateLatestSlot(slot) {
+        this.mostRecentSlot = Math.max(slot, this.mostRecentSlot);
+    }
+    getSlot() {
+        return this.mostRecentSlot;
+    }
 }
 exports.UserMap = UserMap;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.52.0-beta.1",
+	"version": "2.52.0-beta.3",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/webSocketAccountSubscriber.ts

@@ -40,7 +40,7 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 	}
 
 	async subscribe(onChange: (data: T) => void): Promise<void> {
-		if (this.listenerId || this.isUnsubscribing) {
+		if (this.listenerId != null || this.isUnsubscribing) {
 			return;
 		}
 
@@ -95,7 +95,7 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 				console.log(
 					`No ws data from ${this.accountName} in ${this.resubTimeoutMs}ms, resubscribing`
 				);
-				await this.unsubscribe();
+				await this.unsubscribe(true);
 				this.receivingData = false;
 				await this.subscribe(this.onChange);
 			}
@@ -164,12 +164,15 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 		}
 	}
 
-	unsubscribe(): Promise<void> {
+	unsubscribe(onResub = false): Promise<void> {
+		if (!onResub) {
+			this.resubTimeoutMs = undefined;
+		}
 		this.isUnsubscribing = true;
 		clearTimeout(this.timeoutId);
 		this.timeoutId = undefined;
 
-		if (this.listenerId) {
+		if (this.listenerId != null) {
 			const promise = this.program.provider.connection
 				.removeAccountChangeListener(this.listenerId)
 				.then(() => {

package/src/accounts/webSocketProgramAccountSubscriber.ts

@@ -49,7 +49,7 @@ export class WebSocketProgramAccountSubscriber<T>
 	async subscribe(
 		onChange: (accountId: PublicKey, data: T, context: Context) => void
 	): Promise<void> {
-		if (this.listenerId || this.isUnsubscribing) {
+		if (this.listenerId != null || this.isUnsubscribing) {
 			return;
 		}
 
@@ -91,7 +91,7 @@ export class WebSocketProgramAccountSubscriber<T>
 				console.log(
 					`No ws data from ${this.subscriptionName} in ${this.resubTimeoutMs}ms, resubscribing`
 				);
-				await this.unsubscribe();
+				await this.unsubscribe(true);
 				this.receivingData = false;
 				await this.subscribe(this.onChange);
 			}
@@ -145,12 +145,15 @@ export class WebSocketProgramAccountSubscriber<T>
 		}
 	}
 
-	unsubscribe(): Promise<void> {
+	unsubscribe(onResub = false): Promise<void> {
+		if (!onResub) {
+			this.resubTimeoutMs = undefined;
+		}
 		this.isUnsubscribing = true;
 		clearTimeout(this.timeoutId);
 		this.timeoutId = undefined;
 
-		if (this.listenerId) {
+		if (this.listenerId != null) {
 			const promise = this.program.provider.connection
 				.removeAccountChangeListener(this.listenerId)
 				.then(() => {

package/src/dlob/orderBookLevels.ts

@@ -407,3 +407,139 @@ function groupL2Levels(
 	}
 	return groupedLevels;
 }
+
+/**
+ * The purpose of this function is uncross the L2 orderbook by modifying the bid/ask price at the top of the book
+ * This will make the liquidity look worse but more intuitive (users familiar with clob get confused w temporarily
+ * crossing book)
+ *
+ * Things to note about how it works:
+ * - it will not uncross the user's liquidity
+ * - it does the uncrossing by "shifting" the crossing liquidity to the nearest uncrossed levels. Thus the output liquidity maintains the same total size.
+ *
+ * @param bids
+ * @param asks
+ * @param oraclePrice
+ * @param oracleTwap5Min
+ * @param markTwap5Min
+ * @param grouping
+ * @param userBids
+ * @param userAsks
+ */
+export function uncrossL2(
+	bids: L2Level[],
+	asks: L2Level[],
+	oraclePrice: BN,
+	oracleTwap5Min: BN,
+	markTwap5Min: BN,
+	grouping: BN,
+	userBids: Set<string>,
+	userAsks: Set<string>
+): { bids: L2Level[]; asks: L2Level[] } {
+	// If there are no bids or asks, there is nothing to center
+	if (bids.length === 0 || asks.length === 0) {
+		return { bids, asks };
+	}
+
+	// If the top of the book is already centered, there is nothing to do
+	if (bids[0].price.lt(asks[0].price)) {
+		return { bids, asks };
+	}
+
+	const newBids = [];
+	const newAsks = [];
+
+	const updateLevels = (newPrice: BN, oldLevel: L2Level, levels: L2Level[]) => {
+		if (levels.length > 0 && levels[levels.length - 1].price.eq(newPrice)) {
+			levels[levels.length - 1].size = levels[levels.length - 1].size.add(
+				oldLevel.size
+			);
+			for (const [source, size] of Object.entries(oldLevel.sources)) {
+				if (levels[levels.length - 1].sources[source]) {
+					levels[levels.length - 1].sources = {
+						...levels[levels.length - 1].sources,
+						[source]: levels[levels.length - 1].sources[source].add(size),
+					};
+				} else {
+					levels[levels.length - 1].sources[source] = size;
+				}
+			}
+		} else {
+			levels.push({
+				price: newPrice,
+				size: oldLevel.size,
+				sources: oldLevel.sources,
+			});
+		}
+	};
+
+	// This is the best estimate of the premium in the market vs oracle to filter crossing around
+	const referencePrice = oraclePrice.add(markTwap5Min.sub(oracleTwap5Min));
+
+	let bidIndex = 0;
+	let askIndex = 0;
+	while (bidIndex < bids.length || askIndex < asks.length) {
+		const nextBid = bids[bidIndex];
+		const nextAsk = asks[askIndex];
+
+		if (!nextBid) {
+			newAsks.push(nextAsk);
+			askIndex++;
+			continue;
+		}
+
+		if (!nextAsk) {
+			newBids.push(nextBid);
+			bidIndex++;
+			continue;
+		}
+
+		if (nextBid.price.gt(nextAsk.price)) {
+			if (userBids.has(nextBid.price.toString())) {
+				newBids.push(nextBid);
+				bidIndex++;
+				continue;
+			}
+
+			if (userAsks.has(nextAsk.price.toString())) {
+				newAsks.push(nextAsk);
+				askIndex++;
+				continue;
+			}
+
+			if (
+				nextBid.price.gt(referencePrice) &&
+				nextAsk.price.gt(referencePrice)
+			) {
+				const newBidPrice = nextAsk.price.sub(grouping);
+				updateLevels(newBidPrice, nextBid, newBids);
+				bidIndex++;
+			} else if (
+				nextAsk.price.lt(referencePrice) &&
+				nextBid.price.lt(referencePrice)
+			) {
+				const newAskPrice = nextBid.price.add(grouping);
+				updateLevels(newAskPrice, nextAsk, newAsks);
+				askIndex++;
+			} else {
+				const newBidPrice = referencePrice.sub(grouping);
+				const newAskPrice = referencePrice.add(grouping);
+				updateLevels(newBidPrice, nextBid, newBids);
+				updateLevels(newAskPrice, nextAsk, newAsks);
+				bidIndex++;
+				askIndex++;
+			}
+		} else {
+			newAsks.push(nextAsk);
+			askIndex++;
+
+			newBids.push(nextBid);
+			bidIndex++;
+		}
+	}
+
+	return {
+		bids: newBids,
+		asks: newAsks,
+	};
+}

package/src/driftClient.ts

@@ -3959,9 +3959,14 @@ export class DriftClient {
 			userAccountPublicKey || (await this.getUserAccountPublicKey());
 
 		const userAccounts = [];
-		if (this.hasUser() && this.getUser().getUserAccountAndSlot()) {
-			userAccounts.push(this.getUser().getUserAccountAndSlot()!.data);
+		try {
+			if (this.hasUser() && this.getUser().getUserAccountAndSlot()) {
+				userAccounts.push(this.getUser().getUserAccountAndSlot()!.data);
+			}
+		} catch (err) {
+			// ignore
 		}
+
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts,
 			writableSpotMarketIndexes: [outMarketIndex, inMarketIndex],

package/src/events/webSocketLogProvider.ts

@@ -23,7 +23,7 @@ export class WebSocketLogProvider implements LogProvider {
 	}
 
 	public async subscribe(callback: logProviderCallback): Promise<boolean> {
-		if (this.subscriptionId) {
+		if (this.subscriptionId != null) {
 			return true;
 		}
 
@@ -62,7 +62,7 @@ export class WebSocketLogProvider implements LogProvider {
 	}
 
 	public isSubscribed(): boolean {
-		return this.subscriptionId !== undefined;
+		return this.subscriptionId != null;
 	}
 
 	public async unsubscribe(external = false): Promise<boolean> {
@@ -71,7 +71,7 @@ export class WebSocketLogProvider implements LogProvider {
 		clearTimeout(this.timeoutId);
 		this.timeoutId = undefined;
 
-		if (this.subscriptionId !== undefined) {
+		if (this.subscriptionId != null) {
 			try {
 				await this.connection.removeOnLogsListener(this.subscriptionId);
 				this.subscriptionId = undefined;

package/src/factory/bigNum.ts

@@ -497,7 +497,11 @@ export class BigNum {
 		return `${prefix}${val.replace('-', '')}`;
 	}
 
-	public toMillified(precision = 3, rounded = false): string {
+	public toMillified(
+		precision = 3,
+		rounded = false,
+		type: 'financial' | 'scientific' = 'financial'
+	): string {
 		if (rounded) {
 			return this.toRounded(precision).toMillified(precision);
 		}
@@ -520,7 +524,12 @@ export class BigNum {
 			return this.shift(new BN(precision)).toPrecision(precision, true);
 		}
 
-		const unitTicks = ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+		const unitTicks =
+			type === 'financial'
+				? ['', 'K', 'M', 'B', 'T', 'Q']
+				: ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+		// TODO -- handle nubers which are larger than the max unit tick
+
 		const unitNumber = Math.floor((leftSide.length - 1) / 3);
 		const unit = unitTicks[unitNumber];
 

package/src/idl/drift.json

@@ -7343,12 +7343,24 @@
             "name": "totalFeeEarnedPerLp",
             "type": "u64"
           },
+          {
+            "name": "netUnsettledFundingPnl",
+            "type": "i64"
+          },
+          {
+            "name": "quoteAssetAmountWithUnsettledLp",
+            "type": "i64"
+          },
+          {
+            "name": "referencePriceOffset",
+            "type": "i32"
+          },
           {
             "name": "padding",
             "type": {
               "array": [
                 "u8",
-                32
+                12
               ]
             }
           }

package/src/math/amm.ts

@@ -12,6 +12,7 @@ import {
 	PRICE_DIV_PEG,
 	PERCENTAGE_PRECISION,
 	DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT,
+	FUNDING_RATE_BUFFER_PRECISION,
 	TWO,
 } from '../constants/numericConstants';
 import {
@@ -22,7 +23,7 @@ import {
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
-import { squareRootBN, clampBN, standardizeBaseAssetAmount } from '..';
+import { squareRootBN, sigNum, clampBN, standardizeBaseAssetAmount } from '..';
 
 import { OraclePriceData } from '../oracles/types';
 import {
@@ -352,21 +353,12 @@ export function calculateMarketOpenBidAsk(
 	return [openBids, openAsks];
 }
 
-export function calculateInventoryScale(
+export function calculateInventoryLiquidityRatio(
 	baseAssetAmountWithAmm: BN,
 	baseAssetReserve: BN,
 	minBaseAssetReserve: BN,
-	maxBaseAssetReserve: BN,
-	directionalSpread: number,
-	maxSpread: number
-): number {
-	if (baseAssetAmountWithAmm.eq(ZERO)) {
-		return 1;
-	}
-
-	const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = BID_ASK_SPREAD_PRECISION.mul(
-		new BN(10)
-	);
+	maxBaseAssetReserve: BN
+): BN {
 	// inventory skew
 	const [openBids, openAsks] = calculateMarketOpenBidAsk(
 		baseAssetReserve,
@@ -383,6 +375,31 @@ export function calculateInventoryScale(
 			.abs(),
 		PERCENTAGE_PRECISION
 	);
+	return inventoryScaleBN;
+}
+
+export function calculateInventoryScale(
+	baseAssetAmountWithAmm: BN,
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN,
+	directionalSpread: number,
+	maxSpread: number
+): number {
+	if (baseAssetAmountWithAmm.eq(ZERO)) {
+		return 1;
+	}
+
+	const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = BID_ASK_SPREAD_PRECISION.mul(
+		new BN(10)
+	);
+
+	const inventoryScaleBN = calculateInventoryLiquidityRatio(
+		baseAssetAmountWithAmm,
+		baseAssetReserve,
+		minBaseAssetReserve,
+		maxBaseAssetReserve
+	);
 
 	const inventoryScaleMaxBN = BN.max(
 		MAX_BID_ASK_INVENTORY_SKEW_FACTOR,
@@ -402,6 +419,76 @@ export function calculateInventoryScale(
 	return inventoryScaleCapped;
 }
 
+export function calculateReferencePriceOffset(
+	reservePrice: BN,
+	last24hAvgFundingRate: BN,
+	liquidityFraction: BN,
+	oracleTwapFast: BN,
+	markTwapFast: BN,
+	oracleTwapSlow: BN,
+	markTwapSlow: BN,
+	maxOffsetPct: number
+): BN {
+	if (last24hAvgFundingRate.eq(ZERO)) {
+		return ZERO;
+	}
+
+	const maxOffsetInPrice = new BN(maxOffsetPct)
+		.mul(reservePrice)
+		.div(PERCENTAGE_PRECISION);
+
+	// Calculate quote denominated market premium
+	const markPremiumMinute = clampBN(
+		markTwapFast.sub(oracleTwapFast),
+		maxOffsetInPrice.mul(new BN(-1)),
+		maxOffsetInPrice
+	);
+
+	const markPremiumHour = clampBN(
+		markTwapSlow.sub(oracleTwapSlow),
+		maxOffsetInPrice.mul(new BN(-1)),
+		maxOffsetInPrice
+	);
+
+	// Convert last24hAvgFundingRate to quote denominated premium
+	const markPremiumDay = clampBN(
+		last24hAvgFundingRate.div(FUNDING_RATE_BUFFER_PRECISION).mul(new BN(24)),
+		maxOffsetInPrice.mul(new BN(-1)),
+		maxOffsetInPrice
+	);
+
+	// Take average clamped premium as the price-based offset
+	const markPremiumAvg = markPremiumMinute
+		.add(markPremiumHour)
+		.add(markPremiumDay)
+		.div(new BN(3));
+
+	const markPremiumAvgPct = markPremiumAvg
+		.mul(PRICE_PRECISION)
+		.div(reservePrice);
+
+	const inventoryPct = clampBN(
+		liquidityFraction.mul(new BN(maxOffsetPct)).div(PERCENTAGE_PRECISION),
+		maxOffsetInPrice.mul(new BN(-1)),
+		maxOffsetInPrice
+	);
+
+	// Only apply when inventory is consistent with recent and 24h market premium
+	let offsetPct = markPremiumAvgPct.add(inventoryPct);
+
+	if (!sigNum(inventoryPct).eq(sigNum(markPremiumAvgPct))) {
+		offsetPct = ZERO;
+	}
+
+	const clampedOffsetPct = clampBN(
+		offsetPct,
+		new BN(-maxOffsetPct),
+		new BN(maxOffsetPct)
+	);
+
+	return clampedOffsetPct;
+}
+
 export function calculateEffectiveLeverage(
 	baseSpread: number,
 	quoteAssetReserve: BN,
@@ -532,6 +619,8 @@ export function calculateSpreadBN(
 		halfRevenueRetreatAmount: 0,
 		longSpreadwRevRetreat: 0,
 		shortSpreadwRevRetreat: 0,
+		longSpreadwOffsetShrink: 0,
+		shortSpreadwOffsetShrink: 0,
 		totalSpread: 0,
 		longSpread: 0,
 		shortSpread: 0,
@@ -678,7 +767,6 @@ export function calculateSpreadBN(
 	spreadTerms.totalSpread = totalSpread;
 	spreadTerms.longSpread = longSpread;
 	spreadTerms.shortSpread = shortSpread;
-
 	if (returnTerms) {
 		return spreadTerms;
 	}
@@ -688,17 +776,20 @@ export function calculateSpreadBN(
 export function calculateSpread(
 	amm: AMM,
 	oraclePriceData: OraclePriceData,
-	now?: BN
+	now?: BN,
+	reservePrice?: BN
 ): [number, number] {
 	if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
 		return [amm.baseSpread / 2, amm.baseSpread / 2];
 	}
 
-	const reservePrice = calculatePrice(
-		amm.baseAssetReserve,
-		amm.quoteAssetReserve,
-		amm.pegMultiplier
-	);
+	if (!reservePrice) {
+		reservePrice = calculatePrice(
+			amm.baseAssetReserve,
+			amm.quoteAssetReserve,
+			amm.pegMultiplier
+		);
+	}
 
 	const targetPrice = oraclePriceData?.price || reservePrice;
 	const confInterval = oraclePriceData.confidence || ZERO;
@@ -760,13 +851,22 @@ export function calculateSpreadReserves(
 				quoteAssetReserve: amm.quoteAssetReserve,
 			};
 		}
-		const spreadFraction = BN.max(new BN(spread / 2), ONE);
+		let spreadFraction = new BN(spread / 2);
+
+		// make non-zero
+		if (spreadFraction.eq(ZERO)) {
+			spreadFraction = spread >= 0 ? new BN(1) : new BN(-1);
+		}
+
 		const quoteAssetReserveDelta = amm.quoteAssetReserve.div(
 			BID_ASK_SPREAD_PRECISION.div(spreadFraction)
 		);
 
 		let quoteAssetReserve;
-		if (isVariant(direction, 'long')) {
+		if (
+			(spread >= 0 && isVariant(direction, 'long')) ||
+			(spread <= 0 && isVariant(direction, 'short'))
+		) {
 			quoteAssetReserve = amm.quoteAssetReserve.add(quoteAssetReserveDelta);
 		} else {
 			quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAssetReserveDelta);
@@ -779,14 +879,48 @@ export function calculateSpreadReserves(
 		};
 	}
 
-	const [longSpread, shortSpread] = calculateSpread(amm, oraclePriceData, now);
+	const reservePrice = calculatePrice(
+		amm.baseAssetReserve,
+		amm.quoteAssetReserve,
+		amm.pegMultiplier
+	);
+
+	// always allow 10 bps of price offset, up to a fifth of the market's max_spread
+	const maxOffset = Math.max(
+		amm.maxSpread / 5,
+		PERCENTAGE_PRECISION.toNumber() / 1000
+	);
+	const liquidityFraction = calculateInventoryLiquidityRatio(
+		amm.baseAssetAmountWithAmm,
+		amm.baseAssetReserve,
+		amm.minBaseAssetReserve,
+		amm.maxBaseAssetReserve
+	);
+	const referencePriceOffset = calculateReferencePriceOffset(
+		reservePrice,
+		amm.last24HAvgFundingRate,
+		liquidityFraction,
+		amm.historicalOracleData.lastOraclePriceTwap5Min,
+		amm.lastMarkPriceTwap5Min,
+		amm.historicalOracleData.lastOraclePriceTwap,
+		amm.lastMarkPriceTwap,
+		maxOffset
+	);
+
+	const [longSpread, shortSpread] = calculateSpread(
+		amm,
+		oraclePriceData,
+		now,
+		reservePrice
+	);
+
 	const askReserves = calculateSpreadReserve(
-		longSpread,
+		longSpread + referencePriceOffset.toNumber(),
 		PositionDirection.LONG,
 		amm
 	);
 	const bidReserves = calculateSpreadReserve(
-		shortSpread,
+		shortSpread + referencePriceOffset.toNumber(),
 		PositionDirection.SHORT,
 		amm
 	);

package/src/phoenix/phoenixSubscriber.ts

@@ -178,9 +178,9 @@ export class PhoenixSubscriber implements L2OrderBookGenerator {
 
 		for (let i = 0; i < ladder[side].length; i++) {
 			const { price, quantity } = ladder[side][i];
-			const size = new BN(Math.floor(quantity * basePrecision));
+			const size = new BN(quantity).mul(new BN(basePrecision));
 			yield {
-				price: new BN(Math.floor(price * pricePrecision)),
+				price: new BN(price).mul(new BN(pricePrecision)),
 				size,
 				sources: {
 					phoenix: size,