@injectivelabs/sdk-ts 1.15.0 → 1.15.2

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

@@ -0,0 +1,76 @@
+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 { IndexerSpotStreamTransformer } from '../transformers/index.js';
+import { Subscription } from 'rxjs';
+import { InjectiveSpotExchangeRpc } from '@injectivelabs/indexer-proto-ts';
+export type MarketsStreamCallback = (response: InjectiveSpotExchangeRpc.StreamMarketsResponse) => void;
+export type SpotOrderbookV2StreamCallback = (response: ReturnType<typeof IndexerSpotStreamTransformer.orderbookV2StreamCallback>) => void;
+export type SpotOrderbookUpdateStreamCallback = (response: ReturnType<typeof IndexerSpotStreamTransformer.orderbookUpdateStreamCallback>) => void;
+export type SpotOrdersStreamCallback = (response: ReturnType<typeof IndexerSpotStreamTransformer.ordersStreamCallback>) => void;
+export type SpotOrderHistoryStreamCallback = (response: ReturnType<typeof IndexerSpotStreamTransformer.orderHistoryStreamCallback>) => void;
+export type SpotTradesStreamCallback = (response: ReturnType<typeof IndexerSpotStreamTransformer.tradesStreamCallback>) => void;
+/**
+ * @category Indexer Grpc Stream
+ */
+export declare class IndexerGrpcSpotStream {
+    protected client: InjectiveSpotExchangeRpc.InjectiveSpotExchangeRPCClientImpl;
+    constructor(endpoint: string);
+    /** @deprecated - use streamSpotOrderbookV2 */
+    streamSpotOrderbook(_args: {
+        marketIds: string[];
+        callback: any;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamSpotOrders({ marketId, subaccountId, orderSide, callback, onEndCallback, onStatusCallback, }: {
+        marketId?: string;
+        subaccountId?: string;
+        orderSide?: OrderSide;
+        callback: SpotOrdersStreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamSpotOrderHistory({ marketId, subaccountId, orderTypes, executionTypes, direction, state, callback, onEndCallback, onStatusCallback, }: {
+        marketId?: string;
+        subaccountId?: string;
+        orderTypes?: OrderSide[];
+        executionTypes?: TradeExecutionType[];
+        direction?: TradeDirection;
+        state?: OrderState;
+        callback: SpotOrderHistoryStreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamSpotTrades({ marketIds, marketId, subaccountIds, subaccountId, pagination, direction, executionSide, callback, onEndCallback, onStatusCallback, }: {
+        marketIds?: string[];
+        marketId?: string;
+        subaccountIds?: string[];
+        subaccountId?: string;
+        pagination?: PaginationOption;
+        direction?: TradeDirection;
+        executionSide?: TradeExecutionSide;
+        callback: SpotTradesStreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamSpotMarket({ marketIds, callback, onEndCallback, onStatusCallback, }: {
+        marketIds?: string[];
+        callback: MarketsStreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamSpotOrderbookV2({ marketIds, callback, onEndCallback, onStatusCallback, }: {
+        marketIds: string[];
+        callback: SpotOrderbookV2StreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+    streamSpotOrderbookUpdate({ marketIds, callback, onEndCallback, onStatusCallback, }: {
+        marketIds: string[];
+        callback: SpotOrderbookUpdateStreamCallback;
+        onEndCallback?: (status?: StreamStatusResponse) => void;
+        onStatusCallback?: (status: StreamStatusResponse) => void;
+    }): Subscription;
+}

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

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcSpotStream = 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");
+const exceptions_1 = require("@injectivelabs/exceptions");
+/**
+ * @category Indexer Grpc Stream
+ */
+class IndexerGrpcSpotStream {
+    client;
+    constructor(endpoint) {
+        this.client =
+            new indexer_proto_ts_1.InjectiveSpotExchangeRpc.InjectiveSpotExchangeRPCClientImpl((0, BaseIndexerGrpcWebConsumer_js_1.getGrpcIndexerWebImpl)(endpoint));
+    }
+    /** @deprecated - use streamSpotOrderbookV2 */
+    streamSpotOrderbook(_args) {
+        throw new exceptions_1.GeneralException(new Error('deprecated - use streamDerivativeOrderbookV2'));
+    }
+    streamSpotOrders({ marketId, subaccountId, orderSide, callback, onEndCallback, onStatusCallback, }) {
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.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(index_js_1.IndexerSpotStreamTransformer.ordersStreamCallback(response));
+            },
+            error(err) {
+                if (onStatusCallback) {
+                    onStatusCallback(err);
+                }
+            },
+            complete() {
+                if (onEndCallback) {
+                    onEndCallback();
+                }
+            },
+        });
+        return subscription;
+    }
+    streamSpotOrderHistory({ marketId, subaccountId, orderTypes, executionTypes, direction, state, callback, onEndCallback, onStatusCallback, }) {
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.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(index_js_1.IndexerSpotStreamTransformer.orderHistoryStreamCallback(response));
+            },
+            error(err) {
+                if (onStatusCallback) {
+                    onStatusCallback(err);
+                }
+            },
+            complete() {
+                if (onEndCallback) {
+                    onEndCallback();
+                }
+            },
+        });
+        return subscription;
+    }
+    streamSpotTrades({ marketIds, marketId, subaccountIds, subaccountId, pagination, direction, executionSide, callback, onEndCallback, onStatusCallback, }) {
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.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(index_js_1.IndexerSpotStreamTransformer.tradesStreamCallback(response));
+            },
+            error(err) {
+                if (onStatusCallback) {
+                    onStatusCallback(err);
+                }
+            },
+            complete() {
+                if (onEndCallback) {
+                    onEndCallback();
+                }
+            },
+        });
+        return subscription;
+    }
+    streamSpotMarket({ marketIds, callback, onEndCallback, onStatusCallback, }) {
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.StreamMarketsRequest.create();
+        if (marketIds) {
+            request.marketIds = marketIds;
+        }
+        const subscription = this.client.StreamMarkets(request).subscribe({
+            next(response) {
+                callback(response);
+            },
+            error(err) {
+                if (onStatusCallback) {
+                    onStatusCallback(err);
+                }
+            },
+            complete() {
+                if (onEndCallback) {
+                    onEndCallback();
+                }
+            },
+        });
+        return subscription;
+    }
+    streamSpotOrderbookV2({ marketIds, callback, onEndCallback, onStatusCallback, }) {
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.StreamOrderbookV2Request.create();
+        request.marketIds = marketIds;
+        const subscription = this.client.StreamOrderbookV2(request).subscribe({
+            next(response) {
+                callback(index_js_1.IndexerSpotStreamTransformer.orderbookV2StreamCallback(response));
+            },
+            error(err) {
+                if (onStatusCallback) {
+                    onStatusCallback(err);
+                }
+            },
+            complete() {
+                if (onEndCallback) {
+                    onEndCallback();
+                }
+            },
+        });
+        return subscription;
+    }
+    streamSpotOrderbookUpdate({ marketIds, callback, onEndCallback, onStatusCallback, }) {
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.StreamOrderbookUpdateRequest.create();
+        request.marketIds = marketIds;
+        const subscription = this.client.StreamOrderbookUpdate(request).subscribe({
+            next(response) {
+                callback(index_js_1.IndexerSpotStreamTransformer.orderbookUpdateStreamCallback(response));
+            },
+            error(err) {
+                if (onStatusCallback) {
+                    onStatusCallback(err);
+                }
+            },
+            complete() {
+                if (onEndCallback) {
+                    onEndCallback();
+                }
+            },
+        });
+        return subscription;
+    }
+}
+exports.IndexerGrpcSpotStream = IndexerGrpcSpotStream;

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

@@ -0,0 +1,8 @@
+export * from './IndexerGrpcSpotStream.js';
+export * from './IndexerGrpcMitoStream.js';
+export * from './IndexerGrpcOracleStream.js';
+export * from './IndexerGrpcAccountStream.js';
+export * from './IndexerGrpcAuctionStream.js';
+export * from './IndexerGrpcExplorerStream.js';
+export * from './IndexerGrpcDerivativesStream.js';
+export * from './IndexerGrpcAccountPortfolioStream.js';

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

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IndexerGrpcSpotStream.js"), exports);
+__exportStar(require("./IndexerGrpcMitoStream.js"), exports);
+__exportStar(require("./IndexerGrpcOracleStream.js"), exports);
+__exportStar(require("./IndexerGrpcAccountStream.js"), exports);
+__exportStar(require("./IndexerGrpcAuctionStream.js"), exports);
+__exportStar(require("./IndexerGrpcExplorerStream.js"), exports);
+__exportStar(require("./IndexerGrpcDerivativesStream.js"), exports);
+__exportStar(require("./IndexerGrpcAccountPortfolioStream.js"), exports);

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

@@ -0,0 +1,5 @@
+export * from './grpc/index.js';
+export * from './grpc_stream/index.js';
+export * from './transformers/index.js';
+export * from './types/index.js';
+export * from './rest/index.js';

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

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// export * from './ExchangeGrpcClient'
+// export * from './ExchangeRestClient'
+// export * from './ExchangeGrpcStreamClient'
+__exportStar(require("./grpc/index.js"), exports);
+__exportStar(require("./grpc_stream/index.js"), exports);
+__exportStar(require("./transformers/index.js"), exports);
+__exportStar(require("./types/index.js"), exports);
+__exportStar(require("./rest/index.js"), exports);

package/dist/cjs/client/indexer/rest/IndexerRestDerivativesChronosApi.d.ts

@@ -0,0 +1,8 @@
+import BaseRestConsumer from '../../base/BaseRestConsumer.js';
+/**
+ * @category Indexer Chronos API
+ */
+export declare class IndexerRestDerivativesChronosApi extends BaseRestConsumer {
+    fetchMarketSummary(marketId: string): Promise<import("../types/derivatives-rest.js").ChronosDerivativeMarketSummary>;
+    fetchMarketsSummary(): Promise<import("../types/derivatives-rest.js").AllChronosDerivativeMarketSummary[]>;
+}

package/dist/cjs/client/indexer/rest/IndexerRestDerivativesChronosApi.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerRestDerivativesChronosApi = void 0;
+const BaseRestConsumer_js_1 = __importDefault(require("../../base/BaseRestConsumer.js"));
+const exceptions_1 = require("@injectivelabs/exceptions");
+const index_js_1 = require("../types/index.js");
+/**
+ * @category Indexer Chronos API
+ */
+class IndexerRestDerivativesChronosApi extends BaseRestConsumer_js_1.default {
+    async fetchMarketSummary(marketId) {
+        const path = `market_summary`;
+        try {
+            const { data } = await this.retry(() => this.get(path, {
+                marketId,
+                resolution: '24h',
+            }));
+            return data;
+        }
+        catch (e) {
+            if (e instanceof exceptions_1.HttpRequestException) {
+                throw e;
+            }
+            throw new exceptions_1.HttpRequestException(new Error(e), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: `${this.endpoint}/${path}?marketId=${marketId}`,
+                contextModule: index_js_1.IndexerModule.ChronosDerivative,
+            });
+        }
+    }
+    async fetchMarketsSummary() {
+        const path = `market_summary_all`;
+        try {
+            const { data } = await this.retry(() => this.get(path, {
+                resolution: '24h',
+            }));
+            return data;
+        }
+        catch (e) {
+            if (e instanceof exceptions_1.HttpRequestException) {
+                throw e;
+            }
+            throw new exceptions_1.HttpRequestException(new Error(e), {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: `${this.endpoint}/${path}`,
+                contextModule: index_js_1.IndexerModule.ChronosDerivative,
+            });
+        }
+    }
+}
+exports.IndexerRestDerivativesChronosApi = IndexerRestDerivativesChronosApi;

package/dist/cjs/client/indexer/rest/IndexerRestExplorerApi.d.ts

@@ -0,0 +1,127 @@
+import { MsgStatus, MsgType } from '@injectivelabs/ts-types';
+import { Paging, Contract, WasmCode, BankTransfer, ExplorerTransaction, ContractTransaction, ExplorerBlockWithTxs, ExplorerValidatorUptime, ExplorerCW20BalanceWithToken, ContractTransactionWithMessages } from '../types/explorer.js';
+import { CW20BalanceExplorerApiResponse } from '../types/explorer-rest.js';
+import BaseRestConsumer from '../../base/BaseRestConsumer.js';
+import { Block, ExplorerValidator } from '../types/explorer.js';
+/**
+ * @category Indexer Rest API
+ */
+export declare class IndexerRestExplorerApi extends BaseRestConsumer {
+    constructor(endpoint: string);
+    fetchBlock(blockHashHeight: string): Promise<ExplorerBlockWithTxs>;
+    fetchBlocks(params?: {
+        before?: number;
+        limit?: number;
+        from?: number;
+        to?: number;
+    }): Promise<{
+        paging: Paging;
+        blocks: Block[];
+    }>;
+    fetchBlocksWithTx(params?: {
+        before?: number;
+        limit?: number;
+        from?: number;
+        to?: number;
+    }): Promise<{
+        paging: Paging;
+        blocks: ExplorerBlockWithTxs[];
+    }>;
+    fetchTransactions(params?: {
+        fromNumber?: number;
+        limit?: number;
+        before?: number;
+        after?: number;
+        toNumber?: number;
+        skip?: number;
+        startTime?: number;
+        endTime?: number;
+        status?: MsgStatus;
+        type?: MsgType[];
+    }): Promise<{
+        paging: Paging;
+        transactions: ExplorerTransaction[];
+    }>;
+    fetchAccountTransactions({ account, params, }: {
+        account: string;
+        params?: {
+            skip?: number;
+            limit?: number;
+            after?: number;
+            before?: number;
+            type?: MsgType[];
+            status?: MsgStatus;
+            endTime?: number;
+            toNumber?: number;
+            fromNumber?: number;
+            startTime?: number;
+            withClaimId?: boolean;
+        };
+    }): Promise<{
+        paging: Paging;
+        transactions: ExplorerTransaction[];
+    }>;
+    fetchTransaction(hash: string): Promise<ExplorerTransaction>;
+    fetchValidators(): Promise<Partial<ExplorerValidator>[]>;
+    fetchValidatorUptime(validatorConsensusAddress: string): Promise<ExplorerValidatorUptime[]>;
+    fetchContract(contractAddress: string): Promise<Contract>;
+    fetchContracts(params?: {
+        assetsOnly?: boolean;
+        fromNumber?: number;
+        codeId?: string | number;
+        limit?: number;
+        skip?: number;
+        label?: string;
+    }): Promise<{
+        paging: Paging;
+        contracts: Contract[];
+    }>;
+    fetchContractTransactions({ contractAddress, params, }: {
+        contractAddress: string;
+        params?: {
+            fromNumber?: number;
+            limit?: number;
+            toNumber?: number;
+            skip?: number;
+        };
+    }): Promise<{
+        paging: Paging;
+        transactions: ContractTransaction[];
+    }>;
+    fetchContractTransactionsWithMessages({ contractAddress, params, }: {
+        contractAddress: string;
+        params?: {
+            fromNumber?: number;
+            limit?: number;
+            toNumber?: number;
+            skip?: number;
+        };
+    }): Promise<{
+        paging: Paging;
+        transactions: ContractTransactionWithMessages[];
+    }>;
+    fetchWasmCode(codeId: number): Promise<WasmCode>;
+    fetchWasmCodes(params?: {
+        fromNumber?: number;
+        limit?: number;
+        toNumber?: number;
+    }): Promise<{
+        paging: Paging;
+        wasmCodes: WasmCode[];
+    }>;
+    fetchCW20Balances(address: string): Promise<ExplorerCW20BalanceWithToken[]>;
+    fetchCW20BalancesNoThrow(address: string): Promise<CW20BalanceExplorerApiResponse[]>;
+    fetchBankTransfers(params: {
+        limit?: number;
+        skip?: number;
+        startTime?: number;
+        endTime?: number;
+        address?: string;
+        isCommunitySpendPool?: boolean;
+        senders?: string;
+        recipients?: string;
+    }): Promise<{
+        paging: Paging;
+        data: BankTransfer[];
+    }>;
+}