@drift-labs/sdk 2.49.0-beta.15 → 2.49.0-beta.17

package/src/orderSubscriber/types.ts

@@ -16,14 +16,26 @@ export type OrderSubscriberConfig = {
 				resubTimeoutMs?: number;
 				commitment?: Commitment;
 		  };
+	fastDecode?: boolean;
 };
 
 export interface OrderSubscriberEvents {
-	onUpdate: (
+	orderCreated: (
 		account: UserAccount,
 		updatedOrders: Order[],
 		pubkey: PublicKey,
 		slot: number,
 		dataType: 'raw' | 'decoded'
 	) => void;
+	userUpdated: (
+		account: UserAccount,
+		pubkey: PublicKey,
+		slot: number,
+		dataType: 'raw' | 'decoded'
+	) => void;
+	updateReceived: (
+		pubkey: PublicKey,
+		slot: number,
+		dataType: 'raw' | 'decoded'
+	) => void;
 }

package/src/types.ts

@@ -552,6 +552,7 @@ export type StateAccount = {
 	lpCooldownTime: BN;
 	initialPctToLiquidate: number;
 	liquidationDuration: number;
+	maxInitializeUserFee: number;
 };
 
 export type PerpMarketAccount = {
@@ -870,7 +871,6 @@ export type Order = {
 	price: BN;
 	baseAssetAmount: BN;
 	baseAssetAmountFilled: BN;
-	quoteAssetAmount: BN;
 	quoteAssetAmountFilled: BN;
 	direction: PositionDirection;
 	reduceOnly: boolean;

package/src/user.ts

@@ -422,7 +422,8 @@ export class User {
 	public getPerpPositionWithLPSettle(
 		marketIndex: number,
 		originalPosition?: PerpPosition,
-		burnLpShares = false
+		burnLpShares = false,
+		includeRemainderInBaseAmount = false
 	): [PerpPosition, BN, BN] {
 		originalPosition =
 			originalPosition ??
@@ -600,7 +601,16 @@ export class User {
 			position.lastCumulativeFundingRate = ZERO;
 		}
 
-		return [position, remainderBaa, pnl];
+		const remainderBeforeRemoval = new BN(position.remainderBaseAssetAmount);
+
+		if (includeRemainderInBaseAmount) {
+			position.baseAssetAmount = position.baseAssetAmount.add(
+				remainderBeforeRemoval
+			);
+			position.remainderBaseAssetAmount = 0;
+		}
+
+		return [position, remainderBeforeRemoval, pnl];
 	}
 
 	/**

package/src/userMap/PollingSubscription.ts

@@ -27,10 +27,12 @@ export class PollingSubscription {
 			return;
 		}
 
-		this.intervalId = setInterval(
-			this.userMap.sync.bind(this.userMap),
-			this.frequency
-		);
+		if (this.frequency > 0) {
+			this.intervalId = setInterval(
+				this.userMap.sync.bind(this.userMap),
+				this.frequency
+			);
+		}
 
 		if (!this.skipInitialLoad) {
 			await this.userMap.sync();

package/src/userMap/WebsocketSubscription.ts

@@ -10,6 +10,7 @@ export class WebsocketSubscription {
 	private skipInitialLoad: boolean;
 	private resubTimeoutMs?: number;
 	private includeIdle?: boolean;
+	private decodeFn: (name: string, data: Buffer) => UserAccount;
 
 	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
 
@@ -19,18 +20,21 @@ export class WebsocketSubscription {
 		skipInitialLoad = false,
 		resubTimeoutMs,
 		includeIdle = false,
+		decodeFn,
 	}: {
 		userMap: UserMap;
 		commitment: Commitment;
 		skipInitialLoad?: boolean;
 		resubTimeoutMs?: number;
 		includeIdle?: boolean;
+		decodeFn: (name: string, data: Buffer) => UserAccount;
 	}) {
 		this.userMap = userMap;
 		this.commitment = commitment;
 		this.skipInitialLoad = skipInitialLoad;
 		this.resubTimeoutMs = resubTimeoutMs;
 		this.includeIdle = includeIdle || false;
+		this.decodeFn = decodeFn;
 	}
 
 	public async subscribe(): Promise<void> {
@@ -43,9 +47,7 @@ export class WebsocketSubscription {
 				'UserMap',
 				'User',
 				this.userMap.driftClient.program,
-				this.userMap.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(
-					this.userMap.driftClient.program.account.user.coder.accounts
-				),
+				this.decodeFn,
 				{
 					filters,
 					commitment: this.commitment,

package/src/userMap/userMap.ts

@@ -31,6 +31,7 @@ import {
 } from './userMapConfig';
 import { WebsocketSubscription } from './WebsocketSubscription';
 import { PollingSubscription } from './PollingSubscription';
+import { decodeUser } from '../decode/user';
 
 export interface UserMapInterface {
 	subscribe(): Promise<void>;
@@ -58,6 +59,7 @@ export class UserMap implements UserMapInterface {
 			this.lastNumberOfSubAccounts = state.numberOfSubAccounts;
 		}
 	};
+	private decode;
 
 	private syncPromise?: Promise<void>;
 	private syncPromiseResolver: () => void;
@@ -75,6 +77,18 @@ export class UserMap implements UserMapInterface {
 		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,
@@ -87,6 +101,7 @@ export class UserMap implements UserMapInterface {
 				commitment: this.commitment,
 				resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
 				skipInitialLoad: config.skipInitialLoad,
+				decodeFn,
 			});
 		}
 	}
@@ -309,12 +324,9 @@ 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.decodeUnchecked(
-							'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));
@@ -324,13 +336,6 @@ export class UserMap implements UserMapInterface {
 				if (!programAccountBufferMap.has(key)) {
 					await user.unsubscribe();
 					this.userMap.delete(key);
-				} else {
-					const userAccount =
-						this.driftClient.program.account.user.coder.accounts.decodeUnchecked(
-							'User',
-							programAccountBufferMap.get(key)
-						);
-					user.accountSubscriber.updateData(userAccount, slot);
 				}
 				// give event loop a chance to breathe
 				await new Promise((resolve) => setTimeout(resolve, 0));

package/src/userMap/userMapConfig.ts

@@ -28,4 +28,7 @@ export type UserMapConfig = {
 
 	// 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/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');
+	}
+}