@drift-labs/sdk 2.97.0-beta.22 → 2.97.0-beta.23

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

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { DataAndSlot, OracleEvents, OracleAccountSubscriber } from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { OracleClient, OraclePriceData } from '../oracles/types';
+export declare class PollingOracleAccountSubscriber implements OracleAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, OracleEvents>;
+    publicKey: PublicKey;
+    accountLoader: BulkAccountLoader;
+    oracleClient: OracleClient;
+    callbackId?: string;
+    errorCallbackId?: string;
+    oraclePriceData?: DataAndSlot<OraclePriceData>;
+    constructor(publicKey: PublicKey, oracleClient: OracleClient, accountLoader: BulkAccountLoader);
+    subscribe(): Promise<boolean>;
+    addToAccountLoader(): Promise<void>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getOraclePriceData(): DataAndSlot<OraclePriceData>;
+    didSubscriptionSucceed(): boolean;
+}

package/lib/node/accounts/pollingOracleAccountSubscriber.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingOracleAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+class PollingOracleAccountSubscriber {
+    constructor(publicKey, oracleClient, accountLoader) {
+        this.isSubscribed = false;
+        this.publicKey = publicKey;
+        this.oracleClient = oracleClient;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        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.isSubscribed = subscriptionSucceeded;
+        return subscriptionSucceeded;
+    }
+    async addToAccountLoader() {
+        if (this.callbackId) {
+            return;
+        }
+        this.callbackId = await this.accountLoader.addAccount(this.publicKey, async (buffer, slot) => {
+            const oraclePriceData = await this.oracleClient.getOraclePriceDataFromBuffer(buffer);
+            this.oraclePriceData = { data: oraclePriceData, slot };
+            // @ts-ignore
+            this.eventEmitter.emit('oracleUpdate', oraclePriceData);
+            this.eventEmitter.emit('update');
+        });
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
+    }
+    async fetch() {
+        await this.accountLoader.load();
+        const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.publicKey);
+        this.oraclePriceData = {
+            data: await this.oracleClient.getOraclePriceDataFromBuffer(buffer),
+            slot,
+        };
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        this.accountLoader.removeAccount(this.publicKey, 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');
+        }
+    }
+    getOraclePriceData() {
+        this.assertIsSubscribed();
+        return this.oraclePriceData;
+    }
+    didSubscriptionSucceed() {
+        return !!this.oraclePriceData;
+    }
+}
+exports.PollingOracleAccountSubscriber = PollingOracleAccountSubscriber;

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

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { DataAndSlot, TokenAccountEvents, TokenAccountSubscriber } from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { Account } from '@solana/spl-token';
+export declare class PollingTokenAccountSubscriber implements TokenAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, TokenAccountEvents>;
+    publicKey: PublicKey;
+    accountLoader: BulkAccountLoader;
+    callbackId?: string;
+    errorCallbackId?: string;
+    tokenAccountAndSlot?: DataAndSlot<Account>;
+    constructor(publicKey: PublicKey, accountLoader: BulkAccountLoader);
+    subscribe(): Promise<boolean>;
+    addToAccountLoader(): Promise<void>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getTokenAccountAndSlot(): DataAndSlot<Account>;
+    didSubscriptionSucceed(): boolean;
+}

package/lib/node/accounts/pollingTokenAccountSubscriber.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingTokenAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const token_1 = require("../token");
+class PollingTokenAccountSubscriber {
+    constructor(publicKey, accountLoader) {
+        this.isSubscribed = false;
+        this.publicKey = publicKey;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        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.isSubscribed = subscriptionSucceeded;
+        return subscriptionSucceeded;
+    }
+    async addToAccountLoader() {
+        if (this.callbackId) {
+            return;
+        }
+        this.callbackId = await this.accountLoader.addAccount(this.publicKey, (buffer, slot) => {
+            const tokenAccount = (0, token_1.parseTokenAccount)(buffer, this.publicKey);
+            this.tokenAccountAndSlot = { data: tokenAccount, slot };
+            // @ts-ignore
+            this.eventEmitter.emit('tokenAccountUpdate', tokenAccount);
+            this.eventEmitter.emit('update');
+        });
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
+    }
+    async fetch() {
+        await this.accountLoader.load();
+        const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.publicKey);
+        this.tokenAccountAndSlot = {
+            data: (0, token_1.parseTokenAccount)(buffer, this.publicKey),
+            slot,
+        };
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        this.accountLoader.removeAccount(this.publicKey, 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');
+        }
+    }
+    getTokenAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.tokenAccountAndSlot;
+    }
+    didSubscriptionSucceed() {
+        return !!this.tokenAccountAndSlot;
+    }
+}
+exports.PollingTokenAccountSubscriber = PollingTokenAccountSubscriber;

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

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { DataAndSlot, UserAccountEvents, UserAccountSubscriber } from './types';
+import { Connection } from '../bankrun/bankrunConnection';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { UserAccount } from '../types';
+import { BulkAccountLoader } from './bulkAccountLoader';
+export declare class PollingUserAccountSubscriber implements UserAccountSubscriber {
+    isSubscribed: boolean;
+    connection: Connection;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
+    userAccountPublicKey: PublicKey;
+    accountLoader: BulkAccountLoader;
+    callbackId?: string;
+    errorCallbackId?: string;
+    decode: (name: any, buffer: any) => UserAccount;
+    user?: DataAndSlot<UserAccount>;
+    constructor(connection: Connection, userAccountPublicKey: PublicKey, accountLoader: BulkAccountLoader, decode: (name: any, buffer: any) => UserAccount);
+    subscribe(userAccount?: UserAccount): Promise<boolean>;
+    addToAccountLoader(): Promise<void>;
+    fetchIfUnloaded(): Promise<void>;
+    fetch(): Promise<void>;
+    doesAccountExist(): boolean;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserAccountAndSlot(): DataAndSlot<UserAccount>;
+    updateData(userAccount: UserAccount, slot: number): void;
+}

package/lib/node/accounts/pollingUserAccountSubscriber.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingUserAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+class PollingUserAccountSubscriber {
+    constructor(connection, userAccountPublicKey, accountLoader, decode) {
+        this.isSubscribed = false;
+        this.connection = connection;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.userAccountPublicKey = userAccountPublicKey;
+        this.decode = decode;
+    }
+    async subscribe(userAccount) {
+        if (this.isSubscribed) {
+            return true;
+        }
+        if (userAccount) {
+            this.user = { data: userAccount, 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) {
+            return;
+        }
+        this.callbackId = await this.accountLoader.addAccount(this.userAccountPublicKey, (buffer, slot) => {
+            if (!buffer) {
+                return;
+            }
+            if (this.user && this.user.slot > slot) {
+                return;
+            }
+            const account = this.decode('User', buffer);
+            this.user = { data: account, slot };
+            this.eventEmitter.emit('userAccountUpdate', account);
+            this.eventEmitter.emit('update');
+        });
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
+    }
+    async fetchIfUnloaded() {
+        if (this.user === undefined) {
+            await this.fetch();
+        }
+    }
+    async fetch() {
+        var _a, _b;
+        try {
+            const dataAndContext = await this.connection.getAccountInfoAndContext(this.userAccountPublicKey, this.accountLoader.commitment);
+            if (dataAndContext.context.slot > ((_b = (_a = this.user) === null || _a === void 0 ? void 0 : _a.slot) !== null && _b !== void 0 ? _b : 0)) {
+                this.user = {
+                    data: this.decode('User', dataAndContext.value.data),
+                    slot: dataAndContext.context.slot,
+                };
+            }
+        }
+        catch (e) {
+            console.log(`PollingUserAccountSubscriber.fetch() UserAccount does not exist: ${e.message}-${e.stack}`);
+        }
+    }
+    doesAccountExist() {
+        return this.user !== undefined;
+    }
+    async unsubscribe() {
+        if (!this.isSubscribed) {
+            return;
+        }
+        this.accountLoader.removeAccount(this.userAccountPublicKey, 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');
+        }
+    }
+    getUserAccountAndSlot() {
+        if (!this.doesAccountExist()) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` or `fetch` before using this function');
+        }
+        return this.user;
+    }
+    updateData(userAccount, slot) {
+        if (!this.user || this.user.slot < slot) {
+            this.user = { data: userAccount, slot };
+            this.eventEmitter.emit('userAccountUpdate', userAccount);
+            this.eventEmitter.emit('update');
+        }
+    }
+}
+exports.PollingUserAccountSubscriber = PollingUserAccountSubscriber;

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

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { DataAndSlot, UserStatsAccountSubscriber, UserStatsAccountEvents } from './types';
+import { Program } from '@coral-xyz/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;
+    callbackId?: string;
+    errorCallbackId?: string;
+    userStats?: DataAndSlot<UserStatsAccount>;
+    constructor(program: Program, userStatsAccountPublicKey: PublicKey, accountLoader: BulkAccountLoader);
+    subscribe(userStatsAccount?: UserStatsAccount): Promise<boolean>;
+    addToAccountLoader(): Promise<void>;
+    fetchIfUnloaded(): Promise<void>;
+    fetch(): Promise<void>;
+    doesAccountExist(): boolean;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}

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.account.userStats.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/testBulkAccountLoader.d.ts

@@ -0,0 +1,4 @@
+import { AccountToLoad, BulkAccountLoader } from './bulkAccountLoader';
+export declare class TestBulkAccountLoader extends BulkAccountLoader {
+    loadChunk(accountsToLoadChunks: AccountToLoad[][]): Promise<void>;
+}

package/lib/node/accounts/testBulkAccountLoader.js

@@ -0,0 +1,45 @@
+"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;
+        }
+        const accounts = [];
+        for (const accountsToLoadChunk of accountsToLoadChunks) {
+            for (const accountToLoad of accountsToLoadChunk) {
+                const account = await this.connection.getAccountInfoAndContext(accountToLoad.publicKey, this.commitment);
+                accounts.push(account);
+                const newSlot = account.context.slot;
+                if (newSlot > this.mostRecentSlot) {
+                    this.mostRecentSlot = newSlot;
+                }
+                if (accountToLoad.callbacks.size === 0) {
+                    return;
+                }
+                const key = accountToLoad.publicKey.toBase58();
+                const prev = this.bufferAndSlotMap.get(key);
+                if (prev && newSlot < prev.slot) {
+                    return;
+                }
+                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);
+                    return;
+                }
+                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;

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

@@ -0,0 +1,155 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { SpotMarketAccount, PerpMarketAccount, OracleSource, StateAccount, UserAccount, UserStatsAccount, InsuranceFundStake } from '../types';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { Context, PublicKey } from '@solana/web3.js';
+import { Account } from '@solana/spl-token';
+import { OracleInfo, OraclePriceData } from '..';
+import { ChannelOptions, CommitmentLevel } from '../isomorphic/grpc';
+export interface AccountSubscriber<T> {
+    dataAndSlot?: DataAndSlot<T>;
+    subscribe(onChange: (data: T) => void): Promise<void>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    setData(userAccount: T, slot?: number): void;
+}
+export interface ProgramAccountSubscriber<T> {
+    subscribe(onChange: (accountId: PublicKey, data: T, context: Context, buffer: Buffer) => void): Promise<void>;
+    unsubscribe(): Promise<void>;
+}
+export declare class NotSubscribedError extends Error {
+    name: string;
+}
+export interface DriftClientAccountEvents {
+    stateAccountUpdate: (payload: StateAccount) => 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 DriftClientAccountSubscriber {
+    eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
+    isSubscribed: boolean;
+    subscribe(): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    addPerpMarket(marketIndex: number): Promise<boolean>;
+    addSpotMarket(marketIndex: number): Promise<boolean>;
+    addOracle(oracleInfo: OracleInfo): Promise<boolean>;
+    setPerpOracleMap(): Promise<void>;
+    setSpotOracleMap(): Promise<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;
+    updateAccountLoaderPollingFrequency?: (pollingFrequency: number) => void;
+}
+export declare enum DelistedMarketSetting {
+    Unsubscribe = 0,
+    Subscribe = 1,
+    Discard = 2
+}
+export interface UserAccountEvents {
+    userAccountUpdate: (payload: UserAccount) => void;
+    update: void;
+    error: (e: Error) => void;
+}
+export interface UserAccountSubscriber {
+    eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
+    isSubscribed: boolean;
+    subscribe(userAccount?: UserAccount): Promise<boolean>;
+    fetch(): Promise<void>;
+    updateData(userAccount: UserAccount, slot: number): void;
+    unsubscribe(): Promise<void>;
+    getUserAccountAndSlot(): DataAndSlot<UserAccount>;
+}
+export interface TokenAccountEvents {
+    tokenAccountUpdate: (payload: Account) => void;
+    update: void;
+    error: (e: Error) => void;
+}
+export interface TokenAccountSubscriber {
+    eventEmitter: StrictEventEmitter<EventEmitter, TokenAccountEvents>;
+    isSubscribed: boolean;
+    subscribe(): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    getTokenAccountAndSlot(): DataAndSlot<Account>;
+}
+export interface InsuranceFundStakeAccountSubscriber {
+    eventEmitter: StrictEventEmitter<EventEmitter, InsuranceFundStakeAccountEvents>;
+    isSubscribed: boolean;
+    subscribe(): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    getInsuranceFundStakeAccountAndSlot(): DataAndSlot<InsuranceFundStake>;
+}
+export interface InsuranceFundStakeAccountEvents {
+    insuranceFundStakeAccountUpdate: (payload: InsuranceFundStake) => void;
+    update: void;
+    error: (e: Error) => void;
+}
+export interface OracleEvents {
+    oracleUpdate: (payload: OraclePriceData) => void;
+    update: void;
+    error: (e: Error) => void;
+}
+export interface OracleAccountSubscriber {
+    eventEmitter: StrictEventEmitter<EventEmitter, OracleEvents>;
+    isSubscribed: boolean;
+    subscribe(): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    getOraclePriceData(): DataAndSlot<OraclePriceData>;
+}
+export type AccountToPoll = {
+    key: string;
+    publicKey: PublicKey;
+    eventType: string;
+    callbackId?: string;
+    mapKey?: number;
+};
+export type OraclesToPoll = {
+    publicKey: PublicKey;
+    source: OracleSource;
+    callbackId?: string;
+};
+export type BufferAndSlot = {
+    slot: number;
+    buffer: Buffer | undefined;
+};
+export type DataAndSlot<T> = {
+    data: T;
+    slot: number;
+};
+export type ResubOpts = {
+    resubTimeoutMs?: number;
+    logResubMessages?: boolean;
+};
+export interface UserStatsAccountEvents {
+    userStatsAccountUpdate: (payload: UserStatsAccount) => void;
+    update: void;
+    error: (e: Error) => void;
+}
+export interface UserStatsAccountSubscriber {
+    eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+    isSubscribed: boolean;
+    subscribe(userStatsAccount?: UserStatsAccount): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}
+export type GrpcConfigs = {
+    endpoint: string;
+    token: string;
+    commitmentLevel?: CommitmentLevel;
+    channelOptions?: ChannelOptions;
+};