@gainsnetwork/sdk 0.0.0-v10.rc2 → 0.0.0-v10.rc3

package/lib/backend/tradingVariables/converter.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPairName = exports.convertFeePerBlockCap = exports.convertMaxLeverages = exports.convertGlobalTradeFeeParams = exports.convertTraderFeeTiers = exports.convertFeeTiers = exports.convertCollateralConfig = exports.convertOiWindowsSettings = exports.convertOiWindows = exports.convertPairOi = exports.convertContestLeaderboardEntry = exports.generateStockPairToActiveStockSplit = exports.convertTradeInitialAccFees = exports.convertTradeInfo = exports.convertTrade = exports.convertPairFactor = exports.convertTradeContainer = exports.convertTradesAndLimitOrders = exports.convertTradingPairs = exports.convertTradingGroups = exports.convertGroupBorrowingFees = exports.convertPairBorrowingFees = exports.convertPairDepths = exports.convertOpenInterests = exports.convertCollaterals = exports.convertFees = void 0;
+const __1 = require("../../");
+const convertFees = (fees) => fees === null || fees === void 0 ? void 0 : fees.map(fee => convertFee(fee));
+exports.convertFees = convertFees;
+const convertCollateral = (collateral) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    return ({
+        pairBorrowingFees: ((_a = collateral.borrowingFees) === null || _a === void 0 ? void 0 : _a.v1) !== undefined
+            ? (0, exports.convertPairBorrowingFees)(collateral.borrowingFees.v1)
+            : [],
+        groupBorrowingFees: ((_b = collateral.borrowingFees) === null || _b === void 0 ? void 0 : _b.v1) !== undefined
+            ? (0, exports.convertGroupBorrowingFees)(collateral.borrowingFees.v1)
+            : [],
+        collateral: collateral.collateral,
+        collateralConfig: (0, exports.convertCollateralConfig)(collateral),
+        collateralIndex: collateral.collateralIndex,
+        gToken: collateral.gToken,
+        isActive: true,
+        prices: collateral.prices,
+        symbol: collateral.symbol,
+        pairBorrowingFeesV2: {
+            params: (0, __1.convertBorrowingFeeParamsArrayV2)((_d = (_c = collateral.borrowingFees) === null || _c === void 0 ? void 0 : _c.v2) === null || _d === void 0 ? void 0 : _d.pairParams),
+            data: (0, __1.convertPairBorrowingFeeDataArrayV2)((_f = (_e = collateral.borrowingFees) === null || _e === void 0 ? void 0 : _e.v2) === null || _f === void 0 ? void 0 : _f.pairData),
+        },
+        pairFundingFees: {
+            globalParams: (0, __1.convertPairGlobalParamsArray)((_g = collateral.fundingFees) === null || _g === void 0 ? void 0 : _g.pairGlobalParams),
+            params: (0, __1.convertFundingFeeParamsArray)((_h = collateral.fundingFees) === null || _h === void 0 ? void 0 : _h.pairParams),
+            data: (0, __1.convertPairFundingFeeDataArray)((_j = collateral.fundingFees) === null || _j === void 0 ? void 0 : _j.pairData),
+        },
+        pairOis: (0, __1.convertPairOiArray)(collateral.pairOis, collateral.collateralConfig.decimals),
+    });
+};
+const convertCollaterals = (collaterals) => collaterals === null || collaterals === void 0 ? void 0 : collaterals.map(collateral => convertCollateral(collateral));
+exports.convertCollaterals = convertCollaterals;
+const convertFee = (fee) => ({
+    totalPositionSizeFeeP: parseFloat(fee.totalPositionSizeFeeP) / 1e12,
+    totalLiqCollateralFeeP: parseFloat(fee.totalLiqCollateralFeeP) / 1e12,
+    oraclePositionSizeFeeP: parseFloat(fee.oraclePositionSizeFeeP) / 1e12,
+    minPositionSizeUsd: parseFloat(fee.minPositionSizeUsd) / 1e3,
+});
+const convertOpenInterests = (interests) => interests === null || interests === void 0 ? void 0 : interests.map(interest => convertOpenInterest(interest));
+exports.convertOpenInterests = convertOpenInterests;
+const convertOpenInterest = (interest) => ({
+    long: parseFloat(interest.beforeV10.long) / 1e10,
+    short: parseFloat(interest.beforeV10.short) / 1e10,
+    max: parseFloat(interest.beforeV10.max) / 1e10,
+});
+const convertPairDepths = (pairDepths) => pairDepths === null || pairDepths === void 0 ? void 0 : pairDepths.map(pairDepth => convertPairDepth(pairDepth));
+exports.convertPairDepths = convertPairDepths;
+const convertPairDepth = (pairDepth) => ({
+    onePercentDepthAboveUsd: parseInt(pairDepth.onePercentDepthAboveUsd),
+    onePercentDepthBelowUsd: parseInt(pairDepth.onePercentDepthBelowUsd),
+});
+const convertPairBorrowingFees = (pairParams) => pairParams === null || pairParams === void 0 ? void 0 : pairParams.pairs.map(pairParam => convertPairBorrowingFee(pairParam));
+exports.convertPairBorrowingFees = convertPairBorrowingFees;
+const convertPairGroupBorrowingFee = (pairParam) => ({
+    groupIndex: parseInt(pairParam.groupIndex),
+    initialAccFeeLong: parseFloat(pairParam.initialAccFeeLong) / 1e10,
+    initialAccFeeShort: parseFloat(pairParam.initialAccFeeShort) / 1e10,
+    pairAccFeeLong: parseFloat(pairParam.pairAccFeeLong) / 1e10,
+    pairAccFeeShort: parseFloat(pairParam.pairAccFeeShort) / 1e10,
+    prevGroupAccFeeLong: parseFloat(pairParam.prevGroupAccFeeLong) / 1e10,
+    prevGroupAccFeeShort: parseFloat(pairParam.prevGroupAccFeeShort) / 1e10,
+    block: parseInt(pairParam.block),
+});
+const convertPairBorrowingFee = (pairParams) => ({
+    groups: pairParams.groups.map(pairParam => convertPairGroupBorrowingFee(pairParam)),
+    feePerBlock: parseFloat(pairParams.feePerBlock) / 1e10,
+    accFeeLong: parseFloat(pairParams.accFeeLong) / 1e10,
+    accFeeShort: parseFloat(pairParams.accFeeShort) / 1e10,
+    accLastUpdatedBlock: parseInt(pairParams.accLastUpdatedBlock),
+    oi: {
+        max: parseFloat(pairParams.oi.beforeV10.max) / 1e10 || 0,
+        long: parseFloat(pairParams.oi.beforeV10.long) / 1e10 || 0,
+        short: parseFloat(pairParams.oi.beforeV10.short) / 1e10 || 0,
+    },
+    feeExponent: parseInt(pairParams.feeExponent) || 0,
+    feePerBlockCap: (0, exports.convertFeePerBlockCap)(pairParams === null || pairParams === void 0 ? void 0 : pairParams.feePerBlockCap),
+});
+const convertGroupBorrowingFees = (pairParams) => pairParams === null || pairParams === void 0 ? void 0 : pairParams.groups.map(pairParam => convertGroupBorrowingFee(pairParam));
+exports.convertGroupBorrowingFees = convertGroupBorrowingFees;
+const convertGroupBorrowingFee = (pairParams) => ({
+    oi: {
+        long: parseFloat(pairParams.oi.long) / 1e10,
+        short: parseFloat(pairParams.oi.short) / 1e10,
+        max: parseFloat(pairParams.oi.max) / 1e10 || 0,
+    },
+    feePerBlock: parseFloat(pairParams.feePerBlock) / 1e10,
+    accFeeLong: parseFloat(pairParams.accFeeLong) / 1e10,
+    accFeeShort: parseFloat(pairParams.accFeeShort) / 1e10,
+    accLastUpdatedBlock: parseInt(pairParams.accLastUpdatedBlock),
+    feeExponent: parseInt(pairParams.feeExponent) || 0,
+});
+const convertTradingGroups = (groups) => groups === null || groups === void 0 ? void 0 : groups.map(group => convertTradingGroup(group));
+exports.convertTradingGroups = convertTradingGroups;
+const convertTradingGroup = (group) => ({
+    maxLeverage: parseFloat(group.maxLeverage) / 1e3,
+    minLeverage: parseFloat(group.minLeverage) / 1e3,
+    name: group.name,
+});
+const convertTradingPairs = (pairs) => pairs === null || pairs === void 0 ? void 0 : pairs.filter(pair => pair.from !== "").map((pair, index) => convertTradingPair(pair, index));
+exports.convertTradingPairs = convertTradingPairs;
+const convertTradingPair = (pair, index) => ({
+    name: (0, exports.convertPairName)(pair),
+    description: (0, __1.getPairDescription)(index),
+    from: pair.from,
+    to: pair.to,
+    pairIndex: index,
+    feeIndex: parseInt(pair.feeIndex),
+    groupIndex: parseInt(pair.groupIndex),
+    spreadP: parseFloat(pair.spreadP) / 1e10 / 100,
+});
+const convertTradesAndLimitOrders = (allItems, collaterals) => allItems === null || allItems === void 0 ? void 0 : allItems.map(item => {
+    return (0, exports.convertTradeContainer)(item, collaterals);
+});
+exports.convertTradesAndLimitOrders = convertTradesAndLimitOrders;
+const convertTradeContainer = (tradeContainer, collaterals) => {
+    const trade = (0, exports.convertTrade)(tradeContainer.trade, collaterals);
+    const collateralIndex = trade.collateralIndex;
+    return {
+        trade,
+        tradeInfo: (0, exports.convertTradeInfo)(tradeContainer.tradeInfo),
+        initialAccFees: tradeContainer.initialAccFees === undefined
+            ? {
+                accPairFee: 0,
+                accGroupFee: 0,
+                block: 0,
+            }
+            : (0, exports.convertTradeInitialAccFees)(tradeContainer.initialAccFees),
+        liquidationParams: tradeContainer.liquidationParams === undefined
+            ? {
+                maxLiqSpreadP: 0,
+                startLiqThresholdP: 0,
+                endLiqThresholdP: 0,
+                startLeverage: 0,
+                endLeverage: 0,
+            }
+            : (0, __1.convertLiquidationParams)(tradeContainer.liquidationParams),
+        tradeFeesData: tradeContainer.tradeFeesData
+            ? // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call
+                (0, __1.convertTradeFeesData)(tradeContainer.tradeFeesData, collaterals[collateralIndex - 1].collateralConfig)
+            : undefined,
+        uiRealizedPnlData: tradeContainer.uiRealizedPnlData
+            ? // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call
+                (0, __1.convertUiRealizedPnlData)(tradeContainer.uiRealizedPnlData, collaterals[collateralIndex - 1].collateralConfig)
+            : undefined,
+    };
+};
+exports.convertTradeContainer = convertTradeContainer;
+const convertPairFactor = (pairFactor) => ({
+    cumulativeFactor: parseFloat(pairFactor.cumulativeFactor) / 1e10,
+    protectionCloseFactor: parseFloat(pairFactor.protectionCloseFactor) / 1e10,
+    protectionCloseFactorBlocks: parseInt(pairFactor.protectionCloseFactorBlocks),
+    exemptOnOpen: pairFactor.exemptOnOpen,
+    exemptAfterProtectionCloseFactor: pairFactor.exemptAfterProtectionCloseFactor,
+});
+exports.convertPairFactor = convertPairFactor;
+const convertTrade = (trade, collaterals) => {
+    var _a;
+    const { long, user } = trade;
+    const collateralIndex = parseInt(trade.collateralIndex);
+    const collateral = collaterals[collateralIndex - 1];
+    const decimals = ((_a = collateral === null || collateral === void 0 ? void 0 : collateral.collateralConfig) === null || _a === void 0 ? void 0 : _a.decimals) || 18;
+    return {
+        user,
+        index: parseInt(trade.index),
+        pairIndex: parseInt(trade.pairIndex),
+        leverage: parseInt(trade.leverage) / 1e3,
+        long,
+        isOpen: trade.isOpen,
+        collateralIndex,
+        tradeType: parseInt(trade.tradeType),
+        collateralAmount: parseFloat(trade.collateralAmount) / Math.pow(10, decimals),
+        openPrice: parseFloat(trade.openPrice) / 1e10,
+        sl: parseFloat(trade.sl) / 1e10,
+        tp: parseFloat(trade.tp) / 1e10,
+        isCounterTrade: trade.isCounterTrade,
+        positionSizeToken: trade.positionSizeToken
+            ? parseFloat(trade.positionSizeToken) / Math.pow(10, decimals)
+            : undefined,
+    };
+};
+exports.convertTrade = convertTrade;
+const convertTradeInfo = (tradeInfo) => ({
+    createdBlock: parseInt(tradeInfo.createdBlock),
+    tpLastUpdatedBlock: parseInt(tradeInfo.tpLastUpdatedBlock),
+    slLastUpdatedBlock: parseInt(tradeInfo.slLastUpdatedBlock),
+    maxSlippageP: parseFloat(tradeInfo.maxSlippageP) / 1e3 || 1,
+    lastOiUpdateTs: tradeInfo.lastOiUpdateTs,
+    collateralPriceUsd: tradeInfo.collateralPriceUsd && tradeInfo.collateralPriceUsd !== "0"
+        ? parseFloat(tradeInfo.collateralPriceUsd) / 1e8
+        : 1,
+    contractsVersion: parseInt(tradeInfo.contractsVersion),
+    lastPosIncreaseBlock: parseInt(tradeInfo.lastPosIncreaseBlock),
+});
+exports.convertTradeInfo = convertTradeInfo;
+const convertTradeInitialAccFees = (initialAccFees) => ({
+    accPairFee: parseFloat(initialAccFees.accPairFee || "0") / 1e10,
+    accGroupFee: parseFloat(initialAccFees.accGroupFee || "0") / 1e10,
+    block: parseInt(initialAccFees.block || "0"),
+});
+exports.convertTradeInitialAccFees = convertTradeInitialAccFees;
+const generateStockPairToActiveStockSplit = (pairs) => {
+    const result = new Map();
+    if (!pairs) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return result;
+    }
+    const basePairFroms = new Set();
+    const splitPairFroms = new Set();
+    pairs.forEach(p => {
+        const from = p.from;
+        if (from.includes("_")) {
+            splitPairFroms.add(from);
+        }
+        else {
+            basePairFroms.add(from);
+        }
+    });
+    splitPairFroms.forEach(splitFrom => {
+        const [potentialSplitPairFromBase, potentialSplitPairFromSplitId] = splitFrom.split("_");
+        const currentHighestSplitPairIdForBasePair = result.get(potentialSplitPairFromBase);
+        if ((currentHighestSplitPairIdForBasePair &&
+            +potentialSplitPairFromSplitId >
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+                +currentHighestSplitPairIdForBasePair.split("_")[1]) ||
+            (!currentHighestSplitPairIdForBasePair &&
+                basePairFroms.has(potentialSplitPairFromBase))) {
+            result.set(potentialSplitPairFromBase, splitFrom);
+        }
+    });
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return result;
+};
+exports.generateStockPairToActiveStockSplit = generateStockPairToActiveStockSplit;
+const convertContestLeaderboardEntry = (entry) => {
+    const [trader, numWins, numLosses, avgWin, avgLoss, daiProfit, pctProfit, daiVolume,] = entry;
+    return {
+        trader,
+        numWins,
+        numLosses,
+        avgWin,
+        avgLoss,
+        daiProfit,
+        pctProfit,
+        daiVolume,
+    };
+};
+exports.convertContestLeaderboardEntry = convertContestLeaderboardEntry;
+// OiWindow values are normalized to USD 1e18
+const convertPairOi = (collateral) => ({
+    oiLongUsd: parseFloat(collateral.oiLongUsd) / 1e18,
+    oiShortUsd: parseFloat(collateral.oiShortUsd) / 1e18,
+});
+exports.convertPairOi = convertPairOi;
+const convertOiWindows = (oiWindows) => {
+    return oiWindows === null || oiWindows === void 0 ? void 0 : oiWindows.map(pairWindows => {
+        const converted = {};
+        for (const [key, oiWindow] of Object.entries(pairWindows)) {
+            converted[key] = (0, exports.convertPairOi)(oiWindow);
+        }
+        return converted;
+    });
+};
+exports.convertOiWindows = convertOiWindows;
+const convertOiWindowsSettings = (oiWindowsSettings) => ({
+    startTs: oiWindowsSettings.startTs,
+    windowsDuration: oiWindowsSettings.windowsDuration,
+    windowsCount: oiWindowsSettings.windowsCount,
+});
+exports.convertOiWindowsSettings = convertOiWindowsSettings;
+const convertCollateralConfig = (collateral) => ({
+    collateral: collateral.collateral,
+    isActive: collateral.isActive,
+    precision: parseInt(collateral.collateralConfig.precision),
+    precisionDelta: parseInt(collateral.collateralConfig.precisionDelta),
+    decimals: collateral.collateralConfig.decimals,
+});
+exports.convertCollateralConfig = convertCollateralConfig;
+const convertFeeTiers = (feeTiersBackend) => {
+    var _a;
+    return ({
+        tiers: feeTiersBackend === null || feeTiersBackend === void 0 ? void 0 : feeTiersBackend.tiers.map(tier => ({
+            feeMultiplier: Number(tier.feeMultiplier) / 1e3,
+            pointsThreshold: parseFloat(tier.pointsThreshold),
+        })),
+        multipliers: ((_a = feeTiersBackend === null || feeTiersBackend === void 0 ? void 0 : feeTiersBackend.multipliers) === null || _a === void 0 ? void 0 : _a.map(mult => parseFloat(mult) / 1e3)) || [],
+        currentDay: (feeTiersBackend === null || feeTiersBackend === void 0 ? void 0 : feeTiersBackend.currentDay) || 0,
+    });
+};
+exports.convertFeeTiers = convertFeeTiers;
+const convertTraderFeeTiers = (traderFeeTiers) => ({
+    traderEnrollment: {
+        status: traderFeeTiers.traderEnrollment.status,
+    },
+    traderInfo: {
+        lastDayUpdated: traderFeeTiers.traderInfo.lastDayUpdated,
+        trailingPoints: parseFloat(traderFeeTiers.traderInfo.trailingPoints) / 1e18,
+    },
+    inboundPoints: parseFloat(traderFeeTiers.inboundPoints) / 1e18,
+    outboundPoints: parseFloat(traderFeeTiers.outboundPoints) / 1e18,
+    lastDayUpdatedPoints: parseFloat(traderFeeTiers.lastDayUpdatedPoints) / 1e18,
+    expiredPoints: traderFeeTiers.expiredPoints.map(point => parseFloat(point) / 1e18),
+    unclaimedPoints: parseFloat(traderFeeTiers.unclaimedPoints) / 1e18,
+});
+exports.convertTraderFeeTiers = convertTraderFeeTiers;
+const convertGlobalTradeFeeParams = (fee) => ({
+    referralFeeP: parseFloat(fee.referralFeeP) / 1e5,
+    govFeeP: parseFloat(fee.govFeeP) / 1e5,
+    triggerOrderFeeP: parseFloat(fee.triggerOrderFeeP) / 1e5,
+    gnsOtcFeeP: parseFloat(fee.gnsOtcFeeP) / 1e5,
+    gTokenFeeP: parseFloat(fee.gTokenFeeP) / 1e5,
+});
+exports.convertGlobalTradeFeeParams = convertGlobalTradeFeeParams;
+const convertMaxLeverages = (maxLeverages) => maxLeverages === null || maxLeverages === void 0 ? void 0 : maxLeverages.map(maxLeverage => parseFloat(maxLeverage) / 1e3);
+exports.convertMaxLeverages = convertMaxLeverages;
+const convertFeePerBlockCap = (feeCap) => ({
+    minP: (feeCap === null || feeCap === void 0 ? void 0 : feeCap.minP) ? parseFloat(feeCap.minP.toString()) / 1e3 / 100 : 0,
+    maxP: (feeCap === null || feeCap === void 0 ? void 0 : feeCap.maxP) ? parseFloat(feeCap.maxP.toString()) / 1e3 / 100 : 1,
+});
+exports.convertFeePerBlockCap = convertFeePerBlockCap;
+const convertPairName = (pair) => {
+    if (!pair)
+        return "";
+    return pair.from.split("_")[0] + "/" + pair.to;
+};
+exports.convertPairName = convertPairName;

package/lib/backend/tradingVariables/index.d.ts

@@ -0,0 +1,3 @@
+import { TransformedGlobalTradingVariables } from "./types";
+import { GlobalTradingVariablesBackend } from "./backend.types";
+export declare const transformGlobalTradingVariables: (rawData: GlobalTradingVariablesBackend) => TransformedGlobalTradingVariables;

package/lib/backend/tradingVariables/index.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformGlobalTradingVariables = void 0;
+const converter_1 = require("./converter");
+const trade_1 = require("../../trade");
+const transformGlobalTradingVariables = (rawData) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const globalTradingVariables = {
+        collaterals: (0, converter_1.convertCollaterals)(rawData.collaterals),
+        pairs: (0, converter_1.convertTradingPairs)(rawData.pairs),
+        stockPairToActiveStockSplit: (0, converter_1.generateStockPairToActiveStockSplit)(rawData.pairs),
+        groups: (0, converter_1.convertTradingGroups)(rawData.groups),
+        fees: (0, converter_1.convertFees)(rawData.fees),
+        orderTimeout: rawData.marketOrdersTimeoutBlocks,
+        blockConfirmations: rawData.blockConfirmations,
+        forexClosed: !rawData.isForexOpen,
+        stocksClosed: !rawData.isStocksOpen,
+        indicesClosed: !rawData.isIndicesOpen,
+        commoditiesClosed: !rawData.isCommoditiesOpen,
+        pairDepths: ((_a = rawData.pairInfos) === null || _a === void 0 ? void 0 : _a.pairDepths) !== undefined
+            ? (0, converter_1.convertPairDepths)(rawData.pairInfos.pairDepths)
+            : [],
+        pairMaxLeverages: ((_b = rawData.pairInfos) === null || _b === void 0 ? void 0 : _b.maxLeverages) !== undefined
+            ? (0, converter_1.convertMaxLeverages)(rawData.pairInfos.maxLeverages)
+            : [],
+        maxNegativePnlOnOpenP: (rawData.maxNegativePnlOnOpenP && rawData.maxNegativePnlOnOpenP / 1e10) ||
+            undefined,
+        oiWindowsSettings: rawData.oiWindowsSettings !== undefined
+            ? (0, converter_1.convertOiWindowsSettings)(rawData.oiWindowsSettings)
+            : { startTs: 0, windowsDuration: 0, windowsCount: 0 },
+        oiWindows: rawData.oiWindows !== undefined
+            ? (0, converter_1.convertOiWindows)(rawData.oiWindows)
+            : [],
+        feeTiers: (0, converter_1.convertFeeTiers)(rawData.feeTiers),
+        liquidationParams: {
+            groups: ((_c = rawData.liquidationParams) === null || _c === void 0 ? void 0 : _c.groups.map(liqParams => (0, trade_1.convertLiquidationParams)(liqParams))) || [],
+            pairs: ((_d = rawData.liquidationParams) === null || _d === void 0 ? void 0 : _d.pairs.map(liqParams => (0, trade_1.convertLiquidationParams)(liqParams))) || [],
+        },
+        pairFactors: ((_f = (_e = rawData.pairInfos) === null || _e === void 0 ? void 0 : _e.pairFactors) === null || _f === void 0 ? void 0 : _f.map(factor => (0, converter_1.convertPairFactor)(factor))) || [],
+        globalTradeFeeParams: rawData.globalTradeFeeParams
+            ? (0, converter_1.convertGlobalTradeFeeParams)(rawData.globalTradeFeeParams)
+            : undefined,
+        congestionLevels: rawData.congestionLevels,
+    };
+    const currentBlock = (rawData.currentBlock > -1 && rawData.currentBlock) || undefined;
+    const l1BlockNumber = (rawData.currentL1Block > -1 && rawData.currentL1Block) || undefined;
+    const pairIndexes = {};
+    for (let i = 0; i < ((_g = rawData.pairs) === null || _g === void 0 ? void 0 : _g.length); i++) {
+        pairIndexes[rawData.pairs[i].from + "/" + rawData.pairs[i].to] = i;
+    }
+    if (globalTradingVariables.collaterals !== undefined) {
+        const { collaterals } = globalTradingVariables;
+        for (let i = 0; i < collaterals.length; i++) {
+            collaterals[i].tradingPairs = getTradingPairs(globalTradingVariables.pairs, collaterals);
+        }
+    }
+    return {
+        globalTradingVariables,
+        pairIndexes,
+        blockNumber: currentBlock,
+        l1BlockNumber,
+    };
+};
+exports.transformGlobalTradingVariables = transformGlobalTradingVariables;
+// Orphaned function
+const getTradingPairs = (pairs, collaterals) => {
+    const tradingPairs = new Map();
+    if (pairs) {
+        for (let j = 0; j < pairs.length; j++) {
+            const pair = pairs[j];
+            // pair is tradeable if any collateral is enabled (max oi > 0)
+            if (collaterals.some((collat) => collat.pairOis[j].maxCollateral > 0)) {
+                tradingPairs.set(j, pair);
+            }
+        }
+    }
+    return tradingPairs;
+};

package/lib/backend/tradingVariables/types.d.ts

@@ -0,0 +1,109 @@
+import { CollateralConfig } from "src/markets/collateral";
+import { BorrowingFee, BorrowingFeeV2, Fee, FeeTiers, FundingFees, GlobalTradeFeeParams, LeaderboardTrader, LiquidationParams, OiWindows, OiWindowsSettings, Pair, PairDepth, PairFactor, PairIndexes, TradingGroup } from "../../trade";
+import { UnifiedPairOi } from "src/markets";
+export type TransformedGlobalTradingVariables = {
+    globalTradingVariables: GlobalTradingVariablesType;
+    pairIndexes: PairIndexes;
+    blockNumber: number | undefined;
+    l1BlockNumber: number | undefined;
+};
+/**
+ * @dev Processed collateral data from backend (wrapper of contract data)
+ */
+export type TradingVariablesCollateral = {
+    pairBorrowingFees: BorrowingFee.Pair[];
+    groupBorrowingFees: BorrowingFee.Group[];
+    pairBorrowingFeesV2: {
+        params: BorrowingFeeV2.BorrowingFeeParams[];
+        data: BorrowingFeeV2.PairBorrowingFeeData[];
+    };
+    pairFundingFees: {
+        globalParams: FundingFees.PairGlobalParams[];
+        params: FundingFees.FundingFeeParams[];
+        data: FundingFees.PairFundingFeeData[];
+    };
+    collateral: string;
+    collateralIndex: number;
+    collateralConfig: CollateralConfig;
+    gToken: {
+        address: string;
+        currentBalanceCollateral: string;
+        marketCap: string;
+        maxBalanceCollateral: string;
+    };
+    tradingPairs?: Map<number, Pair>;
+    isActive: boolean;
+    prices: TokenPrices;
+    symbol: string;
+    pairOis: UnifiedPairOi[];
+};
+export type TokenPrices = {
+    collateralPriceUsd: number;
+    gnsPriceCollateral: number;
+    gnsPriceUsd: number;
+};
+export type GlobalTradingVariablesType = {
+    collaterals: TradingVariablesCollateral[];
+    paused?: boolean;
+    pairs?: Pair[];
+    stockPairToActiveStockSplit?: Map<string, string>;
+    groups?: TradingGroup[];
+    fees?: Fee[];
+    orderTimeout?: number;
+    crypto?: string[];
+    forex?: string[];
+    forexClosed?: boolean;
+    stocks?: string[];
+    stocksClosed?: boolean;
+    indices?: string[];
+    indicesClosed?: boolean;
+    commodities?: string[];
+    commoditiesClosed?: boolean;
+    blockConfirmations?: number;
+    pairDepths?: PairDepth[];
+    pairMaxLeverages?: number[];
+    maxNegativePnlOnOpenP?: number;
+    oiWindowsSettings?: OiWindowsSettings;
+    oiWindows?: OiWindows[];
+    collateralConfig?: CollateralConfig;
+    feeTiers?: FeeTiers;
+    liquidationParams: {
+        groups: LiquidationParams[];
+        pairs: LiquidationParams[];
+    };
+    pairFactors: PairFactor[];
+    globalTradeFeeParams?: GlobalTradeFeeParams;
+    congestionLevels: {
+        low: number;
+        high: number;
+    };
+};
+export interface LeaderboardTraderWithWinsLosses extends LeaderboardTrader {
+    wins?: number;
+    losses?: number;
+}
+export interface ILeaderboard {
+    ready: boolean;
+    bestTraders: LeaderboardTraderWithWinsLosses[];
+}
+export declare enum ORDER_TYPE {
+    LIMIT = "LIMIT",
+    STOP = "STOP",
+    MARKET = "MARKET"
+}
+export declare enum TRADE_TYPE {
+    LONG = "LONG",
+    SHORT = "SHORT"
+}
+export interface ActiveNews {
+    desc: string;
+    from: number;
+    to: number;
+}
+export interface BorrowingFeePerBlock {
+    pairFee: number;
+    minPairFee: number;
+    groupFee: number;
+    pairLong: boolean;
+    groupLong: boolean;
+}

package/lib/backend/tradingVariables/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRADE_TYPE = exports.ORDER_TYPE = void 0;
+var ORDER_TYPE;
+(function (ORDER_TYPE) {
+    ORDER_TYPE["LIMIT"] = "LIMIT";
+    ORDER_TYPE["STOP"] = "STOP";
+    ORDER_TYPE["MARKET"] = "MARKET";
+})(ORDER_TYPE = exports.ORDER_TYPE || (exports.ORDER_TYPE = {}));
+var TRADE_TYPE;
+(function (TRADE_TYPE) {
+    TRADE_TYPE["LONG"] = "LONG";
+    TRADE_TYPE["SHORT"] = "SHORT";
+})(TRADE_TYPE = exports.TRADE_TYPE || (exports.TRADE_TYPE = {}));

package/lib/contracts/fetch/fees/borrowingFeesV2.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="mocha" />
 import type { GNSMultiCollatDiamond } from "../../types/generated";
 import { BorrowingFeeV2 } from "../../../trade/fees/borrowingV2";
 /**