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

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,170 @@
+"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");
+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()) {
+            for (const order of userAccount.orders) {
+                dlob.insertOrder(order, key, slot);
+            }
+        }
+        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>;
+}

package/lib/node/orderSubscriber/WebsocketSubscription.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebsocketSubscription = void 0;
+const memcmp_1 = require("../memcmp");
+const webSocketProgramAccountSubscriber_1 = require("../accounts/webSocketProgramAccountSubscriber");
+class WebsocketSubscription {
+    constructor({ orderSubscriber, commitment, skipInitialLoad = false, resubOpts, resyncIntervalMs, decoded = true, }) {
+        this.orderSubscriber = orderSubscriber;
+        this.commitment = commitment;
+        this.skipInitialLoad = skipInitialLoad;
+        this.resubOpts = resubOpts;
+        this.resyncIntervalMs = resyncIntervalMs;
+        this.decoded = decoded;
+    }
+    async subscribe() {
+        if (this.subscriber) {
+            return;
+        }
+        this.subscriber = new webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber('OrderSubscriber', 'User', this.orderSubscriber.driftClient.program, this.orderSubscriber.decodeFn, {
+            filters: [(0, memcmp_1.getUserFilter)(), (0, memcmp_1.getNonIdleUserFilter)()],
+            commitment: this.commitment,
+        }, this.resubOpts);
+        await this.subscriber.subscribe((accountId, account, context, buffer) => {
+            var _a;
+            const userKey = accountId.toBase58();
+            if ((_a = this.decoded) !== null && _a !== void 0 ? _a : true) {
+                this.orderSubscriber.tryUpdateUserAccount(userKey, 'decoded', account, context.slot);
+            }
+            else {
+                this.orderSubscriber.tryUpdateUserAccount(userKey, 'buffer', buffer, context.slot);
+            }
+        });
+        if (!this.skipInitialLoad) {
+            await this.orderSubscriber.fetch();
+        }
+        if (this.resyncIntervalMs) {
+            const recursiveResync = () => {
+                this.resyncTimeoutId = setTimeout(() => {
+                    this.orderSubscriber
+                        .fetch()
+                        .catch((e) => {
+                        console.error('Failed to resync in OrderSubscriber');
+                        console.log(e);
+                    })
+                        .finally(() => {
+                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        if (!this.resyncTimeoutId)
+                            return;
+                        recursiveResync();
+                    });
+                }, this.resyncIntervalMs);
+            };
+            recursiveResync();
+        }
+    }
+    async unsubscribe() {
+        if (!this.subscriber)
+            return;
+        await this.subscriber.unsubscribe();
+        this.subscriber = undefined;
+        if (this.resyncTimeoutId !== undefined) {
+            clearTimeout(this.resyncTimeoutId);
+            this.resyncTimeoutId = undefined;
+        }
+    }
+}
+exports.WebsocketSubscription = WebsocketSubscription;

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

@@ -0,0 +1,22 @@
+import { OrderSubscriber } from './OrderSubscriber';
+import { GrpcConfigs, ResubOpts } from '../accounts/types';
+export declare class grpcSubscription {
+    private orderSubscriber;
+    private skipInitialLoad;
+    private resubOpts?;
+    private resyncIntervalMs?;
+    private subscriber?;
+    private resyncTimeoutId?;
+    private decoded?;
+    private grpcConfigs;
+    constructor({ grpcConfigs, orderSubscriber, skipInitialLoad, resubOpts, resyncIntervalMs, decoded, }: {
+        grpcConfigs: GrpcConfigs;
+        orderSubscriber: OrderSubscriber;
+        skipInitialLoad?: boolean;
+        resubOpts?: ResubOpts;
+        resyncIntervalMs?: number;
+        decoded?: boolean;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/node/orderSubscriber/grpcSubscription.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcSubscription = void 0;
+const grpcProgramAccountSubscriber_1 = require("../accounts/grpcProgramAccountSubscriber");
+const memcmp_1 = require("../memcmp");
+class grpcSubscription {
+    constructor({ grpcConfigs, orderSubscriber, skipInitialLoad = false, resubOpts, resyncIntervalMs, decoded = true, }) {
+        this.orderSubscriber = orderSubscriber;
+        this.skipInitialLoad = skipInitialLoad;
+        this.resubOpts = resubOpts;
+        this.resyncIntervalMs = resyncIntervalMs;
+        this.decoded = decoded;
+        this.grpcConfigs = grpcConfigs;
+    }
+    async subscribe() {
+        if (this.subscriber) {
+            return;
+        }
+        this.subscriber = new grpcProgramAccountSubscriber_1.grpcProgramAccountSubscriber(this.grpcConfigs, 'OrderSubscriber', 'User', this.orderSubscriber.driftClient.program, this.orderSubscriber.decodeFn, {
+            filters: [(0, memcmp_1.getUserFilter)(), (0, memcmp_1.getNonIdleUserFilter)()],
+        }, this.resubOpts);
+        await this.subscriber.subscribe((accountId, account, context, buffer) => {
+            var _a;
+            const userKey = accountId.toBase58();
+            if ((_a = this.decoded) !== null && _a !== void 0 ? _a : true) {
+                this.orderSubscriber.tryUpdateUserAccount(userKey, 'decoded', account, context.slot);
+            }
+            else {
+                this.orderSubscriber.tryUpdateUserAccount(userKey, 'buffer', buffer, context.slot);
+            }
+        });
+        if (!this.skipInitialLoad) {
+            await this.orderSubscriber.fetch();
+        }
+        if (this.resyncIntervalMs) {
+            const recursiveResync = () => {
+                this.resyncTimeoutId = setTimeout(() => {
+                    this.orderSubscriber
+                        .fetch()
+                        .catch((e) => {
+                        console.error('Failed to resync in OrderSubscriber');
+                        console.log(e);
+                    })
+                        .finally(() => {
+                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        if (!this.resyncTimeoutId)
+                            return;
+                        recursiveResync();
+                    });
+                }, this.resyncIntervalMs);
+            };
+            recursiveResync();
+        }
+    }
+    async unsubscribe() {
+        if (!this.subscriber)
+            return;
+        await this.subscriber.unsubscribe();
+        this.subscriber = undefined;
+        if (this.resyncTimeoutId !== undefined) {
+            clearTimeout(this.resyncTimeoutId);
+            this.resyncTimeoutId = undefined;
+        }
+    }
+}
+exports.grpcSubscription = grpcSubscription;

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

@@ -0,0 +1,2 @@
+export * from './OrderSubscriber';
+export * from './types';

package/lib/{auctionSubscriber → node/orderSubscriber}/index.js

@@ -14,5 +14,5 @@ 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("./OrderSubscriber"), exports);
 __exportStar(require("./types"), exports);
-__exportStar(require("./auctionSubscriber"), exports);

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

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