@drift-labs/sdk 2.49.0-beta.8 → 2.52.0-beta.0

package/src/userMap/userMap.ts

@@ -3,7 +3,6 @@ import {
 	DriftClient,
 	UserAccount,
 	OrderRecord,
-	UserSubscriptionConfig,
 	WrappedEvent,
 	DepositRecord,
 	FundingPaymentRecord,
@@ -14,11 +13,25 @@ import {
 	LPRecord,
 	StateAccount,
 	DLOB,
+	BasicUserAccountSubscriber,
+	BN,
 } from '..';
 
-import { PublicKey, RpcResponseAndContext } from '@solana/web3.js';
+import {
+	Commitment,
+	Connection,
+	PublicKey,
+	RpcResponseAndContext,
+} from '@solana/web3.js';
 import { Buffer } from 'buffer';
 import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
+import {
+	UserAccountFilterCriteria as UserFilterCriteria,
+	UserMapConfig,
+} from './userMapConfig';
+import { WebsocketSubscription } from './WebsocketSubscription';
+import { PollingSubscription } from './PollingSubscription';
+import { decodeUser } from '../decode/user';
 
 export interface UserMapInterface {
 	subscribe(): Promise<void>;
@@ -32,59 +45,65 @@ export interface UserMapInterface {
 	values(): IterableIterator<User>;
 }
 
-// filter users that meet these criteria when passing into syncCallback
-export type SyncCallbackCriteria = {
-	// only sync users that have open orders
-	hasOpenOrders: boolean;
-};
-
 export class UserMap implements UserMapInterface {
 	private userMap = new Map<string, User>();
-	private driftClient: DriftClient;
-	private accountSubscription: UserSubscriptionConfig;
+	driftClient: DriftClient;
+	private connection: Connection;
+	private commitment: Commitment;
 	private includeIdle: boolean;
-	private lastNumberOfSubAccounts;
+	private lastNumberOfSubAccounts: BN;
+	private subscription: PollingSubscription | WebsocketSubscription;
 	private stateAccountUpdateCallback = async (state: StateAccount) => {
-		if (state.numberOfSubAccounts !== this.lastNumberOfSubAccounts) {
+		if (!state.numberOfSubAccounts.eq(this.lastNumberOfSubAccounts)) {
 			await this.sync();
 			this.lastNumberOfSubAccounts = state.numberOfSubAccounts;
 		}
 	};
-	private syncCallback: (authorities: PublicKey[]) => Promise<void>;
-	private syncCallbackCriteria: SyncCallbackCriteria;
+	private decode;
 
 	private syncPromise?: Promise<void>;
 	private syncPromiseResolver: () => void;
 
 	/**
 	 * Constructs a new UserMap instance.
-	 *
-	 * @param {DriftClient} driftClient - The DriftClient instance.
-	 * @param {UserSubscriptionConfig} accountSubscription - The UserSubscriptionConfig instance.
-	 * @param {boolean} includeIdle - Whether idle users are subscribed to. Defaults to false to decrease # of user subscriptions.
-	 * @param {(authorities: PublicKey[]) => Promise<void>} syncCallback - Called after `sync` completes, will pas in unique list of authorities. Useful for using it to sync UserStatsMap.
-	 * @param {SyncCallbackCriteria} syncCallbackCriteria - The criteria for the sync callback. Defaults to having no filters
 	 */
-	constructor(
-		driftClient: DriftClient,
-		accountSubscription: UserSubscriptionConfig,
-		includeIdle = false,
-		syncCallback?: (authorities: PublicKey[]) => Promise<void>,
-		syncCallbackCriteria: SyncCallbackCriteria = { hasOpenOrders: false }
-	) {
-		this.driftClient = driftClient;
-		this.accountSubscription = accountSubscription;
-		this.includeIdle = includeIdle;
-		this.syncCallback = syncCallback;
-		this.syncCallbackCriteria = syncCallbackCriteria;
-	}
-
-	public addSyncCallback(
-		syncCallback?: (authorities: PublicKey[]) => Promise<void>,
-		syncCallbackCriteria: SyncCallbackCriteria = { hasOpenOrders: false }
-	) {
-		this.syncCallback = syncCallback;
-		this.syncCallbackCriteria = syncCallbackCriteria;
+	constructor(config: UserMapConfig) {
+		this.driftClient = config.driftClient;
+		if (config.connection) {
+			this.connection = config.connection;
+		} else {
+			this.connection = this.driftClient.connection;
+		}
+		this.commitment =
+			config.subscriptionConfig.commitment ?? this.driftClient.opts.commitment;
+		this.includeIdle = config.includeIdle ?? false;
+
+		let decodeFn;
+		if (config.fastDecode ?? true) {
+			decodeFn = (name, buffer) => decodeUser(buffer);
+		} else {
+			decodeFn =
+				this.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(
+					this.driftClient.program.account.user.coder.accounts
+				);
+		}
+		this.decode = decodeFn;
+
+		if (config.subscriptionConfig.type === 'polling') {
+			this.subscription = new PollingSubscription({
+				userMap: this,
+				frequency: config.subscriptionConfig.frequency,
+				skipInitialLoad: config.skipInitialLoad,
+			});
+		} else {
+			this.subscription = new WebsocketSubscription({
+				userMap: this,
+				commitment: this.commitment,
+				resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
+				skipInitialLoad: config.skipInitialLoad,
+				decodeFn,
+			});
+		}
 	}
 
 	public async subscribe() {
@@ -100,17 +119,25 @@ export class UserMap implements UserMapInterface {
 			this.stateAccountUpdateCallback
 		);
 
-		await this.sync();
+		await this.subscription.subscribe();
 	}
 
 	public async addPubkey(
 		userAccountPublicKey: PublicKey,
-		userAccount?: UserAccount
+		userAccount?: UserAccount,
+		slot?: number
 	) {
 		const user = new User({
 			driftClient: this.driftClient,
 			userAccountPublicKey,
-			accountSubscription: this.accountSubscription,
+			accountSubscription: {
+				type: 'custom',
+				userAccountSubscriber: new BasicUserAccountSubscriber(
+					userAccountPublicKey,
+					userAccount,
+					slot
+				),
+			},
 		});
 		await user.subscribe(userAccount);
 		this.userMap.set(userAccountPublicKey.toString(), user);
@@ -216,14 +243,18 @@ export class UserMap implements UserMapInterface {
 		return this.userMap.size;
 	}
 
-	public getUniqueAuthorities(useSyncCallbackCriteria = true): PublicKey[] {
+	/**
+	 * Returns a unique list of authorities for all users in the UserMap that meet the filter criteria
+	 * @param filterCriteria: Users must meet these criteria to be included
+	 * @returns
+	 */
+	public getUniqueAuthorities(
+		filterCriteria?: UserFilterCriteria
+	): PublicKey[] {
 		const usersMeetingCriteria = Array.from(this.userMap.values()).filter(
 			(user) => {
 				let pass = true;
-				if (
-					useSyncCallbackCriteria &&
-					this.syncCallbackCriteria.hasOpenOrders
-				) {
+				if (filterCriteria && filterCriteria.hasOpenOrders) {
 					pass = pass && user.getUserAccount().hasOpenOrder;
 				}
 				return pass;
@@ -257,7 +288,7 @@ export class UserMap implements UserMapInterface {
 			const rpcRequestArgs = [
 				this.driftClient.program.programId.toBase58(),
 				{
-					commitment: this.driftClient.connection.commitment,
+					commitment: this.commitment,
 					filters,
 					encoding: 'base64',
 					withContext: true,
@@ -266,10 +297,7 @@ export class UserMap implements UserMapInterface {
 
 			const rpcJSONResponse: any =
 				// @ts-ignore
-				await this.driftClient.connection._rpcRequest(
-					'getProgramAccounts',
-					rpcRequestArgs
-				);
+				await this.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
 
 			const rpcResponseAndContext: RpcResponseAndContext<
 				Array<{
@@ -296,34 +324,24 @@ export class UserMap implements UserMapInterface {
 
 			for (const [key, buffer] of programAccountBufferMap.entries()) {
 				if (!this.has(key)) {
-					const userAccount =
-						this.driftClient.program.account.user.coder.accounts.decode(
-							'User',
-							buffer
-						);
+					const userAccount = this.decode('User', buffer);
 					await this.addPubkey(new PublicKey(key), userAccount);
+					this.userMap.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()) {
 				if (!programAccountBufferMap.has(key)) {
 					await user.unsubscribe();
 					this.userMap.delete(key);
-				} else {
-					const userAccount =
-						this.driftClient.program.account.user.coder.accounts.decode(
-							'User',
-							programAccountBufferMap.get(key)
-						);
-					user.accountSubscriber.updateData(userAccount, slot);
 				}
-			}
-
-			if (this.syncCallback) {
-				await this.syncCallback(this.getUniqueAuthorities());
+				// give event loop a chance to breathe
+				await new Promise((resolve) => setTimeout(resolve, 0));
 			}
 		} catch (e) {
-			console.error(`Error in UserMap.sync()`);
+			console.error(`Error in UserMap.sync():`);
 			console.error(e);
 		} finally {
 			this.syncPromiseResolver();
@@ -332,6 +350,8 @@ export class UserMap implements UserMapInterface {
 	}
 
 	public async unsubscribe() {
+		await this.subscription.unsubscribe();
+
 		for (const [key, user] of this.userMap.entries()) {
 			await user.unsubscribe();
 			this.userMap.delete(key);
@@ -345,4 +365,17 @@ export class UserMap implements UserMapInterface {
 			this.lastNumberOfSubAccounts = undefined;
 		}
 	}
+
+	public async updateUserAccount(
+		key: string,
+		userAccount: UserAccount,
+		slot: number
+	) {
+		if (!this.userMap.has(key)) {
+			this.addPubkey(new PublicKey(key), userAccount, slot);
+		} else {
+			const user = this.userMap.get(key);
+			user.accountSubscriber.updateData(userAccount, slot);
+		}
+	}
 }

package/src/userMap/userMapConfig.ts

@@ -0,0 +1,34 @@
+import { Commitment, Connection } from '@solana/web3.js';
+import { DriftClient } from '../driftClient';
+
+// passed into UserMap.getUniqueAuthorities to filter users
+export type UserAccountFilterCriteria = {
+	// only return users that have open orders
+	hasOpenOrders: boolean;
+};
+
+export type UserMapConfig = {
+	driftClient: DriftClient;
+	// connection object to use specifically for the UserMap. If undefined, will use the driftClient's connection
+	connection?: Connection;
+	subscriptionConfig:
+		| {
+				type: 'polling';
+				frequency: number;
+				commitment?: Commitment;
+		  }
+		| {
+				type: 'websocket';
+				resubTimeoutMs?: number;
+				commitment?: Commitment;
+		  };
+
+	// True to skip the initial load of userAccounts via getProgramAccounts
+	skipInitialLoad?: boolean;
+
+	// True to include idle users when loading. Defaults to false to decrease # of accounts subscribed to.
+	includeIdle?: boolean;
+
+	// Whether to skip loading available perp/spot positions and open orders
+	fastDecode?: boolean;
+};

package/tests/amm/test.ts

@@ -361,7 +361,10 @@ describe('AMM Tests', () => {
 
 		console.log(terms2);
 		assert(terms2.effectiveLeverageCapped <= 1.000001);
-		assert(terms2.inventorySpreadScale == 1.013527);
+		assert(
+			terms2.inventorySpreadScale == 1.013527,
+			`got: ${terms2.inventorySpreadScale}`
+		);
 		assert(terms2.longSpread == 1146);
 		assert(terms2.shortSpread == 6686);
 	});
@@ -466,7 +469,7 @@ describe('AMM Tests', () => {
 
 		assert(markTwapLive.eq(new BN('1949826')));
 		assert(oracleTwapLive.eq(new BN('1942510')));
-		assert(est1.eq(new BN('15692')));
+		assert(est1.eq(new BN('15692')), `got: ${est1}`);
 		assert(est2.eq(new BN('15692')));
 	});
 
@@ -556,7 +559,7 @@ describe('AMM Tests', () => {
 		assert(markTwapLive.eq(new BN('1222131')));
 		assert(oracleTwapLive.eq(new BN('1222586')));
 		assert(est1.eq(est2));
-		assert(est2.eq(new BN('-1550')));
+		assert(est2.eq(new BN('-1550')), `got: ${est2}`);
 	});
 
 	it('orderbook L2 gen (no topOfBookQuoteAmounts, 10 numOrders, low liquidity)', async () => {

package/tests/decode/test.ts

@@ -0,0 +1,266 @@
+import { AnchorProvider, Idl, Program } from '@coral-xyz/anchor';
+import driftIDL from '../../src/idl/drift.json';
+import { Connection, Keypair } from '@solana/web3.js';
+import { Wallet } from '../../src';
+import {
+	DRIFT_PROGRAM_ID,
+	isSpotPositionAvailable,
+	isVariant,
+	Order,
+	PerpPosition,
+	positionIsAvailable,
+	SpotPosition,
+} from '../../lib';
+import { decodeUser } from '../../lib/decode/user';
+import { assert } from 'chai';
+import { userAccountBufferStrings } from './userAccountBufferStrings';
+const sizeof = require('object-sizeof');
+
+describe('Custom user decode', () => {
+	it('test', async () => {
+		const connection = new Connection('http://localhost:8899');
+		const wallet = new Wallet(new Keypair());
+		// @ts-ignore
+		const provider = new AnchorProvider(connection, wallet);
+		const program = new Program(driftIDL as Idl, DRIFT_PROGRAM_ID, provider);
+
+		let totalAnchorSize = 0;
+		let totalCustomSize = 0;
+		let totalAnchorTime = 0;
+		let totalCustomTime = 0;
+		for (const [
+			i,
+			userAccountBufferString,
+		] of userAccountBufferStrings.entries()) {
+			const userAccountBuffer = Buffer.from(userAccountBufferString, 'base64');
+			const [anchorSize, customSize, anchorTime, customTime] =
+				testUserAccountDecode(program, userAccountBuffer, i);
+			totalAnchorSize += anchorSize;
+			totalCustomSize += customSize;
+			totalAnchorTime += anchorTime;
+			totalCustomTime += customTime;
+		}
+
+		console.log(`Total anchor size: ${totalAnchorSize}`);
+		console.log(`Total custom size: ${totalCustomSize}`);
+		console.log(`Total anchor time: ${totalAnchorTime}`);
+		console.log(`Total custom size: ${totalCustomTime}`);
+	});
+});
+
+function testUserAccountDecode(program: Program, buffer: Buffer, i: number) {
+	console.log(`Testing user account decode ${i}`);
+
+	const anchorStartTimestamp = Date.now();
+	const anchorUserAccount = program.coder.accounts.decode('User', buffer);
+	const anchorEndTimestamp = Date.now();
+	const anchorTime = anchorEndTimestamp - anchorStartTimestamp;
+
+	const customStartTimestamp = Date.now();
+	const customUserAccount = decodeUser(buffer);
+	const customEndTimestamp = Date.now();
+	const customTime = customEndTimestamp - customStartTimestamp;
+
+	const anchorSize = sizeof(anchorUserAccount);
+	const customSize = sizeof(customUserAccount);
+
+	assert(anchorUserAccount.authority.equals(customUserAccount.authority));
+	assert(anchorUserAccount.delegate.equals(customUserAccount.delegate));
+	assert(arraysAreEqual(anchorUserAccount.name, customUserAccount.name));
+
+	const anchorSpotPositionGenerator = getSpotPositions(
+		anchorUserAccount.spotPositions
+	);
+	const customSpotPositionGenerator = getSpotPositions(
+		customUserAccount.spotPositions
+	);
+	for (const [anchorSpotPosition, customSpotPosition] of zipGenerator(
+		anchorSpotPositionGenerator,
+		customSpotPositionGenerator
+	)) {
+		testSpotPosition(anchorSpotPosition, customSpotPosition);
+	}
+
+	const anchorPerpPositionGenerator = getPerpPositions(
+		anchorUserAccount.perpPositions
+	);
+	const customPerpPositionGenerator = getPerpPositions(
+		customUserAccount.perpPositions
+	);
+	for (const [anchorPerpPosition, customPerpPosition] of zipGenerator(
+		anchorPerpPositionGenerator,
+		customPerpPositionGenerator
+	)) {
+		testPerpPosition(anchorPerpPosition, customPerpPosition);
+	}
+
+	const anchorOrderGenerator = getOrders(anchorUserAccount.orders);
+	const customOrderGenerator = getOrders(customUserAccount.orders);
+	for (const [anchorOrder, customOrder] of zipGenerator(
+		anchorOrderGenerator,
+		customOrderGenerator
+	)) {
+		testOrder(anchorOrder, customOrder);
+	}
+
+	assert(
+		anchorUserAccount.lastAddPerpLpSharesTs.eq(
+			customUserAccount.lastAddPerpLpSharesTs
+		)
+	);
+	assert(anchorUserAccount.totalDeposits.eq(customUserAccount.totalDeposits));
+	assert(anchorUserAccount.totalWithdraws.eq(customUserAccount.totalWithdraws));
+	assert(
+		anchorUserAccount.totalSocialLoss.eq(customUserAccount.totalSocialLoss)
+	);
+	assert(anchorUserAccount.settledPerpPnl.eq(customUserAccount.settledPerpPnl));
+	assert(
+		anchorUserAccount.cumulativeSpotFees.eq(
+			customUserAccount.cumulativeSpotFees
+		)
+	);
+	assert(
+		anchorUserAccount.cumulativePerpFunding.eq(
+			customUserAccount.cumulativePerpFunding
+		)
+	);
+	assert(
+		anchorUserAccount.liquidationMarginFreed.eq(
+			customUserAccount.liquidationMarginFreed
+		)
+	);
+	assert(anchorUserAccount.lastActiveSlot.eq(customUserAccount.lastActiveSlot));
+	assert(anchorUserAccount.subAccountId === customUserAccount.subAccountId);
+	assert(anchorUserAccount.status === customUserAccount.status);
+	assert(
+		anchorUserAccount.nextLiquidationId === customUserAccount.nextLiquidationId
+	);
+	assert(anchorUserAccount.nextOrderId === customUserAccount.nextOrderId);
+	assert(anchorUserAccount.maxMarginRatio === customUserAccount.maxMarginRatio);
+	assert(
+		anchorUserAccount.isMarginTradingEnabled ===
+			customUserAccount.isMarginTradingEnabled
+	);
+	assert(anchorUserAccount.idle === customUserAccount.idle);
+	assert(anchorUserAccount.openOrders === customUserAccount.openOrders);
+	assert(anchorUserAccount.hasOpenOrder === customUserAccount.hasOpenOrder);
+	assert(anchorUserAccount.openAuctions === customUserAccount.openAuctions);
+	assert(anchorUserAccount.hasOpenAuction === customUserAccount.hasOpenAuction);
+
+	return [anchorSize, customSize, anchorTime, customTime];
+}
+
+function* getSpotPositions(spotPositions: SpotPosition[]) {
+	for (const spotPosition of spotPositions) {
+		if (!isSpotPositionAvailable(spotPosition)) {
+			yield spotPosition;
+		}
+	}
+}
+
+function testSpotPosition(anchor: SpotPosition, custom: SpotPosition) {
+	assert(anchor.marketIndex === custom.marketIndex);
+	assert(enumsAreEqual(anchor.balanceType, custom.balanceType));
+	assert(anchor.openOrders === custom.openOrders);
+	assert(anchor.scaledBalance.eq(custom.scaledBalance));
+	assert(anchor.openBids.eq(custom.openBids));
+	assert(anchor.openAsks.eq(custom.openAsks));
+	assert(anchor.cumulativeDeposits.eq(custom.cumulativeDeposits));
+}
+
+function* getPerpPositions(perpPositions: PerpPosition[]) {
+	for (const perpPosition of perpPositions) {
+		if (!positionIsAvailable(perpPosition)) {
+			yield perpPosition;
+		}
+	}
+}
+
+function testPerpPosition(anchor: PerpPosition, custom: PerpPosition) {
+	assert(anchor.baseAssetAmount.eq(custom.baseAssetAmount));
+	assert(anchor.lastCumulativeFundingRate.eq(custom.lastCumulativeFundingRate));
+	assert(anchor.marketIndex === custom.marketIndex);
+	assert(anchor.quoteAssetAmount.eq(custom.quoteAssetAmount));
+	assert(anchor.quoteEntryAmount.eq(custom.quoteEntryAmount));
+	assert(anchor.quoteBreakEvenAmount.eq(custom.quoteBreakEvenAmount));
+	assert(anchor.openBids.eq(custom.openBids));
+	assert(anchor.openAsks.eq(custom.openAsks));
+	assert(anchor.settledPnl.eq(custom.settledPnl));
+	assert(anchor.lpShares.eq(custom.lpShares));
+	assert(anchor.lastBaseAssetAmountPerLp.eq(custom.lastBaseAssetAmountPerLp));
+	assert(anchor.lastQuoteAssetAmountPerLp.eq(custom.lastQuoteAssetAmountPerLp));
+	assert(anchor.openOrders === custom.openOrders);
+	assert(anchor.perLpBase === custom.perLpBase);
+}
+
+function* getOrders(orders: Order[]) {
+	for (const order of orders) {
+		if (isVariant(order.status, 'open')) {
+			yield order;
+		}
+	}
+}
+
+function testOrder(anchor: Order, custom: Order) {
+	assert(enumsAreEqual(anchor.status, custom.status));
+	assert(enumsAreEqual(anchor.orderType, custom.orderType));
+	assert(enumsAreEqual(anchor.marketType, custom.marketType));
+	assert(anchor.slot.eq(custom.slot));
+	assert(anchor.orderId === custom.orderId);
+	assert(anchor.userOrderId === custom.userOrderId);
+	assert(anchor.marketIndex === custom.marketIndex);
+	assert(anchor.price.eq(custom.price));
+	assert(anchor.baseAssetAmount.eq(custom.baseAssetAmount));
+	assert(anchor.baseAssetAmountFilled.eq(custom.baseAssetAmountFilled));
+	assert(anchor.quoteAssetAmountFilled.eq(custom.quoteAssetAmountFilled));
+	assert(enumsAreEqual(anchor.direction, custom.direction));
+	assert(anchor.reduceOnly === custom.reduceOnly);
+	assert(anchor.triggerPrice.eq(custom.triggerPrice));
+	assert(enumsAreEqual(anchor.triggerCondition, custom.triggerCondition));
+	assert(
+		enumsAreEqual(
+			anchor.existingPositionDirection,
+			custom.existingPositionDirection
+		)
+	);
+	assert(anchor.postOnly === custom.postOnly);
+	assert(anchor.immediateOrCancel === custom.immediateOrCancel);
+	assert(anchor.oraclePriceOffset === custom.oraclePriceOffset);
+	assert(anchor.auctionDuration === custom.auctionDuration);
+	assert(anchor.auctionStartPrice.eq(custom.auctionStartPrice));
+	assert(anchor.auctionEndPrice.eq(custom.auctionEndPrice));
+	assert(anchor.maxTs.eq(custom.maxTs));
+}
+
+function enumsAreEqual(e1: any, e2: any) {
+	return JSON.stringify(e1) === JSON.stringify(e2);
+}
+
+function arraysAreEqual(arr1, arr2) {
+	if (arr1.length !== arr2.length) {
+		return false;
+	}
+
+	for (let i = 0; i < arr1.length; i++) {
+		if (arr1[i] !== arr2[i]) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+function* zipGenerator(gen1, gen2) {
+	let iter1 = gen1.next();
+	let iter2 = gen2.next();
+
+	while (!iter1.done && !iter2.done) {
+		yield [iter1.value, iter2.value];
+		iter1 = gen1.next();
+		iter2 = gen2.next();
+	}
+
+	if (iter1.done !== iter2.done) {
+		throw new Error('Generators have different lengths');
+	}
+}