@drift-labs/sdk 2.82.0-beta.2 → 2.82.0-beta.3

package/VERSION

@@ -1 +1 @@
-2.82.0-beta.2
+2.82.0-beta.3

package/lib/priorityFee/driftPriorityFeeMethod.d.ts

@@ -1,3 +1,3 @@
-import { HeliusPriorityFeeLevels } from './heliusPriorityFeeMethod';
-export type DriftPriorityFeeResponse = HeliusPriorityFeeLevels[];
-export declare function fetchDriftPriorityFee(url: string, marketTypes: string[], marketIndexs: number[]): Promise<DriftPriorityFeeResponse>;
+import { DriftPriorityFeeLevels } from './heliusPriorityFeeMethod';
+export type DriftPriorityFeeResponse = DriftPriorityFeeLevels[];
+export declare function fetchDriftPriorityFee(url: string, marketTypes: string[], marketIndexes: number[]): Promise<DriftPriorityFeeResponse>;

package/lib/priorityFee/driftPriorityFeeMethod.js

@@ -5,9 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchDriftPriorityFee = void 0;
 const node_fetch_1 = __importDefault(require("node-fetch"));
-async function fetchDriftPriorityFee(url, marketTypes, marketIndexs) {
+async function fetchDriftPriorityFee(url, marketTypes, marketIndexes) {
     try {
-        const response = await (0, node_fetch_1.default)(`${url}/batchPriorityFees?marketType=${marketTypes.join(',')}&marketIndex=${marketIndexs.join(',')}`);
+        const response = await (0, node_fetch_1.default)(`${url}/batchPriorityFees?marketType=${marketTypes.join(',')}&marketIndex=${marketIndexes.join(',')}`);
         if (!response.ok) {
             throw new Error(`HTTP error! status: ${response.status}`);
         }

package/lib/priorityFee/heliusPriorityFeeMethod.d.ts

@@ -9,6 +9,12 @@ export declare enum HeliusPriorityLevel {
 export type HeliusPriorityFeeLevels = {
     [key in HeliusPriorityLevel]: number;
 };
+export type DriftPriorityFeeLevels = {
+    [key in HeliusPriorityLevel]: number;
+} & {
+    marketType: 'perp' | 'spot';
+    marketIndex: number;
+};
 export type HeliusPriorityFeeResponse = {
     jsonrpc: string;
     result: {

package/lib/priorityFee/priorityFeeSubscriber.d.ts

@@ -1,12 +1,8 @@
 import { Connection, PublicKey } from '@solana/web3.js';
-import { PriorityFeeMethod, PriorityFeeStrategy, PriorityFeeSubscriberConfig } from './types';
+import { DriftMarketInfo, PriorityFeeMethod, PriorityFeeStrategy, PriorityFeeSubscriberConfig } from './types';
 import { AverageOverSlotsStrategy } from './averageOverSlotsStrategy';
 import { MaxOverSlotsStrategy } from './maxOverSlotsStrategy';
 import { HeliusPriorityFeeLevels, HeliusPriorityLevel } from './heliusPriorityFeeMethod';
-export type DriftMarketInfo = {
-    marketType: string;
-    marketIndex: number;
-};
 export declare class PriorityFeeSubscriber {
     connection: Connection;
     frequencyMs: number;

package/lib/priorityFee/priorityFeeSubscriber.js

@@ -9,7 +9,7 @@ const heliusPriorityFeeMethod_1 = require("./heliusPriorityFeeMethod");
 const driftPriorityFeeMethod_1 = require("./driftPriorityFeeMethod");
 class PriorityFeeSubscriber {
     constructor(config) {
-        var _a, _b;
+        var _a, _b, _c;
         this.averageStrategy = new averageOverSlotsStrategy_1.AverageOverSlotsStrategy();
         this.maxStrategy = new maxOverSlotsStrategy_1.MaxOverSlotsStrategy();
         this.priorityFeeMethod = types_1.PriorityFeeMethod.SOLANA;
@@ -19,7 +19,8 @@ class PriorityFeeSubscriber {
         this.lastMaxStrategyResult = 0;
         this.lastSlotSeen = 0;
         this.connection = config.connection;
-        this.frequencyMs = config.frequencyMs;
+        this.frequencyMs =
+            (_a = config.frequencyMs) !== null && _a !== void 0 ? _a : types_1.DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS;
         this.addresses = config.addresses
             ? config.addresses.map((address) => address.toBase58())
             : [];
@@ -30,7 +31,7 @@ class PriorityFeeSubscriber {
         else {
             this.customStrategy = this.averageStrategy;
         }
-        this.lookbackDistance = (_a = config.slotsToCheck) !== null && _a !== void 0 ? _a : 50;
+        this.lookbackDistance = (_b = config.slotsToCheck) !== null && _b !== void 0 ? _b : 50;
         if (config.priorityFeeMethod) {
             this.priorityFeeMethod = config.priorityFeeMethod;
             if (this.priorityFeeMethod === types_1.PriorityFeeMethod.HELIUS) {
@@ -56,7 +57,7 @@ class PriorityFeeSubscriber {
             }
         }
         this.maxFeeMicroLamports = config.maxFeeMicroLamports;
-        this.priorityFeeMultiplier = (_b = config.priorityFeeMultiplier) !== null && _b !== void 0 ? _b : 1.0;
+        this.priorityFeeMultiplier = (_c = config.priorityFeeMultiplier) !== null && _c !== void 0 ? _c : 1.0;
     }
     async subscribe() {
         if (this.intervalId) {

package/lib/priorityFee/priorityFeeSubscriberMap.d.ts

@@ -0,0 +1,48 @@
+import { DriftPriorityFeeLevels } from './heliusPriorityFeeMethod';
+import { DriftMarketInfo, PriorityFeeSubscriberMapConfig } from './types';
+/**
+ * takes advantage of /batchPriorityFees endpoint from drift hosted priority fee service
+ */
+export declare class PriorityFeeSubscriberMap {
+    frequencyMs: number;
+    intervalId?: ReturnType<typeof setTimeout>;
+    driftMarkets?: DriftMarketInfo[];
+    driftPriorityFeeEndpoint?: string;
+    feesMap: Map<string, Map<number, DriftPriorityFeeLevels>>;
+    constructor(config: PriorityFeeSubscriberMapConfig);
+    private updateFeesMap;
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    load(): Promise<void>;
+    updateMarketTypeAndIndex(driftMarkets: DriftMarketInfo[]): void;
+    getPriorityFees(marketType: string, marketIndex: number): DriftPriorityFeeLevels | undefined;
+}
+/** 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/lib/priorityFee/priorityFeeSubscriberMap.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriorityFeeSubscriberMap = void 0;
+const driftPriorityFeeMethod_1 = require("./driftPriorityFeeMethod");
+const types_1 = require("./types");
+/**
+ * takes advantage of /batchPriorityFees endpoint from drift hosted priority fee service
+ */
+class PriorityFeeSubscriberMap {
+    constructor(config) {
+        var _a;
+        this.frequencyMs = config.frequencyMs;
+        this.frequencyMs =
+            (_a = config.frequencyMs) !== null && _a !== void 0 ? _a : types_1.DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS;
+        this.driftPriorityFeeEndpoint = config.driftPriorityFeeEndpoint;
+        this.driftMarkets = config.driftMarkets;
+        this.feesMap = new Map();
+        this.feesMap.set('perp', new Map());
+        this.feesMap.set('spot', new Map());
+    }
+    updateFeesMap(driftPriorityFeeResponse) {
+        driftPriorityFeeResponse.forEach((fee) => {
+            this.feesMap.get(fee.marketType).set(fee.marketIndex, fee);
+        });
+    }
+    async subscribe() {
+        if (this.intervalId) {
+            return;
+        }
+        await this.load();
+        this.intervalId = setInterval(this.load.bind(this), this.frequencyMs);
+    }
+    async unsubscribe() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+    async load() {
+        try {
+            if (!this.driftMarkets) {
+                return;
+            }
+            const fees = await (0, driftPriorityFeeMethod_1.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);
+        }
+    }
+    updateMarketTypeAndIndex(driftMarkets) {
+        this.driftMarkets = driftMarkets;
+    }
+    getPriorityFees(marketType, marketIndex) {
+        var _a;
+        return (_a = this.feesMap.get(marketType)) === null || _a === void 0 ? void 0 : _a.get(marketIndex);
+    }
+}
+exports.PriorityFeeSubscriberMap = PriorityFeeSubscriberMap;
+/** 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/lib/priorityFee/types.d.ts

@@ -1,8 +1,8 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { HeliusPriorityFeeResponse } from './heliusPriorityFeeMethod';
-import { DriftMarketInfo } from './priorityFeeSubscriber';
 import { DriftPriorityFeeResponse } from './driftPriorityFeeMethod';
+export declare const DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS = 10000;
 export interface PriorityFeeStrategy {
     calculate(samples: SolanaPriorityFeeResponse[] | HeliusPriorityFeeResponse | DriftPriorityFeeResponse): number;
 }
@@ -11,9 +11,13 @@ export declare enum PriorityFeeMethod {
     HELIUS = "helius",
     DRIFT = "drift"
 }
+export type DriftMarketInfo = {
+    marketType: string;
+    marketIndex: number;
+};
 export type PriorityFeeSubscriberConfig = {
     connection?: Connection;
-    frequencyMs: number;
+    frequencyMs?: number;
     addresses?: PublicKey[];
     driftMarkets?: DriftMarketInfo[];
     customStrategy?: PriorityFeeStrategy;
@@ -24,3 +28,8 @@ export type PriorityFeeSubscriberConfig = {
     maxFeeMicroLamports?: number;
     priorityFeeMultiplier?: number;
 };
+export type PriorityFeeSubscriberMapConfig = {
+    frequencyMs?: number;
+    driftMarkets?: DriftMarketInfo[];
+    driftPriorityFeeEndpoint: string;
+};

package/lib/priorityFee/types.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PriorityFeeMethod = void 0;
+exports.PriorityFeeMethod = exports.DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS = void 0;
+exports.DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS = 10000;
 var PriorityFeeMethod;
 (function (PriorityFeeMethod) {
     PriorityFeeMethod["SOLANA"] = "solana";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.82.0-beta.2",
+	"version": "2.82.0-beta.3",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/priorityFee/driftPriorityFeeMethod.ts

@@ -1,18 +1,18 @@
 import fetch from 'node-fetch';
-import { HeliusPriorityFeeLevels } from './heliusPriorityFeeMethod';
+import { DriftPriorityFeeLevels } from './heliusPriorityFeeMethod';
 
-export type DriftPriorityFeeResponse = HeliusPriorityFeeLevels[];
+export type DriftPriorityFeeResponse = DriftPriorityFeeLevels[];
 
 export async function fetchDriftPriorityFee(
 	url: string,
 	marketTypes: string[],
-	marketIndexs: number[]
+	marketIndexes: number[]
 ): Promise<DriftPriorityFeeResponse> {
 	try {
 		const response = await fetch(
 			`${url}/batchPriorityFees?marketType=${marketTypes.join(
 				','
-			)}&marketIndex=${marketIndexs.join(',')}`
+			)}&marketIndex=${marketIndexes.join(',')}`
 		);
 		if (!response.ok) {
 			throw new Error(`HTTP error! status: ${response.status}`);

package/src/priorityFee/heliusPriorityFeeMethod.ts

@@ -13,6 +13,13 @@ export type HeliusPriorityFeeLevels = {
 	[key in HeliusPriorityLevel]: number;
 };
 
+export type DriftPriorityFeeLevels = {
+	[key in HeliusPriorityLevel]: number;
+} & {
+	marketType: 'perp' | 'spot';
+	marketIndex: number;
+};
+
 export type HeliusPriorityFeeResponse = {
 	jsonrpc: string;
 	result: {

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -1,5 +1,7 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 import {
+	DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS,
+	DriftMarketInfo,
 	PriorityFeeMethod,
 	PriorityFeeStrategy,
 	PriorityFeeSubscriberConfig,
@@ -14,11 +16,6 @@ import {
 } from './heliusPriorityFeeMethod';
 import { fetchDriftPriorityFee } from './driftPriorityFeeMethod';
 
-export type DriftMarketInfo = {
-	marketType: string;
-	marketIndex: number;
-};
-
 export class PriorityFeeSubscriber {
 	connection: Connection;
 	frequencyMs: number;
@@ -46,7 +43,8 @@ export class PriorityFeeSubscriber {
 
 	public constructor(config: PriorityFeeSubscriberConfig) {
 		this.connection = config.connection;
-		this.frequencyMs = config.frequencyMs;
+		this.frequencyMs =
+			config.frequencyMs ?? DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS;
 		this.addresses = config.addresses
 			? config.addresses.map((address) => address.toBase58())
 			: [];

package/src/priorityFee/priorityFeeSubscriberMap.ts

@@ -0,0 +1,112 @@
+import {
+	DriftPriorityFeeResponse,
+	fetchDriftPriorityFee,
+} from './driftPriorityFeeMethod';
+import { DriftPriorityFeeLevels } from './heliusPriorityFeeMethod';
+import {
+	DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS,
+	DriftMarketInfo,
+	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/types.ts

@@ -1,9 +1,10 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { HeliusPriorityFeeResponse } from './heliusPriorityFeeMethod';
-import { DriftMarketInfo } from './priorityFeeSubscriber';
 import { 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)
@@ -21,11 +22,16 @@ export enum PriorityFeeMethod {
 	DRIFT = 'drift',
 }
 
+export type DriftMarketInfo = {
+	marketType: string;
+	marketIndex: number;
+};
+
 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;
+	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
@@ -45,3 +51,12 @@ export type PriorityFeeSubscriberConfig = {
 	/// 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;
+};