@gainsnetwork/sdk 0.1.29-rc3 → 0.2.0-rc3

package/lib/contracts/utils/openTrades.js

@@ -1,188 +1,380 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchOpenPairTradesRaw = exports.fetchOpenPairTrades = void 0;
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-const ethcall_1 = require("ethcall");
-const fetchOpenPairTrades = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
-    const rawTrades = yield (0, exports.fetchOpenPairTradesRaw)(contracts, overrides);
-    const { precision: collateralPrecision } = yield contracts.gnsBorrowingFees.collateralConfig();
-    return rawTrades.map(rawTrade => _prepareTradeContainer(rawTrade.trade, rawTrade.tradeInfo, rawTrade.initialAccFees, rawTrade.tradeData, collateralPrecision));
-});
-exports.fetchOpenPairTrades = fetchOpenPairTrades;
-const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!contracts) {
-        return [];
-    }
-    const { pairBatchSize = 10, useMulticall = false, blockTag = "latest", } = overrides;
-    const { gnsMultiCollatDiamond: multiCollatDiamondContract } = contracts;
-    try {
-        const totalPairIndexes = (yield multiCollatDiamondContract.pairsCount({ blockTag })).toNumber() -
-            1;
-        let allOpenPairTrades = [];
-        for (let batchStartPairIndex = 0; batchStartPairIndex < totalPairIndexes; batchStartPairIndex += pairBatchSize) {
-            const batchEndPairIndex = Math.min(batchStartPairIndex + pairBatchSize - 1, totalPairIndexes);
-            const openPairTradesBatch = useMulticall
-                ? yield fetchOpenPairTradesBatchMulticall(contracts, batchStartPairIndex, batchEndPairIndex, blockTag)
-                : yield fetchOpenPairTradesBatch(contracts, batchStartPairIndex, batchEndPairIndex);
-            allOpenPairTrades = allOpenPairTrades.concat(openPairTradesBatch);
-        }
-        return allOpenPairTrades;
-    }
-    catch (error) {
-        console.error(`Unexpected error while fetching open pair trades!`);
-        throw error;
-    }
-});
-exports.fetchOpenPairTradesRaw = fetchOpenPairTradesRaw;
-const fetchOpenPairTradesBatch = (contracts, startPairIndex, endPairIndex) => __awaiter(void 0, void 0, void 0, function* () {
-    const { gfarmTradingStorageV5: storageContract, gnsBorrowingFees: borrowingFeesContract, gnsTradingCallbacks: callbacksContract, } = contracts;
-    const maxTradesPerPair = (yield storageContract.maxTradesPerPair()).toNumber();
-    const pairIndexesToFetch = Array.from({ length: endPairIndex - startPairIndex + 1 }, (_, i) => i + startPairIndex);
-    const rawTrades = yield Promise.all(pairIndexesToFetch.map((pairIndex) => __awaiter(void 0, void 0, void 0, function* () {
-        const pairTraderAddresses = yield storageContract.pairTradersArray(pairIndex);
-        if (pairTraderAddresses.length === 0) {
-            return [];
-        }
-        const openTradesForPairTraders = yield Promise.all(pairTraderAddresses.map((pairTraderAddress) => __awaiter(void 0, void 0, void 0, function* () {
-            const openTradesCalls = new Array(maxTradesPerPair);
-            for (let pairTradeIndex = 0; pairTradeIndex < maxTradesPerPair; pairTradeIndex++) {
-                openTradesCalls[pairTradeIndex] = storageContract.openTrades(pairTraderAddress, pairIndex, pairTradeIndex);
-            }
-            const openTradesForTraderAddress = yield Promise.all(openTradesCalls);
-            // Filter out any of the trades that aren't *really* open (NOTE: these will have an empty trader address, so just test against that)
-            const actualOpenTradesForTrader = openTradesForTraderAddress.filter(openTrade => openTrade.trader === pairTraderAddress);
-            const [actualOpenTradesTradeInfos, actualOpenTradesInitialAccFees, actualOpenTradesTradeData,] = yield Promise.all([
-                Promise.all(actualOpenTradesForTrader.map(aot => storageContract.openTradesInfo(aot.trader, aot.pairIndex, aot.index))),
-                Promise.all(actualOpenTradesForTrader.map(aot => borrowingFeesContract.initialAccFees(aot.trader, aot.pairIndex, aot.index))),
-                Promise.all(actualOpenTradesForTrader.map(aot => callbacksContract.tradeData(aot.trader, aot.pairIndex, aot.index, 0))),
-            ]);
-            const finalOpenTradesForTrader = new Array(actualOpenTradesForTrader.length);
-            for (let tradeIndex = 0; tradeIndex < actualOpenTradesForTrader.length; tradeIndex++) {
-                const tradeInfo = actualOpenTradesTradeInfos[tradeIndex];
-                if (tradeInfo === undefined) {
-                    continue;
-                }
-                if (actualOpenTradesInitialAccFees[tradeIndex] === undefined) {
-                    continue;
-                }
-                const trade = actualOpenTradesForTrader[tradeIndex];
-                const tradeData = actualOpenTradesTradeData[tradeIndex];
-                finalOpenTradesForTrader[tradeIndex] = {
-                    trade,
-                    tradeInfo,
-                    initialAccFees: {
-                        borrowing: actualOpenTradesInitialAccFees[tradeIndex],
-                    },
-                    tradeData,
-                };
-            }
-            return finalOpenTradesForTrader;
-        })));
-        return openTradesForPairTraders;
-    })));
-    const perPairTrades = rawTrades.reduce((a, b) => a.concat(b), []);
-    return perPairTrades.reduce((a, b) => a.concat(b), []);
-});
-const fetchOpenPairTradesBatchMulticall = (contracts, startPairIndex, endPairIndex, blockTag) => __awaiter(void 0, void 0, void 0, function* () {
-    const { gfarmTradingStorageV5: storageContract, gnsBorrowingFees: borrowingFeesContract, gnsTradingCallbacks: callbacksContract, } = contracts;
-    // Convert to Multicall for efficient RPC usage
-    const multicallProvider = new ethcall_1.Provider();
-    yield multicallProvider.init(storageContract.provider);
-    const storageContractMulticall = new ethcall_1.Contract(storageContract.address, [
-        ...storageContract.interface.fragments,
-    ]);
-    const borrowingFeesContractMulticall = new ethcall_1.Contract(borrowingFeesContract.address, [...borrowingFeesContract.interface.fragments]);
-    const callbacksContractMulticall = new ethcall_1.Contract(callbacksContract.address, [
-        ...callbacksContract.interface.fragments,
-    ]);
-    const maxTradesPerPair = (yield storageContract.maxTradesPerPair()).toNumber();
-    const pairIndexesToFetch = Array.from({ length: endPairIndex - startPairIndex + 1 }, (_, i) => i + startPairIndex);
-    const mcPairTraderAddresses = yield multicallProvider.all(pairIndexesToFetch.map(pairIndex => storageContractMulticall.pairTradersArray(pairIndex)), blockTag);
-    const mcFlatOpenTrades = yield multicallProvider.all(mcPairTraderAddresses
-        .map((pairTraderAddresses, _ix) => {
-        return pairTraderAddresses
-            .map((pairTraderAddress) => {
-            const openTradesCalls = new Array(maxTradesPerPair);
-            for (let pairTradeIndex = 0; pairTradeIndex < maxTradesPerPair; pairTradeIndex++) {
-                openTradesCalls[pairTradeIndex] =
-                    storageContractMulticall.openTrades(pairTraderAddress, _ix + startPairIndex, pairTradeIndex);
-            }
-            return openTradesCalls;
-        })
-            .reduce((acc, val) => acc.concat(val), []);
-    })
-        .reduce((acc, val) => acc.concat(val), []), blockTag);
-    const openTrades = mcFlatOpenTrades.filter(openTrade => openTrade[0] !== "0x0000000000000000000000000000000000000000");
-    const [openTradesTradeInfos, openTradesInitialAccFees, openTradesTradeData] = yield Promise.all([
-        multicallProvider.all(openTrades.map(openTrade => storageContractMulticall.openTradesInfo(openTrade.trader, openTrade.pairIndex, openTrade.index)), blockTag),
-        multicallProvider.all(openTrades.map(openTrade => borrowingFeesContractMulticall.initialAccFees(openTrade.trader, openTrade.pairIndex, openTrade.index)), blockTag),
-        multicallProvider.all(openTrades.map(openTrade => callbacksContractMulticall.tradeData(openTrade.trader, openTrade.pairIndex, openTrade.index, 0)), blockTag),
-    ]);
-    const finalTrades = new Array(openTrades.length);
-    for (let tradeIndex = 0; tradeIndex < openTradesTradeInfos.length; tradeIndex++) {
-        const tradeInfo = openTradesTradeInfos[tradeIndex];
-        if (tradeInfo === undefined) {
-            console.error("No trade info found for open trade while fetching open trades!", { trade: openTradesTradeInfos[tradeIndex] });
-            continue;
-        }
-        if (openTradesInitialAccFees[tradeIndex] === undefined) {
-            console.error("No initial fees found for open trade while fetching open trades!", { trade: openTrades[tradeIndex] });
-            continue;
-        }
-        const trade = openTrades[tradeIndex];
-        const tradeData = openTradesTradeData[tradeIndex];
-        finalTrades[tradeIndex] = {
-            trade,
-            tradeInfo,
-            initialAccFees: {
-                borrowing: openTradesInitialAccFees[tradeIndex],
-            },
-            tradeData,
-        };
-    }
-    return finalTrades.filter(trade => trade !== undefined);
-});
-const _prepareTradeContainer = (trade, tradeInfo, tradeInitialAccFees, tradeData, collateralPrecision) => ({
-    trade: {
-        trader: trade.trader,
-        pairIndex: parseInt(trade.pairIndex.toString()),
-        index: parseInt(trade.index.toString()),
-        initialPosToken: parseFloat(trade.initialPosToken.toString()) / 1e18,
-        openPrice: parseFloat(trade.openPrice.toString()) / 1e10,
-        buy: trade.buy.toString() === "true",
-        leverage: parseInt(trade.leverage.toString()),
-        tp: parseFloat(trade.tp.toString()) / 1e10,
-        sl: parseFloat(trade.sl.toString()) / 1e10,
-    },
-    tradeInfo: {
-        beingMarketClosed: tradeInfo.beingMarketClosed.toString() === "true",
-        tokenPriceDai: parseFloat(tradeInfo.tokenPriceDai.toString()) / 1e10,
-        openInterestDai: parseFloat(tradeInfo.openInterestDai.toString()) /
-            parseFloat(collateralPrecision.toString()),
-        tpLastUpdated: tradeInfo.tpLastUpdated,
-        slLastUpdated: tradeInfo.slLastUpdated,
-    },
-    tradeData: {
-        maxSlippageP: parseFloat(tradeData.maxSlippageP.toString()) / 1e10,
-        lastOiUpdateTs: parseFloat(tradeData.lastOiUpdateTs),
-        collateralPriceUsd: parseFloat(tradeData.collateralPriceUsd.toString()) / 1e8,
-    },
-    initialAccFees: {
-        borrowing: {
-            accPairFee: parseFloat(tradeInitialAccFees.borrowing.accPairFee.toString()) / 1e10,
-            accGroupFee: parseFloat(tradeInitialAccFees.borrowing.accGroupFee.toString()) / 1e10,
-            block: parseFloat(tradeInitialAccFees.borrowing.block.toString()),
-        },
-    },
-});
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOpenPairTradesRaw = exports.fetchOpenPairTrades = void 0;
+const fetchOpenPairTrades = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const rawTrades = yield (0, exports.fetchOpenPairTradesRaw)(contracts, overrides);
+    const collateralPrecisions = (yield contracts.gnsMultiCollatDiamond.getCollaterals()).map(({ precision }) => precision);
+    return rawTrades.map(rawTrade => _prepareTradeContainer(rawTrade.trade, rawTrade.tradeInfo, rawTrade.initialAccFees, collateralPrecisions[parseInt(rawTrade.trade.collateralIndex.toString()) - 1]));
+});
+exports.fetchOpenPairTrades = fetchOpenPairTrades;
+// @todo rename
+const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!contracts) {
+        return [];
+    }
+    const { batchSize = 50,
+    // useMulticall = false,
+    // blockTag = "latest",
+     } = overrides;
+    const { gnsMultiCollatDiamond: multiCollatDiamondContract } = contracts;
+    try {
+        let allOpenPairTrades = [];
+        let running = true;
+        let offset = 0;
+        while (running) {
+            console.log("fetching with", offset, batchSize);
+            const trades = yield multiCollatDiamondContract.getAllTrades(offset, offset + batchSize);
+            const tradeInfos = yield multiCollatDiamondContract.getAllTradeInfos(offset, offset + batchSize);
+            // Array is always of length `batchSize`
+            // so we need to filter out the empty trades, indexes are reliable
+            const openTrades = trades
+                .filter(t => t.collateralIndex > 0)
+                .map((trade, ix) => ({
+                trade,
+                tradeInfo: tradeInfos[ix],
+                initialAccFees: {
+                    accPairFee: 0,
+                    accGroupFee: 0,
+                    block: 0,
+                    __placeholder: 0,
+                }, // @todo fetch initialAccFees
+            }));
+            allOpenPairTrades = allOpenPairTrades.concat(openTrades);
+            offset += batchSize + 1;
+            running =
+                parseInt(trades[trades.length - 1].collateralIndex.toString()) > 0;
+        }
+        return allOpenPairTrades;
+    }
+    catch (error) {
+        console.error(`Unexpected error while fetching open pair trades!`);
+        throw error;
+    }
+});
+exports.fetchOpenPairTradesRaw = fetchOpenPairTradesRaw;
+// @todo deprecate
+/*
+const fetchOpenPairTradesBatch = async (
+  contracts: Contracts,
+  startPairIndex: number,
+  endPairIndex: number
+): Promise<TradeContainerRaw[]> => {
+  const {
+    gfarmTradingStorageV5: storageContract,
+    gnsBorrowingFees: borrowingFeesContract,
+    gnsTradingCallbacks: callbacksContract,
+  } = contracts;
+
+  const maxTradesPerPair = (
+    await storageContract.maxTradesPerPair()
+  ).toNumber();
+
+  const pairIndexesToFetch = Array.from(
+    { length: endPairIndex - startPairIndex + 1 },
+    (_, i) => i + startPairIndex
+  );
+
+  const rawTrades = await Promise.all(
+    pairIndexesToFetch.map(async pairIndex => {
+      const pairTraderAddresses = await storageContract.pairTradersArray(
+        pairIndex
+      );
+
+      if (pairTraderAddresses.length === 0) {
+        return [];
+      }
+
+      const openTradesForPairTraders = await Promise.all(
+        pairTraderAddresses.map(async pairTraderAddress => {
+          const openTradesCalls = new Array(maxTradesPerPair);
+          for (
+            let pairTradeIndex = 0;
+            pairTradeIndex < maxTradesPerPair;
+            pairTradeIndex++
+          ) {
+            openTradesCalls[pairTradeIndex] = storageContract.openTrades(
+              pairTraderAddress,
+              pairIndex,
+              pairTradeIndex
+            );
+          }
+
+          const openTradesForTraderAddress = await Promise.all(openTradesCalls);
+
+          // Filter out any of the trades that aren't *really* open (NOTE: these will have an empty trader address, so just test against that)
+          const actualOpenTradesForTrader = openTradesForTraderAddress.filter(
+            openTrade => openTrade.trader === pairTraderAddress
+          );
+
+          const [
+            actualOpenTradesTradeInfos,
+            actualOpenTradesInitialAccFees,
+            actualOpenTradesTradeData,
+          ] = await Promise.all([
+            Promise.all(
+              actualOpenTradesForTrader.map(aot =>
+                storageContract.openTradesInfo(
+                  aot.trader,
+                  aot.pairIndex,
+                  aot.index
+                )
+              )
+            ),
+            Promise.all(
+              actualOpenTradesForTrader.map(aot =>
+                borrowingFeesContract.initialAccFees(
+                  aot.trader,
+                  aot.pairIndex,
+                  aot.index
+                )
+              )
+            ),
+            Promise.all(
+              actualOpenTradesForTrader.map(aot =>
+                callbacksContract.tradeData(
+                  aot.trader,
+                  aot.pairIndex,
+                  aot.index,
+                  0
+                )
+              )
+            ),
+          ]);
+
+          const finalOpenTradesForTrader = new Array(
+            actualOpenTradesForTrader.length
+          );
+
+          for (
+            let tradeIndex = 0;
+            tradeIndex < actualOpenTradesForTrader.length;
+            tradeIndex++
+          ) {
+            const tradeInfo = actualOpenTradesTradeInfos[tradeIndex];
+
+            if (tradeInfo === undefined) {
+              continue;
+            }
+
+            if (actualOpenTradesInitialAccFees[tradeIndex] === undefined) {
+              continue;
+            }
+
+            const trade = actualOpenTradesForTrader[tradeIndex];
+            const tradeData = actualOpenTradesTradeData[tradeIndex];
+
+            finalOpenTradesForTrader[tradeIndex] = {
+              trade,
+              tradeInfo,
+              initialAccFees: {
+                borrowing: actualOpenTradesInitialAccFees[tradeIndex],
+              },
+              tradeData,
+            };
+          }
+
+          return finalOpenTradesForTrader;
+        })
+      );
+
+      return openTradesForPairTraders;
+    })
+  );
+
+  const perPairTrades = rawTrades.reduce((a, b) => a.concat(b), []);
+  return perPairTrades.reduce((a, b) => a.concat(b), []);
+};
+*/
+// @todo deprecate
+/*
+const fetchOpenPairTradesBatchMulticall = async (
+  contracts: Contracts,
+  startPairIndex: number,
+  endPairIndex: number,
+  blockTag: BlockTag
+): Promise<TradeContainerRaw[]> => {
+  const {
+    gfarmTradingStorageV5: storageContract,
+    gnsBorrowingFees: borrowingFeesContract,
+    gnsTradingCallbacks: callbacksContract,
+  } = contracts;
+
+  // Convert to Multicall for efficient RPC usage
+  const multicallProvider = new Provider();
+  await multicallProvider.init(storageContract.provider);
+  const storageContractMulticall = new Contract(storageContract.address, [
+    ...storageContract.interface.fragments,
+  ]);
+  const borrowingFeesContractMulticall = new Contract(
+    borrowingFeesContract.address,
+    [...borrowingFeesContract.interface.fragments]
+  );
+  const callbacksContractMulticall = new Contract(callbacksContract.address, [
+    ...callbacksContract.interface.fragments,
+  ]);
+
+  const maxTradesPerPair = (
+    await storageContract.maxTradesPerPair()
+  ).toNumber();
+
+  const pairIndexesToFetch = Array.from(
+    { length: endPairIndex - startPairIndex + 1 },
+    (_, i) => i + startPairIndex
+  );
+
+  const mcPairTraderAddresses: string[][] = await multicallProvider.all(
+    pairIndexesToFetch.map(pairIndex =>
+      storageContractMulticall.pairTradersArray(pairIndex)
+    ),
+    blockTag
+  );
+
+  const mcFlatOpenTrades: any[] = await multicallProvider.all(
+    mcPairTraderAddresses
+      .map((pairTraderAddresses, _ix) => {
+        return pairTraderAddresses
+          .map((pairTraderAddress: string) => {
+            const openTradesCalls: Call[] = new Array(maxTradesPerPair);
+            for (
+              let pairTradeIndex = 0;
+              pairTradeIndex < maxTradesPerPair;
+              pairTradeIndex++
+            ) {
+              openTradesCalls[pairTradeIndex] =
+                storageContractMulticall.openTrades(
+                  pairTraderAddress,
+                  _ix + startPairIndex,
+                  pairTradeIndex
+                );
+            }
+            return openTradesCalls;
+          })
+          .reduce((acc, val) => acc.concat(val), []);
+      })
+      .reduce((acc, val) => acc.concat(val), [] as Call[]),
+    blockTag
+  );
+
+  const openTrades = mcFlatOpenTrades.filter(
+    openTrade => openTrade[0] !== "0x0000000000000000000000000000000000000000"
+  );
+
+  const [openTradesTradeInfos, openTradesInitialAccFees, openTradesTradeData] =
+    await Promise.all([
+      multicallProvider.all(
+        openTrades.map(openTrade =>
+          storageContractMulticall.openTradesInfo(
+            openTrade.trader,
+            openTrade.pairIndex,
+            openTrade.index
+          )
+        ),
+        blockTag
+      ),
+      multicallProvider.all<
+        Awaited<ReturnType<typeof borrowingFeesContract.initialAccFees>>
+      >(
+        openTrades.map(openTrade =>
+          borrowingFeesContractMulticall.initialAccFees(
+            openTrade.trader,
+            openTrade.pairIndex,
+            openTrade.index
+          )
+        ),
+        blockTag
+      ),
+      multicallProvider.all(
+        openTrades.map(openTrade =>
+          callbacksContractMulticall.tradeData(
+            openTrade.trader,
+            openTrade.pairIndex,
+            openTrade.index,
+            0
+          )
+        ),
+        blockTag
+      ),
+    ]);
+
+  const finalTrades = new Array(openTrades.length);
+
+  for (
+    let tradeIndex = 0;
+    tradeIndex < openTradesTradeInfos.length;
+    tradeIndex++
+  ) {
+    const tradeInfo = openTradesTradeInfos[tradeIndex];
+
+    if (tradeInfo === undefined) {
+      console.error(
+        "No trade info found for open trade while fetching open trades!",
+        { trade: openTradesTradeInfos[tradeIndex] }
+      );
+
+      continue;
+    }
+
+    if (openTradesInitialAccFees[tradeIndex] === undefined) {
+      console.error(
+        "No initial fees found for open trade while fetching open trades!",
+        { trade: openTrades[tradeIndex] }
+      );
+
+      continue;
+    }
+
+    const trade = openTrades[tradeIndex];
+    const tradeData = openTradesTradeData[tradeIndex];
+
+    finalTrades[tradeIndex] = {
+      trade,
+      tradeInfo,
+      initialAccFees: {
+        borrowing: openTradesInitialAccFees[tradeIndex],
+      },
+      tradeData,
+    };
+  }
+
+  return finalTrades.filter(trade => trade !== undefined);
+};
+ */
+const _prepareTradeContainer = (trade, tradeInfo, tradeInitialAccFees, collateralPrecision) => ({
+    trade: {
+        user: trade.user,
+        index: parseInt(trade.index.toString()),
+        pairIndex: parseInt(trade.pairIndex.toString()),
+        leverage: parseFloat(trade.leverage.toString()) / 1e3,
+        long: trade.long.toString() === "true",
+        isOpen: trade.isOpen.toString() === "true",
+        collateralIndex: parseInt(trade.collateralIndex.toString()),
+        tradeType: trade.tradeType,
+        collateralAmount: parseFloat(trade.collateralAmount.toString()) /
+            parseFloat(collateralPrecision.toString()),
+        openPrice: parseFloat(trade.openPrice.toString()) / 1e10,
+        tp: parseFloat(trade.tp.toString()) / 1e10,
+        sl: parseFloat(trade.sl.toString()) / 1e10,
+    },
+    tradeInfo: {
+        createdBlock: parseInt(tradeInfo.createdBlock.toString()),
+        tpLastUpdatedBlock: parseInt(tradeInfo.tpLastUpdatedBlock.toString()),
+        slLastUpdatedBlock: parseInt(tradeInfo.slLastUpdatedBlock.toString()),
+        maxSlippageP: parseFloat(tradeInfo.maxSlippageP.toString()) / 1e3,
+        lastOiUpdateTs: parseFloat(tradeInfo.lastOiUpdateTs),
+        collateralPriceUsd: parseFloat(tradeInfo.collateralPriceUsd.toString()) / 1e8,
+    },
+    initialAccFees: {
+        accPairFee: parseFloat(tradeInitialAccFees.accPairFee.toString()) / 1e10,
+        accGroupFee: parseFloat(tradeInitialAccFees.accGroupFee.toString()) / 1e10,
+        block: parseFloat(tradeInitialAccFees.block.toString()),
+    },
+});

package/lib/contracts/utils/pairs.d.ts

@@ -1,7 +1,7 @@
-import { Pair, Fee, OpenInterest, PairDepth, PairIndex } from "../../trade/types";
-import { Contracts } from "../../contracts/types";
-export declare const fetchPairs: (contracts: Contracts, pairIxs: PairIndex[]) => Promise<Pair[]>;
-export declare const fetchPairDepths: (contracts: Contracts, pairIxs: number[]) => Promise<PairDepth[]>;
-export declare const fetchFees: (contracts: Contracts, feeIxs: PairIndex[]) => Promise<Fee[]>;
-export declare const fetchOpenInterest: (contracts: Contracts, pairIxs: number[]) => Promise<OpenInterest[]>;
-export declare const getPairDescription: (pairIndex: PairIndex) => string;
+import { Pair, Fee, OpenInterest, PairDepth, PairIndex } from "../../trade/types";
+import { Contracts } from "../../contracts/types";
+export declare const fetchPairs: (contracts: Contracts, pairIxs: PairIndex[]) => Promise<Pair[]>;
+export declare const fetchPairDepths: (contracts: Contracts, pairIxs: number[]) => Promise<PairDepth[]>;
+export declare const fetchFees: (contracts: Contracts, feeIxs: PairIndex[]) => Promise<Fee[]>;
+export declare const fetchOpenInterest: (collateralIndex: number, contracts: Contracts, pairIxs: number[]) => Promise<OpenInterest[]>;
+export declare const getPairDescription: (pairIndex: PairIndex) => string;