@injectivelabs/sdk-ts 1.16.37 → 1.16.38-alpha.0

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

@@ -1,117 +0,0 @@
-"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

@@ -1,21 +0,0 @@
-import type { InjectiveArchiverRpc } from '@injectivelabs/indexer-proto-ts';
-import type { AccountStats, DenomHolders, HistoricalRPNL, LeaderboardRow, PnlLeaderboard, VolLeaderboard, SpotAverageEntry, HistoricalBalance, HistoricalVolumes } from '../types/archiver.js';
-/**
- * @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;
-    static grpcAccountStatsResponseToAccountStats(response: InjectiveArchiverRpc.AccountStatsResponse): AccountStats;
-    static grpcSpotAverageEntryToSpotAverageEntry(averageEntry: InjectiveArchiverRpc.SpotAverageEntry): SpotAverageEntry;
-}

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

@@ -1,117 +0,0 @@
-"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,
-        };
-    }
-    static grpcAccountStatsResponseToAccountStats(response) {
-        return {
-            pnl: response.pnl,
-            volume: response.volume,
-        };
-    }
-    static grpcSpotAverageEntryToSpotAverageEntry(averageEntry) {
-        return {
-            marketId: averageEntry.marketId,
-            averageEntryPrice: averageEntry.averageEntryPrice,
-            quantity: averageEntry.quantity,
-            usdValue: averageEntry.usdValue,
-        };
-    }
-}
-exports.IndexerGrpcArchiverTransformer = IndexerGrpcArchiverTransformer;

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

@@ -1,28 +0,0 @@
-import type { InjectiveAuctionRpc } from '@injectivelabs/indexer-proto-ts';
-import type { Auction, AuctionV2, AuctionCoin, GrpcAuction, AuctionsStats, 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: IndexerAuctionBid[];
-    };
-    static auctionStatsResponseToAuctionStats(response: InjectiveAuctionRpc.AuctionsStatsResponse): AuctionsStats;
-}

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

@@ -1,89 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexerGrpcAuctionTransformer = void 0;
-/**
- * @category Indexer Grpc Transformer
- */
-class IndexerGrpcAuctionTransformer {
-    static grpcAuctionCoinToAuctionCoin(grpcCoin) {
-        return {
-            denom: grpcCoin.denom,
-            amount: grpcCoin.amount,
-            usdValue: grpcCoin.usdValue,
-        };
-    }
-    static grpcAuctionCoinPricesToAuctionCoinPrices(grpcCoinPrices) {
-        return {
-            denom: grpcCoinPrices.denom,
-            amount: grpcCoinPrices.amount,
-            prices: grpcCoinPrices.prices,
-        };
-    }
-    static grpcBidToBid(grpcBid) {
-        return {
-            bidder: grpcBid.bidder,
-            bidAmount: grpcBid.amount,
-            bidTimestamp: parseInt(grpcBid.timestamp, 10),
-        };
-    }
-    static grpcAuctionToAuction(grpcAuction) {
-        return {
-            winner: grpcAuction.winner,
-            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),
-            contract: grpcAuction.contract,
-            winningBidAmount: grpcAuction.winningBidAmount,
-            winningBidAmountUsd: grpcAuction.winningBidAmountUsd,
-            round: parseInt(grpcAuction.round, 10),
-            endTimestamp: parseInt(grpcAuction.endTimestamp, 10),
-            updatedAt: parseInt(grpcAuction.updatedAt, 10),
-        };
-    }
-    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),
-        };
-    }
-    static auctionStatsResponseToAuctionStats(response) {
-        return {
-            totalBurnt: response.totalBurnt,
-            totalBurntInUsd: response.totalUsdValue,
-        };
-    }
-}
-exports.IndexerGrpcAuctionTransformer = IndexerGrpcAuctionTransformer;

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

@@ -1,90 +0,0 @@
-import type { InjectiveDerivativeExchangeRpc } from '@injectivelabs/indexer-proto-ts';
-import type { Orderbook, PriceLevel, GrpcTokenMeta, GrpcPriceLevel, IndexerTokenMeta, OrderbookWithSequence } from '../types/exchange.js';
-import type { 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';
-/**
- * @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[];
-}