@gainsnetwork/sdk 1.0.5-rc3 → 1.0.6-rc2

package/lib/contracts/utils/borrowingFees.js

@@ -1,13 +1,4 @@
 "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.fetchAllPairAndGroupBorrowingFees = exports.fetchGroupBorrowingFees = exports.fetchAllPairBorrowingFees = exports.getBorrowingGroupName = void 0;
 const trade_1 = require("../../trade");
@@ -31,24 +22,22 @@ const getBorrowingGroupName = (groupIndex) => {
     return groupNamesByIndex[groupIndex - 1] || "Unknown";
 };
 exports.getBorrowingGroupName = getBorrowingGroupName;
-const fetchAllPairBorrowingFees = (contract, collateralIndex) => __awaiter(void 0, void 0, void 0, function* () {
-    const [pairs, pairOi, pairGroups] = yield contract.getAllBorrowingPairs(collateralIndex);
-    const feeCaps = yield contract.getBorrowingPairFeePerBlockCaps(collateralIndex, [...Array(pairs.length).keys()]);
+const fetchAllPairBorrowingFees = async (contract, collateralIndex) => {
+    const [pairs, pairOi, pairGroups] = await contract.getAllBorrowingPairs(collateralIndex);
+    const feeCaps = await contract.getBorrowingPairFeePerBlockCaps(collateralIndex, [...Array(pairs.length).keys()]);
     return (0, trade_1.convertPairBorrowingFees)([pairs, pairOi, pairGroups, feeCaps]);
-});
+};
 exports.fetchAllPairBorrowingFees = fetchAllPairBorrowingFees;
-const fetchGroupBorrowingFees = (contract, collateralIndex, groupIxs) => __awaiter(void 0, void 0, void 0, function* () {
-    return (0, trade_1.convertGroupBorrowingFees)(yield contract.getBorrowingGroups(collateralIndex, groupIxs));
-});
+const fetchGroupBorrowingFees = async (contract, collateralIndex, groupIxs) => (0, trade_1.convertGroupBorrowingFees)(await contract.getBorrowingGroups(collateralIndex, groupIxs));
 exports.fetchGroupBorrowingFees = fetchGroupBorrowingFees;
-const fetchAllPairAndGroupBorrowingFees = (contract, collateralIndex) => __awaiter(void 0, void 0, void 0, function* () {
-    const pairs = yield (0, exports.fetchAllPairBorrowingFees)(contract, collateralIndex);
+const fetchAllPairAndGroupBorrowingFees = async (contract, collateralIndex) => {
+    const pairs = await (0, exports.fetchAllPairBorrowingFees)(contract, collateralIndex);
     const groupIxs = [
         ...new Set(pairs
             .map(value => value.groups.map(value => value.groupIndex))
             .reduce((acc, value) => acc.concat(value), [])),
     ].sort((a, b) => a - b);
-    const groups = yield (0, exports.fetchGroupBorrowingFees)(contract, collateralIndex, groupIxs);
+    const groups = await (0, exports.fetchGroupBorrowingFees)(contract, collateralIndex, groupIxs);
     return { pairs, groups };
-});
+};
 exports.fetchAllPairAndGroupBorrowingFees = fetchAllPairAndGroupBorrowingFees;

package/lib/contracts/utils/openTrades.js

@@ -1,20 +1,11 @@
 "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.fetchOpenPairTradesRaw = exports.fetchOpenPairTrades = void 0;
 const ethcall_1 = require("ethcall");
 const trade_1 = require("../../trade");
-const fetchOpenPairTrades = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
-    const rawTrades = yield (0, exports.fetchOpenPairTradesRaw)(contracts, overrides);
-    const collaterals = yield contracts.gnsMultiCollatDiamond.getCollaterals();
+const fetchOpenPairTrades = async (contracts, overrides = {}) => {
+    const rawTrades = await (0, exports.fetchOpenPairTradesRaw)(contracts, overrides);
+    const collaterals = await contracts.gnsMultiCollatDiamond.getCollaterals();
     const collateralConfigs = collaterals.map(c => ({
         collateral: c.collateral,
         isActive: c.isActive,
@@ -22,10 +13,10 @@ const fetchOpenPairTrades = (contracts, overrides = {}) => __awaiter(void 0, voi
         precisionDelta: parseFloat(c.precisionDelta.toString()),
     }));
     return rawTrades.map(rawTrade => _prepareTradeContainer(rawTrade.trade, rawTrade.tradeInfo, rawTrade.liquidationParams, rawTrade.initialAccFees, rawTrade.tradeFeesData, rawTrade.uiRealizedPnlData, collateralConfigs[parseInt(rawTrade.trade.collateralIndex.toString()) - 1]));
-});
+};
 exports.fetchOpenPairTrades = fetchOpenPairTrades;
 // @todo rename
-const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0, void 0, void 0, function* () {
+const fetchOpenPairTradesRaw = async (contracts, overrides = {}) => {
     if (!contracts) {
         return [];
     }
@@ -39,13 +30,13 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
             ]),
         };
         if (useMulticall) {
-            yield multicallCtx.provider.init(multiCollatDiamondContract.provider);
+            await multicallCtx.provider.init(multiCollatDiamondContract.provider);
         }
         let allOpenPairTrades = [];
         let running = true;
         let offset = 0;
         while (running) {
-            const [trades, tradeInfos, tradeLiquidationParams] = yield Promise.all([
+            const [trades, tradeInfos, tradeLiquidationParams] = await Promise.all([
                 multiCollatDiamondContract.getAllTrades(offset, offset + batchSize),
                 multiCollatDiamondContract.getAllTradeInfos(offset, offset + batchSize),
                 multiCollatDiamondContract.getAllTradesLiquidationParams(offset, offset + batchSize),
@@ -85,7 +76,7 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
                     uiRealizedPnlData: undefined,
                 };
             });
-            const [tradeFeesData, uiRealizedPnlData] = yield Promise.all([
+            const [tradeFeesData, uiRealizedPnlData] = await Promise.all([
                 multiCollatDiamondContract.getTradeFeesDataArray(...fundingFeesCallParams),
                 includeUIRealizedPnlData
                     ? multiCollatDiamondContract.getTradeUiRealizedPnlDataArray(...fundingFeesCallParams)
@@ -100,13 +91,13 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
                 .map(({ collateralIndex, user, index }) => (useMulticall
                 ? multicallCtx.diamond
                 : multiCollatDiamondContract).getBorrowingInitialAccFees(collateralIndex, user, index));
-            const initialAccFees = yield (useMulticall
+            const initialAccFees = await (useMulticall
                 ? multicallCtx.provider.all(initialAccFeesPromises)
                 : Promise.all(initialAccFeesPromises));
             initialAccFees.forEach((accFees, ix) => {
                 openTrades[ix].initialAccFees = accFees;
                 openTrades[ix].tradeFeesData = tradeFeesData[ix];
-                openTrades[ix].uiRealizedPnlData = uiRealizedPnlData === null || uiRealizedPnlData === void 0 ? void 0 : uiRealizedPnlData[ix];
+                openTrades[ix].uiRealizedPnlData = uiRealizedPnlData?.[ix];
             });
             allOpenPairTrades = allOpenPairTrades.concat(openTrades);
             offset += batchSize + 1;
@@ -119,7 +110,7 @@ const fetchOpenPairTradesRaw = (contracts, overrides = {}) => __awaiter(void 0,
         console.error(`Unexpected error while fetching open pair trades!`);
         throw error;
     }
-});
+};
 exports.fetchOpenPairTradesRaw = fetchOpenPairTradesRaw;
 const _prepareTradeContainer = (trade, tradeInfo, tradeLiquidationParams, tradeInitialAccFees, tradeFeesData, uiRealizedPnlData, collateralConfig) => {
     const precision = collateralConfig.precision;

package/lib/contracts/utils/pairs.js

@@ -1,26 +1,17 @@
 "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.getPairDescription = exports.fetchOpenInterest = exports.fetchFees = exports.fetchPairDepths = exports.fetchPairs = void 0;
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 const types_1 = require("../../trade/types");
-const fetchPairs = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0, function* () {
+const fetchPairs = async (contracts, pairIxs) => {
     if (!contracts) {
         return [];
     }
     const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
     try {
-        const pairs = yield Promise.all(pairIxs.map(pairIndex => multiCollatContract.pairs(pairIndex)));
+        const pairs = await Promise.all(pairIxs.map(pairIndex => multiCollatContract.pairs(pairIndex)));
         return pairs.map((pair, index) => {
             return {
                 name: pair.from + "/" + pair.to,
@@ -38,15 +29,15 @@ const fetchPairs = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0, fun
         console.error(`Unexpected error while fetching pairs!`);
         throw error;
     }
-});
+};
 exports.fetchPairs = fetchPairs;
-const fetchPairDepths = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0, function* () {
+const fetchPairDepths = async (contracts, pairIxs) => {
     if (!contracts) {
         return [];
     }
     const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
     try {
-        const pairParams = yield multiCollatContract.getPairDepths(pairIxs);
+        const pairParams = await multiCollatContract.getPairDepths(pairIxs);
         return pairParams.map(pair => {
             return {
                 onePercentDepthAboveUsd: parseFloat(pair.onePercentDepthAboveUsd.toString()),
@@ -58,15 +49,15 @@ const fetchPairDepths = (contracts, pairIxs) => __awaiter(void 0, void 0, void 0
         console.error(`Unexpected error while fetching pairs!`);
         throw error;
     }
-});
+};
 exports.fetchPairDepths = fetchPairDepths;
-const fetchFees = (contracts, feeIxs) => __awaiter(void 0, void 0, void 0, function* () {
+const fetchFees = async (contracts, feeIxs) => {
     if (!contracts) {
         return [];
     }
     const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
     try {
-        const fees = yield Promise.all(feeIxs.map(pairIndex => multiCollatContract.fees(pairIndex)));
+        const fees = await Promise.all(feeIxs.map(pairIndex => multiCollatContract.fees(pairIndex)));
         return fees.map(fee => {
             return {
                 totalPositionSizeFeeP: parseFloat(fee.totalPositionSizeFeeP.toString()) / 1e12,
@@ -80,13 +71,13 @@ const fetchFees = (contracts, feeIxs) => __awaiter(void 0, void 0, void 0, funct
         console.error(`Unexpected error while fetching pairs!`);
         throw error;
     }
-});
+};
 exports.fetchFees = fetchFees;
-const fetchOpenInterest = (contracts, collateralIndex, pairIxs) => __awaiter(void 0, void 0, void 0, function* () {
+const fetchOpenInterest = async (contracts, collateralIndex, pairIxs) => {
     if (pairIxs.length === 0) {
         return [];
     }
-    const openInterests = (yield contracts.gnsMultiCollatDiamond.getAllBorrowingPairs(collateralIndex))[1];
+    const openInterests = (await contracts.gnsMultiCollatDiamond.getAllBorrowingPairs(collateralIndex))[1];
     return pairIxs.map(pairIndex => {
         const openInterest = openInterests[pairIndex];
         if (!openInterest) {
@@ -98,7 +89,7 @@ const fetchOpenInterest = (contracts, collateralIndex, pairIxs) => __awaiter(voi
             max: parseFloat(openInterest[2].toString()) / 1e10,
         };
     });
-});
+};
 exports.fetchOpenInterest = fetchOpenInterest;
 const getPairDescription = (pairIndex) => {
     return PAIR_INDEX_TO_DESCRIPTION[pairIndex] || "";

package/lib/markets/forex.js

@@ -33,7 +33,7 @@ const isForexLowLiquidity = (timestampToCheck, pair) => {
     const hour = now.hour;
     const minute = now.minute;
     const isInDST = now.isInDST;
-    const groupIndex = pair === null || pair === void 0 ? void 0 : pair.groupIndex;
+    const groupIndex = pair?.groupIndex;
     if (groupIndex && extendedLowLiqGroupIds.includes(+groupIndex)) {
         return ((isInDST &&
             ((hour == 14 && minute >= 45) || (hour >= 15 && hour < 21))) ||

package/lib/markets/leverage/builder.js

@@ -18,8 +18,8 @@ const buildMarketLeverageRestrictionsContext = (globalTradingVariables, pairInde
     return {
         groupMinLeverage: group.minLeverage,
         groupMaxLeverage: group.maxLeverage,
-        pairMaxLeverage: pairMaxLeverages === null || pairMaxLeverages === void 0 ? void 0 : pairMaxLeverages[pairIndex],
-        counterTradeSettings: counterTradeSettings === null || counterTradeSettings === void 0 ? void 0 : counterTradeSettings[pairIndex],
+        pairMaxLeverage: pairMaxLeverages?.[pairIndex],
+        counterTradeSettings: counterTradeSettings?.[pairIndex],
     };
 };
 exports.buildMarketLeverageRestrictionsContext = buildMarketLeverageRestrictionsContext;

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

@@ -4,3 +4,4 @@
 export * from "./types";
 export * from "./marketPrice";
 export * from "./builder";
+export * from "./signedPrices";

package/lib/markets/price/index.js

@@ -20,3 +20,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
 __exportStar(require("./marketPrice"), exports);
 __exportStar(require("./builder"), exports);
+__exportStar(require("./signedPrices"), exports);

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

@@ -1,15 +1,31 @@
 import { SignedPricesResponse } from "./types";
-export interface FetchSingedPricesInput {
+import { PendingOrderType } from "../../trade";
+export interface FetchSignedPricesInput {
     oracles: string[];
     pairs: number[];
-    chainId: number;
+    chain: 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 fetchSignedPrices: (input: FetchSignedPricesInput) => Promise<SignedPricesResponse[] | null>;
+export interface FetchSignedLookbackPricesInput {
+    oracles: string[];
+    trader: string;
+    tradeIndex: number;
+    pair: number;
+    orderType: PendingOrderType;
+    currentBlock: number;
+    fromBlock: number;
+    chain: number;
+    authKey?: string;
+    minAnswer?: number;
+    timeoutMs?: number;
+}
+export declare const fetchSignedLookbackPrices: (input: FetchSignedLookbackPricesInput) => Promise<SignedPricesResponse[] | null>;
 export declare const validateSignedPricesPairs: (pairs: number[]) => {
     valid: boolean;
     pairs: number[];
 };
+export declare const isValidSignedPricesChain: (chainId: number) => boolean;
+export declare const isValidSignedPricesOrderType: (orderType: PendingOrderType) => boolean;

package/lib/markets/price/signedPrices.js

@@ -1,21 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSignedPricesPairs = exports.isValidSignedPricesChain = exports.fetchSignedPrices = void 0;
+exports.isValidSignedPricesOrderType = exports.isValidSignedPricesChain = exports.validateSignedPricesPairs = exports.fetchSignedLookbackPrices = exports.fetchSignedPrices = void 0;
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
 const types_1 = require("../../contracts/types");
+const trade_1 = require("../../trade");
 const fetchSignedPrices = async (input) => {
-    const { minAnswers, timeoutMs, oracles, pairs, chainId, authKey } = {
-        minAnswers: input.chainId === types_1.ChainId.ARBITRUM_SEPOLIA ? 2 : 3,
+    const { minAnswers, timeoutMs, oracles, chain, authKey } = {
+        minAnswers: input.chain === 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 (!(0, exports.isValidSignedPricesChain)(chain))
+        throw new Error(`Invalid chain ${chain}`);
+    const { valid, pairs } = (0, exports.validateSignedPricesPairs)(input.pairs);
     if (!valid)
         throw new Error(`Invalid pairs array`);
+    return await initiateSignedPricesRequest(oracles, "signPrices", JSON.stringify({ pairs, chain }), minAnswers, authKey || "", timeoutMs);
+};
+exports.fetchSignedPrices = fetchSignedPrices;
+const fetchSignedLookbackPrices = async (input) => {
+    const { minAnswers, timeoutMs, oracles, trader, tradeIndex, pair, orderType, currentBlock, fromBlock, chain, authKey, } = {
+        minAnswers: input.chain === types_1.ChainId.ARBITRUM_SEPOLIA ? 2 : 3,
+        timeoutMs: 6000,
+        ...input,
+    };
+    if (!(0, exports.isValidSignedPricesChain)(chain))
+        throw new Error(`Invalid chain ${chain}`);
+    if (!(0, exports.isValidSignedPricesOrderType)(orderType))
+        throw new Error(`Invalid orderType ${orderType}`);
+    if (isNaN(pair))
+        throw new Error(`Invalid pair ${pair}`);
+    if (isNaN(tradeIndex) || tradeIndex < 0)
+        throw new Error(`Invalid tradeIndex ${tradeIndex}`);
+    if (!currentBlock || !fromBlock)
+        throw new Error(`Invalid block numbers`);
+    return await initiateSignedPricesRequest(oracles, "signLookbackPrices", JSON.stringify({
+        trader,
+        tradeIndex,
+        pair,
+        orderType,
+        currentBlock,
+        fromBlock,
+        chain,
+    }), minAnswers, authKey || "", timeoutMs);
+};
+exports.fetchSignedLookbackPrices = fetchSignedLookbackPrices;
+const initiateSignedPricesRequest = async (oracles, request, requestBody, minAnswers, authKey, timeoutMs) => {
     try {
         // Fetch signed prices from all oracles in parallel
-        const signedPrices = await Promise.allSettled(oracles.map(signerUrl => _getSignedPricesFromSigner(signerUrl, validPairs, chainId, authKey, timeoutMs)));
+        const signedPrices = await Promise.allSettled(oracles.map(signerUrl => _getSignedPricesFromSigner(`${signerUrl}/${request}`, requestBody, 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
         )
@@ -34,34 +67,41 @@ const fetchSignedPrices = async (input) => {
         throw e;
     }
 };
-exports.fetchSignedPrices = fetchSignedPrices;
-const _getSignedPricesFromSigner = async (signerUrl, pairIndices, chainId, authKey, timeoutMs) => {
+const _getSignedPricesFromSigner = async (url, requestBody, authKey, timeoutMs) => {
     try {
         const controller = new AbortController();
         const timeout = setTimeout(() => {
             controller.abort();
-        }, timeoutMs || 1000);
-        // @todo add retries
-        const response = await fetch(`${signerUrl}/signPrices`, {
+        }, timeoutMs || 2000);
+        const response = await fetch(`${url}`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
                 "x-api-key": authKey || "",
             },
-            body: JSON.stringify({ pairs: pairIndices, chain: chainId }),
+            body: requestBody,
             signal: controller.signal,
         });
         clearTimeout(timeout);
         if (!response.ok) {
-            throw new Error(`Failed to fetch signed prices from ${signerUrl}: ${response.statusText}`);
+            throw new Error(`Failed to fetch signed prices from ${url}: ${response.statusText}`);
         }
         return (await response.json());
     }
     catch (error) {
-        console.error(`Error fetching signed prices from ${signerUrl}`, error);
+        console.error(`Error fetching signed prices from ${url}:`, {
+            error: error?.message,
+        });
         return null;
     }
 };
+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;
 const isValidSignedPricesChain = (chainId) => {
     return (!isNaN(chainId) &&
         [
@@ -73,10 +113,14 @@ const isValidSignedPricesChain = (chainId) => {
         ].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) };
+const isValidSignedPricesOrderType = (orderType) => {
+    return (!isNaN(orderType) &&
+        [
+            trade_1.PendingOrderType.LIMIT_OPEN,
+            trade_1.PendingOrderType.STOP_OPEN,
+            trade_1.PendingOrderType.TP_CLOSE,
+            trade_1.PendingOrderType.SL_CLOSE,
+            trade_1.PendingOrderType.LIQ_CLOSE,
+        ].includes(orderType));
 };
-exports.validateSignedPricesPairs = validateSignedPricesPairs;
+exports.isValidSignedPricesOrderType = isValidSignedPricesOrderType;

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

@@ -21,3 +21,26 @@ export type MarketPriceContext = {
         oiShortToken: number;
     };
 };
+/**
+ * @dev Types for signed prices data structure
+ */
+export type SignedPricesResponse = {
+    signedData: SignedPrices;
+    missingPrices: number[];
+};
+export type SignedPrices = {
+    signerId: number;
+    expiryTs: number;
+    fromBlock: number;
+    isLookback: boolean;
+    pairIndices: number[];
+    prices: Price[];
+    signature: string;
+};
+export type Price = {
+    open: string;
+    high: string;
+    low: string;
+    current: string;
+    ts: number;
+};

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

@@ -13,9 +13,8 @@ exports.buildBorrowingV1Context = void 0;
  * @returns Full borrowing context with all pairs and groups or undefined if data not available
  */
 const buildBorrowingV1Context = (globalTradingVariables, collateralIndex, currentBlock) => {
-    var _a;
     const collateral = globalTradingVariables.collaterals[collateralIndex - 1];
-    if (!(collateral === null || collateral === void 0 ? void 0 : collateral.pairBorrowingFees) || !(collateral === null || collateral === void 0 ? void 0 : collateral.groupBorrowingFees)) {
+    if (!collateral?.pairBorrowingFees || !collateral?.groupBorrowingFees) {
         return undefined;
     }
     const pairs = collateral.pairBorrowingFees;
@@ -27,7 +26,7 @@ const buildBorrowingV1Context = (globalTradingVariables, collateralIndex, curren
         currentBlock,
         pairs,
         groups,
-        collateralPriceUsd: ((_a = collateral.prices) === null || _a === void 0 ? void 0 : _a.collateralPriceUsd) || 1,
+        collateralPriceUsd: collateral.prices?.collateralPriceUsd || 1,
         pairOis: collateral.pairOis,
     };
 };

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

@@ -14,7 +14,11 @@ const convertPairGroupBorrowingFee = (pairGroup) => ({
     block: pairGroup.block,
 });
 exports.convertPairGroupBorrowingFee = convertPairGroupBorrowingFee;
-const convertPairBorrowingFee = (pair, pairOi, pairGroup, feeCap) => (Object.assign(Object.assign({}, (0, exports.convertGroupBorrowingData)(pair, pairOi)), { groups: pairGroup.map(value => (0, exports.convertPairGroupBorrowingFee)(value)), feePerBlockCap: (0, exports.convertFeePerBlockCap)(feeCap) }));
+const convertPairBorrowingFee = (pair, pairOi, pairGroup, feeCap) => ({
+    ...(0, exports.convertGroupBorrowingData)(pair, pairOi),
+    groups: pairGroup.map(value => (0, exports.convertPairGroupBorrowingFee)(value)),
+    feePerBlockCap: (0, exports.convertFeePerBlockCap)(feeCap),
+});
 exports.convertPairBorrowingFee = convertPairBorrowingFee;
 const convertPairBorrowingFees = ([pairs, pairOi, pairGroups, feeCaps]) => pairs.map((value, ix) => (0, exports.convertPairBorrowingFee)(value, pairOi[ix], pairGroups[ix], feeCaps[ix]));
 exports.convertPairBorrowingFees = convertPairBorrowingFees;

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

@@ -48,7 +48,7 @@ const getBorrowingFee = (posDai, pairIndex, long, initialAccFees, currentPairPri
         return 0;
     }
     const pairGroups = pairs[pairIndex].groups;
-    const firstPairGroup = (pairGroups === null || pairGroups === void 0 ? void 0 : pairGroups.length) > 0 ? pairGroups[0] : undefined;
+    const firstPairGroup = pairGroups?.length > 0 ? pairGroups[0] : undefined;
     let fee = 0;
     if (!firstPairGroup || firstPairGroup.block > initialAccFees.block) {
         const openInterest = (0, __1.getPairTotalOisDynamicCollateral)(pairIndex, {
@@ -215,13 +215,13 @@ collateralPriceUsd) => {
 };
 const getPendingAccFeesDelta = (blockDistance, feePerBlock, netOi, maxOi, feeExponent) => {
     return maxOi > 0 && feeExponent > 0
-        ? feePerBlock * blockDistance * Math.pow((netOi / maxOi), feeExponent)
+        ? feePerBlock * blockDistance * (netOi / maxOi) ** feeExponent
         : 0;
 };
 const getFeePerBlockCaps = (cap) => {
     return {
-        minP: (cap === null || cap === void 0 ? void 0 : cap.minP) || 0,
-        maxP: (cap === null || cap === void 0 ? void 0 : cap.maxP) && cap.maxP > 0 ? cap.maxP : 1,
+        minP: cap?.minP || 0,
+        maxP: cap?.maxP && cap.maxP > 0 ? cap.maxP : 1,
     };
 };
 const getBorrowingDataActiveFeePerBlock = (val) => {
@@ -231,7 +231,7 @@ const getBorrowingDataActiveFeePerBlock = (val) => {
     // If minP > 0 then netOi has to be at least minP * maxOi
     // If maxP > 0 then netOi cannot be more than maxP * maxOi
     const effectiveOi = Math.min(Math.max(Math.abs(long - short), max * minP), max * maxP);
-    return val.feePerBlock * Math.pow((effectiveOi / max), val.feeExponent);
+    return val.feePerBlock * (effectiveOi / max) ** val.feeExponent;
 };
 const getActiveFeePerBlock = (pair, group) => {
     const pairFeePerBlock = getBorrowingDataActiveFeePerBlock(pair);

package/lib/trade/fees/borrowingV2/builder.js

@@ -5,13 +5,12 @@ exports.buildBorrowingV2Context = void 0;
  * @dev Builds borrowing v2 sub-context for a specific pair
  */
 const buildBorrowingV2Context = (globalTradingVariables, collateralIndex, pairIndex, currentTimestamp) => {
-    var _a, _b;
     const collateral = globalTradingVariables.collaterals[collateralIndex - 1];
-    if (!(collateral === null || collateral === void 0 ? void 0 : collateral.pairBorrowingFeesV2)) {
+    if (!collateral?.pairBorrowingFeesV2) {
         return undefined;
     }
-    const params = (_a = collateral.pairBorrowingFeesV2.params) === null || _a === void 0 ? void 0 : _a[pairIndex];
-    const data = (_b = collateral.pairBorrowingFeesV2.data) === null || _b === void 0 ? void 0 : _b[pairIndex];
+    const params = collateral.pairBorrowingFeesV2.params?.[pairIndex];
+    const data = collateral.pairBorrowingFeesV2.data?.[pairIndex];
     if (!params || !data) {
         return undefined;
     }

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

@@ -116,7 +116,7 @@ exports.aprToBorrowingRate = aprToBorrowingRate;
  */
 const createCollateralScopedBorrowingContext = (collateralBorrowingData, currentTimestamp) => {
     const context = {
-        currentTimestamp: currentTimestamp !== null && currentTimestamp !== void 0 ? currentTimestamp : Math.floor(Date.now() / 1000),
+        currentTimestamp: currentTimestamp ?? Math.floor(Date.now() / 1000),
         borrowingParams: {},
         borrowingData: {},
     };