@drift-labs/sdk 2.58.0-beta.0 → 2.58.0-beta.1

package/VERSION

@@ -1 +1 @@
-2.58.0-beta.0
+2.58.0-beta.1

package/lib/priorityFee/averageOverSlotsStrategy.d.ts

@@ -1,7 +1,5 @@
+import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { PriorityFeeStrategy } from './types';
 export declare class AverageOverSlotsStrategy implements PriorityFeeStrategy {
-    calculate(samples: {
-        slot: number;
-        prioritizationFee: number;
-    }[]): number;
+    calculate(samples: SolanaPriorityFeeResponse[]): number;
 }

package/lib/priorityFee/averageStrategy.d.ts

@@ -1,7 +1,5 @@
+import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { PriorityFeeStrategy } from './types';
 export declare class AverageStrategy implements PriorityFeeStrategy {
-    calculate(samples: {
-        slot: number;
-        prioritizationFee: number;
-    }[]): number;
+    calculate(samples: SolanaPriorityFeeResponse[]): number;
 }

package/lib/priorityFee/ewmaStrategy.d.ts

@@ -1,3 +1,4 @@
+import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { PriorityFeeStrategy } from './types';
 declare class EwmaStrategy implements PriorityFeeStrategy {
     private halfLife;
@@ -5,9 +6,6 @@ declare class EwmaStrategy implements PriorityFeeStrategy {
      * @param halfLife The half life of the EWMA in slots. Default is 25 slots, approx 10 seconds.
      */
     constructor(halfLife?: number);
-    calculate(samples: {
-        slot: number;
-        prioritizationFee: number;
-    }[]): number;
+    calculate(samples: SolanaPriorityFeeResponse[]): number;
 }
 export { EwmaStrategy };

package/lib/priorityFee/heliusPriorityFeeMethod.d.ts

@@ -0,0 +1,20 @@
+export declare enum HeliusPriorityLevel {
+    MIN = "min",
+    LOW = "low",
+    MEDIUM = "medium",
+    HIGH = "high",
+    VERY_HIGH = "veryHigh",
+    UNSAFE_MAX = "unsafeMax"
+}
+export type HeliusPriorityFeeLevels = {
+    [key in HeliusPriorityLevel]: number;
+};
+export type HeliusPriorityFeeResponse = {
+    jsonrpc: string;
+    result: {
+        priorityFeeEstimate?: number;
+        priorityFeeLevels?: HeliusPriorityFeeLevels;
+    };
+    id: string;
+};
+export declare function fetchHeliusPriorityFee(heliusRpcUrl: string, lookbackDistance: number, addresses: string[]): Promise<HeliusPriorityFeeResponse>;

package/lib/priorityFee/heliusPriorityFeeMethod.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchHeliusPriorityFee = exports.HeliusPriorityLevel = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+var HeliusPriorityLevel;
+(function (HeliusPriorityLevel) {
+    HeliusPriorityLevel["MIN"] = "min";
+    HeliusPriorityLevel["LOW"] = "low";
+    HeliusPriorityLevel["MEDIUM"] = "medium";
+    HeliusPriorityLevel["HIGH"] = "high";
+    HeliusPriorityLevel["VERY_HIGH"] = "veryHigh";
+    HeliusPriorityLevel["UNSAFE_MAX"] = "unsafeMax";
+})(HeliusPriorityLevel = exports.HeliusPriorityLevel || (exports.HeliusPriorityLevel = {}));
+/// Fetches the priority fee from the Helius API
+/// https://docs.helius.dev/solana-rpc-nodes/alpha-priority-fee-api
+async function fetchHeliusPriorityFee(heliusRpcUrl, lookbackDistance, addresses) {
+    const response = await (0, node_fetch_1.default)(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();
+}
+exports.fetchHeliusPriorityFee = fetchHeliusPriorityFee;

package/lib/priorityFee/index.d.ts

@@ -4,4 +4,6 @@ export * from './ewmaStrategy';
 export * from './maxOverSlotsStrategy';
 export * from './maxStrategy';
 export * from './priorityFeeSubscriber';
+export * from './solanaPriorityFeeMethod';
+export * from './heliusPriorityFeeMethod';
 export * from './types';

package/lib/priorityFee/index.js

@@ -20,4 +20,6 @@ __exportStar(require("./ewmaStrategy"), exports);
 __exportStar(require("./maxOverSlotsStrategy"), exports);
 __exportStar(require("./maxStrategy"), exports);
 __exportStar(require("./priorityFeeSubscriber"), exports);
+__exportStar(require("./solanaPriorityFeeMethod"), exports);
+__exportStar(require("./heliusPriorityFeeMethod"), exports);
 __exportStar(require("./types"), exports);

package/lib/priorityFee/maxOverSlotsStrategy.d.ts

@@ -1,7 +1,5 @@
+import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { PriorityFeeStrategy } from './types';
 export declare class MaxOverSlotsStrategy implements PriorityFeeStrategy {
-    calculate(samples: {
-        slot: number;
-        prioritizationFee: number;
-    }[]): number;
+    calculate(samples: SolanaPriorityFeeResponse[]): number;
 }

package/lib/priorityFee/priorityFeeSubscriber.d.ts

@@ -1,33 +1,33 @@
-import { Connection, PublicKey } from '@solana/web3.js';
-import { PriorityFeeStrategy } from './types';
+import { Connection } from '@solana/web3.js';
+import { PriorityFeeMethod, PriorityFeeStrategy, PriorityFeeSubscriberConfig } from './types';
 import { AverageOverSlotsStrategy } from './averageOverSlotsStrategy';
 import { MaxOverSlotsStrategy } from './maxOverSlotsStrategy';
+import { HeliusPriorityFeeLevels, HeliusPriorityLevel } from './heliusPriorityFeeMethod';
 export declare class PriorityFeeSubscriber {
     connection: Connection;
     frequencyMs: number;
-    addresses: PublicKey[];
+    addresses: string[];
     customStrategy?: PriorityFeeStrategy;
     averageStrategy: AverageOverSlotsStrategy;
     maxStrategy: MaxOverSlotsStrategy;
+    priorityFeeMethod: PriorityFeeMethod;
     lookbackDistance: number;
+    heliusRpcUrl?: string;
+    lastHeliusSample?: HeliusPriorityFeeLevels;
     intervalId?: ReturnType<typeof setTimeout>;
     latestPriorityFee: number;
     lastCustomStrategyResult: number;
     lastAvgStrategyResult: number;
     lastMaxStrategyResult: number;
     lastSlotSeen: number;
-    /**
-     * @param props
-     * customStrategy : strategy to return the priority fee to use based on recent samples. defaults to AVERAGE.
-     */
-    constructor({ connection, frequencyMs, addresses, customStrategy, slotsToCheck, }: {
-        connection: Connection;
-        frequencyMs: number;
-        addresses: PublicKey[];
-        customStrategy?: PriorityFeeStrategy;
-        slotsToCheck?: number;
-    });
+    constructor(config: PriorityFeeSubscriberConfig);
     subscribe(): Promise<void>;
+    private loadForSolana;
+    private loadForHelius;
+    getHeliusPriorityFeeLevel(level?: HeliusPriorityLevel): number;
+    getCustomStrategyResult(): number;
+    getAvgStrategyResult(): number;
+    getMaxStrategyResult(): number;
     load(): Promise<void>;
     unsubscribe(): Promise<void>;
 }

package/lib/priorityFee/priorityFeeSubscriber.js

@@ -1,62 +1,103 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PriorityFeeSubscriber = void 0;
+const types_1 = require("./types");
 const averageOverSlotsStrategy_1 = require("./averageOverSlotsStrategy");
 const maxOverSlotsStrategy_1 = require("./maxOverSlotsStrategy");
+const solanaPriorityFeeMethod_1 = require("./solanaPriorityFeeMethod");
+const heliusPriorityFeeMethod_1 = require("./heliusPriorityFeeMethod");
 class PriorityFeeSubscriber {
-    /**
-     * @param props
-     * customStrategy : strategy to return the priority fee to use based on recent samples. defaults to AVERAGE.
-     */
-    constructor({ connection, frequencyMs, addresses, customStrategy, slotsToCheck = 10, }) {
+    constructor(config) {
+        var _a;
         this.averageStrategy = new averageOverSlotsStrategy_1.AverageOverSlotsStrategy();
         this.maxStrategy = new maxOverSlotsStrategy_1.MaxOverSlotsStrategy();
+        this.priorityFeeMethod = types_1.PriorityFeeMethod.SOLANA;
         this.latestPriorityFee = 0;
         this.lastCustomStrategyResult = 0;
         this.lastAvgStrategyResult = 0;
         this.lastMaxStrategyResult = 0;
         this.lastSlotSeen = 0;
-        this.connection = connection;
-        this.frequencyMs = frequencyMs;
-        this.addresses = addresses;
-        if (!customStrategy) {
-            this.customStrategy = new averageOverSlotsStrategy_1.AverageOverSlotsStrategy();
+        this.connection = config.connection;
+        this.frequencyMs = config.frequencyMs;
+        this.addresses = config.addresses.map((address) => address.toBase58());
+        if (config.customStrategy) {
+            this.customStrategy = config.customStrategy;
         }
         else {
-            this.customStrategy = customStrategy;
+            this.customStrategy = this.averageStrategy;
+        }
+        this.lookbackDistance = (_a = config.slotsToCheck) !== null && _a !== void 0 ? _a : 50;
+        if (config.priorityFeeMethod) {
+            this.priorityFeeMethod = config.priorityFeeMethod;
+            if (this.priorityFeeMethod === types_1.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');
+                    }
+                }
+            }
+        }
+        if (this.priorityFeeMethod === types_1.PriorityFeeMethod.SOLANA) {
+            if (this.connection === undefined) {
+                throw new Error('connection must be provided to use SOLANA priority fee API');
+            }
         }
-        this.lookbackDistance = slotsToCheck;
     }
     async subscribe() {
         if (this.intervalId) {
             return;
         }
+        await this.load();
         this.intervalId = setInterval(this.load.bind(this), this.frequencyMs);
     }
+    async loadForSolana() {
+        const samples = await (0, solanaPriorityFeeMethod_1.fetchSolanaPriorityFee)(this.connection, this.lookbackDistance, this.addresses);
+        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);
+        }
+    }
+    async loadForHelius() {
+        var _a, _b;
+        const sample = await (0, heliusPriorityFeeMethod_1.fetchHeliusPriorityFee)(this.heliusRpcUrl, this.lookbackDistance, this.addresses);
+        this.lastHeliusSample = (_b = (_a = sample === null || sample === void 0 ? void 0 : sample.result) === null || _a === void 0 ? void 0 : _a.priorityFeeLevels) !== null && _b !== void 0 ? _b : undefined;
+    }
+    getHeliusPriorityFeeLevel(level = heliusPriorityFeeMethod_1.HeliusPriorityLevel.MEDIUM) {
+        if (this.lastHeliusSample === undefined) {
+            return 0;
+        }
+        return this.lastHeliusSample[level];
+    }
+    getCustomStrategyResult() {
+        return this.lastCustomStrategyResult;
+    }
+    getAvgStrategyResult() {
+        return this.lastAvgStrategyResult;
+    }
+    getMaxStrategyResult() {
+        return this.lastMaxStrategyResult;
+    }
     async load() {
         try {
-            // @ts-ignore
-            const rpcJSONResponse = await this.connection._rpcRequest('getRecentPrioritizationFees', [this.addresses]);
-            const results = rpcJSONResponse === null || rpcJSONResponse === void 0 ? void 0 : 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 mostRecentResult = descResults[0];
-            const cutoffSlot = mostRecentResult.slot - this.lookbackDistance;
-            const resultsToUse = descResults.filter((result) => result.slot >= cutoffSlot);
-            // # Handle results
-            this.latestPriorityFee = mostRecentResult.prioritizationFee;
-            this.lastSlotSeen = mostRecentResult.slot;
-            this.lastAvgStrategyResult = this.averageStrategy.calculate(resultsToUse);
-            this.lastMaxStrategyResult = this.maxStrategy.calculate(resultsToUse);
-            if (this.customStrategy) {
-                this.lastCustomStrategyResult =
-                    this.customStrategy.calculate(resultsToUse);
+            if (this.priorityFeeMethod === types_1.PriorityFeeMethod.SOLANA) {
+                await this.loadForSolana();
+            }
+            else if (this.priorityFeeMethod === types_1.PriorityFeeMethod.HELIUS) {
+                await this.loadForHelius();
+            }
+            else {
+                throw new Error(`${this.priorityFeeMethod} load not implemented`);
             }
         }
         catch (err) {
-            // It's possible to get here with "TypeError: failed to fetch"
+            const e = err;
+            console.error(`Error loading priority fee ${this.priorityFeeMethod}: ${e.message}\n${e.stack ? e.stack : ''}`);
             return;
         }
     }

package/lib/priorityFee/solanaPriorityFeeMethod.d.ts

@@ -0,0 +1,6 @@
+import { Connection } from '@solana/web3.js';
+export type SolanaPriorityFeeResponse = {
+    slot: number;
+    prioritizationFee: number;
+};
+export declare function fetchSolanaPriorityFee(connection: Connection, lookbackDistance: number, addresses: string[]): Promise<SolanaPriorityFeeResponse[]>;

package/lib/priorityFee/solanaPriorityFeeMethod.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSolanaPriorityFee = void 0;
+async function fetchSolanaPriorityFee(connection, lookbackDistance, addresses) {
+    // @ts-ignore
+    const rpcJSONResponse = await connection._rpcRequest('getRecentPrioritizationFees', [addresses]);
+    const results = rpcJSONResponse === null || rpcJSONResponse === void 0 ? void 0 : 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);
+}
+exports.fetchSolanaPriorityFee = fetchSolanaPriorityFee;

package/lib/priorityFee/types.d.ts

@@ -1,6 +1,19 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
+import { HeliusPriorityFeeResponse } from './heliusPriorityFeeMethod';
 export interface PriorityFeeStrategy {
-    calculate(samples: {
-        slot: number;
-        prioritizationFee: number;
-    }[]): number;
+    calculate(samples: SolanaPriorityFeeResponse[] | HeliusPriorityFeeResponse): number;
 }
+export declare enum PriorityFeeMethod {
+    SOLANA = "solana",
+    HELIUS = "helius"
+}
+export type PriorityFeeSubscriberConfig = {
+    connection?: Connection;
+    frequencyMs: number;
+    addresses: PublicKey[];
+    customStrategy?: PriorityFeeStrategy;
+    priorityFeeMethod?: PriorityFeeMethod;
+    slotsToCheck?: number;
+    heliusRpcUrl?: string;
+};

package/lib/priorityFee/types.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriorityFeeMethod = void 0;
+var PriorityFeeMethod;
+(function (PriorityFeeMethod) {
+    PriorityFeeMethod["SOLANA"] = "solana";
+    PriorityFeeMethod["HELIUS"] = "helius";
+})(PriorityFeeMethod = exports.PriorityFeeMethod || (exports.PriorityFeeMethod = {}));

package/package.json

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

package/src/priorityFee/averageOverSlotsStrategy.ts

@@ -1,7 +1,8 @@
+import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { PriorityFeeStrategy } from './types';
 
 export class AverageOverSlotsStrategy implements PriorityFeeStrategy {
-	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
+	calculate(samples: SolanaPriorityFeeResponse[]): number {
 		if (samples.length === 0) {
 			return 0;
 		}

package/src/priorityFee/averageStrategy.ts

@@ -1,7 +1,8 @@
+import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { PriorityFeeStrategy } from './types';
 
 export class AverageStrategy implements PriorityFeeStrategy {
-	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
+	calculate(samples: SolanaPriorityFeeResponse[]): number {
 		return (
 			samples.reduce((a, b) => {
 				return a + b.prioritizationFee;

package/src/priorityFee/ewmaStrategy.ts

@@ -1,3 +1,4 @@
+import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { PriorityFeeStrategy } from './types';
 
 class EwmaStrategy implements PriorityFeeStrategy {
@@ -11,7 +12,7 @@ class EwmaStrategy implements PriorityFeeStrategy {
 	}
 
 	// samples provided in desc slot order
-	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
+	calculate(samples: SolanaPriorityFeeResponse[]): number {
 		if (samples.length === 0) {
 			return 0;
 		}

package/src/priorityFee/heliusPriorityFeeMethod.ts

@@ -0,0 +1,51 @@
+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> {
+	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();
+}

package/src/priorityFee/index.ts

@@ -4,4 +4,6 @@ export * from './ewmaStrategy';
 export * from './maxOverSlotsStrategy';
 export * from './maxStrategy';
 export * from './priorityFeeSubscriber';
+export * from './solanaPriorityFeeMethod';
+export * from './heliusPriorityFeeMethod';
 export * from './types';

package/src/priorityFee/maxOverSlotsStrategy.ts

@@ -1,7 +1,8 @@
+import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { PriorityFeeStrategy } from './types';
 
 export class MaxOverSlotsStrategy implements PriorityFeeStrategy {
-	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
+	calculate(samples: SolanaPriorityFeeResponse[]): number {
 		if (samples.length === 0) {
 			return 0;
 		}

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -1,17 +1,31 @@
-import { Connection, PublicKey } from '@solana/web3.js';
-import { PriorityFeeStrategy } from './types';
+import { Connection } from '@solana/web3.js';
+import {
+	PriorityFeeMethod,
+	PriorityFeeStrategy,
+	PriorityFeeSubscriberConfig,
+} from './types';
 import { AverageOverSlotsStrategy } from './averageOverSlotsStrategy';
 import { MaxOverSlotsStrategy } from './maxOverSlotsStrategy';
+import { fetchSolanaPriorityFee } from './solanaPriorityFeeMethod';
+import {
+	HeliusPriorityFeeLevels,
+	HeliusPriorityLevel,
+	fetchHeliusPriorityFee,
+} from './heliusPriorityFeeMethod';
 
 export class PriorityFeeSubscriber {
 	connection: Connection;
 	frequencyMs: number;
-	addresses: PublicKey[];
+	addresses: string[];
 	customStrategy?: PriorityFeeStrategy;
 	averageStrategy = new AverageOverSlotsStrategy();
 	maxStrategy = new MaxOverSlotsStrategy();
+	priorityFeeMethod = PriorityFeeMethod.SOLANA;
 	lookbackDistance: number;
 
+	heliusRpcUrl?: string;
+	lastHeliusSample?: HeliusPriorityFeeLevels;
+
 	intervalId?: ReturnType<typeof setTimeout>;
 
 	latestPriorityFee = 0;
@@ -20,32 +34,39 @@ export class PriorityFeeSubscriber {
 	lastMaxStrategyResult = 0;
 	lastSlotSeen = 0;
 
-	/**
-	 * @param props
-	 * customStrategy : strategy to return the priority fee to use based on recent samples. defaults to AVERAGE.
-	 */
-	public constructor({
-		connection,
-		frequencyMs,
-		addresses,
-		customStrategy,
-		slotsToCheck = 10,
-	}: {
-		connection: Connection;
-		frequencyMs: number;
-		addresses: PublicKey[];
-		customStrategy?: PriorityFeeStrategy;
-		slotsToCheck?: number;
-	}) {
-		this.connection = connection;
-		this.frequencyMs = frequencyMs;
-		this.addresses = addresses;
-		if (!customStrategy) {
-			this.customStrategy = new AverageOverSlotsStrategy();
+	public constructor(config: PriorityFeeSubscriberConfig) {
+		this.connection = config.connection;
+		this.frequencyMs = config.frequencyMs;
+		this.addresses = config.addresses.map((address) => address.toBase58());
+		if (config.customStrategy) {
+			this.customStrategy = config.customStrategy;
 		} else {
-			this.customStrategy = customStrategy;
+			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'
+						);
+					}
+				}
+			}
+		}
+
+		if (this.priorityFeeMethod === PriorityFeeMethod.SOLANA) {
+			if (this.connection === undefined) {
+				throw new Error(
+					'connection must be provided to use SOLANA priority fee API'
+				);
+			}
 		}
-		this.lookbackDistance = slotsToCheck;
 	}
 
 	public async subscribe(): Promise<void> {
@@ -53,43 +74,72 @@ export class PriorityFeeSubscriber {
 			return;
 		}
 
+		await this.load();
 		this.intervalId = setInterval(this.load.bind(this), this.frequencyMs);
 	}
 
-	public async load(): Promise<void> {
-		try {
-			// @ts-ignore
-			const rpcJSONResponse: any = await this.connection._rpcRequest(
-				'getRecentPrioritizationFees',
-				[this.addresses]
-			);
+	private async loadForSolana(): Promise<void> {
+		const samples = await fetchSolanaPriorityFee(
+			this.connection!,
+			this.lookbackDistance,
+			this.addresses
+		);
+		this.latestPriorityFee = samples[0].prioritizationFee;
+		this.lastSlotSeen = samples[0].slot;
 
-			const results: { slot: number; prioritizationFee: number }[] =
-				rpcJSONResponse?.result;
+		this.lastAvgStrategyResult = this.averageStrategy.calculate(samples);
+		this.lastMaxStrategyResult = this.maxStrategy.calculate(samples);
+		if (this.customStrategy) {
+			this.lastCustomStrategyResult = this.customStrategy.calculate(samples);
+		}
+	}
 
-			if (!results.length) return;
+	private async loadForHelius(): Promise<void> {
+		const sample = await fetchHeliusPriorityFee(
+			this.heliusRpcUrl,
+			this.lookbackDistance,
+			this.addresses
+		);
+		this.lastHeliusSample = sample?.result?.priorityFeeLevels ?? undefined;
+	}
 
-			// # Sort and filter results based on the slot lookback setting
-			const descResults = results.sort((a, b) => b.slot - a.slot);
-			const mostRecentResult = descResults[0];
-			const cutoffSlot = mostRecentResult.slot - this.lookbackDistance;
+	public getHeliusPriorityFeeLevel(
+		level: HeliusPriorityLevel = HeliusPriorityLevel.MEDIUM
+	): number {
+		if (this.lastHeliusSample === undefined) {
+			return 0;
+		}
+		return this.lastHeliusSample[level];
+	}
 
-			const resultsToUse = descResults.filter(
-				(result) => result.slot >= cutoffSlot
-			);
+	public getCustomStrategyResult(): number {
+		return this.lastCustomStrategyResult;
+	}
 
-			// # Handle results
-			this.latestPriorityFee = mostRecentResult.prioritizationFee;
-			this.lastSlotSeen = mostRecentResult.slot;
+	public getAvgStrategyResult(): number {
+		return this.lastAvgStrategyResult;
+	}
 
-			this.lastAvgStrategyResult = this.averageStrategy.calculate(resultsToUse);
-			this.lastMaxStrategyResult = this.maxStrategy.calculate(resultsToUse);
-			if (this.customStrategy) {
-				this.lastCustomStrategyResult =
-					this.customStrategy.calculate(resultsToUse);
+	public getMaxStrategyResult(): number {
+		return this.lastMaxStrategyResult;
+	}
+
+	public async load(): Promise<void> {
+		try {
+			if (this.priorityFeeMethod === PriorityFeeMethod.SOLANA) {
+				await this.loadForSolana();
+			} else if (this.priorityFeeMethod === PriorityFeeMethod.HELIUS) {
+				await this.loadForHelius();
+			} else {
+				throw new Error(`${this.priorityFeeMethod} load not implemented`);
 			}
 		} catch (err) {
-			// It's possible to get here with "TypeError: failed to fetch"
+			const e = err as Error;
+			console.error(
+				`Error loading priority fee ${this.priorityFeeMethod}: ${e.message}\n${
+					e.stack ? e.stack : ''
+				}`
+			);
 			return;
 		}
 	}

package/src/priorityFee/solanaPriorityFeeMethod.ts

@@ -0,0 +1,28 @@
+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[]> {
+	// @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);
+}

package/src/priorityFee/types.ts

@@ -1,5 +1,33 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
+import { HeliusPriorityFeeResponse } from './heliusPriorityFeeMethod';
+
 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: { slot: number; prioritizationFee: number }[]): number;
+	calculate(
+		samples: SolanaPriorityFeeResponse[] | HeliusPriorityFeeResponse
+	): number;
 }
+
+export enum PriorityFeeMethod {
+	SOLANA = 'solana',
+	HELIUS = 'helius',
+}
+
+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[];
+	/// 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;
+};

package/tests/tx/priorityFeeStrategy.ts

@@ -76,7 +76,7 @@ describe('PriorityFeeStrategy', () => {
 			{ slot: 1, prioritizationFee: 1000 },
 		];
 		const maxOverSlots = maxOverSlotsStrategy.calculate(samples);
-		expect(maxOverSlots).to.equal(832);
+		expect(maxOverSlots).to.equal(1000);
 	});
 
 	it('AverageOverSlotsStrategy should calculate the average prioritization fee over slots', () => {
@@ -90,6 +90,6 @@ describe('PriorityFeeStrategy', () => {
 			{ slot: 1, prioritizationFee: 1000 },
 		];
 		const averageOverSlots = averageOverSlotsStrategy.calculate(samples);
-		expect(averageOverSlots).to.equal(454.4);
+		expect(averageOverSlots).to.approximately(545.33333, 0.00001);
 	});
 });