@drift-labs/sdk 2.66.0-beta.1 → 2.66.0-beta.3

package/VERSION

@@ -1 +1 @@
-2.66.0-beta.1
+2.66.0-beta.3

package/lib/accounts/oneShotUserAccountSubscriber.d.ts

@@ -2,12 +2,13 @@ import { Commitment, PublicKey } from '@solana/web3.js';
 import { UserAccount } from '../types';
 import { BasicUserAccountSubscriber } from './basicUserAccountSubscriber';
 import { Program } from '@coral-xyz/anchor';
+import { UserAccountSubscriber } from './types';
 /**
  * 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 declare class OneShotUserAccountSubscriber extends BasicUserAccountSubscriber {
+export declare class OneShotUserAccountSubscriber extends BasicUserAccountSubscriber implements UserAccountSubscriber {
     program: Program;
     commitment: Commitment;
     constructor(program: Program, userAccountPublicKey: PublicKey, data?: UserAccount, slot?: number, commitment?: Commitment);

package/lib/userMap/PollingSubscription.d.ts

@@ -1,9 +1,10 @@
+/// <reference types="node" />
 import { UserMap } from './userMap';
 export declare class PollingSubscription {
     private userMap;
     private frequency;
     private skipInitialLoad;
-    intervalId?: ReturnType<typeof setTimeout>;
+    intervalId?: NodeJS.Timeout;
     constructor({ userMap, frequency, skipInitialLoad, }: {
         userMap: UserMap;
         frequency: number;

package/lib/userMap/PollingSubscription.js

@@ -8,15 +8,17 @@ class PollingSubscription {
         this.skipInitialLoad = skipInitialLoad;
     }
     async subscribe() {
-        if (this.intervalId) {
+        if (this.intervalId || this.frequency <= 0) {
             return;
         }
-        if (this.frequency > 0) {
-            this.intervalId = setInterval(this.userMap.sync.bind(this.userMap), this.frequency);
-        }
+        const executeSync = async () => {
+            await this.userMap.sync();
+            this.intervalId = setTimeout(executeSync, this.frequency);
+        };
         if (!this.skipInitialLoad) {
             await this.userMap.sync();
         }
+        executeSync();
     }
     async unsubscribe() {
         if (this.intervalId) {

package/lib/userMap/userMap.js

@@ -225,6 +225,7 @@ class UserMap {
         return userAuthKeys;
     }
     async sync() {
+        var _a;
         if (this.syncPromise) {
             return this.syncPromise;
         }
@@ -245,43 +246,44 @@ class UserMap {
                     withContext: true,
                 },
             ];
-            const rpcJSONResponse = 
             // @ts-ignore
-            await this.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
+            const rpcJSONResponse = await this.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
             const rpcResponseAndContext = rpcJSONResponse.result;
             const slot = rpcResponseAndContext.context.slot;
             this.updateLatestSlot(slot);
             const programAccountBufferMap = new Map();
-            for (const programAccount of rpcResponseAndContext.value) {
+            rpcResponseAndContext.value.forEach((programAccount) => {
                 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)) {
-                    const userAccount = this.decode('User', buffer);
-                    await this.addPubkey(new web3_js_1.PublicKey(key), userAccount, slot);
-                    this.get(key).accountSubscriber.updateData(userAccount, slot);
+            });
+            const promises = Array.from(programAccountBufferMap.entries()).map(([key, buffer]) => (async () => {
+                const currAccountWithSlot = this.getWithSlot(key);
+                if (currAccountWithSlot) {
+                    if (slot >= currAccountWithSlot.slot) {
+                        const userAccount = this.decode('User', buffer);
+                        this.updateUserAccount(key, userAccount, slot);
+                    }
                 }
                 else {
                     const userAccount = this.decode('User', buffer);
-                    this.get(key).accountSubscriber.updateData(userAccount, slot);
+                    await this.addPubkey(new web3_js_1.PublicKey(key), userAccount, slot);
                 }
-                // give event loop a chance to breathe
-                await new Promise((resolve) => setTimeout(resolve, 0));
-            }
-            for (const [key, user] of this.entries()) {
+            })());
+            await Promise.all(promises);
+            for (const [key] of this.entries()) {
                 if (!programAccountBufferMap.has(key)) {
-                    await user.unsubscribe();
-                    this.userMap.delete(key);
+                    const user = this.get(key);
+                    if (user) {
+                        await user.unsubscribe();
+                        this.userMap.delete(key);
+                    }
                 }
-                // give event loop a chance to breathe
-                await new Promise((resolve) => setTimeout(resolve, 0));
             }
         }
-        catch (e) {
-            console.error(`Error in UserMap.sync():`);
-            console.error(e);
+        catch (err) {
+            const e = err;
+            console.error(`Error in UserMap.sync(): ${e.message} ${(_a = e.stack) !== null && _a !== void 0 ? _a : ''}`);
         }
         finally {
             this.syncPromiseResolver();
@@ -302,17 +304,19 @@ class UserMap {
         }
     }
     async updateUserAccount(key, userAccount, slot) {
+        const userWithSlot = this.getWithSlot(key);
         this.updateLatestSlot(slot);
-        if (!this.has(key)) {
-            this.addPubkey(new web3_js_1.PublicKey(key), userAccount, slot);
+        if (userWithSlot) {
+            if (slot >= userWithSlot.slot) {
+                userWithSlot.data.accountSubscriber.updateData(userAccount, slot);
+                this.userMap.set(key, {
+                    data: userWithSlot.data,
+                    slot,
+                });
+            }
         }
         else {
-            const user = this.get(key);
-            user.accountSubscriber.updateData(userAccount, slot);
-            this.userMap.set(key, {
-                data: user,
-                slot,
-            });
+            this.addPubkey(new web3_js_1.PublicKey(key), userAccount, slot);
         }
     }
     updateLatestSlot(slot) {

package/package.json

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

package/src/accounts/oneShotUserAccountSubscriber.ts

@@ -2,13 +2,17 @@ import { Commitment, PublicKey } from '@solana/web3.js';
 import { UserAccount } from '../types';
 import { BasicUserAccountSubscriber } from './basicUserAccountSubscriber';
 import { Program } from '@coral-xyz/anchor';
+import { UserAccountSubscriber } from './types';
 
 /**
  * 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 {
+export class OneShotUserAccountSubscriber
+	extends BasicUserAccountSubscriber
+	implements UserAccountSubscriber
+{
 	program: Program;
 	commitment: Commitment;
 

package/src/userMap/PollingSubscription.ts

@@ -5,7 +5,7 @@ export class PollingSubscription {
 	private frequency: number;
 	private skipInitialLoad: boolean;
 
-	intervalId?: ReturnType<typeof setTimeout>;
+	intervalId?: NodeJS.Timeout;
 
 	constructor({
 		userMap,
@@ -23,20 +23,19 @@ export class PollingSubscription {
 	}
 
 	public async subscribe(): Promise<void> {
-		if (this.intervalId) {
+		if (this.intervalId || this.frequency <= 0) {
 			return;
 		}
 
-		if (this.frequency > 0) {
-			this.intervalId = setInterval(
-				this.userMap.sync.bind(this.userMap),
-				this.frequency
-			);
-		}
+		const executeSync = async () => {
+			await this.userMap.sync();
+			this.intervalId = setTimeout(executeSync, this.frequency);
+		};
 
 		if (!this.skipInitialLoad) {
 			await this.userMap.sync();
 		}
+		executeSync();
 	}
 
 	public async unsubscribe(): Promise<void> {

package/src/userMap/userMap.ts

@@ -362,25 +362,20 @@ export class UserMap implements UserMapInterface {
 				},
 			];
 
-			const rpcJSONResponse: any =
-				// @ts-ignore
-				await this.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
-
+			// @ts-ignore
+			const rpcJSONResponse: any = await this.connection._rpcRequest(
+				'getProgramAccounts',
+				rpcRequestArgs
+			);
 			const rpcResponseAndContext: RpcResponseAndContext<
-				Array<{
-					pubkey: PublicKey;
-					account: {
-						data: [string, string];
-					};
-				}>
+				Array<{ pubkey: PublicKey; account: { data: [string, string] } }>
 			> = rpcJSONResponse.result;
-
 			const slot = rpcResponseAndContext.context.slot;
 
 			this.updateLatestSlot(slot);
 
 			const programAccountBufferMap = new Map<string, Buffer>();
-			for (const programAccount of rpcResponseAndContext.value) {
+			rpcResponseAndContext.value.forEach((programAccount) => {
 				programAccountBufferMap.set(
 					programAccount.pubkey.toString(),
 					// @ts-ignore
@@ -389,32 +384,38 @@ export class UserMap implements UserMapInterface {
 						programAccount.account.data[1]
 					)
 				);
-			}
+			});
 
-			for (const [key, buffer] of programAccountBufferMap.entries()) {
-				if (!this.has(key)) {
-					const userAccount = this.decode('User', buffer);
-					await this.addPubkey(new PublicKey(key), userAccount, slot);
-					this.get(key).accountSubscriber.updateData(userAccount, slot);
-				} else {
-					const userAccount = this.decode('User', buffer);
-					this.get(key).accountSubscriber.updateData(userAccount, slot);
-				}
-				// give event loop a chance to breathe
-				await new Promise((resolve) => setTimeout(resolve, 0));
-			}
+			const promises = Array.from(programAccountBufferMap.entries()).map(
+				([key, buffer]) =>
+					(async () => {
+						const currAccountWithSlot = this.getWithSlot(key);
+						if (currAccountWithSlot) {
+							if (slot >= currAccountWithSlot.slot) {
+								const userAccount = this.decode('User', buffer);
+								this.updateUserAccount(key, userAccount, slot);
+							}
+						} else {
+							const userAccount = this.decode('User', buffer);
+							await this.addPubkey(new PublicKey(key), userAccount, slot);
+						}
+					})()
+			);
 
-			for (const [key, user] of this.entries()) {
+			await Promise.all(promises);
+
+			for (const [key] of this.entries()) {
 				if (!programAccountBufferMap.has(key)) {
-					await user.unsubscribe();
-					this.userMap.delete(key);
+					const user = this.get(key);
+					if (user) {
+						await user.unsubscribe();
+						this.userMap.delete(key);
+					}
 				}
-				// give event loop a chance to breathe
-				await new Promise((resolve) => setTimeout(resolve, 0));
 			}
-		} catch (e) {
-			console.error(`Error in UserMap.sync():`);
-			console.error(e);
+		} catch (err) {
+			const e = err as Error;
+			console.error(`Error in UserMap.sync(): ${e.message} ${e.stack ?? ''}`);
 		} finally {
 			this.syncPromiseResolver();
 			this.syncPromise = undefined;
@@ -446,16 +447,18 @@ export class UserMap implements UserMapInterface {
 		userAccount: UserAccount,
 		slot: number
 	) {
+		const userWithSlot = this.getWithSlot(key);
 		this.updateLatestSlot(slot);
-		if (!this.has(key)) {
-			this.addPubkey(new PublicKey(key), userAccount, slot);
+		if (userWithSlot) {
+			if (slot >= userWithSlot.slot) {
+				userWithSlot.data.accountSubscriber.updateData(userAccount, slot);
+				this.userMap.set(key, {
+					data: userWithSlot.data,
+					slot,
+				});
+			}
 		} else {
-			const user = this.get(key);
-			user.accountSubscriber.updateData(userAccount, slot);
-			this.userMap.set(key, {
-				data: user,
-				slot,
-			});
+			this.addPubkey(new PublicKey(key), userAccount, slot);
 		}
 	}
 

package/tests/amm/test.ts

@@ -615,11 +615,11 @@ describe('AMM Tests', () => {
 		assert(termsSuiExample.effectiveLeverageCapped <= 1.000001);
 		assert(termsSuiExample.inventorySpreadScale == 1.00007);
 		assert(
-			termsSuiExample.longSpread == 259073,
+			termsSuiExample.longSpread == 269818,
 			`SUI long spread got ${termsSuiExample.longSpread}`
 		);
 		assert(
-			termsSuiExample.shortSpread == 3712,
+			termsSuiExample.shortSpread == 3920,
 			`SUI short spread got ${termsSuiExample.shortSpread}`
 		);
 
@@ -680,7 +680,26 @@ describe('AMM Tests', () => {
 		);
 
 		console.log(termsSuiExampleMod2);
-		// assert(_.isEqual(termsSuiExampleMod2, termsSuiExampleMod1));
+		assert(
+			_.isEqual(
+				termsSuiExampleMod2.maxTargetSpread,
+				termsSuiExampleMod1.maxTargetSpread
+			)
+		);
+		assert(
+			_.isEqual(
+				termsSuiExampleMod2.shortSpreadwPS,
+				termsSuiExampleMod1.shortSpreadwPS
+			)
+		);
+		assert(
+			_.isEqual(
+				termsSuiExampleMod2.longSpreadwPS,
+				termsSuiExampleMod1.longSpreadwPS
+			)
+		);
+
+		// note: effectiveLeverage as currently implemented is sensitive to peg change
 	});
 
 	it('Spread Reserves (with offset)', () => {