@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/accounts/bulkAccountLoader.ts

@@ -1,358 +0,0 @@
-import { Commitment, PublicKey } from '@solana/web3.js';
-import { v4 as uuidv4 } from 'uuid';
-import { BufferAndSlot } from './types';
-import { promiseTimeout } from '../util/promiseTimeout';
-import { Connection } from '../bankrun/bankrunConnection';
-import { GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE } from '../constants/numericConstants';
-
-/** An account registered with a `BulkAccountLoader`, along with every callback subscribed to its updates (keyed by callback id). */
-export type AccountToLoad = {
-	publicKey: PublicKey;
-	callbacks: Map<string, (buffer: Buffer, slot: number) => void>;
-};
-
-const oneMinute = 60 * 1000;
-
-/**
- * Batches many accounts behind a single periodic `getMultipleAccounts` RPC poll instead of one
- * WebSocket subscription per account. Multiple independent callbacks (e.g. from different
- * `PollingUserAccountSubscriber`/`PollingVelocityClientAccountSubscriber` instances) can register
- * against the same `publicKey`; polling starts automatically on the first `addAccount` and stops
- * when the last callback for the last account is removed. A buffer is only re-delivered to
- * callbacks when its slot is not older than the last-seen slot for that account and its bytes
- * actually changed, so a callback never observes a stale or duplicate update. `load()` calls are
- * coalesced: concurrent callers share one in-flight RPC batch rather than issuing redundant
- * requests.
- */
-export class BulkAccountLoader {
-	connection: Connection;
-	commitment: Commitment;
-	pollingFrequency: number;
-	accountsToLoad = new Map<string, AccountToLoad>();
-	bufferAndSlotMap = new Map<string, BufferAndSlot>();
-	errorCallbacks = new Map<string, (e: Error) => void>();
-	intervalId?: ReturnType<typeof setTimeout>;
-	// to handle clients spamming load
-	loadPromise?: Promise<void>;
-	private loadPromiseResolver: () => void = () => {};
-	lastTimeLoadingPromiseCleared = Date.now();
-	mostRecentSlot = 0;
-
-	/**
-	 * @param connection Connection (or bankrun-compatible shim) used for the batched `getMultipleAccounts` polls.
-	 * @param commitment Commitment level applied to every poll.
-	 * @param pollingFrequency Poll interval in ms; `0` disables automatic polling (`startPolling` becomes a no-op), useful when the loader is driven manually via `load()`.
-	 */
-	public constructor(
-		connection: Connection,
-		commitment: Commitment,
-		pollingFrequency: number
-	) {
-		this.connection = connection;
-		this.commitment = commitment;
-		this.pollingFrequency = pollingFrequency;
-	}
-
-	/**
-	 * Registers a callback to be invoked whenever `publicKey`'s account data changes on a poll.
-	 * Multiple callbacks may be registered for the same account. Starts polling automatically if
-	 * this is the loader's first account. Awaits any in-flight `load()` before returning so a
-	 * caller can immediately follow with its own `load()` without racing the poll interval.
-	 * @param publicKey Account to track.
-	 * @param callback Invoked with the raw account buffer and the slot it was fetched at whenever the buffer changes at a non-decreasing slot.
-	 * @returns A callback id to pass to `removeAccount` later.
-	 */
-	public async addAccount(
-		publicKey: PublicKey,
-		callback: (buffer: Buffer, slot: number) => void
-	): Promise<string> {
-		if (!publicKey) {
-			console.trace(`Caught adding blank publickey to bulkAccountLoader`);
-		}
-
-		const existingSize = this.accountsToLoad.size;
-
-		const callbackId = uuidv4();
-		const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
-		if (existingAccountToLoad) {
-			existingAccountToLoad.callbacks.set(callbackId, callback);
-		} else {
-			const callbacks = new Map<
-				string,
-				(buffer: Buffer, slot: number) => void
-			>();
-			callbacks.set(callbackId, callback);
-			const newAccountToLoad = {
-				publicKey,
-				callbacks,
-			};
-			this.accountsToLoad.set(publicKey.toString(), newAccountToLoad);
-		}
-
-		if (existingSize === 0) {
-			this.startPolling();
-		}
-
-		// resolve the current loadPromise in case client wants to call load
-		await this.loadPromise;
-
-		return callbackId;
-	}
-
-	/**
-	 * Unregisters a callback previously returned by `addAccount`. Once an account has no
-	 * remaining callbacks, its cached buffer/slot is dropped and it stops being polled; if no
-	 * accounts remain at all, polling stops entirely. A no-op if `callbackId` is undefined.
-	 * @param publicKey Account the callback was registered against.
-	 * @param callbackId Id returned by `addAccount`.
-	 */
-	public removeAccount(
-		publicKey: PublicKey,
-		callbackId: string | undefined
-	): void {
-		if (callbackId === undefined) {
-			return;
-		}
-		const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
-		if (existingAccountToLoad) {
-			existingAccountToLoad.callbacks.delete(callbackId);
-			if (existingAccountToLoad.callbacks.size === 0) {
-				this.bufferAndSlotMap.delete(publicKey.toString());
-				this.accountsToLoad.delete(existingAccountToLoad.publicKey.toString());
-			}
-		}
-
-		if (this.accountsToLoad.size === 0) {
-			this.stopPolling();
-		}
-	}
-
-	/**
-	 * Registers a callback invoked whenever a `load()` batch throws (e.g. RPC failure or timeout).
-	 * The loader continues polling afterward; errors do not stop the interval.
-	 * @returns A callback id to pass to `removeErrorCallbacks` later.
-	 */
-	public addErrorCallbacks(callback: (error: Error) => void): string {
-		const callbackId = uuidv4();
-		this.errorCallbacks.set(callbackId, callback);
-		return callbackId;
-	}
-
-	/** Unregisters an error callback previously returned by `addErrorCallbacks`. A no-op if `callbackId` is undefined. */
-	public removeErrorCallbacks(callbackId: string | undefined): void {
-		if (callbackId === undefined) {
-			return;
-		}
-		this.errorCallbacks.delete(callbackId);
-	}
-
-	chunks<T>(array: readonly T[], size: number): T[][] {
-		return new Array(Math.ceil(array.length / size))
-			.fill(null)
-			.map((_, index) => index * size)
-			.map((begin) => array.slice(begin, begin + size));
-	}
-
-	/**
-	 * Fetches every registered account in one or more chunked, concurrent `getMultipleAccounts`
-	 * batches (via `loadChunk`) and dispatches changed accounts to their callbacks. Concurrent
-	 * calls while a load is already in flight share that same in-flight promise rather than
-	 * issuing a duplicate RPC batch, unless the previous load has been running for over a minute
-	 * (treated as stuck and restarted). On failure, invokes every registered error callback
-	 * instead of throwing.
-	 */
-	public async load(): Promise<void> {
-		if (this.loadPromise) {
-			const now = Date.now();
-			if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
-				this.loadPromise = undefined;
-			} else {
-				return this.loadPromise;
-			}
-		}
-
-		this.loadPromise = new Promise((resolver) => {
-			this.loadPromiseResolver = resolver;
-		});
-		this.lastTimeLoadingPromiseCleared = Date.now();
-
-		try {
-			const chunks = this.chunks(
-				this.chunks(
-					Array.from(this.accountsToLoad.values()),
-					GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE
-				),
-				10
-			);
-
-			await Promise.all(
-				chunks.map((chunk) => {
-					return this.loadChunk(chunk);
-				})
-			);
-		} catch (e) {
-			console.error(`Error in bulkAccountLoader.load()`);
-			console.error(e);
-			const error = e instanceof Error ? e : new Error(String(e));
-			for (const [_, callback] of this.errorCallbacks) {
-				callback(error);
-			}
-		} finally {
-			this.loadPromiseResolver();
-			this.loadPromise = undefined;
-		}
-	}
-
-	async loadChunk(accountsToLoadChunks: AccountToLoad[][]): Promise<void> {
-		if (accountsToLoadChunks.length === 0) {
-			return;
-		}
-
-		const requests = new Array<{ methodName: string; args: any }>();
-		for (const accountsToLoadChunk of accountsToLoadChunks) {
-			const args = [
-				accountsToLoadChunk
-					.filter((accountToLoad) => accountToLoad.callbacks.size > 0)
-					.map((accountToLoad) => {
-						return accountToLoad.publicKey.toBase58();
-					}),
-				{ commitment: this.commitment },
-			];
-
-			requests.push({
-				methodName: 'getMultipleAccounts',
-				args,
-			});
-		}
-
-		const rpcResponses: any | null = await promiseTimeout(
-			// @ts-ignore
-			this.connection._rpcBatchRequest(requests),
-			10 * 1000 // 30 second timeout
-		);
-
-		if (rpcResponses === null) {
-			this.log('request to rpc timed out');
-			return;
-		}
-
-		rpcResponses.forEach((rpcResponse: any, i: number) => {
-			if (!rpcResponse.result) {
-				console.error('rpc response missing result:');
-				console.log(JSON.stringify(rpcResponse));
-				return;
-			}
-			const newSlot = rpcResponse.result.context.slot;
-
-			if (newSlot > this.mostRecentSlot) {
-				this.mostRecentSlot = newSlot;
-			}
-
-			const accountsToLoad = accountsToLoadChunks[i];
-			accountsToLoad.forEach((accountToLoad, j) => {
-				if (accountToLoad.callbacks.size === 0) {
-					return;
-				}
-
-				const key = accountToLoad.publicKey.toBase58();
-				const oldRPCResponse = this.bufferAndSlotMap.get(key);
-
-				if (oldRPCResponse && newSlot < oldRPCResponse.slot) {
-					return;
-				}
-
-				let newBuffer: Buffer | undefined = undefined;
-				if (rpcResponse.result.value[j]) {
-					const raw: string = rpcResponse.result.value[j].data[0];
-					const dataType = rpcResponse.result.value[j].data[1];
-					newBuffer = Buffer.from(raw, dataType);
-				}
-
-				if (!oldRPCResponse) {
-					this.bufferAndSlotMap.set(key, {
-						slot: newSlot,
-						buffer: newBuffer,
-					});
-					this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
-					return;
-				}
-
-				const oldBuffer = oldRPCResponse.buffer;
-				if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
-					this.bufferAndSlotMap.set(key, {
-						slot: newSlot,
-						buffer: newBuffer,
-					});
-					this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
-				}
-			});
-		});
-	}
-
-	handleAccountCallbacks(
-		accountToLoad: AccountToLoad,
-		buffer: Buffer | undefined,
-		slot: number
-	): void {
-		if (buffer === undefined) {
-			return;
-		}
-		for (const [_, callback] of accountToLoad.callbacks) {
-			try {
-				callback(buffer, slot);
-			} catch (e) {
-				console.log('Bulk account load: error in account callback');
-				console.log('accounto to load', accountToLoad.publicKey.toString());
-				console.log('buffer', buffer.toString('base64'));
-				for (const callback of accountToLoad.callbacks.values()) {
-					console.log('account to load cb', callback);
-				}
-				throw e;
-			}
-		}
-	}
-
-	/** Returns the last-fetched raw buffer/slot for `publicKey`, or undefined if it has never been loaded. */
-	public getBufferAndSlot(publicKey: PublicKey): BufferAndSlot | undefined {
-		return this.bufferAndSlotMap.get(publicKey.toString());
-	}
-
-	/** Returns the highest slot number observed across any account fetched by this loader so far. */
-	public getSlot(): number {
-		return this.mostRecentSlot;
-	}
-
-	/** Starts the polling interval if not already running and `pollingFrequency !== 0`. Called automatically by `addAccount`. */
-	public startPolling(): void {
-		if (this.intervalId) {
-			return;
-		}
-
-		if (this.pollingFrequency !== 0)
-			this.intervalId = setInterval(
-				this.load.bind(this),
-				this.pollingFrequency
-			);
-	}
-
-	/** Stops the polling interval, if running. Called automatically by `removeAccount` once no accounts remain. */
-	public stopPolling(): void {
-		if (this.intervalId) {
-			clearInterval(this.intervalId);
-			this.intervalId = undefined;
-		}
-	}
-
-	public log(msg: string): void {
-		console.log(msg);
-	}
-
-	/** Restarts polling at a new interval (ms), preserving all registered accounts and callbacks. */
-	public updatePollingFrequency(pollingFrequency: number): void {
-		this.stopPolling();
-		this.pollingFrequency = pollingFrequency;
-		if (this.accountsToLoad.size > 0) {
-			this.startPolling();
-		}
-	}
-}

package/src/accounts/bulkUserStatsSubscription.ts

@@ -1,40 +0,0 @@
-import { UserStats } from '../userStats';
-import { BulkAccountLoader } from './bulkAccountLoader';
-import { PollingUserStatsAccountSubscriber } from './pollingUserStatsAccountSubscriber';
-
-/**
- * Subscribes many `UserStats`s that share a single `BulkAccountLoader` in one batched round trip,
- * instead of each `UserStats.subscribe()` triggering its own `addAccount`/`load()`. Registers
- * every account's `PollingUserStatsAccountSubscriber` with the loader first, issues one `load()`
- * to seed all of them from a single batched `getMultipleAccounts` call, and only then calls
- * `userStat.subscribe()` (which becomes a fast no-op fetch since data is already cached). If
- * `userStats` is empty, still calls `accountLoader.load()` so any other accounts already
- * registered on the loader get polled.
- * @param userStats `UserStats` instances to subscribe; each must already be constructed with a `PollingUserStatsAccountSubscriber`.
- * @param accountLoader Shared `BulkAccountLoader` batching the underlying RPC polls.
- */
-export async function bulkPollingUserStatsSubscribe(
-	userStats: UserStats[],
-	accountLoader: BulkAccountLoader
-): Promise<void> {
-	if (userStats.length === 0) {
-		await accountLoader.load();
-		return;
-	}
-
-	await Promise.all(
-		userStats.map((userStat) => {
-			return (
-				userStat.accountSubscriber as PollingUserStatsAccountSubscriber
-			).addToAccountLoader();
-		})
-	);
-
-	await accountLoader.load();
-
-	await Promise.all(
-		userStats.map(async (userStat) => {
-			return userStat.subscribe();
-		})
-	);
-}

package/src/accounts/bulkUserSubscription.ts

@@ -1,39 +0,0 @@
-import { User } from '../user';
-import { BulkAccountLoader } from './bulkAccountLoader';
-import { PollingUserAccountSubscriber } from './pollingUserAccountSubscriber';
-
-/**
- * Subscribes many `User`s that share a single `BulkAccountLoader` in one batched round trip,
- * instead of each `User.subscribe()` triggering its own `addAccount`/`load()`. Registers every
- * user's `PollingUserAccountSubscriber` with the loader first, issues one `load()` to seed all of
- * them from a single batched `getMultipleAccounts` call, and only then calls `user.subscribe()`
- * (which becomes a fast no-op fetch since data is already cached). If `users` is empty, still
- * calls `accountLoader.load()` so any other accounts already registered on the loader get polled.
- * @param users Users to subscribe; each must already be constructed with a `PollingUserAccountSubscriber`.
- * @param accountLoader Shared `BulkAccountLoader` batching the underlying RPC polls.
- */
-export async function bulkPollingUserSubscribe(
-	users: User[],
-	accountLoader: BulkAccountLoader
-): Promise<void> {
-	if (users.length === 0) {
-		await accountLoader.load();
-		return;
-	}
-
-	await Promise.all(
-		users.map((user) => {
-			return (
-				user.accountSubscriber as PollingUserAccountSubscriber
-			).addToAccountLoader();
-		})
-	);
-
-	await accountLoader.load();
-
-	await Promise.all(
-		users.map(async (user) => {
-			return user.subscribe();
-		})
-	);
-}

package/src/accounts/customizedCadenceBulkAccountLoader.ts

@@ -1,250 +0,0 @@
-import { GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE } from '../constants/numericConstants';
-import { BulkAccountLoader } from './bulkAccountLoader';
-import { Commitment, Connection, PublicKey } from '@solana/web3.js';
-import { v4 as uuidv4 } from 'uuid';
-
-/**
- * `BulkAccountLoader` variant where each account can be polled at its own cadence instead of a
- * single shared `pollingFrequency`. Overrides the base class's single `setInterval` with a
- * per-account `accountFrequencies` map: `handleAccountLoading()` only includes an account in a
- * given tick if `Date.now() - lastPollingTime >= frequency` for that account, then delegates to
- * the inherited chunked `loadChunk` for the actual `getMultipleAccounts` batch. The interval
- * itself always runs at the fastest frequency across all registered accounts (see `startPolling`),
- * so slower accounts simply get skipped on ticks that fire before they're due.
- */
-export class CustomizedCadenceBulkAccountLoader extends BulkAccountLoader {
-	private customIntervalId: NodeJS.Timeout | null;
-	private currentPollingFrequency: number | null;
-	private accountFrequencies: Map<string, number>;
-	private lastPollingTimes: Map<string, number>;
-	private defaultPollingFrequency: number;
-
-	/**
-	 * @param connection Connection used for the batched `getMultipleAccounts` polls.
-	 * @param commitment Commitment level applied to every poll.
-	 * @param defaultPollingFrequency Polling cadence in ms (see base `BulkAccountLoader`) used for any account added without an explicit `customPollingFrequency`, and as the floor when computing the shared interval in `startPolling`.
-	 */
-	constructor(
-		connection: Connection,
-		commitment: Commitment,
-		defaultPollingFrequency: number
-	) {
-		super(connection, commitment, defaultPollingFrequency);
-		this.customIntervalId = null;
-		this.currentPollingFrequency = null;
-		this.accountFrequencies = new Map();
-		this.lastPollingTimes = new Map();
-		this.defaultPollingFrequency = defaultPollingFrequency;
-	}
-
-	private getAccountsToLoad(): Array<{
-		publicKey: PublicKey;
-		callbacks: Map<string, (buffer: Buffer, slot: number) => void>;
-	}> {
-		const currentTime = Date.now();
-		const accountsToLoad: Array<{
-			publicKey: PublicKey;
-			callbacks: Map<string, (buffer: Buffer, slot: number) => void>;
-		}> = [];
-
-		for (const [key, frequency] of this.accountFrequencies.entries()) {
-			const lastPollTime = this.lastPollingTimes.get(key) || 0;
-			if (currentTime - lastPollTime >= frequency) {
-				const account = this.accountsToLoad.get(key);
-				if (account) {
-					accountsToLoad.push(account);
-					this.lastPollingTimes.set(key, currentTime);
-				}
-			}
-		}
-
-		return accountsToLoad;
-	}
-
-	/** Immediately runs one due-account loading pass, bypassing the interval timer. Unlike the base class's `load()`, this does not force-load every registered account — only those currently due per their own cadence. */
-	public async load(): Promise<void> {
-		return this.handleAccountLoading();
-	}
-
-	private async handleAccountLoading(): Promise<void> {
-		const accounts = this.getAccountsToLoad();
-
-		if (accounts.length > 0) {
-			const chunks = this.chunks(
-				this.chunks(accounts, GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE),
-				10
-			);
-
-			await Promise.all(
-				chunks.map((chunk) => {
-					return this.loadChunk(chunk);
-				})
-			);
-		}
-	}
-
-	/**
-	 * Updates the polling frequency for an account. This affects all callbacks attached to this account.
-	 *
-	 * @param publicKey The public key of the account to set the custom polling frequency for
-	 * @param newFrequency The new polling frequency in ms
-	 */
-	public setCustomPollingFrequency(
-		publicKey: PublicKey,
-		newFrequency: number
-	): void {
-		const key = publicKey.toBase58();
-		this.accountFrequencies.set(key, newFrequency);
-		this.lastPollingTimes.set(key, 0); // Reset last polling time to ensure immediate load
-		this.restartPollingIfNeeded(newFrequency);
-	}
-
-	private restartPollingIfNeeded(newFrequency: number): void {
-		if (
-			(this.currentPollingFrequency &&
-				newFrequency < this.currentPollingFrequency) ||
-			!this.customIntervalId
-		) {
-			this.stopPolling();
-			this.startPolling();
-		}
-	}
-
-	/**
-	 * Adds an account to be monitored by the bulk account loader
-	 * @param publicKey The public key of the account to monitor
-	 * @param callback Function to be called when account data is received
-	 * @param customPollingFrequency Optional custom polling frequency in ms for this specific account.
-	 * If not provided, will use the default polling frequency
-	 * @returns A unique callback ID that can be used to remove this specific callback later
-	 *
-	 * The method will:
-	 * 1. Create a new callback mapping for the account if it doesn't exist already
-	 * 2. Set up polling frequency tracking for the account if it doesn't exist already. If previous polling frequency is faster than the new one,
-	 *    we will use the previous frequency.
-	 * 3. Reset last polling time to 0 to ensure data fetch is triggered on the next poll. Note that this does not mean the account will be fetched immediately.
-	 * 4. Automatically restart polling if this account needs a faster frequency than existing accounts
-	 */
-	public async addAccount(
-		publicKey: PublicKey,
-		callback: (buffer: Buffer, slot: number) => void,
-		customPollingFrequency?: number
-	): Promise<string> {
-		const callbackId = uuidv4();
-		const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
-
-		if (existingAccountToLoad) {
-			existingAccountToLoad.callbacks.set(callbackId, callback);
-		} else {
-			const callbacks = new Map<
-				string,
-				(buffer: Buffer, slot: number) => void
-			>();
-			callbacks.set(callbackId, callback);
-			const newAccountToLoad = {
-				publicKey,
-				callbacks,
-			};
-			this.accountsToLoad.set(publicKey.toString(), newAccountToLoad);
-		}
-
-		const key = publicKey.toBase58();
-		const previousFrequency =
-			this.accountFrequencies.get(key) || this.defaultPollingFrequency;
-		const updatedFrequency =
-			customPollingFrequency && customPollingFrequency < previousFrequency
-				? customPollingFrequency
-				: previousFrequency;
-
-		this.accountFrequencies.set(key, updatedFrequency);
-		this.lastPollingTimes.set(key, 0); // Reset last polling time to ensure immediate load
-
-		this.restartPollingIfNeeded(updatedFrequency);
-
-		return callbackId;
-	}
-
-	/**
-	 * Unregisters a callback previously returned by `addAccount`. Once an account has no
-	 * remaining callbacks, its cached buffer/slot and cadence bookkeeping (`accountFrequencies`,
-	 * `lastPollingTimes`) are dropped; if no accounts remain at all, polling stops entirely,
-	 * otherwise polling is restarted in case the removed account held the fastest cadence.
-	 * @param publicKey Account the callback was registered against.
-	 * @param callbackId Id returned by `addAccount`.
-	 */
-	public removeAccount(publicKey: PublicKey, callbackId: string): void {
-		const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
-
-		if (existingAccountToLoad) {
-			existingAccountToLoad.callbacks.delete(callbackId);
-
-			if (existingAccountToLoad.callbacks.size === 0) {
-				this.bufferAndSlotMap.delete(publicKey.toString());
-				this.accountsToLoad.delete(existingAccountToLoad.publicKey.toString());
-				const key = publicKey.toBase58();
-				this.accountFrequencies.delete(key);
-				this.lastPollingTimes.delete(key);
-			}
-		}
-
-		if (this.accountsToLoad.size === 0) {
-			this.stopPolling();
-		} else {
-			// Restart polling in case we removed the account with the smallest frequency
-			this.restartPollingIfNeeded(this.defaultPollingFrequency);
-		}
-	}
-
-	/** Returns the polling cadence in ms currently set for `publicKey` (custom or default), or `null` if the account isn't registered. */
-	public getAccountCadence(publicKey: PublicKey): number | null {
-		const key = publicKey.toBase58();
-		return this.accountFrequencies.get(key) || null;
-	}
-
-	/**
-	 * Starts the shared interval timer, ticking at the fastest cadence among all registered
-	 * accounts (or `defaultPollingFrequency` if none are registered). Each tick runs
-	 * `handleAccountLoading()`, which loads only the accounts due at that moment. A no-op if
-	 * already running; call `stopPolling()` first to pick up a new minimum frequency.
-	 */
-	public startPolling(): void {
-		if (this.customIntervalId) {
-			return;
-		}
-
-		const minFrequency = Math.min(
-			...Array.from(this.accountFrequencies.values()),
-			this.defaultPollingFrequency
-		);
-
-		this.currentPollingFrequency = minFrequency;
-
-		this.customIntervalId = setInterval(() => {
-			this.handleAccountLoading().catch((error) => {
-				console.error('Error in account loading:', error);
-			});
-		}, minFrequency);
-	}
-
-	/** Stops the shared interval timer (and the base class's, via `super.stopPolling()`) and clears `lastPollingTimes` so every account is treated as due again once polling restarts. */
-	public stopPolling(): void {
-		super.stopPolling();
-
-		if (this.customIntervalId) {
-			clearInterval(this.customIntervalId);
-			this.customIntervalId = null;
-			this.currentPollingFrequency = null;
-		}
-		this.lastPollingTimes.clear();
-	}
-
-	/**
-	 * Clears all per-account cadence bookkeeping. Because `getAccountsToLoad()` only considers
-	 * accounts with an entry in `accountFrequencies`, this stops polling for every registered
-	 * account until a cadence is re-established via `setCustomPollingFrequency` or `addAccount`.
-	 * Registered accounts/callbacks themselves are untouched.
-	 */
-	public clearAccountFrequencies(): void {
-		this.accountFrequencies.clear();
-	}
-}