@injectivelabs/sdk-ts 1.15.0 → 1.15.2

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

@@ -0,0 +1,444 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcSpotApi = void 0;
+const exceptions_1 = require("@injectivelabs/exceptions");
+const indexer_proto_ts_1 = require("@injectivelabs/indexer-proto-ts");
+const BaseIndexerGrpcConsumer_js_1 = __importDefault(require("../../base/BaseIndexerGrpcConsumer.js"));
+const index_js_1 = require("../types/index.js");
+const index_js_2 = require("../transformers/index.js");
+/**
+ * @category Indexer Grpc API
+ */
+class IndexerGrpcSpotApi extends BaseIndexerGrpcConsumer_js_1.default {
+    module = index_js_1.IndexerModule.Spot;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client =
+            new indexer_proto_ts_1.InjectiveSpotExchangeRpc.InjectiveSpotExchangeRPCClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchMarkets(params) {
+        const { baseDenom, marketStatus, quoteDenom, marketStatuses } = params || {};
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.MarketsRequest.create();
+        if (baseDenom) {
+            request.baseDenom = baseDenom;
+        }
+        if (marketStatus) {
+            request.marketStatus = marketStatus;
+        }
+        if (marketStatuses) {
+            request.marketStatuses = marketStatuses;
+        }
+        if (quoteDenom) {
+            request.quoteDenom = quoteDenom;
+        }
+        try {
+            const response = await this.retry(() => this.client.Markets(request, this.metadata));
+            return index_js_2.IndexerGrpcSpotTransformer.marketsResponseToMarkets(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveSpotExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'Markets',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Markets',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchMarket(marketId) {
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.MarketRequest.create();
+        request.marketId = marketId;
+        try {
+            const response = await this.retry(() => this.client.Market(request, this.metadata));
+            return index_js_2.IndexerGrpcSpotTransformer.marketResponseToMarket(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveSpotExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'Market',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Market',
+                contextModule: this.module,
+            });
+        }
+    }
+    /** @deprecated - use fetchOrderbookV2 */
+    async fetchOrderbook(_marketId) {
+        throw new exceptions_1.GeneralException(new Error('deprecated - use fetchOrderbookV2'));
+    }
+    async fetchOrders(params) {
+        const { cid, tradeId, marketId, marketIds, orderSide, pagination, subaccountId, } = params || {};
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.OrdersRequest.create();
+        if (marketId) {
+            request.marketId = marketId;
+        }
+        if (marketIds) {
+            request.marketIds = marketIds;
+        }
+        if (subaccountId) {
+            request.subaccountId = subaccountId;
+        }
+        if (orderSide) {
+            request.orderSide = orderSide;
+        }
+        if (cid) {
+            request.cid = cid;
+        }
+        if (tradeId) {
+            request.tradeId = tradeId;
+        }
+        // if (isConditional !== undefined) {
+        //   request.isConditional = isConditional
+        // }
+        if (pagination) {
+            if (pagination.skip !== undefined) {
+                request.skip = pagination.skip.toString();
+            }
+            if (pagination.limit !== undefined) {
+                request.limit = pagination.limit;
+            }
+            if (pagination.endTime !== undefined) {
+                request.endTime = pagination.endTime.toString();
+            }
+            if (pagination.startTime !== undefined) {
+                request.startTime = pagination.startTime.toString();
+            }
+        }
+        try {
+            const response = await this.retry(() => this.client.Orders(request, this.metadata));
+            return index_js_2.IndexerGrpcSpotTransformer.ordersResponseToOrders(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveSpotExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'Orders',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Orders',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchOrderHistory(params) {
+        const { cid, state, tradeId, marketId, direction, marketIds, orderTypes, pagination, subaccountId, executionTypes, } = params || {};
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.OrdersHistoryRequest.create();
+        if (subaccountId) {
+            request.subaccountId = subaccountId;
+        }
+        if (marketId) {
+            request.marketId = marketId;
+        }
+        if (marketIds) {
+            request.marketIds = marketIds;
+        }
+        if (orderTypes) {
+            request.orderTypes = orderTypes;
+        }
+        if (executionTypes) {
+            request.executionTypes = executionTypes;
+        }
+        if (direction) {
+            request.direction = direction;
+        }
+        if (state) {
+            request.state = state;
+        }
+        if (cid) {
+            request.cid = cid;
+        }
+        if (tradeId) {
+            request.tradeId = tradeId;
+        }
+        /*
+        if (isConditional !== undefined) {
+          request.isConditional =isConditional
+        }
+        */
+        if (pagination) {
+            if (pagination.skip !== undefined) {
+                request.skip = pagination.skip.toString();
+            }
+            if (pagination.limit !== undefined) {
+                request.limit = pagination.limit;
+            }
+            if (pagination.endTime !== undefined) {
+                request.endTime = pagination.endTime.toString();
+            }
+            if (pagination.startTime !== undefined) {
+                request.startTime = pagination.startTime.toString();
+            }
+        }
+        try {
+            const response = await this.retry(() => this.client.OrdersHistory(request, this.metadata));
+            return index_js_2.IndexerGrpcSpotTransformer.orderHistoryResponseToOrderHistory(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveSpotExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'OrdersHistory',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'OrdersHistory',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchTrades(params) {
+        const { endTime, tradeId, marketId, startTime, direction, marketIds, pagination, subaccountId, executionSide, executionTypes, accountAddress, cid, } = params || {};
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.TradesRequest.create();
+        if (marketId) {
+            request.marketId = marketId;
+        }
+        if (marketIds) {
+            request.marketIds = marketIds;
+        }
+        if (subaccountId) {
+            request.subaccountId = subaccountId;
+        }
+        if (accountAddress) {
+            request.accountAddress = accountAddress;
+        }
+        if (tradeId) {
+            request.tradeId = tradeId;
+        }
+        if (executionTypes) {
+            request.executionTypes = executionTypes;
+        }
+        if (executionSide) {
+            request.executionSide = executionSide;
+        }
+        if (direction) {
+            request.direction = direction;
+        }
+        if (startTime) {
+            request.startTime = startTime.toString();
+        }
+        if (endTime) {
+            request.endTime = endTime.toString();
+        }
+        if (cid) {
+            request.cid = cid;
+        }
+        if (pagination) {
+            if (pagination.skip !== undefined) {
+                request.skip = pagination.skip.toString();
+            }
+            if (pagination.limit !== undefined) {
+                request.limit = pagination.limit;
+            }
+            if (pagination.endTime !== undefined) {
+                request.endTime = pagination.endTime.toString();
+            }
+            if (pagination.startTime !== undefined) {
+                request.startTime = pagination.startTime.toString();
+            }
+        }
+        try {
+            const response = await this.retry(() => this.client.Trades(request, this.metadata));
+            return index_js_2.IndexerGrpcSpotTransformer.tradesResponseToTrades(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveSpotExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'Trades',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'Trades',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchSubaccountOrdersList(params) {
+        const { subaccountId, marketId, pagination } = params || {};
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.SubaccountOrdersListRequest.create();
+        if (subaccountId) {
+            request.subaccountId = subaccountId;
+        }
+        if (marketId) {
+            request.marketId = marketId;
+        }
+        if (pagination) {
+            if (pagination.skip !== undefined) {
+                request.skip = pagination.skip.toString();
+            }
+            if (pagination.limit !== undefined) {
+                request.limit = pagination.limit;
+            }
+        }
+        try {
+            const response = await this.retry(() => this.client.SubaccountOrdersList(request, this.metadata));
+            return index_js_2.IndexerGrpcSpotTransformer.ordersResponseToOrders(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveSpotExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'SubaccountOrdersList',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'SubaccountOrdersList',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchSubaccountTradesList(params) {
+        const { subaccountId, marketId, direction, executionType, pagination } = params || {};
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.SubaccountTradesListRequest.create();
+        if (subaccountId) {
+            request.subaccountId = subaccountId;
+        }
+        if (marketId) {
+            request.marketId = marketId;
+        }
+        if (direction) {
+            request.direction = direction;
+        }
+        if (executionType) {
+            request.executionType = executionType;
+        }
+        if (pagination) {
+            if (pagination.skip !== undefined) {
+                request.skip = pagination.skip.toString();
+            }
+            if (pagination.limit !== undefined) {
+                request.limit = pagination.limit;
+            }
+        }
+        try {
+            const response = await this.retry(() => this.client.SubaccountTradesList(request, this.metadata));
+            return index_js_2.IndexerGrpcSpotTransformer.subaccountTradesListResponseToTradesList(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveSpotExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'SubaccountTradesList',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'SubaccountTradesList',
+                contextModule: this.module,
+            });
+        }
+    }
+    /** @deprecated - use fetchOrderbooksV2 */
+    async fetchOrderbooks(_marketIds) {
+        throw new exceptions_1.GeneralException(new Error('deprecated - use fetchOrderbooksV2'));
+    }
+    async fetchOrderbooksV2(marketIds) {
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.OrderbooksV2Request.create();
+        if (marketIds.length > 0) {
+            request.marketIds = marketIds;
+        }
+        try {
+            const response = await this.retry(() => this.client.OrderbooksV2(request, this.metadata));
+            return index_js_2.IndexerGrpcSpotTransformer.orderbooksV2ResponseToOrderbooksV2(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveSpotExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'OrderbooksV2',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'OrderbooksV2',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchOrderbookV2(marketId) {
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.OrderbookV2Request.create();
+        request.marketId = marketId;
+        try {
+            const response = await this.retry(() => this.client.OrderbookV2(request, this.metadata));
+            return index_js_2.IndexerGrpcSpotTransformer.orderbookV2ResponseToOrderbookV2(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveSpotExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'OrderbookV2',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: '',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchAtomicSwapHistory(params) {
+        const { address, contractAddress, pagination } = params || {};
+        const request = indexer_proto_ts_1.InjectiveSpotExchangeRpc.AtomicSwapHistoryRequest.create();
+        request.address = address;
+        request.contractAddress = contractAddress;
+        if (pagination) {
+            if (pagination.fromNumber !== undefined) {
+                request.fromNumber = pagination.fromNumber;
+            }
+            if (pagination.toNumber !== undefined) {
+                request.toNumber = pagination.toNumber;
+            }
+            if (pagination.skip !== undefined) {
+                request.skip = pagination.skip;
+            }
+            if (pagination.limit !== undefined) {
+                request.limit = pagination.limit;
+            }
+        }
+        try {
+            const response = await this.retry(() => this.client.AtomicSwapHistory(request, this.metadata));
+            return index_js_2.IndexerGrpcSpotTransformer.grpcAtomicSwapHistoryListToAtomicSwapHistoryList(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveSpotExchangeRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'AtomicSwapHistory',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'AtomicSwapHistory',
+                contextModule: this.module,
+            });
+        }
+    }
+}
+exports.IndexerGrpcSpotApi = IndexerGrpcSpotApi;

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

@@ -0,0 +1,29 @@
+import { InjectiveTradingRpc } from '@injectivelabs/indexer-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseIndexerGrpcConsumer.js';
+import { MarketType, GridStrategyType } from '../types/index.js';
+/**
+ * @category Indexer Grpc API
+ */
+export declare class IndexerGrpcTradingApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: InjectiveTradingRpc.InjectiveTradingRPCClientImpl;
+    constructor(endpoint: string);
+    fetchTradingStats(): Promise<InjectiveTradingRpc.GetTradingStatsResponse>;
+    fetchGridStrategies({ skip, state, limit, withTvl, endTime, marketId, startTime, marketType, strategyType, subaccountId, accountAddress, withPerformance, pendingExecution, lastExecutedTime, isTrailingStrategy, }: {
+        skip?: number;
+        state?: string;
+        limit?: number;
+        endTime?: number;
+        withTvl?: boolean;
+        marketId?: string;
+        startTime?: number;
+        marketType?: MarketType;
+        subaccountId?: string;
+        strategyType?: GridStrategyType[];
+        accountAddress?: string;
+        withPerformance?: boolean;
+        pendingExecution?: boolean;
+        lastExecutedTime?: number;
+        isTrailingStrategy?: boolean;
+    }): Promise<InjectiveTradingRpc.ListTradingStrategiesResponse>;
+}

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

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcTradingApi = void 0;
+const exceptions_1 = require("@injectivelabs/exceptions");
+const indexer_proto_ts_1 = require("@injectivelabs/indexer-proto-ts");
+const BaseIndexerGrpcConsumer_js_1 = __importDefault(require("../../base/BaseIndexerGrpcConsumer.js"));
+const index_js_1 = require("../types/index.js");
+/**
+ * @category Indexer Grpc API
+ */
+class IndexerGrpcTradingApi extends BaseIndexerGrpcConsumer_js_1.default {
+    module = index_js_1.IndexerModule.Trading;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new indexer_proto_ts_1.InjectiveTradingRpc.InjectiveTradingRPCClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchTradingStats() {
+        const request = indexer_proto_ts_1.InjectiveTradingRpc.GetTradingStatsRequest.create();
+        try {
+            const response = await this.retry(() => this.client.GetTradingStats(request, this.metadata));
+            return response;
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveTradingRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'TradingStats',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'TradingStats',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchGridStrategies({ skip, state, limit, withTvl, endTime, marketId, startTime, marketType, strategyType, subaccountId, accountAddress, withPerformance, pendingExecution, lastExecutedTime, isTrailingStrategy, }) {
+        const request = indexer_proto_ts_1.InjectiveTradingRpc.ListTradingStrategiesRequest.create();
+        if (accountAddress) {
+            request.accountAddress = accountAddress;
+        }
+        if (subaccountId) {
+            request.subaccountId = subaccountId;
+        }
+        if (strategyType) {
+            request.strategyType = strategyType;
+        }
+        if (marketType) {
+            request.marketType = marketType;
+        }
+        if (state) {
+            request.state = state;
+        }
+        if (limit) {
+            request.limit = limit;
+        }
+        if (skip) {
+            request.skip = skip.toString();
+        }
+        if (marketId) {
+            request.marketId = marketId;
+        }
+        if (withTvl) {
+            request.withTvl = withTvl;
+        }
+        if (withPerformance) {
+            request.withPerformance = withPerformance;
+        }
+        if (isTrailingStrategy) {
+            request.isTrailingStrategy = isTrailingStrategy;
+        }
+        if (startTime) {
+            request.startTime = startTime.toString();
+        }
+        if (endTime) {
+            request.endTime = endTime.toString();
+        }
+        if (pendingExecution) {
+            request.pendingExecution = pendingExecution;
+        }
+        if (lastExecutedTime) {
+            request.lastExecutedTime = lastExecutedTime.toString();
+        }
+        try {
+            const response = await this.retry(() => this.client.ListTradingStrategies(request, this.metadata));
+            return response;
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveTradingRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: (0, exceptions_1.grpcErrorCodeToErrorCode)(e.code),
+                    context: 'GridStrategies',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'GridStrategies',
+                contextModule: this.module,
+            });
+        }
+    }
+}
+exports.IndexerGrpcTradingApi = IndexerGrpcTradingApi;

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

@@ -0,0 +1,65 @@
+import { AccountAddress, EthereumChainId } from '@injectivelabs/ts-types';
+import { InjectiveExchangeRpc } from '@injectivelabs/indexer-proto-ts';
+import { CosmosTxV1Beta1Tx } from '@injectivelabs/core-proto-ts';
+interface PrepareTxArgs {
+    address: AccountAddress;
+    chainId: EthereumChainId;
+    message: any;
+    estimateGas?: boolean;
+    gasLimit?: number;
+    memo?: string | number;
+    timeoutHeight?: number;
+    feeDenom?: string;
+    feePrice?: string;
+}
+/**
+ * @category Indexer Grpc API
+ * @deprecated use IndexerGrpcWeb3GwApi
+ */
+export declare class IndexerGrpcTransactionApi {
+    protected module: string;
+    protected client: InjectiveExchangeRpc.InjectiveExchangeRPCClientImpl;
+    constructor(endpoint: string);
+    prepareTxRequest(args: PrepareTxArgs): Promise<InjectiveExchangeRpc.PrepareTxResponse>;
+    prepareExchangeTxRequest(args: PrepareTxArgs): Promise<InjectiveExchangeRpc.PrepareTxResponse>;
+    prepareCosmosTxRequest({ memo, address, message, estimateGas, gasLimit, feeDenom, feePrice, timeoutHeight, }: {
+        address: string;
+        message: any;
+        estimateGas?: boolean;
+        gasLimit?: number;
+        memo?: string | number;
+        timeoutHeight?: number;
+        feeDenom?: string;
+        feePrice?: string;
+    }): Promise<InjectiveExchangeRpc.PrepareCosmosTxResponse>;
+    /**
+     * 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
+     */
+    broadcastTxRequest({ signature, chainId, message, txResponse, }: {
+        signature: string;
+        chainId: EthereumChainId;
+        useCorrectEIP712Hash?: boolean;
+        txResponse: InjectiveExchangeRpc.PrepareTxResponse;
+        message: Record<string, any>;
+    }): Promise<InjectiveExchangeRpc.BroadcastTxResponse>;
+    /**
+     * 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
+     */
+    broadcastCosmosTxRequest({ address, signature, txRaw, pubKey, }: {
+        address: string;
+        signature: string;
+        txRaw: CosmosTxV1Beta1Tx.TxRaw;
+        pubKey: {
+            type: string;
+            value: string;
+        };
+    }): Promise<InjectiveExchangeRpc.BroadcastCosmosTxResponse>;
+    fetchFeePayer(): Promise<InjectiveExchangeRpc.GetFeePayerResponse>;
+}
+export {};