@velocity-exchange/sdk 0.3.0 → 0.6.0

package/src/priorityFee/priorityFeeSubscriberMap.ts

@@ -1,115 +0,0 @@
-import {
-	VelocityMarketInfo,
-	VelocityPriorityFeeLevels,
-	VelocityPriorityFeeResponse,
-	fetchVelocityPriorityFee,
-} from './velocityPriorityFeeMethod';
-import {
-	DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS,
-	PriorityFeeSubscriberMapConfig,
-} from './types';
-
-/**
- * takes advantage of /batchPriorityFees endpoint from Velocity hosted priority fee service
- */
-export class PriorityFeeSubscriberMap {
-	frequencyMs: number;
-	intervalId?: ReturnType<typeof setTimeout>;
-
-	velocityMarkets?: VelocityMarketInfo[];
-	velocityPriorityFeeEndpoint: string;
-	feesMap: Map<string, Map<number, VelocityPriorityFeeLevels>>; // marketType -> marketIndex -> priority fee
-
-	public constructor(config: PriorityFeeSubscriberMapConfig) {
-		this.frequencyMs =
-			config.frequencyMs ?? DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS;
-		// Type-system guarantees at least one of the two is supplied.
-		this.velocityPriorityFeeEndpoint = (config.velocityPriorityFeeEndpoint ??
-			config.velocityPriorityFeeEndpoint)!;
-		this.velocityMarkets = config.velocityMarkets;
-		this.feesMap = new Map<string, Map<number, VelocityPriorityFeeLevels>>();
-		this.feesMap.set('perp', new Map<number, VelocityPriorityFeeLevels>());
-		this.feesMap.set('spot', new Map<number, VelocityPriorityFeeLevels>());
-	}
-
-	private updateFeesMap(
-		velocityPriorityFeeResponse: VelocityPriorityFeeResponse
-	) {
-		velocityPriorityFeeResponse.forEach((fee: VelocityPriorityFeeLevels) => {
-			this.feesMap.get(fee.marketType)!.set(fee.marketIndex, fee);
-		});
-	}
-
-	public async subscribe(): Promise<void> {
-		if (this.intervalId) {
-			return;
-		}
-
-		await this.load();
-		this.intervalId = setInterval(this.load.bind(this), this.frequencyMs);
-	}
-
-	public async unsubscribe(): Promise<void> {
-		if (this.intervalId) {
-			clearInterval(this.intervalId);
-			this.intervalId = undefined;
-		}
-	}
-
-	public async load(): Promise<void> {
-		try {
-			if (!this.velocityMarkets) {
-				return;
-			}
-			const fees = await fetchVelocityPriorityFee(
-				this.velocityPriorityFeeEndpoint,
-				this.velocityMarkets.map((m) => m.marketType),
-				this.velocityMarkets.map((m) => m.marketIndex)
-			);
-			this.updateFeesMap(fees);
-		} catch (e) {
-			console.error('Error fetching priority fees', e);
-		}
-	}
-
-	public updateMarketTypeAndIndex(velocityMarkets: VelocityMarketInfo[]) {
-		this.velocityMarkets = velocityMarkets;
-	}
-
-	public getPriorityFees(
-		marketType: string,
-		marketIndex: number
-	): VelocityPriorityFeeLevels | undefined {
-		return this.feesMap.get(marketType)?.get(marketIndex);
-	}
-}
-
-/** Example usage:
-async function main() {
-    const velocityMarkets: VelocityMarketInfo[] = [
-        { marketType: 'perp', marketIndex: 0 },
-        { marketType: 'perp', marketIndex: 1 },
-        { marketType: 'spot', marketIndex: 2 }
-    ];
-
-    const subscriber = new PriorityFeeSubscriberMap({
-        velocityPriorityFeeEndpoint: 'https://dlob.velocity.trade',
-        frequencyMs: 5000,
-        velocityMarkets
-    });
-    await subscriber.subscribe();
-
-    for (let i = 0; i < 20; i++) {
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        velocityMarkets.forEach(market => {
-            const fees = subscriber.getPriorityFees(market.marketType, market.marketIndex);
-            console.log(`Priority fees for ${market.marketType} market ${market.marketIndex}:`, fees);
-        });
-    }
-
-
-    await subscriber.unsubscribe();
-}
-
-main().catch(console.error);
-*/

package/src/priorityFee/solanaPriorityFeeMethod.ts

@@ -1,34 +0,0 @@
-import { Connection } from '@solana/web3.js';
-
-export type SolanaPriorityFeeResponse = {
-	slot: number;
-	prioritizationFee: number;
-};
-
-export async function fetchSolanaPriorityFee(
-	connection: Connection,
-	lookbackDistance: number,
-	addresses: string[]
-): Promise<SolanaPriorityFeeResponse[] | undefined> {
-	try {
-		// @ts-ignore
-		const rpcJSONResponse: any = await connection._rpcRequest(
-			'getRecentPrioritizationFees',
-			[addresses]
-		);
-
-		const results: SolanaPriorityFeeResponse[] = rpcJSONResponse?.result;
-
-		if (!results.length) return;
-
-		// Sort and filter results based on the slot lookback setting
-		const descResults = results.sort((a, b) => b.slot - a.slot);
-		const cutoffSlot = descResults[0].slot - lookbackDistance;
-
-		return descResults.filter((result) => result.slot >= cutoffSlot);
-	} catch (err) {
-		console.error(err);
-	}
-
-	return [];
-}

package/src/priorityFee/types.ts

@@ -1,64 +0,0 @@
-import { Connection, PublicKey } from '@solana/web3.js';
-import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
-import { HeliusPriorityFeeResponse } from './heliusPriorityFeeMethod';
-import {
-	VelocityMarketInfo,
-	VelocityPriorityFeeResponse,
-} from './velocityPriorityFeeMethod';
-
-export const DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS = 10_000;
-
-export interface PriorityFeeStrategy {
-	// calculate the priority fee for a given set of samples.
-	// expect samples to be sorted in descending order (by slot)
-	calculate(
-		samples:
-			| SolanaPriorityFeeResponse[]
-			| HeliusPriorityFeeResponse
-			| VelocityPriorityFeeResponse
-	): number;
-}
-
-export enum PriorityFeeMethod {
-	SOLANA = 'solana',
-	HELIUS = 'helius',
-	VELOCITY = 'velocity',
-}
-
-export type PriorityFeeSubscriberConfig = {
-	/// rpc connection, optional if using priorityFeeMethod.HELIUS
-	connection?: Connection;
-	/// frequency to make RPC calls to update priority fee samples, in milliseconds
-	frequencyMs?: number;
-	/// addresses you plan to write lock, used to determine priority fees
-	addresses?: PublicKey[];
-	/// market type and index, optionally provide at initialization time if using priorityFeeMethod.VELOCITY
-	velocityMarkets?: VelocityMarketInfo[];
-	/// custom strategy to calculate priority fees, defaults to AVERAGE
-	customStrategy?: PriorityFeeStrategy;
-	/// method for fetching priority fee samples
-	priorityFeeMethod?: PriorityFeeMethod;
-	/// lookback window to determine priority fees, in slots.
-	slotsToCheck?: number;
-	/// url for helius rpc, required if using priorityFeeMethod.HELIUS
-	heliusRpcUrl?: string;
-	/// url for Velocity cached priority fee endpoint, required if using priorityFeeMethod.VELOCITY
-	velocityPriorityFeeEndpoint?: string;
-	/// clamp any returned priority fee value to this value.
-	maxFeeMicroLamports?: number;
-	/// multiplier applied to priority fee before maxFeeMicroLamports, defaults to 1.0
-	priorityFeeMultiplier?: number;
-};
-
-type PriorityFeeSubscriberMapConfigBase = {
-	/// frequency to make RPC calls to update priority fee samples, in milliseconds
-	frequencyMs?: number;
-	/// market type and associated market index to query
-	velocityMarkets?: VelocityMarketInfo[];
-};
-
-/// url for Velocity cached priority fee endpoint
-export type PriorityFeeSubscriberMapConfig =
-	PriorityFeeSubscriberMapConfigBase & {
-		velocityPriorityFeeEndpoint: string;
-	};

package/src/priorityFee/velocityPriorityFeeMethod.ts

@@ -1,42 +0,0 @@
-import fetch from 'node-fetch';
-import { HeliusPriorityLevel } from './heliusPriorityFeeMethod';
-
-export type VelocityMarketInfo = {
-	marketType: string;
-	marketIndex: number;
-};
-
-export type VelocityPriorityFeeLevels = {
-	[key in HeliusPriorityLevel]: number;
-} & {
-	marketType: 'perp' | 'spot';
-	marketIndex: number;
-};
-
-export type VelocityPriorityFeeResponse = VelocityPriorityFeeLevels[];
-
-export async function fetchVelocityPriorityFee(
-	url: string,
-	marketTypes: string[],
-	marketIndexes: number[]
-): Promise<VelocityPriorityFeeResponse> {
-	try {
-		const response = await fetch(
-			`${url}/batchPriorityFees?marketType=${marketTypes.join(
-				','
-			)}&marketIndex=${marketIndexes.join(',')}`
-		);
-		if (!response.ok) {
-			throw new Error(`HTTP error! status: ${response.status}`);
-		}
-		return await response.json();
-	} catch (err) {
-		if (err instanceof Error) {
-			console.error('Error fetching priority fees:', err.message);
-		} else {
-			console.error('Unknown error fetching priority fees:', err);
-		}
-	}
-
-	return [];
-}

package/src/pyth/constants.ts

@@ -1,9 +0,0 @@
-import { PublicKey } from '@solana/web3.js';
-
-export const DEFAULT_WORMHOLE_PROGRAM_ID = new PublicKey(
-	'HDwcJBJXjL9FpJ7UBsYBtaDjsBUhuLCUYoz3zr8SWWaQ'
-);
-
-export const DEFAULT_RECEIVER_PROGRAM_ID = new PublicKey(
-	'rec5EKMGg6MxZYaMdyBfgwp4d5rB9T1VQH5pJv5LtFJ'
-);

package/src/pyth/index.ts

@@ -1,15 +0,0 @@
-export {
-	type WormholeCoreBridgeSolana,
-	WORMHOLE_CORE_BRIDGE_SOLANA_IDL,
-	type PythSolanaReceiver,
-	type PriceUpdateAccount,
-} from './types';
-export {
-	DEFAULT_WORMHOLE_PROGRAM_ID,
-	DEFAULT_RECEIVER_PROGRAM_ID,
-} from './constants';
-export { getGuardianSetPda } from './utils';
-export {
-	PythLazerSubscriber,
-	type PythLazerPriceFeedArray,
-} from './pythLazerSubscriber';

package/src/pyth/pythLazerSubscriber.ts

@@ -1,365 +0,0 @@
-import {
-	Channel,
-	PriceFeedProperty,
-	PythLazerClient,
-} from '@pythnetwork/pyth-lazer-sdk';
-import { VelocityEnv } from '../config';
-import { PerpMarkets } from '../constants/perpMarkets';
-
-/**
- * Configuration for a group of Pyth Lazer price feeds.
- */
-export type PythLazerPriceFeedArray = {
-	/** Optional channel for update frequency (e.g., 'fixed_rate@200ms') */
-	channel?: Channel;
-	/** Array of Pyth Lazer price feed IDs to subscribe to */
-	priceFeedIds: number[];
-};
-
-type FeedSymbolInfo = {
-	name: string;
-	state: string;
-};
-
-/**
- * Manages subscriptions to Pyth Lazer price feeds and provides access to real-time price data.
- * Automatically filters out non-stable feeds and handles reconnection logic.
- */
-export class PythLazerSubscriber {
-	private static readonly SYMBOLS_API_URL =
-		'https://history.pyth-lazer.dourolabs.app/history/v1/symbols';
-	private symbolsCache: Map<number, FeedSymbolInfo> | null = null;
-	private pythLazerClient?: PythLazerClient;
-	feedIdChunkToPriceMessage: Map<string, string> = new Map();
-	feedIdToPrice: Map<number, number> = new Map();
-	feedIdHashToFeedIds: Map<string, number[]> = new Map();
-	subscriptionIdsToFeedIdsHash: Map<number, string> = new Map();
-	allSubscribedIds: number[] = [];
-
-	timeoutId?: NodeJS.Timeout;
-	receivingData = false;
-	isUnsubscribing = false;
-
-	marketIndextoPriceFeedIdChunk: Map<number, number[]> = new Map();
-	marketIndextoPriceFeedId: Map<number, number> = new Map();
-
-	private readonly feedProperties: PriceFeedProperty[];
-
-	/**
-	 * Creates a new PythLazerSubscriber instance.
-	 * @param endpoints - Array of WebSocket endpoint URLs for Pyth Lazer
-	 * @param token - Authentication token for Pyth Lazer API
-	 * @param priceFeedArrays - Array of price feed configurations to subscribe to
-	 * @param env - Velocity environment (mainnet-beta, devnet, etc.)
-	 * @param resubTimeoutMs - Milliseconds to wait before resubscribing on data timeout
-	 * @param sdkLogging - Whether to log Pyth SDK logs to the console. This is very noisy but could be useful for debugging.
-	 * @param feedProperties - Price feed properties to request. Must include both 'price' and 'exponent' (required for getPriceFromMarketIndex). Defaults to ['price', 'bestAskPrice', 'bestBidPrice', 'exponent']. Stored by copy so caller mutation does not affect this instance.
-	 */
-	constructor(
-		private endpoints: string[],
-		private token: string,
-		private priceFeedArrays: PythLazerPriceFeedArray[],
-		env: VelocityEnv = 'devnet',
-		private resubTimeoutMs: number = 2000,
-		private sdkLogging: boolean = false,
-		feedProperties: PriceFeedProperty[] = [
-			'price',
-			'bestAskPrice',
-			'bestBidPrice',
-			'exponent',
-			'feedUpdateTimestamp',
-		]
-	) {
-		this.feedProperties = [...feedProperties];
-		if (
-			!this.feedProperties.includes('price') ||
-			!this.feedProperties.includes('exponent')
-		) {
-			throw new Error(
-				"feedProperties must include both 'price' and 'exponent' for getPriceFromMarketIndex to work"
-			);
-		}
-		const markets = PerpMarkets[env].filter(
-			(market) => market.pythLazerId !== undefined
-		);
-
-		this.allSubscribedIds = this.priceFeedArrays
-			.map((array) => array.priceFeedIds)
-			.flat();
-
-		for (const priceFeedIds of priceFeedArrays) {
-			const filteredMarkets = markets.filter((market) =>
-				priceFeedIds.priceFeedIds.includes(market.pythLazerId!)
-			);
-			for (const market of filteredMarkets) {
-				this.marketIndextoPriceFeedIdChunk.set(
-					market.marketIndex,
-					priceFeedIds.priceFeedIds
-				);
-				this.marketIndextoPriceFeedId.set(
-					market.marketIndex,
-					market.pythLazerId!
-				);
-			}
-		}
-	}
-
-	private async fetchSymbolsIfNeeded(): Promise<void> {
-		if (this.symbolsCache !== null) return;
-
-		try {
-			const response = await fetch(PythLazerSubscriber.SYMBOLS_API_URL);
-			if (!response.ok) throw new Error(`HTTP ${response.status}`);
-			const symbols = await response.json();
-
-			this.symbolsCache = new Map();
-			for (const symbol of symbols) {
-				this.symbolsCache.set(symbol.pyth_lazer_id, {
-					name: symbol.name,
-					state: symbol.state,
-				});
-			}
-		} catch (error) {
-			console.warn(
-				`Failed to fetch Pyth Lazer symbols, proceeding with all feeds: ${error}`
-			);
-			this.symbolsCache = new Map(); // Empty map = no filtering
-		}
-	}
-
-	private filterStableFeeds(feedIds: number[]): number[] {
-		if (this.symbolsCache === null || this.symbolsCache.size === 0) {
-			return feedIds; // No filtering if cache unavailable
-		}
-
-		return feedIds.filter((feedId) => {
-			const info = this.symbolsCache!.get(feedId);
-			if (!info) {
-				console.warn(
-					`Feed ID ${feedId} not found in symbols API, including anyway`
-				);
-				return true;
-			}
-			if (info.state !== 'stable') {
-				console.warn(
-					`Removing feed ID ${feedId} (${info.name}) - state is "${info.state}", not "stable"`
-				);
-				return false;
-			}
-			return true;
-		});
-	}
-
-	/**
-	 * Subscribes to Pyth Lazer price feeds. Automatically filters out non-stable feeds
-	 * and establishes WebSocket connections for real-time price updates.
-	 */
-	async subscribe() {
-		await this.fetchSymbolsIfNeeded();
-
-		this.pythLazerClient = await PythLazerClient.create({
-			token: this.token,
-			logger: this.sdkLogging ? console : undefined,
-			webSocketPoolConfig: {
-				urls: this.endpoints,
-				numConnections: 4, // Optionally specify number of parallel redundant connections to reduce the chance of dropped messages. The connections will round-robin across the provided URLs. Default is 4.
-				onError: (error) => {
-					console.error('⛔️ PythLazerClient error:', error.message);
-				},
-				onWebSocketError: (error) => {
-					console.error('⛔️ WebSocket error:', error.message);
-				},
-				onWebSocketPoolError: (error) => {
-					console.error('⛔️ WebSocket pool error:', error.message);
-				},
-				// Optional configuration for resilient WebSocket connections
-				rwsConfig: {
-					heartbeatTimeoutDurationMs: 5000, // Optional heartbeat timeout duration in milliseconds
-					maxRetryDelayMs: 1000, // Optional maximum retry delay in milliseconds
-					logAfterRetryCount: 10, // Optional log after how many retries
-				},
-			},
-		});
-		// Reset allSubscribedIds to rebuild with only stable feeds
-		this.allSubscribedIds = [];
-
-		let subscriptionId = 1;
-		for (const priceFeedArray of this.priceFeedArrays) {
-			const filteredFeedIds = this.filterStableFeeds(
-				priceFeedArray.priceFeedIds
-			);
-
-			if (filteredFeedIds.length === 0) {
-				console.warn(
-					`All feeds filtered out for subscription ${subscriptionId}, skipping`
-				);
-				continue;
-			}
-
-			// Update allSubscribedIds with only stable feeds
-			this.allSubscribedIds.push(...filteredFeedIds);
-
-			const feedIdsHash = this.hash(filteredFeedIds);
-			this.feedIdHashToFeedIds.set(feedIdsHash, filteredFeedIds);
-			this.subscriptionIdsToFeedIdsHash.set(subscriptionId, feedIdsHash);
-
-			// Update marketIndextoPriceFeedIdChunk to use filtered feeds
-			for (const [
-				marketIndex,
-				chunk,
-			] of this.marketIndextoPriceFeedIdChunk.entries()) {
-				if (this.hash(chunk) === this.hash(priceFeedArray.priceFeedIds)) {
-					this.marketIndextoPriceFeedIdChunk.set(marketIndex, filteredFeedIds);
-				}
-			}
-
-			// Remove entries from marketIndextoPriceFeedId for filtered-out feeds
-			for (const [
-				marketIndex,
-				feedId,
-			] of this.marketIndextoPriceFeedId.entries()) {
-				if (
-					!filteredFeedIds.includes(feedId) &&
-					priceFeedArray.priceFeedIds.includes(feedId)
-				) {
-					this.marketIndextoPriceFeedId.delete(marketIndex);
-					this.marketIndextoPriceFeedIdChunk.delete(marketIndex);
-				}
-			}
-
-			this.pythLazerClient.addMessageListener((message) => {
-				this.receivingData = true;
-				clearTimeout(this.timeoutId);
-				switch (message.type) {
-					case 'json': {
-						if (message.value.type == 'streamUpdated') {
-							if (message.value.solana?.data) {
-								this.feedIdChunkToPriceMessage.set(
-									this.subscriptionIdsToFeedIdsHash.get(
-										message.value.subscriptionId
-									)!,
-									message.value.solana.data
-								);
-							}
-							if (message.value.parsed?.priceFeeds) {
-								for (const priceFeed of message.value.parsed.priceFeeds) {
-									const price =
-										Number(priceFeed.price!) *
-										Math.pow(10, Number(priceFeed.exponent!));
-									this.feedIdToPrice.set(priceFeed.priceFeedId, price);
-								}
-							}
-						}
-						break;
-					}
-					default: {
-						break;
-					}
-				}
-				this.setTimeout();
-			});
-
-			this.pythLazerClient.send({
-				type: 'subscribe',
-				subscriptionId,
-				priceFeedIds: filteredFeedIds,
-				properties: this.feedProperties,
-				formats: ['solana'],
-				deliveryFormat: 'json',
-				channel: priceFeedArray.channel ?? ('fixed_rate@200ms' as Channel),
-				jsonBinaryEncoding: 'hex',
-			});
-			subscriptionId++;
-		}
-
-		this.receivingData = true;
-		this.setTimeout();
-	}
-
-	protected setTimeout(): void {
-		this.timeoutId = setTimeout(async () => {
-			if (this.isUnsubscribing) {
-				// If we are in the process of unsubscribing, do not attempt to resubscribe
-				return;
-			}
-
-			if (this.receivingData) {
-				console.log(`No ws data from pyth lazer client resubscribing`);
-				await this.unsubscribe();
-				this.receivingData = false;
-				await this.subscribe();
-			}
-		}, this.resubTimeoutMs);
-	}
-
-	/**
-	 * Unsubscribes from all Pyth Lazer price feeds and closes WebSocket connections.
-	 */
-	async unsubscribe() {
-		this.isUnsubscribing = true;
-		this.pythLazerClient?.shutdown();
-		this.pythLazerClient = undefined;
-		clearTimeout(this.timeoutId);
-		this.timeoutId = undefined;
-		this.isUnsubscribing = false;
-	}
-
-	hash(arr: number[]): string {
-		return 'h:' + arr.join('|');
-	}
-
-	/**
-	 * Retrieves the latest Solana-format price message for a group of feed IDs.
-	 * @param feedIds - Array of price feed IDs
-	 * @returns Hex-encoded price message data, or undefined if not available
-	 */
-	async getLatestPriceMessage(feedIds: number[]): Promise<string | undefined> {
-		return this.feedIdChunkToPriceMessage.get(this.hash(feedIds));
-	}
-
-	/**
-	 * Retrieves the latest Solana-format price message for a specific market.
-	 * @param marketIndex - The market index to get price data for
-	 * @returns Hex-encoded price message data, or undefined if not found
-	 */
-	async getLatestPriceMessageForMarketIndex(
-		marketIndex: number
-	): Promise<string | undefined> {
-		const feedIds = this.marketIndextoPriceFeedIdChunk.get(marketIndex);
-		if (!feedIds) {
-			return undefined;
-		}
-		return await this.getLatestPriceMessage(feedIds);
-	}
-
-	/**
-	 * Gets the array of price feed IDs associated with a market index.
-	 * @param marketIndex - The market index to look up
-	 * @returns Array of price feed IDs, or empty array if not found
-	 */
-	getPriceFeedIdsFromMarketIndex(marketIndex: number): number[] {
-		return this.marketIndextoPriceFeedIdChunk.get(marketIndex) || [];
-	}
-
-	/**
-	 * Gets the array of price feed IDs from a subscription hash.
-	 * @param hash - The subscription hash
-	 * @returns Array of price feed IDs, or empty array if not found
-	 */
-	getPriceFeedIdsFromHash(hash: string): number[] {
-		return this.feedIdHashToFeedIds.get(hash) || [];
-	}
-
-	/**
-	 * Gets the current parsed price for a specific market index.
-	 * @param marketIndex - The market index to get the price for
-	 * @returns The price as a number, or undefined if not available
-	 */
-	getPriceFromMarketIndex(marketIndex: number): number | undefined {
-		const feedId = this.marketIndextoPriceFeedId.get(marketIndex);
-		if (feedId === undefined) {
-			return undefined;
-		}
-		return this.feedIdToPrice.get(feedId);
-	}
-}