@gainsnetwork/sdk 0.0.16 → 0.0.18

package/lib/contracts/utils/openTrades.js

@@ -1,116 +1,169 @@
-"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.fetchOpenPairTrades = void 0;
-const fetchOpenPairTrades = (contracts, pairBatchSize = 10) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!contracts) {
-        return [];
-    }
-    const { gnsPairsStorageV6: pairsStorageContract } = contracts;
-    try {
-        const totalPairIndexes = (yield pairsStorageContract.pairsCount()).toNumber() - 1;
-        let allOpenPairTrades = [];
-        for (let batchStartPairIndex = 0; batchStartPairIndex < totalPairIndexes; batchStartPairIndex += pairBatchSize) {
-            const batchEndPairIndex = Math.min(batchStartPairIndex + pairBatchSize - 1, totalPairIndexes);
-            const openPairTradesBatch = yield fetchOpenPairTradesBatch(contracts, batchStartPairIndex, batchEndPairIndex);
-            allOpenPairTrades = allOpenPairTrades.concat(openPairTradesBatch);
-        }
-        console.info(`Fetched ${allOpenPairTrades.length} total open pair trade(s).`);
-        return allOpenPairTrades;
-    }
-    catch (error) {
-        console.error(`Unexpected error while fetching open pair trades!`);
-        throw error;
-    }
-});
-exports.fetchOpenPairTrades = fetchOpenPairTrades;
-const fetchOpenPairTradesBatch = (contracts, startPairIndex, endPairIndex) => __awaiter(void 0, void 0, void 0, function* () {
-    const { gfarmTradingStorageV5: storageContract, gnsPairInfosV6_1: pairInfosContract } = 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* () {
-        console.debug(`Fetching pair traders for pairIndex ${pairIndex}...`);
-        const pairTradersCallStartTime = performance.now();
-        const pairTraderAddresses = yield storageContract.pairTradersArray(pairIndex);
-        if (pairTraderAddresses.length === 0) {
-            console.debug(`No pair traders found for pairIndex ${pairIndex}; no processing left to do!`);
-            return [];
-        }
-        console.debug(`Fetched ${pairTraderAddresses.length} pair traders for pairIndex ${pairIndex} in ${performance.now() - pairTradersCallStartTime}ms; now fetching all open trades...`);
-        const openTradesForPairTraders = yield Promise.all(pairTraderAddresses.map((pairTraderAddress) => __awaiter(void 0, void 0, void 0, function* () {
-            const openTradesCalls = new Array(maxTradesPerPair);
-            const traderOpenTradesCallsStartTime = performance.now();
-            for (let pairTradeIndex = 0; pairTradeIndex < maxTradesPerPair; pairTradeIndex++) {
-                openTradesCalls[pairTradeIndex] = storageContract.openTrades(pairTraderAddress, pairIndex, pairTradeIndex);
-            }
-            /*console.debug(
-              `Waiting on ${openTradesCalls.length} StorageContract::openTrades calls for trader ${pairTraderAddress}...`
-            );*/
-            const openTradesForTraderAddress = yield Promise.all(openTradesCalls);
-            console.debug(`Received all trades for trader ${pairTraderAddress} and pair ${pairIndex} in ${performance.now() - traderOpenTradesCallsStartTime}ms.`);
-            // 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);
-            /*console.debug(
-              `Filtered down to ${actualOpenTradesForTrader.length} actual open trades for trader ${pairTraderAddress} and pair ${pairIndex}; fetching corresponding trade info and initial fees...`
-            );*/
-            const [actualOpenTradesTradeInfos, actualOpenTradesInitialAccFees] = yield Promise.all([
-                Promise.all(actualOpenTradesForTrader.map(aot => storageContract.openTradesInfo(aot.trader, aot.pairIndex, aot.index))),
-                Promise.all(actualOpenTradesForTrader.map(aot => pairInfosContract.tradeInitialAccFees(aot.trader, aot.pairIndex, aot.index))),
-            ]);
-            const finalOpenTradesForTrader = new Array(actualOpenTradesForTrader.length);
-            for (let tradeIndex = 0; tradeIndex < actualOpenTradesForTrader.length; tradeIndex++) {
-                const tradeInfo = actualOpenTradesTradeInfos[tradeIndex];
-                if (tradeInfo === undefined) {
-                    console.error("No trade info found for open trade while fetching open trades!", { trade: actualOpenTradesForTrader[tradeIndex] });
-                    continue;
-                }
-                const tradeInitialAccFees = actualOpenTradesInitialAccFees[tradeIndex];
-                if (tradeInitialAccFees === undefined) {
-                    console.error("No initial fees found for open trade while fetching open trades!", { trade: actualOpenTradesForTrader[tradeIndex] });
-                    continue;
-                }
-                const trade = actualOpenTradesForTrader[tradeIndex];
-                finalOpenTradesForTrader[tradeIndex] = {
-                    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()) / 1e18,
-                        tpLastUpdated: tradeInfo.tpLastUpdated,
-                        slLastUpdated: tradeInfo.slLastUpdated,
-                    },
-                    initialAccFees: {
-                        rollover: parseFloat(tradeInitialAccFees.rollover.toString()) / 1e18,
-                        funding: parseFloat(tradeInitialAccFees.funding.toString()) / 1e18,
-                        openedAfterUpdate: tradeInitialAccFees.openedAfterUpdate.toString() === "true",
-                    },
-                };
-            }
-            /*console.debug(
-              `Trade info and initial fees fetched for ${finalOpenTradesForTrader.length} trades for trader ${pairTraderAddress} and pair ${pairIndex}; done!`
-            );*/
-            return finalOpenTradesForTrader;
-        })));
-        return openTradesForPairTraders;
-    })));
-    const perPairTrades = rawTrades.reduce((a, b) => a.concat(b), []);
-    return perPairTrades.reduce((a, b) => a.concat(b), []);
-});
+"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);
+    return rawTrades.map(rawTrade => _prepareTradeContainer(rawTrade.trade, rawTrade.tradeInfo, rawTrade.initialAccFees));
+});
+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 { gnsPairsStorageV6: pairsStorageContract } = contracts;
+    try {
+        const totalPairIndexes = (yield pairsStorageContract.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, gnsPairInfosV6_1: pairInfosContract, } = 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] = yield Promise.all([
+                Promise.all(actualOpenTradesForTrader.map(aot => storageContract.openTradesInfo(aot.trader, aot.pairIndex, aot.index))),
+                Promise.all(actualOpenTradesForTrader.map(aot => pairInfosContract.tradeInitialAccFees(aot.trader, aot.pairIndex, aot.index))),
+            ]);
+            const finalOpenTradesForTrader = new Array(actualOpenTradesForTrader.length);
+            for (let tradeIndex = 0; tradeIndex < actualOpenTradesForTrader.length; tradeIndex++) {
+                const tradeInfo = actualOpenTradesTradeInfos[tradeIndex];
+                if (tradeInfo === undefined) {
+                    continue;
+                }
+                const tradeInitialAccFees = actualOpenTradesInitialAccFees[tradeIndex];
+                if (tradeInitialAccFees === undefined) {
+                    continue;
+                }
+                const trade = actualOpenTradesForTrader[tradeIndex];
+                finalOpenTradesForTrader[tradeIndex] = {
+                    trade,
+                    tradeInfo,
+                    initialAccFees: tradeInitialAccFees,
+                };
+            }
+            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, gnsPairInfosV6_1: pairInfosContract, } = 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 pairInfosContractMulticall = new ethcall_1.Contract(pairInfosContract.address, [
+        ...pairInfosContract.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] = yield Promise.all([
+        multicallProvider.all(openTrades.map(openTrade => storageContractMulticall.openTradesInfo(openTrade.trader, openTrade.pairIndex, openTrade.index)), blockTag),
+        multicallProvider.all(openTrades.map(openTrade => pairInfosContractMulticall.tradeInitialAccFees(openTrade.trader, openTrade.pairIndex, openTrade.index)), 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;
+        }
+        const tradeInitialAccFees = openTradesInitialAccFees[tradeIndex];
+        if (tradeInitialAccFees === undefined) {
+            console.error("No initial fees found for open trade while fetching open trades!", { trade: openTrades[tradeIndex] });
+            continue;
+        }
+        const trade = openTrades[tradeIndex];
+        finalTrades[tradeIndex] = {
+            trade,
+            tradeInfo,
+            initialAccFees: tradeInitialAccFees,
+        };
+    }
+    return finalTrades.filter(trade => trade !== undefined);
+});
+const _prepareTradeContainer = (trade, tradeInfo, tradeInitialAccFees) => ({
+    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()) / 1e18,
+        tpLastUpdated: tradeInfo.tpLastUpdated,
+        slLastUpdated: tradeInfo.slLastUpdated,
+    },
+    initialAccFees: {
+        rollover: parseFloat(tradeInitialAccFees.rollover.toString()) / 1e18,
+        funding: parseFloat(tradeInitialAccFees.funding.toString()) / 1e18,
+        openedAfterUpdate: tradeInitialAccFees.openedAfterUpdate.toString() === "true",
+    },
+});

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

@@ -0,0 +1,3 @@
+import { TradeContainer } from "@/trade/types";
+import { Contracts } from "@/contracts/types";
+export declare const fetchOpenPairTradesOriginal: (contracts: Contracts, pairBatchSize?: number) => Promise<TradeContainer[]>;

package/lib/contracts/utils/openTradesOriginal.js

@@ -0,0 +1,134 @@
+"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.fetchOpenPairTradesOriginal = void 0;
+const fetchOpenPairTradesOriginal = (contracts, pairBatchSize = 10) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!contracts) {
+        return [];
+    }
+    const { gnsPairsStorageV6: pairsStorageContract } = contracts;
+    try {
+        const totalPairIndexes = (yield pairsStorageContract.pairsCount()).toNumber() - 1;
+        let allOpenPairTrades = [];
+        for (let batchStartPairIndex = 0; batchStartPairIndex < totalPairIndexes; batchStartPairIndex += pairBatchSize) {
+            const batchEndPairIndex = Math.min(batchStartPairIndex + pairBatchSize - 1, totalPairIndexes);
+            const openPairTradesBatch = yield fetchOpenPairTradesBatchOriginal(contracts, batchStartPairIndex, batchEndPairIndex);
+            console.log("openPairTradesBatch", openPairTradesBatch.length);
+            allOpenPairTrades = allOpenPairTrades.concat(openPairTradesBatch);
+        }
+        return allOpenPairTrades;
+    }
+    catch (error) {
+        console.error(`Unexpected error while fetching open pair trades!`);
+        throw error;
+    }
+});
+exports.fetchOpenPairTradesOriginal = fetchOpenPairTradesOriginal;
+const fetchOpenPairTradesBatchOriginal = (contracts, startPairIndex, endPairIndex) => __awaiter(void 0, void 0, void 0, function* () {
+    const { gfarmTradingStorageV5: storageContract, gnsPairInfosV6_1: pairInfosContract, } = 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* () {
+        //   console.debug(`Fetching pair traders for pairIndex ${pairIndex}...`);
+        const pairTradersCallStartTime = performance.now();
+        const pairTraderAddresses = yield storageContract.pairTradersArray(pairIndex);
+        if (pairTraderAddresses.length === 0) {
+            // console.debug(
+            //   `No pair traders found for pairIndex ${pairIndex}; no processing left to do!`
+            // );
+            return [];
+        }
+        //   console.debug(
+        //     `Fetched ${
+        //       pairTraderAddresses.length
+        //     } pair traders for pairIndex ${pairIndex} in ${
+        //       performance.now() - pairTradersCallStartTime
+        //     }ms; now fetching all open trades...`
+        //   );
+        const openTradesForPairTraders = yield Promise.all(pairTraderAddresses.map((pairTraderAddress) => __awaiter(void 0, void 0, void 0, function* () {
+            const openTradesCalls = new Array(maxTradesPerPair);
+            const traderOpenTradesCallsStartTime = performance.now();
+            for (let pairTradeIndex = 0; pairTradeIndex < maxTradesPerPair; pairTradeIndex++) {
+                openTradesCalls[pairTradeIndex] = storageContract.openTrades(pairTraderAddress, pairIndex, pairTradeIndex);
+            }
+            /*console.debug(
+              `Waiting on ${openTradesCalls.length} StorageContract::openTrades calls for trader ${pairTraderAddress}...`
+            );*/
+            const openTradesForTraderAddress = yield Promise.all(openTradesCalls);
+            //   console.debug(
+            //     `Received all trades for trader ${pairTraderAddress} and pair ${pairIndex} in ${
+            //       performance.now() - traderOpenTradesCallsStartTime
+            //     }ms.`
+            //   );
+            // 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);
+            /*console.debug(
+              `Filtered down to ${actualOpenTradesForTrader.length} actual open trades for trader ${pairTraderAddress} and pair ${pairIndex}; fetching corresponding trade info and initial fees...`
+            );*/
+            const [actualOpenTradesTradeInfos, actualOpenTradesInitialAccFees] = yield Promise.all([
+                Promise.all(actualOpenTradesForTrader.map(aot => storageContract.openTradesInfo(aot.trader, aot.pairIndex, aot.index))),
+                Promise.all(actualOpenTradesForTrader.map(aot => pairInfosContract.tradeInitialAccFees(aot.trader, aot.pairIndex, aot.index))),
+            ]);
+            const finalOpenTradesForTrader = new Array(actualOpenTradesForTrader.length);
+            for (let tradeIndex = 0; tradeIndex < actualOpenTradesForTrader.length; tradeIndex++) {
+                const tradeInfo = actualOpenTradesTradeInfos[tradeIndex];
+                if (tradeInfo === undefined) {
+                    //   console.error(
+                    //     "No trade info found for open trade while fetching open trades!",
+                    //     { trade: actualOpenTradesForTrader[tradeIndex] }
+                    //   );
+                    continue;
+                }
+                const tradeInitialAccFees = actualOpenTradesInitialAccFees[tradeIndex];
+                if (tradeInitialAccFees === undefined) {
+                    //   console.error(
+                    //     "No initial fees found for open trade while fetching open trades!",
+                    //     { trade: actualOpenTradesForTrader[tradeIndex] }
+                    //   );
+                    continue;
+                }
+                const trade = actualOpenTradesForTrader[tradeIndex];
+                finalOpenTradesForTrader[tradeIndex] = {
+                    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()) / 1e18,
+                        tpLastUpdated: tradeInfo.tpLastUpdated,
+                        slLastUpdated: tradeInfo.slLastUpdated,
+                    },
+                    initialAccFees: {
+                        rollover: parseFloat(tradeInitialAccFees.rollover.toString()) / 1e18,
+                        funding: parseFloat(tradeInitialAccFees.funding.toString()) / 1e18,
+                        openedAfterUpdate: tradeInitialAccFees.openedAfterUpdate.toString() === "true",
+                    },
+                };
+            }
+            /*console.debug(
+              `Trade info and initial fees fetched for ${finalOpenTradesForTrader.length} trades for trader ${pairTraderAddress} and pair ${pairIndex}; done!`
+            );*/
+            return finalOpenTradesForTrader;
+        })));
+        return openTradesForPairTraders;
+    })));
+    const perPairTrades = rawTrades.reduce((a, b) => a.concat(b), []);
+    return perPairTrades.reduce((a, b) => a.concat(b), []);
+});

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

@@ -1,6 +1,6 @@
-import { Pair, PairParams, PairRolloverFees, Fee } from "@/trade/types";
-import { Contracts } from "@/contracts/types";
-export declare const fetchPairs: (contracts: Contracts, pairIxs: number[]) => Promise<Pair[]>;
-export declare const fetchPairsParams: (contracts: Contracts, pairIxs: number[]) => Promise<PairParams[]>;
-export declare const fetchPairsRolloverFees: (contracts: Contracts, pairIxs: number[]) => Promise<PairRolloverFees[]>;
-export declare const fetchFees: (contracts: Contracts, feeIxs: number[]) => Promise<Fee[]>;
+import { Pair, PairParams, PairRolloverFees, Fee } from "@/trade/types";
+import { Contracts } from "@/contracts/types";
+export declare const fetchPairs: (contracts: Contracts, pairIxs: number[]) => Promise<Pair[]>;
+export declare const fetchPairsParams: (contracts: Contracts, pairIxs: number[]) => Promise<PairParams[]>;
+export declare const fetchPairsRolloverFees: (contracts: Contracts, pairIxs: number[]) => Promise<PairRolloverFees[]>;
+export declare const fetchFees: (contracts: Contracts, feeIxs: number[]) => Promise<Fee[]>;