example-js-sdk 0.0.1

package/lib/clients/GasFee.d.ts

@@ -0,0 +1,12 @@
+import { SimpleMap } from "../util/type";
+import BigNumber from "bignumber.js";
+declare class GasFee {
+    readonly txGasCosts: SimpleMap<BigNumber>;
+    readonly txGasPrices: SimpleMap<BigNumber>;
+    readonly defaultFeeDenom: string;
+    constructor(txGasCosts: SimpleMap<BigNumber>, txGasPrices: SimpleMap<BigNumber>, defaultFeeDenom?: string);
+    getFee(msgTypeUrl: string, denom?: string): BigNumber | null;
+    getGasPrice(denom: string): BigNumber | null;
+    getGasCost(msgTypeUrl: string): BigNumber;
+}
+export default GasFee;

package/lib/clients/GasFee.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constant_1 = require("../constant");
+const number_1 = require("../util/number");
+const tx_1 = require("../util/tx");
+class GasFee {
+    constructor(txGasCosts, txGasPrices, defaultFeeDenom = constant_1.DEFAULT_FEE_DENOM) {
+        this.txGasCosts = txGasCosts;
+        this.txGasPrices = txGasPrices;
+        this.defaultFeeDenom = defaultFeeDenom;
+    }
+    getFee(msgTypeUrl, denom = constant_1.DEFAULT_FEE_DENOM) {
+        const minGasPrice = this.getGasPrice(denom);
+        if (!minGasPrice)
+            return null;
+        const msgGasCost = this.getGasCost(msgTypeUrl);
+        return msgGasCost.times(minGasPrice);
+    }
+    getGasPrice(denom) {
+        const gasPrice = this.txGasPrices[denom];
+        if (!gasPrice) {
+            console.warn("denom not supported for paying gas", denom);
+        }
+        return gasPrice ?? null;
+    }
+    getGasCost(msgTypeUrl) {
+        return this.txGasCosts[msgTypeUrl] ?? this.txGasCosts[tx_1.TxGasCostTypeDefaultKey] ?? number_1.BN_ZERO;
+    }
+}
+exports.default = GasFee;

package/lib/clients/GrpcQueryClient.d.ts

@@ -0,0 +1,22 @@
+import { ProtobufRpcClient } from "@cosmjs/stargate";
+import { grpc } from "@improbable-eng/grpc-web";
+export declare class GrpcWebError extends Error {
+    code: grpc.Code;
+    metadata: grpc.Metadata;
+    constructor(message: string, code: grpc.Code, metadata: grpc.Metadata);
+}
+/**
+ * Uses grpc-web module on cosmos-sdk to simulate gRPC queries
+ * throught HTTP/1.1.
+ * see https://github.com/cosmos/cosmos-sdk/issues/7345
+ */
+export declare class GrpcQueryClient implements ProtobufRpcClient {
+    private host;
+    private options;
+    constructor(host: string, options?: {
+        transport?: grpc.TransportFactory;
+        metadata?: grpc.Metadata;
+    });
+    request(serviceName: string, methodName: string, data: Uint8Array): Promise<Uint8Array>;
+}
+export default GrpcQueryClient;

package/lib/clients/GrpcQueryClient.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcQueryClient = exports.GrpcWebError = void 0;
+const grpc_web_1 = require("@improbable-eng/grpc-web");
+class GrpcWebError extends Error {
+    constructor(message, code, metadata) {
+        super(message);
+        this.code = code;
+        this.metadata = metadata;
+    }
+}
+exports.GrpcWebError = GrpcWebError;
+/**
+ * Uses grpc-web module on cosmos-sdk to simulate gRPC queries
+ * throught HTTP/1.1.
+ * see https://github.com/cosmos/cosmos-sdk/issues/7345
+ */
+class GrpcQueryClient {
+    constructor(host, options = {}) {
+        this.host = host;
+        this.options = options;
+    }
+    request(serviceName, methodName, data) {
+        return new Promise((resolve, reject) => {
+            grpc_web_1.grpc.unary({
+                methodName,
+                service: { serviceName },
+                requestStream: false,
+                responseStream: false,
+                requestType: {},
+                responseType: {
+                    deserializeBinary: (data) => data,
+                },
+            }, {
+                request: {
+                    ...data,
+                    toObject: () => data,
+                    serializeBinary: () => data,
+                },
+                host: this.host,
+                metadata: this.options.metadata,
+                transport: this.options.transport,
+                debug: false,
+                onEnd: function (response) {
+                    if (response.status === grpc_web_1.grpc.Code.OK) {
+                        resolve(response.message);
+                    }
+                    else {
+                        const err = new Error(response.statusMessage);
+                        err.code = response.status;
+                        err.metadata = response.trailers;
+                        reject(err);
+                    }
+                },
+            });
+        });
+    }
+}
+exports.GrpcQueryClient = GrpcQueryClient;
+exports.default = GrpcQueryClient;

package/lib/clients/HydrogenClient.d.ts

@@ -0,0 +1,28 @@
+import { NetworkConfig } from "../constant";
+import { BlockchainUtils } from "../util";
+import { CrossChainTransfer, CrossChainTransferDetailed, GetDetailedTransfersResponse, GetRelaysRequest, GetRelaysResponse, GetStatsResponse, GetTransfersRequest, GetTransfersResponse } from "../hydrogen";
+import { GetFeeQuoteRequest, GetFeeQuoteResponse } from "../hydrogen/feeQuote";
+import TokenClient from './TokenClient';
+export declare const HydrogenEndpoints: {
+    stats: string;
+    transfer_payloads: string;
+    relays: string;
+    fee_quote: string;
+    bridge_fee: string;
+};
+declare class HydrogenClient {
+    private config;
+    private readonly apiManager;
+    private readonly tokenClient;
+    constructor(config: NetworkConfig, tokenClient: TokenClient);
+    static instance(config: NetworkConfig, tokenClient: TokenClient): HydrogenClient;
+    checkState(): void;
+    formatCrossChainTransferV2: (value: any) => CrossChainTransfer;
+    formatCrossChainTransferDetailedV2: (value: any) => CrossChainTransferDetailed;
+    getStats(): Promise<GetStatsResponse>;
+    getTransfers(req: GetTransfersRequest, version?: string): Promise<GetTransfersResponse>;
+    getDetailedTransfers(req: GetTransfersRequest, version?: string): Promise<GetDetailedTransfersResponse>;
+    getRelaysTransfers(req: GetRelaysRequest): Promise<GetRelaysResponse>;
+    getFeeQuote(req: GetFeeQuoteRequest, blockchain?: BlockchainUtils.Blockchain | BlockchainUtils.BlockchainV2 | undefined, version?: string): Promise<GetFeeQuoteResponse>;
+}
+export default HydrogenClient;

package/lib/clients/HydrogenClient.js

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HydrogenEndpoints = void 0;
+const constant_1 = require("../constant");
+const util_1 = require("../util");
+const blockchain_1 = require("../util/blockchain");
+const dayjs_1 = __importDefault(require("dayjs"));
+exports.HydrogenEndpoints = {
+    // Status api
+    stats: "/stats",
+    // Transfer Payloads api
+    transfer_payloads: "/transfer_payloads",
+    // Relays api
+    relays: "/relays",
+    // Fee service api
+    fee_quote: "/fee_quote",
+    // Bridge fees
+    bridge_fee: "/bridge_fee",
+};
+const formatDateField = (value) => {
+    if (typeof value !== "string")
+        return null;
+    return (0, dayjs_1.default)(value);
+};
+// temporary function to parse okt/okc blockchain
+// to remove when automatic deposit/withdraw feature is deployed
+const parseHydrogenBlockchain = (blockchain) => {
+    if (blockchain === "okx")
+        return util_1.BlockchainUtils.Blockchain.Okc;
+    return util_1.BlockchainUtils.parseBlockchain(blockchain);
+};
+const formatCrossChainTransfer = (value) => {
+    if (typeof value !== "object")
+        return value;
+    return {
+        ...value,
+        created_at: formatDateField(value.created_at?.toString()),
+        updated_at: formatDateField(value.updated_at?.toString()),
+        source_blockchain: parseHydrogenBlockchain(value.source_blockchain),
+        bridging_blockchain: parseHydrogenBlockchain(value.bridging_blockchain),
+        destination_blockchain: parseHydrogenBlockchain(value.destination_blockchain),
+        relay: formatRelaysTransfers(value.relay),
+    };
+};
+const formatCrossChainTransferDetailed = (value) => {
+    if (!value || typeof value !== "object")
+        return value;
+    return {
+        ...formatCrossChainTransfer(value),
+        source_event: formatChainEvent(value.source_event),
+        bridging_event: formatChainEvent(value.bridging_event),
+        destination_event: formatChainEvent(value.destination_event),
+    };
+};
+const formatRelaysTransfers = (value) => {
+    if (!value || typeof value !== "object")
+        return value;
+    return {
+        ...value,
+        created_at: formatDateField(value.created_at?.toString()),
+        updated_at: formatDateField(value.updated_at?.toString()),
+        source_blockchain: parseHydrogenBlockchain(value.source_blockchain),
+        destination_blockchain: parseHydrogenBlockchain(value.destination_blockchain),
+    };
+};
+const formatChainEvent = (value) => {
+    if (!value || typeof value !== "object")
+        return value;
+    return {
+        ...value,
+        confirmed_at: formatDateField(value.confirmed_at?.toString()),
+        created_at: formatDateField(value.created_at?.toString()),
+        updated_at: formatDateField(value.updated_at?.toString()),
+        blockchain: parseHydrogenBlockchain(value.blockchain),
+    };
+};
+const formatFeeQuote = (value) => {
+    if (typeof value !== "object")
+        return value;
+    return {
+        ...value,
+        blockchain: parseHydrogenBlockchain(value.blockchain),
+        created_at: formatDateField(value.created_at?.toString()),
+        expires_at: formatDateField(value.expires_at?.toString()),
+    };
+};
+const formatChainEventV2 = (value, blockchain) => {
+    if (!value || typeof value !== "object")
+        return value;
+    return {
+        ...value,
+        confirmed_at: formatDateField(value.confirmed_at?.toString()),
+        created_at: formatDateField(value.created_at?.toString()),
+        updated_at: formatDateField(value.updated_at?.toString()),
+        blockchain,
+    };
+};
+const formatFeeQuoteV2 = (value, blockchain) => {
+    if (typeof value !== "object")
+        return value;
+    return {
+        ...value,
+        blockchain,
+        created_at: formatDateField(value.created_at?.toString()),
+        expires_at: formatDateField(value.expires_at?.toString()),
+    };
+};
+const getBridgeBlockchainFromId = (bridgeId) => {
+    switch (bridgeId) {
+        case 1:
+            return 'Polynetwork';
+        case 2:
+            return 'Ibc';
+        case 3:
+            return 'Axelar';
+        default:
+            return 'Polynetwork';
+    }
+};
+class HydrogenClient {
+    constructor(config, tokenClient) {
+        this.config = config;
+        this.formatCrossChainTransferV2 = (value) => {
+            if (typeof value !== "object")
+                return value;
+            // brdg tokens will all be chain_id 0 which will also be deprecated in future
+            // hence for brdg tokens cannot use chain_id to differentiate between blockchains
+            const isBridgeToken = this.tokenClient.isBridgedToken(value.carbon_token_id);
+            return {
+                ...value,
+                created_at: formatDateField(value.created_at?.toString()),
+                updated_at: formatDateField(value.updated_at?.toString()),
+                source_blockchain: isBridgeToken ? (0, blockchain_1.getFormattedBlockchainName)(value.source_blockchain) : this.tokenClient.getBlockchainV2FromIDs(Number(value.from_chain_id), value.bridge_id),
+                bridging_blockchain: getBridgeBlockchainFromId(value.bridge_id),
+                destination_blockchain: isBridgeToken ? (0, blockchain_1.getFormattedBlockchainName)(value.destination_blockchain) : this.tokenClient.getBlockchainV2FromIDs(Number(value.to_chain_id), value.bridge_id),
+                source_event: formatChainEventV2(value.source_event, value.source_blockchain ?? ''),
+                bridging_event: formatChainEventV2(value.bridging_event, getBridgeBlockchainFromId(value.bridge_id)),
+                destination_event: formatChainEventV2(value.destination_event, value.destination_blockchain ?? ''),
+                relay: formatRelaysTransfers(value.relay),
+            };
+        };
+        this.formatCrossChainTransferDetailedV2 = (value) => {
+            if (!value || typeof value !== "object")
+                return value;
+            const isBridgeToken = this.tokenClient.isBridgedToken(value.carbon_token_id);
+            const source_blockchain = isBridgeToken ? (0, blockchain_1.getFormattedBlockchainName)(value.source_blockchain) : this.tokenClient.getBlockchainV2FromIDs(Number(value.from_chain_id), value.bridge_id);
+            const destination_blockchain = isBridgeToken ? (0, blockchain_1.getFormattedBlockchainName)(value.destination_blockchain) : this.tokenClient.getBlockchainV2FromIDs(Number(value.to_chain_id), value.bridge_id);
+            const bridging_blockchain = getBridgeBlockchainFromId(value.bridge_id);
+            return {
+                ...this.formatCrossChainTransferV2(value),
+                source_event: formatChainEventV2(value.source_event, source_blockchain ?? ''),
+                bridging_event: formatChainEventV2(value.bridging_event, bridging_blockchain),
+                destination_event: formatChainEventV2(value.destination_event, destination_blockchain ?? ''),
+            };
+        };
+        this.apiManager = new util_1.APIUtils.APIManager(config.hydrogenUrl, exports.HydrogenEndpoints);
+        this.tokenClient = tokenClient;
+    }
+    static instance(config, tokenClient) {
+        return new HydrogenClient(config, tokenClient);
+    }
+    checkState() {
+        if (!this.apiManager.apiPrefix?.length) {
+            if ([constant_1.Network.TestNet, constant_1.Network.LocalHost].includes(this.config.network))
+                throw new Error(`hydrogen service not available on ${this.config.network}`);
+            throw new Error("hydrogen api url is empty");
+        }
+    }
+    // Status api
+    async getStats() {
+        this.checkState();
+        const request = this.apiManager.path("stats");
+        const response = await request.get();
+        return response.data;
+    }
+    async getTransfers(req, version = "V1") {
+        this.checkState();
+        const request = this.apiManager.path("transfer_payloads", {}, { ...req });
+        const response = await request.get();
+        const result = response.data;
+        return {
+            ...result,
+            data: result.data.map(version === "V1" ? formatCrossChainTransfer : this.formatCrossChainTransferV2),
+        };
+    }
+    async getDetailedTransfers(req, version = "V1") {
+        this.checkState();
+        const request = this.apiManager.path("transfer_payloads", {}, {
+            ...req,
+            include_tx: true,
+        });
+        const response = await request.get();
+        const result = response.data;
+        return {
+            ...result,
+            data: result.data.map(version === "V1" ? formatCrossChainTransferDetailed : this.formatCrossChainTransferDetailedV2),
+        };
+    }
+    async getRelaysTransfers(req) {
+        this.checkState();
+        const request = this.apiManager.path("relays", {}, {
+            ...req,
+            include_tx: true,
+        });
+        const response = await request.get();
+        const result = response.data;
+        return {
+            ...result,
+            data: result.data.map(formatRelaysTransfers),
+        };
+    }
+    async getFeeQuote(req, blockchain = undefined, version = "V1") {
+        this.checkState();
+        const request = this.apiManager.path("fee_quote", {}, {
+            ...req,
+        });
+        const response = await request.post({ body: { fee_denoms: req.fee_denoms } });
+        const result = response.data;
+        return version === "V1" ? formatFeeQuote(result) : formatFeeQuoteV2(result, blockchain);
+    }
+}
+exports.default = HydrogenClient;

package/lib/clients/InsightsQueryClient.d.ts

@@ -0,0 +1,77 @@
+import { NetworkConfig } from "../constant";
+import { Insights } from "../index";
+import { ConnectedWalletParams, ConnectedWalletResponse, CrossChainVolume, InsightsQueryResponse } from "../insights";
+import { APIUtils } from "../util";
+declare class InsightsQueryClient {
+    readonly apiManager: APIUtils.APIManager<typeof Insights.InsightsEndpoints>;
+    constructor(config: NetworkConfig);
+    parseResponse(response: Response): Promise<APIUtils.RequestResult>;
+    Stake(req?: Insights.QueryGetStakeRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetStakeResponse>>;
+    Transaction(req?: Insights.QueryGetTransactionRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetTransactionResponse>>;
+    AvgBlockTime(req: Insights.QueryGetAvgBlockTimeRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetAvgBlockTimeResponse>>;
+    Inflation(): Promise<Insights.InsightsQueryResponse<Insights.QueryGetInflation>>;
+    ActiveAccounts(req?: Insights.QueryGetActiveAccountsRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetActiveAccountsResponse>>;
+    UserProfile(req: Insights.QueryGetUserProfileRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetUserProfileResponse>>;
+    UserGrowth(req?: Insights.QueryGetUserGrowthRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetUserGrowthResponse>>;
+    UserVolume(req: Insights.QueryGetUserVolumePathParams, query: Insights.QueryGetUserVolumeQueryParams): Promise<Insights.InsightsQueryResponse<Insights.QueryGetUserVolumeResponse>>;
+    TotalUsers(req?: Insights.QueryGetTotalUsersRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetTotalUsersResponse>>;
+    UserPnl(req: Insights.QueryGetUserPnlPathParams, query: Insights.QueryGetUserPnlGraphQueryParams): Promise<Insights.InsightsQueryResponse<Insights.QueryGetUserPnlResponse>>;
+    UserBalanceGraph(req: Insights.QueryGetUserBalanceGraphPathParams, query: Insights.QueryGetUserBalanceGraphQueryParams): Promise<Insights.InsightsQueryResponse<Insights.QueryGetUserBalanceGraphResponse>>;
+    UserPnlGraph(req: Insights.QueryGetUserPnlGraphPathParams, query: Insights.QueryGetUserPnlGraphQueryParams): Promise<Insights.InsightsQueryResponse<Insights.QueryGetUserPnlGraphResponse>>;
+    UserFundings(req: Insights.QueryGetUserFundingsPathParams, query: Insights.QueryGetUserFundingsQueryParams): Promise<Insights.InsightsQueryResponse<Insights.QueryGetUserFundingsResponse>>;
+    UserFundingBreakdown(req: Insights.QueryGetFundingBreakdownChartPathParams, query: Insights.QueryGetFundingBreakdownChartQueryParams): Promise<Insights.InsightsQueryResponse<Insights.QueryGetFundingBreakdownChartResponse>>;
+    Pools(req?: Insights.QueryGetPoolsRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetPoolsResponse>>;
+    PoolHistory(query: Insights.QueryGetPoolHistoryRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetPoolHistoryResponse>>;
+    PerpPoolHistory(query: Insights.QueryGetPerpPoolHistoryRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetPerpPoolHistoryResponse>>;
+    PerpPoolApy(query: Insights.QueryVaultAPY): Promise<Insights.InsightsQueryResponse<Insights.QueryVaultAPYResponse>>;
+    UserVaultApy(query: Insights.QueryVaultAPY): Promise<Insights.InsightsQueryResponse<Insights.QueryVaultAPYResponse>>;
+    UserVaultDepositors(query: Insights.QueryUserVaultDepositors): Promise<Insights.InsightsQueryResponse<Insights.QueryUserVaultDepositorsResponse>>;
+    UserVaultActions(query: Insights.QueryUserVaultActions): Promise<Insights.InsightsQueryResponse<Insights.QueryUserVaultActionsResponse>>;
+    UserVaultDepositorActions(query: Insights.QueryVaultDepositorActions): Promise<Insights.InsightsQueryResponse<Insights.QueryVaultDepositorActionsResponse>>;
+    PerpPoolDepositorActions(query: Insights.QueryVaultDepositorActions): Promise<Insights.InsightsQueryResponse<Insights.QueryVaultDepositorActionsResponse>>;
+    UserVaultDepositorDeposits(query: Insights.QueryUserVaultDepositorDeposits): Promise<Insights.InsightsQueryResponse<Insights.QueryUserVaultDepositorDepositsResponse>>;
+    PoolVolume(req: Insights.QueryGetPoolVolumeRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetPoolVolumeResponse>>;
+    PoolsVolume(req?: Insights.QueryGetPoolsVolumeRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetPoolsVolumeResponse>>;
+    UserRewardsClaimHistory(req: Insights.QueryGetUserRewardsClaimHistoryRequest): Promise<InsightsQueryResponse<Insights.QueryGetUserRewardsClaimHistoryResponse>>;
+    UserWalletConnected(body: ConnectedWalletParams): Promise<ConnectedWalletResponse>;
+    CompetitionList(req?: Insights.QueryGetCompetitionListRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetCompetitionListResponse>>;
+    /**
+     * endpoint for legacy Demex Trading volume Competition (circa. 2021-2022). Keeping this here as endpoint has not been removed.
+     */
+    VolumeCompetitionLeaderboard(req: Insights.QueryGetVolumeCompetitionLeaderboardRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetVolumeCompetitionLeaderboardResponse>>;
+    /**
+     * endpoint for Perps Trading Competition on Demex (14 Nov 2023 - 28 Nov 2023).
+    */
+    PerpsTradingCompetitionVolume(req: Insights.QueryGetPerpsCompTradingVolumeRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetPerpsCompTradingVolumeResponse>>;
+    PNLCompetitionLeaderboard(req: Insights.QueryGetPNLCompetitionLeaderboardRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetPNLCompetitionLeaderboardResponse>>;
+    LotteryCompetitionLeaderboard(req: Insights.QueryGetLotteryCompetitionLeaderboardRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetLotteryCompetitionLeaderboardResponse>>;
+    LeagueCompetitionLeaderboard(req: Insights.QueryGetLeagueCompetitionLeaderboardRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetLeagueCompetitionLeaderboardResponse>>;
+    CosmosCompetitionLeaderboard(req: Insights.QueryGetCosmosCompetitionLeaderboardRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetCosmosCompetitionLeaderboardResponse>>;
+    PoolsLiquidity(req?: Insights.QueryGetPoolsLiquidityRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetPoolsLiquidityResponse>>;
+    MarketsVolume(req?: Insights.QueryGetMarketVolumeRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetMarketVolumeResponse>>;
+    CarbonCreditsRewards(req: Insights.QueryCarbonCreditsRewardsRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryCarbonCreditsRewardsResponse>>;
+    PnlLeaderboard(req: Insights.QueryPnlLeaderboardRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryPnlLeaderboardResponse>>;
+    Nodes(req?: Insights.QueryGetNodesRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetNodesResponse>>;
+    BalanceTotal(req: Insights.QueryGetTotalBalanceRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetTotalBalanceResponse>>;
+    BalanceList(req: Insights.QueryGetBalanceListRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetBalanceListResponse>>;
+    BalanceChange(req: Insights.QueryGetBalanceChangeRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetBalanceChangeResponse>>;
+    BalanceHistory(req: Insights.QueryGetBalanceHistoryRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetBalanceHistoryResponse>>;
+    BalanceSupply(): Promise<Insights.InsightsQueryResponse<Insights.QueryGetBalanceSupplyResponse>>;
+    BalanceDistribution(req?: Insights.QueryGetBalanceDistributionRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetBalanceDistributionResponse>>;
+    LiquidationEngine(query: Insights.GetLiquidationEngineParams): Promise<Insights.InsightsQueryResponse<Insights.QueryGetLiquidationEngineResponse>>;
+    LiquidationAndADL(query: Insights.GetLiquidationAndADLQueryParams): Promise<Insights.InsightsQueryResponse<Insights.QueryGetLiquidationAndADLResponse>>;
+    PositionsView(req: Insights.GetPositionsViewPathParams, query: Insights.GetPositionsViewQueryParams): Promise<Insights.InsightsQueryResponse<Insights.QueryGetPositionsViewResponse>>;
+    Leaderboard(req: Insights.GetLeaderboardPathParams, query: Insights.GetLeaderboardQueryParams): Promise<Insights.InsightsQueryResponse<Insights.QueryGetLeaderboardResponse>>;
+    PositionStats(req: Insights.GetPositionStatsPathParams, query: Insights.GetPositionStatsQueryParams): Promise<Insights.InsightsQueryResponse<Insights.QueryGetPositionStatsResponse>>;
+    DenomToGeckoIdMap(): Promise<Insights.InsightsQueryResponse<Insights.QueryDenomToGeckoIdMap>>;
+    FundingHistory(query: Insights.QueryGetFundingHistoryRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetFundingHistoryResponse>>;
+    HistoricalFundingHistory(query: Insights.QueryGetFundingRateRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetFundingRateResponse>>;
+    FundingHistoryGraphData(query: Insights.QueryGetFundingHistoryGraphDataRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetFundingHistoryGraphDataResponse>>;
+    ProposalVotes(req: Insights.GetProposalVotesPathParams, query: Insights.GetProposalVotesQueryParams): Promise<Insights.InsightsQueryResponse<Insights.QueryGetProposalVotesResponse>>;
+    Delegations(req: Insights.GetDelegationsPathParams, query: Insights.GetDelegationsQueryParams): Promise<Insights.InsightsQueryResponse<Insights.QueryGetDelegationsResponse>>;
+    OraclePrices(req?: Insights.QueryGetOraclesPriceRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetOraclesPriceResponse>>;
+    AlliancesStake(req?: Insights.QueryGetAlliancesStakeRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetAlliancesStakeResponse>>;
+    AlliancesRewards(req?: Insights.QueryGetAlliancesRewardsRequest): Promise<Insights.InsightsQueryResponse<Insights.QueryGetAlliancesRewardsResponse>>;
+    CrosschainVolumes(req?: Insights.QueryCrosschainVolumeRequest): Promise<Insights.InsightsQueryResponse<CrossChainVolume[]>>;
+}
+export default InsightsQueryClient;