@drift-labs/sdk 2.97.0-beta.9 → 2.98.0-beta.0

package/lib/node/accounts/webSocketAccountSubscriber.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketAccountSubscriber = void 0;
+const utils_1 = require("./utils");
+class WebSocketAccountSubscriber {
+    constructor(accountName, program, accountPublicKey, decodeBuffer, resubOpts, commitment) {
+        var _a;
+        this.isUnsubscribing = false;
+        this.accountName = accountName;
+        this.program = program;
+        this.accountPublicKey = accountPublicKey;
+        this.decodeBufferFn = decodeBuffer;
+        this.resubOpts = resubOpts;
+        if (((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) < 1000) {
+            console.log('resubTimeoutMs should be at least 1000ms to avoid spamming resub');
+        }
+        this.receivingData = false;
+        this.commitment =
+            commitment !== null && commitment !== void 0 ? commitment : this.program.provider.opts.commitment;
+    }
+    async subscribe(onChange) {
+        var _a;
+        if (this.listenerId != null || this.isUnsubscribing) {
+            return;
+        }
+        this.onChange = onChange;
+        if (!this.dataAndSlot) {
+            await this.fetch();
+        }
+        this.listenerId = this.program.provider.connection.onAccountChange(this.accountPublicKey, (accountInfo, context) => {
+            var _a;
+            if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
+                this.receivingData = true;
+                clearTimeout(this.timeoutId);
+                this.handleRpcResponse(context, accountInfo);
+                this.setTimeout();
+            }
+            else {
+                this.handleRpcResponse(context, accountInfo);
+            }
+        }, this.commitment);
+        if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
+            this.receivingData = true;
+            this.setTimeout();
+        }
+    }
+    setData(data, slot) {
+        const newSlot = slot || 0;
+        if (this.dataAndSlot && this.dataAndSlot.slot > newSlot) {
+            return;
+        }
+        this.dataAndSlot = {
+            data,
+            slot,
+        };
+    }
+    setTimeout() {
+        var _a;
+        if (!this.onChange) {
+            throw new Error('onChange callback function must be set');
+        }
+        this.timeoutId = setTimeout(async () => {
+            var _a;
+            if (this.isUnsubscribing) {
+                // If we are in the process of unsubscribing, do not attempt to resubscribe
+                return;
+            }
+            if (this.receivingData) {
+                if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.logResubMessages) {
+                    console.log(`No ws data from ${this.accountName} in ${this.resubOpts.resubTimeoutMs}ms, resubscribing`);
+                }
+                await this.unsubscribe(true);
+                this.receivingData = false;
+                await this.subscribe(this.onChange);
+            }
+        }, (_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs);
+    }
+    async fetch() {
+        const rpcResponse = await this.program.provider.connection.getAccountInfoAndContext(this.accountPublicKey, this.program.provider.opts.commitment);
+        this.handleRpcResponse(rpcResponse.context, rpcResponse === null || rpcResponse === void 0 ? void 0 : rpcResponse.value);
+    }
+    handleRpcResponse(context, accountInfo) {
+        const newSlot = context.slot;
+        let newBuffer = undefined;
+        if (accountInfo) {
+            newBuffer = accountInfo.data;
+        }
+        if (!this.bufferAndSlot) {
+            this.bufferAndSlot = {
+                buffer: newBuffer,
+                slot: newSlot,
+            };
+            if (newBuffer) {
+                const account = this.decodeBuffer(newBuffer);
+                this.dataAndSlot = {
+                    data: account,
+                    slot: newSlot,
+                };
+                this.onChange(account);
+            }
+            return;
+        }
+        if (newSlot < this.bufferAndSlot.slot) {
+            return;
+        }
+        const oldBuffer = this.bufferAndSlot.buffer;
+        if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+            this.bufferAndSlot = {
+                buffer: newBuffer,
+                slot: newSlot,
+            };
+            const account = this.decodeBuffer(newBuffer);
+            this.dataAndSlot = {
+                data: account,
+                slot: newSlot,
+            };
+            this.onChange(account);
+        }
+    }
+    decodeBuffer(buffer) {
+        if (this.decodeBufferFn) {
+            return this.decodeBufferFn(buffer);
+        }
+        else {
+            return this.program.account[this.accountName].coder.accounts.decode((0, utils_1.capitalize)(this.accountName), buffer);
+        }
+    }
+    unsubscribe(onResub = false) {
+        if (!onResub && this.resubOpts) {
+            this.resubOpts.resubTimeoutMs = undefined;
+        }
+        this.isUnsubscribing = true;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.listenerId != null) {
+            const promise = this.program.provider.connection
+                .removeAccountChangeListener(this.listenerId)
+                .then(() => {
+                this.listenerId = undefined;
+                this.isUnsubscribing = false;
+            });
+            return promise;
+        }
+        else {
+            this.isUnsubscribing = false;
+        }
+    }
+}
+exports.WebSocketAccountSubscriber = WebSocketAccountSubscriber;

package/lib/node/accounts/webSocketDriftClientAccountSubscriber.d.ts

@@ -0,0 +1,66 @@
+/// <reference types="node" />
+import { AccountSubscriber, DataAndSlot, DelistedMarketSetting, DriftClientAccountEvents, DriftClientAccountSubscriber, ResubOpts } from './types';
+import { PerpMarketAccount, SpotMarketAccount, StateAccount } from '../types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { Commitment, 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;
+    commitment?: Commitment;
+    perpMarketIndexes: number[];
+    spotMarketIndexes: number[];
+    oracleInfos: OracleInfo[];
+    oracleClientCache: OracleClientCache;
+    resubOpts?: ResubOpts;
+    shouldFindAllMarketsAndOracles: boolean;
+    eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
+    stateAccountSubscriber?: AccountSubscriber<StateAccount>;
+    perpMarketAccountSubscribers: Map<number, AccountSubscriber<PerpMarketAccount>>;
+    perpOracleMap: Map<number, PublicKey>;
+    perpOracleStringMap: Map<number, string>;
+    spotMarketAccountSubscribers: Map<number, AccountSubscriber<SpotMarketAccount>>;
+    spotOracleMap: Map<number, PublicKey>;
+    spotOracleStringMap: Map<number, string>;
+    oracleSubscribers: Map<string, AccountSubscriber<OraclePriceData>>;
+    delistedMarketSetting: DelistedMarketSetting;
+    initialPerpMarketAccountData: Map<number, PerpMarketAccount>;
+    initialSpotMarketAccountData: Map<number, SpotMarketAccount>;
+    initialOraclePriceData: Map<string, OraclePriceData>;
+    protected isSubscribing: boolean;
+    protected subscriptionPromise: Promise<boolean>;
+    protected subscriptionPromiseResolver: (val: boolean) => void;
+    constructor(program: Program, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[], shouldFindAllMarketsAndOracles: boolean, delistedMarketSetting: DelistedMarketSetting, resubOpts?: ResubOpts, commitment?: Commitment);
+    subscribe(): Promise<boolean>;
+    setInitialData(): Promise<void>;
+    removeInitialData(): void;
+    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>;
+    setPerpOracleMap(): Promise<void>;
+    setSpotOracleMap(): Promise<void>;
+    handleDelistedMarkets(): Promise<void>;
+    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 | string): DataAndSlot<OraclePriceData> | undefined;
+    getOraclePriceDataAndSlotForPerpMarket(marketIndex: number): DataAndSlot<OraclePriceData> | undefined;
+    getOraclePriceDataAndSlotForSpotMarket(marketIndex: number): DataAndSlot<OraclePriceData> | undefined;
+}

package/lib/node/accounts/webSocketDriftClientAccountSubscriber.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketDriftClientAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const pda_1 = require("../addresses/pda");
+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");
+const config_1 = require("../config");
+const utils_1 = require("./utils");
+const ORACLE_DEFAULT_KEY = web3_js_1.PublicKey.default.toBase58();
+class WebSocketDriftClientAccountSubscriber {
+    constructor(program, perpMarketIndexes, spotMarketIndexes, oracleInfos, shouldFindAllMarketsAndOracles, delistedMarketSetting, resubOpts, commitment) {
+        this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
+        this.perpMarketAccountSubscribers = new Map();
+        this.perpOracleMap = new Map();
+        this.perpOracleStringMap = new Map();
+        this.spotMarketAccountSubscribers = new Map();
+        this.spotOracleMap = new Map();
+        this.spotOracleStringMap = new Map();
+        this.oracleSubscribers = new Map();
+        this.isSubscribing = false;
+        this.isSubscribed = false;
+        this.program = program;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.perpMarketIndexes = perpMarketIndexes;
+        this.spotMarketIndexes = spotMarketIndexes;
+        this.oracleInfos = oracleInfos;
+        this.shouldFindAllMarketsAndOracles = shouldFindAllMarketsAndOracles;
+        this.delistedMarketSetting = delistedMarketSetting;
+        this.resubOpts = resubOpts;
+        this.commitment = commitment;
+    }
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        if (this.isSubscribing) {
+            return await this.subscriptionPromise;
+        }
+        this.isSubscribing = true;
+        this.subscriptionPromise = new Promise((res) => {
+            this.subscriptionPromiseResolver = res;
+        });
+        if (this.shouldFindAllMarketsAndOracles) {
+            const { perpMarketIndexes, perpMarketAccounts, spotMarketIndexes, spotMarketAccounts, oracleInfos, } = await (0, config_1.findAllMarketAndOracles)(this.program);
+            this.perpMarketIndexes = perpMarketIndexes;
+            this.spotMarketIndexes = spotMarketIndexes;
+            this.oracleInfos = oracleInfos;
+            // front run and set the initial data here to save extra gma call in set initial data
+            this.initialPerpMarketAccountData = new Map(perpMarketAccounts.map((market) => [market.marketIndex, market]));
+            this.initialSpotMarketAccountData = new Map(spotMarketAccounts.map((market) => [market.marketIndex, market]));
+        }
+        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, undefined, undefined, this.commitment);
+        await this.stateAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('stateAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        // set initial data to avoid spamming getAccountInfo calls in webSocketAccountSubscriber
+        await this.setInitialData();
+        await Promise.all([
+            // subscribe to market accounts
+            this.subscribeToPerpMarketAccounts(),
+            // subscribe to spot market accounts
+            this.subscribeToSpotMarketAccounts(),
+            // subscribe to oracles
+            this.subscribeToOracles(),
+        ]);
+        this.eventEmitter.emit('update');
+        await this.handleDelistedMarkets();
+        await Promise.all([this.setPerpOracleMap(), this.setSpotOracleMap()]);
+        this.isSubscribing = false;
+        this.isSubscribed = true;
+        this.subscriptionPromiseResolver(true);
+        // delete initial data
+        this.removeInitialData();
+        return true;
+    }
+    async setInitialData() {
+        const connection = this.program.provider.connection;
+        if (!this.initialPerpMarketAccountData) {
+            const perpMarketPublicKeys = this.perpMarketIndexes.map((marketIndex) => (0, pda_1.getPerpMarketPublicKeySync)(this.program.programId, marketIndex));
+            const perpMarketAccountInfos = await connection.getMultipleAccountsInfo(perpMarketPublicKeys);
+            this.initialPerpMarketAccountData = new Map(perpMarketAccountInfos
+                .filter((accountInfo) => !!accountInfo)
+                .map((accountInfo) => {
+                const perpMarket = this.program.coder.accounts.decode('PerpMarket', accountInfo.data);
+                return [perpMarket.marketIndex, perpMarket];
+            }));
+        }
+        if (!this.initialSpotMarketAccountData) {
+            const spotMarketPublicKeys = this.spotMarketIndexes.map((marketIndex) => (0, pda_1.getSpotMarketPublicKeySync)(this.program.programId, marketIndex));
+            const spotMarketAccountInfos = await connection.getMultipleAccountsInfo(spotMarketPublicKeys);
+            this.initialSpotMarketAccountData = new Map(spotMarketAccountInfos
+                .filter((accountInfo) => !!accountInfo)
+                .map((accountInfo) => {
+                const spotMarket = this.program.coder.accounts.decode('SpotMarket', accountInfo.data);
+                return [spotMarket.marketIndex, spotMarket];
+            }));
+        }
+        const oracleAccountInfos = await connection.getMultipleAccountsInfo(this.oracleInfos.map((oracleInfo) => oracleInfo.publicKey));
+        this.initialOraclePriceData = new Map(this.oracleInfos.reduce((result, oracleInfo, i) => {
+            if (!oracleAccountInfos[i]) {
+                return result;
+            }
+            const oracleClient = this.oracleClientCache.get(oracleInfo.source, connection, this.program);
+            const oraclePriceData = oracleClient.getOraclePriceDataFromBuffer(oracleAccountInfos[i].data);
+            result.push([oracleInfo.publicKey.toString(), oraclePriceData]);
+            return result;
+        }, []));
+    }
+    removeInitialData() {
+        this.initialPerpMarketAccountData = new Map();
+        this.initialSpotMarketAccountData = new Map();
+        this.initialOraclePriceData = new Map();
+    }
+    async subscribeToPerpMarketAccounts() {
+        await Promise.all(this.perpMarketIndexes.map((marketIndex) => this.subscribeToPerpMarketAccount(marketIndex)));
+        return true;
+    }
+    async subscribeToPerpMarketAccount(marketIndex) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex);
+        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('perpMarket', this.program, perpMarketPublicKey, undefined, this.resubOpts, this.commitment);
+        accountSubscriber.setData(this.initialPerpMarketAccountData.get(marketIndex));
+        await accountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('perpMarketAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.perpMarketAccountSubscribers.set(marketIndex, accountSubscriber);
+        return true;
+    }
+    async subscribeToSpotMarketAccounts() {
+        await Promise.all(this.spotMarketIndexes.map((marketIndex) => this.subscribeToSpotMarketAccount(marketIndex)));
+        return true;
+    }
+    async subscribeToSpotMarketAccount(marketIndex) {
+        const marketPublicKey = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex);
+        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('spotMarket', this.program, marketPublicKey, undefined, this.resubOpts, this.commitment);
+        accountSubscriber.setData(this.initialSpotMarketAccountData.get(marketIndex));
+        await accountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('spotMarketAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.spotMarketAccountSubscribers.set(marketIndex, accountSubscriber);
+        return true;
+    }
+    async subscribeToOracles() {
+        await Promise.all(this.oracleInfos
+            .filter((oracleInfo) => !oracleInfo.publicKey.equals(web3_js_1.PublicKey.default))
+            .map((oracleInfo) => this.subscribeToOracle(oracleInfo)));
+        return true;
+    }
+    async subscribeToOracle(oracleInfo) {
+        const oracleString = oracleInfo.publicKey.toString();
+        const client = this.oracleClientCache.get(oracleInfo.source, this.program.provider.connection, this.program);
+        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('oracle', this.program, oracleInfo.publicKey, (buffer) => {
+            return client.getOraclePriceDataFromBuffer(buffer);
+        }, this.resubOpts, this.commitment);
+        const initialOraclePriceData = this.initialOraclePriceData.get(oracleString);
+        if (initialOraclePriceData) {
+            accountSubscriber.setData(initialOraclePriceData);
+        }
+        await accountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('oraclePriceUpdate', oracleInfo.publicKey, data);
+            this.eventEmitter.emit('update');
+        });
+        this.oracleSubscribers.set(oracleString, accountSubscriber);
+        return true;
+    }
+    async unsubscribeFromMarketAccounts() {
+        await Promise.all(Array.from(this.perpMarketAccountSubscribers.values()).map((accountSubscriber) => accountSubscriber.unsubscribe()));
+    }
+    async unsubscribeFromSpotMarketAccounts() {
+        await Promise.all(Array.from(this.spotMarketAccountSubscribers.values()).map((accountSubscriber) => accountSubscriber.unsubscribe()));
+    }
+    async unsubscribeFromOracles() {
+        await Promise.all(Array.from(this.oracleSubscribers.values()).map((accountSubscriber) => accountSubscriber.unsubscribe()));
+    }
+    async fetch() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        const promises = [this.stateAccountSubscriber.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() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        await this.stateAccountSubscriber.unsubscribe();
+        await this.unsubscribeFromMarketAccounts();
+        await this.unsubscribeFromSpotMarketAccounts();
+        await this.unsubscribeFromOracles();
+        this.isSubscribed = false;
+    }
+    async addSpotMarket(marketIndex) {
+        if (this.spotMarketAccountSubscribers.has(marketIndex)) {
+            return true;
+        }
+        const subscriptionSuccess = this.subscribeToSpotMarketAccount(marketIndex);
+        await this.setSpotOracleMap();
+        return subscriptionSuccess;
+    }
+    async addPerpMarket(marketIndex) {
+        if (this.perpMarketAccountSubscribers.has(marketIndex)) {
+            return true;
+        }
+        const subscriptionSuccess = this.subscribeToPerpMarketAccount(marketIndex);
+        await this.setPerpOracleMap();
+        return subscriptionSuccess;
+    }
+    async addOracle(oracleInfo) {
+        if (this.oracleSubscribers.has(oracleInfo.publicKey.toString())) {
+            return true;
+        }
+        if (oracleInfo.publicKey.equals(web3_js_1.PublicKey.default)) {
+            return true;
+        }
+        return this.subscribeToOracle(oracleInfo);
+    }
+    async setPerpOracleMap() {
+        const perpMarkets = this.getMarketAccountsAndSlots();
+        const addOraclePromises = [];
+        for (const perpMarket of perpMarkets) {
+            if (!perpMarket || !perpMarket.data) {
+                continue;
+            }
+            const perpMarketAccount = perpMarket.data;
+            const perpMarketIndex = perpMarketAccount.marketIndex;
+            const oracle = perpMarketAccount.amm.oracle;
+            if (!this.oracleSubscribers.has(oracle.toBase58())) {
+                addOraclePromises.push(this.addOracle({
+                    publicKey: oracle,
+                    source: perpMarket.data.amm.oracleSource,
+                }));
+            }
+            this.perpOracleMap.set(perpMarketIndex, oracle);
+            this.perpOracleStringMap.set(perpMarketIndex, oracle.toBase58());
+        }
+        await Promise.all(addOraclePromises);
+    }
+    async setSpotOracleMap() {
+        const spotMarkets = this.getSpotMarketAccountsAndSlots();
+        const addOraclePromises = [];
+        for (const spotMarket of spotMarkets) {
+            if (!spotMarket || !spotMarket.data) {
+                continue;
+            }
+            const spotMarketAccount = spotMarket.data;
+            const spotMarketIndex = spotMarketAccount.marketIndex;
+            const oracle = spotMarketAccount.oracle;
+            if (!this.oracleSubscribers.has(oracle.toBase58())) {
+                addOraclePromises.push(this.addOracle({
+                    publicKey: oracle,
+                    source: spotMarketAccount.oracleSource,
+                }));
+            }
+            this.spotOracleMap.set(spotMarketIndex, oracle);
+            this.spotOracleStringMap.set(spotMarketIndex, oracle.toBase58());
+        }
+        await Promise.all(addOraclePromises);
+    }
+    async handleDelistedMarkets() {
+        if (this.delistedMarketSetting === types_1.DelistedMarketSetting.Subscribe) {
+            return;
+        }
+        const { perpMarketIndexes, oracles } = (0, utils_1.findDelistedPerpMarketsAndOracles)(this.getMarketAccountsAndSlots(), this.getSpotMarketAccountsAndSlots());
+        for (const perpMarketIndex of perpMarketIndexes) {
+            await this.perpMarketAccountSubscribers
+                .get(perpMarketIndex)
+                .unsubscribe();
+            if (this.delistedMarketSetting === types_1.DelistedMarketSetting.Discard) {
+                this.perpMarketAccountSubscribers.delete(perpMarketIndex);
+            }
+        }
+        for (const oracle of oracles) {
+            await this.oracleSubscribers.get(oracle.toBase58()).unsubscribe();
+            if (this.delistedMarketSetting === types_1.DelistedMarketSetting.Discard) {
+                this.oracleSubscribers.delete(oracle.toBase58());
+            }
+        }
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getStateAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.stateAccountSubscriber.dataAndSlot;
+    }
+    getMarketAccountAndSlot(marketIndex) {
+        this.assertIsSubscribed();
+        return this.perpMarketAccountSubscribers.get(marketIndex).dataAndSlot;
+    }
+    getMarketAccountsAndSlots() {
+        return Array.from(this.perpMarketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
+    }
+    getSpotMarketAccountAndSlot(marketIndex) {
+        this.assertIsSubscribed();
+        return this.spotMarketAccountSubscribers.get(marketIndex).dataAndSlot;
+    }
+    getSpotMarketAccountsAndSlots() {
+        return Array.from(this.spotMarketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
+    }
+    getOraclePriceDataAndSlot(oraclePublicKey) {
+        this.assertIsSubscribed();
+        const oracleString = typeof oraclePublicKey === 'string'
+            ? oraclePublicKey
+            : oraclePublicKey.toBase58();
+        if (oracleString === ORACLE_DEFAULT_KEY) {
+            return {
+                data: quoteAssetOracleClient_1.QUOTE_ORACLE_PRICE_DATA,
+                slot: 0,
+            };
+        }
+        return this.oracleSubscribers.get(oracleString).dataAndSlot;
+    }
+    getOraclePriceDataAndSlotForPerpMarket(marketIndex) {
+        const perpMarketAccount = this.getMarketAccountAndSlot(marketIndex);
+        const oracle = this.perpOracleMap.get(marketIndex);
+        const oracleString = this.perpOracleStringMap.get(marketIndex);
+        if (!perpMarketAccount || !oracle) {
+            return undefined;
+        }
+        if (!perpMarketAccount.data.amm.oracle.equals(oracle)) {
+            // If the oracle has changed, we need to update the oracle map in background
+            this.setPerpOracleMap();
+        }
+        return this.getOraclePriceDataAndSlot(oracleString);
+    }
+    getOraclePriceDataAndSlotForSpotMarket(marketIndex) {
+        const spotMarketAccount = this.getSpotMarketAccountAndSlot(marketIndex);
+        const oracle = this.spotOracleMap.get(marketIndex);
+        const oracleString = this.spotOracleStringMap.get(marketIndex);
+        if (!spotMarketAccount || !oracle) {
+            return undefined;
+        }
+        if (!spotMarketAccount.data.oracle.equals(oracle)) {
+            // If the oracle has changed, we need to update the oracle map in background
+            this.setSpotOracleMap();
+        }
+        return this.getOraclePriceDataAndSlot(oracleString);
+    }
+}
+exports.WebSocketDriftClientAccountSubscriber = WebSocketDriftClientAccountSubscriber;

package/lib/node/accounts/webSocketInsuranceFundStakeAccountSubscriber.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { DataAndSlot, AccountSubscriber, InsuranceFundStakeAccountEvents, InsuranceFundStakeAccountSubscriber } from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { InsuranceFundStake } from '../types';
+export declare class WebSocketInsuranceFundStakeAccountSubscriber implements InsuranceFundStakeAccountSubscriber {
+    isSubscribed: boolean;
+    resubTimeoutMs?: number;
+    commitment?: Commitment;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, InsuranceFundStakeAccountEvents>;
+    insuranceFundStakeAccountPublicKey: PublicKey;
+    insuranceFundStakeDataAccountSubscriber: AccountSubscriber<InsuranceFundStake>;
+    constructor(program: Program, insuranceFundStakeAccountPublicKey: PublicKey, resubTimeoutMs?: number, commitment?: Commitment);
+    subscribe(insuranceFundStakeAccount?: InsuranceFundStake): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getInsuranceFundStakeAccountAndSlot(): DataAndSlot<InsuranceFundStake>;
+    updateData(insuranceFundStake: InsuranceFundStake, slot: number): void;
+}

package/lib/node/accounts/webSocketInsuranceFundStakeAccountSubscriber.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketInsuranceFundStakeAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+class WebSocketInsuranceFundStakeAccountSubscriber {
+    constructor(program, insuranceFundStakeAccountPublicKey, resubTimeoutMs, commitment) {
+        this.isSubscribed = false;
+        this.program = program;
+        this.insuranceFundStakeAccountPublicKey =
+            insuranceFundStakeAccountPublicKey;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.resubTimeoutMs = resubTimeoutMs;
+        this.commitment = commitment;
+    }
+    async subscribe(insuranceFundStakeAccount) {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.insuranceFundStakeDataAccountSubscriber =
+            new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('insuranceFundStake', this.program, this.insuranceFundStakeAccountPublicKey, undefined, {
+                resubTimeoutMs: this.resubTimeoutMs,
+            }, this.commitment);
+        if (insuranceFundStakeAccount) {
+            this.insuranceFundStakeDataAccountSubscriber.setData(insuranceFundStakeAccount);
+        }
+        await this.insuranceFundStakeDataAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('insuranceFundStakeAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+    async fetch() {
+        await Promise.all([this.insuranceFundStakeDataAccountSubscriber.fetch()]);
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        await Promise.all([
+            this.insuranceFundStakeDataAccountSubscriber.unsubscribe(),
+        ]);
+        this.isSubscribed = false;
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getInsuranceFundStakeAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.insuranceFundStakeDataAccountSubscriber.dataAndSlot;
+    }
+    updateData(insuranceFundStake, slot) {
+        var _a;
+        const currentDataSlot = ((_a = this.insuranceFundStakeDataAccountSubscriber.dataAndSlot) === null || _a === void 0 ? void 0 : _a.slot) || 0;
+        if (currentDataSlot <= slot) {
+            this.insuranceFundStakeDataAccountSubscriber.setData(insuranceFundStake, slot);
+            this.eventEmitter.emit('insuranceFundStakeAccountUpdate', insuranceFundStake);
+            this.eventEmitter.emit('update');
+        }
+    }
+}
+exports.WebSocketInsuranceFundStakeAccountSubscriber = WebSocketInsuranceFundStakeAccountSubscriber;