@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/orderSubscriber/grpcSubscription.ts

@@ -1,155 +0,0 @@
-import { Context, PublicKey } from '@solana/web3.js';
-import { Buffer } from 'buffer';
-import { grpcProgramAccountSubscriber } from '../accounts/grpcProgramAccountSubscriber';
-import { OrderSubscriber } from './OrderSubscriber';
-import { GrpcConfigs, ResubOpts } from '../accounts/types';
-import { UserAccount } from '../types';
-import { getUserFilter, getNonIdleUserFilter } from '../memcmp';
-import { LaserstreamProgramAccountSubscriber } from '../accounts/laserProgramAccountSubscriber';
-
-/**
- * `OrderSubscriber` transport backed by a gRPC Geyser stream — either the
- * standard `grpcProgramAccountSubscriber` or, when `grpcConfigs.client ===
- * 'laser'`, `LaserstreamProgramAccountSubscriber` — filtered to non-idle
- * `User` accounts. Same initial-load/resync semantics as `WebsocketSubscription`.
- */
-export class grpcSubscription {
-	private orderSubscriber: OrderSubscriber;
-	private skipInitialLoad: boolean;
-	private resubOpts?: ResubOpts;
-	private resyncIntervalMs?: number;
-
-	private subscriber?:
-		| grpcProgramAccountSubscriber<UserAccount>
-		| LaserstreamProgramAccountSubscriber<UserAccount>;
-	private resyncTimeoutId?: ReturnType<typeof setTimeout>;
-
-	private decoded?: boolean;
-
-	private grpcConfigs: GrpcConfigs;
-
-	/**
-	 * @param grpcConfigs gRPC/Geyser endpoint config; `client: 'laser'` selects the Laserstream implementation, otherwise the standard gRPC subscriber is used.
-	 * @param orderSubscriber The `OrderSubscriber` to feed with updates.
-	 * @param skipInitialLoad Skip the initial full `fetch()` snapshot after subscribing; defaults to `false`.
-	 * @param resubOpts Reconnect behavior for the underlying gRPC subscriber.
-	 * @param resyncIntervalMs If set, runs a periodic full `fetch()` resync at this interval.
-	 * @param decoded Whether updates are delivered already Anchor-decoded (`true`, default) or as raw buffers for `OrderSubscriber` to decode itself.
-	 */
-	constructor({
-		grpcConfigs,
-		orderSubscriber,
-		skipInitialLoad = false,
-		resubOpts,
-		resyncIntervalMs,
-		decoded = true,
-	}: {
-		grpcConfigs: GrpcConfigs;
-		orderSubscriber: OrderSubscriber;
-		skipInitialLoad?: boolean;
-		resubOpts?: ResubOpts;
-		resyncIntervalMs?: number;
-		decoded?: boolean;
-	}) {
-		this.orderSubscriber = orderSubscriber;
-		this.skipInitialLoad = skipInitialLoad;
-		this.resubOpts = resubOpts;
-		this.resyncIntervalMs = resyncIntervalMs;
-		this.decoded = decoded;
-		this.grpcConfigs = grpcConfigs;
-	}
-
-	/** Establishes the gRPC/Laserstream program-account subscription (idempotent), optionally backfills with `fetch()`, and starts the resync timer if configured. */
-	public async subscribe(): Promise<void> {
-		if (this.subscriber) {
-			return;
-		}
-
-		if (this.grpcConfigs.client === 'laser') {
-			this.subscriber =
-				await LaserstreamProgramAccountSubscriber.create<UserAccount>(
-					this.grpcConfigs,
-					'OrderSubscriber',
-					'user',
-					this.orderSubscriber.velocityClient.program,
-					this.orderSubscriber.decodeFn,
-					{
-						filters: [getUserFilter(), getNonIdleUserFilter()],
-					},
-					this.resubOpts
-				);
-		} else {
-			this.subscriber = await grpcProgramAccountSubscriber.create<UserAccount>(
-				this.grpcConfigs,
-				'OrderSubscriber',
-				'user',
-				this.orderSubscriber.velocityClient.program,
-				this.orderSubscriber.decodeFn,
-				{
-					filters: [getUserFilter(), getNonIdleUserFilter()],
-				},
-				this.resubOpts
-			);
-		}
-
-		await this.subscriber.subscribe(
-			(
-				accountId: PublicKey,
-				account: UserAccount,
-				context: Context,
-				buffer: Buffer
-			) => {
-				const userKey = accountId.toBase58();
-				if (this.decoded ?? true) {
-					this.orderSubscriber.tryUpdateUserAccount(
-						userKey,
-						'decoded',
-						account,
-						context.slot
-					);
-				} else {
-					this.orderSubscriber.tryUpdateUserAccount(
-						userKey,
-						'buffer',
-						buffer,
-						context.slot
-					);
-				}
-			}
-		);
-
-		if (!this.skipInitialLoad) {
-			await this.orderSubscriber.fetch();
-		}
-
-		if (this.resyncIntervalMs) {
-			const recursiveResync = () => {
-				this.resyncTimeoutId = setTimeout(() => {
-					this.orderSubscriber
-						.fetch()
-						.catch((e) => {
-							console.error('Failed to resync in OrderSubscriber');
-							console.log(e);
-						})
-						.finally(() => {
-							// eslint-disable-next-line @typescript-eslint/no-unused-vars
-							if (!this.resyncTimeoutId) return;
-							recursiveResync();
-						});
-				}, this.resyncIntervalMs);
-			};
-			recursiveResync();
-		}
-	}
-
-	/** Tears down the gRPC subscription and cancels the resync timer, if any. No-op if not subscribed. */
-	public async unsubscribe(): Promise<void> {
-		if (!this.subscriber) return;
-		await this.subscriber.unsubscribe();
-		this.subscriber = undefined;
-		if (this.resyncTimeoutId !== undefined) {
-			clearTimeout(this.resyncTimeoutId);
-			this.resyncTimeoutId = undefined;
-		}
-	}
-}

package/src/orderSubscriber/index.ts

@@ -1,7 +0,0 @@
-/**
- * OrderSubscriber — streams all open orders across all users from on-chain state.
- * Used by keeper bots and the DLOB to maintain a live view of the full order book
- * without subscribing to every individual User account separately.
- */
-export * from './OrderSubscriber';
-export * from './types';

package/src/orderSubscriber/types.ts

@@ -1,64 +0,0 @@
-import { Commitment, PublicKey } from '@solana/web3.js';
-import { Order, UserAccount } from '../types';
-import { VelocityClient } from '../velocityClient';
-import { GrpcConfigs } from '../accounts/types';
-
-/** Configuration for `OrderSubscriber`. */
-export type OrderSubscriberConfig = {
-	velocityClient?: VelocityClient;
-	/** Selects the update transport: `'polling'` (interval `getProgramAccounts`), `'websocket'` (program-account subscription), or `'grpc'` (Geyser/Laserstream). `commitment` defaults to `'processed'` if unset; `skipInitialLoad` (websocket/grpc only) skips the initial `fetch()` full snapshot; `resubTimeoutMs`/`logResubMessages` control websocket/grpc reconnect behavior; `resyncIntervalMs` (websocket/grpc only) triggers a periodic full `fetch()` resync on top of the live subscription. */
-	subscriptionConfig:
-		| {
-				type: 'polling';
-				frequency: number;
-				commitment?: Commitment;
-		  }
-		| {
-				type: 'websocket';
-				skipInitialLoad?: boolean;
-				resubTimeoutMs?: number;
-				logResubMessages?: boolean;
-				resyncIntervalMs?: number;
-				commitment?: Commitment;
-		  }
-		| {
-				type: 'grpc';
-				grpcConfigs: GrpcConfigs;
-				skipInitialLoad?: boolean;
-				resubTimeoutMs?: number;
-				logResubMessages?: boolean;
-				resyncIntervalMs?: number;
-				commitment?: Commitment;
-		  };
-	/** Use the hand-written `decodeUser` fast-path decoder instead of the Anchor account coder. Defaults to `true`. */
-	fastDecode?: boolean;
-	/** For websocket/grpc transports, whether the subscriber's own subscription decodes accounts itself (`true`, default) or passes raw buffers for the caller to decode. */
-	decodeData?: boolean;
-	/** Widen the account filter from "has at least one order" to "any non-idle user", so idle-but-non-empty accounts are also tracked. Defaults to `false`. */
-	fetchAllNonIdleUsers?: boolean;
-};
-
-/** Events emitted on `OrderSubscriber.eventEmitter`. */
-export interface OrderSubscriberEvents {
-	/** Fired when a `User` account update introduces one or more orders newly placed in `(previousObservedSlot, slot]`. */
-	orderCreated: (
-		account: UserAccount,
-		updatedOrders: Order[],
-		pubkey: PublicKey,
-		slot: number,
-		dataType: 'raw' | 'decoded' | 'buffer'
-	) => void;
-	/** Fired whenever a `User` account update is accepted (i.e. not rejected by the staleness/slot check). */
-	userUpdated: (
-		account: UserAccount,
-		pubkey: PublicKey,
-		slot: number,
-		dataType: 'raw' | 'decoded' | 'buffer'
-	) => void;
-	/** Fired for every incoming update, even ones ultimately rejected as stale. */
-	updateReceived: (
-		pubkey: PublicKey,
-		slot: number,
-		dataType: 'raw' | 'decoded' | 'buffer'
-	) => void;
-}

package/src/priorityFee/averageOverSlotsStrategy.ts

@@ -1,17 +0,0 @@
-import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
-import { PriorityFeeStrategy } from './types';
-
-/** `PriorityFeeStrategy` that averages `prioritizationFee` across all samples in the lookback window. Returns `0` for an empty sample set. */
-export class AverageOverSlotsStrategy implements PriorityFeeStrategy {
-	calculate(samples: SolanaPriorityFeeResponse[]): number {
-		if (samples.length === 0) {
-			return 0;
-		}
-		let runningSumFees = 0;
-
-		for (let i = 0; i < samples.length; i++) {
-			runningSumFees += samples[i].prioritizationFee;
-		}
-		return runningSumFees / samples.length;
-	}
-}

package/src/priorityFee/averageStrategy.ts

@@ -1,13 +0,0 @@
-import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
-import { PriorityFeeStrategy } from './types';
-
-/** `PriorityFeeStrategy` that averages `prioritizationFee` across all samples. Unlike `AverageOverSlotsStrategy`, does not guard the empty-sample case — calling with `samples.length === 0` returns `NaN`. */
-export class AverageStrategy implements PriorityFeeStrategy {
-	calculate(samples: SolanaPriorityFeeResponse[]): number {
-		return (
-			samples.reduce((a, b) => {
-				return a + b.prioritizationFee;
-			}, 0) / samples.length
-		);
-	}
-}

package/src/priorityFee/ewmaStrategy.ts

@@ -1,51 +0,0 @@
-import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
-import { PriorityFeeStrategy } from './types';
-
-/**
- * `PriorityFeeStrategy` that computes an exponentially-weighted moving
- * average of `prioritizationFee` over slots, so more recent samples are
- * weighted more heavily and larger slot gaps decay the older sample's
- * influence faster.
- */
-class EwmaStrategy implements PriorityFeeStrategy {
-	private halfLife: number;
-
-	/**
-	 * @param halfLife The half life of the EWMA in slots. Default is 25 slots, approx 10 seconds.
-	 */
-	constructor(halfLife = 25) {
-		this.halfLife = halfLife;
-	}
-
-	// samples provided in desc slot order
-	/**
-	 * @param samples Fee samples sorted descending by slot (as returned by `fetchSolanaPriorityFee`). Reversed internally to process oldest-first.
-	 * @returns `0` for an empty sample set; the single sample's fee if only one is provided; otherwise the EWMA, decayed per-step by `1 - exp(ln(0.5) / halfLife * slotGap)`.
-	 */
-	calculate(samples: SolanaPriorityFeeResponse[]): number {
-		if (samples.length === 0) {
-			return 0;
-		}
-		if (samples.length === 1) {
-			return samples[0].prioritizationFee;
-		}
-
-		let ewma = 0;
-
-		const samplesReversed = samples.slice().reverse();
-		for (let i = 0; i < samplesReversed.length; i++) {
-			if (i === 0) {
-				ewma = samplesReversed[i].prioritizationFee;
-				continue;
-			}
-			const gap = samplesReversed[i].slot - samplesReversed[i - 1].slot;
-			const alpha = 1 - Math.exp((Math.log(0.5) / this.halfLife) * gap);
-
-			ewma = alpha * samplesReversed[i].prioritizationFee + (1 - alpha) * ewma;
-		}
-
-		return ewma;
-	}
-}
-
-export { EwmaStrategy };

package/src/priorityFee/heliusPriorityFeeMethod.ts

@@ -1,68 +0,0 @@
-import fetch from 'node-fetch';
-
-/** Percentile buckets returned by Helius's `getPriorityFeeEstimate` (`includeAllPriorityFeeLevels`). */
-export enum HeliusPriorityLevel {
-	MIN = 'min', // 25th percentile
-	LOW = 'low', // 25th percentile
-	MEDIUM = 'medium', // 50th percentile
-	HIGH = 'high', // 75th percentile
-	VERY_HIGH = 'veryHigh', // 95th percentile
-	UNSAFE_MAX = 'unsafeMax', // 100th percentile
-}
-
-/** Priority fee (micro-lamports/CU) at each `HeliusPriorityLevel` percentile. */
-export type HeliusPriorityFeeLevels = {
-	[key in HeliusPriorityLevel]: number;
-};
-
-/** Raw JSON-RPC response from Helius's `getPriorityFeeEstimate`. */
-export type HeliusPriorityFeeResponse = {
-	jsonrpc: string;
-	result: {
-		/** Single-value estimate; only populated when `includeAllPriorityFeeLevels` was not requested. */
-		priorityFeeEstimate?: number;
-		/** Per-percentile estimates; populated when `includeAllPriorityFeeLevels: true` is requested (as `fetchHeliusPriorityFee` does). */
-		priorityFeeLevels?: HeliusPriorityFeeLevels;
-	};
-	id: string;
-};
-
-/**
- * Fetches priority fee estimates from the Helius `getPriorityFeeEstimate` API
- * (https://docs.helius.dev/solana-rpc-nodes/alpha-priority-fee-api).
- * @param heliusRpcUrl Helius RPC URL to POST the `getPriorityFeeEstimate` request to.
- * @param lookbackDistance Number of recent slots to consider (`lookbackSlots` option).
- * @param addresses Account keys to scope the estimate to (accounts the transaction will write-lock).
- * @returns The full Helius response (with `includeAllPriorityFeeLevels: true`), or `undefined` if the request failed (error is logged, not thrown).
- */
-export async function fetchHeliusPriorityFee(
-	heliusRpcUrl: string,
-	lookbackDistance: number,
-	addresses: string[]
-): Promise<HeliusPriorityFeeResponse | undefined> {
-	try {
-		const response = await fetch(heliusRpcUrl, {
-			method: 'POST',
-			headers: { 'Content-Type': 'application/json' },
-			body: JSON.stringify({
-				jsonrpc: '2.0',
-				id: '1',
-				method: 'getPriorityFeeEstimate',
-				params: [
-					{
-						accountKeys: addresses,
-						options: {
-							includeAllPriorityFeeLevels: true,
-							lookbackSlots: lookbackDistance,
-						},
-					},
-				],
-			}),
-		});
-		return await response.json();
-	} catch (err) {
-		console.error(err);
-	}
-
-	return undefined;
-}

package/src/priorityFee/index.ts

@@ -1,16 +0,0 @@
-/**
- * Priority fee estimation strategies for Solana transactions.
- * Implementations: average, EWMA, max-over-slots, max. Injected via VelocityClientConfig.
- * Select a strategy based on congestion tolerance vs. cost sensitivity.
- */
-export * from './averageOverSlotsStrategy';
-export * from './averageStrategy';
-export * from './ewmaStrategy';
-export * from './maxOverSlotsStrategy';
-export * from './maxStrategy';
-export * from './priorityFeeSubscriber';
-export * from './priorityFeeSubscriberMap';
-export * from './solanaPriorityFeeMethod';
-export * from './heliusPriorityFeeMethod';
-export * from './velocityPriorityFeeMethod';
-export * from './types';

package/src/priorityFee/maxOverSlotsStrategy.ts

@@ -1,18 +0,0 @@
-import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
-import { PriorityFeeStrategy } from './types';
-
-/** `PriorityFeeStrategy` that takes the max `prioritizationFee` across all samples in the lookback window. Returns `0` for an empty sample set. */
-export class MaxOverSlotsStrategy implements PriorityFeeStrategy {
-	calculate(samples: SolanaPriorityFeeResponse[]): number {
-		if (samples.length === 0) {
-			return 0;
-		}
-		// Assuming samples are sorted in descending order of slot.
-		let currMaxFee = samples[0].prioritizationFee;
-
-		for (let i = 0; i < samples.length; i++) {
-			currMaxFee = Math.max(samples[i].prioritizationFee, currMaxFee);
-		}
-		return currMaxFee;
-	}
-}

package/src/priorityFee/maxStrategy.ts

@@ -1,8 +0,0 @@
-import { PriorityFeeStrategy } from './types';
-
-/** `PriorityFeeStrategy` that takes the max `prioritizationFee` across all samples. Unlike `MaxOverSlotsStrategy`, does not guard the empty-sample case — calling with an empty array returns `-Infinity`. */
-export class MaxStrategy implements PriorityFeeStrategy {
-	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
-		return Math.max(...samples.map((result) => result.prioritizationFee));
-	}
-}