@injectivelabs/sdk-ts 1.15.0 → 1.15.2

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

@@ -0,0 +1,66 @@
+import { IndexerCommonTransformer } from './IndexerCommonTransformer.js';
+import { IndexerGrpcDerivativeTransformer } from './IndexerGrpcDerivativeTransformer.js';
+export class IndexerGrpcAccountPortfolioTransformer {
+    static accountPortfolioResponseToAccountPortfolio(response, address) {
+        const portfolio = response.portfolio;
+        const bankBalancesList = portfolio?.bankBalances || [];
+        const subaccountList = portfolio?.subaccounts || [];
+        const positionsWithUpnlList = portfolio?.positionsWithUpnl || [];
+        if (!portfolio) {
+            return {
+                accountAddress: address || '',
+                bankBalancesList: [],
+                subaccountsList: [],
+                positionsWithUpnlList: [],
+            };
+        }
+        return {
+            accountAddress: portfolio.accountAddress,
+            bankBalancesList: bankBalancesList.map(IndexerCommonTransformer.grpcCoinToCoin),
+            subaccountsList: subaccountList.map(IndexerGrpcAccountPortfolioTransformer.grpcSubaccountBalanceToSubaccountBalance),
+            positionsWithUpnlList: positionsWithUpnlList.map(IndexerGrpcAccountPortfolioTransformer.grpcPositionWithUPNLToPositionWithUPNL),
+        };
+    }
+    static accountPortfolioBalancesResponseToAccountPortfolioBalances(response, address) {
+        const portfolio = response.portfolio;
+        const bankBalancesList = portfolio?.bankBalances || [];
+        const subaccountList = portfolio?.subaccounts || [];
+        if (!portfolio) {
+            return {
+                accountAddress: address || '',
+                bankBalancesList: [],
+                subaccountsList: [],
+            };
+        }
+        return {
+            accountAddress: portfolio.accountAddress,
+            bankBalancesList: bankBalancesList.map(IndexerCommonTransformer.grpcCoinToCoin),
+            subaccountsList: subaccountList.map(IndexerGrpcAccountPortfolioTransformer.grpcSubaccountBalanceToSubaccountBalance),
+        };
+    }
+    static grpcPositionWithUPNLToPositionWithUPNL(positionsWithUPNL) {
+        const grpcPosition = positionsWithUPNL.position;
+        return {
+            position: grpcPosition
+                ? IndexerGrpcDerivativeTransformer.grpcPositionToPosition(grpcPosition)
+                : undefined,
+            unrealizedPnl: positionsWithUPNL.unrealizedPnl,
+        };
+    }
+    static grpcSubaccountDepositToSubaccountDeposit(subaccountDeposit) {
+        return {
+            totalBalance: subaccountDeposit.totalBalance,
+            availableBalance: subaccountDeposit.availableBalance,
+        };
+    }
+    static grpcSubaccountBalanceToSubaccountBalance(subaccountBalance) {
+        const deposit = subaccountBalance.deposit;
+        return {
+            subaccountId: subaccountBalance.subaccountId,
+            denom: subaccountBalance.denom,
+            deposit: deposit
+                ? IndexerGrpcAccountPortfolioTransformer.grpcSubaccountDepositToSubaccountDeposit(deposit)
+                : undefined,
+        };
+    }
+}

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

@@ -0,0 +1,12 @@
+import { StreamOperation } from '../../../types/index.js';
+import { InjectiveAccountRpc } from '@injectivelabs/indexer-proto-ts';
+/**
+ * @category Indexer Stream Transformer
+ */
+export declare class IndexerAccountStreamTransformer {
+    static balanceStreamCallback: (response: InjectiveAccountRpc.StreamSubaccountBalanceResponse) => {
+        balance: import("../index.js").SubaccountBalance | undefined;
+        operation: StreamOperation;
+        timestamp: string;
+    };
+}

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

@@ -0,0 +1,17 @@
+import { IndexerGrpcAccountTransformer } from './IndexerGrpcAccountTransformer.js';
+import { StreamOperation } from '../../../types/index.js';
+/**
+ * @category Indexer Stream Transformer
+ */
+export class IndexerAccountStreamTransformer {
+    static balanceStreamCallback = (response) => {
+        const balance = response.balance;
+        return {
+            balance: balance
+                ? IndexerGrpcAccountTransformer.grpcBalanceToBalance(balance)
+                : undefined,
+            operation: StreamOperation.Update,
+            timestamp: response.timestamp,
+        };
+    };
+}

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

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

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

@@ -0,0 +1,14 @@
+import { StreamOperation } from '@injectivelabs/ts-types';
+/**
+ * @category Indexer Stream Transformer
+ */
+export class IndexerAuctionStreamTransformer {
+    static bidsStreamCallback = (response) => ({
+        bid: {
+            bidder: response.bidder,
+            bidAmount: response.bidAmount,
+            bidTimestamp: parseInt(response.timestamp, 10),
+        },
+        operation: StreamOperation.Insert,
+    });
+}

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

@@ -0,0 +1,38 @@
+import { InjectiveCampaignRpc } from '@injectivelabs/indexer-proto-ts';
+import { Guild, Campaign, CampaignV2, GuildMember, CampaignUser, GuildCampaignSummary } from '../types/campaign.js';
+export declare class IndexerCampaignTransformer {
+    static GrpcCampaignUserToCampaignUser(campaignUser: InjectiveCampaignRpc.CampaignUser): CampaignUser;
+    static GrpcCampaignToCampaign(campaign: InjectiveCampaignRpc.Campaign): Campaign;
+    static GrpcGuildToGuild(guild: InjectiveCampaignRpc.Guild): Guild;
+    static GrpcGuildMemberToGuildMember(member: InjectiveCampaignRpc.GuildMember): GuildMember;
+    static GrpcGuildCampaignSummaryToGuildCampaignSummary(campaignSummary: InjectiveCampaignRpc.CampaignSummary): GuildCampaignSummary;
+    static CampaignResponseToCampaign(response: InjectiveCampaignRpc.RankingResponse): {
+        campaign: Campaign | undefined;
+        users: CampaignUser[];
+        paging: import("../../../index.js").ExchangePagination;
+    };
+    static RoundsResponseToRounds(response: InjectiveCampaignRpc.CampaignsResponse): {
+        campaigns: Campaign[];
+        accumulatedRewards: InjectiveCampaignRpc.Coin[];
+        rewardCount: number;
+    };
+    static GuildsResponseToGuilds(response: InjectiveCampaignRpc.ListGuildsResponse): {
+        guilds: Guild[];
+        paging: import("../../../index.js").ExchangePagination;
+        updatedAt: number;
+        summary: GuildCampaignSummary | undefined;
+    };
+    static GuildMemberResponseToGuildMember(response: InjectiveCampaignRpc.GetGuildMemberResponse): {
+        info: GuildMember | undefined;
+    };
+    static GuildMembersResponseToGuildMembers(response: InjectiveCampaignRpc.ListGuildMembersResponse): {
+        members: GuildMember[];
+        paging: import("../../../index.js").ExchangePagination;
+        guildInfo: Guild | undefined;
+    };
+    static GrpcCampaignV2ToCampaignV2(campaign: InjectiveCampaignRpc.CampaignV2): CampaignV2;
+    static CampaignsV2ResponseToCampaigns(response: InjectiveCampaignRpc.CampaignsV2Response): {
+        campaigns: CampaignV2[];
+        cursor: string;
+    };
+}

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

@@ -0,0 +1,151 @@
+import { grpcPagingToPaging } from '../../..//utils/pagination.js';
+import { IndexerCommonTransformer } from './IndexerCommonTransformer.js';
+export class IndexerCampaignTransformer {
+    static GrpcCampaignUserToCampaignUser(campaignUser) {
+        return {
+            campaignId: campaignUser.campaignId,
+            marketId: campaignUser.marketId,
+            accountAddress: campaignUser.accountAddress,
+            score: campaignUser.score,
+            contractUpdated: campaignUser.contractUpdated,
+            blockHeight: campaignUser.blockHeight,
+            blockTime: parseInt(campaignUser.blockTime, 10),
+            purchasedAmount: campaignUser.purchasedAmount,
+            galxeUpdated: campaignUser.galxeUpdated,
+        };
+    }
+    static GrpcCampaignToCampaign(campaign) {
+        return {
+            campaignId: campaign.campaignId,
+            marketId: campaign.marketId,
+            totalScore: campaign.totalScore,
+            lastUpdated: parseInt(campaign.lastUpdated, 10),
+            startDate: parseInt(campaign.startDate, 10),
+            endDate: parseInt(campaign.endDate, 10),
+            isClaimable: campaign.isClaimable,
+            rewards: campaign.rewards,
+            roundId: campaign.roundId,
+            userClaimed: campaign.userClaimed,
+            userScore: campaign.userScore,
+            rewardContract: campaign.rewardContract,
+            version: campaign.version,
+        };
+    }
+    static GrpcGuildToGuild(guild) {
+        return {
+            campaignContract: guild.campaignContract,
+            guildId: guild.guildId,
+            masterAddress: guild.masterAddress,
+            createdAt: parseInt(guild.createdAt, 10),
+            tvlScore: guild.tvlScore,
+            volumeScore: guild.volumeScore,
+            rankByVolume: guild.rankByVolume,
+            rankByTvl: guild.rankByTvl,
+            logo: guild.logo,
+            totalTvl: guild.totalTvl,
+            updatedAt: parseInt(guild.updatedAt, 10),
+            name: guild.name,
+            isActive: guild.isActive,
+            masterBalance: guild.masterBalance,
+            description: guild.description,
+        };
+    }
+    static GrpcGuildMemberToGuildMember(member) {
+        return {
+            campaignContract: member.campaignContract,
+            guildId: member.guildId,
+            address: member.address,
+            joinedAt: parseInt(member.joinedAt, 10),
+            tvlScore: member.tvlScore,
+            volumeScore: member.volumeScore,
+            totalTvl: member.totalTvl,
+            volumeScorePercentage: member.volumeScorePercentage,
+            tvlScorePercentage: member.tvlScorePercentage,
+            tvlReward: member.tvlReward.map(IndexerCommonTransformer.grpcCoinToCoin),
+            volumeReward: member.volumeReward.map(IndexerCommonTransformer.grpcCoinToCoin),
+        };
+    }
+    static GrpcGuildCampaignSummaryToGuildCampaignSummary(campaignSummary) {
+        return {
+            campaignId: campaignSummary.campaignId,
+            campaignContract: campaignSummary.campaignContract,
+            totalGuildsCount: campaignSummary.totalGuildsCount,
+            totalTvl: campaignSummary.totalTvl,
+            totalAverageTvl: campaignSummary.totalAverageTvl,
+            totalVolume: campaignSummary.totalVolume,
+            updatedAt: parseInt(campaignSummary.updatedAt, 10),
+            totalMembersCount: campaignSummary.totalMembersCount,
+            startTime: parseInt(campaignSummary.startTime, 10),
+            endTime: parseInt(campaignSummary.endTime, 10),
+        };
+    }
+    static CampaignResponseToCampaign(response) {
+        return {
+            campaign: response.campaign
+                ? IndexerCampaignTransformer.GrpcCampaignToCampaign(response.campaign)
+                : undefined,
+            users: response.users.map(IndexerCampaignTransformer.GrpcCampaignUserToCampaignUser),
+            paging: grpcPagingToPaging(response.paging),
+        };
+    }
+    static RoundsResponseToRounds(response) {
+        return {
+            campaigns: response.campaigns.map((campaign) => IndexerCampaignTransformer.GrpcCampaignToCampaign(campaign)),
+            accumulatedRewards: response.accumulatedRewards,
+            rewardCount: response.rewardCount,
+        };
+    }
+    static GuildsResponseToGuilds(response) {
+        return {
+            guilds: response.guilds.map(IndexerCampaignTransformer.GrpcGuildToGuild),
+            paging: grpcPagingToPaging(response.paging),
+            updatedAt: parseInt(response.updatedAt, 10),
+            summary: response.campaignSummary
+                ? IndexerCampaignTransformer.GrpcGuildCampaignSummaryToGuildCampaignSummary(response.campaignSummary)
+                : undefined,
+        };
+    }
+    static GuildMemberResponseToGuildMember(response) {
+        return {
+            info: response.info
+                ? IndexerCampaignTransformer.GrpcGuildMemberToGuildMember(response.info)
+                : undefined,
+        };
+    }
+    static GuildMembersResponseToGuildMembers(response) {
+        return {
+            members: response.members.map(IndexerCampaignTransformer.GrpcGuildMemberToGuildMember),
+            paging: grpcPagingToPaging(response.paging),
+            guildInfo: response.guildInfo
+                ? IndexerCampaignTransformer.GrpcGuildToGuild(response.guildInfo)
+                : undefined,
+        };
+    }
+    static GrpcCampaignV2ToCampaignV2(campaign) {
+        return {
+            campaignId: campaign.campaignId,
+            marketId: campaign.marketId,
+            totalScore: campaign.totalScore,
+            createdAt: campaign.createdAt,
+            updatedAt: campaign.updatedAt,
+            startDate: campaign.startDate,
+            endDate: campaign.endDate,
+            isClaimable: campaign.isClaimable,
+            roundId: campaign.roundId,
+            managerContract: campaign.managerContract,
+            rewards: campaign.rewards.map(IndexerCommonTransformer.grpcCoinToCoin),
+            subaccountIdSuffix: campaign.subaccountIdSuffix,
+            rewardContract: campaign.rewardContract,
+            type: campaign.type,
+            version: campaign.version,
+            name: campaign.name,
+            description: campaign.description,
+        };
+    }
+    static CampaignsV2ResponseToCampaigns(response) {
+        return {
+            campaigns: response.campaigns.map(IndexerCampaignTransformer.GrpcCampaignV2ToCampaignV2),
+            cursor: response.cursor,
+        };
+    }
+}

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

@@ -0,0 +1,5 @@
+import { Coin } from '@injectivelabs/ts-types';
+import { GrpcCoin } from '../../../types/index.js';
+export declare class IndexerCommonTransformer {
+    static grpcCoinToCoin(coin: GrpcCoin): Coin;
+}

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

@@ -0,0 +1,8 @@
+export class IndexerCommonTransformer {
+    static grpcCoinToCoin(coin) {
+        return {
+            denom: coin.denom,
+            amount: coin.amount,
+        };
+    }
+}

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

@@ -0,0 +1,42 @@
+import { StreamOperation } from '../../../types/index.js';
+import { InjectiveDerivativeExchangeRpc } from '@injectivelabs/indexer-proto-ts';
+/**
+ * @category Indexer Stream Transformer
+ */
+export declare class IndexerDerivativeStreamTransformer {
+    static tradesStreamCallback: (response: InjectiveDerivativeExchangeRpc.StreamTradesResponse) => {
+        trade: import("../index.js").DerivativeTrade | undefined;
+        operation: StreamOperation;
+        timestamp: string;
+    };
+    static positionStreamCallback: (response: InjectiveDerivativeExchangeRpc.StreamPositionsResponse) => {
+        position: import("../index.js").Position | undefined;
+        timestamp: string;
+    };
+    static ordersStreamCallback: (response: InjectiveDerivativeExchangeRpc.StreamOrdersResponse) => {
+        order: import("../index.js").DerivativeLimitOrder | undefined;
+        operation: StreamOperation;
+        timestamp: string;
+    };
+    static orderHistoryStreamCallback: (response: InjectiveDerivativeExchangeRpc.StreamOrdersHistoryResponse) => {
+        order: import("../index.js").DerivativeOrderHistory | undefined;
+        operation: StreamOperation;
+        timestamp: string;
+    };
+    static orderbookV2StreamCallback: (response: InjectiveDerivativeExchangeRpc.StreamOrderbookV2Response) => {
+        orderbook: import("../index.js").OrderbookWithSequence | undefined;
+        operation: StreamOperation;
+        marketId: string;
+        timestamp: string;
+    };
+    static orderbookUpdateStreamCallback: (response: InjectiveDerivativeExchangeRpc.StreamOrderbookUpdateResponse) => {
+        orderbook: import("../index.js").OrderbookWithSequence | undefined;
+        operation: StreamOperation;
+        marketId: string;
+        timestamp: string;
+    };
+    static positionV2StreamCallback: (response: InjectiveDerivativeExchangeRpc.StreamPositionsV2Response) => {
+        position: import("../index.js").PositionV2 | undefined;
+        timestamp: string;
+    };
+}

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

@@ -0,0 +1,84 @@
+import { IndexerGrpcDerivativeTransformer } from './IndexerGrpcDerivativeTransformer.js';
+/**
+ * @category Indexer Stream Transformer
+ */
+export class IndexerDerivativeStreamTransformer {
+    static tradesStreamCallback = (response) => {
+        const trade = response.trade;
+        return {
+            trade: trade
+                ? IndexerGrpcDerivativeTransformer.grpcTradeToTrade(trade)
+                : undefined,
+            operation: response.operationType,
+            timestamp: response.timestamp,
+        };
+    };
+    static positionStreamCallback = (response) => {
+        const position = response.position;
+        return {
+            position: position
+                ? IndexerGrpcDerivativeTransformer.grpcPositionToPosition(position)
+                : undefined,
+            timestamp: response.timestamp,
+        };
+    };
+    static ordersStreamCallback = (response) => {
+        const order = response.order;
+        return {
+            order: order
+                ? IndexerGrpcDerivativeTransformer.grpcOrderToOrder(order)
+                : undefined,
+            operation: response.operationType,
+            timestamp: response.timestamp,
+        };
+    };
+    static orderHistoryStreamCallback = (response) => {
+        const order = response.order;
+        return {
+            order: order
+                ? IndexerGrpcDerivativeTransformer.grpcOrderHistoryToOrderHistory(order)
+                : undefined,
+            operation: response.operationType,
+            timestamp: response.timestamp,
+        };
+    };
+    static orderbookV2StreamCallback = (response) => {
+        const orderbook = response.orderbook;
+        return {
+            orderbook: orderbook
+                ? IndexerGrpcDerivativeTransformer.grpcOrderbookV2ToOrderbookV2({
+                    sequence: parseInt(orderbook.sequence, 10),
+                    buys: orderbook.buys,
+                    sells: orderbook.sells,
+                })
+                : undefined,
+            operation: response.operationType,
+            marketId: response.marketId,
+            timestamp: response.timestamp,
+        };
+    };
+    static orderbookUpdateStreamCallback = (response) => {
+        const orderbook = response.orderbookLevelUpdates;
+        return {
+            orderbook: orderbook
+                ? IndexerGrpcDerivativeTransformer.grpcOrderbookV2ToOrderbookV2({
+                    sequence: parseInt(orderbook.sequence, 10),
+                    buys: orderbook.buys,
+                    sells: orderbook.sells,
+                })
+                : undefined,
+            operation: response.operationType,
+            marketId: response.marketId,
+            timestamp: response.timestamp,
+        };
+    };
+    static positionV2StreamCallback = (response) => {
+        const position = response.position;
+        return {
+            position: position
+                ? IndexerGrpcDerivativeTransformer.grpcPositionV2ToPositionV2(position)
+                : undefined,
+            timestamp: response.timestamp,
+        };
+    };
+}

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

@@ -0,0 +1,19 @@
+import { StreamOperation } from '../../../types/index.js';
+import { InjectiveExplorerRpc } from '@injectivelabs/indexer-proto-ts';
+/**
+ * @category Indexer Stream Transformer
+ */
+export declare class ExplorerStreamTransformer {
+    static blocksStreamCallback: (response: InjectiveExplorerRpc.StreamBlocksResponse) => {
+        block: import("../index.js").Block;
+        operation: StreamOperation;
+    };
+    static blocksWithTxsStreamCallback: (response: InjectiveExplorerRpc.StreamBlocksResponse) => {
+        block: import("../index.js").BlockWithTxs;
+        operation: StreamOperation;
+    };
+    static transactionsStreamCallback: (response: InjectiveExplorerRpc.StreamTxsResponse) => {
+        block: import("../index.js").IndexerStreamTransaction;
+        operation: StreamOperation;
+    };
+}

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

@@ -0,0 +1,19 @@
+import { IndexerGrpcExplorerTransformer } from './IndexerGrpcExplorerTransformer.js';
+import { StreamOperation } from '../../../types/index.js';
+/**
+ * @category Indexer Stream Transformer
+ */
+export class ExplorerStreamTransformer {
+    static blocksStreamCallback = (response) => ({
+        block: IndexerGrpcExplorerTransformer.grpcBlockToBlock(response),
+        operation: StreamOperation.Insert,
+    });
+    static blocksWithTxsStreamCallback = (response) => ({
+        block: IndexerGrpcExplorerTransformer.grpcBlockToBlockWithTxs(response),
+        operation: StreamOperation.Insert,
+    });
+    static transactionsStreamCallback = (response) => ({
+        block: IndexerGrpcExplorerTransformer.streamTxResponseToTxs(response),
+        operation: StreamOperation.Insert,
+    });
+}

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

@@ -0,0 +1,32 @@
+import { Coin } from '@injectivelabs/ts-types';
+import { GrpcCoin } from '../../../types/index.js';
+import { TradingReward, AccountPortfolio, SubaccountBalance, SubaccountDeposit, GrpcTradingReward, SubaccountTransfer, SubaccountPortfolio, GrpcAccountPortfolio, GrpcSubaccountBalance, GrpcSubaccountDeposit, GrpcSubaccountPortfolio, GrpcSubaccountBalanceTransfer } from '../types/account.js';
+import { InjectiveAccountRpc } from '@injectivelabs/indexer-proto-ts';
+/**
+ * @category Indexer Grpc Transformer
+ *
+ */
+export declare class IndexerGrpcAccountTransformer {
+    /**
+     *
+     * @deprecated - use IndexerGrpcAccountPortfolioApi.accountPortfolioResponseToAccountPortfolio
+     */
+    static accountPortfolioResponseToAccountPortfolio(response: InjectiveAccountRpc.PortfolioResponse): AccountPortfolio;
+    static grpcSubaccountPortfolioToSubaccountPortfolio(subaccountPortfolio: GrpcSubaccountPortfolio): SubaccountPortfolio;
+    static grpcAccountPortfolioToAccountPortfolio(portfolio: GrpcAccountPortfolio): AccountPortfolio;
+    static grpcAmountToAmount(amount: GrpcCoin): Coin;
+    static grpcDepositToDeposit(deposit: GrpcSubaccountDeposit): SubaccountDeposit;
+    static balancesResponseToBalances(response: InjectiveAccountRpc.SubaccountBalancesListResponse): SubaccountBalance[];
+    static balanceResponseToBalance(response: InjectiveAccountRpc.SubaccountBalanceEndpointResponse): SubaccountBalance;
+    static grpcBalanceToBalance(balance: GrpcSubaccountBalance): SubaccountBalance;
+    static grpcBalancesToBalances(balances: GrpcSubaccountBalance[]): SubaccountBalance[];
+    static grpcTransferHistoryEntryToTransferHistoryEntry(transfer: GrpcSubaccountBalanceTransfer): SubaccountTransfer;
+    static tradingRewardsResponseToTradingRewards(response: InjectiveAccountRpc.RewardsResponse): TradingReward[];
+    static grpcTradingRewardsToTradingRewards(rewards: GrpcTradingReward[]): TradingReward[];
+    static grpcTradingRewardToTradingReward(reward: GrpcTradingReward): TradingReward;
+    static transferHistoryResponseToTransferHistory(response: InjectiveAccountRpc.SubaccountHistoryResponse): {
+        transfers: SubaccountTransfer[];
+        pagination: import("../../../types/pagination.js").ExchangePagination;
+    };
+    static grpcTransferHistoryToTransferHistory(transfers: GrpcSubaccountBalanceTransfer[]): SubaccountTransfer[];
+}

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

@@ -0,0 +1,113 @@
+import { grpcPagingToPaging } from '../../..//utils/pagination.js';
+/**
+ * @category Indexer Grpc Transformer
+ *
+ */
+export class IndexerGrpcAccountTransformer {
+    /**
+     *
+     * @deprecated - use IndexerGrpcAccountPortfolioApi.accountPortfolioResponseToAccountPortfolio
+     */
+    static accountPortfolioResponseToAccountPortfolio(response) {
+        const portfolio = response.portfolio;
+        const subaccounts = portfolio.subaccounts || [];
+        return {
+            portfolioValue: portfolio.portfolioValue,
+            availableBalance: portfolio.availableBalance,
+            lockedBalance: portfolio.lockedBalance,
+            unrealizedPnl: portfolio.unrealizedPnl,
+            subaccountsList: subaccounts.map(IndexerGrpcAccountTransformer.grpcSubaccountPortfolioToSubaccountPortfolio),
+        };
+    }
+    static grpcSubaccountPortfolioToSubaccountPortfolio(subaccountPortfolio) {
+        return {
+            subaccountId: subaccountPortfolio.subaccountId,
+            availableBalance: subaccountPortfolio.availableBalance,
+            lockedBalance: subaccountPortfolio.lockedBalance,
+            unrealizedPnl: subaccountPortfolio.unrealizedPnl,
+        };
+    }
+    static grpcAccountPortfolioToAccountPortfolio(portfolio) {
+        return {
+            portfolioValue: portfolio.portfolioValue,
+            availableBalance: portfolio.availableBalance,
+            lockedBalance: portfolio.lockedBalance,
+            unrealizedPnl: portfolio.unrealizedPnl,
+            subaccountsList: portfolio.subaccounts.map(IndexerGrpcAccountTransformer.grpcSubaccountPortfolioToSubaccountPortfolio),
+        };
+    }
+    static grpcAmountToAmount(amount) {
+        return {
+            amount: amount.amount,
+            denom: amount.denom,
+        };
+    }
+    static grpcDepositToDeposit(deposit) {
+        return {
+            totalBalance: deposit.totalBalance,
+            availableBalance: deposit.availableBalance,
+        };
+    }
+    static balancesResponseToBalances(response) {
+        return response.balances.map((b) => IndexerGrpcAccountTransformer.grpcBalanceToBalance(b));
+    }
+    static balanceResponseToBalance(response) {
+        return IndexerGrpcAccountTransformer.grpcBalanceToBalance(response.balance);
+    }
+    static grpcBalanceToBalance(balance) {
+        const deposit = balance.deposit;
+        return {
+            subaccountId: balance.subaccountId,
+            accountAddress: balance.accountAddress,
+            denom: balance.denom,
+            deposit: deposit
+                ? IndexerGrpcAccountTransformer.grpcDepositToDeposit(deposit)
+                : undefined,
+        };
+    }
+    static grpcBalancesToBalances(balances) {
+        return balances.map((balance) => IndexerGrpcAccountTransformer.grpcBalanceToBalance(balance));
+    }
+    static grpcTransferHistoryEntryToTransferHistoryEntry(transfer) {
+        const amount = transfer.amount;
+        return {
+            transferType: transfer.transferType,
+            srcSubaccountId: transfer.srcSubaccountId,
+            srcSubaccountAddress: transfer.srcAccountAddress,
+            dstSubaccountId: transfer.dstSubaccountId,
+            dstSubaccountAddress: transfer.dstAccountAddress,
+            executedAt: parseInt(transfer.executedAt, 10),
+            amount: amount
+                ? IndexerGrpcAccountTransformer.grpcAmountToAmount(amount)
+                : undefined,
+        };
+    }
+    static tradingRewardsResponseToTradingRewards(response) {
+        const rewards = response.rewards;
+        return rewards.map(IndexerGrpcAccountTransformer.grpcTradingRewardToTradingReward);
+    }
+    static grpcTradingRewardsToTradingRewards(rewards) {
+        return rewards.map(IndexerGrpcAccountTransformer.grpcTradingRewardToTradingReward);
+    }
+    static grpcTradingRewardToTradingReward(reward) {
+        return {
+            accountAddress: reward.accountAddress,
+            rewards: reward.rewards.map((r) => ({
+                amount: r.amount,
+                denom: r.denom,
+            })),
+            distributedAt: parseInt(reward.distributedAt, 10),
+        };
+    }
+    static transferHistoryResponseToTransferHistory(response) {
+        const transfers = response.transfers;
+        const pagination = response.paging;
+        return {
+            transfers: transfers.map((transfer) => IndexerGrpcAccountTransformer.grpcTransferHistoryEntryToTransferHistoryEntry(transfer)),
+            pagination: grpcPagingToPaging(pagination),
+        };
+    }
+    static grpcTransferHistoryToTransferHistory(transfers) {
+        return transfers.map((transfer) => IndexerGrpcAccountTransformer.grpcTransferHistoryEntryToTransferHistoryEntry(transfer));
+    }
+}

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

@@ -0,0 +1,19 @@
+import { DenomHolders, HistoricalRPNL, LeaderboardRow, PnlLeaderboard, VolLeaderboard, HistoricalBalance, HistoricalVolumes } from '../types/archiver.js';
+import { InjectiveArchiverRpc } from '@injectivelabs/indexer-proto-ts';
+/**
+ * @category Indexer Grpc Transformer
+ */
+export declare class IndexerGrpcArchiverTransformer {
+    static grpcHistoricalBalanceToHistoricalBalance(historicalBalance: InjectiveArchiverRpc.HistoricalBalance): HistoricalBalance;
+    static grpcHistoricalRPNLToHistoricalRPNL(historicalRPNL: InjectiveArchiverRpc.HistoricalRPNL): HistoricalRPNL;
+    static grpcHistoricalVolumesToHistoricalVolumes(historicalVolumes: InjectiveArchiverRpc.HistoricalVolumes): HistoricalVolumes;
+    static grpcLeaderboardRowToLeaderboardRow(leaderboardRow: InjectiveArchiverRpc.LeaderboardRow): LeaderboardRow;
+    static grpcHistoricalBalanceResponseToHistoricalBalances(response: InjectiveArchiverRpc.BalanceResponse): HistoricalBalance;
+    static grpcHistoricalRPNLResponseToHistoricalRPNL(response: InjectiveArchiverRpc.RpnlResponse): HistoricalRPNL;
+    static grpcHistoricalVolumesResponseToHistoricalVolumes(response: InjectiveArchiverRpc.VolumesResponse): HistoricalVolumes;
+    static grpcPnlLeaderboardResponseToPnlLeaderboard(response: InjectiveArchiverRpc.PnlLeaderboardResponse): PnlLeaderboard;
+    static grpcVolLeaderboardResponseToVolLeaderboard(response: InjectiveArchiverRpc.VolLeaderboardResponse): VolLeaderboard;
+    static grpcPnlLeaderboardFixedResolutionResponseToPnlLeaderboard(response: InjectiveArchiverRpc.PnlLeaderboardFixedResolutionResponse): PnlLeaderboard;
+    static grpcVolLeaderboardFixedResolutionResponseToVolLeaderboard(response: InjectiveArchiverRpc.VolLeaderboardFixedResolutionResponse): VolLeaderboard;
+    static grpcDenomHoldersResponseToDenomHolders(response: InjectiveArchiverRpc.DenomHoldersResponse): DenomHolders;
+}