@drift-labs/sdk 2.40.0-beta.9 → 2.41.0-beta.1

package/lib/jupiter/jupiterClient.js

@@ -43,8 +43,8 @@ class JupiterClient {
      * @param swapMode the swap mode (ExactIn or ExactOut)
      * @param onlyDirectRoutes whether to only return direct routes
      */
-    async getQuote({ inputMint, outputMint, amount, maxAccounts = 52, // 52 is an estimated amount with buffer
-    slippageBps = 50, swapMode = 'ExactIn', onlyDirectRoutes = false, }) {
+    async getQuote({ inputMint, outputMint, amount, maxAccounts = 50, // 50 is an estimated amount with buffer
+    slippageBps = 50, swapMode = 'ExactIn', onlyDirectRoutes = false, excludeDexes = [], }) {
         const params = new URLSearchParams({
             inputMint: inputMint.toString(),
             outputMint: outputMint.toString(),
@@ -53,6 +53,7 @@ class JupiterClient {
             swapMode,
             onlyDirectRoutes: onlyDirectRoutes.toString(),
             maxAccounts: maxAccounts.toString(),
+            excludeDexes: excludeDexes.join(','),
         }).toString();
         const quote = await (await (0, node_fetch_1.default)(`${this.url}/v6/quote?${params}`)).json();
         return quote;

package/lib/math/auction.d.ts

@@ -1,7 +1,18 @@
-import { Order } from '../types';
+import { Order, PositionDirection } from '../types';
 import { BN } from '../.';
 export declare function isAuctionComplete(order: Order, slot: number): boolean;
 export declare function isFallbackAvailableLiquiditySource(order: Order, minAuctionDuration: number, slot: number): boolean;
 export declare function getAuctionPrice(order: Order, slot: number, oraclePrice: BN): BN;
 export declare function getAuctionPriceForFixedAuction(order: Order, slot: number): BN;
 export declare function getAuctionPriceForOracleOffsetAuction(order: Order, slot: number, oraclePrice: BN): BN;
+export declare function deriveOracleAuctionParams({ direction, oraclePrice, auctionStartPrice, auctionEndPrice, limitPrice, }: {
+    direction: PositionDirection;
+    oraclePrice: BN;
+    auctionStartPrice: BN;
+    auctionEndPrice: BN;
+    limitPrice: BN;
+}): {
+    auctionStartPrice: BN;
+    auctionEndPrice: BN;
+    oraclePriceOffset: number;
+};

package/lib/math/auction.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAuctionPriceForOracleOffsetAuction = exports.getAuctionPriceForFixedAuction = exports.getAuctionPrice = exports.isFallbackAvailableLiquiditySource = exports.isAuctionComplete = void 0;
+exports.deriveOracleAuctionParams = exports.getAuctionPriceForOracleOffsetAuction = exports.getAuctionPriceForFixedAuction = exports.getAuctionPrice = exports.isFallbackAvailableLiquiditySource = exports.isAuctionComplete = void 0;
 const types_1 = require("../types");
 const _1 = require("../.");
 function isAuctionComplete(order, slot) {
@@ -89,3 +89,24 @@ function getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice) {
     return oraclePrice.add(priceOffset);
 }
 exports.getAuctionPriceForOracleOffsetAuction = getAuctionPriceForOracleOffsetAuction;
+function deriveOracleAuctionParams({ direction, oraclePrice, auctionStartPrice, auctionEndPrice, limitPrice, }) {
+    let oraclePriceOffset = limitPrice.sub(oraclePrice);
+    if (oraclePriceOffset.eq(_1.ZERO)) {
+        oraclePriceOffset = (0, types_1.isVariant)(direction, 'long')
+            ? auctionEndPrice.sub(oraclePrice).add(_1.ONE)
+            : auctionEndPrice.sub(oraclePrice).sub(_1.ONE);
+    }
+    let oraclePriceOffsetNum;
+    try {
+        oraclePriceOffsetNum = oraclePriceOffset.toNumber();
+    }
+    catch (e) {
+        oraclePriceOffsetNum = 0;
+    }
+    return {
+        auctionStartPrice: auctionStartPrice.sub(oraclePrice),
+        auctionEndPrice: auctionEndPrice.sub(oraclePrice),
+        oraclePriceOffset: oraclePriceOffsetNum,
+    };
+}
+exports.deriveOracleAuctionParams = deriveOracleAuctionParams;

package/lib/math/market.js

@@ -130,12 +130,10 @@ exports.calculateNetUserPnlImbalance = calculateNetUserPnlImbalance;
 function calculateAvailablePerpLiquidity(market, oraclePriceData, dlob, slot) {
     let [bids, asks] = (0, amm_1.calculateMarketOpenBidAsk)(market.amm.baseAssetReserve, market.amm.minBaseAssetReserve, market.amm.maxBaseAssetReserve, market.amm.orderStepSize);
     asks = asks.abs();
-    const bidPrice = calculateBidPrice(market, oraclePriceData);
-    const askPrice = calculateAskPrice(market, oraclePriceData);
-    for (const bid of dlob.getMakerLimitBids(market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData, askPrice)) {
+    for (const bid of dlob.getRestingLimitBids(market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData)) {
         bids = bids.add(bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled));
     }
-    for (const ask of dlob.getMakerLimitAsks(market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData, bidPrice)) {
+    for (const ask of dlob.getRestingLimitAsks(market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData)) {
         asks = asks.add(ask.order.baseAssetAmount.sub(ask.order.baseAssetAmountFilled));
     }
     return {

package/lib/math/superStake.js

@@ -174,7 +174,7 @@ const getJitoSolHistoricalPriceMap = async (timestamps) => {
         const jitoSolHistoricalPriceInSol = [];
         for (let i = 0; i < data.data.getStakePoolStats.supply.length; i++) {
             const priceInSol = data.data.getStakePoolStats.tvl[i].data /
-                new anchor_1.BN(10).pow(numericConstants_1.NINE) /
+                10 ** 9 /
                 data.data.getStakePoolStats.supply[i].data;
             jitoSolHistoricalPriceInSol.push({
                 price: priceInSol,

package/lib/math/trade.js

@@ -278,9 +278,7 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
         };
     }
     const takerIsLong = (0, types_2.isVariant)(direction, 'long');
-    const limitOrders = dlob[takerIsLong ? 'getMakerLimitAsks' : 'getMakerLimitBids'](market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData, takerIsLong
-        ? (0, market_1.calculateBidPrice)(market, oraclePriceData)
-        : (0, market_1.calculateAskPrice)(market, oraclePriceData));
+    const limitOrders = dlob[takerIsLong ? 'getRestingLimitAsks' : 'getRestingLimitBids'](market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData);
     const swapDirection = (0, amm_1.getSwapDirection)(assetType, direction);
     const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData);
     const amm = {
@@ -463,7 +461,7 @@ function calculateEstimatedSpotEntryPrice(assetType, amount, direction, market,
     }
     const basePrecision = new anchor_1.BN(Math.pow(10, market.decimals));
     const takerIsLong = (0, types_2.isVariant)(direction, 'long');
-    const dlobLimitOrders = dlob[takerIsLong ? 'getMakerLimitAsks' : 'getMakerLimitBids'](market.marketIndex, slot, types_1.MarketType.SPOT, oraclePriceData);
+    const dlobLimitOrders = dlob[takerIsLong ? 'getRestingLimitAsks' : 'getRestingLimitBids'](market.marketIndex, slot, types_1.MarketType.SPOT, oraclePriceData);
     const serumLimitOrders = takerIsLong
         ? serumAsks.getL2(100)
         : serumBids.getL2(100);

package/lib/orderSubscriber/WebsocketSubscription.js

@@ -25,6 +25,8 @@ class WebsocketSubscription {
         }
     }
     async unsubscribe() {
+        if (!this.subscriber)
+            return;
         this.subscriber.unsubscribe();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.40.0-beta.9",
+	"version": "2.41.0-beta.1",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -44,6 +44,7 @@
 		"uuid": "^8.3.2"
 	},
 	"devDependencies": {
+		"@types/big.js": "^6.2.0",
 		"@types/chai": "^4.3.1",
 		"@types/jest": "^28.1.3",
 		"@types/mocha": "^9.1.1",

package/src/addresses/pda.ts

@@ -214,3 +214,12 @@ export function getReferrerNamePublicKeySync(
 		programId
 	)[0];
 }
+
+export function getProtocolIfSharesTransferConfigPublicKey(
+	programId: PublicKey
+): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[Buffer.from(anchor.utils.bytes.utf8.encode('if_shares_transfer_config'))],
+		programId
+	)[0];
+}

package/src/adminClient.ts

@@ -25,6 +25,7 @@ import {
 	getSerumOpenOrdersPublicKey,
 	getSerumFulfillmentConfigPublicKey,
 	getPhoenixFulfillmentConfigPublicKey,
+	getProtocolIfSharesTransferConfigPublicKey,
 } from './addresses/pda';
 import { squareRootBN } from './math/utils';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
@@ -1516,4 +1517,35 @@ export class AdminClient extends DriftClient {
 			}
 		);
 	}
+
+	public async initializeProtocolIfSharesTransferConfig(): Promise<TransactionSignature> {
+		return await this.program.rpc.initializeProtocolIfSharesTransferConfig({
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				rent: SYSVAR_RENT_PUBKEY,
+				systemProgram: anchor.web3.SystemProgram.programId,
+				protocolIfSharesTransferConfig:
+					getProtocolIfSharesTransferConfigPublicKey(this.program.programId),
+			},
+		});
+	}
+
+	public async updateProtocolIfSharesTransferConfig(
+		whitelistedSigners?: PublicKey[],
+		maxTransferPerEpoch?: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateProtocolIfSharesTransferConfig(
+			whitelistedSigners || null,
+			maxTransferPerEpoch,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					protocolIfSharesTransferConfig:
+						getProtocolIfSharesTransferConfigPublicKey(this.program.programId),
+				},
+			}
+		);
+	}
 }

package/src/constants/spotMarkets.ts

@@ -128,7 +128,7 @@ export const MainnetSpotMarkets: SpotMarketConfig[] = [
 		serumMarket: new PublicKey('B2na8Awyd7cpC59iEU43FagJAPLigr3AP3s38KM982bu'),
 	},
 	{
-		symbol: 'JitoSOL',
+		symbol: 'jitoSOL',
 		marketIndex: 6,
 		oracle: new PublicKey('7yyaeuJ1GGtVBLT2z2xub5ZWYKaNhF28mj1RdV4VDFVk'),
 		oracleSource: OracleSource.PYTH,

package/src/dlob/DLOB.ts

@@ -675,7 +675,7 @@ export class DLOB {
 			marketType,
 			oraclePriceData,
 			takingOrderGenerator,
-			this.getMakerLimitBids.bind(this),
+			this.getRestingLimitBids.bind(this),
 			(takerPrice, makerPrice) => {
 				if (isVariant(marketType, 'spot')) {
 					if (takerPrice === undefined) {
@@ -687,8 +687,7 @@ export class DLOB {
 					}
 				}
 				return takerPrice === undefined || takerPrice.lte(makerPrice);
-			},
-			fallbackAsk
+			}
 		);
 		for (const takingAskCrossingBid of takingAsksCrossingBids) {
 			nodesToFill.push(takingAskCrossingBid);
@@ -732,7 +731,7 @@ export class DLOB {
 			marketType,
 			oraclePriceData,
 			takingOrderGenerator,
-			this.getMakerLimitAsks.bind(this),
+			this.getRestingLimitAsks.bind(this),
 			(takerPrice, makerPrice) => {
 				if (isVariant(marketType, 'spot')) {
 					if (takerPrice === undefined) {
@@ -745,8 +744,7 @@ export class DLOB {
 				}
 
 				return takerPrice === undefined || takerPrice.gte(makerPrice);
-			},
-			fallbackBid
+			}
 		);
 
 		for (const takingBidToFill of takingBidsToFill) {
@@ -790,11 +788,9 @@ export class DLOB {
 			marketIndex: number,
 			slot: number,
 			marketType: MarketType,
-			oraclePriceData: OraclePriceData,
-			fallbackPrice?: BN
+			oraclePriceData: OraclePriceData
 		) => Generator<DLOBNode>,
-		doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean,
-		fallbackPrice?: BN
+		doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
 
@@ -803,8 +799,7 @@ export class DLOB {
 				marketIndex,
 				slot,
 				marketType,
-				oraclePriceData,
-				fallbackPrice
+				oraclePriceData
 			);
 
 			for (const makerNode of makerNodeGenerator) {
@@ -1714,8 +1709,6 @@ export class DLOB {
 	 * @param slot
 	 * @param oraclePriceData
 	 * @param depth how many levels of the order book to return
-	 * @param fallbackAsk best ask for fallback liquidity, only relevant for perps
-	 * @param fallbackBid best bid for fallback liquidity, only relevant for perps
 	 * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}, openbook {@link SerumSubscriber}
 	 */
 	public getL2({
@@ -1724,8 +1717,6 @@ export class DLOB {
 		slot,
 		oraclePriceData,
 		depth,
-		fallbackAsk,
-		fallbackBid,
 		fallbackL2Generators = [],
 	}: {
 		marketIndex: number;
@@ -1733,18 +1724,10 @@ export class DLOB {
 		slot: number;
 		oraclePriceData: OraclePriceData;
 		depth: number;
-		fallbackAsk?: BN;
-		fallbackBid?: BN;
 		fallbackL2Generators?: L2OrderBookGenerator[];
 	}): L2OrderBook {
 		const makerAskL2LevelGenerator = getL2GeneratorFromDLOBNodes(
-			this.getMakerLimitAsks(
-				marketIndex,
-				slot,
-				marketType,
-				oraclePriceData,
-				fallbackBid
-			),
+			this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData),
 			oraclePriceData,
 			slot
 		);
@@ -1765,13 +1748,7 @@ export class DLOB {
 		const asks = createL2Levels(askL2LevelGenerator, depth);
 
 		const makerBidGenerator = getL2GeneratorFromDLOBNodes(
-			this.getMakerLimitBids(
-				marketIndex,
-				slot,
-				marketType,
-				oraclePriceData,
-				fallbackAsk
-			),
+			this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData),
 			oraclePriceData,
 			slot
 		);

package/src/dlob/DLOBSubscriber.ts

@@ -10,12 +10,12 @@ import {
 import { DriftClient } from '../driftClient';
 import { isVariant, MarketType } from '../types';
 import {
+	DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
 	getVammL2Generator,
 	L2OrderBook,
 	L2OrderBookGenerator,
 	L3OrderBook,
 } from './orderBookLevels';
-import { calculateAskPrice, calculateBidPrice } from '../math/market';
 
 export class DLOBSubscriber {
 	driftClient: DriftClient;
@@ -103,8 +103,6 @@ export class DLOBSubscriber {
 		}
 
 		let oraclePriceData;
-		let fallbackBid;
-		let fallbackAsk;
 		const isPerp = isVariant(marketType, 'perp');
 		if (isPerp) {
 			const perpMarketAccount =
@@ -112,19 +110,24 @@ export class DLOBSubscriber {
 			oraclePriceData = this.driftClient.getOracleDataForPerpMarket(
 				perpMarketAccount.marketIndex
 			);
-			fallbackBid = calculateBidPrice(perpMarketAccount, oraclePriceData);
-			fallbackAsk = calculateAskPrice(perpMarketAccount, oraclePriceData);
 		} else {
 			oraclePriceData =
 				this.driftClient.getOracleDataForSpotMarket(marketIndex);
 		}
 
 		if (isPerp && includeVamm) {
+			if (fallbackL2Generators.length > 0) {
+				throw new Error(
+					'includeVamm can only be used if fallbackL2Generators is empty'
+				);
+			}
+
 			fallbackL2Generators = [
 				getVammL2Generator({
 					marketAccount: this.driftClient.getPerpMarketAccount(marketIndex),
 					oraclePriceData,
 					numOrders: numVammOrders ?? depth,
+					topOfBookQuoteAmounts: DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
 				}),
 			];
 		}
@@ -135,8 +138,6 @@ export class DLOBSubscriber {
 			depth,
 			oraclePriceData,
 			slot: this.slotSource.getSlot(),
-			fallbackBid,
-			fallbackAsk,
 			fallbackL2Generators: fallbackL2Generators,
 		});
 	}

package/src/dlob/orderBookLevels.ts

@@ -10,11 +10,13 @@ import {
 	OraclePriceData,
 	PerpMarketAccount,
 	PositionDirection,
+	QUOTE_PRECISION,
 	standardizePrice,
 	SwapDirection,
 	ZERO,
 } from '..';
 import { PublicKey } from '@solana/web3.js';
+import { assert } from '../assert/assert';
 
 type liquiditySource = 'serum' | 'vamm' | 'dlob' | 'phoenix';
 
@@ -46,9 +48,16 @@ export type L3OrderBook = {
 	bids: L3Level[];
 };
 
+export const DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS = [
+	new BN(500).mul(QUOTE_PRECISION),
+	new BN(1000).mul(QUOTE_PRECISION),
+	new BN(2000).mul(QUOTE_PRECISION),
+	new BN(5000).mul(QUOTE_PRECISION),
+];
+
 /**
  * Get an {@link Generator<L2Level>} generator from a {@link Generator<DLOBNode>}
- * @param dlobNodes e.g. {@link DLOB#getMakerLimitAsks} or {@link DLOB#getMakerLimitBids}
+ * @param dlobNodes e.g. {@link DLOB#getRestingLimitAsks} or {@link DLOB#getRestingLimitBids}
  * @param oraclePriceData
  * @param slot
  */
@@ -139,12 +148,20 @@ export function getVammL2Generator({
 	oraclePriceData,
 	numOrders,
 	now,
+	topOfBookQuoteAmounts,
 }: {
 	marketAccount: PerpMarketAccount;
 	oraclePriceData: OraclePriceData;
 	numOrders: number;
 	now?: BN;
+	topOfBookQuoteAmounts?: BN[];
 }): L2OrderBookGenerator {
+	let numBaseOrders = numOrders;
+	if (topOfBookQuoteAmounts) {
+		numBaseOrders = numOrders - topOfBookQuoteAmounts.length;
+		assert(topOfBookQuoteAmounts.length < numOrders);
+	}
+
 	const updatedAmm = calculateUpdatedAMM(marketAccount.amm, oraclePriceData);
 
 	const [openBids, openAsks] = calculateMarketOpenBidAsk(
@@ -162,38 +179,78 @@ export function getVammL2Generator({
 	);
 
 	let numBids = 0;
-	const baseSize = openBids.div(new BN(numOrders));
+
+	let topOfBookBidSize = ZERO;
+	let bidSize = openBids.div(new BN(numBaseOrders));
 	const bidAmm = {
 		baseAssetReserve: bidReserves.baseAssetReserve,
 		quoteAssetReserve: bidReserves.quoteAssetReserve,
 		sqrtK: updatedAmm.sqrtK,
 		pegMultiplier: updatedAmm.pegMultiplier,
 	};
+
 	const getL2Bids = function* () {
-		while (numBids < numOrders && baseSize.gt(ZERO)) {
-			const [afterSwapQuoteReserves, afterSwapBaseReserves] =
-				calculateAmmReservesAfterSwap(
-					bidAmm,
-					'base',
-					baseSize,
+		while (numBids < numOrders && bidSize.gt(ZERO)) {
+			let quoteSwapped = ZERO;
+			let baseSwapped = ZERO;
+			let [afterSwapQuoteReserves, afterSwapBaseReserves] = [ZERO, ZERO];
+
+			if (topOfBookQuoteAmounts && numBids < topOfBookQuoteAmounts?.length) {
+				const remainingBaseLiquidity = openBids.sub(topOfBookBidSize);
+				quoteSwapped = topOfBookQuoteAmounts[numBids];
+				[afterSwapQuoteReserves, afterSwapBaseReserves] =
+					calculateAmmReservesAfterSwap(
+						bidAmm,
+						'quote',
+						quoteSwapped,
+						SwapDirection.REMOVE
+					);
+
+				baseSwapped = bidAmm.baseAssetReserve.sub(afterSwapBaseReserves).abs();
+				if (remainingBaseLiquidity.lt(baseSwapped)) {
+					baseSwapped = remainingBaseLiquidity;
+					[afterSwapQuoteReserves, afterSwapBaseReserves] =
+						calculateAmmReservesAfterSwap(
+							bidAmm,
+							'base',
+							baseSwapped,
+							SwapDirection.ADD
+						);
+
+					quoteSwapped = calculateQuoteAssetAmountSwapped(
+						bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
+						bidAmm.pegMultiplier,
+						SwapDirection.ADD
+					);
+				}
+				topOfBookBidSize = topOfBookBidSize.add(baseSwapped);
+				bidSize = openBids.sub(topOfBookBidSize).div(new BN(numBaseOrders));
+			} else {
+				baseSwapped = bidSize;
+				[afterSwapQuoteReserves, afterSwapBaseReserves] =
+					calculateAmmReservesAfterSwap(
+						bidAmm,
+						'base',
+						baseSwapped,
+						SwapDirection.ADD
+					);
+
+				quoteSwapped = calculateQuoteAssetAmountSwapped(
+					bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
+					bidAmm.pegMultiplier,
 					SwapDirection.ADD
 				);
+			}
 
-			const quoteSwapped = calculateQuoteAssetAmountSwapped(
-				bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
-				bidAmm.pegMultiplier,
-				SwapDirection.ADD
-			);
-
-			const price = quoteSwapped.mul(BASE_PRECISION).div(baseSize);
+			const price = quoteSwapped.mul(BASE_PRECISION).div(baseSwapped);
 
 			bidAmm.baseAssetReserve = afterSwapBaseReserves;
 			bidAmm.quoteAssetReserve = afterSwapQuoteReserves;
 
 			yield {
 				price,
-				size: baseSize,
-				sources: { vamm: baseSize },
+				size: baseSwapped,
+				sources: { vamm: baseSwapped },
 			};
 
 			numBids++;
@@ -201,38 +258,82 @@ export function getVammL2Generator({
 	};
 
 	let numAsks = 0;
-	const askSize = openAsks.abs().div(new BN(numOrders));
+	let topOfBookAskSize = ZERO;
+	let askSize = openAsks.abs().div(new BN(numBaseOrders));
 	const askAmm = {
 		baseAssetReserve: askReserves.baseAssetReserve,
 		quoteAssetReserve: askReserves.quoteAssetReserve,
 		sqrtK: updatedAmm.sqrtK,
 		pegMultiplier: updatedAmm.pegMultiplier,
 	};
+
 	const getL2Asks = function* () {
 		while (numAsks < numOrders && askSize.gt(ZERO)) {
-			const [afterSwapQuoteReserves, afterSwapBaseReserves] =
-				calculateAmmReservesAfterSwap(
-					askAmm,
-					'base',
-					askSize,
+			let quoteSwapped: BN = ZERO;
+			let baseSwapped: BN = ZERO;
+			let [afterSwapQuoteReserves, afterSwapBaseReserves] = [ZERO, ZERO];
+
+			if (topOfBookQuoteAmounts && numAsks < topOfBookQuoteAmounts?.length) {
+				const remainingBaseLiquidity = openAsks
+					.mul(new BN(-1))
+					.sub(topOfBookAskSize);
+				quoteSwapped = topOfBookQuoteAmounts[numAsks];
+				[afterSwapQuoteReserves, afterSwapBaseReserves] =
+					calculateAmmReservesAfterSwap(
+						askAmm,
+						'quote',
+						quoteSwapped,
+						SwapDirection.ADD
+					);
+
+				baseSwapped = askAmm.baseAssetReserve.sub(afterSwapBaseReserves).abs();
+				if (remainingBaseLiquidity.lt(baseSwapped)) {
+					baseSwapped = remainingBaseLiquidity;
+					[afterSwapQuoteReserves, afterSwapBaseReserves] =
+						calculateAmmReservesAfterSwap(
+							bidAmm,
+							'base',
+							baseSwapped,
+							SwapDirection.REMOVE
+						);
+
+					quoteSwapped = calculateQuoteAssetAmountSwapped(
+						bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
+						bidAmm.pegMultiplier,
+						SwapDirection.REMOVE
+					);
+				}
+				topOfBookAskSize = topOfBookAskSize.add(baseSwapped);
+				askSize = openAsks
+					.abs()
+					.sub(topOfBookAskSize)
+					.div(new BN(numBaseOrders));
+			} else {
+				baseSwapped = askSize;
+				[afterSwapQuoteReserves, afterSwapBaseReserves] =
+					calculateAmmReservesAfterSwap(
+						askAmm,
+						'base',
+						askSize,
+						SwapDirection.REMOVE
+					);
+
+				quoteSwapped = calculateQuoteAssetAmountSwapped(
+					askAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
+					askAmm.pegMultiplier,
 					SwapDirection.REMOVE
 				);
+			}
 
-			const quoteSwapped = calculateQuoteAssetAmountSwapped(
-				askAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
-				askAmm.pegMultiplier,
-				SwapDirection.REMOVE
-			);
-
-			const price = quoteSwapped.mul(BASE_PRECISION).div(askSize);
+			const price = quoteSwapped.mul(BASE_PRECISION).div(baseSwapped);
 
 			askAmm.baseAssetReserve = afterSwapBaseReserves;
 			askAmm.quoteAssetReserve = afterSwapQuoteReserves;
 
 			yield {
 				price,
-				size: askSize,
-				sources: { vamm: baseSize },
+				size: baseSwapped,
+				sources: { vamm: baseSwapped },
 			};
 
 			numAsks++;

package/src/factory/bigNum.ts

@@ -618,6 +618,8 @@ export class BigNum {
 		if (!val.replace(BigNum.delim, '')) {
 			return BigNum.from(ZERO, precisionShift);
 		}
+		if (val.includes('e'))
+			val = (+val).toFixed(precisionShift?.toNumber() ?? 9); // prevent small numbers e.g. 3.1e-8, use assume max precision 9 as default
 
 		const sides = val.split(BigNum.delim);
 		const rightSide = sides[1];