@drift-labs/sdk 2.49.0-beta.9 → 2.52.0-beta.1

package/lib/user.js

@@ -251,7 +251,7 @@ class User {
      * @returns : the dust base asset amount (ie, < stepsize)
      * @returns : pnl from settle
      */
-    getPerpPositionWithLPSettle(marketIndex, originalPosition, burnLpShares = false) {
+    getPerpPositionWithLPSettle(marketIndex, originalPosition, burnLpShares = false, includeRemainderInBaseAmount = false) {
         var _a;
         originalPosition =
             (_a = originalPosition !== null && originalPosition !== void 0 ? originalPosition : this.getPerpPosition(marketIndex)) !== null && _a !== void 0 ? _a : this.getEmptyPosition(marketIndex);
@@ -396,7 +396,12 @@ class User {
         else {
             position.lastCumulativeFundingRate = numericConstants_1.ZERO;
         }
-        return [position, remainderBaa, pnl];
+        const remainderBeforeRemoval = new _1.BN(position.remainderBaseAssetAmount);
+        if (includeRemainderInBaseAmount) {
+            position.baseAssetAmount = position.baseAssetAmount.add(remainderBeforeRemoval);
+            position.remainderBaseAssetAmount = 0;
+        }
+        return [position, remainderBeforeRemoval, pnl];
     }
     /**
      * calculates Buying Power = free collateral / initial margin ratio
@@ -852,15 +857,18 @@ class User {
     getTotalAssetValue(marginCategory) {
         return this.getSpotMarketAssetValue(undefined, marginCategory, true).add(this.getUnrealizedPNL(true, undefined, marginCategory));
     }
+    getNetUsdValue() {
+        const netSpotValue = this.getNetSpotMarketValue();
+        const unrealizedPnl = this.getUnrealizedPNL(true, undefined, undefined);
+        return netSpotValue.add(unrealizedPnl);
+    }
     /**
      * Calculates the all time P&L of the user.
      *
      * Net withdraws + Net spot market value + Net unrealized P&L -
      */
     getTotalAllTimePnl() {
-        const netBankValue = this.getNetSpotMarketValue();
-        const unrealizedPnl = this.getUnrealizedPNL(true, undefined, undefined);
-        const netUsdValue = netBankValue.add(unrealizedPnl);
+        const netUsdValue = this.getNetUsdValue();
         const totalDeposits = this.getUserAccount().totalDeposits;
         const totalWithdraws = this.getUserAccount().totalWithdraws;
         const totalPnl = netUsdValue.add(totalWithdraws).sub(totalDeposits);

package/lib/userMap/PollingSubscription.d.ts

@@ -0,0 +1,15 @@
+import { UserMap } from './userMap';
+export declare class PollingSubscription {
+    private userMap;
+    private frequency;
+    private skipInitialLoad;
+    intervalId?: ReturnType<typeof setTimeout>;
+    constructor({ userMap, frequency, skipInitialLoad, }: {
+        userMap: UserMap;
+        frequency: number;
+        skipInitialLoad?: boolean;
+        includeIdle?: boolean;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/userMap/PollingSubscription.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingSubscription = void 0;
+class PollingSubscription {
+    constructor({ userMap, frequency, skipInitialLoad = false, }) {
+        this.userMap = userMap;
+        this.frequency = frequency;
+        this.skipInitialLoad = skipInitialLoad;
+    }
+    async subscribe() {
+        if (this.intervalId) {
+            return;
+        }
+        if (this.frequency > 0) {
+            this.intervalId = setInterval(this.userMap.sync.bind(this.userMap), this.frequency);
+        }
+        if (!this.skipInitialLoad) {
+            await this.userMap.sync();
+        }
+    }
+    async unsubscribe() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+}
+exports.PollingSubscription = PollingSubscription;

package/lib/userMap/WebsocketSubscription.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { UserMap } from './userMap';
+import { UserAccount } from '../types';
+import { Commitment } from '@solana/web3.js';
+export declare class WebsocketSubscription {
+    private userMap;
+    private commitment;
+    private skipInitialLoad;
+    private resubTimeoutMs?;
+    private includeIdle?;
+    private decodeFn;
+    private subscriber;
+    constructor({ userMap, commitment, skipInitialLoad, resubTimeoutMs, includeIdle, decodeFn, }: {
+        userMap: UserMap;
+        commitment: Commitment;
+        skipInitialLoad?: boolean;
+        resubTimeoutMs?: number;
+        includeIdle?: boolean;
+        decodeFn: (name: string, data: Buffer) => UserAccount;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/userMap/WebsocketSubscription.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsocketSubscription = void 0;
+const memcmp_1 = require("../memcmp");
+const webSocketProgramAccountSubscriber_1 = require("../accounts/webSocketProgramAccountSubscriber");
+class WebsocketSubscription {
+    constructor({ userMap, commitment, skipInitialLoad = false, resubTimeoutMs, includeIdle = false, decodeFn, }) {
+        this.userMap = userMap;
+        this.commitment = commitment;
+        this.skipInitialLoad = skipInitialLoad;
+        this.resubTimeoutMs = resubTimeoutMs;
+        this.includeIdle = includeIdle || false;
+        this.decodeFn = decodeFn;
+    }
+    async subscribe() {
+        if (!this.subscriber) {
+            const filters = [(0, memcmp_1.getUserFilter)()];
+            if (!this.includeIdle) {
+                filters.push((0, memcmp_1.getNonIdleUserFilter)());
+            }
+            this.subscriber = new webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber('UserMap', 'User', this.userMap.driftClient.program, this.decodeFn, {
+                filters,
+                commitment: this.commitment,
+            }, this.resubTimeoutMs);
+        }
+        await this.subscriber.subscribe((accountId, account, context) => {
+            const userKey = accountId.toBase58();
+            this.userMap.updateUserAccount(userKey, account, context.slot);
+        });
+        if (!this.skipInitialLoad) {
+            await this.userMap.sync();
+        }
+    }
+    async unsubscribe() {
+        if (!this.subscriber)
+            return;
+        await this.subscriber.unsubscribe();
+        this.subscriber = undefined;
+    }
+}
+exports.WebsocketSubscription = WebsocketSubscription;

package/lib/userMap/userMap.d.ts

@@ -1,5 +1,6 @@
-import { User, DriftClient, UserAccount, OrderRecord, UserSubscriptionConfig, WrappedEvent, DLOB } from '..';
+import { User, DriftClient, UserAccount, OrderRecord, WrappedEvent, DLOB } from '..';
 import { PublicKey } from '@solana/web3.js';
+import { UserAccountFilterCriteria as UserFilterCriteria, UserMapConfig } from './userMapConfig';
 export interface UserMapInterface {
     subscribe(): Promise<void>;
     unsubscribe(): Promise<void>;
@@ -11,33 +12,24 @@ export interface UserMapInterface {
     updateWithOrderRecord(record: OrderRecord): Promise<void>;
     values(): IterableIterator<User>;
 }
-export type SyncCallbackCriteria = {
-    hasOpenOrders: boolean;
-};
 export declare class UserMap implements UserMapInterface {
     private userMap;
-    private driftClient;
-    private accountSubscription;
+    driftClient: DriftClient;
+    private connection;
+    private commitment;
     private includeIdle;
     private lastNumberOfSubAccounts;
+    private subscription;
     private stateAccountUpdateCallback;
-    private syncCallback;
-    private syncCallbackCriteria;
+    private decode;
     private syncPromise?;
     private syncPromiseResolver;
     /**
      * 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?: boolean, syncCallback?: (authorities: PublicKey[]) => Promise<void>, syncCallbackCriteria?: SyncCallbackCriteria);
-    addSyncCallback(syncCallback?: (authorities: PublicKey[]) => Promise<void>, syncCallbackCriteria?: SyncCallbackCriteria): void;
+    constructor(config: UserMapConfig);
     subscribe(): Promise<void>;
-    addPubkey(userAccountPublicKey: PublicKey, userAccount?: UserAccount): Promise<void>;
+    addPubkey(userAccountPublicKey: PublicKey, userAccount?: UserAccount, slot?: number): Promise<void>;
     has(key: string): boolean;
     /**
      * gets the User for a particular userAccountPublicKey, if no User exists, undefined is returned
@@ -67,7 +59,13 @@ export declare class UserMap implements UserMapInterface {
     updateWithEventRecord(record: WrappedEvent<any>): Promise<void>;
     values(): IterableIterator<User>;
     size(): number;
-    getUniqueAuthorities(useSyncCallbackCriteria?: boolean): 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
+     */
+    getUniqueAuthorities(filterCriteria?: UserFilterCriteria): PublicKey[];
     sync(): Promise<void>;
     unsubscribe(): Promise<void>;
+    updateUserAccount(key: string, userAccount: UserAccount, slot: number): Promise<void>;
 }

package/lib/userMap/userMap.js

@@ -5,33 +5,57 @@ const __1 = require("..");
 const web3_js_1 = require("@solana/web3.js");
 const buffer_1 = require("buffer");
 const memcmp_1 = require("../memcmp");
+const WebsocketSubscription_1 = require("./WebsocketSubscription");
+const PollingSubscription_1 = require("./PollingSubscription");
+const user_1 = require("../decode/user");
 class UserMap {
     /**
      * 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, accountSubscription, includeIdle = false, syncCallback, syncCallbackCriteria = { hasOpenOrders: false }) {
+    constructor(config) {
+        var _a, _b, _c;
         this.userMap = new Map();
         this.stateAccountUpdateCallback = async (state) => {
-            if (state.numberOfSubAccounts !== this.lastNumberOfSubAccounts) {
+            if (!state.numberOfSubAccounts.eq(this.lastNumberOfSubAccounts)) {
                 await this.sync();
                 this.lastNumberOfSubAccounts = state.numberOfSubAccounts;
             }
         };
-        this.driftClient = driftClient;
-        this.accountSubscription = accountSubscription;
-        this.includeIdle = includeIdle;
-        this.syncCallback = syncCallback;
-        this.syncCallbackCriteria = syncCallbackCriteria;
-    }
-    addSyncCallback(syncCallback, syncCallbackCriteria = { hasOpenOrders: false }) {
-        this.syncCallback = syncCallback;
-        this.syncCallbackCriteria = syncCallbackCriteria;
+        this.driftClient = config.driftClient;
+        if (config.connection) {
+            this.connection = config.connection;
+        }
+        else {
+            this.connection = this.driftClient.connection;
+        }
+        this.commitment =
+            (_a = config.subscriptionConfig.commitment) !== null && _a !== void 0 ? _a : this.driftClient.opts.commitment;
+        this.includeIdle = (_b = config.includeIdle) !== null && _b !== void 0 ? _b : false;
+        let decodeFn;
+        if ((_c = config.fastDecode) !== null && _c !== void 0 ? _c : true) {
+            decodeFn = (name, buffer) => (0, user_1.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_1.PollingSubscription({
+                userMap: this,
+                frequency: config.subscriptionConfig.frequency,
+                skipInitialLoad: config.skipInitialLoad,
+            });
+        }
+        else {
+            this.subscription = new WebsocketSubscription_1.WebsocketSubscription({
+                userMap: this,
+                commitment: this.commitment,
+                resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
+                skipInitialLoad: config.skipInitialLoad,
+                decodeFn,
+            });
+        }
     }
     async subscribe() {
         if (this.size() > 0) {
@@ -41,13 +65,16 @@ class UserMap {
         this.lastNumberOfSubAccounts =
             this.driftClient.getStateAccount().numberOfSubAccounts;
         this.driftClient.eventEmitter.on('stateAccountUpdate', this.stateAccountUpdateCallback);
-        await this.sync();
+        await this.subscription.subscribe();
     }
-    async addPubkey(userAccountPublicKey, userAccount) {
+    async addPubkey(userAccountPublicKey, userAccount, slot) {
         const user = new __1.User({
             driftClient: this.driftClient,
             userAccountPublicKey,
-            accountSubscription: this.accountSubscription,
+            accountSubscription: {
+                type: 'custom',
+                userAccountSubscriber: new __1.OneShotUserAccountSubscriber(this.driftClient.program, userAccountPublicKey, userAccount, slot, this.commitment),
+            },
         });
         await user.subscribe(userAccount);
         this.userMap.set(userAccountPublicKey.toString(), user);
@@ -148,11 +175,15 @@ class UserMap {
     size() {
         return this.userMap.size;
     }
-    getUniqueAuthorities(useSyncCallbackCriteria = true) {
+    /**
+     * 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
+     */
+    getUniqueAuthorities(filterCriteria) {
         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;
@@ -176,7 +207,7 @@ class UserMap {
             const rpcRequestArgs = [
                 this.driftClient.program.programId.toBase58(),
                 {
-                    commitment: this.driftClient.connection.commitment,
+                    commitment: this.commitment,
                     filters,
                     encoding: 'base64',
                     withContext: true,
@@ -184,7 +215,7 @@ class UserMap {
             ];
             const rpcJSONResponse = 
             // @ts-ignore
-            await this.driftClient.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
+            await this.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
             const rpcResponseAndContext = rpcJSONResponse.result;
             const slot = rpcResponseAndContext.context.slot;
             const programAccountBufferMap = new Map();
@@ -195,26 +226,24 @@ class UserMap {
             }
             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 web3_js_1.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 {
@@ -223,6 +252,7 @@ class UserMap {
         }
     }
     async unsubscribe() {
+        await this.subscription.unsubscribe();
         for (const [key, user] of this.userMap.entries()) {
             await user.unsubscribe();
             this.userMap.delete(key);
@@ -232,5 +262,14 @@ class UserMap {
             this.lastNumberOfSubAccounts = undefined;
         }
     }
+    async updateUserAccount(key, userAccount, slot) {
+        if (!this.userMap.has(key)) {
+            this.addPubkey(new web3_js_1.PublicKey(key), userAccount, slot);
+        }
+        else {
+            const user = this.userMap.get(key);
+            user.accountSubscriber.updateData(userAccount, slot);
+        }
+    }
 }
 exports.UserMap = UserMap;

package/lib/userMap/userMapConfig.d.ts

@@ -0,0 +1,21 @@
+import { Commitment, Connection } from '@solana/web3.js';
+import { DriftClient } from '../driftClient';
+export type UserAccountFilterCriteria = {
+    hasOpenOrders: boolean;
+};
+export type UserMapConfig = {
+    driftClient: DriftClient;
+    connection?: Connection;
+    subscriptionConfig: {
+        type: 'polling';
+        frequency: number;
+        commitment?: Commitment;
+    } | {
+        type: 'websocket';
+        resubTimeoutMs?: number;
+        commitment?: Commitment;
+    };
+    skipInitialLoad?: boolean;
+    includeIdle?: boolean;
+    fastDecode?: boolean;
+};

package/lib/userMap/userMapConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/userStats.d.ts

@@ -15,4 +15,5 @@ export declare class UserStats {
     getAccountAndSlot(): DataAndSlot<UserStatsAccount>;
     getAccount(): UserStatsAccount;
     getReferrerInfo(): ReferrerInfo | undefined;
+    static getOldestActionTs(account: UserStatsAccount): number;
 }

package/lib/userStats.js

@@ -48,5 +48,8 @@ class UserStats {
             };
         }
     }
+    static getOldestActionTs(account) {
+        return Math.min(account.lastFillerVolume30DTs.toNumber(), account.lastMakerVolume30DTs.toNumber(), account.lastTakerVolume30DTs.toNumber());
+    }
 }
 exports.UserStats = UserStats;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.49.0-beta.9",
+	"version": "2.52.0-beta.1",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -44,6 +44,7 @@
 		"uuid": "^8.3.2"
 	},
 	"devDependencies": {
+		"object-sizeof": "^2.6.3",
 		"@types/big.js": "^6.2.0",
 		"@types/bn.js": "^5.1.3",
 		"@types/chai": "^4.3.1",

package/src/accounts/{mockUserAccountSubscriber.ts → basicUserAccountSubscriber.ts}

@@ -4,7 +4,11 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { UserAccount } from '../types';
 
-export class MockUserAccountSubscriber implements UserAccountSubscriber {
+/**
+ * Basic implementation of UserAccountSubscriber. It will only take in UserAccount
+ * data during initialization and will not fetch or subscribe to updates.
+ */
+export class BasicUserAccountSubscriber implements UserAccountSubscriber {
 	isSubscribed: boolean;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
 	userAccountPublicKey: PublicKey;
@@ -16,8 +20,8 @@ export class MockUserAccountSubscriber implements UserAccountSubscriber {
 
 	public constructor(
 		userAccountPublicKey: PublicKey,
-		data: UserAccount,
-		slot: number
+		data?: UserAccount,
+		slot?: number
 	) {
 		this.isSubscribed = true;
 		this.eventEmitter = new EventEmitter();
@@ -46,8 +50,10 @@ export class MockUserAccountSubscriber implements UserAccountSubscriber {
 	}
 
 	public updateData(userAccount: UserAccount, slot: number): void {
-		this.user = { data: userAccount, slot };
-		this.eventEmitter.emit('userAccountUpdate', userAccount);
-		this.eventEmitter.emit('update');
+		if (!this.user || slot >= (this.user.slot ?? 0)) {
+			this.user = { data: userAccount, slot };
+			this.eventEmitter.emit('userAccountUpdate', userAccount);
+			this.eventEmitter.emit('update');
+		}
 	}
 }

package/src/accounts/bulkAccountLoader.ts

@@ -78,6 +78,7 @@ export class BulkAccountLoader {
 		if (existingAccountToLoad) {
 			existingAccountToLoad.callbacks.delete(callbackId);
 			if (existingAccountToLoad.callbacks.size === 0) {
+				this.bufferAndSlotMap.delete(publicKey.toString());
 				this.accountsToLoad.delete(existingAccountToLoad.publicKey.toString());
 			}
 		}
@@ -153,9 +154,11 @@ export class BulkAccountLoader {
 		const requests = new Array<{ methodName: string; args: any }>();
 		for (const accountsToLoadChunk of accountsToLoadChunks) {
 			const args = [
-				accountsToLoadChunk.map((accountToLoad) => {
-					return accountToLoad.publicKey.toBase58();
-				}),
+				accountsToLoadChunk
+					.filter((accountToLoad) => accountToLoad.callbacks.size > 0)
+					.map((accountToLoad) => {
+						return accountToLoad.publicKey.toBase58();
+					}),
 				{ commitment: this.commitment },
 			];
 
@@ -190,6 +193,10 @@ export class BulkAccountLoader {
 
 			const accountsToLoad = accountsToLoadChunks[i];
 			accountsToLoad.forEach((accountToLoad, j) => {
+				if (accountToLoad.callbacks.size === 0) {
+					return;
+				}
+
 				const key = accountToLoad.publicKey.toBase58();
 				const oldRPCResponse = this.bufferAndSlotMap.get(key);
 

package/src/accounts/oneShotUserAccountSubscriber.ts

@@ -0,0 +1,64 @@
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { UserAccount } from '../types';
+import { BasicUserAccountSubscriber } from './basicUserAccountSubscriber';
+import { Program } from '@coral-xyz/anchor';
+
+/**
+ * Simple implementation of UserAccountSubscriber. It will fetch the UserAccount
+ * date on subscribe (or call to fetch) if no account data is provided on init.
+ * Expect to use only 1 RPC call unless you call fetch repeatedly.
+ */
+export class OneShotUserAccountSubscriber extends BasicUserAccountSubscriber {
+	program: Program;
+	commitment: Commitment;
+
+	public constructor(
+		program: Program,
+		userAccountPublicKey: PublicKey,
+		data?: UserAccount,
+		slot?: number,
+		commitment?: Commitment
+	) {
+		super(userAccountPublicKey, data, slot);
+		this.program = program;
+		this.commitment = commitment ?? 'confirmed';
+	}
+
+	async subscribe(userAccount?: UserAccount): Promise<boolean> {
+		if (userAccount) {
+			this.user = { data: userAccount, slot: this.user.slot };
+			return true;
+		}
+
+		await this.fetchIfUnloaded();
+		if (this.doesAccountExist()) {
+			this.eventEmitter.emit('update');
+		}
+		return true;
+	}
+
+	async fetchIfUnloaded(): Promise<void> {
+		if (this.user.data === undefined) {
+			await this.fetch();
+		}
+	}
+
+	async fetch(): Promise<void> {
+		try {
+			const dataAndContext = await this.program.account.user.fetchAndContext(
+				this.userAccountPublicKey,
+				this.commitment
+			);
+			if (dataAndContext.context.slot > (this.user?.slot ?? 0)) {
+				this.user = {
+					data: dataAndContext.data as UserAccount,
+					slot: dataAndContext.context.slot,
+				};
+			}
+		} catch (e) {
+			console.error(
+				`OneShotUserAccountSubscriber.fetch() UserAccount does not exist: ${e.message}`
+			);
+		}
+	}
+}

package/src/accounts/pollingInsuranceFundStakeAccountSubscriber.ts

@@ -54,6 +54,7 @@ export class PollingInsuranceFundStakeAccountSubscriber
 
 		await this.addToAccountLoader();
 
+		await this.fetchIfUnloaded();
 		if (this.doesAccountExist()) {
 			this.eventEmitter.emit('update');
 		}

package/src/adminClient.ts

@@ -846,6 +846,20 @@ export class AdminClient extends DriftClient {
 		);
 	}
 
+	public async updateStateMaxInitializeUserFee(
+		maxInitializeUserFee: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateStateMaxInitializeUserFee(
+			maxInitializeUserFee,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+				},
+			}
+		);
+	}
+
 	public async updateWithdrawGuardThreshold(
 		spotMarketIndex: number,
 		withdrawGuardThreshold: BN
@@ -1167,6 +1181,19 @@ export class AdminClient extends DriftClient {
 		});
 	}
 
+	public async updatePhoenixFulfillmentConfigStatus(
+		phoenixFulfillmentConfig: PublicKey,
+		status: SpotFulfillmentConfigStatus
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.phoenixFulfillmentConfigStatus(status, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				phoenixFulfillmentConfig,
+			},
+		});
+	}
+
 	public async updateSpotMarketExpiry(
 		spotMarketIndex: number,
 		expiryTs: BN

package/src/constants/numericConstants.ts

@@ -99,3 +99,7 @@ export const OPEN_ORDER_MARGIN_REQUIREMENT = QUOTE_PRECISION.div(new BN(100));
 export const DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT = new BN(
 	-25
 ).mul(QUOTE_PRECISION);
+
+export const ACCOUNT_AGE_DELETION_CUTOFF_SECONDS = 60 * 60 * 24 * 13; // 13 days
+export const IDLE_TIME_SLOTS = 9000;
+export const SLOT_TIME_ESTIMATE_MS = 400;