@gainsnetwork/sdk 0.2.0-rc1 → 0.2.0-rc4

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

@@ -3,6 +3,7 @@ import { Contracts, BlockTag } from "../../contracts/types";
 export type FetchOpenPairTradesOverrides = {
     batchSize?: number;
     useMulticall?: boolean;
+    includeLimits?: boolean;
     blockTag?: BlockTag;
 };
 export declare const fetchOpenPairTrades: (contracts: Contracts, overrides?: FetchOpenPairTradesOverrides) => Promise<TradeContainer[]>;

package/lib/contracts/utils/openTrades.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchOpenPairTradesRaw = exports.fetchOpenPairTrades = void 0;
+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 collateralPrecisions = (yield contracts.gnsMultiCollatDiamond.getCollaterals()).map(({ precision }) => precision);
@@ -21,23 +22,29 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
     if (!contracts) {
         return [];
     }
-    const { batchSize = 50,
-    // useMulticall = false,
-    // blockTag = "latest",
-     } = overrides;
+    const { batchSize = 50, includeLimits = true, useMulticall = false, } = overrides;
     const { gnsMultiCollatDiamond: multiCollatDiamondContract } = contracts;
     try {
+        const multicallCtx = {
+            provider: new ethcall_1.Provider(),
+            diamond: new ethcall_1.Contract(multiCollatDiamondContract.address, [
+                ...multiCollatDiamondContract.interface.fragments,
+            ]),
+        };
+        if (useMulticall) {
+            yield multicallCtx.provider.init(multiCollatDiamondContract.provider);
+        }
         let allOpenPairTrades = [];
         let running = true;
         let offset = 0;
         while (running) {
-            console.log("fetching with", offset, batchSize);
             const trades = yield multiCollatDiamondContract.getAllTrades(offset, offset + batchSize);
             const tradeInfos = yield multiCollatDiamondContract.getAllTradeInfos(offset, offset + batchSize);
             // Array is always of length `batchSize`
             // so we need to filter out the empty trades, indexes are reliable
             const openTrades = trades
-                .filter(t => t.collateralIndex > 0)
+                .filter(t => t.collateralIndex > 0 &&
+                (includeLimits || (!includeLimits && t.tradeType === 0)))
                 .map((trade, ix) => ({
                 trade,
                 tradeInfo: tradeInfos[ix],
@@ -46,8 +53,23 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
                     accGroupFee: 0,
                     block: 0,
                     __placeholder: 0,
-                }, // @todo fetch initialAccFees
+                },
             }));
+            const initialAccFeesPromises = openTrades
+                .map(({ trade }) => ({
+                collateralIndex: trade.collateralIndex,
+                user: trade.user,
+                index: trade.index,
+            }))
+                .map(({ collateralIndex, user, index }) => (useMulticall
+                ? multicallCtx.diamond
+                : multiCollatDiamondContract).getBorrowingInitialAccFees(collateralIndex, user, index));
+            const initialAccFees = yield (useMulticall
+                ? multicallCtx.provider.all(initialAccFeesPromises)
+                : Promise.all(initialAccFeesPromises));
+            initialAccFees.forEach((accFees, ix) => {
+                openTrades[ix].initialAccFees = accFees;
+            });
             allOpenPairTrades = allOpenPairTrades.concat(openTrades);
             offset += batchSize + 1;
             running =
@@ -61,293 +83,6 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
     }
 });
 exports.fetchOpenPairTradesRaw = fetchOpenPairTradesRaw;
-// @todo deprecate
-/*
-const fetchOpenPairTradesBatch = async (
-  contracts: Contracts,
-  startPairIndex: number,
-  endPairIndex: number
-): Promise<TradeContainerRaw[]> => {
-  const {
-    gfarmTradingStorageV5: storageContract,
-    gnsBorrowingFees: borrowingFeesContract,
-    gnsTradingCallbacks: callbacksContract,
-  } = contracts;
-
-  const maxTradesPerPair = (
-    await storageContract.maxTradesPerPair()
-  ).toNumber();
-
-  const pairIndexesToFetch = Array.from(
-    { length: endPairIndex - startPairIndex + 1 },
-    (_, i) => i + startPairIndex
-  );
-
-  const rawTrades = await Promise.all(
-    pairIndexesToFetch.map(async pairIndex => {
-      const pairTraderAddresses = await storageContract.pairTradersArray(
-        pairIndex
-      );
-
-      if (pairTraderAddresses.length === 0) {
-        return [];
-      }
-
-      const openTradesForPairTraders = await Promise.all(
-        pairTraderAddresses.map(async pairTraderAddress => {
-          const openTradesCalls = new Array(maxTradesPerPair);
-          for (
-            let pairTradeIndex = 0;
-            pairTradeIndex < maxTradesPerPair;
-            pairTradeIndex++
-          ) {
-            openTradesCalls[pairTradeIndex] = storageContract.openTrades(
-              pairTraderAddress,
-              pairIndex,
-              pairTradeIndex
-            );
-          }
-
-          const openTradesForTraderAddress = await Promise.all(openTradesCalls);
-
-          // Filter out any of the trades that aren't *really* open (NOTE: these will have an empty trader address, so just test against that)
-          const actualOpenTradesForTrader = openTradesForTraderAddress.filter(
-            openTrade => openTrade.trader === pairTraderAddress
-          );
-
-          const [
-            actualOpenTradesTradeInfos,
-            actualOpenTradesInitialAccFees,
-            actualOpenTradesTradeData,
-          ] = await Promise.all([
-            Promise.all(
-              actualOpenTradesForTrader.map(aot =>
-                storageContract.openTradesInfo(
-                  aot.trader,
-                  aot.pairIndex,
-                  aot.index
-                )
-              )
-            ),
-            Promise.all(
-              actualOpenTradesForTrader.map(aot =>
-                borrowingFeesContract.initialAccFees(
-                  aot.trader,
-                  aot.pairIndex,
-                  aot.index
-                )
-              )
-            ),
-            Promise.all(
-              actualOpenTradesForTrader.map(aot =>
-                callbacksContract.tradeData(
-                  aot.trader,
-                  aot.pairIndex,
-                  aot.index,
-                  0
-                )
-              )
-            ),
-          ]);
-
-          const finalOpenTradesForTrader = new Array(
-            actualOpenTradesForTrader.length
-          );
-
-          for (
-            let tradeIndex = 0;
-            tradeIndex < actualOpenTradesForTrader.length;
-            tradeIndex++
-          ) {
-            const tradeInfo = actualOpenTradesTradeInfos[tradeIndex];
-
-            if (tradeInfo === undefined) {
-              continue;
-            }
-
-            if (actualOpenTradesInitialAccFees[tradeIndex] === undefined) {
-              continue;
-            }
-
-            const trade = actualOpenTradesForTrader[tradeIndex];
-            const tradeData = actualOpenTradesTradeData[tradeIndex];
-
-            finalOpenTradesForTrader[tradeIndex] = {
-              trade,
-              tradeInfo,
-              initialAccFees: {
-                borrowing: actualOpenTradesInitialAccFees[tradeIndex],
-              },
-              tradeData,
-            };
-          }
-
-          return finalOpenTradesForTrader;
-        })
-      );
-
-      return openTradesForPairTraders;
-    })
-  );
-
-  const perPairTrades = rawTrades.reduce((a, b) => a.concat(b), []);
-  return perPairTrades.reduce((a, b) => a.concat(b), []);
-};
-*/
-// @todo deprecate
-/*
-const fetchOpenPairTradesBatchMulticall = async (
-  contracts: Contracts,
-  startPairIndex: number,
-  endPairIndex: number,
-  blockTag: BlockTag
-): Promise<TradeContainerRaw[]> => {
-  const {
-    gfarmTradingStorageV5: storageContract,
-    gnsBorrowingFees: borrowingFeesContract,
-    gnsTradingCallbacks: callbacksContract,
-  } = contracts;
-
-  // Convert to Multicall for efficient RPC usage
-  const multicallProvider = new Provider();
-  await multicallProvider.init(storageContract.provider);
-  const storageContractMulticall = new Contract(storageContract.address, [
-    ...storageContract.interface.fragments,
-  ]);
-  const borrowingFeesContractMulticall = new Contract(
-    borrowingFeesContract.address,
-    [...borrowingFeesContract.interface.fragments]
-  );
-  const callbacksContractMulticall = new Contract(callbacksContract.address, [
-    ...callbacksContract.interface.fragments,
-  ]);
-
-  const maxTradesPerPair = (
-    await storageContract.maxTradesPerPair()
-  ).toNumber();
-
-  const pairIndexesToFetch = Array.from(
-    { length: endPairIndex - startPairIndex + 1 },
-    (_, i) => i + startPairIndex
-  );
-
-  const mcPairTraderAddresses: string[][] = await multicallProvider.all(
-    pairIndexesToFetch.map(pairIndex =>
-      storageContractMulticall.pairTradersArray(pairIndex)
-    ),
-    blockTag
-  );
-
-  const mcFlatOpenTrades: any[] = await multicallProvider.all(
-    mcPairTraderAddresses
-      .map((pairTraderAddresses, _ix) => {
-        return pairTraderAddresses
-          .map((pairTraderAddress: string) => {
-            const openTradesCalls: Call[] = new Array(maxTradesPerPair);
-            for (
-              let pairTradeIndex = 0;
-              pairTradeIndex < maxTradesPerPair;
-              pairTradeIndex++
-            ) {
-              openTradesCalls[pairTradeIndex] =
-                storageContractMulticall.openTrades(
-                  pairTraderAddress,
-                  _ix + startPairIndex,
-                  pairTradeIndex
-                );
-            }
-            return openTradesCalls;
-          })
-          .reduce((acc, val) => acc.concat(val), []);
-      })
-      .reduce((acc, val) => acc.concat(val), [] as Call[]),
-    blockTag
-  );
-
-  const openTrades = mcFlatOpenTrades.filter(
-    openTrade => openTrade[0] !== "0x0000000000000000000000000000000000000000"
-  );
-
-  const [openTradesTradeInfos, openTradesInitialAccFees, openTradesTradeData] =
-    await Promise.all([
-      multicallProvider.all(
-        openTrades.map(openTrade =>
-          storageContractMulticall.openTradesInfo(
-            openTrade.trader,
-            openTrade.pairIndex,
-            openTrade.index
-          )
-        ),
-        blockTag
-      ),
-      multicallProvider.all<
-        Awaited<ReturnType<typeof borrowingFeesContract.initialAccFees>>
-      >(
-        openTrades.map(openTrade =>
-          borrowingFeesContractMulticall.initialAccFees(
-            openTrade.trader,
-            openTrade.pairIndex,
-            openTrade.index
-          )
-        ),
-        blockTag
-      ),
-      multicallProvider.all(
-        openTrades.map(openTrade =>
-          callbacksContractMulticall.tradeData(
-            openTrade.trader,
-            openTrade.pairIndex,
-            openTrade.index,
-            0
-          )
-        ),
-        blockTag
-      ),
-    ]);
-
-  const finalTrades = new Array(openTrades.length);
-
-  for (
-    let tradeIndex = 0;
-    tradeIndex < openTradesTradeInfos.length;
-    tradeIndex++
-  ) {
-    const tradeInfo = openTradesTradeInfos[tradeIndex];
-
-    if (tradeInfo === undefined) {
-      console.error(
-        "No trade info found for open trade while fetching open trades!",
-        { trade: openTradesTradeInfos[tradeIndex] }
-      );
-
-      continue;
-    }
-
-    if (openTradesInitialAccFees[tradeIndex] === undefined) {
-      console.error(
-        "No initial fees found for open trade while fetching open trades!",
-        { trade: openTrades[tradeIndex] }
-      );
-
-      continue;
-    }
-
-    const trade = openTrades[tradeIndex];
-    const tradeData = openTradesTradeData[tradeIndex];
-
-    finalTrades[tradeIndex] = {
-      trade,
-      tradeInfo,
-      initialAccFees: {
-        borrowing: openTradesInitialAccFees[tradeIndex],
-      },
-      tradeData,
-    };
-  }
-
-  return finalTrades.filter(trade => trade !== undefined);
-};
- */
 const _prepareTradeContainer = (trade, tradeInfo, tradeInitialAccFees, collateralPrecision) => ({
     trade: {
         user: trade.user,
@@ -368,7 +103,7 @@ const _prepareTradeContainer = (trade, tradeInfo, tradeInitialAccFees, collatera
         createdBlock: parseInt(tradeInfo.createdBlock.toString()),
         tpLastUpdatedBlock: parseInt(tradeInfo.tpLastUpdatedBlock.toString()),
         slLastUpdatedBlock: parseInt(tradeInfo.slLastUpdatedBlock.toString()),
-        maxSlippageP: parseFloat(tradeInfo.maxSlippageP.toString()) / 1e10,
+        maxSlippageP: parseFloat(tradeInfo.maxSlippageP.toString()) / 1e3,
         lastOiUpdateTs: parseFloat(tradeInfo.lastOiUpdateTs),
         collateralPriceUsd: parseFloat(tradeInfo.collateralPriceUsd.toString()) / 1e8,
     },

package/lib/trade/types.d.ts

@@ -64,7 +64,7 @@ export type Pair = {
 export type TradeHistoryRecord = {
     action: string;
     address: string;
-    buy: number;
+    long: number;
     collateralPriceUsd: number;
     collateralIndex: number;
     date: string;
@@ -153,6 +153,19 @@ export type TraderFeeTiers = {
     lastDayUpdatedPoints: number;
     expiredPoints: number[];
 };
+export declare enum PendingOrderType {
+    MARKET_OPEN = 0,
+    MARKET_CLOSE = 1,
+    LIMIT_OPEN = 2,
+    STOP_OPEN = 3,
+    TP_CLOSE = 4,
+    SL_CLOSE = 5,
+    LIQ_CLOSE = 6
+}
+export declare enum CounterType {
+    TRADE = 0,
+    PENDING_ORDER = 1
+}
 export declare enum TradeType {
     TRADE = 0,
     LIMIT = 1,
@@ -163,6 +176,15 @@ export type OpenInterest = {
     short: number;
     max: number;
 };
+export type PendingOrder = {
+    trade: Trade;
+    user: string;
+    index: string;
+    isOpen: boolean;
+    orderType: PendingOrderType;
+    createdBlock: string;
+    maxSlippageP: string;
+};
 export type TradeInitialAccFees = BorrowingFee.InitialAccFees;
 export declare enum PairIndex {
     BTCUSD = 0,

package/lib/trade/types.js

@@ -1,11 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PairIndex = exports.TradeType = exports.PositionType = void 0;
+exports.PairIndex = exports.TradeType = exports.CounterType = exports.PendingOrderType = exports.PositionType = void 0;
 var PositionType;
 (function (PositionType) {
     PositionType["LONG"] = "LONG";
     PositionType["SHORT"] = "SHORT";
 })(PositionType = exports.PositionType || (exports.PositionType = {}));
+var PendingOrderType;
+(function (PendingOrderType) {
+    PendingOrderType[PendingOrderType["MARKET_OPEN"] = 0] = "MARKET_OPEN";
+    PendingOrderType[PendingOrderType["MARKET_CLOSE"] = 1] = "MARKET_CLOSE";
+    PendingOrderType[PendingOrderType["LIMIT_OPEN"] = 2] = "LIMIT_OPEN";
+    PendingOrderType[PendingOrderType["STOP_OPEN"] = 3] = "STOP_OPEN";
+    PendingOrderType[PendingOrderType["TP_CLOSE"] = 4] = "TP_CLOSE";
+    PendingOrderType[PendingOrderType["SL_CLOSE"] = 5] = "SL_CLOSE";
+    PendingOrderType[PendingOrderType["LIQ_CLOSE"] = 6] = "LIQ_CLOSE";
+})(PendingOrderType = exports.PendingOrderType || (exports.PendingOrderType = {}));
+var CounterType;
+(function (CounterType) {
+    CounterType[CounterType["TRADE"] = 0] = "TRADE";
+    CounterType[CounterType["PENDING_ORDER"] = 1] = "PENDING_ORDER";
+})(CounterType = exports.CounterType || (exports.CounterType = {}));
 var TradeType;
 (function (TradeType) {
     TradeType[TradeType["TRADE"] = 0] = "TRADE";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gainsnetwork/sdk",
-  "version": "0.2.0-rc1",
+  "version": "0.2.0-rc4",
   "description": "Gains Network SDK",
   "main": "./lib/index.js",
   "files": [