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

package/dist/cjs/common-utils/utils/strategies/availability/check-boolean.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 check_boolean_exports = {};
+__export(check_boolean_exports, {
+  checkBoolean: () => checkBoolean
+});
+module.exports = __toCommonJS(check_boolean_exports);
+function checkBoolean(a, b) {
+  if (a && b) return 0;
+  if (a) return -1;
+  if (b) return 1;
+  return 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkBoolean
+});

package/dist/cjs/common-utils/utils/strategies/availability/check-degen-nft.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 check_degen_nft_exports = {};
+__export(check_degen_nft_exports, {
+  checkDegenNFT: () => checkDegenNFT
+});
+module.exports = __toCommonJS(check_degen_nft_exports);
+var import_sdk = require("../../../../sdk/index.js");
+function checkDegenNFT(creditManager) {
+  const nftAddress = creditManager.isDegenMode ? creditManager.degenNFT : import_sdk.ADDRESS_0X0;
+  return {
+    nftAddress,
+    freeOfNFT: nftAddress === import_sdk.ADDRESS_0X0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkDegenNFT
+});

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

@@ -0,0 +1,24 @@
+"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 availability_exports = {};
+module.exports = __toCommonJS(availability_exports);
+__reExport(availability_exports, require("./check-boolean.js"), module.exports);
+__reExport(availability_exports, require("./check-degen-nft.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./check-boolean.js"),
+  ...require("./check-degen-nft.js")
+});

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

@@ -0,0 +1,62 @@
+"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_cm_allowed_collaterals_exports = {};
+__export(get_cm_allowed_collaterals_exports, {
+  getCMAllowedCollaterals: () => getCMAllowedCollaterals
+});
+module.exports = __toCommonJS(get_cm_allowed_collaterals_exports);
+var import_is_collateral_token = require("../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 = (0, import_is_collateral_token.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCMAllowedCollaterals
+});

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

@@ -0,0 +1,109 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_token_data = require("../../../charts/token-data.js");
+var import_test_utils = require("../../../test-utils/index.js");
+var import_is_collateral_token = require("../tokens/is-collateral-token.js");
+var import_get_cm_allowed_collaterals = require("./get-cm-allowed-collaterals.js");
+import_vitest.vi.mock("./is-collateral-token");
+const mockIsCollateralToken = import_vitest.vi.mocked(import_is_collateral_token.isCollateralToken);
+(0, import_vitest.describe)("getCMAllowedCollaterals", () => {
+  const underlying = import_test_utils.mockUnderlyingToken;
+  const allowed = import_test_utils.mockToken1;
+  const rejected = import_test_utils.mockToken2;
+  const tokensList = {
+    [underlying]: new import_token_data.TokenData({
+      addr: underlying,
+      symbol: "DAI",
+      name: "Underlying",
+      decimals: 18,
+      isPhantom: false
+    }),
+    [allowed]: new import_token_data.TokenData({
+      addr: allowed,
+      symbol: "USDC",
+      name: "Allowed",
+      decimals: 6,
+      isPhantom: false
+    }),
+    [rejected]: new import_token_data.TokenData({
+      addr: rejected,
+      symbol: "WBTC",
+      name: "Rejected",
+      decimals: 8,
+      isPhantom: false
+    }),
+    [import_test_utils.mockWrappedNativeTokenAddress]: new import_token_data.TokenData({
+      addr: import_test_utils.mockWrappedNativeTokenAddress,
+      symbol: "WETH",
+      name: "WrappedNative",
+      decimals: 18,
+      isPhantom: false
+    })
+  };
+  const baseCm = (0, import_test_utils.buildCreditManager)({
+    address: "0x0000000000000000000000000000000000000CAA",
+    underlyingToken: underlying,
+    collateralTokens: [
+      underlying,
+      allowed,
+      rejected,
+      import_test_utils.mockWrappedNativeTokenAddress
+    ]
+  });
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.restoreAllMocks();
+    import_vitest.vi.clearAllMocks();
+  });
+  (0, import_vitest.it)("returns empty record when credit manager missing", () => {
+    const result = (0, import_get_cm_allowed_collaterals.getCMAllowedCollaterals)({
+      creditManager: void 0,
+      tokensList,
+      delayedPhantoms: {},
+      nativeTokenAddress: import_test_utils.mockNativeTokenAddress,
+      wrappedNativeTokenAddress: import_test_utils.mockWrappedNativeTokenAddress,
+      extraCollaterals: void 0
+    });
+    (0, import_vitest.expect)(result).toEqual({});
+  });
+  (0, import_vitest.it)("keeps allowed collaterals and mirrors wrapped native to native token", () => {
+    mockIsCollateralToken.mockImplementation(
+      ({ address }) => address !== rejected
+    );
+    const result = (0, import_get_cm_allowed_collaterals.getCMAllowedCollaterals)({
+      creditManager: baseCm,
+      tokensList,
+      delayedPhantoms: {},
+      nativeTokenAddress: import_test_utils.mockNativeTokenAddress,
+      wrappedNativeTokenAddress: import_test_utils.mockWrappedNativeTokenAddress,
+      extraCollaterals: void 0
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      [underlying]: underlying,
+      [allowed]: allowed,
+      [import_test_utils.mockWrappedNativeTokenAddress]: import_test_utils.mockWrappedNativeTokenAddress,
+      [import_test_utils.mockNativeTokenAddress]: import_test_utils.mockNativeTokenAddress
+    });
+  });
+  (0, import_vitest.it)("does not mirror wrapped native when credit manager is paused", () => {
+    mockIsCollateralToken.mockReturnValue(true);
+    const pausedCm = (0, import_test_utils.buildCreditManager)({
+      ...baseCm,
+      isPaused: true
+    });
+    const result = (0, import_get_cm_allowed_collaterals.getCMAllowedCollaterals)({
+      creditManager: pausedCm,
+      tokensList,
+      delayedPhantoms: {},
+      nativeTokenAddress: import_test_utils.mockNativeTokenAddress,
+      wrappedNativeTokenAddress: import_test_utils.mockWrappedNativeTokenAddress,
+      extraCollaterals: void 0
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      [underlying]: underlying,
+      [allowed]: allowed,
+      [rejected]: rejected,
+      [import_test_utils.mockWrappedNativeTokenAddress]: import_test_utils.mockWrappedNativeTokenAddress
+    });
+    (0, import_vitest.expect)(result[import_test_utils.mockNativeTokenAddress]).toBeUndefined();
+  });
+});

package/dist/cjs/common-utils/utils/strategies/credit-managers/get-strategy-credit-managers-list-core.js

@@ -0,0 +1,66 @@
+"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_strategy_credit_managers_list_core_exports = {};
+__export(get_strategy_credit_managers_list_core_exports, {
+  getStrategyCreditManagersListCore: () => getStrategyCreditManagersListCore
+});
+module.exports = __toCommonJS(get_strategy_credit_managers_list_core_exports);
+var import_mappers = require("../../../../sdk/utils/mappers.js");
+var import_tokens = require("../tokens/index.js");
+var import_is_credit_manager_usable = require("./is-credit-manager-usable.js");
+const lc = (address) => address.toLowerCase();
+function getStrategyCreditManagersListCore({
+  strategies,
+  source,
+  curatorFilter
+}) {
+  if (!strategies) return strategies;
+  return strategies.reduce((acc, strategy) => {
+    const targetToken = lc(strategy.tokenOutAddress);
+    const cms = (strategy.creditManagers || []).reduce(
+      (cmAcc, cmAddress) => {
+        const cm = source.getCreditManager(strategy.chainId, cmAddress);
+        if (!cm || !(0, import_is_credit_manager_usable.isCreditManagerUsable)(cm)) return cmAcc;
+        const usable = (0, import_tokens.isUsableToken)({
+          address: targetToken,
+          creditManager: cm
+        });
+        const limit = cm.quotas[targetToken]?.limit || 0n;
+        const limitZero = targetToken === cm.underlyingToken ? false : limit === 0n;
+        if (usable && !cm.isBorrowingForbidden && !limitZero) {
+          cmAcc[cm.address] = cm;
+        }
+        return cmAcc;
+      },
+      {}
+    );
+    const cmsAfterCuratorFilter = curatorFilter ? import_mappers.TypedObjectUtils.entries(cms).filter(
+      ([, cm]) => curatorFilter[cm.marketConfigurator]
+    ) : import_mappers.TypedObjectUtils.entries(cms);
+    if (!acc[strategy.chainId]) acc[strategy.chainId] = {};
+    acc[strategy.chainId][strategy.id] = Object.fromEntries(
+      cmsAfterCuratorFilter
+    );
+    return acc;
+  }, {});
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getStrategyCreditManagersListCore
+});

package/dist/cjs/common-utils/utils/strategies/credit-managers/get-strategy-credit-managers-list.js

@@ -0,0 +1,37 @@
+"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_strategy_credit_managers_list_exports = {};
+__export(get_strategy_credit_managers_list_exports, {
+  getStrategyCreditManagersList: () => getStrategyCreditManagersList
+});
+module.exports = __toCommonJS(get_strategy_credit_managers_list_exports);
+var import_types = require("../types.js");
+var import_get_strategy_credit_managers_list_core = require("./get-strategy-credit-managers-list-core.js");
+function getStrategyCreditManagersList(strategies, sdkStateByChain, curatorFilter) {
+  if (!sdkStateByChain) return sdkStateByChain;
+  return (0, import_get_strategy_credit_managers_list_core.getStrategyCreditManagersListCore)({
+    strategies,
+    source: (0, import_types.createLegacyStrategyDataSource)(sdkStateByChain),
+    curatorFilter
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getStrategyCreditManagersList
+});

package/dist/cjs/common-utils/utils/strategies/credit-managers/get-strategy-credit-managers.js

@@ -0,0 +1,52 @@
+"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_strategy_credit_managers_exports = {};
+__export(get_strategy_credit_managers_exports, {
+  getStrategyCreditManagers: () => getStrategyCreditManagers
+});
+module.exports = __toCommonJS(get_strategy_credit_managers_exports);
+var import_is_usable_token = require("../tokens/is-usable-token.js");
+var import_is_credit_manager_usable = require("./is-credit-manager-usable.js");
+const lc = (address) => address.toLowerCase();
+function getStrategyCreditManagers({ strategy, allCreditManagers }) {
+  const lpAddress = lc(strategy.tokenOutAddress);
+  const res = (strategy?.creditManagers || []).reduce(
+    (acc, cmAddress) => {
+      const cm = allCreditManagers[cmAddress] ?? allCreditManagers[lc(cmAddress)];
+      if (cm && (0, import_is_credit_manager_usable.isCreditManagerUsable)(cm)) {
+        const usable = (0, import_is_usable_token.isUsableToken)({
+          address: lpAddress,
+          creditManager: cm
+        });
+        const limit = cm.quotas[lpAddress]?.limit || 0n;
+        const limitZero = lpAddress === cm.underlyingToken ? false : limit === 0n;
+        if (usable && !cm.isBorrowingForbidden && !limitZero) {
+          acc[cm.address] = cm;
+        }
+      }
+      return acc;
+    },
+    {}
+  );
+  return res;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getStrategyCreditManagers
+});

package/dist/cjs/common-utils/utils/strategies/credit-managers/get-wallet-balances-allowed-on-cm.js

@@ -0,0 +1,75 @@
+"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_wallet_balances_allowed_on_cm_exports = {};
+__export(get_wallet_balances_allowed_on_cm_exports, {
+  getWalletBalancesAllowedOnCM: () => getWalletBalancesAllowedOnCM
+});
+module.exports = __toCommonJS(get_wallet_balances_allowed_on_cm_exports);
+var import_sort = require("../../creditAccount/sort.js");
+var import_wrap_token_address = require("../tokens/wrap-token-address.js");
+function getWalletBalancesAllowedOnCM({
+  walletBalances,
+  collateralRecord,
+  nativeTokenAddress,
+  wrappedNativeTokenAddress,
+  prices,
+  tokensList,
+  isPaused = false
+}) {
+  const walletBalancesSorted = (0, import_sort.sortBalances)(
+    walletBalances || {},
+    prices,
+    tokensList
+  );
+  const { list, record } = walletBalancesSorted.reduce(
+    (acc, [token, balance]) => {
+      if (isPaused && token === nativeTokenAddress) return acc;
+      const wrappedAddress = (0, import_wrap_token_address.wrapTokenAddress)(
+        token,
+        nativeTokenAddress,
+        wrappedNativeTokenAddress
+      );
+      if (collateralRecord[wrappedAddress]) {
+        const asset = {
+          token,
+          balance
+        };
+        acc.list.push(asset);
+        acc.record[wrappedAddress] = asset;
+      }
+      return acc;
+    },
+    { list: [], record: {} }
+  );
+  const collateralList = Object.values(collateralRecord);
+  const missingAssets = collateralList.filter(
+    (token) => isPaused ? token !== nativeTokenAddress && !record[token] : !record[token]
+  ).map(
+    (token) => ({
+      token,
+      balance: 0n
+    })
+  );
+  const r = [...list, ...missingAssets];
+  return r;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getWalletBalancesAllowedOnCM
+});

package/dist/cjs/common-utils/utils/strategies/credit-managers/get-wallet-balances-allowed-on-cm.spec.js

@@ -0,0 +1,93 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_token_data = require("../../../charts/token-data.js");
+var import_test_utils = require("../../../test-utils/index.js");
+var import_sort = require("../../creditAccount/sort.js");
+var import_get_wallet_balances_allowed_on_cm = require("./get-wallet-balances-allowed-on-cm.js");
+import_vitest.vi.mock("../../utils/creditAccount/sort.js", async () => {
+  const actual = await import_vitest.vi.importActual(
+    "../../utils/creditAccount/sort.js"
+  );
+  return {
+    ...actual,
+    sortBalances: import_vitest.vi.fn()
+  };
+});
+const mockSortBalances = import_vitest.vi.mocked(import_sort.sortBalances);
+(0, import_vitest.describe)("getWalletBalancesAllowedOnCM", () => {
+  const allowed = import_test_utils.mockToken1;
+  const prices = {};
+  const tokensList = {
+    [import_test_utils.mockNativeTokenAddress]: new import_token_data.TokenData({
+      addr: import_test_utils.mockNativeTokenAddress,
+      symbol: "ETH",
+      name: "Native",
+      decimals: 18,
+      isPhantom: false
+    }),
+    [import_test_utils.mockWrappedNativeTokenAddress]: new import_token_data.TokenData({
+      addr: import_test_utils.mockWrappedNativeTokenAddress,
+      symbol: "WETH",
+      name: "Wrapped",
+      decimals: 18,
+      isPhantom: false
+    }),
+    [allowed]: new import_token_data.TokenData({
+      addr: allowed,
+      symbol: "DAI",
+      name: "Allowed",
+      decimals: 18,
+      isPhantom: false
+    })
+  };
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.restoreAllMocks();
+    import_vitest.vi.clearAllMocks();
+  });
+  (0, import_vitest.it)("wraps native token when allowed and keeps sorted balances", () => {
+    const collateralRecord = {
+      [import_test_utils.mockWrappedNativeTokenAddress]: import_test_utils.mockWrappedNativeTokenAddress,
+      [allowed]: allowed
+    };
+    mockSortBalances.mockReturnValue([
+      [import_test_utils.mockNativeTokenAddress, 2n],
+      [allowed, 1n]
+    ]);
+    const result = (0, import_get_wallet_balances_allowed_on_cm.getWalletBalancesAllowedOnCM)({
+      walletBalances: {
+        [import_test_utils.mockNativeTokenAddress]: 2n,
+        [allowed]: 1n
+      },
+      collateralRecord,
+      nativeTokenAddress: import_test_utils.mockNativeTokenAddress,
+      wrappedNativeTokenAddress: import_test_utils.mockWrappedNativeTokenAddress,
+      prices,
+      tokensList
+    });
+    (0, import_vitest.expect)(result).toEqual([
+      { token: import_test_utils.mockNativeTokenAddress, balance: 2n },
+      { token: allowed, balance: 1n }
+    ]);
+  });
+  (0, import_vitest.it)("skips native token when paused and fills missing collaterals with zero", () => {
+    const collateralRecord = {
+      [import_test_utils.mockWrappedNativeTokenAddress]: import_test_utils.mockWrappedNativeTokenAddress,
+      [allowed]: allowed,
+      [import_test_utils.mockNativeTokenAddress]: import_test_utils.mockNativeTokenAddress
+    };
+    mockSortBalances.mockReturnValue([[import_test_utils.mockNativeTokenAddress, 5n]]);
+    const result = (0, import_get_wallet_balances_allowed_on_cm.getWalletBalancesAllowedOnCM)({
+      walletBalances: { [import_test_utils.mockNativeTokenAddress]: 5n },
+      collateralRecord,
+      nativeTokenAddress: import_test_utils.mockNativeTokenAddress,
+      wrappedNativeTokenAddress: import_test_utils.mockWrappedNativeTokenAddress,
+      prices,
+      tokensList,
+      isPaused: true
+    });
+    (0, import_vitest.expect)(result).toEqual([
+      { token: import_test_utils.mockWrappedNativeTokenAddress, balance: 0n },
+      { token: allowed, balance: 0n }
+    ]);
+  });
+});

package/dist/cjs/common-utils/utils/strategies/credit-managers/index.js

@@ -0,0 +1,32 @@
+"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 credit_managers_exports = {};
+module.exports = __toCommonJS(credit_managers_exports);
+__reExport(credit_managers_exports, require("./get-cm-allowed-collaterals.js"), module.exports);
+__reExport(credit_managers_exports, require("./get-strategy-credit-managers.js"), module.exports);
+__reExport(credit_managers_exports, require("./get-strategy-credit-managers-list.js"), module.exports);
+__reExport(credit_managers_exports, require("./get-strategy-credit-managers-list-core.js"), module.exports);
+__reExport(credit_managers_exports, require("./get-wallet-balances-allowed-on-cm.js"), module.exports);
+__reExport(credit_managers_exports, require("./is-credit-manager-usable.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./get-cm-allowed-collaterals.js"),
+  ...require("./get-strategy-credit-managers.js"),
+  ...require("./get-strategy-credit-managers-list.js"),
+  ...require("./get-strategy-credit-managers-list-core.js"),
+  ...require("./get-wallet-balances-allowed-on-cm.js"),
+  ...require("./is-credit-manager-usable.js")
+});

package/dist/cjs/common-utils/utils/strategies/credit-managers/is-credit-manager-usable.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 is_credit_manager_usable_exports = {};
+__export(is_credit_manager_usable_exports, {
+  isCreditManagerUsable: () => isCreditManagerUsable
+});
+module.exports = __toCommonJS(is_credit_manager_usable_exports);
+var import_sdk = require("../../../../sdk/index.js");
+function isCreditManagerUsable(cm) {
+  return !cm.isBorrowingForbidden && (0, import_sdk.isV310)(cm.version);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isCreditManagerUsable
+});