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

package/src/dlob/DLOB.ts

@@ -12,17 +12,22 @@ import {
 	isVariant,
 	getVariant,
 	Order,
-	ZERO,
 	PRICE_PRECISION,
 	SpotMarketAccount,
 	PerpMarketAccount,
 	OraclePriceData,
 	SlotSubscriber,
-	UserMap,
+	UserMapInterface,
 	MarketTypeStr,
+	StateAccount,
+	isMarketOrder,
+	isLimitOrder,
+	hasLimitPrice,
+	getOptionalLimitPrice,
 } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { DLOBNode, DLOBNodeType, TriggerOrderNode } from '..';
+import { ammPaused, exchangePaused, fillPaused } from '../math/exchangeStatus';
 
 export type MarketNodeLists = {
 	limit: {
@@ -59,11 +64,13 @@ type Side = 'ask' | 'bid' | 'both' | 'nocross';
 export class DLOB {
 	openOrders = new Map<MarketTypeStr, Set<string>>();
 	orderLists = new Map<MarketTypeStr, Map<number, MarketNodeLists>>();
+	stateAccount: StateAccount;
 	marketIndexToAccount = new Map<
 		MarketTypeStr,
 		Map<number, PerpMarketAccount | SpotMarketAccount>
 	>();
 
+	userMap: UserMapInterface;
 	silent = false;
 	initialized = false;
 
@@ -71,13 +78,18 @@ export class DLOB {
 	 *
 	 * @param perpMarkets The perp markets to maintain a DLOB for
 	 * @param spotMarkets The spot markets to maintain a DLOB for
+	 * @param userMap map of all users
 	 * @param silent set to true to prevent logging on inserts and removals
 	 */
 	public constructor(
 		perpMarkets: PerpMarketAccount[],
 		spotMarkets: SpotMarketAccount[],
+		stateAccount: StateAccount,
+		userMap: UserMapInterface,
 		silent?: boolean
 	) {
+		this.stateAccount = stateAccount;
+		this.userMap = userMap;
 		this.silent = silent;
 
 		this.openOrders.set('perp', new Set<string>());
@@ -135,39 +147,49 @@ export class DLOB {
 		}
 	}
 
+	public clear() {
+		for (const marketType of this.openOrders.keys()) {
+			this.openOrders.get(marketType).clear();
+		}
+		this.openOrders.clear();
+
+		for (const marketType of this.orderLists.keys()) {
+			for (const marketIndex of this.orderLists.get(marketType).keys()) {
+				const marketNodeLists = this.orderLists
+					.get(marketType)
+					.get(marketIndex);
+				for (const side of Object.keys(marketNodeLists)) {
+					for (const orderType of Object.keys(marketNodeLists[side])) {
+						marketNodeLists[side][orderType].clear();
+					}
+				}
+			}
+		}
+		this.orderLists.clear();
+
+		for (const marketType of this.marketIndexToAccount.keys()) {
+			this.marketIndexToAccount.get(marketType).clear();
+		}
+		this.marketIndexToAccount.clear();
+	}
+
 	/**
 	 * initializes a new DLOB instance
 	 *
-	 * @param clearingHouse The ClearingHouse instance to use for price data
 	 * @returns a promise that resolves when the DLOB is initialized
 	 */
-	public async init(
-		clearingHouse: ClearingHouse,
-		userMap?: UserMap
-	): Promise<boolean> {
+	public async init(): Promise<boolean> {
 		if (this.initialized) {
 			return false;
 		}
-		if (userMap) {
-			// initialize the dlob with the user map (prevents hitting getProgramAccounts)
-			for (const user of userMap.values()) {
-				const userAccount = user.getUserAccount();
-				const userAccountPubkey = user.getUserAccountPublicKey();
 
-				for (const order of userAccount.orders) {
-					this.insertOrder(order, userAccountPubkey);
-				}
-			}
-		} else {
-			const programAccounts = await clearingHouse.program.account.user.all();
-			for (const programAccount of programAccounts) {
-				// @ts-ignore
-				const userAccount: UserAccount = programAccount.account;
-				const userAccountPublicKey = programAccount.publicKey;
-
-				for (const order of userAccount.orders) {
-					this.insertOrder(order, userAccountPublicKey);
-				}
+		// initialize the dlob with the user map (prevents hitting getProgramAccounts)
+		for (const user of this.userMap.values()) {
+			const userAccount = user.getUserAccount();
+			const userAccountPubkey = user.getUserAccountPublicKey();
+
+			for (const order of userAccount.orders) {
+				this.insertOrder(order, userAccountPubkey);
 			}
 		}
 
@@ -239,7 +261,7 @@ export class DLOB {
 			type = 'trigger';
 		} else if (isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
 			type = 'market';
-		} else if (!order.oraclePriceOffset.eq(ZERO)) {
+		} else if (order.oraclePriceOffset !== 0) {
 			type = 'floatingLimit';
 		} else {
 			type = 'limit';
@@ -265,12 +287,21 @@ export class DLOB {
 
 	public findNodesToFill(
 		marketIndex: number,
-		vBid: BN | undefined,
-		vAsk: BN | undefined,
+		fallbackBid: BN | undefined,
+		fallbackAsk: BN | undefined,
 		slot: number,
+		ts: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData
 	): NodeToFill[] {
+		const marketAccount = this.marketIndexToAccount
+			.get(getVariant(marketType) as MarketTypeStr)
+			.get(marketIndex);
+
+		if (fillPaused(this.stateAccount, marketAccount)) {
+			return [];
+		}
+
 		// Find all the crossing nodes
 		const crossingNodesToFill: Array<NodeToFill> = this.findCrossingNodesToFill(
 			marketIndex,
@@ -279,25 +310,27 @@ export class DLOB {
 			oraclePriceData
 		);
 
-		const vAMMCrossingNodesToFill: Array<NodeToFill> =
-			this.findvAMMCrossingNodesToFill(
+		let fallbackCrossingNodesToFill = new Array<NodeToFill>();
+		if (!ammPaused(this.stateAccount, marketAccount)) {
+			fallbackCrossingNodesToFill = this.findFallbackCrossingNodesToFill(
 				marketIndex,
-				vBid,
-				vAsk,
+				fallbackBid,
+				fallbackAsk,
 				slot,
 				marketType,
 				oraclePriceData
 			);
+		}
 
 		// get expired market nodes
-		const marketNodesToFill = this.findExpiredMarketNodesToFill(
+		const expiredNodesToFill = this.findExpiredNodesToFill(
 			marketIndex,
-			slot,
+			ts,
 			marketType
 		);
 		return crossingNodesToFill.concat(
-			vAMMCrossingNodesToFill,
-			marketNodesToFill
+			fallbackCrossingNodesToFill,
+			expiredNodesToFill
 		);
 	}
 
@@ -357,10 +390,10 @@ export class DLOB {
 		return nodesToFill;
 	}
 
-	public findvAMMCrossingNodesToFill(
+	public findFallbackCrossingNodesToFill(
 		marketIndex: number,
-		vBid: BN,
-		vAsk: BN,
+		fallbackBid: BN,
+		fallbackAsk: BN,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData
@@ -385,35 +418,67 @@ export class DLOB {
 		let nextAsk = askGenerator.next();
 		let nextBid = bidGenerator.next();
 
-		// check for asks that cross vBid
-		while (!nextAsk.done) {
+		// check for asks that cross fallbackBid
+		while (!nextAsk.done && fallbackBid !== undefined) {
 			const askNode = nextAsk.value;
-			const askPrice = askNode.getPrice(oraclePriceData, slot);
 
-			if (askPrice.lte(vBid) && isAuctionComplete(askNode.order, slot)) {
+			if (isVariant(marketType, 'spot') && askNode.order?.postOnly) {
+				nextAsk = askGenerator.next();
+				continue;
+			}
+
+			const askLimitPrice = getOptionalLimitPrice(
+				askNode.order,
+				oraclePriceData,
+				slot
+			);
+
+			// order crosses if there is no limit price or it crosses fallback price
+			const crosses =
+				askLimitPrice === undefined || askLimitPrice.lte(fallbackBid);
+
+			// fallback is available if auction is complete or it's a spot order
+			const fallbackAvailable =
+				isVariant(marketType, 'spot') || isAuctionComplete(askNode.order, slot);
+
+			if (crosses && fallbackAvailable) {
 				nodesToFill.push({
 					node: askNode,
-					makerNode: undefined, // filled by vAMM
+					makerNode: undefined, // filled by fallback
 				});
-			} else {
-				break;
 			}
 
 			nextAsk = askGenerator.next();
 		}
 
-		// check for bids that cross vAsk
-		while (!nextBid.done) {
+		// check for bids that cross fallbackAsk
+		while (!nextBid.done && fallbackAsk !== undefined) {
 			const bidNode = nextBid.value;
-			const bidPrice = bidNode.getPrice(oraclePriceData, slot);
 
-			if (bidPrice.gte(vAsk) && isAuctionComplete(bidNode.order, slot)) {
+			if (isVariant(marketType, 'spot') && bidNode.order?.postOnly) {
+				nextBid = bidGenerator.next();
+				continue;
+			}
+
+			const bidLimitPrice = getOptionalLimitPrice(
+				bidNode.order,
+				oraclePriceData,
+				slot
+			);
+
+			// order crosses if there is no limit price or it crosses fallback price
+			const crosses =
+				bidLimitPrice === undefined || bidLimitPrice.gte(fallbackAsk);
+
+			// fallback is available if auction is complete or it's a spot order
+			const fallbackAvailable =
+				isVariant(marketType, 'spot') || isAuctionComplete(bidNode.order, slot);
+
+			if (crosses && fallbackAvailable) {
 				nodesToFill.push({
 					node: bidNode,
-					makerNode: undefined, // filled by vAMM
+					makerNode: undefined, // filled by fallback
 				});
-			} else {
-				break;
 			}
 
 			nextBid = bidGenerator.next();
@@ -422,28 +487,48 @@ export class DLOB {
 		return nodesToFill;
 	}
 
-	public findExpiredMarketNodesToFill(
+	public findExpiredNodesToFill(
 		marketIndex: number,
-		slot: number,
+		ts: number,
 		marketType: MarketType
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
-		// Then see if there are orders to fill against vamm
-		for (const marketBid of this.getMarketBids(marketIndex, marketType)) {
-			if (isOrderExpired(marketBid.order, slot)) {
-				nodesToFill.push({
-					node: marketBid,
-				});
+
+		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
+		const nodeLists = this.orderLists.get(marketTypeStr).get(marketIndex);
+
+		// All bids/asks that can expire
+		const bidGenerators = [
+			nodeLists.limit.bid.getGenerator(),
+			nodeLists.floatingLimit.bid.getGenerator(),
+			nodeLists.market.bid.getGenerator(),
+		];
+		const askGenerators = [
+			nodeLists.limit.ask.getGenerator(),
+			nodeLists.floatingLimit.ask.getGenerator(),
+			nodeLists.market.ask.getGenerator(),
+		];
+
+		for (const bidGenerator of bidGenerators) {
+			for (const bid of bidGenerator) {
+				if (isOrderExpired(bid.order, ts)) {
+					nodesToFill.push({
+						node: bid,
+					});
+				}
 			}
 		}
 
-		for (const marketAsk of this.getMarketAsks(marketIndex, marketType)) {
-			if (isOrderExpired(marketAsk.order, slot)) {
-				nodesToFill.push({
-					node: marketAsk,
-				});
+		for (const askGenerator of askGenerators) {
+			for (const ask of askGenerator) {
+				if (isOrderExpired(ask.order, ts)) {
+					nodesToFill.push({
+						node: ask,
+					});
+				}
 			}
 		}
+
 		return nodesToFill;
 	}
 
@@ -496,7 +581,7 @@ export class DLOB {
 
 	*getAsks(
 		marketIndex: number,
-		vAsk: BN | undefined,
+		fallbackAsk: BN | undefined,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData
@@ -513,8 +598,11 @@ export class DLOB {
 			nodeLists.market.ask.getGenerator(),
 		];
 
-		if (marketTypeStr === 'perp' && vAsk) {
-			generatorList.push(getVammNodeGenerator(vAsk));
+		if (marketTypeStr === 'perp' && fallbackAsk) {
+			generatorList.push(getVammNodeGenerator(fallbackAsk));
+		}
+		if (generatorList.length === 0) {
+			throw new Error('No ask generators found');
 		}
 
 		const askGenerators = generatorList.map((generator) => {
@@ -558,6 +646,20 @@ export class DLOB {
 					continue;
 				}
 
+				// skip order if user is being liquidated/bankrupt
+				if (bestGenerator.next.value.userAccount !== undefined) {
+					const user = this.userMap.get(
+						bestGenerator.next.value.userAccount.toString()
+					);
+					if (
+						user?.getUserAccount().isBeingLiquidated ||
+						user?.getUserAccount().isBankrupt
+					) {
+						bestGenerator.next = bestGenerator.generator.next();
+						continue;
+					}
+				}
+
 				yield bestGenerator.next.value;
 				bestGenerator.next = bestGenerator.generator.next();
 			} else {
@@ -568,7 +670,7 @@ export class DLOB {
 
 	*getBids(
 		marketIndex: number,
-		vBid: BN | undefined,
+		fallbackBid: BN | undefined,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData
@@ -585,9 +687,13 @@ export class DLOB {
 			nodeLists.floatingLimit.bid.getGenerator(),
 			nodeLists.market.bid.getGenerator(),
 		];
-		if (marketTypeStr === 'perp' && vBid) {
-			generatorList.push(getVammNodeGenerator(vBid));
+		if (marketTypeStr === 'perp' && fallbackBid) {
+			generatorList.push(getVammNodeGenerator(fallbackBid));
 		}
+		if (generatorList.length === 0) {
+			throw new Error('No bid generators found');
+		}
+
 		const bidGenerators = generatorList.map((generator) => {
 			return {
 				next: generator.next(),
@@ -595,7 +701,7 @@ export class DLOB {
 			};
 		});
 
-		let bidsExhausted = false; // there will always be the vBid
+		let bidsExhausted = false; // there will always be the fallbackBid
 		while (!bidsExhausted) {
 			const bestGenerator = bidGenerators.reduce(
 				(bestGenerator, currentGenerator) => {
@@ -629,6 +735,20 @@ export class DLOB {
 					continue;
 				}
 
+				// skip order if user is being liquidated/bankrupt
+				if (bestGenerator.next.value.userAccount !== undefined) {
+					const user = this.userMap.get(
+						bestGenerator.next.value.userAccount.toString()
+					);
+					if (
+						user?.getUserAccount().isBeingLiquidated ||
+						user?.getUserAccount().isBankrupt
+					) {
+						bestGenerator.next = bestGenerator.generator.next();
+						continue;
+					}
+				}
+
 				yield bestGenerator.next.value;
 				bestGenerator.next = bestGenerator.generator.next();
 			} else {
@@ -660,9 +780,16 @@ export class DLOB {
 		const bidOrder = bidNode.order;
 		const askOrder = askNode.order;
 
-		// Can't match two maker orders or if maker and taker are the same
-		const makerIsTaker = bidNode.userAccount.equals(askNode.userAccount);
-		if (makerIsTaker || (bidOrder.postOnly && askOrder.postOnly)) {
+		const bidUserAuthority = this.userMap.getUserAuthority(
+			bidNode.userAccount.toString()
+		);
+		const askUserAuthority = this.userMap.getUserAuthority(
+			askNode.userAccount.toString()
+		);
+
+		// Can't match orders from the same authority
+		const sameAuthority = bidUserAuthority.equals(askUserAuthority);
+		if (sameAuthority || (bidOrder.postOnly && askOrder.postOnly)) {
 			// don't have a principle way to pick which one to exhaust,
 			// exhaust each one 50% of the time so we can try each one against other orders
 			const exhaustedSide = Math.random() < 0.5 ? 'bid' : 'ask';
@@ -672,6 +799,19 @@ export class DLOB {
 			};
 		}
 
+		const { takerNode, makerNode, makerSide } = this.determineMakerAndTaker(
+			askNode,
+			bidNode
+		);
+
+		// If order doesn't have limit price, cant be maker
+		if (!hasLimitPrice(makerNode.order, slot)) {
+			return {
+				crossingNodes: [],
+				exhaustedSide: makerSide,
+			};
+		}
+
 		const bidBaseRemaining = bidOrder.baseAssetAmount.sub(
 			bidOrder.baseAssetAmountFilled
 		);
@@ -744,68 +884,92 @@ export class DLOB {
 			);
 		}
 
-		// Bid is maker
-		if (bidOrder.postOnly) {
-			return {
-				crossingNodes: [
-					{
-						node: askNode,
-						makerNode: bidNode,
-					},
-				],
-				exhaustedSide,
-			};
-		}
-
-		// Ask is maker
-		if (askOrder.postOnly) {
-			return {
-				crossingNodes: [
-					{
-						node: bidNode,
-						makerNode: askNode,
-					},
-				],
-				exhaustedSide,
-			};
-		}
-
-		// Both are takers
-		// older order is maker
-		const [olderNode, newerNode] = askOrder.ts.lt(bidOrder.ts)
-			? [askNode, bidNode]
-			: [bidNode, askNode];
 		return {
 			crossingNodes: [
 				{
-					node: newerNode,
-					makerNode: olderNode,
+					node: takerNode,
+					makerNode: makerNode,
 				},
 			],
 			exhaustedSide,
 		};
 	}
 
+	determineMakerAndTaker(
+		askNode: DLOBNode,
+		bidNode: DLOBNode
+	): { takerNode: DLOBNode; makerNode: DLOBNode; makerSide: Side } {
+		if (bidNode.order.postOnly) {
+			return {
+				takerNode: askNode,
+				makerNode: bidNode,
+				makerSide: 'bid',
+			};
+		} else if (askNode.order.postOnly) {
+			return {
+				takerNode: bidNode,
+				makerNode: askNode,
+				makerSide: 'ask',
+			};
+		} else if (isMarketOrder(bidNode.order) && isLimitOrder(askNode.order)) {
+			return {
+				takerNode: bidNode,
+				makerNode: askNode,
+				makerSide: 'ask',
+			};
+		} else if (isMarketOrder(askNode.order) && isLimitOrder(bidNode.order)) {
+			return {
+				takerNode: askNode,
+				makerNode: bidNode,
+				makerSide: 'bid',
+			};
+		} else if (askNode.order.slot.lt(bidNode.order.slot)) {
+			return {
+				takerNode: bidNode,
+				makerNode: askNode,
+				makerSide: 'ask',
+			};
+		} else {
+			return {
+				takerNode: askNode,
+				makerNode: bidNode,
+				makerSide: 'bid',
+			};
+		}
+	}
+
 	public getBestAsk(
 		marketIndex: number,
-		vAsk: BN | undefined,
+		fallbackAsk: BN | undefined,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData
 	): BN {
-		return this.getAsks(marketIndex, vAsk, slot, marketType, oraclePriceData)
+		return this.getAsks(
+			marketIndex,
+			fallbackAsk,
+			slot,
+			marketType,
+			oraclePriceData
+		)
 			.next()
 			.value.getPrice(oraclePriceData, slot);
 	}
 
 	public getBestBid(
 		marketIndex: number,
-		vBid: BN | undefined,
+		fallbackBid: BN | undefined,
 		slot: number,
 		marketType: MarketType,
 		oraclePriceData: OraclePriceData
 	): BN {
-		return this.getBids(marketIndex, vBid, slot, marketType, oraclePriceData)
+		return this.getBids(
+			marketIndex,
+			fallbackBid,
+			slot,
+			marketType,
+			oraclePriceData
+		)
 			.next()
 			.value.getPrice(oraclePriceData, slot);
 	}
@@ -816,6 +980,10 @@ export class DLOB {
 		oraclePrice: BN,
 		marketType: MarketType
 	): NodeToTrigger[] {
+		if (exchangePaused(this.stateAccount)) {
+			return [];
+		}
+
 		const nodesToTrigger = [];
 		const marketTypeStr = getVariant(marketType) as MarketTypeStr;
 		for (const node of this.orderLists
@@ -862,20 +1030,21 @@ export class DLOB {
 			const market = clearingHouse.getPerpMarketAccount(marketIndex);
 
 			const slot = slotSubscriber.getSlot();
-			const oraclePriceData = clearingHouse.getOracleDataForMarket(marketIndex);
-			const vAsk = calculateAskPrice(market, oraclePriceData);
-			const vBid = calculateBidPrice(market, oraclePriceData);
+			const oraclePriceData =
+				clearingHouse.getOracleDataForPerpMarket(marketIndex);
+			const fallbackAsk = calculateAskPrice(market, oraclePriceData);
+			const fallbackBid = calculateBidPrice(market, oraclePriceData);
 
 			const bestAsk = this.getBestAsk(
 				marketIndex,
-				vAsk,
+				fallbackAsk,
 				slot,
 				marketType,
 				oraclePriceData
 			);
 			const bestBid = this.getBestBid(
 				marketIndex,
-				vBid,
+				fallbackBid,
 				slot,
 				marketType,
 				oraclePriceData
@@ -907,7 +1076,8 @@ export class DLOB {
 			);
 		} else if (isVariant(marketType, 'spot')) {
 			const slot = slotSubscriber.getSlot();
-			const oraclePriceData = clearingHouse.getOracleDataForMarket(marketIndex);
+			const oraclePriceData =
+				clearingHouse.getOracleDataForPerpMarket(marketIndex);
 
 			const bestAsk = this.getBestAsk(
 				marketIndex,

package/src/dlob/DLOBNode.ts

@@ -1,5 +1,4 @@
 import {
-	isOneOfVariant,
 	AMM_RESERVE_PRECISION,
 	BN,
 	convertToNumber,
@@ -74,18 +73,7 @@ export abstract class OrderNode implements DLOBNode {
 	}
 
 	getPrice(oraclePriceData: OraclePriceData, slot: number): BN {
-		if (isOneOfVariant(this.order.marketType, ['spot'])) {
-			return getLimitPrice(this.order, oraclePriceData, slot);
-		} else if (isOneOfVariant(this.order.marketType, ['perp'])) {
-			return getLimitPrice(
-				this.order,
-				oraclePriceData,
-				slot,
-				this.market as PerpMarketAccount
-			);
-		} else {
-			console.error(`Unknown market type: ${this.order.marketType}`);
-		}
+		return getLimitPrice(this.order, oraclePriceData, slot);
 	}
 
 	isBaseFilled(): boolean {
@@ -111,7 +99,7 @@ export class FloatingLimitOrderNode extends OrderNode {
 	previous?: FloatingLimitOrderNode;
 
 	getSortValue(order: Order): BN {
-		return order.oraclePriceOffset;
+		return new BN(order.oraclePriceOffset);
 	}
 }