@gainsnetwork/sdk 0.2.40-rc2 → 0.2.41-rc2

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

@@ -1,5 +1,6 @@
 import { GNSMultiCollatDiamond } from "../types/generated";
 import { BorrowingFee } from "../../trade";
+export declare const getBorrowingGroupName: (groupIndex: number) => string;
 export declare const fetchAllPairBorrowingFees: (contract: GNSMultiCollatDiamond, collateralIndex: number) => Promise<BorrowingFee.Pair[]>;
 export declare const fetchGroupBorrowingFees: (contract: GNSMultiCollatDiamond, collateralIndex: number, groupIxs: number[]) => Promise<BorrowingFee.Group[]>;
 export declare const fetchAllPairAndGroupBorrowingFees: (contract: GNSMultiCollatDiamond, collateralIndex: number) => Promise<{

package/lib/contracts/utils/borrowingFees.js

@@ -9,8 +9,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchAllPairAndGroupBorrowingFees = exports.fetchGroupBorrowingFees = exports.fetchAllPairBorrowingFees = void 0;
+exports.fetchAllPairAndGroupBorrowingFees = exports.fetchGroupBorrowingFees = exports.fetchAllPairBorrowingFees = exports.getBorrowingGroupName = void 0;
 const trade_1 = require("../../trade");
+const getBorrowingGroupName = (groupIndex) => {
+    const groupNamesByIndex = [
+        "Crypto Core",
+        "Crypto Altcoins",
+        "Forex USD Majors",
+        "Forex USD-Quoted Majors",
+        "Forex EUR Majors",
+        "",
+        "",
+        "Commodities",
+        "Forex USD Minors",
+        "Forex Nordic",
+        "Forex GBP Majors",
+        "Forex AUD",
+        "Forex NZD",
+    ];
+    return groupNamesByIndex[groupIndex - 1] || "Unknown";
+};
+exports.getBorrowingGroupName = getBorrowingGroupName;
 const fetchAllPairBorrowingFees = (contract, collateralIndex) => __awaiter(void 0, void 0, void 0, function* () {
     return (0, trade_1.convertPairBorrowingFees)(yield contract.getAllBorrowingPairs(collateralIndex));
 });

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

@@ -0,0 +1,8 @@
+import { LimitOrder } from "@/trade/types";
+import { BlockTag, Contracts } from "../types";
+export type FetchOpenLimitOrdersOverrides = {
+    blockTag?: BlockTag;
+    useMulticall?: boolean;
+};
+export declare const fetchOpenLimitOrders: (contracts: Contracts, overrides?: FetchOpenLimitOrdersOverrides) => Promise<LimitOrder[]>;
+export declare const fetchOpenLimitOrdersRaw: (contracts: Contracts, overrides?: FetchOpenLimitOrdersOverrides) => Promise<any[]>;

package/lib/contracts/utils/openLimitOrders.js

@@ -0,0 +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;

package/lib/trade/fees/borrowing/converter.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertGroupBorrowingFees = exports.convertGroupBorrowingData = exports.convertGroupBorrowingFee = exports.convertPairBorrowingFees = exports.convertPairBorrowingFee = exports.convertPairGroupBorrowingFee = void 0;
+const borrowingFees_1 = require("../../../contracts/utils/borrowingFees");
 const convertPairGroupBorrowingFee = (pairGroup) => ({
     groupIndex: pairGroup.groupIndex,
+    name: (0, borrowingFees_1.getBorrowingGroupName)(pairGroup.groupIndex),
     initialAccFeeLong: parseFloat(pairGroup.initialAccFeeLong.toString()) / 1e10,
     initialAccFeeShort: parseFloat(pairGroup.initialAccFeeShort.toString()) / 1e10,
     prevGroupAccFeeLong: parseFloat(pairGroup.prevGroupAccFeeLong.toString()) / 1e10,

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

@@ -8,6 +8,7 @@ export type BorrowingData = {
 };
 export type PairGroup = {
     groupIndex: number;
+    name?: string;
     block: number;
     initialAccFeeLong: number;
     initialAccFeeShort: number;

package/lib/trade/openLimitOrder.d.ts

@@ -0,0 +1,2 @@
+import { LimitOrder, Pair, PairDepth, OiWindowsSettings, OiWindows } from "./types";
+export declare const getFulfillmentPrice: (order: LimitOrder, pair: Pair, pairDepth: PairDepth, oiWindowsSettings?: OiWindowsSettings, oiWindows?: OiWindows) => number;

package/lib/trade/openLimitOrder.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFulfillmentPrice = void 0;
+const spread_1 = require("./spread");
+const types_1 = require("./types");
+const getFulfillmentPrice = (order, pair, pairDepth, oiWindowsSettings, oiWindows) => {
+    if (!order || !pair) {
+        return 0;
+    }
+    // Get spread percentage
+    const spreadWithPriceImpactP = (0, spread_1.getSpreadWithPriceImpactP)(pair.spreadP, order.buy, order.positionSize, order.leverage, pairDepth, oiWindowsSettings, oiWindows);
+    if (spreadWithPriceImpactP === 0) {
+        return 0;
+    }
+    const askingPrice = (order.buy && order.type === types_1.OpenLimitOrderType.REVERSAL) ||
+        (!order.buy && order.type === types_1.OpenLimitOrderType.MOMENTUM)
+        ? order.maxPrice
+        : order.minPrice;
+    return order.buy
+        ? askingPrice * (1 + spreadWithPriceImpactP)
+        : askingPrice * (1 - spreadWithPriceImpactP);
+};
+exports.getFulfillmentPrice = getFulfillmentPrice;

package/package.json

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