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

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

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcMegaVaultTransformer = void 0;
+class IndexerGrpcMegaVaultTransformer {
+    static vaultResponseToVault(response) {
+        const vault = response.vault;
+        if (!vault) {
+            return;
+        }
+        return {
+            admin: vault.admin,
+            lpDenom: vault.lpDenom,
+            createdAt: vault.createdAt,
+            updatedAt: vault.updatedAt,
+            quoteDenom: vault.quoteDenom,
+            contractName: vault.contractName,
+            createdHeight: vault.createdHeight,
+            updatedHeight: vault.updatedHeight,
+            contractAddress: vault.contractAddress,
+            contractVersion: vault.contractVersion,
+            stats: vault.stats
+                ? IndexerGrpcMegaVaultTransformer.grpcVaultStatsToVaultStats(vault.stats)
+                : undefined,
+            operators: vault.operators.map(IndexerGrpcMegaVaultTransformer.grpcOperatorToOperator),
+            targetApr: vault.targetApr
+                ? IndexerGrpcMegaVaultTransformer.grpcTargetAprToTargetApr(vault.targetApr)
+                : undefined,
+            incentives: vault.incentives
+                ? IndexerGrpcMegaVaultTransformer.grpcIncentiveToIncentive(vault.incentives)
+                : undefined,
+        };
+    }
+    static userResponseToUser(response) {
+        const user = response.user;
+        if (!user) {
+            return;
+        }
+        return {
+            address: user.address,
+            updatedAt: user.updatedAt,
+            updatedHeight: user.updatedHeight,
+            contractAddress: user.contractAddress,
+            stats: user.stats
+                ? IndexerGrpcMegaVaultTransformer.grpcUserStatsToUserStats(user.stats)
+                : undefined,
+        };
+    }
+    static subscriptionsResponseToSubscriptions(response) {
+        return response.subscriptions.map(IndexerGrpcMegaVaultTransformer.grpcSubscriptionToSubscription);
+    }
+    static redemptionsResponseToRedemptions(response) {
+        return response.redemptions.map(IndexerGrpcMegaVaultTransformer.grpcRedemptionToRedemption);
+    }
+    static operatorRedemptionBucketsResponseToOperatorRedemptionBuckets(response) {
+        return response.buckets.map(IndexerGrpcMegaVaultTransformer.grpcOperatorRedemptionBucketToOperatorRedemptionBucket);
+    }
+    static tvlHistoryResponseToTvlHistory(response) {
+        return response.history.map(IndexerGrpcMegaVaultTransformer.grpcHistoricalTVLToHistoricalTVL);
+    }
+    static pnlHistoryResponseToPnlHistory(response) {
+        return response.history.map(IndexerGrpcMegaVaultTransformer.grpcHistoricalPnLToHistoricalPnL);
+    }
+    static grpcOperatorToOperator(operator) {
+        return {
+            address: operator.address,
+            updatedAt: operator.updatedAt,
+            percentage: operator.percentage,
+            totalAmount: operator.totalAmount,
+            subaccountId: operator.subaccountId,
+            updatedHeight: operator.updatedHeight,
+            totalLiquidAmount: operator.totalLiquidAmount,
+        };
+    }
+    static grpcIncentiveToIncentive(incentive) {
+        return {
+            address: incentive.address,
+            amount: incentive.amount,
+            updatedAt: incentive.updatedAt,
+            updatedHeight: incentive.updatedHeight,
+        };
+    }
+    static grpcTargetAprToTargetApr(targetApr) {
+        return {
+            apr: targetApr.apr,
+            updatedAt: targetApr.updatedAt,
+            upperThreshold: targetApr.upperThreshold,
+            lowerThreshold: targetApr.lowerThreshold,
+            updatedHeight: targetApr.updatedHeight,
+        };
+    }
+    static grpcVaultStatsToVaultStats(stats) {
+        return {
+            currentAmount: stats.currentAmount,
+            currentLpPrice: stats.currentLpPrice,
+            currentLpAmount: stats.currentLpAmount,
+            totalRedeemedAmount: stats.totalRedeemedAmount,
+            totalSubscribedAmount: stats.totalSubscribedAmount,
+            currentAmountWithoutIncentives: stats.currentAmountWithoutIncentives,
+            apr: stats.apr
+                ? IndexerGrpcMegaVaultTransformer.grpcAprStatsToAprStats(stats.apr)
+                : undefined,
+            pnl: stats.pnl
+                ? IndexerGrpcMegaVaultTransformer.grpcPnlStatsToPnlStats(stats.pnl)
+                : undefined,
+            volatility: stats.volatility
+                ? IndexerGrpcMegaVaultTransformer.grpcVolatilityStatsToVolatilityStats(stats.volatility)
+                : undefined,
+            maxDrawdown: stats.maxDrawdown
+                ? IndexerGrpcMegaVaultTransformer.grpcMaxDrawdownToMaxDrawdown(stats.maxDrawdown)
+                : undefined,
+        };
+    }
+    static grpcPnlStatsToPnlStats(pnl) {
+        return {
+            allTime: pnl.allTime
+                ? IndexerGrpcMegaVaultTransformer.grpcPnlToPnl(pnl.allTime)
+                : undefined,
+            unrealized: pnl.unrealized
+                ? IndexerGrpcMegaVaultTransformer.grpcUnrealizedPnlToUnrealizedPnl(pnl.unrealized)
+                : undefined,
+        };
+    }
+    static grpcUnrealizedPnlToUnrealizedPnl(pnl) {
+        return {
+            value: pnl.value,
+            percentage: pnl.percentage,
+        };
+    }
+    static grpcPnlToPnl(pnl) {
+        return {
+            value: pnl.value,
+            percentage: pnl.percentage,
+            currentAmount: pnl.currentAmount,
+            totalAmountRedeemed: pnl.totalAmountRedeemed,
+            totalAmountSubscribed: pnl.totalAmountSubscribed,
+        };
+    }
+    static grpcMaxDrawdownToMaxDrawdown(maxDrawdown) {
+        return {
+            value: maxDrawdown.value,
+            latestPnLPeak: maxDrawdown.latestPnLPeak,
+        };
+    }
+    static grpcVolatilityStatsToVolatilityStats(volatility) {
+        return {
+            thirtyDays: volatility.thirtyDays
+                ? IndexerGrpcMegaVaultTransformer.grpcVolatilityToVolatility(volatility.thirtyDays)
+                : undefined,
+        };
+    }
+    static grpcVolatilityToVolatility(volatility) {
+        return {
+            value: volatility.value,
+        };
+    }
+    static grpcAprStatsToAprStats(apr) {
+        return {
+            thirtyDays: apr.thirtyDays
+                ? IndexerGrpcMegaVaultTransformer.grpcAprToApr(apr.thirtyDays)
+                : undefined,
+        };
+    }
+    static grpcAprToApr(apr) {
+        return {
+            value: apr.value,
+            currentLpPrice: apr.currentLpPrice,
+            originalLpPrice: apr.originalLpPrice,
+        };
+    }
+    static grpcUserStatsToUserStats(stats) {
+        return {
+            currentAmount: stats.currentAmount,
+            depositedValue: stats.depositedValue,
+            currentLpAmount: stats.currentLpAmount,
+            pnl: stats.pnl
+                ? IndexerGrpcMegaVaultTransformer.grpcPnlStatsToPnlStats(stats.pnl)
+                : undefined,
+        };
+    }
+    static grpcSubscriptionsToSubscriptions(subscriptions) {
+        return subscriptions.map(IndexerGrpcMegaVaultTransformer.grpcSubscriptionToSubscription);
+    }
+    static grpcSubscriptionToSubscription(subscription) {
+        return {
+            user: subscription.user,
+            index: subscription.index,
+            amount: subscription.amount,
+            status: subscription.status,
+            lpAmount: subscription.lpAmount,
+            createdAt: subscription.createdAt,
+            executedAt: subscription.executedAt,
+            createdHeight: subscription.createdHeight,
+            executedHeight: subscription.executedHeight,
+            contractAddress: subscription.contractAddress,
+            log: subscription.log.map(IndexerGrpcMegaVaultTransformer.grpcOperationStatusLogEntryToOperationStatusLogEntry),
+        };
+    }
+    static grpcRedemptionToRedemption(redemption) {
+        return {
+            user: redemption.user,
+            dueAt: redemption.dueAt,
+            index: redemption.index,
+            amount: redemption.amount,
+            status: redemption.status,
+            lpAmount: redemption.lpAmount,
+            createdAt: redemption.createdAt,
+            executedAt: redemption.executedAt,
+            createdHeight: redemption.createdHeight,
+            executedHeight: redemption.executedHeight,
+            contractAddress: redemption.contractAddress,
+            log: redemption.log.map(IndexerGrpcMegaVaultTransformer.grpcOperationStatusLogEntryToOperationStatusLogEntry),
+        };
+    }
+    static grpcOperatorRedemptionBucketToOperatorRedemptionBucket(bucket) {
+        return {
+            bucket: bucket.bucket,
+            neededAmount: bucket.neededAmount,
+            lpAmountToRedeem: bucket.lpAmountToRedeem,
+            missingLiquidity: bucket.missingLiquidity,
+        };
+    }
+    static grpcHistoricalTVLToHistoricalTVL(history) {
+        return {
+            t: history.t,
+            v: history.v,
+        };
+    }
+    static grpcHistoricalPnLToHistoricalPnL(history) {
+        return {
+            t: history.t,
+            v: history.v,
+        };
+    }
+    static grpcOperationStatusLogEntryToOperationStatusLogEntry(log) {
+        return {
+            status: log.status,
+            txHash: log.txHash,
+            blockTime: log.blockTime,
+            blockHeight: log.blockHeight,
+        };
+    }
+}
+exports.IndexerGrpcMegaVaultTransformer = IndexerGrpcMegaVaultTransformer;

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

@@ -0,0 +1,44 @@
+import type { MitoApi } from '@injectivelabs/mito-proto-ts';
+import type { 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("../../../../../ts-types/dist/cjs/cosmos.js").Coin[];
+            stakedAmount: import("../../../../../ts-types/dist/cjs/cosmos.js").Coin | undefined;
+            lockedAmount: import("../../../../../ts-types/dist/cjs/cosmos.js").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("../../../../../ts-types/dist/cjs/cosmos.js").Coin[];
+            stakeAmount: import("../../../../../ts-types/dist/cjs/cosmos.js").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 type { MitoApi } from '@injectivelabs/mito-proto-ts';
+import type { 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("../../../../../ts-types/dist/cjs/cosmos.js").Coin[];
+        stakedAmount: import("../../../../../ts-types/dist/cjs/cosmos.js").Coin | undefined;
+        lockedAmount: import("../../../../../ts-types/dist/cjs/cosmos.js").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("../../../../../ts-types/dist/cjs/cosmos.js").Coin[];
+        stakeAmount: import("../../../../../ts-types/dist/cjs/cosmos.js").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("../../../../../ts-types/dist/cjs/cosmos.js").Coin[];
+            stakedAmount: import("../../../../../ts-types/dist/cjs/cosmos.js").Coin | undefined;
+            lockedAmount: import("../../../../../ts-types/dist/cjs/cosmos.js").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("../../../../../ts-types/dist/cjs/cosmos.js").Coin[];
+            stakeAmount: import("../../../../../ts-types/dist/cjs/cosmos.js").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;
+    };
+}