@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -1,328 +0,0 @@
-import { Connection, PublicKey } from '@solana/web3.js';
-import {
-	DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS,
-	PriorityFeeMethod,
-	PriorityFeeStrategy,
-	PriorityFeeSubscriberConfig,
-} from './types';
-import { AverageOverSlotsStrategy } from './averageOverSlotsStrategy';
-import { MaxOverSlotsStrategy } from './maxOverSlotsStrategy';
-import { fetchSolanaPriorityFee } from './solanaPriorityFeeMethod';
-import {
-	HeliusPriorityFeeLevels,
-	HeliusPriorityLevel,
-	fetchHeliusPriorityFee,
-} from './heliusPriorityFeeMethod';
-import {
-	fetchVelocityPriorityFee,
-	VelocityMarketInfo,
-} from './velocityPriorityFeeMethod';
-
-/**
- * PriorityFeeSubscriber — polls one of three sources (Solana RPC, Helius, or
- * the Velocity-hosted priority fee cache — see `PriorityFeeMethod`) on an
- * interval and exposes several aggregations over the resulting samples: a
- * simple average, a max, and a caller-supplied `customStrategy`. All
- * `get*StrategyResult` accessors return `0` until the first successful poll,
- * and are clamped to `maxFeeMicroLamports` (if set) after applying
- * `priorityFeeMultiplier`. All returned fee values are in micro-lamports per
- * compute unit, the unit Solana's `ComputeBudgetProgram.setComputeUnitPrice`
- * expects.
- */
-export class PriorityFeeSubscriber {
-	connection?: Connection;
-	frequencyMs: number;
-	addresses: string[];
-	velocityMarkets?: VelocityMarketInfo[];
-	customStrategy?: PriorityFeeStrategy;
-	averageStrategy = new AverageOverSlotsStrategy();
-	maxStrategy = new MaxOverSlotsStrategy();
-	priorityFeeMethod = PriorityFeeMethod.SOLANA;
-	lookbackDistance: number;
-	maxFeeMicroLamports?: number;
-	priorityFeeMultiplier?: number;
-
-	velocityPriorityFeeEndpoint?: string;
-	heliusRpcUrl?: string;
-	lastHeliusSample?: HeliusPriorityFeeLevels;
-
-	intervalId?: ReturnType<typeof setTimeout>;
-
-	latestPriorityFee = 0;
-	lastCustomStrategyResult = 0;
-	lastAvgStrategyResult = 0;
-	lastMaxStrategyResult = 0;
-	lastSlotSeen = 0;
-
-	/**
-	 * @param config See `PriorityFeeSubscriberConfig`. Required fields depend on `priorityFeeMethod` (default `SOLANA`): SOLANA needs `connection`; HELIUS needs `heliusRpcUrl` or a Helius `connection`; VELOCITY needs `velocityPriorityFeeEndpoint`.
-	 * @throws If `priorityFeeMethod` is `HELIUS` without a resolvable Helius RPC URL, or `SOLANA` without a `connection`.
-	 */
-	public constructor(config: PriorityFeeSubscriberConfig) {
-		this.connection = config.connection;
-		this.frequencyMs =
-			config.frequencyMs ?? DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS;
-		this.addresses = config.addresses
-			? config.addresses.map((address) => address.toBase58())
-			: [];
-		this.velocityMarkets = config.velocityMarkets;
-
-		if (config.customStrategy) {
-			this.customStrategy = config.customStrategy;
-		} else {
-			this.customStrategy = this.averageStrategy;
-		}
-		this.lookbackDistance = config.slotsToCheck ?? 50;
-
-		if (config.priorityFeeMethod) {
-			this.priorityFeeMethod = config.priorityFeeMethod;
-
-			if (this.priorityFeeMethod === PriorityFeeMethod.HELIUS) {
-				if (config.heliusRpcUrl === undefined) {
-					if (this.connection?.rpcEndpoint.includes('helius')) {
-						this.heliusRpcUrl = this.connection.rpcEndpoint;
-					} else {
-						throw new Error(
-							'Connection must be helius, or heliusRpcUrl must be provided to use PriorityFeeMethod.HELIUS'
-						);
-					}
-				} else {
-					this.heliusRpcUrl = config.heliusRpcUrl;
-				}
-			} else if (this.priorityFeeMethod === PriorityFeeMethod.VELOCITY) {
-				this.velocityPriorityFeeEndpoint =
-					config.velocityPriorityFeeEndpoint ??
-					config.velocityPriorityFeeEndpoint;
-			}
-		}
-
-		if (this.priorityFeeMethod === PriorityFeeMethod.SOLANA) {
-			if (this.connection === undefined) {
-				throw new Error(
-					'connection must be provided to use SOLANA priority fee API'
-				);
-			}
-		}
-
-		this.maxFeeMicroLamports = config.maxFeeMicroLamports;
-		this.priorityFeeMultiplier = config.priorityFeeMultiplier ?? 1.0;
-	}
-
-	/** Starts polling at `frequencyMs` and performs one immediate `load()`. Idempotent while already subscribed. */
-	public async subscribe(): Promise<void> {
-		if (this.intervalId) {
-			return;
-		}
-
-		this.intervalId = setInterval(this.load.bind(this), this.frequencyMs); // we set the intervalId first, preventing a side effect of unsubscribing failing during the race condition where unsubscribes happens before subscribe is finished
-		await this.load();
-	}
-
-	private async loadForSolana(): Promise<void> {
-		if (this.connection === undefined) {
-			throw new Error(
-				'connection must be provided to use SOLANA priority fee API'
-			);
-		}
-		const samples = await fetchSolanaPriorityFee(
-			this.connection,
-			this.lookbackDistance,
-			this.addresses
-		);
-		if (samples === undefined) {
-			throw new Error('fetchSolanaPriorityFee returned no samples');
-		}
-		if (samples.length > 0) {
-			this.latestPriorityFee = samples[0].prioritizationFee;
-			this.lastSlotSeen = samples[0].slot;
-
-			this.lastAvgStrategyResult = this.averageStrategy.calculate(samples);
-			this.lastMaxStrategyResult = this.maxStrategy.calculate(samples);
-			if (this.customStrategy) {
-				this.lastCustomStrategyResult = this.customStrategy.calculate(samples);
-			}
-		}
-	}
-
-	private async loadForHelius(): Promise<void> {
-		if (this.heliusRpcUrl === undefined) {
-			throw new Error(
-				'heliusRpcUrl must be provided to use PriorityFeeMethod.HELIUS'
-			);
-		}
-		const sample = await fetchHeliusPriorityFee(
-			this.heliusRpcUrl,
-			this.lookbackDistance,
-			this.addresses
-		);
-		this.lastHeliusSample = sample?.result?.priorityFeeLevels ?? undefined;
-
-		if (sample !== undefined && this.lastHeliusSample) {
-			this.lastAvgStrategyResult =
-				this.lastHeliusSample[HeliusPriorityLevel.MEDIUM];
-			this.lastMaxStrategyResult =
-				this.lastHeliusSample[HeliusPriorityLevel.UNSAFE_MAX];
-			if (this.customStrategy) {
-				this.lastCustomStrategyResult = this.customStrategy.calculate(sample);
-			}
-		}
-	}
-
-	private async loadForVelocity(): Promise<void> {
-		if (!this.velocityMarkets) {
-			return;
-		}
-		if (this.velocityPriorityFeeEndpoint === undefined) {
-			throw new Error(
-				'velocityPriorityFeeEndpoint must be provided to use PriorityFeeMethod.VELOCITY'
-			);
-		}
-		const sample = await fetchVelocityPriorityFee(
-			this.velocityPriorityFeeEndpoint,
-			this.velocityMarkets.map((m) => m.marketType),
-			this.velocityMarkets.map((m) => m.marketIndex)
-		);
-		if (sample.length > 0) {
-			// The endpoint returns one fee-level set per requested market. Take the
-			// max level across markets so a transaction touching several markets is
-			// covered by the most expensive one. (Base indexed the array itself with
-			// a string enum key — `sample['medium']` — which yielded `undefined` and
-			// produced NaN strategy results; the missing per-element index is fixed
-			// here.)
-			this.lastAvgStrategyResult = Math.max(
-				...sample.map((s) => s[HeliusPriorityLevel.MEDIUM])
-			);
-			this.lastMaxStrategyResult = Math.max(
-				...sample.map((s) => s[HeliusPriorityLevel.UNSAFE_MAX])
-			);
-			if (this.customStrategy) {
-				// Custom strategies expect `{ slot, prioritizationFee }[]`; map each
-				// market's medium level into that shape so they aggregate real values
-				// instead of summing the absent `prioritizationFee` field (NaN).
-				this.lastCustomStrategyResult = this.customStrategy.calculate(
-					sample.map((s) => ({
-						slot: 0,
-						prioritizationFee: s[HeliusPriorityLevel.MEDIUM],
-					}))
-				);
-			}
-		}
-	}
-
-	/** @returns The current clamp on returned fee values (micro-lamports/CU), or `undefined` if unclamped. */
-	public getMaxPriorityFee(): number | undefined {
-		return this.maxFeeMicroLamports;
-	}
-
-	/** Updates the clamp applied to all `get*StrategyResult`/`getHeliusPriorityFeeLevel` results. Pass `undefined` to remove the clamp. */
-	public updateMaxPriorityFee(newMaxFee: number | undefined) {
-		this.maxFeeMicroLamports = newMaxFee;
-	}
-
-	/** @returns The multiplier applied to strategy results before clamping; defaults to `1.0`. */
-	public getPriorityFeeMultiplier(): number {
-		return this.priorityFeeMultiplier ?? 1.0;
-	}
-
-	/** Updates the multiplier applied to `getCustomStrategyResult`/`getAvgStrategyResult`/`getMaxStrategyResult` before clamping. */
-	public updatePriorityFeeMultiplier(newPriorityFeeMultiplier: number) {
-		this.priorityFeeMultiplier = newPriorityFeeMultiplier;
-	}
-
-	/** Swaps the `PriorityFeeStrategy` used to compute `getCustomStrategyResult`; takes effect on the next `load()`. */
-	public updateCustomStrategy(newStrategy: PriorityFeeStrategy) {
-		this.customStrategy = newStrategy;
-	}
-
-	/**
-	 * Only meaningful with `priorityFeeMethod: HELIUS`.
-	 * @param level Helius percentile level to read; defaults to `MEDIUM`.
-	 * @returns That level's fee (micro-lamports/CU) from the most recent Helius sample, clamped to `maxFeeMicroLamports` if set, or `0` if no sample has been loaded yet.
-	 */
-	public getHeliusPriorityFeeLevel(
-		level: HeliusPriorityLevel = HeliusPriorityLevel.MEDIUM
-	): number {
-		if (this.lastHeliusSample === undefined) {
-			return 0;
-		}
-		if (this.maxFeeMicroLamports !== undefined) {
-			return Math.min(this.maxFeeMicroLamports, this.lastHeliusSample[level]);
-		}
-		return this.lastHeliusSample[level];
-	}
-
-	/** @returns The configured `customStrategy`'s result from the most recent poll (micro-lamports/CU), scaled by `priorityFeeMultiplier` and clamped to `maxFeeMicroLamports` if set. `0` before the first successful `load()`. */
-	public getCustomStrategyResult(): number {
-		const result =
-			this.lastCustomStrategyResult * this.getPriorityFeeMultiplier();
-		if (this.maxFeeMicroLamports !== undefined) {
-			return Math.min(this.maxFeeMicroLamports, result);
-		}
-		return result;
-	}
-
-	/** @returns The average-over-samples fee from the most recent poll (micro-lamports/CU) — for HELIUS this is the MEDIUM level, for VELOCITY the max MEDIUM level across configured markets — scaled by `priorityFeeMultiplier` and clamped to `maxFeeMicroLamports` if set. `0` before the first successful `load()`. */
-	public getAvgStrategyResult(): number {
-		const result = this.lastAvgStrategyResult * this.getPriorityFeeMultiplier();
-		if (this.maxFeeMicroLamports !== undefined) {
-			return Math.min(this.maxFeeMicroLamports, result);
-		}
-		return result;
-	}
-
-	/** @returns The max-over-samples fee from the most recent poll (micro-lamports/CU) — for HELIUS this is the UNSAFE_MAX level, for VELOCITY the max UNSAFE_MAX level across configured markets — scaled by `priorityFeeMultiplier` and clamped to `maxFeeMicroLamports` if set. `0` before the first successful `load()`. */
-	public getMaxStrategyResult(): number {
-		const result = this.lastMaxStrategyResult * this.getPriorityFeeMultiplier();
-		if (this.maxFeeMicroLamports !== undefined) {
-			return Math.min(this.maxFeeMicroLamports, result);
-		}
-		return result;
-	}
-
-	/**
-	 * Fetches one round of samples from the configured `priorityFeeMethod`
-	 * and recomputes `latestPriorityFee`/`lastAvgStrategyResult`/
-	 * `lastMaxStrategyResult`/`lastCustomStrategyResult`. Errors are caught
-	 * and logged, not thrown, so a transient failure just leaves the previous
-	 * values in place until the next poll.
-	 */
-	public async load(): Promise<void> {
-		try {
-			if (this.priorityFeeMethod === PriorityFeeMethod.SOLANA) {
-				await this.loadForSolana();
-			} else if (this.priorityFeeMethod === PriorityFeeMethod.HELIUS) {
-				await this.loadForHelius();
-			} else if (this.priorityFeeMethod === PriorityFeeMethod.VELOCITY) {
-				await this.loadForVelocity();
-			} else {
-				throw new Error(`${this.priorityFeeMethod} load not implemented`);
-			}
-		} catch (err) {
-			const e = err as Error;
-			console.error(
-				`Error loading priority fee ${this.priorityFeeMethod}: ${e.message}\n${
-					e.stack ? e.stack : ''
-				}`
-			);
-			return;
-		}
-	}
-
-	/** Stops polling. */
-	public async unsubscribe(): Promise<void> {
-		if (this.intervalId) {
-			clearInterval(this.intervalId);
-			this.intervalId = undefined;
-		}
-	}
-
-	/** Replaces the set of write-locked addresses used for SOLANA/HELIUS fee sampling; takes effect on the next `load()`. */
-	public updateAddresses(addresses: PublicKey[]) {
-		this.addresses = addresses.map((k) => k.toBase58());
-	}
-
-	/** Replaces the set of markets queried when `priorityFeeMethod` is VELOCITY; takes effect on the next `load()`. */
-	public updateMarketTypeAndIndex(velocityMarkets: VelocityMarketInfo[]) {
-		this.velocityMarkets = velocityMarkets;
-	}
-}

package/src/priorityFee/priorityFeeSubscriberMap.ts

@@ -1,134 +0,0 @@
-import {
-	VelocityMarketInfo,
-	VelocityPriorityFeeLevels,
-	VelocityPriorityFeeResponse,
-	fetchVelocityPriorityFee,
-} from './velocityPriorityFeeMethod';
-import {
-	DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS,
-	PriorityFeeSubscriberMapConfig,
-} from './types';
-
-/**
- * PriorityFeeSubscriberMap — polls the Velocity-hosted `/batchPriorityFees`
- * endpoint for a fixed set of markets and caches the latest per-market fee
- * levels, keyed by market type and index. Unlike `PriorityFeeSubscriber`
- * (single aggregated result across `PriorityFeeMethod.VELOCITY` markets),
- * this exposes each market's fee levels independently via `getPriorityFees`.
- */
-export class PriorityFeeSubscriberMap {
-	frequencyMs: number;
-	intervalId?: ReturnType<typeof setTimeout>;
-
-	velocityMarkets?: VelocityMarketInfo[];
-	velocityPriorityFeeEndpoint: string;
-	feesMap: Map<string, Map<number, VelocityPriorityFeeLevels>>; // marketType -> marketIndex -> priority fee
-
-	/** @param config `frequencyMs` defaults to `DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS` (10s); `velocityPriorityFeeEndpoint` is required. */
-	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);
-		});
-	}
-
-	/** Performs an immediate `load()` and then polls at `frequencyMs`. Idempotent while already subscribed. */
-	public async subscribe(): Promise<void> {
-		if (this.intervalId) {
-			return;
-		}
-
-		await this.load();
-		this.intervalId = setInterval(this.load.bind(this), this.frequencyMs);
-	}
-
-	/** Stops polling. */
-	public async unsubscribe(): Promise<void> {
-		if (this.intervalId) {
-			clearInterval(this.intervalId);
-			this.intervalId = undefined;
-		}
-	}
-
-	/**
-	 * Fetches one batch of per-market fee levels from
-	 * `/batchPriorityFees` for all `velocityMarkets` and merges the results
-	 * into `feesMap`. No-ops if no markets are configured. Errors are caught
-	 * and logged, not thrown — `feesMap` is left at its previous state.
-	 */
-	public async load(): Promise<void> {
-		try {
-			if (!this.velocityMarkets || this.velocityMarkets.length === 0) {
-				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);
-		}
-	}
-
-	/** Replaces the set of markets to fetch fees for; takes effect on the next `load()`. */
-	public updateMarketTypeAndIndex(velocityMarkets: VelocityMarketInfo[]) {
-		this.velocityMarkets = velocityMarkets;
-	}
-
-	/**
-	 * @param marketType `'perp'` or `'spot'`.
-	 * @param marketIndex Market index within that market type.
-	 * @returns The most recently fetched fee-level set for that market, or `undefined` if never fetched (including before the first successful `load()`).
-	 */
-	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,46 +0,0 @@
-import { Connection } from '@solana/web3.js';
-
-/** One sample from Solana's `getRecentPrioritizationFees`. */
-export type SolanaPriorityFeeResponse = {
-	slot: number;
-	/** Priority fee paid, in micro-lamports per compute unit. */
-	prioritizationFee: number;
-};
-
-/**
- * Fetches recent prioritization fees for `addresses` via the Solana RPC
- * `getRecentPrioritizationFees` method, then filters to the most recent
- * `lookbackDistance` slots (relative to the newest returned slot, not the
- * current chain tip) and sorts descending by slot.
- * @param connection RPC connection.
- * @param lookbackDistance Number of slots back from the newest sample to retain.
- * @param addresses Account keys to scope the fee lookup to (accounts the transaction will write-lock).
- * @returns Filtered, slot-descending samples; `undefined` if the RPC returned zero results; an empty array if the RPC call itself threw (error is logged, not thrown).
- */
-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,82 +0,0 @@
-import { Connection, PublicKey } from '@solana/web3.js';
-import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
-import { HeliusPriorityFeeResponse } from './heliusPriorityFeeMethod';
-import {
-	VelocityMarketInfo,
-	VelocityPriorityFeeResponse,
-} from './velocityPriorityFeeMethod';
-
-/** Default poll interval (ms) for `PriorityFeeSubscriber`/`PriorityFeeSubscriberMap` when `frequencyMs` is not configured. */
-export const DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS = 10_000;
-
-/**
- * A pluggable priority-fee aggregation function. `PriorityFeeSubscriber`
- * calls `calculate` after each poll to derive `getCustomStrategyResult()`.
- * Built-in implementations: `AverageStrategy`/`AverageOverSlotsStrategy`,
- * `EwmaStrategy`, `MaxStrategy`/`MaxOverSlotsStrategy`.
- */
-export interface PriorityFeeStrategy {
-	// calculate the priority fee for a given set of samples.
-	// when samples is an array (SOLANA), expect it sorted in descending order (by slot)
-	/**
-	 * @param samples Fee samples from whichever `priorityFeeMethod` is active — `SolanaPriorityFeeResponse[]` for SOLANA (expected sorted descending by slot), a single `HeliusPriorityFeeResponse` for HELIUS, or `VelocityPriorityFeeResponse` for VELOCITY.
-	 * @returns A priority fee estimate in micro-lamports per compute unit.
-	 */
-	calculate(
-		samples:
-			| SolanaPriorityFeeResponse[]
-			| HeliusPriorityFeeResponse
-			| VelocityPriorityFeeResponse
-	): number;
-}
-
-/** Which upstream API `PriorityFeeSubscriber` queries for priority-fee samples. */
-export enum PriorityFeeMethod {
-	/** Solana RPC `getRecentPrioritizationFees`. Requires `connection`. */
-	SOLANA = 'solana',
-	/** Helius `getPriorityFeeEstimate`. Requires `heliusRpcUrl` or a Helius `connection`. */
-	HELIUS = 'helius',
-	/** Velocity-hosted priority fee cache, scoped by market. Requires `velocityPriorityFeeEndpoint` and `velocityMarkets`. */
-	VELOCITY = 'velocity',
-}
-
-/** Configuration for `PriorityFeeSubscriber`. Which fields are required depends on `priorityFeeMethod` — see `PriorityFeeMethod`. */
-export type PriorityFeeSubscriberConfig = {
-	/** RPC connection used for SOLANA sampling (and as a Helius URL source for HELIUS if `heliusRpcUrl` is omitted); optional only when `priorityFeeMethod` is `HELIUS` or `VELOCITY`. */
-	connection?: Connection;
-	/** Poll interval in milliseconds for `load()`; defaults to `DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS` (10s). */
-	frequencyMs?: number;
-	/** Account keys the transaction will write-lock; scopes SOLANA/HELIUS fee sampling to congestion on these accounts specifically. */
-	addresses?: PublicKey[];
-	/** Markets to query when `priorityFeeMethod` is `VELOCITY`; can also be supplied later via `updateMarketTypeAndIndex`. */
-	velocityMarkets?: VelocityMarketInfo[];
-	/** `PriorityFeeStrategy` backing `getCustomStrategyResult()`; defaults to `AverageOverSlotsStrategy`. */
-	customStrategy?: PriorityFeeStrategy;
-	/** Which upstream API to sample from; defaults to `PriorityFeeMethod.SOLANA`. */
-	priorityFeeMethod?: PriorityFeeMethod;
-	/** Number of recent slots to consider when computing fee estimates; defaults to 50. */
-	slotsToCheck?: number;
-	/** Helius RPC URL; required for `PriorityFeeMethod.HELIUS` unless `connection`'s endpoint already points at Helius. */
-	heliusRpcUrl?: string;
-	/** Base URL of the Velocity-hosted priority fee service; required for `PriorityFeeMethod.VELOCITY`. */
-	velocityPriorityFeeEndpoint?: string;
-	/** Upper bound (micro-lamports per compute unit) applied to every `get*StrategyResult`/`getHeliusPriorityFeeLevel` return value, after `priorityFeeMultiplier`. Unset (`undefined`) means no clamp. */
-	maxFeeMicroLamports?: number;
-	/** Multiplier applied to the raw strategy result before `maxFeeMicroLamports` clamping; defaults to `1.0`. */
-	priorityFeeMultiplier?: number;
-};
-
-/** Base config for `PriorityFeeSubscriberMap`, which only supports `PriorityFeeMethod.VELOCITY` (batched per-market fee lookups via `/batchPriorityFees`). */
-type PriorityFeeSubscriberMapConfigBase = {
-	/** Poll interval in milliseconds for `load()`; defaults to `DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS` (10s). */
-	frequencyMs?: number;
-	/** Markets to fetch fees for; can also be supplied later via `updateMarketTypeAndIndex`. */
-	velocityMarkets?: VelocityMarketInfo[];
-};
-
-/** Configuration for `PriorityFeeSubscriberMap`. */
-export type PriorityFeeSubscriberMapConfig =
-	PriorityFeeSubscriberMapConfigBase & {
-		/** Base URL of the Velocity-hosted priority fee service (queried via `/batchPriorityFees`). */
-		velocityPriorityFeeEndpoint: string;
-	};

package/src/priorityFee/velocityPriorityFeeMethod.ts

@@ -1,53 +0,0 @@
-import fetch from 'node-fetch';
-import { HeliusPriorityLevel } from './heliusPriorityFeeMethod';
-
-/** Identifies a market to fetch/track priority fees for. */
-export type VelocityMarketInfo = {
-	marketType: string;
-	marketIndex: number;
-};
-
-/** Per-percentile priority fee (micro-lamports/CU, same buckets as `HeliusPriorityLevel`) for one market, as returned by the Velocity priority fee endpoint. */
-export type VelocityPriorityFeeLevels = {
-	[key in HeliusPriorityLevel]: number;
-} & {
-	marketType: 'perp' | 'spot';
-	marketIndex: number;
-};
-
-/** One `VelocityPriorityFeeLevels` entry per requested market. */
-export type VelocityPriorityFeeResponse = VelocityPriorityFeeLevels[];
-
-/**
- * Fetches per-market priority fee levels from the Velocity-hosted
- * `/batchPriorityFees` endpoint.
- * @param url Base URL of the Velocity priority fee service.
- * @param marketTypes Market types to query, parallel-indexed to `marketIndexes` (e.g. `['perp', 'perp', 'spot']`).
- * @param marketIndexes Market indexes to query, parallel-indexed to `marketTypes`.
- * @returns One `VelocityPriorityFeeLevels` per requested market; an empty array if the request failed (error is logged, not thrown) or returned a non-OK HTTP status.
- */
-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';