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

package/dist/cjs/common-utils/utils/strategies/strategy-info/get-strategy-you-can-earn.js

@@ -0,0 +1,108 @@
+"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_you_can_earn_exports = {};
+__export(get_strategy_you_can_earn_exports, {
+  getStrategyYouCanEarn: () => getStrategyYouCanEarn
+});
+module.exports = __toCommonJS(get_strategy_you_can_earn_exports);
+var import_is_strategy_cm_disabled = require("../../strategies/strategy-info/is-strategy-cm-disabled.js");
+var import_get_chain_phantom_tokens = require("../tokens/get-chain-phantom-tokens.js");
+var import_get_native_token_address = require("../tokens/get-native-token-address.js");
+var import_get_cm_you_can_earn = require("./get-cm-you-can-earn.js");
+function getStrategyYouCanEarn({
+  strategy,
+  creditManagers,
+  sdkState,
+  apyList,
+  quotaReserve,
+  slippage,
+  allPrices,
+  walletBalances
+}) {
+  const strategyCMs = creditManagers;
+  const baseInfo = {
+    strategy: strategy.name,
+    strategyChainId: strategy.chainId,
+    strategyNetwork: strategy.network,
+    strategyType: strategy.strategyType,
+    strategyTokenOutAddress: strategy.tokenOutAddress
+  };
+  if (!strategyCMs || !walletBalances || !allPrices || !apyList || !sdkState) {
+    return [
+      {
+        status: "error",
+        description: "No strategy cms or wallet balances or all prices or apy list or sdk state",
+        otherInfo: baseInfo,
+        data: void 0
+      }
+    ];
+  }
+  const openableCMsList = Object.values(strategyCMs).filter(
+    (cm) => !(0, import_is_strategy_cm_disabled.isStrategyCMDisabled)(cm, cm.quotas[strategy.tokenOutAddress])
+  );
+  if (openableCMsList.length === 0) {
+    return [
+      {
+        status: "error",
+        description: "No openable cms list",
+        otherInfo: baseInfo,
+        data: void 0
+      }
+    ];
+  }
+  const pools = sdkState.pools;
+  const tokensList = sdkState.tokens?.tokenDataList;
+  if (!tokensList || !pools || Object.keys(pools).length === 0) {
+    return [
+      {
+        status: "error",
+        description: "No pools or tokens list",
+        otherInfo: baseInfo,
+        data: void 0
+      }
+    ];
+  }
+  const ap = sdkState.addressProvider;
+  const nativeTokenAddress = (0, import_get_native_token_address.getNativeTokenAddress)();
+  const delayedPhantoms = (0, import_get_chain_phantom_tokens.getChainPhantomTokens)(sdkState.withdrawableAssets);
+  const results = openableCMsList.map(
+    (creditManager) => {
+      const info = (0, import_get_cm_you_can_earn.getCMYouCanEarn)({
+        allPrices,
+        creditManager,
+        tokensList,
+        delayedPhantoms,
+        nativeTokenAddress,
+        wrappedNativeTokenAddress: ap.wrappedNativeToken,
+        walletBalances,
+        strategy,
+        slippage,
+        quotaReserve,
+        apyList,
+        pools
+      });
+      return info;
+    }
+  );
+  return results;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getStrategyYouCanEarn
+});

package/dist/cjs/common-utils/utils/strategies/tokens/add-amount-in-target.js

@@ -0,0 +1,41 @@
+"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 add_amount_in_target_exports = {};
+__export(add_amount_in_target_exports, {
+  addAmountInTarget: () => addAmountInTarget
+});
+module.exports = __toCommonJS(add_amount_in_target_exports);
+var import_price_math = require("../../price-math.js");
+function addAmountInTarget(asset, tokensList, prices, toPrice, toDecimals) {
+  const { balance: fromAmount, token: fromToken } = asset;
+  const { decimals: fromDecimals = 18, address: fromAddress } = tokensList[fromToken] || {};
+  const fromPrice = prices[fromAddress] || 0n;
+  const inTarget = import_price_math.PriceUtils.convertByPrice(
+    import_price_math.PriceUtils.calcTotalPrice(fromPrice, fromAmount, fromDecimals),
+    {
+      price: toPrice,
+      decimals: toDecimals
+    }
+  );
+  return { ...asset, amountInTarget: inTarget };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addAmountInTarget
+});

package/dist/cjs/common-utils/utils/strategies/tokens/add-amount-in-target.spec.js

@@ -0,0 +1,38 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../../test-utils/index.js");
+var import_assets = require("../assets/assets.js");
+var import_add_amount_in_target = require("./add-amount-in-target.js");
+(0, import_vitest.describe)("addAmountInTarget", () => {
+  const fromToken = import_test_utils.mockToken1;
+  const toPrice = 4n;
+  const toDecimals = 18;
+  (0, import_vitest.it)("converts amount to target token using prices", () => {
+    const asset = {
+      ...(0, import_assets.getDefaultAsset)(fromToken),
+      balance: 10n ** 18n
+    };
+    const result = (0, import_add_amount_in_target.addAmountInTarget)(
+      asset,
+      import_test_utils.mockTokenData,
+      import_test_utils.mockPrices,
+      toPrice,
+      toDecimals
+    );
+    (0, import_vitest.expect)(result.amountInTarget).toBe(75000000000000000000000000n);
+  });
+  (0, import_vitest.it)("handles missing price data gracefully", () => {
+    const asset = { ...(0, import_assets.getDefaultAsset)(fromToken), balance: 10n ** 18n };
+    const tokensList = {
+      [fromToken]: import_test_utils.mockTokenData[fromToken]
+    };
+    const result = (0, import_add_amount_in_target.addAmountInTarget)(
+      asset,
+      tokensList,
+      {},
+      toPrice,
+      toDecimals
+    );
+    (0, import_vitest.expect)(result.amountInTarget).toBe(0n);
+  });
+});

package/dist/cjs/common-utils/utils/strategies/tokens/get-chain-phantom-tokens.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 get_chain_phantom_tokens_exports = {};
+__export(get_chain_phantom_tokens_exports, {
+  getChainPhantomTokens: () => getChainPhantomTokens
+});
+module.exports = __toCommonJS(get_chain_phantom_tokens_exports);
+function getChainPhantomTokens(config) {
+  const allConfigs = Object.values(config || {}).flat(1);
+  const r = allConfigs.reduce((acc, cfg) => {
+    acc[cfg.withdrawalPhantomToken] = true;
+    return acc;
+  }, {});
+  return r;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getChainPhantomTokens
+});

package/dist/cjs/common-utils/utils/strategies/tokens/get-list-with-amount-in-target.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 get_list_with_amount_in_target_exports = {};
+__export(get_list_with_amount_in_target_exports, {
+  getListWithAmountInTarget: () => getListWithAmountInTarget
+});
+module.exports = __toCommonJS(get_list_with_amount_in_target_exports);
+var import_add_amount_in_target = require("./add-amount-in-target.js");
+function getListWithAmountInTarget({
+  assets,
+  targetToken,
+  prices,
+  tokensList
+}) {
+  const { decimals: toDecimals = 18 } = tokensList[targetToken] || {};
+  const toPrice = prices[targetToken] || 0n;
+  const withAmount = assets.map((asset) => {
+    const a = (0, import_add_amount_in_target.addAmountInTarget)(asset, tokensList, prices, toPrice, toDecimals);
+    return a;
+  });
+  return withAmount;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getListWithAmountInTarget
+});

package/dist/cjs/common-utils/utils/strategies/tokens/get-list-with-amount-in-target.spec.js

@@ -0,0 +1,32 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../../test-utils/index.js");
+var import_assets = require("../assets/assets.js");
+var import_get_list_with_amount_in_target = require("./get-list-with-amount-in-target.js");
+(0, import_vitest.describe)("getListWithAmountInTarget", () => {
+  const targetToken = import_test_utils.mockToken2;
+  (0, import_vitest.it)("converts multiple assets to target token using prices", () => {
+    const assets = [
+      { ...(0, import_assets.getDefaultAsset)(import_test_utils.mockToken1), balance: 10n ** 18n },
+      { ...(0, import_assets.getDefaultAsset)(import_test_utils.mockToken2), balance: 10n ** 18n }
+    ];
+    const result = (0, import_get_list_with_amount_in_target.getListWithAmountInTarget)({
+      assets,
+      targetToken,
+      prices: import_test_utils.mockPrices,
+      tokensList: import_test_utils.mockTokenData
+    });
+    (0, import_vitest.expect)(result).toHaveLength(2);
+    (0, import_vitest.expect)(result[0].amountInTarget).toBe(1500000000000000000n);
+    (0, import_vitest.expect)(result[1].amountInTarget).toBe(1000000000000000000n);
+  });
+  (0, import_vitest.it)("returns empty array for empty assets", () => {
+    const result = (0, import_get_list_with_amount_in_target.getListWithAmountInTarget)({
+      assets: [],
+      targetToken,
+      prices: import_test_utils.mockPrices,
+      tokensList: import_test_utils.mockTokenData
+    });
+    (0, import_vitest.expect)(result).toEqual([]);
+  });
+});

package/dist/cjs/common-utils/utils/strategies/tokens/get-native-token-address.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_native_token_address_exports = {};
+__export(get_native_token_address_exports, {
+  getNativeTokenAddress: () => getNativeTokenAddress
+});
+module.exports = __toCommonJS(get_native_token_address_exports);
+const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE".toLowerCase();
+function getNativeTokenAddress() {
+  return NATIVE_ADDRESS;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNativeTokenAddress
+});

package/dist/cjs/common-utils/utils/strategies/tokens/is-apy-with-points-exception.js

@@ -0,0 +1,36 @@
+"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_apy_with_points_exception_exports = {};
+__export(is_apy_with_points_exception_exports, {
+  RST_ETH_ADDRESS: () => RST_ETH_ADDRESS,
+  isApyWithPointsException: () => isApyWithPointsException
+});
+module.exports = __toCommonJS(is_apy_with_points_exception_exports);
+const RST_ETH_ADDRESS = "0x7a4EffD87C2f3C55CA251080b1343b605f327E3a".toLowerCase();
+const SHOW_APY_FOR_TOKENS_WITH_POINTS = {
+  [RST_ETH_ADDRESS]: RST_ETH_ADDRESS
+};
+function isApyWithPointsException(token) {
+  return !!SHOW_APY_FOR_TOKENS_WITH_POINTS[(token || "").toLowerCase()];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RST_ETH_ADDRESS,
+  isApyWithPointsException
+});

package/dist/cjs/common-utils/utils/strategies/tokens/is-collateral-token.js

@@ -0,0 +1,59 @@
+"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_collateral_token_exports = {};
+__export(is_collateral_token_exports, {
+  isCollateralToken: () => isCollateralToken
+});
+module.exports = __toCommonJS(is_collateral_token_exports);
+var import_is_obtainable_token = require("./is-obtainable-token.js");
+var import_is_valid_extra_collateral_token = require("./is-valid-extra-collateral-token.js");
+function isCollateralToken({
+  address,
+  tokensList,
+  creditManager,
+  zeroDebt = false,
+  delayedPhantoms,
+  extraCollateralConfigs,
+  prices
+}) {
+  if (creditManager && address === creditManager.underlyingToken) return true;
+  if (zeroDebt && creditManager) return false;
+  const token = tokensList[address];
+  const cmCheckPassed = (0, import_is_obtainable_token.isObtainableToken)({
+    address,
+    creditManager,
+    delayedPhantoms
+  });
+  const { isPhantom = false } = token || {};
+  const allowedAsMain = !isPhantom && cmCheckPassed;
+  const allowedAsExtra = (0, import_is_valid_extra_collateral_token.isValidExtraCollateralToken)({
+    address,
+    extraCollateralConfigs,
+    creditManager,
+    delayedPhantoms,
+    tokensList,
+    zeroDebt,
+    prices
+  });
+  return allowedAsMain || allowedAsExtra;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isCollateralToken
+});

package/dist/cjs/common-utils/utils/strategies/tokens/is-collateral-token.spec.js

@@ -0,0 +1,135 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../../test-utils/index.js");
+var import_is_collateral_token = require("./is-collateral-token.js");
+const buildAllPrices = (_, token, value = 100n) => {
+  return {
+    [token]: value
+  };
+};
+(0, import_vitest.describe)("isCollateralToken", () => {
+  const underlying = "0xunderlying";
+  const token = "0xtoken";
+  const tokensList = {
+    [token]: (0, import_test_utils.buildTokenData)(token, "TOKEN")
+  };
+  const baseCM = (0, import_test_utils.buildCreditManager)({
+    underlyingToken: underlying,
+    quotas: {}
+  });
+  (0, import_vitest.it)("returns true for underlying token", () => {
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: underlying,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: void 0,
+      prices: void 0
+    });
+    (0, import_vitest.expect)(result).toBe(true);
+  });
+  (0, import_vitest.it)("returns false when zeroDebt is true", () => {
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: true,
+      delayedPhantoms: {},
+      extraCollateralConfigs: void 0,
+      prices: void 0
+    });
+    (0, import_vitest.expect)(result).toBe(false);
+  });
+  (0, import_vitest.it)("returns false when cm check fails", () => {
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: void 0,
+      prices: void 0
+    });
+    (0, import_vitest.expect)(result).toBe(false);
+  });
+  (0, import_vitest.it)("returns true when not obtainable but listed as extra collateral for cm and has price", () => {
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: [{ token, cm: baseCM.address }],
+      prices: buildAllPrices(baseCM, token)
+    });
+    (0, import_vitest.expect)(result).toBe(true);
+  });
+  (0, import_vitest.it)("returns false when not obtainable but listed as extra collateral for cm and has no price", () => {
+    const zeroPriceResult = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: [{ token, cm: baseCM.address }],
+      prices: buildAllPrices(baseCM, token, 0n)
+    });
+    (0, import_vitest.expect)(zeroPriceResult).toBe(false);
+    const undefinedPriceResult = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: [{ token, cm: baseCM.address }],
+      prices: void 0
+    });
+    (0, import_vitest.expect)(undefinedPriceResult).toBe(false);
+  });
+  (0, import_vitest.it)("returns false when extra collateral config targets different credit manager", () => {
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: [{ token, cm: "0xother" }],
+      prices: buildAllPrices(baseCM, token)
+    });
+    (0, import_vitest.expect)(result).toBe(false);
+  });
+  (0, import_vitest.it)("returns false when token is phantom", () => {
+    const phantomTokenList = {
+      [token]: (0, import_test_utils.buildTokenData)(token, "TOKEN", 18, true)
+    };
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList: phantomTokenList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: void 0,
+      prices: void 0
+    });
+    (0, import_vitest.expect)(result).toBe(false);
+  });
+  (0, import_vitest.it)("returns true when obtainable, non-phantom, not underlying", () => {
+    const cmWithSupportedToken = (0, import_test_utils.buildCreditManager)({
+      underlyingToken: underlying,
+      supportedTokens: { [token]: true },
+      liquidationThresholds: { [token]: 8000n },
+      quotas: {}
+    });
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: cmWithSupportedToken,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: void 0,
+      prices: void 0
+    });
+    (0, import_vitest.expect)(result).toBe(true);
+  });
+});

package/dist/cjs/common-utils/utils/strategies/tokens/is-obtainable-token.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 is_obtainable_token_exports = {};
+__export(is_obtainable_token_exports, {
+  isObtainableToken: () => isObtainableToken
+});
+module.exports = __toCommonJS(is_obtainable_token_exports);
+var import_is_usable_token = require("../../strategies/tokens/is-usable-token.js");
+function isObtainableToken({
+  address,
+  creditManager,
+  delayedPhantoms
+}) {
+  const {
+    isActive,
+    limit = 0n,
+    totalQuoted = 0n
+  } = creditManager.quotas[address] || {};
+  const realLimit = isActive ? limit || 0n : 0n;
+  const quotaLeft = realLimit - totalQuoted;
+  return (creditManager.isQuoted(address) ? quotaLeft > 0 : true) && (0, import_is_usable_token.isUsableToken)({ address, creditManager }) && !delayedPhantoms[address];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isObtainableToken
+});