@gainsnetwork/sdk 0.0.0-me-rc1

package/lib/backend/tradingVariables/converter.js

@@ -0,0 +1,359 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertLiquidationParams = 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.convertPairSkewDepths = exports.convertDepthBandsMapping = exports.convertPairDepthBands = exports.convertOpenInterests = exports.convertCollaterals = exports.convertFees = void 0;
+const __1 = require("../../");
+Object.defineProperty(exports, "convertLiquidationParams", { enumerable: true, get: function () { return __1.convertLiquidationParams; } });
+const converter_1 = require("../../trade/priceImpact/skew/converter");
+const converter_2 = require("../../trade/priceImpact/cumulVol/converter");
+const depthBands_1 = require("../../pricing/depthBands");
+const convertFees = (fees) => fees?.map(fee => convertFee(fee));
+exports.convertFees = convertFees;
+const convertCollateral = (collateral) => ({
+    pairBorrowingFees: collateral.borrowingFees?.v1 !== undefined
+        ? (0, exports.convertPairBorrowingFees)(collateral.borrowingFees.v1)
+        : [],
+    groupBorrowingFees: collateral.borrowingFees?.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)(collateral.borrowingFees?.v2
+            ?.pairParams),
+        data: (0, __1.convertPairBorrowingFeeDataArrayV2)(collateral.borrowingFees?.v2
+            ?.pairData),
+    },
+    pairFundingFees: {
+        globalParams: (0, __1.convertPairGlobalParamsArray)(collateral.fundingFees
+            ?.pairGlobalParams),
+        params: (0, __1.convertFundingFeeParamsArray)(collateral.fundingFees
+            ?.pairParams),
+        data: (0, __1.convertPairFundingFeeDataArray)(collateral.fundingFees
+            ?.pairData),
+    },
+    pairOis: (0, __1.convertPairOiArray)(collateral.pairOis, parseInt(collateral.collateralConfig.precision)),
+    pairSkewDepths: (0, exports.convertPairSkewDepths)(collateral.pairSkewDepths),
+});
+const convertCollaterals = (collaterals) => 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?.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 convertPairDepthBands = (pairDepthBands) => pairDepthBands?.map(bands => (0, converter_2.convertPairDepthBandsFromSlots)(BigInt(bands.aboveSlot1), BigInt(bands.aboveSlot2), BigInt(bands.belowSlot1), BigInt(bands.belowSlot2))) || [];
+exports.convertPairDepthBands = convertPairDepthBands;
+const convertDepthBandsMapping = (mapping) => {
+    // First decode the raw slots to get bands in basis points
+    const bandsBps = (0, depthBands_1.decodeDepthBandsMapping)(BigInt(mapping.slot1), BigInt(mapping.slot2));
+    // Convert from basis points to 0-1 range
+    return {
+        bands: bandsBps.map(bps => bps / 10000),
+    };
+};
+exports.convertDepthBandsMapping = convertDepthBandsMapping;
+const convertPairSkewDepths = (pairSkewDepths) => {
+    if (!pairSkewDepths)
+        return {};
+    return (0, converter_1.convertPairSkewDepths)(pairSkewDepths);
+};
+exports.convertPairSkewDepths = convertPairSkewDepths;
+const convertPairBorrowingFees = (pairParams) => 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?.feePerBlockCap),
+});
+const convertGroupBorrowingFees = (pairParams) => 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?.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
+    ?.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,
+});
+const convertTradesAndLimitOrders = (allItems, collaterals) => 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) => {
+    const { long, user } = trade;
+    const collateralIndex = parseInt(trade.collateralIndex);
+    const collateral = collaterals[collateralIndex - 1];
+    const decimals = collateral?.collateralConfig?.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) / 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) / 1e18
+            : 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?.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) => ({
+    tiers: feeTiersBackend?.tiers.map(tier => ({
+        feeMultiplier: Number(tier.feeMultiplier) / 1e3,
+        pointsThreshold: parseFloat(tier.pointsThreshold),
+    })),
+    multipliers: feeTiersBackend?.multipliers?.map(mult => parseFloat(mult) / 1e3) || [],
+    currentDay: feeTiersBackend?.currentDay || 0,
+    stakingTiers: feeTiersBackend?.stakingTiers.map(tier => ({
+        feeMultiplier: Number(tier.feeMultiplier) / 1e3,
+        pointsThreshold: parseFloat(tier.pointsThreshold),
+    })) || [],
+    gnsVaultAddress: feeTiersBackend?.gnsVaultAddress ||
+        "0x0000000000000000000000000000000000000000",
+    useGnsVaultBalance: feeTiersBackend?.useGnsVaultBalance || false,
+});
+exports.convertFeeTiers = convertFeeTiers;
+const convertTraderFeeTiers = (traderFeeTiers) => ({
+    traderEnrollment: {
+        status: traderFeeTiers.traderEnrollment.status,
+    },
+    traderInfo: {
+        lastDayUpdated: traderFeeTiers.traderInfo.lastDayUpdated,
+        trailingPoints: parseFloat(traderFeeTiers.traderInfo.trailingPoints) / 1e18,
+    },
+    stakingInfo: {
+        stakedGns: parseFloat(traderFeeTiers.stakingInfo.stakedGns) / 1e18,
+        stakedVaultGns: parseFloat(traderFeeTiers.stakingInfo.stakedVaultGns) / 1e18,
+        bonusAmount: Number(traderFeeTiers.stakingInfo.bonusAmount),
+        stakeTimestamp: traderFeeTiers.stakingInfo.stakeTimestamp,
+        feeMultiplierCache: parseFloat(traderFeeTiers.stakingInfo.feeMultiplierCache) / 1e3,
+    },
+    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?.map(maxLeverage => parseFloat(maxLeverage) / 1e3);
+exports.convertMaxLeverages = convertMaxLeverages;
+const convertFeePerBlockCap = (feeCap) => ({
+    minP: feeCap?.minP ? parseFloat(feeCap.minP.toString()) / 1e3 / 100 : 0,
+    maxP: 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,5 @@
+import { TransformedGlobalTradingVariables } from "./types";
+import { GlobalTradingVariablesBackend } from "./backend.types";
+export declare const transformGlobalTradingVariables: (rawData: GlobalTradingVariablesBackend) => TransformedGlobalTradingVariables;
+export * from "./backend.types";
+export * from "./types";

package/lib/backend/tradingVariables/index.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformGlobalTradingVariables = void 0;
+const converter_1 = require("./converter");
+const trade_1 = require("../../trade");
+const transformGlobalTradingVariables = (rawData) => {
+    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,
+        pairDepthBands: rawData.pairInfos?.pairDepthBands !== undefined
+            ? (0, converter_1.convertPairDepthBands)(rawData.pairInfos.pairDepthBands)
+            : [],
+        depthBandsMapping: rawData.depthBandsMapping !== undefined
+            ? (0, converter_1.convertDepthBandsMapping)(rawData.depthBandsMapping)
+            : { bands: [] },
+        pairMaxLeverages: rawData.pairInfos?.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: rawData.liquidationParams?.groups?.map(liqParams => (0, trade_1.convertLiquidationParams)(liqParams)) || [],
+            pairs: rawData.liquidationParams?.pairs?.map(liqParams => (0, trade_1.convertLiquidationParams)(liqParams)) || [],
+        },
+        counterTradeSettings: (0, trade_1.convertCounterTradeSettingsArray)(rawData.counterTradeSettings),
+        pairFactors: rawData.pairInfos?.pairFactors?.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 < rawData.pairs?.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;
+};
+// Re-export everything from backend.types
+__exportStar(require("./backend.types"), exports);
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,115 @@
+import { CollateralConfig } from "src/markets/collateral";
+import { BorrowingFee, BorrowingFeeV2, CounterTradeSettings, Fee, FeeTiers, FundingFees, GlobalTradeFeeParams, LeaderboardTrader, LiquidationParams, OiWindows, OiWindowsSettings, Pair, PairFactor, PairIndexes, TradingGroup } from "../../trade";
+import { PairDepthBands, DepthBandsMapping } from "../../trade/priceImpact/cumulVol/types";
+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[];
+    pairSkewDepths: {
+        [pairIndex: number]: number;
+    };
+};
+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;
+    pairDepthBands?: PairDepthBands[];
+    depthBandsMapping?: DepthBandsMapping;
+    pairMaxLeverages?: number[];
+    maxNegativePnlOnOpenP?: number;
+    oiWindowsSettings?: OiWindowsSettings;
+    oiWindows?: OiWindows[];
+    collateralConfig?: CollateralConfig;
+    feeTiers?: FeeTiers;
+    liquidationParams: {
+        groups: LiquidationParams[];
+        pairs: LiquidationParams[];
+    };
+    counterTradeSettings: CounterTradeSettings[];
+    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 = {}));