@drift-labs/sdk 2.49.0-beta.1 → 2.49.0-beta.11

package/lib/userMap/userMap.js

@@ -5,33 +5,46 @@ 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");
 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;
         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;
+        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,
+            });
+        }
     }
     async subscribe() {
         if (this.size() > 0) {
@@ -41,13 +54,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.BasicUserAccountSubscriber(userAccountPublicKey, userAccount, slot),
+            },
         });
         await user.subscribe(userAccount);
         this.userMap.set(userAccountPublicKey.toString(), user);
@@ -148,11 +164,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 +196,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 +204,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,9 +215,11 @@ 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.driftClient.program.account.user.coder.accounts.decodeUnchecked('User', buffer);
                     await this.addPubkey(new web3_js_1.PublicKey(key), userAccount);
                 }
+                // 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)) {
@@ -205,16 +227,15 @@ class UserMap {
                     this.userMap.delete(key);
                 }
                 else {
-                    const userAccount = this.driftClient.program.account.user.coder.accounts.decode('User', programAccountBufferMap.get(key));
+                    const userAccount = this.driftClient.program.account.user.coder.accounts.decodeUnchecked('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 +244,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 +254,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,20 @@
+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;
+};

package/lib/userMap/userMapConfig.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.49.0-beta.1",
+	"version": "2.49.0-beta.11",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

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

@@ -4,7 +4,7 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { UserAccount } from '../types';
 
-export class MockUserAccountSubscriber implements UserAccountSubscriber {
+export class BasicUserAccountSubscriber implements UserAccountSubscriber {
 	isSubscribed: boolean;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
 	userAccountPublicKey: PublicKey;
@@ -16,8 +16,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 +46,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/pollingInsuranceFundStakeAccountSubscriber.ts

@@ -0,0 +1,185 @@
+import {
+	DataAndSlot,
+	NotSubscribedError,
+	InsuranceFundStakeAccountEvents,
+	InsuranceFundStakeAccountSubscriber,
+} from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { InsuranceFundStake } from '../types';
+
+export class PollingInsuranceFundStakeAccountSubscriber
+	implements InsuranceFundStakeAccountSubscriber
+{
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<
+		EventEmitter,
+		InsuranceFundStakeAccountEvents
+	>;
+	insuranceFundStakeAccountPublicKey: PublicKey;
+
+	accountLoader: BulkAccountLoader;
+	callbackId?: string;
+	errorCallbackId?: string;
+
+	insuranceFundStakeAccountAndSlot?: DataAndSlot<InsuranceFundStake>;
+
+	public constructor(
+		program: Program,
+		publicKey: PublicKey,
+		accountLoader: BulkAccountLoader
+	) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.insuranceFundStakeAccountPublicKey = publicKey;
+		this.accountLoader = accountLoader;
+		this.eventEmitter = new EventEmitter();
+	}
+
+	async subscribe(insuranceFundStake?: InsuranceFundStake): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		if (insuranceFundStake) {
+			this.insuranceFundStakeAccountAndSlot = {
+				data: insuranceFundStake,
+				slot: undefined,
+			};
+		}
+
+		await this.addToAccountLoader();
+
+		if (this.doesAccountExist()) {
+			this.eventEmitter.emit('update');
+		}
+
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async addToAccountLoader(): Promise<void> {
+		if (this.callbackId) {
+			return;
+		}
+
+		this.callbackId = await this.accountLoader.addAccount(
+			this.insuranceFundStakeAccountPublicKey,
+			(buffer, slot: number) => {
+				if (!buffer) {
+					return;
+				}
+
+				if (
+					this.insuranceFundStakeAccountAndSlot &&
+					this.insuranceFundStakeAccountAndSlot.slot > slot
+				) {
+					return;
+				}
+
+				const account = this.program.account.user.coder.accounts.decode(
+					'InsuranceFundStake',
+					buffer
+				);
+				this.insuranceFundStakeAccountAndSlot = { data: account, slot };
+				this.eventEmitter.emit('insuranceFundStakeAccountUpdate', account);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+			this.eventEmitter.emit('error', error);
+		});
+	}
+
+	async fetchIfUnloaded(): Promise<void> {
+		if (this.insuranceFundStakeAccountAndSlot === undefined) {
+			await this.fetch();
+		}
+	}
+
+	async fetch(): Promise<void> {
+		try {
+			const dataAndContext =
+				await this.program.account.insuranceFundStake.fetchAndContext(
+					this.insuranceFundStakeAccountPublicKey,
+					this.accountLoader.commitment
+				);
+			if (
+				dataAndContext.context.slot >
+				(this.insuranceFundStakeAccountAndSlot?.slot ?? 0)
+			) {
+				this.insuranceFundStakeAccountAndSlot = {
+					data: dataAndContext.data as InsuranceFundStake,
+					slot: dataAndContext.context.slot,
+				};
+			}
+		} catch (e) {
+			console.log(
+				`PollingInsuranceFundStakeAccountSubscriber.fetch() InsuranceFundStake does not exist: ${e.message}`
+			);
+		}
+	}
+
+	doesAccountExist(): boolean {
+		return this.insuranceFundStakeAccountAndSlot !== undefined;
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		this.accountLoader.removeAccount(
+			this.insuranceFundStakeAccountPublicKey,
+			this.callbackId
+		);
+		this.callbackId = undefined;
+
+		this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+		this.errorCallbackId = undefined;
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getInsuranceFundStakeAccountAndSlot(): DataAndSlot<InsuranceFundStake> {
+		this.assertIsSubscribed();
+		return this.insuranceFundStakeAccountAndSlot;
+	}
+
+	didSubscriptionSucceed(): boolean {
+		return !!this.insuranceFundStakeAccountAndSlot;
+	}
+
+	public updateData(
+		insuranceFundStake: InsuranceFundStake,
+		slot: number
+	): void {
+		if (
+			!this.insuranceFundStakeAccountAndSlot ||
+			this.insuranceFundStakeAccountAndSlot.slot < slot
+		) {
+			this.insuranceFundStakeAccountAndSlot = {
+				data: insuranceFundStake,
+				slot,
+			};
+			this.eventEmitter.emit(
+				'insuranceFundStakeAccountUpdate',
+				insuranceFundStake
+			);
+			this.eventEmitter.emit('update');
+		}
+	}
+}

package/src/accounts/types.ts

@@ -5,6 +5,7 @@ import {
 	StateAccount,
 	UserAccount,
 	UserStatsAccount,
+	InsuranceFundStake,
 } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
@@ -105,6 +106,26 @@ export interface TokenAccountSubscriber {
 	getTokenAccountAndSlot(): DataAndSlot<Account>;
 }
 
+export interface InsuranceFundStakeAccountSubscriber {
+	eventEmitter: StrictEventEmitter<
+		EventEmitter,
+		InsuranceFundStakeAccountEvents
+	>;
+	isSubscribed: boolean;
+
+	subscribe(): Promise<boolean>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	getInsuranceFundStakeAccountAndSlot(): DataAndSlot<InsuranceFundStake>;
+}
+
+export interface InsuranceFundStakeAccountEvents {
+	insuranceFundStakeAccountUpdate: (payload: InsuranceFundStake) => void;
+	update: void;
+	error: (e: Error) => void;
+}
+
 export interface OracleEvents {
 	oracleUpdate: (payload: OraclePriceData) => void;
 	update: void;

package/src/accounts/webSocketInsuranceFundStakeAccountSubscriber.ts

@@ -0,0 +1,127 @@
+import {
+	DataAndSlot,
+	AccountSubscriber,
+	NotSubscribedError,
+	InsuranceFundStakeAccountEvents,
+	InsuranceFundStakeAccountSubscriber,
+} from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
+import { InsuranceFundStake } from '../types';
+
+export class WebSocketInsuranceFundStakeAccountSubscriber
+	implements InsuranceFundStakeAccountSubscriber
+{
+	isSubscribed: boolean;
+	reconnectTimeoutMs?: number;
+	commitment?: Commitment;
+	program: Program;
+	eventEmitter: StrictEventEmitter<
+		EventEmitter,
+		InsuranceFundStakeAccountEvents
+	>;
+	insuranceFundStakeAccountPublicKey: PublicKey;
+
+	insuranceFundStakeDataAccountSubscriber: AccountSubscriber<InsuranceFundStake>;
+
+	public constructor(
+		program: Program,
+		insuranceFundStakeAccountPublicKey: PublicKey,
+		reconnectTimeoutMs?: number,
+		commitment?: Commitment
+	) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.insuranceFundStakeAccountPublicKey =
+			insuranceFundStakeAccountPublicKey;
+		this.eventEmitter = new EventEmitter();
+		this.reconnectTimeoutMs = reconnectTimeoutMs;
+		this.commitment = commitment;
+	}
+
+	async subscribe(
+		insuranceFundStakeAccount?: InsuranceFundStake
+	): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		this.insuranceFundStakeDataAccountSubscriber =
+			new WebSocketAccountSubscriber(
+				'insuranceFundStake',
+				this.program,
+				this.insuranceFundStakeAccountPublicKey,
+				undefined,
+				this.reconnectTimeoutMs,
+				this.commitment
+			);
+
+		if (insuranceFundStakeAccount) {
+			this.insuranceFundStakeDataAccountSubscriber.setData(
+				insuranceFundStakeAccount
+			);
+		}
+
+		await this.insuranceFundStakeDataAccountSubscriber.subscribe(
+			(data: InsuranceFundStake) => {
+				this.eventEmitter.emit('insuranceFundStakeAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.eventEmitter.emit('update');
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async fetch(): Promise<void> {
+		await Promise.all([this.insuranceFundStakeDataAccountSubscriber.fetch()]);
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		await Promise.all([
+			this.insuranceFundStakeDataAccountSubscriber.unsubscribe(),
+		]);
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getInsuranceFundStakeAccountAndSlot(): DataAndSlot<InsuranceFundStake> {
+		this.assertIsSubscribed();
+		return this.insuranceFundStakeDataAccountSubscriber.dataAndSlot;
+	}
+
+	public updateData(
+		insuranceFundStake: InsuranceFundStake,
+		slot: number
+	): void {
+		const currentDataSlot =
+			this.insuranceFundStakeDataAccountSubscriber.dataAndSlot?.slot || 0;
+		if (currentDataSlot <= slot) {
+			this.insuranceFundStakeDataAccountSubscriber.setData(
+				insuranceFundStake,
+				slot
+			);
+			this.eventEmitter.emit(
+				'insuranceFundStakeAccountUpdate',
+				insuranceFundStake
+			);
+			this.eventEmitter.emit('update');
+		}
+	}
+}