@gainsnetwork/sdk 0.1.29-rc3 → 0.1.29-rc4

package/lib/contracts/utils/openLimitOrders.js

@@ -1,88 +1,88 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-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.fetchOpenLimitOrdersRaw = exports.fetchOpenLimitOrders = void 0;
-const ethcall_1 = require("ethcall");
-const fetchOpenLimitOrders = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
-    const openLimitOrdersRaw = yield (0, exports.fetchOpenLimitOrdersRaw)(contracts, overrides);
-    return openLimitOrdersRaw.map((order) => ({
-        block: parseInt(order.block.toString()),
-        buy: order.buy,
-        index: parseInt(order.index.toString()),
-        leverage: parseInt(order.leverage.toString()),
-        maxPrice: parseFloat(order.maxPrice.toString()) / 1e10,
-        minPrice: parseFloat(order.minPrice.toString()) / 1e10,
-        pairIndex: parseInt(order.pairIndex.toString()),
-        positionSize: parseFloat(order.positionSize.toString()) / 1e18,
-        sl: parseFloat(order.sl.toString()) / 1e10,
-        spreadReductionP: parseInt(order.spreadReductionP.toString()) / 100,
-        tp: parseFloat(order.tp.toString()) / 1e10,
-        trader: order.trader,
-        type: parseInt(order.type.toString()),
-        maxSlippageP: parseFloat(order.maxSlippageP.toString()) / 1e10,
-    }));
-});
-exports.fetchOpenLimitOrders = fetchOpenLimitOrders;
-const fetchOpenLimitOrdersRaw = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!contracts) {
-        return [];
-    }
-    console.time("fetchOpenLimitOrdersRaw");
-    const { useMulticall = false, blockTag = "latest" } = overrides;
-    const { gfarmTradingStorageV5: storageContract, gnsNftRewards: nftRewards, gnsTradingCallbacks: callbacks, } = contracts;
-    const openLimitOrders = yield storageContract.getOpenLimitOrders({
-        blockTag,
-    });
-    let openLimitOrderTypes = [];
-    let openLimitOrderTradeData = [];
-    if (useMulticall) {
-        const multicallProvider = new ethcall_1.Provider();
-        yield multicallProvider.init(storageContract.provider);
-        const nftRewardsContractMulticall = new ethcall_1.Contract(nftRewards.address, [
-            ...nftRewards.interface.fragments,
-        ]);
-        const callbacksContractMulticall = new ethcall_1.Contract(callbacks.address, [
-            ...callbacks.interface.fragments,
-        ]);
-        openLimitOrderTypes = yield multicallProvider.all(openLimitOrders.map(order => nftRewardsContractMulticall.openLimitOrderTypes(order.trader, order.pairIndex, order.index)), blockTag);
-        openLimitOrderTradeData = yield multicallProvider.all(openLimitOrders.map(order => callbacksContractMulticall.tradeData(order.trader, order.pairIndex, order.index, 1)), blockTag);
-    }
-    else {
-        openLimitOrderTypes = yield Promise.all(openLimitOrders.map(order => nftRewards.openLimitOrderTypes(order.trader, order.pairIndex, order.index, { blockTag })));
-        openLimitOrderTradeData = yield Promise.all(openLimitOrders.map(order => callbacks.tradeData(order.trader, order.pairIndex, order.index, 1, {
-            blockTag,
-        })));
-    }
-    return openLimitOrderTypes.map((openLimitOrderType, index) => {
-        const openLimitOrder = openLimitOrders[index];
-        const tradeData = openLimitOrderTradeData[index];
-        return {
-            trader: openLimitOrder.trader,
-            pairIndex: openLimitOrder.pairIndex,
-            index: openLimitOrder.index,
-            positionSize: openLimitOrder.positionSize,
-            spreadReductionP: openLimitOrder.spreadReductionP,
-            buy: openLimitOrder.buy,
-            leverage: openLimitOrder.leverage,
-            tp: openLimitOrder.tp,
-            sl: openLimitOrder.sl,
-            minPrice: openLimitOrder.minPrice,
-            maxPrice: openLimitOrder.maxPrice,
-            block: openLimitOrder.block,
-            type: openLimitOrderType,
-            maxSlippageP: tradeData.maxSlippageP,
-        };
-    });
-});
-exports.fetchOpenLimitOrdersRaw = fetchOpenLimitOrdersRaw;
+"use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+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.fetchOpenLimitOrdersRaw = exports.fetchOpenLimitOrders = void 0;
+const ethcall_1 = require("ethcall");
+const fetchOpenLimitOrders = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const openLimitOrdersRaw = yield (0, exports.fetchOpenLimitOrdersRaw)(contracts, overrides);
+    return openLimitOrdersRaw.map((order) => ({
+        block: parseInt(order.block.toString()),
+        buy: order.buy,
+        index: parseInt(order.index.toString()),
+        leverage: parseInt(order.leverage.toString()),
+        maxPrice: parseFloat(order.maxPrice.toString()) / 1e10,
+        minPrice: parseFloat(order.minPrice.toString()) / 1e10,
+        pairIndex: parseInt(order.pairIndex.toString()),
+        positionSize: parseFloat(order.positionSize.toString()) / 1e18,
+        sl: parseFloat(order.sl.toString()) / 1e10,
+        spreadReductionP: parseInt(order.spreadReductionP.toString()) / 100,
+        tp: parseFloat(order.tp.toString()) / 1e10,
+        trader: order.trader,
+        type: parseInt(order.type.toString()),
+        maxSlippageP: parseFloat(order.maxSlippageP.toString()) / 1e10,
+    }));
+});
+exports.fetchOpenLimitOrders = fetchOpenLimitOrders;
+const fetchOpenLimitOrdersRaw = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!contracts) {
+        return [];
+    }
+    console.time("fetchOpenLimitOrdersRaw");
+    const { useMulticall = false, blockTag = "latest" } = overrides;
+    const { gfarmTradingStorageV5: storageContract, gnsNftRewards: nftRewards, gnsTradingCallbacks: callbacks, } = contracts;
+    const openLimitOrders = yield storageContract.getOpenLimitOrders({
+        blockTag,
+    });
+    let openLimitOrderTypes = [];
+    let openLimitOrderTradeData = [];
+    if (useMulticall) {
+        const multicallProvider = new ethcall_1.Provider();
+        yield multicallProvider.init(storageContract.provider);
+        const nftRewardsContractMulticall = new ethcall_1.Contract(nftRewards.address, [
+            ...nftRewards.interface.fragments,
+        ]);
+        const callbacksContractMulticall = new ethcall_1.Contract(callbacks.address, [
+            ...callbacks.interface.fragments,
+        ]);
+        openLimitOrderTypes = yield multicallProvider.all(openLimitOrders.map(order => nftRewardsContractMulticall.openLimitOrderTypes(order.trader, order.pairIndex, order.index)), blockTag);
+        openLimitOrderTradeData = yield multicallProvider.all(openLimitOrders.map(order => callbacksContractMulticall.tradeData(order.trader, order.pairIndex, order.index, 1)), blockTag);
+    }
+    else {
+        openLimitOrderTypes = yield Promise.all(openLimitOrders.map(order => nftRewards.openLimitOrderTypes(order.trader, order.pairIndex, order.index, { blockTag })));
+        openLimitOrderTradeData = yield Promise.all(openLimitOrders.map(order => callbacks.tradeData(order.trader, order.pairIndex, order.index, 1, {
+            blockTag,
+        })));
+    }
+    return openLimitOrderTypes.map((openLimitOrderType, index) => {
+        const openLimitOrder = openLimitOrders[index];
+        const tradeData = openLimitOrderTradeData[index];
+        return {
+            trader: openLimitOrder.trader,
+            pairIndex: openLimitOrder.pairIndex,
+            index: openLimitOrder.index,
+            positionSize: openLimitOrder.positionSize,
+            spreadReductionP: openLimitOrder.spreadReductionP,
+            buy: openLimitOrder.buy,
+            leverage: openLimitOrder.leverage,
+            tp: openLimitOrder.tp,
+            sl: openLimitOrder.sl,
+            minPrice: openLimitOrder.minPrice,
+            maxPrice: openLimitOrder.maxPrice,
+            block: openLimitOrder.block,
+            type: openLimitOrderType,
+            maxSlippageP: tradeData.maxSlippageP,
+        };
+    });
+});
+exports.fetchOpenLimitOrdersRaw = fetchOpenLimitOrdersRaw;

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

@@ -1,9 +1,9 @@
-import { TradeContainer, TradeContainerRaw } from "../../trade/types";
-import { Contracts, BlockTag } from "../../contracts/types";
-export type FetchOpenPairTradesOverrides = {
-    pairBatchSize?: number;
-    useMulticall?: boolean;
-    blockTag?: BlockTag;
-};
-export declare const fetchOpenPairTrades: (contracts: Contracts, overrides?: FetchOpenPairTradesOverrides) => Promise<TradeContainer[]>;
-export declare const fetchOpenPairTradesRaw: (contracts: Contracts, overrides?: FetchOpenPairTradesOverrides) => Promise<TradeContainerRaw[]>;
+import { TradeContainer, TradeContainerRaw } from "../../trade/types";
+import { Contracts, BlockTag } from "../../contracts/types";
+export type FetchOpenPairTradesOverrides = {
+    pairBatchSize?: number;
+    useMulticall?: boolean;
+    blockTag?: BlockTag;
+};
+export declare const fetchOpenPairTrades: (contracts: Contracts, overrides?: FetchOpenPairTradesOverrides) => Promise<TradeContainer[]>;
+export declare const fetchOpenPairTradesRaw: (contracts: Contracts, overrides?: FetchOpenPairTradesOverrides) => Promise<TradeContainerRaw[]>;

package/lib/contracts/utils/openTrades.js

@@ -1,188 +1,188 @@
-"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;
+/* 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()),
+        },
+    },
+});

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