@drift-labs/sdk 2.48.0-beta.2 → 2.48.0-beta.20

package/lib/userMap/userMap.js

@@ -7,14 +7,17 @@ const buffer_1 = require("buffer");
 const memcmp_1 = require("../memcmp");
 class UserMap {
     /**
+     * Constructs a new UserMap instance.
      *
-     * @param driftClient
-     * @param accountSubscription
-     * @param includeIdle whether idle users are subscribed to. defaults to false to decrease # of user subscriptions
+     * @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) {
+    constructor(driftClient, accountSubscription, includeIdle = false, syncCallback, syncCallbackCriteria = { hasOpenOrders: false }) {
         this.userMap = new Map();
-        this.syncCallback = async (state) => {
+        this.stateAccountUpdateCallback = async (state) => {
             if (state.numberOfSubAccounts !== this.lastNumberOfSubAccounts) {
                 await this.sync();
                 this.lastNumberOfSubAccounts = state.numberOfSubAccounts;
@@ -23,6 +26,12 @@ class UserMap {
         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;
     }
     async subscribe() {
         if (this.size() > 0) {
@@ -31,7 +40,7 @@ class UserMap {
         await this.driftClient.subscribe();
         this.lastNumberOfSubAccounts =
             this.driftClient.getStateAccount().numberOfSubAccounts;
-        this.driftClient.eventEmitter.on('stateAccountUpdate', this.syncCallback);
+        this.driftClient.eventEmitter.on('stateAccountUpdate', this.stateAccountUpdateCallback);
         await this.sync();
     }
     async addPubkey(userAccountPublicKey, userAccount) {
@@ -139,45 +148,78 @@ class UserMap {
     size() {
         return this.userMap.size;
     }
+    getUniqueAuthorities(useSyncCallbackCriteria = true) {
+        const usersMeetingCriteria = Array.from(this.userMap.values()).filter((user) => {
+            let pass = true;
+            if (useSyncCallbackCriteria &&
+                this.syncCallbackCriteria.hasOpenOrders) {
+                pass = pass && user.getUserAccount().hasOpenOrder;
+            }
+            return pass;
+        });
+        const userAuths = new Set(usersMeetingCriteria.map((user) => user.getUserAccount().authority.toBase58()));
+        const userAuthKeys = Array.from(userAuths).map((userAuth) => new web3_js_1.PublicKey(userAuth));
+        return userAuthKeys;
+    }
     async sync() {
-        const filters = [(0, memcmp_1.getUserFilter)()];
-        if (!this.includeIdle) {
-            filters.push((0, memcmp_1.getNonIdleUserFilter)());
-        }
-        const rpcRequestArgs = [
-            this.driftClient.program.programId.toBase58(),
-            {
-                commitment: this.driftClient.connection.commitment,
-                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]));
+        if (this.syncPromise) {
+            return this.syncPromise;
         }
-        for (const [key, buffer] of programAccountBufferMap.entries()) {
-            if (!this.has(key)) {
-                const userAccount = this.driftClient.program.account.user.coder.accounts.decode('User', buffer);
-                await this.addPubkey(new web3_js_1.PublicKey(key), userAccount);
+        this.syncPromise = new Promise((resolver) => {
+            this.syncPromiseResolver = resolver;
+        });
+        try {
+            const filters = [(0, memcmp_1.getUserFilter)()];
+            if (!this.includeIdle) {
+                filters.push((0, memcmp_1.getNonIdleUserFilter)());
             }
-        }
-        for (const [key, user] of this.userMap.entries()) {
-            if (!programAccountBufferMap.has(key)) {
-                await user.unsubscribe();
-                this.userMap.delete(key);
+            const rpcRequestArgs = [
+                this.driftClient.program.programId.toBase58(),
+                {
+                    commitment: this.driftClient.connection.commitment,
+                    filters,
+                    encoding: 'base64',
+                    withContext: true,
+                },
+            ];
+            const rpcJSONResponse = 
+            // @ts-ignore
+            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)) {
+                    const userAccount = this.driftClient.program.account.user.coder.accounts.decode('User', buffer);
+                    await this.addPubkey(new web3_js_1.PublicKey(key), userAccount);
+                }
             }
-            else {
-                const userAccount = this.driftClient.program.account.user.coder.accounts.decode('User', programAccountBufferMap.get(key));
-                user.accountSubscriber.updateData(userAccount, slot);
+            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());
+            }
+        }
+        catch (e) {
+            console.error(`Error in UserMap.sync()`);
+            console.error(e);
+        }
+        finally {
+            this.syncPromiseResolver();
+            this.syncPromise = undefined;
         }
     }
     async unsubscribe() {
@@ -186,7 +228,7 @@ class UserMap {
             this.userMap.delete(key);
         }
         if (this.lastNumberOfSubAccounts) {
-            this.driftClient.eventEmitter.removeListener('stateAccountUpdate', this.syncCallback);
+            this.driftClient.eventEmitter.removeListener('stateAccountUpdate', this.stateAccountUpdateCallback);
             this.lastNumberOfSubAccounts = undefined;
         }
     }

package/lib/userMap/userStatsMap.d.ts

@@ -1,4 +1,4 @@
-import { DriftClient, OrderRecord, UserStatsAccount, UserStats, UserStatsSubscriptionConfig, WrappedEvent } from '..';
+import { DriftClient, OrderRecord, UserStatsAccount, UserStats, WrappedEvent, BulkAccountLoader } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { UserMap } from './userMap';
 export declare class UserStatsMap {
@@ -7,19 +7,40 @@ export declare class UserStatsMap {
      */
     private userStatsMap;
     private driftClient;
-    private accountSubscription;
-    private lastNumberOfAuthorities;
-    private syncCallback;
-    constructor(driftClient: DriftClient, accountSubscription: UserStatsSubscriptionConfig);
-    subscribe(): Promise<void>;
-    addUserStat(authority: PublicKey, userStatsAccount?: UserStatsAccount): Promise<void>;
+    private bulkAccountLoader;
+    /**
+     * Creates a new UserStatsMap instance.
+     *
+     * @param {DriftClient} driftClient - The DriftClient instance.
+     * @param {BulkAccountLoader} [bulkAccountLoader] - If not provided, a new BulkAccountLoader with polling disabled will be created.
+     */
+    constructor(driftClient: DriftClient, bulkAccountLoader?: BulkAccountLoader);
+    subscribe(authorities: PublicKey[]): Promise<void>;
+    /**
+     *
+     * @param authority that owns the UserStatsAccount
+     * @param userStatsAccount optional UserStatsAccount to subscribe to, if undefined will be fetched later
+     * @param skipFetch if true, will not immediately fetch the UserStatsAccount
+     */
+    addUserStat(authority: PublicKey, userStatsAccount?: UserStatsAccount, skipFetch?: boolean): Promise<void>;
     updateWithOrderRecord(record: OrderRecord, userMap: UserMap): Promise<void>;
     updateWithEventRecord(record: WrappedEvent<any>, userMap?: UserMap): Promise<void>;
     has(authorityPublicKey: string): boolean;
     get(authorityPublicKey: string): UserStats;
+    /**
+     * Enforce that a UserStats will exist for the given authorityPublicKey,
+     * reading one from the blockchain if necessary.
+     * @param authorityPublicKey
+     * @returns
+     */
     mustGet(authorityPublicKey: string): Promise<UserStats>;
     values(): IterableIterator<UserStats>;
     size(): number;
-    sync(): Promise<void>;
+    /**
+     * Sync the UserStatsMap
+     * @param authorities list of authorities to derive UserStatsAccount public keys from.
+     * You may want to get this list from UserMap in order to filter out idle users
+     */
+    sync(authorities: PublicKey[]): Promise<void>;
     unsubscribe(): Promise<void>;
 }

package/lib/userMap/userStatsMap.js

@@ -4,43 +4,57 @@ exports.UserStatsMap = void 0;
 const __1 = require("..");
 const web3_js_1 = require("@solana/web3.js");
 class UserStatsMap {
-    constructor(driftClient, accountSubscription) {
+    /**
+     * Creates a new UserStatsMap instance.
+     *
+     * @param {DriftClient} driftClient - The DriftClient instance.
+     * @param {BulkAccountLoader} [bulkAccountLoader] - If not provided, a new BulkAccountLoader with polling disabled will be created.
+     */
+    constructor(driftClient, bulkAccountLoader) {
         /**
          * 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;
+        if (!bulkAccountLoader) {
+            bulkAccountLoader = new __1.BulkAccountLoader(driftClient.connection, driftClient.opts.commitment, 0);
+        }
+        this.bulkAccountLoader = bulkAccountLoader;
     }
-    async subscribe() {
+    async subscribe(authorities) {
         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();
+        await this.sync(authorities);
     }
-    async addUserStat(authority, userStatsAccount) {
+    /**
+     *
+     * @param authority that owns the UserStatsAccount
+     * @param userStatsAccount optional UserStatsAccount to subscribe to, if undefined will be fetched later
+     * @param skipFetch if true, will not immediately fetch the UserStatsAccount
+     */
+    async addUserStat(authority, userStatsAccount, skipFetch) {
         const userStat = new __1.UserStats({
             driftClient: this.driftClient,
             userStatsAccountPublicKey: (0, __1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, authority),
-            accountSubscription: this.accountSubscription,
+            accountSubscription: {
+                type: 'polling',
+                accountLoader: this.bulkAccountLoader,
+            },
         });
-        await userStat.subscribe(userStatsAccount);
+        if (skipFetch) {
+            await userStat.accountSubscriber.addToAccountLoader();
+        }
+        else {
+            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())) {
-            await this.addUserStat(user.getUserAccount().authority);
+            await this.addUserStat(user.getUserAccount().authority, undefined, false);
         }
     }
     async updateWithEventRecord(record, userMap) {
@@ -114,9 +128,15 @@ class UserStatsMap {
     get(authorityPublicKey) {
         return this.userStatsMap.get(authorityPublicKey);
     }
+    /**
+     * Enforce that a UserStats will exist for the given authorityPublicKey,
+     * reading one from the blockchain if necessary.
+     * @param authorityPublicKey
+     * @returns
+     */
     async mustGet(authorityPublicKey) {
         if (!this.has(authorityPublicKey)) {
-            await this.addUserStat(new web3_js_1.PublicKey(authorityPublicKey));
+            await this.addUserStat(new web3_js_1.PublicKey(authorityPublicKey), undefined, false);
         }
         return this.get(authorityPublicKey);
     }
@@ -126,35 +146,20 @@ class UserStatsMap {
     size() {
         return this.userStatsMap.size;
     }
-    async sync() {
-        const programAccounts = await this.driftClient.connection.getProgramAccounts(this.driftClient.program.programId, {
-            commitment: this.driftClient.connection.commitment,
-            filters: [
-                {
-                    memcmp: this.driftClient.program.coder.accounts.memcmp('UserStats'),
-                },
-            ],
-        });
-        const programAccountMap = new Map();
-        for (const programAccount of programAccounts) {
-            programAccountMap.set(new web3_js_1.PublicKey(programAccount.account.data.slice(8, 40)).toString(), programAccount.account);
-        }
-        for (const key of programAccountMap.keys()) {
-            if (!this.has(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);
-            }
-        }
+    /**
+     * Sync the UserStatsMap
+     * @param authorities list of authorities to derive UserStatsAccount public keys from.
+     * You may want to get this list from UserMap in order to filter out idle users
+     */
+    async sync(authorities) {
+        await Promise.all(authorities.map((authority) => this.addUserStat(authority, undefined, true)));
+        await this.bulkAccountLoader.load();
     }
     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.48.0-beta.2",
+	"version": "2.48.0-beta.20",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/bulkAccountLoader.ts

@@ -193,7 +193,7 @@ export class BulkAccountLoader {
 				const key = accountToLoad.publicKey.toBase58();
 				const oldRPCResponse = this.bufferAndSlotMap.get(key);
 
-				if (oldRPCResponse && newSlot <= oldRPCResponse.slot) {
+				if (oldRPCResponse && newSlot < oldRPCResponse.slot) {
 					return;
 				}
 

package/src/accounts/pollingUserAccountSubscriber.ts

@@ -93,17 +93,21 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 	}
 
 	async fetch(): Promise<void> {
-		await this.accountLoader.load();
-		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
+		try {
+			const dataAndContext = await this.program.account.user.fetchAndContext(
+				this.userAccountPublicKey,
+				this.accountLoader.commitment
+			);
+			if (dataAndContext.context.slot > (this.user?.slot ?? 0)) {
+				this.user = {
+					data: dataAndContext.data as UserAccount,
+					slot: dataAndContext.context.slot,
+				};
+			}
+		} catch (e) {
+			console.log(
+				`PollingUserAccountSubscriber.fetch() UserAccount does not exist: ${e.message}`
 			);
-			this.user = { data: account, slot };
 		}
 	}
 
@@ -137,7 +141,11 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 	}
 
 	public getUserAccountAndSlot(): DataAndSlot<UserAccount> {
-		this.assertIsSubscribed();
+		if (!this.doesAccountExist()) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` or `fetch` before using this function'
+			);
+		}
 		return this.user;
 	}
 

package/src/accounts/pollingUserStatsAccountSubscriber.ts

@@ -97,18 +97,22 @@ export class PollingUserStatsAccountSubscriber
 	}
 
 	async fetch(): Promise<void> {
-		await this.accountLoader.load();
-		const { buffer, slot } = this.accountLoader.getBufferAndSlot(
-			this.userStatsAccountPublicKey
-		);
-		const currentSlot = this.userStats?.slot ?? 0;
-		if (buffer && slot > currentSlot) {
-			const account =
-				this.program.account.userStats.coder.accounts.decodeUnchecked(
-					'UserStats',
-					buffer
+		try {
+			const dataAndContext =
+				await this.program.account.userStats.fetchAndContext(
+					this.userStatsAccountPublicKey,
+					this.accountLoader.commitment
 				);
-			this.userStats = { data: account, slot };
+			if (dataAndContext.context.slot > (this.userStats?.slot ?? 0)) {
+				this.userStats = {
+					data: dataAndContext.data as UserStatsAccount,
+					slot: dataAndContext.context.slot,
+				};
+			}
+		} catch (e) {
+			console.log(
+				`PollingUserStatsAccountSubscriber.fetch() UserStatsAccount does not exist: ${e.message}`
+			);
 		}
 	}
 
@@ -142,7 +146,11 @@ export class PollingUserStatsAccountSubscriber
 	}
 
 	public getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount> {
-		this.assertIsSubscribed();
+		if (!this.doesAccountExist()) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` or `fetch` before using this function'
+			);
+		}
 		return this.userStats;
 	}
 }

package/src/accounts/webSocketAccountSubscriber.ts

@@ -134,7 +134,7 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 			return;
 		}
 
-		if (newSlot <= this.bufferAndSlot.slot) {
+		if (newSlot < this.bufferAndSlot.slot) {
 			return;
 		}
 

package/src/accounts/webSocketDriftClientAccountSubscriber.ts

@@ -14,7 +14,7 @@ import {
 	getPerpMarketPublicKey,
 } from '../addresses/pda';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
-import { PublicKey } from '@solana/web3.js';
+import { Commitment, PublicKey } from '@solana/web3.js';
 import { OracleInfo, OraclePriceData } from '../oracles/types';
 import { OracleClientCache } from '../oracles/oracleClientCache';
 import * as Buffer from 'buffer';
@@ -26,6 +26,7 @@ export class WebSocketDriftClientAccountSubscriber
 {
 	isSubscribed: boolean;
 	program: Program;
+	commitment?: Commitment;
 	perpMarketIndexes: number[];
 	spotMarketIndexes: number[];
 	oracleInfos: OracleInfo[];
@@ -56,7 +57,8 @@ export class WebSocketDriftClientAccountSubscriber
 		spotMarketIndexes: number[],
 		oracleInfos: OracleInfo[],
 		shouldFindAllMarketsAndOracles: boolean,
-		resubTimeoutMs?: number
+		resubTimeoutMs?: number,
+		commitment?: Commitment
 	) {
 		this.isSubscribed = false;
 		this.program = program;
@@ -66,6 +68,7 @@ export class WebSocketDriftClientAccountSubscriber
 		this.oracleInfos = oracleInfos;
 		this.shouldFindAllMarketsAndOracles = shouldFindAllMarketsAndOracles;
 		this.resubTimeoutMs = resubTimeoutMs;
+		this.commitment = commitment;
 	}
 
 	public async subscribe(): Promise<boolean> {
@@ -101,7 +104,8 @@ export class WebSocketDriftClientAccountSubscriber
 			this.program,
 			statePublicKey,
 			undefined,
-			this.resubTimeoutMs
+			this.resubTimeoutMs,
+			this.commitment
 		);
 		await this.stateAccountSubscriber.subscribe((data: StateAccount) => {
 			this.eventEmitter.emit('stateAccountUpdate', data);
@@ -143,7 +147,8 @@ export class WebSocketDriftClientAccountSubscriber
 			this.program,
 			perpMarketPublicKey,
 			undefined,
-			this.resubTimeoutMs
+			this.resubTimeoutMs,
+			this.commitment
 		);
 		await accountSubscriber.subscribe((data: PerpMarketAccount) => {
 			this.eventEmitter.emit('perpMarketAccountUpdate', data);
@@ -170,7 +175,8 @@ export class WebSocketDriftClientAccountSubscriber
 			this.program,
 			marketPublicKey,
 			undefined,
-			this.resubTimeoutMs
+			this.resubTimeoutMs,
+			this.commitment
 		);
 		await accountSubscriber.subscribe((data: SpotMarketAccount) => {
 			this.eventEmitter.emit('spotMarketAccountUpdate', data);
@@ -202,7 +208,8 @@ export class WebSocketDriftClientAccountSubscriber
 			(buffer: Buffer) => {
 				return client.getOraclePriceDataFromBuffer(buffer);
 			},
-			this.resubTimeoutMs
+			this.resubTimeoutMs,
+			this.commitment
 		);
 
 		await accountSubscriber.subscribe((data: OraclePriceData) => {

package/src/accounts/webSocketProgramAccountSubscriber.ts

@@ -125,7 +125,7 @@ export class WebSocketProgramAccountSubscriber<T>
 			return;
 		}
 
-		if (newSlot <= this.bufferAndSlot.slot) {
+		if (newSlot < this.bufferAndSlot.slot) {
 			return;
 		}
 

package/src/accounts/webSocketUserAccountSubscriber.ts

@@ -94,7 +94,7 @@ export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 	public updateData(userAccount: UserAccount, slot: number) {
 		const currentDataSlot =
 			this.userDataAccountSubscriber.dataAndSlot?.slot || 0;
-		if (currentDataSlot < slot) {
+		if (currentDataSlot <= slot) {
 			this.userDataAccountSubscriber.setData(userAccount, slot);
 			this.eventEmitter.emit('userAccountUpdate', userAccount);
 			this.eventEmitter.emit('update');

package/src/constants/spotMarkets.ts

@@ -150,6 +150,16 @@ export const MainnetSpotMarkets: SpotMarketConfig[] = [
 			'2sTMN9A1D1qeZLF95XQgJCUPiKe5DiV52jLfZGqMP46m'
 		),
 	},
+	{
+		symbol: 'bSOL',
+		marketIndex: 8,
+		oracle: new PublicKey('AFrYBhb5wKQtxRS9UA9YRS4V3dwFm7SqmS6DHKq6YVgo'),
+		oracleSource: OracleSource.PYTH,
+		mint: new PublicKey('bSo13r4TkiE4KumL71LsHTPpL2euBYLFx6h9HP3piy1'),
+		precision: new BN(10).pow(NINE),
+		precisionExp: NINE,
+		serumMarket: new PublicKey('ARjaHVxGCQfTvvKjLd7U7srvk6orthZSE6uqWchCczZc'),
+	},
 ];
 
 export const SpotMarkets: { [key in DriftEnv]: SpotMarketConfig[] } = {

package/src/dlob/orderBookLevels.ts

@@ -173,7 +173,7 @@ export function getVammL2Generator({
 		updatedAmm.orderStepSize
 	);
 
-	const minOrderSize = marketAccount.amm.orderStepSize;
+	const minOrderSize = marketAccount.amm.minOrderSize;
 	if (openBids.lt(minOrderSize.muln(2))) {
 		openBids = ZERO;
 	}

package/src/driftClient.ts

@@ -283,7 +283,8 @@ export class DriftClient {
 				config.spotMarketIndexes ?? [],
 				config.oracleInfos ?? [],
 				noMarketsAndOraclesSpecified,
-				config.accountSubscription?.resubTimeoutMs
+				config.accountSubscription?.resubTimeoutMs,
+				config.accountSubscription?.commitment
 			);
 		}
 		this.eventEmitter = this.accountSubscriber.eventEmitter;
@@ -2028,7 +2029,7 @@ export class DriftClient {
 		}
 
 		const tx = await this.buildTransaction(withdrawIxs, {
-			computeUnits: 600_000,
+			computeUnits: 1_400_000,
 		});
 		const { txSig, slot } = await this.sendTransaction(
 			tx,

package/src/events/eventSubscriber.ts

@@ -56,7 +56,8 @@ export class EventSubscriber {
 			this.logProvider = new WebSocketLogProvider(
 				this.connection,
 				this.address,
-				this.options.commitment
+				this.options.commitment,
+				this.options.resubTimeoutMs
 			);
 		} else {
 			this.logProvider = new PollingLogProvider(

package/src/events/types.ts

@@ -28,6 +28,7 @@ export type EventSubscriptionOptions = {
 	// when the subscription starts, client might want to backtrack and fetch old tx's
 	// this specifies how far to backtrack
 	untilTx?: TransactionSignature;
+	resubTimeoutMs?: number;
 };
 
 export const DefaultEventSubscriptionOptions: EventSubscriptionOptions = {