@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/accounts/laserProgramAccountSubscriber.ts

@@ -1,266 +0,0 @@
-import { LaserGrpcConfigs, ResubOpts } from './types';
-import { Context, MemcmpFilter, PublicKey } from '@solana/web3.js';
-import { VelocityProgram } from '../config';
-import * as Buffer from 'buffer';
-import { WebSocketProgramAccountSubscriber } from './webSocketProgramAccountSubscriber';
-
-import {
-	LaserCommitmentLevel,
-	LaserstreamConfig,
-	LaserSubscribeRequest,
-	LaserSubscribeUpdate,
-	CommitmentLevel,
-	getLaserSubscribe,
-	getLaserCompressionAlgorithms,
-	getLaserCommitmentLevel,
-} from '../isomorphic/grpc';
-
-type LaserCommitment =
-	(typeof LaserCommitmentLevel)[keyof typeof LaserCommitmentLevel];
-
-/**
- * `ProgramAccountSubscriber` that streams every account owned by the program (optionally filtered
- * by `memcmp`) via Helius LaserStream instead of `connection.onProgramAccountChange`. Extends
- * `WebSocketProgramAccountSubscriber` to reuse its per-account buffering/decode/resub-timer logic
- * (`handleRpcResponse`, `bufferAndSlotMap`) — only the transport (`subscribe`/`unsubscribe`) is
- * replaced. Construct via the static `create` factory, not the constructor directly, since it
- * dynamically loads the optional `helius-laserstream` peer dependency and its enums.
- */
-export class LaserstreamProgramAccountSubscriber<
-	T,
-> extends WebSocketProgramAccountSubscriber<T> {
-	private stream:
-		| {
-				id: string;
-				cancel: () => void;
-				write?: (req: LaserSubscribeRequest) => Promise<void>;
-		  }
-		| undefined;
-
-	private commitmentLevel: CommitmentLevel;
-	public listenerId?: number;
-
-	private readonly laserConfig: LaserstreamConfig;
-	private readonly laserCommitmentLevel: typeof LaserCommitmentLevel;
-
-	private constructor(
-		laserConfig: LaserstreamConfig,
-		commitmentLevel: CommitmentLevel,
-		laserCommitmentLevel: typeof LaserCommitmentLevel,
-		subscriptionName: string,
-		accountDiscriminator: string,
-		program: VelocityProgram,
-		decodeBufferFn: (accountName: string, ix: Buffer) => T,
-		options: { filters: MemcmpFilter[] } = { filters: [] },
-		resubOpts?: ResubOpts
-	) {
-		super(
-			subscriptionName,
-			accountDiscriminator,
-			program,
-			decodeBufferFn,
-			options,
-			resubOpts
-		);
-		this.laserConfig = laserConfig;
-		this.laserCommitmentLevel = laserCommitmentLevel;
-		this.commitmentLevel = this.toLaserCommitment(commitmentLevel);
-	}
-
-	/**
-	 * Loads the optional `helius-laserstream` module, builds its `LaserstreamConfig` (forcing zstd
-	 * compression and a 1GB max receive message size), and constructs a
-	 * `LaserstreamProgramAccountSubscriber`. Does not itself start streaming — call
-	 * `subscribe(onChange)` on the result.
-	 * @param grpcConfigs LaserStream endpoint/token/commitment config; `enableReconnect` maps to up to 10 reconnect attempts (0 if unset).
-	 * @param subscriptionName Human-readable name for logging.
-	 * @param accountDiscriminator Anchor account type name passed to `decodeBufferFn` for each update.
-	 * @param program Anchor program whose accounts to stream (filtered to `program.programId` as owner).
-	 * @param decodeBufferFn Decode function for each account's raw buffer.
-	 * @param options `filters` (memcmp) narrowing which program accounts are streamed; empty streams every account owned by the program.
-	 * @param resubOpts Resubscription watchdog options; omit to disable the inactivity timer.
-	 */
-	public static async create<U>(
-		grpcConfigs: LaserGrpcConfigs,
-		subscriptionName: string,
-		accountDiscriminator: string,
-		program: VelocityProgram,
-		decodeBufferFn: (accountName: string, ix: Buffer) => U,
-		options: { filters: MemcmpFilter[] } = {
-			filters: [],
-		},
-		resubOpts?: ResubOpts
-	): Promise<LaserstreamProgramAccountSubscriber<U>> {
-		// Load enums from the optional helius-laserstream module
-		const [compressionAlgorithms, laserCommitmentLevel] = await Promise.all([
-			getLaserCompressionAlgorithms(),
-			getLaserCommitmentLevel(),
-		]);
-
-		const laserConfig: LaserstreamConfig = {
-			apiKey: grpcConfigs.token,
-			endpoint: grpcConfigs.endpoint,
-			maxReconnectAttempts: grpcConfigs.enableReconnect ? 10 : 0,
-			channelOptions: {
-				'grpc.default_compression_algorithm': compressionAlgorithms.zstd,
-				'grpc.max_receive_message_length': 1_000_000_000,
-			},
-		};
-
-		const commitmentLevel =
-			grpcConfigs.commitmentLevel ?? CommitmentLevel.CONFIRMED;
-
-		return new LaserstreamProgramAccountSubscriber<U>(
-			laserConfig,
-			commitmentLevel,
-			laserCommitmentLevel,
-			subscriptionName,
-			accountDiscriminator,
-			program,
-			decodeBufferFn,
-			options,
-			resubOpts
-		);
-	}
-
-	/**
-	 * Opens a LaserStream `accounts` subscription filtered to `program.programId` as owner
-	 * (further narrowed by the `filters` passed to `create`). Idempotent: a no-op if already
-	 * subscribed or mid-unsubscribe. Does not perform an initial fetch — the caller must fetch any
-	 * pre-existing matching accounts separately if needed. Throws if the LaserStream client fails
-	 * to start.
-	 * @param onChange Invoked once per changed account with its pubkey, decoded data, the notification's `Context` (slot only), and the raw buffer.
-	 */
-	async subscribe(
-		onChange: (
-			accountId: PublicKey,
-			data: T,
-			context: Context,
-			buffer: Buffer
-		) => void
-	): Promise<void> {
-		if (this.listenerId != null || this.isUnsubscribing) return;
-
-		this.onChange = onChange;
-
-		const filters = this.options.filters.map((filter) => {
-			return {
-				memcmp: {
-					offset: filter.memcmp.offset,
-					base58: filter.memcmp.bytes,
-				},
-			};
-		});
-
-		const request: LaserSubscribeRequest = {
-			slots: {},
-			accounts: {
-				velocity: {
-					account: [],
-					owner: [this.program.programId.toBase58()],
-					filters,
-				},
-			},
-			transactions: {},
-			blocks: {},
-			blocksMeta: {},
-			accountsDataSlice: [],
-			commitment: this.commitmentLevel,
-			entry: {},
-			transactionsStatus: {},
-		};
-
-		try {
-			// Dynamically load LaserSubscribe from the optional helius-laserstream module
-			const laserSubscribe = await getLaserSubscribe();
-
-			const stream = await laserSubscribe(
-				this.laserConfig,
-				request,
-				async (update: LaserSubscribeUpdate) => {
-					if (update.account) {
-						const slot = Number(update.account.slot);
-						const acc = update.account.account;
-						if (!acc) {
-							return;
-						}
-
-						const accountInfo = {
-							owner: new PublicKey(acc.owner),
-							lamports: Number(acc.lamports),
-							data: Buffer.Buffer.from(acc.data),
-							executable: acc.executable,
-							rentEpoch: Number(acc.rentEpoch),
-						};
-
-						const payload = {
-							accountId: new PublicKey(acc.pubkey),
-							accountInfo,
-						};
-
-						if (this.resubOpts?.resubTimeoutMs) {
-							this.receivingData = true;
-							clearTimeout(this.timeoutId);
-							this.handleRpcResponse({ slot }, payload);
-							this.setTimeout();
-						} else {
-							this.handleRpcResponse({ slot }, payload);
-						}
-					}
-				},
-				async (error) => {
-					console.error('LaserStream client error:', error);
-					throw error;
-				}
-			);
-
-			this.stream = stream;
-			this.listenerId = 1;
-
-			if (this.resubOpts?.resubTimeoutMs) {
-				this.receivingData = true;
-				this.setTimeout();
-			}
-		} catch (err) {
-			console.error('Failed to start LaserStream client:', err);
-			throw err;
-		}
-	}
-
-	/**
-	 * Cancels the LaserStream and clears any pending resub timeout.
-	 * @param onResub Internal flag set to `true` when called as part of an automatic resubscribe cycle, which preserves `resubOpts.resubTimeoutMs` instead of clearing it. Callers should omit this.
-	 */
-	public 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 && this.stream) {
-			try {
-				this.stream.cancel();
-			} finally {
-				this.listenerId = undefined;
-				this.isUnsubscribing = false;
-			}
-		} else {
-			this.isUnsubscribing = false;
-		}
-	}
-
-	/** Coerces a commitment level (string name, numeric enum value, or undefined) into a LaserStream `LaserCommitmentLevel`, defaulting to `CONFIRMED`. */
-	public toLaserCommitment(
-		level: string | number | undefined
-	): LaserCommitment {
-		if (typeof level === 'string') {
-			return (
-				(this.laserCommitmentLevel as any)[level.toUpperCase()] ??
-				this.laserCommitmentLevel.CONFIRMED
-			);
-		}
-		return (level as LaserCommitment) ?? this.laserCommitmentLevel.CONFIRMED;
-	}
-}

package/src/accounts/oneShotUserAccountSubscriber.ts

@@ -1,88 +0,0 @@
-import { Commitment, PublicKey } from '@solana/web3.js';
-import { UserAccount } from '../types';
-import { BasicUserAccountSubscriber } from './basicUserAccountSubscriber';
-import { UserAccountSubscriber } from './types';
-import { VelocityProgram } from '../config';
-
-/**
- * Simple implementation of UserAccountSubscriber. It will fetch the UserAccount
- * date on subscribe (or call to fetch) if no account data is provided on init.
- * Expect to use only 1 RPC call unless you call fetch repeatedly.
- */
-export class OneShotUserAccountSubscriber
-	extends BasicUserAccountSubscriber
-	implements UserAccountSubscriber
-{
-	program: VelocityProgram;
-	commitment: Commitment;
-
-	/**
-	 * @param program Anchor program used for the one-off `fetchAndContext` call.
-	 * @param userAccountPublicKey Address of the `UserAccount` to fetch.
-	 * @param data Optional pre-fetched account data to seed with, skipping the RPC call entirely.
-	 * @param slot Slot `data` was observed at, if provided.
-	 * @param commitment Commitment for the fetch; defaults to `'confirmed'`.
-	 */
-	public constructor(
-		program: VelocityProgram,
-		userAccountPublicKey: PublicKey,
-		data?: UserAccount,
-		slot?: number,
-		commitment?: Commitment
-	) {
-		super(userAccountPublicKey, data, slot);
-		this.program = program;
-		this.commitment = commitment ?? 'confirmed';
-	}
-
-	/**
-	 * If `userAccount` is supplied, seeds directly with no RPC call. Otherwise fetches once via
-	 * `fetchIfUnloaded()` if no data is cached yet. Always resolves `true` — there is no
-	 * persistent subscription to fail.
-	 * @param userAccount Optional pre-fetched account data to seed with instead of fetching.
-	 */
-	async subscribe(userAccount?: UserAccount): Promise<boolean> {
-		if (userAccount) {
-			this.user = { data: userAccount, slot: this.user?.slot ?? 0 };
-			return true;
-		}
-
-		await this.fetchIfUnloaded();
-		if (this.doesAccountExist()) {
-			this.eventEmitter.emit('update');
-		}
-		return true;
-	}
-
-	/** Fetches via `fetch()` only if no data is cached yet; otherwise a no-op. */
-	async fetchIfUnloaded(): Promise<void> {
-		if (!this.user) {
-			await this.fetch();
-		}
-	}
-
-	/**
-	 * Fetches the account once via `program.account.user.fetchAndContext`, applying it only if
-	 * the response's slot is newer than what's cached. Logs and swallows errors (e.g. account not
-	 * yet initialized) rather than throwing.
-	 */
-	async fetch(): Promise<void> {
-		try {
-			const dataAndContext = await (
-				this.program.account as any
-			).user.fetchAndContext(this.userAccountPublicKey, this.commitment);
-			if (dataAndContext.context.slot > (this.user?.slot ?? 0)) {
-				this.user = {
-					data: dataAndContext.data as UserAccount,
-					slot: dataAndContext.context.slot,
-				};
-			}
-		} catch (e) {
-			console.error(
-				`OneShotUserAccountSubscriber.fetch() UserAccount does not exist: ${
-					e instanceof Error ? e.message : String(e)
-				}`
-			);
-		}
-	}
-}

package/src/accounts/oneShotUserStatsAccountSubscriber.ts

@@ -1,94 +0,0 @@
-import { Commitment, PublicKey } from '@solana/web3.js';
-import { UserStatsAccount } from '../types';
-import { BasicUserStatsAccountSubscriber } from './basicUserStatsAccountSubscriber';
-import { UserStatsAccountSubscriber } from './types';
-import { VelocityProgram } from '../config';
-
-/**
- * Simple implementation of UserStatsAccountSubscriber. It will fetch the UserStatsAccount
- * data on subscribe (or call to fetch) if no account data is provided on init.
- * Expect to use only 1 RPC call unless you call fetch repeatedly.
- */
-export class OneShotUserStatsAccountSubscriber
-	extends BasicUserStatsAccountSubscriber
-	implements UserStatsAccountSubscriber
-{
-	program: VelocityProgram;
-	commitment: Commitment;
-
-	/**
-	 * @param program Anchor program used for the one-off `fetchAndContext` call.
-	 * @param userStatsAccountPublicKey Address of the `UserStatsAccount` to fetch.
-	 * @param data Optional pre-fetched account data to seed with, skipping the RPC call entirely.
-	 * @param slot Slot `data` was observed at, if provided.
-	 * @param commitment Commitment for the fetch; defaults to `'confirmed'`.
-	 */
-	public constructor(
-		program: VelocityProgram,
-		userStatsAccountPublicKey: PublicKey,
-		data?: UserStatsAccount,
-		slot?: number,
-		commitment?: Commitment
-	) {
-		super(userStatsAccountPublicKey, data, slot);
-		this.program = program;
-		this.commitment = commitment ?? 'confirmed';
-	}
-
-	/**
-	 * If `userStatsAccount` is supplied, seeds directly with no RPC call. Otherwise fetches once
-	 * via `fetchIfUnloaded()` if no data is cached yet. Always resolves `true` — there is no
-	 * persistent subscription to fail.
-	 * @param userStatsAccount Optional pre-fetched account data to seed with instead of fetching.
-	 */
-	async subscribe(userStatsAccount?: UserStatsAccount): Promise<boolean> {
-		if (userStatsAccount) {
-			this.userStats = {
-				data: userStatsAccount,
-				slot: this.userStats?.slot ?? 0,
-			};
-			return true;
-		}
-
-		await this.fetchIfUnloaded();
-		if (this.doesAccountExist()) {
-			this.eventEmitter.emit('update');
-		}
-		return true;
-	}
-
-	/** Fetches via `fetch()` only if no data is cached yet; otherwise a no-op. */
-	async fetchIfUnloaded(): Promise<void> {
-		if (!this.userStats) {
-			await this.fetch();
-		}
-	}
-
-	/**
-	 * Fetches the account once via `program.account.userStats.fetchAndContext`, applying it only
-	 * if the response's slot is newer than what's cached. Logs and swallows errors (e.g. account
-	 * not yet initialized) rather than throwing.
-	 */
-	async fetch(): Promise<void> {
-		try {
-			const dataAndContext = await (
-				this.program.account as any
-			).userStats.fetchAndContext(
-				this.userStatsAccountPublicKey,
-				this.commitment
-			);
-			if (dataAndContext.context.slot > (this.userStats?.slot ?? 0)) {
-				this.userStats = {
-					data: dataAndContext.data as unknown as UserStatsAccount,
-					slot: dataAndContext.context.slot,
-				};
-			}
-		} catch (e) {
-			console.error(
-				`OneShotUserStatsAccountSubscriber.fetch() UserStatsAccount does not exist: ${
-					e instanceof Error ? e.message : String(e)
-				}`
-			);
-		}
-	}
-}

package/src/accounts/pollingInsuranceFundStakeAccountSubscriber.ts

@@ -1,223 +0,0 @@
-import {
-	DataAndSlot,
-	NotSubscribedError,
-	InsuranceFundStakeAccountEvents,
-	InsuranceFundStakeAccountSubscriber,
-} from './types';
-import { VelocityProgram } from '../config';
-import StrictEventEmitter from 'strict-event-emitter-types';
-import { EventEmitter } from 'events';
-import { PublicKey } from '@solana/web3.js';
-import { BulkAccountLoader } from './bulkAccountLoader';
-import { InsuranceFundStake } from '../types';
-
-/**
- * `InsuranceFundStakeAccountSubscriber` backed by a shared `BulkAccountLoader` instead of a
- * dedicated WebSocket subscription, mirroring `PollingUserAccountSubscriber` for
- * `InsuranceFundStake` accounts.
- */
-export class PollingInsuranceFundStakeAccountSubscriber
-	implements InsuranceFundStakeAccountSubscriber
-{
-	isSubscribed: boolean;
-	program: VelocityProgram;
-	eventEmitter: StrictEventEmitter<
-		EventEmitter,
-		InsuranceFundStakeAccountEvents
-	>;
-	insuranceFundStakeAccountPublicKey: PublicKey;
-
-	accountLoader: BulkAccountLoader;
-	callbackId?: string;
-	errorCallbackId?: string;
-
-	insuranceFundStakeAccountAndSlot?: DataAndSlot<InsuranceFundStake>;
-
-	/**
-	 * @param program Anchor program used for the one-off `fetch()` fallback and account decoding.
-	 * @param publicKey Address of the `InsuranceFundStake` account to track.
-	 * @param accountLoader Shared `BulkAccountLoader` this subscriber registers its callback with.
-	 */
-	public constructor(
-		program: VelocityProgram,
-		publicKey: PublicKey,
-		accountLoader: BulkAccountLoader
-	) {
-		this.isSubscribed = false;
-		this.program = program;
-		this.insuranceFundStakeAccountPublicKey = publicKey;
-		this.accountLoader = accountLoader;
-		this.eventEmitter = new EventEmitter();
-	}
-
-	/**
-	 * Registers this account with the shared `BulkAccountLoader`. Note this does not wait for an
-	 * initial fetch to land before returning `isSubscribed = true`, unlike the analogous
-	 * `PollingUserAccountSubscriber.subscribe`; call `fetchIfUnloaded()` explicitly if data is
-	 * needed immediately. Idempotent: a no-op if already subscribed.
-	 * @param insuranceFundStake Optional pre-fetched account data to seed with (at slot 0) instead of an immediate fetch.
-	 */
-	async subscribe(insuranceFundStake?: InsuranceFundStake): Promise<boolean> {
-		if (this.isSubscribed) {
-			return true;
-		}
-
-		if (insuranceFundStake) {
-			this.insuranceFundStakeAccountAndSlot = {
-				data: insuranceFundStake,
-				slot: 0,
-			};
-		}
-
-		await this.addToAccountLoader();
-
-		if (this.doesAccountExist()) {
-			this.eventEmitter.emit('update');
-		}
-
-		this.isSubscribed = true;
-		return true;
-	}
-
-	/** Registers this account and an error callback with the `BulkAccountLoader`. A no-op if already registered. */
-	async addToAccountLoader(): Promise<void> {
-		if (this.callbackId) {
-			return;
-		}
-
-		this.callbackId = await this.accountLoader.addAccount(
-			this.insuranceFundStakeAccountPublicKey,
-			(buffer, slot: number) => {
-				if (!buffer) {
-					return;
-				}
-
-				if (
-					this.insuranceFundStakeAccountAndSlot &&
-					this.insuranceFundStakeAccountAndSlot.slot > slot
-				) {
-					return;
-				}
-
-				const account = this.program.coder.accounts.decode(
-					'insuranceFundStake',
-					buffer
-				);
-				this.insuranceFundStakeAccountAndSlot = { data: account, slot };
-				this.eventEmitter.emit('insuranceFundStakeAccountUpdate', account);
-				this.eventEmitter.emit('update');
-			}
-		);
-
-		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
-			this.eventEmitter.emit('error', error);
-		});
-	}
-
-	/** Fetches via `fetch()` only if no data is cached yet; otherwise a no-op. */
-	async fetchIfUnloaded(): Promise<void> {
-		if (!this.doesAccountExist()) {
-			await this.fetch();
-		}
-	}
-
-	/** Fetches the account once directly via `program.account.insuranceFundStake.fetchAndContext` (independent of the account loader's poll cycle), applying it only if the response's slot is newer than what's cached. Logs and swallows errors rather than throwing. */
-	async fetch(): Promise<void> {
-		try {
-			const dataAndContext = await (
-				this.program.account as any
-			).insuranceFundStake.fetchAndContext(
-				this.insuranceFundStakeAccountPublicKey,
-				this.accountLoader.commitment
-			);
-			if (
-				dataAndContext.context.slot >
-				(this.insuranceFundStakeAccountAndSlot?.slot ?? 0)
-			) {
-				this.insuranceFundStakeAccountAndSlot = {
-					data: dataAndContext.data as InsuranceFundStake,
-					slot: dataAndContext.context.slot,
-				};
-			}
-		} catch (e) {
-			console.log(
-				`PollingInsuranceFundStakeAccountSubscriber.fetch() InsuranceFundStake does not exist: ${
-					e instanceof Error ? e.message : String(e)
-				}`
-			);
-		}
-	}
-
-	/** Type predicate: true once `insuranceFundStakeAccountAndSlot` has loaded, narrowing it to non-undefined. */
-	doesAccountExist(): this is {
-		insuranceFundStakeAccountAndSlot: DataAndSlot<InsuranceFundStake>;
-	} {
-		return this.insuranceFundStakeAccountAndSlot !== undefined;
-	}
-
-	/** Unregisters this account (and its error callback) from the `BulkAccountLoader`. A no-op if not subscribed. */
-	async unsubscribe(): Promise<void> {
-		if (!this.isSubscribed) {
-			return;
-		}
-
-		this.accountLoader.removeAccount(
-			this.insuranceFundStakeAccountPublicKey,
-			this.callbackId
-		);
-		this.callbackId = undefined;
-
-		this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
-		this.errorCallbackId = undefined;
-
-		this.isSubscribed = false;
-	}
-
-	/** Throws `NotSubscribedError` if `subscribe()` has not been called. */
-	assertIsSubscribed(): void {
-		if (!this.isSubscribed) {
-			throw new NotSubscribedError(
-				'You must call `subscribe` before using this function'
-			);
-		}
-	}
-
-	/** Throws `NotSubscribedError` if not subscribed. Returns undefined only if subscribed but no data has loaded yet. */
-	public getInsuranceFundStakeAccountAndSlot():
-		| DataAndSlot<InsuranceFundStake>
-		| undefined {
-		this.assertIsSubscribed();
-		return this.insuranceFundStakeAccountAndSlot;
-	}
-
-	/** True once account data has been loaded, independent of `isSubscribed`. */
-	didSubscriptionSucceed(): boolean {
-		return !!this.insuranceFundStakeAccountAndSlot;
-	}
-
-	/**
-	 * Applies an externally-obtained account update if `slot` is newer than the currently cached
-	 * slot (strictly newer — unlike most other subscribers here, an equal slot is not accepted).
-	 * @param insuranceFundStake Decoded account data to apply.
-	 * @param slot Slot the data was observed at.
-	 */
-	public updateData(
-		insuranceFundStake: InsuranceFundStake,
-		slot: number
-	): void {
-		if (
-			!this.insuranceFundStakeAccountAndSlot ||
-			this.insuranceFundStakeAccountAndSlot.slot < slot
-		) {
-			this.insuranceFundStakeAccountAndSlot = {
-				data: insuranceFundStake,
-				slot,
-			};
-			this.eventEmitter.emit(
-				'insuranceFundStakeAccountUpdate',
-				insuranceFundStake
-			);
-			this.eventEmitter.emit('update');
-		}
-	}
-}