feat: polling check on websocket acct subscriber v2 + naming

Author: LukasDeco

sdk/src/accounts/README_WebSocketAccountSubscriberV2.md

@@ -31,6 +31,46 @@ await subscriber.subscribe((data) => {
 await subscriber.unsubscribe();
 ```
 
+### Polling Instead of Resubscribing
+
+For accounts that rarely update (like long-tail markets), you can use polling instead of resubscribing to reduce resource usage:
+
+```typescript
+const resubOpts = {
+	resubTimeoutMs: 30000, // 30 seconds
+	logResubMessages: true,
+	usePollingInsteadOfResub: true, // Enable polling mode
+	pollingIntervalMs: 30000, // Poll every 30 seconds (optional, defaults to 30000)
+};
+
+const subscriber = new WebSocketAccountSubscriberV2(
+	'perpMarket', // account name
+	program,
+	marketPublicKey,
+	undefined, // decodeBuffer
+	resubOpts
+);
+```
+
+**How it works:**
+1. Initially subscribes to WebSocket updates
+2. If no WebSocket data is received for `resubTimeoutMs` (30s), switches to polling mode
+3. Polls every `pollingIntervalMs` (30s) to check for updates by:
+   - Storing current account buffer state
+   - Fetching latest account data
+   - Comparing buffers to detect any missed updates
+4. If polling detects new data (indicating missed WebSocket events):
+   - Immediately stops polling
+   - Resubscribes to WebSocket to restore real-time updates
+   - This helps recover from degraded WebSocket connections
+5. If a WebSocket event is received while polling:
+   - Polling is automatically stopped
+   - System continues with normal WebSocket updates
+6. This approach provides:
+   - Efficient handling of rarely-updated accounts
+   - Automatic recovery from WebSocket connection issues
+   - Seamless fallback between polling and WebSocket modes
+
 ## Implementation Details
 
 ### Gill Integration
@@ -52,3 +92,4 @@ const { rpc, rpcSubscriptions } = createSolanaClient({
 3. **Address Handling**: Converts `PublicKey` to gill's `Address` type for compatibility
 4. **Response Formatting**: Converts gill responses to match the expected `AccountInfo<Buffer>` format
 5. **Abort Signal**: Utilizes AbortSignal nodejs/web class to shutdown websocket connection synchronously
+6. **Polling Mode**: Optional polling mechanism for accounts that rarely update

sdk/src/accounts/types.ts

@@ -202,6 +202,9 @@ export type DataAndSlot<T> = {
 export type ResubOpts = {
 	resubTimeoutMs?: number;
 	logResubMessages?: boolean;
+	// New options for polling-based resubscription
+	usePollingInsteadOfResub?: boolean;
+	pollingIntervalMs?: number;
 };
 
 export interface UserStatsAccountEvents {

sdk/src/accounts/webSocketAccountSubscriberV2.ts

@@ -35,6 +35,7 @@ export class WebSocketAccountSubscriberV2<T> implements AccountSubscriber<T> {
 	isUnsubscribing = false;
 
 	timeoutId?: ReturnType<typeof setTimeout>;
+	pollingTimeoutId?: ReturnType<typeof setTimeout>;
 
 	receivingData: boolean;
 
@@ -175,29 +176,102 @@ export class WebSocketAccountSubscriberV2<T> implements AccountSubscriber<T> {
 				}
 
 				if (this.receivingData) {
+					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();
+					} 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 (this.resubOpts?.logResubMessages) {
 						console.log(
-							`No ws data from ${this.logAccountName} in ${this.resubOpts.resubTimeoutMs}ms, resubscribing - listenerId=${this.listenerId}, isUnsubscribing=${this.isUnsubscribing}`
+							`[${this.logAccountName}] Timeout fired but receivingData=false, skipping resubscribe`
 						);
 					}
-					await this.unsubscribe(true);
-					this.receivingData = false;
-					await this.subscribe(this.onChange);
+				}
+			},
+			this.resubOpts?.resubTimeoutMs
+		);
+	}
+
+	private startPolling(): void {
+		const pollingInterval = this.resubOpts?.pollingIntervalMs || 30000; // Default to 30s
+
+		const poll = async () => {
+			if (this.isUnsubscribing) {
+				return;
+			}
+
+			try {
+				// Store current data and buffer before polling
+				const currentBuffer = this.bufferAndSlot?.buffer;
+
+				// Fetch latest account data
+				await this.fetch();
+
+				// Check if we got new data by comparing buffers
+				const newBuffer = this.bufferAndSlot?.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}] Resubscribe completed - receivingData=${this.receivingData}, listenerId=${this.listenerId}, isUnsubscribing=${this.isUnsubscribing}`
+							`[${this.logAccountName}] Polling detected account data change, resubscribing to websocket`
 						);
 					}
+					this.stopPolling();
+					this.receivingData = false;
+					await this.subscribe(this.onChange);
 				} else {
+					// No new data, continue polling
 					if (this.resubOpts?.logResubMessages) {
 						console.log(
-							`[${this.logAccountName}] Timeout fired but receivingData=false, skipping resubscribe`
+							`[${this.logAccountName}] Polling found no account changes, continuing to poll every ${pollingInterval}ms`
 						);
 					}
+					this.pollingTimeoutId = setTimeout(poll, pollingInterval);
 				}
-			},
-			this.resubOpts?.resubTimeoutMs
-		);
+			} 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();
+	}
+
+	private stopPolling(): void {
+		if (this.pollingTimeoutId) {
+			clearTimeout(this.pollingTimeoutId);
+			this.pollingTimeoutId = undefined;
+		}
 	}
 
 	async fetch(): Promise<void> {
@@ -301,6 +375,9 @@ export class WebSocketAccountSubscriberV2<T> implements AccountSubscriber<T> {
 		clearTimeout(this.timeoutId);
 		this.timeoutId = undefined;
 
+		// Stop polling if active
+		this.stopPolling();
+
 		// Abort the WebSocket subscription
 		if (this.abortController) {
 			this.abortController.abort('unsubscribing');