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

package/tests/tx/TransactionConfirmationManager.test.ts

@@ -0,0 +1,286 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { Connection, SignatureStatus } from '@solana/web3.js';
+import { TransactionConfirmationManager } from '../../src/util/TransactionConfirmationManager';
+import assert from 'assert';
+
+describe('TransactionConfirmationManager', () => {
+	let manager: TransactionConfirmationManager;
+	let mockConnection: sinon.SinonStubbedInstance<Connection>;
+
+	beforeEach(() => {
+		mockConnection = sinon.createStubInstance(Connection);
+		manager = new TransactionConfirmationManager(
+			mockConnection as unknown as Connection
+		);
+	});
+
+	afterEach(() => {
+		sinon.restore();
+	});
+
+	it('should throw error for invalid poll interval', async () => {
+		try {
+			await manager.confirmTransaction('fakeTxSig', 'confirmed', 30000, 300);
+			assert.fail('Expected an error to be thrown');
+		} catch (error) {
+			assert(error instanceof Error);
+			assert.strictEqual(
+				error.message,
+				'Transaction confirmation polling interval must be at least 400ms and a multiple of 100ms'
+			);
+		}
+	});
+
+	it('should resolve when transaction is confirmed', async () => {
+		const fakeTxSig = 'fakeTxSig';
+		const fakeStatus: SignatureStatus = {
+			slot: 100,
+			confirmations: 1,
+			err: null,
+			confirmationStatus: 'confirmed',
+		};
+
+		mockConnection.getSignatureStatuses.resolves({
+			context: { slot: 100 },
+			value: [fakeStatus],
+		});
+
+		const result = await manager.confirmTransaction(
+			fakeTxSig,
+			'confirmed',
+			30000,
+			400
+		);
+
+		expect(result).to.deep.equal(fakeStatus);
+		expect(
+			mockConnection.getSignatureStatuses.calledWith([fakeTxSig], {
+				searchTransactionHistory: false,
+			})
+		).to.be.true;
+	});
+
+	it('should reject when transaction fails', async () => {
+		const fakeTxSig = 'fakeTxSig';
+		const fakeStatus: SignatureStatus = {
+			slot: 100,
+			confirmations: 1,
+			err: { InstructionError: [0, 'Custom'] },
+			confirmationStatus: 'confirmed',
+		};
+
+		mockConnection.getSignatureStatuses.resolves({
+			context: { slot: 100 },
+			value: [fakeStatus],
+		});
+
+		try {
+			await manager.confirmTransaction(fakeTxSig, 'confirmed', 30000, 400);
+			assert.fail('Expected an error to be thrown');
+		} catch (error) {
+			assert(error instanceof Error);
+			assert.strictEqual(
+				error.message,
+				'Transaction failed: {"InstructionError":[0,"Custom"]}'
+			);
+		}
+	});
+
+	it('should reject on timeout', async () => {
+		const clock = sinon.useFakeTimers();
+
+		const fakeTxSig = 'fakeTxSig';
+		mockConnection.getSignatureStatuses.resolves({
+			context: { slot: 100 },
+			value: [null],
+		});
+
+		const promise = manager.confirmTransaction(
+			fakeTxSig,
+			'confirmed',
+			5000,
+			1000
+		);
+
+		clock.tick(6000);
+
+		try {
+			await promise;
+			assert.fail('Expected an error to be thrown');
+		} catch (error) {
+			assert(error instanceof Error);
+			assert.strictEqual(
+				error.message,
+				'Transaction confirmation timeout after 5000ms'
+			);
+		}
+
+		clock.restore();
+	});
+
+	it('should check multiple transactions together', async () => {
+		const fakeTxSig1 = 'fakeTxSig1';
+		const fakeTxSig2 = 'fakeTxSig2';
+		const fakeStatus1: SignatureStatus = {
+			slot: 100,
+			confirmations: 1,
+			err: null,
+			confirmationStatus: 'confirmed',
+		};
+		const fakeStatus2: SignatureStatus = {
+			slot: 100,
+			confirmations: 1,
+			err: null,
+			confirmationStatus: 'confirmed',
+		};
+
+		mockConnection.getSignatureStatuses.resolves({
+			context: { slot: 100 },
+			value: [fakeStatus1, fakeStatus2],
+		});
+
+		const promise1 = manager.confirmTransaction(
+			fakeTxSig1,
+			'confirmed',
+			30000,
+			400
+		);
+		const promise2 = manager.confirmTransaction(
+			fakeTxSig2,
+			'confirmed',
+			30000,
+			400
+		);
+
+		const clock = sinon.useFakeTimers();
+		clock.tick(400);
+		clock.restore();
+
+		const [result1, result2] = await Promise.all([promise1, promise2]);
+
+		expect(result1).to.deep.equal(fakeStatus1);
+		expect(result2).to.deep.equal(fakeStatus2);
+		expect(
+			mockConnection.getSignatureStatuses.calledWith([fakeTxSig1, fakeTxSig2], {
+				searchTransactionHistory: false,
+			})
+		).to.be.true;
+	});
+
+	it('should have overlapping request for transactions with 400ms and 1200ms intervals on the third 400ms interval', async function () {
+		this.timeout(5000); // Increase timeout for this test to 5 seconds
+
+		const fakeTxSig1 = 'fakeTxSig1'; // 400ms interval
+		const fakeTxSig2 = 'fakeTxSig2'; // 1200ms interval
+		const fakeStatus: SignatureStatus = {
+			slot: 100,
+			confirmations: 1,
+			err: null,
+			confirmationStatus: 'confirmed',
+		};
+
+		let callCount = 0;
+		const callTimes: number[] = [];
+		const callSignatures: string[][] = [];
+
+		mockConnection.getSignatureStatuses = async (signatures) => {
+			callCount++;
+			const currentTime = Date.now();
+			callTimes.push(currentTime);
+			callSignatures.push([...signatures]);
+
+			if (callCount < 3) {
+				return {
+					context: { slot: 100 },
+					value: signatures.map(() => null),
+				};
+			} else {
+				return {
+					context: { slot: 100 },
+					value: signatures.map(() => fakeStatus),
+				};
+			}
+		};
+
+		const startTime = Date.now();
+
+		// Start both confirmation processes
+		const promise1 = manager.confirmTransaction(
+			fakeTxSig1,
+			'confirmed',
+			5000,
+			400
+		);
+		const promise2 = manager.confirmTransaction(
+			fakeTxSig2,
+			'confirmed',
+			5000,
+			1200
+		);
+
+		// Wait for 1250ms to ensure we've hit the third 400ms interval and first 1200ms interval
+		await new Promise((resolve) => setTimeout(resolve, 1250));
+
+		// Resolve both promises
+		await Promise.all([promise1, promise2]);
+
+		// Check the call times and signatures
+		assert.strictEqual(callTimes.length, 3, 'Should have exactly 3 calls');
+
+		// Check if the third call is close to 1200ms and includes both signatures
+		const overlapCall = 2; // The third call should be the overlapping one
+		const overlapTime = callTimes[overlapCall] - startTime;
+
+		assert(
+			Math.abs(overlapTime - 1200) < 100,
+			`Overlapping call should be around 1200ms, but was at ${overlapTime}ms`
+		);
+
+		// Verify the call pattern
+		assert(
+			callSignatures[0].includes(fakeTxSig1) &&
+				!callSignatures[0].includes(fakeTxSig2),
+			'First call should only include 400ms interval transaction'
+		);
+		assert(
+			callSignatures[1].includes(fakeTxSig1) &&
+				!callSignatures[1].includes(fakeTxSig2),
+			'Second call should only include 400ms interval transaction'
+		);
+		assert(
+			callSignatures[2].includes(fakeTxSig1) &&
+				callSignatures[2].includes(fakeTxSig2),
+			'Third call should include both transactions'
+		);
+
+		// Wait for 1000ms to check that we haven't made any more calls now that all transactions are confirmed
+		await new Promise((resolve) => setTimeout(resolve, 1000));
+
+		// Verify that no more calls were made
+		assert.strictEqual(
+			callTimes.length,
+			3,
+			'Should not have made any more calls after all transactions are confirmed'
+		);
+
+		// Verify that only the third call returns non-null results
+		callCount = 0;
+		const results = await Promise.all(
+			callSignatures.map((sigs) => mockConnection.getSignatureStatuses!(sigs))
+		);
+
+		assert(
+			results[0].value.every((v) => v === null),
+			'First call should return null results'
+		);
+		assert(
+			results[1].value.every((v) => v === null),
+			'Second call should return null results'
+		);
+		assert(
+			results[2].value.every((v) => v !== null),
+			'Third call should return non-null results'
+		);
+	});
+});

package/lib/accounts/grpcAccountSubscriber.d.ts

@@ -1,16 +0,0 @@
-/// <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

@@ -1,155 +0,0 @@
-"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

@@ -1,13 +0,0 @@
-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

@@ -1,96 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-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

@@ -1,30 +0,0 @@
-"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

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