@injectivelabs/sdk-ts 1.16.16 → 1.16.18

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

@@ -0,0 +1,207 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcMegaVaultApi = void 0;
+const indexer_proto_ts_1 = require("@injectivelabs/indexer-proto-ts");
+const exceptions_1 = require("@injectivelabs/exceptions");
+const index_js_1 = require("../types/index.js");
+const BaseIndexerGrpcConsumer_js_1 = __importDefault(require("../../base/BaseIndexerGrpcConsumer.js"));
+const index_js_2 = require("../transformers/index.js");
+/**
+ * @category Indexer Grpc API
+ */
+class IndexerGrpcMegaVaultApi extends BaseIndexerGrpcConsumer_js_1.default {
+    module = index_js_1.IndexerModule.MegaVault;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new indexer_proto_ts_1.InjectiveMegaVaultRpc.InjectiveMegavaultRPCClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchVault({ vaultAddress }) {
+        const request = indexer_proto_ts_1.InjectiveMegaVaultRpc.GetVaultRequest.create();
+        request.vaultAddress = vaultAddress;
+        try {
+            const response = await this.retry(() => this.client.GetVault(request, this.metadata));
+            return index_js_2.IndexerGrpcMegaVaultTransformer.vaultResponseToVault(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchVault',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'fetchVault',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchVaultUser({ vaultAddress, userAddress, }) {
+        const request = indexer_proto_ts_1.InjectiveMegaVaultRpc.GetUserRequest.create();
+        request.vaultAddress = vaultAddress;
+        request.userAddress = userAddress;
+        try {
+            const response = await this.retry(() => this.client.GetUser(request, this.metadata));
+            return index_js_2.IndexerGrpcMegaVaultTransformer.userResponseToUser(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchVaultUser',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'fetchVaultUser',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchVaultSubscriptions({ token, status, perPage, userAddress, vaultAddress, }) {
+        const request = indexer_proto_ts_1.InjectiveMegaVaultRpc.ListSubscriptionsRequest.create();
+        request.vaultAddress = vaultAddress;
+        request.userAddress = userAddress;
+        if (status) {
+            request.status = status;
+        }
+        if (perPage) {
+            request.perPage = perPage;
+        }
+        if (token) {
+            request.token = token;
+        }
+        try {
+            const response = await this.retry(() => this.client.ListSubscriptions(request, this.metadata));
+            return index_js_2.IndexerGrpcMegaVaultTransformer.subscriptionsResponseToSubscriptions(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchVaultSubscriptions',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'fetchVaultSubscriptions',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchVaultRedemptions({ token, status, perPage, userAddress, vaultAddress, }) {
+        const request = indexer_proto_ts_1.InjectiveMegaVaultRpc.ListRedemptionsRequest.create();
+        request.vaultAddress = vaultAddress;
+        request.userAddress = userAddress;
+        if (status) {
+            request.status = status;
+        }
+        if (perPage) {
+            request.perPage = perPage;
+        }
+        if (token) {
+            request.token = token;
+        }
+        try {
+            const response = await this.retry(() => this.client.ListRedemptions(request, this.metadata));
+            return index_js_2.IndexerGrpcMegaVaultTransformer.redemptionsResponseToRedemptions(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchVaultRedemptions',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'fetchVaultRedemptions',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchOperatorRedemptionBuckets({ vaultAddress, operatorAddress, }) {
+        const request = indexer_proto_ts_1.InjectiveMegaVaultRpc.GetOperatorRedemptionBucketsRequest.create();
+        request.vaultAddress = vaultAddress;
+        request.operatorAddress = operatorAddress;
+        try {
+            const response = await this.retry(() => this.client.GetOperatorRedemptionBuckets(request, this.metadata));
+            return index_js_2.IndexerGrpcMegaVaultTransformer.operatorRedemptionBucketsResponseToOperatorRedemptionBuckets(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchOperatorRedemptionBuckets',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'fetchOperatorRedemptionBuckets',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchVaultTvlHistory({ since, vaultAddress, maxDataPoints, }) {
+        const request = indexer_proto_ts_1.InjectiveMegaVaultRpc.TvlHistoryRequest.create();
+        request.vaultAddress = vaultAddress;
+        request.since = since.toString();
+        if (maxDataPoints) {
+            request.maxDataPoints = maxDataPoints;
+        }
+        try {
+            const response = await this.retry(() => this.client.TvlHistory(request, this.metadata));
+            return index_js_2.IndexerGrpcMegaVaultTransformer.tvlHistoryResponseToTvlHistory(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchVaultTvlHistory',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'fetchVaultTvlHistory',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchVaultPnlHistory({ since, vaultAddress, maxDataPoints, }) {
+        const request = indexer_proto_ts_1.InjectiveMegaVaultRpc.PnlHistoryRequest.create();
+        request.vaultAddress = vaultAddress;
+        request.since = since.toString();
+        if (maxDataPoints) {
+            request.maxDataPoints = maxDataPoints;
+        }
+        try {
+            const response = await this.retry(() => this.client.PnlHistory(request, this.metadata));
+            return index_js_2.IndexerGrpcMegaVaultTransformer.pnlHistoryResponseToPnlHistory(response);
+        }
+        catch (e) {
+            if (e instanceof indexer_proto_ts_1.InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new exceptions_1.GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchVaultPnlHistory',
+                    contextModule: this.module,
+                });
+            }
+            throw new exceptions_1.GrpcUnaryRequestException(e, {
+                code: exceptions_1.UnspecifiedErrorCode,
+                context: 'fetchVaultPnlHistory',
+                contextModule: this.module,
+            });
+        }
+    }
+}
+exports.IndexerGrpcMegaVaultApi = IndexerGrpcMegaVaultApi;

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

@@ -10,6 +10,7 @@ export { IndexerGrpcExplorerApi } from './IndexerGrpcExplorerApi.js';
 export { IndexerGrpcCampaignApi } from './IndexerGrpcCampaignApi.js';
 export { IndexerGrpcArchiverApi } from './IndexerGrpcArchiverApi.js';
 export { IndexerGrpcReferralApi } from './IndexerGrpcReferralApi.js';
+export { IndexerGrpcMegaVaultApi } from './IndexerGrpcMegaVaultApi.js';
 export { IndexerGrpcDerivativesApi } from './IndexerGrpcDerivativesApi.js';
 export { IndexerGrpcTransactionApi } from './IndexerGrpcTransactionApi.js';
 export { IndexerGrpcAccountPortfolioApi } from './IndexerGrpcPortfolioApi.js';

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexerGrpcInsuranceFundApi = exports.IndexerGrpcAccountPortfolioApi = exports.IndexerGrpcTransactionApi = exports.IndexerGrpcDerivativesApi = exports.IndexerGrpcReferralApi = exports.IndexerGrpcArchiverApi = exports.IndexerGrpcCampaignApi = exports.IndexerGrpcExplorerApi = exports.IndexerGrpcTradingApi = exports.IndexerGrpcAuctionApi = exports.IndexerGrpcAccountApi = exports.IndexerGrpcWeb3GwApi = exports.IndexerGrpcOracleApi = exports.IndexerGrpcSpotApi = exports.IndexerGrpcMetaApi = exports.IndexerGrpcMitoApi = void 0;
+exports.IndexerGrpcInsuranceFundApi = exports.IndexerGrpcAccountPortfolioApi = exports.IndexerGrpcTransactionApi = exports.IndexerGrpcDerivativesApi = exports.IndexerGrpcMegaVaultApi = exports.IndexerGrpcReferralApi = exports.IndexerGrpcArchiverApi = exports.IndexerGrpcCampaignApi = exports.IndexerGrpcExplorerApi = exports.IndexerGrpcTradingApi = exports.IndexerGrpcAuctionApi = exports.IndexerGrpcAccountApi = exports.IndexerGrpcWeb3GwApi = exports.IndexerGrpcOracleApi = exports.IndexerGrpcSpotApi = exports.IndexerGrpcMetaApi = exports.IndexerGrpcMitoApi = void 0;
 var IndexerGrpcMitoApi_js_1 = require("./IndexerGrpcMitoApi.js");
 Object.defineProperty(exports, "IndexerGrpcMitoApi", { enumerable: true, get: function () { return IndexerGrpcMitoApi_js_1.IndexerGrpcMitoApi; } });
 var IndexerGrpcMetaApi_js_1 = require("./IndexerGrpcMetaApi.js");
@@ -25,6 +25,8 @@ var IndexerGrpcArchiverApi_js_1 = require("./IndexerGrpcArchiverApi.js");
 Object.defineProperty(exports, "IndexerGrpcArchiverApi", { enumerable: true, get: function () { return IndexerGrpcArchiverApi_js_1.IndexerGrpcArchiverApi; } });
 var IndexerGrpcReferralApi_js_1 = require("./IndexerGrpcReferralApi.js");
 Object.defineProperty(exports, "IndexerGrpcReferralApi", { enumerable: true, get: function () { return IndexerGrpcReferralApi_js_1.IndexerGrpcReferralApi; } });
+var IndexerGrpcMegaVaultApi_js_1 = require("./IndexerGrpcMegaVaultApi.js");
+Object.defineProperty(exports, "IndexerGrpcMegaVaultApi", { enumerable: true, get: function () { return IndexerGrpcMegaVaultApi_js_1.IndexerGrpcMegaVaultApi; } });
 var IndexerGrpcDerivativesApi_js_1 = require("./IndexerGrpcDerivativesApi.js");
 Object.defineProperty(exports, "IndexerGrpcDerivativesApi", { enumerable: true, get: function () { return IndexerGrpcDerivativesApi_js_1.IndexerGrpcDerivativesApi; } });
 var IndexerGrpcTransactionApi_js_1 = require("./IndexerGrpcTransactionApi.js");

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

@@ -1,11 +1,11 @@
-import type { IndexerBid } from '../types/index.js';
+import type { IndexerAuctionBid } from '../types/index.js';
 import type { InjectiveAuctionRpc } from '@injectivelabs/indexer-proto-ts';
 /**
  * @category Indexer Stream Transformer
  */
 export declare class IndexerAuctionStreamTransformer {
     static bidsStreamCallback: (response: InjectiveAuctionRpc.StreamBidsResponse) => {
-        bid: IndexerBid;
+        bid: IndexerAuctionBid;
         operation: "insert";
     };
 }

package/dist/cjs/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/cjs/client/indexer/transformers/IndexerGrpcAuctionTransformer.js

@@ -1,19 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexerGrpcAuctionTransformer = void 0;
-const IndexerCommonTransformer_js_1 = require("./IndexerCommonTransformer.js");
 /**
  * @category Indexer Grpc Transformer
  */
 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 {
@@ -25,15 +29,53 @@ class IndexerGrpcAuctionTransformer {
     static grpcAuctionToAuction(grpcAuction) {
         return {
             winner: grpcAuction.winner,
-            basketList: grpcAuction.basket.map(IndexerCommonTransformer_js_1.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),
+        };
     }
 }
 exports.IndexerGrpcAuctionTransformer = IndexerGrpcAuctionTransformer;

package/dist/cjs/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/cjs/client/indexer/transformers/IndexerGrpcMegaVaultTransformer.js

@@ -0,0 +1,230 @@
+"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,
+            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,
+        };
+    }
+}
+exports.IndexerGrpcMegaVaultTransformer = IndexerGrpcMegaVaultTransformer;

package/dist/cjs/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/cjs/client/indexer/transformers/index.js

@@ -28,6 +28,7 @@ __exportStar(require("./IndexerOracleStreamTransformer.js"), exports);
 __exportStar(require("./IndexerRestExplorerTransformer.js"), exports);
 __exportStar(require("./IndexerAccountStreamTransformer.js"), exports);
 __exportStar(require("./IndexerAuctionStreamTransformer.js"), exports);
+__exportStar(require("./IndexerGrpcMegaVaultTransformer.js"), exports);
 __exportStar(require("./IndexerArchiverStreamTransformer.js"), exports);
 __exportStar(require("./IndexerExplorerStreamTransformer.js"), exports);
 __exportStar(require("./IndexerGrpcDerivativeTransformer.js"), exports);