@velocity-exchange/sdk 0.0.1

package/lib/node/accounts/pollingUserStatsAccountSubscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pollingUserStatsAccountSubscriber.d.ts","sourceRoot":"","sources":["../../../src/accounts/pollingUserStatsAccountSubscriber.ts"],"names":[],"mappings":";AAAA,OAAO,EACN,WAAW,EAEX,0BAA0B,EAC1B,sBAAsB,EACtB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,kBAAkB,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,qBAAa,iCACZ,YAAW,0BAA0B;IAErC,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,eAAe,CAAC;IACzB,YAAY,EAAE,kBAAkB,CAAC,YAAY,EAAE,sBAAsB,CAAC,CAAC;IACvE,yBAAyB,EAAE,SAAS,CAAC;IAErC,aAAa,EAAE,iBAAiB,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,SAAS,CAAC,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC;gBAGzC,OAAO,EAAE,eAAe,EACxB,yBAAyB,EAAE,SAAS,EACpC,aAAa,EAAE,iBAAiB;IAS3B,SAAS,CAAC,gBAAgB,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBhE,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IA+BnC,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAMhC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAqB5B,gBAAgB,IAAI,OAAO;IAIrB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBlC,kBAAkB,IAAI,IAAI;IAQnB,0BAA0B,IAAI,WAAW,CAAC,gBAAgB,CAAC;CAQlE"}

package/lib/node/accounts/pollingUserStatsAccountSubscriber.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingUserStatsAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+class PollingUserStatsAccountSubscriber {
+    constructor(program, userStatsAccountPublicKey, accountLoader) {
+        this.isSubscribed = false;
+        this.program = program;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+    }
+    async subscribe(userStatsAccount) {
+        if (this.isSubscribed) {
+            return true;
+        }
+        if (userStatsAccount) {
+            this.userStats = { data: userStatsAccount, slot: undefined };
+        }
+        await this.addToAccountLoader();
+        await this.fetchIfUnloaded();
+        if (this.doesAccountExist()) {
+            this.eventEmitter.emit('update');
+        }
+        this.isSubscribed = true;
+        return true;
+    }
+    async addToAccountLoader() {
+        if (this.callbackId !== undefined) {
+            return;
+        }
+        this.callbackId = await this.accountLoader.addAccount(this.userStatsAccountPublicKey, (buffer, slot) => {
+            if (!buffer) {
+                return;
+            }
+            if (this.userStats && this.userStats.slot > slot) {
+                return;
+            }
+            const account = this.program.coder.accounts.decodeUnchecked('userStats', buffer);
+            this.userStats = { data: account, slot };
+            this.eventEmitter.emit('userStatsAccountUpdate', account);
+            this.eventEmitter.emit('update');
+        });
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
+    }
+    async fetchIfUnloaded() {
+        if (this.userStats === undefined) {
+            await this.fetch();
+        }
+    }
+    async fetch() {
+        var _a, _b;
+        try {
+            const dataAndContext = await this.program.account.userStats.fetchAndContext(this.userStatsAccountPublicKey, this.accountLoader.commitment);
+            if (dataAndContext.context.slot > ((_b = (_a = this.userStats) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : 0)) {
+                this.userStats = {
+                    data: dataAndContext.data,
+                    slot: dataAndContext.context.slot,
+                };
+            }
+        }
+        catch (e) {
+            console.log(`PollingUserStatsAccountSubscriber.fetch() UserStatsAccount does not exist: ${e.message}`);
+        }
+    }
+    doesAccountExist() {
+        return this.userStats !== undefined;
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        this.accountLoader.removeAccount(this.userStatsAccountPublicKey, this.callbackId);
+        this.callbackId = undefined;
+        this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+        this.errorCallbackId = undefined;
+        this.isSubscribed = false;
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getUserStatsAccountAndSlot() {
+        if (!this.doesAccountExist()) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` or `fetch` before using this function');
+        }
+        return this.userStats;
+    }
+}
+exports.PollingUserStatsAccountSubscriber = PollingUserStatsAccountSubscriber;

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

@@ -0,0 +1,74 @@
+/// <reference types="node" />
+import { AccountToPoll, DataAndSlot, DelistedMarketSetting, VelocityClientAccountEvents, VelocityClientAccountSubscriber, OraclesToPoll } from './types';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PerpMarketAccount, SpotMarketAccount, 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';
+import { VelocityProgram } from '../config';
+export declare class PollingVelocityClientAccountSubscriber implements VelocityClientAccountSubscriber {
+    isSubscribed: boolean;
+    program: VelocityProgram;
+    perpMarketIndexes: number[];
+    spotMarketIndexes: number[];
+    oracleInfos: OracleInfo[];
+    oracleClientCache: OracleClientCache;
+    shouldFindAllMarketsAndOracles: boolean;
+    eventEmitter: StrictEventEmitter<EventEmitter, VelocityClientAccountEvents>;
+    accountLoader: BulkAccountLoader;
+    accountsToPoll: Map<string, AccountToPoll>;
+    oraclesToPoll: Map<string, OraclesToPoll>;
+    errorCallbackId?: string;
+    state?: DataAndSlot<StateAccount>;
+    perpMarket: Map<number, DataAndSlot<PerpMarketAccount>>;
+    perpOracleMap: Map<number, PublicKey>;
+    perpOracleStringMap: Map<number, string>;
+    spotMarket: Map<number, DataAndSlot<SpotMarketAccount>>;
+    spotOracleMap: Map<number, PublicKey>;
+    spotOracleStringMap: Map<number, string>;
+    oracles: Map<string, DataAndSlot<OraclePriceData>>;
+    user?: DataAndSlot<UserAccount>;
+    delistedMarketSetting: DelistedMarketSetting;
+    private isSubscribing;
+    private subscriptionPromise;
+    private subscriptionPromiseResolver;
+    constructor(program: VelocityProgram, accountLoader: BulkAccountLoader, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[], shouldFindAllMarketsAndOracles: boolean, delistedMarketSetting: DelistedMarketSetting);
+    subscribe(): Promise<boolean>;
+    updateAccountsToPoll(): Promise<void>;
+    updatePerpMarketAccountsToPoll(): Promise<boolean>;
+    addPerpMarketAccountToPoll(marketIndex: number): Promise<boolean>;
+    updateSpotMarketAccountsToPoll(): Promise<boolean>;
+    addSpotMarketAccountToPoll(marketIndex: number): Promise<boolean>;
+    updateOraclesToPoll(): boolean;
+    addOracleToPoll(oracleInfo: OracleInfo): boolean;
+    addToAccountLoader(): Promise<void>;
+    addAccountToAccountLoader(accountToPoll: AccountToPoll): Promise<void>;
+    addOracleToAccountLoader(oracleToPoll: OraclesToPoll): Promise<void>;
+    fetch(): Promise<void>;
+    didSubscriptionSucceed(): boolean;
+    unsubscribe(): Promise<void>;
+    addSpotMarket(marketIndex: number): Promise<boolean>;
+    addPerpMarket(marketIndex: number): Promise<boolean>;
+    addOracle(oracleInfo: OracleInfo): Promise<boolean>;
+    private pauseForOracleToBeAdded;
+    setPerpOracleMap(): Promise<void>;
+    setSpotOracleMap(): Promise<void>;
+    handleDelistedMarkets(): 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(oracleId: string): DataAndSlot<OraclePriceData> | undefined;
+    getOraclePriceDataAndSlotForPerpMarket(marketIndex: number): DataAndSlot<OraclePriceData> | undefined;
+    getOraclePriceDataAndSlotForSpotMarket(marketIndex: number): DataAndSlot<OraclePriceData> | undefined;
+    updateAccountLoaderPollingFrequency(pollingFrequency: number): void;
+}
+/** @deprecated Use `PollingVelocityClientAccountSubscriber` instead. `PollingDriftClientAccountSubscriber` will be removed in a future major. */
+export declare const PollingDriftClientAccountSubscriber: typeof PollingVelocityClientAccountSubscriber;
+/** @deprecated Use `PollingVelocityClientAccountSubscriber` instead. `PollingDriftClientAccountSubscriber` will be removed in a future major. */
+export type PollingDriftClientAccountSubscriber = PollingVelocityClientAccountSubscriber;
+//# sourceMappingURL=pollingVelocityClientAccountSubscriber.d.ts.map

package/lib/node/accounts/pollingVelocityClientAccountSubscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pollingVelocityClientAccountSubscriber.d.ts","sourceRoot":"","sources":["../../../src/accounts/pollingVelocityClientAccountSubscriber.ts"],"names":[],"mappings":"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"}

package/lib/node/accounts/pollingVelocityClientAccountSubscriber.js

@@ -0,0 +1,420 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingDriftClientAccountSubscriber = exports.PollingVelocityClientAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const types_2 = require("../types");
+const pda_1 = require("../addresses/pda");
+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");
+const config_1 = require("../config");
+const oracleId_1 = require("../oracles/oracleId");
+const ORACLE_DEFAULT_ID = (0, oracleId_1.getOracleId)(web3_js_1.PublicKey.default, types_2.OracleSource.QUOTE_ASSET);
+class PollingVelocityClientAccountSubscriber {
+    constructor(program, accountLoader, perpMarketIndexes, spotMarketIndexes, oracleInfos, shouldFindAllMarketsAndOracles, delistedMarketSetting) {
+        this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
+        this.accountsToPoll = new Map();
+        this.oraclesToPoll = new Map();
+        this.perpMarket = new Map();
+        this.perpOracleMap = new Map();
+        this.perpOracleStringMap = new Map();
+        this.spotMarket = new Map();
+        this.spotOracleMap = new Map();
+        this.spotOracleStringMap = 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.perpMarketIndexes = perpMarketIndexes;
+        this.spotMarketIndexes = spotMarketIndexes;
+        this.oracleInfos = oracleInfos;
+        this.shouldFindAllMarketsAndOracles = shouldFindAllMarketsAndOracles;
+        this.delistedMarketSetting = delistedMarketSetting;
+    }
+    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, spotMarketIndexes, oracleInfos } = await (0, config_1.findAllMarketAndOracles)(this.program);
+            this.perpMarketIndexes = perpMarketIndexes;
+            this.spotMarketIndexes = spotMarketIndexes;
+            this.oracleInfos = oracleInfos;
+        }
+        await this.updateAccountsToPoll();
+        this.updateOraclesToPoll();
+        await this.addToAccountLoader();
+        let subscriptionSucceeded = false;
+        let retries = 0;
+        while (!subscriptionSucceeded && retries < 5) {
+            await this.fetch();
+            subscriptionSucceeded = this.didSubscriptionSucceed();
+            retries++;
+        }
+        if (subscriptionSucceeded) {
+            this.eventEmitter.emit('update');
+        }
+        this.handleDelistedMarkets();
+        await Promise.all([this.setPerpOracleMap(), this.setSpotOracleMap()]);
+        this.isSubscribing = false;
+        this.isSubscribed = subscriptionSucceeded;
+        this.subscriptionPromiseResolver(subscriptionSucceeded);
+        return subscriptionSucceeded;
+    }
+    async updateAccountsToPoll() {
+        if (this.accountsToPoll.size > 0) {
+            return;
+        }
+        const statePublicKey = await (0, pda_1.getVelocityStateAccountPublicKey)(this.program.programId);
+        this.accountsToPoll.set(statePublicKey.toString(), {
+            key: 'state',
+            publicKey: statePublicKey,
+            eventType: 'stateAccountUpdate',
+        });
+        await Promise.all([
+            this.updatePerpMarketAccountsToPoll(),
+            this.updateSpotMarketAccountsToPoll(),
+        ]);
+    }
+    async updatePerpMarketAccountsToPoll() {
+        await Promise.all(this.perpMarketIndexes.map((marketIndex) => {
+            return this.addPerpMarketAccountToPoll(marketIndex);
+        }));
+        return true;
+    }
+    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 updateSpotMarketAccountsToPoll() {
+        await Promise.all(this.spotMarketIndexes.map(async (marketIndex) => {
+            await this.addSpotMarketAccountToPoll(marketIndex);
+        }));
+        return true;
+    }
+    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;
+    }
+    updateOraclesToPoll() {
+        for (const oracleInfo of this.oracleInfos) {
+            if (!oracleInfo.publicKey.equals(web3_js_1.PublicKey.default)) {
+                this.addOracleToPoll(oracleInfo);
+            }
+        }
+        return true;
+    }
+    addOracleToPoll(oracleInfo) {
+        this.oraclesToPoll.set((0, oracleId_1.getOracleId)(oracleInfo.publicKey, oracleInfo.source), {
+            publicKey: oracleInfo.publicKey,
+            source: oracleInfo.source,
+        });
+        return true;
+    }
+    async addToAccountLoader() {
+        const accountPromises = [];
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            accountPromises.push(this.addAccountToAccountLoader(accountToPoll));
+        }
+        const oraclePromises = [];
+        for (const [_, oracleToPoll] of this.oraclesToPoll) {
+            oraclePromises.push(this.addOracleToAccountLoader(oracleToPoll));
+        }
+        await Promise.all([...accountPromises, ...oraclePromises]);
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
+    }
+    async addAccountToAccountLoader(accountToPoll) {
+        accountToPoll.callbackId = await this.accountLoader.addAccount(accountToPoll.publicKey, (buffer, slot) => {
+            if (!buffer)
+                return;
+            const account = this.program.coder.accounts.decodeUnchecked(accountToPoll.key, buffer);
+            const dataAndSlot = {
+                data: account,
+                slot,
+            };
+            if (accountToPoll.mapKey != undefined) {
+                this[accountToPoll.key].set(accountToPoll.mapKey, dataAndSlot);
+            }
+            else {
+                this[accountToPoll.key] = dataAndSlot;
+            }
+            // @ts-ignore
+            this.eventEmitter.emit(accountToPoll.eventType, account);
+            this.eventEmitter.emit('update');
+            if (!this.isSubscribed) {
+                this.isSubscribed = this.didSubscriptionSucceed();
+            }
+        });
+    }
+    async addOracleToAccountLoader(oracleToPoll) {
+        const oracleClient = this.oracleClientCache.get(oracleToPoll.source, this.program.provider.connection, this.program);
+        const oracleId = (0, oracleId_1.getOracleId)(oracleToPoll.publicKey, oracleToPoll.source);
+        oracleToPoll.callbackId = await this.accountLoader.addAccount(oracleToPoll.publicKey, (buffer, slot) => {
+            if (!buffer)
+                return;
+            const oraclePriceData = oracleClient.getOraclePriceDataFromBuffer(buffer);
+            const dataAndSlot = {
+                data: oraclePriceData,
+                slot,
+            };
+            this.oracles.set(oracleId, dataAndSlot);
+            this.eventEmitter.emit('oraclePriceUpdate', oracleToPoll.publicKey, oracleToPoll.source, oraclePriceData);
+            this.eventEmitter.emit('update');
+        });
+    }
+    async fetch() {
+        await this.accountLoader.load();
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            const bufferAndSlot = this.accountLoader.getBufferAndSlot(accountToPoll.publicKey);
+            if (!bufferAndSlot) {
+                continue;
+            }
+            const { buffer, slot } = bufferAndSlot;
+            if (buffer) {
+                const account = this.program.coder.accounts.decodeUnchecked(accountToPoll.key, buffer);
+                if (accountToPoll.mapKey != undefined) {
+                    this[accountToPoll.key].set(accountToPoll.mapKey, {
+                        data: account,
+                        slot,
+                    });
+                }
+                else {
+                    this[accountToPoll.key] = {
+                        data: account,
+                        slot,
+                    };
+                }
+            }
+        }
+        for (const [_, oracleToPoll] of this.oraclesToPoll) {
+            const bufferAndSlot = this.accountLoader.getBufferAndSlot(oracleToPoll.publicKey);
+            if (!bufferAndSlot) {
+                continue;
+            }
+            const { buffer, slot } = bufferAndSlot;
+            if (buffer) {
+                const oracleClient = this.oracleClientCache.get(oracleToPoll.source, this.program.provider.connection, this.program);
+                const oraclePriceData = oracleClient.getOraclePriceDataFromBuffer(buffer);
+                this.oracles.set((0, oracleId_1.getOracleId)(oracleToPoll.publicKey, oracleToPoll.source), {
+                    data: oraclePriceData,
+                    slot,
+                });
+            }
+        }
+    }
+    didSubscriptionSucceed() {
+        if (this.state)
+            return true;
+        return false;
+    }
+    async unsubscribe() {
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            this.accountLoader.removeAccount(accountToPoll.publicKey, accountToPoll.callbackId);
+        }
+        for (const [_, oracleToPoll] of this.oraclesToPoll) {
+            this.accountLoader.removeAccount(oracleToPoll.publicKey, oracleToPoll.callbackId);
+        }
+        this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+        this.errorCallbackId = undefined;
+        this.accountsToPoll.clear();
+        this.oraclesToPoll.clear();
+        this.isSubscribed = false;
+    }
+    async addSpotMarket(marketIndex) {
+        const marketPublicKey = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex);
+        if (this.accountsToPoll.has(marketPublicKey.toString())) {
+            return true;
+        }
+        await this.addSpotMarketAccountToPoll(marketIndex);
+        const accountToPoll = this.accountsToPoll.get(marketPublicKey.toString());
+        await this.addAccountToAccountLoader(accountToPoll);
+        this.setSpotOracleMap();
+        return true;
+    }
+    async addPerpMarket(marketIndex) {
+        const marketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex);
+        if (this.accountsToPoll.has(marketPublicKey.toString())) {
+            return true;
+        }
+        await this.addPerpMarketAccountToPoll(marketIndex);
+        const accountToPoll = this.accountsToPoll.get(marketPublicKey.toString());
+        await this.addAccountToAccountLoader(accountToPoll);
+        await this.setPerpOracleMap();
+        return true;
+    }
+    async addOracle(oracleInfo) {
+        const oracleId = (0, oracleId_1.getOracleId)(oracleInfo.publicKey, oracleInfo.source);
+        if (oracleInfo.publicKey.equals(web3_js_1.PublicKey.default) ||
+            this.oracles.has(oracleId)) {
+            return true;
+        }
+        // this func can be called multiple times before the first pauseForOracleToBeAdded finishes
+        // avoid adding to oraclesToPoll multiple time
+        if (!this.oraclesToPoll.has(oracleId)) {
+            this.addOracleToPoll(oracleInfo);
+            const oracleToPoll = this.oraclesToPoll.get(oracleId);
+            await this.addOracleToAccountLoader(oracleToPoll);
+        }
+        await this.pauseForOracleToBeAdded(3, oracleInfo.publicKey.toBase58());
+        return true;
+    }
+    async pauseForOracleToBeAdded(tries, oracle) {
+        let i = 0;
+        while (i < tries) {
+            await new Promise((r) => setTimeout(r, this.accountLoader.pollingFrequency));
+            if (this.accountLoader.bufferAndSlotMap.has(oracle)) {
+                return;
+            }
+            i++;
+        }
+        console.log(`Pausing to find oracle ${oracle} failed`);
+    }
+    async setPerpOracleMap() {
+        const perpMarkets = this.getMarketAccountsAndSlots();
+        const oraclePromises = [];
+        for (const perpMarket of perpMarkets) {
+            const perpMarketAccount = perpMarket.data;
+            const perpMarketIndex = perpMarketAccount.marketIndex;
+            const oracle = perpMarketAccount.amm.oracle;
+            const oracleId = (0, oracleId_1.getOracleId)(oracle, perpMarketAccount.amm.oracleSource);
+            if (!this.oracles.has(oracleId)) {
+                oraclePromises.push(this.addOracle({
+                    publicKey: oracle,
+                    source: perpMarketAccount.amm.oracleSource,
+                }));
+            }
+            this.perpOracleMap.set(perpMarketIndex, oracle);
+            this.perpOracleStringMap.set(perpMarketIndex, oracleId);
+        }
+        await Promise.all(oraclePromises);
+    }
+    async setSpotOracleMap() {
+        const spotMarkets = this.getSpotMarketAccountsAndSlots();
+        const oraclePromises = [];
+        for (const spotMarket of spotMarkets) {
+            const spotMarketAccount = spotMarket.data;
+            const spotMarketIndex = spotMarketAccount.marketIndex;
+            const oracle = spotMarketAccount.oracle;
+            const oracleId = (0, oracleId_1.getOracleId)(oracle, spotMarketAccount.oracleSource);
+            if (!this.oracles.has(oracleId)) {
+                oraclePromises.push(this.addOracle({
+                    publicKey: oracle,
+                    source: spotMarketAccount.oracleSource,
+                }));
+            }
+            this.spotOracleMap.set(spotMarketIndex, oracle);
+            this.spotOracleStringMap.set(spotMarketIndex, oracleId);
+        }
+        await Promise.all(oraclePromises);
+    }
+    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) {
+            const perpMarketPubkey = this.perpMarket.get(perpMarketIndex).data.pubkey;
+            const callbackId = this.accountsToPoll.get(perpMarketPubkey.toBase58()).callbackId;
+            this.accountLoader.removeAccount(perpMarketPubkey, callbackId);
+            if (this.delistedMarketSetting === types_1.DelistedMarketSetting.Discard) {
+                this.perpMarket.delete(perpMarketIndex);
+            }
+        }
+        for (const oracle of oracles) {
+            const oracleId = (0, oracleId_1.getOracleId)(oracle.publicKey, oracle.source);
+            const callbackId = this.oraclesToPoll.get(oracleId).callbackId;
+            this.accountLoader.removeAccount(oracle.publicKey, callbackId);
+            if (this.delistedMarketSetting === types_1.DelistedMarketSetting.Discard) {
+                this.oracles.delete(oracleId);
+            }
+        }
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getStateAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.state;
+    }
+    getMarketAccountAndSlot(marketIndex) {
+        return this.perpMarket.get(marketIndex);
+    }
+    getMarketAccountsAndSlots() {
+        return Array.from(this.perpMarket.values());
+    }
+    getSpotMarketAccountAndSlot(marketIndex) {
+        return this.spotMarket.get(marketIndex);
+    }
+    getSpotMarketAccountsAndSlots() {
+        return Array.from(this.spotMarket.values());
+    }
+    getOraclePriceDataAndSlot(oracleId) {
+        this.assertIsSubscribed();
+        if (oracleId === ORACLE_DEFAULT_ID) {
+            return {
+                data: quoteAssetOracleClient_1.QUOTE_ORACLE_PRICE_DATA,
+                slot: 0,
+            };
+        }
+        return this.oracles.get(oracleId);
+    }
+    getOraclePriceDataAndSlotForPerpMarket(marketIndex) {
+        const perpMarketAccount = this.getMarketAccountAndSlot(marketIndex);
+        const oracle = this.perpOracleMap.get(marketIndex);
+        const oracleId = 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(oracleId);
+    }
+    getOraclePriceDataAndSlotForSpotMarket(marketIndex) {
+        const spotMarketAccount = this.getSpotMarketAccountAndSlot(marketIndex);
+        const oracle = this.spotOracleMap.get(marketIndex);
+        const oracleId = 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(oracleId);
+    }
+    updateAccountLoaderPollingFrequency(pollingFrequency) {
+        this.accountLoader.updatePollingFrequency(pollingFrequency);
+    }
+}
+exports.PollingVelocityClientAccountSubscriber = PollingVelocityClientAccountSubscriber;
+/** @deprecated Use `PollingVelocityClientAccountSubscriber` instead. `PollingDriftClientAccountSubscriber` will be removed in a future major. */
+exports.PollingDriftClientAccountSubscriber = PollingVelocityClientAccountSubscriber;

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

@@ -0,0 +1,5 @@
+import { AccountToLoad, BulkAccountLoader } from './bulkAccountLoader';
+export declare class TestBulkAccountLoader extends BulkAccountLoader {
+    loadChunk(accountsToLoadChunks: AccountToLoad[][]): Promise<void>;
+}
+//# sourceMappingURL=testBulkAccountLoader.d.ts.map

package/lib/node/accounts/testBulkAccountLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testBulkAccountLoader.d.ts","sourceRoot":"","sources":["../../../src/accounts/testBulkAccountLoader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAEvE,qBAAa,qBAAsB,SAAQ,iBAAiB;IACrD,SAAS,CAAC,oBAAoB,EAAE,aAAa,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CA+CvE"}

package/lib/node/accounts/testBulkAccountLoader.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestBulkAccountLoader = void 0;
+const bulkAccountLoader_1 = require("./bulkAccountLoader");
+class TestBulkAccountLoader extends bulkAccountLoader_1.BulkAccountLoader {
+    async loadChunk(accountsToLoadChunks) {
+        if (accountsToLoadChunks.length === 0) {
+            return;
+        }
+        for (const accountsToLoadChunk of accountsToLoadChunks) {
+            for (const accountToLoad of accountsToLoadChunk) {
+                const account = await this.connection.getAccountInfoAndContext(accountToLoad.publicKey, this.commitment);
+                const newSlot = account.context.slot;
+                if (newSlot > this.mostRecentSlot) {
+                    this.mostRecentSlot = newSlot;
+                }
+                if (accountToLoad.callbacks.size === 0) {
+                    continue;
+                }
+                const key = accountToLoad.publicKey.toBase58();
+                const prev = this.bufferAndSlotMap.get(key);
+                if (prev && newSlot < prev.slot) {
+                    continue;
+                }
+                let newBuffer = undefined;
+                if (account.value) {
+                    newBuffer = account.value.data;
+                }
+                if (!prev) {
+                    this.bufferAndSlotMap.set(key, { slot: newSlot, buffer: newBuffer });
+                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+                    continue;
+                }
+                const oldBuffer = prev.buffer;
+                if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+                    this.bufferAndSlotMap.set(key, { slot: newSlot, buffer: newBuffer });
+                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+                }
+            }
+        }
+    }
+}
+exports.TestBulkAccountLoader = TestBulkAccountLoader;