@injectivelabs/sdk-ts 1.16.16 → 1.16.18

package/dist/esm/client/chain/transformers/ChainGrpcWasmTransformer.js

@@ -1,5 +1,5 @@
 import { fromUtf8 } from '../../../utils/index.js';
-import { grpcPaginationToPagination } from './../../../utils/pagination.js';
+import { ChainGrpcCommonTransformer } from './ChainGrpcCommonTransformer.js';
 /**
  * @category Chain Grpc Transformer
  */
@@ -37,7 +37,7 @@ export class ChainGrpcWasmTransformer {
             tokenInfo: JSON.parse(tokenInfoValue || '{}'),
             contractInfo: JSON.parse(contractInfoValue || '{}'),
             marketingInfo: JSON.parse(marketingInfoValue || '{}'),
-            pagination: grpcPaginationToPagination(response.pagination),
+            pagination: ChainGrpcCommonTransformer.grpcPaginationToPagination(response.pagination),
         };
     }
     static allContractStateResponseToContractState(response) {
@@ -73,7 +73,7 @@ export class ChainGrpcWasmTransformer {
             tokenInfo: JSON.parse(tokenInfoValue || '{}'),
             contractInfo: JSON.parse(contractInfoValue || '{}'),
             marketingInfo: JSON.parse(marketingInfoValue || '{}'),
-            pagination: grpcPaginationToPagination(response.pagination),
+            pagination: ChainGrpcCommonTransformer.grpcPaginationToPagination(response.pagination),
         };
     }
     static contactInfoResponseToContractInfo(contractInfo) {
@@ -114,13 +114,13 @@ export class ChainGrpcWasmTransformer {
     static contactHistoryResponseToContractHistory(response) {
         return {
             entriesList: response.entries.map(ChainGrpcWasmTransformer.grpcContractCodeHistoryEntryToContractCodeHistoryEntry),
-            pagination: grpcPaginationToPagination(response.pagination),
+            pagination: ChainGrpcCommonTransformer.grpcPaginationToPagination(response.pagination),
         };
     }
     static contractCodesResponseToContractCodes(response) {
         return {
             codeInfosList: response.codeInfos.map(ChainGrpcWasmTransformer.grpcCodeInfoResponseToCodeInfoResponse),
-            pagination: grpcPaginationToPagination(response.pagination),
+            pagination: ChainGrpcCommonTransformer.grpcPaginationToPagination(response.pagination),
         };
     }
     static contractCodeResponseToContractCode(response) {
@@ -132,7 +132,7 @@ export class ChainGrpcWasmTransformer {
     static contractByCodeResponseToContractByCode(response) {
         return {
             contractsList: response.contracts,
-            pagination: grpcPaginationToPagination(response.pagination),
+            pagination: ChainGrpcCommonTransformer.grpcPaginationToPagination(response.pagination),
         };
     }
 }

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

@@ -1,16 +1,19 @@
-export * from './ChainGrpcAuctionTransformer.js';
+export * from './ChainGrpcGovTransformer.js';
+export * from './ChainGrpcEvmTransformer.js';
 export * from './ChainGrpcAuthTransformer.js';
-export * from './ChainGrpcAuthZTransformer.js';
 export * from './ChainGrpcBankTransformer.js';
-export * from './ChainGrpcDistributionTransformer.js';
-export * from './ChainGrpcExchangeTransformer.js';
-export * from './ChainGrpcExchangeTransformer.js';
-export * from './ChainGrpcGovTransformer.js';
-export * from './ChainGrpcInsuranceFundTransformer.js';
 export * from './ChainGrpcMintTransformer.js';
+export * from './ChainGrpcWasmTransformer.js';
+export * from './ChainGrpcAuthZTransformer.js';
 export * from './ChainGrpcPeggyTransformer.js';
-export * from './ChainGrpcPermissionsTransformer.js';
+export * from './ChainGrpcErc20Transformer.js';
+export * from './ChainGrpcTxFeesTransformer.js';
+export * from './ChainGrpcCommonTransformer.js';
+export * from './ChainGrpcAuctionTransformer.js';
 export * from './ChainGrpcStakingTransformer.js';
+export * from './ChainGrpcExchangeTransformer.js';
+export * from './ChainGrpcExchangeTransformer.js';
+export * from './ChainGrpcPermissionsTransformer.js';
+export * from './ChainGrpcDistributionTransformer.js';
 export * from './ChainGrpcTokenFactoryTransformer.js';
-export * from './ChainGrpcWasmTransformer.js';
-export * from './ChainGrpcTxFeesTransformer.js';
+export * from './ChainGrpcInsuranceFundTransformer.js';

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

@@ -1,16 +1,19 @@
-export * from './ChainGrpcAuctionTransformer.js';
+export * from './ChainGrpcGovTransformer.js';
+export * from './ChainGrpcEvmTransformer.js';
 export * from './ChainGrpcAuthTransformer.js';
-export * from './ChainGrpcAuthZTransformer.js';
 export * from './ChainGrpcBankTransformer.js';
-export * from './ChainGrpcDistributionTransformer.js';
-export * from './ChainGrpcExchangeTransformer.js';
-export * from './ChainGrpcExchangeTransformer.js';
-export * from './ChainGrpcGovTransformer.js';
-export * from './ChainGrpcInsuranceFundTransformer.js';
 export * from './ChainGrpcMintTransformer.js';
+export * from './ChainGrpcWasmTransformer.js';
+export * from './ChainGrpcAuthZTransformer.js';
 export * from './ChainGrpcPeggyTransformer.js';
-export * from './ChainGrpcPermissionsTransformer.js';
+export * from './ChainGrpcErc20Transformer.js';
+export * from './ChainGrpcTxFeesTransformer.js';
+export * from './ChainGrpcCommonTransformer.js';
+export * from './ChainGrpcAuctionTransformer.js';
 export * from './ChainGrpcStakingTransformer.js';
+export * from './ChainGrpcExchangeTransformer.js';
+export * from './ChainGrpcExchangeTransformer.js';
+export * from './ChainGrpcPermissionsTransformer.js';
+export * from './ChainGrpcDistributionTransformer.js';
 export * from './ChainGrpcTokenFactoryTransformer.js';
-export * from './ChainGrpcWasmTransformer.js';
-export * from './ChainGrpcTxFeesTransformer.js';
+export * from './ChainGrpcInsuranceFundTransformer.js';

package/dist/esm/client/chain/types/erc20.d.ts

@@ -0,0 +1,13 @@
+import type { Coin } from '@injectivelabs/ts-types';
+import type { InjectiveErc20V1Beta1Erc20, InjectiveErc20V1Beta1Params } from '@injectivelabs/core-proto-ts';
+export interface TokenPair {
+    /** bank denom */
+    bankDenom: string;
+    /** address of erc20 smart contract that is backed by */
+    erc20Address: string;
+}
+export interface Params {
+    denomCreationFee?: Coin;
+}
+export type GrpcParams = InjectiveErc20V1Beta1Params.Params;
+export type GrpcTokenPair = InjectiveErc20V1Beta1Erc20.TokenPair;

package/dist/esm/client/chain/types/erc20.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/client/chain/types/evm.d.ts

@@ -0,0 +1,62 @@
+import type { InjectiveEvmV1Log, InjectiveEvmV1Params, InjectiveEvmV1ChainConfig } from '@injectivelabs/core-proto-ts';
+export interface EvmLog {
+    address: string;
+    topics: string[];
+    data: Uint8Array;
+    blockNumber: string;
+    txHash: string;
+    txIndex: string;
+    blockHash: string;
+    index: string;
+    removed: boolean;
+}
+export interface EvmBlobConfig {
+    target: string;
+    max: string;
+    baseFeeUpdateFraction: string;
+}
+export interface EvmBlobScheduleConfig {
+    cancun?: EvmBlobConfig;
+    prague?: EvmBlobConfig;
+    osaka?: EvmBlobConfig;
+    verkle?: EvmBlobConfig;
+}
+export interface EvmChainConfig {
+    homesteadBlock: string;
+    daoForkBlock: string;
+    daoForkSupport: boolean;
+    eip150Block: string;
+    eip150Hash: string;
+    eip155Block: string;
+    eip158Block: string;
+    byzantiumBlock: string;
+    constantinopleBlock: string;
+    petersburgBlock: string;
+    istanbulBlock: string;
+    muirGlacierBlock: string;
+    berlinBlock: string;
+    londonBlock: string;
+    arrowGlacierBlock: string;
+    grayGlacierBlock: string;
+    mergeNetsplitBlock: string;
+    shanghaiTime: string;
+    cancunTime: string;
+    pragueTime: string;
+    eip155ChainId: string;
+    blobScheduleConfig?: EvmBlobScheduleConfig;
+}
+export interface EvmParams {
+    evmDenom: string;
+    enableCreate: boolean;
+    enableCall: boolean;
+    extraEips: string[];
+    chainConfig?: EvmChainConfig;
+    allowUnprotectedTxs: boolean;
+    authorizedDeployers: string[];
+    permissioned: boolean;
+}
+export type GrpcEvmLog = InjectiveEvmV1Log.Log;
+export type GrpcEvmParams = InjectiveEvmV1Params.Params;
+export type GrpcEvmChainConfig = InjectiveEvmV1ChainConfig.ChainConfig;
+export type GrpcEvmBlobScheduleConfig = InjectiveEvmV1ChainConfig.BlobScheduleConfig;
+export type GrpcEvmBlobConfig = InjectiveEvmV1ChainConfig.BlobConfig;

package/dist/esm/client/chain/types/evm.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,42 +1,46 @@
 export * from './gov.js';
+export * from './wasm.js';
+export * from './staking.js';
+export * from './exchange.js';
+export type * from './evm.js';
 export type * from './auth.js';
 export type * from './bank.js';
 export type * from './mint.js';
-export * from './wasm.js';
+export * from './insurance.js';
 export type * from './authZ.js';
 export type * from './peggy.js';
+export type * from './erc20.js';
 export type * from './txFees.js';
 export type * from './oracle.js';
+export * from './permissions.js';
 export type * from './auction.js';
-export * from './staking.js';
-export * from './exchange.js';
 export type * from './auth-rest.js';
 export type * from './bank-rest.js';
-export * from './insurance.js';
 export type * from './distribution.js';
 export type * from './tokenfactory.js';
 export type * from './tendermint-rest.js';
-export * from './permissions.js';
 export interface RestApiResponse<T> {
     data: T;
 }
 export declare const ChainModule: {
-    Auction: "chain-auction";
-    Auth: "chain-auth";
-    Authz: "chain-authz";
-    Bank: "chain-bank";
-    Distribution: "chain-distribution";
-    Exchange: "chain-exchange";
     Gov: "chain-gov";
     Ibc: "chain-ibc";
-    InsuranceFund: "chain-insurance";
+    Evm: "chain-evm";
+    Auth: "chain-auth";
+    Bank: "chain-bank";
     Mint: "chain-mint";
-    Oracle: "chain-oracle";
-    Peggy: "chain-peggy";
-    Staking: "chain-staking";
     Wasm: "chain-wasm";
+    Authz: "chain-authz";
+    Peggy: "chain-peggy";
     WasmX: "chain-wasmx";
+    Erc20: "chain-erc20";
+    Oracle: "chain-oracle";
+    TxFees: "chain-tx-fees";
+    Auction: "chain-auction";
+    Staking: "chain-staking";
+    Exchange: "chain-exchange";
     Tendermint: "chain-tendermint";
+    InsuranceFund: "chain-insurance";
     Permissions: "chain-permissions";
-    TxFees: "chain-tx-fees";
+    Distribution: "chain-distribution";
 };

package/dist/esm/client/indexer/grpc/IndexerGrpcAuctionApi.d.ts

@@ -9,8 +9,26 @@ export declare class IndexerGrpcAuctionApi extends BaseGrpcConsumer {
     constructor(endpoint: string);
     fetchAuction(round?: number): Promise<{
         auction: import("../types/auction.js").Auction;
-        bids: import("../types/auction.js").IndexerBid[];
+        bids: import("../types/auction.js").IndexerAuctionBid[];
     }>;
     fetchAuctions(): Promise<import("../types/auction.js").Auction[]>;
     fetchInjBurnt(): Promise<number>;
+    fetchAuctionsHistoryV2({ token, endTime, perPage, }: {
+        token?: string;
+        endTime?: string;
+        perPage?: number;
+    }): Promise<{
+        auctions: import("../types/auction.js").AuctionV2[];
+        next: string[];
+    }>;
+    fetchAuctionV2(round?: number | string): Promise<import("../types/auction.js").AuctionV2>;
+    fetchAccountAuctionsV2({ token, address, perPage, }: {
+        token?: string;
+        address: string;
+        perPage?: number;
+    }): Promise<{
+        auctions: import("../types/auction.js").AccountAuctionV2[];
+        next: string[];
+        total: string;
+    }>;
 }

package/dist/esm/client/indexer/grpc/IndexerGrpcAuctionApi.js

@@ -66,7 +66,7 @@ export class IndexerGrpcAuctionApi extends BaseGrpcConsumer {
         const request = {};
         try {
             const response = await this.retry(() => this.client.InjBurntEndpoint(request, this.metadata));
-            return IndexerGrpcAuctionTransformer.injBurntResponseToInjBurnt(response);
+            return Number(response.totalInjBurnt);
         }
         catch (e) {
             if (e instanceof InjectiveAuctionRpc.GrpcWebError) {
@@ -83,4 +83,82 @@ export class IndexerGrpcAuctionApi extends BaseGrpcConsumer {
             });
         }
     }
+    async fetchAuctionsHistoryV2({ token, endTime, perPage = 5, }) {
+        const request = InjectiveAuctionRpc.AuctionsHistoryV2Request.create();
+        request.perPage = perPage;
+        if (endTime) {
+            request.endTime = endTime;
+        }
+        if (token) {
+            request.token = token;
+        }
+        try {
+            const response = await this.retry(() => this.client.AuctionsHistoryV2(request, this.metadata));
+            return IndexerGrpcAuctionTransformer.auctionsHistoryV2ResponseToAuctionHistory(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveAuctionRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'AuctionsV2',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'AuctionsV2',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchAuctionV2(round = -1) {
+        const request = InjectiveAuctionRpc.AuctionV2Request.create();
+        if (round) {
+            request.round = round.toString();
+        }
+        try {
+            const response = await this.retry(() => this.client.AuctionV2(request, this.metadata));
+            return IndexerGrpcAuctionTransformer.grpcAuctionV2ToAuctionV2(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveAuctionRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'AuctionV2',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'AuctionV2',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchAccountAuctionsV2({ token, address, perPage = 5, }) {
+        const request = InjectiveAuctionRpc.AccountAuctionsV2Request.create();
+        request.address = address;
+        request.perPage = perPage;
+        if (token) {
+            request.token = token.toString();
+        }
+        try {
+            const response = await this.retry(() => this.client.AccountAuctionsV2(request, this.metadata));
+            return IndexerGrpcAuctionTransformer.accountAuctionsV2ResponseToAccountAuctionsV2(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveAuctionRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: grpcErrorCodeToErrorCode(e.code),
+                    context: 'AccountAuctionsV2',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'AccountAuctionsV2',
+                contextModule: this.module,
+            });
+        }
+    }
 }

package/dist/esm/client/indexer/grpc/IndexerGrpcMegaVaultApi.d.ts

@@ -0,0 +1,45 @@
+import { InjectiveMegaVaultRpc } from '@injectivelabs/indexer-proto-ts';
+import BaseGrpcConsumer from '../../base/BaseIndexerGrpcConsumer.js';
+/**
+ * @category Indexer Grpc API
+ */
+export declare class IndexerGrpcMegaVaultApi extends BaseGrpcConsumer {
+    protected module: string;
+    protected client: InjectiveMegaVaultRpc.InjectiveMegavaultRPCClientImpl;
+    constructor(endpoint: string);
+    fetchVault({ vaultAddress }: {
+        vaultAddress: string;
+    }): Promise<import("../types/mega-vault.js").MegaVault | undefined>;
+    fetchVaultUser({ vaultAddress, userAddress, }: {
+        userAddress: string;
+        vaultAddress: string;
+    }): Promise<import("../types/mega-vault.js").MegaVaultUser | undefined>;
+    fetchVaultSubscriptions({ token, status, perPage, userAddress, vaultAddress, }: {
+        token?: string;
+        status?: string;
+        perPage?: number;
+        userAddress: string;
+        vaultAddress: string;
+    }): Promise<import("../types/mega-vault.js").MegaVaultSubscription[]>;
+    fetchVaultRedemptions({ token, status, perPage, userAddress, vaultAddress, }: {
+        token?: string;
+        status?: string;
+        perPage?: number;
+        vaultAddress: string;
+        userAddress: string;
+    }): Promise<import("../types/mega-vault.js").MegaVaultRedemption[]>;
+    fetchOperatorRedemptionBuckets({ vaultAddress, operatorAddress, }: {
+        vaultAddress: string;
+        operatorAddress: string;
+    }): Promise<import("../types/mega-vault.js").MegaVaultOperatorRedemptionBucket[]>;
+    fetchVaultTvlHistory({ since, vaultAddress, maxDataPoints, }: {
+        since: number;
+        vaultAddress: string;
+        maxDataPoints?: number;
+    }): Promise<import("../types/mega-vault.js").MegaVaultHistoricalTVL[]>;
+    fetchVaultPnlHistory({ since, vaultAddress, maxDataPoints, }: {
+        since: number;
+        vaultAddress: string;
+        maxDataPoints?: number;
+    }): Promise<import("../types/mega-vault.js").MegaVaultHistoricalPnL[]>;
+}

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

@@ -0,0 +1,200 @@
+import { InjectiveMegaVaultRpc } from '@injectivelabs/indexer-proto-ts';
+import { UnspecifiedErrorCode, GrpcUnaryRequestException, } from '@injectivelabs/exceptions';
+import { IndexerModule } from '../types/index.js';
+import BaseGrpcConsumer from '../../base/BaseIndexerGrpcConsumer.js';
+import { IndexerGrpcMegaVaultTransformer } from '../transformers/index.js';
+/**
+ * @category Indexer Grpc API
+ */
+export class IndexerGrpcMegaVaultApi extends BaseGrpcConsumer {
+    module = IndexerModule.MegaVault;
+    client;
+    constructor(endpoint) {
+        super(endpoint);
+        this.client = new InjectiveMegaVaultRpc.InjectiveMegavaultRPCClientImpl(this.getGrpcWebImpl(endpoint));
+    }
+    async fetchVault({ vaultAddress }) {
+        const request = InjectiveMegaVaultRpc.GetVaultRequest.create();
+        request.vaultAddress = vaultAddress;
+        try {
+            const response = await this.retry(() => this.client.GetVault(request, this.metadata));
+            return IndexerGrpcMegaVaultTransformer.vaultResponseToVault(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchVault',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'fetchVault',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchVaultUser({ vaultAddress, userAddress, }) {
+        const request = InjectiveMegaVaultRpc.GetUserRequest.create();
+        request.vaultAddress = vaultAddress;
+        request.userAddress = userAddress;
+        try {
+            const response = await this.retry(() => this.client.GetUser(request, this.metadata));
+            return IndexerGrpcMegaVaultTransformer.userResponseToUser(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchVaultUser',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'fetchVaultUser',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchVaultSubscriptions({ token, status, perPage, userAddress, vaultAddress, }) {
+        const request = 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 IndexerGrpcMegaVaultTransformer.subscriptionsResponseToSubscriptions(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchVaultSubscriptions',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'fetchVaultSubscriptions',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchVaultRedemptions({ token, status, perPage, userAddress, vaultAddress, }) {
+        const request = 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 IndexerGrpcMegaVaultTransformer.redemptionsResponseToRedemptions(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchVaultRedemptions',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'fetchVaultRedemptions',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchOperatorRedemptionBuckets({ vaultAddress, operatorAddress, }) {
+        const request = InjectiveMegaVaultRpc.GetOperatorRedemptionBucketsRequest.create();
+        request.vaultAddress = vaultAddress;
+        request.operatorAddress = operatorAddress;
+        try {
+            const response = await this.retry(() => this.client.GetOperatorRedemptionBuckets(request, this.metadata));
+            return IndexerGrpcMegaVaultTransformer.operatorRedemptionBucketsResponseToOperatorRedemptionBuckets(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchOperatorRedemptionBuckets',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'fetchOperatorRedemptionBuckets',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchVaultTvlHistory({ since, vaultAddress, maxDataPoints, }) {
+        const request = 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 IndexerGrpcMegaVaultTransformer.tvlHistoryResponseToTvlHistory(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchVaultTvlHistory',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'fetchVaultTvlHistory',
+                contextModule: this.module,
+            });
+        }
+    }
+    async fetchVaultPnlHistory({ since, vaultAddress, maxDataPoints, }) {
+        const request = 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 IndexerGrpcMegaVaultTransformer.pnlHistoryResponseToPnlHistory(response);
+        }
+        catch (e) {
+            if (e instanceof InjectiveMegaVaultRpc.GrpcWebError) {
+                throw new GrpcUnaryRequestException(new Error(e.toString()), {
+                    code: e.code,
+                    context: 'fetchVaultPnlHistory',
+                    contextModule: this.module,
+                });
+            }
+            throw new GrpcUnaryRequestException(e, {
+                code: UnspecifiedErrorCode,
+                context: 'fetchVaultPnlHistory',
+                contextModule: this.module,
+            });
+        }
+    }
+}

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

@@ -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/esm/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";
     };
 }