@drift-labs/sdk 2.97.0-beta.21 → 2.97.0-beta.23

package/lib/node/orderSubscriber/types.d.ts

@@ -0,0 +1,34 @@
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { Order, UserAccount } from '../types';
+import { DriftClient } from '../driftClient';
+import { GrpcConfigs } from '../accounts/types';
+export type OrderSubscriberConfig = {
+    driftClient: DriftClient;
+    subscriptionConfig: {
+        type: 'polling';
+        frequency: number;
+        commitment?: Commitment;
+    } | {
+        type: 'websocket';
+        skipInitialLoad?: boolean;
+        resubTimeoutMs?: number;
+        logResubMessages?: boolean;
+        resyncIntervalMs?: number;
+        commitment?: Commitment;
+    } | {
+        type: 'grpc';
+        grpcConfigs: GrpcConfigs;
+        skipInitialLoad?: boolean;
+        resubTimeoutMs?: number;
+        logResubMessages?: boolean;
+        resyncIntervalMs?: number;
+        commitment?: Commitment;
+    };
+    fastDecode?: boolean;
+    decodeData?: boolean;
+};
+export interface OrderSubscriberEvents {
+    orderCreated: (account: UserAccount, updatedOrders: Order[], pubkey: PublicKey, slot: number, dataType: 'raw' | 'decoded' | 'buffer') => void;
+    userUpdated: (account: UserAccount, pubkey: PublicKey, slot: number, dataType: 'raw' | 'decoded' | 'buffer') => void;
+    updateReceived: (pubkey: PublicKey, slot: number, dataType: 'raw' | 'decoded' | 'buffer') => void;
+}

package/lib/node/orderSubscriber/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/node/phoenix/phoenixFulfillmentConfigMap.d.ts

@@ -0,0 +1,10 @@
+import { PublicKey } from '@solana/web3.js';
+import { PhoenixV1FulfillmentConfigAccount } from '../types';
+import { DriftClient } from '../driftClient';
+export declare class PhoenixFulfillmentConfigMap {
+    driftClient: DriftClient;
+    map: Map<number, PhoenixV1FulfillmentConfigAccount>;
+    constructor(driftClient: DriftClient);
+    add(marketIndex: number, phoenixMarketAddress: PublicKey): Promise<void>;
+    get(marketIndex: number): PhoenixV1FulfillmentConfigAccount;
+}

package/lib/node/phoenix/phoenixFulfillmentConfigMap.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhoenixFulfillmentConfigMap = void 0;
+class PhoenixFulfillmentConfigMap {
+    constructor(driftClient) {
+        this.map = new Map();
+        this.driftClient = driftClient;
+    }
+    async add(marketIndex, phoenixMarketAddress) {
+        const account = await this.driftClient.getPhoenixV1FulfillmentConfig(phoenixMarketAddress);
+        this.map.set(marketIndex, account);
+    }
+    get(marketIndex) {
+        return this.map.get(marketIndex);
+    }
+}
+exports.PhoenixFulfillmentConfigMap = PhoenixFulfillmentConfigMap;

package/lib/node/phoenix/phoenixSubscriber.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="bn.js" />
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+import { Client, Market } from '@ellipsis-labs/phoenix-sdk';
+import { BN } from '@coral-xyz/anchor';
+import { L2Level, L2OrderBookGenerator } from '../dlob/orderBookLevels';
+export type PhoenixMarketSubscriberConfig = {
+    connection: Connection;
+    programId: PublicKey;
+    marketAddress: PublicKey;
+    accountSubscription: {
+        type: 'polling';
+        accountLoader: BulkAccountLoader;
+    } | {
+        type: 'websocket';
+    };
+    fastDecode?: boolean;
+};
+export declare class PhoenixSubscriber implements L2OrderBookGenerator {
+    connection: Connection;
+    client: Client;
+    programId: PublicKey;
+    marketAddress: PublicKey;
+    subscriptionType: 'polling' | 'websocket';
+    accountLoader: BulkAccountLoader | undefined;
+    market: Market;
+    marketCallbackId: string | number;
+    clockCallbackId: string | number;
+    fastDecode: boolean;
+    subscribed: boolean;
+    lastSlot: number;
+    lastUnixTimestamp: number;
+    constructor(config: PhoenixMarketSubscriberConfig);
+    subscribe(): Promise<void>;
+    getBestBid(): BN | undefined;
+    getBestAsk(): BN | undefined;
+    getL2Bids(): Generator<L2Level>;
+    getL2Asks(): Generator<L2Level>;
+    getL2Levels(side: 'bids' | 'asks'): Generator<L2Level>;
+    unsubscribe(): Promise<void>;
+}

package/lib/node/phoenix/phoenixSubscriber.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhoenixSubscriber = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const phoenix_sdk_1 = require("@ellipsis-labs/phoenix-sdk");
+const numericConstants_1 = require("../constants/numericConstants");
+const anchor_1 = require("@coral-xyz/anchor");
+const phoenix_1 = require("../decode/phoenix");
+class PhoenixSubscriber {
+    constructor(config) {
+        var _a;
+        this.connection = config.connection;
+        this.programId = config.programId;
+        this.marketAddress = config.marketAddress;
+        if (config.accountSubscription.type === 'polling') {
+            this.subscriptionType = 'polling';
+            this.accountLoader = config.accountSubscription.accountLoader;
+        }
+        else {
+            this.subscriptionType = 'websocket';
+        }
+        this.lastSlot = 0;
+        this.lastUnixTimestamp = 0;
+        this.fastDecode = (_a = config.fastDecode) !== null && _a !== void 0 ? _a : true;
+    }
+    async subscribe() {
+        if (this.subscribed) {
+            return;
+        }
+        this.market = await phoenix_sdk_1.Market.loadFromAddress({
+            connection: this.connection,
+            address: this.marketAddress,
+        });
+        const clock = (0, phoenix_sdk_1.deserializeClockData)((await this.connection.getAccountInfo(web3_js_1.SYSVAR_CLOCK_PUBKEY, 'confirmed'))
+            .data);
+        this.lastUnixTimestamp = (0, phoenix_sdk_1.toNum)(clock.unixTimestamp);
+        if (this.subscriptionType === 'websocket') {
+            this.marketCallbackId = this.connection.onAccountChange(this.marketAddress, (accountInfo, _ctx) => {
+                try {
+                    if (this.fastDecode) {
+                        this.market.data = (0, phoenix_1.fastDecode)(accountInfo.data);
+                    }
+                    else {
+                        this.market = this.market.reload(accountInfo.data);
+                    }
+                }
+                catch {
+                    console.error('Failed to reload Phoenix market data');
+                }
+            });
+            this.clockCallbackId = this.connection.onAccountChange(web3_js_1.SYSVAR_CLOCK_PUBKEY, (accountInfo, ctx) => {
+                try {
+                    this.lastSlot = ctx.slot;
+                    const clock = (0, phoenix_sdk_1.deserializeClockData)(accountInfo.data);
+                    this.lastUnixTimestamp = (0, phoenix_sdk_1.toNum)(clock.unixTimestamp);
+                }
+                catch {
+                    console.error('Failed to reload clock data');
+                }
+            });
+        }
+        else {
+            this.marketCallbackId = await this.accountLoader.addAccount(this.marketAddress, (buffer, slot) => {
+                try {
+                    this.lastSlot = slot;
+                    if (buffer) {
+                        if (this.fastDecode) {
+                            this.market.data = (0, phoenix_1.fastDecode)(buffer);
+                        }
+                        else {
+                            this.market = this.market.reload(buffer);
+                        }
+                    }
+                }
+                catch {
+                    console.error('Failed to reload Phoenix market data');
+                }
+            });
+            this.clockCallbackId = await this.accountLoader.addAccount(web3_js_1.SYSVAR_CLOCK_PUBKEY, (buffer, slot) => {
+                try {
+                    this.lastSlot = slot;
+                    const clock = (0, phoenix_sdk_1.deserializeClockData)(buffer);
+                    this.lastUnixTimestamp = (0, phoenix_sdk_1.toNum)(clock.unixTimestamp);
+                }
+                catch {
+                    console.error('Failed to reload clock data');
+                }
+            });
+        }
+        this.subscribed = true;
+    }
+    getBestBid() {
+        const ladder = (0, phoenix_sdk_1.getMarketUiLadder)(this.market, this.lastSlot, this.lastUnixTimestamp, 1);
+        const bestBid = ladder.bids[0];
+        if (!bestBid) {
+            return undefined;
+        }
+        return new anchor_1.BN(Math.floor(bestBid.price * numericConstants_1.PRICE_PRECISION.toNumber()));
+    }
+    getBestAsk() {
+        const ladder = (0, phoenix_sdk_1.getMarketUiLadder)(this.market, this.lastSlot, this.lastUnixTimestamp, 1);
+        const bestAsk = ladder.asks[0];
+        if (!bestAsk) {
+            return undefined;
+        }
+        return new anchor_1.BN(Math.floor(bestAsk.price * numericConstants_1.PRICE_PRECISION.toNumber()));
+    }
+    getL2Bids() {
+        return this.getL2Levels('bids');
+    }
+    getL2Asks() {
+        return this.getL2Levels('asks');
+    }
+    *getL2Levels(side) {
+        const basePrecision = Math.pow(10, this.market.data.header.baseParams.decimals);
+        const pricePrecision = numericConstants_1.PRICE_PRECISION.toNumber();
+        const ladder = (0, phoenix_sdk_1.getMarketUiLadder)(this.market, this.lastSlot, this.lastUnixTimestamp, 20);
+        for (let i = 0; i < ladder[side].length; i++) {
+            const { price, quantity } = ladder[side][i];
+            try {
+                const size = new anchor_1.BN(quantity * basePrecision);
+                const updatedPrice = new anchor_1.BN(price * pricePrecision);
+                yield {
+                    price: updatedPrice,
+                    size,
+                    sources: {
+                        phoenix: size,
+                    },
+                };
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    async unsubscribe() {
+        if (!this.subscribed) {
+            return;
+        }
+        // remove listeners
+        if (this.subscriptionType === 'websocket') {
+            await this.connection.removeAccountChangeListener(this.marketCallbackId);
+            await this.connection.removeAccountChangeListener(this.clockCallbackId);
+        }
+        else {
+            this.accountLoader.removeAccount(this.marketAddress, this.marketCallbackId);
+            this.accountLoader.removeAccount(web3_js_1.SYSVAR_CLOCK_PUBKEY, this.clockCallbackId);
+        }
+        this.subscribed = false;
+    }
+}
+exports.PhoenixSubscriber = PhoenixSubscriber;

package/lib/node/priorityFee/averageOverSlotsStrategy.d.ts

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

package/lib/node/priorityFee/averageOverSlotsStrategy.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AverageOverSlotsStrategy = void 0;
+class AverageOverSlotsStrategy {
+    calculate(samples) {
+        if (samples.length === 0) {
+            return 0;
+        }
+        let runningSumFees = 0;
+        for (let i = 0; i < samples.length; i++) {
+            runningSumFees += samples[i].prioritizationFee;
+        }
+        return runningSumFees / samples.length;
+    }
+}
+exports.AverageOverSlotsStrategy = AverageOverSlotsStrategy;

package/lib/node/priorityFee/averageStrategy.d.ts

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

package/lib/node/priorityFee/averageStrategy.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AverageStrategy = void 0;
+class AverageStrategy {
+    calculate(samples) {
+        return (samples.reduce((a, b) => {
+            return a + b.prioritizationFee;
+        }, 0) / samples.length);
+    }
+}
+exports.AverageStrategy = AverageStrategy;

package/lib/node/priorityFee/driftPriorityFeeMethod.d.ts

@@ -0,0 +1,13 @@
+import { HeliusPriorityLevel } from './heliusPriorityFeeMethod';
+export type DriftMarketInfo = {
+    marketType: string;
+    marketIndex: number;
+};
+export type DriftPriorityFeeLevels = {
+    [key in HeliusPriorityLevel]: number;
+} & {
+    marketType: 'perp' | 'spot';
+    marketIndex: number;
+};
+export type DriftPriorityFeeResponse = DriftPriorityFeeLevels[];
+export declare function fetchDriftPriorityFee(url: string, marketTypes: string[], marketIndexes: number[]): Promise<DriftPriorityFeeResponse>;

package/lib/node/priorityFee/driftPriorityFeeMethod.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchDriftPriorityFee = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+async function fetchDriftPriorityFee(url, marketTypes, marketIndexes) {
+    try {
+        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}`);
+        }
+        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 [];
+}
+exports.fetchDriftPriorityFee = fetchDriftPriorityFee;

package/lib/node/priorityFee/ewmaStrategy.d.ts

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

package/lib/node/priorityFee/ewmaStrategy.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EwmaStrategy = void 0;
+class EwmaStrategy {
+    /**
+     * @param halfLife The half life of the EWMA in slots. Default is 25 slots, approx 10 seconds.
+     */
+    constructor(halfLife = 25) {
+        this.halfLife = halfLife;
+    }
+    // samples provided in desc slot order
+    calculate(samples) {
+        if (samples.length === 0) {
+            return 0;
+        }
+        if (samples.length === 1) {
+            return samples[0].prioritizationFee;
+        }
+        let ewma = 0;
+        const samplesReversed = samples.slice().reverse();
+        for (let i = 0; i < samplesReversed.length; i++) {
+            if (i === 0) {
+                ewma = samplesReversed[i].prioritizationFee;
+                continue;
+            }
+            const gap = samplesReversed[i].slot - samplesReversed[i - 1].slot;
+            const alpha = 1 - Math.exp((Math.log(0.5) / this.halfLife) * gap);
+            ewma = alpha * samplesReversed[i].prioritizationFee + (1 - alpha) * ewma;
+        }
+        return ewma;
+    }
+}
+exports.EwmaStrategy = EwmaStrategy;

package/lib/node/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/node/priorityFee/heliusPriorityFeeMethod.js

@@ -0,0 +1,46 @@
+"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) {
+    try {
+        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();
+    }
+    catch (err) {
+        console.error(err);
+    }
+    return undefined;
+}
+exports.fetchHeliusPriorityFee = fetchHeliusPriorityFee;

package/lib/node/priorityFee/index.d.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/lib/node/priorityFee/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./averageOverSlotsStrategy"), exports);
+__exportStar(require("./averageStrategy"), exports);
+__exportStar(require("./ewmaStrategy"), exports);
+__exportStar(require("./maxOverSlotsStrategy"), exports);
+__exportStar(require("./maxStrategy"), exports);
+__exportStar(require("./priorityFeeSubscriber"), exports);
+__exportStar(require("./priorityFeeSubscriberMap"), exports);
+__exportStar(require("./solanaPriorityFeeMethod"), exports);
+__exportStar(require("./heliusPriorityFeeMethod"), exports);
+__exportStar(require("./driftPriorityFeeMethod"), exports);
+__exportStar(require("./types"), exports);

package/lib/node/priorityFee/maxOverSlotsStrategy.d.ts

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

package/lib/node/priorityFee/maxOverSlotsStrategy.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxOverSlotsStrategy = void 0;
+class MaxOverSlotsStrategy {
+    calculate(samples) {
+        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;
+    }
+}
+exports.MaxOverSlotsStrategy = MaxOverSlotsStrategy;

package/lib/node/priorityFee/maxStrategy.d.ts

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

package/lib/node/priorityFee/maxStrategy.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxStrategy = void 0;
+class MaxStrategy {
+    calculate(samples) {
+        return Math.max(...samples.map((result) => result.prioritizationFee));
+    }
+}
+exports.MaxStrategy = MaxStrategy;

package/lib/node/priorityFee/priorityFeeSubscriber.d.ts

@@ -0,0 +1,46 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { PriorityFeeMethod, PriorityFeeStrategy, PriorityFeeSubscriberConfig } from './types';
+import { AverageOverSlotsStrategy } from './averageOverSlotsStrategy';
+import { MaxOverSlotsStrategy } from './maxOverSlotsStrategy';
+import { HeliusPriorityFeeLevels, HeliusPriorityLevel } from './heliusPriorityFeeMethod';
+import { DriftMarketInfo } from './driftPriorityFeeMethod';
+export declare class PriorityFeeSubscriber {
+    connection: Connection;
+    frequencyMs: number;
+    addresses: string[];
+    driftMarkets?: DriftMarketInfo[];
+    customStrategy?: PriorityFeeStrategy;
+    averageStrategy: AverageOverSlotsStrategy;
+    maxStrategy: MaxOverSlotsStrategy;
+    priorityFeeMethod: PriorityFeeMethod;
+    lookbackDistance: number;
+    maxFeeMicroLamports?: number;
+    priorityFeeMultiplier?: number;
+    driftPriorityFeeEndpoint?: string;
+    heliusRpcUrl?: string;
+    lastHeliusSample?: HeliusPriorityFeeLevels;
+    intervalId?: ReturnType<typeof setTimeout>;
+    latestPriorityFee: number;
+    lastCustomStrategyResult: number;
+    lastAvgStrategyResult: number;
+    lastMaxStrategyResult: number;
+    lastSlotSeen: number;
+    constructor(config: PriorityFeeSubscriberConfig);
+    subscribe(): Promise<void>;
+    private loadForSolana;
+    private loadForHelius;
+    private loadForDrift;
+    getMaxPriorityFee(): number | undefined;
+    updateMaxPriorityFee(newMaxFee: number | undefined): void;
+    getPriorityFeeMultiplier(): number;
+    updatePriorityFeeMultiplier(newPriorityFeeMultiplier: number): void;
+    updateCustomStrategy(newStrategy: PriorityFeeStrategy): void;
+    getHeliusPriorityFeeLevel(level?: HeliusPriorityLevel): number;
+    getCustomStrategyResult(): number;
+    getAvgStrategyResult(): number;
+    getMaxStrategyResult(): number;
+    load(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    updateAddresses(addresses: PublicKey[]): void;
+    updateMarketTypeAndIndex(driftMarkets: DriftMarketInfo[]): void;
+}