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

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>;
+    doAccountsExist(): boolean;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}

package/lib/accounts/pollingUserStatsAccountSubscriber.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingUserStatsAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const utils_1 = require("./utils");
+class PollingUserStatsAccountSubscriber {
+    constructor(program, userStatsAccountPublicKey, accountLoader) {
+        this.accountsToPoll = new Map();
+        this.isSubscribed = false;
+        this.program = program;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+    }
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        await this.addToAccountLoader();
+        await this.fetchIfUnloaded();
+        if (this.doAccountsExist()) {
+            this.eventEmitter.emit('update');
+        }
+        this.isSubscribed = true;
+        return true;
+    }
+    async addToAccountLoader() {
+        if (this.accountsToPoll.size > 0) {
+            return;
+        }
+        this.accountsToPoll.set(this.userStatsAccountPublicKey.toString(), {
+            key: 'userStats',
+            publicKey: this.userStatsAccountPublicKey,
+            eventType: 'userStatsAccountUpdate',
+        });
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            accountToPoll.callbackId = this.accountLoader.addAccount(accountToPoll.publicKey, (buffer, slot) => {
+                if (!buffer) {
+                    return;
+                }
+                const account = this.program.account[accountToPoll.key].coder.accounts.decode((0, utils_1.capitalize)(accountToPoll.key), buffer);
+                this[accountToPoll.key] = { data: account, slot };
+                // @ts-ignore
+                this.eventEmitter.emit(accountToPoll.eventType, account);
+                this.eventEmitter.emit('update');
+            });
+        }
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
+    }
+    async fetchIfUnloaded() {
+        let shouldFetch = false;
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            if (this[accountToPoll.key] === undefined) {
+                shouldFetch = true;
+                break;
+            }
+        }
+        if (shouldFetch) {
+            await this.fetch();
+        }
+    }
+    async fetch() {
+        await this.accountLoader.load();
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            const { buffer, slot } = this.accountLoader.getBufferAndSlot(accountToPoll.publicKey);
+            if (buffer) {
+                const account = this.program.account[accountToPoll.key].coder.accounts.decode((0, utils_1.capitalize)(accountToPoll.key), buffer);
+                this[accountToPoll.key] = { data: account, slot };
+            }
+        }
+    }
+    doAccountsExist() {
+        let success = true;
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            if (!this[accountToPoll.key]) {
+                success = false;
+                break;
+            }
+        }
+        return success;
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            this.accountLoader.removeAccount(accountToPoll.publicKey, accountToPoll.callbackId);
+        }
+        this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+        this.errorCallbackId = undefined;
+        this.accountsToPoll.clear();
+        this.isSubscribed = false;
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getUserStatsAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.userStats;
+    }
+}
+exports.PollingUserStatsAccountSubscriber = PollingUserStatsAccountSubscriber;

package/lib/accounts/types.d.ts

@@ -1,13 +1,10 @@
 /// <reference types="node" />
-/// <reference types="bn.js" />
-/// <reference types="node" />
-import { BankAccount, MarketAccount, OracleSource, StateAccount, UserAccount } from '../types';
+import { SpotMarketAccount, PerpMarketAccount, OracleSource, StateAccount, UserAccount, UserStatsAccount } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
 import { AccountInfo } from '@solana/spl-token';
 import { OracleInfo, OraclePriceData } from '..';
-import { BN } from '@project-serum/anchor';
 export interface AccountSubscriber<T> {
     dataAndSlot?: DataAndSlot<T>;
     subscribe(onChange: (data: T) => void): Promise<void>;
@@ -17,28 +14,29 @@ export interface AccountSubscriber<T> {
 export declare class NotSubscribedError extends Error {
     name: string;
 }
-export interface ClearingHouseAccountEvents {
+export interface DriftClientAccountEvents {
     stateAccountUpdate: (payload: StateAccount) => void;
-    marketAccountUpdate: (payload: MarketAccount) => void;
-    bankAccountUpdate: (payload: BankAccount) => void;
+    perpMarketAccountUpdate: (payload: PerpMarketAccount) => void;
+    spotMarketAccountUpdate: (payload: SpotMarketAccount) => void;
     oraclePriceUpdate: (publicKey: PublicKey, data: OraclePriceData) => void;
     userAccountUpdate: (payload: UserAccount) => void;
     update: void;
     error: (e: Error) => void;
 }
-export interface ClearingHouseAccountSubscriber {
-    eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
+export interface DriftClientAccountSubscriber {
+    eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
     isSubscribed: boolean;
     subscribe(): Promise<boolean>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
-    addMarket(marketIndex: BN): Promise<boolean>;
-    addBank(bankIndex: BN): Promise<boolean>;
+    addPerpMarket(marketIndex: number): Promise<boolean>;
+    addSpotMarket(marketIndex: number): Promise<boolean>;
     addOracle(oracleInfo: OracleInfo): Promise<boolean>;
     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;
 }
 export interface UserAccountEvents {
@@ -72,7 +70,7 @@ export interface OracleEvents {
     update: void;
     error: (e: Error) => void;
 }
-export interface OracleSubscriber {
+export interface OracleAccountSubscriber {
     eventEmitter: StrictEventEmitter<EventEmitter, OracleEvents>;
     isSubscribed: boolean;
     subscribe(): Promise<boolean>;
@@ -100,3 +98,16 @@ export declare type DataAndSlot<T> = {
     data: T;
     slot: number;
 };
+export interface UserStatsAccountEvents {
+    userStatsAccountUpdate: (payload: UserStatsAccount) => void;
+    update: void;
+    error: (e: Error) => void;
+}
+export interface UserStatsAccountSubscriber {
+    eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+    isSubscribed: boolean;
+    subscribe(): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}

package/lib/accounts/webSocketDriftClientAccountSubscriber.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+import { DriftClientAccountSubscriber, DriftClientAccountEvents, DataAndSlot } from './types';
+import { AccountSubscriber } from './types';
+import { SpotMarketAccount, PerpMarketAccount, StateAccount } 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 { OracleInfo, OraclePriceData } from '../oracles/types';
+import { OracleClientCache } from '../oracles/oracleClientCache';
+export declare class WebSocketDriftClientAccountSubscriber implements DriftClientAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    perpMarketIndexes: number[];
+    spotMarketIndexes: number[];
+    oracleInfos: OracleInfo[];
+    oracleClientCache: OracleClientCache;
+    eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
+    stateAccountSubscriber?: AccountSubscriber<StateAccount>;
+    perpMarketAccountSubscribers: Map<number, AccountSubscriber<PerpMarketAccount>>;
+    spotMarketAccountSubscribers: Map<number, AccountSubscriber<SpotMarketAccount>>;
+    oracleSubscribers: Map<string, AccountSubscriber<OraclePriceData>>;
+    private isSubscribing;
+    private subscriptionPromise;
+    private subscriptionPromiseResolver;
+    constructor(program: Program, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[]);
+    subscribe(): Promise<boolean>;
+    subscribeToPerpMarketAccounts(): Promise<boolean>;
+    subscribeToPerpMarketAccount(marketIndex: number): Promise<boolean>;
+    subscribeToSpotMarketAccounts(): Promise<boolean>;
+    subscribeToSpotMarketAccount(marketIndex: number): Promise<boolean>;
+    subscribeToOracles(): Promise<boolean>;
+    subscribeToOracle(oracleInfo: OracleInfo): Promise<boolean>;
+    unsubscribeFromMarketAccounts(): Promise<void>;
+    unsubscribeFromSpotMarketAccounts(): Promise<void>;
+    unsubscribeFromOracles(): Promise<void>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    addSpotMarket(marketIndex: number): Promise<boolean>;
+    addPerpMarket(marketIndex: number): Promise<boolean>;
+    addOracle(oracleInfo: OracleInfo): Promise<boolean>;
+    assertIsSubscribed(): void;
+    getStateAccountAndSlot(): DataAndSlot<StateAccount>;
+    getMarketAccountAndSlot(marketIndex: number): DataAndSlot<PerpMarketAccount> | undefined;
+    getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[];
+    getSpotMarketAccountAndSlot(marketIndex: number): DataAndSlot<SpotMarketAccount> | undefined;
+    getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[];
+    getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
+}

package/lib/accounts/{webSocketClearingHouseAccountSubscriber.js → webSocketDriftClientAccountSubscriber.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketClearingHouseAccountSubscriber = void 0;
+exports.WebSocketDriftClientAccountSubscriber = void 0;
 const types_1 = require("./types");
 const events_1 = require("events");
 const pda_1 = require("../addresses/pda");
@@ -8,18 +8,18 @@ const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
 const web3_js_1 = require("@solana/web3.js");
 const oracleClientCache_1 = require("../oracles/oracleClientCache");
 const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
-class WebSocketClearingHouseAccountSubscriber {
-    constructor(program, marketIndexes, bankIndexes, oracleInfos) {
+class WebSocketDriftClientAccountSubscriber {
+    constructor(program, perpMarketIndexes, spotMarketIndexes, oracleInfos) {
         this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
-        this.marketAccountSubscribers = new Map();
-        this.bankAccountSubscribers = new Map();
+        this.perpMarketAccountSubscribers = new Map();
+        this.spotMarketAccountSubscribers = new Map();
         this.oracleSubscribers = new Map();
         this.isSubscribing = false;
         this.isSubscribed = false;
         this.program = program;
         this.eventEmitter = new events_1.EventEmitter();
-        this.marketIndexes = marketIndexes;
-        this.bankIndexes = bankIndexes;
+        this.perpMarketIndexes = perpMarketIndexes;
+        this.spotMarketIndexes = spotMarketIndexes;
         this.oracleInfos = oracleInfos;
     }
     async subscribe() {
@@ -33,7 +33,7 @@ class WebSocketClearingHouseAccountSubscriber {
         this.subscriptionPromise = new Promise((res) => {
             this.subscriptionPromiseResolver = res;
         });
-        const statePublicKey = await (0, pda_1.getClearingHouseStateAccountPublicKey)(this.program.programId);
+        const statePublicKey = await (0, pda_1.getDriftStateAccountPublicKey)(this.program.programId);
         // create and activate main state account subscription
         this.stateAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('state', this.program, statePublicKey);
         await this.stateAccountSubscriber.subscribe((data) => {
@@ -41,9 +41,9 @@ class WebSocketClearingHouseAccountSubscriber {
             this.eventEmitter.emit('update');
         });
         // subscribe to market accounts
-        await this.subscribeToMarketAccounts();
-        // subscribe to bank accounts
-        await this.subscribeToBankAccounts();
+        await this.subscribeToPerpMarketAccounts();
+        // subscribe to spot market accounts
+        await this.subscribeToSpotMarketAccounts();
         // subscribe to oracles
         await this.subscribeToOracles();
         this.eventEmitter.emit('update');
@@ -52,36 +52,36 @@ class WebSocketClearingHouseAccountSubscriber {
         this.subscriptionPromiseResolver(true);
         return true;
     }
-    async subscribeToMarketAccounts() {
-        for (const marketIndex of this.marketIndexes) {
-            await this.subscribeToMarketAccount(marketIndex);
+    async subscribeToPerpMarketAccounts() {
+        for (const marketIndex of this.perpMarketIndexes) {
+            await this.subscribeToPerpMarketAccount(marketIndex);
         }
         return true;
     }
-    async subscribeToMarketAccount(marketIndex) {
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('market', this.program, marketPublicKey);
+    async subscribeToPerpMarketAccount(marketIndex) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex);
+        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('perpMarket', this.program, perpMarketPublicKey);
         await accountSubscriber.subscribe((data) => {
-            this.eventEmitter.emit('marketAccountUpdate', data);
+            this.eventEmitter.emit('perpMarketAccountUpdate', data);
             this.eventEmitter.emit('update');
         });
-        this.marketAccountSubscribers.set(marketIndex.toNumber(), accountSubscriber);
+        this.perpMarketAccountSubscribers.set(marketIndex, accountSubscriber);
         return true;
     }
-    async subscribeToBankAccounts() {
-        for (const bankIndex of this.bankIndexes) {
-            await this.subscribeToBankAccount(bankIndex);
+    async subscribeToSpotMarketAccounts() {
+        for (const marketIndex of this.spotMarketIndexes) {
+            await this.subscribeToSpotMarketAccount(marketIndex);
         }
         return true;
     }
-    async subscribeToBankAccount(bankIndex) {
-        const bankPublicKey = await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex);
-        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('bank', this.program, bankPublicKey);
+    async subscribeToSpotMarketAccount(marketIndex) {
+        const marketPublicKey = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex);
+        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('spotMarket', this.program, marketPublicKey);
         await accountSubscriber.subscribe((data) => {
-            this.eventEmitter.emit('bankAccountUpdate', data);
+            this.eventEmitter.emit('spotMarketAccountUpdate', data);
             this.eventEmitter.emit('update');
         });
-        this.bankAccountSubscribers.set(bankIndex.toNumber(), accountSubscriber);
+        this.spotMarketAccountSubscribers.set(marketIndex, accountSubscriber);
         return true;
     }
     async subscribeToOracles() {
@@ -105,12 +105,12 @@ class WebSocketClearingHouseAccountSubscriber {
         return true;
     }
     async unsubscribeFromMarketAccounts() {
-        for (const accountSubscriber of this.marketAccountSubscribers.values()) {
+        for (const accountSubscriber of this.perpMarketAccountSubscribers.values()) {
             await accountSubscriber.unsubscribe();
         }
     }
-    async unsubscribeFromBankAccounts() {
-        for (const accountSubscriber of this.bankAccountSubscribers.values()) {
+    async unsubscribeFromSpotMarketAccounts() {
+        for (const accountSubscriber of this.spotMarketAccountSubscribers.values()) {
             await accountSubscriber.unsubscribe();
         }
     }
@@ -124,8 +124,8 @@ class WebSocketClearingHouseAccountSubscriber {
             return;
         }
         const promises = [this.stateAccountSubscriber.fetch()]
-            .concat(Array.from(this.marketAccountSubscribers.values()).map((subscriber) => subscriber.fetch()))
-            .concat(Array.from(this.bankAccountSubscribers.values()).map((subscriber) => subscriber.fetch()));
+            .concat(Array.from(this.perpMarketAccountSubscribers.values()).map((subscriber) => subscriber.fetch()))
+            .concat(Array.from(this.spotMarketAccountSubscribers.values()).map((subscriber) => subscriber.fetch()));
         await Promise.all(promises);
     }
     async unsubscribe() {
@@ -134,21 +134,21 @@ class WebSocketClearingHouseAccountSubscriber {
         }
         await this.stateAccountSubscriber.unsubscribe();
         await this.unsubscribeFromMarketAccounts();
-        await this.unsubscribeFromBankAccounts();
+        await this.unsubscribeFromSpotMarketAccounts();
         await this.unsubscribeFromOracles();
         this.isSubscribed = false;
     }
-    async addBank(bankIndex) {
-        if (this.bankAccountSubscribers.has(bankIndex.toNumber())) {
+    async addSpotMarket(marketIndex) {
+        if (this.spotMarketAccountSubscribers.has(marketIndex)) {
             return true;
         }
-        return this.subscribeToBankAccount(bankIndex);
+        return this.subscribeToSpotMarketAccount(marketIndex);
     }
-    async addMarket(marketIndex) {
-        if (this.marketAccountSubscribers.has(marketIndex.toNumber())) {
+    async addPerpMarket(marketIndex) {
+        if (this.perpMarketAccountSubscribers.has(marketIndex)) {
             return true;
         }
-        return this.subscribeToMarketAccount(marketIndex);
+        return this.subscribeToPerpMarketAccount(marketIndex);
     }
     async addOracle(oracleInfo) {
         if (this.oracleSubscribers.has(oracleInfo.publicKey.toString())) {
@@ -170,15 +170,17 @@ class WebSocketClearingHouseAccountSubscriber {
     }
     getMarketAccountAndSlot(marketIndex) {
         this.assertIsSubscribed();
-        return this.marketAccountSubscribers.get(marketIndex.toNumber())
-            .dataAndSlot;
+        return this.perpMarketAccountSubscribers.get(marketIndex).dataAndSlot;
     }
     getMarketAccountsAndSlots() {
-        return Array.from(this.marketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
+        return Array.from(this.perpMarketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
     }
-    getBankAccountAndSlot(bankIndex) {
+    getSpotMarketAccountAndSlot(marketIndex) {
         this.assertIsSubscribed();
-        return this.bankAccountSubscribers.get(bankIndex.toNumber()).dataAndSlot;
+        return this.spotMarketAccountSubscribers.get(marketIndex).dataAndSlot;
+    }
+    getSpotMarketAccountsAndSlots() {
+        return Array.from(this.spotMarketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
     }
     getOraclePriceDataAndSlot(oraclePublicKey) {
         this.assertIsSubscribed();
@@ -191,4 +193,4 @@ class WebSocketClearingHouseAccountSubscriber {
         return this.oracleSubscribers.get(oraclePublicKey.toString()).dataAndSlot;
     }
 }
-exports.WebSocketClearingHouseAccountSubscriber = WebSocketClearingHouseAccountSubscriber;
+exports.WebSocketDriftClientAccountSubscriber = WebSocketDriftClientAccountSubscriber;

package/lib/accounts/webSocketUserStatsAccountSubsriber.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { DataAndSlot, AccountSubscriber, 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';
+export declare class WebSocketUserStatsAccountSubscriber implements UserStatsAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+    userStatsAccountPublicKey: PublicKey;
+    userStatsAccountSubscriber: AccountSubscriber<UserStatsAccount>;
+    constructor(program: Program, userStatsAccountPublicKey: PublicKey);
+    subscribe(): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}

package/lib/accounts/webSocketUserStatsAccountSubsriber.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketUserStatsAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+class WebSocketUserStatsAccountSubscriber {
+    constructor(program, userStatsAccountPublicKey) {
+        this.isSubscribed = false;
+        this.program = program;
+        this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.userStatsAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('userStats', this.program, this.userStatsAccountPublicKey);
+        await this.userStatsAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('userStatsAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+    async fetch() {
+        await Promise.all([this.userStatsAccountSubscriber.fetch()]);
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        await Promise.all([this.userStatsAccountSubscriber.unsubscribe()]);
+        this.isSubscribed = false;
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getUserStatsAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.userStatsAccountSubscriber.dataAndSlot;
+    }
+}
+exports.WebSocketUserStatsAccountSubscriber = WebSocketUserStatsAccountSubscriber;

package/lib/addresses/marketAddresses.d.ts

@@ -1,4 +1,2 @@
-/// <reference types="bn.js" />
 import { PublicKey } from '@solana/web3.js';
-import { BN } from '@project-serum/anchor';
-export declare function getMarketAddress(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
+export declare function getMarketAddress(programId: PublicKey, marketIndex: number): Promise<PublicKey>;

package/lib/addresses/marketAddresses.js

@@ -8,7 +8,7 @@ async function getMarketAddress(programId, marketIndex) {
     if (CACHE.has(cacheKey)) {
         return CACHE.get(cacheKey);
     }
-    const publicKey = await (0, pda_1.getMarketPublicKey)(programId, marketIndex);
+    const publicKey = await (0, pda_1.getPerpMarketPublicKey)(programId, marketIndex);
     CACHE.set(cacheKey, publicKey);
     return publicKey;
 }

package/lib/addresses/pda.d.ts

@@ -1,12 +1,18 @@
 /// <reference types="bn.js" />
 import { PublicKey } from '@solana/web3.js';
 import { BN } from '@project-serum/anchor';
-export declare function getClearingHouseStateAccountPublicKeyAndNonce(programId: PublicKey): Promise<[PublicKey, number]>;
-export declare function getClearingHouseStateAccountPublicKey(programId: PublicKey): Promise<PublicKey>;
-export declare function getUserAccountPublicKeyAndNonce(programId: PublicKey, authority: PublicKey, userId?: number): Promise<[PublicKey, number]>;
-export declare function getUserAccountPublicKey(programId: PublicKey, authority: PublicKey, userId?: number): Promise<PublicKey>;
-export declare function getUserAccountPublicKeySync(programId: PublicKey, authority: PublicKey, userId?: number): PublicKey;
-export declare function getMarketPublicKey(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
-export declare function getBankPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
-export declare function getBankVaultPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
-export declare function getBankVaultAuthorityPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
+export declare function getDriftStateAccountPublicKeyAndNonce(programId: PublicKey): Promise<[PublicKey, number]>;
+export declare function getDriftStateAccountPublicKey(programId: PublicKey): Promise<PublicKey>;
+export declare function getUserAccountPublicKeyAndNonce(programId: PublicKey, authority: PublicKey, subAccountId?: number): Promise<[PublicKey, number]>;
+export declare function getUserAccountPublicKey(programId: PublicKey, authority: PublicKey, subAccountId?: number): Promise<PublicKey>;
+export declare function getUserAccountPublicKeySync(programId: PublicKey, authority: PublicKey, subAccountId?: number): PublicKey;
+export declare function getUserStatsAccountPublicKey(programId: PublicKey, authority: PublicKey): PublicKey;
+export declare function getPerpMarketPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getSpotMarketPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getSpotMarketVaultPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getInsuranceFundVaultPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getInsuranceFundStakeAccountPublicKey(programId: PublicKey, authority: PublicKey, marketIndex: number): PublicKey;
+export declare function getDriftSignerPublicKey(programId: PublicKey): PublicKey;
+export declare function getSerumOpenOrdersPublicKey(programId: PublicKey, market: PublicKey): PublicKey;
+export declare function getSerumSignerPublicKey(programId: PublicKey, market: PublicKey, nonce: BN): PublicKey;
+export declare function getSerumFulfillmentConfigPublicKey(programId: PublicKey, market: PublicKey): PublicKey;