@drift-labs/sdk 2.12.0-beta.3 → 2.13.0-beta.0

package/src/dlob/DLOB.ts

@@ -519,10 +519,11 @@ export class DLOB {
 			marketType,
 			oraclePriceData,
 			marketOrderGenerator,
-			this.getLimitBids.bind(this),
+			this.getMakerLimitBids.bind(this),
 			(takerPrice, makerPrice) => {
 				return takerPrice === undefined || takerPrice.lte(makerPrice);
-			}
+			},
+			fallbackAsk
 		);
 		for (const marketAskCrossingBid of marketAsksCrossingBids) {
 			nodesToFill.push(marketAskCrossingBid);
@@ -555,10 +556,11 @@ export class DLOB {
 			marketType,
 			oraclePriceData,
 			marketOrderGenerator,
-			this.getLimitAsks.bind(this),
+			this.getMakerLimitAsks.bind(this),
 			(takerPrice, fallbackPrice) => {
 				return takerPrice === undefined || takerPrice.gte(fallbackPrice);
-			}
+			},
+			fallbackBid
 		);
 
 		for (const marketBidToFill of marketBidsToFill) {
@@ -596,9 +598,11 @@ export class DLOB {
 			marketIndex: number,
 			slot: number,
 			marketType: MarketType,
-			oraclePriceData: OraclePriceData
+			oraclePriceData: OraclePriceData,
+			fallbackPrice?: BN
 		) => Generator<DLOBNode>,
-		doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean
+		doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean,
+		fallbackPrice?: BN
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
@@ -607,7 +611,8 @@ export class DLOB {
 				marketIndex,
 				slot,
 				marketType,
-				oraclePriceData
+				oraclePriceData,
+				fallbackPrice
 			);
 
 			for (const makerNode of makerNodeGenerator) {
@@ -916,17 +921,17 @@ export class DLOB {
 	}
 
 	/**
-	 * Filters the limit asks that are post only or have been place for sufficiently long
-	 * Useful for displaying order book that doesn't have taker limit orders crossing spread
+	 * Filters the limit asks that are post only, have been place for sufficiently long or are above the fallback bid
+	 * Market orders can only fill against orders that meet this criteria
 	 *
 	 * @returns
 	 */
-	*getRestingLimitAsks(
+	*getMakerLimitAsks(
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData,
-		minPerpAuctionDuration: number
+		fallbackBid?: BN
 	): Generator<DLOBNode> {
 		for (const node of this.getLimitAsks(
 			marketIndex,
@@ -934,21 +939,19 @@ export class DLOB {
 			marketType,
 			oraclePriceData
 		)) {
-			if (this.isRestingLimitOrder(node.order, slot, minPerpAuctionDuration)) {
+			if (this.isRestingLimitOrder(node.order, slot)) {
+				yield node;
+			} else if (
+				fallbackBid &&
+				node.getPrice(oraclePriceData, slot).gt(fallbackBid)
+			) {
 				yield node;
 			}
 		}
 	}
 
-	isRestingLimitOrder(
-		order: Order,
-		slot: number,
-		minPerpAuctionDuration: number
-	): boolean {
-		return (
-			order.postOnly ||
-			new BN(slot).sub(order.slot).gte(new BN(minPerpAuctionDuration * 1.5))
-		);
+	isRestingLimitOrder(order: Order, slot: number): boolean {
+		return order.postOnly || new BN(slot).sub(order.slot).gte(new BN(15));
 	}
 
 	*getLimitBids(
@@ -984,17 +987,17 @@ export class DLOB {
 	}
 
 	/**
-	 * Filters the limit bids that are post only or have been place for sufficiently long
-	 * Useful for displaying order book that doesn't have taker limit orders crossing spread
+	 * Filters the limit bids that are post only, have been place for sufficiently long or are below the fallback ask
+	 * Market orders can only fill against orders that meet this criteria
 	 *
 	 * @returns
 	 */
-	*getRestingLimitBids(
+	*getMakerLimitBids(
 		marketIndex: number,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData,
-		minPerpAuctionDuration: number
+		fallbackAsk?: BN
 	): Generator<DLOBNode> {
 		for (const node of this.getLimitBids(
 			marketIndex,
@@ -1002,7 +1005,12 @@ export class DLOB {
 			marketType,
 			oraclePriceData
 		)) {
-			if (this.isRestingLimitOrder(node.order, slot, minPerpAuctionDuration)) {
+			if (this.isRestingLimitOrder(node.order, slot)) {
+				yield node;
+			} else if (
+				fallbackAsk &&
+				node.getPrice(oraclePriceData, slot).lt(fallbackAsk)
+			) {
 				yield node;
 			}
 		}

package/src/examples/loadDlob.ts

@@ -0,0 +1,82 @@
+import { AnchorProvider } from '@project-serum/anchor';
+import { DLOB, UserMap, Wallet } from '..';
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import {
+	DriftClient,
+	initialize,
+	BulkAccountLoader,
+	getMarketsAndOraclesForSubscription,
+} from '..';
+
+const env = 'mainnet-beta';
+
+const main = async () => {
+	// Initialize Drift SDK
+	const sdkConfig = initialize({ env });
+
+	// Set up the Wallet and Provider
+	const privateKey = process.env.BOT_PRIVATE_KEY; // stored as an array string
+	const keypair = Keypair.fromSecretKey(
+		Uint8Array.from(JSON.parse(privateKey))
+	);
+	const wallet = new Wallet(keypair);
+
+	// Set up the Connection
+	const rpcAddress = process.env.RPC_ADDRESS; // can use: https://api.devnet.solana.com for devnet; https://api.mainnet-beta.solana.com for mainnet;
+	const connection = new Connection(rpcAddress);
+
+	// Set up the Provider
+	const provider = new AnchorProvider(
+		connection,
+		wallet,
+		AnchorProvider.defaultOptions()
+	);
+
+	// Set up the Drift Clearing House
+	const driftPublicKey = new PublicKey(sdkConfig.DRIFT_PROGRAM_ID);
+	const bulkAccountLoader = new BulkAccountLoader(
+		connection,
+		'confirmed',
+		1000
+	);
+	const driftClient = new DriftClient({
+		connection,
+		wallet: provider.wallet,
+		programID: driftPublicKey,
+		...getMarketsAndOraclesForSubscription(env),
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: bulkAccountLoader,
+		},
+	});
+
+	console.log('Subscribing drift client...');
+	await driftClient.subscribe();
+
+	console.log('Loading user map...');
+	const userMap = new UserMap(driftClient, {
+		type: 'polling',
+		accountLoader: bulkAccountLoader,
+	});
+
+	// fetches all users and subscribes for updates
+	await userMap.fetchAllUsers();
+
+	console.log('Loading dlob from user map...');
+	const dlob = new DLOB();
+	await dlob.initFromUserMap(userMap);
+
+	console.log('number of orders', dlob.getDLOBOrders().length);
+
+	dlob.clear();
+
+	console.log('Unsubscribing users...');
+	for (const user of userMap.values()) {
+		await user.unsubscribe();
+	}
+
+	console.log('Unsubscribing drift client...');
+	await driftClient.unsubscribe();
+};
+
+main();

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.12.0-beta.3",
+  "version": "2.13.0-beta.0",
   "name": "drift",
   "instructions": [
     {

package/src/math/trade.ts

@@ -1,4 +1,9 @@
-import { MarketType, PerpMarketAccount, PositionDirection } from '../types';
+import {
+	MarketType,
+	PerpMarketAccount,
+	PositionDirection,
+	SpotMarketAccount,
+} from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -7,6 +12,7 @@ import {
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	ZERO,
 	BASE_PRECISION,
+	BN_MAX,
 } from '../constants/numericConstants';
 import {
 	calculateBidPrice,
@@ -20,11 +26,14 @@ import {
 	AssetType,
 	calculateUpdatedAMMSpreadReserves,
 	calculateQuoteAssetAmountSwapped,
+	calculateMarketOpenBidAsk,
 } from './amm';
 import { squareRootBN } from './utils';
 import { isVariant } from '../types';
 import { OraclePriceData } from '../oracles/types';
 import { DLOB } from '../dlob/DLOB';
+import { PublicKey } from '@solana/web3.js';
+import { Orderbook } from '@project-serum/serum';
 
 const MAXPCT = new BN(1000); //percentage units are [0,1000] => [0,1]
 
@@ -363,7 +372,7 @@ export function calculateTargetPriceTrade(
  * @param oraclePriceData
  * @param dlob
  * @param slot
- * @param minPerpAuctionDuration
+ * @param usersToSkip
  */
 export function calculateEstimatedPerpEntryPrice(
 	assetType: AssetType,
@@ -373,21 +382,37 @@ export function calculateEstimatedPerpEntryPrice(
 	oraclePriceData: OraclePriceData,
 	dlob: DLOB,
 	slot: number,
-	minPerpAuctionDuration: number
-): [BN, BN] {
+	usersToSkip = new Map<PublicKey, boolean>()
+): {
+	entryPrice: BN;
+	priceImpact: BN;
+	bestPrice: BN;
+	worstPrice: BN;
+	baseFilled: BN;
+	quoteFilled: BN;
+} {
 	if (amount.eq(ZERO)) {
-		return [ZERO, ZERO];
+		return {
+			entryPrice: ZERO,
+			priceImpact: ZERO,
+			bestPrice: ZERO,
+			worstPrice: ZERO,
+			baseFilled: ZERO,
+			quoteFilled: ZERO,
+		};
 	}
 
 	const takerIsLong = isVariant(direction, 'long');
 	const limitOrders = dlob[
-		takerIsLong ? 'getRestingLimitAsks' : 'getRestingLimitBids'
+		takerIsLong ? 'getMakerLimitAsks' : 'getMakerLimitBids'
 	](
 		market.marketIndex,
 		slot,
 		MarketType.PERP,
 		oraclePriceData,
-		minPerpAuctionDuration
+		takerIsLong
+			? calculateBidPrice(market, oraclePriceData)
+			: calculateAskPrice(market, oraclePriceData)
 	);
 
 	const swapDirection = getSwapDirection(assetType, direction);
@@ -401,9 +426,34 @@ export function calculateEstimatedPerpEntryPrice(
 		pegMultiplier: newPeg,
 	};
 
+	const [ammBids, ammAsks] = calculateMarketOpenBidAsk(
+		market.amm.baseAssetReserve,
+		market.amm.minBaseAssetReserve,
+		market.amm.maxBaseAssetReserve,
+		market.amm.orderStepSize
+	);
+
+	let ammLiquidity: BN;
+	if (assetType === 'base') {
+		ammLiquidity = takerIsLong ? ammAsks.abs() : ammBids;
+	} else {
+		const [afterSwapQuoteReserves, _] = calculateAmmReservesAfterSwap(
+			amm,
+			'base',
+			takerIsLong ? ammAsks.abs() : ammBids,
+			getSwapDirection('base', direction)
+		);
+
+		ammLiquidity = calculateQuoteAssetAmountSwapped(
+			amm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
+			amm.pegMultiplier,
+			swapDirection
+		);
+	}
+
 	const invariant = amm.sqrtK.mul(amm.sqrtK);
 
-	let initialPrice = calculatePrice(
+	let bestPrice = calculatePrice(
 		amm.baseAssetReserve,
 		amm.quoteAssetReserve,
 		amm.pegMultiplier
@@ -415,13 +465,18 @@ export function calculateEstimatedPerpEntryPrice(
 	let limitOrder = limitOrders.next().value;
 	if (limitOrder) {
 		const limitOrderPrice = limitOrder.getPrice(oraclePriceData, slot);
-		initialPrice = takerIsLong
-			? BN.min(limitOrderPrice, initialPrice)
-			: BN.max(limitOrderPrice, initialPrice);
+		bestPrice = takerIsLong
+			? BN.min(limitOrderPrice, bestPrice)
+			: BN.max(limitOrderPrice, bestPrice);
 	}
 
+	let worstPrice = bestPrice;
+
 	if (assetType === 'base') {
-		while (!cumulativeBaseFilled.eq(amount)) {
+		while (
+			!cumulativeBaseFilled.eq(amount) &&
+			(ammLiquidity.gt(ZERO) || limitOrder)
+		) {
 			const limitOrderPrice = limitOrder?.getPrice(oraclePriceData, slot);
 
 			let maxAmmFill: BN;
@@ -442,11 +497,15 @@ export function calculateEstimatedPerpEntryPrice(
 				maxAmmFill = amount.sub(cumulativeBaseFilled);
 			}
 
+			maxAmmFill = BN.min(maxAmmFill, ammLiquidity);
+
 			if (maxAmmFill.gt(ZERO)) {
 				const baseFilled = BN.min(amount.sub(cumulativeBaseFilled), maxAmmFill);
 				const [afterSwapQuoteReserves, afterSwapBaseReserves] =
 					calculateAmmReservesAfterSwap(amm, 'base', baseFilled, swapDirection);
 
+				ammLiquidity = ammLiquidity.sub(baseFilled);
+
 				const quoteFilled = calculateQuoteAssetAmountSwapped(
 					amm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
 					amm.pegMultiplier,
@@ -459,11 +518,21 @@ export function calculateEstimatedPerpEntryPrice(
 				amm.baseAssetReserve = afterSwapBaseReserves;
 				amm.quoteAssetReserve = afterSwapQuoteReserves;
 
+				worstPrice = calculatePrice(
+					amm.baseAssetReserve,
+					amm.quoteAssetReserve,
+					amm.pegMultiplier
+				);
+
 				if (cumulativeBaseFilled.eq(amount)) {
 					break;
 				}
 			}
 
+			if (limitOrder && usersToSkip.has(limitOrder.userAccount)) {
+				continue;
+			}
+
 			const baseFilled = BN.min(
 				limitOrder.order.baseAssetAmount.sub(
 					limitOrder.order.baseAssetAmountFilled
@@ -475,6 +544,8 @@ export function calculateEstimatedPerpEntryPrice(
 			cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
 			cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
 
+			worstPrice = limitOrderPrice;
+
 			if (cumulativeBaseFilled.eq(amount)) {
 				break;
 			}
@@ -482,7 +553,10 @@ export function calculateEstimatedPerpEntryPrice(
 			limitOrder = limitOrders.next().value;
 		}
 	} else {
-		while (!cumulativeQuoteFilled.eq(amount)) {
+		while (
+			!cumulativeQuoteFilled.eq(amount) &&
+			(ammLiquidity.gt(ZERO) || limitOrder)
+		) {
 			const limitOrderPrice = limitOrder?.getPrice(oraclePriceData, slot);
 
 			let maxAmmFill: BN;
@@ -503,6 +577,8 @@ export function calculateEstimatedPerpEntryPrice(
 				maxAmmFill = amount.sub(cumulativeQuoteFilled);
 			}
 
+			maxAmmFill = BN.min(maxAmmFill, ammLiquidity);
+
 			if (maxAmmFill.gt(ZERO)) {
 				const quoteFilled = BN.min(
 					amount.sub(cumulativeQuoteFilled),
@@ -516,6 +592,8 @@ export function calculateEstimatedPerpEntryPrice(
 						swapDirection
 					);
 
+				ammLiquidity = ammLiquidity.sub(quoteFilled);
+
 				const baseFilled = afterSwapBaseReserves
 					.sub(amm.baseAssetReserve)
 					.abs();
@@ -526,11 +604,21 @@ export function calculateEstimatedPerpEntryPrice(
 				amm.baseAssetReserve = afterSwapBaseReserves;
 				amm.quoteAssetReserve = afterSwapQuoteReserves;
 
+				worstPrice = calculatePrice(
+					amm.baseAssetReserve,
+					amm.quoteAssetReserve,
+					amm.pegMultiplier
+				);
+
 				if (cumulativeQuoteFilled.eq(amount)) {
 					break;
 				}
 			}
 
+			if (limitOrder && usersToSkip.has(limitOrder.userAccount)) {
+				continue;
+			}
+
 			const quoteFilled = BN.min(
 				limitOrder.order.baseAssetAmount
 					.sub(limitOrder.order.baseAssetAmountFilled)
@@ -544,6 +632,8 @@ export function calculateEstimatedPerpEntryPrice(
 			cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
 			cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
 
+			worstPrice = limitOrderPrice;
+
 			if (cumulativeQuoteFilled.eq(amount)) {
 				break;
 			}
@@ -557,10 +647,226 @@ export function calculateEstimatedPerpEntryPrice(
 		.div(cumulativeBaseFilled);
 
 	const priceImpact = entryPrice
-		.sub(initialPrice)
+		.sub(bestPrice)
+		.mul(PRICE_PRECISION)
+		.div(bestPrice)
+		.abs();
+
+	return {
+		entryPrice,
+		priceImpact,
+		bestPrice,
+		worstPrice,
+		baseFilled: cumulativeBaseFilled,
+		quoteFilled: cumulativeQuoteFilled,
+	};
+}
+
+/**
+ * Calculates the estimated entry price and price impact of order, in base or quote
+ * Price impact is based on the difference between the entry price and the best bid/ask price (whether it's dlob or serum)
+ *
+ * @param assetType
+ * @param amount
+ * @param direction
+ * @param market
+ * @param oraclePriceData
+ * @param dlob
+ * @param serumBids
+ * @param serumAsks
+ * @param slot
+ * @param usersToSkip
+ */
+export function calculateEstimatedSpotEntryPrice(
+	assetType: AssetType,
+	amount: BN,
+	direction: PositionDirection,
+	market: SpotMarketAccount,
+	oraclePriceData: OraclePriceData,
+	dlob: DLOB,
+	serumBids: Orderbook,
+	serumAsks: Orderbook,
+	slot: number,
+	usersToSkip = new Map<PublicKey, boolean>()
+): {
+	entryPrice: BN;
+	priceImpact: BN;
+	bestPrice: BN;
+	worstPrice: BN;
+	baseFilled: BN;
+	quoteFilled: BN;
+} {
+	if (amount.eq(ZERO)) {
+		return {
+			entryPrice: ZERO,
+			priceImpact: ZERO,
+			bestPrice: ZERO,
+			worstPrice: ZERO,
+			baseFilled: ZERO,
+			quoteFilled: ZERO,
+		};
+	}
+
+	const basePrecision = new BN(Math.pow(10, market.decimals));
+
+	const takerIsLong = isVariant(direction, 'long');
+	const dlobLimitOrders = dlob[
+		takerIsLong ? 'getMakerLimitAsks' : 'getMakerLimitBids'
+	](market.marketIndex, slot, MarketType.SPOT, oraclePriceData);
+	const serumLimitOrders = takerIsLong
+		? serumAsks.getL2(100)
+		: serumBids.getL2(100);
+
+	let cumulativeBaseFilled = ZERO;
+	let cumulativeQuoteFilled = ZERO;
+
+	let dlobLimitOrder = dlobLimitOrders.next().value;
+	let serumLimitOrder = serumLimitOrders.shift();
+
+	const dlobLimitOrderPrice = dlobLimitOrder?.getPrice(oraclePriceData, slot);
+	const serumLimitOrderPrice = serumLimitOrder
+		? new BN(serumLimitOrder[0] * PRICE_PRECISION.toNumber())
+		: undefined;
+
+	const bestPrice = takerIsLong
+		? BN.min(serumLimitOrderPrice || BN_MAX, dlobLimitOrderPrice || BN_MAX)
+		: BN.max(serumLimitOrderPrice || ZERO, dlobLimitOrderPrice || ZERO);
+	let worstPrice = bestPrice;
+
+	if (assetType === 'base') {
+		while (
+			!cumulativeBaseFilled.eq(amount) &&
+			(dlobLimitOrder || serumLimitOrder)
+		) {
+			const dlobLimitOrderPrice = dlobLimitOrder?.getPrice(
+				oraclePriceData,
+				slot
+			);
+			const serumLimitOrderPrice = serumLimitOrder
+				? new BN(serumLimitOrder[0] * PRICE_PRECISION.toNumber())
+				: undefined;
+
+			const useSerum = takerIsLong
+				? (serumLimitOrderPrice || BN_MAX).lt(dlobLimitOrderPrice || BN_MAX)
+				: (serumLimitOrderPrice || ZERO).gt(dlobLimitOrderPrice || ZERO);
+
+			if (!useSerum) {
+				if (dlobLimitOrder && usersToSkip.has(dlobLimitOrder.userAccount)) {
+					continue;
+				}
+
+				const baseFilled = BN.min(
+					dlobLimitOrder.order.baseAssetAmount.sub(
+						dlobLimitOrder.order.baseAssetAmountFilled
+					),
+					amount.sub(cumulativeBaseFilled)
+				);
+				const quoteFilled = baseFilled
+					.mul(dlobLimitOrderPrice)
+					.div(basePrecision);
+
+				cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+				cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+
+				worstPrice = dlobLimitOrder;
+
+				dlobLimitOrder = dlobLimitOrders.next().value;
+			} else {
+				const baseFilled = BN.min(
+					new BN(serumLimitOrder[1] * basePrecision.toNumber()),
+					amount.sub(cumulativeBaseFilled)
+				);
+				const quoteFilled = baseFilled
+					.mul(serumLimitOrderPrice)
+					.div(basePrecision);
+
+				cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+				cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+
+				worstPrice = serumLimitOrderPrice;
+
+				serumLimitOrder = serumLimitOrders.shift();
+			}
+		}
+	} else {
+		while (
+			!cumulativeQuoteFilled.eq(amount) &&
+			(dlobLimitOrder || serumLimitOrder)
+		) {
+			const dlobLimitOrderPrice = dlobLimitOrder?.getPrice(
+				oraclePriceData,
+				slot
+			);
+			const serumLimitOrderPrice = serumLimitOrder
+				? new BN(serumLimitOrder[0] * PRICE_PRECISION.toNumber())
+				: undefined;
+
+			const useSerum = takerIsLong
+				? (serumLimitOrderPrice || BN_MAX).lt(dlobLimitOrderPrice || BN_MAX)
+				: (serumLimitOrderPrice || ZERO).gt(dlobLimitOrderPrice || ZERO);
+
+			if (!useSerum) {
+				if (dlobLimitOrder && usersToSkip.has(dlobLimitOrder.userAccount)) {
+					continue;
+				}
+
+				const quoteFilled = BN.min(
+					dlobLimitOrder.order.baseAssetAmount
+						.sub(dlobLimitOrder.order.baseAssetAmountFilled)
+						.mul(dlobLimitOrderPrice)
+						.div(basePrecision),
+					amount.sub(cumulativeQuoteFilled)
+				);
+
+				const baseFilled = quoteFilled
+					.mul(basePrecision)
+					.div(dlobLimitOrderPrice);
+
+				cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+				cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+
+				worstPrice = dlobLimitOrderPrice;
+
+				dlobLimitOrder = dlobLimitOrders.next().value;
+			} else {
+				const serumOrderBaseAmount = new BN(
+					serumLimitOrder[1] * basePrecision.toNumber()
+				);
+				const quoteFilled = BN.min(
+					serumOrderBaseAmount.mul(serumLimitOrderPrice).div(basePrecision),
+					amount.sub(cumulativeQuoteFilled)
+				);
+
+				const baseFilled = quoteFilled
+					.mul(basePrecision)
+					.div(serumLimitOrderPrice);
+
+				cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+				cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+
+				worstPrice = serumLimitOrderPrice;
+
+				serumLimitOrder = serumLimitOrders.shift();
+			}
+		}
+	}
+
+	const entryPrice = cumulativeQuoteFilled
+		.mul(basePrecision)
+		.div(cumulativeBaseFilled);
+
+	const priceImpact = entryPrice
+		.sub(bestPrice)
 		.mul(PRICE_PRECISION)
-		.div(initialPrice)
+		.div(bestPrice)
 		.abs();
 
-	return [entryPrice, priceImpact];
+	return {
+		entryPrice,
+		priceImpact,
+		bestPrice,
+		worstPrice,
+		baseFilled: cumulativeBaseFilled,
+		quoteFilled: cumulativeQuoteFilled,
+	};
 }