@injectivelabs/sdk-ts 1.16.16 → 1.16.17

package/dist/esm/client/indexer/transformers/IndexerGrpcAuctionTransformer.d.ts

@@ -1,15 +1,27 @@
 import type { InjectiveAuctionRpc } from '@injectivelabs/indexer-proto-ts';
-import type { Auction, IndexerBid, GrpcAuction, TotalInjBurnt, GrpcIndexerBid } from '../types/auction.js';
+import type { Auction, AuctionV2, AuctionCoin, GrpcAuction, GrpcAuctionV2, GrpcAuctionCoin, AccountAuctionV2, AuctionCoinPrices, IndexerAuctionBid, GrpcAccountAuctionV2, GrpcIndexerAuctionBid, GrpcAuctionCoinPrices } from '../types/auction.js';
 /**
  * @category Indexer Grpc Transformer
  */
 export declare class IndexerGrpcAuctionTransformer {
+    static grpcAuctionCoinToAuctionCoin(grpcCoin: GrpcAuctionCoin): AuctionCoin;
+    static grpcAuctionCoinPricesToAuctionCoinPrices(grpcCoinPrices: GrpcAuctionCoinPrices): AuctionCoinPrices;
+    static grpcBidToBid(grpcBid: GrpcIndexerAuctionBid): IndexerAuctionBid;
+    static grpcAuctionToAuction(grpcAuction: GrpcAuction): Auction;
+    static grpcAuctionV2ToAuctionV2(grpcAuction: GrpcAuctionV2): AuctionV2;
+    static grpcAccountAuctionV2ToAccountAuctionV2(grpcAccountAuction: GrpcAccountAuctionV2): AccountAuctionV2;
+    static auctionsResponseToAuctions(response: InjectiveAuctionRpc.AuctionsResponse): Auction[];
+    static auctionsHistoryV2ResponseToAuctionHistory(response: InjectiveAuctionRpc.AuctionsHistoryV2Response): {
+        auctions: AuctionV2[];
+        next: string[];
+    };
+    static accountAuctionsV2ResponseToAccountAuctionsV2(response: InjectiveAuctionRpc.AccountAuctionsV2Response): {
+        auctions: AccountAuctionV2[];
+        next: string[];
+        total: string;
+    };
     static auctionResponseToAuction(response: InjectiveAuctionRpc.AuctionEndpointResponse): {
         auction: Auction;
-        bids: IndexerBid[];
+        bids: IndexerAuctionBid[];
     };
-    static auctionsResponseToAuctions(response: InjectiveAuctionRpc.AuctionsResponse): Auction[];
-    static grpcBidToBid(grpcBid: GrpcIndexerBid): IndexerBid;
-    static grpcAuctionToAuction(grpcAuction: GrpcAuction): Auction;
-    static injBurntResponseToInjBurnt(response: InjectiveAuctionRpc.InjBurntEndpointResponse): TotalInjBurnt;
 }

package/dist/esm/client/indexer/transformers/IndexerGrpcAuctionTransformer.js

@@ -1,16 +1,20 @@
-import { IndexerCommonTransformer } from './IndexerCommonTransformer.js';
 /**
  * @category Indexer Grpc Transformer
  */
 export class IndexerGrpcAuctionTransformer {
-    static auctionResponseToAuction(response) {
+    static grpcAuctionCoinToAuctionCoin(grpcCoin) {
         return {
-            auction: IndexerGrpcAuctionTransformer.grpcAuctionToAuction(response.auction),
-            bids: response.bids.map(IndexerGrpcAuctionTransformer.grpcBidToBid),
+            denom: grpcCoin.denom,
+            amount: grpcCoin.amount,
+            usdValue: grpcCoin.usdValue,
         };
     }
-    static auctionsResponseToAuctions(response) {
-        return response.auctions.map((a) => IndexerGrpcAuctionTransformer.grpcAuctionToAuction(a));
+    static grpcAuctionCoinPricesToAuctionCoinPrices(grpcCoinPrices) {
+        return {
+            denom: grpcCoinPrices.denom,
+            amount: grpcCoinPrices.amount,
+            prices: grpcCoinPrices.prices,
+        };
     }
     static grpcBidToBid(grpcBid) {
         return {
@@ -22,14 +26,52 @@ export class IndexerGrpcAuctionTransformer {
     static grpcAuctionToAuction(grpcAuction) {
         return {
             winner: grpcAuction.winner,
-            basketList: grpcAuction.basket.map(IndexerCommonTransformer.grpcCoinToCoin),
+            basket: grpcAuction.basket.map(IndexerGrpcAuctionTransformer.grpcAuctionCoinToAuctionCoin),
+            winningBidAmount: grpcAuction.winningBidAmount,
+            round: parseInt(grpcAuction.round, 10),
+            endTimestamp: parseInt(grpcAuction.endTimestamp, 10),
+            updatedAt: parseInt(grpcAuction.updatedAt, 10),
+        };
+    }
+    static grpcAuctionV2ToAuctionV2(grpcAuction) {
+        return {
+            winner: grpcAuction.winner,
+            basket: grpcAuction.basket.map(IndexerGrpcAuctionTransformer.grpcAuctionCoinPricesToAuctionCoinPrices),
             winningBidAmount: grpcAuction.winningBidAmount,
             round: parseInt(grpcAuction.round, 10),
             endTimestamp: parseInt(grpcAuction.endTimestamp, 10),
             updatedAt: parseInt(grpcAuction.updatedAt, 10),
         };
     }
-    static injBurntResponseToInjBurnt(response) {
-        return Number(response.totalInjBurnt);
+    static grpcAccountAuctionV2ToAccountAuctionV2(grpcAccountAuction) {
+        return {
+            id: grpcAccountAuction.id,
+            round: parseInt(grpcAccountAuction.round, 10),
+            amountDeposited: grpcAccountAuction.amountDeposited,
+            isClaimable: grpcAccountAuction.isClaimable,
+            claimedAssets: grpcAccountAuction.claimedAssets.map(IndexerGrpcAuctionTransformer.grpcAuctionCoinPricesToAuctionCoinPrices),
+        };
+    }
+    static auctionsResponseToAuctions(response) {
+        return response.auctions.map((a) => IndexerGrpcAuctionTransformer.grpcAuctionToAuction(a));
+    }
+    static auctionsHistoryV2ResponseToAuctionHistory(response) {
+        return {
+            auctions: response.auctions.map(IndexerGrpcAuctionTransformer.grpcAuctionV2ToAuctionV2),
+            next: response.next,
+        };
+    }
+    static accountAuctionsV2ResponseToAccountAuctionsV2(response) {
+        return {
+            auctions: response.auctions.map(IndexerGrpcAuctionTransformer.grpcAccountAuctionV2ToAccountAuctionV2),
+            next: response.next,
+            total: response.total,
+        };
+    }
+    static auctionResponseToAuction(response) {
+        return {
+            auction: IndexerGrpcAuctionTransformer.grpcAuctionToAuction(response.auction),
+            bids: response.bids.map(IndexerGrpcAuctionTransformer.grpcBidToBid),
+        };
     }
 }

package/dist/esm/client/indexer/transformers/IndexerGrpcMegaVaultTransformer.d.ts

@@ -0,0 +1,30 @@
+import type { InjectiveMegaVaultRpc } from '@injectivelabs/indexer-proto-ts';
+import type { MegaVault, MegaVaultApr, MegaVaultPnl, MegaVaultUser, MegaVaultStats, GrpcMegaVaultApr, GrpcMegaVaultPnl, MegaVaultAprStats, MegaVaultOperator, MegaVaultPnlStats, MegaVaultTargetApr, MegaVaultUserStats, MegaVaultIncentives, MegaVaultRedemption, MegaVaultVolatility, MegaVaultMaxDrawdown, GrpcMegaVaultAprStats, GrpcMegaVaultPnlStats, GrpcMegaVaultOperator, MegaVaultSubscription, GrpcMegaVaultTargetApr, GrpcMegaVaultUserStats, MegaVaultHistoricalPnL, MegaVaultHistoricalTVL, MegaVaultUnrealizedPnl, GrpcMegaVaultIncentives, GrpcMegaVaultRedemption, GrpcMegaVaultVaultStats, GrpcMegaVaultVolatility, GrpcMegaVaultMaxDrawdown, MegaVaultVolatilityStats, GrpcMegaVaultSubscription, GrpcMegaVaultHistoricalPnL, GrpcMegaVaultHistoricalTVL, GrpcMegaVaultUnrealizedPnl, GrpcMegaVaultVolatilityStats, MegaVaultOperatorRedemptionBucket, GrpcMegaVaultOperatorRedemptionBucket } from '../types/mega-vault.js';
+export declare class IndexerGrpcMegaVaultTransformer {
+    static vaultResponseToVault(response: InjectiveMegaVaultRpc.GetVaultResponse): MegaVault | undefined;
+    static userResponseToUser(response: InjectiveMegaVaultRpc.GetUserResponse): MegaVaultUser | undefined;
+    static subscriptionsResponseToSubscriptions(response: InjectiveMegaVaultRpc.ListSubscriptionsResponse): MegaVaultSubscription[];
+    static redemptionsResponseToRedemptions(response: InjectiveMegaVaultRpc.ListRedemptionsResponse): MegaVaultRedemption[];
+    static operatorRedemptionBucketsResponseToOperatorRedemptionBuckets(response: InjectiveMegaVaultRpc.GetOperatorRedemptionBucketsResponse): MegaVaultOperatorRedemptionBucket[];
+    static tvlHistoryResponseToTvlHistory(response: InjectiveMegaVaultRpc.TvlHistoryResponse): MegaVaultHistoricalTVL[];
+    static pnlHistoryResponseToPnlHistory(response: InjectiveMegaVaultRpc.PnlHistoryResponse): MegaVaultHistoricalPnL[];
+    static grpcOperatorToOperator(operator: GrpcMegaVaultOperator): MegaVaultOperator;
+    static grpcIncentiveToIncentive(incentive: GrpcMegaVaultIncentives): MegaVaultIncentives;
+    static grpcTargetAprToTargetApr(targetApr: GrpcMegaVaultTargetApr): MegaVaultTargetApr;
+    static grpcVaultStatsToVaultStats(stats: GrpcMegaVaultVaultStats): MegaVaultStats;
+    static grpcPnlStatsToPnlStats(pnl: GrpcMegaVaultPnlStats): MegaVaultPnlStats;
+    static grpcUnrealizedPnlToUnrealizedPnl(pnl: GrpcMegaVaultUnrealizedPnl): MegaVaultUnrealizedPnl;
+    static grpcPnlToPnl(pnl: GrpcMegaVaultPnl): MegaVaultPnl;
+    static grpcMaxDrawdownToMaxDrawdown(maxDrawdown: GrpcMegaVaultMaxDrawdown): MegaVaultMaxDrawdown;
+    static grpcVolatilityStatsToVolatilityStats(volatility: GrpcMegaVaultVolatilityStats): MegaVaultVolatilityStats;
+    static grpcVolatilityToVolatility(volatility: GrpcMegaVaultVolatility): MegaVaultVolatility;
+    static grpcAprStatsToAprStats(apr: GrpcMegaVaultAprStats): MegaVaultAprStats;
+    static grpcAprToApr(apr: GrpcMegaVaultApr): MegaVaultApr;
+    static grpcUserStatsToUserStats(stats: GrpcMegaVaultUserStats): MegaVaultUserStats;
+    static grpcSubscriptionsToSubscriptions(subscriptions: GrpcMegaVaultSubscription[]): MegaVaultSubscription[];
+    static grpcSubscriptionToSubscription(subscription: GrpcMegaVaultSubscription): MegaVaultSubscription;
+    static grpcRedemptionToRedemption(redemption: GrpcMegaVaultRedemption): MegaVaultRedemption;
+    static grpcOperatorRedemptionBucketToOperatorRedemptionBucket(bucket: GrpcMegaVaultOperatorRedemptionBucket): MegaVaultOperatorRedemptionBucket;
+    static grpcHistoricalTVLToHistoricalTVL(history: GrpcMegaVaultHistoricalTVL): MegaVaultHistoricalTVL;
+    static grpcHistoricalPnLToHistoricalPnL(history: GrpcMegaVaultHistoricalPnL): MegaVaultHistoricalPnL;
+}

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

@@ -0,0 +1,226 @@
+export 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,
+            totalAmount: operator.totalAmount,
+            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,
+            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,
+        };
+    }
+    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,
+        };
+    }
+    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,
+        };
+    }
+}

package/dist/esm/client/indexer/transformers/index.d.ts

@@ -12,6 +12,7 @@ export * from './IndexerOracleStreamTransformer.js';
 export * from './IndexerRestExplorerTransformer.js';
 export * from './IndexerAccountStreamTransformer.js';
 export * from './IndexerAuctionStreamTransformer.js';
+export * from './IndexerGrpcMegaVaultTransformer.js';
 export * from './IndexerArchiverStreamTransformer.js';
 export * from './IndexerExplorerStreamTransformer.js';
 export * from './IndexerGrpcDerivativeTransformer.js';

package/dist/esm/client/indexer/transformers/index.js

@@ -12,6 +12,7 @@ export * from './IndexerOracleStreamTransformer.js';
 export * from './IndexerRestExplorerTransformer.js';
 export * from './IndexerAccountStreamTransformer.js';
 export * from './IndexerAuctionStreamTransformer.js';
+export * from './IndexerGrpcMegaVaultTransformer.js';
 export * from './IndexerArchiverStreamTransformer.js';
 export * from './IndexerExplorerStreamTransformer.js';
 export * from './IndexerGrpcDerivativeTransformer.js';

package/dist/esm/client/indexer/types/auction.d.ts

@@ -1,19 +1,63 @@
-import type { Coin } from '@injectivelabs/ts-types';
 import type { InjectiveAuctionRpc } from '@injectivelabs/indexer-proto-ts';
-export interface IndexerBid {
+export interface IndexerAuctionBid {
     bidder: string;
     bidAmount: string;
     bidTimestamp: number;
 }
+export interface AuctionCoin {
+    denom: string;
+    amount: string;
+    usdValue: string;
+}
+export interface AuctionCoinPrices {
+    denom: string;
+    amount: string;
+    prices: {
+        [key: string]: string;
+    };
+}
+export interface AuctionContract {
+    id: string;
+    bidTarget: string;
+    currentSlots: string;
+    totalSlots: string;
+    maxUserAllocation: string;
+    totalCommitted: string;
+    whitelistAddresses: string[];
+    startTimestamp: string;
+    endTimestamp: string;
+    maxRoundAllocation: string;
+}
 export interface Auction {
     winner: string;
-    basketList: Coin[];
+    basket: AuctionCoin[];
     winningBidAmount: string;
     round: number;
     endTimestamp: number;
     updatedAt: number;
+    contract?: AuctionContract;
+}
+export interface AuctionV2 {
+    winner: string;
+    basket: AuctionCoinPrices[];
+    winningBidAmount: string;
+    round: number;
+    endTimestamp: number;
+    updatedAt: number;
+    contract?: AuctionContract;
+}
+export interface AccountAuctionV2 {
+    id: string;
+    round: number;
+    amountDeposited: string;
+    isClaimable: boolean;
+    claimedAssets: AuctionCoinPrices[];
 }
-export type TotalInjBurnt = number;
-export type GrpcIndexerBid = InjectiveAuctionRpc.Bid;
 export type GrpcAuction = InjectiveAuctionRpc.Auction;
+export type GrpcAuctionCoin = InjectiveAuctionRpc.Coin;
+export type GrpcIndexerAuctionBid = InjectiveAuctionRpc.Bid;
+export type GrpcAuctionV2 = InjectiveAuctionRpc.AuctionV2Result;
+export type GrpcAuctionCoinPrices = InjectiveAuctionRpc.CoinPrices;
+export type GrpcAccountAuctionV2 = InjectiveAuctionRpc.AccountAuctionV2;
+export type GrpcAuctionContract = InjectiveAuctionRpc.AuctionContract;
 export type StreamBidsResponse = InjectiveAuctionRpc.StreamBidsResponse;

package/dist/esm/client/indexer/types/index.d.ts

@@ -11,6 +11,7 @@ export * from './explorer.js';
 export type * from './referral.js';
 export type * from './campaign.js';
 export type * from './spot-rest.js';
+export type * from './mega-vault.js';
 export type * from './incentives.js';
 export type * from './derivatives.js';
 export type * from './explorer-rest.js';
@@ -25,26 +26,27 @@ export interface StreamStatusResponse {
     metadata: any;
 }
 export declare const IndexerModule: {
-    Account: "indexer-account";
-    Auction: "indexer-auction";
-    Archiver: "indexer-archiver";
-    Derivatives: "indexer-derivatives";
-    Explorer: "indexer-explorer";
-    InsuranceFund: "indexer-insurance-fund";
-    Meta: "indexer-meta";
-    Mito: "indexer-mito";
     Dmm: "dmm";
     OLP: "olp";
+    Abacus: "abacus";
+    Meta: "indexer-meta";
+    Mito: "indexer-mito";
     Referral: "referral";
+    Spot: "indexer-spot";
+    Web3Gw: "web3-gateway";
     Oracle: "indexer-oracle";
+    Account: "indexer-account";
+    Auction: "indexer-auction";
+    Trading: "indexer-trading";
+    Archiver: "indexer-archiver";
+    Explorer: "indexer-explorer";
+    Campaign: "indexer-campaign";
     Portfolio: "indexer-portfolio";
-    Spot: "indexer-spot";
+    MegaVault: "indexer-mega-vault";
+    Derivatives: "indexer-derivatives";
     Transaction: "indexer-transaction";
-    Trading: "indexer-trading";
-    ChronosDerivative: "indexer-chronos-derivative";
     ChronosSpot: "indexer-chronos-spot";
+    InsuranceFund: "indexer-insurance-fund";
     ChronosMarkets: "indexer-chronos-markets";
-    Campaign: "indexer-campaign";
-    Web3Gw: "web3-gateway";
-    Abacus: "abacus";
+    ChronosDerivative: "indexer-chronos-derivative";
 };

package/dist/esm/client/indexer/types/mega-vault.d.ts

@@ -0,0 +1,153 @@
+import type { InjectiveMegaVaultRpc } from '@injectivelabs/indexer-proto-ts';
+export interface MegaVaultOperator {
+    address: string;
+    totalAmount: string;
+    totalLiquidAmount: string;
+    updatedHeight: string;
+    updatedAt: string;
+}
+export interface MegaVault {
+    admin: string;
+    lpDenom: string;
+    createdAt: string;
+    updatedAt: string;
+    quoteDenom: string;
+    contractName: string;
+    createdHeight: string;
+    updatedHeight: string;
+    contractAddress: string;
+    contractVersion: string;
+    operators: MegaVaultOperator[];
+    stats: MegaVaultStats | undefined;
+    incentives: MegaVaultIncentives | undefined;
+    targetApr: MegaVaultTargetApr | undefined;
+}
+export interface MegaVaultIncentives {
+    amount: string;
+    address: string;
+    updatedAt: string;
+    updatedHeight: string;
+}
+export interface MegaVaultStats {
+    currentAmount: string;
+    currentLpPrice: string;
+    currentLpAmount: string;
+    totalRedeemedAmount: string;
+    totalSubscribedAmount: string;
+    apr: MegaVaultAprStats | undefined;
+    pnl: MegaVaultPnlStats | undefined;
+    currentAmountWithoutIncentives: string;
+    maxDrawdown: MegaVaultMaxDrawdown | undefined;
+    volatility: MegaVaultVolatilityStats | undefined;
+}
+export interface MegaVaultPnlStats {
+    allTime: MegaVaultPnl | undefined;
+    unrealized: MegaVaultUnrealizedPnl | undefined;
+}
+export interface MegaVaultUnrealizedPnl {
+    value: string;
+    percentage: string;
+}
+export interface MegaVaultPnl {
+    value: string;
+    percentage: string;
+    currentAmount: string;
+    totalAmountRedeemed: string;
+    totalAmountSubscribed: string;
+}
+export interface MegaVaultMaxDrawdown {
+    value: string;
+    latestPnLPeak: string;
+}
+export interface MegaVaultVolatilityStats {
+    thirtyDays: MegaVaultVolatility | undefined;
+}
+export interface MegaVaultVolatility {
+    value: string;
+}
+export interface MegaVaultAprStats {
+    thirtyDays: MegaVaultApr | undefined;
+}
+export interface MegaVaultApr {
+    value: string;
+    currentLpPrice: string;
+    originalLpPrice: string;
+}
+export interface MegaVaultUser {
+    address: string;
+    updatedAt: string;
+    updatedHeight: string;
+    contractAddress: string;
+    stats: MegaVaultUserStats | undefined;
+}
+export interface MegaVaultUserStats {
+    currentAmount: string;
+    currentLpAmount: string;
+    pnl: MegaVaultPnlStats | undefined;
+}
+export interface MegaVaultSubscription {
+    user: string;
+    index: string;
+    amount: string;
+    status: string;
+    lpAmount: string;
+    createdAt: string;
+    executedAt: string;
+    createdHeight: string;
+    executedHeight: string;
+    contractAddress: string;
+}
+export interface MegaVaultRedemption {
+    user: string;
+    index: string;
+    dueAt: string;
+    amount: string;
+    status: string;
+    lpAmount: string;
+    createdAt: string;
+    executedAt: string;
+    createdHeight: string;
+    executedHeight: string;
+    contractAddress: string;
+}
+export interface MegaVaultOperatorRedemptionBucket {
+    bucket: string;
+    neededAmount: string;
+    lpAmountToRedeem: string;
+    missingLiquidity: string;
+}
+export interface MegaVaultHistoricalTVL {
+    t: number;
+    v: string;
+}
+export interface MegaVaultHistoricalPnL {
+    t: number;
+    v: string;
+}
+export interface MegaVaultTargetApr {
+    apr: string;
+    updatedAt: string;
+    updatedHeight: string;
+    upperThreshold: string;
+    lowerThreshold: string;
+}
+export type MegaVaultRedemptionStatus = 'pending' | 'executed' | 'executing';
+export type MegaVaultSubscriptionStatus = 'pending' | 'executed';
+export type GrpcMegaVaultApr = InjectiveMegaVaultRpc.Apr;
+export type GrpcMegaVaultPnl = InjectiveMegaVaultRpc.Pnl;
+export type GrpcMegaVaultAprStats = InjectiveMegaVaultRpc.AprStats;
+export type GrpcMegaVaultPnlStats = InjectiveMegaVaultRpc.PnlStats;
+export type GrpcMegaVaultOperator = InjectiveMegaVaultRpc.Operator;
+export type GrpcMegaVaultTargetApr = InjectiveMegaVaultRpc.TargetApr;
+export type GrpcMegaVaultUserStats = InjectiveMegaVaultRpc.UserStats;
+export type GrpcMegaVaultIncentives = InjectiveMegaVaultRpc.Incentives;
+export type GrpcMegaVaultVaultStats = InjectiveMegaVaultRpc.VaultStats;
+export type GrpcMegaVaultVolatility = InjectiveMegaVaultRpc.Volatility;
+export type GrpcMegaVaultRedemption = InjectiveMegaVaultRpc.Redemption;
+export type GrpcMegaVaultMaxDrawdown = InjectiveMegaVaultRpc.MaxDrawdown;
+export type GrpcMegaVaultSubscription = InjectiveMegaVaultRpc.Subscription;
+export type GrpcMegaVaultHistoricalPnL = InjectiveMegaVaultRpc.HistoricalPnL;
+export type GrpcMegaVaultHistoricalTVL = InjectiveMegaVaultRpc.HistoricalTVL;
+export type GrpcMegaVaultUnrealizedPnl = InjectiveMegaVaultRpc.UnrealizedPnl;
+export type GrpcMegaVaultVolatilityStats = InjectiveMegaVaultRpc.VolatilityStats;
+export type GrpcMegaVaultOperatorRedemptionBucket = InjectiveMegaVaultRpc.RedemptionBucket;

package/dist/esm/client/indexer/types/mega-vault.js

@@ -0,0 +1,10 @@
+const MegaVaultRedemptionStatus = {
+    Pending: 'pending',
+    Executed: 'executed',
+    Executing: 'executing',
+};
+const MegaVaultSubscriptionStatus = {
+    Pending: 'pending',
+    Executed: 'executed',
+};
+export {};