@drift-labs/sdk 0.1.18-orders.1 → 0.1.18-orders.2

package/README.md

@@ -84,7 +84,7 @@ convertToNumber(new BN(10500), new BN(1000)); // = 10.5
 ### Setting up an account and making a trade
 
 ```typescript
-import { BN, Provider, Wallet } from '@project-serum/anchor';
+import { BN, Provider } from '@project-serum/anchor';
 import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import {
@@ -98,6 +98,7 @@ import {
 	calculateTradeSlippage,
 	MARK_PRICE_PRECISION,
 	QUOTE_PRECISION,
+	Wallet
 } from '@drift-labs/sdk';
 
 export const getTokenAddress = (

package/lib/accounts/bulkAccountLoader.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+declare type AccountToLoad = {
+    publicKey: PublicKey;
+    callbacks: Map<string, (buffer: Buffer) => void>;
+};
+declare type AccountData = {
+    slot: number;
+    buffer: Buffer | undefined;
+};
+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;
+    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 {};

package/lib/accounts/bulkAccountLoader.js

@@ -0,0 +1,156 @@
+"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();
+        }
+        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* () {
+            const chunks = this.chunks(Array.from(this.accountsToLoad.values()), GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE);
+            yield Promise.all(chunks.map((chunk) => {
+                return this.loadChunk(chunk);
+            }));
+        });
+    }
+    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,7 @@
+import { ClearingHouseUser } from '../clearingHouseUser';
+import { BulkAccountLoader } from './bulkAccountLoader';
+/**
+ * @param users
+ * @param accountLoader
+ */
+export declare function bulkPollingUserSubscribe(users: ClearingHouseUser[], accountLoader: BulkAccountLoader): Promise<void>;

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,49 @@
+/// <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, OrderHistoryAccount, OrderStateAccount, 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;
+    orderState?: OrderStateAccount;
+    tradeHistory?: TradeHistoryAccount;
+    depositHistory?: DepositHistoryAccount;
+    fundingPaymentHistory?: FundingPaymentHistoryAccount;
+    fundingRateHistory?: FundingRateHistoryAccount;
+    liquidationHistory?: LiquidationHistoryAccount;
+    extendedCurveHistory: ExtendedCurveHistoryAccount;
+    orderHistory?: OrderHistoryAccount;
+    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;
+    getOrderStateAccount(): OrderStateAccount;
+    getTradeHistoryAccount(): TradeHistoryAccount;
+    getDepositHistoryAccount(): DepositHistoryAccount;
+    getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount;
+    getFundingRateHistoryAccount(): FundingRateHistoryAccount;
+    getCurveHistoryAccount(): ExtendedCurveHistoryAccount;
+    getLiquidationHistoryAccount(): LiquidationHistoryAccount;
+    getOrderHistoryAccount(): OrderHistoryAccount;
+}

package/lib/accounts/pollingClearingHouseAccountSubscriber.js

@@ -0,0 +1,228 @@
+"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, _g;
+        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',
+            });
+            this.accountsToPoll.set(state.orderState.toString(), {
+                key: 'orderState',
+                publicKey: state.orderState,
+                eventType: 'orderStateAccountUpdate',
+            });
+            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',
+                });
+            }
+            if ((_g = this.optionalExtraSubscriptions) === null || _g === void 0 ? void 0 : _g.includes('orderHistoryAccount')) {
+                const orderState = (yield this.program.account.orderState.fetch(state.orderState));
+                this.accountsToPoll.set(orderState.orderHistory.toString(), {
+                    key: 'orderHistory',
+                    publicKey: orderState.orderHistory,
+                    eventType: 'orderHistoryAccountUpdate',
+                });
+            }
+        });
+    }
+    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;
+    }
+    getOrderStateAccount() {
+        this.assertIsSubscribed();
+        return this.orderState;
+    }
+    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;
+    }
+    getOrderHistoryAccount() {
+        this.assertIsSubscribed();
+        this.assertOptionalIsSubscribed('orderHistoryAccount');
+        return this.orderHistory;
+    }
+}
+exports.PollingClearingHouseAccountSubscriber = PollingClearingHouseAccountSubscriber;

package/lib/accounts/pollingTokenAccountSubscriber.d.ts

@@ -0,0 +1,25 @@
+/// <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;
+}

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,32 @@
+/// <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, UserOrdersAccount, 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;
+    userOrders?: UserOrdersAccount;
+    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;
+    getUserOrdersAccount(): UserOrdersAccount;
+}