@drift-labs/sdk 2.40.0-beta.12 → 2.40.0-beta.14

package/VERSION

@@ -1 +1 @@
-2.40.0-beta.12
+2.40.0-beta.14

package/lib/dlob/DLOBSubscriber.js

@@ -60,6 +60,9 @@ class DLOBSubscriber {
                 throw new Error('Either marketName or marketIndex and marketType must be provided');
             }
         }
+        if (includeVamm && fallbackL2Generators.length > 0) {
+            throw new Error('includeVamm can only be used if fallbackL2Generators is empty');
+        }
         let oraclePriceData;
         let fallbackBid;
         let fallbackAsk;
@@ -80,6 +83,7 @@ class DLOBSubscriber {
                     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,15 @@
 "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(100).mul(__1.QUOTE_PRECISION),
+    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 +86,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 +106,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 +153,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,8 +229,8 @@ 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
-    slippageBps, swapMode, onlyDirectRoutes, }: {
+    getQuote({ inputMint, outputMint, amount, maxAccounts, // 50 is an estimated amount with buffer
+    slippageBps, swapMode, onlyDirectRoutes, excludeDexes, }: {
         inputMint: PublicKey;
         outputMint: PublicKey;
         amount: BN;
@@ -238,6 +238,7 @@ export declare class JupiterClient {
         slippageBps?: number;
         swapMode?: SwapMode;
         onlyDirectRoutes?: boolean;
+        excludeDexes?: string[];
     }): Promise<QuoteResponse>;
     /**
      * Get a swap transaction for quote

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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.40.0-beta.12",
+	"version": "2.40.0-beta.14",
 	"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,
@@ -102,6 +103,12 @@ export class DLOBSubscriber {
 			}
 		}
 
+		if (includeVamm && fallbackL2Generators.length > 0) {
+			throw new Error(
+				'includeVamm can only be used if fallbackL2Generators is empty'
+			);
+		}
+
 		let oraclePriceData;
 		let fallbackBid;
 		let fallbackAsk;
@@ -125,6 +132,7 @@ export class DLOBSubscriber {
 					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,14 @@ export type L3OrderBook = {
 	bids: L3Level[];
 };
 
+export const DEFAULT_TOP_OF_BOOK_QUOTE_AMOUNTS = [
+	new BN(100).mul(QUOTE_PRECISION),
+	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 +149,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 +180,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 +259,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,10 +275,11 @@ 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,
+		excludeDexes = [],
 	}: {
 		inputMint: PublicKey;
 		outputMint: PublicKey;
@@ -287,6 +288,7 @@ export class JupiterClient {
 		slippageBps?: number;
 		swapMode?: SwapMode;
 		onlyDirectRoutes?: boolean;
+		excludeDexes?: string[];
 	}): Promise<QuoteResponse> {
 		const params = new URLSearchParams({
 			inputMint: inputMint.toString(),
@@ -296,6 +298,7 @@ export class JupiterClient {
 			swapMode,
 			onlyDirectRoutes: onlyDirectRoutes.toString(),
 			maxAccounts: maxAccounts.toString(),
+			excludeDexes: excludeDexes.join(','),
 		}).toString();
 		const quote = await (await fetch(`${this.url}/v6/quote?${params}`)).json();
 		return quote;

package/src/math/auction.ts

@@ -1,5 +1,5 @@
-import { isOneOfVariant, isVariant, Order } from '../types';
-import { BN, ZERO } from '../.';
+import { isOneOfVariant, isVariant, Order, PositionDirection } from '../types';
+import { BN, ONE, ZERO } from '../.';
 
 export function isAuctionComplete(order: Order, slot: number): boolean {
 	if (order.auctionDuration === 0) {
@@ -104,3 +104,37 @@ export function getAuctionPriceForOracleOffsetAuction(
 
 	return oraclePrice.add(priceOffset);
 }
+
+export function deriveOracleAuctionParams({
+	direction,
+	oraclePrice,
+	auctionStartPrice,
+	auctionEndPrice,
+	limitPrice,
+}: {
+	direction: PositionDirection;
+	oraclePrice: BN;
+	auctionStartPrice: BN;
+	auctionEndPrice: BN;
+	limitPrice: BN;
+}): { auctionStartPrice: BN; auctionEndPrice: BN; oraclePriceOffset: number } {
+	let oraclePriceOffset = limitPrice.sub(oraclePrice);
+	if (oraclePriceOffset.eq(ZERO)) {
+		oraclePriceOffset = isVariant(direction, 'long')
+			? auctionEndPrice.sub(oraclePrice).add(ONE)
+			: auctionEndPrice.sub(oraclePrice).sub(ONE);
+	}
+
+	let oraclePriceOffsetNum;
+	try {
+		oraclePriceOffsetNum = oraclePriceOffset.toNumber();
+	} catch (e) {
+		oraclePriceOffsetNum = 0;
+	}
+
+	return {
+		auctionStartPrice: auctionStartPrice.sub(oraclePrice),
+		auctionEndPrice: auctionEndPrice.sub(oraclePrice),
+		oraclePriceOffset: oraclePriceOffsetNum,
+	};
+}

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
+	});
 });

package/tests/auctions/test.ts

@@ -0,0 +1,66 @@
+import {PRICE_PRECISION, BN, deriveOracleAuctionParams} from "../../src";
+import {assert} from "chai";
+import {PositionDirection} from "../../lib";
+
+describe('Auction Tests', () => {
+
+	it('deriveOracleAuctionParams', async () => {
+		let oraclePrice = new BN(100).mul(PRICE_PRECISION);
+		let auctionStartPrice = new BN(90).mul(PRICE_PRECISION);
+		let auctionEndPrice = new BN(110).mul(PRICE_PRECISION);
+		let limitPrice = new BN(120).mul(PRICE_PRECISION);
+
+		let oracleOrderParams = deriveOracleAuctionParams({
+			direction: PositionDirection.LONG,
+			oraclePrice,
+			auctionStartPrice,
+			auctionEndPrice,
+			limitPrice,
+		});
+
+		assert(oracleOrderParams.auctionStartPrice.eq(new BN(-10).mul(PRICE_PRECISION)));
+		assert(oracleOrderParams.auctionEndPrice.eq(new BN(10).mul(PRICE_PRECISION)));
+		assert(oracleOrderParams.oraclePriceOffset === 20 * PRICE_PRECISION.toNumber());
+
+		oracleOrderParams = deriveOracleAuctionParams({
+			direction: PositionDirection.LONG,
+			oraclePrice,
+			auctionStartPrice: oraclePrice,
+			auctionEndPrice: oraclePrice,
+			limitPrice: oraclePrice,
+		});
+
+		assert(oracleOrderParams.auctionStartPrice.eq(new BN(0)));
+		assert(oracleOrderParams.auctionEndPrice.eq(new BN(0)));
+		assert(oracleOrderParams.oraclePriceOffset === 1);
+
+		oraclePrice = new BN(100).mul(PRICE_PRECISION);
+		auctionStartPrice = new BN(110).mul(PRICE_PRECISION);
+		auctionEndPrice = new BN(90).mul(PRICE_PRECISION);
+		limitPrice = new BN(80).mul(PRICE_PRECISION);
+
+		oracleOrderParams = deriveOracleAuctionParams({
+			direction: PositionDirection.SHORT,
+			oraclePrice,
+			auctionStartPrice,
+			auctionEndPrice,
+			limitPrice,
+		});
+
+		assert(oracleOrderParams.auctionStartPrice.eq(new BN(10).mul(PRICE_PRECISION)));
+		assert(oracleOrderParams.auctionEndPrice.eq(new BN(-10).mul(PRICE_PRECISION)));
+		assert(oracleOrderParams.oraclePriceOffset === -20 * PRICE_PRECISION.toNumber());
+
+		oracleOrderParams = deriveOracleAuctionParams({
+			direction: PositionDirection.SHORT,
+			oraclePrice,
+			auctionStartPrice: oraclePrice,
+			auctionEndPrice: oraclePrice,
+			limitPrice: oraclePrice,
+		});
+
+		assert(oracleOrderParams.auctionStartPrice.eq(new BN(0)));
+		assert(oracleOrderParams.auctionEndPrice.eq(new BN(0)));
+		assert(oracleOrderParams.oraclePriceOffset === -1);
+	});
+});