@drift-labs/sdk 2.40.0-beta.6 → 2.40.0-beta.8

package/src/accounts/types.ts

@@ -8,7 +8,7 @@ import {
 } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
-import { PublicKey } from '@solana/web3.js';
+import { Context, PublicKey } from '@solana/web3.js';
 import { Account } from '@solana/spl-token';
 import { OracleInfo, OraclePriceData } from '..';
 
@@ -21,6 +21,13 @@ export interface AccountSubscriber<T> {
 	setData(userAccount: T, slot?: number): void;
 }
 
+export interface ProgramAccountSubscriber<T> {
+	subscribe(
+		onChange: (accountId: PublicKey, data: T, context: Context) => void
+	): Promise<void>;
+	unsubscribe(): Promise<void>;
+}
+
 export class NotSubscribedError extends Error {
 	name = 'NotSubscribedError';
 }

package/src/accounts/webSocketAccountSubscriber.ts

@@ -13,17 +13,24 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 	decodeBufferFn: (buffer: Buffer) => T;
 	onChange: (data: T) => void;
 	listenerId?: number;
+	resubTimeoutMs?: number;
+	timeoutId?: NodeJS.Timeout;
+
+	receivingData: boolean;
 
 	public constructor(
 		accountName: string,
 		program: Program,
 		accountPublicKey: PublicKey,
-		decodeBuffer?: (buffer: Buffer) => T
+		decodeBuffer?: (buffer: Buffer) => T,
+		resubTimeoutMs?: number
 	) {
 		this.accountName = accountName;
 		this.program = program;
 		this.accountPublicKey = accountPublicKey;
 		this.decodeBufferFn = decodeBuffer;
+		this.resubTimeoutMs = resubTimeoutMs;
+		this.receivingData = false;
 	}
 
 	async subscribe(onChange: (data: T) => void): Promise<void> {
@@ -39,10 +46,21 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 		this.listenerId = this.program.provider.connection.onAccountChange(
 			this.accountPublicKey,
 			(accountInfo, context) => {
-				this.handleRpcResponse(context, accountInfo);
+				if (this.resubTimeoutMs) {
+					this.receivingData = true;
+					clearTimeout(this.timeoutId);
+					this.handleRpcResponse(context, accountInfo);
+					this.setTimeout();
+				} else {
+					this.handleRpcResponse(context, accountInfo);
+				}
 			},
 			(this.program.provider as AnchorProvider).opts.commitment
 		);
+
+		if (this.resubTimeoutMs) {
+			this.setTimeout();
+		}
 	}
 
 	setData(data: T, slot?: number): void {
@@ -57,6 +75,22 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 		};
 	}
 
+	private setTimeout(): void {
+		if (!this.onChange) {
+			throw new Error('onChange callback function must be set');
+		}
+		this.timeoutId = setTimeout(async () => {
+			if (this.receivingData) {
+				console.log(
+					`No ws data from ${this.accountName} in ${this.resubTimeoutMs}ms, resubscribing`
+				);
+				await this.unsubscribe();
+				this.receivingData = false;
+				await this.subscribe(this.onChange);
+			}
+		}, this.resubTimeoutMs);
+	}
+
 	async fetch(): Promise<void> {
 		const rpcResponse =
 			await this.program.provider.connection.getAccountInfoAndContext(

package/src/accounts/webSocketDriftClientAccountSubscriber.ts

@@ -31,6 +31,7 @@ export class WebSocketDriftClientAccountSubscriber
 	oracleInfos: OracleInfo[];
 	oracleClientCache = new OracleClientCache();
 
+	resubTimeoutMs?: number;
 	shouldFindAllMarketsAndOracles: boolean;
 
 	eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
@@ -54,7 +55,8 @@ export class WebSocketDriftClientAccountSubscriber
 		perpMarketIndexes: number[],
 		spotMarketIndexes: number[],
 		oracleInfos: OracleInfo[],
-		shouldFindAllMarketsAndOracles: boolean
+		shouldFindAllMarketsAndOracles: boolean,
+		resubTimeoutMs?: number
 	) {
 		this.isSubscribed = false;
 		this.program = program;
@@ -63,6 +65,7 @@ export class WebSocketDriftClientAccountSubscriber
 		this.spotMarketIndexes = spotMarketIndexes;
 		this.oracleInfos = oracleInfos;
 		this.shouldFindAllMarketsAndOracles = shouldFindAllMarketsAndOracles;
+		this.resubTimeoutMs = resubTimeoutMs;
 	}
 
 	public async subscribe(): Promise<boolean> {
@@ -96,7 +99,9 @@ export class WebSocketDriftClientAccountSubscriber
 		this.stateAccountSubscriber = new WebSocketAccountSubscriber(
 			'state',
 			this.program,
-			statePublicKey
+			statePublicKey,
+			undefined,
+			this.resubTimeoutMs
 		);
 		await this.stateAccountSubscriber.subscribe((data: StateAccount) => {
 			this.eventEmitter.emit('stateAccountUpdate', data);
@@ -136,7 +141,9 @@ export class WebSocketDriftClientAccountSubscriber
 		const accountSubscriber = new WebSocketAccountSubscriber<PerpMarketAccount>(
 			'perpMarket',
 			this.program,
-			perpMarketPublicKey
+			perpMarketPublicKey,
+			undefined,
+			this.resubTimeoutMs
 		);
 		await accountSubscriber.subscribe((data: PerpMarketAccount) => {
 			this.eventEmitter.emit('perpMarketAccountUpdate', data);
@@ -161,7 +168,9 @@ export class WebSocketDriftClientAccountSubscriber
 		const accountSubscriber = new WebSocketAccountSubscriber<SpotMarketAccount>(
 			'spotMarket',
 			this.program,
-			marketPublicKey
+			marketPublicKey,
+			undefined,
+			this.resubTimeoutMs
 		);
 		await accountSubscriber.subscribe((data: SpotMarketAccount) => {
 			this.eventEmitter.emit('spotMarketAccountUpdate', data);
@@ -192,7 +201,8 @@ export class WebSocketDriftClientAccountSubscriber
 			oracleInfo.publicKey,
 			(buffer: Buffer) => {
 				return client.getOraclePriceDataFromBuffer(buffer);
-			}
+			},
+			this.resubTimeoutMs
 		);
 
 		await accountSubscriber.subscribe((data: OraclePriceData) => {

package/src/accounts/webSocketProgramAccountSubscriber.ts

@@ -0,0 +1,152 @@
+import { DataAndSlot, BufferAndSlot, ProgramAccountSubscriber } from './types';
+import { AnchorProvider, Program } from '@coral-xyz/anchor';
+import {
+	Commitment,
+	Context,
+	KeyedAccountInfo,
+	MemcmpFilter,
+	PublicKey,
+} from '@solana/web3.js';
+import * as Buffer from 'buffer';
+
+export class WebSocketProgramAccountSubscriber<T>
+	implements ProgramAccountSubscriber<T>
+{
+	subscriptionName: string;
+	accountDiscriminator: string;
+	dataAndSlot?: DataAndSlot<T> & { accountId: PublicKey };
+	bufferAndSlot?: BufferAndSlot;
+	program: Program;
+	decodeBuffer: (accountName: string, ix: Buffer) => T;
+	onChange: (accountId: PublicKey, data: T, context: Context) => void;
+	listenerId?: number;
+	resubTimeoutMs?: number;
+	timeoutId?: NodeJS.Timeout;
+	options: { filters: MemcmpFilter[]; commitment?: Commitment };
+
+	receivingData = false;
+
+	public constructor(
+		subscriptionName: string,
+		accountDiscriminator: string,
+		program: Program,
+		decodeBufferFn: (accountName: string, ix: Buffer) => T,
+		options: { filters: MemcmpFilter[]; commitment?: Commitment } = {
+			filters: [],
+		},
+		resubTimeoutMs?: number
+	) {
+		this.subscriptionName = subscriptionName;
+		this.accountDiscriminator = accountDiscriminator;
+		this.program = program;
+		this.decodeBuffer = decodeBufferFn;
+		this.resubTimeoutMs = resubTimeoutMs;
+		this.options = options;
+		this.receivingData = false;
+	}
+
+	async subscribe(
+		onChange: (accountId: PublicKey, data: T, context: Context) => void
+	): Promise<void> {
+		if (this.listenerId) {
+			return;
+		}
+
+		this.onChange = onChange;
+
+		this.listenerId = this.program.provider.connection.onProgramAccountChange(
+			this.program.programId,
+			(keyedAccountInfo, context) => {
+				if (this.resubTimeoutMs) {
+					this.receivingData = true;
+					clearTimeout(this.timeoutId);
+					this.handleRpcResponse(context, keyedAccountInfo);
+					this.setTimeout();
+				} else {
+					this.handleRpcResponse(context, keyedAccountInfo);
+				}
+			},
+			this.options.commitment ??
+				(this.program.provider as AnchorProvider).opts.commitment,
+			this.options.filters
+		);
+
+		if (this.resubTimeoutMs) {
+			this.setTimeout();
+		}
+	}
+
+	private setTimeout(): void {
+		if (!this.onChange) {
+			throw new Error('onChange callback function must be set');
+		}
+		this.timeoutId = setTimeout(async () => {
+			if (this.receivingData) {
+				console.log(
+					`No ws data from ${this.subscriptionName} in ${this.resubTimeoutMs}ms, resubscribing`
+				);
+				await this.unsubscribe();
+				this.receivingData = false;
+				await this.subscribe(this.onChange);
+			}
+		}, this.resubTimeoutMs);
+	}
+
+	handleRpcResponse(
+		context: Context,
+		keyedAccountInfo: KeyedAccountInfo
+	): void {
+		const newSlot = context.slot;
+		let newBuffer: Buffer | undefined = undefined;
+		if (keyedAccountInfo) {
+			newBuffer = keyedAccountInfo.accountInfo.data;
+		}
+
+		if (!this.bufferAndSlot) {
+			this.bufferAndSlot = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			if (newBuffer) {
+				const account = this.decodeBuffer(this.accountDiscriminator, newBuffer);
+				this.dataAndSlot = {
+					data: account,
+					slot: newSlot,
+					accountId: keyedAccountInfo.accountId,
+				};
+				this.onChange(keyedAccountInfo.accountId, account, context);
+			}
+			return;
+		}
+
+		if (newSlot <= this.bufferAndSlot.slot) {
+			return;
+		}
+
+		const oldBuffer = this.bufferAndSlot.buffer;
+		if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+			this.bufferAndSlot = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			const account = this.decodeBuffer(this.accountDiscriminator, newBuffer);
+			this.dataAndSlot = {
+				data: account,
+				slot: newSlot,
+				accountId: keyedAccountInfo.accountId,
+			};
+			this.onChange(keyedAccountInfo.accountId, account, context);
+		}
+	}
+
+	unsubscribe(): Promise<void> {
+		if (this.listenerId) {
+			const promise =
+				this.program.provider.connection.removeAccountChangeListener(
+					this.listenerId
+				);
+			this.listenerId = undefined;
+			return promise;
+		}
+	}
+}

package/src/accounts/webSocketUserAccountSubscriber.ts

@@ -14,17 +14,23 @@ import { UserAccount } from '../types';
 
 export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 	isSubscribed: boolean;
+	reconnectTimeoutMs?: number;
 	program: Program;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
 	userAccountPublicKey: PublicKey;
 
 	userDataAccountSubscriber: AccountSubscriber<UserAccount>;
 
-	public constructor(program: Program, userAccountPublicKey: PublicKey) {
+	public constructor(
+		program: Program,
+		userAccountPublicKey: PublicKey,
+		reconnectTimeoutMs?: number
+	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.userAccountPublicKey = userAccountPublicKey;
 		this.eventEmitter = new EventEmitter();
+		this.reconnectTimeoutMs = reconnectTimeoutMs;
 	}
 
 	async subscribe(userAccount?: UserAccount): Promise<boolean> {
@@ -35,7 +41,9 @@ export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 		this.userDataAccountSubscriber = new WebSocketAccountSubscriber(
 			'user',
 			this.program,
-			this.userAccountPublicKey
+			this.userAccountPublicKey,
+			undefined,
+			this.reconnectTimeoutMs
 		);
 
 		if (userAccount) {

package/src/accounts/webSocketUserStatsAccountSubsriber.ts

@@ -16,17 +16,23 @@ export class WebSocketUserStatsAccountSubscriber
 	implements UserStatsAccountSubscriber
 {
 	isSubscribed: boolean;
+	reconnectTimeoutMs?: number;
 	program: Program;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
 	userStatsAccountPublicKey: PublicKey;
 
 	userStatsAccountSubscriber: AccountSubscriber<UserStatsAccount>;
 
-	public constructor(program: Program, userStatsAccountPublicKey: PublicKey) {
+	public constructor(
+		program: Program,
+		userStatsAccountPublicKey: PublicKey,
+		reconnectTimeoutMs?: number
+	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
 		this.eventEmitter = new EventEmitter();
+		this.reconnectTimeoutMs = reconnectTimeoutMs;
 	}
 
 	async subscribe(userStatsAccount?: UserStatsAccount): Promise<boolean> {
@@ -37,7 +43,9 @@ export class WebSocketUserStatsAccountSubscriber
 		this.userStatsAccountSubscriber = new WebSocketAccountSubscriber(
 			'userStats',
 			this.program,
-			this.userStatsAccountPublicKey
+			this.userStatsAccountPublicKey,
+			undefined,
+			this.reconnectTimeoutMs
 		);
 
 		if (userStatsAccount) {

package/src/auctionSubscriber/auctionSubscriber.ts

@@ -4,48 +4,57 @@ import { getUserFilter, getUserWithAuctionFilter } from '../memcmp';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { UserAccount } from '../types';
-import { ConfirmOptions } from '@solana/web3.js';
+import { ConfirmOptions, Context, PublicKey } from '@solana/web3.js';
+import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
 
 export class AuctionSubscriber {
 	private driftClient: DriftClient;
 	private opts: ConfirmOptions;
+	private resubTimeoutMs?: number;
 
 	eventEmitter: StrictEventEmitter<EventEmitter, AuctionSubscriberEvents>;
+	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
 
-	private websocketId: number;
-
-	constructor({ driftClient, opts }: AuctionSubscriberConfig) {
+	constructor({ driftClient, opts, resubTimeoutMs }: AuctionSubscriberConfig) {
 		this.driftClient = driftClient;
 		this.opts = opts || this.driftClient.opts;
 		this.eventEmitter = new EventEmitter();
+		this.resubTimeoutMs = resubTimeoutMs;
 	}
 
 	public async subscribe() {
-		this.websocketId = this.driftClient.connection.onProgramAccountChange(
-			this.driftClient.program.programId,
-			(keyAccountInfo, context) => {
-				const userAccount =
-					this.driftClient.program.account.user.coder.accounts.decode(
-						'User',
-						keyAccountInfo.accountInfo.data
-					) as UserAccount;
+		if (!this.subscriber) {
+			this.subscriber = new WebSocketProgramAccountSubscriber<UserAccount>(
+				'AuctionSubscriber',
+				'User',
+				this.driftClient.program,
+				this.driftClient.program.account.user.coder.accounts.decode.bind(
+					this.driftClient.program.account.user.coder.accounts
+				),
+				{
+					filters: [getUserFilter(), getUserWithAuctionFilter()],
+					commitment: this.driftClient.opts.commitment,
+				},
+				this.resubTimeoutMs
+			);
+		}
+
+		await this.subscriber.subscribe(
+			(accountId: PublicKey, data: UserAccount, context: Context) => {
 				this.eventEmitter.emit(
 					'onAccountUpdate',
-					userAccount,
-					keyAccountInfo.accountId,
+					data,
+					accountId,
 					context.slot
 				);
-			},
-			this.driftClient.opts.commitment,
-			[getUserFilter(), getUserWithAuctionFilter()]
+			}
 		);
 	}
 
 	public async unsubscribe() {
-		if (this.websocketId) {
-			await this.driftClient.connection.removeProgramAccountChangeListener(
-				this.websocketId
-			);
+		if (!this.subscriber) {
+			return;
 		}
+		this.subscriber.unsubscribe();
 	}
 }

package/src/auctionSubscriber/types.ts

@@ -5,6 +5,7 @@ import { ConfirmOptions, PublicKey } from '@solana/web3.js';
 export type AuctionSubscriberConfig = {
 	driftClient: DriftClient;
 	opts?: ConfirmOptions;
+	resubTimeoutMs?: number;
 };
 
 export interface AuctionSubscriberEvents {

package/src/driftClient.ts

@@ -278,7 +278,8 @@ export class DriftClient {
 				config.perpMarketIndexes ?? [],
 				config.spotMarketIndexes ?? [],
 				config.oracleInfos ?? [],
-				noMarketsAndOraclesSpecified
+				noMarketsAndOraclesSpecified,
+				config.accountSubscription?.resubTimeoutMs
 			);
 		}
 		this.eventEmitter = this.accountSubscriber.eventEmitter;

package/src/driftClientConfig.ts

@@ -36,6 +36,7 @@ export type DriftClientConfig = {
 export type DriftClientSubscriptionConfig =
 	| {
 			type: 'websocket';
+			resubTimeoutMs?: number;
 	  }
 	| {
 			type: 'polling';

package/src/orderSubscriber/OrderSubscriber.ts

@@ -30,6 +30,7 @@ export class OrderSubscriber {
 			this.subscription = new WebsocketSubscription({
 				orderSubscriber: this,
 				skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
+				resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
 			});
 		}
 		this.eventEmitter = new EventEmitter();
@@ -86,7 +87,12 @@ export class OrderSubscriber {
 					programAccount.account.data[1]
 				);
 				programAccountSet.add(key);
-				this.tryUpdateUserAccount(key, buffer, slot);
+				const userAccount =
+					this.driftClient.program.account.user.coder.accounts.decode(
+						'User',
+						buffer
+					) as UserAccount;
+				this.tryUpdateUserAccount(key, userAccount, slot);
 			}
 
 			for (const key of this.usersAccounts.keys()) {
@@ -102,14 +108,13 @@ export class OrderSubscriber {
 		}
 	}
 
-	tryUpdateUserAccount(key: string, buffer: Buffer, slot: number): void {
+	tryUpdateUserAccount(
+		key: string,
+		userAccount: UserAccount,
+		slot: number
+	): void {
 		const slotAndUserAccount = this.usersAccounts.get(key);
 		if (!slotAndUserAccount || slotAndUserAccount.slot < slot) {
-			const userAccount =
-				this.driftClient.program.account.user.coder.accounts.decode(
-					'User',
-					buffer
-				) as UserAccount;
 			const newOrders = userAccount.orders.filter(
 				(order) =>
 					order.slot.toNumber() > (slotAndUserAccount?.slot ?? 0) &&

package/src/orderSubscriber/WebsocketSubscription.ts

@@ -1,42 +1,57 @@
 import { OrderSubscriber } from './OrderSubscriber';
 import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
+import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
+import { UserAccount } from '../types';
+import { Context, PublicKey } from '@solana/web3.js';
 
 export class WebsocketSubscription {
 	private orderSubscriber: OrderSubscriber;
 	private skipInitialLoad: boolean;
+	private resubTimeoutMs?: number;
 
-	private websocketId: number;
+	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
 
 	constructor({
 		orderSubscriber,
 		skipInitialLoad = false,
+		resubTimeoutMs,
 	}: {
 		orderSubscriber: OrderSubscriber;
 		skipInitialLoad?: boolean;
+		resubTimeoutMs?: number;
 	}) {
 		this.orderSubscriber = orderSubscriber;
 		this.skipInitialLoad = skipInitialLoad;
+		this.resubTimeoutMs = resubTimeoutMs;
 	}
 
 	public async subscribe(): Promise<void> {
-		if (this.websocketId) {
-			return;
-		}
-
-		this.websocketId =
-			this.orderSubscriber.driftClient.connection.onProgramAccountChange(
-				this.orderSubscriber.driftClient.program.programId,
-				(keyAccountInfo, context) => {
-					const userKey = keyAccountInfo.accountId.toBase58();
-					this.orderSubscriber.tryUpdateUserAccount(
-						userKey,
-						keyAccountInfo.accountInfo.data,
-						context.slot
-					);
+		if (!this.subscriber) {
+			this.subscriber = new WebSocketProgramAccountSubscriber<UserAccount>(
+				'OrderSubscriber',
+				'User',
+				this.orderSubscriber.driftClient.program,
+				this.orderSubscriber.driftClient.program.account.user.coder.accounts.decode.bind(
+					this.orderSubscriber.driftClient.program.account.user.coder.accounts
+				),
+				{
+					filters: [getUserFilter(), getNonIdleUserFilter()],
+					commitment: this.orderSubscriber.driftClient.opts.commitment,
 				},
-				this.orderSubscriber.driftClient.opts.commitment,
-				[getUserFilter(), getNonIdleUserFilter()]
+				this.resubTimeoutMs
 			);
+		}
+
+		await this.subscriber.subscribe(
+			(accountId: PublicKey, account: UserAccount, context: Context) => {
+				const userKey = accountId.toBase58();
+				this.orderSubscriber.tryUpdateUserAccount(
+					userKey,
+					account,
+					context.slot
+				);
+			}
+		);
 
 		if (!this.skipInitialLoad) {
 			await this.orderSubscriber.fetch();
@@ -44,11 +59,6 @@ export class WebsocketSubscription {
 	}
 
 	public async unsubscribe(): Promise<void> {
-		if (this.websocketId) {
-			await this.orderSubscriber.driftClient.connection.removeProgramAccountChangeListener(
-				this.websocketId
-			);
-			this.websocketId = undefined;
-		}
+		this.subscriber.unsubscribe();
 	}
 }

package/src/orderSubscriber/types.ts

@@ -12,6 +12,7 @@ export type OrderSubscriberConfig = {
 		| {
 				type: 'websocket';
 				skipInitialLoad?: boolean;
+				resubTimeoutMs?: number;
 		  };
 };
 

package/src/user.ts

@@ -1465,8 +1465,10 @@ export class User {
 	 * calculates current user leverage which is (total liability size) / (net asset value)
 	 * @returns : Precision TEN_THOUSAND
 	 */
-	public getLeverage(): BN {
-		return this.calculateLeverageFromComponents(this.getLeverageComponents());
+	public getLeverage(includeOpenOrders = true): BN {
+		return this.calculateLeverageFromComponents(
+			this.getLeverageComponents(includeOpenOrders)
+		);
 	}
 
 	calculateLeverageFromComponents({
@@ -1491,7 +1493,7 @@ export class User {
 		return totalLiabilityValue.mul(TEN_THOUSAND).div(netAssetValue);
 	}
 
-	getLeverageComponents(): {
+	getLeverageComponents(includeOpenOrders = true): {
 		perpLiabilityValue: BN;
 		perpPnl: BN;
 		spotAssetValue: BN;
@@ -1500,7 +1502,7 @@ export class User {
 		const perpLiability = this.getTotalPerpPositionValue(
 			undefined,
 			undefined,
-			true
+			includeOpenOrders
 		);
 		const perpPnl = this.getUnrealizedPNL(true);
 
@@ -1511,7 +1513,7 @@ export class User {
 			undefined,
 			undefined,
 			undefined,
-			true
+			includeOpenOrders
 		);
 
 		return {