@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.10

package/lib/accounts/pollingTokenAccountSubscriber.js

@@ -1,13 +1,4 @@
 "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");
@@ -20,33 +11,31 @@ class PollingTokenAccountSubscriber {
         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();
-            let subscriptionSucceeded = false;
-            let retries = 0;
-            while (!subscriptionSucceeded && retries < 5) {
-                yield this.fetch();
-                subscriptionSucceeded = this.didSubscriptionSucceed();
-                retries++;
-            }
-            if (subscriptionSucceeded) {
-                this.eventEmitter.emit('update');
-            }
-            this.isSubscribed = subscriptionSucceeded;
-            return subscriptionSucceeded;
-        });
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.addToAccountLoader();
+        let subscriptionSucceeded = false;
+        let retries = 0;
+        while (!subscriptionSucceeded && retries < 5) {
+            await this.fetch();
+            subscriptionSucceeded = this.didSubscriptionSucceed();
+            retries++;
+        }
+        if (subscriptionSucceeded) {
+            this.eventEmitter.emit('update');
+        }
+        this.isSubscribed = subscriptionSucceeded;
+        return subscriptionSucceeded;
     }
     addToAccountLoader() {
         if (this.callbackId) {
             return;
         }
-        this.callbackId = this.accountLoader.addAccount(this.publicKey, (buffer) => {
+        this.callbackId = this.accountLoader.addAccount(this.publicKey, (buffer, slot) => {
             const tokenAccount = (0, token_1.parseTokenAccount)(buffer);
-            this.tokenAccount = tokenAccount;
+            this.tokenAccountAndSlot = { data: tokenAccount, slot };
             // @ts-ignore
             this.eventEmitter.emit('tokenAccountUpdate', tokenAccount);
             this.eventEmitter.emit('update');
@@ -55,36 +44,32 @@ class PollingTokenAccountSubscriber {
             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 = (0, token_1.parseTokenAccount)(buffer);
-        });
+    async fetch() {
+        await this.accountLoader.load();
+        const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.publicKey);
+        this.tokenAccountAndSlot = { data: (0, token_1.parseTokenAccount)(buffer), slot };
     }
-    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;
-        });
+    async unsubscribe() {
+        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() {
+    getTokenAccountAndSlot() {
         this.assertIsSubscribed();
-        return this.tokenAccount;
+        return this.tokenAccountAndSlot;
     }
     didSubscriptionSucceed() {
-        return !!this.tokenAccount;
+        return !!this.tokenAccountAndSlot;
     }
 }
 exports.PollingTokenAccountSubscriber = PollingTokenAccountSubscriber;

package/lib/accounts/pollingUserAccountSubscriber.d.ts

@@ -1,33 +1,27 @@
 /// <reference types="node" />
-import { AccountToPoll, UserAccountEvents, UserAccountSubscriber, UserPublicKeys } from './types';
+import { DataAndSlot, 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 { UserAccount } 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;
+    userAccountPublicKey: PublicKey;
     accountLoader: BulkAccountLoader;
     accountsToPoll: Map<string, AccountToPoll>;
     errorCallbackId?: string;
-    user?: UserAccount;
-    userPositions?: UserPositionsAccount;
-    userOrders?: UserOrdersAccount;
-    type: ClearingHouseConfigType;
-    constructor(program: Program, authority: PublicKey, accountLoader: BulkAccountLoader);
+    user?: DataAndSlot<UserAccount>;
+    constructor(program: Program, userAccountPublicKey: PublicKey, accountLoader: BulkAccountLoader);
     subscribe(): Promise<boolean>;
-    addToAccountLoader(userPublicKeys?: UserPublicKeys): Promise<void>;
+    addToAccountLoader(): Promise<void>;
     fetchIfUnloaded(): Promise<void>;
     fetch(): Promise<void>;
     didSubscriptionSucceed(): boolean;
     unsubscribe(): Promise<void>;
     assertIsSubscribed(): void;
-    getUserAccount(): UserAccount;
-    getUserPositionsAccount(): UserPositionsAccount;
-    getUserOrdersAccount(): UserOrdersAccount;
+    getUserAccountAndSlot(): DataAndSlot<UserAccount>;
 }

package/lib/accounts/pollingUserAccountSubscriber.js

@@ -1,176 +1,113 @@
 "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.PollingUserAccountSubscriber = void 0;
 const types_1 = require("./types");
 const events_1 = require("events");
-const addresses_1 = require("../addresses");
 const utils_1 = require("./utils");
 class PollingUserAccountSubscriber {
-    constructor(program, authority, accountLoader) {
+    constructor(program, userAccountPublicKey, accountLoader) {
         this.accountsToPoll = new Map();
-        this.type = 'polling';
         this.isSubscribed = false;
         this.program = program;
-        this.authority = authority;
         this.accountLoader = accountLoader;
         this.eventEmitter = new events_1.EventEmitter();
+        this.userAccountPublicKey = userAccountPublicKey;
     }
-    subscribe() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isSubscribed) {
-                return true;
-            }
-            yield this.addToAccountLoader();
-            let subscriptionSucceeded = false;
-            let retries = 0;
-            while (!subscriptionSucceeded && retries < 5) {
-                yield this.fetchIfUnloaded();
-                subscriptionSucceeded = this.didSubscriptionSucceed();
-                retries++;
-            }
-            if (subscriptionSucceeded) {
-                this.eventEmitter.emit('update');
-            }
-            this.isSubscribed = subscriptionSucceeded;
-            return subscriptionSucceeded;
-        });
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        await this.addToAccountLoader();
+        let subscriptionSucceeded = false;
+        let retries = 0;
+        while (!subscriptionSucceeded && retries < 5) {
+            await this.fetchIfUnloaded();
+            subscriptionSucceeded = this.didSubscriptionSucceed();
+            retries++;
+        }
+        if (subscriptionSucceeded) {
+            this.eventEmitter.emit('update');
+        }
+        this.isSubscribed = subscriptionSucceeded;
+        return subscriptionSucceeded;
     }
-    addToAccountLoader(userPublicKeys) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.accountsToPoll.size > 0) {
-                return;
-            }
-            if (!userPublicKeys) {
-                const userPublicKey = yield (0, addresses_1.getUserAccountPublicKey)(this.program.programId, this.authority);
-                const userAccount = (yield this.program.account.user.fetch(userPublicKey));
-                this.accountsToPoll.set(userPublicKey.toString(), {
-                    key: 'user',
-                    publicKey: userPublicKey,
-                    eventType: 'userAccountData',
-                });
-                this.accountsToPoll.set(userAccount.positions.toString(), {
-                    key: 'userPositions',
-                    publicKey: userAccount.positions,
-                    eventType: 'userPositionsData',
-                });
-                const userOrdersPublicKey = yield (0, addresses_1.getUserOrdersAccountPublicKey)(this.program.programId, userPublicKey);
-                this.accountsToPoll.set(userOrdersPublicKey.toString(), {
-                    key: 'userOrders',
-                    publicKey: userOrdersPublicKey,
-                    eventType: 'userOrdersData',
-                });
-            }
-            else {
-                this.accountsToPoll.set(userPublicKeys.user.toString(), {
-                    key: 'user',
-                    publicKey: userPublicKeys.user,
-                    eventType: 'userAccountData',
-                });
-                this.accountsToPoll.set(userPublicKeys.userPositions.toString(), {
-                    key: 'userPositions',
-                    publicKey: userPublicKeys.userPositions,
-                    eventType: 'userPositionsData',
-                });
-                if (userPublicKeys.userOrders) {
-                    this.accountsToPoll.set(userPublicKeys.userOrders.toString(), {
-                        key: 'userOrders',
-                        publicKey: userPublicKeys.userOrders,
-                        eventType: 'userOrdersData',
-                    });
+    async addToAccountLoader() {
+        if (this.accountsToPoll.size > 0) {
+            return;
+        }
+        this.accountsToPoll.set(this.userAccountPublicKey.toString(), {
+            key: 'user',
+            publicKey: this.userAccountPublicKey,
+            eventType: 'userAccountUpdate',
+        });
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            accountToPoll.callbackId = this.accountLoader.addAccount(accountToPoll.publicKey, (buffer, slot) => {
+                if (!buffer) {
+                    return;
                 }
-            }
-            for (const [_, accountToPoll] of this.accountsToPoll) {
-                accountToPoll.callbackId = this.accountLoader.addAccount(accountToPoll.publicKey, (buffer) => {
-                    if (!buffer) {
-                        return;
-                    }
-                    const account = this.program.account[accountToPoll.key].coder.accounts.decode((0, 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);
+                const account = this.program.account[accountToPoll.key].coder.accounts.decode((0, utils_1.capitalize)(accountToPoll.key), buffer);
+                this[accountToPoll.key] = { data: account, slot };
+                // @ts-ignore
+                this.eventEmitter.emit(accountToPoll.eventType, account);
+                this.eventEmitter.emit('update');
             });
+        }
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
         });
     }
-    fetchIfUnloaded() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let shouldFetch = false;
-            for (const [_, accountToPoll] of this.accountsToPoll) {
-                if (this[accountToPoll.key] === undefined) {
-                    shouldFetch = true;
-                    break;
-                }
-            }
-            if (shouldFetch) {
-                yield this.fetch();
+    async fetchIfUnloaded() {
+        let shouldFetch = false;
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            if (this[accountToPoll.key] === undefined) {
+                shouldFetch = true;
+                break;
             }
-        });
+        }
+        if (shouldFetch) {
+            await this.fetch();
+        }
     }
-    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((0, utils_1.capitalize)(accountToPoll.key), buffer);
-                }
+    async fetch() {
+        await this.accountLoader.load();
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            const { buffer, slot } = this.accountLoader.getBufferAndSlot(accountToPoll.publicKey);
+            if (buffer) {
+                const account = this.program.account[accountToPoll.key].coder.accounts.decode((0, utils_1.capitalize)(accountToPoll.key), buffer);
+                this[accountToPoll.key] = { data: account, slot };
             }
-        });
+        }
     }
     didSubscriptionSucceed() {
         let success = true;
         for (const [_, accountToPoll] of this.accountsToPoll) {
-            // userOrders may not exist
-            if (accountToPoll.key !== 'userOrders' && !this[accountToPoll.key]) {
+            if (!this[accountToPoll.key]) {
                 success = false;
                 break;
             }
         }
         return success;
     }
-    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;
-        });
+    async unsubscribe() {
+        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');
         }
     }
-    getUserAccount() {
+    getUserAccountAndSlot() {
         this.assertIsSubscribed();
         return this.user;
     }
-    getUserPositionsAccount() {
-        this.assertIsSubscribed();
-        return this.userPositions;
-    }
-    getUserOrdersAccount() {
-        this.assertIsSubscribed();
-        return this.userOrders;
-    }
 }
 exports.PollingUserAccountSubscriber = PollingUserAccountSubscriber;

package/lib/accounts/types.d.ts

@@ -1,12 +1,15 @@
 /// <reference types="node" />
-import { DepositHistoryAccount, ExtendedCurveHistoryAccount, FundingPaymentHistoryAccount, FundingRateHistoryAccount, LiquidationHistoryAccount, MarketsAccount, OrderHistoryAccount, OrderStateAccount, StateAccount, TradeHistoryAccount, UserAccount, UserOrdersAccount, UserPositionsAccount } from '../types';
+/// <reference types="bn.js" />
+/// <reference types="node" />
+import { BankAccount, MarketAccount, OracleSource, StateAccount, UserAccount } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
 import { AccountInfo } from '@solana/spl-token';
-import { ClearingHouseConfigType, ClearingHouseUserConfigType, OraclePriceData } from '..';
+import { OracleInfo, OraclePriceData } from '..';
+import { BN } from '@project-serum/anchor';
 export interface AccountSubscriber<T> {
-    data?: T;
+    dataAndSlot?: DataAndSlot<T>;
     subscribe(onChange: (data: T) => void): Promise<void>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
@@ -16,47 +19,30 @@ export declare class NotSubscribedError extends Error {
 }
 export interface ClearingHouseAccountEvents {
     stateAccountUpdate: (payload: StateAccount) => void;
-    marketsAccountUpdate: (payload: MarketsAccount) => void;
-    fundingPaymentHistoryAccountUpdate: (payload: FundingPaymentHistoryAccount) => void;
-    fundingRateHistoryAccountUpdate: (payload: FundingRateHistoryAccount) => void;
-    tradeHistoryAccountUpdate: (payload: TradeHistoryAccount) => void;
-    liquidationHistoryAccountUpdate: (payload: LiquidationHistoryAccount) => void;
-    depositHistoryAccountUpdate: (payload: DepositHistoryAccount) => void;
-    curveHistoryAccountUpdate: (payload: ExtendedCurveHistoryAccount) => void;
-    orderHistoryAccountUpdate: (payload: OrderHistoryAccount) => void;
-    orderStateAccountUpdate: (payload: OrderStateAccount) => void;
+    marketAccountUpdate: (payload: MarketAccount) => void;
+    bankAccountUpdate: (payload: BankAccount) => void;
+    oraclePriceUpdate: (publicKey: PublicKey, data: OraclePriceData) => void;
+    userAccountUpdate: (payload: UserAccount) => void;
     update: void;
     error: (e: Error) => void;
 }
-export declare type ClearingHouseAccountTypes = 'tradeHistoryAccount' | 'depositHistoryAccount' | 'fundingPaymentHistoryAccount' | 'fundingRateHistoryAccount' | 'curveHistoryAccount' | 'liquidationHistoryAccount' | 'orderHistoryAccount';
 export interface ClearingHouseAccountSubscriber {
     eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
     isSubscribed: boolean;
-    optionalExtraSubscriptions: ClearingHouseAccountTypes[];
-    subscribe(optionalSubscriptions?: ClearingHouseAccountTypes[]): Promise<boolean>;
+    subscribe(): Promise<boolean>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
-    getStateAccount(): StateAccount;
-    getMarketsAccount(): MarketsAccount;
-    getTradeHistoryAccount(): TradeHistoryAccount;
-    getDepositHistoryAccount(): DepositHistoryAccount;
-    getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount;
-    getFundingRateHistoryAccount(): FundingRateHistoryAccount;
-    getCurveHistoryAccount(): ExtendedCurveHistoryAccount;
-    getLiquidationHistoryAccount(): LiquidationHistoryAccount;
-    getOrderStateAccount(): OrderStateAccount;
-    getOrderHistoryAccount(): OrderHistoryAccount;
-    type: ClearingHouseConfigType;
+    addMarket(marketIndex: BN): Promise<boolean>;
+    addBank(bankIndex: BN): Promise<boolean>;
+    addOracle(oracleInfo: OracleInfo): Promise<boolean>;
+    getStateAccountAndSlot(): DataAndSlot<StateAccount>;
+    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<MarketAccount> | undefined;
+    getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[];
+    getBankAccountAndSlot(bankIndex: BN): DataAndSlot<BankAccount> | undefined;
+    getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
 }
-export declare type UserPublicKeys = {
-    user: PublicKey;
-    userPositions: PublicKey;
-    userOrders: PublicKey | undefined;
-};
 export interface UserAccountEvents {
-    userAccountData: (payload: UserAccount) => void;
-    userPositionsData: (payload: UserPositionsAccount) => void;
-    userOrdersData: (payload: UserOrdersAccount) => void;
+    userAccountUpdate: (payload: UserAccount) => void;
     update: void;
     error: (e: Error) => void;
 }
@@ -66,10 +52,7 @@ export interface UserAccountSubscriber {
     subscribe(): Promise<boolean>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
-    getUserAccount(): UserAccount;
-    getUserPositionsAccount(): UserPositionsAccount;
-    getUserOrdersAccount(): UserOrdersAccount;
-    type: ClearingHouseUserConfigType;
+    getUserAccountAndSlot(): DataAndSlot<UserAccount>;
 }
 export interface TokenAccountEvents {
     tokenAccountUpdate: (payload: AccountInfo) => void;
@@ -82,7 +65,7 @@ export interface TokenAccountSubscriber {
     subscribe(): Promise<boolean>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
-    getTokenAccount(): AccountInfo;
+    getTokenAccountAndSlot(): DataAndSlot<AccountInfo>;
 }
 export interface OracleEvents {
     oracleUpdate: (payload: OraclePriceData) => void;
@@ -95,15 +78,25 @@ export interface OracleSubscriber {
     subscribe(): Promise<boolean>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
-    getOraclePriceData(): OraclePriceData;
+    getOraclePriceData(): DataAndSlot<OraclePriceData>;
 }
 export declare type AccountToPoll = {
     key: string;
     publicKey: PublicKey;
     eventType: string;
     callbackId?: string;
+    mapKey?: number;
+};
+export declare type OraclesToPoll = {
+    publicKey: PublicKey;
+    source: OracleSource;
+    callbackId?: string;
 };
-export declare type AccountData = {
+export declare type BufferAndSlot = {
     slot: number;
     buffer: Buffer | undefined;
 };
+export declare type DataAndSlot<T> = {
+    data: T;
+    slot: number;
+};

package/lib/accounts/webSocketAccountSubscriber.d.ts

@@ -1,18 +1,20 @@
 /// <reference types="node" />
-import { AccountData, AccountSubscriber } from './types';
+import { DataAndSlot, BufferAndSlot, AccountSubscriber } from './types';
 import { Program } from '@project-serum/anchor';
 import { AccountInfo, Context, PublicKey } from '@solana/web3.js';
 export declare class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
-    data?: T;
-    accountData?: AccountData;
+    dataAndSlot?: DataAndSlot<T>;
+    bufferAndSlot?: BufferAndSlot;
     accountName: string;
     program: Program;
     accountPublicKey: PublicKey;
+    decodeBufferFn: (buffer: Buffer) => T;
     onChange: (data: T) => void;
     listenerId?: number;
-    constructor(accountName: string, program: Program, accountPublicKey: PublicKey);
+    constructor(accountName: string, program: Program, accountPublicKey: PublicKey, decodeBuffer?: (buffer: Buffer) => T);
     subscribe(onChange: (data: T) => void): Promise<void>;
     fetch(): Promise<void>;
     handleRpcResponse(context: Context, accountInfo?: AccountInfo<Buffer>): void;
+    decodeBuffer(buffer: Buffer): T;
     unsubscribe(): Promise<void>;
 }