@drift-labs/sdk 0.2.0-master.4 → 0.2.0-master.40

package/README.md

@@ -54,13 +54,13 @@ a BigNum: 10,500,000, with precision 10^6, is equal to 10.5 because 10,500,000 /
 
 The Drift SDK uses some common precisions, which are available as constants to import from the SDK.
 
-| Precision Name            | Value |
-| ------------------------- | ----- |
-| QUOTE_PRECISION           | 10^6  |
-| MARK_PRICE_PRECISION      | 10^10 |
-| AMM_RESERVE_PRECISION     | 10^13 |
-| FUNDING_PAYMENT_PRECISION | 10^4  |
-| PEG_PRECISION             | 10^3  |
+| Precision Name        | Value |
+| --------------------- | ----- |
+| FUNDING_RATE_BUFFER   | 10^3  |
+| QUOTE_PRECISION       | 10^6  |
+| PEG_PRECISION         | 10^6  |
+| PRICE_PRECISION       | 10^6  |
+| AMM_RESERVE_PRECISION | 10^9  |
 
 **Important Note for BigNum division**
 
@@ -88,17 +88,17 @@ import { BN, Provider } from '@project-serum/anchor';
 import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import {
-	calculateMarkPrice,
-	ClearingHouse,
-	ClearingHouseUser,
+	calculateReservePrice,
+	DriftClient,
+	User,
 	initialize,
 	Markets,
 	PositionDirection,
 	convertToNumber,
 	calculateTradeSlippage,
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	QUOTE_PRECISION,
-	Wallet
+	Wallet,
 } from '@drift-labs/sdk';
 
 export const getTokenAddress = (
@@ -141,19 +141,19 @@ const main = async () => {
 		wallet.publicKey.toString()
 	);
 
-	// Set up the Drift Clearing House
-	const clearingHousePublicKey = new PublicKey(
+	// Set up the Drift Client
+	const driftClientPublicKey = new PublicKey(
 		sdkConfig.CLEARING_HOUSE_PROGRAM_ID
 	);
-	const clearingHouse = ClearingHouse.from(
+	const driftClient = DriftClient.from(
 		connection,
 		provider.wallet,
-		clearingHousePublicKey
+		driftClientPublicKey
 	);
-	await clearingHouse.subscribe();
+	await driftClient.subscribe();
 
 	// Set up Clearing House user client
-	const user = ClearingHouseUser.from(clearingHouse, wallet.publicKey);
+	const user = User.from(driftClient, wallet.publicKey);
 
 	//// Check if clearing house account exists for the current wallet
 	const userAccountExists = await user.exists();
@@ -161,7 +161,7 @@ const main = async () => {
 	if (!userAccountExists) {
 		//// Create a Clearing House account by Depositing some USDC ($10,000 in this case)
 		const depositAmount = new BN(10000).mul(QUOTE_PRECISION);
-		await clearingHouse.initializeUserAccountAndDepositCollateral(
+		await driftClient.initializeUserAccountAndDepositCollateral(
 			depositAmount,
 			await getTokenAddress(
 				usdcTokenAddress.toString(),
@@ -177,16 +177,16 @@ const main = async () => {
 		(market) => market.baseAssetSymbol === 'SOL'
 	);
 
-	const currentMarketPrice = calculateMarkPrice(
-		clearingHouse.getMarket(solMarketInfo.marketIndex)
+	const currentMarketPrice = calculateReservePrice(
+		driftClient.getMarket(solMarketInfo.marketIndex)
 	);
 
-	const formattedPrice = convertToNumber(currentMarketPrice, MARK_PRICE_PRECISION);
+	const formattedPrice = convertToNumber(currentMarketPrice, PRICE_PRECISION);
 
 	console.log(`Current Market Price is $${formattedPrice}`);
 
 	// Estimate the slippage for a $5000 LONG trade
-	const solMarketAccount = clearingHouse.getMarket(solMarketInfo.marketIndex);
+	const solMarketAccount = driftClient.getMarket(solMarketInfo.marketIndex);
 
 	const slippage = convertToNumber(
 		calculateTradeSlippage(
@@ -194,7 +194,7 @@ const main = async () => {
 			new BN(5000).mul(QUOTE_PRECISION),
 			solMarketAccount
 		)[0],
-		MARK_PRICE_PRECISION
+		PRICE_PRECISION
 	);
 
 	console.log(
@@ -202,7 +202,7 @@ const main = async () => {
 	);
 
 	// Make a $5000 LONG trade
-	await clearingHouse.openPosition(
+	await driftClient.openPosition(
 		PositionDirection.LONG,
 		new BN(5000).mul(QUOTE_PRECISION),
 		solMarketInfo.marketIndex
@@ -210,14 +210,14 @@ const main = async () => {
 	console.log(`LONGED $5000 worth of SOL`);
 
 	// Reduce the position by $2000
-	await clearingHouse.openPosition(
+	await driftClient.openPosition(
 		PositionDirection.SHORT,
 		new BN(2000).mul(QUOTE_PRECISION),
 		solMarketInfo.marketIndex
 	);
 
 	// Close the rest of the position
-	await clearingHouse.closePosition(solMarketInfo.marketIndex);
+	await driftClient.closePosition(solMarketInfo.marketIndex);
 };
 
 main();

package/lib/accounts/bulkAccountLoader.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { Commitment, Connection, PublicKey } from '@solana/web3.js';
 import { BufferAndSlot } from './types';
+import { Mutex } from 'async-mutex';
 declare type AccountToLoad = {
     publicKey: PublicKey;
     callbacks: Map<string, (buffer: Buffer, slot: number) => void>;
@@ -14,6 +15,7 @@ export declare class BulkAccountLoader {
     errorCallbacks: Map<string, (e: any) => void>;
     intervalId?: NodeJS.Timer;
     loadPromise?: Promise<void>;
+    loadPromiseLock: Mutex;
     loadPromiseResolver: () => void;
     lastTimeLoadingPromiseCleared: number;
     mostRecentSlot: number;

package/lib/accounts/bulkAccountLoader.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BulkAccountLoader = void 0;
 const uuid_1 = require("uuid");
 const promiseTimeout_1 = require("../util/promiseTimeout");
+const async_mutex_1 = require("async-mutex");
 const GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
 const oneMinute = 60 * 1000;
 class BulkAccountLoader {
@@ -10,6 +11,7 @@ class BulkAccountLoader {
         this.accountsToLoad = new Map();
         this.bufferAndSlotMap = new Map();
         this.errorCallbacks = new Map();
+        this.loadPromiseLock = new async_mutex_1.Mutex();
         this.lastTimeLoadingPromiseCleared = Date.now();
         this.mostRecentSlot = 0;
         this.connection = connection;
@@ -36,7 +38,9 @@ class BulkAccountLoader {
             this.startPolling();
         }
         // if a new account needs to be polled, remove the cached loadPromise in case client calls load immediately after
-        this.loadPromise = undefined;
+        this.loadPromiseLock.runExclusive(() => {
+            this.loadPromise = undefined;
+        });
         return callbackId;
     }
     removeAccount(publicKey, callbackId) {
@@ -66,36 +70,38 @@ class BulkAccountLoader {
             .map((begin) => array.slice(begin, begin + size));
     }
     async load() {
-        if (this.loadPromise) {
-            const now = Date.now();
-            if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
-                this.loadPromise = undefined;
+        await this.loadPromiseLock.runExclusive(async () => {
+            if (this.loadPromise) {
+                const now = Date.now();
+                if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
+                    this.loadPromise = undefined;
+                }
+                else {
+                    return this.loadPromise;
+                }
             }
-            else {
-                return this.loadPromise;
+            this.loadPromise = new Promise((resolver) => {
+                this.loadPromiseResolver = resolver;
+            });
+            this.lastTimeLoadingPromiseCleared = Date.now();
+            try {
+                const chunks = this.chunks(Array.from(this.accountsToLoad.values()), GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE);
+                await Promise.all(chunks.map((chunk) => {
+                    return this.loadChunk(chunk);
+                }));
             }
-        }
-        this.loadPromise = new Promise((resolver) => {
-            this.loadPromiseResolver = resolver;
-        });
-        this.lastTimeLoadingPromiseCleared = Date.now();
-        try {
-            const chunks = this.chunks(Array.from(this.accountsToLoad.values()), GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE);
-            await Promise.all(chunks.map((chunk) => {
-                return this.loadChunk(chunk);
-            }));
-        }
-        catch (e) {
-            console.error(`Error in bulkAccountLoader.load()`);
-            console.error(e);
-            for (const [_, callback] of this.errorCallbacks) {
-                callback(e);
+            catch (e) {
+                console.error(`Error in bulkAccountLoader.load()`);
+                console.error(e);
+                for (const [_, callback] of this.errorCallbacks) {
+                    callback(e);
+                }
             }
-        }
-        finally {
-            this.loadPromiseResolver();
-            this.loadPromise = undefined;
-        }
+            finally {
+                this.loadPromiseResolver();
+                this.loadPromise = undefined;
+            }
+        });
     }
     async loadChunk(accountsToLoad) {
         if (accountsToLoad.length === 0) {
@@ -162,7 +168,8 @@ class BulkAccountLoader {
         if (this.intervalId) {
             return;
         }
-        this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
+        if (this.pollingFrequency !== 0)
+            this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
     }
     stopPolling() {
         if (this.intervalId) {

package/lib/accounts/bulkUserStatsSubscription.d.ts

@@ -0,0 +1,7 @@
+import { UserStats } from '../userStats';
+import { BulkAccountLoader } from './bulkAccountLoader';
+/**
+ * @param userStats
+ * @param accountLoader
+ */
+export declare function bulkPollingUserStatsSubscribe(userStats: UserStats[], accountLoader: BulkAccountLoader): Promise<void>;

package/lib/accounts/bulkUserStatsSubscription.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulkPollingUserStatsSubscribe = void 0;
+/**
+ * @param userStats
+ * @param accountLoader
+ */
+async function bulkPollingUserStatsSubscribe(userStats, accountLoader) {
+    if (userStats.length === 0) {
+        await accountLoader.load();
+        return;
+    }
+    await Promise.all(userStats.map((userStat) => {
+        return userStat.accountSubscriber.addToAccountLoader();
+    }));
+    await accountLoader.load();
+    await Promise.all(userStats.map(async (userStat) => {
+        return userStat.subscribe();
+    }));
+}
+exports.bulkPollingUserStatsSubscribe = bulkPollingUserStatsSubscribe;

package/lib/accounts/bulkUserSubscription.d.ts

@@ -1,7 +1,7 @@
-import { ClearingHouseUser } from '../clearingHouseUser';
+import { User } from '../user';
 import { BulkAccountLoader } from './bulkAccountLoader';
 /**
  * @param users
  * @param accountLoader
  */
-export declare function bulkPollingUserSubscribe(users: ClearingHouseUser[], accountLoader: BulkAccountLoader): Promise<void>;
+export declare function bulkPollingUserSubscribe(users: User[], accountLoader: BulkAccountLoader): Promise<void>;

package/lib/accounts/bulkUserSubscription.js

@@ -11,7 +11,6 @@ async function bulkPollingUserSubscribe(users, accountLoader) {
         return;
     }
     await Promise.all(users.map((user) => {
-        // Pull the keys from the authority map so we can skip fetching them in addToAccountLoader
         return user.accountSubscriber.addToAccountLoader();
     }));
     await accountLoader.load();

package/lib/accounts/fetch.d.ts

@@ -1,4 +1,5 @@
 import { Connection, PublicKey } from '@solana/web3.js';
-import { UserAccount } from '../types';
+import { UserAccount, UserStatsAccount } from '../types';
 import { Program } from '@project-serum/anchor';
 export declare function fetchUserAccounts(connection: Connection, program: Program, authority: PublicKey, limit?: number): Promise<(UserAccount | undefined)[]>;
+export declare function fetchUserStatsAccount(connection: Connection, program: Program, authority: PublicKey): Promise<UserStatsAccount | undefined>;

package/lib/accounts/fetch.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchUserAccounts = void 0;
+exports.fetchUserStatsAccount = exports.fetchUserAccounts = void 0;
 const pda_1 = require("../addresses/pda");
 async function fetchUserAccounts(connection, program, authority, limit = 8) {
     const userAccountPublicKeys = new Array();
@@ -16,3 +16,11 @@ async function fetchUserAccounts(connection, program, authority, limit = 8) {
     });
 }
 exports.fetchUserAccounts = fetchUserAccounts;
+async function fetchUserStatsAccount(connection, program, authority) {
+    const userStatsPublicKey = (0, pda_1.getUserStatsAccountPublicKey)(program.programId, authority);
+    const accountInfo = await connection.getAccountInfo(userStatsPublicKey, 'confirmed');
+    return accountInfo
+        ? program.account.user.coder.accounts.decode('UserStats', accountInfo.data)
+        : undefined;
+}
+exports.fetchUserStatsAccount = fetchUserStatsAccount;

package/lib/accounts/{pollingClearingHouseAccountSubscriber.d.ts → pollingDriftClientAccountSubscriber.d.ts}

@@ -1,61 +1,56 @@
-/// <reference types="bn.js" />
 /// <reference types="node" />
-import { DataAndSlot, AccountToPoll, ClearingHouseAccountEvents, ClearingHouseAccountSubscriber, OraclesToPoll } from './types';
-import { BN, Program } from '@project-serum/anchor';
+import { DataAndSlot, AccountToPoll, DriftClientAccountEvents, DriftClientAccountSubscriber, OraclesToPoll } from './types';
+import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
-import { BankAccount, MarketAccount, StateAccount, UserAccount } from '../types';
+import { SpotMarketAccount, PerpMarketAccount, StateAccount, UserAccount } from '../types';
 import { BulkAccountLoader } from './bulkAccountLoader';
 import { PublicKey } from '@solana/web3.js';
 import { OracleInfo, OraclePriceData } from '../oracles/types';
 import { OracleClientCache } from '../oracles/oracleClientCache';
-export declare class PollingClearingHouseAccountSubscriber implements ClearingHouseAccountSubscriber {
+export declare class PollingDriftClientAccountSubscriber implements DriftClientAccountSubscriber {
     isSubscribed: boolean;
     program: Program;
-    marketIndexes: BN[];
-    bankIndexes: BN[];
+    perpMarketIndexes: number[];
+    spotMarketIndexes: number[];
     oracleInfos: OracleInfo[];
     oracleClientCache: OracleClientCache;
-    eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
+    eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
     accountLoader: BulkAccountLoader;
     accountsToPoll: Map<string, AccountToPoll>;
     oraclesToPoll: Map<string, OraclesToPoll>;
     errorCallbackId?: string;
     state?: DataAndSlot<StateAccount>;
-    market: Map<number, DataAndSlot<MarketAccount>>;
-    bank: Map<number, DataAndSlot<BankAccount>>;
+    perpMarket: Map<number, DataAndSlot<PerpMarketAccount>>;
+    spotMarket: Map<number, DataAndSlot<SpotMarketAccount>>;
     oracles: Map<string, DataAndSlot<OraclePriceData>>;
     user?: DataAndSlot<UserAccount>;
     private isSubscribing;
     private subscriptionPromise;
     private subscriptionPromiseResolver;
-    constructor(program: Program, accountLoader: BulkAccountLoader, marketIndexes: BN[], bankIndexes: BN[], oracleInfos: OracleInfo[]);
+    constructor(program: Program, accountLoader: BulkAccountLoader, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[]);
     subscribe(): Promise<boolean>;
     updateAccountsToPoll(): Promise<void>;
-    updateMarketAccountsToPoll(): Promise<boolean>;
-    addMarketAccountToPoll(marketIndex: BN): Promise<boolean>;
-    updateBankAccountsToPoll(): Promise<boolean>;
-    addBankAccountToPoll(bankIndex: BN): Promise<boolean>;
+    updatePerpMarketAccountsToPoll(): Promise<boolean>;
+    addPerpMarketAccountToPoll(marketIndex: number): Promise<boolean>;
+    updateSpotMarketAccountsToPoll(): Promise<boolean>;
+    addSpotMarketAccountToPoll(marketIndex: number): Promise<boolean>;
     updateOraclesToPoll(): boolean;
     addOracleToPoll(oracleInfo: OracleInfo): boolean;
-    getClearingHouseAccounts(): Promise<ClearingHouseAccounts>;
     addToAccountLoader(): Promise<void>;
     addAccountToAccountLoader(accountToPoll: AccountToPoll): void;
     addOracleToAccountLoader(oracleToPoll: OraclesToPoll): void;
     fetch(): Promise<void>;
     didSubscriptionSucceed(): boolean;
     unsubscribe(): Promise<void>;
-    addBank(bankIndex: BN): Promise<boolean>;
-    addMarket(marketIndex: BN): Promise<boolean>;
+    addSpotMarket(marketIndex: number): Promise<boolean>;
+    addPerpMarket(marketIndex: number): Promise<boolean>;
     addOracle(oracleInfo: OracleInfo): Promise<boolean>;
     assertIsSubscribed(): void;
     getStateAccountAndSlot(): DataAndSlot<StateAccount>;
-    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<MarketAccount> | undefined;
-    getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[];
-    getBankAccountAndSlot(bankIndex: BN): DataAndSlot<BankAccount> | undefined;
+    getMarketAccountAndSlot(marketIndex: number): DataAndSlot<PerpMarketAccount> | undefined;
+    getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[];
+    getSpotMarketAccountAndSlot(marketIndex: number): DataAndSlot<SpotMarketAccount> | undefined;
+    getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[];
     getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
 }
-declare type ClearingHouseAccounts = {
-    state: PublicKey;
-};
-export {};

package/lib/accounts/{pollingClearingHouseAccountSubscriber.js → pollingDriftClientAccountSubscriber.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PollingClearingHouseAccountSubscriber = void 0;
+exports.PollingDriftClientAccountSubscriber = void 0;
 const types_1 = require("./types");
 const events_1 = require("events");
 const pda_1 = require("../addresses/pda");
@@ -8,21 +8,21 @@ const utils_1 = require("./utils");
 const web3_js_1 = require("@solana/web3.js");
 const oracleClientCache_1 = require("../oracles/oracleClientCache");
 const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
-class PollingClearingHouseAccountSubscriber {
-    constructor(program, accountLoader, marketIndexes, bankIndexes, oracleInfos) {
+class PollingDriftClientAccountSubscriber {
+    constructor(program, accountLoader, perpMarketIndexes, spotMarketIndexes, oracleInfos) {
         this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
         this.accountsToPoll = new Map();
         this.oraclesToPoll = new Map();
-        this.market = new Map();
-        this.bank = new Map();
+        this.perpMarket = new Map();
+        this.spotMarket = new Map();
         this.oracles = new Map();
         this.isSubscribing = false;
         this.isSubscribed = false;
         this.program = program;
         this.eventEmitter = new events_1.EventEmitter();
         this.accountLoader = accountLoader;
-        this.marketIndexes = marketIndexes;
-        this.bankIndexes = bankIndexes;
+        this.perpMarketIndexes = perpMarketIndexes;
+        this.spotMarketIndexes = spotMarketIndexes;
         this.oracleInfos = oracleInfos;
     }
     async subscribe() {
@@ -58,44 +58,44 @@ class PollingClearingHouseAccountSubscriber {
         if (this.accountsToPoll.size > 0) {
             return;
         }
-        const accounts = await this.getClearingHouseAccounts();
-        this.accountsToPoll.set(accounts.state.toString(), {
+        const statePublicKey = await (0, pda_1.getDriftStateAccountPublicKey)(this.program.programId);
+        this.accountsToPoll.set(statePublicKey.toString(), {
             key: 'state',
-            publicKey: accounts.state,
+            publicKey: statePublicKey,
             eventType: 'stateAccountUpdate',
         });
-        await this.updateMarketAccountsToPoll();
-        await this.updateBankAccountsToPoll();
+        await this.updatePerpMarketAccountsToPoll();
+        await this.updateSpotMarketAccountsToPoll();
     }
-    async updateMarketAccountsToPoll() {
-        for (const marketIndex of this.marketIndexes) {
-            await this.addMarketAccountToPoll(marketIndex);
+    async updatePerpMarketAccountsToPoll() {
+        for (const marketIndex of this.perpMarketIndexes) {
+            await this.addPerpMarketAccountToPoll(marketIndex);
         }
         return true;
     }
-    async addMarketAccountToPoll(marketIndex) {
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        this.accountsToPoll.set(marketPublicKey.toString(), {
-            key: 'market',
-            publicKey: marketPublicKey,
-            eventType: 'marketAccountUpdate',
-            mapKey: marketIndex.toNumber(),
+    async addPerpMarketAccountToPoll(marketIndex) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex);
+        this.accountsToPoll.set(perpMarketPublicKey.toString(), {
+            key: 'perpMarket',
+            publicKey: perpMarketPublicKey,
+            eventType: 'perpMarketAccountUpdate',
+            mapKey: marketIndex,
         });
         return true;
     }
-    async updateBankAccountsToPoll() {
-        for (const bankIndex of this.bankIndexes) {
-            await this.addBankAccountToPoll(bankIndex);
+    async updateSpotMarketAccountsToPoll() {
+        for (const marketIndex of this.spotMarketIndexes) {
+            await this.addSpotMarketAccountToPoll(marketIndex);
         }
         return true;
     }
-    async addBankAccountToPoll(bankIndex) {
-        const bankPublicKey = await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex);
-        this.accountsToPoll.set(bankPublicKey.toString(), {
-            key: 'bank',
-            publicKey: bankPublicKey,
-            eventType: 'bankAccountUpdate',
-            mapKey: bankIndex.toNumber(),
+    async addSpotMarketAccountToPoll(marketIndex) {
+        const marketPublicKey = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex);
+        this.accountsToPoll.set(marketPublicKey.toString(), {
+            key: 'spotMarket',
+            publicKey: marketPublicKey,
+            eventType: 'spotMarketAccountUpdate',
+            mapKey: marketIndex,
         });
         return true;
     }
@@ -114,13 +114,6 @@ class PollingClearingHouseAccountSubscriber {
         });
         return true;
     }
-    async getClearingHouseAccounts() {
-        const statePublicKey = await (0, pda_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
-        const accounts = {
-            state: statePublicKey,
-        };
-        return accounts;
-    }
     async addToAccountLoader() {
         for (const [_, accountToPoll] of this.accountsToPoll) {
             this.addAccountToAccountLoader(accountToPoll);
@@ -223,14 +216,14 @@ class PollingClearingHouseAccountSubscriber {
         this.oraclesToPoll.clear();
         this.isSubscribed = false;
     }
-    async addBank(bankIndex) {
-        await this.addBankAccountToPoll(bankIndex);
-        const accountToPoll = this.accountsToPoll.get(bankIndex.toString());
+    async addSpotMarket(marketIndex) {
+        await this.addSpotMarketAccountToPoll(marketIndex);
+        const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
         this.addAccountToAccountLoader(accountToPoll);
         return true;
     }
-    async addMarket(marketIndex) {
-        await this.addMarketAccountToPoll(marketIndex);
+    async addPerpMarket(marketIndex) {
+        await this.addPerpMarketAccountToPoll(marketIndex);
         const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
         this.addAccountToAccountLoader(accountToPoll);
         return true;
@@ -254,13 +247,16 @@ class PollingClearingHouseAccountSubscriber {
         return this.state;
     }
     getMarketAccountAndSlot(marketIndex) {
-        return this.market.get(marketIndex.toNumber());
+        return this.perpMarket.get(marketIndex);
     }
     getMarketAccountsAndSlots() {
-        return Array.from(this.market.values());
+        return Array.from(this.perpMarket.values());
+    }
+    getSpotMarketAccountAndSlot(marketIndex) {
+        return this.spotMarket.get(marketIndex);
     }
-    getBankAccountAndSlot(bankIndex) {
-        return this.bank.get(bankIndex.toNumber());
+    getSpotMarketAccountsAndSlots() {
+        return Array.from(this.spotMarket.values());
     }
     getOraclePriceDataAndSlot(oraclePublicKey) {
         this.assertIsSubscribed();
@@ -273,4 +269,4 @@ class PollingClearingHouseAccountSubscriber {
         return this.oracles.get(oraclePublicKey.toString());
     }
 }
-exports.PollingClearingHouseAccountSubscriber = PollingClearingHouseAccountSubscriber;
+exports.PollingDriftClientAccountSubscriber = PollingDriftClientAccountSubscriber;

package/lib/accounts/{pollingOracleSubscriber.d.ts → pollingOracleAccountSubscriber.d.ts}

@@ -1,12 +1,12 @@
 /// <reference types="node" />
-import { DataAndSlot, OracleEvents, OracleSubscriber } from './types';
+import { DataAndSlot, OracleEvents, OracleAccountSubscriber } from './types';
 import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './bulkAccountLoader';
 import { OracleClient, OraclePriceData } from '../oracles/types';
-export declare class PollingOracleSubscriber implements OracleSubscriber {
+export declare class PollingOracleAccountSubscriber implements OracleAccountSubscriber {
     isSubscribed: boolean;
     program: Program;
     eventEmitter: StrictEventEmitter<EventEmitter, OracleEvents>;

package/lib/accounts/{pollingOracleSubscriber.js → pollingOracleAccountSubscriber.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PollingOracleSubscriber = void 0;
+exports.PollingOracleAccountSubscriber = void 0;
 const types_1 = require("./types");
 const events_1 = require("events");
-class PollingOracleSubscriber {
+class PollingOracleAccountSubscriber {
     constructor(publicKey, oracleClient, accountLoader) {
         this.isSubscribed = false;
         this.publicKey = publicKey;
@@ -75,4 +75,4 @@ class PollingOracleSubscriber {
         return !!this.oraclePriceData;
     }
 }
-exports.PollingOracleSubscriber = PollingOracleSubscriber;
+exports.PollingOracleAccountSubscriber = PollingOracleAccountSubscriber;

package/lib/accounts/pollingUserStatsAccountSubscriber.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { DataAndSlot, AccountToPoll, UserStatsAccountSubscriber, UserStatsAccountEvents } from './types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { UserStatsAccount } from '../types';
+import { BulkAccountLoader } from './bulkAccountLoader';
+export declare class PollingUserStatsAccountSubscriber implements UserStatsAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+    userStatsAccountPublicKey: PublicKey;
+    accountLoader: BulkAccountLoader;
+    accountsToPoll: Map<string, AccountToPoll>;
+    errorCallbackId?: string;
+    userStats?: DataAndSlot<UserStatsAccount>;
+    constructor(program: Program, userStatsAccountPublicKey: PublicKey, accountLoader: BulkAccountLoader);
+    subscribe(): Promise<boolean>;
+    addToAccountLoader(): Promise<void>;
+    fetchIfUnloaded(): Promise<void>;
+    fetch(): Promise<void>;
+    didSubscriptionSucceed(): boolean;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}