@drift-labs/sdk 2.25.4 → 2.26.0-beta.0

package/lib/userMap/userMap.d.ts

@@ -1,7 +1,8 @@
-import { User, DriftClient, OrderRecord, UserSubscriptionConfig, WrappedEvent } from '..';
+import { User, DriftClient, UserAccount, OrderRecord, UserSubscriptionConfig, WrappedEvent, DLOB } from '..';
 import { PublicKey } from '@solana/web3.js';
 export interface UserMapInterface {
-    fetchAllUsers(): Promise<void>;
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
     addPubkey(userAccountPublicKey: PublicKey): Promise<void>;
     has(key: string): boolean;
     get(key: string): User | undefined;
@@ -14,9 +15,12 @@ export declare class UserMap implements UserMapInterface {
     private userMap;
     private driftClient;
     private accountSubscription;
-    constructor(driftClient: DriftClient, accountSubscription: UserSubscriptionConfig);
-    fetchAllUsers(includeIdle?: boolean): Promise<void>;
-    addPubkey(userAccountPublicKey: PublicKey): Promise<void>;
+    private includeIdle;
+    private lastNumberOfSubAccounts;
+    private syncCallback;
+    constructor(driftClient: DriftClient, accountSubscription: UserSubscriptionConfig, includeIdle?: boolean);
+    subscribe(): Promise<void>;
+    addPubkey(userAccountPublicKey: PublicKey, userAccount?: UserAccount): Promise<void>;
     has(key: string): boolean;
     /**
      * gets the User for a particular userAccountPublicKey, if no User exists, undefined is returned
@@ -36,9 +40,16 @@ export declare class UserMap implements UserMapInterface {
      * @returns authority PublicKey | undefined
      */
     getUserAuthority(key: string): PublicKey | undefined;
+    /**
+     * implements the {@link DLOBSource} interface
+     * create a DLOB from all the subscribed users
+     * @param slot
+     */
+    getDLOB(slot: number): Promise<DLOB>;
     updateWithOrderRecord(record: OrderRecord): Promise<void>;
     updateWithEventRecord(record: WrappedEvent<any>): Promise<void>;
     values(): IterableIterator<User>;
     size(): number;
-    sync(includeIdle?: boolean): Promise<void>;
+    sync(): Promise<void>;
+    unsubscribe(): Promise<void>;
 }

package/lib/userMap/userMap.js

@@ -6,46 +6,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserMap = void 0;
 const __1 = require("..");
 const web3_js_1 = require("@solana/web3.js");
+const buffer_1 = require("buffer");
 const bs58_1 = __importDefault(require("bs58"));
 class UserMap {
-    constructor(driftClient, accountSubscription) {
+    constructor(driftClient, accountSubscription, includeIdle = true) {
         this.userMap = new Map();
+        this.syncCallback = async (state) => {
+            if (state.numberOfSubAccounts !== this.lastNumberOfSubAccounts) {
+                await this.sync();
+                this.lastNumberOfSubAccounts = state.numberOfSubAccounts;
+            }
+        };
         this.driftClient = driftClient;
         this.accountSubscription = accountSubscription;
+        this.includeIdle = includeIdle;
     }
-    async fetchAllUsers(includeIdle = true) {
-        const userArray = [];
-        const userAccountArray = [];
-        const programUserAccounts = await this.driftClient.fetchAllUserAccounts(includeIdle);
-        for (const programUserAccount of programUserAccounts) {
-            if (this.userMap.has(programUserAccount.publicKey.toString())) {
-                continue;
-            }
-            const user = new __1.User({
-                driftClient: this.driftClient,
-                userAccountPublicKey: programUserAccount.publicKey,
-                accountSubscription: this.accountSubscription,
-            });
-            userArray.push(user);
-            userAccountArray.push(programUserAccount.account);
-        }
-        if (this.accountSubscription.type === 'polling') {
-            await (0, __1.bulkPollingUserSubscribe)(userArray, this.accountSubscription.accountLoader);
-        }
-        else {
-            await Promise.all(userArray.map((user, i) => user.subscribe(userAccountArray[i])));
-        }
-        for (const user of userArray) {
-            this.userMap.set(user.getUserAccountPublicKey().toString(), user);
-        }
+    async subscribe() {
+        if (this.size() > 0) {
+            return;
+        }
+        await this.driftClient.subscribe();
+        this.lastNumberOfSubAccounts =
+            this.driftClient.getStateAccount().numberOfSubAccounts;
+        this.driftClient.eventEmitter.on('stateAccountUpdate', this.syncCallback);
+        await this.sync();
     }
-    async addPubkey(userAccountPublicKey) {
+    async addPubkey(userAccountPublicKey, userAccount) {
         const user = new __1.User({
             driftClient: this.driftClient,
             userAccountPublicKey,
             accountSubscription: this.accountSubscription,
         });
-        await user.subscribe();
+        await user.subscribe(userAccount);
         this.userMap.set(userAccountPublicKey.toString(), user);
     }
     has(key) {
@@ -83,6 +75,16 @@ class UserMap {
         }
         return chUser.getUserAccount().authority;
     }
+    /**
+     * implements the {@link DLOBSource} interface
+     * create a DLOB from all the subscribed users
+     * @param slot
+     */
+    async getDLOB(slot) {
+        const dlob = new __1.DLOB();
+        await dlob.initFromUserMap(this, slot);
+        return dlob;
+    }
     async updateWithOrderRecord(record) {
         if (!this.has(record.user.toString())) {
             await this.addPubkey(record.user);
@@ -134,9 +136,9 @@ class UserMap {
     size() {
         return this.userMap.size;
     }
-    async sync(includeIdle = true) {
+    async sync() {
         let filters = undefined;
-        if (!includeIdle) {
+        if (!this.includeIdle) {
             filters = [
                 {
                     memcmp: {
@@ -146,29 +148,55 @@ class UserMap {
                 },
             ];
         }
-        const programAccounts = await this.driftClient.connection.getProgramAccounts(this.driftClient.program.programId, {
-            commitment: this.driftClient.connection.commitment,
-            filters: [
-                {
-                    memcmp: this.driftClient.program.coder.accounts.memcmp('User'),
-                },
-                ...(Array.isArray(filters) ? filters : []),
-            ],
-        });
-        const programAccountMap = new Map();
-        for (const programAccount of programAccounts) {
-            programAccountMap.set(programAccount.pubkey.toString(), programAccount.account);
-        }
-        for (const key of programAccountMap.keys()) {
+        const rpcRequestArgs = [
+            this.driftClient.program.programId.toBase58(),
+            {
+                commitment: this.driftClient.connection.commitment,
+                filters: [
+                    {
+                        memcmp: this.driftClient.program.coder.accounts.memcmp('User'),
+                    },
+                    ...(Array.isArray(filters) ? filters : []),
+                ],
+                encoding: 'base64',
+                withContext: true,
+            },
+        ];
+        // @ts-ignore
+        const rpcJSONResponse = await this.driftClient.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
+        const rpcResponseAndContext = rpcJSONResponse.result;
+        const slot = rpcResponseAndContext.context.slot;
+        const programAccountBufferMap = new Map();
+        for (const programAccount of rpcResponseAndContext.value) {
+            programAccountBufferMap.set(programAccount.pubkey.toString(), 
+            // @ts-ignore
+            buffer_1.Buffer.from(programAccount.account.data[0], programAccount.account.data[1]));
+        }
+        for (const [key, buffer] of programAccountBufferMap.entries()) {
             if (!this.has(key)) {
-                await this.addPubkey(new web3_js_1.PublicKey(key));
+                const userAccount = this.driftClient.program.account.user.coder.accounts.decode('User', buffer);
+                await this.addPubkey(new web3_js_1.PublicKey(key), userAccount);
             }
         }
         for (const [key, user] of this.userMap.entries()) {
-            if (!programAccountMap.has(key)) {
+            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);
+            }
+        }
+    }
+    async unsubscribe() {
+        for (const [key, user] of this.userMap.entries()) {
+            await user.unsubscribe();
+            this.userMap.delete(key);
+        }
+        if (this.lastNumberOfSubAccounts) {
+            this.driftClient.eventEmitter.removeListener('stateAccountUpdate', this.syncCallback);
+            this.lastNumberOfSubAccounts = undefined;
         }
     }
 }

package/lib/userMap/userStatsMap.d.ts

@@ -1,4 +1,4 @@
-import { DriftClient, OrderRecord, UserStats, UserStatsSubscriptionConfig, WrappedEvent } from '..';
+import { DriftClient, OrderRecord, UserStatsAccount, UserStats, UserStatsSubscriptionConfig, WrappedEvent } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { UserMap } from './userMap';
 export declare class UserStatsMap {
@@ -8,9 +8,11 @@ export declare class UserStatsMap {
     private userStatsMap;
     private driftClient;
     private accountSubscription;
+    private lastNumberOfAuthorities;
+    private syncCallback;
     constructor(driftClient: DriftClient, accountSubscription: UserStatsSubscriptionConfig);
-    fetchAllUserStats(): Promise<void>;
-    addUserStat(authority: PublicKey): Promise<void>;
+    subscribe(): Promise<void>;
+    addUserStat(authority: PublicKey, userStatsAccount?: UserStatsAccount): Promise<void>;
     updateWithOrderRecord(record: OrderRecord, userMap: UserMap): Promise<void>;
     updateWithEventRecord(record: WrappedEvent<any>, userMap?: UserMap): Promise<void>;
     has(authorityPublicKey: string): boolean;
@@ -19,4 +21,5 @@ export declare class UserStatsMap {
     values(): IterableIterator<UserStats>;
     size(): number;
     sync(): Promise<void>;
+    unsubscribe(): Promise<void>;
 }

package/lib/userMap/userStatsMap.js

@@ -9,49 +9,38 @@ class UserStatsMap {
          * map from authority pubkey to UserStats
          */
         this.userStatsMap = new Map();
+        this.syncCallback = async (state) => {
+            if (state.numberOfAuthorities !== this.lastNumberOfAuthorities) {
+                await this.sync();
+                this.lastNumberOfAuthorities = state.numberOfAuthorities;
+            }
+        };
         this.driftClient = driftClient;
         this.accountSubscription = accountSubscription;
     }
-    async fetchAllUserStats() {
-        const userStatArray = [];
-        const userStatsAccountArray = [];
-        const programUserAccounts = (await this.driftClient.program.account.userStats.all());
-        for (const programUserAccount of programUserAccounts) {
-            const userStat = programUserAccount.account;
-            if (this.userStatsMap.has(userStat.authority.toString())) {
-                continue;
-            }
-            const chUserStat = new __1.UserStats({
-                driftClient: this.driftClient,
-                userStatsAccountPublicKey: programUserAccount.publicKey,
-                accountSubscription: this.accountSubscription,
-            });
-            userStatArray.push(chUserStat);
-            userStatsAccountArray.push(userStat);
-        }
-        if (this.accountSubscription.type === 'polling') {
-            await (0, __1.bulkPollingUserStatsSubscribe)(userStatArray, this.accountSubscription.accountLoader);
-        }
-        else {
-            await Promise.all(userStatArray.map((userStat, i) => userStat.subscribe(userStatsAccountArray[i])));
-        }
-        for (const userStat of userStatArray) {
-            this.userStatsMap.set(userStat.getAccount().authority.toString(), userStat);
-        }
+    async subscribe() {
+        if (this.size() > 0) {
+            return;
+        }
+        await this.driftClient.subscribe();
+        this.lastNumberOfAuthorities =
+            this.driftClient.getStateAccount().numberOfAuthorities;
+        this.driftClient.eventEmitter.on('stateAccountUpdate', this.syncCallback);
+        await this.sync();
     }
-    async addUserStat(authority) {
+    async addUserStat(authority, userStatsAccount) {
         const userStat = new __1.UserStats({
             driftClient: this.driftClient,
             userStatsAccountPublicKey: (0, __1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, authority),
             accountSubscription: this.accountSubscription,
         });
-        await userStat.subscribe();
+        await userStat.subscribe(userStatsAccount);
         this.userStatsMap.set(authority.toString(), userStat);
     }
     async updateWithOrderRecord(record, userMap) {
         const user = await userMap.mustGet(record.user.toString());
         if (!this.has(user.getUserAccount().authority.toString())) {
-            this.addUserStat(user.getUserAccount().authority);
+            await this.addUserStat(user.getUserAccount().authority);
         }
     }
     async updateWithEventRecord(record, userMap) {
@@ -152,9 +141,20 @@ class UserStatsMap {
         }
         for (const key of programAccountMap.keys()) {
             if (!this.has(key)) {
-                await this.addUserStat(new web3_js_1.PublicKey(key));
+                const userStatsAccount = this.driftClient.program.account.userStats.coder.accounts.decode('UserStats', programAccountMap.get(key).data);
+                await this.addUserStat(new web3_js_1.PublicKey(key), userStatsAccount);
             }
         }
     }
+    async unsubscribe() {
+        for (const [key, userStats] of this.userStatsMap.entries()) {
+            await userStats.unsubscribe();
+            this.userStatsMap.delete(key);
+        }
+        if (this.lastNumberOfAuthorities) {
+            this.driftClient.eventEmitter.removeListener('stateAccountUpdate', this.syncCallback);
+            this.lastNumberOfAuthorities = undefined;
+        }
+    }
 }
 exports.UserStatsMap = UserStatsMap;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.25.4",
+	"version": "2.26.0-beta.0",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -34,6 +34,7 @@
 	},
 	"dependencies": {
 		"@coral-xyz/anchor": "0.26.0",
+		"@ellipsis-labs/phoenix-sdk": "^1.3.2",
 		"@project-serum/serum": "^0.13.38",
 		"@pythnetwork/client": "2.5.3",
 		"@solana/spl-token": "^0.1.6",

package/src/accounts/pollingUserAccountSubscriber.ts

@@ -1,6 +1,5 @@
 import {
 	DataAndSlot,
-	AccountToPoll,
 	NotSubscribedError,
 	UserAccountEvents,
 	UserAccountSubscriber,
@@ -11,7 +10,6 @@ import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
 import { UserAccount } from '../types';
 import { BulkAccountLoader } from './bulkAccountLoader';
-import { capitalize } from './utils';
 
 export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 	isSubscribed: boolean;
@@ -20,7 +18,7 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 	userAccountPublicKey: PublicKey;
 
 	accountLoader: BulkAccountLoader;
-	accountsToPoll = new Map<string, AccountToPoll>();
+	callbackId?: string;
 	errorCallbackId?: string;
 
 	user?: DataAndSlot<UserAccount>;
@@ -37,15 +35,19 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 		this.userAccountPublicKey = userAccountPublicKey;
 	}
 
-	async subscribe(): Promise<boolean> {
+	async subscribe(userAccount?: UserAccount): Promise<boolean> {
 		if (this.isSubscribed) {
 			return true;
 		}
 
+		if (userAccount) {
+			this.user = { data: userAccount, slot: undefined };
+		}
+
 		await this.addToAccountLoader();
 
 		await this.fetchIfUnloaded();
-		if (this.doAccountsExist()) {
+		if (this.doesAccountExist()) {
 			this.eventEmitter.emit('update');
 		}
 
@@ -54,34 +56,30 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 	}
 
 	async addToAccountLoader(): Promise<void> {
-		if (this.accountsToPoll.size > 0) {
+		if (this.callbackId) {
 			return;
 		}
 
-		this.accountsToPoll.set(this.userAccountPublicKey.toString(), {
-			key: 'user',
-			publicKey: this.userAccountPublicKey,
-			eventType: 'userAccountUpdate',
-		});
+		this.callbackId = await this.accountLoader.addAccount(
+			this.userAccountPublicKey,
+			(buffer, slot: number) => {
+				if (!buffer) {
+					return;
+				}
 
-		for (const [_, accountToPoll] of this.accountsToPoll) {
-			accountToPoll.callbackId = await this.accountLoader.addAccount(
-				accountToPoll.publicKey,
-				(buffer, slot) => {
-					if (!buffer) {
-						return;
-					}
-
-					const account = this.program.account[
-						accountToPoll.key
-					].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
-					this[accountToPoll.key] = { data: account, slot };
-					// @ts-ignore
-					this.eventEmitter.emit(accountToPoll.eventType, account);
-					this.eventEmitter.emit('update');
+				if (this.user && this.user.slot > slot) {
+					return;
 				}
-			);
-		}
+
+				const account = this.program.account.user.coder.accounts.decode(
+					'User',
+					buffer
+				);
+				this.user = { data: account, slot };
+				this.eventEmitter.emit('userAccountUpdate', account);
+				this.eventEmitter.emit('update');
+			}
+		);
 
 		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
 			this.eventEmitter.emit('error', error);
@@ -89,43 +87,28 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 	}
 
 	async fetchIfUnloaded(): Promise<void> {
-		let shouldFetch = false;
-		for (const [_, accountToPoll] of this.accountsToPoll) {
-			if (this[accountToPoll.key] === undefined) {
-				shouldFetch = true;
-				break;
-			}
-		}
-
-		if (shouldFetch) {
+		if (this.user === undefined) {
 			await this.fetch();
 		}
 	}
 
 	async fetch(): Promise<void> {
 		await this.accountLoader.load();
-		for (const [_, accountToPoll] of this.accountsToPoll) {
-			const { buffer, slot } = this.accountLoader.getBufferAndSlot(
-				accountToPoll.publicKey
+		const { buffer, slot } = this.accountLoader.getBufferAndSlot(
+			this.userAccountPublicKey
+		);
+		const currentSlot = this.user?.slot ?? 0;
+		if (buffer && slot > currentSlot) {
+			const account = this.program.account.user.coder.accounts.decode(
+				'User',
+				buffer
 			);
-			if (buffer) {
-				const account = this.program.account[
-					accountToPoll.key
-				].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
-				this[accountToPoll.key] = { data: account, slot };
-			}
+			this.user = { data: account, slot };
 		}
 	}
 
-	doAccountsExist(): boolean {
-		let success = true;
-		for (const [_, accountToPoll] of this.accountsToPoll) {
-			if (!this[accountToPoll.key]) {
-				success = false;
-				break;
-			}
-		}
-		return success;
+	doesAccountExist(): boolean {
+		return this.user !== undefined;
 	}
 
 	async unsubscribe(): Promise<void> {
@@ -133,18 +116,15 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 			return;
 		}
 
-		for (const [_, accountToPoll] of this.accountsToPoll) {
-			this.accountLoader.removeAccount(
-				accountToPoll.publicKey,
-				accountToPoll.callbackId
-			);
-		}
+		this.accountLoader.removeAccount(
+			this.userAccountPublicKey,
+			this.callbackId
+		);
+		this.callbackId = undefined;
 
 		this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
 		this.errorCallbackId = undefined;
 
-		this.accountsToPoll.clear();
-
 		this.isSubscribed = false;
 	}
 
@@ -160,4 +140,12 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 		this.assertIsSubscribed();
 		return this.user;
 	}
+
+	public updateData(userAccount: UserAccount, slot: number): void {
+		if (!this.user || this.user.slot < slot) {
+			this.user = { data: userAccount, slot };
+			this.eventEmitter.emit('userAccountUpdate', userAccount);
+			this.eventEmitter.emit('update');
+		}
+	}
 }