@gainsnetwork/sdk 0.1.28-rc1 → 0.2.0-rc1

package/lib/contracts/utils/openTrades.js

@@ -10,32 +10,48 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 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));
+    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 { pairBatchSize = 10, useMulticall = false, blockTag = "latest", } = overrides;
+    const { batchSize = 50,
+    // 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);
+        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;
     }
@@ -45,144 +61,320 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
     }
 });
 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);
+// @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;
             }
-            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,
-                };
+
+            if (actualOpenTradesInitialAccFees[tradeIndex] === undefined) {
+              continue;
             }
-            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) => {
+
+            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) => {
-            const openTradesCalls = new Array(maxTradesPerPair);
-            for (let pairTradeIndex = 0; pairTradeIndex < maxTradesPerPair; pairTradeIndex++) {
-                openTradesCalls[pairTradeIndex] =
-                    storageContractMulticall.openTrades(pairTraderAddress, _ix + startPairIndex, pairTradeIndex);
+          .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), []), 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),
+          })
+          .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,
-        };
+
+  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;
     }
-    return finalTrades.filter(trade => trade !== undefined);
-});
-const _prepareTradeContainer = (trade, tradeInfo, tradeInitialAccFees, tradeData, collateralPrecision) => ({
+
+    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: {
-        trader: trade.trader,
-        pairIndex: parseInt(trade.pairIndex.toString()),
+        user: trade.user,
         index: parseInt(trade.index.toString()),
-        initialPosToken: parseFloat(trade.initialPosToken.toString()) / 1e18,
+        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,
-        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,
+        createdBlock: parseInt(tradeInfo.createdBlock.toString()),
+        tpLastUpdatedBlock: parseInt(tradeInfo.tpLastUpdatedBlock.toString()),
+        slLastUpdatedBlock: parseInt(tradeInfo.slLastUpdatedBlock.toString()),
+        maxSlippageP: parseFloat(tradeInfo.maxSlippageP.toString()) / 1e10,
+        lastOiUpdateTs: parseFloat(tradeInfo.lastOiUpdateTs),
+        collateralPriceUsd: parseFloat(tradeInfo.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()),
-        },
+        accPairFee: parseFloat(tradeInitialAccFees.accPairFee.toString()) / 1e10,
+        accGroupFee: parseFloat(tradeInitialAccFees.accGroupFee.toString()) / 1e10,
+        block: parseFloat(tradeInitialAccFees.block.toString()),
     },
 });

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

@@ -3,5 +3,5 @@ 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 fetchOpenInterest: (collateralIndex: number, contracts: Contracts, pairIxs: number[]) => Promise<OpenInterest[]>;
 export declare const getPairDescription: (pairIndex: PairIndex) => string;

package/lib/contracts/utils/pairs.js

@@ -69,10 +69,10 @@ const fetchFees = (contracts, feeIxs) => __awaiter(void 0, void 0, void 0, funct
         const fees = yield Promise.all(feeIxs.map(pairIndex => multiCollatContract.fees(pairIndex)));
         return fees.map(fee => {
             return {
-                closeFeeP: parseFloat(fee.closeFeeP.toString()) / 1e12,
-                minLevPosUsd: parseFloat(fee.minLevPosUsd.toString()) / 1e18,
-                nftLimitOrderFeeP: parseFloat(fee.nftLimitOrderFeeP.toString()) / 1e12,
                 openFeeP: parseFloat(fee.openFeeP.toString()) / 1e12,
+                closeFeeP: parseFloat(fee.closeFeeP.toString()) / 1e12,
+                triggerOrderFeeP: parseFloat(fee.triggerOrderFeeP.toString()) / 1e12,
+                minPositionSizeUsd: parseFloat(fee.minPositionSizeUsd.toString()) / 1e18,
             };
         });
     }
@@ -82,19 +82,30 @@ const fetchFees = (contracts, feeIxs) => __awaiter(void 0, void 0, void 0, funct
     }
 });
 exports.fetchFees = fetchFees;
-const fetchOpenInterest = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0, function* () {
-    const { precision: collateralPrecision } = yield contracts.gnsBorrowingFees.collateralConfig();
-    const openInterests = yield Promise.all(pairIxs.map(pairIndex => Promise.all([
-        contracts.gfarmTradingStorageV5.openInterestDai(pairIndex, 0),
-        contracts.gfarmTradingStorageV5.openInterestDai(pairIndex, 1),
-        contracts.gnsBorrowingFees.getPairMaxOi(pairIndex),
-    ])));
+// @todo test
+const fetchOpenInterest = (collateralIndex, contracts, pairIxs) => __awaiter(void 0, void 0, void 0, function* () {
+    if (pairIxs.length === 0) {
+        return [];
+    }
+    const { precision: collateralPrecision, precisionDelta: collateralPrecisionDelta, } = yield contracts.gnsMultiCollatDiamond.getCollateral(collateralIndex);
     const precision = parseFloat(collateralPrecision.toString());
-    return openInterests.map(openInterest => ({
-        long: parseFloat(openInterest[0].toString()) / precision,
-        short: parseFloat(openInterest[1].toString()) / precision,
-        max: parseFloat(openInterest[2].toString()) / 1e10,
-    }));
+    const precisionDelta = parseFloat(collateralPrecisionDelta.toString());
+    const openInterests = (yield contracts.gnsMultiCollatDiamond.getAllBorrowingPairs(collateralIndex))[1];
+    return pairIxs.map(pairIndex => {
+        const openInterest = openInterests[pairIndex];
+        if (!openInterest) {
+            return { long: 0, short: 0, max: 0 };
+        }
+        return {
+            long: (parseFloat(openInterest[0].toString()) * precisionDelta) /
+                1e10 /
+                precision,
+            short: (parseFloat(openInterest[1].toString()) * precisionDelta) /
+                1e10 /
+                precision,
+            max: parseFloat(openInterest[2].toString()) / 1e10,
+        };
+    });
 });
 exports.fetchOpenInterest = fetchOpenInterest;
 const getPairDescription = (pairIndex) => {
@@ -323,13 +334,6 @@ const PAIR_INDEX_TO_DESCRIPTION = {
     [types_1.PairIndex.RONINUSD]: "Ronin to US Dollar",
     [types_1.PairIndex.ENAUSD]: "Ethena to US Dollar",
     [types_1.PairIndex.WUSD]: "Wormhole to US Dollar",
-    [types_1.PairIndex.ZEUSUSD]: "Zeus to US Dollar",
     [types_1.PairIndex.TNSRUSD]: "Tensor to US Dollar",
-    [types_1.PairIndex.TAOUSD]: "Bittensor to US Dollar",
-    [types_1.PairIndex.OMNIUSD]: "Omni Network to US Dollar",
-    [types_1.PairIndex.PRCLUSD]: "Parcl to US Dollar",
-    [types_1.PairIndex.MERLUSD]: "Merlin Chain to US Dollar",
-    [types_1.PairIndex.SAFEUSD]: "Safe to US Dollar",
-    [types_1.PairIndex.SAGAUSD]: "Saga to US Dollar",
-    [types_1.PairIndex.LLUSD]: "Light Link to US Dollar",
+    [types_1.PairIndex.ZEUSUSD]: "Zeus to US Dollar",
 };

package/lib/trade/fees/borrowing/converter.d.ts

@@ -1,13 +1,15 @@
-import { IGNSBorrowingFees } from "../../../contracts/types/generated/GNSBorrowingFees";
+import { IBorrowingFees } from "../../../contracts/types/generated/GNSMultiCollatDiamond";
 import { BorrowingFee } from ".";
-export declare const convertPairGroupBorrowingFee: (pairGroup: IGNSBorrowingFees.PairGroupStructOutput) => BorrowingFee.PairGroup;
-export declare const convertPairBorrowingFee: (pair: IGNSBorrowingFees.PairStructOutput, pairOi: IGNSBorrowingFees.PairOiStructOutput) => BorrowingFee.Pair;
-export declare const convertPairBorrowingFees: ([pairs, pairOi]: [
-    IGNSBorrowingFees.PairStructOutput[],
-    IGNSBorrowingFees.PairOiStructOutput[]
+export declare const convertPairGroupBorrowingFee: (pairGroup: IBorrowingFees.BorrowingPairGroupStructOutput) => BorrowingFee.PairGroup;
+export declare const convertPairBorrowingFee: (pair: IBorrowingFees.BorrowingDataStructOutput, pairOi: IBorrowingFees.OpenInterestStructOutput, pairGroup: IBorrowingFees.BorrowingPairGroupStructOutput[]) => BorrowingFee.Pair;
+export declare const convertPairBorrowingFees: ([pairs, pairOi, pairGroups]: [
+    IBorrowingFees.BorrowingDataStructOutput[],
+    IBorrowingFees.OpenInterestStructOutput[],
+    IBorrowingFees.BorrowingPairGroupStructOutput[][]
 ]) => BorrowingFee.Pair[];
-export declare const convertGroupBorrowingFee: (group: IGNSBorrowingFees.GroupStructOutput, groupFeeExponent: number) => BorrowingFee.Group;
-export declare const convertGroupBorrowingFees: ([groups, groupFeeExponents]: [
-    IGNSBorrowingFees.GroupStructOutput[],
-    number[]
+export declare const convertGroupBorrowingFee: (group: IBorrowingFees.BorrowingDataStructOutput, groupOi: IBorrowingFees.OpenInterestStructOutput) => BorrowingFee.Group;
+export declare const convertGroupBorrowingData: (obj: IBorrowingFees.BorrowingDataStructOutput, oi: IBorrowingFees.OpenInterestStructOutput) => BorrowingFee.BorrowingData & BorrowingFee.BorrowingOi;
+export declare const convertGroupBorrowingFees: ([groups, groupOis]: [
+    IBorrowingFees.BorrowingDataStructOutput[],
+    IBorrowingFees.OpenInterestStructOutput[]
 ]) => BorrowingFee.Group[];