@drift-labs/sdk 2.26.0-beta.1 → 2.26.0-beta.2

package/src/dlob/DLOB.ts

@@ -1,37 +1,48 @@
 import { getOrderSignature, getVammNodeGenerator, NodeList } from './NodeList';
 import {
-	MarketType,
 	BN,
 	calculateAskPrice,
 	calculateBidPrice,
-	DriftClient,
 	convertToNumber,
-	isOrderExpired,
+	DLOBNode,
+	DLOBNodeType,
+	DriftClient,
+	getLimitPrice,
+	getVariant,
+	isFallbackAvailableLiquiditySource,
 	isOneOfVariant,
+	isOrderExpired,
+	isRestingLimitOrder,
+	isTakingOrder,
+	isTriggered,
 	isVariant,
-	getVariant,
+	MarketType,
+	MarketTypeStr,
+	mustBeTriggered,
+	OraclePriceData,
 	Order,
-	PRICE_PRECISION,
-	SpotMarketAccount,
+	OrderActionRecord,
+	OrderRecord,
 	PerpMarketAccount,
-	OraclePriceData,
+	PRICE_PRECISION,
 	SlotSubscriber,
-	MarketTypeStr,
+	SpotMarketAccount,
 	StateAccount,
-	mustBeTriggered,
-	isTriggered,
-	getLimitPrice,
+	TriggerOrderNode,
 	UserMap,
-	OrderRecord,
-	OrderActionRecord,
-	isRestingLimitOrder,
-	isTakingOrder,
-	isFallbackAvailableLiquiditySource,
 } from '..';
 import { PublicKey } from '@solana/web3.js';
-import { DLOBNode, DLOBNodeType, TriggerOrderNode } from '..';
 import { ammPaused, exchangePaused, fillPaused } from '../math/exchangeStatus';
 import { DLOBOrders } from './DLOBOrders';
+import {
+	createL2Levels,
+	getL2GeneratorFromDLOBNodes,
+	L2OrderBook,
+	L2OrderBookGenerator,
+	L3Level,
+	L3OrderBook,
+	mergeL2LevelGenerators,
+} from './orderBookLevels';
 
 export type MarketNodeLists = {
 	restingLimit: {
@@ -1689,4 +1700,153 @@ export class DLOB {
 			yield nodeLists.trigger.below;
 		}
 	}
+
+	/**
+	 * Get an L2 view of the order book for a given market.
+	 *
+	 * @param marketIndex
+	 * @param marketType
+	 * @param slot
+	 * @param oraclePriceData
+	 * @param depth how many levels of the order book to return
+	 * @param fallbackAsk best ask for fallback liquidity, only relevant for perps
+	 * @param fallbackBid best bid for fallback liquidity, only relevant for perps
+	 * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}, openbook {@link SerumSubscriber}
+	 */
+	public getL2({
+		marketIndex,
+		marketType,
+		slot,
+		oraclePriceData,
+		depth,
+		fallbackAsk,
+		fallbackBid,
+		fallbackL2Generators = [],
+	}: {
+		marketIndex: number;
+		marketType: MarketType;
+		slot: number;
+		oraclePriceData: OraclePriceData;
+		depth: number;
+		fallbackAsk?: BN;
+		fallbackBid?: BN;
+		fallbackL2Generators?: L2OrderBookGenerator[];
+	}): L2OrderBook {
+		const makerAskL2LevelGenerator = getL2GeneratorFromDLOBNodes(
+			this.getMakerLimitAsks(
+				marketIndex,
+				slot,
+				marketType,
+				oraclePriceData,
+				fallbackBid
+			),
+			oraclePriceData,
+			slot
+		);
+
+		const fallbackAskGenerators = fallbackL2Generators.map(
+			(fallbackL2Generator) => {
+				return fallbackL2Generator.getL2Asks();
+			}
+		);
+
+		const askL2LevelGenerator = mergeL2LevelGenerators(
+			[makerAskL2LevelGenerator, ...fallbackAskGenerators],
+			(a, b) => {
+				return a.price.lt(b.price);
+			}
+		);
+
+		const asks = createL2Levels(askL2LevelGenerator, depth);
+
+		const makerBidGenerator = getL2GeneratorFromDLOBNodes(
+			this.getMakerLimitBids(
+				marketIndex,
+				slot,
+				marketType,
+				oraclePriceData,
+				fallbackAsk
+			),
+			oraclePriceData,
+			slot
+		);
+
+		const fallbackBidGenerators = fallbackL2Generators.map((fallbackOrders) => {
+			return fallbackOrders.getL2Bids();
+		});
+
+		const bidL2LevelGenerator = mergeL2LevelGenerators(
+			[makerBidGenerator, ...fallbackBidGenerators],
+			(a, b) => {
+				return a.price.gt(b.price);
+			}
+		);
+
+		const bids = createL2Levels(bidL2LevelGenerator, depth);
+
+		return {
+			bids,
+			asks,
+		};
+	}
+
+	/**
+	 * Get an L3 view of the order book for a given market. Does not include fallback liquidity sources
+	 *
+	 * @param marketIndex
+	 * @param marketType
+	 * @param slot
+	 * @param oraclePriceData
+	 */
+	public getL3({
+		marketIndex,
+		marketType,
+		slot,
+		oraclePriceData,
+	}: {
+		marketIndex: number;
+		marketType: MarketType;
+		slot: number;
+		oraclePriceData: OraclePriceData;
+	}): L3OrderBook {
+		const bids: L3Level[] = [];
+		const asks: L3Level[] = [];
+
+		const restingAsks = this.getRestingLimitAsks(
+			marketIndex,
+			slot,
+			marketType,
+			oraclePriceData
+		);
+
+		for (const ask of restingAsks) {
+			asks.push({
+				price: ask.getPrice(oraclePriceData, slot),
+				size: ask.order.baseAssetAmount.sub(ask.order.baseAssetAmountFilled),
+				maker: ask.userAccount,
+				orderId: ask.order.orderId,
+			});
+		}
+
+		const restingBids = this.getRestingLimitBids(
+			marketIndex,
+			slot,
+			marketType,
+			oraclePriceData
+		);
+
+		for (const bid of restingBids) {
+			bids.push({
+				price: bid.getPrice(oraclePriceData, slot),
+				size: bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled),
+				maker: bid.userAccount,
+				orderId: bid.order.orderId,
+			});
+		}
+
+		return {
+			bids,
+			asks,
+		};
+	}
 }

package/src/dlob/DLOBApiClient.ts

@@ -19,7 +19,9 @@ export class DLOBApiClient {
 	public async getDLOB(slot: number): Promise<DLOB> {
 		const r = await fetch(this.url);
 		if (!r.ok) {
-			throw new Error(`Failed to fetch DLOB from ${this.url}`);
+			throw new Error(
+				`Failed to fetch DLOB from ${this.url}. Status: ${r.status}, ${r.statusText}`
+			);
 		}
 
 		const resp = await r.json();

package/src/dlob/DLOBSubscriber.ts

@@ -7,8 +7,18 @@ import {
 	DLOBSubscriptionConfig,
 	SlotSource,
 } from './types';
+import { DriftClient } from '../driftClient';
+import { isVariant, MarketType } from '../types';
+import {
+	getVammL2Generator,
+	L2OrderBook,
+	L2OrderBookGenerator,
+	L3OrderBook,
+} from './orderBookLevels';
+import { calculateAskPrice, calculateBidPrice } from '../math/market';
 
 export class DLOBSubscriber {
+	driftClient: DriftClient;
 	dlobSource: DLOBSource;
 	slotSource: SlotSource;
 	updateFrequency: number;
@@ -17,6 +27,7 @@ export class DLOBSubscriber {
 	public eventEmitter: StrictEventEmitter<EventEmitter, DLOBSubscriberEvents>;
 
 	constructor(config: DLOBSubscriptionConfig) {
+		this.driftClient = config.driftClient;
 		this.dlobSource = config.dlobSource;
 		this.slotSource = config.slotSource;
 		this.updateFrequency = config.updateFrequency;
@@ -48,6 +59,136 @@ export class DLOBSubscriber {
 		return this.dlob;
 	}
 
+	/**
+	 * Get the L2 order book for a given market.
+	 *
+	 * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+	 * @param marketIndex
+	 * @param marketType
+	 * @param depth Number of orders to include in the order book. Defaults to 10.
+	 * @param includeVamm Whether to include the VAMM orders in the order book. Defaults to false. If true, creates vAMM generator {@link getVammL2Generator} and adds it to fallbackL2Generators.
+	 * @param fallbackL2Generators L2 generators for fallback liquidity e.g. vAMM {@link getVammL2Generator}, openbook {@link SerumSubscriber}
+	 */
+	public getL2({
+		marketName,
+		marketIndex,
+		marketType,
+		depth = 10,
+		includeVamm = false,
+		fallbackL2Generators = [],
+	}: {
+		marketName?: string;
+		marketIndex?: number;
+		marketType?: MarketType;
+		depth?: number;
+		includeVamm?: boolean;
+		fallbackL2Generators?: L2OrderBookGenerator[];
+	}): L2OrderBook {
+		if (marketName) {
+			const derivedMarketInfo =
+				this.driftClient.getMarketIndexAndType(marketName);
+			if (!derivedMarketInfo) {
+				throw new Error(`Market ${marketName} not found`);
+			}
+			marketIndex = derivedMarketInfo.marketIndex;
+			marketType = derivedMarketInfo.marketType;
+		} else {
+			if (marketIndex === undefined || marketType === undefined) {
+				throw new Error(
+					'Either marketName or marketIndex and marketType must be provided'
+				);
+			}
+		}
+
+		let oraclePriceData;
+		let fallbackBid;
+		let fallbackAsk;
+		const isPerp = isVariant(marketType, 'perp');
+		if (isPerp) {
+			const perpMarketAccount =
+				this.driftClient.getPerpMarketAccount(marketIndex);
+			oraclePriceData = this.driftClient.getOraclePriceDataAndSlot(
+				perpMarketAccount.amm.oracle
+			);
+			fallbackBid = calculateBidPrice(perpMarketAccount, oraclePriceData);
+			fallbackAsk = calculateAskPrice(perpMarketAccount, oraclePriceData);
+		} else {
+			oraclePriceData =
+				this.driftClient.getOracleDataForSpotMarket(marketIndex);
+		}
+
+		if (isPerp && includeVamm) {
+			fallbackL2Generators = [
+				getVammL2Generator({
+					marketAccount: this.driftClient.getPerpMarketAccount(marketIndex),
+					oraclePriceData,
+					numOrders: depth,
+				}),
+			];
+		}
+
+		return this.dlob.getL2({
+			marketIndex,
+			marketType,
+			depth,
+			oraclePriceData,
+			slot: this.slotSource.getSlot(),
+			fallbackBid,
+			fallbackAsk,
+			fallbackL2Generators: fallbackL2Generators,
+		});
+	}
+
+	/**
+	 * Get the L3 order book for a given market.
+	 *
+	 * @param marketName e.g. "SOL-PERP" or "SOL". If not provided, marketIndex and marketType must be provided.
+	 * @param marketIndex
+	 * @param marketType
+	 */
+	public getL3({
+		marketName,
+		marketIndex,
+		marketType,
+	}: {
+		marketName?: string;
+		marketIndex?: number;
+		marketType?: MarketType;
+	}): L3OrderBook {
+		if (marketName) {
+			const derivedMarketInfo =
+				this.driftClient.getMarketIndexAndType(marketName);
+			if (!derivedMarketInfo) {
+				throw new Error(`Market ${marketName} not found`);
+			}
+			marketIndex = derivedMarketInfo.marketIndex;
+			marketType = derivedMarketInfo.marketType;
+		} else {
+			if (marketIndex === undefined || marketType === undefined) {
+				throw new Error(
+					'Either marketName or marketIndex and marketType must be provided'
+				);
+			}
+		}
+
+		let oraclePriceData;
+		const isPerp = isVariant(marketType, 'perp');
+		if (isPerp) {
+			oraclePriceData =
+				this.driftClient.getOracleDataForPerpMarket(marketIndex);
+		} else {
+			oraclePriceData =
+				this.driftClient.getOracleDataForSpotMarket(marketIndex);
+		}
+
+		return this.dlob.getL3({
+			marketIndex,
+			marketType,
+			oraclePriceData,
+			slot: this.slotSource.getSlot(),
+		});
+	}
+
 	public async unsubscribe(): Promise<void> {
 		if (this.intervalId) {
 			clearInterval(this.intervalId);

package/src/dlob/orderBookLevels.ts

@@ -0,0 +1,243 @@
+import {
+	BASE_PRECISION,
+	BN,
+	calculateAmmReservesAfterSwap,
+	calculateMarketOpenBidAsk,
+	calculateQuoteAssetAmountSwapped,
+	calculateSpreadReserves,
+	calculateUpdatedAMM,
+	DLOBNode,
+	OraclePriceData,
+	PerpMarketAccount,
+	SwapDirection,
+} from '..';
+import { PublicKey } from '@solana/web3.js';
+
+type liquiditySource = 'serum' | 'vamm' | 'dlob';
+
+export type L2Level = {
+	price: BN;
+	size: BN;
+	sources: { [key in liquiditySource]?: BN };
+};
+
+export type L2OrderBook = {
+	asks: L2Level[];
+	bids: L2Level[];
+};
+
+export interface L2OrderBookGenerator {
+	getL2Asks(): Generator<L2Level>;
+	getL2Bids(): Generator<L2Level>;
+}
+
+export type L3Level = {
+	price: BN;
+	size: BN;
+	maker: PublicKey;
+	orderId: number;
+};
+
+export type L3OrderBook = {
+	asks: L3Level[];
+	bids: L3Level[];
+};
+
+/**
+ * Get an {@link Generator<L2Level>} generator from a {@link Generator<DLOBNode>}
+ * @param dlobNodes e.g. {@link DLOB#getMakerLimitAsks} or {@link DLOB#getMakerLimitBids}
+ * @param oraclePriceData
+ * @param slot
+ */
+export function* getL2GeneratorFromDLOBNodes(
+	dlobNodes: Generator<DLOBNode>,
+	oraclePriceData: OraclePriceData,
+	slot: number
+): Generator<L2Level> {
+	for (const dlobNode of dlobNodes) {
+		const size = dlobNode.order.baseAssetAmount.sub(
+			dlobNode.order.baseAssetAmountFilled
+		) as BN;
+		yield {
+			size,
+			price: dlobNode.getPrice(oraclePriceData, slot),
+			sources: {
+				dlob: size,
+			},
+		};
+	}
+}
+
+export function* mergeL2LevelGenerators(
+	l2LevelGenerators: Generator<L2Level>[],
+	compare: (a: L2Level, b: L2Level) => boolean
+): Generator<L2Level> {
+	const generators = l2LevelGenerators.map((generator) => {
+		return {
+			generator,
+			next: generator.next(),
+		};
+	});
+
+	let next;
+	do {
+		next = generators.reduce((best, next) => {
+			if (next.next.done) {
+				return best;
+			}
+
+			if (!best) {
+				return next;
+			}
+
+			if (compare(next.next.value, best.next.value)) {
+				return next;
+			} else {
+				return best;
+			}
+		}, undefined);
+
+		if (next) {
+			yield next.next.value;
+			next.next = next.generator.next();
+		}
+	} while (next !== undefined);
+}
+
+export function createL2Levels(
+	generator: Generator<L2Level>,
+	depth: number
+): L2Level[] {
+	const levels = [];
+	for (const level of generator) {
+		const price = level.price;
+		const size = level.size;
+		if (levels.length > 0 && levels[levels.length - 1].price.eq(price)) {
+			const currentLevel = levels[levels.length - 1];
+			currentLevel.size.add(size);
+			for (const [source, size] of Object.entries(level.sources)) {
+				if (currentLevel.sources[source]) {
+					currentLevel.sources[source] = currentLevel.sources[source].add(size);
+				} else {
+					currentLevel.sources[source] = size;
+				}
+			}
+		} else if (levels.length === depth) {
+			break;
+		} else {
+			levels.push(level);
+		}
+	}
+	return levels;
+}
+
+export function getVammL2Generator({
+	marketAccount,
+	oraclePriceData,
+	numOrders,
+	now,
+}: {
+	marketAccount: PerpMarketAccount;
+	oraclePriceData: OraclePriceData;
+	numOrders: number;
+	now?: BN;
+}): L2OrderBookGenerator {
+	const updatedAmm = calculateUpdatedAMM(marketAccount.amm, oraclePriceData);
+
+	const [openBids, openAsks] = calculateMarketOpenBidAsk(
+		updatedAmm.baseAssetReserve,
+		updatedAmm.minBaseAssetReserve,
+		updatedAmm.maxBaseAssetReserve,
+		updatedAmm.orderStepSize
+	);
+
+	now = now ?? new BN(Date.now() / 1000);
+	const [bidReserves, askReserves] = calculateSpreadReserves(
+		updatedAmm,
+		oraclePriceData,
+		now
+	);
+
+	let numBids = 0;
+	const baseSize = openBids.div(new BN(numOrders));
+	const bidAmm = {
+		baseAssetReserve: bidReserves.baseAssetReserve,
+		quoteAssetReserve: bidReserves.quoteAssetReserve,
+		sqrtK: updatedAmm.sqrtK,
+		pegMultiplier: updatedAmm.pegMultiplier,
+	};
+	const getL2Bids = function* () {
+		while (numBids < numOrders) {
+			const [afterSwapQuoteReserves, afterSwapBaseReserves] =
+				calculateAmmReservesAfterSwap(
+					bidAmm,
+					'base',
+					baseSize,
+					SwapDirection.ADD
+				);
+
+			const quoteSwapped = calculateQuoteAssetAmountSwapped(
+				bidAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
+				bidAmm.pegMultiplier,
+				SwapDirection.ADD
+			);
+
+			const price = quoteSwapped.mul(BASE_PRECISION).div(baseSize);
+
+			bidAmm.baseAssetReserve = afterSwapBaseReserves;
+			bidAmm.quoteAssetReserve = afterSwapQuoteReserves;
+
+			yield {
+				price,
+				size: baseSize,
+				sources: { vamm: baseSize },
+			};
+
+			numBids++;
+		}
+	};
+
+	let numAsks = 0;
+	const askSize = openAsks.abs().div(new BN(numOrders));
+	const askAmm = {
+		baseAssetReserve: askReserves.baseAssetReserve,
+		quoteAssetReserve: askReserves.quoteAssetReserve,
+		sqrtK: updatedAmm.sqrtK,
+		pegMultiplier: updatedAmm.pegMultiplier,
+	};
+	const getL2Asks = function* () {
+		while (numAsks < numOrders) {
+			const [afterSwapQuoteReserves, afterSwapBaseReserves] =
+				calculateAmmReservesAfterSwap(
+					askAmm,
+					'base',
+					askSize,
+					SwapDirection.REMOVE
+				);
+
+			const quoteSwapped = calculateQuoteAssetAmountSwapped(
+				askAmm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
+				askAmm.pegMultiplier,
+				SwapDirection.REMOVE
+			);
+
+			const price = quoteSwapped.mul(BASE_PRECISION).div(askSize);
+
+			askAmm.baseAssetReserve = afterSwapBaseReserves;
+			askAmm.quoteAssetReserve = afterSwapQuoteReserves;
+
+			yield {
+				price,
+				size: askSize,
+				sources: { vamm: baseSize },
+			};
+
+			numAsks++;
+		}
+	};
+
+	return {
+		getL2Bids,
+		getL2Asks,
+	};
+}

package/src/dlob/types.ts

@@ -1,6 +1,8 @@
 import { DLOB } from './DLOB';
+import { DriftClient } from '../driftClient';
 
 export type DLOBSubscriptionConfig = {
+	driftClient: DriftClient;
 	dlobSource: DLOBSource;
 	slotSource: SlotSource;
 	updateFrequency: number;