@drift-labs/sdk 2.136.0-beta.0 → 2.136.0-beta.2

package/VERSION

@@ -1 +1 @@
-2.136.0-beta.0
+2.136.0-beta.2

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

@@ -139,6 +139,8 @@ export type DataAndSlot<T> = {
 export type ResubOpts = {
     resubTimeoutMs?: number;
     logResubMessages?: boolean;
+    usePollingInsteadOfResub?: boolean;
+    pollingIntervalMs?: number;
 };
 export interface UserStatsAccountEvents {
     userStatsAccountUpdate: (payload: UserStatsAccount) => void;

package/lib/browser/accounts/webSocketAccountSubscriberV2.d.ts

@@ -2,8 +2,56 @@
 /// <reference types="node" />
 import { DataAndSlot, AccountSubscriber, ResubOpts, BufferAndSlot } from './types';
 import { Program } from '@coral-xyz/anchor';
-import { AccountInfoBase, AccountInfoWithBase58EncodedData, AccountInfoWithBase64EncodedData, type Commitment } from 'gill';
+import { AccountInfoBase, AccountInfoWithBase64EncodedData, AccountInfoWithBase58EncodedData, Rpc, RpcSubscriptions, SolanaRpcSubscriptionsApi, type Commitment } from 'gill';
 import { PublicKey } from '@solana/web3.js';
+/**
+ * WebSocketAccountSubscriberV2
+ *
+ * High-level overview
+ * - WebSocket-first subscriber for a single Solana account with optional
+ *   polling safeguards when the WS feed goes quiet.
+ * - Emits decoded updates via `onChange` and maintains the latest
+ *   `{buffer, slot}` and decoded `{data, slot}` internally.
+ *
+ * Why polling if this is a WebSocket subscriber?
+ * - Under real-world conditions, WS notifications can stall or get dropped.
+ * - When `resubOpts.resubTimeoutMs` elapses without WS data, you can either:
+ *   - resubscribe to the WS stream (default), or
+ *   - enable `resubOpts.usePollingInsteadOfResub` to start polling this single
+ *     account via RPC to check for missed changes.
+ * - Polling compares the fetched buffer to the last known buffer. If different
+ *   at an equal-or-later slot, it indicates a missed update and we resubscribe
+ *   to WS to restore a clean stream.
+ *
+ * Initial fetch (on subscribe)
+ * - On `subscribe()`, we do a one-time RPC `fetch()` to seed internal state and
+ *   emit the latest account state, ensuring consumers start from ground truth
+ *   even before WS events arrive.
+ *
+ * Continuous polling (opt-in)
+ * - If `usePollingInsteadOfResub` is set, the inactivity timeout triggers a
+ *   polling loop that periodically `fetch()`es the account and checks for
+ *   changes. On change, polling stops and we resubscribe to WS.
+ * - If not set (default), the inactivity timeout immediately triggers a WS
+ *   resubscription (no polling loop).
+ *
+ * Account focus
+ * - This class tracks exactly one account — the one passed to the constructor —
+ *   which is by definition the account the consumer cares about. The extra
+ *   logic is narrowly scoped to this account to minimize overhead.
+ *
+ * Tuning knobs
+ * - `resubOpts.resubTimeoutMs`: WS inactivity threshold before fallback.
+ * - `resubOpts.usePollingInsteadOfResub`: toggle polling vs immediate resub.
+ * - `resubOpts.pollingIntervalMs`: polling cadence (default 30s).
+ * - `resubOpts.logResubMessages`: verbose logs for diagnostics.
+ * - `commitment`: WS/RPC commitment used for reads and notifications.
+ * - `decodeBufferFn`: optional custom decode; defaults to Anchor coder.
+ *
+ * Implementation notes
+ * - Uses `gill` for both WS (`rpcSubscriptions`) and RPC (`rpc`) to match the
+ *   program provider’s RPC endpoint. Handles base58/base64 encoded data.
+ */
 export declare class WebSocketAccountSubscriberV2<T> implements AccountSubscriber<T> {
     dataAndSlot?: DataAndSlot<T>;
     bufferAndSlot?: BufferAndSlot;
@@ -14,19 +62,44 @@ export declare class WebSocketAccountSubscriberV2<T> implements AccountSubscribe
     decodeBufferFn: (buffer: Buffer) => T;
     onChange: (data: T) => void;
     listenerId?: number;
-    resubOpts?: ResubOpts;
+    resubOpts: ResubOpts;
     commitment?: Commitment;
     isUnsubscribing: boolean;
     timeoutId?: ReturnType<typeof setTimeout>;
+    pollingTimeoutId?: ReturnType<typeof setTimeout>;
     receivingData: boolean;
     private rpc;
     private rpcSubscriptions;
     private abortController?;
-    constructor(accountName: string, program: Program, accountPublicKey: PublicKey, decodeBuffer?: (buffer: Buffer) => T, resubOpts?: ResubOpts, commitment?: Commitment);
+    /**
+     * Create a single-account WebSocket subscriber with optional polling fallback.
+     *
+     * @param accountName Name of the Anchor account type (used for default decode).
+     * @param program Anchor `Program` used for decoding and provider access.
+     * @param accountPublicKey Public key of the account to track.
+     * @param decodeBuffer Optional custom decode function; if omitted, uses
+     *   program coder to decode `accountName`.
+     * @param resubOpts Resubscription/polling options. See class docs.
+     * @param commitment Commitment for WS and RPC operations.
+     * @param rpcSubscriptions Optional override/injection for testing.
+     * @param rpc Optional override/injection for testing.
+     */
+    constructor(accountName: string, program: Program, accountPublicKey: PublicKey, decodeBuffer?: (buffer: Buffer) => T, resubOpts?: ResubOpts, commitment?: Commitment, rpcSubscriptions?: RpcSubscriptions<SolanaRpcSubscriptionsApi> & string, rpc?: Rpc<any>);
     private handleNotificationLoop;
     subscribe(onChange: (data: T) => void): Promise<void>;
     setData(data: T, slot?: number): void;
     protected setTimeout(): void;
+    /**
+     * Start the polling loop (single-account).
+     * - Periodically calls `fetch()` and compares buffers to detect changes.
+     * - On detected change, stops polling and resubscribes to WS.
+     */
+    private startPolling;
+    private stopPolling;
+    /**
+     * Fetch the current account state via RPC and process it through the same
+     * decoding and update pathway as WS notifications.
+     */
     fetch(): Promise<void>;
     handleRpcResponse(context: {
         slot: bigint;

package/lib/browser/accounts/webSocketAccountSubscriberV2.js

@@ -7,17 +7,81 @@ exports.WebSocketAccountSubscriberV2 = void 0;
 const utils_1 = require("./utils");
 const gill_1 = require("gill");
 const bs58_1 = __importDefault(require("bs58"));
+/**
+ * WebSocketAccountSubscriberV2
+ *
+ * High-level overview
+ * - WebSocket-first subscriber for a single Solana account with optional
+ *   polling safeguards when the WS feed goes quiet.
+ * - Emits decoded updates via `onChange` and maintains the latest
+ *   `{buffer, slot}` and decoded `{data, slot}` internally.
+ *
+ * Why polling if this is a WebSocket subscriber?
+ * - Under real-world conditions, WS notifications can stall or get dropped.
+ * - When `resubOpts.resubTimeoutMs` elapses without WS data, you can either:
+ *   - resubscribe to the WS stream (default), or
+ *   - enable `resubOpts.usePollingInsteadOfResub` to start polling this single
+ *     account via RPC to check for missed changes.
+ * - Polling compares the fetched buffer to the last known buffer. If different
+ *   at an equal-or-later slot, it indicates a missed update and we resubscribe
+ *   to WS to restore a clean stream.
+ *
+ * Initial fetch (on subscribe)
+ * - On `subscribe()`, we do a one-time RPC `fetch()` to seed internal state and
+ *   emit the latest account state, ensuring consumers start from ground truth
+ *   even before WS events arrive.
+ *
+ * Continuous polling (opt-in)
+ * - If `usePollingInsteadOfResub` is set, the inactivity timeout triggers a
+ *   polling loop that periodically `fetch()`es the account and checks for
+ *   changes. On change, polling stops and we resubscribe to WS.
+ * - If not set (default), the inactivity timeout immediately triggers a WS
+ *   resubscription (no polling loop).
+ *
+ * Account focus
+ * - This class tracks exactly one account — the one passed to the constructor —
+ *   which is by definition the account the consumer cares about. The extra
+ *   logic is narrowly scoped to this account to minimize overhead.
+ *
+ * Tuning knobs
+ * - `resubOpts.resubTimeoutMs`: WS inactivity threshold before fallback.
+ * - `resubOpts.usePollingInsteadOfResub`: toggle polling vs immediate resub.
+ * - `resubOpts.pollingIntervalMs`: polling cadence (default 30s).
+ * - `resubOpts.logResubMessages`: verbose logs for diagnostics.
+ * - `commitment`: WS/RPC commitment used for reads and notifications.
+ * - `decodeBufferFn`: optional custom decode; defaults to Anchor coder.
+ *
+ * Implementation notes
+ * - Uses `gill` for both WS (`rpcSubscriptions`) and RPC (`rpc`) to match the
+ *   program provider’s RPC endpoint. Handles base58/base64 encoded data.
+ */
 class WebSocketAccountSubscriberV2 {
-    constructor(accountName, program, accountPublicKey, decodeBuffer, resubOpts, commitment) {
-        var _a;
+    /**
+     * Create a single-account WebSocket subscriber with optional polling fallback.
+     *
+     * @param accountName Name of the Anchor account type (used for default decode).
+     * @param program Anchor `Program` used for decoding and provider access.
+     * @param accountPublicKey Public key of the account to track.
+     * @param decodeBuffer Optional custom decode function; if omitted, uses
+     *   program coder to decode `accountName`.
+     * @param resubOpts Resubscription/polling options. See class docs.
+     * @param commitment Commitment for WS and RPC operations.
+     * @param rpcSubscriptions Optional override/injection for testing.
+     * @param rpc Optional override/injection for testing.
+     */
+    constructor(accountName, program, accountPublicKey, decodeBuffer, resubOpts, commitment, rpcSubscriptions, rpc) {
         this.isUnsubscribing = false;
         this.accountName = accountName;
         this.logAccountName = `${accountName}-${accountPublicKey.toBase58()}-ws-acct-subscriber-v2`;
         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) {
+        this.resubOpts = resubOpts !== null && resubOpts !== void 0 ? resubOpts : {
+            resubTimeoutMs: 30000,
+            usePollingInsteadOfResub: true,
+            logResubMessages: false,
+        };
+        if (this.resubOpts.resubTimeoutMs < 1000) {
             console.log(`resubTimeoutMs should be at least 1000ms to avoid spamming resub ${this.logAccountName}`);
         }
         this.receivingData = false;
@@ -27,32 +91,59 @@ class WebSocketAccountSubscriberV2 {
         this.commitment =
             commitment !== null && commitment !== void 0 ? commitment : this.program.provider.opts.commitment;
         // Initialize gill client using the same RPC URL as the program provider
-        const rpcUrl = this.program.provider.connection
-            .rpcEndpoint;
-        const { rpc, rpcSubscriptions } = (0, gill_1.createSolanaClient)({
-            urlOrMoniker: rpcUrl,
-        });
-        this.rpc = rpc;
-        this.rpcSubscriptions = rpcSubscriptions;
+        this.rpc = rpc
+            ? rpc
+            : (() => {
+                const rpcUrl = this.program.provider.connection
+                    .rpcEndpoint;
+                const { rpc } = (0, gill_1.createSolanaClient)({
+                    urlOrMoniker: rpcUrl,
+                });
+                return rpc;
+            })();
+        this.rpcSubscriptions = rpcSubscriptions
+            ? rpcSubscriptions
+            : (() => {
+                const rpcUrl = this.program.provider.connection
+                    .rpcEndpoint;
+                const { rpcSubscriptions } = (0, gill_1.createSolanaClient)({
+                    urlOrMoniker: rpcUrl,
+                });
+                return rpcSubscriptions;
+            })();
     }
-    async handleNotificationLoop(subscription) {
-        var _a;
+    async handleNotificationLoop(subscriptionPromise) {
+        const subscription = await subscriptionPromise;
         for await (const notification of subscription) {
-            if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
-                this.receivingData = true;
-                clearTimeout(this.timeoutId);
-                this.handleRpcResponse(notification.context, notification.value);
-                this.setTimeout();
-            }
-            else {
-                this.handleRpcResponse(notification.context, notification.value);
+            // If we're currently polling and receive a WebSocket event, stop polling
+            if (this.pollingTimeoutId) {
+                if (this.resubOpts.logResubMessages) {
+                    console.log(`[${this.logAccountName}] Received WebSocket event while polling, stopping polling`);
+                }
+                this.stopPolling();
             }
+            this.receivingData = true;
+            clearTimeout(this.timeoutId);
+            this.handleRpcResponse(notification.context, notification.value);
+            this.setTimeout();
         }
     }
     async subscribe(onChange) {
-        var _a, _b;
+        /**
+         * Start the WebSocket subscription and (optionally) setup inactivity
+         * fallback.
+         *
+         * Flow
+         * - If we do not have initial state, perform a one-time `fetch()` to seed
+         *   internal buffers and emit current data.
+         * - Subscribe to account notifications via WS.
+         * - If `resubOpts.resubTimeoutMs` is set, schedule an inactivity timeout.
+         *   When it fires:
+         *   - if `usePollingInsteadOfResub` is true, start polling loop;
+         *   - otherwise, resubscribe to WS immediately.
+         */
         if (this.listenerId != null || this.isUnsubscribing) {
-            if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.logResubMessages) {
+            if (this.resubOpts.logResubMessages) {
                 console.log(`[${this.logAccountName}] Subscribe returning early - listenerId=${this.listenerId}, isUnsubscribing=${this.isUnsubscribing}`);
             }
             return;
@@ -65,14 +156,14 @@ class WebSocketAccountSubscriberV2 {
         const abortController = new AbortController();
         this.abortController = abortController;
         this.listenerId = Math.random(); // Unique ID for logging purposes
-        if ((_b = this.resubOpts) === null || _b === void 0 ? void 0 : _b.resubTimeoutMs) {
+        if (this.resubOpts.resubTimeoutMs) {
             this.receivingData = true;
             this.setTimeout();
         }
         // Subscribe to account changes using gill's rpcSubscriptions
         const pubkey = this.accountPublicKey.toBase58();
         if ((0, gill_1.isAddress)(pubkey)) {
-            const subscription = await this.rpcSubscriptions
+            const subscriptionPromise = this.rpcSubscriptions
                 .accountNotifications(pubkey, {
                 commitment: this.commitment,
                 encoding: 'base64',
@@ -80,8 +171,11 @@ class WebSocketAccountSubscriberV2 {
                 .subscribe({
                 abortSignal: abortController.signal,
             });
-            // Start notification loop without awaiting
-            this.handleNotificationLoop(subscription);
+            // Start notification loop with the subscription promise
+            this.handleNotificationLoop(subscriptionPromise);
+        }
+        else {
+            throw new Error('Invalid account public key');
         }
     }
     setData(data, slot) {
@@ -95,37 +189,108 @@ class WebSocketAccountSubscriberV2 {
         };
     }
     setTimeout() {
-        var _a;
+        /**
+         * Schedule inactivity handling. If WS is quiet for
+         * `resubOpts.resubTimeoutMs` and `receivingData` is true, trigger either
+         * a polling loop or a resubscribe depending on options.
+         */
         if (!this.onChange) {
             throw new Error('onChange callback function must be set');
         }
         this.timeoutId = setTimeout(async () => {
-            var _a, _b, _c, _d;
             if (this.isUnsubscribing) {
                 // If we are in the process of unsubscribing, do not attempt to resubscribe
-                if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.logResubMessages) {
+                if (this.resubOpts.logResubMessages) {
                     console.log(`[${this.logAccountName}] Timeout fired but isUnsubscribing=true, skipping resubscribe`);
                 }
                 return;
             }
             if (this.receivingData) {
-                if ((_b = this.resubOpts) === null || _b === void 0 ? void 0 : _b.logResubMessages) {
-                    console.log(`No ws data from ${this.logAccountName} in ${this.resubOpts.resubTimeoutMs}ms, resubscribing - listenerId=${this.listenerId}, isUnsubscribing=${this.isUnsubscribing}`);
+                if (this.resubOpts.usePollingInsteadOfResub) {
+                    // Use polling instead of resubscribing
+                    if (this.resubOpts.logResubMessages) {
+                        console.log(`[${this.logAccountName}] No ws data in ${this.resubOpts.resubTimeoutMs}ms, starting polling - listenerId=${this.listenerId}`);
+                    }
+                    this.startPolling();
                 }
-                await this.unsubscribe(true);
-                this.receivingData = false;
-                await this.subscribe(this.onChange);
-                if ((_c = this.resubOpts) === null || _c === void 0 ? void 0 : _c.logResubMessages) {
-                    console.log(`[${this.logAccountName}] Resubscribe completed - receivingData=${this.receivingData}, listenerId=${this.listenerId}, isUnsubscribing=${this.isUnsubscribing}`);
+                else {
+                    // Original resubscribe behavior
+                    if (this.resubOpts.logResubMessages) {
+                        console.log(`No ws data from ${this.logAccountName} in ${this.resubOpts.resubTimeoutMs}ms, resubscribing - listenerId=${this.listenerId}, isUnsubscribing=${this.isUnsubscribing}`);
+                    }
+                    await this.unsubscribe(true);
+                    this.receivingData = false;
+                    await this.subscribe(this.onChange);
+                    if (this.resubOpts.logResubMessages) {
+                        console.log(`[${this.logAccountName}] Resubscribe completed - receivingData=${this.receivingData}, listenerId=${this.listenerId}, isUnsubscribing=${this.isUnsubscribing}`);
+                    }
                 }
             }
             else {
-                if ((_d = this.resubOpts) === null || _d === void 0 ? void 0 : _d.logResubMessages) {
+                if (this.resubOpts.logResubMessages) {
                     console.log(`[${this.logAccountName}] Timeout fired but receivingData=false, skipping resubscribe`);
                 }
             }
-        }, (_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs);
+        }, this.resubOpts.resubTimeoutMs);
+    }
+    /**
+     * Start the polling loop (single-account).
+     * - Periodically calls `fetch()` and compares buffers to detect changes.
+     * - On detected change, stops polling and resubscribes to WS.
+     */
+    startPolling() {
+        const pollingInterval = this.resubOpts.pollingIntervalMs || 30000; // Default to 30s
+        const poll = async () => {
+            var _a, _b;
+            if (this.isUnsubscribing) {
+                return;
+            }
+            try {
+                // Store current data and buffer before polling
+                const currentBuffer = (_a = this.bufferAndSlot) === null || _a === void 0 ? void 0 : _a.buffer;
+                // Fetch latest account data
+                await this.fetch();
+                // Check if we got new data by comparing buffers
+                const newBuffer = (_b = this.bufferAndSlot) === null || _b === void 0 ? void 0 : _b.buffer;
+                const hasNewData = newBuffer && (!currentBuffer || !newBuffer.equals(currentBuffer));
+                if (hasNewData) {
+                    // New data received, stop polling and resubscribe to websocket
+                    if (this.resubOpts.logResubMessages) {
+                        console.log(`[${this.logAccountName}] Polling detected account data change, resubscribing to websocket`);
+                    }
+                    await this.unsubscribe(true);
+                    this.receivingData = false;
+                    await this.subscribe(this.onChange);
+                }
+                else {
+                    // No new data, continue polling
+                    if (this.resubOpts.logResubMessages) {
+                        console.log(`[${this.logAccountName}] Polling found no account changes, continuing to poll every ${pollingInterval}ms`);
+                    }
+                    this.pollingTimeoutId = setTimeout(poll, pollingInterval);
+                }
+            }
+            catch (error) {
+                if (this.resubOpts.logResubMessages) {
+                    console.error(`[${this.logAccountName}] Error during polling:`, error);
+                }
+                // On error, continue polling
+                this.pollingTimeoutId = setTimeout(poll, pollingInterval);
+            }
+        };
+        // Start polling immediately
+        poll();
+    }
+    stopPolling() {
+        if (this.pollingTimeoutId) {
+            clearTimeout(this.pollingTimeoutId);
+            this.pollingTimeoutId = undefined;
+        }
     }
+    /**
+     * Fetch the current account state via RPC and process it through the same
+     * decoding and update pathway as WS notifications.
+     */
     async fetch() {
         // Use gill's rpc for fetching account info
         const accountAddress = this.accountPublicKey.toBase58();
@@ -204,12 +369,19 @@ class WebSocketAccountSubscriberV2 {
         }
     }
     unsubscribe(onResub = false) {
+        /**
+         * Stop timers, polling, and WS subscription.
+         * - When called during a resubscribe (`onResub=true`), we preserve
+         *   `resubOpts.resubTimeoutMs` for the restarted subscription.
+         */
         if (!onResub && this.resubOpts) {
             this.resubOpts.resubTimeoutMs = undefined;
         }
         this.isUnsubscribing = true;
         clearTimeout(this.timeoutId);
         this.timeoutId = undefined;
+        // Stop polling if active
+        this.stopPolling();
         // Abort the WebSocket subscription
         if (this.abortController) {
             this.abortController.abort('unsubscribing');

package/lib/browser/accounts/webSocketDriftClientAccountSubscriberV2.d.ts

@@ -0,0 +1,87 @@
+/// <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 { PublicKey } from '@solana/web3.js';
+import { Commitment } from 'gill';
+import { OracleInfo, OraclePriceData } from '../oracles/types';
+import { OracleClientCache } from '../oracles/oracleClientCache';
+import { WebSocketProgramAccountsSubscriberV2 } from './webSocketProgramAccountsSubscriberV2';
+import { WebSocketAccountSubscriberV2 } from './webSocketAccountSubscriberV2';
+export declare class WebSocketDriftClientAccountSubscriberV2 implements DriftClientAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    commitment?: Commitment;
+    perpMarketIndexes: number[];
+    spotMarketIndexes: number[];
+    oracleInfos: OracleInfo[];
+    oracleClientCache: OracleClientCache;
+    resubOpts?: ResubOpts;
+    shouldFindAllMarketsAndOracles: boolean;
+    skipInitialData: boolean;
+    eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
+    stateAccountSubscriber?: WebSocketAccountSubscriberV2<StateAccount>;
+    perpMarketAllAccountsSubscriber: WebSocketProgramAccountsSubscriberV2<PerpMarketAccount>;
+    perpMarketAccountLatestData: Map<number, DataAndSlot<PerpMarketAccount>>;
+    spotMarketAllAccountsSubscriber: WebSocketProgramAccountsSubscriberV2<SpotMarketAccount>;
+    spotMarketAccountLatestData: Map<number, DataAndSlot<SpotMarketAccount>>;
+    perpOracleMap: Map<number, PublicKey>;
+    perpOracleStringMap: Map<number, string>;
+    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;
+    private rpc;
+    private rpcSubscriptions;
+    constructor(program: Program, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[], shouldFindAllMarketsAndOracles: boolean, delistedMarketSetting: DelistedMarketSetting, resubOpts?: ResubOpts, commitment?: Commitment, skipInitialData?: boolean);
+    subscribe(): Promise<boolean>;
+    chunks: <T>(array: readonly T[], size: number) => T[][];
+    fetch(): Promise<void>;
+    /**
+     * This is a no-op method that always returns true.
+     * Unlike the previous implementation, we don't need to manually subscribe to individual perp markets
+     * because we automatically receive updates for all program account changes via a single websocket subscription.
+     * This means any new perp markets will automatically be included without explicit subscription.
+     * @param marketIndex The perp market index to add (unused)
+     * @returns Promise that resolves to true
+     */
+    addPerpMarket(_marketIndex: number): Promise<boolean>;
+    /**
+     * This is a no-op method that always returns true.
+     * Unlike the previous implementation, we don't need to manually subscribe to individual spot markets
+     * because we automatically receive updates for all program account changes via a single websocket subscription.
+     * This means any new spot markets will automatically be included without explicit subscription.
+     * @param marketIndex The spot market index to add (unused)
+     * @returns Promise that resolves to true
+     */
+    addSpotMarket(_marketIndex: number): Promise<boolean>;
+    setInitialData(): Promise<void>;
+    removeInitialData(): void;
+    subscribeToOracles(): Promise<boolean>;
+    subscribeToOracle(oracleInfo: OracleInfo): Promise<boolean>;
+    unsubscribeFromMarketAccounts(): Promise<void>;
+    unsubscribeFromSpotMarketAccounts(): Promise<void>;
+    unsubscribeFromOracles(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    addOracle(oracleInfo: OracleInfo): Promise<boolean>;
+    setPerpOracleMap(): Promise<void>;
+    setSpotOracleMap(): Promise<void>;
+    handleDelistedMarketOracles(): 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(oracleId: string): DataAndSlot<OraclePriceData> | undefined;
+    getOraclePriceDataAndSlotForPerpMarket(marketIndex: number): DataAndSlot<OraclePriceData> | undefined;
+    getOraclePriceDataAndSlotForSpotMarket(marketIndex: number): DataAndSlot<OraclePriceData> | undefined;
+}