@gainsnetwork/sdk 0.0.15 → 0.0.16-rc1

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

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

package/lib/contracts/utils/openTrades.js

@@ -10,7 +10,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchOpenPairTrades = void 0;
-const fetchOpenPairTrades = (contracts, pairBatchSize = 10) => __awaiter(void 0, void 0, void 0, function* () {
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+const ethers_multicall_1 = require("ethers-multicall");
+const fetchOpenPairTrades = (contracts, pairBatchSize = 50, useMulticall = false) => __awaiter(void 0, void 0, void 0, function* () {
     if (!contracts) {
         return [];
     }
@@ -20,7 +24,9 @@ const fetchOpenPairTrades = (contracts, pairBatchSize = 10) => __awaiter(void 0,
         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);
+            const openPairTradesBatch = useMulticall
+                ? yield fetchOpenPairTradesBatchMulticall(contracts, batchStartPairIndex, batchEndPairIndex)
+                : yield fetchOpenPairTradesBatch(contracts, batchStartPairIndex, batchEndPairIndex);
             allOpenPairTrades = allOpenPairTrades.concat(openPairTradesBatch);
         }
         console.info(`Fetched ${allOpenPairTrades.length} total open pair trade(s).`);
@@ -33,7 +39,7 @@ const fetchOpenPairTrades = (contracts, pairBatchSize = 10) => __awaiter(void 0,
 });
 exports.fetchOpenPairTrades = fetchOpenPairTrades;
 const fetchOpenPairTradesBatch = (contracts, startPairIndex, endPairIndex) => __awaiter(void 0, void 0, void 0, function* () {
-    const { gfarmTradingStorageV5: storageContract, gnsPairInfosV6_1: pairInfosContract } = contracts;
+    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* () {
@@ -69,12 +75,18 @@ const fetchOpenPairTradesBatch = (contracts, startPairIndex, endPairIndex) => __
             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] });
+                    //   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] });
+                    //   console.error(
+                    //     "No initial fees found for open trade while fetching open trades!",
+                    //     { trade: actualOpenTradesForTrader[tradeIndex] }
+                    //   );
                     continue;
                 }
                 const trade = actualOpenTradesForTrader[tradeIndex];
@@ -114,3 +126,77 @@ const fetchOpenPairTradesBatch = (contracts, startPairIndex, endPairIndex) => __
     const perPairTrades = rawTrades.reduce((a, b) => a.concat(b), []);
     return perPairTrades.reduce((a, b) => a.concat(b), []);
 });
+const fetchOpenPairTradesBatchMulticall = (contracts, startPairIndex, endPairIndex) => __awaiter(void 0, void 0, void 0, function* () {
+    const { gfarmTradingStorageV5: storageContract, gnsPairInfosV6_1: pairInfosContract, } = contracts;
+    // Convert to Multicall for efficient RPC usage
+    const chainId = (yield storageContract.provider.getNetwork()).chainId;
+    const multicallProvider = new ethers_multicall_1.Provider(storageContract.provider, chainId);
+    const storageContractMulticall = new ethers_multicall_1.Contract(storageContract.address, [
+        ...storageContract.interface.fragments,
+    ]);
+    const pairInfosContractMulticall = new ethers_multicall_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)));
+    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), []));
+    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))),
+        multicallProvider.all(openTrades.map(openTrade => pairInfosContractMulticall.tradeInitialAccFees(openTrade.trader, openTrade.pairIndex, openTrade.index))),
+    ]);
+    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: {
+                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",
+            },
+        };
+    }
+    return finalTrades.filter(trade => trade !== undefined);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gainsnetwork/sdk",
-  "version": "0.0.15",
+  "version": "0.0.16-rc1",
   "description": "Gains Network SDK",
   "main": "./lib/index.js",
   "files": [
@@ -98,6 +98,7 @@
   "dependencies": {
     "@ethersproject/providers": "^5.7.2",
     "ethers": "^5.7.2",
+    "ethers-multicall": "^0.2.3",
     "luxon": "^3.2.0"
   }
 }