@drift-labs/sdk 2.31.0-beta.2 → 2.31.0-beta.5

package/get_events.ts

@@ -0,0 +1,47 @@
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import {
+  configs,
+  DriftClient,
+  Wallet,
+} from "@drift-labs/sdk";
+
+
+async function main() {
+
+  const driftConfig = configs['mainnet-beta'];
+  const connection = new Connection('https://api.mainnet-beta.solana.com');
+
+  const driftClient = new DriftClient({
+    connection: connection,
+    wallet: new Wallet(new Keypair()),
+    programID: new PublicKey(driftConfig.DRIFT_PROGRAM_ID),
+    userStats: true,
+    env: 'mainnet-beta',
+  });
+  console.log(`driftClientSubscribed: ${await driftClient.subscribe()}`);
+
+  const txHash = "3gvGQufckXGHrFDv4dNWEXuXKRMy3NZkKHMyFrAhLoYScaXXTGCp9vq58kWkfyJ8oDYZrz4bTyGayjUy9PKigeLS";
+
+  const tx = await driftClient.connection.getParsedTransaction(txHash, {
+    commitment: "confirmed",
+    maxSupportedTransactionVersion: 0,
+  });
+
+  let logIdx = 0;
+  // @ts-ignore
+  for (const event of driftClient.program._events._eventParser.parseLogs(tx!.meta!.logMessages)) {
+    console.log("----------------------------------------");
+    console.log(`Log ${logIdx++}`);
+    console.log("----------------------------------------");
+    console.log(`${JSON.stringify(event, null, 2)}`);
+  }
+
+  console.log("========================================");
+  console.log("Raw transaction logs");
+  console.log("========================================");
+  console.log(JSON.stringify(tx!.meta!.logMessages, null, 2));
+
+  process.exit(0);
+}
+
+main().catch(console.error);

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/config.js

@@ -78,8 +78,8 @@ async function findAllMarketAndOracles(program) {
     const perpMarketIndexes = [];
     const spotMarketIndexes = [];
     const oracleInfos = new Map();
-    const perpMarketProgramAccounts = await program.account.perpMarket.all();
-    const spotMarketProgramAccounts = await program.account.spotMarket.all();
+    const perpMarketProgramAccounts = (await program.account.perpMarket.all());
+    const spotMarketProgramAccounts = (await program.account.spotMarket.all());
     for (const perpMarketProgramAccount of perpMarketProgramAccounts) {
         const perpMarket = perpMarketProgramAccount.account;
         perpMarketIndexes.push(perpMarket.marketIndex);

package/lib/dlob/orderBookLevels.d.ts

@@ -41,5 +41,5 @@ export declare function getVammL2Generator({ marketAccount, oraclePriceData, num
     numOrders: number;
     now?: BN;
 }): L2OrderBookGenerator;
-export declare function groupL2(l2: L2OrderBook, grouping: BN): L2OrderBook;
+export declare function groupL2(l2: L2OrderBook, grouping: BN, depth: number): L2OrderBook;
 export {};

package/lib/dlob/orderBookLevels.js

@@ -135,14 +135,14 @@ function getVammL2Generator({ marketAccount, oraclePriceData, numOrders, now, })
     };
 }
 exports.getVammL2Generator = getVammL2Generator;
-function groupL2(l2, grouping) {
+function groupL2(l2, grouping, depth) {
     return {
-        bids: groupL2Levels(l2.bids, grouping, __1.PositionDirection.LONG),
-        asks: groupL2Levels(l2.asks, grouping, __1.PositionDirection.SHORT),
+        bids: groupL2Levels(l2.bids, grouping, __1.PositionDirection.LONG, depth),
+        asks: groupL2Levels(l2.asks, grouping, __1.PositionDirection.SHORT, depth),
     };
 }
 exports.groupL2 = groupL2;
-function groupL2Levels(levels, grouping, direction) {
+function groupL2Levels(levels, grouping, direction, depth) {
     const groupedLevels = [];
     for (const level of levels) {
         const price = (0, __1.standardizePrice)(level.price, grouping, direction);
@@ -168,6 +168,9 @@ function groupL2Levels(levels, grouping, direction) {
             };
             groupedLevels.push(groupedLevel);
         }
+        if (groupedLevels.length === depth) {
+            break;
+        }
     }
     return groupedLevels;
 }

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.2",
+    "version": "2.31.0-beta.5",
     "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,6 @@
+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;
+export declare function getUserThatHasBeenLP(): MemcmpFilter;

package/lib/memcmp.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserThatHasBeenLP = 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;
+function getUserThatHasBeenLP() {
+    return {
+        memcmp: {
+            offset: 4267,
+            bytes: bs58_1.default.encode(Uint8Array.from([99])),
+        },
+    };
+}
+exports.getUserThatHasBeenLP = getUserThatHasBeenLP;

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>;
+}