@injectivelabs/sdk-ts 1.17.2-alpha.1 → 1.17.2-alpha.10

package/dist/esm/{IndexerGrpcAccountPortfolioStream-CxK8ZbH1.js → StreamManager-Bz2mGjMt.js}

@@ -1,13 +1,12 @@
-import { a as grpcPagingToPagingV2, on as uint8ArrayToString, pt as isJsonString } from "./utils-BaRG9oyg.js";
+import { Jt as uint8ArrayToString, a as grpcPagingToPagingV2, en as isJsonString } from "./utils-DwGoPRTL.js";
 import { t as _defineProperty } from "./defineProperty-Bq6QU9Te.js";
 import { n as GrpcWebRpcTransport } from "./BaseGrpcConsumer-DptVGP0n.js";
 import { t as BaseIndexerGrpcConsumer } from "./BaseIndexerGrpcConsumer-CjpUoGXy.js";
 import { t as BaseRestConsumer } from "./BaseRestConsumer-rK4eS4W8.js";
-import { r as IndexerModule } from "./IndexerGrpcWeb3GwApi-C82holuJ.js";
-import { a as StreamOperation$1, c as TokenVerification, s as TokenType } from "./types-Cq0sRR6y.js";
+import { r as IndexerModule } from "./IndexerGrpcWeb3GwApi-CtUYowus.js";
+import { a as TradeDirection, c as StreamDisconnectReason, f as TokenType, i as OrderState, l as StreamEvent, p as TokenVerification, t as StreamOperation, u as StreamState } from "./types-Bu8IAJ0R.js";
 import { BigNumber, toBigNumber, toHumanReadable } from "@injectivelabs/utils";
 import { GeneralException, HttpRequestException, UnspecifiedErrorCode } from "@injectivelabs/exceptions";
-import { OrderState, StreamOperation, TradeDirection } from "@injectivelabs/ts-types";
 import { MitoAPIClient } from "@injectivelabs/mito-proto-ts-v2/generated/goadesign_goagen_mito_api_pb.client";
 import * as GoadesignGoagenMitoApiPb from "@injectivelabs/mito-proto-ts-v2/generated/goadesign_goagen_mito_api_pb";
 import * as InjectiveMetaRpcPb from "@injectivelabs/indexer-proto-ts-v2/generated/injective_meta_rpc_pb";
@@ -38,6 +37,7 @@ import * as InjectivePortfolioRpcPb from "@injectivelabs/indexer-proto-ts-v2/gen
 import { InjectivePortfolioRPCClient } from "@injectivelabs/indexer-proto-ts-v2/generated/injective_portfolio_rpc_pb.client";
 import * as InjectiveInsuranceRpcPb from "@injectivelabs/indexer-proto-ts-v2/generated/injective_insurance_rpc_pb";
 import { InjectiveInsuranceRPCClient } from "@injectivelabs/indexer-proto-ts-v2/generated/injective_insurance_rpc_pb.client";
+import { EventEmitter } from "eventemitter3";
 
 //#region src/client/indexer/transformers/IndexerCommonTransformer.ts
 var IndexerCommonTransformer = class {
@@ -1710,7 +1710,7 @@ var IndexerGrpcReferralTransformer = class {
 var IndexerOracleStreamTransformer = class {};
 _defineProperty(IndexerOracleStreamTransformer, "pricesStreamCallback", (response) => ({
 	price: response.price,
-	operation: StreamOperation$1.Update,
+	operation: StreamOperation.Update,
 	timestamp: typeof response.timestamp === "bigint" ? Number(response.timestamp) : parseInt(response.timestamp, 10)
 }));
 _defineProperty(IndexerOracleStreamTransformer, "pricesByMarketsCallback", (response) => ({ ...response }));
@@ -1949,7 +1949,7 @@ _defineProperty(IndexerAccountStreamTransformer, "balanceStreamCallback", (respo
 	const balance = response.balance;
 	return {
 		balance: balance ? IndexerGrpcAccountTransformer.grpcBalanceToBalance(balance) : void 0,
-		operation: StreamOperation$1.Update,
+		operation: StreamOperation.Update,
 		timestamp: response.timestamp
 	};
 });
@@ -2185,7 +2185,7 @@ _defineProperty(IndexerArchiverStreamTransformer, "spotAverageEntriesStreamCallb
 	const averageEntry = response.averageEntry;
 	return {
 		averageEntry: averageEntry ? IndexerGrpcArchiverTransformer.grpcSpotAverageEntryToSpotAverageEntry(averageEntry) : void 0,
-		operation: StreamOperation$1.Update,
+		operation: StreamOperation.Update,
 		timestamp: typeof response.timestamp === "bigint" ? Number(response.timestamp) : response.timestamp
 	};
 });
@@ -2198,15 +2198,15 @@ _defineProperty(IndexerArchiverStreamTransformer, "spotAverageEntriesStreamCallb
 var ExplorerStreamTransformer = class {};
 _defineProperty(ExplorerStreamTransformer, "blocksStreamCallback", (response) => ({
 	block: IndexerGrpcExplorerTransformer.grpcBlockToBlock(response),
-	operation: StreamOperation$1.Insert
+	operation: StreamOperation.Insert
 }));
 _defineProperty(ExplorerStreamTransformer, "blocksWithTxsStreamCallback", (response) => ({
 	block: IndexerGrpcExplorerTransformer.grpcBlockToBlockWithTxs(response),
-	operation: StreamOperation$1.Insert
+	operation: StreamOperation.Insert
 }));
 _defineProperty(ExplorerStreamTransformer, "transactionsStreamCallback", (response) => ({
 	block: IndexerGrpcExplorerTransformer.streamTxResponseToTxs(response),
-	operation: StreamOperation$1.Insert
+	operation: StreamOperation.Insert
 }));
 
 //#endregion
@@ -4616,7 +4616,7 @@ var IndexerRestLeaderboardChronosApi = class extends BaseRestConsumer {
 };
 
 //#endregion
-//#region src/client/indexer/grpc_stream/streamHelpers.ts
+//#region src/client/indexer/grpc_stream/stream/streamHelpers.ts
 /**
 * Creates a subscription wrapper for V2 streaming with proper cancellation support.
 *
@@ -4650,7 +4650,7 @@ function createStreamSubscription(stream, handleResponse, onEndCallback, onStatu
 }
 
 //#endregion
-//#region src/client/indexer/grpc_stream/IndexerGrpcSpotStream.ts
+//#region src/client/indexer/grpc_stream/stream/IndexerGrpcSpotStream.ts
 /**
 * @category Indexer Grpc Stream
 * @description Provides streaming access to spot market data from Injective Indexer
@@ -4662,9 +4662,9 @@ var IndexerGrpcSpotStream = class {
 		this.transport = new GrpcWebRpcTransport(endpoint, metadata);
 		this.client = new InjectiveSpotExchangeRPCClient(this.transport);
 	}
-	/** @deprecated - use streamSpotOrderbookV2 */
-	streamSpotOrderbook(_args) {
-		throw new GeneralException(/* @__PURE__ */ new Error("deprecated - use streamDerivativeOrderbookV2"));
+	/** @deprecated - use streamOrderbookV2 */
+	streamOrderbook(_args) {
+		throw new GeneralException(/* @__PURE__ */ new Error("deprecated - use streamOrderbookV2"));
 	}
 	/**
 	* Stream spot orders
@@ -4677,7 +4677,7 @@ var IndexerGrpcSpotStream = class {
 	* @param params.onStatusCallback - Called on stream errors
 	* @returns Subscription object with unsubscribe method
 	*/
-	streamSpotOrders({ marketId, subaccountId, orderSide, callback, onEndCallback, onStatusCallback }) {
+	streamOrders({ marketId, subaccountId, orderSide, callback, onEndCallback, onStatusCallback }) {
 		if (typeof callback !== "function") throw new Error("callback must be a function");
 		const request = InjectiveSpotExchangeRpcPb.StreamOrdersRequest.create();
 		if (marketId) request.marketId = marketId;
@@ -4701,7 +4701,7 @@ var IndexerGrpcSpotStream = class {
 	* @param params.onStatusCallback - Called on stream errors
 	* @returns Subscription object with unsubscribe method
 	*/
-	streamSpotOrderHistory({ marketId, subaccountId, orderTypes, executionTypes, direction, state, callback, onEndCallback, onStatusCallback }) {
+	streamOrderHistory({ marketId, subaccountId, orderTypes, executionTypes, direction, state, callback, onEndCallback, onStatusCallback }) {
 		if (typeof callback !== "function") throw new Error("callback must be a function");
 		const request = InjectiveSpotExchangeRpcPb.StreamOrdersHistoryRequest.create();
 		if (subaccountId) request.subaccountId = subaccountId;
@@ -4729,7 +4729,7 @@ var IndexerGrpcSpotStream = class {
 	* @param params.onStatusCallback - Called on stream errors
 	* @returns Subscription object with unsubscribe method
 	*/
-	streamSpotTrades({ marketIds, marketId, subaccountIds, subaccountId, pagination, direction, executionSide, callback, onEndCallback, onStatusCallback }) {
+	streamTrades({ marketIds, marketId, subaccountIds, subaccountId, pagination, direction, executionSide, callback, onEndCallback, onStatusCallback }) {
 		if (typeof callback !== "function") throw new Error("callback must be a function");
 		const request = InjectiveSpotExchangeRpcPb.StreamTradesRequest.create();
 		if (marketIds) request.marketIds = marketIds;
@@ -4755,7 +4755,7 @@ var IndexerGrpcSpotStream = class {
 	* @param params.onStatusCallback - Called on stream errors
 	* @returns Subscription object with unsubscribe method
 	*/
-	streamSpotMarket({ marketIds, callback, onEndCallback, onStatusCallback }) {
+	streamMarkets({ marketIds, callback, onEndCallback, onStatusCallback }) {
 		if (typeof callback !== "function") throw new Error("callback must be a function");
 		const request = InjectiveSpotExchangeRpcPb.StreamMarketsRequest.create();
 		if (marketIds) request.marketIds = marketIds;
@@ -4772,7 +4772,7 @@ var IndexerGrpcSpotStream = class {
 	* @param params.onStatusCallback - Called on stream errors
 	* @returns Subscription object with unsubscribe method
 	*/
-	streamSpotOrderbookV2({ marketIds, callback, onEndCallback, onStatusCallback }) {
+	streamOrderbooksV2({ marketIds, callback, onEndCallback, onStatusCallback }) {
 		if (!marketIds || marketIds.length === 0) throw new Error("marketIds is required and cannot be empty");
 		if (typeof callback !== "function") throw new Error("callback must be a function");
 		const request = InjectiveSpotExchangeRpcPb.StreamOrderbookV2Request.create();
@@ -4790,7 +4790,7 @@ var IndexerGrpcSpotStream = class {
 	* @param params.onStatusCallback - Called on stream errors
 	* @returns Subscription object with unsubscribe method
 	*/
-	streamSpotOrderbookUpdate({ marketIds, callback, onEndCallback, onStatusCallback }) {
+	streamOrderbookUpdates({ marketIds, callback, onEndCallback, onStatusCallback }) {
 		if (!marketIds || marketIds.length === 0) throw new Error("marketIds is required and cannot be empty");
 		if (typeof callback !== "function") throw new Error("callback must be a function");
 		const request = InjectiveSpotExchangeRpcPb.StreamOrderbookUpdateRequest.create();
@@ -4802,7 +4802,7 @@ var IndexerGrpcSpotStream = class {
 };
 
 //#endregion
-//#region src/client/indexer/grpc_stream/IndexerGrpcMitoStream.ts
+//#region src/client/indexer/grpc_stream/stream/IndexerGrpcMitoStream.ts
 /**
 * @category Indexer Grpc Stream
 * @description Provides streaming access to Mito vault data from Injective Indexer
@@ -4917,7 +4917,7 @@ var IndexerGrpcMitoStream = class {
 };
 
 //#endregion
-//#region src/client/indexer/grpc_stream/IndexerGrpcOracleStream.ts
+//#region src/client/indexer/grpc_stream/stream/IndexerGrpcOracleStream.ts
 /**
 * @category Indexer Grpc Stream
 * @description Provides streaming access to oracle price data from Injective Indexer
@@ -4971,7 +4971,7 @@ var IndexerGrpcOracleStream = class {
 };
 
 //#endregion
-//#region src/client/indexer/grpc_stream/IndexerGrpcAccountStream.ts
+//#region src/client/indexer/grpc_stream/stream/IndexerGrpcAccountStream.ts
 /**
 * @category Indexer Grpc Stream
 * @description Provides streaming access to account data from the Injective Indexer
@@ -5004,7 +5004,7 @@ var IndexerGrpcAccountStream = class {
 };
 
 //#endregion
-//#region src/client/indexer/grpc_stream/IndexerGrpcAuctionStream.ts
+//#region src/client/indexer/grpc_stream/stream/IndexerGrpcAuctionStream.ts
 /**
 * @category Indexer Grpc Stream
 * @description Provides streaming access to auction data from Injective Indexer
@@ -5034,7 +5034,7 @@ var IndexerGrpcAuctionStream = class {
 };
 
 //#endregion
-//#region src/client/indexer/grpc_stream/IndexerGrpcTradingStream.ts
+//#region src/client/indexer/grpc_stream/stream/IndexerGrpcTradingStream.ts
 /**
 * @category Indexer Grid Strategy Grpc Stream
 * @description Provides streaming access to grid strategy data from Injective Indexer
@@ -5069,7 +5069,7 @@ var IndexerGrpcTradingStream = class {
 };
 
 //#endregion
-//#region src/client/indexer/grpc_stream/IndexerGrpcArchiverStream.ts
+//#region src/client/indexer/grpc_stream/stream/IndexerGrpcArchiverStream.ts
 /**
 * @category Indexer Grpc Stream
 * @description Provides streaming access to archiver data from Injective Indexer
@@ -5102,7 +5102,7 @@ var IndexerGrpcArchiverStream = class {
 };
 
 //#endregion
-//#region src/client/indexer/grpc_stream/IndexerGrpcExplorerStream.ts
+//#region src/client/indexer/grpc_stream/stream/IndexerGrpcExplorerStream.ts
 /**
 * @category Indexer Grpc Stream
 * @description Provides streaming access to blockchain explorer data from Injective Indexer
@@ -5162,7 +5162,7 @@ var IndexerGrpcExplorerStream = class {
 };
 
 //#endregion
-//#region src/client/indexer/grpc_stream/IndexerGrpcDerivativesStream.ts
+//#region src/client/indexer/grpc_stream/stream/IndexerGrpcDerivativesStream.ts
 /**
 * @category Indexer Grpc Stream
 * @description Provides streaming access to derivatives market data from Injective Indexer
@@ -5352,7 +5352,7 @@ var IndexerGrpcDerivativesStream = class {
 };
 
 //#endregion
-//#region src/client/indexer/grpc_stream/IndexerGrpcAccountPortfolioStream.ts
+//#region src/client/indexer/grpc_stream/stream/IndexerGrpcAccountPortfolioStream.ts
 /**
 * @category Indexer Grpc Stream
 * @description Provides streaming access to account portfolio data from Injective Indexer
@@ -5389,4 +5389,899 @@ var IndexerGrpcAccountPortfolioStream = class {
 };
 
 //#endregion
-export { IndexerGrpcMitoTransformer as $, IndexerGrpcMitoApi as A, IndexerAuctionStreamTransformer as B, IndexerGrpcExplorerApi as C, IndexerGrpcOracleApi as D, IndexerGrpcAccountApi as E, IndexerGrpcMitoStreamTransformer as F, IndexerGrpcExplorerTransformer as G, IndexerRestExplorerTransformer as H, IndexerGrpcDerivativeTransformer as I, IndexerGrpcAccountTransformer as J, IndexerGrpcArchiverTransformer as K, ExplorerStreamTransformer as L, IndexerGrpcInsuranceFundTransformer as M, IndexerDerivativeStreamTransformer as N, IndexerGrpcSpotApi as O, IndexerGrpcAccountPortfolioTransformer as P, IndexerGrpcSpotTransformer as Q, IndexerArchiverStreamTransformer as R, IndexerGrpcCampaignApi as S, IndexerGrpcAuctionApi as T, IndexerOracleStreamTransformer as U, IndexerAccountStreamTransformer as V, IndexerGrpcReferralTransformer as W, IndexerGrpcOracleTransformer as X, IndexerSpotStreamTransformer as Y, IndexerCampaignTransformer as Z, IndexerGrpcAccountPortfolioApi as _, IndexerGrpcTradingStream as a, IndexerGrpcReferralApi as b, IndexerGrpcOracleStream as c, IndexerRestLeaderboardChronosApi as d, IndexerRestDerivativesChronosApi as f, IndexerGrpcInsuranceFundApi as g, IndexerRestExplorerApi as h, IndexerGrpcArchiverStream as i, IndexerAccountPortfolioStreamTransformer as j, IndexerGrpcMetaApi as k, IndexerGrpcMitoStream as l, IndexerRestSpotChronosApi as m, IndexerGrpcDerivativesStream as n, IndexerGrpcAuctionStream as o, IndexerRestMarketChronosApi as p, IndexerGrpcAuctionTransformer as q, IndexerGrpcExplorerStream as r, IndexerGrpcAccountStream as s, IndexerGrpcAccountPortfolioStream as t, IndexerGrpcSpotStream as u, IndexerGrpcDerivativesApi as v, IndexerGrpcTradingApi as w, IndexerGrpcArchiverApi as x, IndexerGrpcMegaVaultApi as y, IndexerGrpcMegaVaultTransformer as z };
+//#region src/client/indexer/grpc_stream/stream/StreamManager.ts
+/**
+* StreamManager - Simple registry for managing multiple V1 stream subscriptions by key
+*
+* This is a lightweight utility for storing and canceling multiple V1 RxJS-based streams.
+* For V2 streams with advanced lifecycle management and retry logic, use StreamManagerV2.
+*/
+var StreamManager = class {
+	constructor() {
+		_defineProperty(this, "streams", /* @__PURE__ */ new Map());
+	}
+	set(stream, streamKey) {
+		if (this.streams.has(streamKey)) throw new Error(`Stream ${streamKey} already exists`);
+		this.streams.set(streamKey, stream);
+	}
+	get(streamKey) {
+		if (!this.streams.has(streamKey)) throw new Error(`Stream ${streamKey} is not found`);
+		return this.streams.get(streamKey);
+	}
+	exists(streamKey) {
+		return this.streams.has(streamKey);
+	}
+	cancelAll() {
+		this.streams.forEach((stream) => {
+			stream.cancel();
+		});
+		this.streams = /* @__PURE__ */ new Map();
+	}
+	cancel(streamKey) {
+		if (!this.streams.has(streamKey)) throw new Error(`Stream ${streamKey} is not found`);
+		this.streams.get(streamKey).cancel();
+		this.streams.delete(streamKey);
+	}
+	cancelIfExists(streamKey) {
+		if (!this.streams.has(streamKey)) return;
+		this.streams.get(streamKey).cancel();
+		this.streams.delete(streamKey);
+	}
+};
+
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/streamHelpersV2.ts
+/**
+* Creates an event-based subscription for StreamManager V2.
+* This emits 'error' and 'complete' events instead of using callbacks.
+*
+* @param stream - The ServerStreamingCall from the V2 client
+* @param handleResponse - Callback to process each stream response
+* @returns StreamSubscription with event emitters for error/complete
+*/
+function createStreamSubscriptionV2(stream, handleResponse) {
+	const emitter = new EventEmitter();
+	const abortController = new AbortController();
+	const subscription = {
+		unsubscribe: () => {
+			abortController.abort();
+			emitter.removeAllListeners();
+		},
+		on: (event, handler) => {
+			emitter.on(event, handler);
+		},
+		off: (event, handler) => {
+			emitter.off(event, handler);
+		}
+	};
+	(async () => {
+		try {
+			for await (const response of stream.responses) {
+				if (abortController.signal.aborted) break;
+				if (abortController.signal.aborted) break;
+				handleResponse(response);
+			}
+			if (!abortController.signal.aborted) emitter.emit("complete");
+		} catch (error) {
+			if (!abortController.signal.aborted) {
+				const errorMessage = error instanceof Error ? error.message : "Unknown stream error";
+				let grpcCode = 2;
+				if (error && typeof error === "object" && "code" in error) grpcCode = error.code;
+				const streamError = {
+					code: grpcCode,
+					metadata: error,
+					details: errorMessage
+				};
+				emitter.emit("error", streamError);
+			}
+		}
+	})();
+	return subscription;
+}
+
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/IndexerGrpcSpotStreamV2.ts
+var IndexerGrpcSpotStreamV2 = class {
+	constructor(endpoint, metadata) {
+		_defineProperty(this, "client", void 0);
+		_defineProperty(this, "transport", void 0);
+		this.transport = new GrpcWebRpcTransport(endpoint, metadata);
+		this.client = new InjectiveSpotExchangeRPCClient(this.transport);
+	}
+	/**
+	* Stream spot orderbook updates
+	* @param params.marketIds - Array of market IDs to stream
+	* @param params.callback - Called for each orderbook update
+	* @returns StreamSubscription
+	*/
+	streamOrderbookUpdates({ marketIds, callback }) {
+		if (!marketIds || marketIds.length === 0) throw new Error("marketIds is required");
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveSpotExchangeRpcPb.StreamOrderbookUpdateRequest.create();
+		request.marketIds = marketIds;
+		return createStreamSubscriptionV2(this.client.streamOrderbookUpdate(request), (response) => {
+			callback(IndexerSpotStreamTransformer.orderbookUpdateStreamCallback(response));
+		});
+	}
+	/**
+	* Stream spot orders
+	* @param params.marketId - Optional market ID to filter
+	* @param params.subaccountId - Optional subaccount ID to filter
+	* @param params.orderSide - Optional order side to filter
+	* @param params.callback - Called for each order update
+	* @returns StreamSubscription
+	*/
+	streamOrders({ marketId, subaccountId, orderSide, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveSpotExchangeRpcPb.StreamOrdersRequest.create();
+		if (marketId) request.marketId = marketId;
+		if (subaccountId) request.subaccountId = subaccountId;
+		if (orderSide) request.orderSide = orderSide;
+		return createStreamSubscriptionV2(this.client.streamOrders(request), (response) => {
+			callback(IndexerSpotStreamTransformer.ordersStreamCallback(response));
+		});
+	}
+	/**
+	* Stream spot order history
+	* @param params.subaccountId - Optional subaccount ID to filter
+	* @param params.marketId - Optional market ID to filter
+	* @param params.orderTypes - Optional order types to filter
+	* @param params.direction - Optional direction to filter
+	* @param params.state - Optional state to filter
+	* @param params.executionTypes - Optional execution types to filter
+	* @param params.callback - Called for each order history update
+	* @returns StreamSubscription
+	*/
+	streamOrderHistory({ subaccountId, marketId, orderTypes, direction, state, executionTypes, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveSpotExchangeRpcPb.StreamOrdersHistoryRequest.create();
+		if (subaccountId) request.subaccountId = subaccountId;
+		if (marketId) request.marketId = marketId;
+		if (orderTypes) request.orderTypes = orderTypes;
+		if (direction) request.direction = direction;
+		if (state) request.state = state;
+		if (executionTypes) request.executionTypes = executionTypes;
+		return createStreamSubscriptionV2(this.client.streamOrdersHistory(request), (response) => {
+			callback(IndexerSpotStreamTransformer.orderHistoryStreamCallback(response));
+		});
+	}
+	/**
+	* Stream spot trades
+	* @param params.marketId - Optional market ID to filter
+	* @param params.marketIds - Optional array of market IDs to filter
+	* @param params.subaccountId - Optional subaccount ID to filter
+	* @param params.subaccountIds - Optional array of subaccount IDs to filter
+	* @param params.executionSide - Optional execution side to filter
+	* @param params.direction - Optional direction to filter
+	* @param params.executionTypes - Optional execution types to filter
+	* @param params.callback - Called for each trade update
+	* @returns StreamSubscription
+	*/
+	streamTrades({ marketId, marketIds, subaccountId, subaccountIds, executionSide, direction, executionTypes, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveSpotExchangeRpcPb.StreamTradesRequest.create();
+		if (marketId) request.marketId = marketId;
+		if (marketIds) request.marketIds = marketIds;
+		if (subaccountId) request.subaccountId = subaccountId;
+		if (subaccountIds) request.subaccountIds = subaccountIds;
+		if (executionSide) request.executionSide = executionSide;
+		if (direction) request.direction = direction;
+		if (executionTypes) request.executionTypes = executionTypes;
+		return createStreamSubscriptionV2(this.client.streamTrades(request), (response) => {
+			callback(IndexerSpotStreamTransformer.tradesStreamCallback(response));
+		});
+	}
+};
+
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/IndexerGrpcMitoStreamV2.ts
+var IndexerGrpcMitoStreamV2 = class {
+	constructor(endpoint, metadata) {
+		_defineProperty(this, "client", void 0);
+		_defineProperty(this, "transport", void 0);
+		this.transport = new GrpcWebRpcTransport(endpoint, metadata);
+		this.client = new MitoAPIClient(this.transport);
+	}
+	/**
+	* Stream vault transfers
+	* @param params.vault - Optional vault address to filter
+	* @param params.account - Optional account address to filter
+	* @param params.callback - Called for each transfer update
+	* @returns StreamSubscription
+	*/
+	streamTransfers({ vault, account, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = GoadesignGoagenMitoApiPb.StreamTransfersRequest.create();
+		if (vault) request.vault = vault;
+		if (account) request.account = account;
+		return createStreamSubscriptionV2(this.client.streamTransfers(request), (response) => {
+			callback(IndexerGrpcMitoStreamTransformer.transfersStreamCallback(response));
+		});
+	}
+	/**
+	* Stream vault information
+	* @param params.vault - Optional vault address to filter
+	* @param params.callback - Called for each vault update
+	* @returns StreamSubscription
+	*/
+	streamVault({ vault, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = GoadesignGoagenMitoApiPb.StreamVaultRequest.create();
+		if (vault) request.vault = vault;
+		return createStreamSubscriptionV2(this.client.streamVault(request), (response) => {
+			callback(IndexerGrpcMitoStreamTransformer.vaultStreamCallback(response));
+		});
+	}
+	/**
+	* Stream vault holder subscriptions
+	* @param params.holderAddress - The holder address to stream subscriptions for
+	* @param params.vaultAddress - Optional vault address to filter
+	* @param params.stakingContractAddress - Optional staking contract address to filter
+	* @param params.callback - Called for each subscription update
+	* @returns StreamSubscription
+	*/
+	streamVaultHolderSubscriptions({ holderAddress, vaultAddress, stakingContractAddress, callback }) {
+		if (!holderAddress) throw new Error("holderAddress is required");
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = GoadesignGoagenMitoApiPb.StreamHolderSubscriptionRequest.create();
+		request.holderAddress = holderAddress;
+		if (vaultAddress) request.vaultAddress = vaultAddress;
+		if (stakingContractAddress) request.stakingContractAddress = stakingContractAddress;
+		return createStreamSubscriptionV2(this.client.streamHolderSubscription(request), (response) => {
+			callback(IndexerGrpcMitoStreamTransformer.vaultHolderSubscriptionStreamCallback(response));
+		});
+	}
+	/**
+	* Stream staking rewards by account
+	* @param params.staker - The staker address to stream rewards for
+	* @param params.stakingContractAddress - The staking contract address
+	* @param params.callback - Called for each reward update
+	* @returns StreamSubscription
+	*/
+	streamStakingRewardsByAccount({ staker, stakingContractAddress, callback }) {
+		if (!staker) throw new Error("staker is required");
+		if (!stakingContractAddress) throw new Error("stakingContractAddress is required");
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = GoadesignGoagenMitoApiPb.StreamStakingRewardByAccountRequest.create();
+		request.staker = staker;
+		request.stakingContractAddress = stakingContractAddress;
+		return createStreamSubscriptionV2(this.client.streamStakingRewardByAccount(request), (response) => {
+			callback(IndexerGrpcMitoStreamTransformer.stakingRewardByAccountStreamCallback(response));
+		});
+	}
+	/**
+	* Stream historical staking data
+	* @param params.staker - The staker address to stream data for
+	* @param params.stakingContractAddress - The staking contract address
+	* @param params.callback - Called for each historical staking update
+	* @returns StreamSubscription
+	*/
+	streamHistoricalStaking({ staker, stakingContractAddress, callback }) {
+		if (!staker) throw new Error("staker is required");
+		if (!stakingContractAddress) throw new Error("stakingContractAddress is required");
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = GoadesignGoagenMitoApiPb.StreamHistoricalStakingRequest.create();
+		request.staker = staker;
+		request.stakingContractAddress = stakingContractAddress;
+		return createStreamSubscriptionV2(this.client.streamHistoricalStaking(request), (response) => {
+			callback(IndexerGrpcMitoStreamTransformer.historicalStakingStreamCallback(response));
+		});
+	}
+};
+
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/IndexerGrpcOracleStreamV2.ts
+var IndexerGrpcOracleStreamV2 = class {
+	constructor(endpoint, metadata) {
+		_defineProperty(this, "client", void 0);
+		_defineProperty(this, "transport", void 0);
+		this.transport = new GrpcWebRpcTransport(endpoint, metadata);
+		this.client = new InjectiveOracleRPCClient(this.transport);
+	}
+	/**
+	* Stream oracle price updates
+	* @param params.oracleType - The oracle type to stream prices for
+	* @param params.baseSymbol - Optional base symbol filter
+	* @param params.quoteSymbol - Optional quote symbol filter
+	* @param params.callback - Called for each price update
+	* @returns StreamSubscription
+	*/
+	streamOraclePrices({ oracleType, baseSymbol, quoteSymbol, callback }) {
+		if (!oracleType) throw new Error("oracleType is required");
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveOracleRpcPb.StreamPricesRequest.create();
+		if (baseSymbol) request.baseSymbol = baseSymbol;
+		if (quoteSymbol) request.quoteSymbol = quoteSymbol;
+		request.oracleType = oracleType;
+		return createStreamSubscriptionV2(this.client.streamPrices(request), (response) => {
+			callback(IndexerOracleStreamTransformer.pricesStreamCallback(response));
+		});
+	}
+	/**
+	* Stream oracle prices by markets
+	* @param params.marketIds - Optional array of market IDs to filter
+	* @param params.callback - Called for each price update
+	* @returns StreamSubscription
+	*/
+	streamOraclePricesByMarkets({ marketIds, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveOracleRpcPb.StreamPricesByMarketsRequest.create();
+		if (marketIds) request.marketIds = marketIds;
+		return createStreamSubscriptionV2(this.client.streamPricesByMarkets(request), (response) => {
+			callback(IndexerOracleStreamTransformer.pricesByMarketsCallback(response));
+		});
+	}
+};
+
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/IndexerGrpcAccountStreamV2.ts
+var IndexerGrpcAccountStreamV2 = class {
+	constructor(endpoint, metadata) {
+		_defineProperty(this, "client", void 0);
+		_defineProperty(this, "transport", void 0);
+		this.transport = new GrpcWebRpcTransport(endpoint, metadata);
+		this.client = new InjectiveAccountsRPCClient(this.transport);
+	}
+	/**
+	* Stream subaccount balance updates
+	* @param params.subaccountId - The subaccount ID to stream balance for
+	* @param params.callback - Called for each balance update
+	* @returns StreamSubscription
+	*/
+	streamSubaccountBalance({ subaccountId, callback }) {
+		if (!subaccountId) throw new Error("subaccountId is required");
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveAccountsRpcPb.StreamSubaccountBalanceRequest.create();
+		request.subaccountId = subaccountId;
+		return createStreamSubscriptionV2(this.client.streamSubaccountBalance(request), (response) => {
+			callback(IndexerAccountStreamTransformer.balanceStreamCallback(response));
+		});
+	}
+};
+
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/IndexerGrpcAuctionStreamV2.ts
+var IndexerGrpcAuctionStreamV2 = class {
+	constructor(endpoint, metadata) {
+		_defineProperty(this, "client", void 0);
+		_defineProperty(this, "transport", void 0);
+		this.transport = new GrpcWebRpcTransport(endpoint, metadata);
+		this.client = new InjectiveAuctionRPCClient(this.transport);
+	}
+	/**
+	* Stream auction bids
+	* @param params.callback - Called for each bid update
+	* @returns StreamSubscription
+	*/
+	streamBids({ callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveAuctionRpcPb.StreamBidsRequest.create();
+		return createStreamSubscriptionV2(this.client.streamBids(request), (response) => {
+			callback(IndexerAuctionStreamTransformer.bidsStreamCallback(response));
+		});
+	}
+};
+
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/IndexerGrpcTradingStreamV2.ts
+var IndexerGrpcTradingStreamV2 = class {
+	constructor(endpoint, metadata) {
+		_defineProperty(this, "client", void 0);
+		_defineProperty(this, "transport", void 0);
+		this.transport = new GrpcWebRpcTransport(endpoint, metadata);
+		this.client = new InjectiveTradingRPCClient(this.transport);
+	}
+	/**
+	* Stream grid strategies
+	* @param params.marketId - Optional market ID to filter strategies
+	* @param params.accountAddresses - Optional array of account addresses to filter
+	* @param params.callback - Called for each strategy update
+	* @returns StreamSubscription
+	*/
+	streamGridStrategies({ marketId, accountAddresses, callback }) {
+		if ((!accountAddresses || accountAddresses.length === 0) && !marketId) throw new Error("accountAddresses or marketId is required");
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveTradingRpcPb.StreamStrategyRequest.create();
+		if (accountAddresses) request.accountAddresses = accountAddresses;
+		if (marketId) request.marketId = marketId;
+		return createStreamSubscriptionV2(this.client.streamStrategy(request), (response) => {
+			callback(response);
+		});
+	}
+};
+
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/IndexerGrpcArchiverStreamV2.ts
+var IndexerGrpcArchiverStreamV2 = class {
+	constructor(endpoint, metadata) {
+		_defineProperty(this, "client", void 0);
+		_defineProperty(this, "transport", void 0);
+		this.transport = new GrpcWebRpcTransport(endpoint, metadata);
+		this.client = new InjectiveArchiverRPCClient(this.transport);
+	}
+	/**
+	* Stream spot average entries
+	* @param params.account - The account address to stream entries for
+	* @param params.callback - Called for each average entry update
+	* @returns StreamSubscription
+	*/
+	streamSpotAverageEntries({ account, callback }) {
+		if (!account) throw new Error("account is required");
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveArchiverRpcPb.StreamSpotAverageEntriesRequest.create();
+		request.account = account;
+		return createStreamSubscriptionV2(this.client.streamSpotAverageEntries(request), (response) => {
+			callback(IndexerArchiverStreamTransformer.spotAverageEntriesStreamCallback(response));
+		});
+	}
+};
+
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/IndexerGrpcExplorerStreamV2.ts
+var IndexerGrpcExplorerStreamV2 = class {
+	constructor(endpoint, metadata) {
+		_defineProperty(this, "client", void 0);
+		_defineProperty(this, "transport", void 0);
+		this.transport = new GrpcWebRpcTransport(endpoint, metadata);
+		this.client = new InjectiveExplorerRPCClient(this.transport);
+	}
+	/**
+	* Stream block updates
+	* @param params.callback - Called for each block update
+	* @returns StreamSubscription
+	*/
+	streamBlocks({ callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveExplorerRpcPb.StreamBlocksRequest.create();
+		return createStreamSubscriptionV2(this.client.streamBlocks(request), (response) => {
+			callback(ExplorerStreamTransformer.blocksStreamCallback(response));
+		});
+	}
+	/**
+	* Stream blocks with transactions
+	* @param params.callback - Called for each block with transactions update
+	* @returns StreamSubscription
+	*/
+	streamBlocksWithTxs({ callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveExplorerRpcPb.StreamBlocksRequest.create();
+		return createStreamSubscriptionV2(this.client.streamBlocks(request), (response) => {
+			callback(ExplorerStreamTransformer.blocksWithTxsStreamCallback(response));
+		});
+	}
+	/**
+	* Stream transaction updates
+	* @param params.callback - Called for each transaction update
+	* @returns StreamSubscription
+	*/
+	streamTransactions({ callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveExplorerRpcPb.StreamTxsRequest.create();
+		return createStreamSubscriptionV2(this.client.streamTxs(request), (response) => {
+			callback(ExplorerStreamTransformer.transactionsStreamCallback(response));
+		});
+	}
+};
+
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/IndexerGrpcDerivativesStreamV2.ts
+var IndexerGrpcDerivativesStreamV2 = class {
+	constructor(endpoint, metadata) {
+		_defineProperty(this, "client", void 0);
+		_defineProperty(this, "transport", void 0);
+		this.transport = new GrpcWebRpcTransport(endpoint, metadata);
+		this.client = new InjectiveDerivativeExchangeRPCClient(this.transport);
+	}
+	/**
+	* Stream derivative orders
+	* @param params.marketId - Optional market ID to filter
+	* @param params.subaccountId - Optional subaccount ID to filter
+	* @param params.orderSide - Optional order side to filter
+	* @param params.callback - Called for each order update
+	* @returns StreamSubscription
+	*/
+	streamOrders({ marketId, subaccountId, orderSide, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveDerivativeExchangeRpcPb.StreamOrdersRequest.create();
+		if (marketId) request.marketId = marketId;
+		if (subaccountId) request.subaccountId = subaccountId;
+		if (orderSide) request.orderSide = orderSide;
+		return createStreamSubscriptionV2(this.client.streamOrders(request), (response) => {
+			callback(IndexerDerivativeStreamTransformer.ordersStreamCallback(response));
+		});
+	}
+	/**
+	* Stream derivative order history
+	* @param params.subaccountId - Optional subaccount ID to filter
+	* @param params.marketId - Optional market ID to filter
+	* @param params.orderTypes - Optional order types to filter
+	* @param params.direction - Optional direction to filter
+	* @param params.state - Optional state to filter
+	* @param params.executionTypes - Optional execution types to filter
+	* @param params.callback - Called for each order history update
+	* @returns StreamSubscription
+	*/
+	streamOrdersHistory({ subaccountId, marketId, orderTypes, direction, state, executionTypes, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveDerivativeExchangeRpcPb.StreamOrdersHistoryRequest.create();
+		if (subaccountId) request.subaccountId = subaccountId;
+		if (marketId) request.marketId = marketId;
+		if (orderTypes) request.orderTypes = orderTypes;
+		if (direction) request.direction = direction;
+		if (state) request.state = state;
+		if (executionTypes) request.executionTypes = executionTypes;
+		return createStreamSubscriptionV2(this.client.streamOrdersHistory(request), (response) => {
+			callback(IndexerDerivativeStreamTransformer.orderHistoryStreamCallback(response));
+		});
+	}
+	/**
+	* Stream derivative trades
+	* @param params.marketId - Optional market ID to filter
+	* @param params.marketIds - Optional array of market IDs to filter
+	* @param params.subaccountId - Optional subaccount ID to filter
+	* @param params.subaccountIds - Optional array of subaccount IDs to filter
+	* @param params.executionSide - Optional execution side to filter
+	* @param params.direction - Optional direction to filter
+	* @param params.pagination - Optional pagination options
+	* @param params.callback - Called for each trade update
+	* @returns StreamSubscription
+	*/
+	streamTrades({ marketIds, marketId, subaccountIds, subaccountId, executionSide, direction, pagination, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveDerivativeExchangeRpcPb.StreamTradesRequest.create();
+		if (marketIds) request.marketIds = marketIds;
+		if (marketId) request.marketId = marketId;
+		if (subaccountIds) request.subaccountIds = subaccountIds;
+		if (subaccountId) request.subaccountId = subaccountId;
+		if (executionSide) request.executionSide = executionSide;
+		if (direction) request.direction = direction;
+		if (pagination) {
+			if (pagination.skip !== void 0) request.skip = BigInt(pagination.skip);
+			if (pagination.limit !== void 0) request.limit = pagination.limit;
+		}
+		return createStreamSubscriptionV2(this.client.streamTrades(request), (response) => {
+			callback(IndexerDerivativeStreamTransformer.tradesStreamCallback(response));
+		});
+	}
+	/**
+	* Stream derivative positions
+	* @param params.marketId - Optional market ID to filter
+	* @param params.address - Optional address to filter
+	* @param params.subaccountId - Optional subaccount ID to filter
+	* @param params.callback - Called for each position update
+	* @returns StreamSubscription
+	*/
+	streamPositions({ marketId, address, subaccountId, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveDerivativeExchangeRpcPb.StreamPositionsRequest.create();
+		if (marketId) request.marketId = marketId;
+		if (address) request.accountAddress = address;
+		if (subaccountId) request.subaccountId = subaccountId;
+		return createStreamSubscriptionV2(this.client.streamPositions(request), (response) => {
+			callback(IndexerDerivativeStreamTransformer.positionStreamCallback(response));
+		});
+	}
+	/**
+	* Stream derivative markets
+	* @param params.marketIds - Optional array of market IDs to filter
+	* @param params.callback - Called for each market update
+	* @returns StreamSubscription
+	*/
+	streamMarkets({ marketIds, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveDerivativeExchangeRpcPb.StreamMarketRequest.create();
+		if (marketIds && marketIds.length) request.marketIds = marketIds;
+		return createStreamSubscriptionV2(this.client.streamMarket(request), (response) => {
+			callback(response);
+		});
+	}
+	/**
+	* Stream derivative orderbooks V2
+	* @param params.marketIds - Array of market IDs to stream
+	* @param params.callback - Called for each orderbook update
+	* @returns StreamSubscription
+	*/
+	streamOrderbooksV2({ marketIds, callback }) {
+		if (!marketIds || marketIds.length === 0) throw new Error("marketIds is required and cannot be empty");
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveDerivativeExchangeRpcPb.StreamOrderbookV2Request.create();
+		request.marketIds = marketIds;
+		return createStreamSubscriptionV2(this.client.streamOrderbookV2(request), (response) => {
+			callback(IndexerDerivativeStreamTransformer.orderbookV2StreamCallback(response));
+		});
+	}
+	/**
+	* Stream derivative orderbook updates
+	* @param params.marketIds - Array of market IDs to stream
+	* @param params.callback - Called for each orderbook update
+	* @returns StreamSubscription
+	*/
+	streamOrderbookUpdates({ marketIds, callback }) {
+		if (!marketIds || marketIds.length === 0) throw new Error("marketIds is required and cannot be empty");
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveDerivativeExchangeRpcPb.StreamOrderbookUpdateRequest.create();
+		request.marketIds = marketIds;
+		return createStreamSubscriptionV2(this.client.streamOrderbookUpdate(request), (response) => {
+			callback(IndexerDerivativeStreamTransformer.orderbookUpdateStreamCallback(response));
+		});
+	}
+	/**
+	* Stream derivative positions V2
+	* @param params.marketId - Optional market ID to filter
+	* @param params.address - Optional address to filter
+	* @param params.subaccountId - Optional subaccount ID to filter
+	* @param params.callback - Called for each position update
+	* @returns StreamSubscription
+	*/
+	streamPositionsV2({ marketId, address, subaccountId, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveDerivativeExchangeRpcPb.StreamPositionsV2Request.create();
+		if (marketId) request.marketId = marketId;
+		if (address) request.accountAddress = address;
+		if (subaccountId) request.subaccountId = subaccountId;
+		return createStreamSubscriptionV2(this.client.streamPositionsV2(request), (response) => {
+			callback(IndexerDerivativeStreamTransformer.positionV2StreamCallback(response));
+		});
+	}
+};
+
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/IndexerGrpcAccountPortfolioStreamV2.ts
+var IndexerGrpcAccountPortfolioStreamV2 = class {
+	constructor(endpoint, metadata) {
+		_defineProperty(this, "client", void 0);
+		_defineProperty(this, "transport", void 0);
+		this.transport = new GrpcWebRpcTransport(endpoint, metadata);
+		this.client = new InjectivePortfolioRPCClient(this.transport);
+	}
+	/**
+	* Stream account portfolio updates
+	* @param params.accountAddress - The account address to stream portfolio for
+	* @param params.subaccountId - Optional subaccount ID to filter
+	* @param params.type - Optional portfolio type to filter
+	* @param params.callback - Called for each portfolio update
+	* @returns StreamSubscription
+	*/
+	streamAccountPortfolio({ accountAddress, subaccountId, type, callback }) {
+		if (!accountAddress) throw new Error("accountAddress is required");
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectivePortfolioRpcPb.StreamAccountPortfolioRequest.create();
+		request.accountAddress = accountAddress;
+		if (subaccountId) request.subaccountId = subaccountId;
+		if (type) request.type = type;
+		return createStreamSubscriptionV2(this.client.streamAccountPortfolio(request), (response) => {
+			callback(IndexerAccountPortfolioStreamTransformer.accountPortfolioStreamCallback(response));
+		});
+	}
+};
+
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/StreamManager.ts
+/**
+* Default retry configuration
+*/
+const DEFAULT_RETRY_CONFIG = {
+	enabled: true,
+	maxAttempts: 5,
+	initialDelayMs: 1e3,
+	maxDelayMs: 3e4,
+	backoffMultiplier: 2,
+	persistent: true
+};
+/**
+* StreamManagerV2 - Manages gRPC stream connections with automatic retry
+*
+* V2 Features:
+* - Event-based lifecycle (on/off methods)
+* - Automatic retry with exponential backoff
+* - Persistent retry mode
+* - Comprehensive statistics tracking
+* - gRPC error code mapping
+*
+*/
+var StreamManagerV2 = class extends EventEmitter {
+	constructor(config) {
+		super();
+		_defineProperty(this, "config", void 0);
+		_defineProperty(this, "state", StreamState.Idle);
+		_defineProperty(this, "subscription", null);
+		_defineProperty(this, "retryTimeoutId", null);
+		_defineProperty(this, "stats", void 0);
+		_defineProperty(this, "retryAttempt", 0);
+		this.config = {
+			id: config.id,
+			streamFactory: config.streamFactory,
+			onData: config.onData,
+			retryConfig: {
+				...DEFAULT_RETRY_CONFIG,
+				...config.retryConfig
+			}
+		};
+		this.stats = {
+			state: StreamState.Idle,
+			connectCount: 0,
+			disconnectCount: 0,
+			retryCount: 0,
+			dataReceivedCount: 0,
+			errorCount: 0,
+			lastDataAt: null,
+			createdAt: Date.now(),
+			connectedAt: null,
+			disconnectedAt: null
+		};
+		const originalEmit = this.emit.bind(this);
+		this.emit = ((event, ...args) => {
+			if (event === StreamEvent.Data && args.length > 0) this.handleData(args[0]);
+			return originalEmit(event, ...args);
+		});
+	}
+	start() {
+		if (this.state !== StreamState.Idle && this.state !== StreamState.Stopped) {
+			this.emit(StreamEvent.Warn, { message: `Stream already started (state: ${this.state})` });
+			return;
+		}
+		this.connect();
+	}
+	stop() {
+		this.handleDisconnect(StreamDisconnectReason.UserStopped);
+	}
+	getId() {
+		return this.config.id;
+	}
+	getState() {
+		return this.state;
+	}
+	getStats() {
+		return {
+			...this.stats,
+			state: this.state
+		};
+	}
+	/**
+	* Destroy the stream manager and clean up all resources
+	* Call this when the stream manager is no longer needed
+	*/
+	destroy() {
+		this.stop();
+		this.removeAllListeners();
+	}
+	updateState(newState) {
+		const oldState = this.state;
+		this.state = newState;
+		this.stats.state = newState;
+		this.emit(StreamEvent.StateChange, {
+			from: oldState,
+			to: newState
+		});
+	}
+	clearSubscription() {
+		if (!this.subscription) return;
+		this.subscription.unsubscribe();
+		this.subscription = null;
+	}
+	clearRetryTimeout() {
+		if (!this.retryTimeoutId) return;
+		clearTimeout(this.retryTimeoutId);
+		this.retryTimeoutId = null;
+	}
+	calculateNextBackoff() {
+		if (this.config.retryConfig.maxAttempts > 0 && this.retryAttempt >= this.config.retryConfig.maxAttempts) return this.config.retryConfig.persistent ? this.config.retryConfig.maxDelayMs : null;
+		const nextBackoffDelay = this.config.retryConfig.initialDelayMs * Math.pow(this.config.retryConfig.backoffMultiplier, this.retryAttempt);
+		return Math.min(nextBackoffDelay, this.config.retryConfig.maxDelayMs);
+	}
+	scheduleRetry() {
+		if (!this.config.retryConfig.enabled) return;
+		const nextBackoff = this.calculateNextBackoff();
+		if (nextBackoff === null) {
+			this.handleMaxRetriesReached();
+			return;
+		}
+		this.retryTimeoutId = setTimeout(() => {
+			this.retryAttempt++;
+			this.stats.retryCount++;
+			this.emit(StreamEvent.Retry, {
+				attempt: this.retryAttempt,
+				delayMs: nextBackoff,
+				nextBackoff: this.calculateNextBackoff()
+			});
+			this.connect();
+		}, nextBackoff);
+	}
+	handleMaxRetriesReached() {
+		this.emit(StreamEvent.Error, { message: `Max retries (${this.config.retryConfig.maxAttempts}) reached` });
+		this.handleDisconnect(StreamDisconnectReason.MaxRetries);
+	}
+	handleError(error) {
+		const errorInfo = this.extractErrorInfo(error);
+		this.stats.errorCount++;
+		this.emit(StreamEvent.Error, errorInfo);
+		let reason = StreamDisconnectReason.StreamError;
+		if (error && typeof error === "object" && "code" in error) switch (error.code) {
+			case 14:
+				reason = StreamDisconnectReason.NetworkError;
+				break;
+			case 4:
+				reason = StreamDisconnectReason.Timeout;
+				break;
+			case 16:
+				reason = StreamDisconnectReason.AuthenticationError;
+				break;
+			case 1:
+				reason = StreamDisconnectReason.UserStopped;
+				break;
+		}
+		this.handleDisconnect(reason);
+	}
+	/**
+	* Handles incoming data - tracks stats and calls user callback
+	* Called automatically when user emits 'data' event from streamFactory callback
+	*/
+	handleData(response) {
+		this.stats.dataReceivedCount++;
+		this.stats.lastDataAt = Date.now();
+		try {
+			this.config.onData(response);
+		} catch (error) {
+			this.handleError(error);
+		}
+	}
+	handleConnected(isReconnect) {
+		this.updateState(StreamState.Connected);
+		this.retryAttempt = 0;
+		this.stats.connectCount++;
+		this.stats.connectedAt = Date.now();
+		this.emit(StreamEvent.Connect, {
+			isReconnect,
+			attempt: this.stats.connectCount
+		});
+	}
+	handleDisconnect(reason) {
+		this.clearSubscription();
+		this.clearRetryTimeout();
+		this.stats.disconnectCount++;
+		this.stats.disconnectedAt = Date.now();
+		const willRetry = reason !== StreamDisconnectReason.UserStopped && reason !== StreamDisconnectReason.MaxRetries && this.config.retryConfig.enabled;
+		this.emit(StreamEvent.Disconnect, {
+			reason,
+			willRetry,
+			attempt: this.retryAttempt
+		});
+		if (willRetry) {
+			this.updateState(StreamState.Reconnecting);
+			this.scheduleRetry();
+		} else this.updateState(StreamState.Stopped);
+	}
+	connect() {
+		this.clearSubscription();
+		const isReconnect = this.state === StreamState.Reconnecting;
+		this.updateState(isReconnect ? StreamState.Reconnecting : StreamState.Connecting);
+		try {
+			this.subscription = this.config.streamFactory();
+			this.subscription.on("error", (error) => {
+				this.handleError(error);
+			});
+			this.subscription.on("complete", () => {
+				this.handleDisconnect(StreamDisconnectReason.StreamEnded);
+			});
+			this.handleConnected(isReconnect);
+		} catch (error) {
+			this.handleError(error);
+		}
+	}
+	/**
+	* Extracts error message and details from an error object
+	*/
+	extractErrorInfo(error) {
+		if (error && typeof error === "object" && "details" in error) return {
+			message: error.details,
+			details: error
+		};
+		return {
+			message: error instanceof Error ? error.message : "Unknown error",
+			details: error instanceof Error ? error.stack : error
+		};
+	}
+};
+
+//#endregion
+export { IndexerGrpcMegaVaultTransformer as $, IndexerGrpcInsuranceFundApi as A, IndexerGrpcAccountApi as B, IndexerGrpcSpotStream as C, IndexerRestMarketChronosApi as D, IndexerRestDerivativesChronosApi as E, IndexerGrpcArchiverApi as F, IndexerAccountPortfolioStreamTransformer as G, IndexerGrpcSpotApi as H, IndexerGrpcCampaignApi as I, IndexerGrpcAccountPortfolioTransformer as J, IndexerGrpcInsuranceFundTransformer as K, IndexerGrpcExplorerApi as L, IndexerGrpcDerivativesApi as M, IndexerGrpcMegaVaultApi as N, IndexerRestSpotChronosApi as O, IndexerGrpcReferralApi as P, IndexerArchiverStreamTransformer as Q, IndexerGrpcTradingApi as R, IndexerGrpcMitoStream as S, IndexerRestLeaderboardChronosApi as T, IndexerGrpcMetaApi as U, IndexerGrpcOracleApi as V, IndexerGrpcMitoApi as W, IndexerGrpcDerivativeTransformer as X, IndexerGrpcMitoStreamTransformer as Y, ExplorerStreamTransformer as Z, IndexerGrpcArchiverStream as _, IndexerGrpcArchiverStreamV2 as a, IndexerGrpcExplorerTransformer as at, IndexerGrpcAccountStream as b, IndexerGrpcAccountStreamV2 as c, IndexerGrpcAccountTransformer as ct, IndexerGrpcSpotStreamV2 as d, IndexerCampaignTransformer as dt, IndexerAuctionStreamTransformer as et, createStreamSubscriptionV2 as f, IndexerGrpcSpotTransformer as ft, IndexerGrpcExplorerStream as g, IndexerGrpcDerivativesStream as h, IndexerGrpcExplorerStreamV2 as i, IndexerGrpcReferralTransformer as it, IndexerGrpcAccountPortfolioApi as j, IndexerRestExplorerApi as k, IndexerGrpcOracleStreamV2 as l, IndexerSpotStreamTransformer as lt, IndexerGrpcAccountPortfolioStream as m, IndexerGrpcAccountPortfolioStreamV2 as n, IndexerRestExplorerTransformer as nt, IndexerGrpcTradingStreamV2 as o, IndexerGrpcArchiverTransformer as ot, StreamManager as p, IndexerGrpcMitoTransformer as pt, IndexerDerivativeStreamTransformer as q, IndexerGrpcDerivativesStreamV2 as r, IndexerOracleStreamTransformer as rt, IndexerGrpcAuctionStreamV2 as s, IndexerGrpcAuctionTransformer as st, StreamManagerV2 as t, IndexerAccountStreamTransformer as tt, IndexerGrpcMitoStreamV2 as u, IndexerGrpcOracleTransformer as ut, IndexerGrpcTradingStream as v, createStreamSubscription as w, IndexerGrpcOracleStream as x, IndexerGrpcAuctionStream as y, IndexerGrpcAuctionApi as z };