@injectivelabs/sdk-ts 1.15.0 → 1.15.2

package/dist/cjs/client/indexer/grpc/IndexerGrpcTransactionApi.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcTransactionApi = void 0;
+const utils_1 = require("@injectivelabs/utils");
+const transaction_js_1 = require("../../../utils/transaction.js");
+const index_js_1 = require("../types/index.js");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const BaseIndexerGrpcWebConsumer_js_1 = require("../../base/BaseIndexerGrpcWebConsumer.js");
+const indexer_proto_ts_1 = require("@injectivelabs/indexer-proto-ts");
+const core_proto_ts_1 = require("@injectivelabs/core-proto-ts");
+/**
+ * @category Indexer Grpc API
+ * @deprecated use IndexerGrpcWeb3GwApi
+ */
+class IndexerGrpcTransactionApi {
+    module = index_js_1.IndexerModule.Transaction;
+    client;
+    constructor(endpoint) {
+        this.client = new indexer_proto_ts_1.InjectiveExchangeRpc.InjectiveExchangeRPCClientImpl((0, BaseIndexerGrpcWebConsumer_js_1.getGrpcIndexerWebImpl)(endpoint));
+    }
+    async prepareTxRequest(args) {
+        const { address, chainId, message, memo, estimateGas = true, gasLimit = utils_1.DEFAULT_GAS_LIMIT, feeDenom = utils_1.DEFAULT_BRIDGE_FEE_DENOM, feePrice = utils_1.DEFAULT_BRIDGE_FEE_PRICE, timeoutHeight, } = args;
+        const txFeeAmount = core_proto_ts_1.CosmosBaseV1Beta1Coin.Coin.create();
+        txFeeAmount.denom = feeDenom;
+        txFeeAmount.amount = feePrice;
+        const cosmosTxFee = indexer_proto_ts_1.InjectiveExchangeRpc.CosmosTxFee.create();
+        cosmosTxFee.price = [txFeeAmount];
+        if (!estimateGas) {
+            cosmosTxFee.gas = gasLimit.toString();
+        }
+        const prepareTxRequest = indexer_proto_ts_1.InjectiveExchangeRpc.PrepareTxRequest.create();
+        prepareTxRequest.chainId = chainId.toString();
+        prepareTxRequest.signerAddress = address;
+        prepareTxRequest.fee = cosmosTxFee;
+        const arrayOfMessages = Array.isArray(message) ? message : [message];
+        const messagesList = arrayOfMessages.map((message) => Buffer.from(JSON.stringify(message), 'utf8'));
+        prepareTxRequest.msgs = messagesList;
+        if (timeoutHeight !== undefined) {
+            prepareTxRequest.timeoutHeight = timeoutHeight.toString();
+        }
+        if (memo) {
+            prepareTxRequest.memo = typeof memo === 'number' ? memo.toString() : memo;
+        }
+        try {
+            const response = await this.client.PrepareTx(prepareTxRequest);
+            return response;
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.TransactionException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'PrepareTx',
+                    contextModule: 'Web3Gateway',
+                    type: e.type,
+                });
+            }
+            throw new exceptions_1.TransactionException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Web3Gateway.PrepareTx',
+                type: exceptions_1.ErrorType.Web3Gateway,
+            });
+        }
+    }
+    async prepareExchangeTxRequest(args) {
+        return this.prepareTxRequest({
+            ...args,
+            gasLimit: args.gasLimit || utils_1.DEFAULT_EXCHANGE_LIMIT,
+        });
+    }
+    async prepareCosmosTxRequest({ memo, address, message, estimateGas = true, gasLimit = utils_1.DEFAULT_GAS_LIMIT, feeDenom = utils_1.DEFAULT_BRIDGE_FEE_DENOM, feePrice = utils_1.DEFAULT_BRIDGE_FEE_PRICE, timeoutHeight, }) {
+        const txFeeAmount = core_proto_ts_1.CosmosBaseV1Beta1Coin.Coin.create();
+        txFeeAmount.denom = feeDenom;
+        txFeeAmount.amount = feePrice;
+        const cosmosTxFee = indexer_proto_ts_1.InjectiveExchangeRpc.CosmosTxFee.create();
+        cosmosTxFee.price = [txFeeAmount];
+        if (!estimateGas) {
+            cosmosTxFee.gas = gasLimit.toString();
+        }
+        const prepareTxRequest = indexer_proto_ts_1.InjectiveExchangeRpc.PrepareCosmosTxRequest.create();
+        prepareTxRequest.fee = cosmosTxFee;
+        prepareTxRequest.senderAddress = address;
+        const arrayOfMessages = Array.isArray(message) ? message : [message];
+        const messagesList = arrayOfMessages.map((message) => Buffer.from(JSON.stringify(message), 'utf8'));
+        prepareTxRequest.msgs = messagesList;
+        if (timeoutHeight !== undefined) {
+            prepareTxRequest.timeoutHeight = timeoutHeight.toString();
+        }
+        if (memo) {
+            prepareTxRequest.memo = typeof memo === 'number' ? memo.toString() : memo;
+        }
+        try {
+            const response = await this.client.PrepareCosmosTx(prepareTxRequest);
+            return response;
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.TransactionException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    type: e.type,
+                    contextCode: e.code,
+                    context: 'Web3Gateway.CosmosPrepareTx',
+                });
+            }
+            throw new exceptions_1.TransactionException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Web3Gateway.CosmosPrepareTx',
+                type: exceptions_1.ErrorType.Web3Gateway,
+            });
+        }
+    }
+    /**
+     * Keep in mind that the transaction is just added
+     * to the mempool, we need to query the transaction hash
+     * if we want to ensure that the transaction is included
+     * in the block
+     */
+    async broadcastTxRequest({ signature, chainId, message, txResponse, }) {
+        const parsedTypedData = JSON.parse(txResponse.data);
+        const publicKeyHex = (0, transaction_js_1.recoverTypedSignaturePubKey)(parsedTypedData, signature);
+        const cosmosPubKey = indexer_proto_ts_1.InjectiveExchangeRpc.CosmosPubKey.create();
+        cosmosPubKey.type = txResponse.pubKeyType;
+        cosmosPubKey.key = publicKeyHex;
+        parsedTypedData.message.msgs = null;
+        const broadcastTxRequest = indexer_proto_ts_1.InjectiveExchangeRpc.BroadcastTxRequest.create();
+        broadcastTxRequest.mode = 'sync';
+        broadcastTxRequest.chainId = chainId.toString();
+        broadcastTxRequest.pubKey = cosmosPubKey;
+        broadcastTxRequest.signature = signature;
+        broadcastTxRequest.tx = Buffer.from(JSON.stringify(parsedTypedData.message), 'utf8');
+        broadcastTxRequest.feePayer = txResponse.feePayer;
+        broadcastTxRequest.feePayerSig = txResponse.feePayerSig;
+        const arrayOfMessages = Array.isArray(message) ? message : [message];
+        const messagesList = arrayOfMessages.map((message) => Buffer.from(JSON.stringify(message), 'utf8'));
+        broadcastTxRequest.msgs = messagesList;
+        try {
+            const response = await this.client.BroadcastTx(broadcastTxRequest);
+            return response;
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.TransactionException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    type: e.type,
+                    contextCode: e.code,
+                    context: 'Web3Gateway.BroadcastTx',
+                });
+            }
+            throw new exceptions_1.TransactionException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Web3Gateway.BroadcastTx',
+                type: exceptions_1.ErrorType.Web3Gateway,
+            });
+        }
+    }
+    /**
+     * Keep in mind that the transaction is just added
+     * to the mempool, we need to query the transaction hash
+     * if we want to ensure that the transaction is included
+     * in the block
+     */
+    async broadcastCosmosTxRequest({ address, signature, txRaw, pubKey, }) {
+        const pubKeyInHex = Buffer.from(pubKey.value, 'base64').toString('hex');
+        const signatureInHex = Buffer.from(signature, 'base64').toString('hex');
+        const cosmosPubKey = indexer_proto_ts_1.InjectiveExchangeRpc.CosmosPubKey.create();
+        cosmosPubKey.type = pubKey.type;
+        cosmosPubKey.key = `0x${pubKeyInHex}`;
+        txRaw.signatures = [];
+        const broadcastTxRequest = indexer_proto_ts_1.InjectiveExchangeRpc.BroadcastCosmosTxRequest.create();
+        broadcastTxRequest.senderAddress = address;
+        broadcastTxRequest.pubKey = cosmosPubKey;
+        broadcastTxRequest.signature = `0x${signatureInHex}`;
+        broadcastTxRequest.tx = core_proto_ts_1.CosmosTxV1Beta1Tx.TxRaw.encode(txRaw).finish();
+        try {
+            const response = await this.client.BroadcastCosmosTx(broadcastTxRequest);
+            return response;
+        }
+        catch (e) {
+            if (e instanceof exceptions_1.GrpcUnaryRequestException) {
+                throw new exceptions_1.TransactionException(e.toOriginalError(), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    type: e.type,
+                    contextCode: e.code,
+                    context: 'Web3Gateway.BroadcastCosmosTx',
+                });
+            }
+            throw new exceptions_1.TransactionException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Web3Gateway.BroadcastCosmosTx',
+                type: exceptions_1.ErrorType.Web3Gateway,
+            });
+        }
+    }
+    async fetchFeePayer() {
+        const request = indexer_proto_ts_1.InjectiveExchangeRpc.GetFeePayerRequest.create();
+        try {
+            const response = await this.client.GetFeePayer(request);
+            return response;
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.TransactionException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    type: e.type,
+                    context: 'Web3Gateway.FeePayer',
+                });
+            }
+            throw new exceptions_1.TransactionException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Web3Gateway.FeePayer',
+                type: exceptions_1.ErrorType.Web3Gateway,
+            });
+        }
+    }
+}
+exports.IndexerGrpcTransactionApi = IndexerGrpcTransactionApi;

package/dist/cjs/client/indexer/grpc/IndexerGrpcWeb3GwApi.d.ts

@@ -0,0 +1,24 @@
+import { AccountAddress, EthereumChainId } from '@injectivelabs/ts-types';
+import { InjectiveExchangeRpc } from '@injectivelabs/indexer-proto-ts';
+import { IndexerGrpcTransactionApi } from './IndexerGrpcTransactionApi.js';
+/**
+ * @category Indexer Grpc API
+ */
+export declare class IndexerGrpcWeb3GwApi extends IndexerGrpcTransactionApi {
+    protected module: string;
+    constructor(endpoint: string);
+    prepareEip712Request({ address, chainId, message, memo, sequence, accountNumber, estimateGas, gasLimit, feeDenom, feePrice, timeoutHeight, eip712Version, }: {
+        address: AccountAddress;
+        chainId: EthereumChainId;
+        message: any;
+        estimateGas?: boolean;
+        gasLimit?: number;
+        memo?: string | number;
+        timeoutHeight?: number;
+        feeDenom?: string;
+        feePrice?: string;
+        sequence?: number;
+        accountNumber?: number;
+        eip712Version?: string;
+    }): Promise<InjectiveExchangeRpc.PrepareEip712Response>;
+}

package/dist/cjs/client/indexer/grpc/IndexerGrpcWeb3GwApi.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcWeb3GwApi = void 0;
+const utils_1 = require("@injectivelabs/utils");
+const index_js_1 = require("../types/index.js");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const indexer_proto_ts_1 = require("@injectivelabs/indexer-proto-ts");
+const core_proto_ts_1 = require("@injectivelabs/core-proto-ts");
+const IndexerGrpcTransactionApi_js_1 = require("./IndexerGrpcTransactionApi.js");
+/**
+ * @category Indexer Grpc API
+ */
+class IndexerGrpcWeb3GwApi extends IndexerGrpcTransactionApi_js_1.IndexerGrpcTransactionApi {
+    module = index_js_1.IndexerModule.Web3Gw;
+    constructor(endpoint) {
+        super(endpoint);
+    }
+    async prepareEip712Request({ address, chainId, message, memo, sequence, accountNumber, estimateGas = false, gasLimit = utils_1.DEFAULT_GAS_LIMIT, feeDenom = utils_1.DEFAULT_BRIDGE_FEE_DENOM, feePrice = utils_1.DEFAULT_BRIDGE_FEE_PRICE, timeoutHeight, eip712Version = 'v1', }) {
+        const txFeeAmount = core_proto_ts_1.CosmosBaseV1Beta1Coin.Coin.create();
+        txFeeAmount.denom = feeDenom;
+        txFeeAmount.amount = feePrice;
+        const cosmosTxFee = indexer_proto_ts_1.InjectiveExchangeRpc.CosmosTxFee.create();
+        cosmosTxFee.price = [txFeeAmount];
+        if (!estimateGas) {
+            cosmosTxFee.gas = gasLimit.toString();
+        }
+        const prepareTxRequest = indexer_proto_ts_1.InjectiveExchangeRpc.PrepareEip712Request.create();
+        prepareTxRequest.chainId = chainId.toString();
+        prepareTxRequest.signerAddress = address;
+        prepareTxRequest.fee = cosmosTxFee;
+        const arrayOfMessages = Array.isArray(message) ? message : [message];
+        const messagesList = arrayOfMessages.map((message) => Buffer.from(JSON.stringify(message), 'utf8'));
+        prepareTxRequest.msgs = messagesList;
+        if (timeoutHeight !== undefined) {
+            prepareTxRequest.timeoutHeight = timeoutHeight.toString();
+        }
+        if (memo) {
+            prepareTxRequest.memo = typeof memo === 'number' ? memo.toString() : memo;
+        }
+        if (eip712Version) {
+            prepareTxRequest.eip712Wrapper = eip712Version;
+        }
+        if (accountNumber) {
+            prepareTxRequest.accountNumber = accountNumber.toString();
+        }
+        if (sequence) {
+            prepareTxRequest.sequence = sequence.toString();
+        }
+        try {
+            const response = await this.client.PrepareEip712(prepareTxRequest);
+            return response;
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.TransactionException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'PrepareEip712',
+                    contextModule: 'Web3Gateway',
+                    type: e.type,
+                });
+            }
+            throw new exceptions_1.TransactionException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Web3Gateway.PrepareEip712',
+                type: exceptions_1.ErrorType.Web3Gateway,
+            });
+        }
+    }
+}
+exports.IndexerGrpcWeb3GwApi = IndexerGrpcWeb3GwApi;

package/dist/cjs/client/indexer/grpc/index.d.ts

@@ -0,0 +1,16 @@
+export { IndexerGrpcMitoApi } from './IndexerGrpcMitoApi.js';
+export { IndexerGrpcMetaApi } from './IndexerGrpcMetaApi.js';
+export { IndexerGrpcSpotApi } from './IndexerGrpcSpotApi.js';
+export { IndexerGrpcOracleApi } from './IndexerGrpcOracleApi.js';
+export { IndexerGrpcWeb3GwApi } from './IndexerGrpcWeb3GwApi.js';
+export { IndexerGrpcAccountApi } from './IndexerGrpcAccountApi.js';
+export { IndexerGrpcAuctionApi } from './IndexerGrpcAuctionApi.js';
+export { IndexerGrpcTradingApi } from './IndexerGrpcTradingApi.js';
+export { IndexerGrpcExplorerApi } from './IndexerGrpcExplorerApi.js';
+export { IndexerGrpcCampaignApi } from './IndexerGrpcCampaignApi.js';
+export { IndexerGrpcArchiverApi } from './IndexerGrpcArchiverApi.js';
+export { IndexerGrpcReferralApi } from './IndexerGrpcReferralApi.js';
+export { IndexerGrpcDerivativesApi } from './IndexerGrpcDerivativesApi.js';
+export { IndexerGrpcTransactionApi } from './IndexerGrpcTransactionApi.js';
+export { IndexerGrpcAccountPortfolioApi } from './IndexerGrpcPortfolioApi.js';
+export { IndexerGrpcInsuranceFundApi } from './IndexerGrpcInsuranceFundApi.js';

package/dist/cjs/client/indexer/grpc/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcInsuranceFundApi = exports.IndexerGrpcAccountPortfolioApi = exports.IndexerGrpcTransactionApi = exports.IndexerGrpcDerivativesApi = exports.IndexerGrpcReferralApi = exports.IndexerGrpcArchiverApi = exports.IndexerGrpcCampaignApi = exports.IndexerGrpcExplorerApi = exports.IndexerGrpcTradingApi = exports.IndexerGrpcAuctionApi = exports.IndexerGrpcAccountApi = exports.IndexerGrpcWeb3GwApi = exports.IndexerGrpcOracleApi = exports.IndexerGrpcSpotApi = exports.IndexerGrpcMetaApi = exports.IndexerGrpcMitoApi = void 0;
+var IndexerGrpcMitoApi_js_1 = require("./IndexerGrpcMitoApi.js");
+Object.defineProperty(exports, "IndexerGrpcMitoApi", { enumerable: true, get: function () { return IndexerGrpcMitoApi_js_1.IndexerGrpcMitoApi; } });
+var IndexerGrpcMetaApi_js_1 = require("./IndexerGrpcMetaApi.js");
+Object.defineProperty(exports, "IndexerGrpcMetaApi", { enumerable: true, get: function () { return IndexerGrpcMetaApi_js_1.IndexerGrpcMetaApi; } });
+var IndexerGrpcSpotApi_js_1 = require("./IndexerGrpcSpotApi.js");
+Object.defineProperty(exports, "IndexerGrpcSpotApi", { enumerable: true, get: function () { return IndexerGrpcSpotApi_js_1.IndexerGrpcSpotApi; } });
+var IndexerGrpcOracleApi_js_1 = require("./IndexerGrpcOracleApi.js");
+Object.defineProperty(exports, "IndexerGrpcOracleApi", { enumerable: true, get: function () { return IndexerGrpcOracleApi_js_1.IndexerGrpcOracleApi; } });
+var IndexerGrpcWeb3GwApi_js_1 = require("./IndexerGrpcWeb3GwApi.js");
+Object.defineProperty(exports, "IndexerGrpcWeb3GwApi", { enumerable: true, get: function () { return IndexerGrpcWeb3GwApi_js_1.IndexerGrpcWeb3GwApi; } });
+var IndexerGrpcAccountApi_js_1 = require("./IndexerGrpcAccountApi.js");
+Object.defineProperty(exports, "IndexerGrpcAccountApi", { enumerable: true, get: function () { return IndexerGrpcAccountApi_js_1.IndexerGrpcAccountApi; } });
+var IndexerGrpcAuctionApi_js_1 = require("./IndexerGrpcAuctionApi.js");
+Object.defineProperty(exports, "IndexerGrpcAuctionApi", { enumerable: true, get: function () { return IndexerGrpcAuctionApi_js_1.IndexerGrpcAuctionApi; } });
+var IndexerGrpcTradingApi_js_1 = require("./IndexerGrpcTradingApi.js");
+Object.defineProperty(exports, "IndexerGrpcTradingApi", { enumerable: true, get: function () { return IndexerGrpcTradingApi_js_1.IndexerGrpcTradingApi; } });
+var IndexerGrpcExplorerApi_js_1 = require("./IndexerGrpcExplorerApi.js");
+Object.defineProperty(exports, "IndexerGrpcExplorerApi", { enumerable: true, get: function () { return IndexerGrpcExplorerApi_js_1.IndexerGrpcExplorerApi; } });
+var IndexerGrpcCampaignApi_js_1 = require("./IndexerGrpcCampaignApi.js");
+Object.defineProperty(exports, "IndexerGrpcCampaignApi", { enumerable: true, get: function () { return IndexerGrpcCampaignApi_js_1.IndexerGrpcCampaignApi; } });
+var IndexerGrpcArchiverApi_js_1 = require("./IndexerGrpcArchiverApi.js");
+Object.defineProperty(exports, "IndexerGrpcArchiverApi", { enumerable: true, get: function () { return IndexerGrpcArchiverApi_js_1.IndexerGrpcArchiverApi; } });
+var IndexerGrpcReferralApi_js_1 = require("./IndexerGrpcReferralApi.js");
+Object.defineProperty(exports, "IndexerGrpcReferralApi", { enumerable: true, get: function () { return IndexerGrpcReferralApi_js_1.IndexerGrpcReferralApi; } });
+var IndexerGrpcDerivativesApi_js_1 = require("./IndexerGrpcDerivativesApi.js");
+Object.defineProperty(exports, "IndexerGrpcDerivativesApi", { enumerable: true, get: function () { return IndexerGrpcDerivativesApi_js_1.IndexerGrpcDerivativesApi; } });
+var IndexerGrpcTransactionApi_js_1 = require("./IndexerGrpcTransactionApi.js");
+Object.defineProperty(exports, "IndexerGrpcTransactionApi", { enumerable: true, get: function () { return IndexerGrpcTransactionApi_js_1.IndexerGrpcTransactionApi; } });
+var IndexerGrpcPortfolioApi_js_1 = require("./IndexerGrpcPortfolioApi.js");
+Object.defineProperty(exports, "IndexerGrpcAccountPortfolioApi", { enumerable: true, get: function () { return IndexerGrpcPortfolioApi_js_1.IndexerGrpcAccountPortfolioApi; } });
+var IndexerGrpcInsuranceFundApi_js_1 = require("./IndexerGrpcInsuranceFundApi.js");
+Object.defineProperty(exports, "IndexerGrpcInsuranceFundApi", { enumerable: true, get: function () { return IndexerGrpcInsuranceFundApi_js_1.IndexerGrpcInsuranceFundApi; } });

package/dist/cjs/client/indexer/grpc_stream/IndexerGrpcAccountPortfolioStream.d.ts

@@ -0,0 +1,20 @@
+import { StreamStatusResponse } from '../types/index.js';
+import { IndexerAccountPortfolioStreamTransformer } from '../transformers/index.js';
+import { Subscription } from 'rxjs';
+import { InjectivePortfolioRpc } from '@injectivelabs/indexer-proto-ts';
+export type AccountPortfolioStreamCallback = (response: ReturnType<typeof IndexerAccountPortfolioStreamTransformer.accountPortfolioStreamCallback>) => void;
+/**
+ * @category Indexer Grpc Stream
+ */
+export declare class IndexerGrpcAccountPortfolioStream {
+    protected client: InjectivePortfolioRpc.InjectivePortfolioRPCClientImpl;
+    constructor(endpoint: string);
+    streamAccountPortfolio({ subaccountId, accountAddress, type, callback, onEndCallback, onStatusCallback, }: {
+        accountAddress: string;
+        subaccountId?: string;
+        type?: string;
+        callback: AccountPortfolioStreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+}

package/dist/cjs/client/indexer/grpc_stream/IndexerGrpcAccountPortfolioStream.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcAccountPortfolioStream = void 0;
+const index_js_1 = require("../transformers/index.js");
+const BaseIndexerGrpcWebConsumer_js_1 = require("../../base/BaseIndexerGrpcWebConsumer.js");
+const indexer_proto_ts_1 = require("@injectivelabs/indexer-proto-ts");
+/**
+ * @category Indexer Grpc Stream
+ */
+class IndexerGrpcAccountPortfolioStream {
+    client;
+    constructor(endpoint) {
+        this.client = new indexer_proto_ts_1.InjectivePortfolioRpc.InjectivePortfolioRPCClientImpl((0, BaseIndexerGrpcWebConsumer_js_1.getGrpcIndexerWebImpl)(endpoint));
+    }
+    streamAccountPortfolio({ subaccountId, accountAddress, type, callback, onEndCallback, onStatusCallback, }) {
+        const request = indexer_proto_ts_1.InjectivePortfolioRpc.StreamAccountPortfolioRequest.create();
+        request.accountAddress = accountAddress;
+        if (subaccountId) {
+            request.subaccountId = subaccountId;
+        }
+        if (type) {
+            request.type = type;
+        }
+        const subscription = this.client.StreamAccountPortfolio(request).subscribe({
+            next(response) {
+                callback(index_js_1.IndexerAccountPortfolioStreamTransformer.accountPortfolioStreamCallback(response));
+            },
+            error(err) {
+                if (onStatusCallback) {
+                    onStatusCallback(err);
+                }
+            },
+            complete() {
+                if (onEndCallback) {
+                    onEndCallback();
+                }
+            },
+        });
+        return subscription;
+    }
+}
+exports.IndexerGrpcAccountPortfolioStream = IndexerGrpcAccountPortfolioStream;

package/dist/cjs/client/indexer/grpc_stream/IndexerGrpcAccountStream.d.ts

@@ -0,0 +1,18 @@
+import { StreamStatusResponse } from '../types/index.js';
+import { IndexerAccountStreamTransformer } from '../transformers/index.js';
+import { Subscription } from 'rxjs';
+import { InjectiveAccountRpc } from '@injectivelabs/indexer-proto-ts';
+export type BalanceStreamCallback = (response: ReturnType<typeof IndexerAccountStreamTransformer.balanceStreamCallback>) => void;
+/**
+ * @category Indexer Grpc Stream
+ */
+export declare class IndexerGrpcAccountStream {
+    protected client: InjectiveAccountRpc.InjectiveAccountsRPCClientImpl;
+    constructor(endpoint: string);
+    streamSubaccountBalance({ subaccountId, callback, onEndCallback, onStatusCallback, }: {
+        subaccountId: string;
+        callback: BalanceStreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+}

package/dist/cjs/client/indexer/grpc_stream/IndexerGrpcAccountStream.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcAccountStream = void 0;
+const index_js_1 = require("../transformers/index.js");
+const BaseIndexerGrpcWebConsumer_js_1 = require("../../base/BaseIndexerGrpcWebConsumer.js");
+const indexer_proto_ts_1 = require("@injectivelabs/indexer-proto-ts");
+/**
+ * @category Indexer Grpc Stream
+ */
+class IndexerGrpcAccountStream {
+    client;
+    constructor(endpoint) {
+        this.client = new indexer_proto_ts_1.InjectiveAccountRpc.InjectiveAccountsRPCClientImpl((0, BaseIndexerGrpcWebConsumer_js_1.getGrpcIndexerWebImpl)(endpoint));
+    }
+    streamSubaccountBalance({ subaccountId, callback, onEndCallback, onStatusCallback, }) {
+        const request = indexer_proto_ts_1.InjectiveAccountRpc.StreamSubaccountBalanceRequest.create();
+        request.subaccountId = subaccountId;
+        const subscription = this.client
+            .StreamSubaccountBalance(request)
+            .subscribe({
+            next(response) {
+                callback(index_js_1.IndexerAccountStreamTransformer.balanceStreamCallback(response));
+            },
+            error(err) {
+                if (onStatusCallback) {
+                    onStatusCallback(err);
+                }
+            },
+            complete() {
+                if (onEndCallback) {
+                    onEndCallback();
+                }
+            },
+        });
+        return subscription;
+    }
+}
+exports.IndexerGrpcAccountStream = IndexerGrpcAccountStream;

package/dist/cjs/client/indexer/grpc_stream/IndexerGrpcAuctionStream.d.ts

@@ -0,0 +1,17 @@
+import { StreamStatusResponse } from '../types/index.js';
+import { IndexerAuctionStreamTransformer } from '../transformers/index.js';
+import { Subscription } from 'rxjs';
+import { InjectiveAuctionRpc } from '@injectivelabs/indexer-proto-ts';
+export type BidsStreamCallback = (response: ReturnType<typeof IndexerAuctionStreamTransformer.bidsStreamCallback>) => void;
+/**
+ * @category Indexer Grpc Stream
+ */
+export declare class IndexerGrpcAuctionStream {
+    protected client: InjectiveAuctionRpc.InjectiveAuctionRPCClientImpl;
+    constructor(endpoint: string);
+    streamBids({ callback, onEndCallback, onStatusCallback, }: {
+        callback: BidsStreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+}

package/dist/cjs/client/indexer/grpc_stream/IndexerGrpcAuctionStream.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcAuctionStream = void 0;
+const index_js_1 = require("../transformers/index.js");
+const BaseIndexerGrpcWebConsumer_js_1 = require("../../base/BaseIndexerGrpcWebConsumer.js");
+const indexer_proto_ts_1 = require("@injectivelabs/indexer-proto-ts");
+/**
+ * @category Indexer Grpc Stream
+ */
+class IndexerGrpcAuctionStream {
+    client;
+    constructor(endpoint) {
+        this.client = new indexer_proto_ts_1.InjectiveAuctionRpc.InjectiveAuctionRPCClientImpl((0, BaseIndexerGrpcWebConsumer_js_1.getGrpcIndexerWebImpl)(endpoint));
+    }
+    streamBids({ callback, onEndCallback, onStatusCallback, }) {
+        const request = indexer_proto_ts_1.InjectiveAuctionRpc.StreamBidsRequest.create();
+        const subscription = this.client.StreamBids(request).subscribe({
+            next(response) {
+                callback(index_js_1.IndexerAuctionStreamTransformer.bidsStreamCallback(response));
+            },
+            error(err) {
+                if (onStatusCallback) {
+                    onStatusCallback(err);
+                }
+            },
+            complete() {
+                if (onEndCallback) {
+                    onEndCallback();
+                }
+            },
+        });
+        return subscription;
+    }
+}
+exports.IndexerGrpcAuctionStream = IndexerGrpcAuctionStream;

package/dist/cjs/client/indexer/grpc_stream/IndexerGrpcDerivativesStream.d.ts

@@ -0,0 +1,94 @@
+import { TradeDirection, TradeExecutionSide, TradeExecutionType } from '../../../types/index.js';
+import { StreamStatusResponse } from '../types/index.js';
+import { PaginationOption } from '../../../types/pagination.js';
+import { OrderSide, OrderState } from '@injectivelabs/ts-types';
+import { IndexerDerivativeStreamTransformer } from '../transformers/index.js';
+import { Subscription } from 'rxjs';
+import { InjectiveDerivativeExchangeRpc } from '@injectivelabs/indexer-proto-ts';
+export type DerivativeOrderbookV2StreamCallback = (response: ReturnType<typeof IndexerDerivativeStreamTransformer.orderbookV2StreamCallback>) => void;
+export type DerivativeOrderbookUpdateStreamCallback = (response: ReturnType<typeof IndexerDerivativeStreamTransformer.orderbookUpdateStreamCallback>) => void;
+export type DerivativeOrdersStreamCallback = (response: ReturnType<typeof IndexerDerivativeStreamTransformer.ordersStreamCallback>) => void;
+export type DerivativeOrderHistoryStreamCallback = (response: ReturnType<typeof IndexerDerivativeStreamTransformer.orderHistoryStreamCallback>) => void;
+export type DerivativeTradesStreamCallback = (response: ReturnType<typeof IndexerDerivativeStreamTransformer.tradesStreamCallback>) => void;
+export type PositionsStreamCallback = (response: ReturnType<typeof IndexerDerivativeStreamTransformer.positionStreamCallback>) => void;
+export type PositionsV2StreamCallback = (response: ReturnType<typeof IndexerDerivativeStreamTransformer.positionV2StreamCallback>) => void;
+export type MarketStreamCallback = (response: InjectiveDerivativeExchangeRpc.StreamMarketResponse) => void;
+/**
+ * @category Indexer Grpc Stream
+ */
+export declare class IndexerGrpcDerivativesStream {
+    protected client: InjectiveDerivativeExchangeRpc.InjectiveDerivativeExchangeRPCClientImpl;
+    constructor(endpoint: string);
+    /** @deprecated - use streamDerivativeOrderbookV2 */
+    streamDerivativeOrderbook(_args: {
+        marketIds: string[];
+        callback: any;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamDerivativeOrders({ marketId, subaccountId, orderSide, callback, onEndCallback, onStatusCallback, }: {
+        marketId?: string;
+        subaccountId?: string;
+        orderSide?: OrderSide;
+        callback: DerivativeOrdersStreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamDerivativeOrderHistory({ subaccountId, marketId, orderTypes, executionTypes, direction, state, callback, onEndCallback, onStatusCallback, }: {
+        marketId?: string;
+        subaccountId?: string;
+        orderTypes?: OrderSide[];
+        executionTypes?: TradeExecutionType[];
+        direction?: TradeDirection;
+        state?: OrderState;
+        callback: DerivativeOrderHistoryStreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamDerivativeTrades({ marketIds, marketId, subaccountIds, subaccountId, callback, pagination, executionSide, direction, onEndCallback, onStatusCallback, }: {
+        marketIds?: string[];
+        marketId?: string;
+        subaccountIds?: string[];
+        subaccountId?: string;
+        pagination?: PaginationOption;
+        executionSide?: TradeExecutionSide;
+        direction?: TradeDirection;
+        callback: DerivativeTradesStreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamDerivativePositions({ marketId, subaccountId, callback, address, onEndCallback, onStatusCallback, }: {
+        marketId?: string;
+        address?: string;
+        subaccountId?: string;
+        callback: PositionsStreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamDerivativeMarket({ marketIds, callback, onEndCallback, onStatusCallback, }: {
+        marketIds?: string[];
+        callback: MarketStreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamDerivativeOrderbookV2({ marketIds, callback, onEndCallback, onStatusCallback, }: {
+        marketIds: string[];
+        callback: DerivativeOrderbookV2StreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamDerivativeOrderbookUpdate({ marketIds, callback, onEndCallback, onStatusCallback, }: {
+        marketIds: string[];
+        callback: DerivativeOrderbookV2StreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamDerivativePositionsV2({ marketId, subaccountId, callback, address, onEndCallback, onStatusCallback, }: {
+        marketId?: string;
+        address?: string;
+        subaccountId?: string;
+        callback: PositionsV2StreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+}