@drift-labs/sdk 2.31.0-beta.1 → 2.31.0-beta.4

package/lib/accounts/bulkAccountLoader.js

@@ -124,6 +124,11 @@ class BulkAccountLoader {
         }
         for (const i in rpcResponses) {
             const rpcResponse = rpcResponses[i];
+            if (!rpcResponse.result) {
+                console.error('rpc response missing result:');
+                console.log(JSON.stringify(rpcResponse));
+                continue;
+            }
             const newSlot = rpcResponse.result.context.slot;
             if (newSlot > this.mostRecentSlot) {
                 this.mostRecentSlot = newSlot;

package/lib/auctionSubscriber/auctionSubscriber.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { AuctionSubscriberConfig, AuctionSubscriberEvents } from './types';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+export declare class AuctionSubscriber {
+    private driftClient;
+    private opts;
+    eventEmitter: StrictEventEmitter<EventEmitter, AuctionSubscriberEvents>;
+    private websocketId;
+    constructor({ driftClient, opts }: AuctionSubscriberConfig);
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/auctionSubscriber/auctionSubscriber.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuctionSubscriber = void 0;
+const memcmp_1 = require("../memcmp");
+class AuctionSubscriber {
+    constructor({ driftClient, opts }) {
+        this.driftClient = driftClient;
+        this.opts = opts || this.driftClient.opts;
+    }
+    async subscribe() {
+        this.websocketId = this.driftClient.connection.onProgramAccountChange(this.driftClient.program.programId, (keyAccountInfo, context) => {
+            const userAccount = this.driftClient.program.account.user.coder.accounts.decode('User', keyAccountInfo.accountInfo.data);
+            this.eventEmitter.emit('onAccountUpdate', userAccount, keyAccountInfo.accountId, context.slot);
+        }, this.driftClient.opts.commitment, [(0, memcmp_1.getUserFilter)(), (0, memcmp_1.getUserWithAuctionFilter)()]);
+    }
+    async unsubscribe() {
+        if (this.websocketId) {
+            await this.driftClient.connection.removeProgramAccountChangeListener(this.websocketId);
+        }
+    }
+}
+exports.AuctionSubscriber = AuctionSubscriber;

package/lib/auctionSubscriber/index.d.ts

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

package/lib/auctionSubscriber/index.js

@@ -0,0 +1,18 @@
+"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("./types"), exports);
+__exportStar(require("./auctionSubscriber"), exports);

package/lib/auctionSubscriber/types.d.ts

@@ -0,0 +1,10 @@
+import { DriftClient } from '../driftClient';
+import { UserAccount } from '../types';
+import { ConfirmOptions, PublicKey } from '@solana/web3.js';
+export type AuctionSubscriberConfig = {
+    driftClient: DriftClient;
+    opts?: ConfirmOptions;
+};
+export interface AuctionSubscriberEvents {
+    onAccountUpdate: (account: UserAccount, pubkey: PublicKey, slot: number) => void;
+}

package/lib/auctionSubscriber/types.js

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

package/lib/driftClient.d.ts

@@ -329,6 +329,8 @@ export declare class DriftClient {
     getForceCancelOrdersIx(userAccountPublicKey: PublicKey, userAccount: UserAccount): Promise<TransactionInstruction>;
     updateUserIdle(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams): Promise<TransactionSignature>;
     getUpdateUserIdleIx(userAccountPublicKey: PublicKey, userAccount: UserAccount): Promise<TransactionInstruction>;
+    updateUserOpenOrdersCount(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams): Promise<TransactionSignature>;
+    getUpdateUserOpenOrdersCountIx(userAccountPublicKey: PublicKey, userAccount: UserAccount): Promise<TransactionInstruction>;
     placeAndTakePerpOrder(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
     getPlaceAndTakePerpOrderIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     placeAndMakePerpOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;

package/lib/driftClient.js

@@ -51,6 +51,7 @@ const spotPosition_1 = require("./math/spotPosition");
 const market_1 = require("./math/market");
 const fetch_1 = require("./accounts/fetch");
 const spotMarket_1 = require("./math/spotMarket");
+const memcmp_1 = require("./memcmp");
 /**
  * # DriftClient
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -515,14 +516,7 @@ class DriftClient {
     async fetchAllUserAccounts(includeIdle = true) {
         let filters = undefined;
         if (!includeIdle) {
-            filters = [
-                {
-                    memcmp: {
-                        offset: 4350,
-                        bytes: bs58_1.default.encode(Uint8Array.from([0])),
-                    },
-                },
-            ];
+            filters = [(0, memcmp_1.getNonIdleUserFilter)()];
         }
         return (await this.program.account.user.all(filters));
     }
@@ -2024,7 +2018,7 @@ class DriftClient {
             ...jupiterInstructions,
             endSwapIx,
         ];
-        const tx = await this.buildTransaction(instructions, txParams, 0, lookupTables);
+        const tx = (await this.buildTransaction(instructions, txParams, 0, lookupTables));
         const { txSig, slot } = await this.sendTransaction(tx);
         this.spotMarketLastSlotCache.set(outMarketIndex, slot);
         this.spotMarketLastSlotCache.set(inMarketIndex, slot);
@@ -2152,6 +2146,25 @@ class DriftClient {
             remainingAccounts,
         });
     }
+    async updateUserOpenOrdersCount(userAccountPublicKey, user, txParams) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getUpdateUserOpenOrdersCountIx(userAccountPublicKey, user), txParams), [], this.opts);
+        return txSig;
+    }
+    async getUpdateUserOpenOrdersCountIx(userAccountPublicKey, userAccount) {
+        const fillerPublicKey = await this.getUserAccountPublicKey();
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [userAccount],
+        });
+        return await this.program.instruction.updateUserOpenOrdersCount({
+            accounts: {
+                state: await this.getStatePublicKey(),
+                filler: fillerPublicKey,
+                user: userAccountPublicKey,
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
     async placeAndTakePerpOrder(orderParams, makerInfo, referrerInfo, txParams) {
         const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo), txParams), [], this.opts);
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);

package/lib/events/eventSubscriber.d.ts

@@ -9,6 +9,7 @@ export declare class EventSubscriber {
     private connection;
     private program;
     private options;
+    private address;
     private eventListMap;
     private txEventCache;
     private awaitTxPromises;

package/lib/events/eventSubscriber.js

@@ -11,12 +11,14 @@ const events_1 = require("events");
 const sort_1 = require("./sort");
 class EventSubscriber {
     constructor(connection, program, options = types_1.DefaultEventSubscriptionOptions) {
+        var _a;
         this.connection = connection;
         this.program = program;
         this.options = options;
         this.awaitTxPromises = new Map();
         this.awaitTxResolver = new Map();
         this.options = Object.assign({}, types_1.DefaultEventSubscriptionOptions, options);
+        this.address = (_a = this.options.address) !== null && _a !== void 0 ? _a : program.programId;
         this.txEventCache = new txEventCache_1.TxEventCache(this.options.maxTx);
         this.eventListMap = new Map();
         for (const eventType of this.options.eventTypes) {
@@ -24,10 +26,10 @@ class EventSubscriber {
         }
         this.eventEmitter = new events_1.EventEmitter();
         if (this.options.logProviderConfig.type === 'websocket') {
-            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(this.connection, this.program.programId, this.options.commitment);
+            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(this.connection, this.address, this.options.commitment);
         }
         else {
-            this.logProvider = new pollingLogProvider_1.PollingLogProvider(this.connection, this.program.programId, options.commitment, this.options.logProviderConfig.frequency);
+            this.logProvider = new pollingLogProvider_1.PollingLogProvider(this.connection, this.address, options.commitment, this.options.logProviderConfig.frequency);
         }
     }
     async subscribe() {
@@ -80,7 +82,7 @@ class EventSubscriber {
         let beforeTx = undefined;
         const untilTx = this.options.untilTx;
         while (txFetched < this.options.maxTx) {
-            const response = await (0, fetchLogs_1.fetchLogs)(this.connection, this.program.programId, this.options.commitment === 'finalized' ? 'finalized' : 'confirmed', beforeTx, untilTx);
+            const response = await (0, fetchLogs_1.fetchLogs)(this.connection, this.address, this.options.commitment === 'finalized' ? 'finalized' : 'confirmed', beforeTx, untilTx);
             if (response === undefined) {
                 break;
             }

package/lib/events/fetchLogs.d.ts

@@ -14,7 +14,7 @@ type FetchLogsResponse = {
     transactionLogs: Log[];
     mostRecentBlockTime: number | undefined;
 };
-export declare function fetchLogs(connection: Connection, programId: PublicKey, finality: Finality, beforeTx?: TransactionSignature, untilTx?: TransactionSignature, limit?: number): Promise<FetchLogsResponse>;
+export declare function fetchLogs(connection: Connection, address: PublicKey, finality: Finality, beforeTx?: TransactionSignature, untilTx?: TransactionSignature, limit?: number): Promise<FetchLogsResponse>;
 export declare class LogParser {
     private program;
     constructor(program: Program);

package/lib/events/fetchLogs.js

@@ -8,8 +8,8 @@ function mapTransactionResponseToLog(transaction) {
         logs: transaction.meta.logMessages,
     };
 }
-async function fetchLogs(connection, programId, finality, beforeTx, untilTx, limit) {
-    const signatures = await connection.getSignaturesForAddress(programId, {
+async function fetchLogs(connection, address, finality, beforeTx, untilTx, limit) {
+    const signatures = await connection.getSignaturesForAddress(address, {
         before: beforeTx,
         until: untilTx,
         limit,

package/lib/events/pollingLogProvider.d.ts

@@ -2,14 +2,14 @@ import { LogProvider, logProviderCallback } from './types';
 import { Commitment, Connection, PublicKey } from '@solana/web3.js';
 export declare class PollingLogProvider implements LogProvider {
     private connection;
-    private programId;
+    private address;
     private frequency;
     private finality;
     private intervalId;
     private mostRecentSeenTx?;
     private mutex;
     private firstFetch;
-    constructor(connection: Connection, programId: PublicKey, commitment: Commitment, frequency?: number);
+    constructor(connection: Connection, address: PublicKey, commitment: Commitment, frequency?: number);
     subscribe(callback: logProviderCallback, skipHistory?: boolean): boolean;
     isSubscribed(): boolean;
     unsubscribe(): Promise<boolean>;

package/lib/events/pollingLogProvider.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PollingLogProvider = void 0;
 const fetchLogs_1 = require("./fetchLogs");
 class PollingLogProvider {
-    constructor(connection, programId, commitment, frequency = 15 * 1000) {
+    constructor(connection, address, commitment, frequency = 15 * 1000) {
         this.connection = connection;
-        this.programId = programId;
+        this.address = address;
         this.frequency = frequency;
         this.firstFetch = true;
         this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
@@ -20,7 +20,7 @@ class PollingLogProvider {
             }
             this.mutex = 1;
             try {
-                const response = await (0, fetchLogs_1.fetchLogs)(this.connection, this.programId, this.finality, undefined, this.mostRecentSeenTx, 
+                const response = await (0, fetchLogs_1.fetchLogs)(this.connection, this.address, this.finality, undefined, this.mostRecentSeenTx, 
                 // If skipping history, only fetch one log back, not the maximum amount available
                 skipHistory && this.firstFetch ? 1 : undefined);
                 if (response === undefined) {

package/lib/events/types.d.ts

@@ -1,6 +1,7 @@
-import { Commitment, TransactionSignature } from '@solana/web3.js';
+import { Commitment, PublicKey, TransactionSignature } from '@solana/web3.js';
 import { DepositRecord, FundingPaymentRecord, FundingRateRecord, LiquidationRecord, NewUserRecord, OrderActionRecord, OrderRecord, SettlePnlRecord, LPRecord, InsuranceFundRecord, SpotInterestRecord, InsuranceFundStakeRecord, CurveRecord, SwapRecord } from '../index';
 export type EventSubscriptionOptions = {
+    address?: PublicKey;
     eventTypes?: EventType[];
     maxEventsPerType?: number;
     orderBy?: EventSubscriptionOrderBy;

package/lib/events/webSocketLogProvider.d.ts

@@ -2,10 +2,10 @@ import { LogProvider, logProviderCallback } from './types';
 import { Commitment, Connection, PublicKey } from '@solana/web3.js';
 export declare class WebSocketLogProvider implements LogProvider {
     private connection;
-    private programId;
+    private address;
     private commitment;
     private subscriptionId;
-    constructor(connection: Connection, programId: PublicKey, commitment: Commitment);
+    constructor(connection: Connection, address: PublicKey, commitment: Commitment);
     subscribe(callback: logProviderCallback): boolean;
     isSubscribed(): boolean;
     unsubscribe(): Promise<boolean>;

package/lib/events/webSocketLogProvider.js

@@ -2,16 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocketLogProvider = void 0;
 class WebSocketLogProvider {
-    constructor(connection, programId, commitment) {
+    constructor(connection, address, commitment) {
         this.connection = connection;
-        this.programId = programId;
+        this.address = address;
         this.commitment = commitment;
     }
     subscribe(callback) {
         if (this.subscriptionId) {
             return true;
         }
-        this.subscriptionId = this.connection.onLogs(this.programId, (logs, ctx) => {
+        this.subscriptionId = this.connection.onLogs(this.address, (logs, ctx) => {
             callback(logs.signature, ctx.slot, logs.logs, undefined);
         }, this.commitment);
         return true;

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.31.0-beta.1",
+    "version": "2.31.0-beta.4",
     "name": "drift",
     "instructions": [
         {
@@ -1305,6 +1305,32 @@
             ],
             "args": []
         },
+        {
+            "name": "updateUserOpenOrdersCount",
+            "accounts": [
+                {
+                    "name": "state",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "authority",
+                    "isMut": false,
+                    "isSigner": true
+                },
+                {
+                    "name": "filler",
+                    "isMut": true,
+                    "isSigner": false
+                },
+                {
+                    "name": "user",
+                    "isMut": true,
+                    "isSigner": false
+                }
+            ],
+            "args": []
+        },
         {
             "name": "settlePnl",
             "accounts": [
@@ -5438,12 +5464,40 @@
                         ],
                         "type": "bool"
                     },
+                    {
+                        "name": "openOrders",
+                        "docs": [
+                            "number of open orders"
+                        ],
+                        "type": "u8"
+                    },
+                    {
+                        "name": "hasOpenOrder",
+                        "docs": [
+                            "Whether or not user has open order"
+                        ],
+                        "type": "bool"
+                    },
+                    {
+                        "name": "openAuctions",
+                        "docs": [
+                            "number of open orders with auction"
+                        ],
+                        "type": "u8"
+                    },
+                    {
+                        "name": "hasOpenAuction",
+                        "docs": [
+                            "Whether or not user has open order with auction"
+                        ],
+                        "type": "bool"
+                    },
                     {
                         "name": "padding",
                         "type": {
                             "array": [
                                 "u8",
-                                25
+                                21
                             ]
                         }
                     }
@@ -10433,6 +10487,11 @@
             "code": 6250,
             "name": "SpotMarketReduceOnly",
             "msg": "SpotMarketReduceOnly"
+        },
+        {
+            "code": 6251,
+            "name": "FundingWasNotUpdated",
+            "msg": "FundingWasNotUpdated"
         }
     ]
 }

package/lib/index.d.ts

@@ -74,4 +74,5 @@ export * from './dlob/orderBookLevels';
 export * from './userMap/userMap';
 export * from './userMap/userStatsMap';
 export * from './math/bankruptcy';
+export * from './orderSubscriber';
 export { BN, PublicKey, pyth };

package/lib/index.js

@@ -98,3 +98,4 @@ __exportStar(require("./dlob/orderBookLevels"), exports);
 __exportStar(require("./userMap/userMap"), exports);
 __exportStar(require("./userMap/userStatsMap"), exports);
 __exportStar(require("./math/bankruptcy"), exports);
+__exportStar(require("./orderSubscriber"), exports);

package/lib/math/spotBalance.js

@@ -189,7 +189,7 @@ function calculateInterestRate(bank) {
     else {
         const borrowRateSlope = new anchor_1.BN(bank.optimalBorrowRate)
             .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
-            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(new anchor_1.BN(bank.optimalUtilization)));
+            .div(new anchor_1.BN(bank.optimalUtilization));
         interestRate = utilization
             .mul(borrowRateSlope)
             .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);

package/lib/memcmp.d.ts

@@ -0,0 +1,5 @@
+import { MemcmpFilter } from '@solana/web3.js';
+export declare function getUserFilter(): MemcmpFilter;
+export declare function getNonIdleUserFilter(): MemcmpFilter;
+export declare function getUserWithOrderFilter(): MemcmpFilter;
+export declare function getUserWithAuctionFilter(): MemcmpFilter;

package/lib/memcmp.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserWithAuctionFilter = exports.getUserWithOrderFilter = exports.getNonIdleUserFilter = exports.getUserFilter = void 0;
+const bs58_1 = __importDefault(require("bs58"));
+const anchor_1 = require("@coral-xyz/anchor");
+function getUserFilter() {
+    return {
+        memcmp: {
+            offset: 0,
+            bytes: bs58_1.default.encode(anchor_1.BorshAccountsCoder.accountDiscriminator('User')),
+        },
+    };
+}
+exports.getUserFilter = getUserFilter;
+function getNonIdleUserFilter() {
+    return {
+        memcmp: {
+            offset: 4350,
+            bytes: bs58_1.default.encode(Uint8Array.from([0])),
+        },
+    };
+}
+exports.getNonIdleUserFilter = getNonIdleUserFilter;
+function getUserWithOrderFilter() {
+    return {
+        memcmp: {
+            offset: 4352,
+            bytes: bs58_1.default.encode(Uint8Array.from([1])),
+        },
+    };
+}
+exports.getUserWithOrderFilter = getUserWithOrderFilter;
+function getUserWithAuctionFilter() {
+    return {
+        memcmp: {
+            offset: 4354,
+            bytes: bs58_1.default.encode(Uint8Array.from([1])),
+        },
+    };
+}
+exports.getUserWithAuctionFilter = getUserWithAuctionFilter;

package/lib/orderSubscriber/OrderSubscriber.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { DriftClient } from '../driftClient';
+import { UserAccount } from '../types';
+import { Buffer } from 'buffer';
+import { DLOB } from '../dlob/DLOB';
+import { OrderSubscriberConfig } from './types';
+import { PollingSubscription } from './PollingSubscription';
+import { WebsocketSubscription } from './WebsocketSubscription';
+export declare class OrderSubscriber {
+    driftClient: DriftClient;
+    usersAccounts: Map<string, {
+        slot: number;
+        userAccount: UserAccount;
+    }>;
+    subscription: PollingSubscription | WebsocketSubscription;
+    fetchPromise?: Promise<void>;
+    fetchPromiseResolver: () => void;
+    constructor(config: OrderSubscriberConfig);
+    subscribe(): Promise<void>;
+    fetch(): Promise<void>;
+    tryUpdateUserAccount(key: string, buffer: Buffer, slot: number): void;
+    getDLOB(slot: number): Promise<DLOB>;
+    unsubscribe(): Promise<void>;
+}

package/lib/orderSubscriber/OrderSubscriber.js

@@ -0,0 +1,100 @@
+"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");
+class OrderSubscriber {
+    constructor(config) {
+        this.usersAccounts = new Map();
+        this.driftClient = config.driftClient;
+        if (config.subscriptionConfig.type === 'polling') {
+            this.subscription = new PollingSubscription_1.PollingSubscription({
+                orderSubscriber: this,
+                frequency: config.subscriptionConfig.frequency,
+            });
+        }
+        else {
+            this.subscription = new WebsocketSubscription_1.WebsocketSubscription({
+                orderSubscriber: this,
+                skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
+            });
+        }
+    }
+    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.driftClient.opts.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;
+            const programAccountSet = new Set();
+            for (const programAccount of rpcResponseAndContext.value) {
+                const key = programAccount.pubkey.toString();
+                // @ts-ignore
+                const buffer = buffer_1.Buffer.from(programAccount.account.data[0], programAccount.account.data[1]);
+                programAccountSet.add(key);
+                this.tryUpdateUserAccount(key, buffer, slot);
+            }
+            for (const key of this.usersAccounts.keys()) {
+                if (!programAccountSet.has(key)) {
+                    this.usersAccounts.delete(key);
+                }
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        finally {
+            this.fetchPromiseResolver();
+            this.fetchPromise = undefined;
+        }
+    }
+    tryUpdateUserAccount(key, buffer, slot) {
+        const slotAndUserAccount = this.usersAccounts.get(key);
+        if (!slotAndUserAccount || slotAndUserAccount.slot < slot) {
+            const userAccount = this.driftClient.program.account.user.coder.accounts.decode('User', buffer);
+            if (userAccount.hasOpenOrder) {
+                this.usersAccounts.set(key, { slot, userAccount });
+            }
+            else {
+                this.usersAccounts.delete(key);
+            }
+        }
+    }
+    async getDLOB(slot) {
+        const dlob = new DLOB_1.DLOB();
+        for (const [key, { userAccount }] of this.usersAccounts.entries()) {
+            const userAccountPubkey = new web3_js_1.PublicKey(key);
+            for (const order of userAccount.orders) {
+                dlob.insertOrder(order, userAccountPubkey, slot);
+            }
+        }
+        return dlob;
+    }
+    async unsubscribe() {
+        await this.subscription.unsubscribe();
+    }
+}
+exports.OrderSubscriber = OrderSubscriber;

package/lib/orderSubscriber/PollingSubscription.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { OrderSubscriber } from './OrderSubscriber';
+export declare class PollingSubscription {
+    private orderSubscriber;
+    private frequency;
+    intervalId?: NodeJS.Timer;
+    constructor({ orderSubscriber, frequency, }: {
+        orderSubscriber: OrderSubscriber;
+        frequency: number;
+    });
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

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