@drift-labs/sdk 0.1.18 → 0.1.20

package/lib/accounts/bulkAccountLoader.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+import { AccountData } from './types';
+declare type AccountToLoad = {
+    publicKey: PublicKey;
+    callbacks: Map<string, (buffer: Buffer) => void>;
+};
+export declare class BulkAccountLoader {
+    connection: Connection;
+    commitment: Commitment;
+    pollingFrequency: number;
+    accountsToLoad: Map<string, AccountToLoad>;
+    accountData: Map<string, AccountData>;
+    errorCallbacks: Map<string, (e: any) => void>;
+    intervalId?: NodeJS.Timer;
+    loadPromise?: Promise<void>;
+    loadPromiseResolver: () => void;
+    constructor(connection: Connection, commitment: Commitment, pollingFrequency: number);
+    addAccount(publicKey: PublicKey, callback: (buffer: Buffer) => void): string;
+    removeAccount(publicKey: PublicKey, callbackId: string): void;
+    addErrorCallbacks(callback: (error: Error) => void): string;
+    removeErrorCallbacks(callbackId: string): void;
+    chunks<T>(array: readonly T[], size: number): T[][];
+    load(): Promise<void>;
+    loadChunk(accountsToLoad: AccountToLoad[]): Promise<void>;
+    handleAccountCallbacks(accountToLoad: AccountToLoad, buffer: Buffer): void;
+    getAccountData(publicKey: PublicKey): Buffer | undefined;
+    startPolling(): void;
+    stopPolling(): void;
+}
+export {};
+//# sourceMappingURL=bulkAccountLoader.d.ts.map

package/lib/accounts/bulkAccountLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulkAccountLoader.d.ts","sourceRoot":"","sources":["../../src/accounts/bulkAccountLoader.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEpE,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,aAAK,aAAa,GAAG;IACpB,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC,CAAC;CACjD,CAAC;AAIF,qBAAa,iBAAiB;IAC7B,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,EAAE,UAAU,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,6BAAoC;IAClD,WAAW,2BAAkC;IAC7C,cAAc,0BAA0B,IAAI,EAAI;IAChD,UAAU,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC;IAE1B,WAAW,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,mBAAmB,EAAE,MAAM,IAAI,CAAC;gBAG/B,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,UAAU,EACtB,gBAAgB,EAAE,MAAM;IAOlB,UAAU,CAChB,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAChC,MAAM;IA2BF,aAAa,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAc7D,iBAAiB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM;IAM3D,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAIrD,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE;IAOtC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAuB5B,SAAS,CAAC,cAAc,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAgE/D,sBAAsB,CAAC,aAAa,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAMnE,cAAc,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS;IAKxD,YAAY,IAAI,IAAI;IAQpB,WAAW,IAAI,IAAI;CAM1B"}

package/lib/accounts/bulkAccountLoader.js

@@ -0,0 +1,166 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkAccountLoader = void 0;
+const uuid_1 = require("uuid");
+const GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
+class BulkAccountLoader {
+    constructor(connection, commitment, pollingFrequency) {
+        this.accountsToLoad = new Map();
+        this.accountData = new Map();
+        this.errorCallbacks = new Map();
+        this.connection = connection;
+        this.commitment = commitment;
+        this.pollingFrequency = pollingFrequency;
+    }
+    addAccount(publicKey, callback) {
+        const existingSize = this.accountsToLoad.size;
+        const callbackId = uuid_1.v4();
+        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
+        if (existingAccountToLoad) {
+            existingAccountToLoad.callbacks.set(callbackId, callback);
+        }
+        else {
+            const callbacks = new Map();
+            callbacks.set(callbackId, callback);
+            const newAccountToLoad = {
+                publicKey,
+                callbacks,
+            };
+            this.accountsToLoad.set(publicKey.toString(), newAccountToLoad);
+        }
+        if (existingSize === 0) {
+            this.startPolling();
+        }
+        // if a new account needs to be polled, remove the cached loadPromise in case client calls load immediately after
+        this.loadPromise = undefined;
+        return callbackId;
+    }
+    removeAccount(publicKey, callbackId) {
+        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
+        if (existingAccountToLoad) {
+            existingAccountToLoad.callbacks.delete(callbackId);
+            if (existingAccountToLoad.callbacks.size === 0) {
+                this.accountsToLoad.delete(existingAccountToLoad.publicKey.toString());
+            }
+        }
+        if (this.accountsToLoad.size === 0) {
+            this.stopPolling();
+        }
+    }
+    addErrorCallbacks(callback) {
+        const callbackId = uuid_1.v4();
+        this.errorCallbacks.set(callbackId, callback);
+        return callbackId;
+    }
+    removeErrorCallbacks(callbackId) {
+        this.errorCallbacks.delete(callbackId);
+    }
+    chunks(array, size) {
+        return new Array(Math.ceil(array.length / size))
+            .fill(null)
+            .map((_, index) => index * size)
+            .map((begin) => array.slice(begin, begin + size));
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.loadPromise) {
+                return this.loadPromise;
+            }
+            this.loadPromise = new Promise((resolver) => {
+                this.loadPromiseResolver = resolver;
+            });
+            const chunks = this.chunks(Array.from(this.accountsToLoad.values()), GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE);
+            yield Promise.all(chunks.map((chunk) => {
+                return this.loadChunk(chunk);
+            }));
+            this.loadPromiseResolver();
+            this.loadPromise = undefined;
+        });
+    }
+    loadChunk(accountsToLoad) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (accountsToLoad.length === 0) {
+                return;
+            }
+            const args = [
+                accountsToLoad.map((accountToLoad) => {
+                    return accountToLoad.publicKey.toBase58();
+                }),
+                { commitment: this.commitment },
+            ];
+            let rpcResponse;
+            try {
+                // @ts-ignore
+                rpcResponse = yield this.connection._rpcRequest('getMultipleAccounts', args);
+            }
+            catch (e) {
+                for (const [_, callback] of this.errorCallbacks) {
+                    callback(e);
+                }
+                return;
+            }
+            const newSlot = rpcResponse.result.context.slot;
+            for (const i in accountsToLoad) {
+                const accountToLoad = accountsToLoad[i];
+                const key = accountToLoad.publicKey.toString();
+                const oldRPCResponse = this.accountData.get(key);
+                let newBuffer = undefined;
+                if (rpcResponse.result.value[i]) {
+                    const raw = rpcResponse.result.value[i].data[0];
+                    const dataType = rpcResponse.result.value[i].data[1];
+                    newBuffer = Buffer.from(raw, dataType);
+                }
+                if (!oldRPCResponse) {
+                    this.accountData.set(key, {
+                        slot: newSlot,
+                        buffer: newBuffer,
+                    });
+                    this.handleAccountCallbacks(accountToLoad, newBuffer);
+                    continue;
+                }
+                if (newSlot <= oldRPCResponse.slot) {
+                    continue;
+                }
+                const oldBuffer = oldRPCResponse.buffer;
+                if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+                    this.accountData.set(key, {
+                        slot: newSlot,
+                        buffer: newBuffer,
+                    });
+                    this.handleAccountCallbacks(accountToLoad, newBuffer);
+                }
+            }
+        });
+    }
+    handleAccountCallbacks(accountToLoad, buffer) {
+        for (const [_, callback] of accountToLoad.callbacks) {
+            callback(buffer);
+        }
+    }
+    getAccountData(publicKey) {
+        const accountData = this.accountData.get(publicKey.toString());
+        return accountData === null || accountData === void 0 ? void 0 : accountData.buffer;
+    }
+    startPolling() {
+        if (this.intervalId) {
+            return;
+        }
+        this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
+    }
+    stopPolling() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+}
+exports.BulkAccountLoader = BulkAccountLoader;

package/lib/accounts/bulkUserSubscription.d.ts

@@ -0,0 +1,8 @@
+import { ClearingHouseUser } from '../clearingHouseUser';
+import { BulkAccountLoader } from './bulkAccountLoader';
+/**
+ * @param users
+ * @param accountLoader
+ */
+export declare function bulkPollingUserSubscribe(users: ClearingHouseUser[], accountLoader: BulkAccountLoader): Promise<void>;
+//# sourceMappingURL=bulkUserSubscription.d.ts.map

package/lib/accounts/bulkUserSubscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulkUserSubscription.d.ts","sourceRoot":"","sources":["../../src/accounts/bulkUserSubscription.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAGxD;;;GAGG;AACH,wBAAsB,wBAAwB,CAC7C,KAAK,EAAE,iBAAiB,EAAE,EAC1B,aAAa,EAAE,iBAAiB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAgBf"}

package/lib/accounts/bulkUserSubscription.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulkPollingUserSubscribe = void 0;
+/**
+ * @param users
+ * @param accountLoader
+ */
+function bulkPollingUserSubscribe(users, accountLoader) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Promise.all(users.map((user) => {
+            return user.accountSubscriber.addToAccountLoader();
+        }));
+        yield accountLoader.load();
+        yield Promise.all(users.map((user) => __awaiter(this, void 0, void 0, function* () {
+            return user.subscribe();
+        })));
+    });
+}
+exports.bulkPollingUserSubscribe = bulkPollingUserSubscribe;

package/lib/accounts/pollingClearingHouseAccountSubscriber.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { AccountToPoll, ClearingHouseAccountEvents, ClearingHouseAccountSubscriber, ClearingHouseAccountTypes } from './types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { DepositHistoryAccount, ExtendedCurveHistoryAccount, FundingPaymentHistoryAccount, FundingRateHistoryAccount, LiquidationHistoryAccount, MarketsAccount, StateAccount, TradeHistoryAccount } from '../types';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { ClearingHouseConfigType } from '../factory/clearingHouse';
+export declare class PollingClearingHouseAccountSubscriber implements ClearingHouseAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
+    accountLoader: BulkAccountLoader;
+    accountsToPoll: Map<string, AccountToPoll>;
+    errorCallbackId?: string;
+    state?: StateAccount;
+    markets?: MarketsAccount;
+    tradeHistory?: TradeHistoryAccount;
+    depositHistory?: DepositHistoryAccount;
+    fundingPaymentHistory?: FundingPaymentHistoryAccount;
+    fundingRateHistory?: FundingRateHistoryAccount;
+    liquidationHistory?: LiquidationHistoryAccount;
+    extendedCurveHistory: ExtendedCurveHistoryAccount;
+    optionalExtraSubscriptions: ClearingHouseAccountTypes[];
+    type: ClearingHouseConfigType;
+    private isSubscribing;
+    private subscriptionPromise;
+    private subscriptionPromiseResolver;
+    constructor(program: Program, accountLoader: BulkAccountLoader);
+    subscribe(optionalSubscriptions?: ClearingHouseAccountTypes[]): Promise<boolean>;
+    updateAccountsToPoll(): Promise<void>;
+    addToAccountLoader(): Promise<void>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    assertOptionalIsSubscribed(optionalSubscription: ClearingHouseAccountTypes): void;
+    getStateAccount(): StateAccount;
+    getMarketsAccount(): MarketsAccount;
+    getTradeHistoryAccount(): TradeHistoryAccount;
+    getDepositHistoryAccount(): DepositHistoryAccount;
+    getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount;
+    getFundingRateHistoryAccount(): FundingRateHistoryAccount;
+    getCurveHistoryAccount(): ExtendedCurveHistoryAccount;
+    getLiquidationHistoryAccount(): LiquidationHistoryAccount;
+}
+//# sourceMappingURL=pollingClearingHouseAccountSubscriber.d.ts.map

package/lib/accounts/pollingClearingHouseAccountSubscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pollingClearingHouseAccountSubscriber.d.ts","sourceRoot":"","sources":["../../src/accounts/pollingClearingHouseAccountSubscriber.ts"],"names":[],"mappings":";AAAA,OAAO,EACN,aAAa,EACb,0BAA0B,EAC1B,8BAA8B,EAC9B,yBAAyB,EAEzB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,kBAAkB,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EACN,qBAAqB,EACrB,2BAA2B,EAC3B,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,qBAAa,qCACZ,YAAW,8BAA8B;IAEzC,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,kBAAkB,CAAC,YAAY,EAAE,0BAA0B,CAAC,CAAC;IAE3E,aAAa,EAAE,iBAAiB,CAAC;IACjC,cAAc,6BAAoC;IAClD,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,YAAY,CAAC,EAAE,mBAAmB,CAAC;IACnC,cAAc,CAAC,EAAE,qBAAqB,CAAC;IACvC,qBAAqB,CAAC,EAAE,4BAA4B,CAAC;IACrD,kBAAkB,CAAC,EAAE,yBAAyB,CAAC;IAC/C,kBAAkB,CAAC,EAAE,yBAAyB,CAAC;IAC/C,oBAAoB,EAAE,2BAA2B,CAAC;IAElD,0BAA0B,EAAE,yBAAyB,EAAE,CAAM;IAE7D,IAAI,EAAE,uBAAuB,CAAa;IAE1C,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,2BAA2B,CAAyB;gBAEzC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,iBAAiB;IAOxD,SAAS,CACrB,qBAAqB,CAAC,EAAE,yBAAyB,EAAE,GACjD,OAAO,CAAC,OAAO,CAAC;IA6Bb,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC;IAgFrC,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAqB5B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAYtB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAmBzC,kBAAkB,IAAI,IAAI;IAQ1B,0BAA0B,CACzB,oBAAoB,EAAE,yBAAyB,GAC7C,IAAI;IAcA,eAAe,IAAI,YAAY;IAK/B,iBAAiB,IAAI,cAAc;IAKnC,sBAAsB,IAAI,mBAAmB;IAM7C,wBAAwB,IAAI,qBAAqB;IAMjD,+BAA+B,IAAI,4BAA4B;IAM/D,4BAA4B,IAAI,yBAAyB;IAMzD,sBAAsB,IAAI,2BAA2B;IAMrD,4BAA4B,IAAI,yBAAyB;CAKhE"}

package/lib/accounts/pollingClearingHouseAccountSubscriber.js

@@ -0,0 +1,206 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingClearingHouseAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const addresses_1 = require("../addresses");
+const utils_1 = require("./utils");
+class PollingClearingHouseAccountSubscriber {
+    constructor(program, accountLoader) {
+        this.accountsToPoll = new Map();
+        this.optionalExtraSubscriptions = [];
+        this.type = 'polling';
+        this.isSubscribing = false;
+        this.isSubscribed = false;
+        this.program = program;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.accountLoader = accountLoader;
+    }
+    subscribe(optionalSubscriptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed) {
+                return true;
+            }
+            if (this.isSubscribing) {
+                return yield this.subscriptionPromise;
+            }
+            this.optionalExtraSubscriptions = optionalSubscriptions;
+            this.isSubscribing = true;
+            this.subscriptionPromise = new Promise((res) => {
+                this.subscriptionPromiseResolver = res;
+            });
+            yield this.updateAccountsToPoll();
+            yield this.addToAccountLoader();
+            yield this.fetch();
+            this.eventEmitter.emit('update');
+            this.isSubscribing = false;
+            this.isSubscribed = true;
+            this.subscriptionPromiseResolver(true);
+            return true;
+        });
+    }
+    updateAccountsToPoll() {
+        var _a, _b, _c, _d, _e, _f;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.accountsToPoll.size > 0) {
+                return;
+            }
+            const statePublicKey = yield addresses_1.getClearingHouseStateAccountPublicKey(this.program.programId);
+            const state = (yield this.program.account.state.fetch(statePublicKey));
+            this.accountsToPoll.set(statePublicKey.toString(), {
+                key: 'state',
+                publicKey: statePublicKey,
+                eventType: 'stateAccountUpdate',
+            });
+            this.accountsToPoll.set(state.markets.toString(), {
+                key: 'markets',
+                publicKey: state.markets,
+                eventType: 'marketsAccountUpdate',
+            });
+            if ((_a = this.optionalExtraSubscriptions) === null || _a === void 0 ? void 0 : _a.includes('tradeHistoryAccount')) {
+                this.accountsToPoll.set(state.tradeHistory.toString(), {
+                    key: 'tradeHistory',
+                    publicKey: state.tradeHistory,
+                    eventType: 'tradeHistoryAccountUpdate',
+                });
+            }
+            if ((_b = this.optionalExtraSubscriptions) === null || _b === void 0 ? void 0 : _b.includes('depositHistoryAccount')) {
+                this.accountsToPoll.set(state.depositHistory.toString(), {
+                    key: 'depositHistory',
+                    publicKey: state.depositHistory,
+                    eventType: 'depositHistoryAccountUpdate',
+                });
+            }
+            if ((_c = this.optionalExtraSubscriptions) === null || _c === void 0 ? void 0 : _c.includes('fundingPaymentHistoryAccount')) {
+                this.accountsToPoll.set(state.fundingPaymentHistory.toString(), {
+                    key: 'fundingPaymentHistory',
+                    publicKey: state.fundingPaymentHistory,
+                    eventType: 'fundingPaymentHistoryAccountUpdate',
+                });
+            }
+            if ((_d = this.optionalExtraSubscriptions) === null || _d === void 0 ? void 0 : _d.includes('fundingRateHistoryAccount')) {
+                this.accountsToPoll.set(state.fundingRateHistory.toString(), {
+                    key: 'fundingRateHistory',
+                    publicKey: state.fundingRateHistory,
+                    eventType: 'fundingRateHistoryAccountUpdate',
+                });
+            }
+            if ((_e = this.optionalExtraSubscriptions) === null || _e === void 0 ? void 0 : _e.includes('curveHistoryAccount')) {
+                this.accountsToPoll.set(state.extendedCurveHistory.toString(), {
+                    key: 'extendedCurveHistory',
+                    publicKey: state.extendedCurveHistory,
+                    eventType: 'curveHistoryAccountUpdate',
+                });
+            }
+            if ((_f = this.optionalExtraSubscriptions) === null || _f === void 0 ? void 0 : _f.includes('liquidationHistoryAccount')) {
+                this.accountsToPoll.set(state.liquidationHistory.toString(), {
+                    key: 'liquidationHistory',
+                    publicKey: state.liquidationHistory,
+                    eventType: 'liquidationHistoryAccountUpdate',
+                });
+            }
+        });
+    }
+    addToAccountLoader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                accountToPoll.callbackId = this.accountLoader.addAccount(accountToPoll.publicKey, (buffer) => {
+                    const account = this.program.account[accountToPoll.key].coder.accounts.decode(utils_1.capitalize(accountToPoll.key), buffer);
+                    this[accountToPoll.key] = account;
+                    // @ts-ignore
+                    this.eventEmitter.emit(accountToPoll.eventType, account);
+                    this.eventEmitter.emit('update');
+                });
+            }
+            this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+                this.eventEmitter.emit('error', error);
+            });
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.accountLoader.load();
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                const buffer = this.accountLoader.getAccountData(accountToPoll.publicKey);
+                if (buffer) {
+                    this[accountToPoll.key] = this.program.account[accountToPoll.key].coder.accounts.decode(utils_1.capitalize(accountToPoll.key), buffer);
+                }
+            }
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                this.accountLoader.removeAccount(accountToPoll.publicKey, accountToPoll.callbackId);
+            }
+            this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+            this.errorCallbackId = undefined;
+            this.accountsToPoll.clear();
+            this.isSubscribed = false;
+        });
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    assertOptionalIsSubscribed(optionalSubscription) {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+        if (!this.optionalExtraSubscriptions.includes(optionalSubscription)) {
+            throw new types_1.NotSubscribedError(`You need to subscribe to the optional Clearing House account "${optionalSubscription}" to use this method`);
+        }
+    }
+    getStateAccount() {
+        this.assertIsSubscribed();
+        return this.state;
+    }
+    getMarketsAccount() {
+        this.assertIsSubscribed();
+        return this.markets;
+    }
+    getTradeHistoryAccount() {
+        this.assertIsSubscribed();
+        this.assertOptionalIsSubscribed('tradeHistoryAccount');
+        return this.tradeHistory;
+    }
+    getDepositHistoryAccount() {
+        this.assertIsSubscribed();
+        this.assertOptionalIsSubscribed('depositHistoryAccount');
+        return this.depositHistory;
+    }
+    getFundingPaymentHistoryAccount() {
+        this.assertIsSubscribed();
+        this.assertOptionalIsSubscribed('fundingPaymentHistoryAccount');
+        return this.fundingPaymentHistory;
+    }
+    getFundingRateHistoryAccount() {
+        this.assertIsSubscribed();
+        this.assertOptionalIsSubscribed('fundingRateHistoryAccount');
+        return this.fundingRateHistory;
+    }
+    getCurveHistoryAccount() {
+        this.assertIsSubscribed();
+        this.assertOptionalIsSubscribed('curveHistoryAccount');
+        return this.extendedCurveHistory;
+    }
+    getLiquidationHistoryAccount() {
+        this.assertIsSubscribed();
+        this.assertOptionalIsSubscribed('liquidationHistoryAccount');
+        return this.liquidationHistory;
+    }
+}
+exports.PollingClearingHouseAccountSubscriber = PollingClearingHouseAccountSubscriber;

package/lib/accounts/pollingTokenAccountSubscriber.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { TokenAccountEvents, TokenAccountSubscriber } from './types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { AccountInfo } from '@solana/spl-token';
+export declare class PollingTokenAccountSubscriber implements TokenAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, TokenAccountEvents>;
+    publicKey: PublicKey;
+    accountLoader: BulkAccountLoader;
+    callbackId?: string;
+    errorCallbackId?: string;
+    tokenAccount?: AccountInfo;
+    constructor(publicKey: PublicKey, accountLoader: BulkAccountLoader);
+    subscribe(): Promise<boolean>;
+    addToAccountLoader(): void;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getTokenAccount(): AccountInfo;
+}
+//# sourceMappingURL=pollingTokenAccountSubscriber.d.ts.map

package/lib/accounts/pollingTokenAccountSubscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pollingTokenAccountSubscriber.d.ts","sourceRoot":"","sources":["../../src/accounts/pollingTokenAccountSubscriber.ts"],"names":[],"mappings":";AAAA,OAAO,EAEN,kBAAkB,EAClB,sBAAsB,EACtB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,kBAAkB,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,qBAAa,6BAA8B,YAAW,sBAAsB;IAC3E,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,kBAAkB,CAAC,YAAY,EAAE,kBAAkB,CAAC,CAAC;IACnE,SAAS,EAAE,SAAS,CAAC;IAErB,aAAa,EAAE,iBAAiB,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,YAAY,CAAC,EAAE,WAAW,CAAC;gBAER,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,iBAAiB;IAOnE,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAanC,kBAAkB,IAAI,IAAI;IAqBpB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAMtB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAclC,kBAAkB,IAAI,IAAI;IAQnB,eAAe,IAAI,WAAW;CAIrC"}

package/lib/accounts/pollingTokenAccountSubscriber.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingTokenAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const token_1 = require("../token");
+class PollingTokenAccountSubscriber {
+    constructor(publicKey, accountLoader) {
+        this.isSubscribed = false;
+        this.publicKey = publicKey;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed) {
+                return true;
+            }
+            this.addToAccountLoader();
+            yield this.fetch();
+            this.eventEmitter.emit('update');
+            this.isSubscribed = true;
+            return true;
+        });
+    }
+    addToAccountLoader() {
+        if (this.callbackId) {
+            return;
+        }
+        this.callbackId = this.accountLoader.addAccount(this.publicKey, (buffer) => {
+            const tokenAccount = token_1.parseTokenAccount(buffer);
+            this.tokenAccount = tokenAccount;
+            // @ts-ignore
+            this.eventEmitter.emit('tokenAccountUpdate', tokenAccount);
+            this.eventEmitter.emit('update');
+        });
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.accountLoader.load();
+            const buffer = this.accountLoader.getAccountData(this.publicKey);
+            this.tokenAccount = token_1.parseTokenAccount(buffer);
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            this.accountLoader.removeAccount(this.publicKey, this.callbackId);
+            this.callbackId = undefined;
+            this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+            this.errorCallbackId = undefined;
+            this.isSubscribed = false;
+        });
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getTokenAccount() {
+        this.assertIsSubscribed();
+        return this.tokenAccount;
+    }
+}
+exports.PollingTokenAccountSubscriber = PollingTokenAccountSubscriber;

package/lib/accounts/pollingUserAccountSubscriber.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import { AccountToPoll, UserAccountEvents, UserAccountSubscriber } from './types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { UserAccount, UserPositionsAccount } from '../types';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { ClearingHouseConfigType } from '../factory/clearingHouse';
+export declare class PollingUserAccountSubscriber implements UserAccountSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
+    authority: PublicKey;
+    accountLoader: BulkAccountLoader;
+    accountsToPoll: Map<string, AccountToPoll>;
+    errorCallbackId?: string;
+    user?: UserAccount;
+    userPositions?: UserPositionsAccount;
+    type: ClearingHouseConfigType;
+    constructor(program: Program, authority: PublicKey, accountLoader: BulkAccountLoader);
+    subscribe(): Promise<boolean>;
+    addToAccountLoader(): Promise<void>;
+    fetchIfUnloaded(): Promise<void>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getUserAccount(): UserAccount;
+    getUserPositionsAccount(): UserPositionsAccount;
+}
+//# sourceMappingURL=pollingUserAccountSubscriber.d.ts.map

package/lib/accounts/pollingUserAccountSubscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pollingUserAccountSubscriber.d.ts","sourceRoot":"","sources":["../../src/accounts/pollingUserAccountSubscriber.ts"],"names":[],"mappings":";AAAA,OAAO,EACN,aAAa,EAEb,iBAAiB,EACjB,qBAAqB,EACrB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,kBAAkB,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,qBAAa,4BAA6B,YAAW,qBAAqB;IACzE,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,kBAAkB,CAAC,YAAY,EAAE,iBAAiB,CAAC,CAAC;IAClE,SAAS,EAAE,SAAS,CAAC;IAErB,aAAa,EAAE,iBAAiB,CAAC;IACjC,cAAc,6BAAoC;IAClD,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,aAAa,CAAC,EAAE,oBAAoB,CAAC;IAErC,IAAI,EAAE,uBAAuB,CAAa;gBAGzC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,iBAAiB;IAS3B,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAa7B,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IA8CnC,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAchC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAYtB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAoBlC,kBAAkB,IAAI,IAAI;IAQnB,cAAc,IAAI,WAAW;IAK7B,uBAAuB,IAAI,oBAAoB;CAItD"}