@gainsnetwork/sdk 0.2.22 → 0.2.23

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

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

@@ -1,88 +0,0 @@
-"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/openLimitOrder.d.ts

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

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