@gainsnetwork/sdk 1.0.5-rc2 → 1.0.5-rc3

package/lib/markets/price/signedPrices.d.ts

@@ -0,0 +1,15 @@
+import { SignedPricesResponse } from "./types";
+export interface FetchSingedPricesInput {
+    oracles: string[];
+    pairs: number[];
+    chainId: number;
+    authKey?: string;
+    minAnswer?: number;
+    timeoutMs?: number;
+}
+export declare const fetchSignedPrices: (input: FetchSingedPricesInput) => Promise<SignedPricesResponse[] | null>;
+export declare const isValidSignedPricesChain: (chainId: number) => boolean;
+export declare const validateSignedPricesPairs: (pairs: number[]) => {
+    valid: boolean;
+    pairs: number[];
+};

package/lib/markets/price/signedPrices.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSignedPricesPairs = exports.isValidSignedPricesChain = exports.fetchSignedPrices = void 0;
+const types_1 = require("../../contracts/types");
+const fetchSignedPrices = async (input) => {
+    const { minAnswers, timeoutMs, oracles, pairs, chainId, authKey } = {
+        minAnswers: input.chainId === types_1.ChainId.ARBITRUM_SEPOLIA ? 2 : 3,
+        timeoutMs: 1000,
+        ...input,
+    };
+    if (!(0, exports.isValidSignedPricesChain)(chainId))
+        throw new Error(`Invalid chainId ${chainId}`);
+    const { valid, pairs: validPairs } = (0, exports.validateSignedPricesPairs)(pairs);
+    if (!valid)
+        throw new Error(`Invalid pairs array`);
+    try {
+        // Fetch signed prices from all oracles in parallel
+        const signedPrices = await Promise.allSettled(oracles.map(signerUrl => _getSignedPricesFromSigner(signerUrl, validPairs, chainId, authKey, timeoutMs)));
+        // Filter out failed requests and null responses, then sort by signerId
+        const successfulResponses = signedPrices.filter(res => res.status === "fulfilled" && res.value !== null // Filter out failed or null responses
+        )
+            // Extract `value`
+            .map((res) => res.value)
+            // Sort by signerId, contracts expect signerId ascending
+            .sort((a, b) => a.signedData.signerId - b.signedData.signerId);
+        // Ensure we have at least `minAnswers` valid responses
+        if (successfulResponses.length < minAnswers) {
+            throw new Error(`Not enough valid signed prices. Wanted ${minAnswers} but got ${successfulResponses.length}`);
+        }
+        return successfulResponses;
+    }
+    catch (e) {
+        console.error("Error processing signed prices", e);
+        throw e;
+    }
+};
+exports.fetchSignedPrices = fetchSignedPrices;
+const _getSignedPricesFromSigner = async (signerUrl, pairIndices, chainId, authKey, timeoutMs) => {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => {
+            controller.abort();
+        }, timeoutMs || 1000);
+        // @todo add retries
+        const response = await fetch(`${signerUrl}/signPrices`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": authKey || "",
+            },
+            body: JSON.stringify({ pairs: pairIndices, chain: chainId }),
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch signed prices from ${signerUrl}: ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        console.error(`Error fetching signed prices from ${signerUrl}`, error);
+        return null;
+    }
+};
+const isValidSignedPricesChain = (chainId) => {
+    return (!isNaN(chainId) &&
+        [
+            types_1.ChainId.POLYGON,
+            types_1.ChainId.BASE,
+            types_1.ChainId.ARBITRUM,
+            types_1.ChainId.ARBITRUM_SEPOLIA,
+            types_1.ChainId.APECHAIN,
+        ].includes(chainId));
+};
+exports.isValidSignedPricesChain = isValidSignedPricesChain;
+const validateSignedPricesPairs = (pairs) => {
+    if (!Array.isArray(pairs) || pairs?.length === 0 || pairs.some(p => isNaN(p)))
+        return { valid: false, pairs: [] };
+    // Pairs must always be in ascending order
+    return { valid: true, pairs: [...new Set(pairs)].sort((a, b) => a - b) };
+};
+exports.validateSignedPricesPairs = validateSignedPricesPairs;

package/lib/trade/fees/borrowingV2/fetcher.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="mocha" />
 import type { GNSMultiCollatDiamond } from "../../../contracts/types/generated";
 import { BorrowingFeeV2 } from ".";
 /**

package/package.json

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

package/lib/trade/liquidation.d.ts

@@ -1,12 +0,0 @@
-import { GetBorrowingFeeContext, BorrowingFee } from "./fees";
-import { Fee, LiquidationParams, Trade, UserPriceImpact } from "./types";
-import { ContractsVersion } from "../contracts/types";
-export type GetLiquidationPriceContext = GetBorrowingFeeContext & {
-    liquidationParams: LiquidationParams | undefined;
-    pairSpreadP: number | undefined;
-    collateralPriceUsd: number | undefined;
-    contractsVersion: ContractsVersion | undefined;
-    userPriceImpact?: UserPriceImpact | undefined;
-};
-export declare const getLiquidationPrice: (trade: Trade, fee: Fee, initialAccFees: BorrowingFee.InitialAccFees, context: GetLiquidationPriceContext) => number;
-export declare const getLiqPnlThresholdP: (liquidationParams: LiquidationParams | undefined, leverage: number | undefined) => number;

package/lib/trade/liquidation.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLiqPnlThresholdP = exports.getLiquidationPrice = void 0;
-const fees_1 = require("./fees");
-const spread_1 = require("./spread");
-const types_1 = require("../contracts/types");
-const getLiquidationPrice = (trade, fee, initialAccFees, context) => {
-    var _a, _b;
-    const closingFee = (0, fees_1.getClosingFee)(trade.collateralAmount, trade.leverage, trade.pairIndex, fee, context.collateralPriceUsd);
-    const borrowingFee = (0, fees_1.getBorrowingFee)(trade.collateralAmount * trade.leverage, trade.pairIndex, trade.long, initialAccFees, context);
-    const liqThresholdP = (0, exports.getLiqPnlThresholdP)(context.liquidationParams, trade.leverage);
-    let liqPriceDistance = (trade.openPrice *
-        (trade.collateralAmount * liqThresholdP - (borrowingFee + closingFee))) /
-        trade.collateralAmount /
-        trade.leverage;
-    if ((context === null || context === void 0 ? void 0 : context.contractsVersion) !== undefined &&
-        context.contractsVersion >= types_1.ContractsVersion.V9_2 &&
-        ((((_a = context === null || context === void 0 ? void 0 : context.liquidationParams) === null || _a === void 0 ? void 0 : _a.maxLiqSpreadP) !== undefined &&
-            context.liquidationParams.maxLiqSpreadP > 0) ||
-            (((_b = context === null || context === void 0 ? void 0 : context.userPriceImpact) === null || _b === void 0 ? void 0 : _b.fixedSpreadP) !== undefined &&
-                context.userPriceImpact.fixedSpreadP > 0))) {
-        const closingSpreadP = (0, spread_1.getSpreadP)(context.pairSpreadP, true, context.liquidationParams, context.userPriceImpact);
-        liqPriceDistance -= trade.openPrice * closingSpreadP;
-    }
-    return trade.long
-        ? Math.max(trade.openPrice - liqPriceDistance, 0)
-        : Math.max(trade.openPrice + liqPriceDistance, 0);
-};
-exports.getLiquidationPrice = getLiquidationPrice;
-const getLiqPnlThresholdP = (liquidationParams, leverage) => {
-    if (liquidationParams === undefined ||
-        leverage === undefined ||
-        liquidationParams.maxLiqSpreadP === 0 ||
-        liquidationParams.startLiqThresholdP === 0 ||
-        liquidationParams.endLiqThresholdP === 0 ||
-        liquidationParams.startLeverage === 0 ||
-        liquidationParams.endLeverage === 0) {
-        return 0.9;
-    }
-    if (leverage < liquidationParams.startLeverage) {
-        return liquidationParams.startLiqThresholdP;
-    }
-    if (leverage > liquidationParams.endLeverage) {
-        return liquidationParams.endLiqThresholdP;
-    }
-    if (liquidationParams.startLiqThresholdP === liquidationParams.endLiqThresholdP) {
-        return liquidationParams.endLiqThresholdP;
-    }
-    return (liquidationParams.startLiqThresholdP -
-        ((leverage - liquidationParams.startLeverage) *
-            (liquidationParams.startLiqThresholdP -
-                liquidationParams.endLiqThresholdP)) /
-            (liquidationParams.endLeverage - liquidationParams.startLeverage));
-};
-exports.getLiqPnlThresholdP = getLiqPnlThresholdP;

package/lib/trade/pnl.d.ts

@@ -1,10 +0,0 @@
-import { GetBorrowingFeeContext } from "./fees";
-import { Fee, LiquidationParams, Trade, TradeInfo, TradeInitialAccFees } from "./types";
-import { ContractsVersion } from "../contracts/types";
-export type GetPnlContext = GetBorrowingFeeContext & {
-    fee: Fee | undefined;
-    collateralPriceUsd: number | undefined;
-    contractsVersion: ContractsVersion | undefined;
-    feeMultiplier: number | undefined;
-};
-export declare const getPnl: (price: number | undefined, trade: Trade, tradeInfo: TradeInfo, initialAccFees: TradeInitialAccFees, liquidationParams: LiquidationParams, useFees: boolean, context: GetPnlContext) => number[] | undefined;

package/lib/trade/pnl.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPnl = void 0;
-const fees_1 = require("./fees");
-const liquidation_1 = require("./liquidation");
-const getPnl = (price, trade, tradeInfo, initialAccFees, liquidationParams, useFees, context) => {
-    if (!price) {
-        return;
-    }
-    const posCollat = trade.collateralAmount;
-    const { openPrice, leverage } = trade;
-    const { fee } = context;
-    let pnlCollat = trade.long
-        ? ((price - openPrice) / openPrice) * leverage * posCollat
-        : ((openPrice - price) / openPrice) * leverage * posCollat;
-    if (useFees) {
-        pnlCollat -= (0, fees_1.getBorrowingFee)(posCollat * trade.leverage, trade.pairIndex, trade.long, initialAccFees, context);
-    }
-    let pnlPercentage = (pnlCollat / posCollat) * 100;
-    // Can be liquidated
-    if (pnlPercentage <=
-        (0, liquidation_1.getLiqPnlThresholdP)(liquidationParams, leverage) * -100) {
-        pnlPercentage = -100;
-    }
-    else {
-        pnlCollat -= (0, fees_1.getClosingFee)(posCollat, trade.leverage, trade.pairIndex, fee, context.collateralPriceUsd, context.feeMultiplier);
-        pnlPercentage = (pnlCollat / posCollat) * 100;
-    }
-    pnlPercentage = pnlPercentage < -100 ? -100 : pnlPercentage;
-    pnlCollat = (posCollat * pnlPercentage) / 100;
-    return [pnlCollat, pnlPercentage];
-};
-exports.getPnl = getPnl;