@drift-labs/sdk 2.40.0-beta.13 → 2.40.0-beta.15

package/VERSION

@@ -1 +1 @@
-2.40.0-beta.13
+2.40.0-beta.15

package/lib/dlob/DLOBSubscriber.js

@@ -75,11 +75,15 @@ class DLOBSubscriber {
                 this.driftClient.getOracleDataForSpotMarket(marketIndex);
         }
         if (isPerp && includeVamm) {
+            if (fallbackL2Generators.length > 0) {
+                throw new Error('includeVamm can only be used if fallbackL2Generators is empty');
+            }
             fallbackL2Generators = [
                 (0, orderBookLevels_1.getVammL2Generator)({
                     marketAccount: this.driftClient.getPerpMarketAccount(marketIndex),
                     oraclePriceData,
                     numOrders: numVammOrders !== null && numVammOrders !== void 0 ? numVammOrders : depth,
+                    topOfBookQuoteAmounts: orderBookLevels_1.DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
                 }),
             ];
         }

package/lib/dlob/orderBookLevels.d.ts

@@ -26,6 +26,7 @@ export type L3OrderBook = {
     asks: L3Level[];
     bids: L3Level[];
 };
+export declare const DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS: any[];
 /**
  * Get an {@link Generator<L2Level>} generator from a {@link Generator<DLOBNode>}
  * @param dlobNodes e.g. {@link DLOB#getMakerLimitAsks} or {@link DLOB#getMakerLimitBids}
@@ -35,11 +36,12 @@ export type L3OrderBook = {
 export declare function getL2GeneratorFromDLOBNodes(dlobNodes: Generator<DLOBNode>, oraclePriceData: OraclePriceData, slot: number): Generator<L2Level>;
 export declare function mergeL2LevelGenerators(l2LevelGenerators: Generator<L2Level>[], compare: (a: L2Level, b: L2Level) => boolean): Generator<L2Level>;
 export declare function createL2Levels(generator: Generator<L2Level>, depth: number): L2Level[];
-export declare function getVammL2Generator({ marketAccount, oraclePriceData, numOrders, now, }: {
+export declare function getVammL2Generator({ marketAccount, oraclePriceData, numOrders, now, topOfBookQuoteAmounts, }: {
     marketAccount: PerpMarketAccount;
     oraclePriceData: OraclePriceData;
     numOrders: number;
     now?: BN;
+    topOfBookQuoteAmounts?: BN[];
 }): L2OrderBookGenerator;
 export declare function groupL2(l2: L2OrderBook, grouping: BN, depth: number): L2OrderBook;
 export {};

package/lib/dlob/orderBookLevels.js

@@ -1,7 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupL2 = exports.getVammL2Generator = exports.createL2Levels = exports.mergeL2LevelGenerators = exports.getL2GeneratorFromDLOBNodes = void 0;
+exports.groupL2 = exports.getVammL2Generator = exports.createL2Levels = exports.mergeL2LevelGenerators = exports.getL2GeneratorFromDLOBNodes = exports.DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS = void 0;
 const __1 = require("..");
+const assert_1 = require("../assert/assert");
+exports.DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS = [
+    new __1.BN(500).mul(__1.QUOTE_PRECISION),
+    new __1.BN(1000).mul(__1.QUOTE_PRECISION),
+    new __1.BN(2000).mul(__1.QUOTE_PRECISION),
+    new __1.BN(5000).mul(__1.QUOTE_PRECISION),
+];
 /**
  * Get an {@link Generator<L2Level>} generator from a {@link Generator<DLOBNode>}
  * @param dlobNodes e.g. {@link DLOB#getMakerLimitAsks} or {@link DLOB#getMakerLimitBids}
@@ -78,13 +85,19 @@ function createL2Levels(generator, depth) {
     return levels;
 }
 exports.createL2Levels = createL2Levels;
-function getVammL2Generator({ marketAccount, oraclePriceData, numOrders, now, }) {
+function getVammL2Generator({ marketAccount, oraclePriceData, numOrders, now, topOfBookQuoteAmounts, }) {
+    let numBaseOrders = numOrders;
+    if (topOfBookQuoteAmounts) {
+        numBaseOrders = numOrders - topOfBookQuoteAmounts.length;
+        (0, assert_1.assert)(topOfBookQuoteAmounts.length < numOrders);
+    }
     const updatedAmm = (0, __1.calculateUpdatedAMM)(marketAccount.amm, oraclePriceData);
     const [openBids, openAsks] = (0, __1.calculateMarketOpenBidAsk)(updatedAmm.baseAssetReserve, updatedAmm.minBaseAssetReserve, updatedAmm.maxBaseAssetReserve, updatedAmm.orderStepSize);
     now = now !== null && now !== void 0 ? now : new __1.BN(Date.now() / 1000);
     const [bidReserves, askReserves] = (0, __1.calculateSpreadReserves)(updatedAmm, oraclePriceData, now);
     let numBids = 0;
-    const baseSize = openBids.div(new __1.BN(numOrders));
+    let topOfBookBidSize = __1.ZERO;
+    let bidSize = openBids.div(new __1.BN(numBaseOrders));
     const bidAmm = {
         baseAssetReserve: bidReserves.baseAssetReserve,
         quoteAssetReserve: bidReserves.quoteAssetReserve,
@@ -92,22 +105,45 @@ function getVammL2Generator({ marketAccount, oraclePriceData, numOrders, now, })
         pegMultiplier: updatedAmm.pegMultiplier,
     };
     const getL2Bids = function* () {
-        while (numBids < numOrders && baseSize.gt(__1.ZERO)) {
-            const [afterSwapQuoteReserves, afterSwapBaseReserves] = (0, __1.calculateAmmReservesAfterSwap)(bidAmm, 'base', baseSize, __1.SwapDirection.ADD);
-            const quoteSwapped = (0, __1.calculateQuoteAssetAmountSwapped)(bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), bidAmm.pegMultiplier, __1.SwapDirection.ADD);
-            const price = quoteSwapped.mul(__1.BASE_PRECISION).div(baseSize);
+        while (numBids < numOrders && bidSize.gt(__1.ZERO)) {
+            let quoteSwapped = __1.ZERO;
+            let baseSwapped = __1.ZERO;
+            let [afterSwapQuoteReserves, afterSwapBaseReserves] = [__1.ZERO, __1.ZERO];
+            if (topOfBookQuoteAmounts && numBids < (topOfBookQuoteAmounts === null || topOfBookQuoteAmounts === void 0 ? void 0 : topOfBookQuoteAmounts.length)) {
+                const remainingBaseLiquidity = openBids.sub(topOfBookBidSize);
+                quoteSwapped = topOfBookQuoteAmounts[numBids];
+                [afterSwapQuoteReserves, afterSwapBaseReserves] =
+                    (0, __1.calculateAmmReservesAfterSwap)(bidAmm, 'quote', quoteSwapped, __1.SwapDirection.REMOVE);
+                baseSwapped = bidAmm.baseAssetReserve.sub(afterSwapBaseReserves).abs();
+                if (remainingBaseLiquidity.lt(baseSwapped)) {
+                    baseSwapped = remainingBaseLiquidity;
+                    [afterSwapQuoteReserves, afterSwapBaseReserves] =
+                        (0, __1.calculateAmmReservesAfterSwap)(bidAmm, 'base', baseSwapped, __1.SwapDirection.ADD);
+                    quoteSwapped = (0, __1.calculateQuoteAssetAmountSwapped)(bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), bidAmm.pegMultiplier, __1.SwapDirection.ADD);
+                }
+                topOfBookBidSize = topOfBookBidSize.add(baseSwapped);
+                bidSize = openBids.sub(topOfBookBidSize).div(new __1.BN(numBaseOrders));
+            }
+            else {
+                baseSwapped = bidSize;
+                [afterSwapQuoteReserves, afterSwapBaseReserves] =
+                    (0, __1.calculateAmmReservesAfterSwap)(bidAmm, 'base', baseSwapped, __1.SwapDirection.ADD);
+                quoteSwapped = (0, __1.calculateQuoteAssetAmountSwapped)(bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), bidAmm.pegMultiplier, __1.SwapDirection.ADD);
+            }
+            const price = quoteSwapped.mul(__1.BASE_PRECISION).div(baseSwapped);
             bidAmm.baseAssetReserve = afterSwapBaseReserves;
             bidAmm.quoteAssetReserve = afterSwapQuoteReserves;
             yield {
                 price,
-                size: baseSize,
-                sources: { vamm: baseSize },
+                size: baseSwapped,
+                sources: { vamm: baseSwapped },
             };
             numBids++;
         }
     };
     let numAsks = 0;
-    const askSize = openAsks.abs().div(new __1.BN(numOrders));
+    let topOfBookAskSize = __1.ZERO;
+    let askSize = openAsks.abs().div(new __1.BN(numBaseOrders));
     const askAmm = {
         baseAssetReserve: askReserves.baseAssetReserve,
         quoteAssetReserve: askReserves.quoteAssetReserve,
@@ -116,15 +152,42 @@ function getVammL2Generator({ marketAccount, oraclePriceData, numOrders, now, })
     };
     const getL2Asks = function* () {
         while (numAsks < numOrders && askSize.gt(__1.ZERO)) {
-            const [afterSwapQuoteReserves, afterSwapBaseReserves] = (0, __1.calculateAmmReservesAfterSwap)(askAmm, 'base', askSize, __1.SwapDirection.REMOVE);
-            const quoteSwapped = (0, __1.calculateQuoteAssetAmountSwapped)(askAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), askAmm.pegMultiplier, __1.SwapDirection.REMOVE);
-            const price = quoteSwapped.mul(__1.BASE_PRECISION).div(askSize);
+            let quoteSwapped = __1.ZERO;
+            let baseSwapped = __1.ZERO;
+            let [afterSwapQuoteReserves, afterSwapBaseReserves] = [__1.ZERO, __1.ZERO];
+            if (topOfBookQuoteAmounts && numAsks < (topOfBookQuoteAmounts === null || topOfBookQuoteAmounts === void 0 ? void 0 : topOfBookQuoteAmounts.length)) {
+                const remainingBaseLiquidity = openAsks
+                    .mul(new __1.BN(-1))
+                    .sub(topOfBookAskSize);
+                quoteSwapped = topOfBookQuoteAmounts[numAsks];
+                [afterSwapQuoteReserves, afterSwapBaseReserves] =
+                    (0, __1.calculateAmmReservesAfterSwap)(askAmm, 'quote', quoteSwapped, __1.SwapDirection.ADD);
+                baseSwapped = askAmm.baseAssetReserve.sub(afterSwapBaseReserves).abs();
+                if (remainingBaseLiquidity.lt(baseSwapped)) {
+                    baseSwapped = remainingBaseLiquidity;
+                    [afterSwapQuoteReserves, afterSwapBaseReserves] =
+                        (0, __1.calculateAmmReservesAfterSwap)(bidAmm, 'base', baseSwapped, __1.SwapDirection.REMOVE);
+                    quoteSwapped = (0, __1.calculateQuoteAssetAmountSwapped)(bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), bidAmm.pegMultiplier, __1.SwapDirection.REMOVE);
+                }
+                topOfBookAskSize = topOfBookAskSize.add(baseSwapped);
+                askSize = openAsks
+                    .abs()
+                    .sub(topOfBookAskSize)
+                    .div(new __1.BN(numBaseOrders));
+            }
+            else {
+                baseSwapped = askSize;
+                [afterSwapQuoteReserves, afterSwapBaseReserves] =
+                    (0, __1.calculateAmmReservesAfterSwap)(askAmm, 'base', askSize, __1.SwapDirection.REMOVE);
+                quoteSwapped = (0, __1.calculateQuoteAssetAmountSwapped)(askAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), askAmm.pegMultiplier, __1.SwapDirection.REMOVE);
+            }
+            const price = quoteSwapped.mul(__1.BASE_PRECISION).div(baseSwapped);
             askAmm.baseAssetReserve = afterSwapBaseReserves;
             askAmm.quoteAssetReserve = afterSwapQuoteReserves;
             yield {
                 price,
-                size: askSize,
-                sources: { vamm: baseSize },
+                size: baseSwapped,
+                sources: { vamm: baseSwapped },
             };
             numAsks++;
         }

package/lib/jupiter/jupiterClient.d.ts

@@ -229,7 +229,7 @@ export declare class JupiterClient {
      * @param swapMode the swap mode (ExactIn or ExactOut)
      * @param onlyDirectRoutes whether to only return direct routes
      */
-    getQuote({ inputMint, outputMint, amount, maxAccounts, // 52 is an estimated amount with buffer
+    getQuote({ inputMint, outputMint, amount, maxAccounts, // 50 is an estimated amount with buffer
     slippageBps, swapMode, onlyDirectRoutes, excludeDexes, }: {
         inputMint: PublicKey;
         outputMint: PublicKey;

package/lib/jupiter/jupiterClient.js

@@ -43,7 +43,7 @@ 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
+    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(),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.40.0-beta.13",
+	"version": "2.40.0-beta.15",
 	"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/dlob/DLOBSubscriber.ts

@@ -10,6 +10,7 @@ import {
 import { DriftClient } from '../driftClient';
 import { isVariant, MarketType } from '../types';
 import {
+	DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS,
 	getVammL2Generator,
 	L2OrderBook,
 	L2OrderBookGenerator,
@@ -120,11 +121,18 @@ export class DLOBSubscriber {
 		}
 
 		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,
 				}),
 			];
 		}

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,6 +48,13 @@ 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}
@@ -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/jupiter/jupiterClient.ts

@@ -275,7 +275,7 @@ export class JupiterClient {
 		inputMint,
 		outputMint,
 		amount,
-		maxAccounts = 52, // 52 is an estimated amount with buffer
+		maxAccounts = 50, // 50 is an estimated amount with buffer
 		slippageBps = 50,
 		swapMode = 'ExactIn',
 		onlyDirectRoutes = false,

package/tests/amm/test.ts

@@ -13,6 +13,12 @@ import {
 	calculateAllEstimatedFundingRate,
 	calculateLongShortFundingRateAndLiveTwaps,
 	OraclePriceData,
+	getVammL2Generator,
+	BASE_PRECISION,
+	PerpMarketAccount,
+	L2Level,
+	calculateUpdatedAMM,
+	calculateMarketOpenBidAsk,
 } from '../../src';
 import { mockPerpMarkets } from '../dlob/helpers';
 
@@ -552,4 +558,400 @@ describe('AMM Tests', () => {
 		assert(est1.eq(est2));
 		assert(est2.eq(new BN('-1550')));
 	});
+
+	it('orderbook L2 gen (no topOfBookQuoteAmounts, 10 numOrders, low liquidity)', async () => {
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+
+		const mockMarket1: PerpMarketAccount = myMockPerpMarkets[0];
+		const cc = 38104569;
+		mockMarket1.amm.baseAssetReserve = new BN(cc).mul(BASE_PRECISION);
+		mockMarket1.amm.maxBaseAssetReserve = mockMarket1.amm.baseAssetReserve.add(
+			new BN(1234835)
+		);
+		mockMarket1.amm.minBaseAssetReserve = mockMarket1.amm.baseAssetReserve.sub(BASE_PRECISION);
+		mockMarket1.amm.quoteAssetReserve = new BN(cc).mul(BASE_PRECISION);
+		mockMarket1.amm.pegMultiplier = new BN(18.32 * PEG_PRECISION.toNumber());
+		mockMarket1.amm.sqrtK = new BN(cc).mul(BASE_PRECISION);
+
+		const now = new BN(1688881915);
+
+		const oraclePriceData: OraclePriceData = {
+			price: new BN(18.624 * PRICE_PRECISION.toNumber()),
+			slot: new BN(0),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+		mockMarket1.amm.historicalOracleData.lastOraclePrice = new BN(
+			18.5535 * PRICE_PRECISION.toNumber()
+		);
+
+		const updatedAmm = calculateUpdatedAMM(mockMarket1.amm, oraclePriceData);
+
+		const [openBids, openAsks] = calculateMarketOpenBidAsk(
+			updatedAmm.baseAssetReserve,
+			updatedAmm.minBaseAssetReserve,
+			updatedAmm.maxBaseAssetReserve,
+			updatedAmm.orderStepSize
+		);
+
+		const generator = getVammL2Generator({
+			marketAccount: mockMarket1,
+			oraclePriceData,
+			numOrders: 10,
+			now,
+			topOfBookQuoteAmounts: [],
+		});
+
+		const bids = Array.from(generator.getL2Bids());
+		// console.log(bids);
+
+		const totalBidSize = bids.reduce((total: BN, order: L2Level) => {
+			return total.add(order.size);
+		}, ZERO);
+
+		console.log(
+			'totalBidSize:',
+			totalBidSize.toString(),
+			'openBids:',
+			openBids.toString()
+		);
+		assert(totalBidSize.sub(openBids).abs().lt(new BN(10))); // smol err
+		assert(totalBidSize.sub(openBids).lt(ZERO)); // under estimation
+
+		const asks = Array.from(generator.getL2Asks());
+		// console.log(asks);
+
+		const totalAskSize = asks.reduce((total: BN, order: L2Level) => {
+			return total.add(order.size);
+		}, ZERO);
+		console.log(
+			'totalAskSize:',
+			totalAskSize.toString(),
+			'openAsks:',
+			openAsks.toString()
+		);
+		assert(totalAskSize.sub(openAsks.abs()).lte(new BN(5))); // only tiny rounding errors
+	});
+
+	it('orderbook L2 gen (no topOfBookQuoteAmounts, 10 numOrders)', async () => {
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+
+		const mockMarket1: PerpMarketAccount = myMockPerpMarkets[0];
+		const cc = 38104569;
+		mockMarket1.amm.baseAssetReserve = new BN(cc).mul(BASE_PRECISION);
+		mockMarket1.amm.maxBaseAssetReserve = mockMarket1.amm.baseAssetReserve.mul(
+			new BN(2)
+		);
+		mockMarket1.amm.minBaseAssetReserve = mockMarket1.amm.baseAssetReserve.div(
+			new BN(2)
+		);
+		mockMarket1.amm.quoteAssetReserve = new BN(cc).mul(BASE_PRECISION);
+		mockMarket1.amm.pegMultiplier = new BN(18.32 * PEG_PRECISION.toNumber());
+		mockMarket1.amm.sqrtK = new BN(cc).mul(BASE_PRECISION);
+
+		const now = new BN(1688881915);
+
+		const oraclePriceData: OraclePriceData = {
+			price: new BN(18.624 * PRICE_PRECISION.toNumber()),
+			slot: new BN(0),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+		mockMarket1.amm.historicalOracleData.lastOraclePrice = new BN(
+			18.5535 * PRICE_PRECISION.toNumber()
+		);
+
+		const updatedAmm = calculateUpdatedAMM(mockMarket1.amm, oraclePriceData);
+
+		const [openBids, openAsks] = calculateMarketOpenBidAsk(
+			updatedAmm.baseAssetReserve,
+			updatedAmm.minBaseAssetReserve,
+			updatedAmm.maxBaseAssetReserve,
+			updatedAmm.orderStepSize
+		);
+
+		const generator = getVammL2Generator({
+			marketAccount: mockMarket1,
+			oraclePriceData,
+			numOrders: 10,
+			now,
+			topOfBookQuoteAmounts: [],
+		});
+
+		const bids = Array.from(generator.getL2Bids());
+		// console.log(bids);
+
+		const totalBidSize = bids.reduce((total: BN, order: L2Level) => {
+			return total.add(order.size);
+		}, ZERO);
+
+		console.log(
+			'totalBidSize:',
+			totalBidSize.toString(),
+			'openBids:',
+			openBids.toString()
+		);
+		assert(totalBidSize.eq(openBids));
+
+		const asks = Array.from(generator.getL2Asks());
+		// console.log(asks);
+
+		const totalAskSize = asks.reduce((total: BN, order: L2Level) => {
+			return total.add(order.size);
+		}, ZERO);
+		console.log(
+			'totalAskSize:',
+			totalAskSize.toString(),
+			'openAsks:',
+			openAsks.toString()
+		);
+		assert(totalAskSize.sub(openAsks.abs()).lte(new BN(5))); // only tiny rounding errors
+	});
+
+	it('orderbook L2 gen (4 topOfBookQuoteAmounts, 10 numOrders)', async () => {
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+
+		const mockMarket1: PerpMarketAccount = myMockPerpMarkets[0];
+		const cc = 38104569;
+		mockMarket1.amm.baseAssetReserve = new BN(cc).mul(BASE_PRECISION);
+		mockMarket1.amm.maxBaseAssetReserve = mockMarket1.amm.baseAssetReserve.mul(
+			new BN(2)
+		);
+		mockMarket1.amm.minBaseAssetReserve = mockMarket1.amm.baseAssetReserve.div(
+			new BN(2)
+		);
+		mockMarket1.amm.quoteAssetReserve = new BN(cc).mul(BASE_PRECISION);
+		mockMarket1.amm.pegMultiplier = new BN(18.32 * PEG_PRECISION.toNumber());
+		mockMarket1.amm.sqrtK = new BN(cc).mul(BASE_PRECISION);
+
+		const now = new BN(1688881915);
+
+		const oraclePriceData: OraclePriceData = {
+			price: new BN(18.624 * PRICE_PRECISION.toNumber()),
+			slot: new BN(0),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+		mockMarket1.amm.historicalOracleData.lastOraclePrice = new BN(
+			18.5535 * PRICE_PRECISION.toNumber()
+		);
+
+		const updatedAmm = calculateUpdatedAMM(mockMarket1.amm, oraclePriceData);
+
+		const [openBids, openAsks] = calculateMarketOpenBidAsk(
+			updatedAmm.baseAssetReserve,
+			updatedAmm.minBaseAssetReserve,
+			updatedAmm.maxBaseAssetReserve,
+			updatedAmm.orderStepSize
+		);
+
+		assert(!openAsks.eq(openBids));
+
+		const generator = getVammL2Generator({
+			marketAccount: mockMarket1,
+			oraclePriceData,
+			numOrders: 10,
+			now,
+			topOfBookQuoteAmounts: [
+				new BN(10).mul(QUOTE_PRECISION),
+				new BN(100).mul(QUOTE_PRECISION),
+				new BN(1000).mul(QUOTE_PRECISION),
+				new BN(10000).mul(QUOTE_PRECISION),
+			],
+		});
+
+		const bids = Array.from(generator.getL2Bids());
+		// console.log(bids);
+
+		const totalBidSize = bids.reduce((total: BN, order: L2Level) => {
+			return total.add(order.size);
+		}, ZERO);
+
+		console.log(
+			'totalBidSize:',
+			totalBidSize.toString(),
+			'openBids:',
+			openBids.toString()
+		);
+		assert(totalBidSize.eq(openBids));
+
+		const asks = Array.from(generator.getL2Asks());
+		// console.log(asks);
+
+		const totalAskSize = asks.reduce((total: BN, order: L2Level) => {
+			return total.add(order.size);
+		}, ZERO);
+		console.log(
+			'totalAskSize:',
+			totalAskSize.toString(),
+			'openAsks:',
+			openAsks.toString()
+		);
+		assert(totalAskSize.sub(openAsks.abs()).lte(new BN(5))); // only tiny rounding errors
+	});
+
+
+	it('orderbook L2 gen (4 topOfBookQuoteAmounts, 10 numOrders, low bid liquidity)', async () => {
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+
+		const mockMarket1: PerpMarketAccount = myMockPerpMarkets[0];
+		const cc = 38104569;
+		mockMarket1.amm.baseAssetReserve = new BN(cc).mul(BASE_PRECISION);
+		mockMarket1.amm.maxBaseAssetReserve = mockMarket1.amm.baseAssetReserve.add(BASE_PRECISION); // only 1 base
+		mockMarket1.amm.minBaseAssetReserve = mockMarket1.amm.baseAssetReserve.div(
+			new BN(2)
+		);
+		mockMarket1.amm.quoteAssetReserve = new BN(cc).mul(BASE_PRECISION);
+		mockMarket1.amm.pegMultiplier = new BN(18.32 * PEG_PRECISION.toNumber());
+		mockMarket1.amm.sqrtK = new BN(cc).mul(BASE_PRECISION);
+
+		const now = new BN(1688881915);
+
+		const oraclePriceData: OraclePriceData = {
+			price: new BN(18.624 * PRICE_PRECISION.toNumber()),
+			slot: new BN(0),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+		mockMarket1.amm.historicalOracleData.lastOraclePrice = new BN(
+			18.5535 * PRICE_PRECISION.toNumber()
+		);
+
+		const updatedAmm = calculateUpdatedAMM(mockMarket1.amm, oraclePriceData);
+
+		const [openBids, openAsks] = calculateMarketOpenBidAsk(
+			updatedAmm.baseAssetReserve,
+			updatedAmm.minBaseAssetReserve,
+			updatedAmm.maxBaseAssetReserve,
+			updatedAmm.orderStepSize
+		);
+
+		assert(!openAsks.eq(openBids));
+
+		const generator = getVammL2Generator({
+			marketAccount: mockMarket1,
+			oraclePriceData,
+			numOrders: 10,
+			now,
+			topOfBookQuoteAmounts: [
+				new BN(10).mul(QUOTE_PRECISION),
+				new BN(100).mul(QUOTE_PRECISION),
+				new BN(1000).mul(QUOTE_PRECISION),
+				new BN(10000).mul(QUOTE_PRECISION),
+			],
+		});
+
+		const bids = Array.from(generator.getL2Bids());
+		assert(bids.length == 2);
+		console.log(bids[0].size.toString());
+		console.log(bids[1].size.toString());
+
+		const totalBidSize = bids.reduce((total: BN, order: L2Level) => {
+			return total.add(order.size);
+		}, ZERO);
+
+		console.log(
+			'totalBidSize:',
+			totalBidSize.toString(),
+			'openBids:',
+			openBids.toString()
+		);
+		assert(totalBidSize.eq(openBids));
+
+		const asks = Array.from(generator.getL2Asks());
+		// console.log(asks);
+
+		const totalAskSize = asks.reduce((total: BN, order: L2Level) => {
+			return total.add(order.size);
+		}, ZERO);
+		console.log(
+			'totalAskSize:',
+			totalAskSize.toString(),
+			'openAsks:',
+			openAsks.toString()
+		);
+		assert(totalAskSize.sub(openAsks.abs()).lte(new BN(5))); // only tiny rounding errors
+	});
+
+
+	it('orderbook L2 gen (4 topOfBookQuoteAmounts, 10 numOrders, low ask liquidity)', async () => {
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+
+		const mockMarket1: PerpMarketAccount = myMockPerpMarkets[0];
+		const cc = 38104569;
+		mockMarket1.amm.baseAssetReserve = new BN(cc).mul(BASE_PRECISION);
+		mockMarket1.amm.maxBaseAssetReserve = mockMarket1.amm.baseAssetReserve.add(BASE_PRECISION.mul(new BN(1000))); // 1000 base
+		mockMarket1.amm.minBaseAssetReserve = mockMarket1.amm.baseAssetReserve.sub(
+			BASE_PRECISION.div(new BN(2))
+		); // only .5 base
+		mockMarket1.amm.quoteAssetReserve = new BN(cc).mul(BASE_PRECISION);
+		mockMarket1.amm.pegMultiplier = new BN(18.32 * PEG_PRECISION.toNumber());
+		mockMarket1.amm.sqrtK = new BN(cc).mul(BASE_PRECISION);
+
+		const now = new BN(1688881915);
+
+		const oraclePriceData: OraclePriceData = {
+			price: new BN(18.624 * PRICE_PRECISION.toNumber()),
+			slot: new BN(0),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+		mockMarket1.amm.historicalOracleData.lastOraclePrice = new BN(
+			18.5535 * PRICE_PRECISION.toNumber()
+		);
+
+		const updatedAmm = calculateUpdatedAMM(mockMarket1.amm, oraclePriceData);
+
+		const [openBids, openAsks] = calculateMarketOpenBidAsk(
+			updatedAmm.baseAssetReserve,
+			updatedAmm.minBaseAssetReserve,
+			updatedAmm.maxBaseAssetReserve,
+			updatedAmm.orderStepSize
+		);
+
+		assert(!openAsks.eq(openBids));
+
+		const generator = getVammL2Generator({
+			marketAccount: mockMarket1,
+			oraclePriceData,
+			numOrders: 10,
+			now,
+			topOfBookQuoteAmounts: [
+				new BN(10).mul(QUOTE_PRECISION),
+				new BN(100).mul(QUOTE_PRECISION),
+				new BN(1000).mul(QUOTE_PRECISION),
+				new BN(10000).mul(QUOTE_PRECISION),
+			],
+		});
+
+		const bids = Array.from(generator.getL2Bids());
+
+		const totalBidSize = bids.reduce((total: BN, order: L2Level) => {
+			return total.add(order.size);
+		}, ZERO);
+
+		console.log(
+			'totalBidSize:',
+			totalBidSize.toString(),
+			'openBids:',
+			openBids.toString()
+		);
+		assert(totalBidSize.sub(openBids).abs().lt(new BN(5)));
+
+		const asks = Array.from(generator.getL2Asks());
+		// console.log(asks);
+
+		assert(asks.length == 1);
+		console.log(asks[0].size.toString());
+		const totalAskSize = asks.reduce((total: BN, order: L2Level) => {
+			return total.add(order.size);
+		}, ZERO);
+		console.log(
+			'totalAskSize:',
+			totalAskSize.toString(),
+			'openAsks:',
+			openAsks.toString()
+		);
+		assert(totalAskSize.sub(openAsks.abs()).lte(new BN(5))); // only tiny rounding errors
+	});
 });