@drift-labs/sdk 2.97.0-beta.9 → 2.98.0-beta.0

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

package/lib/node/serum/serumSubscriber.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerumSubscriber = void 0;
+const serum_1 = require("@project-serum/serum");
+const anchor_1 = require("@coral-xyz/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+class SerumSubscriber {
+    constructor(config) {
+        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';
+        }
+    }
+    async subscribe() {
+        if (this.subscribed) {
+            return;
+        }
+        this.market = await serum_1.Market.load(this.connection, this.marketAddress, undefined, this.programId);
+        this.asksAddress = this.market.asksAddress;
+        this.asks = await this.market.loadAsks(this.connection);
+        if (this.subscriptionType === 'websocket') {
+            this.asksCallbackId = this.connection.onAccountChange(this.asksAddress, (accountInfo, ctx) => {
+                this.lastAsksSlot = ctx.slot;
+                this.asks = serum_1.Orderbook.decode(this.market, accountInfo.data);
+            });
+        }
+        else {
+            this.asksCallbackId = await this.accountLoader.addAccount(this.asksAddress, (buffer, slot) => {
+                this.lastAsksSlot = slot;
+                this.asks = serum_1.Orderbook.decode(this.market, buffer);
+            });
+        }
+        this.bidsAddress = this.market.bidsAddress;
+        this.bids = await this.market.loadBids(this.connection);
+        if (this.subscriptionType === 'websocket') {
+            this.bidsCallbackId = this.connection.onAccountChange(this.bidsAddress, (accountInfo, ctx) => {
+                this.lastBidsSlot = ctx.slot;
+                this.bids = serum_1.Orderbook.decode(this.market, accountInfo.data);
+            });
+        }
+        else {
+            this.bidsCallbackId = await this.accountLoader.addAccount(this.bidsAddress, (buffer, slot) => {
+                this.lastBidsSlot = slot;
+                this.bids = serum_1.Orderbook.decode(this.market, buffer);
+            });
+        }
+        this.subscribed = true;
+    }
+    getBestBid() {
+        const bestBid = this.bids.getL2(1)[0];
+        if (!bestBid) {
+            return undefined;
+        }
+        return new anchor_1.BN(bestBid[0] * numericConstants_1.PRICE_PRECISION.toNumber());
+    }
+    getBestAsk() {
+        const bestAsk = this.asks.getL2(1)[0];
+        if (!bestAsk) {
+            return undefined;
+        }
+        return new anchor_1.BN(bestAsk[0] * numericConstants_1.PRICE_PRECISION.toNumber());
+    }
+    getL2Bids() {
+        return this.getL2Levels('bids');
+    }
+    getL2Asks() {
+        return this.getL2Levels('asks');
+    }
+    *getL2Levels(side) {
+        // @ts-ignore
+        const basePrecision = Math.pow(10, this.market._baseSplTokenDecimals);
+        const pricePrecision = numericConstants_1.PRICE_PRECISION.toNumber();
+        for (const { price: priceNum, size: sizeNum } of this[side].items(side === 'bids')) {
+            const price = new anchor_1.BN(priceNum * pricePrecision);
+            const size = new anchor_1.BN(sizeNum * basePrecision);
+            yield {
+                price,
+                size,
+                sources: {
+                    serum: size,
+                },
+            };
+        }
+    }
+    async unsubscribe() {
+        if (!this.subscribed) {
+            return;
+        }
+        // remove listeners
+        if (this.subscriptionType === 'websocket') {
+            await this.connection.removeAccountChangeListener(this.asksCallbackId);
+            await this.connection.removeAccountChangeListener(this.bidsCallbackId);
+        }
+        else {
+            this.accountLoader.removeAccount(this.asksAddress, this.asksCallbackId);
+            this.accountLoader.removeAccount(this.bidsAddress, this.bidsCallbackId);
+        }
+        this.subscribed = false;
+    }
+}
+exports.SerumSubscriber = SerumSubscriber;

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

@@ -0,0 +1,13 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+export type SerumMarketSubscriberConfig = {
+    connection: Connection;
+    programId: PublicKey;
+    marketAddress: PublicKey;
+    accountSubscription: {
+        type: 'polling';
+        accountLoader: BulkAccountLoader;
+    } | {
+        type: 'websocket';
+    };
+};

package/lib/node/serum/types.js

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

package/lib/node/slot/SlotSubscriber.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Connection } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
+type SlotSubscriberConfig = {
+    resubTimeoutMs?: number;
+};
+export interface SlotSubscriberEvents {
+    newSlot: (newSlot: number) => void;
+}
+export declare class SlotSubscriber {
+    private connection;
+    currentSlot: number;
+    subscriptionId: number;
+    eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
+    timeoutId?: NodeJS.Timeout;
+    resubTimeoutMs?: number;
+    isUnsubscribing: boolean;
+    receivingData: boolean;
+    constructor(connection: Connection, config?: SlotSubscriberConfig);
+    subscribe(): Promise<void>;
+    private setTimeout;
+    getSlot(): number;
+    unsubscribe(onResub?: boolean): Promise<void>;
+}
+export {};