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

package/src/priorityFee/heliusPriorityFeeMethod.ts

@@ -0,0 +1,57 @@
+import fetch from 'node-fetch';
+
+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
+}
+
+export type HeliusPriorityFeeLevels = {
+	[key in HeliusPriorityLevel]: number;
+};
+
+export type HeliusPriorityFeeResponse = {
+	jsonrpc: string;
+	result: {
+		priorityFeeEstimate?: number;
+		priorityFeeLevels?: HeliusPriorityFeeLevels;
+	};
+	id: string;
+};
+
+/// Fetches the priority fee from the Helius API
+/// https://docs.helius.dev/solana-rpc-nodes/alpha-priority-fee-api
+export async function fetchHeliusPriorityFee(
+	heliusRpcUrl: string,
+	lookbackDistance: number,
+	addresses: string[]
+): Promise<HeliusPriorityFeeResponse> {
+	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

@@ -0,0 +1,11 @@
+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 './driftPriorityFeeMethod';
+export * from './types';

package/src/priorityFee/maxOverSlotsStrategy.ts

@@ -0,0 +1,17 @@
+import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
+import { PriorityFeeStrategy } from './types';
+
+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

@@ -0,0 +1,7 @@
+import { PriorityFeeStrategy } from './types';
+
+export class MaxStrategy implements PriorityFeeStrategy {
+	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
+		return Math.max(...samples.map((result) => result.prioritizationFee));
+	}
+}

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -0,0 +1,251 @@
+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 {
+	fetchDriftPriorityFee,
+	DriftMarketInfo,
+} from './driftPriorityFeeMethod';
+
+export class PriorityFeeSubscriber {
+	connection: Connection;
+	frequencyMs: number;
+	addresses: string[];
+	driftMarkets?: DriftMarketInfo[];
+	customStrategy?: PriorityFeeStrategy;
+	averageStrategy = new AverageOverSlotsStrategy();
+	maxStrategy = new MaxOverSlotsStrategy();
+	priorityFeeMethod = PriorityFeeMethod.SOLANA;
+	lookbackDistance: number;
+	maxFeeMicroLamports?: number;
+	priorityFeeMultiplier?: number;
+
+	driftPriorityFeeEndpoint?: string;
+	heliusRpcUrl?: string;
+	lastHeliusSample?: HeliusPriorityFeeLevels;
+
+	intervalId?: ReturnType<typeof setTimeout>;
+
+	latestPriorityFee = 0;
+	lastCustomStrategyResult = 0;
+	lastAvgStrategyResult = 0;
+	lastMaxStrategyResult = 0;
+	lastSlotSeen = 0;
+
+	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.driftMarkets = config.driftMarkets;
+
+		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.DRIFT) {
+				this.driftPriorityFeeEndpoint = config.driftPriorityFeeEndpoint;
+			}
+		}
+
+		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;
+	}
+
+	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> {
+		const samples = await fetchSolanaPriorityFee(
+			this.connection!,
+			this.lookbackDistance,
+			this.addresses
+		);
+		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> {
+		const sample = await fetchHeliusPriorityFee(
+			this.heliusRpcUrl,
+			this.lookbackDistance,
+			this.addresses
+		);
+		this.lastHeliusSample = sample?.result?.priorityFeeLevels ?? undefined;
+
+		if (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 loadForDrift(): Promise<void> {
+		if (!this.driftMarkets) {
+			return;
+		}
+		const sample = await fetchDriftPriorityFee(
+			this.driftPriorityFeeEndpoint!,
+			this.driftMarkets.map((m) => m.marketType),
+			this.driftMarkets.map((m) => m.marketIndex)
+		);
+		if (sample.length > 0) {
+			this.lastAvgStrategyResult = sample[HeliusPriorityLevel.MEDIUM];
+			this.lastMaxStrategyResult = sample[HeliusPriorityLevel.UNSAFE_MAX];
+			if (this.customStrategy) {
+				this.lastCustomStrategyResult = this.customStrategy.calculate(sample);
+			}
+		}
+	}
+
+	public getMaxPriorityFee(): number | undefined {
+		return this.maxFeeMicroLamports;
+	}
+
+	public updateMaxPriorityFee(newMaxFee: number | undefined) {
+		this.maxFeeMicroLamports = newMaxFee;
+	}
+
+	public getPriorityFeeMultiplier(): number {
+		return this.priorityFeeMultiplier ?? 1.0;
+	}
+
+	public updatePriorityFeeMultiplier(newPriorityFeeMultiplier: number) {
+		this.priorityFeeMultiplier = newPriorityFeeMultiplier;
+	}
+
+	public updateCustomStrategy(newStrategy: PriorityFeeStrategy) {
+		this.customStrategy = newStrategy;
+	}
+
+	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];
+	}
+
+	public getCustomStrategyResult(): number {
+		const result =
+			this.lastCustomStrategyResult * this.getPriorityFeeMultiplier();
+		if (this.maxFeeMicroLamports !== undefined) {
+			return Math.min(this.maxFeeMicroLamports, result);
+		}
+		return result;
+	}
+
+	public getAvgStrategyResult(): number {
+		const result = this.lastAvgStrategyResult * this.getPriorityFeeMultiplier();
+		if (this.maxFeeMicroLamports !== undefined) {
+			return Math.min(this.maxFeeMicroLamports, result);
+		}
+		return result;
+	}
+
+	public getMaxStrategyResult(): number {
+		const result = this.lastMaxStrategyResult * this.getPriorityFeeMultiplier();
+		if (this.maxFeeMicroLamports !== undefined) {
+			return Math.min(this.maxFeeMicroLamports, result);
+		}
+		return result;
+	}
+
+	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.DRIFT) {
+				await this.loadForDrift();
+			} 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;
+		}
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+	}
+
+	public updateAddresses(addresses: PublicKey[]) {
+		this.addresses = addresses.map((k) => k.toBase58());
+	}
+
+	public updateMarketTypeAndIndex(driftMarkets: DriftMarketInfo[]) {
+		this.driftMarkets = driftMarkets;
+	}
+}

package/src/priorityFee/priorityFeeSubscriberMap.ts

@@ -0,0 +1,112 @@
+import {
+	DriftMarketInfo,
+	DriftPriorityFeeLevels,
+	DriftPriorityFeeResponse,
+	fetchDriftPriorityFee,
+} from './driftPriorityFeeMethod';
+import {
+	DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS,
+	PriorityFeeSubscriberMapConfig,
+} from './types';
+
+/**
+ * takes advantage of /batchPriorityFees endpoint from drift hosted priority fee service
+ */
+export class PriorityFeeSubscriberMap {
+	frequencyMs: number;
+	intervalId?: ReturnType<typeof setTimeout>;
+
+	driftMarkets?: DriftMarketInfo[];
+	driftPriorityFeeEndpoint?: string;
+	feesMap: Map<string, Map<number, DriftPriorityFeeLevels>>; // marketType -> marketIndex -> priority fee
+
+	public constructor(config: PriorityFeeSubscriberMapConfig) {
+		this.frequencyMs = config.frequencyMs;
+		this.frequencyMs =
+			config.frequencyMs ?? DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS;
+		this.driftPriorityFeeEndpoint = config.driftPriorityFeeEndpoint;
+		this.driftMarkets = config.driftMarkets;
+		this.feesMap = new Map<string, Map<number, DriftPriorityFeeLevels>>();
+		this.feesMap.set('perp', new Map<number, DriftPriorityFeeLevels>());
+		this.feesMap.set('spot', new Map<number, DriftPriorityFeeLevels>());
+	}
+
+	private updateFeesMap(driftPriorityFeeResponse: DriftPriorityFeeResponse) {
+		driftPriorityFeeResponse.forEach((fee: DriftPriorityFeeLevels) => {
+			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.driftMarkets) {
+				return;
+			}
+			const fees = await fetchDriftPriorityFee(
+				this.driftPriorityFeeEndpoint!,
+				this.driftMarkets.map((m) => m.marketType),
+				this.driftMarkets.map((m) => m.marketIndex)
+			);
+			this.updateFeesMap(fees);
+		} catch (e) {
+			console.error('Error fetching drift priority fees', e);
+		}
+	}
+
+	public updateMarketTypeAndIndex(driftMarkets: DriftMarketInfo[]) {
+		this.driftMarkets = driftMarkets;
+	}
+
+	public getPriorityFees(
+		marketType: string,
+		marketIndex: number
+	): DriftPriorityFeeLevels | undefined {
+		return this.feesMap.get(marketType)?.get(marketIndex);
+	}
+}
+
+/** Example usage:
+async function main() {
+    const driftMarkets: DriftMarketInfo[] = [
+        { marketType: 'perp', marketIndex: 0 },
+        { marketType: 'perp', marketIndex: 1 },
+        { marketType: 'spot', marketIndex: 2 }
+    ];
+
+    const subscriber = new PriorityFeeSubscriberMap({
+        driftPriorityFeeEndpoint: 'https://dlob.drift.trade',
+        frequencyMs: 5000,
+        driftMarkets
+    });
+    await subscriber.subscribe();
+
+    for (let i = 0; i < 20; i++) {
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        driftMarkets.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

@@ -0,0 +1,34 @@
+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[]> {
+	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

@@ -0,0 +1,60 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
+import { HeliusPriorityFeeResponse } from './heliusPriorityFeeMethod';
+import {
+	DriftMarketInfo,
+	DriftPriorityFeeResponse,
+} from './driftPriorityFeeMethod';
+
+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
+			| DriftPriorityFeeResponse
+	): number;
+}
+
+export enum PriorityFeeMethod {
+	SOLANA = 'solana',
+	HELIUS = 'helius',
+	DRIFT = 'drift',
+}
+
+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[];
+	/// drift market type and index, optionally provide at initialization time if using priorityFeeMethod.DRIFT
+	driftMarkets?: DriftMarketInfo[];
+	/// 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 drift cached priority fee endpoint, required if using priorityFeeMethod.DRIFT
+	driftPriorityFeeEndpoint?: 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;
+};
+
+export type PriorityFeeSubscriberMapConfig = {
+	/// frequency to make RPC calls to update priority fee samples, in milliseconds
+	frequencyMs?: number;
+	/// drift market type and associated market index to query
+	driftMarkets?: DriftMarketInfo[];
+	/// url for drift cached priority fee endpoint
+	driftPriorityFeeEndpoint: string;
+};

package/src/serum/serumFulfillmentConfigMap.ts

@@ -0,0 +1,26 @@
+import { PublicKey } from '@solana/web3.js';
+import { SerumV3FulfillmentConfigAccount } from '../types';
+import { DriftClient } from '../driftClient';
+
+export class SerumFulfillmentConfigMap {
+	driftClient: DriftClient;
+	map = new Map<number, SerumV3FulfillmentConfigAccount>();
+
+	public constructor(driftClient: DriftClient) {
+		this.driftClient = driftClient;
+	}
+
+	public async add(
+		marketIndex: number,
+		serumMarketAddress: PublicKey
+	): Promise<void> {
+		const account = await this.driftClient.getSerumV3FulfillmentConfig(
+			serumMarketAddress
+		);
+		this.map.set(marketIndex, account);
+	}
+
+	public get(marketIndex: number): SerumV3FulfillmentConfigAccount {
+		return this.map.get(marketIndex);
+	}
+}