@velocity-exchange/sdk 0.0.1

package/src/accounts/webSocketProgramAccountSubscriberV2.ts

@@ -0,0 +1,996 @@
+import { BufferAndSlot, ProgramAccountSubscriber, ResubOpts } from './types';
+import { AnchorProvider } from '../isomorphic/anchor';
+import { VelocityProgram } from '../config';
+import { Commitment, Context, MemcmpFilter, PublicKey } from '@solana/web3.js';
+import {
+	AccountInfoBase,
+	AccountInfoWithBase58EncodedData,
+	AccountInfoWithBase64EncodedData,
+	createSolanaClient,
+	isAddress,
+	Lamports,
+	Slot,
+	Address,
+	Commitment as GillCommitment,
+} from 'gill';
+import bs58 from 'bs58';
+
+type ProgramAccountSubscriptionAsyncIterable = AsyncIterable<
+	Readonly<{
+		context: Readonly<{
+			slot: Slot;
+		}>;
+		value: Readonly<{
+			account: Readonly<{
+				executable: boolean;
+				lamports: Lamports;
+				owner: Address;
+				rentEpoch: bigint;
+				space: bigint;
+			}> &
+				Readonly<any>;
+			pubkey: Address;
+		}>;
+	}>
+>;
+/**
+ * WebSocketProgramAccountsSubscriberV2
+ *
+ * High-level overview
+ * - WebSocket-first subscriber for Solana program accounts that also layers in
+ *   targeted polling to detect missed updates reliably.
+ * - Emits decoded account updates via the provided `onChange` callback.
+ * - Designed to focus extra work on the specific accounts the consumer cares
+ *   about ("monitored accounts") while keeping baseline WS behavior for the
+ *   full program subscription.
+ *
+ * Why polling if this is a WebSocket subscriber?
+ * - WS infra can stall, drop, or reorder notifications under network stress or
+ *   provider hiccups. When that happens, critical account changes can be missed.
+ * - To mitigate this, the class accepts a set of accounts (provided via constructor) to monitor
+ *   and uses light polling to verify whether a WS change was missed.
+ * - If polling detects a newer slot with different data than the last seen
+ *   buffer, a centralized resubscription is triggered to restore a clean stream.
+ *
+ * Initial fetch (on subscribe)
+ * - On `subscribe()`, we first perform a single batched fetch of all monitored
+ *   accounts ("initial monitor fetch").
+ * - Purpose: seed the internal `bufferAndSlotMap` and emit the latest state so
+ *   consumers have up-to-date data immediately, even before WS events arrive.
+ * - This step does not decide resubscription; it only establishes ground truth.
+ *
+ * Continuous polling (only for monitored accounts)
+ * - After seeding, each monitored account is put into a monitoring cycle:
+ *   1) If no WS notification for an account is observed for `pollingIntervalMs`,
+ *      we enqueue it for a batched fetch (buffered for a short window).
+ *   2) Once an account enters the "currently polling" set, a shared batch poll
+ *      runs every `pollingIntervalMs` across all such accounts.
+ *   3) If WS notifications resume for an account, that account is removed from
+ *      the polling set and returns to passive monitoring.
+ * - Polling compares the newly fetched buffer with the last stored buffer at a
+ *   later slot. A difference indicates a missed update; we schedule a single
+ *   resubscription (coalesced across accounts) to re-sync.
+ *
+ * Accounts the consumer cares about
+ * - Provide accounts up-front via the constructor `accountsToMonitor`, or add
+ *   them dynamically with `addAccountToMonitor()` and remove with
+ *   `removeAccountFromMonitor()`.
+ * - Only these accounts incur additional polling safeguards; other accounts are
+ *   still processed from the WS stream normally.
+ *
+ * Resubscription strategy
+ * - Missed updates from any monitored account are coalesced and trigger a single
+ *   resubscription after a short delay. This avoids rapid churn.
+ * - If `resubOpts.resubTimeoutMs` is set, an inactivity timer also performs a
+ *   batch check of monitored accounts. If a missed update is found, the same
+ *   centralized resubscription flow is used.
+ *
+ * Tuning knobs
+ * - `setPollingInterval(ms)`: adjust how often monitoring/polling runs
+ *   (default 30s). Shorter = faster detection, higher RPC load.
+ * - Debounced immediate poll (~100ms): batches accounts added to polling right after inactivity.
+ * - Batch size for `getMultipleAccounts` is limited to 100, requests are chunked
+ *   and processed concurrently.
+ */
+
+export class WebSocketProgramAccountsSubscriberV2<T>
+	implements ProgramAccountSubscriber<T>
+{
+	subscriptionName: string;
+	accountDiscriminator: string;
+	bufferAndSlotMap: Map<string, BufferAndSlot> = new Map();
+	program: VelocityProgram;
+	decodeBuffer: (accountName: string, ix: Buffer) => T;
+	onChange: (
+		accountId: PublicKey,
+		data: T,
+		context: Context,
+		buffer: Buffer
+	) => void;
+	listenerId?: number;
+	resubOpts: ResubOpts;
+	isUnsubscribing = false;
+	timeoutId?: ReturnType<typeof setTimeout>;
+	options: { filters: MemcmpFilter[]; commitment?: Commitment };
+
+	receivingData = false;
+
+	// Gill client components
+	private rpc: ReturnType<typeof createSolanaClient>['rpc'];
+	private rpcSubscriptions: ReturnType<
+		typeof createSolanaClient
+	>['rpcSubscriptions'];
+	private abortController?: AbortController;
+
+	// Polling logic for specific accounts
+	private accountsToMonitor: Set<string> = new Set();
+	private pollingIntervalMs: number = 30000; // 30 seconds
+	private pollingTimeouts: Map<string, ReturnType<typeof setTimeout>> =
+		new Map();
+	private lastWsNotificationTime: Map<string, number> = new Map(); // Track last WS notification time per account
+	private accountsCurrentlyPolling: Set<string> = new Set(); // Track which accounts are being polled
+	private batchPollingTimeout?: ReturnType<typeof setTimeout>; // Single timeout for batch polling
+
+	// Debounced immediate poll to batch multiple additions within a short window
+	private debouncedImmediatePollTimeout?: ReturnType<typeof setTimeout>;
+	private debouncedImmediatePollMs: number = 100; // configurable short window
+
+	// Centralized resubscription handling
+	private missedChangeDetected = false; // Flag to track if any missed change was detected
+	private resubscriptionTimeout?: ReturnType<typeof setTimeout>; // Timeout for delayed resubscription
+	private accountsWithMissedUpdates: Set<string> = new Set(); // Track which accounts had missed updates
+
+	public constructor(
+		subscriptionName: string,
+		accountDiscriminator: string,
+		program: VelocityProgram,
+		decodeBufferFn: (accountName: string, ix: Buffer) => T,
+		options: { filters: MemcmpFilter[]; commitment?: Commitment } = {
+			filters: [],
+		},
+		resubOpts?: ResubOpts,
+		accountsToMonitor?: PublicKey[] // Optional list of accounts to poll
+	) {
+		this.subscriptionName = subscriptionName;
+		this.accountDiscriminator = accountDiscriminator;
+		this.program = program;
+		this.decodeBuffer = decodeBufferFn;
+		this.resubOpts = 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.options = options;
+		this.receivingData = false;
+
+		// Initialize accounts to monitor
+		if (accountsToMonitor) {
+			accountsToMonitor.forEach((account) => {
+				this.accountsToMonitor.add(account.toBase58());
+			});
+		}
+
+		// Initialize gill client using the same RPC URL as the program provider
+		const rpcUrl = (this.program.provider as AnchorProvider).connection
+			.rpcEndpoint;
+		const { rpc, rpcSubscriptions } = createSolanaClient({
+			urlOrMoniker: rpcUrl,
+		});
+		this.rpc = rpc;
+		this.rpcSubscriptions = rpcSubscriptions;
+	}
+
+	private async handleNotificationLoop(
+		notificationPromise: Promise<ProgramAccountSubscriptionAsyncIterable>
+	) {
+		try {
+			const subscriptionIterable = await notificationPromise;
+			for await (const notification of subscriptionIterable) {
+				try {
+					if (this.resubOpts?.resubTimeoutMs) {
+						this.receivingData = true;
+						clearTimeout(this.timeoutId);
+						this.handleRpcResponse(
+							notification.context,
+							notification.value.pubkey,
+							notification.value.account.data
+						);
+						this.setTimeout();
+					} else {
+						this.handleRpcResponse(
+							notification.context,
+							notification.value.pubkey,
+							notification.value.account.data
+						);
+					}
+				} catch (error) {
+					console.error(
+						`Error handling RPC response for pubkey ${notification.value.pubkey}:`,
+						error
+					);
+				}
+			}
+		} catch (error) {
+			console.error(
+				`[${this.subscriptionName}] Error in notification loop:`,
+				error
+			);
+		}
+	}
+
+	async subscribe(
+		onChange: (
+			accountId: PublicKey,
+			data: T,
+			context: Context,
+			buffer: Buffer
+		) => void
+	): Promise<void> {
+		/**
+		 * Start the WebSocket subscription and initialize polling safeguards.
+		 *
+		 * Flow
+		 * - Seeds all monitored accounts with a single batched RPC fetch and emits
+		 *   their current state.
+		 * - Subscribes to program notifications via WS using gill.
+		 * - If `resubOpts.resubTimeoutMs` is set, starts an inactivity timer that
+		 *   batch-checks monitored accounts when WS goes quiet.
+		 * - Begins monitoring for accounts that may need polling when WS
+		 *   notifications are not observed within `pollingIntervalMs`.
+		 *
+		 * @param onChange Callback invoked with decoded account data when an update
+		 * is detected (via WS or batch RPC fetch).
+		 */
+		const startTime = performance.now();
+		if (this.listenerId != null || this.isUnsubscribing) {
+			return;
+		}
+
+		if (this.resubOpts?.logResubMessages) {
+			console.log(
+				`[${this.subscriptionName}] initializing subscription. This many monitored accounts: ${this.accountsToMonitor.size}`
+			);
+		}
+
+		this.onChange = onChange;
+
+		// initial fetch of monitored data - only fetch and populate, don't check for missed changes
+		await this.fetchAndPopulateAllMonitoredAccounts();
+
+		// Create abort controller for proper cleanup
+		const abortController = new AbortController();
+		this.abortController = abortController;
+
+		this.listenerId = Math.random(); // Unique ID for logging purposes
+
+		if (this.resubOpts?.resubTimeoutMs) {
+			this.receivingData = true;
+			this.setTimeout();
+		}
+
+		// Subscribe to program account changes using gill's rpcSubscriptions
+		const programId = this.program.programId.toBase58();
+		if (isAddress(programId)) {
+			const subscriptionPromise = this.rpcSubscriptions
+				.programNotifications(programId, {
+					commitment: this.options.commitment as GillCommitment,
+					encoding: 'base64',
+					filters: this.options.filters.map((filter) => {
+						// Convert filter bytes from base58 to base64 if needed
+						let bytes = filter.memcmp.bytes;
+						if (
+							typeof bytes === 'string' &&
+							/^[1-9A-HJ-NP-Za-km-z]+$/.test(bytes)
+						) {
+							// Looks like base58 - convert to base64
+							const decoded = bs58.decode(bytes);
+							bytes = Buffer.from(decoded).toString('base64');
+						}
+
+						return {
+							memcmp: {
+								offset: BigInt(filter.memcmp.offset),
+								bytes: bytes as any,
+								encoding: 'base64' as const,
+							},
+						};
+					}),
+				})
+				.subscribe({
+					abortSignal: abortController.signal,
+				});
+
+			// Start notification loop without awaiting
+			this.handleNotificationLoop(subscriptionPromise);
+			// Start monitoring for accounts that may need polling if no WS event is received
+			this.startMonitoringForAccounts();
+		}
+		const endTime = performance.now();
+		console.log(
+			`[PROFILING] ${this.subscriptionName}.subscribe() completed in ${
+				endTime - startTime
+			}ms`
+		);
+	}
+
+	protected setTimeout(): void {
+		if (!this.onChange) {
+			throw new Error('onChange callback function must be set');
+		}
+		this.timeoutId = setTimeout(
+			async () => {
+				if (this.isUnsubscribing) {
+					// If we are in the process of unsubscribing, do not attempt to resubscribe
+					return;
+				}
+
+				if (this.receivingData) {
+					if (this.resubOpts?.logResubMessages) {
+						console.log(
+							`No ws data from ${this.subscriptionName} in ${this.resubOpts?.resubTimeoutMs}ms, checking for missed changes`
+						);
+					}
+
+					// Check for missed changes in monitored accounts
+					const missedChangeDetected = await this.fetchAllMonitoredAccounts();
+
+					if (missedChangeDetected) {
+						// Signal missed change with a generic identifier since we don't have specific account IDs from this context
+						this.signalMissedChange('timeout-check');
+					} else {
+						// No missed changes, continue monitoring
+						this.receivingData = false;
+						this.setTimeout();
+					}
+				}
+			},
+			this.resubOpts?.resubTimeoutMs
+		);
+	}
+
+	handleRpcResponse(
+		context: { slot: bigint },
+		accountId: Address,
+		accountInfo?: AccountInfoBase &
+			(
+				| AccountInfoWithBase58EncodedData
+				| AccountInfoWithBase64EncodedData
+			)['data']
+	): void {
+		const newSlot = Number(context.slot);
+		let newBuffer: Buffer | undefined = undefined;
+
+		if (accountInfo) {
+			// Handle different data formats from gill
+			if (Array.isArray(accountInfo)) {
+				// If it's a tuple [data, encoding]
+				const [data, encoding] = accountInfo;
+
+				if (encoding === ('base58' as any)) {
+					// Convert base58 to buffer using bs58
+					newBuffer = Buffer.from(bs58.decode(data));
+				} else {
+					newBuffer = Buffer.from(data, 'base64');
+				}
+			}
+		}
+
+		const accountIdString = accountId.toString();
+		const existingBufferAndSlot = this.bufferAndSlotMap.get(accountIdString);
+
+		// Track WebSocket notification time for this account
+		this.lastWsNotificationTime.set(accountIdString, Date.now());
+
+		// If this account was being polled, stop polling it if the buffer has changed
+		if (
+			this.accountsCurrentlyPolling.has(accountIdString) &&
+			!existingBufferAndSlot?.buffer.equals(newBuffer)
+		) {
+			this.accountsCurrentlyPolling.delete(accountIdString);
+
+			// If no more accounts are being polled, stop batch polling
+			if (
+				this.accountsCurrentlyPolling.size === 0 &&
+				this.batchPollingTimeout
+			) {
+				clearTimeout(this.batchPollingTimeout);
+				this.batchPollingTimeout = undefined;
+			}
+		}
+
+		if (!existingBufferAndSlot) {
+			if (newBuffer) {
+				this.updateBufferAndHandleChange(newBuffer, newSlot, accountIdString);
+			}
+			return;
+		}
+
+		if (newSlot < existingBufferAndSlot.slot) {
+			return;
+		}
+
+		const oldBuffer = existingBufferAndSlot.buffer;
+		if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+			this.updateBufferAndHandleChange(newBuffer, newSlot, accountIdString);
+		}
+	}
+
+	private startMonitoringForAccounts(): void {
+		// Clear any existing polling timeouts
+		this.clearPollingTimeouts();
+
+		// Start monitoring for each account in the accountsToMonitor set
+		this.accountsToMonitor.forEach((accountIdString) => {
+			this.startMonitoringForAccount(accountIdString);
+		});
+	}
+
+	private startMonitoringForAccount(accountIdString: string): void {
+		// Clear existing timeout for this account
+		const existingTimeout = this.pollingTimeouts.get(accountIdString);
+		if (existingTimeout) {
+			clearTimeout(existingTimeout);
+		}
+
+		// Set up monitoring timeout - only start polling if no WS notification in 30s
+		const timeoutId = setTimeout(async () => {
+			// Check if we've received a WS notification for this account recently
+			const lastNotificationTime =
+				this.lastWsNotificationTime.get(accountIdString) || 0;
+			const currentTime = Date.now();
+
+			if (
+				!lastNotificationTime ||
+				currentTime - lastNotificationTime >= this.pollingIntervalMs
+			) {
+				if (this.resubOpts?.logResubMessages) {
+					console.debug(
+						`[${this.subscriptionName}] No recent WS notification for ${accountIdString}, adding to polling set`
+					);
+				}
+				// No recent WS notification: add to polling and schedule debounced poll
+				this.accountsCurrentlyPolling.add(accountIdString);
+				this.scheduleDebouncedImmediatePoll();
+			} else {
+				// We received a WS notification recently, continue monitoring
+				this.startMonitoringForAccount(accountIdString);
+			}
+		}, this.pollingIntervalMs);
+
+		this.pollingTimeouts.set(accountIdString, timeoutId);
+	}
+
+	private scheduleDebouncedImmediatePoll(): void {
+		if (this.debouncedImmediatePollTimeout) {
+			clearTimeout(this.debouncedImmediatePollTimeout);
+		}
+		this.debouncedImmediatePollTimeout = setTimeout(async () => {
+			try {
+				await this.pollAllAccounts();
+				// After the immediate poll, ensure continuous batch polling is active
+				if (
+					!this.batchPollingTimeout &&
+					this.accountsCurrentlyPolling.size > 0
+				) {
+					this.startBatchPolling();
+				}
+			} catch (e) {
+				if (this.resubOpts?.logResubMessages) {
+					console.log(
+						`[${this.subscriptionName}] Error during debounced immediate poll:`,
+						e
+					);
+				}
+			}
+		}, this.debouncedImmediatePollMs);
+	}
+
+	private startBatchPolling(): void {
+		if (this.resubOpts?.logResubMessages) {
+			console.debug(`[${this.subscriptionName}] Scheduling batch polling`);
+		}
+		// Clear existing batch polling timeout
+		if (this.batchPollingTimeout) {
+			clearTimeout(this.batchPollingTimeout);
+		}
+
+		// Set up batch polling interval
+		this.batchPollingTimeout = setTimeout(async () => {
+			await this.pollAllAccounts();
+			// Schedule next batch poll
+			this.startBatchPolling();
+		}, this.pollingIntervalMs);
+	}
+
+	private async pollAllAccounts(): Promise<void> {
+		try {
+			// Get all accounts currently being polled
+			const accountsToPoll = Array.from(this.accountsCurrentlyPolling);
+			if (accountsToPoll.length === 0) {
+				return;
+			}
+
+			if (this.resubOpts?.logResubMessages) {
+				console.debug(
+					`[${this.subscriptionName}] Polling all accounts`,
+					accountsToPoll.length,
+					'accounts'
+				);
+			}
+
+			// Use the shared batch fetch method
+			await this.fetchAccountsBatch(accountsToPoll);
+		} catch (error) {
+			if (this.resubOpts?.logResubMessages) {
+				console.log(
+					`[${this.subscriptionName}] Error batch polling accounts:`,
+					error
+				);
+			}
+		}
+	}
+
+	/**
+	 * Fetches and populates all monitored accounts data without checking for missed changes
+	 * This is used during initial subscription to populate data
+	 */
+	private async fetchAndPopulateAllMonitoredAccounts(): Promise<void> {
+		try {
+			// Get all accounts currently being polled
+			const accountsToMonitor = Array.from(this.accountsToMonitor);
+			if (accountsToMonitor.length === 0) {
+				return;
+			}
+
+			// Fetch all accounts in a single batch request
+			const accountAddresses = accountsToMonitor.map(
+				(accountId) => accountId as Address
+			);
+			const rpcResponse = await this.rpc
+				.getMultipleAccounts(accountAddresses, {
+					commitment: this.options.commitment as GillCommitment,
+					encoding: 'base64',
+				})
+				.send();
+
+			const currentSlot = Number(rpcResponse.context.slot);
+
+			// Process each account response
+			for (let i = 0; i < accountsToMonitor.length; i++) {
+				const accountIdString = accountsToMonitor[i];
+				const accountInfo = rpcResponse.value[i];
+
+				if (!accountInfo) {
+					continue;
+				}
+
+				const existingBufferAndSlot =
+					this.bufferAndSlotMap.get(accountIdString);
+
+				if (!existingBufferAndSlot) {
+					// Account not in our map yet, add it
+					let newBuffer: Buffer | undefined = undefined;
+					if (accountInfo) {
+						if (Array.isArray(accountInfo.data)) {
+							const [data, encoding] = accountInfo.data;
+							newBuffer = Buffer.from(data, encoding);
+						}
+					}
+
+					if (newBuffer) {
+						this.updateBufferAndHandleChange(
+							newBuffer,
+							currentSlot,
+							accountIdString
+						);
+					}
+					continue;
+				}
+
+				// For initial population, just update the slot if we have newer data
+				if (currentSlot > existingBufferAndSlot.slot) {
+					let newBuffer: Buffer | undefined = undefined;
+					if (accountInfo.data) {
+						if (Array.isArray(accountInfo.data)) {
+							const [data, encoding] = accountInfo.data;
+							if (encoding === ('base58' as any)) {
+								newBuffer = Buffer.from(bs58.decode(data));
+							} else {
+								newBuffer = Buffer.from(data, 'base64');
+							}
+						}
+					}
+
+					// Update with newer data if available
+					if (newBuffer) {
+						this.updateBufferAndHandleChange(
+							newBuffer,
+							currentSlot,
+							accountIdString
+						);
+					}
+				}
+			}
+		} catch (error) {
+			if (this.resubOpts?.logResubMessages) {
+				console.log(
+					`[${this.subscriptionName}] Error fetching and populating monitored accounts:`,
+					error
+				);
+			}
+		}
+	}
+
+	/**
+	 * Fetches all monitored accounts and checks for missed changes
+	 * Returns true if a missed change was detected and resubscription is needed
+	 */
+	private async fetchAllMonitoredAccounts(): Promise<boolean> {
+		try {
+			// Get all accounts currently being polled
+			const accountsToMonitor = Array.from(this.accountsToMonitor);
+			if (accountsToMonitor.length === 0) {
+				return false;
+			}
+
+			// Fetch all accounts in a single batch request
+			const accountAddresses = accountsToMonitor.map(
+				(accountId) => accountId as Address
+			);
+			const rpcResponse = await this.rpc
+				.getMultipleAccounts(accountAddresses, {
+					commitment: this.options.commitment as GillCommitment,
+					encoding: 'base64',
+				})
+				.send();
+
+			const currentSlot = Number(rpcResponse.context.slot);
+
+			// Process each account response
+			for (let i = 0; i < accountsToMonitor.length; i++) {
+				const accountIdString = accountsToMonitor[i];
+				const accountInfo = rpcResponse.value[i];
+
+				if (!accountInfo) {
+					continue;
+				}
+
+				const existingBufferAndSlot =
+					this.bufferAndSlotMap.get(accountIdString);
+
+				if (!existingBufferAndSlot) {
+					// Account not in our map yet, add it
+					let newBuffer: Buffer | undefined = undefined;
+					if (accountInfo.data) {
+						if (Array.isArray(accountInfo.data)) {
+							const [data, encoding] = accountInfo.data;
+							newBuffer = Buffer.from(data, encoding);
+						}
+					}
+
+					if (newBuffer) {
+						this.updateBufferAndHandleChange(
+							newBuffer,
+							currentSlot,
+							accountIdString
+						);
+					}
+					continue;
+				}
+
+				// Check if we missed an update
+				if (currentSlot > existingBufferAndSlot.slot) {
+					let newBuffer: Buffer | undefined = undefined;
+					if (accountInfo.data) {
+						if (Array.isArray(accountInfo.data)) {
+							const [data, encoding] = accountInfo.data;
+							if (encoding === ('base58' as any)) {
+								newBuffer = Buffer.from(bs58.decode(data));
+							} else {
+								newBuffer = Buffer.from(data, 'base64');
+							}
+						}
+					}
+
+					// Check if buffer has changed
+					if (
+						newBuffer &&
+						(!existingBufferAndSlot.buffer ||
+							!newBuffer.equals(existingBufferAndSlot.buffer))
+					) {
+						if (this.resubOpts?.logResubMessages) {
+							console.log(
+								`[${this.subscriptionName}] Batch polling detected missed update for account ${accountIdString}, resubscribing`
+							);
+						}
+						// We missed an update, return true to indicate resubscription is needed
+						return true;
+					}
+				}
+			}
+
+			// No missed changes detected
+			return false;
+		} catch (error) {
+			if (this.resubOpts?.logResubMessages) {
+				console.log(
+					`[${this.subscriptionName}] Error batch polling accounts:`,
+					error
+				);
+			}
+			return false;
+		}
+	}
+
+	private async fetchAccountsBatch(accountIds: string[]): Promise<void> {
+		try {
+			// Chunk account IDs into groups of 100 (getMultipleAccounts limit)
+			const chunkSize = 100;
+			const chunks: string[][] = [];
+			for (let i = 0; i < accountIds.length; i += chunkSize) {
+				chunks.push(accountIds.slice(i, i + chunkSize));
+			}
+
+			// Process all chunks concurrently
+			await Promise.all(
+				chunks.map(async (chunk) => {
+					const accountAddresses = chunk.map(
+						(accountId) => accountId as Address
+					);
+					const rpcResponse = await this.rpc
+						.getMultipleAccounts(accountAddresses, {
+							commitment: this.options.commitment as GillCommitment,
+							encoding: 'base64',
+						})
+						.send();
+
+					const currentSlot = Number(rpcResponse.context.slot);
+
+					// Process each account response in this chunk
+					for (let i = 0; i < chunk.length; i++) {
+						const accountIdString = chunk[i];
+						const accountInfo = rpcResponse.value[i];
+
+						if (!accountInfo) {
+							continue;
+						}
+
+						const existingBufferAndSlot =
+							this.bufferAndSlotMap.get(accountIdString);
+
+						if (!existingBufferAndSlot) {
+							// Account not in our map yet, add it
+							let newBuffer: Buffer | undefined = undefined;
+							if (accountInfo.data) {
+								if (Array.isArray(accountInfo.data)) {
+									const [data, encoding] = accountInfo.data;
+									newBuffer = Buffer.from(data, encoding);
+								}
+							}
+
+							if (newBuffer) {
+								this.updateBufferAndHandleChange(
+									newBuffer,
+									currentSlot,
+									accountIdString
+								);
+							}
+							continue;
+						}
+
+						// Check if we missed an update
+						if (currentSlot > existingBufferAndSlot.slot) {
+							let newBuffer: Buffer | undefined = undefined;
+							if (accountInfo.data) {
+								if (Array.isArray(accountInfo.data)) {
+									const [data, encoding] = accountInfo.data;
+									if (encoding === ('base58' as any)) {
+										newBuffer = Buffer.from(bs58.decode(data));
+									} else {
+										newBuffer = Buffer.from(data, 'base64');
+									}
+								}
+							}
+
+							// Check if buffer has changed
+							if (
+								newBuffer &&
+								(!existingBufferAndSlot.buffer ||
+									!newBuffer.equals(existingBufferAndSlot.buffer))
+							) {
+								if (this.resubOpts?.logResubMessages) {
+									console.log(
+										`[${this.subscriptionName}] Batch polling detected missed update for account ${accountIdString}, signaling resubscription`
+									);
+								}
+								// Signal missed change instead of immediately resubscribing
+								this.signalMissedChange(accountIdString);
+								return;
+							}
+						}
+					}
+				})
+			);
+		} catch (error) {
+			if (this.resubOpts?.logResubMessages) {
+				console.log(
+					`[${this.subscriptionName}] Error fetching accounts batch:`,
+					error
+				);
+			}
+		}
+	}
+
+	private clearPollingTimeouts(): void {
+		this.pollingTimeouts.forEach((timeoutId) => {
+			clearTimeout(timeoutId);
+		});
+		this.pollingTimeouts.clear();
+
+		// Clear batch polling timeout
+		if (this.batchPollingTimeout) {
+			clearTimeout(this.batchPollingTimeout);
+			this.batchPollingTimeout = undefined;
+		}
+
+		// Clear initial fetch timeout
+		// if (this.initialFetchTimeout) {
+		// 	clearTimeout(this.initialFetchTimeout);
+		// 	this.initialFetchTimeout = undefined;
+		// }
+
+		// Clear resubscription timeout
+		if (this.resubscriptionTimeout) {
+			clearTimeout(this.resubscriptionTimeout);
+			this.resubscriptionTimeout = undefined;
+		}
+
+		// Clear accounts currently polling
+		this.accountsCurrentlyPolling.clear();
+
+		// Clear accounts pending initial monitor fetch
+		// this.accountsPendingInitialMonitorFetch.clear();
+
+		// Reset missed change flag and clear accounts with missed updates
+		this.missedChangeDetected = false;
+		this.accountsWithMissedUpdates.clear();
+	}
+
+	/**
+	 * Centralized resubscription handler that only resubscribes once after checking all accounts
+	 */
+	private async handleResubscription(): Promise<void> {
+		if (this.missedChangeDetected) {
+			if (this.resubOpts?.logResubMessages) {
+				console.log(
+					`[${this.subscriptionName}] Missed change detected for ${
+						this.accountsWithMissedUpdates.size
+					} accounts: ${Array.from(this.accountsWithMissedUpdates).join(
+						', '
+					)}, resubscribing`
+				);
+			}
+			await this.unsubscribe(true);
+			this.receivingData = false;
+			await this.subscribe(this.onChange);
+			this.missedChangeDetected = false;
+			this.accountsWithMissedUpdates.clear();
+		}
+	}
+
+	/**
+	 * Signal that a missed change was detected and schedule resubscription
+	 */
+	private signalMissedChange(accountIdString: string): void {
+		if (!this.missedChangeDetected) {
+			this.missedChangeDetected = true;
+			this.accountsWithMissedUpdates.add(accountIdString);
+
+			// Clear any existing resubscription timeout
+			if (this.resubscriptionTimeout) {
+				clearTimeout(this.resubscriptionTimeout);
+			}
+
+			// Schedule resubscription after a short delay to allow for batch processing
+			this.resubscriptionTimeout = setTimeout(async () => {
+				await this.handleResubscription();
+			}, 100); // 100ms delay to allow for batch processing
+		} else {
+			// If already detected, just add the account to the set
+			this.accountsWithMissedUpdates.add(accountIdString);
+		}
+	}
+
+	unsubscribe(onResub = false): Promise<void> {
+		if (!onResub) {
+			this.resubOpts.resubTimeoutMs = undefined;
+		}
+		this.isUnsubscribing = true;
+		clearTimeout(this.timeoutId);
+		this.timeoutId = undefined;
+
+		// Clear polling timeouts
+		this.clearPollingTimeouts();
+
+		// Abort the WebSocket subscription
+		if (this.abortController) {
+			this.abortController.abort('unsubscribing');
+			this.abortController = undefined;
+		}
+
+		this.listenerId = undefined;
+		this.isUnsubscribing = false;
+
+		return Promise.resolve();
+	}
+
+	// Method to add accounts to the polling list
+	/**
+	 * Add an account to the monitored set.
+	 * - Monitored accounts are subject to initial fetch and periodic batch polls
+	 *   if WS notifications are not observed within `pollingIntervalMs`.
+	 */
+	addAccountToMonitor(accountId: PublicKey): void {
+		const accountIdString = accountId.toBase58();
+		this.accountsToMonitor.add(accountIdString);
+
+		// If already subscribed, start monitoring for this account
+		if (this.listenerId != null && !this.isUnsubscribing) {
+			this.startMonitoringForAccount(accountIdString);
+		}
+	}
+
+	// Method to remove accounts from the polling list
+	removeAccountFromMonitor(accountId: PublicKey): void {
+		const accountIdString = accountId.toBase58();
+		this.accountsToMonitor.delete(accountIdString);
+
+		// Clear monitoring timeout for this account
+		const timeoutId = this.pollingTimeouts.get(accountIdString);
+		if (timeoutId) {
+			clearTimeout(timeoutId);
+			this.pollingTimeouts.delete(accountIdString);
+		}
+
+		// Remove from currently polling set if it was being polled
+		this.accountsCurrentlyPolling.delete(accountIdString);
+
+		// If no more accounts are being polled, stop batch polling
+		if (this.accountsCurrentlyPolling.size === 0 && this.batchPollingTimeout) {
+			clearTimeout(this.batchPollingTimeout);
+			this.batchPollingTimeout = undefined;
+		}
+	}
+
+	// Method to set polling interval
+	/**
+	 * Set the monitoring/polling interval for monitored accounts.
+	 * Shorter intervals detect missed updates sooner but increase RPC load.
+	 */
+	setPollingInterval(intervalMs: number): void {
+		this.pollingIntervalMs = intervalMs;
+		// Restart monitoring with new interval if already subscribed
+		if (this.listenerId != null && !this.isUnsubscribing) {
+			this.startMonitoringForAccounts();
+		}
+	}
+
+	private updateBufferAndHandleChange(
+		newBuffer: Buffer,
+		newSlot: number,
+		accountIdString: string
+	) {
+		this.bufferAndSlotMap.set(accountIdString, {
+			buffer: newBuffer,
+			slot: newSlot,
+		});
+		const account = this.decodeBuffer(this.accountDiscriminator, newBuffer);
+		const accountIdPubkey = new PublicKey(accountIdString);
+		this.onChange(accountIdPubkey, account, { slot: newSlot }, newBuffer);
+	}
+}