@gearbox-protocol/sdk 14.10.1 → 14.10.2-next.2

package/dist/cjs/common-utils/utils/validation/validate-quota.spec.js

@@ -0,0 +1,79 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../test-utils/index.js");
+var import_validate_quota = require("./validate-quota.js");
+const mockCreditManager = (0, import_test_utils.buildCreditManager)({
+  minDebt: 1000n,
+  maxDebt: 1000000n,
+  totalDebtLimit: 5000000n,
+  totalDebt: 2000000n,
+  availableToBorrow: 3000000n,
+  quotas: {
+    [import_test_utils.mockToken1]: (0, import_test_utils.buildQuota)({
+      token: import_test_utils.mockToken1,
+      limit: 1000000n,
+      totalQuoted: 500000n,
+      rate: 0n
+    }),
+    [import_test_utils.mockToken2]: (0, import_test_utils.buildQuota)({
+      token: import_test_utils.mockToken2,
+      limit: 2000000n,
+      totalQuoted: 1000000n,
+      rate: 0n
+    })
+  },
+  maxEnabledTokensLength: 2
+});
+(0, import_vitest.describe)("validateQuota", () => {
+  (0, import_vitest.it)("returns null when all conditions are met", () => {
+    const result = (0, import_validate_quota.validateQuota)({
+      desiredQuota: {},
+      quotaUpdate: [],
+      creditManager: mockCreditManager,
+      throwOnZeroQuotaUpdate: false
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns error when max quotas length is reached", () => {
+    const result = (0, import_validate_quota.validateQuota)({
+      desiredQuota: {
+        [import_test_utils.mockToken1]: { token: import_test_utils.mockToken1, balance: 1000n },
+        [import_test_utils.mockToken2]: { token: import_test_utils.mockToken2, balance: 1000n }
+      },
+      quotaUpdate: [],
+      creditManager: (0, import_test_utils.buildCreditManager)({
+        ...mockCreditManager,
+        maxEnabledTokensLength: 1
+      }),
+      throwOnZeroQuotaUpdate: false
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "maxQuotasLengthReached",
+      count: 2,
+      max: 1
+    });
+  });
+  (0, import_vitest.it)("returns error when quota update is empty and throwOnZeroQuotaUpdate is true", () => {
+    const result = (0, import_validate_quota.validateQuota)({
+      desiredQuota: {},
+      quotaUpdate: [],
+      creditManager: mockCreditManager,
+      throwOnZeroQuotaUpdate: true
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "quotaShouldBeUpdated"
+    });
+  });
+  (0, import_vitest.it)("returns error when quota is insufficient", () => {
+    const result = (0, import_validate_quota.validateQuota)({
+      desiredQuota: {},
+      quotaUpdate: [{ token: import_test_utils.mockToken1, balance: 600000n }],
+      creditManager: mockCreditManager,
+      throwOnZeroQuotaUpdate: false
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "insufficientQuota",
+      token: import_test_utils.mockToken1
+    });
+  });
+});

package/dist/cjs/common-utils/utils/validation/validate-token-to-obtain.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 validate_token_to_obtain_exports = {};
+__export(validate_token_to_obtain_exports, {
+  validateTokenToObtain: () => validateTokenToObtain
+});
+module.exports = __toCommonJS(validate_token_to_obtain_exports);
+function validateTokenToObtain({
+  creditManager,
+  targetToken
+}) {
+  if (Array.isArray(targetToken)) {
+    for (const asset of targetToken) {
+      if (creditManager.forbiddenTokens[asset.token])
+        return { message: "tokenIsForbidden", token: asset.token };
+    }
+    return null;
+  }
+  if (targetToken !== null && creditManager.forbiddenTokens[targetToken])
+    return { message: "tokenIsForbidden", token: targetToken };
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateTokenToObtain
+});

package/dist/cjs/common-utils/utils/validation/validate-token-to-obtain.spec.js

@@ -0,0 +1,35 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../test-utils/index.js");
+var import_validate_token_to_obtain = require("./validate-token-to-obtain.js");
+const mockCreditManager = (0, import_test_utils.buildCreditManager)({
+  forbiddenTokens: {}
+});
+(0, import_vitest.describe)("validateTokenToObtain", () => {
+  (0, import_vitest.it)("returns null when targetToken is null", () => {
+    const result = (0, import_validate_token_to_obtain.validateTokenToObtain)({
+      targetToken: null,
+      creditManager: mockCreditManager
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns null when targetToken is not forbidden", () => {
+    const result = (0, import_validate_token_to_obtain.validateTokenToObtain)({
+      targetToken: import_test_utils.mockToken1,
+      creditManager: mockCreditManager
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns error when targetToken is forbidden", () => {
+    const result = (0, import_validate_token_to_obtain.validateTokenToObtain)({
+      targetToken: import_test_utils.mockToken1,
+      creditManager: (0, import_test_utils.buildCreditManager)({
+        ...mockCreditManager,
+        forbiddenTokens: {
+          [import_test_utils.mockToken1]: true
+        }
+      })
+    });
+    (0, import_vitest.expect)(result).toEqual({ message: "tokenIsForbidden", token: import_test_utils.mockToken1 });
+  });
+});

package/dist/cjs/common-utils/utils/validation/validation-types.js

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validation_types_exports = {};
+module.exports = __toCommonJS(validation_types_exports);

package/dist/cjs/plugins/apy/strategy-data-source.js

@@ -137,6 +137,7 @@ class OnchainSdkStrategyDataSource {
       liquidationThresholds,
       quotas,
       collateralTokens: cm.collateralTokens.map(lc),
+      maxEnabledTokensLength: cm.maxEnabledTokens,
       version: Number(facade.version),
       isBorrowingForbidden: facade.maxDebtPerBlockMultiplier === 0,
       marketConfigurator: lc(cs.marketConfigurator),

package/dist/cjs/sdk/constants/math.js

@@ -25,6 +25,7 @@ __export(math_exports, {
   MIN_INT96: () => MIN_INT96,
   PERCENTAGE_DECIMALS: () => PERCENTAGE_DECIMALS,
   PERCENTAGE_FACTOR: () => PERCENTAGE_FACTOR,
+  PERCENTAGE_FACTOR_1KK: () => PERCENTAGE_FACTOR_1KK,
   PRICE_DECIMALS: () => PRICE_DECIMALS,
   PRICE_DECIMALS_POW: () => PRICE_DECIMALS_POW,
   RAY: () => RAY,
@@ -52,6 +53,7 @@ const PRICE_DECIMALS = 10n ** BigInt(PRICE_DECIMALS_POW);
 const SECONDS_PER_YEAR = 365 * 24 * 3600;
 const PERCENTAGE_DECIMALS = 100n;
 const PERCENTAGE_FACTOR = 10000n;
+const PERCENTAGE_FACTOR_1KK = PERCENTAGE_FACTOR * PERCENTAGE_DECIMALS;
 const LEVERAGE_DECIMALS = 100n;
 const SLIPPAGE_DECIMALS = 100n;
 // Annotate the CommonJS export names for ESM import in node:
@@ -63,6 +65,7 @@ const SLIPPAGE_DECIMALS = 100n;
   MIN_INT96,
   PERCENTAGE_DECIMALS,
   PERCENTAGE_FACTOR,
+  PERCENTAGE_FACTOR_1KK,
   PRICE_DECIMALS,
   PRICE_DECIMALS_POW,
   RAY,

package/dist/esm/common-utils/test-utils/index.js

@@ -0,0 +1,104 @@
+import { TokenData } from "../charts/token-data.js";
+const mockToken1 = "0x1111111111111111111111111111111111111111";
+const mockToken2 = "0x2222222222222222222222222222222222222222";
+const mockUnderlyingToken = "0x9999999999999999999999999999999999999999";
+const mockNativeTokenAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+const mockWrappedNativeTokenAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
+const mockCMAddress = "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+function buildQuota(overrides) {
+  return {
+    rate: 0n,
+    quotaIncreaseFee: 0n,
+    totalQuoted: 0n,
+    limit: 0n,
+    isActive: true,
+    ...overrides
+  };
+}
+function buildPool(overrides = {}) {
+  const address = overrides.address ?? "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+  return {
+    address,
+    expectedLiquidity: 0n,
+    availableLiquidity: 0n,
+    interestModel: {
+      interestModel: "0x0000000000000000000000000000000000000000",
+      U_1: 0n,
+      U_2: 0n,
+      R_base: 0n,
+      R_slope1: 0n,
+      R_slope2: 0n,
+      R_slope3: 0n,
+      version: 0,
+      isBorrowingMoreU2Forbidden: false
+    },
+    totalDebtLimit: 0n,
+    totalBorrowed: 0n,
+    ...overrides
+  };
+}
+function buildCreditManager(overrides = {}) {
+  const address = overrides.address ?? "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+  const pool = overrides.pool ?? "0xcccccccccccccccccccccccccccccccccccccccc";
+  const underlyingToken = overrides.underlyingToken ?? mockUnderlyingToken;
+  const quotas = overrides.quotas ?? {};
+  return {
+    address,
+    name: overrides.name ?? "",
+    underlyingToken,
+    pool,
+    isPaused: overrides.isPaused ?? false,
+    collateralTokens: overrides.collateralTokens ?? [],
+    forbiddenTokens: overrides.forbiddenTokens ?? {},
+    supportedTokens: overrides.supportedTokens ?? {},
+    quotas,
+    liquidationThresholds: overrides.liquidationThresholds ?? {},
+    maxDebt: overrides.maxDebt ?? 0n,
+    minDebt: overrides.minDebt ?? 0n,
+    availableToBorrow: overrides.availableToBorrow ?? 0n,
+    totalDebt: overrides.totalDebt ?? 0n,
+    totalDebtLimit: overrides.totalDebtLimit ?? -1n,
+    feeInterest: overrides.feeInterest ?? 0,
+    baseBorrowRate: overrides.baseBorrowRate ?? 0,
+    maxEnabledTokensLength: overrides.maxEnabledTokensLength ?? 0,
+    chainId: overrides.chainId ?? 1,
+    isDegenMode: overrides.isDegenMode ?? false,
+    degenNFT: overrides.degenNFT ?? "0x0000000000000000000000000000000000000000",
+    isQuoted: overrides.isQuoted ?? (() => false),
+    isForbidden: overrides.isForbidden ?? (() => false),
+    ...overrides
+  };
+}
+function buildTokenData(address, symbol, decimals = 18, isPhantom = false) {
+  return new TokenData({
+    addr: address,
+    symbol,
+    name: symbol,
+    decimals,
+    isPhantom
+  });
+}
+const mockTokenData = {
+  [mockToken1]: buildTokenData(mockToken1, "T1"),
+  [mockToken2]: buildTokenData(mockToken2, "T2"),
+  [mockUnderlyingToken]: buildTokenData(mockUnderlyingToken, "UNDER")
+};
+const mockPrices = {
+  [mockToken1]: 300000000n,
+  [mockToken2]: 200000000n,
+  [mockUnderlyingToken]: 100000000n
+};
+export {
+  buildCreditManager,
+  buildPool,
+  buildQuota,
+  buildTokenData,
+  mockCMAddress,
+  mockNativeTokenAddress,
+  mockPrices,
+  mockToken1,
+  mockToken2,
+  mockTokenData,
+  mockUnderlyingToken,
+  mockWrappedNativeTokenAddress
+};

package/dist/esm/common-utils/utils/apy/calculate-borrow-rate-from-utilization.js

@@ -0,0 +1,35 @@
+import { PERCENTAGE_FACTOR } from "../../../sdk/constants/math.js";
+function calculateBorrowRateFromUtilization(util, model, extraPrecision = 1n) {
+  const {
+    U_1: U_1_r,
+    U_2: U_2_r,
+    R_base: R_base_r,
+    R_slope1: R_slope1_r,
+    R_slope2: R_slope2_r,
+    R_slope3: R_slope3_r
+  } = model;
+  const U_1 = U_1_r * extraPrecision;
+  const U_2 = U_2_r * extraPrecision;
+  const R_base = R_base_r * extraPrecision;
+  const R_slope1 = R_slope1_r * extraPrecision;
+  const R_slope2 = R_slope2_r * extraPrecision;
+  const R_slope3 = R_slope3_r * extraPrecision;
+  const ONE = PERCENTAGE_FACTOR * extraPrecision;
+  if (util === 0n) {
+    return R_base;
+  }
+  if (util <= U_1) {
+    if (U_1 === 0n) return R_base;
+    const rate2 = R_base + R_slope1 * util / U_1;
+    return rate2;
+  }
+  if (util > U_1 && util <= U_2) {
+    const rate2 = R_base + R_slope1 + R_slope2 * (util - U_1) / (U_2 - U_1);
+    return rate2;
+  }
+  const rate = R_base + R_slope1 + R_slope2 + R_slope3 * (util - U_2) / (ONE - U_2);
+  return rate;
+}
+export {
+  calculateBorrowRateFromUtilization
+};

package/dist/esm/common-utils/utils/apy/calculate-borrow-rate-from-utilization.spec.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { calculateBorrowRateFromUtilization } from "./calculate-borrow-rate-from-utilization.js";
+describe("calculateBorrowRateFromUtilization", () => {
+  const model = {
+    U_1: 30n,
+    U_2: 80n,
+    R_base: 100n,
+    R_slope1: 200n,
+    R_slope2: 300n,
+    R_slope3: 400n,
+    interestModel: "0x1",
+    isBorrowingMoreU2Forbidden: false,
+    version: 3
+  };
+  it("returns base rate when util is zero", () => {
+    expect(calculateBorrowRateFromUtilization(0n, model)).toBe(100n);
+  });
+  it("uses first segment when util <= U1", () => {
+    expect(calculateBorrowRateFromUtilization(15n, model)).toBe(200n);
+  });
+  it("uses second segment when U1 < util <= U2", () => {
+    expect(calculateBorrowRateFromUtilization(50n, model)).toBe(420n);
+  });
+  it("uses third segment when util > U2", () => {
+    expect(calculateBorrowRateFromUtilization(90n, model)).toBe(600n);
+  });
+  it("supports extraPrecision scaling", () => {
+    const scaled = calculateBorrowRateFromUtilization(3000n, model, 100n);
+    expect(scaled).toBe(30000n);
+  });
+});

package/dist/esm/common-utils/utils/apy/calculate-earnings.js

@@ -0,0 +1,35 @@
+import { PERCENTAGE_FACTOR_1KK } from "../../../sdk/constants/math.js";
+import { PriceUtils } from "../../utils/price-math.js";
+function calculateEarnings({
+  overallAPYBigInt,
+  targetAmount,
+  targetToken,
+  tokensList,
+  prices
+}) {
+  if (overallAPYBigInt === void 0 || overallAPYBigInt === null)
+    return {
+      earnings: null,
+      earningsUSD: null
+    };
+  if (targetAmount === void 0 || targetAmount <= 0n)
+    return {
+      earnings: null,
+      earningsUSD: null
+    };
+  const earnings = overallAPYBigInt * targetAmount / PERCENTAGE_FACTOR_1KK;
+  const targetPrice = prices[targetToken] || 0n;
+  const targetDecimals = tokensList[targetToken]?.decimals || 18;
+  const earningsUSD = PriceUtils.calcTotalPrice(
+    targetPrice,
+    earnings,
+    targetDecimals
+  );
+  return {
+    earnings,
+    earningsUSD
+  };
+}
+export {
+  calculateEarnings
+};

package/dist/esm/common-utils/utils/apy/calculate-earnings.spec.js

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { PERCENTAGE_FACTOR_1KK } from "../../../sdk/constants/math.js";
+import { toBN } from "../../../sdk/utils/formatter.js";
+import {
+  mockPrices,
+  mockToken1,
+  mockTokenData
+} from "../../test-utils/index.js";
+import { calculateEarnings } from "./calculate-earnings.js";
+describe("calculateEarnings", () => {
+  const targetToken = mockToken1;
+  const tokensList = mockTokenData;
+  const prices = mockPrices;
+  const targetAmount = toBN("100", 18);
+  const baseArgs = {
+    overallAPYBigInt: 1n,
+    targetAmount,
+    targetToken,
+    tokensList,
+    prices
+  };
+  it("returns null earnings when overallAPYBigInt is undefined", () => {
+    expect(
+      calculateEarnings({
+        ...baseArgs,
+        overallAPYBigInt: void 0
+      })
+    ).toEqual({ earnings: null, earningsUSD: null });
+    expect(
+      calculateEarnings({
+        ...baseArgs,
+        overallAPYBigInt: null
+      })
+    ).toEqual({ earnings: null, earningsUSD: null });
+  });
+  it("returns null earnings when targetAmount is missing or non-positive", () => {
+    expect(
+      calculateEarnings({
+        ...baseArgs,
+        targetAmount: void 0
+      })
+    ).toEqual({ earnings: null, earningsUSD: null });
+    expect(
+      calculateEarnings({
+        ...baseArgs,
+        targetAmount: 0n
+      })
+    ).toEqual({ earnings: null, earningsUSD: null });
+  });
+  it("calculates earnings and earningsUSD", () => {
+    const overallAPYBigInt = 2n * BigInt(PERCENTAGE_FACTOR_1KK);
+    const result = calculateEarnings({
+      ...baseArgs,
+      overallAPYBigInt,
+      targetAmount,
+      targetToken,
+      tokensList,
+      prices
+    });
+    expect(result).toEqual({
+      earnings: 200000000000000000000n,
+      earningsUSD: 600000000000000000000n
+    });
+  });
+});

package/dist/esm/common-utils/utils/apy/calculate-safe-borrow-rate.js

@@ -0,0 +1,34 @@
+import {
+  PERCENTAGE_DECIMALS,
+  PERCENTAGE_FACTOR
+} from "../../../sdk/constants/math.js";
+import { BigIntMath } from "../../utils/bigint-math.js";
+import { calculateBorrowRateFromUtilization } from "./calculate-borrow-rate-from-utilization.js";
+function calculateSafeBorrowRate({
+  pool,
+  creditManager,
+  expectedLiquidityChange = 0n,
+  availableLiquidityChange = 0n
+}) {
+  const expectedLiquidity = pool.expectedLiquidity + expectedLiquidityChange;
+  const availableLiquidity = pool.availableLiquidity + availableLiquidityChange;
+  const borrowed = BigIntMath.max(expectedLiquidity - availableLiquidity, 0n);
+  const EXTRA_PRECISION = 100n;
+  const ONE = PERCENTAGE_FACTOR * EXTRA_PRECISION;
+  const utilization = BigIntMath.min(
+    expectedLiquidity > 0 ? borrowed * ONE / expectedLiquidity : 0n,
+    ONE
+  );
+  const rate = calculateBorrowRateFromUtilization(
+    utilization,
+    pool.interestModel,
+    EXTRA_PRECISION
+  );
+  const rateWithDaoFee = Number(
+    rate * (BigInt(creditManager.feeInterest) + PERCENTAGE_FACTOR) / PERCENTAGE_DECIMALS / EXTRA_PRECISION
+  );
+  return rateWithDaoFee;
+}
+export {
+  calculateSafeBorrowRate
+};

package/dist/esm/common-utils/utils/apy/calculate-safe-borrow-rate.spec.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { buildCreditManager, buildPool } from "../../test-utils/index.js";
+import { calculateSafeBorrowRate } from "./calculate-safe-borrow-rate.js";
+describe("calculateSafeBorrowRate", () => {
+  const baseModel = {
+    U_1: 50n,
+    U_2: 80n,
+    R_base: 100n,
+    R_slope1: 0n,
+    R_slope2: 0n,
+    R_slope3: 0n,
+    interestModel: "0x1",
+    isBorrowingMoreU2Forbidden: false,
+    version: 3
+  };
+  const poolBase = buildPool({
+    expectedLiquidity: 1000n,
+    availableLiquidity: 1000n,
+    // util = 0
+    interestModel: baseModel
+  });
+  it("returns rate with no fee at zero utilization", () => {
+    const creditManager = buildCreditManager({ feeInterest: 0 });
+    const rate = calculateSafeBorrowRate({
+      pool: poolBase,
+      creditManager
+    });
+    expect(rate).toBe(1e4);
+  });
+  it("applies feeInterest scaling", () => {
+    const creditManager = buildCreditManager({ feeInterest: 200 });
+    const rate = calculateSafeBorrowRate({
+      pool: poolBase,
+      creditManager
+    });
+    expect(rate).toBe(10200);
+  });
+});

package/dist/esm/common-utils/utils/apy/get-safe-base-borrow-rate.js

@@ -0,0 +1,16 @@
+import {
+  calculateSafeBorrowRate
+} from "./calculate-safe-borrow-rate.js";
+const getSafeBaseBorrowRate = (props) => {
+  const { onError, ...rest } = props;
+  try {
+    const rate = calculateSafeBorrowRate(rest);
+    return rate;
+  } catch (e) {
+    onError?.(e);
+    return void 0;
+  }
+};
+export {
+  getSafeBaseBorrowRate
+};

package/dist/esm/common-utils/utils/apy/index.js

@@ -1,6 +1,10 @@
 export * from "./bonus-apy-from-points.js";
+export * from "./calculate-borrow-rate-from-utilization.js";
+export * from "./calculate-earnings.js";
 export * from "./calculate-effective-borrow-rate.js";
+export * from "./calculate-safe-borrow-rate.js";
 export * from "./get-complex-apy-list.js";
 export * from "./get-rate-with-fee.js";
+export * from "./get-safe-base-borrow-rate.js";
 export * from "./get-single-quota-borrow-rate.js";
 export * from "./max-apy-formula.js";

package/dist/esm/common-utils/utils/constants.js

@@ -0,0 +1,8 @@
+const EMPTY_OBJECT = {};
+const EMPTY_ARRAY = [];
+const EMPTY_ADDRESS = "";
+export {
+  EMPTY_ADDRESS,
+  EMPTY_ARRAY,
+  EMPTY_OBJECT
+};

package/dist/esm/common-utils/utils/index.js

@@ -1,6 +1,8 @@
 export * from "./apy/index.js";
 export * from "./assets-math.js";
 export * from "./bigint-math.js";
+export * from "./constants.js";
 export * from "./creditAccount/index.js";
 export * from "./price-math.js";
 export * from "./strategies/index.js";
+export * from "./validation/index.js";

package/dist/esm/common-utils/utils/strategies/assets/assets.js

@@ -0,0 +1,6 @@
+function getDefaultAsset(token) {
+  return { token };
+}
+export {
+  getDefaultAsset
+};

package/dist/esm/common-utils/utils/strategies/assets/index.js

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

package/dist/esm/common-utils/utils/strategies/availability/index.js

@@ -1,4 +1,2 @@
 export * from "./check-boolean.js";
 export * from "./check-degen-nft.js";
-export * from "./validate-open-account-pool-quota-status.js";
-export * from "./validate-open-account-pool-status.js";

package/dist/esm/common-utils/utils/strategies/credit-managers/get-cm-allowed-collaterals.js

@@ -0,0 +1,38 @@
+import { isCollateralToken } from "../tokens/is-collateral-token.js";
+function getCMAllowedCollaterals({
+  creditManager,
+  tokensList,
+  zeroDebt = false,
+  delayedPhantoms,
+  extraCollaterals,
+  nativeTokenAddress,
+  wrappedNativeTokenAddress
+}) {
+  const tokens = creditManager?.collateralTokens;
+  if (!tokens) return {};
+  const collateralRecord = tokens.reduce(
+    (acc, address) => {
+      const allowed = isCollateralToken({
+        address,
+        tokensList,
+        creditManager,
+        zeroDebt,
+        delayedPhantoms,
+        extraCollateralConfigs: extraCollaterals?.list?.[address],
+        prices: extraCollaterals?.prices
+      });
+      if (allowed) {
+        acc[address] = address;
+      }
+      return acc;
+    },
+    {}
+  );
+  if (!creditManager.isPaused && wrappedNativeTokenAddress && collateralRecord[wrappedNativeTokenAddress] && nativeTokenAddress) {
+    collateralRecord[nativeTokenAddress] = nativeTokenAddress;
+  }
+  return collateralRecord;
+}
+export {
+  getCMAllowedCollaterals
+};