@drift-labs/sdk-browser 2.104.0-beta.21

package/src/accounts/bulkAccountLoader.ts

@@ -0,0 +1,294 @@
+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';
+
+export type AccountToLoad = {
+	publicKey: PublicKey;
+	callbacks: Map<string, (buffer: Buffer, slot: number) => void>;
+};
+
+const GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
+
+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) => void>();
+	intervalId?: ReturnType<typeof setTimeout>;
+	// to handle clients spamming load
+	loadPromise?: Promise<void>;
+	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): 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());
+			}
+		}
+
+		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): void {
+		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);
+			for (const [_, callback] of this.errorCallbacks) {
+				callback(e);
+			}
+		} 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, i) => {
+			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,
+		slot: number
+	): void {
+		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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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/fetch.ts

@@ -0,0 +1,66 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { UserAccount, UserStatsAccount } from '../types';
+import {
+	getUserAccountPublicKey,
+	getUserStatsAccountPublicKey,
+} from '../addresses/pda';
+import { Program } from '@coral-xyz/anchor';
+
+export async function fetchUserAccounts(
+	connection: Connection,
+	program: Program,
+	authority: PublicKey,
+	limit = 8
+): Promise<(UserAccount | undefined)[]> {
+	const userAccountPublicKeys = new Array<PublicKey>();
+	for (let i = 0; i < limit; i++) {
+		userAccountPublicKeys.push(
+			await getUserAccountPublicKey(program.programId, authority, i)
+		);
+	}
+
+	return fetchUserAccountsUsingKeys(connection, program, userAccountPublicKeys);
+}
+
+export async function fetchUserAccountsUsingKeys(
+	connection: Connection,
+	program: Program,
+	userAccountPublicKeys: PublicKey[]
+): Promise<(UserAccount | undefined)[]> {
+	const accountInfos = await connection.getMultipleAccountsInfo(
+		userAccountPublicKeys,
+		'confirmed'
+	);
+
+	return accountInfos.map((accountInfo) => {
+		if (!accountInfo) {
+			return undefined;
+		}
+		return program.account.user.coder.accounts.decodeUnchecked(
+			'User',
+			accountInfo.data
+		) as UserAccount;
+	});
+}
+
+export async function fetchUserStatsAccount(
+	connection: Connection,
+	program: Program,
+	authority: PublicKey
+): Promise<UserStatsAccount | undefined> {
+	const userStatsPublicKey = getUserStatsAccountPublicKey(
+		program.programId,
+		authority
+	);
+	const accountInfo = await connection.getAccountInfo(
+		userStatsPublicKey,
+		'confirmed'
+	);
+
+	return accountInfo
+		? (program.account.user.coder.accounts.decodeUnchecked(
+				'UserStats',
+				accountInfo.data
+		  ) as UserStatsAccount)
+		: undefined;
+}

package/src/accounts/grpcAccountSubscriber.ts

@@ -0,0 +1,160 @@
+import { ResubOpts, GrpcConfigs } from './types';
+import { Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import * as Buffer from 'buffer';
+
+import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
+import {
+	Client,
+	ClientDuplexStream,
+	CommitmentLevel,
+	createClient,
+	SubscribeRequest,
+	SubscribeUpdate,
+} from '../isomorphic/grpc';
+
+export class grpcAccountSubscriber<T> extends WebSocketAccountSubscriber<T> {
+	client: Client;
+	stream: ClientDuplexStream<SubscribeRequest, SubscribeUpdate>;
+	commitmentLevel: CommitmentLevel;
+	listenerId?: number;
+
+	public constructor(
+		grpcConfigs: GrpcConfigs,
+		accountName: string,
+		program: Program,
+		accountPublicKey: PublicKey,
+		decodeBuffer?: (buffer: Buffer) => T,
+		resubOpts?: ResubOpts
+	) {
+		super(accountName, program, accountPublicKey, decodeBuffer, resubOpts);
+		this.client = createClient(
+			grpcConfigs.endpoint,
+			grpcConfigs.token,
+			grpcConfigs.channelOptions ?? {}
+		);
+		this.commitmentLevel =
+			// @ts-ignore :: isomorphic exported enum fails typescript but will work at runtime
+			grpcConfigs.commitmentLevel ?? CommitmentLevel.CONFIRMED;
+	}
+
+	override async subscribe(onChange: (data: T) => void): Promise<void> {
+		if (this.listenerId != null || this.isUnsubscribing) {
+			return;
+		}
+
+		this.onChange = onChange;
+		if (!this.dataAndSlot) {
+			await this.fetch();
+		}
+
+		// Subscribe with grpc
+		this.stream = await this.client.subscribe();
+		const request: SubscribeRequest = {
+			slots: {},
+			accounts: {
+				account: {
+					account: [this.accountPublicKey.toString()],
+					owner: [],
+					filters: [],
+				},
+			},
+			transactions: {},
+			blocks: {},
+			blocksMeta: {},
+			accountsDataSlice: [],
+			commitment: this.commitmentLevel,
+			entry: {},
+			transactionsStatus: {},
+		};
+		this.stream.on('data', (chunk: SubscribeUpdate) => {
+			if (!chunk.account) {
+				return;
+			}
+			const slot = Number(chunk.account.slot);
+			const accountInfo = {
+				owner: new PublicKey(chunk.account.account.owner),
+				lamports: Number(chunk.account.account.lamports),
+				data: Buffer.Buffer.from(chunk.account.account.data),
+				executable: chunk.account.account.executable,
+				rentEpoch: Number(chunk.account.account.rentEpoch),
+			};
+
+			if (this.resubOpts?.resubTimeoutMs) {
+				this.receivingData = true;
+				clearTimeout(this.timeoutId);
+				this.handleRpcResponse(
+					{
+						slot,
+					},
+					accountInfo
+				);
+				this.setTimeout();
+			} else {
+				this.handleRpcResponse(
+					{
+						slot,
+					},
+					accountInfo
+				);
+			}
+		});
+
+		return new Promise<void>((resolve, reject) => {
+			this.stream.write(request, (err) => {
+				if (err === null || err === undefined) {
+					this.listenerId = 1;
+					if (this.resubOpts?.resubTimeoutMs) {
+						this.receivingData = true;
+						this.setTimeout();
+					}
+					resolve();
+				} else {
+					reject(err);
+				}
+			});
+		}).catch((reason) => {
+			console.error(reason);
+			throw reason;
+		});
+	}
+
+	override async unsubscribe(onResub = false): Promise<void> {
+		if (!onResub && this.resubOpts) {
+			this.resubOpts.resubTimeoutMs = undefined;
+		}
+		this.isUnsubscribing = true;
+		clearTimeout(this.timeoutId);
+		this.timeoutId = undefined;
+
+		if (this.listenerId != null) {
+			const promise = new Promise<void>((resolve, reject) => {
+				const request: SubscribeRequest = {
+					slots: {},
+					accounts: {},
+					transactions: {},
+					blocks: {},
+					blocksMeta: {},
+					accountsDataSlice: [],
+					entry: {},
+					transactionsStatus: {},
+				};
+				this.stream.write(request, (err) => {
+					if (err === null || err === undefined) {
+						this.listenerId = undefined;
+						this.isUnsubscribing = false;
+						resolve();
+					} else {
+						reject(err);
+					}
+				});
+			}).catch((reason) => {
+				console.error(reason);
+				throw reason;
+			});
+			return promise;
+		} else {
+			this.isUnsubscribing = false;
+		}
+	}
+}