@velocity-exchange/sdk 0.3.0 → 0.6.0

package/src/accounts/basicUserAccountSubscriber.ts

@@ -1,61 +0,0 @@
-import { DataAndSlot, UserAccountEvents, UserAccountSubscriber } from './types';
-import { PublicKey } from '@solana/web3.js';
-import StrictEventEmitter from 'strict-event-emitter-types';
-import { EventEmitter } from 'events';
-import { UserAccount } from '../types';
-
-/**
- * Basic implementation of UserAccountSubscriber. It will only take in UserAccount
- * data during initialization and will not fetch or subscribe to updates.
- */
-export class BasicUserAccountSubscriber implements UserAccountSubscriber {
-	isSubscribed: boolean;
-	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
-	userAccountPublicKey: PublicKey;
-
-	callbackId?: string;
-	errorCallbackId?: string;
-
-	user?: DataAndSlot<UserAccount>;
-
-	public constructor(
-		userAccountPublicKey: PublicKey,
-		data?: UserAccount,
-		slot?: number
-	) {
-		this.isSubscribed = true;
-		this.eventEmitter = new EventEmitter();
-		this.userAccountPublicKey = userAccountPublicKey;
-		// `slot ?? 0` keeps {data, slot} atomic: a seeded account always carries a
-		// slot (0 = oldest-possible sentinel, overwritten by the first real fetch).
-		this.user = data ? { data, slot: slot ?? 0 } : undefined;
-	}
-
-	async subscribe(_userAccount?: UserAccount): Promise<boolean> {
-		return true;
-	}
-
-	async addToAccountLoader(): Promise<void> {}
-
-	async fetch(): Promise<void> {}
-
-	doesAccountExist(): this is { user: DataAndSlot<UserAccount> } {
-		return this.user !== undefined;
-	}
-
-	async unsubscribe(): Promise<void> {}
-
-	assertIsSubscribed(): void {}
-
-	public getUserAccountAndSlot(): DataAndSlot<UserAccount> | undefined {
-		return this.user;
-	}
-
-	public updateData(userAccount: UserAccount, slot: number): void {
-		if (!this.user || slot >= this.user.slot) {
-			this.user = { data: userAccount, slot };
-			this.eventEmitter.emit('userAccountUpdate', userAccount);
-			this.eventEmitter.emit('update');
-		}
-	}
-}

package/src/accounts/basicUserStatsAccountSubscriber.ts

@@ -1,69 +0,0 @@
-import {
-	DataAndSlot,
-	UserStatsAccountEvents,
-	UserStatsAccountSubscriber,
-} from './types';
-import { PublicKey } from '@solana/web3.js';
-import StrictEventEmitter from 'strict-event-emitter-types';
-import { EventEmitter } from 'events';
-import { UserStatsAccount } from '../types';
-
-/**
- * Basic implementation of UserStatsAccountSubscriber. It will only take in UserStatsAccount
- * data during initialization and will not fetch or subscribe to updates.
- */
-export class BasicUserStatsAccountSubscriber
-	implements UserStatsAccountSubscriber
-{
-	isSubscribed: boolean;
-	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
-	userStatsAccountPublicKey: PublicKey;
-
-	callbackId?: string;
-	errorCallbackId?: string;
-
-	userStats?: DataAndSlot<UserStatsAccount>;
-
-	public constructor(
-		userStatsAccountPublicKey: PublicKey,
-		data?: UserStatsAccount,
-		slot?: number
-	) {
-		this.isSubscribed = true;
-		this.eventEmitter = new EventEmitter();
-		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
-		// `slot ?? 0` keeps {data, slot} atomic: a seeded account always carries a
-		// slot (0 = oldest-possible sentinel, overwritten by the first real fetch).
-		this.userStats = data ? { data, slot: slot ?? 0 } : undefined;
-	}
-
-	async subscribe(_userStatsAccount?: UserStatsAccount): Promise<boolean> {
-		return true;
-	}
-
-	async addToAccountLoader(): Promise<void> {}
-
-	async fetch(): Promise<void> {}
-
-	doesAccountExist(): this is { userStats: DataAndSlot<UserStatsAccount> } {
-		return this.userStats !== undefined;
-	}
-
-	async unsubscribe(): Promise<void> {}
-
-	assertIsSubscribed(): void {}
-
-	public getUserStatsAccountAndSlot():
-		| DataAndSlot<UserStatsAccount>
-		| undefined {
-		return this.userStats;
-	}
-
-	public updateData(userStatsAccount: UserStatsAccount, slot: number): void {
-		if (!this.userStats || slot >= this.userStats.slot) {
-			this.userStats = { data: userStatsAccount, slot };
-			this.eventEmitter.emit('userStatsAccountUpdate', userStatsAccount);
-			this.eventEmitter.emit('update');
-		}
-	}
-}

package/src/accounts/bulkAccountLoader.ts

@@ -1,306 +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';
-
-export type AccountToLoad = {
-	publicKey: PublicKey;
-	callbacks: Map<string, (buffer: Buffer, slot: number) => void>;
-};
-
-const oneMinute = 60 * 1000;
-
-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;
-
-	public constructor(
-		connection: Connection,
-		commitment: Commitment,
-		pollingFrequency: number
-	) {
-		this.connection = connection;
-		this.commitment = commitment;
-		this.pollingFrequency = pollingFrequency;
-	}
-
-	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;
-	}
-
-	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();
-		}
-	}
-
-	public addErrorCallbacks(callback: (error: Error) => void): string {
-		const callbackId = uuidv4();
-		this.errorCallbacks.set(callbackId, callback);
-		return callbackId;
-	}
-
-	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));
-	}
-
-	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;
-			}
-		}
-	}
-
-	public getBufferAndSlot(publicKey: PublicKey): BufferAndSlot | undefined {
-		return this.bufferAndSlotMap.get(publicKey.toString());
-	}
-
-	public getSlot(): number {
-		return this.mostRecentSlot;
-	}
-
-	public startPolling(): void {
-		if (this.intervalId) {
-			return;
-		}
-
-		if (this.pollingFrequency !== 0)
-			this.intervalId = setInterval(
-				this.load.bind(this),
-				this.pollingFrequency
-			);
-	}
-
-	public stopPolling(): void {
-		if (this.intervalId) {
-			clearInterval(this.intervalId);
-			this.intervalId = undefined;
-		}
-	}
-
-	public log(msg: string): void {
-		console.log(msg);
-	}
-
-	public updatePollingFrequency(pollingFrequency: number): void {
-		this.stopPolling();
-		this.pollingFrequency = pollingFrequency;
-		if (this.accountsToLoad.size > 0) {
-			this.startPolling();
-		}
-	}
-}

package/src/accounts/bulkUserStatsSubscription.ts

@@ -1,33 +0,0 @@
-import { UserStats } from '../userStats';
-import { BulkAccountLoader } from './bulkAccountLoader';
-import { PollingUserStatsAccountSubscriber } from './pollingUserStatsAccountSubscriber';
-
-/**
- * @param userStats
- * @param accountLoader
- */
-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,33 +0,0 @@
-import { User } from '../user';
-import { BulkAccountLoader } from './bulkAccountLoader';
-import { PollingUserAccountSubscriber } from './pollingUserAccountSubscriber';
-
-/**
- * @param users
- * @param accountLoader
- */
-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,213 +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';
-
-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;
-
-	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;
-	}
-
-	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;
-	}
-
-	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);
-		}
-	}
-
-	public getAccountCadence(publicKey: PublicKey): number | null {
-		const key = publicKey.toBase58();
-		return this.accountFrequencies.get(key) || null;
-	}
-
-	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);
-	}
-
-	public stopPolling(): void {
-		super.stopPolling();
-
-		if (this.customIntervalId) {
-			clearInterval(this.customIntervalId);
-			this.customIntervalId = null;
-			this.currentPollingFrequency = null;
-		}
-		this.lastPollingTimes.clear();
-	}
-
-	public clearAccountFrequencies(): void {
-		this.accountFrequencies.clear();
-	}
-}