@gainsnetwork/sdk 0.0.0-v10.rc1

package/lib/markets/stocks.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUSMarketsNow = exports.isStocksOpen = void 0;
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+// @ts-ignore-file
+const luxon_1 = require("luxon");
+const STOCKS_MARKETS_TIME_ZONE_IANA = luxon_1.IANAZone.create("America/New_York");
+const isStocksOpen = (dateToCheck) => {
+    const now = luxon_1.DateTime.fromJSDate(dateToCheck).setZone(STOCKS_MARKETS_TIME_ZONE_IANA);
+    const weekday = now.weekday;
+    const hour = now.hour;
+    const dayOfMonth = now.day;
+    const month = now.month;
+    const minute = now.minute;
+    const isClosed = 
+    // New Year's Day 2026
+    (month === 1 && dayOfMonth === 1) ||
+        // Martin Luther King, Jr. Day 2026
+        (month === 1 && dayOfMonth === 19) ||
+        // Presidents' Day 2026
+        (month === 2 && dayOfMonth === 16) ||
+        // Good Friday 2026
+        (month === 4 && dayOfMonth === 3) ||
+        // Memorial Day 2025
+        (month === 5 && dayOfMonth === 26) ||
+        // Juneteenth National Independence Day 2025
+        (month === 6 && dayOfMonth === 19) ||
+        // Independence Day 2025
+        (month === 7 && dayOfMonth === 4) ||
+        // Labor Day 2025
+        (month === 9 && dayOfMonth === 1) ||
+        // Thanksgiving Day 2025
+        (month === 11 && dayOfMonth === 27) ||
+        // Black Friday 2025 (closes early at 1PM)
+        (month === 11 && dayOfMonth === 28 && hour >= 13) ||
+        // Christmas Eve 2025 (closes early at 1PM)
+        (month === 12 && dayOfMonth === 24 && hour >= 13) ||
+        // Christmas Day 2025
+        (month === 12 && dayOfMonth === 25) ||
+        // Day before Independence Day 2025 (closes early at 1PM)
+        (month === 7 && dayOfMonth === 3 && hour >= 13) ||
+        // Saturday
+        weekday === 6 ||
+        // Sunday
+        weekday === 7 ||
+        // Mo-Fr Daily Opening
+        hour < 9 ||
+        (hour === 9 && minute < 30) ||
+        // Mo-Fr Daily Closing
+        hour >= 16;
+    return !isClosed;
+};
+exports.isStocksOpen = isStocksOpen;
+const getUSMarketsNow = () => {
+    return luxon_1.DateTime.now().setZone(STOCKS_MARKETS_TIME_ZONE_IANA);
+};
+exports.getUSMarketsNow = getUSMarketsNow;

package/lib/trade/fees/borrowing/converter.d.ts

@@ -0,0 +1,17 @@
+import { IBorrowingFees } from "../../../contracts/types/generated/GNSMultiCollatDiamond";
+import { BorrowingFee } from ".";
+export declare const convertPairGroupBorrowingFee: (pairGroup: IBorrowingFees.BorrowingPairGroupStructOutput) => BorrowingFee.PairGroup;
+export declare const convertPairBorrowingFee: (pair: IBorrowingFees.BorrowingDataStructOutput, pairOi: IBorrowingFees.OpenInterestStructOutput, pairGroup: IBorrowingFees.BorrowingPairGroupStructOutput[], feeCap: IBorrowingFees.BorrowingFeePerBlockCapStructOutput) => BorrowingFee.Pair;
+export declare const convertPairBorrowingFees: ([pairs, pairOi, pairGroups, feeCaps]: [
+    IBorrowingFees.BorrowingDataStructOutput[],
+    IBorrowingFees.OpenInterestStructOutput[],
+    IBorrowingFees.BorrowingPairGroupStructOutput[][],
+    IBorrowingFees.BorrowingFeePerBlockCapStructOutput[]
+]) => BorrowingFee.Pair[];
+export declare const convertGroupBorrowingFee: (group: IBorrowingFees.BorrowingDataStructOutput, groupOi: IBorrowingFees.OpenInterestStructOutput) => BorrowingFee.Group;
+export declare const convertGroupBorrowingData: (obj: IBorrowingFees.BorrowingDataStructOutput, oi: IBorrowingFees.OpenInterestStructOutput) => BorrowingFee.BorrowingData & BorrowingFee.BorrowingOi;
+export declare const convertGroupBorrowingFees: ([groups, groupOis]: [
+    IBorrowingFees.BorrowingDataStructOutput[],
+    IBorrowingFees.OpenInterestStructOutput[]
+]) => BorrowingFee.Group[];
+export declare const convertFeePerBlockCap: (feeCap: IBorrowingFees.BorrowingFeePerBlockCapStructOutput) => BorrowingFee.BorrowingFeePerBlockCap;

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFeePerBlockCap = exports.convertGroupBorrowingFees = exports.convertGroupBorrowingData = exports.convertGroupBorrowingFee = exports.convertPairBorrowingFees = exports.convertPairBorrowingFee = exports.convertPairGroupBorrowingFee = void 0;
+const borrowingFees_1 = require("../../../contracts/utils/borrowingFees");
+const convertPairGroupBorrowingFee = (pairGroup) => ({
+    groupIndex: pairGroup.groupIndex,
+    name: (0, borrowingFees_1.getBorrowingGroupName)(pairGroup.groupIndex),
+    initialAccFeeLong: parseFloat(pairGroup.initialAccFeeLong.toString()) / 1e10,
+    initialAccFeeShort: parseFloat(pairGroup.initialAccFeeShort.toString()) / 1e10,
+    prevGroupAccFeeLong: parseFloat(pairGroup.prevGroupAccFeeLong.toString()) / 1e10,
+    prevGroupAccFeeShort: parseFloat(pairGroup.prevGroupAccFeeShort.toString()) / 1e10,
+    pairAccFeeLong: parseFloat(pairGroup.pairAccFeeLong.toString()) / 1e10,
+    pairAccFeeShort: parseFloat(pairGroup.pairAccFeeShort.toString()) / 1e10,
+    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) }));
+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;
+const convertGroupBorrowingFee = (group, groupOi) => (0, exports.convertGroupBorrowingData)(group, groupOi);
+exports.convertGroupBorrowingFee = convertGroupBorrowingFee;
+const convertGroupBorrowingData = (obj, oi) => ({
+    oi: {
+        long: parseFloat(oi.long.toString()) / 1e10,
+        short: parseFloat(oi.short.toString()) / 1e10,
+        max: parseFloat(oi.max.toString()) / 1e10,
+    },
+    feePerBlock: obj.feePerBlock / 1e10,
+    accFeeLong: parseFloat(obj.accFeeLong.toString()) / 1e10,
+    accFeeShort: parseFloat(obj.accFeeShort.toString()) / 1e10,
+    accLastUpdatedBlock: obj.accLastUpdatedBlock,
+    feeExponent: obj.feeExponent,
+});
+exports.convertGroupBorrowingData = convertGroupBorrowingData;
+const convertGroupBorrowingFees = ([groups, groupOis]) => groups.map((value, ix) => (0, exports.convertGroupBorrowingFee)(value, groupOis[ix]));
+exports.convertGroupBorrowingFees = convertGroupBorrowingFees;
+const convertFeePerBlockCap = (feeCap) => ({
+    minP: feeCap.minP ? parseFloat(feeCap.minP.toString()) / 1e3 / 100 : 0,
+    maxP: feeCap.maxP ? parseFloat(feeCap.maxP.toString()) / 1e3 / 100 : 1,
+});
+exports.convertFeePerBlockCap = convertFeePerBlockCap;

package/lib/trade/fees/borrowing/index.d.ts

@@ -0,0 +1,58 @@
+import { OpenInterest, PairIndex } from "../../types";
+import * as BorrowingFee from "./types";
+export type GetBorrowingFeeContext = {
+    currentBlock: number;
+    groups: BorrowingFee.Group[];
+    pairs: BorrowingFee.Pair[];
+};
+export declare const getBorrowingFee: (posDai: number, pairIndex: PairIndex, long: boolean, initialAccFees: BorrowingFee.InitialAccFees, context: GetBorrowingFeeContext) => number;
+export declare const withinMaxGroupOi: (pairIndex: PairIndex, long: boolean, positionSizeCollateral: number, context: {
+    groups: BorrowingFee.Group[];
+    pairs: BorrowingFee.Pair[];
+}) => boolean;
+export declare const borrowingFeeUtils: {
+    getPairGroupAccFeesDeltas: (i: number, pairGroups: BorrowingFee.PairGroup[], initialFees: BorrowingFee.InitialAccFees, pairIndex: PairIndex, long: boolean, context: GetBorrowingFeeContext) => {
+        deltaGroup: number;
+        deltaPair: number;
+        beforeTradeOpen: boolean;
+    };
+    getPairPendingAccFees: (pairIndex: PairIndex, currentBlock: number, context: {
+        pairs: BorrowingFee.Pair[];
+        openInterest: OpenInterest;
+    }) => {
+        accFeeLong: number;
+        accFeeShort: number;
+        deltaLong: number;
+        deltaShort: number;
+    };
+    getPairPendingAccFee: (pairIndex: PairIndex, currentBlock: number, long: boolean, context: {
+        pairs: BorrowingFee.Pair[];
+        openInterest: OpenInterest;
+    }) => number;
+    getGroupPendingAccFees: (groupIndex: number, currentBlock: number, context: {
+        groups: BorrowingFee.Group[];
+    }) => {
+        accFeeLong: number;
+        accFeeShort: number;
+        deltaLong: number;
+        deltaShort: number;
+    };
+    getGroupPendingAccFee: (groupIndex: number, currentBlock: number, long: boolean, context: {
+        groups: BorrowingFee.Group[];
+    }) => number;
+    getPendingAccFees: (accFeeLong: number, accFeeShort: number, oiLong: number, oiShort: number, feePerBlock: number, currentBlock: number, accLastUpdatedBlock: number, maxOi: number, feeExponent: number, feeCaps?: BorrowingFee.BorrowingFeePerBlockCap) => {
+        accFeeLong: number;
+        accFeeShort: number;
+        deltaLong: number;
+        deltaShort: number;
+    };
+    getActiveFeePerBlock: (pair: BorrowingFee.Pair, group: BorrowingFee.Group | undefined) => number;
+    getBorrowingDataActiveFeePerBlock: (val: BorrowingFee.Pair | BorrowingFee.Group) => number;
+    getPairGroupIndex: (pairIndex: PairIndex, context: {
+        pairs: BorrowingFee.Pair[];
+    }) => number;
+    getPendingAccFeesDelta: (blockDistance: number, feePerBlock: number, netOi: number, maxOi: number, feeExponent: number) => number;
+    getFeePerBlockCaps: (cap?: BorrowingFee.BorrowingFeePerBlockCap) => BorrowingFee.BorrowingFeePerBlockCap;
+};
+export * as BorrowingFee from "./types";
+export * from "./converter";

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

@@ -0,0 +1,209 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 });
+exports.BorrowingFee = exports.borrowingFeeUtils = exports.withinMaxGroupOi = exports.getBorrowingFee = void 0;
+const getBorrowingFee = (posDai, pairIndex, long, initialAccFees, context) => {
+    if (!context.groups || !context.pairs || !context.pairs[pairIndex]) {
+        return 0;
+    }
+    const { pairs } = context;
+    const pairGroups = pairs[pairIndex].groups;
+    const firstPairGroup = (pairGroups === null || pairGroups === void 0 ? void 0 : pairGroups.length) > 0 ? pairGroups[0] : undefined;
+    let fee = 0;
+    if (!firstPairGroup || firstPairGroup.block > initialAccFees.block) {
+        const openInterest = pairs[pairIndex].oi;
+        fee =
+            (!firstPairGroup
+                ? getPairPendingAccFee(pairIndex, context.currentBlock, long, {
+                    pairs,
+                    openInterest,
+                })
+                : long
+                    ? firstPairGroup.pairAccFeeLong
+                    : firstPairGroup.pairAccFeeShort) - initialAccFees.accPairFee;
+    }
+    for (let i = pairGroups.length; i > 0; i--) {
+        const { deltaGroup, deltaPair, beforeTradeOpen } = getPairGroupAccFeesDeltas(i - 1, pairGroups, initialAccFees, pairIndex, long, context);
+        fee += Math.max(deltaGroup, deltaPair);
+        if (beforeTradeOpen) {
+            break;
+        }
+    }
+    return (posDai * fee) / 100;
+};
+exports.getBorrowingFee = getBorrowingFee;
+const withinMaxGroupOi = (pairIndex, long, positionSizeCollateral, context) => {
+    const { groups, pairs } = context;
+    if (!groups || !pairs) {
+        return false;
+    }
+    const g = groups[getPairGroupIndex(pairIndex, { pairs })].oi;
+    return (g.max == 0 || (long ? g.long : g.short) + positionSizeCollateral <= g.max);
+};
+exports.withinMaxGroupOi = withinMaxGroupOi;
+const getPairGroupIndex = (pairIndex, context) => {
+    const { pairs } = context;
+    if (!pairs[pairIndex]) {
+        return 0;
+    }
+    const pairGroups = pairs[pairIndex].groups;
+    return pairGroups.length == 0 ? 0 : pairGroups[0].groupIndex;
+};
+const getPairPendingAccFees = (pairIndex, currentBlock, context) => {
+    const { pairs, openInterest: { long, short }, } = context;
+    const pair = pairs[pairIndex];
+    return getPendingAccFees(pair.accFeeLong, pair.accFeeShort, long, short, pair.feePerBlock, currentBlock, pair.accLastUpdatedBlock, pair.oi.max, pair.feeExponent, pair.feePerBlockCap);
+};
+const getPairPendingAccFee = (pairIndex, currentBlock, long, context) => {
+    const { accFeeLong, accFeeShort } = getPairPendingAccFees(pairIndex, currentBlock, context);
+    return long ? accFeeLong : accFeeShort;
+};
+const getGroupPendingAccFees = (groupIndex, currentBlock, context) => {
+    const { groups } = context;
+    const group = groups[groupIndex];
+    return getPendingAccFees(group.accFeeLong, group.accFeeShort, group.oi.long, group.oi.short, group.feePerBlock, currentBlock, group.accLastUpdatedBlock, group.oi.max, group.feeExponent);
+};
+const getGroupPendingAccFee = (groupIndex, currentBlock, long, context) => {
+    const { accFeeLong, accFeeShort } = getGroupPendingAccFees(groupIndex, currentBlock, context);
+    return long ? accFeeLong : accFeeShort;
+};
+const getPairGroupAccFeesDeltas = (i, pairGroups, initialFees, pairIndex, long, context) => {
+    const group = pairGroups[i];
+    const beforeTradeOpen = group.block < initialFees.block;
+    let deltaGroup, deltaPair;
+    if (i == pairGroups.length - 1) {
+        const { currentBlock, groups, pairs } = context;
+        const openInterest = pairs[pairIndex].oi;
+        deltaGroup = getGroupPendingAccFee(group.groupIndex, currentBlock, long, {
+            groups,
+        });
+        deltaPair = getPairPendingAccFee(pairIndex, currentBlock, long, {
+            pairs,
+            openInterest,
+        });
+    }
+    else {
+        const nextGroup = pairGroups[i + 1];
+        if (beforeTradeOpen && nextGroup.block <= initialFees.block) {
+            return { deltaGroup: 0, deltaPair: 0, beforeTradeOpen };
+        }
+        deltaGroup = long
+            ? nextGroup.prevGroupAccFeeLong
+            : nextGroup.prevGroupAccFeeShort;
+        deltaPair = long ? nextGroup.pairAccFeeLong : nextGroup.pairAccFeeShort;
+    }
+    if (beforeTradeOpen) {
+        deltaGroup -= initialFees.accGroupFee;
+        deltaPair -= initialFees.accPairFee;
+    }
+    else {
+        deltaGroup -= long ? group.initialAccFeeLong : group.initialAccFeeShort;
+        deltaPair -= long ? group.pairAccFeeLong : group.pairAccFeeShort;
+    }
+    return { deltaGroup, deltaPair, beforeTradeOpen };
+};
+const getPendingAccFees = (accFeeLong, accFeeShort, oiLong, oiShort, feePerBlock, currentBlock, accLastUpdatedBlock, maxOi, feeExponent, feeCaps // as percentage: eg minP: 0.1 = 10%, maxP: 0.5 = 50%
+) => {
+    const moreShorts = oiLong < oiShort;
+    const blockDistance = currentBlock > accLastUpdatedBlock ? currentBlock - accLastUpdatedBlock : 0;
+    // If block distance is zero nothing changes
+    if (blockDistance === 0) {
+        return {
+            accFeeLong,
+            accFeeShort,
+            deltaLong: 0,
+            deltaShort: 0,
+        };
+    }
+    const netOi = Math.abs(oiLong - oiShort);
+    // Calculate minimum and maximum effective oi
+    const { minP, maxP } = getFeePerBlockCaps(feeCaps);
+    const minNetOi = maxOi * minP;
+    const maxNetOi = maxOi * maxP;
+    // Calculate the minimum acc fee delta (applies to both sides)
+    const minDelta = minNetOi > 0
+        ? getPendingAccFeesDelta(blockDistance, feePerBlock, netOi, maxOi, feeExponent)
+        : 0;
+    // Calculate the actual acc fee (using capped oi of 100% or less)
+    const delta = netOi > minNetOi
+        ? getPendingAccFeesDelta(blockDistance, feePerBlock, Math.min(netOi, maxNetOi), // if netOi > cap, use cap
+        maxOi, feeExponent)
+        : minDelta;
+    const [deltaLong, deltaShort] = moreShorts
+        ? [minDelta, delta]
+        : [delta, minDelta];
+    return {
+        accFeeLong: accFeeLong + deltaLong,
+        accFeeShort: accFeeShort + deltaShort,
+        deltaLong,
+        deltaShort,
+    };
+};
+const getPendingAccFeesDelta = (blockDistance, feePerBlock, netOi, maxOi, feeExponent) => {
+    return maxOi > 0 && feeExponent > 0
+        ? feePerBlock * blockDistance * Math.pow((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,
+    };
+};
+const getBorrowingDataActiveFeePerBlock = (val) => {
+    const { long, short, max } = val.oi;
+    const { minP, maxP } = getFeePerBlockCaps("feePerBlockCap" in val ? val.feePerBlockCap : undefined);
+    // Calculate the effective open interest
+    // 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);
+};
+const getActiveFeePerBlock = (pair, group) => {
+    const pairFeePerBlock = getBorrowingDataActiveFeePerBlock(pair);
+    if (!group) {
+        return pairFeePerBlock;
+    }
+    const groupFeePerBlock = getBorrowingDataActiveFeePerBlock(group);
+    return Math.max(pairFeePerBlock, groupFeePerBlock);
+};
+exports.borrowingFeeUtils = {
+    getPairGroupAccFeesDeltas,
+    getPairPendingAccFees,
+    getPairPendingAccFee,
+    getGroupPendingAccFees,
+    getGroupPendingAccFee,
+    getPendingAccFees,
+    getActiveFeePerBlock,
+    getBorrowingDataActiveFeePerBlock,
+    getPairGroupIndex,
+    getPendingAccFeesDelta,
+    getFeePerBlockCaps,
+};
+exports.BorrowingFee = __importStar(require("./types"));
+__exportStar(require("./converter"), exports);

package/lib/trade/fees/borrowing/types.d.ts

@@ -0,0 +1,36 @@
+import { OpenInterest } from "../../types";
+export type BorrowingData = {
+    feePerBlock: number;
+    accFeeLong: number;
+    accFeeShort: number;
+    accLastUpdatedBlock: number;
+    feeExponent: number;
+};
+export type PairGroup = {
+    groupIndex: number;
+    name?: string;
+    block: number;
+    initialAccFeeLong: number;
+    initialAccFeeShort: number;
+    prevGroupAccFeeLong: number;
+    prevGroupAccFeeShort: number;
+    pairAccFeeLong: number;
+    pairAccFeeShort: number;
+};
+export type BorrowingOi = {
+    oi: OpenInterest;
+};
+export type BorrowingFeePerBlockCap = {
+    minP: number;
+    maxP: number;
+};
+export type Pair = BorrowingData & BorrowingOi & {
+    groups: PairGroup[];
+    feePerBlockCap?: BorrowingFeePerBlockCap;
+};
+export type Group = BorrowingData & BorrowingOi;
+export type InitialAccFees = {
+    accPairFee: number;
+    accGroupFee: number;
+    block: number;
+};

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

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

package/lib/trade/fees/index.d.ts

@@ -0,0 +1,4 @@
+import { Fee, PairIndex } from "../types";
+export declare const getClosingFee: (posDai: number, leverage: number, pairIndex: PairIndex, pairFee: Fee | undefined, collateralPriceUsd?: number | undefined, feeMultiplier?: number | undefined) => number;
+export * from "./borrowing";
+export * from "./tiers";

package/lib/trade/fees/index.js

@@ -0,0 +1,34 @@
+"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 });
+exports.getClosingFee = void 0;
+const getClosingFee = (posDai, leverage, pairIndex, pairFee, collateralPriceUsd = 0, feeMultiplier = 1) => {
+    if (posDai === undefined ||
+        leverage === undefined ||
+        pairIndex === undefined ||
+        pairFee === undefined) {
+        return 0;
+    }
+    const { totalPositionSizeFeeP, minPositionSizeUsd } = pairFee;
+    return (totalPositionSizeFeeP *
+        feeMultiplier *
+        Math.max(collateralPriceUsd && collateralPriceUsd > 0
+            ? minPositionSizeUsd / collateralPriceUsd
+            : 0, posDai * leverage));
+};
+exports.getClosingFee = getClosingFee;
+__exportStar(require("./borrowing"), exports);
+__exportStar(require("./tiers"), exports);

package/lib/trade/fees/tiers/index.d.ts

@@ -0,0 +1,12 @@
+import { FeeTiers, TraderFeeTiers } from "../../types";
+import { FeeTier } from "./types";
+export declare const TRAILING_PERIOD_DAYS = 30;
+export declare const FEE_MULTIPLIER_SCALE = 1;
+export declare const MAX_FEE_TIERS = 8;
+export declare const getCurrentDay: () => number;
+export declare const getFeeTiersCount: (feeTiers: FeeTier[]) => number;
+export declare const getFeeMultiplier: (trailingPoints: number, tiers: FeeTier[]) => number;
+export declare const computeFeeMultiplier: (feeTiers: FeeTiers, traderFeeTiers: TraderFeeTiers) => {
+    feeMultiplier: number;
+    trailingPoints: number;
+};

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeFeeMultiplier = exports.getFeeMultiplier = exports.getFeeTiersCount = exports.getCurrentDay = exports.MAX_FEE_TIERS = exports.FEE_MULTIPLIER_SCALE = exports.TRAILING_PERIOD_DAYS = void 0;
+const types_1 = require("./types");
+exports.TRAILING_PERIOD_DAYS = 30;
+exports.FEE_MULTIPLIER_SCALE = 1;
+exports.MAX_FEE_TIERS = 8;
+const getCurrentDay = () => Math.floor(Date.now() / 1000 / 60 / 60 / 24);
+exports.getCurrentDay = getCurrentDay;
+const getFeeTiersCount = (feeTiers) => {
+    var _a;
+    for (let i = exports.MAX_FEE_TIERS; i > 0; --i) {
+        if (((_a = feeTiers[i - 1]) === null || _a === void 0 ? void 0 : _a.feeMultiplier) > 0) {
+            return i;
+        }
+    }
+    return 0;
+};
+exports.getFeeTiersCount = getFeeTiersCount;
+const getFeeMultiplier = (trailingPoints, tiers) => {
+    let feeMultiplier = exports.FEE_MULTIPLIER_SCALE;
+    for (let i = (0, exports.getFeeTiersCount)(tiers); i > 0; --i) {
+        const feeTier = tiers[i - 1];
+        if (trailingPoints >= feeTier.pointsThreshold) {
+            feeMultiplier = feeTier.feeMultiplier;
+            break;
+        }
+    }
+    return feeMultiplier;
+};
+exports.getFeeMultiplier = getFeeMultiplier;
+const computeFeeMultiplier = (feeTiers, traderFeeTiers) => {
+    const { currentDay, tiers } = feeTiers;
+    const { traderInfo, expiredPoints, lastDayUpdatedPoints, traderEnrollment } = traderFeeTiers;
+    const { lastDayUpdated, trailingPoints } = traderInfo;
+    let curTrailingPoints = trailingPoints;
+    if (currentDay > lastDayUpdated) {
+        curTrailingPoints = 0;
+        const earliestActiveDay = currentDay - exports.TRAILING_PERIOD_DAYS;
+        if (lastDayUpdated >= earliestActiveDay) {
+            curTrailingPoints = trailingPoints + lastDayUpdatedPoints;
+            const expiredTrailingPoints = expiredPoints.reduce((acc, points) => acc + points, 0);
+            curTrailingPoints -= expiredTrailingPoints;
+        }
+    }
+    const feeMultiplier = traderEnrollment.status === types_1.TraderEnrollmentStatus.EXCLUDED
+        ? exports.FEE_MULTIPLIER_SCALE
+        : (0, exports.getFeeMultiplier)(curTrailingPoints, tiers);
+    return {
+        feeMultiplier,
+        trailingPoints: curTrailingPoints,
+    };
+};
+exports.computeFeeMultiplier = computeFeeMultiplier;

package/lib/trade/fees/tiers/types.d.ts

@@ -0,0 +1,15 @@
+export type FeeTier = {
+    feeMultiplier: number;
+    pointsThreshold: number;
+};
+export type TraderInfo = {
+    lastDayUpdated: number;
+    trailingPoints: number;
+};
+export declare enum TraderEnrollmentStatus {
+    ENROLLED = 0,
+    EXCLUDED = 1
+}
+export type TraderEnrollment = {
+    status: TraderEnrollmentStatus;
+};

package/lib/trade/fees/tiers/types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraderEnrollmentStatus = void 0;
+var TraderEnrollmentStatus;
+(function (TraderEnrollmentStatus) {
+    TraderEnrollmentStatus[TraderEnrollmentStatus["ENROLLED"] = 0] = "ENROLLED";
+    TraderEnrollmentStatus[TraderEnrollmentStatus["EXCLUDED"] = 1] = "EXCLUDED";
+})(TraderEnrollmentStatus = exports.TraderEnrollmentStatus || (exports.TraderEnrollmentStatus = {}));

package/lib/trade/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./fees";
+export * from "./pnl";
+export * from "./spread";
+export * from "./liquidation";
+export * from "./fees";
+export * from "./types";
+export * from "./oiWindows";

package/lib/trade/index.js

@@ -0,0 +1,23 @@
+"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("./fees"), exports);
+__exportStar(require("./pnl"), exports);
+__exportStar(require("./spread"), exports);
+__exportStar(require("./liquidation"), exports);
+__exportStar(require("./fees"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./oiWindows"), exports);

package/lib/trade/liquidation.d.ts

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