@injectivelabs/sdk-ts 1.15.0 → 1.15.2

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcAccountTransformer = void 0;
+const pagination_js_1 = require("../../..//utils/pagination.js");
+/**
+ * @category Indexer Grpc Transformer
+ *
+ */
+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: (0, pagination_js_1.grpcPagingToPaging)(pagination),
+        };
+    }
+    static grpcTransferHistoryToTransferHistory(transfers) {
+        return transfers.map((transfer) => IndexerGrpcAccountTransformer.grpcTransferHistoryEntryToTransferHistoryEntry(transfer));
+    }
+}
+exports.IndexerGrpcAccountTransformer = IndexerGrpcAccountTransformer;

package/dist/cjs/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;
+}

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerGrpcArchiverTransformer = void 0;
+/**
+ * @category Indexer Grpc Transformer
+ */
+class IndexerGrpcArchiverTransformer {
+    static grpcHistoricalBalanceToHistoricalBalance(historicalBalance) {
+        return {
+            t: historicalBalance.t,
+            v: historicalBalance.v,
+        };
+    }
+    static grpcHistoricalRPNLToHistoricalRPNL(historicalRPNL) {
+        return {
+            t: historicalRPNL.t,
+            v: historicalRPNL.v,
+        };
+    }
+    static grpcHistoricalVolumesToHistoricalVolumes(historicalVolumes) {
+        return {
+            t: historicalVolumes.t,
+            v: historicalVolumes.v,
+        };
+    }
+    static grpcLeaderboardRowToLeaderboardRow(leaderboardRow) {
+        return {
+            account: leaderboardRow.account,
+            pnl: leaderboardRow.pnl,
+            volume: leaderboardRow.volume,
+            rank: leaderboardRow.rank,
+        };
+    }
+    static grpcHistoricalBalanceResponseToHistoricalBalances(response) {
+        if (!response.historicalBalance) {
+            return { t: [], v: [] };
+        }
+        return IndexerGrpcArchiverTransformer.grpcHistoricalBalanceToHistoricalBalance(response.historicalBalance);
+    }
+    static grpcHistoricalRPNLResponseToHistoricalRPNL(response) {
+        if (!response.historicalRpnl) {
+            return { t: [], v: [] };
+        }
+        return IndexerGrpcArchiverTransformer.grpcHistoricalRPNLToHistoricalRPNL(response.historicalRpnl);
+    }
+    static grpcHistoricalVolumesResponseToHistoricalVolumes(response) {
+        if (!response.historicalVolumes) {
+            return { t: [], v: [] };
+        }
+        return IndexerGrpcArchiverTransformer.grpcHistoricalVolumesToHistoricalVolumes(response.historicalVolumes);
+    }
+    static grpcPnlLeaderboardResponseToPnlLeaderboard(response) {
+        return {
+            firstDate: response.firstDate,
+            lastDate: response.lastDate,
+            leaders: response.leaders.map(IndexerGrpcArchiverTransformer.grpcLeaderboardRowToLeaderboardRow),
+            accountRow: response.accountRow
+                ? IndexerGrpcArchiverTransformer.grpcLeaderboardRowToLeaderboardRow(response.accountRow)
+                : undefined,
+        };
+    }
+    static grpcVolLeaderboardResponseToVolLeaderboard(response) {
+        return {
+            firstDate: response.firstDate,
+            lastDate: response.lastDate,
+            leaders: response.leaders.map(IndexerGrpcArchiverTransformer.grpcLeaderboardRowToLeaderboardRow),
+            accountRow: response.accountRow
+                ? IndexerGrpcArchiverTransformer.grpcLeaderboardRowToLeaderboardRow(response.accountRow)
+                : undefined,
+        };
+    }
+    static grpcPnlLeaderboardFixedResolutionResponseToPnlLeaderboard(response) {
+        return {
+            firstDate: response.firstDate,
+            lastDate: response.lastDate,
+            leaders: response.leaders.map(IndexerGrpcArchiverTransformer.grpcLeaderboardRowToLeaderboardRow),
+            accountRow: response.accountRow
+                ? IndexerGrpcArchiverTransformer.grpcLeaderboardRowToLeaderboardRow(response.accountRow)
+                : undefined,
+        };
+    }
+    static grpcVolLeaderboardFixedResolutionResponseToVolLeaderboard(response) {
+        return {
+            firstDate: response.firstDate,
+            lastDate: response.lastDate,
+            leaders: response.leaders.map(IndexerGrpcArchiverTransformer.grpcLeaderboardRowToLeaderboardRow),
+            accountRow: response.accountRow
+                ? IndexerGrpcArchiverTransformer.grpcLeaderboardRowToLeaderboardRow(response.accountRow)
+                : undefined,
+        };
+    }
+    static grpcDenomHoldersResponseToDenomHolders(response) {
+        return {
+            holders: response.holders.map((holder) => ({
+                accountAddress: holder.accountAddress,
+                balance: holder.balance,
+            })),
+            next: response.next,
+            total: response.total,
+        };
+    }
+}
+exports.IndexerGrpcArchiverTransformer = IndexerGrpcArchiverTransformer;

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

@@ -0,0 +1,15 @@
+import { InjectiveAuctionRpc } from '@injectivelabs/indexer-proto-ts';
+import { Auction, IndexerBid, GrpcAuction, TotalInjBurnt, GrpcIndexerBid } from '../types/auction.js';
+/**
+ * @category Indexer Grpc Transformer
+ */
+export declare class IndexerGrpcAuctionTransformer {
+    static auctionResponseToAuction(response: InjectiveAuctionRpc.AuctionEndpointResponse): {
+        auction: Auction;
+        bids: IndexerBid[];
+    };
+    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

@@ -0,0 +1,39 @@
+"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) {
+        return {
+            auction: IndexerGrpcAuctionTransformer.grpcAuctionToAuction(response.auction),
+            bids: response.bids.map(IndexerGrpcAuctionTransformer.grpcBidToBid),
+        };
+    }
+    static auctionsResponseToAuctions(response) {
+        return response.auctions.map((a) => IndexerGrpcAuctionTransformer.grpcAuctionToAuction(a));
+    }
+    static grpcBidToBid(grpcBid) {
+        return {
+            bidder: grpcBid.bidder,
+            bidAmount: grpcBid.amount,
+            bidTimestamp: parseInt(grpcBid.timestamp, 10),
+        };
+    }
+    static grpcAuctionToAuction(grpcAuction) {
+        return {
+            winner: grpcAuction.winner,
+            basketList: grpcAuction.basket.map(IndexerCommonTransformer_js_1.IndexerCommonTransformer.grpcCoinToCoin),
+            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);
+    }
+}
+exports.IndexerGrpcAuctionTransformer = IndexerGrpcAuctionTransformer;

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

@@ -0,0 +1,90 @@
+import { GrpcDerivativeMarketInfo, GrpcDerivativeLimitOrder, GrpcDerivativeTrade, DerivativeMarket, DerivativeLimitOrder, DerivativeTrade, PositionDelta, GrpcDerivativePosition, Position, GrpcPositionDelta, PerpetualMarketInfo, GrpcPerpetualMarketInfo, GrpcPerpetualMarketFunding, PerpetualMarketFunding, GrpcExpiryFuturesMarketInfo, GrpcFundingPayment, GrpcFundingRate, FundingPayment, FundingRate, ExpiryFuturesMarketInfo, GrpcBinaryOptionsMarketInfo, BinaryOptionsMarket, GrpcDerivativeOrderHistory, DerivativeOrderHistory, GrpcDerivativePositionV2, PositionV2 } from '../types/derivatives.js';
+import { Orderbook, PriceLevel, GrpcTokenMeta, GrpcPriceLevel, IndexerTokenMeta, OrderbookWithSequence } from '../types/exchange.js';
+import { InjectiveDerivativeExchangeRpc } from '@injectivelabs/indexer-proto-ts';
+/**
+ * @category Indexer Grpc Transformer
+ */
+export declare class IndexerGrpcDerivativeTransformer {
+    static grpcTokenMetaToTokenMeta(tokenMeta: GrpcTokenMeta | undefined): IndexerTokenMeta | undefined;
+    static grpcPerpetualMarketInfoToPerpetualMarketInfo(perpetualMarketInfo: GrpcPerpetualMarketInfo | undefined): PerpetualMarketInfo | undefined;
+    static grpcPerpetualMarketFundingToPerpetualMarketFunding(perpetualMarketFunding: GrpcPerpetualMarketFunding | undefined): PerpetualMarketFunding | undefined;
+    static grpcExpiryFuturesMarketInfoToExpiryFuturesMarketInfo(expiryFuturesMarketInfo: GrpcExpiryFuturesMarketInfo | undefined): ExpiryFuturesMarketInfo | undefined;
+    static marketResponseToMarket(response: InjectiveDerivativeExchangeRpc.MarketResponse): DerivativeMarket;
+    static marketsResponseToMarkets(response: InjectiveDerivativeExchangeRpc.MarketsResponse): DerivativeMarket[];
+    static ordersResponseToOrders(response: InjectiveDerivativeExchangeRpc.OrdersResponse): {
+        orders: DerivativeLimitOrder[];
+        pagination: import("../../../index.js").ExchangePagination;
+    };
+    static orderHistoryResponseToOrderHistory(response: InjectiveDerivativeExchangeRpc.OrdersHistoryResponse, isConditional?: boolean): {
+        orderHistory: DerivativeOrderHistory[];
+        pagination: import("../../../index.js").ExchangePagination;
+    };
+    static positionsResponseToPositions(response: InjectiveDerivativeExchangeRpc.PositionsResponse): {
+        positions: Position[];
+        pagination: import("../../../index.js").ExchangePagination;
+    };
+    static positionsV2ResponseToPositionsV2(response: InjectiveDerivativeExchangeRpc.PositionsV2Response): {
+        positions: PositionV2[];
+        pagination: import("../../../index.js").ExchangePagination;
+    };
+    static tradesResponseToTrades(response: InjectiveDerivativeExchangeRpc.TradesResponse): {
+        trades: DerivativeTrade[];
+        pagination: import("../../../index.js").ExchangePagination;
+    };
+    static subaccountTradesListResponseToSubaccountTradesList(response: InjectiveDerivativeExchangeRpc.SubaccountTradesListResponse): DerivativeTrade[];
+    static fundingPaymentsResponseToFundingPayments(response: InjectiveDerivativeExchangeRpc.FundingPaymentsResponse): {
+        fundingPayments: FundingPayment[];
+        pagination: import("../../../index.js").ExchangePagination;
+    };
+    static fundingRatesResponseToFundingRates(response: InjectiveDerivativeExchangeRpc.FundingRatesResponse): {
+        fundingRates: FundingRate[];
+        pagination: import("../../../index.js").ExchangePagination;
+    };
+    static orderbookV2ResponseToOrderbookV2(response: InjectiveDerivativeExchangeRpc.OrderbookV2Response): OrderbookWithSequence;
+    static orderbooksV2ResponseToOrderbooksV2(response: InjectiveDerivativeExchangeRpc.OrderbooksV2Response): {
+        marketId: string;
+        orderbook: OrderbookWithSequence;
+    }[];
+    static binaryOptionsMarketResponseToBinaryOptionsMarket(response: InjectiveDerivativeExchangeRpc.BinaryOptionsMarketResponse): BinaryOptionsMarket;
+    static binaryOptionsMarketResponseWithPaginationToBinaryOptionsMarket(response: InjectiveDerivativeExchangeRpc.BinaryOptionsMarketsResponse): {
+        markets: BinaryOptionsMarket[];
+        pagination: {
+            to: number;
+            from: number;
+            total: number;
+            countBySubaccount: number;
+            next: string[];
+        };
+    };
+    static binaryOptionsMarketsResponseToBinaryOptionsMarkets(response: InjectiveDerivativeExchangeRpc.BinaryOptionsMarketsResponse): BinaryOptionsMarket[];
+    static grpcBinaryOptionsMarketToBinaryOptionsMarket(market: GrpcBinaryOptionsMarketInfo): BinaryOptionsMarket;
+    static grpcBinaryOptionsMarketsToBinaryOptionsMarkets(markets: GrpcBinaryOptionsMarketInfo[]): BinaryOptionsMarket[];
+    static grpcMarketToMarket(market: GrpcDerivativeMarketInfo): DerivativeMarket;
+    static grpcMarketsToMarkets(markets: GrpcDerivativeMarketInfo[]): DerivativeMarket[];
+    static grpcPositionDeltaToPositionDelta(positionDelta: GrpcPositionDelta): PositionDelta;
+    static grpcPriceLevelToPriceLevel(priceLevel: GrpcPriceLevel): PriceLevel;
+    static grpcPriceLevelsToPriceLevels(priceLevels: GrpcPriceLevel[]): PriceLevel[];
+    static grpcOrderbookToOrderbook({ buys, sells, }: {
+        buys: GrpcPriceLevel[];
+        sells: GrpcPriceLevel[];
+    }): Orderbook;
+    static grpcOrderbookV2ToOrderbookV2({ sequence, buys, sells, }: {
+        sequence: number;
+        buys: GrpcPriceLevel[];
+        sells: GrpcPriceLevel[];
+    }): OrderbookWithSequence;
+    static grpcOrderToOrder(order: GrpcDerivativeLimitOrder): DerivativeLimitOrder;
+    static grpcOrdersToOrders(orders: GrpcDerivativeLimitOrder[]): DerivativeLimitOrder[];
+    static grpcOrderHistoryToOrderHistory(orderHistory: GrpcDerivativeOrderHistory): DerivativeOrderHistory;
+    static grpcOrderHistoryListToOrderHistoryList(orderHistory: GrpcDerivativeOrderHistory[], isConditional?: boolean): DerivativeOrderHistory[];
+    static grpcPositionToPosition(position: GrpcDerivativePosition): Position;
+    static grpcPositionV2ToPositionV2(position: GrpcDerivativePositionV2): PositionV2;
+    static grpcPositionsToPositions(positions: GrpcDerivativePosition[]): Position[];
+    static grpcPositionsV2ToPositionsV2(positions: GrpcDerivativePositionV2[]): PositionV2[];
+    static grpcTradeToTrade(trade: GrpcDerivativeTrade): DerivativeTrade;
+    static grpcTradesToTrades(trades: GrpcDerivativeTrade[]): DerivativeTrade[];
+    static grpcFundingPaymentToFundingPayment(fundingPayment: GrpcFundingPayment): FundingPayment;
+    static grpcFundingPaymentsToFundingPayments(fundingPayments: GrpcFundingPayment[]): FundingPayment[];
+    static grpcFundingRateToFundingRate(fundingRate: GrpcFundingRate): FundingRate;
+    static grpcFundingRatesToFundingRates(fundingRates: GrpcFundingRate[]): FundingRate[];
+}