@gainsnetwork/sdk 0.0.2-rc.2 → 0.0.2

package/README.md

@@ -3,7 +3,7 @@
 ## Install
 
 ```bash
-npm install @gains-network/sdk
+npm install @gainsnetwork/sdk
 ```
 
 ## Usage

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

@@ -1 +1,2 @@
 export * from "./openTrades";
+export * from "./pairs";

package/lib/contracts/utils/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./openTrades"), exports);
+__exportStar(require("./pairs"), exports);

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

@@ -1,8 +1,3 @@
 import { TradeContainer } from "@/trade/types";
-import { GFarmTradingStorageV5, GNSPairInfosV6_1, GNSPairsStorageV6 } from "../types/generated";
-export type FetchTradesTradingContracts = {
-    storage: GFarmTradingStorageV5;
-    pairInfos: GNSPairInfosV6_1;
-    pairsStorage: GNSPairsStorageV6;
-};
-export declare const fetchOpenPairTrades: (contracts: FetchTradesTradingContracts, pairBatchSize?: number) => Promise<TradeContainer[]>;
+import { Contracts } from "@/contracts/types";
+export declare const fetchOpenPairTrades: (contracts: Contracts, pairBatchSize?: number) => Promise<TradeContainer[]>;

package/lib/contracts/utils/openTrades.js

@@ -14,7 +14,7 @@ const fetchOpenPairTrades = (contracts, pairBatchSize = 10) => __awaiter(void 0,
     if (!contracts) {
         return [];
     }
-    const { pairsStorage: pairsStorageContract } = contracts;
+    const { gnsPairsStorageV6: pairsStorageContract } = contracts;
     try {
         const totalPairIndexes = (yield pairsStorageContract.pairsCount()).toNumber() - 1;
         let allOpenPairTrades = [];
@@ -33,7 +33,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 { storage: storageContract, pairInfos: 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* () {
@@ -51,12 +51,16 @@ const fetchOpenPairTradesBatch = (contracts, startPairIndex, endPairIndex) => __
             for (let pairTradeIndex = 0; pairTradeIndex < maxTradesPerPair; pairTradeIndex++) {
                 openTradesCalls[pairTradeIndex] = storageContract.openTrades(pairTraderAddress, pairIndex, pairTradeIndex);
             }
-            console.debug(`Waiting on ${openTradesCalls.length} StorageContract::openTrades calls for trader ${pairTraderAddress}...`);
+            /*console.debug(
+              `Waiting on ${openTradesCalls.length} StorageContract::openTrades calls for trader ${pairTraderAddress}...`
+            );*/
             const openTradesForTraderAddress = yield Promise.all(openTradesCalls);
             console.debug(`Received all trades for trader ${pairTraderAddress} and pair ${pairIndex} in ${performance.now() - traderOpenTradesCallsStartTime}ms.`);
             // 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);
-            console.debug(`Filtered down to ${actualOpenTradesForTrader.length} actual open trades for trader ${pairTraderAddress} and pair ${pairIndex}; fetching corresponding trade info and initial fees...`);
+            /*console.debug(
+              `Filtered down to ${actualOpenTradesForTrader.length} actual open trades for trader ${pairTraderAddress} and pair ${pairIndex}; fetching corresponding trade info and initial fees...`
+            );*/
             const [actualOpenTradesTradeInfos, actualOpenTradesInitialAccFees] = yield Promise.all([
                 Promise.all(actualOpenTradesForTrader.map(aot => storageContract.openTradesInfo(aot.trader, aot.pairIndex, aot.index))),
                 Promise.all(actualOpenTradesForTrader.map(aot => pairInfosContract.tradeInitialAccFees(aot.trader, aot.pairIndex, aot.index))),
@@ -77,30 +81,32 @@ const fetchOpenPairTradesBatch = (contracts, startPairIndex, endPairIndex) => __
                 finalOpenTradesForTrader[tradeIndex] = {
                     trade: {
                         trader: trade.trader,
-                        pairIndex: trade.pairIndex,
-                        index: trade.index,
-                        initialPosToken: trade.initialPosToken,
-                        openPrice: trade.openPrice,
-                        buy: trade.buy,
-                        leverage: trade.leverage,
-                        tp: trade.tp,
-                        sl: trade.sl,
+                        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,
-                        tokenPriceDai: tradeInfo.tokenPriceDai,
-                        openInterestDai: tradeInfo.openInterestDai,
+                        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: tradeInitialAccFees.rollover,
-                        funding: tradeInitialAccFees.funding,
-                        openedAfterUpdate: tradeInitialAccFees.openedAfterUpdate,
+                        rollover: parseFloat(tradeInitialAccFees.rollover.toString()) / 1e18,
+                        funding: parseFloat(tradeInitialAccFees.funding.toString()) / 1e18,
+                        openedAfterUpdate: tradeInitialAccFees.openedAfterUpdate.toString() === "true",
                     },
                 };
             }
-            console.debug(`Trade info and initial fees fetched for ${finalOpenTradesForTrader.length} trades for trader ${pairTraderAddress} and pair ${pairIndex}; done!`);
+            /*console.debug(
+              `Trade info and initial fees fetched for ${finalOpenTradesForTrader.length} trades for trader ${pairTraderAddress} and pair ${pairIndex}; done!`
+            );*/
             return finalOpenTradesForTrader;
         })));
         return openTradesForPairTraders;

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

@@ -0,0 +1,6 @@
+import { Pair, PairParams, PairRolloverFees, Fee } from "@/trade/types";
+import { Contracts } from "@/contracts/types";
+export declare const fetchPairs: (contracts: Contracts, pairIxs: number[]) => Promise<Pair[]>;
+export declare const fetchPairsParams: (contracts: Contracts, pairIxs: number[]) => Promise<PairParams[]>;
+export declare const fetchPairsRolloverFees: (contracts: Contracts, pairIxs: number[]) => Promise<PairRolloverFees[]>;
+export declare const fetchFees: (contracts: Contracts, feeIxs: number[]) => Promise<Fee[]>;

package/lib/contracts/utils/pairs.js

@@ -0,0 +1,102 @@
+"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.fetchFees = exports.fetchPairsRolloverFees = exports.fetchPairsParams = exports.fetchPairs = void 0;
+const fetchPairs = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!contracts) {
+        return [];
+    }
+    const { gnsPairsStorageV6: pairsStorageContract } = contracts;
+    try {
+        const pairs = yield Promise.all(pairIxs.map((pairIndex) => pairsStorageContract.pairs(pairIndex)));
+        return pairs.map((pair, index) => {
+            return {
+                name: pair.from + "/" + pair.to,
+                from: pair.from,
+                to: pair.to,
+                feeIndex: parseInt(pair.feeIndex.toString()),
+                groupIndex: parseInt(pair.groupIndex.toString()),
+                pairIndex: pairIxs[index],
+                spreadP: parseFloat(pair.spreadP.toString()) / 1e12,
+            };
+        });
+    }
+    catch (error) {
+        console.error(`Unexpected error while fetching pairs!`);
+        throw error;
+    }
+});
+exports.fetchPairs = fetchPairs;
+const fetchPairsParams = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!contracts) {
+        return [];
+    }
+    const { gnsPairInfosV6_1: pairInfosContract } = contracts;
+    try {
+        const pairParams = yield Promise.all(pairIxs.map((pairIndex) => pairInfosContract.pairParams(pairIndex)));
+        return pairParams.map((pair) => {
+            return {
+                onePercentDepthAbove: parseFloat(pair.onePercentDepthAbove.toString()),
+                onePercentDepthBelow: parseFloat(pair.onePercentDepthBelow.toString()),
+                rolloverFeePerBlockP: parseFloat(pair.rolloverFeePerBlockP.toString()) / 1e12,
+                fundingFeePerBlockP: parseFloat(pair.fundingFeePerBlockP.toString()) / 1e12,
+            };
+        });
+    }
+    catch (error) {
+        console.error(`Unexpected error while fetching pairs!`);
+        throw error;
+    }
+});
+exports.fetchPairsParams = fetchPairsParams;
+const fetchPairsRolloverFees = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!contracts) {
+        return [];
+    }
+    const { gnsPairInfosV6_1: pairInfosContract } = contracts;
+    try {
+        const pairsRolloverFees = yield Promise.all(pairIxs.map((pairIndex) => pairInfosContract.pairRolloverFees(pairIndex)));
+        return pairsRolloverFees.map((pairData) => {
+            return {
+                accPerCollateral: parseFloat(pairData.accPerCollateral.toString()) / 1e18,
+                lastUpdateBlock: parseInt(pairData.lastUpdateBlock.toString()),
+            };
+        });
+    }
+    catch (error) {
+        console.error(`Unexpected error while fetching pairs!`);
+        throw error;
+    }
+});
+exports.fetchPairsRolloverFees = fetchPairsRolloverFees;
+const fetchFees = (contracts, feeIxs) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!contracts) {
+        return [];
+    }
+    const { gnsPairsStorageV6: pairsStorageContract } = contracts;
+    try {
+        const fees = yield Promise.all(feeIxs.map((pairIndex) => pairsStorageContract.fees(pairIndex)));
+        return fees.map((fee) => {
+            return {
+                closeFeeP: parseFloat(fee.closeFeeP.toString()) / 1e12,
+                minLevPosDai: parseFloat(fee.minLevPosDai.toString()) / 1e12,
+                nftLimitOrderFeeP: parseFloat(fee.nftLimitOrderFeeP.toString()) / 1e12,
+                openFeeP: parseFloat(fee.openFeeP.toString()) / 1e12,
+                referralFeeP: parseFloat(fee.referralFeeP.toString()) / 1e12,
+            };
+        });
+    }
+    catch (error) {
+        console.error(`Unexpected error while fetching pairs!`);
+        throw error;
+    }
+});
+exports.fetchFees = fetchFees;

package/package.json

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