@drift-labs/sdk 2.96.0-beta.0 → 2.96.0-beta.2

package/VERSION

@@ -1 +1 @@
-2.96.0-beta.0
+2.96.0-beta.2

package/lib/accounts/grpcAccountSubscriber.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { ResubOpts, GrpcConfigs } from './types';
+import { Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { ClientDuplexStream } from '@grpc/grpc-js';
+import Client, { CommitmentLevel, SubscribeRequest, SubscribeUpdate } from '@triton-one/yellowstone-grpc';
+import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
+export declare class grpcAccountSubscriber<T> extends WebSocketAccountSubscriber<T> {
+    client: Client;
+    stream: ClientDuplexStream<SubscribeRequest, SubscribeUpdate>;
+    commitmentLevel: CommitmentLevel;
+    listenerId?: number;
+    constructor(grpcConfigs: GrpcConfigs, accountName: string, program: Program, accountPublicKey: PublicKey, decodeBuffer?: (buffer: Buffer) => T, resubOpts?: ResubOpts);
+    subscribe(onChange: (data: T) => void): Promise<void>;
+    unsubscribe(onResub?: boolean): Promise<void>;
+}

package/lib/accounts/grpcAccountSubscriber.js

@@ -0,0 +1,155 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcAccountSubscriber = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const Buffer = __importStar(require("buffer"));
+const yellowstone_grpc_1 = __importStar(require("@triton-one/yellowstone-grpc"));
+const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+class grpcAccountSubscriber extends webSocketAccountSubscriber_1.WebSocketAccountSubscriber {
+    constructor(grpcConfigs, accountName, program, accountPublicKey, decodeBuffer, resubOpts) {
+        var _a, _b;
+        super(accountName, program, accountPublicKey, decodeBuffer, resubOpts);
+        this.client = new yellowstone_grpc_1.default(grpcConfigs.endpoint, grpcConfigs.token, (_a = grpcConfigs.channelOptions) !== null && _a !== void 0 ? _a : {});
+        this.commitmentLevel =
+            (_b = grpcConfigs.commitmentLevel) !== null && _b !== void 0 ? _b : yellowstone_grpc_1.CommitmentLevel.CONFIRMED;
+    }
+    async subscribe(onChange) {
+        if (this.listenerId != null || this.isUnsubscribing) {
+            return;
+        }
+        this.onChange = onChange;
+        if (!this.dataAndSlot) {
+            await this.fetch();
+        }
+        // Subscribe with grpc
+        this.stream = await this.client.subscribe();
+        const request = {
+            slots: {
+                slots: {},
+            },
+            accounts: {
+                account: {
+                    account: [this.accountPublicKey.toString()],
+                    owner: [],
+                    filters: [],
+                },
+            },
+            transactions: {},
+            blocks: {},
+            blocksMeta: {},
+            accountsDataSlice: [],
+            commitment: this.commitmentLevel,
+            entry: {},
+            transactionsStatus: {},
+        };
+        this.stream.on('data', (chunk) => {
+            var _a;
+            if (!chunk.account) {
+                return;
+            }
+            const slot = Number(chunk.account.slot);
+            const accountInfo = {
+                owner: new web3_js_1.PublicKey(chunk.account.account.owner),
+                lamports: Number(chunk.account.account.lamports),
+                data: Buffer.Buffer.from(chunk.account.account.data),
+                executable: chunk.account.account.executable,
+                rentEpoch: Number(chunk.account.account.rentEpoch),
+            };
+            if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
+                this.receivingData = true;
+                clearTimeout(this.timeoutId);
+                this.handleRpcResponse({
+                    slot,
+                }, accountInfo);
+                this.setTimeout();
+            }
+            else {
+                this.handleRpcResponse({
+                    slot,
+                }, accountInfo);
+            }
+        });
+        return new Promise((resolve, reject) => {
+            this.stream.write(request, (err) => {
+                var _a;
+                if (err === null || err === undefined) {
+                    this.listenerId = 1;
+                    if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
+                        this.receivingData = true;
+                        this.setTimeout();
+                    }
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+        }).catch((reason) => {
+            console.error(reason);
+            throw reason;
+        });
+    }
+    async unsubscribe(onResub = false) {
+        if (!onResub && this.resubOpts) {
+            this.resubOpts.resubTimeoutMs = undefined;
+        }
+        this.isUnsubscribing = true;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.listenerId != null) {
+            const promise = new Promise((resolve, reject) => {
+                const request = {
+                    slots: {},
+                    accounts: {},
+                    transactions: {},
+                    blocks: {},
+                    blocksMeta: {},
+                    accountsDataSlice: [],
+                    entry: {},
+                    transactionsStatus: {},
+                };
+                this.stream.write(request, (err) => {
+                    if (err === null || err === undefined) {
+                        this.listenerId = undefined;
+                        this.isUnsubscribing = false;
+                        resolve();
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+            }).catch((reason) => {
+                console.error(reason);
+                throw reason;
+            });
+            return promise;
+        }
+        else {
+            this.isUnsubscribing = false;
+        }
+    }
+}
+exports.grpcAccountSubscriber = grpcAccountSubscriber;

package/lib/accounts/grpcDriftClientAccountSubscriber.d.ts

@@ -0,0 +1,13 @@
+import { WebSocketDriftClientAccountSubscriber } from './webSocketDriftClientAccountSubscriber';
+import { OracleInfo } from '../oracles/types';
+import { Program } from '@coral-xyz/anchor';
+import { GrpcConfigs, ResubOpts } from './types';
+import { Commitment } from '@solana/web3.js';
+export declare class gprcDriftClientAccountSubscriber extends WebSocketDriftClientAccountSubscriber {
+    private grpcConfigs;
+    constructor(grpcConfigs: GrpcConfigs, program: Program, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[], shouldFindAllMarketsAndOracles: boolean, resubOpts?: ResubOpts, commitment?: Commitment);
+    subscribe(): Promise<boolean>;
+    subscribeToSpotMarketAccount(marketIndex: number): Promise<boolean>;
+    subscribeToPerpMarketAccount(marketIndex: number): Promise<boolean>;
+    subscribeToOracle(oracleInfo: OracleInfo): Promise<boolean>;
+}

package/lib/accounts/grpcDriftClientAccountSubscriber.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gprcDriftClientAccountSubscriber = void 0;
+const webSocketDriftClientAccountSubscriber_1 = require("./webSocketDriftClientAccountSubscriber");
+const config_1 = require("../config");
+const pda_1 = require("../addresses/pda");
+const grpcAccountSubscriber_1 = require("./grpcAccountSubscriber");
+class gprcDriftClientAccountSubscriber extends webSocketDriftClientAccountSubscriber_1.WebSocketDriftClientAccountSubscriber {
+    constructor(grpcConfigs, program, perpMarketIndexes, spotMarketIndexes, oracleInfos, shouldFindAllMarketsAndOracles, resubOpts, commitment) {
+        super(program, perpMarketIndexes, spotMarketIndexes, oracleInfos, shouldFindAllMarketsAndOracles, resubOpts, commitment);
+        this.grpcConfigs = grpcConfigs;
+    }
+    async subscribe() {
+        if (this.isSubscribed) {
+            return true;
+        }
+        if (this.isSubscribing) {
+            return await this.subscriptionPromise;
+        }
+        this.isSubscribing = true;
+        this.subscriptionPromise = new Promise((res) => {
+            this.subscriptionPromiseResolver = res;
+        });
+        if (this.shouldFindAllMarketsAndOracles) {
+            const { perpMarketIndexes, perpMarketAccounts, spotMarketIndexes, spotMarketAccounts, oracleInfos, } = await (0, config_1.findAllMarketAndOracles)(this.program);
+            this.perpMarketIndexes = perpMarketIndexes;
+            this.spotMarketIndexes = spotMarketIndexes;
+            this.oracleInfos = oracleInfos;
+            // front run and set the initial data here to save extra gma call in set initial data
+            this.initialPerpMarketAccountData = new Map(perpMarketAccounts.map((market) => [market.marketIndex, market]));
+            this.initialSpotMarketAccountData = new Map(spotMarketAccounts.map((market) => [market.marketIndex, market]));
+        }
+        const statePublicKey = await (0, pda_1.getDriftStateAccountPublicKey)(this.program.programId);
+        // create and activate main state account subscription
+        this.stateAccountSubscriber = new grpcAccountSubscriber_1.grpcAccountSubscriber(this.grpcConfigs, 'state', this.program, statePublicKey, undefined, undefined);
+        await this.stateAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('stateAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        // set initial data to avoid spamming getAccountInfo calls in webSocketAccountSubscriber
+        await this.setInitialData();
+        await Promise.all([
+            // subscribe to market accounts
+            this.subscribeToPerpMarketAccounts(),
+            // subscribe to spot market accounts
+            this.subscribeToSpotMarketAccounts(),
+            // subscribe to oracles
+            this.subscribeToOracles(),
+        ]);
+        this.eventEmitter.emit('update');
+        await Promise.all([this.setPerpOracleMap(), this.setSpotOracleMap()]);
+        this.subscriptionPromiseResolver(true);
+        this.isSubscribing = false;
+        this.isSubscribed = true;
+        // delete initial data
+        this.removeInitialData();
+        return true;
+    }
+    async subscribeToSpotMarketAccount(marketIndex) {
+        const marketPublicKey = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex);
+        const accountSubscriber = new grpcAccountSubscriber_1.grpcAccountSubscriber(this.grpcConfigs, 'spotMarket', this.program, marketPublicKey, undefined, this.resubOpts);
+        accountSubscriber.setData(this.initialSpotMarketAccountData.get(marketIndex));
+        await accountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('spotMarketAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.spotMarketAccountSubscribers.set(marketIndex, accountSubscriber);
+        return true;
+    }
+    async subscribeToPerpMarketAccount(marketIndex) {
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex);
+        const accountSubscriber = new grpcAccountSubscriber_1.grpcAccountSubscriber(this.grpcConfigs, 'perpMarket', this.program, perpMarketPublicKey, undefined, this.resubOpts);
+        accountSubscriber.setData(this.initialPerpMarketAccountData.get(marketIndex));
+        await accountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('perpMarketAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.perpMarketAccountSubscribers.set(marketIndex, accountSubscriber);
+        return true;
+    }
+    async subscribeToOracle(oracleInfo) {
+        const oracleString = oracleInfo.publicKey.toString();
+        const client = this.oracleClientCache.get(oracleInfo.source, this.program.provider.connection, this.program);
+        const accountSubscriber = new grpcAccountSubscriber_1.grpcAccountSubscriber(this.grpcConfigs, 'oracle', this.program, oracleInfo.publicKey, (buffer) => {
+            return client.getOraclePriceDataFromBuffer(buffer);
+        }, this.resubOpts);
+        accountSubscriber.setData(this.initialOraclePriceData.get(oracleString));
+        await accountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('oraclePriceUpdate', oracleInfo.publicKey, data);
+            this.eventEmitter.emit('update');
+        });
+        this.oracleSubscribers.set(oracleString, accountSubscriber);
+        return true;
+    }
+}
+exports.gprcDriftClientAccountSubscriber = gprcDriftClientAccountSubscriber;

package/lib/accounts/grpcInsuranceFundStakeAccountSubscriber.d.ts

@@ -0,0 +1,10 @@
+import { GrpcConfigs } from './types';
+import { Program } from '@coral-xyz/anchor';
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { InsuranceFundStake } from '../types';
+import { WebSocketInsuranceFundStakeAccountSubscriber } from './webSocketInsuranceFundStakeAccountSubscriber';
+export declare class grpcInsuranceFundStakeAccountSubscriber extends WebSocketInsuranceFundStakeAccountSubscriber {
+    private grpcConfigs;
+    constructor(grpcConfigs: GrpcConfigs, program: Program, insuranceFundStakeAccountPublicKey: PublicKey, resubTimeoutMs?: number, commitment?: Commitment);
+    subscribe(insuranceFundStakeAccount?: InsuranceFundStake): Promise<boolean>;
+}

package/lib/accounts/grpcInsuranceFundStakeAccountSubscriber.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcInsuranceFundStakeAccountSubscriber = void 0;
+const webSocketInsuranceFundStakeAccountSubscriber_1 = require("./webSocketInsuranceFundStakeAccountSubscriber");
+const grpcAccountSubscriber_1 = require("./grpcAccountSubscriber");
+class grpcInsuranceFundStakeAccountSubscriber extends webSocketInsuranceFundStakeAccountSubscriber_1.WebSocketInsuranceFundStakeAccountSubscriber {
+    constructor(grpcConfigs, program, insuranceFundStakeAccountPublicKey, resubTimeoutMs, commitment) {
+        super(program, insuranceFundStakeAccountPublicKey, resubTimeoutMs, commitment);
+        this.grpcConfigs = grpcConfigs;
+    }
+    async subscribe(insuranceFundStakeAccount) {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.insuranceFundStakeDataAccountSubscriber = new grpcAccountSubscriber_1.grpcAccountSubscriber(this.grpcConfigs, 'insuranceFundStake', this.program, this.insuranceFundStakeAccountPublicKey, undefined, {
+            resubTimeoutMs: this.resubTimeoutMs,
+        });
+        if (insuranceFundStakeAccount) {
+            this.insuranceFundStakeDataAccountSubscriber.setData(insuranceFundStakeAccount);
+        }
+        await this.insuranceFundStakeDataAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('insuranceFundStakeAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+}
+exports.grpcInsuranceFundStakeAccountSubscriber = grpcInsuranceFundStakeAccountSubscriber;

package/lib/accounts/grpcProgramAccountSubscriber.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { ResubOpts, GrpcConfigs } from './types';
+import { Program } from '@coral-xyz/anchor';
+import { Commitment, Context, MemcmpFilter, PublicKey } from '@solana/web3.js';
+import { WebSocketProgramAccountSubscriber } from './webSocketProgramAccountSubscriber';
+import { ClientDuplexStream } from '@grpc/grpc-js';
+import Client, { SubscribeRequest, SubscribeUpdate, CommitmentLevel } from '@triton-one/yellowstone-grpc';
+export declare class grpcProgramAccountSubscriber<T> extends WebSocketProgramAccountSubscriber<T> {
+    client: Client;
+    stream: ClientDuplexStream<SubscribeRequest, SubscribeUpdate>;
+    commitmentLevel: CommitmentLevel;
+    listenerId?: number;
+    constructor(grpcConfigs: GrpcConfigs, subscriptionName: string, accountDiscriminator: string, program: Program, decodeBufferFn: (accountName: string, ix: Buffer) => T, options?: {
+        filters: MemcmpFilter[];
+        commitment?: Commitment;
+    }, resubOpts?: ResubOpts);
+    subscribe(onChange: (accountId: PublicKey, data: T, context: Context, buffer: Buffer) => void): Promise<void>;
+    unsubscribe(onResub?: boolean): Promise<void>;
+}

package/lib/accounts/grpcProgramAccountSubscriber.js

@@ -0,0 +1,161 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcProgramAccountSubscriber = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const Buffer = __importStar(require("buffer"));
+const webSocketProgramAccountSubscriber_1 = require("./webSocketProgramAccountSubscriber");
+const yellowstone_grpc_1 = __importStar(require("@triton-one/yellowstone-grpc"));
+class grpcProgramAccountSubscriber extends webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber {
+    constructor(grpcConfigs, subscriptionName, accountDiscriminator, program, decodeBufferFn, options = {
+        filters: [],
+    }, resubOpts) {
+        var _a, _b;
+        super(subscriptionName, accountDiscriminator, program, decodeBufferFn, options, resubOpts);
+        this.client = new yellowstone_grpc_1.default(grpcConfigs.endpoint, grpcConfigs.token, (_a = grpcConfigs.channelOptions) !== null && _a !== void 0 ? _a : {});
+        this.commitmentLevel =
+            (_b = grpcConfigs.commitmentLevel) !== null && _b !== void 0 ? _b : yellowstone_grpc_1.CommitmentLevel.CONFIRMED;
+    }
+    async subscribe(onChange) {
+        if (this.listenerId != null || this.isUnsubscribing) {
+            return;
+        }
+        this.onChange = onChange;
+        // Subscribe with grpc
+        this.stream = await this.client.subscribe();
+        const request = {
+            slots: {
+                slots: {},
+            },
+            accounts: {
+                drift: {
+                    account: [],
+                    owner: [this.program.programId.toBase58()],
+                    // @ts-ignore
+                    filters: this.options.filters,
+                },
+            },
+            transactions: {},
+            blocks: {},
+            blocksMeta: {},
+            accountsDataSlice: [],
+            commitment: this.commitmentLevel,
+            entry: {},
+            transactionsStatus: {},
+        };
+        this.stream.on('data', (chunk) => {
+            var _a;
+            if (!chunk.account) {
+                return;
+            }
+            const slot = Number(chunk.account.slot);
+            const accountInfo = {
+                owner: new web3_js_1.PublicKey(chunk.account.account.owner),
+                lamports: Number(chunk.account.account.lamports),
+                data: Buffer.Buffer.from(chunk.account.account.data),
+                executable: chunk.account.account.executable,
+                rentEpoch: Number(chunk.account.account.rentEpoch),
+            };
+            if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
+                this.receivingData = true;
+                clearTimeout(this.timeoutId);
+                this.handleRpcResponse({
+                    slot,
+                }, {
+                    accountId: new web3_js_1.PublicKey(chunk.account.account.pubkey),
+                    accountInfo,
+                });
+                this.setTimeout();
+            }
+            else {
+                this.handleRpcResponse({
+                    slot,
+                }, {
+                    accountId: new web3_js_1.PublicKey(chunk.account.account.pubkey),
+                    accountInfo,
+                });
+            }
+        });
+        return new Promise((resolve, reject) => {
+            this.stream.write(request, (err) => {
+                var _a;
+                if (err === null || err === undefined) {
+                    this.listenerId = 1;
+                    if ((_a = this.resubOpts) === null || _a === void 0 ? void 0 : _a.resubTimeoutMs) {
+                        this.receivingData = true;
+                        this.setTimeout();
+                    }
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+        }).catch((reason) => {
+            console.error(reason);
+            throw reason;
+        });
+    }
+    async unsubscribe(onResub = false) {
+        if (!onResub && this.resubOpts) {
+            this.resubOpts.resubTimeoutMs = undefined;
+        }
+        this.isUnsubscribing = true;
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.listenerId != null) {
+            const promise = new Promise((resolve, reject) => {
+                const request = {
+                    slots: {},
+                    accounts: {},
+                    transactions: {},
+                    blocks: {},
+                    blocksMeta: {},
+                    accountsDataSlice: [],
+                    entry: {},
+                    transactionsStatus: {},
+                };
+                this.stream.write(request, (err) => {
+                    if (err === null || err === undefined) {
+                        this.listenerId = undefined;
+                        this.isUnsubscribing = false;
+                        resolve();
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+            }).catch((reason) => {
+                console.error(reason);
+                throw reason;
+            });
+            return promise;
+        }
+        else {
+            this.isUnsubscribing = false;
+        }
+    }
+}
+exports.grpcProgramAccountSubscriber = grpcProgramAccountSubscriber;

package/lib/accounts/grpcUserAccountSubscriber.d.ts

@@ -0,0 +1,10 @@
+import { ResubOpts, GrpcConfigs } from './types';
+import { Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { UserAccount } from '../types';
+import { WebSocketUserAccountSubscriber } from './webSocketUserAccountSubscriber';
+export declare class grpcUserAccountSubscriber extends WebSocketUserAccountSubscriber {
+    private grpcConfigs;
+    constructor(grpcConfigs: GrpcConfigs, program: Program, userAccountPublicKey: PublicKey, resubOpts?: ResubOpts);
+    subscribe(userAccount?: UserAccount): Promise<boolean>;
+}

package/lib/accounts/grpcUserAccountSubscriber.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcUserAccountSubscriber = void 0;
+const webSocketUserAccountSubscriber_1 = require("./webSocketUserAccountSubscriber");
+const grpcAccountSubscriber_1 = require("./grpcAccountSubscriber");
+class grpcUserAccountSubscriber extends webSocketUserAccountSubscriber_1.WebSocketUserAccountSubscriber {
+    constructor(grpcConfigs, program, userAccountPublicKey, resubOpts) {
+        super(program, userAccountPublicKey, resubOpts);
+        this.grpcConfigs = grpcConfigs;
+    }
+    async subscribe(userAccount) {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.userDataAccountSubscriber = new grpcAccountSubscriber_1.grpcAccountSubscriber(this.grpcConfigs, 'user', this.program, this.userAccountPublicKey, undefined, this.resubOpts);
+        if (userAccount) {
+            this.userDataAccountSubscriber.setData(userAccount);
+        }
+        await this.userDataAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('userAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+}
+exports.grpcUserAccountSubscriber = grpcUserAccountSubscriber;

package/lib/accounts/grpcUserStatsAccountSubscriber.d.ts

@@ -0,0 +1,10 @@
+import { ResubOpts, GrpcConfigs } from './types';
+import { Program } from '@coral-xyz/anchor';
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { UserStatsAccount } from '../types';
+import { WebSocketUserStatsAccountSubscriber } from './webSocketUserStatsAccountSubsriber';
+export declare class grpcUserStatsAccountSubscriber extends WebSocketUserStatsAccountSubscriber {
+    private grpcConfigs;
+    constructor(grpcConfigs: GrpcConfigs, program: Program, userStatsAccountPublicKey: PublicKey, resubOpts?: ResubOpts, commitment?: Commitment);
+    subscribe(userStatsAccount?: UserStatsAccount): Promise<boolean>;
+}

package/lib/accounts/grpcUserStatsAccountSubscriber.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcUserStatsAccountSubscriber = void 0;
+const webSocketUserStatsAccountSubsriber_1 = require("./webSocketUserStatsAccountSubsriber");
+const grpcAccountSubscriber_1 = require("./grpcAccountSubscriber");
+class grpcUserStatsAccountSubscriber extends webSocketUserStatsAccountSubsriber_1.WebSocketUserStatsAccountSubscriber {
+    constructor(grpcConfigs, program, userStatsAccountPublicKey, resubOpts, commitment) {
+        super(program, userStatsAccountPublicKey, resubOpts, commitment);
+        this.grpcConfigs = grpcConfigs;
+    }
+    async subscribe(userStatsAccount) {
+        if (this.isSubscribed) {
+            return true;
+        }
+        this.userStatsAccountSubscriber = new grpcAccountSubscriber_1.grpcAccountSubscriber(this.grpcConfigs, 'userStats', this.program, this.userStatsAccountPublicKey, undefined, this.resubOpts);
+        if (userStatsAccount) {
+            this.userStatsAccountSubscriber.setData(userStatsAccount);
+        }
+        await this.userStatsAccountSubscriber.subscribe((data) => {
+            this.eventEmitter.emit('userStatsAccountUpdate', data);
+            this.eventEmitter.emit('update');
+        });
+        this.eventEmitter.emit('update');
+        this.isSubscribed = true;
+        return true;
+    }
+}
+exports.grpcUserStatsAccountSubscriber = grpcUserStatsAccountSubscriber;

package/lib/accounts/types.d.ts

@@ -6,6 +6,8 @@ import { EventEmitter } from 'events';
 import { Context, PublicKey } from '@solana/web3.js';
 import { Account } from '@solana/spl-token';
 import { OracleInfo, OraclePriceData } from '..';
+import { CommitmentLevel } from '@triton-one/yellowstone-grpc';
+import { ChannelOptions } from '@grpc/grpc-js';
 export interface AccountSubscriber<T> {
     dataAndSlot?: DataAndSlot<T>;
     subscribe(onChange: (data: T) => void): Promise<void>;
@@ -140,3 +142,9 @@ export interface UserStatsAccountSubscriber {
     unsubscribe(): Promise<void>;
     getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
 }
+export type GrpcConfigs = {
+    endpoint: string;
+    token: string;
+    commitmentLevel?: CommitmentLevel;
+    channelOptions?: ChannelOptions;
+};

package/lib/accounts/webSocketAccountSubscriber.d.ts

@@ -20,7 +20,7 @@ export declare class WebSocketAccountSubscriber<T> implements AccountSubscriber<
     constructor(accountName: string, program: Program, accountPublicKey: PublicKey, decodeBuffer?: (buffer: Buffer) => T, resubOpts?: ResubOpts, commitment?: Commitment);
     subscribe(onChange: (data: T) => void): Promise<void>;
     setData(data: T, slot?: number): void;
-    private setTimeout;
+    protected setTimeout(): void;
     fetch(): Promise<void>;
     handleRpcResponse(context: Context, accountInfo?: AccountInfo<Buffer>): void;
     decodeBuffer(buffer: Buffer): T;

package/lib/accounts/webSocketDriftClientAccountSubscriber.d.ts

@@ -30,9 +30,9 @@ export declare class WebSocketDriftClientAccountSubscriber implements DriftClien
     initialPerpMarketAccountData: Map<number, PerpMarketAccount>;
     initialSpotMarketAccountData: Map<number, SpotMarketAccount>;
     initialOraclePriceData: Map<string, OraclePriceData>;
-    private isSubscribing;
-    private subscriptionPromise;
-    private subscriptionPromiseResolver;
+    protected isSubscribing: boolean;
+    protected subscriptionPromise: Promise<boolean>;
+    protected subscriptionPromiseResolver: (val: boolean) => void;
     constructor(program: Program, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[], shouldFindAllMarketsAndOracles: boolean, resubOpts?: ResubOpts, commitment?: Commitment);
     subscribe(): Promise<boolean>;
     setInitialData(): Promise<void>;

package/lib/accounts/webSocketProgramAccountSubscriber.d.ts

@@ -27,7 +27,7 @@ export declare class WebSocketProgramAccountSubscriber<T> implements ProgramAcco
         commitment?: Commitment;
     }, resubOpts?: ResubOpts);
     subscribe(onChange: (accountId: PublicKey, data: T, context: Context, buffer: Buffer) => void): Promise<void>;
-    private setTimeout;
+    protected setTimeout(): void;
     handleRpcResponse(context: Context, keyedAccountInfo: KeyedAccountInfo): void;
     unsubscribe(onResub?: boolean): Promise<void>;
 }