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

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

@@ -1,220 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexerGrpcSpotTransformer = void 0;
-const utils_1 = require("@injectivelabs/utils");
-const token_js_1 = require("../../../types/token.js");
-const pagination_js_1 = require("../../../utils/pagination.js");
-const zeroPriceLevel = () => ({
-    price: '0',
-    quantity: '0',
-    timestamp: 0,
-});
-/**
- * @category Indexer Grpc Transformer
- */
-class IndexerGrpcSpotTransformer {
-    static grpcTokenMetaToTokenMeta(tokenMeta) {
-        if (!tokenMeta) {
-            return;
-        }
-        return {
-            name: tokenMeta.name,
-            address: tokenMeta.address,
-            symbol: tokenMeta.symbol,
-            logo: tokenMeta.logo,
-            decimals: tokenMeta.decimals,
-            updatedAt: tokenMeta.updatedAt,
-            coinGeckoId: '',
-            tokenType: token_js_1.TokenType.Unknown,
-        };
-    }
-    static marketResponseToMarket(response) {
-        const market = response.market;
-        return IndexerGrpcSpotTransformer.grpcMarketToMarket(market);
-    }
-    static marketsResponseToMarkets(response) {
-        const markets = response.markets;
-        return IndexerGrpcSpotTransformer.grpcMarketsToMarkets(markets);
-    }
-    static ordersResponseToOrders(response) {
-        const orders = response.orders;
-        const pagination = response.paging;
-        return {
-            orders: IndexerGrpcSpotTransformer.grpcOrdersToOrders(orders),
-            pagination: (0, pagination_js_1.grpcPagingToPaging)(pagination),
-        };
-    }
-    static orderHistoryResponseToOrderHistory(response) {
-        const orderHistory = response.orders;
-        const pagination = response.paging;
-        return {
-            orderHistory: IndexerGrpcSpotTransformer.grpcOrderHistoryListToOrderHistoryList(orderHistory),
-            pagination: (0, pagination_js_1.grpcPagingToPaging)(pagination),
-        };
-    }
-    static tradesResponseToTrades(response) {
-        const trades = response.trades;
-        const pagination = response.paging;
-        return {
-            trades: IndexerGrpcSpotTransformer.grpcTradesToTrades(trades),
-            pagination: (0, pagination_js_1.grpcPagingToPaging)(pagination),
-        };
-    }
-    static subaccountTradesListResponseToTradesList(response) {
-        const tradesList = response.trades;
-        return IndexerGrpcSpotTransformer.grpcTradesToTrades(tradesList);
-    }
-    static orderbookV2ResponseToOrderbookV2(response) {
-        const orderbook = response.orderbook;
-        return IndexerGrpcSpotTransformer.grpcOrderbookV2ToOrderbookV2({
-            sequence: parseInt(orderbook.sequence, 10),
-            buys: orderbook?.buys,
-            sells: orderbook?.sells,
-        });
-    }
-    static orderbooksV2ResponseToOrderbooksV2(response) {
-        const orderbooks = response.orderbooks;
-        return orderbooks.map((o) => {
-            const orderbook = o.orderbook;
-            return {
-                marketId: o.marketId,
-                orderbook: IndexerGrpcSpotTransformer.grpcOrderbookV2ToOrderbookV2({
-                    sequence: parseInt(orderbook.sequence, 10),
-                    buys: orderbook.buys,
-                    sells: orderbook.sells,
-                }),
-            };
-        });
-    }
-    static grpcMarketToMarket(market) {
-        return {
-            marketId: market.marketId,
-            marketStatus: market.marketStatus,
-            ticker: market.ticker,
-            baseDenom: market.baseDenom,
-            quoteDenom: market.quoteDenom,
-            quoteToken: IndexerGrpcSpotTransformer.grpcTokenMetaToTokenMeta(market.quoteTokenMeta),
-            baseToken: IndexerGrpcSpotTransformer.grpcTokenMetaToTokenMeta(market.baseTokenMeta),
-            makerFeeRate: market.makerFeeRate,
-            takerFeeRate: market.takerFeeRate,
-            serviceProviderFee: market.serviceProviderFee,
-            minPriceTickSize: new utils_1.BigNumber(market.minPriceTickSize).toNumber(),
-            minQuantityTickSize: new utils_1.BigNumber(market.minQuantityTickSize).toNumber(),
-            minNotional: new utils_1.BigNumber(market.minNotional).toNumber(),
-        };
-    }
-    static grpcMarketsToMarkets(markets) {
-        return markets.map((market) => IndexerGrpcSpotTransformer.grpcMarketToMarket(market));
-    }
-    static grpcPriceLevelToPriceLevel(priceLevel) {
-        return {
-            price: priceLevel.price,
-            quantity: priceLevel.quantity,
-            timestamp: parseInt(priceLevel.timestamp, 10),
-        };
-    }
-    static grpcPriceLevelsToPriceLevels(priceLevels) {
-        return priceLevels.map((priceLevel) => IndexerGrpcSpotTransformer.grpcPriceLevelToPriceLevel(priceLevel));
-    }
-    static grpcOrderbookToOrderbook({ buys, sells, }) {
-        return {
-            buys: IndexerGrpcSpotTransformer.grpcPriceLevelsToPriceLevels(buys),
-            sells: IndexerGrpcSpotTransformer.grpcPriceLevelsToPriceLevels(sells),
-        };
-    }
-    static grpcOrderbookV2ToOrderbookV2({ buys, sells, sequence, }) {
-        return {
-            sequence,
-            buys: IndexerGrpcSpotTransformer.grpcPriceLevelsToPriceLevels(buys),
-            sells: IndexerGrpcSpotTransformer.grpcPriceLevelsToPriceLevels(sells),
-        };
-    }
-    static grpcOrderToOrder(order) {
-        return {
-            orderHash: order.orderHash,
-            orderSide: order.orderSide,
-            marketId: order.marketId,
-            cid: order.cid,
-            subaccountId: order.subaccountId,
-            price: order.price,
-            state: order.state,
-            quantity: order.quantity,
-            unfilledQuantity: order.unfilledQuantity,
-            triggerPrice: order.triggerPrice,
-            feeRecipient: order.feeRecipient,
-            createdAt: parseInt(order.createdAt, 10),
-            updatedAt: parseInt(order.updatedAt, 10),
-        };
-    }
-    static grpcOrdersToOrders(orders) {
-        return orders.map((order) => IndexerGrpcSpotTransformer.grpcOrderToOrder(order));
-    }
-    static grpcOrderHistoryToOrderHistory(orderHistory) {
-        return {
-            orderHash: orderHistory.orderHash,
-            marketId: orderHistory.marketId,
-            cid: orderHistory.cid,
-            active: orderHistory.isActive,
-            subaccountId: orderHistory.subaccountId,
-            executionType: orderHistory.executionType,
-            orderType: orderHistory.orderType,
-            price: orderHistory.price,
-            triggerPrice: orderHistory.triggerPrice,
-            quantity: orderHistory.quantity,
-            filledQuantity: orderHistory.filledQuantity,
-            state: orderHistory.state,
-            createdAt: parseInt(orderHistory.createdAt, 10),
-            updatedAt: parseInt(orderHistory.updatedAt, 10),
-            direction: orderHistory.direction,
-        };
-    }
-    static grpcOrderHistoryListToOrderHistoryList(orderHistory) {
-        return orderHistory.map((orderHistory) => IndexerGrpcSpotTransformer.grpcOrderHistoryToOrderHistory(orderHistory));
-    }
-    static grpcTradeToTrade(trade) {
-        const price = trade.price;
-        const mappedPrice = price
-            ? IndexerGrpcSpotTransformer.grpcPriceLevelToPriceLevel(price)
-            : zeroPriceLevel();
-        return {
-            orderHash: trade.orderHash,
-            subaccountId: trade.subaccountId,
-            marketId: trade.marketId,
-            tradeId: trade.tradeId,
-            cid: trade.cid,
-            executedAt: parseInt(trade.executedAt, 10),
-            feeRecipient: trade.feeRecipient,
-            tradeExecutionType: trade.tradeExecutionType,
-            executionSide: trade.executionSide,
-            tradeDirection: trade.tradeDirection,
-            fee: trade.fee,
-            ...mappedPrice,
-        };
-    }
-    static grpcTradesToTrades(trades) {
-        return trades.map((trade) => IndexerGrpcSpotTransformer.grpcTradeToTrade(trade));
-    }
-    static grpcAtomicSwapHistoryListToAtomicSwapHistoryList(response) {
-        const swapHistory = response.data;
-        const pagination = response.paging;
-        return {
-            swapHistory: swapHistory.map(IndexerGrpcSpotTransformer.grpcAtomicSwapHistoryToAtomicSwapHistory),
-            pagination: (0, pagination_js_1.grpcPagingToPaging)(pagination),
-        };
-    }
-    static grpcAtomicSwapHistoryToAtomicSwapHistory(swapHistory) {
-        return {
-            sender: swapHistory.sender,
-            route: swapHistory.route,
-            sourceCoin: swapHistory.sourceCoin,
-            destinationCoin: swapHistory.destCoin,
-            fees: swapHistory.fees,
-            contractAddress: swapHistory.contractAddress,
-            indexBySender: swapHistory.indexBySender,
-            indexBySenderContract: swapHistory.indexBySenderContract,
-            txHash: swapHistory.txHash,
-            executedAt: parseInt(swapHistory.executedAt, 10),
-        };
-    }
-}
-exports.IndexerGrpcSpotTransformer = IndexerGrpcSpotTransformer;

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

@@ -1,17 +0,0 @@
-import { StreamOperation } from '../../../types/index.js';
-import type { InjectiveOracleRpc } from '@injectivelabs/indexer-proto-ts';
-/**
- * @category Indexer Stream Transformer
- */
-export declare class IndexerOracleStreamTransformer {
-    static pricesStreamCallback: (response: InjectiveOracleRpc.StreamPricesResponse) => {
-        price: string;
-        operation: StreamOperation;
-        timestamp: number;
-    };
-    static pricesByMarketsCallback: (response: InjectiveOracleRpc.StreamPricesByMarketsResponse) => {
-        price: string;
-        timestamp: string;
-        marketId: string;
-    };
-}

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

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexerOracleStreamTransformer = void 0;
-const index_js_1 = require("../../../types/index.js");
-/**
- * @category Indexer Stream Transformer
- */
-class IndexerOracleStreamTransformer {
-    static pricesStreamCallback = (response) => ({
-        price: response.price,
-        operation: index_js_1.StreamOperation.Update,
-        timestamp: parseInt(response.timestamp, 10),
-    });
-    static pricesByMarketsCallback = (response) => ({
-        ...response,
-    });
-}
-exports.IndexerOracleStreamTransformer = IndexerOracleStreamTransformer;

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

@@ -1,24 +0,0 @@
-import type { Block, ExplorerValidator, ContractTransactionWithMessages } from '../types/explorer.js';
-import type { Contract, WasmCode, Transaction, BankTransfer, ExplorerTransaction, ContractTransaction, ExplorerBlockWithTxs, ExplorerValidatorUptime, ExplorerCW20BalanceWithToken } from '../types/explorer.js';
-import type { ContractExplorerApiResponse, WasmCodeExplorerApiResponse, BlockFromExplorerApiResponse, CW20BalanceExplorerApiResponse, TransactionFromExplorerApiResponse, BankTransferFromExplorerApiResponse, ContractTransactionExplorerApiResponse, ValidatorUptimeFromExplorerApiResponse } from '../types/explorer-rest.js';
-/**
- * @category Indexer Rest Transformer
- */
-export declare class IndexerRestExplorerTransformer {
-    static blockToBlock(block: BlockFromExplorerApiResponse): Block;
-    static blocksToBlocks(blocks: BlockFromExplorerApiResponse[]): Block[];
-    static transactionToTransaction(transaction: TransactionFromExplorerApiResponse): ExplorerTransaction;
-    static transactionsToTransactions(transactions: TransactionFromExplorerApiResponse[]): ExplorerTransaction[];
-    static blockWithTxToBlockWithTx(block: BlockFromExplorerApiResponse): ExplorerBlockWithTxs;
-    static blocksWithTxsToBlocksWithTxs(blocks: BlockFromExplorerApiResponse[]): ExplorerBlockWithTxs[];
-    static baseTransactionToTransaction(transaction: Transaction): ExplorerTransaction;
-    static validatorExplorerToValidator(validators: any[]): Partial<ExplorerValidator>[];
-    static validatorUptimeToExplorerValidatorUptime(validatorUptimeList: ValidatorUptimeFromExplorerApiResponse[]): ExplorerValidatorUptime[];
-    static contractToExplorerContract(contract: ContractExplorerApiResponse): Contract;
-    static contractTransactionToExplorerContractTransaction(transaction: ContractTransactionExplorerApiResponse): ContractTransaction;
-    static contractTransactionToExplorerContractTransactionWithMessages(transaction: ContractTransactionExplorerApiResponse): ContractTransactionWithMessages;
-    static wasmCodeToExplorerWasmCode(wasmCode: WasmCodeExplorerApiResponse): WasmCode;
-    static CW20BalanceToExplorerCW20Balance(balance: CW20BalanceExplorerApiResponse): ExplorerCW20BalanceWithToken;
-    static bankTransferToBankTransfer(transfer: BankTransferFromExplorerApiResponse): BankTransfer;
-    static bankTransfersToBankTransfers(transfers: BankTransferFromExplorerApiResponse[]): BankTransfer[];
-}

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

@@ -1,247 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexerRestExplorerTransformer = void 0;
-const utils_1 = require("@injectivelabs/utils");
-const helpers_js_1 = require("../../../utils/helpers.js");
-const token_js_1 = require("../../../types/token.js");
-const ZERO_IN_BASE = (0, utils_1.toBigNumber)(0);
-const getContractTransactionAmount = (ApiTransaction) => {
-    const { type, value: { msg }, } = ApiTransaction.messages[0];
-    if (!type.includes('MsgExecuteContract')) {
-        return ZERO_IN_BASE;
-    }
-    if (typeof msg === 'string' && !(0, helpers_js_1.isJsonString)(msg)) {
-        return ZERO_IN_BASE;
-    }
-    const msgObj = typeof msg === 'string' ? JSON.parse(msg) : msg;
-    if (!msgObj.transfer) {
-        return ZERO_IN_BASE;
-    }
-    return (0, utils_1.toHumanReadable)(msgObj.transfer.amount);
-};
-const parseCW20Message = (jsonObject) => {
-    if (!jsonObject) {
-        return undefined;
-    }
-    return JSON.parse(jsonObject);
-};
-/**
- * @category Indexer Rest Transformer
- */
-class IndexerRestExplorerTransformer {
-    static blockToBlock(block) {
-        return {
-            height: block.height,
-            proposer: block.proposer,
-            moniker: block.moniker,
-            blockHash: block.block_hash,
-            parentHash: block.parent_hash,
-            numPreCommits: block.num_pre_commits,
-            numTxs: block.num_txs,
-            timestamp: block.timestamp,
-        };
-    }
-    static blocksToBlocks(blocks) {
-        return blocks.map(IndexerRestExplorerTransformer.blockToBlock);
-    }
-    static transactionToTransaction(transaction) {
-        return {
-            id: transaction.id,
-            blockNumber: transaction.block_number,
-            blockTimestamp: transaction.block_timestamp,
-            hash: transaction.hash,
-            code: transaction.code,
-            info: transaction.info,
-            memo: transaction.memo || '',
-            gasWanted: transaction.gas_wanted,
-            gasFee: {
-                amounts: transaction.gas_fee?.amount,
-                gasLimit: transaction.gas_fee?.gas_limit,
-                payer: transaction.gas_fee?.payer,
-                granter: transaction.gas_fee?.granter,
-            },
-            gasUsed: transaction.gas_used,
-            codespace: transaction.codespace,
-            signatures: transaction.signatures,
-            txType: transaction.tx_type,
-            data: transaction.data,
-            events: transaction.events || [],
-            messages: (transaction.messages || [])
-                .filter((m) => m)
-                .map((message) => ({
-                type: message.type,
-                message: message.value,
-            })),
-            logs: transaction.logs,
-            errorLog: transaction.error_log,
-            claimIds: transaction.claim_id || [],
-        };
-    }
-    static transactionsToTransactions(transactions) {
-        return transactions.map(IndexerRestExplorerTransformer.transactionToTransaction);
-    }
-    static blockWithTxToBlockWithTx(block) {
-        return {
-            height: block.height,
-            proposer: block.proposer,
-            moniker: block.moniker,
-            blockHash: block.block_hash,
-            parentHash: block.parent_hash,
-            numPreCommits: block.num_pre_commits,
-            numTxs: block.num_txs,
-            timestamp: block.timestamp,
-            txs: block.txs
-                ? IndexerRestExplorerTransformer.transactionsToTransactions(block.txs)
-                : [],
-        };
-    }
-    static blocksWithTxsToBlocksWithTxs(blocks) {
-        return blocks.map(IndexerRestExplorerTransformer.blockWithTxToBlockWithTx);
-    }
-    static baseTransactionToTransaction(transaction) {
-        return {
-            ...transaction,
-            messages: (transaction.messages || [])
-                .filter((m) => m)
-                .map((message) => ({
-                type: message.type,
-                message: message.value,
-            })),
-            memo: transaction.memo || '',
-        };
-    }
-    static validatorExplorerToValidator(validators) {
-        return validators.map((validator) => {
-            return {
-                id: validator.id,
-                moniker: validator.moniker,
-                consensusAddress: validator.consensus_address,
-                operatorAddress: validator.operator_address,
-                proposed: validator.proposed,
-                signed: validator.signed,
-                missed: validator.missed,
-                uptimePercentage: validator.uptime_percentage,
-                imageUrl: validator.imageURL,
-            };
-        });
-    }
-    static validatorUptimeToExplorerValidatorUptime(validatorUptimeList) {
-        return validatorUptimeList.map((validatorUptime) => ({
-            blockNumber: validatorUptime.block_number,
-            status: validatorUptime.status,
-        }));
-    }
-    static contractToExplorerContract(contract) {
-        return {
-            label: contract.label,
-            address: contract.address,
-            txHash: contract.tx_hash,
-            creator: contract.creator,
-            executes: contract.executes,
-            instantiatedAt: contract.instantiated_at,
-            lastExecutedAt: contract.last_executed_at,
-            funds: contract.funds,
-            codeId: contract.code_id,
-            admin: contract.admin,
-            cw20_metadata: contract.cw20_metadata,
-            initMessage: parseCW20Message(contract.init_message),
-            currentMigrateMessage: parseCW20Message(contract.current_migrate_message),
-        };
-    }
-    static contractTransactionToExplorerContractTransaction(transaction) {
-        return {
-            txHash: transaction.hash,
-            code: transaction.code,
-            data: transaction.data,
-            memo: transaction.memo,
-            tx_number: transaction.tx_number,
-            error_log: transaction.error_log,
-            height: transaction.block_number,
-            time: transaction.block_unix_timestamp,
-            type: transaction.messages[0].type,
-            logs: transaction.logs,
-            signatures: transaction.signatures,
-            messages: (transaction.messages || [])
-                .filter((m) => m)
-                .map((message) => ({
-                type: message.type,
-                message: message.value,
-            })),
-            fee: transaction.gas_fee.amount
-                ? (0, utils_1.toHumanReadable)(transaction.gas_fee.amount[0].amount)
-                : ZERO_IN_BASE,
-            amount: getContractTransactionAmount(transaction),
-        };
-    }
-    static contractTransactionToExplorerContractTransactionWithMessages(transaction) {
-        return {
-            ...IndexerRestExplorerTransformer.contractTransactionToExplorerContractTransaction(transaction),
-            messages: (transaction.messages || []).map((message) => {
-                if (!(0, helpers_js_1.isJsonString)(message.value.msg)) {
-                    return {
-                        type: message.type,
-                        value: {
-                            ...message.value,
-                            msg: message.value.msg,
-                        },
-                    };
-                }
-                const msg = message.value.msg;
-                return {
-                    type: message.type,
-                    value: {
-                        ...message.value,
-                        msg: JSON.parse(msg),
-                    },
-                };
-            }),
-        };
-    }
-    static wasmCodeToExplorerWasmCode(wasmCode) {
-        return {
-            id: wasmCode.code_id,
-            txHash: wasmCode.tx_hash,
-            creator: wasmCode.creator,
-            contractType: wasmCode.contract_type,
-            version: wasmCode.version,
-            instantiates: wasmCode.instantiates,
-            creationDate: wasmCode.created_at,
-            checksum: wasmCode.checksum,
-            permission: wasmCode.permission,
-            proposalId: wasmCode.proposal_id,
-        };
-    }
-    static CW20BalanceToExplorerCW20Balance(balance) {
-        const { marketing_info, token_info: { name, symbol, decimals }, } = balance.cw20_metadata || { token_info: {} };
-        return {
-            contractAddress: balance.contract_address,
-            account: balance.account,
-            balance: balance.balance,
-            updatedAt: balance.updated_at,
-            token: {
-                address: balance.contract_address,
-                denom: balance.contract_address,
-                decimals,
-                name,
-                symbol,
-                tokenVerification: token_js_1.TokenVerification.Internal,
-                logo: marketing_info?.logo || '',
-                coinGeckoId: name,
-                tokenType: token_js_1.TokenType.Cw20,
-            },
-        };
-    }
-    static bankTransferToBankTransfer(transfer) {
-        return {
-            sender: transfer.sender,
-            recipient: transfer.recipient,
-            amounts: transfer.amounts,
-            blockNumber: transfer.block_number,
-            blockTimestamp: new Date(transfer.block_timestamp).getTime(),
-        };
-    }
-    static bankTransfersToBankTransfers(transfers) {
-        return transfers.map(IndexerRestExplorerTransformer.bankTransferToBankTransfer);
-    }
-}
-exports.IndexerRestExplorerTransformer = IndexerRestExplorerTransformer;

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

@@ -1,34 +0,0 @@
-import type { StreamOperation } from '../../../types/index.js';
-import type { InjectiveSpotExchangeRpc } from '@injectivelabs/indexer-proto-ts';
-/**
- * @category Indexer Stream Transformer
- */
-export declare class IndexerSpotStreamTransformer {
-    static tradesStreamCallback: (response: InjectiveSpotExchangeRpc.StreamTradesResponse) => {
-        trade: import("../index.js").SpotTrade | undefined;
-        operation: StreamOperation;
-        timestamp: string;
-    };
-    static ordersStreamCallback: (response: InjectiveSpotExchangeRpc.StreamOrdersResponse) => {
-        order: import("../index.js").SpotLimitOrder | undefined;
-        operation: StreamOperation;
-        timestamp: string;
-    };
-    static orderHistoryStreamCallback: (response: InjectiveSpotExchangeRpc.StreamOrdersHistoryResponse) => {
-        order: import("../index.js").SpotOrderHistory | undefined;
-        operation: StreamOperation;
-        timestamp: string;
-    };
-    static orderbookV2StreamCallback: (response: InjectiveSpotExchangeRpc.StreamOrderbookV2Response) => {
-        orderbook: import("../index.js").OrderbookWithSequence | undefined;
-        operation: StreamOperation;
-        marketId: string;
-        timestamp: string;
-    };
-    static orderbookUpdateStreamCallback: (response: InjectiveSpotExchangeRpc.StreamOrderbookUpdateResponse) => {
-        orderbook: import("../index.js").OrderbookWithSequence | undefined;
-        operation: StreamOperation;
-        marketId: string;
-        timestamp: string;
-    };
-}

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

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexerSpotStreamTransformer = void 0;
-const IndexerGrpcSpotTransformer_js_1 = require("./IndexerGrpcSpotTransformer.js");
-/**
- * @category Indexer Stream Transformer
- */
-class IndexerSpotStreamTransformer {
-    static tradesStreamCallback = (response) => {
-        const trade = response.trade;
-        return {
-            trade: trade
-                ? IndexerGrpcSpotTransformer_js_1.IndexerGrpcSpotTransformer.grpcTradeToTrade(trade)
-                : undefined,
-            operation: response.operationType,
-            timestamp: response.timestamp,
-        };
-    };
-    static ordersStreamCallback = (response) => {
-        const order = response.order;
-        return {
-            order: order
-                ? IndexerGrpcSpotTransformer_js_1.IndexerGrpcSpotTransformer.grpcOrderToOrder(order)
-                : undefined,
-            operation: response.operationType,
-            timestamp: response.timestamp,
-        };
-    };
-    static orderHistoryStreamCallback = (response) => {
-        const order = response.order;
-        return {
-            order: order
-                ? IndexerGrpcSpotTransformer_js_1.IndexerGrpcSpotTransformer.grpcOrderHistoryToOrderHistory(order)
-                : undefined,
-            operation: response.operationType,
-            timestamp: response.timestamp,
-        };
-    };
-    static orderbookV2StreamCallback = (response) => {
-        const orderbook = response.orderbook;
-        return {
-            orderbook: orderbook
-                ? IndexerGrpcSpotTransformer_js_1.IndexerGrpcSpotTransformer.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
-                ? IndexerGrpcSpotTransformer_js_1.IndexerGrpcSpotTransformer.grpcOrderbookV2ToOrderbookV2({
-                    sequence: parseInt(orderbook.sequence, 10),
-                    buys: orderbook.buys,
-                    sells: orderbook.sells,
-                })
-                : undefined,
-            operation: response.operationType,
-            marketId: response.marketId,
-            timestamp: response.timestamp,
-        };
-    };
-}
-exports.IndexerSpotStreamTransformer = IndexerSpotStreamTransformer;

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

@@ -1,23 +0,0 @@
-export * from './IndexerGrpcMitoTransformer.js';
-export * from './IndexerGrpcSpotTransformer.js';
-export * from './IndexerCampaignTransformer.js';
-export * from './IndexerGrpcOracleTransformer.js';
-export * from './IndexerSpotStreamTransformer.js';
-export * from './IndexerGrpcAccountTransformer.js';
-export * from './IndexerGrpcAuctionTransformer.js';
-export * from './IndexerGrpcArchiverTransformer.js';
-export * from './IndexerGrpcExplorerTransformer.js';
-export * from './IndexerGrpcReferralTransformer.js';
-export * from './IndexerOracleStreamTransformer.js';
-export * from './IndexerRestExplorerTransformer.js';
-export * from './IndexerAccountStreamTransformer.js';
-export * from './IndexerAuctionStreamTransformer.js';
-export * from './IndexerGrpcMegaVaultTransformer.js';
-export * from './IndexerArchiverStreamTransformer.js';
-export * from './IndexerExplorerStreamTransformer.js';
-export * from './IndexerGrpcDerivativeTransformer.js';
-export * from './IndexerGrpcMitoStreamTransformer.js';
-export * from './IndexerAccountPortfolioTransformer.js';
-export * from './IndexerDerivativeStreamTransformer.js';
-export * from './IndexerGrpcInsuranceFundTransformer.js';
-export * from './IndexerAccountPortfolioStreamTransformer.js';