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

package/VERSION

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

package/lib/driftClient.d.ts

@@ -650,7 +650,8 @@ export declare class DriftClient {
     requestRemoveInsuranceFundStake(marketIndex: number, amount: BN, txParams?: TxParams): Promise<TransactionSignature>;
     cancelRequestRemoveInsuranceFundStake(marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     removeInsuranceFundStake(marketIndex: number, collateralAccountPublicKey: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
-    settleRevenueToInsuranceFund(marketIndex: number): Promise<TransactionSignature>;
+    settleRevenueToInsuranceFund(spotMarketIndex: number, subAccountId?: number, txParams?: TxParams): Promise<TransactionSignature>;
+    getSettleRevenueToInsuranceFundIx(spotMarketIndex: number, subAccountId?: number): Promise<TransactionInstruction>;
     resolvePerpPnlDeficit(spotMarketIndex: number, perpMarketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     getResolvePerpPnlDeficitIx(spotMarketIndex: number, perpMarketIndex: number): Promise<TransactionInstruction>;
     getDepositIntoSpotMarketRevenuePoolIx(marketIndex: number, amount: BN, userTokenAccountPublicKey: PublicKey): Promise<TransactionInstruction>;

package/lib/driftClient.js

@@ -3465,14 +3465,19 @@ class DriftClient {
         const { txSig } = await this.sendTransaction(tx, additionalSigners, this.opts);
         return txSig;
     }
-    async settleRevenueToInsuranceFund(marketIndex) {
-        const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+    async settleRevenueToInsuranceFund(spotMarketIndex, subAccountId, txParams) {
+        const tx = await this.buildTransaction(await this.getSettleRevenueToInsuranceFundIx(spotMarketIndex, subAccountId), txParams);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getSettleRevenueToInsuranceFundIx(spotMarketIndex, subAccountId) {
+        const spotMarketAccount = this.getSpotMarketAccount(spotMarketIndex);
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts: [this.getUserAccount(subAccountId)],
             useMarketLastSlotCache: true,
-            writableSpotMarketIndexes: [marketIndex],
+            writableSpotMarketIndexes: [spotMarketIndex],
         });
-        const ix = await this.program.instruction.settleRevenueToInsuranceFund(marketIndex, {
+        const ix = await this.program.instruction.settleRevenueToInsuranceFund(spotMarketIndex, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 spotMarket: spotMarketAccount.pubkey,
@@ -3483,9 +3488,7 @@ class DriftClient {
             },
             remainingAccounts,
         });
-        const tx = await this.buildTransaction(ix);
-        const { txSig } = await this.sendTransaction(tx, [], this.opts);
-        return txSig;
+        return ix;
     }
     async resolvePerpPnlDeficit(spotMarketIndex, perpMarketIndex, txParams) {
         const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getResolvePerpPnlDeficitIx(spotMarketIndex, perpMarketIndex), txParams), [], this.opts);

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.1",
+	"version": "2.82.0-beta.3",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/blockhashSubscriber/types.ts

@@ -1,8 +1,12 @@
 import { Commitment, Connection } from '@solana/web3.js';
 
 export type BlockhashSubscriberConfig = {
+	/// rpcUrl to poll block hashes from, one of rpcUrl or Connection must provided
 	rpcUrl?: string;
+	/// connection to poll block hashes from, one of rpcUrl or Connection must provided
 	connection?: Connection;
+	/// commitment to poll block hashes with, default is 'confirmed'
 	commitment?: Commitment;
+	/// interval to poll block hashes, default is 1000 ms
 	updateIntervalMs?: number;
 };

package/src/driftClient.ts

@@ -6488,18 +6488,33 @@ export class DriftClient {
 	}
 
 	public async settleRevenueToInsuranceFund(
-		marketIndex: number
+		spotMarketIndex: number,
+		subAccountId?: number,
+		txParams?: TxParams
 	): Promise<TransactionSignature> {
-		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const tx = await this.buildTransaction(
+			await this.getSettleRevenueToInsuranceFundIx(
+				spotMarketIndex,
+				subAccountId
+			),
+			txParams
+		);
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+		return txSig;
+	}
 
+	public async getSettleRevenueToInsuranceFundIx(
+		spotMarketIndex: number,
+		subAccountId?: number
+	): Promise<TransactionInstruction> {
+		const spotMarketAccount = this.getSpotMarketAccount(spotMarketIndex);
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount()],
+			userAccounts: [this.getUserAccount(subAccountId)],
 			useMarketLastSlotCache: true,
-			writableSpotMarketIndexes: [marketIndex],
+			writableSpotMarketIndexes: [spotMarketIndex],
 		});
-
 		const ix = await this.program.instruction.settleRevenueToInsuranceFund(
-			marketIndex,
+			spotMarketIndex,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
@@ -6512,11 +6527,7 @@ export class DriftClient {
 				remainingAccounts,
 			}
 		);
-
-		const tx = await this.buildTransaction(ix);
-
-		const { txSig } = await this.sendTransaction(tx, [], this.opts);
-		return txSig;
+		return ix;
 	}
 
 	public async resolvePerpPnlDeficit(

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;
+};

package/tests/dlob/helpers.ts

@@ -142,6 +142,10 @@ export const mockAMM: AMM = {
 	bidQuoteAssetReserve: new BN(0),
 	askBaseAssetReserve: new BN(0),
 	askQuoteAssetReserve: new BN(0),
+
+	netUnsettledFundingPnl: new BN(0),
+	quoteAssetAmountWithUnsettledLp: new BN(0),
+	referencePriceOffset: 0,
 };
 
 export const mockPerpMarkets: Array<PerpMarketAccount> = [