@drift-labs/sdk 0.2.0-master.31 → 0.2.0-master.33

package/src/idl/pyth.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.0",
+  "version": "0.1.0",
   "name": "pyth",
   "instructions": [
     {
@@ -41,6 +41,102 @@
           "type": "i64"
         }
       ]
+    },
+    {
+      "name": "setPriceInfo",
+      "accounts": [
+        {
+          "name": "price",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "price",
+          "type": "i64"
+        },
+        {
+          "name": "conf",
+          "type": "u64"
+        },
+        {
+          "name": "slot",
+          "type": "u64"
+        }
+      ]
+    },
+    {
+      "name": "setTwap",
+      "accounts": [
+        {
+          "name": "price",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "twap",
+          "type": "i64"
+        }
+      ]
+    }
+  ],
+  "types": [
+    {
+      "name": "PriceStatus",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "Unknown"
+          },
+          {
+            "name": "Trading"
+          },
+          {
+            "name": "Halted"
+          },
+          {
+            "name": "Auction"
+          }
+        ]
+      }
+    },
+    {
+      "name": "CorpAction",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "NoCorpAct"
+          }
+        ]
+      }
+    },
+    {
+      "name": "PriceType",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "Unknown"
+          },
+          {
+            "name": "Price"
+          },
+          {
+            "name": "TWAP"
+          },
+          {
+            "name": "Volatility"
+          }
+        ]
+      }
     }
-  ]
+  ],
+  "metadata": {
+    "address": "gSbePebfvPy7tRqimPoVecS2UsBvYv46ynrzWocc92s"
+  }
 }

package/src/index.ts

@@ -34,6 +34,7 @@ export * from './events/fetchLogs';
 export * from './math/auction';
 export * from './math/spotMarket';
 export * from './math/conversion';
+export * from './math/exchangeStatus';
 export * from './math/funding';
 export * from './math/market';
 export * from './math/position';
@@ -52,9 +53,11 @@ export * from './math/utils';
 export * from './config';
 export * from './constants/numericConstants';
 export * from './serum/serumSubscriber';
+export * from './serum/serumFulfillmentConfigMap';
 export * from './tx/retryTxSender';
 export * from './util/computeUnits';
 export * from './util/tps';
+export * from './util/promiseTimeout';
 export * from './math/spotBalance';
 export * from './constants/spotMarkets';
 export * from './clearingHouseConfig';

package/src/math/amm.ts

@@ -117,7 +117,7 @@ export function calculateNewAmm(
 		newAmm.sqrtK = newAmm.sqrtK.mul(pKNumer).div(pKDenom);
 		const invariant = newAmm.sqrtK.mul(newAmm.sqrtK);
 		newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
-		const directionToClose = amm.netBaseAssetAmount.gt(ZERO)
+		const directionToClose = amm.baseAssetAmountWithAmm.gt(ZERO)
 			? PositionDirection.SHORT
 			: PositionDirection.LONG;
 
@@ -125,7 +125,7 @@ export function calculateNewAmm(
 			calculateAmmReservesAfterSwap(
 				newAmm,
 				'base',
-				amm.netBaseAssetAmount.abs(),
+				amm.baseAssetAmountWithAmm.abs(),
 				getSwapDirection('base', directionToClose)
 			);
 
@@ -157,7 +157,7 @@ export function calculateUpdatedAMM(
 	newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
 	newAmm.pegMultiplier = newPeg;
 
-	const directionToClose = amm.netBaseAssetAmount.gt(ZERO)
+	const directionToClose = amm.baseAssetAmountWithAmm.gt(ZERO)
 		? PositionDirection.SHORT
 		: PositionDirection.LONG;
 
@@ -165,7 +165,7 @@ export function calculateUpdatedAMM(
 		calculateAmmReservesAfterSwap(
 			newAmm,
 			'base',
-			amm.netBaseAssetAmount.abs(),
+			amm.baseAssetAmountWithAmm.abs(),
 			getSwapDirection('base', directionToClose)
 		);
 
@@ -522,7 +522,7 @@ export function calculateSpread(
 		amm.quoteAssetReserve,
 		amm.terminalQuoteAssetReserve,
 		amm.pegMultiplier,
-		amm.netBaseAssetAmount,
+		amm.baseAssetAmountWithAmm,
 		reservePrice,
 		amm.totalFeeMinusDistributions,
 		amm.baseAssetReserve,
@@ -629,7 +629,7 @@ export function getSwapDirection(
  * @returns cost : Precision PRICE_PRECISION
  */
 export function calculateTerminalPrice(market: PerpMarketAccount) {
-	const directionToClose = market.amm.netBaseAssetAmount.gt(ZERO)
+	const directionToClose = market.amm.baseAssetAmountWithAmm.gt(ZERO)
 		? PositionDirection.SHORT
 		: PositionDirection.LONG;
 
@@ -637,7 +637,7 @@ export function calculateTerminalPrice(market: PerpMarketAccount) {
 		calculateAmmReservesAfterSwap(
 			market.amm,
 			'base',
-			market.amm.netBaseAssetAmount.abs(),
+			market.amm.baseAssetAmountWithAmm.abs(),
 			getSwapDirection('base', directionToClose)
 		);
 
@@ -713,7 +713,7 @@ export function calculateMaxBaseAssetAmountFillable(
 	orderDirection: PositionDirection
 ): BN {
 	const maxFillSize = amm.baseAssetReserve.div(
-		new BN(amm.maxBaseAssetAmountRatio)
+		new BN(amm.maxFillReserveFraction)
 	);
 	let maxBaseAssetAmountOnSide: BN;
 	if (isVariant(orderDirection, 'long')) {
@@ -730,6 +730,6 @@ export function calculateMaxBaseAssetAmountFillable(
 
 	return standardizeBaseAssetAmount(
 		BN.min(maxFillSize, maxBaseAssetAmountOnSide),
-		amm.baseAssetAmountStepSize
+		amm.orderStepSize
 	);
 }

package/src/math/exchangeStatus.ts

@@ -0,0 +1,31 @@
+import {
+	isOneOfVariant,
+	isVariant,
+	PerpMarketAccount,
+	SpotMarketAccount,
+	StateAccount,
+} from '../types';
+
+export function exchangePaused(state: StateAccount): boolean {
+	return isVariant(state.exchangeStatus, 'paused');
+}
+
+export function fillPaused(
+	state: StateAccount,
+	market: PerpMarketAccount | SpotMarketAccount
+): boolean {
+	return (
+		isOneOfVariant(state.exchangeStatus, ['paused', 'fillPaused']) ||
+		isOneOfVariant(market.status, ['paused', 'fillPaused'])
+	);
+}
+
+export function ammPaused(
+	state: StateAccount,
+	market: PerpMarketAccount | SpotMarketAccount
+): boolean {
+	return (
+		isOneOfVariant(state.exchangeStatus, ['paused', 'ammPaused']) ||
+		isOneOfVariant(market.status, ['paused', 'ammPaused'])
+	);
+}

package/src/math/funding.ts

@@ -137,9 +137,11 @@ export async function calculateAllEstimatedFundingRate(
 	let cappedAltEst: BN;
 	let largerSide: BN;
 	let smallerSide: BN;
-	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
-		largerSide = market.baseAssetAmountLong.abs();
-		smallerSide = market.baseAssetAmountShort.abs();
+	if (
+		market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())
+	) {
+		largerSide = market.amm.baseAssetAmountLong.abs();
+		smallerSide = market.amm.baseAssetAmountShort.abs();
 		if (twapSpread.gt(new BN(0))) {
 			return [
 				markTwapWithMantissa,
@@ -149,9 +151,11 @@ export async function calculateAllEstimatedFundingRate(
 				interpEst,
 			];
 		}
-	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
-		largerSide = market.baseAssetAmountShort.abs();
-		smallerSide = market.baseAssetAmountLong.abs();
+	} else if (
+		market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())
+	) {
+		largerSide = market.amm.baseAssetAmountShort.abs();
+		smallerSide = market.amm.baseAssetAmountLong.abs();
 		if (twapSpread.lt(new BN(0))) {
 			return [
 				markTwapWithMantissa,
@@ -251,9 +255,11 @@ export async function calculateLongShortFundingRate(
 			periodAdjustment
 		);
 
-	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
+	if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort)) {
 		return [cappedAltEst, interpEst];
-	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
+	} else if (
+		market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort)
+	) {
 		return [interpEst, cappedAltEst];
 	} else {
 		return [interpEst, interpEst];
@@ -279,9 +285,13 @@ export async function calculateLongShortFundingRateAndLiveTwaps(
 			periodAdjustment
 		);
 
-	if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+	if (
+		market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())
+	) {
 		return [markTwapLive, oracleTwapLive, cappedAltEst, interpEst];
-	} else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+	} else if (
+		market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())
+	) {
 		return [markTwapLive, oracleTwapLive, interpEst, cappedAltEst];
 	} else {
 		return [markTwapLive, oracleTwapLive, interpEst, interpEst];

package/src/math/margin.ts

@@ -9,6 +9,7 @@ import {
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
 import { PerpMarketAccount, PerpPosition } from '..';
+import { isVariant } from '../types';
 import { assert } from '../assert/assert';
 
 export function calculateSizePremiumLiabilityWeight(
@@ -107,9 +108,14 @@ export function calculateBaseAssetValueWithOracle(
 	perpPosition: PerpPosition,
 	oraclePriceData: OraclePriceData
 ): BN {
+	let price = oraclePriceData.price;
+	if (isVariant(market.status, 'settlement')) {
+		price = market.expiryPrice;
+	}
+
 	return perpPosition.baseAssetAmount
 		.abs()
-		.mul(oraclePriceData.price)
+		.mul(price)
 		.div(AMM_RESERVE_PRECISION);
 }
 

package/src/math/market.ts

@@ -159,29 +159,29 @@ export function calculateUnrealizedAssetWeight(
 	let assetWeight: BN;
 	switch (marginCategory) {
 		case 'Initial':
-			assetWeight = new BN(market.unrealizedInitialAssetWeight);
+			assetWeight = new BN(market.unrealizedPnlInitialAssetWeight);
 
-			if (market.unrealizedMaxImbalance.gt(ZERO)) {
+			if (market.unrealizedPnlMaxImbalance.gt(ZERO)) {
 				const netUnsettledPnl = calculateNetUserPnlImbalance(
 					market,
 					quoteSpotMarket,
 					oraclePriceData
 				);
-				if (netUnsettledPnl.gt(market.unrealizedMaxImbalance)) {
+				if (netUnsettledPnl.gt(market.unrealizedPnlMaxImbalance)) {
 					assetWeight = assetWeight
-						.mul(market.unrealizedMaxImbalance)
+						.mul(market.unrealizedPnlMaxImbalance)
 						.div(netUnsettledPnl);
 				}
 			}
 
 			assetWeight = calculateSizeDiscountAssetWeight(
 				unrealizedPnl,
-				market.unrealizedImfFactor,
+				market.unrealizedPnlImfFactor,
 				assetWeight
 			);
 			break;
 		case 'Maintenance':
-			assetWeight = new BN(market.unrealizedMaintenanceAssetWeight);
+			assetWeight = new BN(market.unrealizedPnlMaintenanceAssetWeight);
 			break;
 	}
 
@@ -193,7 +193,7 @@ export function calculateMarketAvailablePNL(
 	spotMarket: SpotMarketAccount
 ): BN {
 	return getTokenAmount(
-		perpMarket.pnlPool.balance,
+		perpMarket.pnlPool.scaledBalance,
 		spotMarket,
 		SpotBalanceType.DEPOSIT
 	);
@@ -203,7 +203,7 @@ export function calculateNetUserPnl(
 	perpMarket: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
-	const netUserPositionValue = perpMarket.amm.netBaseAssetAmount
+	const netUserPositionValue = perpMarket.amm.baseAssetAmountWithAmm
 		.mul(oraclePriceData.price)
 		.div(BASE_PRECISION)
 		.div(PRICE_TO_QUOTE_PRECISION);
@@ -225,7 +225,7 @@ export function calculateNetUserPnlImbalance(
 	const netUserPnl = calculateNetUserPnl(perpMarket, oraclePriceData);
 
 	const pnlPool = getTokenAmount(
-		perpMarket.pnlPool.balance,
+		perpMarket.pnlPool.scaledBalance,
 		spotMarket,
 		SpotBalanceType.DEPOSIT
 	);

package/src/math/orders.ts

@@ -10,7 +10,6 @@ import { ZERO, TWO } from '../constants/numericConstants';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
 import { getAuctionPrice, isAuctionComplete } from './auction';
-import { calculateAskPrice, calculateBidPrice } from './market';
 import {
 	calculateMaxBaseAssetAmountFillable,
 	calculateMaxBaseAssetAmountToTrade,
@@ -132,36 +131,23 @@ export function standardizeBaseAssetAmount(
 export function getLimitPrice(
 	order: Order,
 	oraclePriceData: OraclePriceData,
-	slot: number,
-	perpMarket?: PerpMarketAccount
+	slot: number
 ): BN {
 	let limitPrice;
-	if (!order.oraclePriceOffset.eq(ZERO)) {
-		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+	if (order.oraclePriceOffset !== 0) {
+		limitPrice = oraclePriceData.price.add(new BN(order.oraclePriceOffset));
 	} else if (isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
 		if (!isAuctionComplete(order, slot)) {
 			limitPrice = getAuctionPrice(order, slot);
 		} else if (!order.price.eq(ZERO)) {
 			limitPrice = order.price;
 		} else {
-			if (perpMarket) {
-				if (isVariant(order.direction, 'long')) {
-					const askPrice = calculateAskPrice(perpMarket, oraclePriceData);
-					const delta = askPrice.div(new BN(perpMarket.amm.maxSlippageRatio));
-					limitPrice = askPrice.add(delta);
-				} else {
-					const bidPrice = calculateBidPrice(perpMarket, oraclePriceData);
-					const delta = bidPrice.div(new BN(perpMarket.amm.maxSlippageRatio));
-					limitPrice = bidPrice.sub(delta);
-				}
+			// check oracle validity?
+			const oraclePrice1Pct = oraclePriceData.price.div(new BN(100));
+			if (isVariant(order.direction, 'long')) {
+				limitPrice = oraclePriceData.price.add(oraclePrice1Pct);
 			} else {
-				// check oracle validity?
-				const oraclePrice1Pct = oraclePriceData.price.div(new BN(100));
-				if (isVariant(order.direction, 'long')) {
-					limitPrice = oraclePriceData.price.add(oraclePrice1Pct);
-				} else {
-					limitPrice = oraclePriceData.price.sub(oraclePrice1Pct);
-				}
+				limitPrice = oraclePriceData.price.sub(oraclePrice1Pct);
 			}
 		}
 	} else {
@@ -171,11 +157,32 @@ export function getLimitPrice(
 	return limitPrice;
 }
 
+export function getOptionalLimitPrice(
+	order: Order,
+	oraclePriceData: OraclePriceData,
+	slot: number
+): BN | undefined {
+	if (hasLimitPrice(order, slot)) {
+		return getLimitPrice(order, oraclePriceData, slot);
+	} else {
+		return undefined;
+	}
+}
+
+export function hasLimitPrice(order: Order, slot: number): boolean {
+	return (
+		order.price.gt(ZERO) ||
+		order.oraclePriceOffset != 0 ||
+		!isAuctionComplete(order, slot)
+	);
+}
+
 export function isFillableByVAMM(
 	order: Order,
 	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,
-	slot: number
+	slot: number,
+	ts: number
 ): boolean {
 	return (
 		(isAuctionComplete(order, slot) &&
@@ -185,7 +192,7 @@ export function isFillableByVAMM(
 				oraclePriceData,
 				slot
 			).eq(ZERO)) ||
-		isOrderExpired(order, slot)
+		isOrderExpired(order, ts)
 	);
 }
 
@@ -202,7 +209,7 @@ export function calculateBaseAssetAmountForAmmToFulfill(
 		return ZERO;
 	}
 
-	const limitPrice = getLimitPrice(order, oraclePriceData, slot, market);
+	const limitPrice = getLimitPrice(order, oraclePriceData, slot);
 	const baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(
 		order,
 		market,
@@ -233,7 +240,7 @@ export function calculateBaseAssetAmountToFillUpToLimitPrice(
 
 	const baseAssetAmount = standardizeBaseAssetAmount(
 		maxAmountToTrade,
-		market.amm.baseAssetAmountStepSize
+		market.amm.orderStepSize
 	);
 
 	// Check that directions are the same
@@ -257,14 +264,22 @@ function isSameDirection(
 	);
 }
 
-export function isOrderExpired(order: Order, slot: number): boolean {
+export function isOrderExpired(order: Order, ts: number): boolean {
 	if (
 		isOneOfVariant(order.orderType, ['triggerMarket', 'triggerLimit']) ||
 		!isVariant(order.status, 'open') ||
-		order.timeInForce === 0
+		order.maxTs.eq(ZERO)
 	) {
 		return false;
 	}
 
-	return new BN(slot).sub(order.slot).gt(new BN(order.timeInForce));
+	return new BN(ts).gt(order.maxTs);
+}
+
+export function isMarketOrder(order: Order): boolean {
+	return isOneOfVariant(order.orderType, ['market', 'triggerMarket']);
+}
+
+export function isLimitOrder(order: Order): boolean {
+	return isOneOfVariant(order.orderType, ['limit', 'triggerLimit']);
 }

package/src/math/repeg.ts

@@ -26,7 +26,7 @@ export function calculateAdjustKCost(
 	const x = amm.baseAssetReserve;
 	const y = amm.quoteAssetReserve;
 
-	const d = amm.netBaseAssetAmount;
+	const d = amm.baseAssetAmountWithAmm;
 	const Q = amm.pegMultiplier;
 
 	const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
@@ -135,7 +135,7 @@ export function calculateBudgetedK(amm: AMM, cost: BN): [BN, BN] {
 	const x = amm.baseAssetReserve;
 	const y = amm.quoteAssetReserve;
 
-	const d = amm.netBaseAssetAmount;
+	const d = amm.baseAssetAmountWithAmm;
 	const Q = amm.pegMultiplier;
 
 	const [numerator, denominator] = calculateBudgetedKBN(x, y, cost, Q, d);
@@ -159,7 +159,7 @@ export function calculateBudgetedPeg(amm: AMM, cost: BN, targetPrice: BN): BN {
 	const x = amm.baseAssetReserve;
 	const y = amm.quoteAssetReserve;
 
-	const d = amm.netBaseAssetAmount;
+	const d = amm.baseAssetAmountWithAmm;
 	const Q = amm.pegMultiplier;
 
 	const C = cost.mul(new BN(-1));

package/src/math/spotBalance.ts

@@ -287,20 +287,20 @@ export function calculateWithdrawLimit(
 	const borrowTokenTwapLive = spotMarket.borrowTokenTwap
 		.mul(sinceStart)
 		.add(marketBorrowTokenAmount.mul(sinceLast))
-		.div(sinceLast.add(sinceLast));
+		.div(sinceLast.add(sinceStart));
 
 	const depositTokenTwapLive = spotMarket.depositTokenTwap
 		.mul(sinceStart)
 		.add(marketDepositTokenAmount.mul(sinceLast))
-		.div(sinceLast.add(sinceLast));
+		.div(sinceLast.add(sinceStart));
 
 	const maxBorrowTokens = BN.min(
 		BN.max(
 			marketDepositTokenAmount.div(new BN(6)),
 			borrowTokenTwapLive.add(borrowTokenTwapLive.div(new BN(5)))
 		),
-		marketDepositTokenAmount.sub(marketDepositTokenAmount.div(new BN(10)))
-	); // between ~15-90% utilization with friction on twap
+		marketDepositTokenAmount.sub(marketDepositTokenAmount.div(new BN(5)))
+	); // between ~15-80% utilization with friction on twap
 
 	const minDepositTokens = depositTokenTwapLive.sub(
 		BN.min(

package/src/math/spotPosition.ts

@@ -9,7 +9,7 @@ import {
 import { OraclePriceData } from '../oracles/types';
 
 export function isSpotPositionAvailable(position: SpotPosition): boolean {
-	return position.balance.eq(ZERO) && position.openOrders === 0;
+	return position.scaledBalance.eq(ZERO) && position.openOrders === 0;
 }
 
 export function getWorstCaseTokenAmounts(
@@ -19,7 +19,7 @@ export function getWorstCaseTokenAmounts(
 ): [BN, BN] {
 	const tokenAmount = getSignedTokenAmount(
 		getTokenAmount(
-			spotPosition.balance,
+			spotPosition.scaledBalance,
 			spotMarketAccount,
 			spotPosition.balanceType
 		),

package/src/serum/serumFulfillmentConfigMap.ts

@@ -0,0 +1,26 @@
+import { PublicKey } from '@solana/web3.js';
+import { SerumV3FulfillmentConfigAccount } from '../types';
+import { ClearingHouse } from '../clearingHouse';
+
+export class SerumFulfillmentConfigMap {
+	clearingHouse: ClearingHouse;
+	map = new Map<number, SerumV3FulfillmentConfigAccount>();
+
+	public constructor(clearingHouse: ClearingHouse) {
+		this.clearingHouse = clearingHouse;
+	}
+
+	public async add(
+		marketIndex: number,
+		serumMarketAddress: PublicKey
+	): Promise<void> {
+		const account = await this.clearingHouse.getSerumV3FulfillmentConfig(
+			serumMarketAddress
+		);
+		this.map.set(marketIndex, account);
+	}
+
+	public get(marketIndex: number): SerumV3FulfillmentConfigAccount {
+		return this.map.get(marketIndex);
+	}
+}

package/src/serum/serumSubscriber.ts

@@ -2,6 +2,8 @@ import { Connection, PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
 import { Market, Orderbook } from '@project-serum/serum';
 import { SerumMarketSubscriberConfig } from './types';
+import { BN } from '@project-serum/anchor';
+import { PRICE_PRECISION } from '../constants/numericConstants';
 
 export class SerumSubscriber {
 	connection: Connection;
@@ -49,7 +51,6 @@ export class SerumSubscriber {
 			(buffer, slot) => {
 				this.lastAsksSlot = slot;
 				this.asks = Orderbook.decode(this.market, buffer);
-				console.log(this.asks.getL2(3));
 			}
 		);
 
@@ -67,6 +68,24 @@ export class SerumSubscriber {
 		this.subscribed = true;
 	}
 
+	public getBestBid(): BN | undefined {
+		const bestBid = this.bids.getL2(1)[0];
+		if (!bestBid) {
+			return undefined;
+		}
+
+		return new BN(bestBid[0] * PRICE_PRECISION.toNumber());
+	}
+
+	public getBestAsk(): BN | undefined {
+		const bestAsk = this.asks.getL2(1)[0];
+		if (!bestAsk) {
+			return undefined;
+		}
+
+		return new BN(bestAsk[0] * PRICE_PRECISION.toNumber());
+	}
+
 	public async unsubscribe(): Promise<void> {
 		if (!this.subscribed) {
 			return;