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

package/lib/node/oracles/pythPullClient.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="bn.js" />
+import { Connection, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BN, Program } from '@coral-xyz/anchor';
+import { PythSolanaReceiverProgram } from '@pythnetwork/pyth-solana-receiver';
+import { PriceUpdateAccount } from '@pythnetwork/pyth-solana-receiver/lib/PythSolanaReceiver';
+export declare class PythPullClient implements OracleClient {
+    private connection;
+    private multiple;
+    private stableCoin;
+    readonly receiver: Program<PythSolanaReceiverProgram>;
+    readonly decodeFunc: (name: string, data: Buffer) => PriceUpdateAccount;
+    constructor(connection: Connection, multiple?: BN, stableCoin?: boolean);
+    getOraclePriceData(pricePublicKey: PublicKey): Promise<OraclePriceData>;
+    getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
+}
+export declare function convertPythPrice(price: BN, exponent: number, multiple: BN): BN;

package/lib/node/oracles/pythPullClient.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPythPrice = exports.PythPullClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const pyth_solana_receiver_1 = require("@pythnetwork/pyth-solana-receiver");
+const __1 = require("..");
+class PythPullClient {
+    constructor(connection, multiple = numericConstants_1.ONE, stableCoin = false) {
+        this.connection = connection;
+        this.multiple = multiple;
+        this.stableCoin = stableCoin;
+        const provider = new anchor_1.AnchorProvider(this.connection, 
+        //@ts-ignore
+        new __1.Wallet(new web3_js_1.Keypair()), {
+            commitment: connection.commitment,
+        });
+        this.receiver = new anchor_1.Program(pyth_solana_receiver_1.pythSolanaReceiverIdl, __1.DRIFT_ORACLE_RECEIVER_ID, provider);
+        this.decodeFunc =
+            this.receiver.account.priceUpdateV2.coder.accounts.decodeUnchecked.bind(this.receiver.account.priceUpdateV2.coder.accounts);
+    }
+    async getOraclePriceData(pricePublicKey) {
+        const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+        return this.getOraclePriceDataFromBuffer(accountInfo.data);
+    }
+    getOraclePriceDataFromBuffer(buffer) {
+        const message = this.decodeFunc('priceUpdateV2', buffer);
+        const priceData = message.priceMessage;
+        const confidence = convertPythPrice(priceData.conf, priceData.exponent, this.multiple);
+        let price = convertPythPrice(priceData.price, priceData.exponent, this.multiple);
+        if (this.stableCoin) {
+            price = getStableCoinPrice(price, confidence);
+        }
+        return {
+            price,
+            slot: message.postedSlot,
+            confidence,
+            twap: convertPythPrice(priceData.price, priceData.exponent, this.multiple),
+            twapConfidence: convertPythPrice(priceData.price, priceData.exponent, this.multiple),
+            hasSufficientNumberOfDataPoints: true,
+        };
+    }
+}
+exports.PythPullClient = PythPullClient;
+function convertPythPrice(price, exponent, multiple) {
+    exponent = Math.abs(exponent);
+    const pythPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(exponent).abs()).div(multiple);
+    return price.mul(numericConstants_1.PRICE_PRECISION).div(pythPrecision);
+}
+exports.convertPythPrice = convertPythPrice;
+const fiveBPS = new anchor_1.BN(500);
+function getStableCoinPrice(price, confidence) {
+    if (price.sub(numericConstants_1.QUOTE_PRECISION).abs().lt(anchor_1.BN.min(confidence, fiveBPS))) {
+        return numericConstants_1.QUOTE_PRECISION;
+    }
+    else {
+        return price;
+    }
+}

package/lib/node/oracles/quoteAssetOracleClient.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+export declare const QUOTE_ORACLE_PRICE_DATA: OraclePriceData;
+export declare class QuoteAssetOracleClient implements OracleClient {
+    constructor();
+    getOraclePriceData(_pricePublicKey: PublicKey): Promise<OraclePriceData>;
+    getOraclePriceDataFromBuffer(_buffer: Buffer): OraclePriceData;
+}

package/lib/node/oracles/quoteAssetOracleClient.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuoteAssetOracleClient = exports.QUOTE_ORACLE_PRICE_DATA = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+exports.QUOTE_ORACLE_PRICE_DATA = {
+    price: numericConstants_1.PRICE_PRECISION,
+    slot: new anchor_1.BN(0),
+    confidence: new anchor_1.BN(1),
+    hasSufficientNumberOfDataPoints: true,
+};
+class QuoteAssetOracleClient {
+    constructor() { }
+    async getOraclePriceData(_pricePublicKey) {
+        return Promise.resolve(exports.QUOTE_ORACLE_PRICE_DATA);
+    }
+    getOraclePriceDataFromBuffer(_buffer) {
+        return exports.QUOTE_ORACLE_PRICE_DATA;
+    }
+}
+exports.QuoteAssetOracleClient = QuoteAssetOracleClient;

package/lib/node/oracles/strictOraclePrice.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="bn.js" />
+import { BN } from '@coral-xyz/anchor';
+export declare class StrictOraclePrice {
+    current: BN;
+    twap?: BN;
+    constructor(current: BN, twap?: BN);
+    max(): BN;
+    min(): BN;
+}

package/lib/node/oracles/strictOraclePrice.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrictOraclePrice = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+class StrictOraclePrice {
+    constructor(current, twap) {
+        this.current = current;
+        this.twap = twap;
+    }
+    max() {
+        return this.twap ? anchor_1.BN.max(this.twap, this.current) : this.current;
+    }
+    min() {
+        return this.twap ? anchor_1.BN.min(this.twap, this.current) : this.current;
+    }
+}
+exports.StrictOraclePrice = StrictOraclePrice;

package/lib/node/oracles/switchboardClient.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Connection, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BorshAccountsCoder } from '@coral-xyz/anchor';
+export declare class SwitchboardClient implements OracleClient {
+    connection: Connection;
+    coder: BorshAccountsCoder;
+    constructor(connection: Connection);
+    getOraclePriceData(pricePublicKey: PublicKey): Promise<OraclePriceData>;
+    getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
+}

package/lib/node/oracles/switchboardClient.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwitchboardClient = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const switchboard_json_1 = __importDefault(require("../idl/switchboard.json"));
+const anchor_1 = require("@coral-xyz/anchor");
+class SwitchboardClient {
+    constructor(connection) {
+        this.connection = connection;
+        this.coder = new anchor_1.BorshAccountsCoder(switchboard_json_1.default);
+    }
+    async getOraclePriceData(pricePublicKey) {
+        const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+        return this.getOraclePriceDataFromBuffer(accountInfo.data);
+    }
+    getOraclePriceDataFromBuffer(buffer) {
+        const aggregatorAccountData = this.coder.decodeUnchecked('AggregatorAccountData', buffer);
+        const price = convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound.result);
+        const confidence = anchor_1.BN.max(convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound.stdDeviation), price.divn(1000));
+        const hasSufficientNumberOfDataPoints = aggregatorAccountData.latestConfirmedRound.numSuccess >=
+            aggregatorAccountData.minOracleResults;
+        const slot = aggregatorAccountData.latestConfirmedRound.roundOpenSlot;
+        return {
+            price,
+            slot,
+            confidence,
+            hasSufficientNumberOfDataPoints,
+        };
+    }
+}
+exports.SwitchboardClient = SwitchboardClient;
+function convertSwitchboardDecimal(switchboardDecimal) {
+    const switchboardPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(switchboardDecimal.scale));
+    return switchboardDecimal.mantissa
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .div(switchboardPrecision);
+}

package/lib/node/oracles/switchboardOnDemandClient.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Connection, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BorshAccountsCoder as BorshAccountsCoder30 } from '@coral-xyz/anchor-30';
+export declare class SwitchboardOnDemandClient implements OracleClient {
+    connection: Connection;
+    coder: BorshAccountsCoder30;
+    constructor(connection: Connection);
+    getOraclePriceData(pricePublicKey: PublicKey): Promise<OraclePriceData>;
+    getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
+}

package/lib/node/oracles/switchboardOnDemandClient.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwitchboardOnDemandClient = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const switchboard_on_demand_30_json_1 = __importDefault(require("../idl/switchboard_on_demand_30.json"));
+const numericConstants_1 = require("../constants/numericConstants");
+const anchor_30_1 = require("@coral-xyz/anchor-30");
+const SB_PRECISION_EXP = new anchor_1.BN(18);
+const SB_PRECISION = new anchor_1.BN(10).pow(SB_PRECISION_EXP.sub(numericConstants_1.PRICE_PRECISION_EXP));
+class SwitchboardOnDemandClient {
+    constructor(connection) {
+        this.connection = connection;
+        this.coder = new anchor_30_1.BorshAccountsCoder(switchboard_on_demand_30_json_1.default);
+    }
+    async getOraclePriceData(pricePublicKey) {
+        const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+        return this.getOraclePriceDataFromBuffer(accountInfo.data);
+    }
+    getOraclePriceDataFromBuffer(buffer) {
+        const pullFeedAccountData = this.coder.decodeUnchecked('PullFeedAccountData', buffer);
+        return {
+            price: pullFeedAccountData.result.value.div(SB_PRECISION),
+            slot: pullFeedAccountData.result.slot,
+            confidence: pullFeedAccountData.result.range.div(SB_PRECISION),
+            hasSufficientNumberOfDataPoints: true,
+        };
+    }
+}
+exports.SwitchboardOnDemandClient = SwitchboardOnDemandClient;

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

@@ -0,0 +1,23 @@
+/// <reference types="bn.js" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { BN } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { OracleSource } from '../types';
+export type OraclePriceData = {
+    price: BN;
+    slot: BN;
+    confidence: BN;
+    hasSufficientNumberOfDataPoints: boolean;
+    twap?: BN;
+    twapConfidence?: BN;
+    maxPrice?: BN;
+};
+export type OracleInfo = {
+    publicKey: PublicKey;
+    source: OracleSource;
+};
+export interface OracleClient {
+    getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
+    getOraclePriceData(publicKey: PublicKey): Promise<OraclePriceData>;
+}

package/lib/node/oracles/types.js

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

package/lib/node/orderParams.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="bn.js" />
+import { OptionalOrderParams, OrderParams, OrderTriggerCondition } from './types';
+import { BN } from '@coral-xyz/anchor';
+export declare function getLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+    price: BN;
+}): OptionalOrderParams;
+export declare function getTriggerMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+    triggerCondition: OrderTriggerCondition;
+    triggerPrice: BN;
+}): OptionalOrderParams;
+export declare function getTriggerLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+    triggerCondition: OrderTriggerCondition;
+    triggerPrice: BN;
+    price: BN;
+}): OptionalOrderParams;
+export declare function getMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType'>): OptionalOrderParams;
+/**
+ * Creates an OrderParams object with the given OptionalOrderParams and any params to override.
+ *
+ * example:
+ * ```
+ * const orderParams = getOrderParams(optionalOrderParams, { marketType: MarketType.PERP });
+ * ```
+ *
+ * @param optionalOrderParams
+ * @param overridingParams
+ * @returns
+ */
+export declare function getOrderParams(optionalOrderParams: OptionalOrderParams, overridingParams?: Record<string, any>): OrderParams;

package/lib/node/orderParams.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrderParams = exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
+const types_1 = require("./types");
+function getLimitOrderParams(params) {
+    return getOrderParams(Object.assign({}, params, {
+        orderType: types_1.OrderType.LIMIT,
+    }));
+}
+exports.getLimitOrderParams = getLimitOrderParams;
+function getTriggerMarketOrderParams(params) {
+    return getOrderParams(Object.assign({}, params, {
+        orderType: types_1.OrderType.TRIGGER_MARKET,
+    }));
+}
+exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
+function getTriggerLimitOrderParams(params) {
+    return getOrderParams(Object.assign({}, params, {
+        orderType: types_1.OrderType.TRIGGER_LIMIT,
+    }));
+}
+exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
+function getMarketOrderParams(params) {
+    return getOrderParams(Object.assign({}, params, {
+        orderType: types_1.OrderType.MARKET,
+    }));
+}
+exports.getMarketOrderParams = getMarketOrderParams;
+/**
+ * Creates an OrderParams object with the given OptionalOrderParams and any params to override.
+ *
+ * example:
+ * ```
+ * const orderParams = getOrderParams(optionalOrderParams, { marketType: MarketType.PERP });
+ * ```
+ *
+ * @param optionalOrderParams
+ * @param overridingParams
+ * @returns
+ */
+function getOrderParams(optionalOrderParams, overridingParams = {}) {
+    return Object.assign({}, types_1.DefaultOrderParams, optionalOrderParams, overridingParams);
+}
+exports.getOrderParams = getOrderParams;

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

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { DriftClient } from '../driftClient';
+import { UserAccount } from '../types';
+import { Commitment } from '@solana/web3.js';
+import { Buffer } from 'buffer';
+import { DLOB } from '../dlob/DLOB';
+import { OrderSubscriberConfig, OrderSubscriberEvents } from './types';
+import { PollingSubscription } from './PollingSubscription';
+import { WebsocketSubscription } from './WebsocketSubscription';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { grpcSubscription } from './grpcSubscription';
+export declare class OrderSubscriber {
+    driftClient: DriftClient;
+    usersAccounts: Map<string, {
+        slot: number;
+        userAccount: UserAccount;
+    }>;
+    subscription: PollingSubscription | WebsocketSubscription | grpcSubscription;
+    commitment: Commitment;
+    eventEmitter: StrictEventEmitter<EventEmitter, OrderSubscriberEvents>;
+    fetchPromise?: Promise<void>;
+    fetchPromiseResolver: () => void;
+    mostRecentSlot: number;
+    decodeFn: (name: string, data: Buffer) => UserAccount;
+    decodeData?: boolean;
+    constructor(config: OrderSubscriberConfig);
+    subscribe(): Promise<void>;
+    fetch(): Promise<void>;
+    tryUpdateUserAccount(key: string, dataType: 'raw' | 'decoded' | 'buffer', data: string[] | UserAccount | Buffer, slot: number): void;
+    /**
+     * Creates a new DLOB for the order subscriber to fill. This will allow a
+     * caller to extend the DLOB Subscriber with a custom DLOB type.
+     * @returns New, empty DLOB object.
+     */
+    protected createDLOB(): DLOB;
+    getDLOB(slot: number): Promise<DLOB>;
+    getSlot(): number;
+    unsubscribe(): Promise<void>;
+}

package/lib/node/orderSubscriber/OrderSubscriber.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderSubscriber = void 0;
+const memcmp_1 = require("../memcmp");
+const web3_js_1 = require("@solana/web3.js");
+const buffer_1 = require("buffer");
+const DLOB_1 = require("../dlob/DLOB");
+const PollingSubscription_1 = require("./PollingSubscription");
+const WebsocketSubscription_1 = require("./WebsocketSubscription");
+const events_1 = require("events");
+const index_1 = require("../index");
+const user_1 = require("../decode/user");
+const grpcSubscription_1 = require("./grpcSubscription");
+const userStatus_1 = require("../math/userStatus");
+class OrderSubscriber {
+    constructor(config) {
+        var _a, _b, _c, _d, _e;
+        this.usersAccounts = new Map();
+        this.driftClient = config.driftClient;
+        this.commitment = config.subscriptionConfig.commitment || 'processed';
+        if (config.subscriptionConfig.type === 'polling') {
+            this.subscription = new PollingSubscription_1.PollingSubscription({
+                orderSubscriber: this,
+                frequency: config.subscriptionConfig.frequency,
+            });
+        }
+        else if (config.subscriptionConfig.type === 'grpc') {
+            this.subscription = new grpcSubscription_1.grpcSubscription({
+                orderSubscriber: this,
+                grpcConfigs: config.subscriptionConfig.grpcConfigs,
+                skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
+                resubOpts: {
+                    resubTimeoutMs: (_a = config.subscriptionConfig) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs,
+                    logResubMessages: (_b = config.subscriptionConfig) === null || _b === void 0 ? void 0 : _b.logResubMessages,
+                },
+                resyncIntervalMs: config.subscriptionConfig.resyncIntervalMs,
+                decoded: config.decodeData,
+            });
+        }
+        else {
+            this.subscription = new WebsocketSubscription_1.WebsocketSubscription({
+                orderSubscriber: this,
+                commitment: this.commitment,
+                skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
+                resubOpts: {
+                    resubTimeoutMs: (_c = config.subscriptionConfig) === null || _c === void 0 ? void 0 : _c.resubTimeoutMs,
+                    logResubMessages: (_d = config.subscriptionConfig) === null || _d === void 0 ? void 0 : _d.logResubMessages,
+                },
+                resyncIntervalMs: config.subscriptionConfig.resyncIntervalMs,
+                decoded: config.decodeData,
+            });
+        }
+        if ((_e = config.fastDecode) !== null && _e !== void 0 ? _e : true) {
+            this.decodeFn = (name, data) => (0, user_1.decodeUser)(data);
+        }
+        else {
+            this.decodeFn =
+                this.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(this.driftClient.program.account.user.coder.accounts);
+        }
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    async subscribe() {
+        await this.subscription.subscribe();
+    }
+    async fetch() {
+        if (this.fetchPromise) {
+            return this.fetchPromise;
+        }
+        this.fetchPromise = new Promise((resolver) => {
+            this.fetchPromiseResolver = resolver;
+        });
+        try {
+            const rpcRequestArgs = [
+                this.driftClient.program.programId.toBase58(),
+                {
+                    commitment: this.commitment,
+                    filters: [(0, memcmp_1.getUserFilter)(), (0, memcmp_1.getUserWithOrderFilter)()],
+                    encoding: 'base64',
+                    withContext: true,
+                },
+            ];
+            const rpcJSONResponse = 
+            // @ts-ignore
+            await this.driftClient.connection._rpcRequest('getProgramAccounts', rpcRequestArgs);
+            const rpcResponseAndContext = rpcJSONResponse.result;
+            const slot = rpcResponseAndContext.context.slot;
+            for (const programAccount of rpcResponseAndContext.value) {
+                const key = programAccount.pubkey.toString();
+                this.tryUpdateUserAccount(key, 'raw', programAccount.account.data, slot);
+                // give event loop a chance to breathe
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        finally {
+            this.fetchPromiseResolver();
+            this.fetchPromise = undefined;
+        }
+    }
+    tryUpdateUserAccount(key, dataType, data, slot) {
+        if (!this.mostRecentSlot || slot > this.mostRecentSlot) {
+            this.mostRecentSlot = slot;
+        }
+        this.eventEmitter.emit('updateReceived', new web3_js_1.PublicKey(key), slot, dataType);
+        const slotAndUserAccount = this.usersAccounts.get(key);
+        if (!slotAndUserAccount || slotAndUserAccount.slot <= slot) {
+            let userAccount;
+            // Polling leads to a lot of redundant decoding, so we only decode if data is from a fresh slot
+            if (dataType === 'raw') {
+                // @ts-ignore
+                const buffer = buffer_1.Buffer.from(data[0], data[1]);
+                const newLastActiveSlot = new index_1.BN(buffer.subarray(4328, 4328 + 8), undefined, 'le');
+                if (slotAndUserAccount &&
+                    slotAndUserAccount.userAccount.lastActiveSlot.gt(newLastActiveSlot)) {
+                    return;
+                }
+                userAccount = this.decodeFn('User', buffer);
+            }
+            else if (dataType === 'buffer') {
+                const buffer = data;
+                const newLastActiveSlot = new index_1.BN(buffer.subarray(4328, 4328 + 8), undefined, 'le');
+                if (slotAndUserAccount &&
+                    slotAndUserAccount.userAccount.lastActiveSlot.gt(newLastActiveSlot)) {
+                    return;
+                }
+                userAccount = this.decodeFn('User', data);
+            }
+            else {
+                userAccount = data;
+            }
+            this.eventEmitter.emit('userUpdated', userAccount, new web3_js_1.PublicKey(key), slot, dataType);
+            const newOrders = userAccount.orders.filter((order) => {
+                var _a;
+                return order.slot.toNumber() > ((_a = slotAndUserAccount === null || slotAndUserAccount === void 0 ? void 0 : slotAndUserAccount.slot) !== null && _a !== void 0 ? _a : 0) &&
+                    order.slot.toNumber() <= slot;
+            });
+            if (newOrders.length > 0) {
+                this.eventEmitter.emit('orderCreated', userAccount, newOrders, new web3_js_1.PublicKey(key), slot, dataType);
+            }
+            this.usersAccounts.set(key, { slot, userAccount });
+        }
+    }
+    /**
+     * Creates a new DLOB for the order subscriber to fill. This will allow a
+     * caller to extend the DLOB Subscriber with a custom DLOB type.
+     * @returns New, empty DLOB object.
+     */
+    createDLOB() {
+        return new DLOB_1.DLOB();
+    }
+    async getDLOB(slot) {
+        const dlob = this.createDLOB();
+        for (const [key, { userAccount }] of this.usersAccounts.entries()) {
+            const protectedMaker = (0, userStatus_1.isUserProtectedMaker)(userAccount);
+            for (const order of userAccount.orders) {
+                dlob.insertOrder(order, key, slot, protectedMaker);
+            }
+        }
+        return dlob;
+    }
+    getSlot() {
+        var _a;
+        return (_a = this.mostRecentSlot) !== null && _a !== void 0 ? _a : 0;
+    }
+    async unsubscribe() {
+        this.usersAccounts.clear();
+        await this.subscription.unsubscribe();
+    }
+}
+exports.OrderSubscriber = OrderSubscriber;

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

@@ -0,0 +1,12 @@
+import { OrderSubscriber } from './OrderSubscriber';
+export declare class PollingSubscription {
+    private orderSubscriber;
+    private frequency;
+    intervalId?: ReturnType<typeof setTimeout>;
+    constructor({ orderSubscriber, frequency, }: {
+        orderSubscriber: OrderSubscriber;
+        frequency: number;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/node/orderSubscriber/PollingSubscription.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingSubscription = void 0;
+class PollingSubscription {
+    constructor({ orderSubscriber, frequency, }) {
+        this.orderSubscriber = orderSubscriber;
+        this.frequency = frequency;
+    }
+    async subscribe() {
+        if (this.intervalId) {
+            return;
+        }
+        this.intervalId = setInterval(this.orderSubscriber.fetch.bind(this.orderSubscriber), this.frequency);
+        await this.orderSubscriber.fetch();
+    }
+    async unsubscribe() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+}
+exports.PollingSubscription = PollingSubscription;

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

@@ -0,0 +1,23 @@
+import { OrderSubscriber } from './OrderSubscriber';
+import { Commitment } from '@solana/web3.js';
+import { ResubOpts } from '../accounts/types';
+export declare class WebsocketSubscription {
+    private orderSubscriber;
+    private commitment;
+    private skipInitialLoad;
+    private resubOpts?;
+    private resyncIntervalMs?;
+    private subscriber?;
+    private resyncTimeoutId?;
+    private decoded?;
+    constructor({ orderSubscriber, commitment, skipInitialLoad, resubOpts, resyncIntervalMs, decoded, }: {
+        orderSubscriber: OrderSubscriber;
+        commitment: Commitment;
+        skipInitialLoad?: boolean;
+        resubOpts?: ResubOpts;
+        resyncIntervalMs?: number;
+        decoded?: boolean;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}