@injectivelabs/sdk-ts 1.16.24 → 1.16.25-alpha.1

package/dist/esm/client/indexer/grpc_stream/IndexerGrpcDerivativesStream.js

@@ -1,246 +0,0 @@
-import { GeneralException } from '@injectivelabs/exceptions';
-import { InjectiveDerivativeExchangeRpc } from '@injectivelabs/indexer-proto-ts';
-import { IndexerDerivativeStreamTransformer } from '../transformers/index.js';
-import { getGrpcIndexerWebImpl } from '../../base/BaseIndexerGrpcWebConsumer.js';
-/**
- * @category Indexer Grpc Stream
- */
-export class IndexerGrpcDerivativesStream {
-    client;
-    constructor(endpoint) {
-        this.client =
-            new InjectiveDerivativeExchangeRpc.InjectiveDerivativeExchangeRPCClientImpl(getGrpcIndexerWebImpl(endpoint));
-    }
-    /** @deprecated - use streamDerivativeOrderbookV2 */
-    streamDerivativeOrderbook(_args) {
-        throw new GeneralException(new Error('deprecated - use streamDerivativeOrderbookV2'));
-    }
-    streamDerivativeOrders({ marketId, subaccountId, orderSide, callback, onEndCallback, onStatusCallback, }) {
-        const request = InjectiveDerivativeExchangeRpc.StreamOrdersRequest.create();
-        if (marketId) {
-            request.marketId = marketId;
-        }
-        if (subaccountId) {
-            request.subaccountId = subaccountId;
-        }
-        if (orderSide) {
-            request.orderSide = orderSide;
-        }
-        const subscription = this.client.StreamOrders(request).subscribe({
-            next(response) {
-                callback(IndexerDerivativeStreamTransformer.ordersStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamDerivativeOrderHistory({ subaccountId, marketId, orderTypes, executionTypes, direction, state, callback, onEndCallback, onStatusCallback, }) {
-        const request = InjectiveDerivativeExchangeRpc.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;
-        }
-        const subscription = this.client.StreamOrdersHistory(request).subscribe({
-            next(response) {
-                callback(IndexerDerivativeStreamTransformer.orderHistoryStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamDerivativeTrades({ marketIds, marketId, subaccountIds, subaccountId, callback, pagination, executionSide, direction, onEndCallback, onStatusCallback, }) {
-        const request = InjectiveDerivativeExchangeRpc.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 !== undefined) {
-                request.skip = pagination.skip.toString();
-            }
-            if (pagination.limit !== undefined) {
-                request.limit = pagination.limit;
-            }
-        }
-        const subscription = this.client.StreamTrades(request).subscribe({
-            next(response) {
-                callback(IndexerDerivativeStreamTransformer.tradesStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamDerivativePositions({ marketId, subaccountId, callback, address, onEndCallback, onStatusCallback, }) {
-        const request = InjectiveDerivativeExchangeRpc.StreamPositionsRequest.create();
-        if (marketId) {
-            request.marketId = marketId;
-        }
-        if (address) {
-            request.accountAddress = address;
-        }
-        if (subaccountId) {
-            request.subaccountId = subaccountId;
-        }
-        const subscription = this.client.StreamPositions(request).subscribe({
-            next(response) {
-                callback(IndexerDerivativeStreamTransformer.positionStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamDerivativeMarket({ marketIds, callback, onEndCallback, onStatusCallback, }) {
-        const request = InjectiveDerivativeExchangeRpc.StreamMarketRequest.create();
-        if (marketIds && marketIds.length) {
-            request.marketIds = marketIds;
-        }
-        const subscription = this.client.StreamMarket(request).subscribe({
-            next(response) {
-                callback(response);
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamDerivativeOrderbookV2({ marketIds, callback, onEndCallback, onStatusCallback, }) {
-        const request = InjectiveDerivativeExchangeRpc.StreamOrderbookV2Request.create();
-        request.marketIds = marketIds;
-        const subscription = this.client.StreamOrderbookV2(request).subscribe({
-            next(response) {
-                callback(IndexerDerivativeStreamTransformer.orderbookV2StreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamDerivativeOrderbookUpdate({ marketIds, callback, onEndCallback, onStatusCallback, }) {
-        const request = InjectiveDerivativeExchangeRpc.StreamOrderbookUpdateRequest.create();
-        request.marketIds = marketIds;
-        const subscription = this.client.StreamOrderbookUpdate(request).subscribe({
-            next(response) {
-                callback(IndexerDerivativeStreamTransformer.orderbookUpdateStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamDerivativePositionsV2({ marketId, subaccountId, callback, address, onEndCallback, onStatusCallback, }) {
-        const request = InjectiveDerivativeExchangeRpc.StreamPositionsV2Request.create();
-        if (marketId) {
-            request.marketId = marketId;
-        }
-        if (address) {
-            request.accountAddress = address;
-        }
-        if (subaccountId) {
-            request.subaccountId = subaccountId;
-        }
-        const subscription = this.client.StreamPositionsV2(request).subscribe({
-            next(response) {
-                callback(IndexerDerivativeStreamTransformer.positionV2StreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-}

package/dist/esm/client/indexer/grpc_stream/IndexerGrpcExplorerStream.d.ts

@@ -1,29 +0,0 @@
-import { InjectiveExplorerRpc } from '@injectivelabs/indexer-proto-ts';
-import { ExplorerStreamTransformer } from '../transformers/index.js';
-import type { Subscription } from 'rxjs';
-import type { StreamStatusResponse } from '../types/index.js';
-export type BlocksStreamCallback = (response: ReturnType<typeof ExplorerStreamTransformer.blocksStreamCallback>) => void;
-export type BlocksWithTxsStreamCallback = (response: ReturnType<typeof ExplorerStreamTransformer.blocksWithTxsStreamCallback>) => void;
-export type TransactionsStreamCallback = (response: ReturnType<typeof ExplorerStreamTransformer.transactionsStreamCallback>) => void;
-/**
- * @category Indexer Grpc Stream
- */
-export declare class IndexerGrpcExplorerStream {
-    protected client: InjectiveExplorerRpc.InjectiveExplorerRPCClientImpl;
-    constructor(endpoint: string);
-    streamBlocks({ callback, onEndCallback, onStatusCallback, }: {
-        callback: BlocksStreamCallback;
-        onEndCallback?: (status?: StreamStatusResponse) => void;
-        onStatusCallback?: (status: StreamStatusResponse) => void;
-    }): Subscription;
-    streamBlocksWithTxs({ callback, onEndCallback, onStatusCallback, }: {
-        callback: BlocksWithTxsStreamCallback;
-        onEndCallback?: (status?: StreamStatusResponse) => void;
-        onStatusCallback?: (status: StreamStatusResponse) => void;
-    }): Subscription;
-    streamTransactions({ callback, onEndCallback, onStatusCallback, }: {
-        callback: TransactionsStreamCallback;
-        onEndCallback?: (status?: StreamStatusResponse) => void;
-        onStatusCallback?: (status: StreamStatusResponse) => void;
-    }): Subscription;
-}

package/dist/esm/client/indexer/grpc_stream/IndexerGrpcExplorerStream.js

@@ -1,69 +0,0 @@
-import { InjectiveExplorerRpc } from '@injectivelabs/indexer-proto-ts';
-import { ExplorerStreamTransformer } from '../transformers/index.js';
-import { getGrpcIndexerWebImpl } from '../../base/BaseIndexerGrpcWebConsumer.js';
-/**
- * @category Indexer Grpc Stream
- */
-export class IndexerGrpcExplorerStream {
-    client;
-    constructor(endpoint) {
-        this.client = new InjectiveExplorerRpc.InjectiveExplorerRPCClientImpl(getGrpcIndexerWebImpl(endpoint));
-    }
-    streamBlocks({ callback, onEndCallback, onStatusCallback, }) {
-        const request = InjectiveExplorerRpc.StreamBlocksRequest.create();
-        const subscription = this.client.StreamBlocks(request).subscribe({
-            next(response) {
-                callback(ExplorerStreamTransformer.blocksStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamBlocksWithTxs({ callback, onEndCallback, onStatusCallback, }) {
-        const request = InjectiveExplorerRpc.StreamBlocksRequest.create();
-        const subscription = this.client.StreamBlocks(request).subscribe({
-            next(response) {
-                callback(ExplorerStreamTransformer.blocksWithTxsStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamTransactions({ callback, onEndCallback, onStatusCallback, }) {
-        const request = InjectiveExplorerRpc.StreamTxsRequest.create();
-        const subscription = this.client.StreamTxs(request).subscribe({
-            next(response) {
-                callback(ExplorerStreamTransformer.transactionsStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-}

package/dist/esm/client/indexer/grpc_stream/IndexerGrpcMitoStream.d.ts

@@ -1,51 +0,0 @@
-import { MitoApi } from '@injectivelabs/mito-proto-ts';
-import { IndexerGrpcMitoStreamTransformer } from '../transformers/index.js';
-import type { Subscription } from 'rxjs';
-import type { StreamStatusResponse } from '../types/index.js';
-export type TransfersStreamCallback = (response: ReturnType<typeof IndexerGrpcMitoStreamTransformer.transfersStreamCallback>) => void;
-export type VaultStreamCallback = (response: ReturnType<typeof IndexerGrpcMitoStreamTransformer.vaultStreamCallback>) => void;
-export type VaultHolderSubscriptionStreamCallback = (response: ReturnType<typeof IndexerGrpcMitoStreamTransformer.vaultHolderSubscriptionStreamCallback>) => void;
-export type StakingRewardByAccountStreamCallback = (response: ReturnType<typeof IndexerGrpcMitoStreamTransformer.stakingRewardByAccountStreamCallback>) => void;
-export type HistoricalStakingStreamCallback = (response: ReturnType<typeof IndexerGrpcMitoStreamTransformer.historicalStakingStreamCallback>) => void;
-/**
- * @category Indexer Grpc Stream
- */
-export declare class IndexerGrpcMitoStream {
-    protected client: MitoApi.MitoAPIClientImpl;
-    constructor(endpoint: string);
-    streamTransfers({ vault, account, callback, onEndCallback, onStatusCallback, }: {
-        vault?: string;
-        account?: string;
-        callback: TransfersStreamCallback;
-        onEndCallback?: (status?: StreamStatusResponse) => void;
-        onStatusCallback?: (status: StreamStatusResponse) => void;
-    }): Subscription;
-    streamVault({ vault, callback, onEndCallback, onStatusCallback, }: {
-        vault?: string;
-        callback: VaultStreamCallback;
-        onEndCallback?: (status?: StreamStatusResponse) => void;
-        onStatusCallback?: (status: StreamStatusResponse) => void;
-    }): Subscription;
-    streamVaultHolderSubscriptions({ holderAddress, vaultAddress, stakingContractAddress, callback, onEndCallback, onStatusCallback, }: {
-        holderAddress: string;
-        vaultAddress?: string;
-        stakingContractAddress?: string;
-        callback: VaultHolderSubscriptionStreamCallback;
-        onEndCallback?: (status?: StreamStatusResponse) => void;
-        onStatusCallback?: (status: StreamStatusResponse) => void;
-    }): Subscription;
-    streamStakingRewardsByAccount({ staker, callback, onEndCallback, onStatusCallback, stakingContractAddress, }: {
-        staker: string;
-        stakingContractAddress: string;
-        callback: StakingRewardByAccountStreamCallback;
-        onEndCallback?: (status?: StreamStatusResponse) => void;
-        onStatusCallback?: (status: StreamStatusResponse) => void;
-    }): Subscription;
-    streamHistoricalStaking({ staker, stakingContractAddress, callback, onEndCallback, onStatusCallback, }: {
-        staker: string;
-        stakingContractAddress: string;
-        callback: HistoricalStakingStreamCallback;
-        onEndCallback?: (status?: StreamStatusResponse) => void;
-        onStatusCallback?: (status: StreamStatusResponse) => void;
-    }): Subscription;
-}

package/dist/esm/client/indexer/grpc_stream/IndexerGrpcMitoStream.js

@@ -1,133 +0,0 @@
-import { MitoApi } from '@injectivelabs/mito-proto-ts';
-import { IndexerGrpcMitoStreamTransformer } from '../transformers/index.js';
-import { getGrpcIndexerWebImpl } from '../../base/BaseIndexerGrpcWebConsumer.js';
-/**
- * @category Indexer Grpc Stream
- */
-export class IndexerGrpcMitoStream {
-    client;
-    constructor(endpoint) {
-        this.client = new MitoApi.MitoAPIClientImpl(getGrpcIndexerWebImpl(endpoint));
-    }
-    streamTransfers({ vault, account, callback, onEndCallback, onStatusCallback, }) {
-        const request = MitoApi.StreamTransfersRequest.create();
-        if (vault) {
-            request.vault = vault;
-        }
-        if (account) {
-            request.account = account;
-        }
-        const subscription = this.client.StreamTransfers(request).subscribe({
-            next(response) {
-                callback(IndexerGrpcMitoStreamTransformer.transfersStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamVault({ vault, callback, onEndCallback, onStatusCallback, }) {
-        const request = MitoApi.StreamVaultRequest.create();
-        if (vault) {
-            request.vault = vault;
-        }
-        const subscription = this.client.StreamVault(request).subscribe({
-            next(response) {
-                callback(IndexerGrpcMitoStreamTransformer.vaultStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamVaultHolderSubscriptions({ holderAddress, vaultAddress, stakingContractAddress, callback, onEndCallback, onStatusCallback, }) {
-        const request = MitoApi.StreamHolderSubscriptionRequest.create();
-        request.holderAddress = holderAddress;
-        if (vaultAddress) {
-            request.vaultAddress = vaultAddress;
-        }
-        if (stakingContractAddress) {
-            request.stakingContractAddress = stakingContractAddress;
-        }
-        const subscription = this.client
-            .StreamHolderSubscription(request)
-            .subscribe({
-            next(response) {
-                callback(IndexerGrpcMitoStreamTransformer.vaultHolderSubscriptionStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamStakingRewardsByAccount({ staker, callback, onEndCallback, onStatusCallback, stakingContractAddress, }) {
-        const request = MitoApi.StreamStakingRewardByAccountRequest.create();
-        request.staker = staker;
-        request.stakingContractAddress = stakingContractAddress;
-        const subscription = this.client
-            .StreamStakingRewardByAccount(request)
-            .subscribe({
-            next(response) {
-                callback(IndexerGrpcMitoStreamTransformer.stakingRewardByAccountStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamHistoricalStaking({ staker, stakingContractAddress, callback, onEndCallback, onStatusCallback, }) {
-        const request = MitoApi.StreamHistoricalStakingRequest.create();
-        request.staker = staker;
-        request.stakingContractAddress = stakingContractAddress;
-        const subscription = this.client
-            .StreamHistoricalStaking(request)
-            .subscribe({
-            next(response) {
-                callback(IndexerGrpcMitoStreamTransformer.historicalStakingStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-}

package/dist/esm/client/indexer/grpc_stream/IndexerGrpcOracleStream.d.ts

@@ -1,27 +0,0 @@
-import { InjectiveOracleRpc } from '@injectivelabs/indexer-proto-ts';
-import { IndexerOracleStreamTransformer } from '../transformers/IndexerOracleStreamTransformer.js';
-import type { Subscription } from 'rxjs';
-import type { StreamStatusResponse } from '../types/index.js';
-export type OraclePriceStreamCallback = (response: ReturnType<typeof IndexerOracleStreamTransformer.pricesStreamCallback>) => void;
-export type OraclePricesByMarketsStreamCallback = (response: ReturnType<typeof IndexerOracleStreamTransformer.pricesByMarketsCallback>) => void;
-/**
- * @category Indexer Grpc Stream
- */
-export declare class IndexerGrpcOracleStream {
-    protected client: InjectiveOracleRpc.InjectiveOracleRPCClientImpl;
-    constructor(endpoint: string);
-    streamOraclePrices({ oracleType, baseSymbol, quoteSymbol, callback, onEndCallback, onStatusCallback, }: {
-        oracleType: string;
-        baseSymbol?: string;
-        quoteSymbol?: string;
-        callback: OraclePriceStreamCallback;
-        onEndCallback?: (status?: StreamStatusResponse) => void;
-        onStatusCallback?: (status: StreamStatusResponse) => void;
-    }): Subscription;
-    streamOraclePricesByMarkets({ marketIds, callback, onEndCallback, onStatusCallback, }: {
-        marketIds?: string[];
-        callback: OraclePricesByMarketsStreamCallback;
-        onEndCallback?: (status?: StreamStatusResponse) => void;
-        onStatusCallback?: (status: StreamStatusResponse) => void;
-    }): Subscription;
-}

package/dist/esm/client/indexer/grpc_stream/IndexerGrpcOracleStream.js

@@ -1,60 +0,0 @@
-import { InjectiveOracleRpc } from '@injectivelabs/indexer-proto-ts';
-import { getGrpcIndexerWebImpl } from '../../base/BaseIndexerGrpcWebConsumer.js';
-import { IndexerOracleStreamTransformer } from '../transformers/IndexerOracleStreamTransformer.js';
-/**
- * @category Indexer Grpc Stream
- */
-export class IndexerGrpcOracleStream {
-    client;
-    constructor(endpoint) {
-        this.client = new InjectiveOracleRpc.InjectiveOracleRPCClientImpl(getGrpcIndexerWebImpl(endpoint));
-    }
-    streamOraclePrices({ oracleType, baseSymbol, quoteSymbol, callback, onEndCallback, onStatusCallback, }) {
-        const request = InjectiveOracleRpc.StreamPricesRequest.create();
-        if (baseSymbol) {
-            request.baseSymbol = baseSymbol;
-        }
-        if (quoteSymbol) {
-            request.quoteSymbol = quoteSymbol;
-        }
-        request.oracleType = oracleType;
-        const subscription = this.client.StreamPrices(request).subscribe({
-            next(response) {
-                callback(IndexerOracleStreamTransformer.pricesStreamCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-    streamOraclePricesByMarkets({ marketIds, callback, onEndCallback, onStatusCallback, }) {
-        const request = InjectiveOracleRpc.StreamPricesByMarketsRequest.create();
-        if (marketIds) {
-            request.marketIds = marketIds;
-        }
-        const subscription = this.client.StreamPricesByMarkets(request).subscribe({
-            next(response) {
-                callback(IndexerOracleStreamTransformer.pricesByMarketsCallback(response));
-            },
-            error(err) {
-                if (onStatusCallback) {
-                    onStatusCallback(err);
-                }
-            },
-            complete() {
-                if (onEndCallback) {
-                    onEndCallback();
-                }
-            },
-        });
-        return subscription;
-    }
-}