@injectivelabs/sdk-ts 1.15.0 → 1.15.2

package/dist/cjs/client/indexer/transformers/IndexerGrpcExplorerTransformer.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcExplorerTransformer = void 0;
+const index_js_1 = require("../../../utils/index.js");
+/**
+ * @category Indexer Grpc Transformer
+ */
+class IndexerGrpcExplorerTransformer {
+    static getTxByTxHashResponseToTx(tx) {
+        return IndexerGrpcExplorerTransformer.grpcTransactionToTransaction(tx);
+    }
+    static getAccountTxsResponseToAccountTxs(response) {
+        const txs = response.data;
+        const pagination = response.paging;
+        return {
+            txs: IndexerGrpcExplorerTransformer.grpcTransactionsToTransactionsFromDetail(txs),
+            pagination: (0, index_js_1.grpcPagingToPaging)(pagination),
+        };
+    }
+    static getValidatorUptimeResponseToValidatorUptime(response) {
+        const data = response.data;
+        return data.map((field) => IndexerGrpcExplorerTransformer.grpcValidatorUptimeToValidatorUptime(field));
+    }
+    static getPeggyDepositTxsResponseToPeggyDepositTxs(response) {
+        return response.field.map((field) => IndexerGrpcExplorerTransformer.grpcPeggyDepositTx(field));
+    }
+    static getPeggyWithdrawalTxsResponseToPeggyWithdrawalTxs(response) {
+        return response.field.map((field) => IndexerGrpcExplorerTransformer.grpcPeggyWithdrawalTx(field));
+    }
+    static getIBCTransferTxsResponseToIBCTransferTxs(response) {
+        return response.field.map((field) => IndexerGrpcExplorerTransformer.grpcIBCTransferTxToIBCTransferTx(field));
+    }
+    static validatorResponseToValidator(validator) {
+        const data = validator.data;
+        return {
+            id: data.id,
+            moniker: data.moniker,
+            operatorAddress: data.operatorAddress,
+            consensusAddress: data.consensusAddress,
+            jailed: data.jailed,
+            status: data.status,
+            tokens: data.tokens,
+            delegatorShares: data.delegatorShares,
+            description: IndexerGrpcExplorerTransformer.grpcValidatorDescriptionToValidatorDescription(data.description),
+            unbondingHeight: parseInt(data.unbondingHeight, 10),
+            unbondingTime: data.unbondingTime,
+            commissionRate: data.commissionRate,
+            commissionMaxRate: data.commissionMaxRate,
+            commissionMaxChangeRate: data.commissionMaxChangeRate,
+            commissionUpdateTime: data.commissionUpdateTime,
+            proposed: parseInt(data.proposed, 10),
+            signed: parseInt(data.signed, 10),
+            missed: parseInt(data.missed, 10),
+            uptimePercentage: data.uptimePercentage,
+            imageUrl: data.imageUrl,
+            timestamp: data.timestamp,
+            uptimesList: data.uptimes.map(IndexerGrpcExplorerTransformer.grpcValidatorUptimeToValidatorUptime),
+            slashingEventsList: data.slashingEvents.map(IndexerGrpcExplorerTransformer.grpcValidatorSlashingEventToValidatorSlashingEvent),
+        };
+    }
+    static streamTxResponseToTxs(response) {
+        return {
+            id: response.id,
+            blockNumber: parseInt(response.blockNumber, 10),
+            blockTimestamp: response.blockTimestamp,
+            hash: response.hash,
+            codespace: response.codespace,
+            messages: response.messages,
+            txNumber: parseInt(response.txNumber, 10),
+            errorLog: response.errorLog,
+            code: response.code,
+        };
+    }
+    static grpcGasFeeToGasFee(gasFee) {
+        const amounts = gasFee.amount.map((amount) => ({
+            amount: amount.amount,
+            denom: amount.denom,
+        }));
+        return {
+            amounts,
+            gasLimit: parseInt(gasFee.gasLimit, 10),
+            payer: gasFee.payer,
+            granter: gasFee.granter,
+        };
+    }
+    static grpcTransactionToBankMsgSendTransaction(tx) {
+        const data = tx.data;
+        const [message] = JSON.parse(Buffer.from(data.messages).toString());
+        return {
+            blockNumber: parseInt(data.blockNumber, 10),
+            blockTimestamp: data.blockTimestamp,
+            hash: data.hash,
+            amount: message.value.amount[0].amount,
+            denom: message.value.amount[0].denom,
+            sender: message.value.from_address,
+            receiver: message.value.to_address,
+        };
+    }
+    static grpcTransactionToTransaction(tx) {
+        const data = tx.data;
+        return {
+            id: data.id,
+            blockNumber: parseInt(data.blockNumber, 10),
+            blockTimestamp: data.blockTimestamp,
+            hash: data.hash,
+            code: data.code,
+            info: data.info,
+            gasWanted: parseInt(data.gasWanted, 10),
+            gasUsed: parseInt(data.gasUsed, 10),
+            codespace: data.codespace,
+            data: data.data,
+            gasFee: IndexerGrpcExplorerTransformer.grpcGasFeeToGasFee(data.gasFee),
+            txType: data.txType,
+            signatures: data.signatures.map((signature) => ({
+                pubkey: signature.pubkey,
+                address: signature.address,
+                sequence: parseInt(signature.sequence, 10),
+                signature: signature.signature,
+            })),
+            events: data.events.map((event) => ({
+                type: event.type,
+                attributes: event.attributes,
+            })),
+            messages: JSON.parse(Buffer.from(data.messages).toString()),
+        };
+    }
+    static grpcTransactionsToTransactions(txs) {
+        return txs.map((tx) => IndexerGrpcExplorerTransformer.grpcTransactionToTransaction(tx));
+    }
+    static grpcTransactionToTransactionFromDetail(tx) {
+        const messages = JSON.parse(Buffer.from(tx.messages).toString('utf8'));
+        return {
+            ...tx,
+            gasWanted: parseInt(tx.gasWanted, 10),
+            gasUsed: parseInt(tx.gasUsed, 10),
+            blockNumber: parseInt(tx.blockNumber, 10),
+            signatures: tx.signatures.map((signature) => ({
+                pubkey: signature.pubkey,
+                address: signature.address,
+                sequence: parseInt(signature.sequence, 10),
+                signature: signature.signature,
+            })),
+            gasFee: tx.gasFee
+                ? IndexerGrpcExplorerTransformer.grpcGasFeeToGasFee(tx.gasFee)
+                : {
+                    gasLimit: 0,
+                    payer: '',
+                    granter: '',
+                    amounts: [],
+                },
+            events: tx.events.map((event) => ({
+                type: event.type,
+                attributes: event.attributes,
+            })),
+            messages,
+        };
+    }
+    static grpcTransactionsToTransactionsFromDetail(txs) {
+        return txs.map(IndexerGrpcExplorerTransformer.grpcTransactionToTransactionFromDetail);
+    }
+    static grpcBlockToBlock(block) {
+        return {
+            height: parseInt(block.height, 10),
+            proposer: block.proposer,
+            moniker: block.moniker,
+            blockHash: block.blockHash,
+            parentHash: block.parentHash,
+            numPreCommits: parseInt(block.numPreCommits, 10),
+            numTxs: parseInt(block.numTxs, 10),
+            timestamp: block.timestamp,
+        };
+    }
+    static grpcBlockToBlockWithTxs(block) {
+        return {
+            height: parseInt(block.height, 10),
+            proposer: block.proposer,
+            moniker: block.moniker,
+            blockHash: block.blockHash,
+            parentHash: block.parentHash,
+            numPreCommits: parseInt(block.numPreCommits, 10),
+            numTxs: parseInt(block.numTxs, 10),
+            timestamp: block.timestamp,
+        };
+    }
+    static grpcBlocksToBlocks(blocks) {
+        return blocks.map((block) => IndexerGrpcExplorerTransformer.grpcBlockToBlock(block));
+    }
+    static grpcBlocksToBlocksWithTxs(blocks) {
+        return blocks.map((block) => IndexerGrpcExplorerTransformer.grpcBlockToBlockWithTxs(block));
+    }
+    static grpcValidatorDescriptionToValidatorDescription(validatorDescription) {
+        return {
+            moniker: validatorDescription.moniker,
+            identity: validatorDescription.identity,
+            website: validatorDescription.website,
+            securityContact: validatorDescription.securityContact,
+            details: validatorDescription.details,
+        };
+    }
+    static grpcValidatorUptimeToValidatorUptime(validatorUptime) {
+        return {
+            blockNumber: parseInt(validatorUptime.blockNumber, 10),
+            status: validatorUptime.status,
+        };
+    }
+    static grpcValidatorSlashingEventToValidatorSlashingEvent(validatorUptime) {
+        return {
+            blockNumber: parseInt(validatorUptime.blockNumber, 10),
+            blockTimestamp: validatorUptime.blockTimestamp,
+            address: validatorUptime.address,
+            power: parseInt(validatorUptime.power, 10),
+            reason: validatorUptime.reason,
+            jailed: validatorUptime.jailed,
+            missedBlocks: parseInt(validatorUptime.missedBlocks, 10),
+        };
+    }
+    static grpcIBCTransferTxToIBCTransferTx(grpcIBCTransferTx) {
+        return {
+            sender: grpcIBCTransferTx.sender,
+            receiver: grpcIBCTransferTx.receiver,
+            sourcePort: grpcIBCTransferTx.sourcePort,
+            sourceChannel: grpcIBCTransferTx.sourceChannel,
+            destinationPort: grpcIBCTransferTx.destinationPort,
+            destinationChannel: grpcIBCTransferTx.destinationChannel,
+            amount: grpcIBCTransferTx.amount,
+            denom: grpcIBCTransferTx.denom,
+            timeoutHeight: grpcIBCTransferTx.timeoutHeight,
+            timeoutTimestamp: parseInt(grpcIBCTransferTx.timeoutTimestamp, 10),
+            packetSequence: parseInt(grpcIBCTransferTx.packetSequence, 10),
+            dataHex: grpcIBCTransferTx.dataHex,
+            state: grpcIBCTransferTx.state,
+            txHashesList: grpcIBCTransferTx.txHashes,
+            createdAt: grpcIBCTransferTx.createdAt,
+            updatedAt: grpcIBCTransferTx.updatedAt,
+        };
+    }
+    static grpcPeggyDepositTx(grpcPeggyDepositTx) {
+        return {
+            sender: grpcPeggyDepositTx.sender,
+            receiver: grpcPeggyDepositTx.receiver,
+            eventNonce: parseInt(grpcPeggyDepositTx.eventNonce, 10),
+            eventHeight: parseInt(grpcPeggyDepositTx.eventHeight, 10),
+            amount: grpcPeggyDepositTx.amount,
+            denom: grpcPeggyDepositTx.denom,
+            orchestratorAddress: grpcPeggyDepositTx.orchestratorAddress,
+            state: grpcPeggyDepositTx.state,
+            claimType: grpcPeggyDepositTx.claimType,
+            txHashesList: grpcPeggyDepositTx.txHashes,
+            createdAt: grpcPeggyDepositTx.createdAt,
+            updatedAt: grpcPeggyDepositTx.updatedAt,
+        };
+    }
+    static grpcPeggyWithdrawalTx(grpcPeggyWithdrawalTx) {
+        return {
+            sender: grpcPeggyWithdrawalTx.sender,
+            receiver: grpcPeggyWithdrawalTx.receiver,
+            amount: grpcPeggyWithdrawalTx.amount,
+            denom: grpcPeggyWithdrawalTx.denom,
+            bridgeFee: grpcPeggyWithdrawalTx.bridgeFee,
+            outgoingTxId: parseInt(grpcPeggyWithdrawalTx.outgoingTxId, 10),
+            batchTimeout: parseInt(grpcPeggyWithdrawalTx.batchTimeout, 10),
+            batchNonce: parseInt(grpcPeggyWithdrawalTx.batchNonce, 10),
+            eventNonce: parseInt(grpcPeggyWithdrawalTx.eventNonce, 10),
+            eventHeight: parseInt(grpcPeggyWithdrawalTx.eventHeight, 10),
+            orchestratorAddress: grpcPeggyWithdrawalTx.orchestratorAddress,
+            state: grpcPeggyWithdrawalTx.state,
+            claimType: grpcPeggyWithdrawalTx.claimType,
+            txHashesList: grpcPeggyWithdrawalTx.txHashes,
+            createdAt: grpcPeggyWithdrawalTx.createdAt,
+            updatedAt: grpcPeggyWithdrawalTx.updatedAt,
+        };
+    }
+    static getExplorerStatsResponseToExplorerStats(response) {
+        return {
+            assets: response.assets,
+            txsTotal: response.txsTotal,
+            addresses: response.addresses,
+            injSupply: response.injSupply,
+            txsInPast24Hours: response.txs24H,
+            txsInPast30Days: response.txs30D,
+            blockCountInPast24Hours: response.blockCount24H,
+            txsPerSecondInPast24Hours: response.txsPs24H,
+            txsPerSecondInPast100Blocks: response.txsPs100B,
+        };
+    }
+}
+exports.IndexerGrpcExplorerTransformer = IndexerGrpcExplorerTransformer;

package/dist/cjs/client/indexer/transformers/IndexerGrpcInsuranceFundTransformer.d.ts

@@ -0,0 +1,13 @@
+import { IndexerInsuranceFund, GrpcIndexerInsuranceFund, GrpcIndexerRedemptionSchedule, Redemption } from '../types/insurance-funds.js';
+import { InjectiveInsuranceRpc } from '@injectivelabs/indexer-proto-ts';
+/**
+ * @category Indexer Grpc Transformer
+ */
+export declare class IndexerGrpcInsuranceFundTransformer {
+    static insuranceFundsResponseToInsuranceFunds(response: InjectiveInsuranceRpc.FundsResponse): IndexerInsuranceFund[];
+    static redemptionsResponseToRedemptions(response: InjectiveInsuranceRpc.RedemptionsResponse): Redemption[];
+    static grpcInsuranceFundToInsuranceFund(grpcInsuranceFund: GrpcIndexerInsuranceFund): IndexerInsuranceFund;
+    static grpcInsuranceFundsToInsuranceFunds(grpcInsuranceFunds: GrpcIndexerInsuranceFund[]): IndexerInsuranceFund[];
+    static grpcRedemptionToRedemption(redemption: GrpcIndexerRedemptionSchedule): Redemption;
+    static grpcRedemptionsToRedemptions(redemptions: GrpcIndexerRedemptionSchedule[]): Redemption[];
+}

package/dist/cjs/client/indexer/transformers/IndexerGrpcInsuranceFundTransformer.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcInsuranceFundTransformer = void 0;
+/**
+ * @category Indexer Grpc Transformer
+ */
+class IndexerGrpcInsuranceFundTransformer {
+    static insuranceFundsResponseToInsuranceFunds(response) {
+        const insuranceFunds = response.funds;
+        return IndexerGrpcInsuranceFundTransformer.grpcInsuranceFundsToInsuranceFunds(insuranceFunds);
+    }
+    static redemptionsResponseToRedemptions(response) {
+        const redemptions = response.redemptionSchedules;
+        return IndexerGrpcInsuranceFundTransformer.grpcRedemptionsToRedemptions(redemptions);
+    }
+    static grpcInsuranceFundToInsuranceFund(grpcInsuranceFund) {
+        const redemptionNoticePeriodDuration = grpcInsuranceFund.redemptionNoticePeriodDuration;
+        const tokenMeta = grpcInsuranceFund.depositTokenMeta;
+        const depositDenom = grpcInsuranceFund.depositDenom;
+        return {
+            depositDenom,
+            insurancePoolTokenDenom: grpcInsuranceFund.poolTokenDenom,
+            redemptionNoticePeriodDuration: parseInt(redemptionNoticePeriodDuration || '0', 10),
+            balance: grpcInsuranceFund.balance,
+            totalShare: grpcInsuranceFund.totalShare,
+            depositTokenMeta: tokenMeta,
+            marketId: grpcInsuranceFund.marketId,
+            marketTicker: grpcInsuranceFund.marketTicker,
+            oracleBase: grpcInsuranceFund.oracleBase,
+            oracleQuote: grpcInsuranceFund.oracleQuote,
+            oracleType: parseInt(grpcInsuranceFund.oracleType),
+            expiry: parseInt(grpcInsuranceFund.expiry, 10),
+        };
+    }
+    static grpcInsuranceFundsToInsuranceFunds(grpcInsuranceFunds) {
+        return grpcInsuranceFunds.map(IndexerGrpcInsuranceFundTransformer.grpcInsuranceFundToInsuranceFund);
+    }
+    static grpcRedemptionToRedemption(redemption) {
+        return {
+            redemptionId: parseInt(redemption.redemptionId, 10),
+            status: redemption.status,
+            redeemer: redemption.redeemer,
+            claimableRedemptionTime: parseInt(redemption.claimableRedemptionTime, 10),
+            redemptionAmount: redemption.redemptionAmount,
+            redemptionDenom: redemption.redemptionDenom,
+            requestedAt: parseInt(redemption.requestedAt, 10),
+            disbursedAmount: redemption.disbursedAmount,
+            disbursedDenom: redemption.disbursedDenom,
+            disbursedAt: parseInt(redemption.disbursedAt, 10),
+        };
+    }
+    static grpcRedemptionsToRedemptions(redemptions) {
+        return redemptions.map(IndexerGrpcInsuranceFundTransformer.grpcRedemptionToRedemption);
+    }
+}
+exports.IndexerGrpcInsuranceFundTransformer = IndexerGrpcInsuranceFundTransformer;

package/dist/cjs/client/indexer/transformers/IndexerGrpcMitoStreamTransformer.d.ts

@@ -0,0 +1,44 @@
+import { MitoApi } from '@injectivelabs/mito-proto-ts';
+import { StreamOperation } from '../../../types/index.js';
+/**
+ * @category Indexer Stream Transformer
+ */
+export declare class IndexerGrpcMitoStreamTransformer {
+    static transfersStreamCallback: (response: MitoApi.StreamTransfersResponse) => {
+        transfer: import("../index.js").MitoTransfer | undefined;
+        opType: StreamOperation;
+    };
+    static vaultStreamCallback: (response: MitoApi.StreamVaultResponse) => {
+        vault: import("../index.js").MitoVault | undefined;
+        opType: StreamOperation;
+    };
+    static vaultHolderSubscriptionStreamCallback: (response: MitoApi.StreamHolderSubscriptionResponse) => {
+        subscription: import("../index.js").MitoSubscription | undefined;
+        opType: StreamOperation;
+    };
+    static stakingRewardByAccountStreamCallback: (response: MitoApi.StreamStakingRewardByAccountResponse) => {
+        stakingReward: {
+            apr: number;
+            vaultName: string;
+            vaultAddress: string;
+            lockTimestamp: number;
+            claimableRewards: import("@injectivelabs/ts-types").Coin[];
+            stakedAmount: import("@injectivelabs/ts-types").Coin | undefined;
+            lockedAmount: import("@injectivelabs/ts-types").Coin | undefined;
+        } | undefined;
+        opType: StreamOperation;
+    };
+    static historicalStakingStreamCallback: (response: MitoApi.StreamHistoricalStakingResponse) => {
+        historicalStaking: {
+            action: string;
+            txHash: string;
+            staker: string;
+            vaultAddress: string;
+            numberByAccount: number;
+            timestamp: number;
+            rewardedTokens: import("@injectivelabs/ts-types").Coin[];
+            stakeAmount: import("@injectivelabs/ts-types").Coin | undefined;
+        } | undefined;
+        opType: StreamOperation;
+    };
+}

package/dist/cjs/client/indexer/transformers/IndexerGrpcMitoStreamTransformer.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcMitoStreamTransformer = void 0;
+const IndexerGrpcMitoTransformer_js_1 = require("./IndexerGrpcMitoTransformer.js");
+/**
+ * @category Indexer Stream Transformer
+ */
+class IndexerGrpcMitoStreamTransformer {
+    static transfersStreamCallback = (response) => ({
+        transfer: response.data
+            ? IndexerGrpcMitoTransformer_js_1.IndexerGrpcMitoTransformer.mitoTransferHistoryToTransferHistory(response.data)
+            : undefined,
+        opType: response.opType,
+    });
+    static vaultStreamCallback = (response) => ({
+        vault: response.data
+            ? IndexerGrpcMitoTransformer_js_1.IndexerGrpcMitoTransformer.mitoVaultToVault(response.data)
+            : undefined,
+        opType: response.opType,
+    });
+    static vaultHolderSubscriptionStreamCallback = (response) => ({
+        subscription: response.data
+            ? IndexerGrpcMitoTransformer_js_1.IndexerGrpcMitoTransformer.mitoSubscriptionToSubscription(response.data)
+            : undefined,
+        opType: response.opType,
+    });
+    static stakingRewardByAccountStreamCallback = (response) => ({
+        stakingReward: response.data
+            ? IndexerGrpcMitoTransformer_js_1.IndexerGrpcMitoTransformer.mitoStakingRewardToStakingReward(response.data)
+            : undefined,
+        opType: response.opType,
+    });
+    static historicalStakingStreamCallback = (response) => ({
+        historicalStaking: response.data
+            ? IndexerGrpcMitoTransformer_js_1.IndexerGrpcMitoTransformer.mitoStakingActivityToStakingActivity(response.data)
+            : undefined,
+        opType: response.opType,
+    });
+}
+exports.IndexerGrpcMitoStreamTransformer = IndexerGrpcMitoStreamTransformer;

package/dist/cjs/client/indexer/transformers/IndexerGrpcMitoTransformer.d.ts

@@ -0,0 +1,137 @@
+import { MitoApi } from '@injectivelabs/mito-proto-ts';
+import { MitoIDO, MitoGauge, MitoVault, MitoHolders, MitoChanges, MitoMission, MitoTransfer, MitoTokenInfo, MitoPortfolio, MitoPagination, MitoIDOProgress, MitoStakingPool, MitoLeaderboard, MitoVestingConfig, MitoDenomBalance, MitoSubscription, MitoIDOSubscriber, MitoPriceSnapshot, MitoClaimReference, MitoIDOSubscription, MitoVestingConfigMap, MitoWhitelistAccount, MitoLeaderboardEpoch, MitoSubaccountBalance, MitoMissionLeaderboard, MitoStakeToSubscription, MitoIDOSubscriptionActivity, MitoMissionLeaderboardEntry, MitoIDOClaimedCoins } from '../types/mito.js';
+/**
+ * @category Indexer Grpc Transformer
+ */
+export declare class IndexerGrpcMitoTransformer {
+    static grpcTokenInfoToTokenInfo(tokenInfo: MitoApi.TokenInfo): MitoTokenInfo;
+    static mitoPaginationToPagination(pagination?: MitoApi.Pagination): MitoPagination | undefined;
+    static mitoDenomBalanceToDenomBalance(denomBalance: MitoApi.DenomBalance): MitoDenomBalance;
+    static changesResponseToChanges(changes?: MitoApi.Changes): MitoChanges | undefined;
+    static mitoSubaccountInfoToSubaccountInfo(mitoSubaccountInfo?: MitoApi.SubaccountBalance): MitoSubaccountBalance | undefined;
+    static mitoVaultToVault(vault: MitoApi.Vault): MitoVault;
+    static mitoPriceSnapshotToPriceSnapshot(snapshot: MitoApi.PriceSnapshot): MitoPriceSnapshot;
+    static portfolioResponseToPortfolio(portfolio: MitoApi.PortfolioResponse): MitoPortfolio;
+    static leaderboardResponseToLeaderboard(leaderboard: MitoApi.LeaderboardResponse): MitoLeaderboard;
+    static mitoTransferHistoryToTransferHistory(transfer: MitoApi.Transfer): MitoTransfer;
+    static mitoLeaderboardEpochToLeaderboardEpoch(leaderboardEpoch: MitoApi.LeaderboardEpoch): MitoLeaderboardEpoch;
+    static mitoStakingRewardToStakingReward(stakingReward: MitoApi.StakingReward): {
+        apr: number;
+        vaultName: string;
+        vaultAddress: string;
+        lockTimestamp: number;
+        claimableRewards: import("@injectivelabs/ts-types").Coin[];
+        stakedAmount: import("@injectivelabs/ts-types").Coin | undefined;
+        lockedAmount: import("@injectivelabs/ts-types").Coin | undefined;
+    };
+    static mitoGaugeToGauge(gauge: MitoApi.Gauge): MitoGauge;
+    static mitoStakingPoolToStakingPool(stakingPool: MitoApi.StakingPool): MitoStakingPool;
+    static mitoStakingActivityToStakingActivity(stakingActivity: MitoApi.StakingActivity): {
+        action: string;
+        txHash: string;
+        staker: string;
+        vaultAddress: string;
+        numberByAccount: number;
+        timestamp: number;
+        rewardedTokens: import("@injectivelabs/ts-types").Coin[];
+        stakeAmount: import("@injectivelabs/ts-types").Coin | undefined;
+    };
+    static mitoSubscriptionToSubscription(subscription: MitoApi.Subscription): MitoSubscription;
+    static mitoLpHolderToLPHolder(holder: MitoApi.Holders): MitoHolders;
+    static mitoMissionToMission(mission: MitoApi.Mission): MitoMission;
+    static mitoMissionLeaderboardEntryToMissionLeaderboardEntry(entry: MitoApi.MissionLeaderboardEntry): MitoMissionLeaderboardEntry;
+    static mitoIDOProgressToIDOProgress(progress: MitoApi.IDOProgress): MitoIDOProgress;
+    static mitoStakedToSubscriptionToStakedToSubscription(data: MitoApi.ArrayOfString): MitoStakeToSubscription;
+    static mitoIDOToIDO(IDO: MitoApi.IDO): MitoIDO;
+    static mitoIDOSubscriberToIDOSubscriber(IDOSubscriber: MitoApi.IDOSubscriber): MitoIDOSubscriber;
+    static mitoIDOClaimedCoinsToIDOClaimedCoins(claimedCoins: MitoApi.IDOClaimedCoins): MitoIDOClaimedCoins;
+    static mitoIDOSubscriptionToIDOSubscription(subscription: MitoApi.IDOSubscription): MitoIDOSubscription;
+    static mitoIDOSubscriptionActivityToIDOSubscriptionActivity(IDOSubscriptionActivity: MitoApi.IDOSubscriptionActivity): MitoIDOSubscriptionActivity;
+    static mitoWhitelistAccountToWhitelistAccount(account: MitoApi.WhitelistAccount): MitoWhitelistAccount;
+    static mitoClaimReferenceToClaimReference(claimReference: MitoApi.ClaimReference): MitoClaimReference;
+    static mitoVestingCOonfigToVestingConfig(config?: MitoApi.VestingConfig): MitoVestingConfig;
+    static mitoIDOInitParamsToIDOVestingConfig(initParams?: MitoApi.InitParams): MitoVestingConfigMap | undefined;
+    static vaultResponseToVault(response: MitoApi.GetVaultResponse): MitoVault;
+    static vaultsResponseToVaults(response: MitoApi.GetVaultsResponse): {
+        vaults: MitoVault[];
+        pagination?: MitoPagination;
+    };
+    static lpTokenPriceChartResponseToLPTokenPriceChart(response: MitoApi.LPTokenPriceChartResponse): MitoPriceSnapshot[];
+    static vaultsByHolderAddressResponseToVaultsByHolderAddress(response: MitoApi.VaultsByHolderAddressResponse): {
+        subscriptions: MitoSubscription[];
+        pagination: MitoPagination | undefined;
+    };
+    static lpHoldersResponseToLPHolders(response: MitoApi.LPHoldersResponse): {
+        holders: MitoHolders[];
+        pagination: MitoPagination | undefined;
+    };
+    static transferHistoryResponseToTransfer(response: MitoApi.TransfersHistoryResponse): {
+        transfers: MitoTransfer[];
+        pagination: MitoPagination | undefined;
+    };
+    static leaderboardEpochsResponseToLeaderboardEpochs(response: MitoApi.LeaderboardEpochsResponse): {
+        epochs: MitoLeaderboardEpoch[];
+        pagination: MitoPagination | undefined;
+    };
+    static stakingPoolsResponseToStakingPools(response: MitoApi.GetStakingPoolsResponse): {
+        pools: MitoStakingPool[];
+        pagination: MitoPagination | undefined;
+    };
+    static stakingRewardByAccountResponseToStakingRewardByAccount(response: MitoApi.StakingRewardByAccountResponse): {
+        rewards: {
+            apr: number;
+            vaultName: string;
+            vaultAddress: string;
+            lockTimestamp: number;
+            claimableRewards: import("@injectivelabs/ts-types").Coin[];
+            stakedAmount: import("@injectivelabs/ts-types").Coin | undefined;
+            lockedAmount: import("@injectivelabs/ts-types").Coin | undefined;
+        }[];
+        pagination: MitoPagination | undefined;
+    };
+    static mitoStakingHistoryResponseTpStakingHistory(response: MitoApi.StakingHistoryResponse): {
+        activities: {
+            action: string;
+            txHash: string;
+            staker: string;
+            vaultAddress: string;
+            numberByAccount: number;
+            timestamp: number;
+            rewardedTokens: import("@injectivelabs/ts-types").Coin[];
+            stakeAmount: import("@injectivelabs/ts-types").Coin | undefined;
+        }[];
+        pagination: MitoPagination | undefined;
+    };
+    static mitoMissionsResponseMissions(response: MitoApi.MissionsResponse): MitoMission[];
+    static mitoMissionLeaderboardResponseToMissionLeaderboard(response: MitoApi.MissionLeaderboardResponse): MitoMissionLeaderboard;
+    static mitoListIDOsResponseToIDOs(response: MitoApi.ListIDOsResponse): {
+        idos: MitoIDO[];
+        pagination: MitoPagination | undefined;
+    };
+    static mitoIDOResponseToIDO(response: MitoApi.GetIDOResponse): {
+        ido: MitoIDO | undefined;
+    };
+    static mitoIDOSubscribersResponseToIDOSubscribers(response: MitoApi.GetIDOSubscribersResponse): {
+        marketId: string;
+        quoteDenom: string;
+        subscribers: MitoIDOSubscriber[];
+        pagination: MitoPagination | undefined;
+        tokenInfo: MitoTokenInfo | undefined;
+    };
+    static mitoIDOSubscriptionResponseToIDOSubscription(response: MitoApi.GetIDOSubscriptionResponse): {
+        subscription: MitoIDOSubscription | undefined;
+    };
+    static mitoIDOActivitiesResponseToIDOActivities(response: MitoApi.GetIDOActivitiesResponse): {
+        activities: MitoIDOSubscriptionActivity[];
+        pagination: MitoPagination | undefined;
+    };
+    static mitoWhitelistAccountResponseToWhitelistAccount(response: MitoApi.GetWhitelistResponse): {
+        idoAddress: string | undefined;
+        accounts: MitoWhitelistAccount[];
+        pagination: MitoPagination | undefined;
+    };
+    static claimReferencesResponseToClaimReferences(response: MitoApi.GetClaimReferencesResponse): {
+        claimReferences: MitoClaimReference[];
+        pagination?: MitoPagination;
+    };
+}