@drift-labs/sdk 2.65.0-beta.0 → 2.65.0-beta.10

package/src/constants/spotMarkets.ts

@@ -137,6 +137,9 @@ export const MainnetSpotMarkets: SpotMarketConfig[] = [
 		precision: new BN(10).pow(NINE),
 		precisionExp: NINE,
 		serumMarket: new PublicKey('DkbVbMhFxswS32xnn1K2UY4aoBugXooBTxdzkWWDWRkH'),
+		phoenixMarket: new PublicKey(
+			'5LQLfGtqcC5rm2WuGxJf4tjqYmDjsQAbKo2AMLQ8KB7p'
+		),
 	},
 	{
 		symbol: 'PYTH',

package/src/dlob/orderBookLevels.ts

@@ -7,6 +7,7 @@ import {
 	calculateSpreadReserves,
 	calculateUpdatedAMM,
 	DLOBNode,
+	isVariant,
 	OraclePriceData,
 	PerpMarketAccount,
 	PositionDirection,
@@ -492,6 +493,19 @@ export function uncrossL2(
 
 	let bidIndex = 0;
 	let askIndex = 0;
+	let maxBid: BN;
+	let minAsk: BN;
+
+	const getPriceAndSetBound = (newPrice: BN, direction: PositionDirection) => {
+		if (isVariant(direction, 'long')) {
+			maxBid = maxBid ? BN.min(maxBid, newPrice) : newPrice;
+			return maxBid;
+		} else {
+			minAsk = minAsk ? BN.max(minAsk, newPrice) : newPrice;
+			return minAsk;
+		}
+	};
+
 	while (bidIndex < bids.length || askIndex < asks.length) {
 		const nextBid = cloneL2Level(bids[bidIndex]);
 		const nextAsk = cloneL2Level(asks[askIndex]);
@@ -508,7 +522,7 @@ export function uncrossL2(
 			continue;
 		}
 
-		if (nextBid.price.gt(nextAsk.price)) {
+		if (nextBid.price.gte(nextAsk.price)) {
 			if (userBids.has(nextBid.price.toString())) {
 				newBids.push(nextBid);
 				bidIndex++;
@@ -525,29 +539,51 @@ export function uncrossL2(
 				nextBid.price.gt(referencePrice) &&
 				nextAsk.price.gt(referencePrice)
 			) {
-				const newBidPrice = nextAsk.price.sub(grouping);
+				let newBidPrice = nextAsk.price.sub(grouping);
+				newBidPrice = getPriceAndSetBound(newBidPrice, PositionDirection.LONG);
 				updateLevels(newBidPrice, nextBid, newBids);
 				bidIndex++;
 			} else if (
 				nextAsk.price.lt(referencePrice) &&
 				nextBid.price.lt(referencePrice)
 			) {
-				const newAskPrice = nextBid.price.add(grouping);
+				let newAskPrice = nextBid.price.add(grouping);
+				newAskPrice = getPriceAndSetBound(newAskPrice, PositionDirection.SHORT);
 				updateLevels(newAskPrice, nextAsk, newAsks);
 				askIndex++;
 			} else {
-				const newBidPrice = referencePrice.sub(grouping);
-				const newAskPrice = referencePrice.add(grouping);
+				let newBidPrice = referencePrice.sub(grouping);
+				let newAskPrice = referencePrice.add(grouping);
+
+				newBidPrice = getPriceAndSetBound(newBidPrice, PositionDirection.LONG);
+				newAskPrice = getPriceAndSetBound(newAskPrice, PositionDirection.SHORT);
+
 				updateLevels(newBidPrice, nextBid, newBids);
 				updateLevels(newAskPrice, nextAsk, newAsks);
 				bidIndex++;
 				askIndex++;
 			}
 		} else {
-			newAsks.push(nextAsk);
+			if (minAsk && nextAsk.price.lte(minAsk)) {
+				const newAskPrice = getPriceAndSetBound(
+					nextAsk.price,
+					PositionDirection.SHORT
+				);
+				updateLevels(newAskPrice, nextAsk, newAsks);
+			} else {
+				newAsks.push(nextAsk);
+			}
 			askIndex++;
 
-			newBids.push(nextBid);
+			if (maxBid && nextBid.price.gte(maxBid)) {
+				const newBidPrice = getPriceAndSetBound(
+					nextBid.price,
+					PositionDirection.LONG
+				);
+				updateLevels(newBidPrice, nextBid, newBids);
+			} else {
+				newBids.push(nextBid);
+			}
 			bidIndex++;
 		}
 	}

package/src/driftClient.ts

@@ -693,25 +693,36 @@ export class DriftClient {
 				);
 			}
 		} else {
-			const userAccounts =
-				(await this.getUserAccountsForAuthority(this.wallet.publicKey)) ?? [];
+			let userAccounts = [];
 			let delegatedAccounts = [];
 
+			const userAccountsPromise = this.getUserAccountsForAuthority(
+				this.wallet.publicKey
+			);
+
 			if (this.includeDelegates) {
-				delegatedAccounts =
-					(await this.getUserAccountsForDelegate(this.wallet.publicKey)) ?? [];
-			}
+				const delegatedAccountsPromise = this.getUserAccountsForDelegate(
+					this.wallet.publicKey
+				);
+				[userAccounts, delegatedAccounts] = await Promise.all([
+					userAccountsPromise,
+					delegatedAccountsPromise,
+				]);
 
-			for (const account of userAccounts.concat(delegatedAccounts)) {
-				result =
-					result &&
-					(await this.addUser(
-						account.subAccountId,
-						account.authority,
-						account
-					));
+				!userAccounts && (userAccounts = []);
+				!delegatedAccounts && (delegatedAccounts = []);
+			} else {
+				userAccounts = (await userAccountsPromise) ?? [];
 			}
 
+			const allAccounts = userAccounts.concat(delegatedAccounts);
+			const addAllAccountsPromise = allAccounts.map((acc) =>
+				this.addUser(acc.subAccountId, acc.authority, acc)
+			);
+
+			const addAllAccountsResults = await Promise.all(addAllAccountsPromise);
+			result = addAllAccountsResults.every((res) => !!res);
+
 			if (this.activeSubAccountId == undefined) {
 				this.switchActiveUser(
 					userAccounts.concat(delegatedAccounts)[0]?.subAccountId ?? 0,

package/src/jupiter/jupiterClient.ts

@@ -305,9 +305,14 @@ export class JupiterClient {
 			onlyDirectRoutes: onlyDirectRoutes.toString(),
 			maxAccounts: maxAccounts.toString(),
 			...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
-		}).toString();
-		const quote = await (await fetch(`${this.url}/v6/quote?${params}`)).json();
-		return quote;
+		});
+		if (swapMode === 'ExactOut') {
+			params.delete('maxAccounts');
+		}
+		const quote = await (
+			await fetch(`${this.url}/v6/quote?${params.toString()}`)
+		).json();
+		return quote as QuoteResponse;
 	}
 
 	/**

package/src/userMap/userMap.ts

@@ -13,9 +13,10 @@ import {
 	LPRecord,
 	StateAccount,
 	DLOB,
-	OneShotUserAccountSubscriber,
 	BN,
 	UserSubscriptionConfig,
+	DataAndSlot,
+	OneShotUserAccountSubscriber,
 } from '..';
 
 import {
@@ -37,17 +38,33 @@ import { decodeUser } from '../decode/user';
 export interface UserMapInterface {
 	subscribe(): Promise<void>;
 	unsubscribe(): Promise<void>;
-	addPubkey(userAccountPublicKey: PublicKey): Promise<void>;
+	addPubkey(
+		userAccountPublicKey: PublicKey,
+		userAccount?: UserAccount,
+		slot?: number,
+		accountSubscription?: UserSubscriptionConfig
+	): Promise<void>;
 	has(key: string): boolean;
 	get(key: string): User | undefined;
-	mustGet(key: string): Promise<User>;
+	getWithSlot(key: string): DataAndSlot<User> | undefined;
+	mustGet(
+		key: string,
+		accountSubscription?: UserSubscriptionConfig
+	): Promise<User>;
+	mustGetWithSlot(
+		key: string,
+		accountSubscription?: UserSubscriptionConfig
+	): Promise<DataAndSlot<User>>;
 	getUserAuthority(key: string): PublicKey | undefined;
 	updateWithOrderRecord(record: OrderRecord): Promise<void>;
 	values(): IterableIterator<User>;
+	valuesWithSlot(): IterableIterator<DataAndSlot<User>>;
+	entries(): IterableIterator<[string, User]>;
+	entriesWithSlot(): IterableIterator<[string, DataAndSlot<User>]>;
 }
 
 export class UserMap implements UserMapInterface {
-	private userMap = new Map<string, User>();
+	private userMap = new Map<string, DataAndSlot<User>>();
 	driftClient: DriftClient;
 	private connection: Connection;
 	private commitment: Commitment;
@@ -140,6 +157,7 @@ export class UserMap implements UserMapInterface {
 			userAccountPublicKey,
 			accountSubscription: accountSubscription ?? {
 				type: 'custom',
+				// OneShotUserAccountSubscriber used here so we don't load up the RPC with AccountSubscribes
 				userAccountSubscriber: new OneShotUserAccountSubscriber(
 					this.driftClient.program,
 					userAccountPublicKey,
@@ -150,7 +168,10 @@ export class UserMap implements UserMapInterface {
 			},
 		});
 		await user.subscribe(userAccount);
-		this.userMap.set(userAccountPublicKey.toString(), user);
+		this.userMap.set(userAccountPublicKey.toString(), {
+			data: user,
+			slot: slot ?? user.getUserAccountAndSlot()?.slot,
+		});
 	}
 
 	public has(key: string): boolean {
@@ -163,6 +184,9 @@ export class UserMap implements UserMapInterface {
 	 * @returns user User | undefined
 	 */
 	public get(key: string): User | undefined {
+		return this.userMap.get(key)?.data;
+	}
+	public getWithSlot(key: string): DataAndSlot<User> | undefined {
 		return this.userMap.get(key);
 	}
 
@@ -183,8 +207,21 @@ export class UserMap implements UserMapInterface {
 				accountSubscription
 			);
 		}
-		const user = this.userMap.get(key);
-		return user;
+		return this.userMap.get(key).data;
+	}
+	public async mustGetWithSlot(
+		key: string,
+		accountSubscription?: UserSubscriptionConfig
+	): Promise<DataAndSlot<User>> {
+		if (!this.has(key)) {
+			await this.addPubkey(
+				new PublicKey(key),
+				undefined,
+				undefined,
+				accountSubscription
+			);
+		}
+		return this.userMap.get(key);
 	}
 
 	/**
@@ -193,11 +230,11 @@ export class UserMap implements UserMapInterface {
 	 * @returns authority PublicKey | undefined
 	 */
 	public getUserAuthority(key: string): PublicKey | undefined {
-		const chUser = this.userMap.get(key);
-		if (!chUser) {
+		const user = this.userMap.get(key);
+		if (!user) {
 			return undefined;
 		}
-		return chUser.getUserAccount().authority;
+		return user.data.getUserAccount().authority;
 	}
 
 	/**
@@ -253,10 +290,24 @@ export class UserMap implements UserMapInterface {
 		}
 	}
 
-	public values(): IterableIterator<User> {
+	public *values(): IterableIterator<User> {
+		for (const dataAndSlot of this.userMap.values()) {
+			yield dataAndSlot.data;
+		}
+	}
+	public valuesWithSlot(): IterableIterator<DataAndSlot<User>> {
 		return this.userMap.values();
 	}
 
+	public *entries(): IterableIterator<[string, User]> {
+		for (const [key, dataAndSlot] of this.userMap.entries()) {
+			yield [key, dataAndSlot.data];
+		}
+	}
+	public entriesWithSlot(): IterableIterator<[string, DataAndSlot<User>]> {
+		return this.userMap.entries();
+	}
+
 	public size(): number {
 		return this.userMap.size;
 	}
@@ -269,15 +320,13 @@ export class UserMap implements UserMapInterface {
 	public getUniqueAuthorities(
 		filterCriteria?: UserFilterCriteria
 	): PublicKey[] {
-		const usersMeetingCriteria = Array.from(this.userMap.values()).filter(
-			(user) => {
-				let pass = true;
-				if (filterCriteria && filterCriteria.hasOpenOrders) {
-					pass = pass && user.getUserAccount().hasOpenOrder;
-				}
-				return pass;
+		const usersMeetingCriteria = Array.from(this.values()).filter((user) => {
+			let pass = true;
+			if (filterCriteria && filterCriteria.hasOpenOrders) {
+				pass = pass && user.getUserAccount().hasOpenOrder;
 			}
-		);
+			return pass;
+		});
 		const userAuths = new Set(
 			usersMeetingCriteria.map((user) =>
 				user.getUserAccount().authority.toBase58()
@@ -345,17 +394,17 @@ export class UserMap implements UserMapInterface {
 			for (const [key, buffer] of programAccountBufferMap.entries()) {
 				if (!this.has(key)) {
 					const userAccount = this.decode('User', buffer);
-					await this.addPubkey(new PublicKey(key), userAccount);
-					this.userMap.get(key).accountSubscriber.updateData(userAccount, slot);
+					await this.addPubkey(new PublicKey(key), userAccount, slot);
+					this.get(key).accountSubscriber.updateData(userAccount, slot);
 				} else {
 					const userAccount = this.decode('User', buffer);
-					this.userMap.get(key).accountSubscriber.updateData(userAccount, slot);
+					this.get(key).accountSubscriber.updateData(userAccount, slot);
 				}
 				// give event loop a chance to breathe
 				await new Promise((resolve) => setTimeout(resolve, 0));
 			}
 
-			for (const [key, user] of this.userMap.entries()) {
+			for (const [key, user] of this.entries()) {
 				if (!programAccountBufferMap.has(key)) {
 					await user.unsubscribe();
 					this.userMap.delete(key);
@@ -375,7 +424,7 @@ export class UserMap implements UserMapInterface {
 	public async unsubscribe() {
 		await this.subscription.unsubscribe();
 
-		for (const [key, user] of this.userMap.entries()) {
+		for (const [key, user] of this.entries()) {
 			await user.unsubscribe();
 			this.userMap.delete(key);
 		}
@@ -398,11 +447,15 @@ export class UserMap implements UserMapInterface {
 		slot: number
 	) {
 		this.updateLatestSlot(slot);
-		if (!this.userMap.has(key)) {
+		if (!this.has(key)) {
 			this.addPubkey(new PublicKey(key), userAccount, slot);
 		} else {
-			const user = this.userMap.get(key);
+			const user = this.get(key);
 			user.accountSubscriber.updateData(userAccount, slot);
+			this.userMap.set(key, {
+				data: user,
+				slot,
+			});
 		}
 	}
 

package/tests/dlob/test.ts

@@ -24,11 +24,32 @@ import {
 	QUOTE_PRECISION,
 	isVariant,
 	uncrossL2,
+	L2Level,
 } from '../../src';
 
 import { mockPerpMarkets, mockSpotMarkets, mockStateAccount } from './helpers';
 import { DLOBOrdersCoder } from '../../src/dlob/DLOBOrders';
 
+// Returns true if asks are sorted ascending
+const asksAreSortedAsc = (asks: L2Level[]) => {
+	return asks.every((ask, i) => {
+		if (i === 0) {
+			return true;
+		}
+		return ask.price.gt(asks[i - 1].price);
+	});
+};
+
+// Returns true if asks are sorted descending
+const bidsAreSortedDesc = (bids: L2Level[]) => {
+	return bids.every((bid, i) => {
+		if (i === 0) {
+			return true;
+		}
+		return bid.price.lt(bids[i - 1].price);
+	});
+};
+
 function insertOrderToDLOB(
 	dlob: DLOB,
 	userAccount: PublicKey,
@@ -6592,4 +6613,130 @@ describe('Uncross L2', () => {
 			new BN(1).mul(BASE_PRECISION).toString()
 		);
 	});
+
+	it('Handles edge case bide and asks with large cross and an overlapping level', () => {
+		const bids = [
+			'104411000',
+			'103835800',
+			'103826259',
+			'103825000',
+			'103822000',
+			'103821500',
+			'103820283',
+			'103816900',
+			'103816000',
+			'103815121',
+		].map((priceStr) => ({
+			price: new BN(priceStr),
+			size: new BN(1).mul(BASE_PRECISION),
+			sources: { vamm: new BN(1).mul(BASE_PRECISION) },
+		}));
+
+		const asks = [
+			'103822000',
+			'103838354',
+			'103843087',
+			'103843351',
+			'103843880',
+			'103845114',
+			'103846148',
+			'103850100',
+			'103851300',
+			'103854304',
+		].map((priceStr) => ({
+			price: new BN(priceStr),
+			size: new BN(1).mul(BASE_PRECISION),
+			sources: { vamm: new BN(1).mul(BASE_PRECISION) },
+		}));
+
+		expect(asksAreSortedAsc(asks), 'Input asks are ascending').to.be.true;
+		expect(bidsAreSortedDesc(bids), 'Input bids are descending').to.be.true;
+
+		const oraclePrice = new BN('103649895');
+		const oraclePrice5Min = new BN('103285000');
+		const markPrice5Min = new BN('103371000');
+
+		const groupingSize = new BN('100');
+
+		const userAsks = new Set<string>();
+
+		const { bids: newBids, asks: newAsks } = uncrossL2(
+			bids,
+			asks,
+			oraclePrice,
+			oraclePrice5Min,
+			markPrice5Min,
+			groupingSize,
+			new Set<string>(),
+			userAsks
+		);
+
+		expect(asksAreSortedAsc(newAsks), 'Uncrossed asks are ascending').to.be
+			.true;
+		expect(bidsAreSortedDesc(newBids), 'Uncrossed bids are descending').to.be
+			.true;
+	});
+
+	it('Crossing edge case : top bid and ask have a big cross, following ones dont - shouldnt get uncrossed out of order', () => {
+		const bids = [
+			'101825900',
+			'101783900',
+			'101783000',
+			'101782600',
+			'101770700',
+			'101770200',
+			'101749857',
+			'101735900',
+			'101729994',
+			'101726900',
+		].map((priceStr) => ({
+			price: new BN(priceStr),
+			size: new BN(1).mul(BASE_PRECISION),
+			sources: { vamm: new BN(1).mul(BASE_PRECISION) },
+		}));
+
+		const asks = [
+			'101750700',
+			'101790467',
+			'101793400',
+			'101794116',
+			'101798548',
+			'101799532',
+			'101803500',
+			'101820927',
+			'101823900',
+			'101827638',
+		].map((priceStr) => ({
+			price: new BN(priceStr),
+			size: new BN(1).mul(BASE_PRECISION),
+			sources: { vamm: new BN(1).mul(BASE_PRECISION) },
+		}));
+
+		expect(asksAreSortedAsc(asks), 'Input asks are ascending').to.be.true;
+		expect(bidsAreSortedDesc(bids), 'Input bids are descending').to.be.true;
+
+		const oraclePrice = new BN('101711384');
+		const oraclePrice5Min = new BN('101805000');
+		const markPrice5Min = new BN('101867000');
+
+		const groupingSize = new BN('100');
+
+		const userAsks = new Set<string>();
+
+		const { bids: newBids, asks: newAsks } = uncrossL2(
+			bids,
+			asks,
+			oraclePrice,
+			oraclePrice5Min,
+			markPrice5Min,
+			groupingSize,
+			new Set<string>(),
+			userAsks
+		);
+
+		expect(asksAreSortedAsc(newAsks), 'Uncrossed asks are ascending').to.be
+			.true;
+		expect(bidsAreSortedDesc(newBids), 'Uncrossed bids are descending').to.be
+			.true;
+	});
 });