@gearbox-protocol/sdk 15.0.0-next.2 → 15.0.0-pyth.1

package/dist/cjs/common-utils/utils/strategies/leverage/get-collateral-by-debt.spec.js

@@ -0,0 +1,30 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_math = require("../../../../sdk/constants/math.js");
+var import_formatter = require("../../../../sdk/utils/formatter.js");
+var import_get_collateral_by_debt = require("./get-collateral-by-debt.js");
+(0, import_vitest.describe)("getCollateralByDebt", () => {
+  (0, import_vitest.it)("returns full debt when target HF equals 1 and LT is 0.5", () => {
+    const debt = 1000000n;
+    const lt = (0, import_formatter.toBN)("0.5", 4);
+    const result = (0, import_get_collateral_by_debt.getCollateralByDebt)(debt, lt);
+    (0, import_vitest.expect)(result).toBe(debt);
+  });
+  (0, import_vitest.it)("returns 0 when lt = hf", () => {
+    const debt = 1000000n;
+    const result = (0, import_get_collateral_by_debt.getCollateralByDebt)(debt, import_math.PERCENTAGE_FACTOR);
+    (0, import_vitest.expect)(result).toBe(0n);
+  });
+  (0, import_vitest.it)("returns when lt = 0", () => {
+    const debt = 1000000n;
+    const result = (0, import_get_collateral_by_debt.getCollateralByDebt)(debt, 0n);
+    (0, import_vitest.expect)(result).toBe(0n);
+  });
+  (0, import_vitest.it)("handles fractional LT and target HF values", () => {
+    const debt = 35n * import_math.WAD / 2n;
+    const lt = (0, import_formatter.toBN)("0.93", 4);
+    const targetHF = (0, import_formatter.toBN)("1.035", 4);
+    const result = (0, import_get_collateral_by_debt.getCollateralByDebt)(debt, lt, targetHF);
+    (0, import_vitest.expect)(result).toBe(1975806451612903225n);
+  });
+});

package/dist/cjs/common-utils/utils/strategies/leverage/get-factor-from-leverage.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_factor_from_leverage_exports = {};
+__export(get_factor_from_leverage_exports, {
+  getFactorFromLeverage: () => getFactorFromLeverage
+});
+module.exports = __toCommonJS(get_factor_from_leverage_exports);
+var import_sdk = require("../../../../sdk/index.js");
+function getFactorFromLeverage(leverage) {
+  return leverage - import_sdk.LEVERAGE_DECIMALS;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFactorFromLeverage
+});

package/dist/cjs/common-utils/utils/strategies/leverage/get-leverage-from-factor.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_leverage_from_factor_exports = {};
+__export(get_leverage_from_factor_exports, {
+  getLeverageFromFactor: () => getLeverageFromFactor
+});
+module.exports = __toCommonJS(get_leverage_from_factor_exports);
+var import_sdk = require("../../../../sdk/index.js");
+function getLeverageFromFactor(factor) {
+  return factor + import_sdk.LEVERAGE_DECIMALS;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLeverageFromFactor
+});

package/dist/cjs/common-utils/utils/strategies/leverage/get-recommended-debt.js

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_recommended_debt_exports = {};
+__export(get_recommended_debt_exports, {
+  getRecommendedDebt: () => getRecommendedDebt
+});
+module.exports = __toCommonJS(get_recommended_debt_exports);
+var import_math = require("../../../../sdk/constants/math.js");
+var import_calculate_max_leverage_factor = require("./calculate-max-leverage-factor.js");
+var import_calculate_max_strategy_debt = require("./calculate-max-strategy-debt.js");
+var import_get_recommended_leverage_factor = require("./get-recommended-leverage-factor.js");
+function getRecommendedDebt({
+  targetToken,
+  amount,
+  creditManager,
+  slippage,
+  maxLeverageConstantLoss,
+  maxDebtConstantLoss,
+  recommendedDebtConstantLoss = 3400n,
+  swapCollateral,
+  leverageLimit
+}) {
+  const maxDebt = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+    targetToken,
+    amount,
+    creditManager,
+    slippage,
+    constantLoss: maxDebtConstantLoss,
+    swapCollateral
+  });
+  const recommendedLeverageFactor = (0, import_get_recommended_leverage_factor.getRecommendedLeverageFactor)({
+    maxLeverageFactor: (0, import_calculate_max_leverage_factor.calculateMaxLeverageFactor)({
+      targetToken,
+      creditManagers: [creditManager],
+      slippage,
+      leverageLimit,
+      constantLoss: maxLeverageConstantLoss
+    })
+  });
+  if (maxDebt === 0n || amount === 0n) {
+    return {
+      maxDebt,
+      recommended: {
+        factor: recommendedLeverageFactor,
+        debt: maxDebt
+      }
+    };
+  }
+  const recommendedMaxDebt = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+    targetToken,
+    amount,
+    creditManager,
+    slippage,
+    constantLoss: recommendedDebtConstantLoss,
+    swapCollateral
+  });
+  const leverageFactorOfMaxDebt = recommendedMaxDebt * import_math.LEVERAGE_DECIMALS / amount;
+  return {
+    maxDebt,
+    recommended: {
+      factor: leverageFactorOfMaxDebt,
+      debt: recommendedMaxDebt
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRecommendedDebt
+});

package/dist/cjs/common-utils/utils/strategies/leverage/get-recommended-debt.spec.js

@@ -0,0 +1,227 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_math = require("../../../../sdk/constants/math.js");
+var import_test_utils = require("../../../test-utils/index.js");
+var import_calculate_max_leverage_factor = require("./calculate-max-leverage-factor.js");
+var import_calculate_max_strategy_debt = require("./calculate-max-strategy-debt.js");
+var import_get_recommended_debt = require("./get-recommended-debt.js");
+import_vitest.vi.mock("./calculate-max-strategy-debt");
+import_vitest.vi.mock(
+  "../../utils/strategies/leverage/calculate-max-leverage-factor.js",
+  async () => {
+    const actual = await import_vitest.vi.importActual(
+      "../../utils/strategies/leverage/calculate-max-leverage-factor.js"
+    );
+    return {
+      ...actual,
+      calculateMaxLeverageFactor: import_vitest.vi.fn(
+        actual.calculateMaxLeverageFactor
+      )
+    };
+  }
+);
+const mockCalculateMaxStrategyDebt = import_vitest.vi.mocked(import_calculate_max_strategy_debt.calculateMaxStrategyDebt);
+const mockCalculateMaxLeverageFactor = import_vitest.vi.mocked(import_calculate_max_leverage_factor.calculateMaxLeverageFactor);
+(0, import_vitest.describe)("getRecommendedDebt", () => {
+  const mockCreditManager = (0, import_test_utils.buildCreditManager)({});
+  (0, import_vitest.beforeEach)(() => {
+    mockCalculateMaxStrategyDebt.mockReset();
+    mockCalculateMaxLeverageFactor.mockReset();
+  });
+  (0, import_vitest.it)("returns zero max debt with recommended factor when maxDebt is zero", () => {
+    const maxDebt = 0n;
+    mockCalculateMaxStrategyDebt.mockReturnValue(maxDebt);
+    mockCalculateMaxLeverageFactor.mockReturnValue(300n);
+    const result = (0, import_get_recommended_debt.getRecommendedDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount: 1000n,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      maxDebtConstantLoss: 30n,
+      swapCollateral: true,
+      leverageLimit: void 0
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenCalledWith({
+      targetToken: import_test_utils.mockToken1,
+      amount: 1000n,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      constantLoss: 30n,
+      swapCollateral: true
+    });
+    (0, import_vitest.expect)(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
+      targetToken: import_test_utils.mockToken1,
+      creditManagers: [mockCreditManager],
+      slippage: 100,
+      leverageLimit: void 0
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      maxDebt,
+      recommended: {
+        factor: 210n,
+        debt: maxDebt
+      }
+    });
+  });
+  (0, import_vitest.it)("returns zero max debt with recommended factor when amount is zero", () => {
+    const maxDebt = 500n;
+    mockCalculateMaxStrategyDebt.mockReturnValue(maxDebt);
+    mockCalculateMaxLeverageFactor.mockReturnValue(300n);
+    const result = (0, import_get_recommended_debt.getRecommendedDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount: 0n,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      maxDebtConstantLoss: 30n,
+      swapCollateral: true,
+      leverageLimit: void 0
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenCalledWith({
+      targetToken: import_test_utils.mockToken1,
+      amount: 0n,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      constantLoss: 30n,
+      swapCollateral: true
+    });
+    (0, import_vitest.expect)(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
+      targetToken: import_test_utils.mockToken1,
+      creditManagers: [mockCreditManager],
+      slippage: 100,
+      leverageLimit: void 0
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      maxDebt,
+      recommended: {
+        factor: 210n,
+        debt: maxDebt
+      }
+    });
+  });
+  (0, import_vitest.it)("returns recommended debt using adjusted constant loss when amount and maxDebt are positive", () => {
+    const maxDebt = 5000n;
+    const recommendedMaxDebt = 3500n;
+    const amount = 1000n;
+    const leverageLimit = Number(4n * import_math.LEVERAGE_DECIMALS);
+    mockCalculateMaxStrategyDebt.mockReturnValueOnce(maxDebt).mockReturnValueOnce(recommendedMaxDebt);
+    mockCalculateMaxLeverageFactor.mockReturnValue(450n);
+    const result = (0, import_get_recommended_debt.getRecommendedDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 50,
+      maxDebtConstantLoss: 75n,
+      swapCollateral: false,
+      leverageLimit
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(1, {
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 50,
+      constantLoss: 75n,
+      swapCollateral: false
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(2, {
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 50,
+      constantLoss: 3400n,
+      swapCollateral: false
+    });
+    (0, import_vitest.expect)(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
+      targetToken: import_test_utils.mockToken1,
+      creditManagers: [mockCreditManager],
+      slippage: 50,
+      leverageLimit
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      maxDebt,
+      recommended: {
+        factor: recommendedMaxDebt * import_math.LEVERAGE_DECIMALS / amount,
+        debt: recommendedMaxDebt
+      }
+    });
+  });
+  (0, import_vitest.it)("passes maxLeverageConstantLoss through to leverage calculation", () => {
+    const maxDebt = 2000n;
+    const recommendedMaxDebt = 1000n;
+    const amount = 500n;
+    const maxLeverageConstantLoss = 999n;
+    const maxDebtConstantLoss = 55n;
+    const recommendedDebtConstantLoss = 777n;
+    mockCalculateMaxStrategyDebt.mockReturnValueOnce(maxDebt).mockReturnValueOnce(recommendedMaxDebt);
+    mockCalculateMaxLeverageFactor.mockReturnValue(420n);
+    const result = (0, import_get_recommended_debt.getRecommendedDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 25,
+      maxLeverageConstantLoss,
+      maxDebtConstantLoss,
+      recommendedDebtConstantLoss,
+      swapCollateral: true,
+      leverageLimit: 123
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(1, {
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 25,
+      constantLoss: maxDebtConstantLoss,
+      swapCollateral: true
+    });
+    (0, import_vitest.expect)(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
+      targetToken: import_test_utils.mockToken1,
+      creditManagers: [mockCreditManager],
+      slippage: 25,
+      leverageLimit: 123,
+      constantLoss: maxLeverageConstantLoss
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(2, {
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 25,
+      constantLoss: recommendedDebtConstantLoss,
+      swapCollateral: true
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      maxDebt,
+      recommended: {
+        factor: 200n,
+        debt: recommendedMaxDebt
+      }
+    });
+  });
+  (0, import_vitest.it)("uses custom recommendedDebtConstantLoss when provided", () => {
+    const maxDebt = 10000n;
+    const recommendedMaxDebt = 6000n;
+    const amount = 2000n;
+    const recommendedDebtConstantLoss = 1234n;
+    mockCalculateMaxStrategyDebt.mockReturnValueOnce(maxDebt).mockReturnValueOnce(recommendedMaxDebt);
+    mockCalculateMaxLeverageFactor.mockReturnValue(800n);
+    const result = (0, import_get_recommended_debt.getRecommendedDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 15,
+      maxDebtConstantLoss: 60n,
+      maxLeverageConstantLoss: 70n,
+      recommendedDebtConstantLoss,
+      swapCollateral: false,
+      leverageLimit: void 0
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(2, {
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 15,
+      constantLoss: recommendedDebtConstantLoss,
+      swapCollateral: false
+    });
+    (0, import_vitest.expect)(result.recommended.debt).toBe(recommendedMaxDebt);
+    (0, import_vitest.expect)(result.recommended.factor).toBe(300n);
+  });
+});

package/dist/cjs/common-utils/utils/strategies/leverage/get-recommended-leverage-factor.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_recommended_leverage_factor_exports = {};
+__export(get_recommended_leverage_factor_exports, {
+  getRecommendedLeverageFactor: () => getRecommendedLeverageFactor
+});
+module.exports = __toCommonJS(get_recommended_leverage_factor_exports);
+function getRecommendedLeverageFactor({
+  maxLeverageFactor
+}) {
+  const l = BigInt(Math.floor(Number(maxLeverageFactor) * 0.7 / 10)) * 10n;
+  return l;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRecommendedLeverageFactor
+});

package/dist/cjs/common-utils/utils/strategies/leverage/get-recommended-leverage-factor.spec.js

@@ -0,0 +1,23 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_get_recommended_leverage_factor = require("./get-recommended-leverage-factor.js");
+(0, import_vitest.describe)("getRecommendedLeverageFactor", () => {
+  (0, import_vitest.it)("returns zero when max factor is zero", () => {
+    const factor = (0, import_get_recommended_leverage_factor.getRecommendedLeverageFactor)({
+      maxLeverageFactor: 0n
+    });
+    (0, import_vitest.expect)(factor).toBe(0n);
+  });
+  (0, import_vitest.it)("returns 70% of max rounded down to tens", () => {
+    const factor = (0, import_get_recommended_leverage_factor.getRecommendedLeverageFactor)({
+      maxLeverageFactor: 550n
+    });
+    (0, import_vitest.expect)(factor).toBe(380n);
+  });
+  (0, import_vitest.it)("rounds down fractional 70% results to nearest ten", () => {
+    const factor = (0, import_get_recommended_leverage_factor.getRecommendedLeverageFactor)({
+      maxLeverageFactor: 503n
+    });
+    (0, import_vitest.expect)(factor).toBe(350n);
+  });
+});

package/dist/cjs/common-utils/utils/strategies/leverage/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var leverage_exports = {};
+module.exports = __toCommonJS(leverage_exports);
+__reExport(leverage_exports, require("./calculate-loss-coefficient.js"), module.exports);
+__reExport(leverage_exports, require("./calculate-max-leverage-factor.js"), module.exports);
+__reExport(leverage_exports, require("./calculate-max-strategy-debt.js"), module.exports);
+__reExport(leverage_exports, require("./get-collateral-by-debt.js"), module.exports);
+__reExport(leverage_exports, require("./get-factor-from-leverage.js"), module.exports);
+__reExport(leverage_exports, require("./get-leverage-from-factor.js"), module.exports);
+__reExport(leverage_exports, require("./get-recommended-debt.js"), module.exports);
+__reExport(leverage_exports, require("./get-recommended-leverage-factor.js"), module.exports);
+__reExport(leverage_exports, require("./max-leverage.js"), module.exports);
+__reExport(leverage_exports, require("./max-leverage-threshold.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./calculate-loss-coefficient.js"),
+  ...require("./calculate-max-leverage-factor.js"),
+  ...require("./calculate-max-strategy-debt.js"),
+  ...require("./get-collateral-by-debt.js"),
+  ...require("./get-factor-from-leverage.js"),
+  ...require("./get-leverage-from-factor.js"),
+  ...require("./get-recommended-debt.js"),
+  ...require("./get-recommended-leverage-factor.js"),
+  ...require("./max-leverage.js"),
+  ...require("./max-leverage-threshold.js")
+});

package/dist/cjs/common-utils/utils/strategies/leverage/max-leverage-threshold.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var max_leverage_threshold_exports = {};
+__export(max_leverage_threshold_exports, {
+  maxLeverageThreshold: () => maxLeverageThreshold
+});
+module.exports = __toCommonJS(max_leverage_threshold_exports);
+const EMPTY_ADDRESS = "";
+function maxLeverageThreshold(lpToken, cms) {
+  const lpTokenLC = lpToken.toLowerCase();
+  const ltByCM = cms.map((cm2) => {
+    const lt2 = cm2.liquidationThresholds[lpTokenLC] || 0n;
+    return [cm2.address, lt2];
+  });
+  const sorted = ltByCM.sort(([, ltA], [, ltB]) => {
+    if (ltA > ltB) return -1;
+    if (ltB > ltA) return 1;
+    return 0;
+  });
+  const [cm = EMPTY_ADDRESS, lt = 0n] = sorted[0] || [];
+  return [lt, cm];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  maxLeverageThreshold
+});

package/dist/cjs/common-utils/utils/strategies/leverage/max-leverage.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var max_leverage_exports = {};
+__export(max_leverage_exports, {
+  maxLeverage: () => maxLeverage
+});
+module.exports = __toCommonJS(max_leverage_exports);
+var import_sdk = require("../../../../sdk/index.js");
+var import_get_factor_from_leverage = require("./get-factor-from-leverage.js");
+var import_max_leverage_threshold = require("./max-leverage-threshold.js");
+function maxLeverage(lpToken, cms, targetHF = import_sdk.PERCENTAGE_FACTOR) {
+  const [maxThreshold] = (0, import_max_leverage_threshold.maxLeverageThreshold)(lpToken, cms);
+  const maxLeverage2 = targetHF * import_sdk.LEVERAGE_DECIMALS / (targetHF - maxThreshold);
+  return (0, import_get_factor_from_leverage.getFactorFromLeverage)(maxLeverage2);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  maxLeverage
+});

package/dist/cjs/common-utils/utils/strategies/lists/get-available-and-disabled-strategies.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_available_and_disabled_strategies_exports = {};
+__export(get_available_and_disabled_strategies_exports, {
+  getAvailableAndDisabledStrategies: () => getAvailableAndDisabledStrategies
+});
+module.exports = __toCommonJS(get_available_and_disabled_strategies_exports);
+var import_get_available_strategies = require("./get-available-strategies.js");
+var import_get_disabled_strategies = require("./get-disabled-strategies.js");
+function getAvailableAndDisabledStrategies(list, listCMs, curatorFilter) {
+  const available = (0, import_get_available_strategies.getAvailableStrategies)(list, listCMs);
+  const disabled = (0, import_get_disabled_strategies.getDisabledStrategies)(list, listCMs, curatorFilter);
+  return {
+    available: available.record,
+    disabled: disabled.record,
+    availableList: available.list,
+    disabledList: disabled.list
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAvailableAndDisabledStrategies
+});

package/dist/cjs/common-utils/utils/strategies/lists/get-available-strategies.js

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_available_strategies_exports = {};
+__export(get_available_strategies_exports, {
+  getAvailableStrategies: () => getAvailableStrategies
+});
+module.exports = __toCommonJS(get_available_strategies_exports);
+var import_is_strategy_disabled = require("../strategy-state/is-strategy-disabled.js");
+function getAvailableStrategies(list, listCMs) {
+  if (listCMs instanceof Error) return { record: listCMs, list: listCMs };
+  if (!list) return { record: null, list: null };
+  if (!listCMs) return { record: null, list: null };
+  const a = list.reduce(
+    (acc, s) => {
+      const targetAddress = s.tokenOutAddress;
+      const strategyCmsList = Object.values(listCMs?.[s.chainId]?.[s.id] || {});
+      if (!acc.record[s.chainId]) acc.record[s.chainId] = {};
+      if (!(0, import_is_strategy_disabled.isStrategyDisabled)(targetAddress, strategyCmsList)) {
+        acc.record[s.chainId][s.id] = s;
+        acc.list.push(s);
+      }
+      return acc;
+    },
+    { record: {}, list: [] }
+  );
+  return a;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAvailableStrategies
+});