@gainsnetwork/sdk 0.2.67-rc7 → 0.2.67-rc8

package/lib/contracts/types/generated/factories/GToken__factory.js

@@ -260,6 +260,12 @@ const _abi = [
                 name: "assetsLessDeplete",
                 type: "uint256",
             },
+            {
+                indexed: false,
+                internalType: "bool",
+                name: "burn",
+                type: "bool",
+            },
         ],
         name: "AssetsReceived",
         type: "event",
@@ -308,31 +314,6 @@ const _abi = [
         name: "DailyAccPnlDeltaReset",
         type: "event",
     },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "address",
-                name: "asset",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "delegatee",
-                type: "address",
-            },
-            {
-                indexed: false,
-                internalType: "bool",
-                name: "success",
-                type: "bool",
-            },
-        ],
-        name: "Delegated",
-        type: "event",
-    },
     {
         anonymous: false,
         inputs: [
@@ -933,32 +914,6 @@ const _abi = [
         stateMutability: "view",
         type: "function",
     },
-    {
-        inputs: [],
-        name: "accBlockWeightedMarketCap",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "accBlockWeightedMarketCapLastStored",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
     {
         inputs: [],
         name: "accPnlPerToken",
@@ -1454,6 +1409,60 @@ const _abi = [
         stateMutability: "view",
         type: "function",
     },
+    {
+        inputs: [],
+        name: "getTotalDepleted",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "assets",
+                type: "uint256",
+            },
+            {
+                internalType: "uint256",
+                name: "gns",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getTotalDiscounts",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "unlocked",
+                type: "uint256",
+            },
+            {
+                internalType: "uint256",
+                name: "locked",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getTotalRefilled",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "assets",
+                type: "uint256",
+            },
+            {
+                internalType: "uint256",
+                name: "gns",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
     {
         inputs: [],
         name: "gnsPriceProvider",
@@ -2213,6 +2222,11 @@ const _abi = [
                 name: "user",
                 type: "address",
             },
+            {
+                internalType: "bool",
+                name: "_burn",
+                type: "bool",
+            },
         ],
         name: "receiveAssets",
         outputs: [],
@@ -2338,32 +2352,6 @@ const _abi = [
         stateMutability: "view",
         type: "function",
     },
-    {
-        inputs: [],
-        name: "totalDepleted",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "totalDepletedGns",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
     {
         inputs: [],
         name: "totalDeposited",
@@ -2377,19 +2365,6 @@ const _abi = [
         stateMutability: "view",
         type: "function",
     },
-    {
-        inputs: [],
-        name: "totalDiscounts",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
     {
         inputs: [],
         name: "totalLiability",
@@ -2403,45 +2378,6 @@ const _abi = [
         stateMutability: "view",
         type: "function",
     },
-    {
-        inputs: [],
-        name: "totalLockedDiscounts",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "totalRefilled",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "totalRefilledGns",
-        outputs: [
-            {
-                internalType: "uint256",
-                name: "",
-                type: "uint256",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
     {
         inputs: [],
         name: "totalRewards",
@@ -2642,19 +2578,6 @@ const _abi = [
         stateMutability: "nonpayable",
         type: "function",
     },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "_delegatee",
-                type: "address",
-            },
-        ],
-        name: "updateDelegatee",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
     {
         inputs: [
             {

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/markets/collateral/converter.d.ts

@@ -0,0 +1,5 @@
+import { ITradingStorage } from "src/contracts/types/generated/GNSMultiCollatDiamond";
+import { CollateralConfig } from "./types";
+export declare const convertCollateralConfig: (collateral: ITradingStorage.CollateralStructOutput & {
+    decimals: number;
+}) => CollateralConfig;

package/lib/markets/collateral/converter.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertCollateralConfig = void 0;
+const convertCollateralConfig = (collateral) => ({
+    collateral: collateral.collateral,
+    isActive: collateral.isActive,
+    precision: Number(collateral.precision),
+    precisionDelta: Number(collateral.precisionDelta),
+    decimals: collateral.decimals,
+});
+exports.convertCollateralConfig = convertCollateralConfig;

package/lib/markets/collateral/index.d.ts

@@ -0,0 +1 @@
+export * from "./types";

package/lib/markets/collateral/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);

package/lib/markets/collateral/types.d.ts

@@ -0,0 +1,7 @@
+export type CollateralConfig = {
+    collateral: string;
+    isActive: boolean;
+    precision: number;
+    precisionDelta: number;
+    decimals?: number;
+};

package/lib/markets/collateral/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/markets/oi/converter.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @dev Converters for OI data between contract and SDK formats
+ * @dev Handles the three OI storage systems and precision conversions
+ */
+import { IBorrowingFees, IPriceImpact } from "../../contracts/types/generated/GNSMultiCollatDiamond";
+import { UnifiedPairOi, ComputedOi } from "./types";
+/**
+ * @dev Converts pre-v10 OI from contract format
+ * @param contractOi Contract OpenInterest struct from BorrowingFeesStorage
+ * @param precision Collateral precision for conversion
+ * @returns Normalized OI with long/short values
+ */
+export declare const convertBeforeV10Collateral: (contractOi: IBorrowingFees.OpenInterestStructOutput, precision: number) => {
+    long: number;
+    short: number;
+};
+/**
+ * @dev Converts post-v10 collateral OI from contract format
+ * @param contractOi Contract PairOiCollateral struct
+ * @param precision Collateral precision for conversion
+ * @returns Normalized OI with long/short values
+ */
+export declare const convertCollateralOi: (contractOi: IPriceImpact.PairOiCollateralStructOutput, precision: number) => {
+    long: number;
+    short: number;
+};
+/**
+ * @dev Converts post-v10 token OI from contract format
+ * @param contractOi Contract PairOiToken struct
+ * @returns Normalized OI with long/short values (1e18 precision)
+ */
+export declare const convertTokenOi: (contractOi: IPriceImpact.PairOiTokenStructOutput) => {
+    long: number;
+    short: number;
+};
+/**
+ * @dev Converts all OI data for a pair into unified structure
+ * @param beforeV10 Pre-v10 OI from BorrowingFeesStorage
+ * @param afterV10Collateral Post-v10 collateral OI from PriceImpactStorage
+ * @param afterV10Token Post-v10 token OI from PriceImpactStorage
+ * @param maxOi Maximum OI allowed (from BorrowingFeesStorage)
+ * @param collateralPrecision Precision for collateral conversions
+ * @returns Unified PairOi structure
+ */
+export declare const convertPairOi: (beforeV10: IBorrowingFees.OpenInterestStructOutput, afterV10Collateral: IPriceImpact.PairOiCollateralStructOutput, afterV10Token: IPriceImpact.PairOiTokenStructOutput, collateralPrecision: number) => UnifiedPairOi;
+/**
+ * @dev Batch converter for multiple pairs
+ * @param pairs Array of OI data for multiple pairs
+ * @param collateralPrecision Precision for collateral conversions
+ * @returns Array of unified PairOi structures
+ */
+export declare const convertPairOiArray: (pairs: Array<{
+    beforeV10: IBorrowingFees.OpenInterestStructOutput;
+    collateral: IPriceImpact.PairOiCollateralStructOutput;
+    token: IPriceImpact.PairOiTokenStructOutput;
+}>, collateralPrecision: number) => UnifiedPairOi[];
+/**
+ * @dev Computes derived OI values from unified structure
+ * @param pairOi Unified pair OI data
+ * @param tokenPriceCollateral Current token price in collateral units
+ * @returns Computed values including total OI and skew
+ */
+export declare const computeOiValues: (pairOi: UnifiedPairOi, tokenPriceCollateral: number) => ComputedOi;

package/lib/markets/oi/converter.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * @dev Converters for OI data between contract and SDK formats
+ * @dev Handles the three OI storage systems and precision conversions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeOiValues = exports.convertPairOiArray = exports.convertPairOi = exports.convertTokenOi = exports.convertCollateralOi = exports.convertBeforeV10Collateral = void 0;
+/**
+ * @dev Converts pre-v10 OI from contract format
+ * @param contractOi Contract OpenInterest struct from BorrowingFeesStorage
+ * @param precision Collateral precision for conversion
+ * @returns Normalized OI with long/short values
+ */
+const convertBeforeV10Collateral = (contractOi, precision) => {
+    return {
+        long: Number(contractOi.long) / precision,
+        short: Number(contractOi.short) / precision,
+    };
+};
+exports.convertBeforeV10Collateral = convertBeforeV10Collateral;
+/**
+ * @dev Converts post-v10 collateral OI from contract format
+ * @param contractOi Contract PairOiCollateral struct
+ * @param precision Collateral precision for conversion
+ * @returns Normalized OI with long/short values
+ */
+const convertCollateralOi = (contractOi, precision) => {
+    return {
+        long: Number(contractOi.oiLongCollateral) / precision,
+        short: Number(contractOi.oiShortCollateral) / precision,
+    };
+};
+exports.convertCollateralOi = convertCollateralOi;
+/**
+ * @dev Converts post-v10 token OI from contract format
+ * @param contractOi Contract PairOiToken struct
+ * @returns Normalized OI with long/short values (1e18 precision)
+ */
+const convertTokenOi = (contractOi) => {
+    return {
+        long: Number(contractOi.oiLongToken) / 1e18,
+        short: Number(contractOi.oiShortToken) / 1e18,
+    };
+};
+exports.convertTokenOi = convertTokenOi;
+/**
+ * @dev Converts all OI data for a pair into unified structure
+ * @param beforeV10 Pre-v10 OI from BorrowingFeesStorage
+ * @param afterV10Collateral Post-v10 collateral OI from PriceImpactStorage
+ * @param afterV10Token Post-v10 token OI from PriceImpactStorage
+ * @param maxOi Maximum OI allowed (from BorrowingFeesStorage)
+ * @param collateralPrecision Precision for collateral conversions
+ * @returns Unified PairOi structure
+ */
+const convertPairOi = (beforeV10, afterV10Collateral, afterV10Token, collateralPrecision) => {
+    return {
+        maxCollateral: Number(beforeV10.max) / collateralPrecision,
+        beforeV10Collateral: (0, exports.convertBeforeV10Collateral)(beforeV10, collateralPrecision),
+        collateral: (0, exports.convertCollateralOi)(afterV10Collateral, collateralPrecision),
+        token: (0, exports.convertTokenOi)(afterV10Token),
+    };
+};
+exports.convertPairOi = convertPairOi;
+/**
+ * @dev Batch converter for multiple pairs
+ * @param pairs Array of OI data for multiple pairs
+ * @param collateralPrecision Precision for collateral conversions
+ * @returns Array of unified PairOi structures
+ */
+const convertPairOiArray = (pairs, collateralPrecision) => {
+    return pairs.map(p => (0, exports.convertPairOi)(p.beforeV10, p.collateral, p.token, collateralPrecision));
+};
+exports.convertPairOiArray = convertPairOiArray;
+/**
+ * @dev Computes derived OI values from unified structure
+ * @param pairOi Unified pair OI data
+ * @param tokenPriceCollateral Current token price in collateral units
+ * @returns Computed values including total OI and skew
+ */
+const computeOiValues = (pairOi, tokenPriceCollateral) => {
+    // Static total (used for admin operations)
+    const totalStaticLong = pairOi.beforeV10Collateral.long + pairOi.collateral.long;
+    const totalStaticShort = pairOi.beforeV10Collateral.short + pairOi.collateral.short;
+    // Dynamic total (used for real-time calculations)
+    const tokenLongCollateral = pairOi.token.long * tokenPriceCollateral;
+    const tokenShortCollateral = pairOi.token.short * tokenPriceCollateral;
+    const totalDynamicLong = pairOi.beforeV10Collateral.long + tokenLongCollateral;
+    const totalDynamicShort = pairOi.beforeV10Collateral.short + tokenShortCollateral;
+    // Skew (v10+ only, in tokens)
+    const skewToken = pairOi.token.long - pairOi.token.short;
+    return {
+        totalStaticCollateral: {
+            long: totalStaticLong,
+            short: totalStaticShort,
+        },
+        totalDynamicCollateral: {
+            long: totalDynamicLong,
+            short: totalDynamicShort,
+        },
+        skewToken,
+    };
+};
+exports.computeOiValues = computeOiValues;

package/lib/markets/oi/fetcher.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @dev Fetchers for retrieving OI data from contracts
+ * @dev Consolidates the three OI storage systems into unified format
+ */
+import { ethers } from "ethers";
+import { ChainId } from "../../contracts/types";
+import { UnifiedPairOi } from "./types";
+/**
+ * @dev Fetches all OI data for a single pair
+ * @param chainId Target chain
+ * @param collateralIndex Collateral type
+ * @param pairIndex Trading pair
+ * @param signer Ethers signer
+ * @returns Unified PairOi structure with all OI data
+ */
+export declare function fetchPairOi(chainId: ChainId, collateralIndex: number, pairIndex: number, signer: ethers.Signer): Promise<UnifiedPairOi>;
+/**
+ * @dev Fetches OI data for multiple pairs efficiently
+ * @param chainId Target chain
+ * @param collateralIndex Collateral type
+ * @param pairIndices Array of trading pairs
+ * @param signer Ethers signer
+ * @returns Array of unified PairOi structures
+ */
+export declare function fetchMultiplePairOi(chainId: ChainId, collateralIndex: number, pairIndices: number[], signer: ethers.Signer): Promise<UnifiedPairOi[]>;
+/**
+ * @dev Creates OI context for fee calculations
+ * @param chainId Target chain
+ * @param collateralIndex Collateral type
+ * @param pairIndex Trading pair
+ * @param signer Ethers signer
+ * @returns OI data formatted for SDK calculations
+ */
+export declare function createOiContext(chainId: ChainId, collateralIndex: number, pairIndex: number, signer: ethers.Signer): Promise<{
+    pairOi: UnifiedPairOi;
+    currentPrice: number;
+    computed: {
+        totalDynamicOi: {
+            long: number;
+            short: number;
+        };
+        totalStaticOi: {
+            long: number;
+            short: number;
+        };
+        skew: number;
+    };
+}>;
+/**
+ * @dev Fetches only the OI data needed for specific use cases
+ * @param chainId Target chain
+ * @param collateralIndex Collateral type
+ * @param pairIndex Trading pair
+ * @param useCase Which OI systems to fetch
+ * @param signer Ethers signer
+ * @returns Partial OI data based on use case
+ */
+export declare function fetchOiForUseCase(chainId: ChainId, collateralIndex: number, pairIndex: number, useCase: "skew" | "funding" | "borrowingV1" | "limits", signer: ethers.Signer): Promise<Partial<UnifiedPairOi>>;