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

package/lib/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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;
+}

package/lib/browser/priorityFee/priorityFeeSubscriber.js

@@ -0,0 +1,188 @@
+"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");
+const driftPriorityFeeMethod_1 = require("./driftPriorityFeeMethod");
+class PriorityFeeSubscriber {
+    constructor(config) {
+        var _a, _b, _c;
+        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 = config.connection;
+        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())
+            : [];
+        this.driftMarkets = config.driftMarkets;
+        if (config.customStrategy) {
+            this.customStrategy = config.customStrategy;
+        }
+        else {
+            this.customStrategy = this.averageStrategy;
+        }
+        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) {
+                if (config.heliusRpcUrl === undefined) {
+                    if (this.connection.rpcEndpoint.includes('helius')) {
+                        this.heliusRpcUrl = this.connection.rpcEndpoint;
+                    }
+                    else {
+                        throw new Error('Connection must be helius, or heliusRpcUrl must be provided to use PriorityFeeMethod.HELIUS');
+                    }
+                }
+                else {
+                    this.heliusRpcUrl = config.heliusRpcUrl;
+                }
+            }
+            else if (this.priorityFeeMethod === types_1.PriorityFeeMethod.DRIFT) {
+                this.driftPriorityFeeEndpoint = config.driftPriorityFeeEndpoint;
+            }
+        }
+        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.maxFeeMicroLamports = config.maxFeeMicroLamports;
+        this.priorityFeeMultiplier = (_c = config.priorityFeeMultiplier) !== null && _c !== void 0 ? _c : 1.0;
+    }
+    async subscribe() {
+        if (this.intervalId) {
+            return;
+        }
+        this.intervalId = setInterval(this.load.bind(this), this.frequencyMs); // we set the intervalId first, preventing a side effect of unsubscribing failing during the race condition where unsubscribes happens before subscribe is finished
+        await this.load();
+    }
+    async loadForSolana() {
+        const samples = await (0, solanaPriorityFeeMethod_1.fetchSolanaPriorityFee)(this.connection, this.lookbackDistance, this.addresses);
+        if (samples.length > 0) {
+            this.latestPriorityFee = samples[0].prioritizationFee;
+            this.lastSlotSeen = samples[0].slot;
+            this.lastAvgStrategyResult = this.averageStrategy.calculate(samples);
+            this.lastMaxStrategyResult = this.maxStrategy.calculate(samples);
+            if (this.customStrategy) {
+                this.lastCustomStrategyResult = this.customStrategy.calculate(samples);
+            }
+        }
+    }
+    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;
+        if (this.lastHeliusSample) {
+            this.lastAvgStrategyResult =
+                this.lastHeliusSample[heliusPriorityFeeMethod_1.HeliusPriorityLevel.MEDIUM];
+            this.lastMaxStrategyResult =
+                this.lastHeliusSample[heliusPriorityFeeMethod_1.HeliusPriorityLevel.UNSAFE_MAX];
+            if (this.customStrategy) {
+                this.lastCustomStrategyResult = this.customStrategy.calculate(sample);
+            }
+        }
+    }
+    async loadForDrift() {
+        if (!this.driftMarkets) {
+            return;
+        }
+        const sample = await (0, driftPriorityFeeMethod_1.fetchDriftPriorityFee)(this.driftPriorityFeeEndpoint, this.driftMarkets.map((m) => m.marketType), this.driftMarkets.map((m) => m.marketIndex));
+        if (sample.length > 0) {
+            this.lastAvgStrategyResult = sample[heliusPriorityFeeMethod_1.HeliusPriorityLevel.MEDIUM];
+            this.lastMaxStrategyResult = sample[heliusPriorityFeeMethod_1.HeliusPriorityLevel.UNSAFE_MAX];
+            if (this.customStrategy) {
+                this.lastCustomStrategyResult = this.customStrategy.calculate(sample);
+            }
+        }
+    }
+    getMaxPriorityFee() {
+        return this.maxFeeMicroLamports;
+    }
+    updateMaxPriorityFee(newMaxFee) {
+        this.maxFeeMicroLamports = newMaxFee;
+    }
+    getPriorityFeeMultiplier() {
+        var _a;
+        return (_a = this.priorityFeeMultiplier) !== null && _a !== void 0 ? _a : 1.0;
+    }
+    updatePriorityFeeMultiplier(newPriorityFeeMultiplier) {
+        this.priorityFeeMultiplier = newPriorityFeeMultiplier;
+    }
+    updateCustomStrategy(newStrategy) {
+        this.customStrategy = newStrategy;
+    }
+    getHeliusPriorityFeeLevel(level = heliusPriorityFeeMethod_1.HeliusPriorityLevel.MEDIUM) {
+        if (this.lastHeliusSample === undefined) {
+            return 0;
+        }
+        if (this.maxFeeMicroLamports !== undefined) {
+            return Math.min(this.maxFeeMicroLamports, this.lastHeliusSample[level]);
+        }
+        return this.lastHeliusSample[level];
+    }
+    getCustomStrategyResult() {
+        const result = this.lastCustomStrategyResult * this.getPriorityFeeMultiplier();
+        if (this.maxFeeMicroLamports !== undefined) {
+            return Math.min(this.maxFeeMicroLamports, result);
+        }
+        return result;
+    }
+    getAvgStrategyResult() {
+        const result = this.lastAvgStrategyResult * this.getPriorityFeeMultiplier();
+        if (this.maxFeeMicroLamports !== undefined) {
+            return Math.min(this.maxFeeMicroLamports, result);
+        }
+        return result;
+    }
+    getMaxStrategyResult() {
+        const result = this.lastMaxStrategyResult * this.getPriorityFeeMultiplier();
+        if (this.maxFeeMicroLamports !== undefined) {
+            return Math.min(this.maxFeeMicroLamports, result);
+        }
+        return result;
+    }
+    async load() {
+        try {
+            if (this.priorityFeeMethod === types_1.PriorityFeeMethod.SOLANA) {
+                await this.loadForSolana();
+            }
+            else if (this.priorityFeeMethod === types_1.PriorityFeeMethod.HELIUS) {
+                await this.loadForHelius();
+            }
+            else if (this.priorityFeeMethod === types_1.PriorityFeeMethod.DRIFT) {
+                await this.loadForDrift();
+            }
+            else {
+                throw new Error(`${this.priorityFeeMethod} load not implemented`);
+            }
+        }
+        catch (err) {
+            const e = err;
+            console.error(`Error loading priority fee ${this.priorityFeeMethod}: ${e.message}\n${e.stack ? e.stack : ''}`);
+            return;
+        }
+    }
+    async unsubscribe() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+    updateAddresses(addresses) {
+        this.addresses = addresses.map((k) => k.toBase58());
+    }
+    updateMarketTypeAndIndex(driftMarkets) {
+        this.driftMarkets = driftMarkets;
+    }
+}
+exports.PriorityFeeSubscriber = PriorityFeeSubscriber;

package/lib/browser/priorityFee/priorityFeeSubscriberMap.d.ts

@@ -0,0 +1,48 @@
+import { DriftMarketInfo, DriftPriorityFeeLevels } from './driftPriorityFeeMethod';
+import { 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/browser/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/browser/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/browser/priorityFee/solanaPriorityFeeMethod.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSolanaPriorityFee = void 0;
+async function fetchSolanaPriorityFee(connection, lookbackDistance, addresses) {
+    try {
+        // @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);
+    }
+    catch (err) {
+        console.error(err);
+    }
+    return [];
+}
+exports.fetchSolanaPriorityFee = fetchSolanaPriorityFee;

package/lib/browser/priorityFee/types.d.ts

@@ -0,0 +1,31 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
+import { HeliusPriorityFeeResponse } from './heliusPriorityFeeMethod';
+import { DriftMarketInfo, DriftPriorityFeeResponse } from './driftPriorityFeeMethod';
+export declare const DEFAULT_PRIORITY_FEE_MAP_FREQUENCY_MS = 10000;
+export interface PriorityFeeStrategy {
+    calculate(samples: SolanaPriorityFeeResponse[] | HeliusPriorityFeeResponse | DriftPriorityFeeResponse): number;
+}
+export declare enum PriorityFeeMethod {
+    SOLANA = "solana",
+    HELIUS = "helius",
+    DRIFT = "drift"
+}
+export type PriorityFeeSubscriberConfig = {
+    connection?: Connection;
+    frequencyMs?: number;
+    addresses?: PublicKey[];
+    driftMarkets?: DriftMarketInfo[];
+    customStrategy?: PriorityFeeStrategy;
+    priorityFeeMethod?: PriorityFeeMethod;
+    slotsToCheck?: number;
+    heliusRpcUrl?: string;
+    driftPriorityFeeEndpoint?: string;
+    maxFeeMicroLamports?: number;
+    priorityFeeMultiplier?: number;
+};
+export type PriorityFeeSubscriberMapConfig = {
+    frequencyMs?: number;
+    driftMarkets?: DriftMarketInfo[];
+    driftPriorityFeeEndpoint: string;
+};

package/lib/browser/priorityFee/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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";
+    PriorityFeeMethod["HELIUS"] = "helius";
+    PriorityFeeMethod["DRIFT"] = "drift";
+})(PriorityFeeMethod = exports.PriorityFeeMethod || (exports.PriorityFeeMethod = {}));

package/lib/browser/serum/serumFulfillmentConfigMap.d.ts

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

package/lib/browser/serum/serumFulfillmentConfigMap.js

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

package/lib/browser/serum/serumSubscriber.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="bn.js" />
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+import { Market, Orderbook } from '@project-serum/serum';
+import { SerumMarketSubscriberConfig } from './types';
+import { BN } from '@coral-xyz/anchor';
+import { L2Level, L2OrderBookGenerator } from '../dlob/orderBookLevels';
+export declare class SerumSubscriber implements L2OrderBookGenerator {
+    connection: Connection;
+    programId: PublicKey;
+    marketAddress: PublicKey;
+    subscriptionType: 'polling' | 'websocket';
+    accountLoader: BulkAccountLoader | undefined;
+    market: Market;
+    subscribed: boolean;
+    asksAddress: PublicKey;
+    asks: Orderbook;
+    asksCallbackId: string | number;
+    lastAsksSlot: number;
+    bidsAddress: PublicKey;
+    bids: Orderbook;
+    bidsCallbackId: string | number;
+    lastBidsSlot: number;
+    constructor(config: SerumMarketSubscriberConfig);
+    subscribe(): Promise<void>;
+    getBestBid(): BN | undefined;
+    getBestAsk(): BN | undefined;
+    getL2Bids(): Generator<L2Level>;
+    getL2Asks(): Generator<L2Level>;
+    getL2Levels(side: 'bids' | 'asks'): Generator<L2Level>;
+    unsubscribe(): Promise<void>;
+}