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

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;