@velocity-exchange/sdk 0.3.0 → 0.6.0

package/src/accounts/grpcVelocityClientAccountSubscriberV2.ts

@@ -1,782 +0,0 @@
-import StrictEventEmitter from 'strict-event-emitter-types';
-import { EventEmitter } from 'events';
-import { OracleInfo, OraclePriceData } from '../oracles/types';
-import { AccountInfo, PublicKey } from '@solana/web3.js';
-import { findAllMarketAndOracles, VelocityProgram } from '../config';
-import {
-	getVelocityStateAccountPublicKey,
-	getPerpMarketPublicKey,
-	getPerpMarketPublicKeySync,
-	getSpotMarketPublicKey,
-	getSpotMarketPublicKeySync,
-} from '../addresses/pda';
-import {
-	AccountSubscriber,
-	DataAndSlot,
-	DelistedMarketSetting,
-	VelocityClientAccountEvents,
-	VelocityClientAccountSubscriber,
-	NotSubscribedError,
-	GrpcConfigs,
-	ResubOpts,
-} from './types';
-import { grpcAccountSubscriber } from './grpcAccountSubscriber';
-import { grpcMultiAccountSubscriber } from './grpcMultiAccountSubscriber';
-import { PerpMarketAccount, SpotMarketAccount, StateAccount } from '../types';
-import {
-	getOracleId,
-	getPublicKeyAndSourceFromOracleId,
-} from '../oracles/oracleId';
-import { OracleClientCache } from '../oracles/oracleClientCache';
-import { findDelistedPerpMarketsAndOracles } from './utils';
-
-export class grpcVelocityClientAccountSubscriberV2
-	implements VelocityClientAccountSubscriber
-{
-	private grpcConfigs: GrpcConfigs;
-	private perpMarketsSubscriber?: grpcMultiAccountSubscriber<PerpMarketAccount>;
-	private spotMarketsSubscriber?: grpcMultiAccountSubscriber<SpotMarketAccount>;
-	private oracleMultiSubscriber?: grpcMultiAccountSubscriber<
-		OraclePriceData,
-		OracleInfo
-	>;
-	private perpMarketIndexToAccountPubkeyMap = new Map<number, string>();
-	private spotMarketIndexToAccountPubkeyMap = new Map<number, string>();
-	private delistedMarketSetting: DelistedMarketSetting;
-
-	public eventEmitter: StrictEventEmitter<
-		EventEmitter,
-		VelocityClientAccountEvents
-	>;
-	public isSubscribed: boolean;
-	public isSubscribing: boolean;
-	public program: VelocityProgram;
-	public perpMarketIndexes: number[];
-	public spotMarketIndexes: number[];
-	public shouldFindAllMarketsAndOracles: boolean;
-	public oracleInfos: OracleInfo[];
-	public initialPerpMarketAccountData: Map<number, PerpMarketAccount>;
-	public initialSpotMarketAccountData: Map<number, SpotMarketAccount>;
-	public initialOraclePriceData: Map<string, OraclePriceData>;
-	public perpOracleMap = new Map<number, PublicKey>();
-	public perpOracleStringMap = new Map<number, string>();
-	public spotOracleMap = new Map<number, PublicKey>();
-	public spotOracleStringMap = new Map<number, string>();
-	private oracleIdToOracleDataMap = new Map<
-		string,
-		DataAndSlot<OraclePriceData>
-	>();
-	public stateAccountSubscriber?: AccountSubscriber<StateAccount>;
-	oracleClientCache = new OracleClientCache();
-	private resubOpts?: ResubOpts;
-
-	private subscriptionPromiseResolver: (val: boolean) => void = () => {};
-	private subscriptionPromise: Promise<boolean> = Promise.resolve(false);
-
-	constructor(
-		grpcConfigs: GrpcConfigs,
-		program: VelocityProgram,
-		perpMarketIndexes: number[],
-		spotMarketIndexes: number[],
-		oracleInfos: OracleInfo[],
-		shouldFindAllMarketsAndOracles: boolean,
-		delistedMarketSetting: DelistedMarketSetting,
-		resubOpts?: ResubOpts
-	) {
-		this.eventEmitter = new EventEmitter();
-		this.isSubscribed = false;
-		this.isSubscribing = false;
-		this.program = program;
-		this.perpMarketIndexes = perpMarketIndexes;
-		this.spotMarketIndexes = spotMarketIndexes;
-		this.shouldFindAllMarketsAndOracles = shouldFindAllMarketsAndOracles;
-		this.oracleInfos = oracleInfos;
-		this.initialPerpMarketAccountData = new Map();
-		this.initialSpotMarketAccountData = new Map();
-		this.initialOraclePriceData = new Map();
-		this.perpOracleMap = new Map();
-		this.perpOracleStringMap = new Map();
-		this.spotOracleMap = new Map();
-		this.spotOracleStringMap = new Map();
-		this.grpcConfigs = grpcConfigs;
-		this.resubOpts = resubOpts;
-		this.delistedMarketSetting = delistedMarketSetting;
-	}
-
-	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));
-	};
-
-	async setInitialData(): Promise<void> {
-		const connection = this.program.provider.connection;
-
-		if (
-			!this.initialPerpMarketAccountData ||
-			this.initialPerpMarketAccountData.size === 0
-		) {
-			const perpMarketPublicKeys = this.perpMarketIndexes.map((marketIndex) =>
-				getPerpMarketPublicKeySync(this.program.programId, marketIndex)
-			);
-			const perpMarketPublicKeysChunks = this.chunks(perpMarketPublicKeys, 75);
-			const perpMarketAccountInfos = (
-				await Promise.all(
-					perpMarketPublicKeysChunks.map((perpMarketPublicKeysChunk) =>
-						connection.getMultipleAccountsInfo(perpMarketPublicKeysChunk)
-					)
-				)
-			).flat();
-			this.initialPerpMarketAccountData = new Map(
-				perpMarketAccountInfos
-					.filter(
-						(accountInfo): accountInfo is AccountInfo<Buffer> => !!accountInfo
-					)
-					.map((accountInfo) => {
-						const perpMarket = this.program.coder.accounts.decode(
-							'perpMarket',
-							accountInfo.data
-						);
-						return [perpMarket.marketIndex, perpMarket];
-					})
-			);
-		}
-
-		if (
-			!this.initialSpotMarketAccountData ||
-			this.initialSpotMarketAccountData.size === 0
-		) {
-			const spotMarketPublicKeys = this.spotMarketIndexes.map((marketIndex) =>
-				getSpotMarketPublicKeySync(this.program.programId, marketIndex)
-			);
-			const spotMarketPublicKeysChunks = this.chunks(spotMarketPublicKeys, 75);
-			const spotMarketAccountInfos = (
-				await Promise.all(
-					spotMarketPublicKeysChunks.map((spotMarketPublicKeysChunk) =>
-						connection.getMultipleAccountsInfo(spotMarketPublicKeysChunk)
-					)
-				)
-			).flat();
-			this.initialSpotMarketAccountData = new Map(
-				spotMarketAccountInfos
-					.filter(
-						(accountInfo): accountInfo is AccountInfo<Buffer> => !!accountInfo
-					)
-					.map((accountInfo) => {
-						const spotMarket = this.program.coder.accounts.decode(
-							'spotMarket',
-							accountInfo.data
-						);
-						return [spotMarket.marketIndex, spotMarket];
-					})
-			);
-		}
-
-		const oracleAccountPubkeyChunks = this.chunks(
-			this.oracleInfos.map((oracleInfo) => oracleInfo.publicKey),
-			75
-		);
-		const oracleAccountInfos = (
-			await Promise.all(
-				oracleAccountPubkeyChunks.map((oracleAccountPublicKeysChunk) =>
-					connection.getMultipleAccountsInfo(oracleAccountPublicKeysChunk)
-				)
-			)
-		).flat();
-		this.initialOraclePriceData = new Map(
-			this.oracleInfos.reduce<[string, OraclePriceData][]>(
-				(result, oracleInfo, i) => {
-					const oracleAccountInfo = oracleAccountInfos[i];
-					if (!oracleAccountInfo) {
-						return result;
-					}
-					const oracleClient = this.oracleClientCache.get(
-						oracleInfo.source,
-						connection,
-						this.program
-					);
-					if (!oracleClient) {
-						return result;
-					}
-					const oraclePriceData = oracleClient.getOraclePriceDataFromBuffer(
-						oracleAccountInfo.data
-					);
-					result.push([
-						getOracleId(oracleInfo.publicKey, oracleInfo.source),
-						oraclePriceData,
-					]);
-					return result;
-				},
-				[]
-			)
-		);
-	}
-
-	async addPerpMarket(_marketIndex: number): Promise<boolean> {
-		if (!this.perpMarketIndexes.includes(_marketIndex)) {
-			this.perpMarketIndexes = this.perpMarketIndexes.concat(_marketIndex);
-		}
-		return true;
-	}
-
-	async addSpotMarket(_marketIndex: number): Promise<boolean> {
-		return true;
-	}
-
-	async addOracle(oracleInfo: OracleInfo): Promise<boolean> {
-		if (this.resubOpts?.logResubMessages) {
-			console.log('[grpcVelocityClientAccountSubscriberV2] addOracle');
-		}
-		if (oracleInfo.publicKey.equals(PublicKey.default)) {
-			return true;
-		}
-
-		const exists = this.oracleInfos.some(
-			(o) =>
-				o.source === oracleInfo.source &&
-				o.publicKey.equals(oracleInfo.publicKey)
-		);
-		if (exists) {
-			return true; // Already exists, don't add duplicate
-		}
-
-		this.oracleInfos = this.oracleInfos.concat(oracleInfo);
-		this.oracleMultiSubscriber?.addAccounts([oracleInfo.publicKey]);
-
-		return true;
-	}
-
-	public async subscribe(): Promise<boolean> {
-		if (this.isSubscribed) {
-			return true;
-		}
-
-		if (this.isSubscribing) {
-			return await this.subscriptionPromise;
-		}
-
-		this.isSubscribing = true;
-
-		this.subscriptionPromise = new Promise((res) => {
-			this.subscriptionPromiseResolver = res;
-		});
-
-		if (this.shouldFindAllMarketsAndOracles) {
-			const {
-				perpMarketIndexes,
-				perpMarketAccounts,
-				spotMarketIndexes,
-				spotMarketAccounts,
-				oracleInfos,
-			} = await findAllMarketAndOracles(this.program);
-			this.perpMarketIndexes = perpMarketIndexes;
-			this.spotMarketIndexes = spotMarketIndexes;
-			this.oracleInfos = oracleInfos;
-			// front run and set the initial data here to save extra gma call in set initial data
-			this.initialPerpMarketAccountData = new Map(
-				perpMarketAccounts.map((market) => [market.marketIndex, market])
-			);
-			this.initialSpotMarketAccountData = new Map(
-				spotMarketAccounts.map((market) => [market.marketIndex, market])
-			);
-		}
-
-		const statePublicKey = await getVelocityStateAccountPublicKey(
-			this.program.programId
-		);
-
-		// create and activate main state account subscription
-		this.stateAccountSubscriber =
-			await grpcAccountSubscriber.create<StateAccount>(
-				this.grpcConfigs,
-				'state',
-				this.program,
-				statePublicKey,
-				undefined,
-				undefined
-			);
-		await this.stateAccountSubscriber.subscribe((data: StateAccount) => {
-			this.eventEmitter.emit('stateAccountUpdate', data);
-			this.eventEmitter.emit('update');
-		});
-
-		// set initial data to avoid spamming getAccountInfo calls in webSocketAccountSubscriber
-		await this.setInitialData();
-
-		// subscribe to perp + spot markets (separate) and oracles
-		await Promise.all([
-			this.subscribeToPerpMarketAccounts(),
-			this.subscribeToSpotMarketAccounts(),
-			this.subscribeToOracles(),
-		]);
-
-		this.eventEmitter.emit('update');
-
-		await this.handleDelistedMarkets();
-
-		await Promise.all([this.setPerpOracleMap(), this.setSpotOracleMap()]);
-
-		this.subscriptionPromiseResolver(true);
-
-		this.isSubscribing = false;
-		this.isSubscribed = true;
-
-		// delete initial data
-		this.removeInitialData();
-
-		return true;
-	}
-
-	public async fetch(): Promise<void> {
-		await this.stateAccountSubscriber?.fetch();
-		await this.perpMarketsSubscriber?.fetch();
-		await this.spotMarketsSubscriber?.fetch();
-		await this.oracleMultiSubscriber?.fetch();
-	}
-
-	private assertIsSubscribed(): void {
-		if (!this.isSubscribed) {
-			throw new NotSubscribedError(
-				'You must call `subscribe` before using this function'
-			);
-		}
-	}
-
-	public getStateAccountAndSlot(): DataAndSlot<StateAccount> {
-		this.assertIsSubscribed();
-		return this.stateAccountSubscriber!.dataAndSlot!;
-	}
-
-	public getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[] {
-		const map = this.perpMarketsSubscriber?.getAccountDataMap();
-		return Array.from(map?.values() ?? []);
-	}
-
-	public getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[] {
-		const map = this.spotMarketsSubscriber?.getAccountDataMap();
-		return Array.from(map?.values() ?? []);
-	}
-
-	getMarketAccountAndSlot(
-		marketIndex: number
-	): DataAndSlot<PerpMarketAccount> | undefined {
-		const accountPubkey =
-			this.perpMarketIndexToAccountPubkeyMap.get(marketIndex);
-		if (!accountPubkey) {
-			return undefined;
-		}
-		return this.perpMarketsSubscriber?.getAccountData(accountPubkey);
-	}
-
-	getSpotMarketAccountAndSlot(
-		marketIndex: number
-	): DataAndSlot<SpotMarketAccount> | undefined {
-		const accountPubkey =
-			this.spotMarketIndexToAccountPubkeyMap.get(marketIndex);
-		if (!accountPubkey) {
-			return undefined;
-		}
-		return this.spotMarketsSubscriber?.getAccountData(accountPubkey);
-	}
-
-	public getOraclePriceDataAndSlot(
-		oracleId: string
-	): DataAndSlot<OraclePriceData> | undefined {
-		this.assertIsSubscribed();
-		// we need to rely on a map we store in this class because the grpcMultiAccountSubscriber does not track a mapping or oracle ID.
-		// DO NOT call getAccountData on the oracleMultiSubscriber, it will not return the correct data in certain cases(BONK spot and perp market subscribed too at once).
-		return this.oracleIdToOracleDataMap.get(oracleId);
-	}
-
-	public getOraclePriceDataAndSlotForPerpMarket(
-		marketIndex: number
-	): DataAndSlot<OraclePriceData> | undefined {
-		const perpMarketAccount = this.getMarketAccountAndSlot(marketIndex);
-		const oracle = this.perpOracleMap.get(marketIndex);
-		const oracleId = this.perpOracleStringMap.get(marketIndex);
-		if (!perpMarketAccount || !oracleId) {
-			return undefined;
-		}
-
-		if (!oracle || !perpMarketAccount.data.oracle.equals(oracle)) {
-			// If the oracle has changed (or not yet cached), update the oracle map in background
-			this.setPerpOracleMap();
-		}
-
-		return this.getOraclePriceDataAndSlot(oracleId);
-	}
-
-	public getOraclePriceDataAndSlotForSpotMarket(
-		marketIndex: number
-	): DataAndSlot<OraclePriceData> | undefined {
-		const spotMarketAccount = this.getSpotMarketAccountAndSlot(marketIndex);
-		const oracle = this.spotOracleMap.get(marketIndex);
-		const oracleId = this.spotOracleStringMap.get(marketIndex);
-		if (!spotMarketAccount || !oracleId) {
-			return undefined;
-		}
-
-		if (!oracle || !spotMarketAccount.data.oracle.equals(oracle)) {
-			// If the oracle has changed (or not yet cached), update the oracle map in background
-			this.setSpotOracleMap();
-		}
-
-		return this.getOraclePriceDataAndSlot(oracleId);
-	}
-
-	async setPerpOracleMap() {
-		const perpMarketsMap = this.perpMarketsSubscriber?.getAccountDataMap();
-		const perpMarkets = Array.from(perpMarketsMap?.values() ?? []);
-		const addOraclePromises = [];
-		for (const perpMarket of perpMarkets) {
-			if (!perpMarket || !perpMarket.data) {
-				continue;
-			}
-			const perpMarketAccount = perpMarket.data;
-			const perpMarketIndex = perpMarketAccount.marketIndex;
-			const oracle = perpMarketAccount.oracle;
-			const oracleId = getOracleId(oracle, perpMarket.data.oracleSource);
-			if (!this.oracleMultiSubscriber?.getAccountDataMap().has(oracleId)) {
-				addOraclePromises.push(
-					this.addOracle({
-						publicKey: oracle,
-						source: perpMarket.data.oracleSource,
-					})
-				);
-			}
-			this.perpOracleMap.set(perpMarketIndex, oracle);
-			this.perpOracleStringMap.set(perpMarketIndex, oracleId);
-		}
-		await Promise.all(addOraclePromises);
-	}
-
-	async setSpotOracleMap() {
-		const spotMarketsMap = this.spotMarketsSubscriber?.getAccountDataMap();
-		const spotMarkets = Array.from(spotMarketsMap?.values() ?? []);
-		const addOraclePromises = [];
-		for (const spotMarket of spotMarkets) {
-			if (!spotMarket || !spotMarket.data) {
-				continue;
-			}
-			const spotMarketAccount = spotMarket.data;
-			const spotMarketIndex = spotMarketAccount.marketIndex;
-			const oracle = spotMarketAccount.oracle;
-			const oracleId = getOracleId(oracle, spotMarketAccount.oracleSource);
-			if (!this.oracleMultiSubscriber?.getAccountDataMap().has(oracleId)) {
-				addOraclePromises.push(
-					this.addOracle({
-						publicKey: oracle,
-						source: spotMarketAccount.oracleSource,
-					})
-				);
-			}
-			this.spotOracleMap.set(spotMarketIndex, oracle);
-			this.spotOracleStringMap.set(spotMarketIndex, oracleId);
-		}
-		await Promise.all(addOraclePromises);
-	}
-
-	async subscribeToPerpMarketAccounts(): Promise<boolean> {
-		if (this.resubOpts?.logResubMessages) {
-			console.log(
-				'[grpcVelocityClientAccountSubscriberV2] subscribeToPerpMarketAccounts'
-			);
-		}
-		const perpMarketIndexToAccountPubkeys: Array<[number, PublicKey]> =
-			await Promise.all(
-				this.perpMarketIndexes.map(async (marketIndex) => [
-					marketIndex,
-					await getPerpMarketPublicKey(this.program.programId, marketIndex),
-				])
-			);
-		for (const [
-			marketIndex,
-			accountPubkey,
-		] of perpMarketIndexToAccountPubkeys) {
-			this.perpMarketIndexToAccountPubkeyMap.set(
-				marketIndex,
-				accountPubkey.toBase58()
-			);
-		}
-
-		const perpMarketPubkeys = perpMarketIndexToAccountPubkeys.map(
-			([_, accountPubkey]) => accountPubkey
-		);
-
-		this.perpMarketsSubscriber =
-			await grpcMultiAccountSubscriber.create<PerpMarketAccount>(
-				this.grpcConfigs,
-				'perpMarket',
-				this.program,
-				undefined,
-				this.resubOpts,
-				undefined,
-				async () => {
-					try {
-						if (this.resubOpts?.logResubMessages) {
-							console.log(
-								'[grpcVelocityClientAccountSubscriberV2] perp markets subscriber unsubscribed; resubscribing'
-							);
-						}
-						await this.subscribeToPerpMarketAccounts();
-					} catch (e) {
-						console.error('Perp markets resubscribe failed:', e);
-					}
-				}
-			);
-
-		for (const data of this.initialPerpMarketAccountData.values()) {
-			this.perpMarketsSubscriber.setAccountData(data.pubkey.toBase58(), data);
-		}
-
-		await this.perpMarketsSubscriber.subscribe(
-			perpMarketPubkeys,
-			(_accountId, data) => {
-				this.eventEmitter.emit(
-					'perpMarketAccountUpdate',
-					data as PerpMarketAccount
-				);
-				this.eventEmitter.emit('update');
-			}
-		);
-
-		return true;
-	}
-
-	async subscribeToSpotMarketAccounts(): Promise<boolean> {
-		if (this.resubOpts?.logResubMessages) {
-			console.log(
-				'[grpcVelocityClientAccountSubscriberV2] subscribeToSpotMarketAccounts'
-			);
-		}
-		const spotMarketIndexToAccountPubkeys: Array<[number, PublicKey]> =
-			await Promise.all(
-				this.spotMarketIndexes.map(async (marketIndex) => [
-					marketIndex,
-					await getSpotMarketPublicKey(this.program.programId, marketIndex),
-				])
-			);
-		for (const [
-			marketIndex,
-			accountPubkey,
-		] of spotMarketIndexToAccountPubkeys) {
-			this.spotMarketIndexToAccountPubkeyMap.set(
-				marketIndex,
-				accountPubkey.toBase58()
-			);
-		}
-
-		const spotMarketPubkeys = spotMarketIndexToAccountPubkeys.map(
-			([_, accountPubkey]) => accountPubkey
-		);
-
-		this.spotMarketsSubscriber =
-			await grpcMultiAccountSubscriber.create<SpotMarketAccount>(
-				this.grpcConfigs,
-				'spotMarket',
-				this.program,
-				undefined,
-				this.resubOpts,
-				undefined,
-				async () => {
-					try {
-						if (this.resubOpts?.logResubMessages) {
-							console.log(
-								'[grpcVelocityClientAccountSubscriberV2] spot markets subscriber unsubscribed; resubscribing'
-							);
-						}
-						await this.subscribeToSpotMarketAccounts();
-					} catch (e) {
-						console.error('Spot markets resubscribe failed:', e);
-					}
-				}
-			);
-
-		for (const data of this.initialSpotMarketAccountData.values()) {
-			this.spotMarketsSubscriber.setAccountData(data.pubkey.toBase58(), data);
-		}
-
-		await this.spotMarketsSubscriber.subscribe(
-			spotMarketPubkeys,
-			(_accountId, data) => {
-				this.eventEmitter.emit(
-					'spotMarketAccountUpdate',
-					data as SpotMarketAccount
-				);
-				this.eventEmitter.emit('update');
-			}
-		);
-
-		return true;
-	}
-
-	async subscribeToOracles(): Promise<boolean> {
-		if (this.resubOpts?.logResubMessages) {
-			console.log('grpcVelocityClientAccountSubscriberV2 subscribeToOracles');
-		}
-		const oraclePubkeyToInfosMap = new Map<string, OracleInfo[]>();
-		for (const info of this.oracleInfos) {
-			const pubkey = info.publicKey.toBase58();
-			if (!oraclePubkeyToInfosMap.has(pubkey)) {
-				oraclePubkeyToInfosMap.set(pubkey, []);
-			}
-			oraclePubkeyToInfosMap.get(pubkey)!.push(info);
-		}
-
-		const oraclePubkeys = Array.from(
-			new Set(this.oracleInfos.map((info) => info.publicKey))
-		);
-
-		this.oracleMultiSubscriber = await grpcMultiAccountSubscriber.create<
-			OraclePriceData,
-			OracleInfo
-		>(
-			this.grpcConfigs,
-			'oracle',
-			this.program,
-			(buffer: Buffer, pubkey?: string, accountProps?: OracleInfo) => {
-				if (!pubkey) {
-					throw new Error('Oracle pubkey missing in decode');
-				}
-
-				if (!accountProps) {
-					throw new Error('Oracle accountProps missing in decode');
-				}
-
-				const client = this.oracleClientCache.get(
-					accountProps.source,
-					this.program.provider.connection,
-					this.program
-				);
-				if (!client) {
-					throw new Error('Oracle client missing in decode');
-				}
-				const price = client.getOraclePriceDataFromBuffer(buffer);
-				return price;
-			},
-			this.resubOpts,
-			undefined,
-			async () => {
-				try {
-					if (this.resubOpts?.logResubMessages) {
-						console.log(
-							'[grpcVelocityClientAccountSubscriberV2] oracle subscriber unsubscribed; resubscribing'
-						);
-					}
-					await this.subscribeToOracles();
-				} catch (e) {
-					console.error('Oracle resubscribe failed:', e);
-				}
-			},
-			oraclePubkeyToInfosMap
-		);
-
-		for (const data of this.initialOraclePriceData.entries()) {
-			const { publicKey } = getPublicKeyAndSourceFromOracleId(data[0]);
-			this.oracleMultiSubscriber.setAccountData(publicKey.toBase58(), data[1]);
-			this.oracleIdToOracleDataMap.set(data[0], {
-				data: data[1],
-				slot: 0,
-			});
-		}
-
-		await this.oracleMultiSubscriber.subscribe(
-			oraclePubkeys,
-			(accountId, data, context, _b, accountProps) => {
-				if (accountProps === undefined) {
-					return;
-				}
-				const oracleId = getOracleId(accountId, accountProps.source);
-				this.oracleIdToOracleDataMap.set(oracleId, {
-					data,
-					slot: context.slot,
-				});
-				this.eventEmitter.emit(
-					'oraclePriceUpdate',
-					accountId,
-					accountProps.source,
-					data
-				);
-
-				this.eventEmitter.emit('update');
-			}
-		);
-
-		return true;
-	}
-
-	async handleDelistedMarkets(): Promise<void> {
-		if (this.delistedMarketSetting === DelistedMarketSetting.Subscribe) {
-			return;
-		}
-
-		const { perpMarketIndexes, oracles } = findDelistedPerpMarketsAndOracles(
-			Array.from(
-				this.perpMarketsSubscriber?.getAccountDataMap().values() || []
-			),
-			Array.from(this.spotMarketsSubscriber?.getAccountDataMap().values() || [])
-		);
-
-		// Build array of perp market pubkeys to remove
-		const perpMarketPubkeysToRemove = perpMarketIndexes
-			.map((marketIndex) => {
-				const pubkeyString =
-					this.perpMarketIndexToAccountPubkeyMap.get(marketIndex);
-				return pubkeyString ? new PublicKey(pubkeyString) : null;
-			})
-			.filter((pubkey): pubkey is PublicKey => pubkey !== null);
-
-		// Build array of oracle pubkeys to remove
-		const oraclePubkeysToRemove = oracles.map((oracle) => oracle.publicKey);
-
-		// Remove accounts in batches - perp markets
-		if (perpMarketPubkeysToRemove.length > 0) {
-			await this.perpMarketsSubscriber?.removeAccounts(
-				perpMarketPubkeysToRemove
-			);
-		}
-
-		// Remove accounts in batches - oracles
-		if (oraclePubkeysToRemove.length > 0) {
-			await this.oracleMultiSubscriber?.removeAccounts(oraclePubkeysToRemove);
-		}
-	}
-
-	removeInitialData() {
-		this.initialPerpMarketAccountData = new Map();
-		this.initialSpotMarketAccountData = new Map();
-		this.initialOraclePriceData = new Map();
-	}
-
-	async unsubscribeFromOracles(): Promise<void> {
-		if (this.oracleMultiSubscriber) {
-			await this.oracleMultiSubscriber.unsubscribe();
-			this.oracleMultiSubscriber = undefined;
-			return;
-		}
-	}
-
-	async unsubscribe(): Promise<void> {
-		if (!this.isSubscribed) {
-			return;
-		}
-
-		this.isSubscribed = false;
-		this.isSubscribing = false;
-
-		await this.stateAccountSubscriber?.unsubscribe();
-		await this.unsubscribeFromOracles();
-		await this.perpMarketsSubscriber?.unsubscribe();
-		await this.spotMarketsSubscriber?.unsubscribe();
-
-		// Clean up all maps to prevent memory leaks
-		this.perpMarketIndexToAccountPubkeyMap.clear();
-		this.spotMarketIndexToAccountPubkeyMap.clear();
-		this.oracleIdToOracleDataMap.clear();
-		this.perpOracleMap.clear();
-		this.perpOracleStringMap.clear();
-		this.spotOracleMap.clear();
-		this.spotOracleStringMap.clear();
-	}
-}